Introduce integer ecma-value representation to reduce the double allocations.

JerryScript-DCO-1.0-Signed-off-by: Zoltan Herczeg zherczeg.u-szeged@partner.samsung.com

jerry-core/ecma/base/ecma-globals.h

@@ -55,8 +55,8 @@
  */
 typedef enum
 {
-  ECMA_TYPE_SIMPLE, /**< simple value */
+  ECMA_TYPE_DIRECT, /**< directly encoded value, a 28 bit signed integer or a simple value */
-  ECMA_TYPE_NUMBER, /**< 64-bit integer */
+  ECMA_TYPE_FLOAT, /**< pointer to a 64 or 32 bit floating point number */
   ECMA_TYPE_STRING, /**< pointer to description of a string */
   ECMA_TYPE_OBJECT, /**< pointer to description of an object */
   ECMA_TYPE___MAX = ECMA_TYPE_OBJECT /** highest value for ecma types */
@@ -68,10 +68,10 @@ typedef enum
 typedef enum
 {
   /**
-   * Empty value is implementation defined value, used for:
+   * Empty value is implementation defined value, used for representing:
-   *   - representing empty value in completion values (see also: ECMA-262 v5, 8.9 Completion specification type);
+   *   - empty (uninitialized) values
-   *   - values of uninitialized immutable bindings;
+   *   - immutable binding values
-   *   - values of empty register variables.
+   *   - special register or stack values for vm
    */
   ECMA_SIMPLE_VALUE_EMPTY,
   ECMA_SIMPLE_VALUE_UNDEFINED, /**< undefined value */
@@ -90,6 +90,11 @@ typedef enum
  */
 typedef uint32_t ecma_value_t;
 
+/**
+ * Type for directly encoded integer numbers in JerryScript.
+ */
+typedef int32_t ecma_integer_value_t;
+
 #if UINTPTR_MAX <= UINT32_MAX
 
 /**
@@ -114,6 +119,50 @@ typedef uint32_t ecma_value_t;
  */
 #define ECMA_VALUE_SHIFT 3
 
+/**
+ * Mask for directly encoded values
+ */
+#define ECMA_DIRECT_TYPE_MASK ((1u << ECMA_VALUE_SHIFT) | ECMA_VALUE_TYPE_MASK)
+
+/**
+ * Ecma integer value type
+ */
+#define ECMA_DIRECT_TYPE_INTEGER_VALUE ((0u << ECMA_VALUE_SHIFT) | ECMA_TYPE_DIRECT)
+
+/**
+ * Ecma simple value type
+ */
+#define ECMA_DIRECT_TYPE_SIMPLE_VALUE ((1u << ECMA_VALUE_SHIFT) | ECMA_TYPE_DIRECT)
+
+/**
+ * Shift for directly encoded values in ecma_value_t
+ */
+#define ECMA_DIRECT_SHIFT 4
+
+/**
+ * Maximum integer number for an ecma value
+ */
+#if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32
+#define ECMA_INTEGER_NUMBER_MAX 0x7fffff
+#else /* CONFIG_ECMA_NUMBER_TYPE != CONFIG_ECMA_NUMBER_FLOAT32 */
+#define ECMA_INTEGER_NUMBER_MAX 0x7ffffff
+#endif /* CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 */
+
+/**
+ * Minimum integer number for an ecma value
+ */
+#if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32
+#define ECMA_INTEGER_NUMBER_MIN -0x7fffff
+#else /* CONFIG_ECMA_NUMBER_TYPE != CONFIG_ECMA_NUMBER_FLOAT32 */
+#define ECMA_INTEGER_NUMBER_MIN -0x8000000
+#endif /* CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 */
+
+/**
+ * Checks whether the integer number is in the integer number range.
+ */
+#define ECMA_IS_INTEGER_NUMBER(num) \
+  (ECMA_INTEGER_NUMBER_MIN <= (num) && (num) <= ECMA_INTEGER_NUMBER_MAX)
+
 /**
  * Internal properties' identifiers.
  */

jerry-core/ecma/base/ecma-helpers-number.c

@@ -24,6 +24,15 @@
  * @{
  */
 
+JERRY_STATIC_ASSERT (sizeof (ecma_value_t) == sizeof (ecma_integer_value_t),
+                     size_of_ecma_value_t_must_be_equal_to_the_size_of_ecma_integer_value_t);
+
+JERRY_STATIC_ASSERT (ECMA_DIRECT_SHIFT == ECMA_VALUE_SHIFT + 1,
+                     currently_directly_encoded_values_has_one_extra_flag);
+
+JERRY_STATIC_ASSERT (((1 << (ECMA_DIRECT_SHIFT - 1)) | ECMA_TYPE_DIRECT) == ECMA_DIRECT_TYPE_SIMPLE_VALUE,
+                     currently_directly_encoded_values_start_after_direct_type_simple_value);
+
 #define ECMA_NUMBER_SIGN_POS (ECMA_NUMBER_FRACTION_WIDTH + \
                               ECMA_NUMBER_BIASED_EXP_WIDTH)
 

jerry-core/ecma/base/ecma-helpers-value.c

@@ -206,6 +206,30 @@ ecma_is_value_array_hole (ecma_value_t value) /**< ecma value */
   return ecma_is_value_equal_to_simple_value (value, ECMA_SIMPLE_VALUE_ARRAY_HOLE);
 } /* ecma_is_value_array_hole */
 
+/**
+ * Check if the value is integer ecma-number.
+ *
+ * @return true - if the value contains an integer ecma-number value,
+ *         false - otherwise.
+ */
+inline bool __attr_pure___ __attr_always_inline___
+ecma_is_value_integer_number (ecma_value_t value) /**< ecma value */
+{
+  return (value & ECMA_DIRECT_TYPE_MASK) == ECMA_DIRECT_TYPE_INTEGER_VALUE;
+} /* ecma_is_value_integer_number */
+
+/**
+ * Check if the value is floating-point ecma-number.
+ *
+ * @return true - if the value contains a floating-point ecma-number value,
+ *         false - otherwise.
+ */
+inline bool __attr_pure___ __attr_always_inline___
+ecma_is_value_float_number (ecma_value_t value) /**< ecma value */
+{
+  return (ecma_get_value_type_field (value) == ECMA_TYPE_FLOAT);
+} /* ecma_is_value_float_number */
+
 /**
  * Check if the value is ecma-number.
  *
@@ -215,7 +239,8 @@ ecma_is_value_array_hole (ecma_value_t value) /**< ecma value */
 inline bool __attr_pure___ __attr_always_inline___
 ecma_is_value_number (ecma_value_t value) /**< ecma value */
 {
-  return (ecma_get_value_type_field (value) == ECMA_TYPE_NUMBER);
+  return (ecma_is_value_integer_number (value)
+          || ecma_is_value_float_number (value));
 } /* ecma_is_value_number */
 
 /**
@@ -275,20 +300,134 @@ ecma_check_value_type_is_spec_defined (ecma_value_t value) /**< ecma value */
 inline ecma_value_t __attr_const___ __attr_always_inline___
 ecma_make_simple_value (const ecma_simple_value_t simple_value) /**< simple value */
 {
-  return (((ecma_value_t) (simple_value)) << ECMA_VALUE_SHIFT) | ECMA_TYPE_SIMPLE;
+  return (((ecma_value_t) (simple_value)) << ECMA_DIRECT_SHIFT) | ECMA_DIRECT_TYPE_SIMPLE_VALUE;
 } /* ecma_make_simple_value */
 
 /**
- * Number value constructor
+ * Encode an integer number into an ecma-value without allocating memory
+ *
+ * Note:
+ *   The value must fit into the range of allowed ecma integer values
+ *
+ * @return ecma-value
  */
-ecma_value_t __attr_const___
+inline ecma_value_t __attr_const___ __attr_always_inline___
-ecma_make_number_value (const ecma_number_t *ecma_num_p) /**< number to reference in value */
+ecma_make_integer_value (ecma_integer_value_t integer_value) /**< integer number to be encoded */
 {
-  JERRY_ASSERT (ecma_num_p != NULL);
+  JERRY_ASSERT (ECMA_IS_INTEGER_NUMBER (integer_value));
 
-  return ecma_pointer_to_ecma_value (ecma_num_p) | ECMA_TYPE_NUMBER;
+  return ((ecma_value_t) (integer_value << ECMA_DIRECT_SHIFT)) | ECMA_DIRECT_TYPE_INTEGER_VALUE;
+} /* ecma_make_integer_value */
+
+/**
+ * Allocate and initialize a new float number without checks.
+ *
+ * @return ecma-value
+ */
+static ecma_value_t __attr_const___
+ecma_create_float_number (ecma_number_t ecma_number) /**< value of the float number */
+{
+  ecma_number_t *ecma_num_p = ecma_alloc_number ();
+
+  *ecma_num_p = ecma_number;
+
+  return ecma_pointer_to_ecma_value (ecma_num_p) | ECMA_TYPE_FLOAT;
+} /* ecma_create_float_number */
+
+/**
+ * Create a new NaN value.
+ *
+ * @return ecma-value
+ */
+inline ecma_value_t __attr_always_inline___
+ecma_make_nan_value (void)
+{
+  return ecma_create_float_number (ecma_number_make_nan ());
+} /* ecma_make_nan_value */
+
+/**
+ * Checks whether the passed number is +0.0
+ *
+ * @return true, if it is +0.0, false otherwise
+ */
+static inline bool __attr_const___ __attr_always_inline___
+ecma_is_number_equal_to_positive_zero (ecma_number_t ecma_number) /**< number */
+{
+#if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32
+  union
+  {
+    uint32_t u32_value;
+    ecma_number_t float_value;
+  } u;
+
+  u.float_value = ecma_number;
+
+  return u.u32_value == 0;
+#else /* CONFIG_ECMA_NUMBER_TYPE != CONFIG_ECMA_NUMBER_FLOAT32 */
+  union
+  {
+    uint64_t u64_value;
+    ecma_number_t float_value;
+  } u;
+
+  u.float_value = ecma_number;
+
+  return u.u64_value == 0;
+#endif /* CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 */
+} /* ecma_is_number_equal_to_positive_zero */
+
+/**
+ * Encode a number into an ecma-value
+ *
+ * @return ecma-value
+ */
+ecma_value_t
+ecma_make_number_value (ecma_number_t ecma_number) /**< number to be encoded */
+{
+  ecma_integer_value_t integer_value = (ecma_integer_value_t) ecma_number;
+
+  if ((ecma_number_t) integer_value == ecma_number
+      && ((integer_value == 0) ? ecma_is_number_equal_to_positive_zero (ecma_number)
+                               : ECMA_IS_INTEGER_NUMBER (integer_value)))
+  {
+    return ecma_make_integer_value (integer_value);
+  }
+
+  return ecma_create_float_number (ecma_number);
 } /* ecma_make_number_value */
 
+/**
+ * Encode an int32 number into an ecma-value
+ *
+ * @return ecma-value
+ */
+ecma_value_t
+ecma_make_int32_value (int32_t int32_number) /**< int32 number to be encoded */
+{
+  if (ECMA_IS_INTEGER_NUMBER (int32_number))
+  {
+    return ecma_make_integer_value ((ecma_integer_value_t) int32_number);
+  }
+
+  return ecma_create_float_number ((ecma_number_t) int32_number);
+} /* ecma_make_int32_value */
+
+/**
+ * Encode an unsigned int32 number into an ecma-value
+ *
+ * @return ecma-value
+ */
+ecma_value_t
+ecma_make_uint32_value (uint32_t uint32_number) /**< uint32 number to be encoded */
+{
+  if (uint32_number <= ECMA_INTEGER_NUMBER_MAX)
+  {
+    return ecma_make_integer_value ((ecma_integer_value_t) uint32_number);
+  }
+
+  return ecma_create_float_number ((ecma_number_t) uint32_number);
+} /* ecma_make_uint32_value */
+
 /**
  * String value constructor
  */
@@ -333,24 +472,48 @@ ecma_make_error_obj_value (const ecma_object_t *object_p) /**< object to referen
 } /* ecma_make_error_obj_value */
 
 /**
- * Get pointer to ecma-number from ecma value
+ * Get floating point value from an ecma value
  *
- * @return the pointer
+ * @return floating point value
  */
-ecma_number_t *__attr_pure___
+ecma_number_t __attr_pure___
 ecma_get_number_from_value (ecma_value_t value) /**< ecma value */
 {
-  JERRY_ASSERT (ecma_get_value_type_field (value) == ECMA_TYPE_NUMBER);
+  if (ecma_is_value_integer_number (value))
+  {
+    return (ecma_number_t) (((ecma_integer_value_t) value) >> ECMA_DIRECT_SHIFT);
+  }
 
-  return (ecma_number_t *) ecma_get_pointer_from_ecma_value (value);
+  JERRY_ASSERT (ecma_get_value_type_field (value) == ECMA_TYPE_FLOAT);
+
+  return *(ecma_number_t *) ecma_get_pointer_from_ecma_value (value);
 } /* ecma_get_number_from_value */
 
+/**
+ * Get uint32 value from an ecma value
+ *
+ * @return floating point value
+ */
+uint32_t __attr_pure___
+ecma_get_uint32_from_value (ecma_value_t value) /**< ecma value */
+{
+  if (ecma_is_value_integer_number (value))
+  {
+    /* Works with negative numbers as well. */
+    return (uint32_t) (((ecma_integer_value_t) value) >> ECMA_DIRECT_SHIFT);
+  }
+
+  JERRY_ASSERT (ecma_get_value_type_field (value) == ECMA_TYPE_FLOAT);
+
+  return ecma_number_to_uint32 (*(ecma_number_t *) ecma_get_pointer_from_ecma_value (value));
+} /* ecma_get_uint32_from_value */
+
 /**
  * Get pointer to ecma-string from ecma value
  *
  * @return the pointer
  */
-ecma_string_t *__attr_pure___
+inline ecma_string_t *__attr_pure___ __attr_always_inline___
 ecma_get_string_from_value (ecma_value_t value) /**< ecma value */
 {
   JERRY_ASSERT (ecma_get_value_type_field (value) == ECMA_TYPE_STRING);
@@ -363,7 +526,7 @@ ecma_get_string_from_value (ecma_value_t value) /**< ecma value */
  *
  * @return the pointer
  */
-ecma_object_t *__attr_pure___
+inline ecma_object_t *__attr_pure___ __attr_always_inline___
 ecma_get_object_from_value (ecma_value_t value) /**< ecma value */
 {
   JERRY_ASSERT (ecma_get_value_type_field (value) == ECMA_TYPE_OBJECT);
@@ -398,18 +561,15 @@ ecma_copy_value (ecma_value_t value)  /**< value description */
 {
   switch (ecma_get_value_type_field (value))
   {
-    case ECMA_TYPE_SIMPLE:
+    case ECMA_TYPE_DIRECT:
     {
       return value;
     }
-    case ECMA_TYPE_NUMBER:
+    case ECMA_TYPE_FLOAT:
     {
-      ecma_number_t *num_p = ecma_get_number_from_value (value);
+      ecma_number_t *num_p = (ecma_number_t *) ecma_get_pointer_from_ecma_value (value);
 
-      ecma_number_t *number_copy_p = ecma_alloc_number ();
+      return ecma_create_float_number (*num_p);
-      *number_copy_p = *num_p;
-
-      return ecma_make_number_value (number_copy_p);
     }
     case ECMA_TYPE_STRING:
     {
@@ -441,6 +601,118 @@ ecma_copy_value_if_not_object (ecma_value_t value) /**< value description */
   return value;
 } /* ecma_copy_value_if_not_object */
 
+/**
+ * Assign a new value to an ecma-value
+ *
+ * Note:
+ *      value previously stored in the property is freed
+ */
+void
+ecma_value_assign_value (ecma_value_t *value_p, /**< [in, out] ecma value */
+                         ecma_value_t ecma_value) /**< value to assign */
+{
+  JERRY_STATIC_ASSERT (ECMA_TYPE_DIRECT == 0,
+                       ecma_type_direct_must_be_zero_for_the_next_check);
+
+  if (ecma_get_value_type_field (ecma_value || *value_p) == ECMA_TYPE_DIRECT)
+  {
+    *value_p = ecma_value;
+  }
+  else if (ecma_is_value_float_number (ecma_value)
+           && ecma_is_value_float_number (*value_p))
+  {
+    const ecma_number_t *num_src_p = (ecma_number_t *) ecma_get_pointer_from_ecma_value (ecma_value);
+    ecma_number_t *num_dst_p = (ecma_number_t *) ecma_get_pointer_from_ecma_value (*value_p);
+
+    *num_dst_p = *num_src_p;
+  }
+  else
+  {
+    ecma_free_value_if_not_object (*value_p);
+    *value_p = ecma_copy_value_if_not_object (ecma_value);
+  }
+} /* ecma_value_assign_value */
+
+/**
+ * Assign a float number to an ecma-value
+ *
+ * Note:
+ *      value previously stored in the property is freed
+ */
+static void
+ecma_value_assign_float_number (ecma_value_t *value_p, /**< [in, out] ecma value */
+                                ecma_number_t ecma_number) /**< number to assign */
+{
+  if (ecma_is_value_float_number (*value_p))
+  {
+    ecma_number_t *num_dst_p = (ecma_number_t *) ecma_get_pointer_from_ecma_value (*value_p);
+
+    *num_dst_p = ecma_number;
+    return;
+  }
+
+  if (ecma_get_value_type_field (*value_p) != ECMA_TYPE_DIRECT
+      && ecma_get_value_type_field (*value_p) != ECMA_TYPE_OBJECT)
+  {
+    ecma_free_value (*value_p);
+  }
+
+  *value_p = ecma_create_float_number (ecma_number);
+} /* ecma_value_assign_float_number */
+
+/**
+ * Assign a number to an ecma-value
+ *
+ * Note:
+ *      value previously stored in the property is freed
+ */
+void
+ecma_value_assign_number (ecma_value_t *value_p, /**< [in, out] ecma value */
+                          ecma_number_t ecma_number) /**< number to assign */
+{
+  ecma_integer_value_t integer_value = (ecma_integer_value_t) ecma_number;
+
+  if ((ecma_number_t) integer_value == ecma_number
+      && ((integer_value == 0) ? ecma_is_number_equal_to_positive_zero (ecma_number)
+                               : ECMA_IS_INTEGER_NUMBER (integer_value)))
+  {
+    if (ecma_get_value_type_field (*value_p) != ECMA_TYPE_DIRECT
+        && ecma_get_value_type_field (*value_p) != ECMA_TYPE_OBJECT)
+    {
+      ecma_free_value (*value_p);
+    }
+    *value_p = ecma_make_integer_value (integer_value);
+    return;
+  }
+
+  ecma_value_assign_float_number (value_p, ecma_number);
+} /* ecma_value_assign_number */
+
+/**
+ * Assign an uint32 value to an ecma-value
+ *
+ * Note:
+ *      value previously stored in the property is freed
+ */
+void
+ecma_value_assign_uint32 (ecma_value_t *value_p, /**< [in, out] ecma value */
+                          uint32_t uint32_number) /**< number to assign */
+{
+  if (uint32_number <= ECMA_INTEGER_NUMBER_MAX)
+  {
+    if (ecma_get_value_type_field (*value_p) != ECMA_TYPE_DIRECT
+        && ecma_get_value_type_field (*value_p) != ECMA_TYPE_OBJECT)
+    {
+      ecma_free_value (*value_p);
+    }
+
+    *value_p = ecma_make_integer_value ((ecma_integer_value_t) uint32_number);
+    return;
+  }
+
+  ecma_value_assign_float_number (value_p, (ecma_number_t) uint32_number);
+} /* ecma_value_assign_uint32 */
+
 /**
  * Free the ecma value
  */
@@ -449,15 +721,15 @@ ecma_free_value (ecma_value_t value) /**< value description */
 {
   switch (ecma_get_value_type_field (value))
   {
-    case ECMA_TYPE_SIMPLE:
+    case ECMA_TYPE_DIRECT:
     {
-      /* doesn't hold additional memory */
+      /* no memory is allocated */
       break;
     }
 
-    case ECMA_TYPE_NUMBER:
+    case ECMA_TYPE_FLOAT:
     {
-      ecma_number_t *number_p = ecma_get_number_from_value (value);
+      ecma_number_t *number_p = (ecma_number_t *) ecma_get_pointer_from_ecma_value (value);
       ecma_dealloc_number (number_p);
       break;
     }

jerry-core/ecma/base/ecma-helpers.c

@@ -1110,21 +1110,9 @@ ecma_named_data_property_assign_value (ecma_object_t *obj_p, /**< object */
   JERRY_ASSERT (ECMA_PROPERTY_GET_TYPE (prop_p) == ECMA_PROPERTY_TYPE_NAMEDDATA);
   ecma_assert_object_contains_the_property (obj_p, prop_p);
 
-  if (ecma_is_value_number (value)
+  ecma_property_value_t *prop_value_p = ECMA_PROPERTY_VALUE_PTR (prop_p);
-      && ecma_is_value_number (ecma_get_named_data_property_value (prop_p)))
-  {
-    const ecma_number_t *num_src_p = ecma_get_number_from_value (value);
-    ecma_number_t *num_dst_p = ecma_get_number_from_value (ecma_get_named_data_property_value (prop_p));
 
-    *num_dst_p = *num_src_p;
+  ecma_value_assign_value (&prop_value_p->value, value);
-  }
-  else
-  {
-    ecma_value_t v = ecma_get_named_data_property_value (prop_p);
-    ecma_free_value_if_not_object (v);
-
-    ecma_set_named_data_property_value (prop_p, ecma_copy_value_if_not_object (value));
-  }
 } /* ecma_named_data_property_assign_value */
 
 /**

jerry-core/ecma/base/ecma-helpers.h

@@ -122,6 +122,8 @@ extern bool ecma_is_value_true (ecma_value_t);
 extern bool ecma_is_value_false (ecma_value_t);
 extern bool ecma_is_value_array_hole (ecma_value_t);
 
+extern bool ecma_is_value_integer_number (ecma_value_t);
+extern bool ecma_is_value_float_number (ecma_value_t);
 extern bool ecma_is_value_number (ecma_value_t);
 extern bool ecma_is_value_string (ecma_value_t);
 extern bool ecma_is_value_object (ecma_value_t);
@@ -130,17 +132,25 @@ extern bool ecma_is_value_error (ecma_value_t);
 extern void ecma_check_value_type_is_spec_defined (ecma_value_t);
 
 extern ecma_value_t ecma_make_simple_value (const ecma_simple_value_t value);
-extern ecma_value_t ecma_make_number_value (const ecma_number_t *);
+extern ecma_value_t ecma_make_integer_value (ecma_integer_value_t);
+extern ecma_value_t ecma_make_nan_value (void);
+extern ecma_value_t ecma_make_number_value (ecma_number_t);
+extern ecma_value_t ecma_make_int32_value (int32_t);
+extern ecma_value_t ecma_make_uint32_value (uint32_t);
 extern ecma_value_t ecma_make_string_value (const ecma_string_t *);
 extern ecma_value_t ecma_make_object_value (const ecma_object_t *);
 extern ecma_value_t ecma_make_error_value (ecma_value_t);
 extern ecma_value_t ecma_make_error_obj_value (const ecma_object_t *);
-extern ecma_number_t *ecma_get_number_from_value (ecma_value_t) __attr_pure___;
+extern ecma_number_t ecma_get_number_from_value (ecma_value_t) __attr_pure___;
+extern uint32_t ecma_get_uint32_from_value (ecma_value_t) __attr_pure___;
 extern ecma_string_t *ecma_get_string_from_value (ecma_value_t) __attr_pure___;
 extern ecma_object_t *ecma_get_object_from_value (ecma_value_t) __attr_pure___;
 extern ecma_value_t ecma_get_value_from_error_value (ecma_value_t) __attr_pure___;
 extern ecma_value_t ecma_copy_value (ecma_value_t);
 extern ecma_value_t ecma_copy_value_if_not_object (ecma_value_t);
+extern void ecma_value_assign_value (ecma_value_t *, ecma_value_t);
+extern void ecma_value_assign_number (ecma_value_t *, ecma_number_t);
+extern void ecma_value_assign_uint32 (ecma_value_t *, uint32_t);
 extern void ecma_free_value (ecma_value_t);
 extern void ecma_free_value_if_not_object (ecma_value_t);
 

jerry-core/ecma/builtin-objects/ecma-builtin-array-prototype.c

@@ -62,14 +62,13 @@ ecma_builtin_array_prototype_helper_set_length (ecma_object_t *object, /**< obje
   ecma_value_t ret_value;
   ecma_string_t *magic_string_length_p = ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH);
 
-  ecma_number_t *len_p = ecma_alloc_number ();
+  ecma_value_t length_value = ecma_make_number_value (length);
-  *len_p = length;
-
   ret_value = ecma_op_object_put (object,
                                   magic_string_length_p,
-                                  ecma_make_number_value (len_p),
+                                  length_value,
                                   true),
-  ecma_dealloc_number (len_p);
+
+  ecma_free_value (length_value);
   ecma_deref_ecma_string (magic_string_length_p);
 
   return ret_value;
@@ -587,10 +586,7 @@ ecma_builtin_array_prototype_object_push (ecma_value_t this_arg, /**< this argum
                     ecma_builtin_array_prototype_helper_set_length (obj_p, n),
                     ret_value);
 
-    ecma_number_t *ret_num_p = ecma_alloc_number ();
+    ret_value = ecma_make_number_value (n);
-    *ret_num_p = n;
-
-    ret_value = ecma_make_number_value (ret_num_p);
 
     ECMA_FINALIZE (set_length_value)
   }
@@ -952,7 +948,7 @@ ecma_builtin_array_prototype_object_sort_compare_helper (ecma_value_t j, /**< le
    * sort to the end of the result, followed by non-existent property values.
    */
   ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
-  ecma_number_t *result_p = ecma_alloc_number ();
+  ecma_number_t result = ECMA_NUMBER_ZERO;
 
   bool j_is_undef = ecma_is_value_undefined (j);
   bool k_is_undef = ecma_is_value_undefined (k);
@@ -961,18 +957,18 @@ ecma_builtin_array_prototype_object_sort_compare_helper (ecma_value_t j, /**< le
   {
     if (k_is_undef)
     {
-      *result_p = ECMA_NUMBER_ZERO;
+      result = ECMA_NUMBER_ZERO;
     }
     else
     {
-      *result_p = ECMA_NUMBER_ONE;
+      result = ECMA_NUMBER_ONE;
     }
   }
   else
   {
     if (k_is_undef)
     {
-      *result_p = ECMA_NUMBER_MINUS_ONE;
+      result = ECMA_NUMBER_MINUS_ONE;
     }
     else
     {
@@ -986,15 +982,15 @@ ecma_builtin_array_prototype_object_sort_compare_helper (ecma_value_t j, /**< le
 
         if (ecma_compare_ecma_strings_relational (j_str_p, k_str_p))
         {
-          *result_p = ECMA_NUMBER_MINUS_ONE;
+          result = ECMA_NUMBER_MINUS_ONE;
         }
         else if (!ecma_compare_ecma_strings (j_str_p, k_str_p))
         {
-          *result_p = ECMA_NUMBER_ONE;
+          result = ECMA_NUMBER_ONE;
         }
         else
         {
-          *result_p = ECMA_NUMBER_ZERO;
+          result = ECMA_NUMBER_ZERO;
         }
 
         ECMA_FINALIZE (k_value);
@@ -1021,12 +1017,12 @@ ecma_builtin_array_prototype_object_sort_compare_helper (ecma_value_t j, /**< le
         if (!ecma_is_value_number (call_value))
         {
           ECMA_OP_TO_NUMBER_TRY_CATCH (ret_num, call_value, ret_value);
-          *result_p = ret_num;
+          result = ret_num;
           ECMA_OP_TO_NUMBER_FINALIZE (ret_num);
         }
         else
         {
-          *result_p = *ecma_get_number_from_value (call_value);
+          result = ecma_get_number_from_value (call_value);
         }
 
         ECMA_FINALIZE (call_value);
@@ -1036,11 +1032,7 @@ ecma_builtin_array_prototype_object_sort_compare_helper (ecma_value_t j, /**< le
 
   if (ecma_is_value_empty (ret_value))
   {
-    ret_value = ecma_make_number_value (result_p);
+    ret_value = ecma_make_number_value (result);
-  }
-  else
-  {
-    ecma_dealloc_number (result_p);
   }
 
   return ret_value;
@@ -1080,7 +1072,7 @@ ecma_builtin_array_prototype_object_array_to_heap_helper (ecma_value_t array[],
       JERRY_ASSERT (ecma_is_value_number (child_compare_value));
 
       /* Use the child that is greater. */
-      if (*ecma_get_number_from_value (child_compare_value) < ECMA_NUMBER_ZERO)
+      if (ecma_get_number_from_value (child_compare_value) < ECMA_NUMBER_ZERO)
       {
         child++;
       }
@@ -1100,7 +1092,7 @@ ecma_builtin_array_prototype_object_array_to_heap_helper (ecma_value_t array[],
                       ret_value);
       JERRY_ASSERT (ecma_is_value_number (swap_compare_value));
 
-      if (*ecma_get_number_from_value (swap_compare_value) <= ECMA_NUMBER_ZERO)
+      if (ecma_get_number_from_value (swap_compare_value) <= ECMA_NUMBER_ZERO)
       {
         /* Break from loop if current child is less than swap (tree top) */
         should_break = true;
@@ -1713,9 +1705,7 @@ ecma_builtin_array_prototype_object_unshift (ecma_value_t this_arg, /**< this ar
     ECMA_TRY_CATCH (set_length_value,
                     ecma_builtin_array_prototype_helper_set_length (obj_p, new_len),
                     ret_value);
-    ecma_number_t *num_p = ecma_alloc_number ();
+    ret_value = ecma_make_number_value (new_len);
-    *num_p = new_len;
-    ret_value = ecma_make_number_value (num_p);
 
     ECMA_FINALIZE (set_length_value);
   }
@@ -1765,9 +1755,7 @@ ecma_builtin_array_prototype_object_index_of (ecma_value_t this_arg, /**< this a
   /* 4. */
   if (len == 0)
   {
-    ecma_number_t *num_p = ecma_alloc_number ();
+    ret_value = ecma_make_integer_value (-1);
-    *num_p = ECMA_NUMBER_MINUS_ONE;
-    ret_value = ecma_make_number_value (num_p);
   }
   else
   {
@@ -1808,9 +1796,7 @@ ecma_builtin_array_prototype_object_index_of (ecma_value_t this_arg, /**< this a
 
     if (ecma_is_value_empty (ret_value))
     {
-      ecma_number_t *num_p = ecma_alloc_number ();
+      ret_value = ecma_make_number_value (found_index);
-      *num_p = found_index;
-      ret_value = ecma_make_number_value (num_p);
     }
 
     ECMA_OP_TO_NUMBER_FINALIZE (arg_from_idx);
@@ -1862,13 +1848,12 @@ ecma_builtin_array_prototype_object_last_index_of (ecma_value_t this_arg, /**< t
   /* 3. */
   uint32_t len = ecma_number_to_uint32 (len_number);
 
-  ecma_number_t *num_p = ecma_alloc_number ();
+  ecma_number_t num = ECMA_NUMBER_MINUS_ONE;
-  *num_p = ECMA_NUMBER_MINUS_ONE;
 
   /* 4. */
   if (len == 0)
   {
-    ret_value = ecma_make_number_value (num_p);
+    ret_value = ecma_make_number_value (num);
   }
   else
   {
@@ -1937,7 +1922,7 @@ ecma_builtin_array_prototype_object_last_index_of (ecma_value_t this_arg, /**< t
      * for an underflow instead. This is safe, because from_idx will always start in [0, len - 1],
      * and len is in [0, UINT_MAX], so from_idx >= len means we've had an underflow, and should stop.
      */
-    for (; from_idx < len && *num_p < 0 && ecma_is_value_empty (ret_value); from_idx--)
+    for (; from_idx < len && num < 0 && ecma_is_value_empty (ret_value); from_idx--)
     {
       /* 8.a */
       ecma_string_t *idx_str_p = ecma_new_ecma_string_from_uint32 (from_idx);
@@ -1951,7 +1936,7 @@ ecma_builtin_array_prototype_object_last_index_of (ecma_value_t this_arg, /**< t
         /* 8.b.ii */
         if (ecma_op_strict_equality_compare (search_element, get_value))
         {
-          *num_p = ((ecma_number_t) from_idx);
+          num = ((ecma_number_t) from_idx);
         }
 
         ECMA_FINALIZE (get_value);
@@ -1962,11 +1947,7 @@ ecma_builtin_array_prototype_object_last_index_of (ecma_value_t this_arg, /**< t
 
     if (ecma_is_value_empty (ret_value))
     {
-      ret_value = ecma_make_number_value (num_p);
+      ret_value = ecma_make_number_value (num);
-    }
-    else
-    {
-      ecma_dealloc_number (num_p);
     }
   }
 
@@ -2020,7 +2001,6 @@ ecma_builtin_array_prototype_object_every (ecma_value_t this_arg, /**< this argu
   else
   {
     ecma_value_t current_index;
-    ecma_number_t *num_p = ecma_alloc_number ();
     ecma_object_t *func_object_p;
 
     /* We already checked that arg1 is callable, so it will always coerce to an object. */
@@ -2041,8 +2021,7 @@ ecma_builtin_array_prototype_object_every (ecma_value_t this_arg, /**< this argu
         /* 7.c.i */
         ECMA_TRY_CATCH (get_value, ecma_op_object_get (obj_p, index_str_p), ret_value);
 
-        *num_p = ((ecma_number_t) index);
+        current_index = ecma_make_uint32_value (index);
-        current_index = ecma_make_number_value (num_p);
 
         ecma_value_t call_args[] = { get_value, current_index, obj_this };
         /* 7.c.ii */
@@ -2062,7 +2041,6 @@ ecma_builtin_array_prototype_object_every (ecma_value_t this_arg, /**< this argu
     }
 
     ecma_free_value (to_object_comp);
-    ecma_dealloc_number (num_p);
 
     if (ecma_is_value_empty (ret_value))
     {
@@ -2121,7 +2099,6 @@ ecma_builtin_array_prototype_object_some (ecma_value_t this_arg, /**< this argum
   else
   {
     ecma_value_t current_index;
-    ecma_number_t *num_p = ecma_alloc_number ();
     ecma_object_t *func_object_p;
 
     /* We already checked that arg1 is callable, so it will always coerce to an object. */
@@ -2142,8 +2119,7 @@ ecma_builtin_array_prototype_object_some (ecma_value_t this_arg, /**< this argum
         /* 7.c.i */
         ECMA_TRY_CATCH (get_value, ecma_op_object_get (obj_p, index_str_p), ret_value);
 
-        *num_p = ((ecma_number_t) index);
+        current_index = ecma_make_uint32_value (index);
-        current_index = ecma_make_number_value (num_p);
 
         ecma_value_t call_args[] = { get_value, current_index, obj_this };
         /* 7.c.ii */
@@ -2163,7 +2139,6 @@ ecma_builtin_array_prototype_object_some (ecma_value_t this_arg, /**< this argum
     }
 
     ecma_free_value (to_object_comp);
-    ecma_dealloc_number (num_p);
 
     if (ecma_is_value_empty (ret_value))
     {
@@ -2221,7 +2196,6 @@ ecma_builtin_array_prototype_object_for_each (ecma_value_t this_arg, /**< this a
   else
   {
     ecma_value_t current_index;
-    ecma_number_t *num_p = ecma_alloc_number ();
     ecma_object_t *func_object_p;
 
     /* We already checked that arg1 is callable, so it will always coerce to an object. */
@@ -2242,8 +2216,7 @@ ecma_builtin_array_prototype_object_for_each (ecma_value_t this_arg, /**< this a
         /* 7.c.i */
         ECMA_TRY_CATCH (current_value, ecma_op_object_get (obj_p, index_str_p), ret_value);
 
-        *num_p = ((ecma_number_t) index);
+        current_index = ecma_make_uint32_value (index);
-        current_index = ecma_make_number_value (num_p);
 
         /* 7.c.ii */
         ecma_value_t call_args[] = {current_value, current_index, obj_this};
@@ -2263,7 +2236,6 @@ ecma_builtin_array_prototype_object_for_each (ecma_value_t this_arg, /**< this a
     }
 
     ecma_free_value (to_object_comp);
-    ecma_dealloc_number (num_p);
   }
 
   ECMA_OP_TO_NUMBER_FINALIZE (len_number);
@@ -2315,7 +2287,6 @@ ecma_builtin_array_prototype_object_map (ecma_value_t this_arg, /**< this argume
   }
   else
   {
-    ecma_number_t *num_p = ecma_alloc_number ();
     ecma_object_t *func_object_p;
     JERRY_ASSERT (ecma_is_value_object (arg1));
     func_object_p = ecma_get_object_from_value (arg1);
@@ -2340,8 +2311,7 @@ ecma_builtin_array_prototype_object_map (ecma_value_t this_arg, /**< this argume
         /* 8.c.i */
         ECMA_TRY_CATCH (current_value, ecma_op_object_get (obj_p, index_str_p), ret_value);
         /* 8.c.ii */
-        *num_p = ((ecma_number_t) index);
+        current_index = ecma_make_uint32_value (index);
-        current_index = ecma_make_number_value (num_p);
         ecma_value_t call_args[] = {current_value, current_index, obj_this};
 
         ECMA_TRY_CATCH (mapped_value, ecma_op_function_call (func_object_p, arg2, call_args, 3), ret_value);
@@ -2376,8 +2346,6 @@ ecma_builtin_array_prototype_object_map (ecma_value_t this_arg, /**< this argume
     {
       ecma_free_value (new_array);
     }
-
-    ecma_dealloc_number (num_p);
   }
 
   ECMA_OP_TO_NUMBER_FINALIZE (len_number);
@@ -2430,7 +2398,6 @@ ecma_builtin_array_prototype_object_filter (ecma_value_t this_arg, /**< this arg
   else
   {
     ecma_value_t current_index;
-    ecma_number_t *num_p = ecma_alloc_number ();
     ecma_object_t *func_object_p;
 
     /* 6. */
@@ -2457,8 +2424,7 @@ ecma_builtin_array_prototype_object_filter (ecma_value_t this_arg, /**< this arg
         /* 9.c.i */
         ECMA_TRY_CATCH (get_value, ecma_op_object_get (obj_p, index_str_p), ret_value);
 
-        *num_p = ((ecma_number_t) index);
+        current_index = ecma_make_uint32_value (index);
-        current_index = ecma_make_number_value (num_p);
 
         ecma_value_t call_args[] = { get_value, current_index, obj_this };
         /* 9.c.ii */
@@ -2490,8 +2456,6 @@ ecma_builtin_array_prototype_object_filter (ecma_value_t this_arg, /**< this arg
       ecma_deref_ecma_string (index_str_p);
     }
 
-    ecma_dealloc_number (num_p);
-
     if (ecma_is_value_empty (ret_value))
     {
       /* 10. */
@@ -2554,7 +2518,6 @@ ecma_builtin_array_prototype_object_reduce (ecma_value_t this_arg, /**< this arg
   }
   else
   {
-    ecma_number_t *num_p = ecma_alloc_number ();
     ecma_object_t *func_object_p;
 
     JERRY_ASSERT (ecma_is_value_object (callbackfn));
@@ -2617,8 +2580,7 @@ ecma_builtin_array_prototype_object_reduce (ecma_value_t this_arg, /**< this arg
           /* 9.c.i */
           ECMA_TRY_CATCH (current_value, ecma_op_object_get (obj_p, index_str_p), ret_value);
           /* 9.c.ii */
-          *num_p = ((ecma_number_t) index);
+          current_index = ecma_make_uint32_value (index);
-          current_index = ecma_make_number_value (num_p);
           ecma_value_t call_args[] = {accumulator, current_value, current_index, obj_this};
 
           ECMA_TRY_CATCH (call_value,
@@ -2645,7 +2607,6 @@ ecma_builtin_array_prototype_object_reduce (ecma_value_t this_arg, /**< this arg
     }
 
     ecma_free_value (accumulator);
-    ecma_dealloc_number (num_p);
   }
 
   ECMA_OP_TO_NUMBER_FINALIZE (len_number);
@@ -2711,7 +2672,6 @@ ecma_builtin_array_prototype_object_reduce_right (ecma_value_t this_arg, /**< th
     }
     else
     {
-      ecma_number_t *num_p = ecma_alloc_number ();
       ecma_value_t accumulator = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);
 
       /* 6. */
@@ -2763,8 +2723,7 @@ ecma_builtin_array_prototype_object_reduce_right (ecma_value_t this_arg, /**< th
           /* 9.c.i */
           ECMA_TRY_CATCH (current_value, ecma_op_object_get (obj_p, index_str_p), ret_value);
           /* 9.c.ii */
-          *num_p = ((ecma_number_t) (uint32_t) index);
+          current_index = ecma_make_uint32_value ((uint32_t) index);
-          current_index = ecma_make_number_value (num_p);
           ecma_value_t call_args[] = {accumulator, current_value, current_index, obj_this};
 
           ECMA_TRY_CATCH (call_value,
@@ -2790,7 +2749,6 @@ ecma_builtin_array_prototype_object_reduce_right (ecma_value_t this_arg, /**< th
       }
 
       ecma_free_value (accumulator);
-      ecma_dealloc_number (num_p);
     }
   }
 

jerry-core/ecma/builtin-objects/ecma-builtin-date-prototype.c

@@ -62,16 +62,16 @@ ecma_builtin_date_prototype_to_string (ecma_value_t this_arg) /**< this argument
                   ecma_date_get_primitive_value (this_arg),
                   ret_value);
 
-  ecma_number_t *prim_num_p = ecma_get_number_from_value (prim_value);
+  ecma_number_t prim_num = ecma_get_number_from_value (prim_value);
 
-  if (ecma_number_is_nan (*prim_num_p))
+  if (ecma_number_is_nan (prim_num))
   {
     ecma_string_t *magic_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_INVALID_DATE_UL);
     ret_value = ecma_make_string_value (magic_str_p);
   }
   else
   {
-    ret_value = ecma_date_value_to_string (*prim_num_p);
+    ret_value = ecma_date_value_to_string (prim_num);
   }
 
   ECMA_FINALIZE (prim_value);
@@ -257,10 +257,7 @@ ecma_builtin_date_prototype_get_time (ecma_value_t this_arg) /**< this argument
       prim_value_num_p = ECMA_GET_INTERNAL_VALUE_POINTER (ecma_number_t,
                                                           ecma_get_internal_property_value (prim_prop_p));
 
-      ecma_number_t *ret_num_p = ecma_alloc_number ();
+      return ecma_make_number_value (*prim_value_num_p);
-      *ret_num_p = *prim_value_num_p;
-
-      return ecma_make_number_value (ret_num_p);
     }
   }
 
@@ -293,9 +290,9 @@ ecma_builtin_date_prototype_get_ ## _routine_name (ecma_value_t this_arg) /**< t
  \
   /* 1. */ \
   ECMA_TRY_CATCH (value, ecma_builtin_date_prototype_get_time (this_arg), ret_value); \
-  ecma_number_t *this_num_p = ecma_get_number_from_value (value); \
+  ecma_number_t this_num = ecma_get_number_from_value (value); \
   /* 2. */ \
-  if (ecma_number_is_nan (*this_num_p)) \
+  if (ecma_number_is_nan (this_num)) \
   { \
     ecma_string_t *nan_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_NAN); \
     ret_value = ecma_make_string_value (nan_str_p); \
@@ -303,9 +300,8 @@ ecma_builtin_date_prototype_get_ ## _routine_name (ecma_value_t this_arg) /**< t
   else \
   { \
     /* 3. */ \
-    ecma_number_t *ret_num_p = ecma_alloc_number (); \
+    ecma_number_t ret_num = _getter_name (DEFINE_GETTER_ARGUMENT_ ## _timezone (this_num)); \
-    *ret_num_p = _getter_name (DEFINE_GETTER_ARGUMENT_ ## _timezone (*this_num_p)); \
+    ret_value = ecma_make_number_value (ret_num); \
-    ret_value = ecma_make_number_value (ret_num_p); \
   } \
   ECMA_FINALIZE (value); \
   \
@@ -358,8 +354,7 @@ ecma_builtin_date_prototype_set_time (ecma_value_t this_arg, /**< this argument
   {
     /* 1. */
     ECMA_OP_TO_NUMBER_TRY_CATCH (t, time, ret_value);
-    ecma_number_t *value_p = ecma_alloc_number ();
+    ecma_number_t value = ecma_date_time_clip (t);
-    *value_p = ecma_date_time_clip (t);
 
     /* 2. */
     ecma_object_t *obj_p = ecma_get_object_from_value (this_arg);
@@ -369,10 +364,10 @@ ecma_builtin_date_prototype_set_time (ecma_value_t this_arg, /**< this argument
 
     ecma_number_t *prim_value_num_p = ECMA_GET_INTERNAL_VALUE_POINTER (ecma_number_t,
                                                                        ecma_get_internal_property_value (prim_prop_p));
-    *prim_value_num_p = *value_p;
+    *prim_value_num_p = value;
 
     /* 3. */
-    ret_value = ecma_make_number_value (value_p);
+    ret_value = ecma_make_number_value (value);
     ECMA_OP_TO_NUMBER_FINALIZE (t);
   }
 
@@ -396,7 +391,7 @@ ecma_builtin_date_prototype_set_milliseconds (ecma_value_t this_arg, /**< this a
 
   /* 1. */
   ECMA_TRY_CATCH (this_time_value, ecma_builtin_date_prototype_get_time (this_arg), ret_value);
-  ecma_number_t t = ecma_date_local_time (*ecma_get_number_from_value (this_time_value));
+  ecma_number_t t = ecma_date_local_time (ecma_get_number_from_value (this_time_value));
 
   /* 2. */
   ECMA_OP_TO_NUMBER_TRY_CATCH (milli, ms, ret_value);
@@ -433,7 +428,7 @@ ecma_builtin_date_prototype_set_utc_milliseconds (ecma_value_t this_arg, /**< th
 
   /* 1. */
   ECMA_TRY_CATCH (this_time_value, ecma_builtin_date_prototype_get_time (this_arg), ret_value);
-  ecma_number_t t = *ecma_get_number_from_value (this_time_value);
+  ecma_number_t t = ecma_get_number_from_value (this_time_value);
 
   /* 2. */
   ECMA_OP_TO_NUMBER_TRY_CATCH (milli, ms, ret_value);
@@ -471,7 +466,7 @@ ecma_builtin_date_prototype_set_seconds (ecma_value_t this_arg, /**< this argume
 
   /* 1. */
   ECMA_TRY_CATCH (this_time_value, ecma_builtin_date_prototype_get_time (this_arg), ret_value);
-  ecma_number_t t = ecma_date_local_time (*ecma_get_number_from_value (this_time_value));
+  ecma_number_t t = ecma_date_local_time (ecma_get_number_from_value (this_time_value));
 
   /* 2. */
   ECMA_OP_TO_NUMBER_TRY_CATCH (s, sec, ret_value);
@@ -516,7 +511,7 @@ ecma_builtin_date_prototype_set_utc_seconds (ecma_value_t this_arg, /**< this ar
 
   /* 1. */
   ECMA_TRY_CATCH (this_time_value, ecma_builtin_date_prototype_get_time (this_arg), ret_value);
-  ecma_number_t t = *ecma_get_number_from_value (this_time_value);
+  ecma_number_t t = ecma_get_number_from_value (this_time_value);
 
   /* 2. */
   ECMA_OP_TO_NUMBER_TRY_CATCH (s, sec, ret_value);
@@ -561,7 +556,7 @@ ecma_builtin_date_prototype_set_minutes (ecma_value_t this_arg, /**< this argume
 
   /* 1. */
   ECMA_TRY_CATCH (this_time_value, ecma_builtin_date_prototype_get_time (this_arg), ret_value);
-  ecma_number_t t = ecma_date_local_time (*ecma_get_number_from_value (this_time_value));
+  ecma_number_t t = ecma_date_local_time (ecma_get_number_from_value (this_time_value));
 
   /* 2. */
   ecma_number_t m = ecma_number_make_nan ();
@@ -622,7 +617,7 @@ ecma_builtin_date_prototype_set_utc_minutes (ecma_value_t this_arg, /**< this ar
 
   /* 1. */
   ECMA_TRY_CATCH (this_time_value, ecma_builtin_date_prototype_get_time (this_arg), ret_value);
-  ecma_number_t t = *ecma_get_number_from_value (this_time_value);
+  ecma_number_t t = ecma_get_number_from_value (this_time_value);
 
   /* 2. */
   ecma_number_t m = ecma_number_make_nan ();
@@ -683,7 +678,7 @@ ecma_builtin_date_prototype_set_hours (ecma_value_t this_arg, /**< this argument
 
   /* 1. */
   ECMA_TRY_CATCH (this_time_value, ecma_builtin_date_prototype_get_time (this_arg), ret_value);
-  ecma_number_t t = ecma_date_local_time (*ecma_get_number_from_value (this_time_value));
+  ecma_number_t t = ecma_date_local_time (ecma_get_number_from_value (this_time_value));
 
   /* 2. */
   ecma_number_t h = ecma_number_make_nan ();
@@ -752,7 +747,7 @@ ecma_builtin_date_prototype_set_utc_hours (ecma_value_t this_arg, /**< this argu
 
   /* 1. */
   ECMA_TRY_CATCH (this_time_value, ecma_builtin_date_prototype_get_time (this_arg), ret_value);
-  ecma_number_t t = *ecma_get_number_from_value (this_time_value);
+  ecma_number_t t = ecma_get_number_from_value (this_time_value);
 
   /* 2. */
   ecma_number_t h = ecma_number_make_nan ();
@@ -820,7 +815,7 @@ ecma_builtin_date_prototype_set_date (ecma_value_t this_arg, /**< this argument
 
   /* 1. */
   ECMA_TRY_CATCH (this_time_value, ecma_builtin_date_prototype_get_time (this_arg), ret_value);
-  ecma_number_t t = ecma_date_local_time (*ecma_get_number_from_value (this_time_value));
+  ecma_number_t t = ecma_date_local_time (ecma_get_number_from_value (this_time_value));
 
   /* 2. */
   ECMA_OP_TO_NUMBER_TRY_CATCH (dt, date, ret_value);
@@ -856,7 +851,7 @@ ecma_builtin_date_prototype_set_utc_date (ecma_value_t this_arg, /**< this argum
 
   /* 1. */
   ECMA_TRY_CATCH (this_time_value, ecma_builtin_date_prototype_get_time (this_arg), ret_value);
-  ecma_number_t t = *ecma_get_number_from_value (this_time_value);
+  ecma_number_t t = ecma_get_number_from_value (this_time_value);
 
   /* 2. */
   ECMA_OP_TO_NUMBER_TRY_CATCH (dt, date, ret_value);
@@ -893,7 +888,7 @@ ecma_builtin_date_prototype_set_month (ecma_value_t this_arg, /**< this argument
 
   /* 1. */
   ECMA_TRY_CATCH (this_time_value, ecma_builtin_date_prototype_get_time (this_arg), ret_value);
-  ecma_number_t t = ecma_date_local_time (*ecma_get_number_from_value (this_time_value));
+  ecma_number_t t = ecma_date_local_time (ecma_get_number_from_value (this_time_value));
 
   /* 2. */
   ECMA_OP_TO_NUMBER_TRY_CATCH (m, month, ret_value);
@@ -937,7 +932,7 @@ ecma_builtin_date_prototype_set_utc_month (ecma_value_t this_arg, /**< this argu
 
   /* 1. */
   ECMA_TRY_CATCH (this_time_value, ecma_builtin_date_prototype_get_time (this_arg), ret_value);
-  ecma_number_t t = *ecma_get_number_from_value (this_time_value);
+  ecma_number_t t = ecma_get_number_from_value (this_time_value);
 
   /* 2. */
   ECMA_OP_TO_NUMBER_TRY_CATCH (m, month, ret_value);
@@ -981,7 +976,7 @@ ecma_builtin_date_prototype_set_full_year (ecma_value_t this_arg, /**< this argu
 
   /* 1. */
   ECMA_TRY_CATCH (this_time_value, ecma_builtin_date_prototype_get_time (this_arg), ret_value);
-  ecma_number_t t = ecma_date_local_time (*ecma_get_number_from_value (this_time_value));
+  ecma_number_t t = ecma_date_local_time (ecma_get_number_from_value (this_time_value));
   if (ecma_number_is_nan (t))
   {
     t = ECMA_NUMBER_ZERO;
@@ -1045,7 +1040,7 @@ ecma_builtin_date_prototype_set_utc_full_year (ecma_value_t this_arg, /**< this
 
   /* 1. */
   ECMA_TRY_CATCH (this_time_value, ecma_builtin_date_prototype_get_time (this_arg), ret_value);
-  ecma_number_t t = *ecma_get_number_from_value (this_time_value);
+  ecma_number_t t = ecma_get_number_from_value (this_time_value);
   if (ecma_number_is_nan (t))
   {
     t = ECMA_NUMBER_ZERO;
@@ -1109,16 +1104,16 @@ ecma_builtin_date_prototype_to_utc_string (ecma_value_t this_arg) /**< this argu
                   ecma_date_get_primitive_value (this_arg),
                   ret_value);
 
-  ecma_number_t *prim_num_p = ecma_get_number_from_value (prim_value);
+  ecma_number_t prim_num = ecma_get_number_from_value (prim_value);
 
-  if (ecma_number_is_nan (*prim_num_p))
+  if (ecma_number_is_nan (prim_num))
   {
     ecma_string_t *magic_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_INVALID_DATE_UL);
     ret_value = ecma_make_string_value (magic_str_p);
   }
   else
   {
-    ret_value = ecma_date_value_to_utc_string (*prim_num_p);
+    ret_value = ecma_date_value_to_utc_string (prim_num);
   }
 
   ECMA_FINALIZE (prim_value);
@@ -1144,15 +1139,15 @@ ecma_builtin_date_prototype_to_iso_string (ecma_value_t this_arg) /**< this argu
                   ecma_date_get_primitive_value (this_arg),
                   ret_value);
 
-  ecma_number_t *prim_num_p = ecma_get_number_from_value (prim_value);
+  ecma_number_t prim_num = ecma_get_number_from_value (prim_value);
 
-  if (ecma_number_is_nan (*prim_num_p) || ecma_number_is_infinity (*prim_num_p))
+  if (ecma_number_is_nan (prim_num) || ecma_number_is_infinity (prim_num))
   {
     ret_value = ecma_raise_range_error (ECMA_ERR_MSG (""));
   }
   else
   {
-    ret_value = ecma_date_value_to_iso_string (*prim_num_p);
+    ret_value = ecma_date_value_to_iso_string (prim_num);
   }
 
   ECMA_FINALIZE (prim_value);
@@ -1188,9 +1183,9 @@ ecma_builtin_date_prototype_to_json (ecma_value_t this_arg, /**< this argument *
   /* 3. */
   if (ecma_is_value_number (tv))
   {
-    ecma_number_t num_value_p = *ecma_get_number_from_value (tv);
+    ecma_number_t num_value = ecma_get_number_from_value (tv);
 
-    if (ecma_number_is_nan (num_value_p) || ecma_number_is_infinity (num_value_p))
+    if (ecma_number_is_nan (num_value) || ecma_number_is_infinity (num_value))
     {
       ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_NULL);
     }
@@ -1247,9 +1242,9 @@ ecma_builtin_date_prototype_get_year (ecma_value_t this_arg) /**< this argument
 
   /* 1. */
   ECMA_TRY_CATCH (value, ecma_builtin_date_prototype_get_time (this_arg), ret_value);
-  ecma_number_t *this_num_p = ecma_get_number_from_value (value);
+  ecma_number_t this_num = ecma_get_number_from_value (value);
   /* 2. */
-  if (ecma_number_is_nan (*this_num_p))
+  if (ecma_number_is_nan (this_num))
   {
     ecma_string_t *nan_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_NAN);
     ret_value = ecma_make_string_value (nan_str_p);
@@ -1257,9 +1252,8 @@ ecma_builtin_date_prototype_get_year (ecma_value_t this_arg) /**< this argument
   else
   {
     /* 3. */
-    ecma_number_t *ret_num_p = ecma_alloc_number ();
+    ecma_number_t ret_num = ecma_date_year_from_time (ecma_date_local_time (this_num)) - 1900;
-    *ret_num_p = ecma_date_year_from_time (ecma_date_local_time (*this_num_p)) - 1900;
+    ret_value = ecma_make_number_value (ret_num);
-    ret_value = ecma_make_number_value (ret_num_p);
   }
   ECMA_FINALIZE (value);
 
@@ -1283,7 +1277,7 @@ ecma_builtin_date_prototype_set_year (ecma_value_t this_arg, /**< this argument
 
   /* 1. */
   ECMA_TRY_CATCH (this_time_value, ecma_builtin_date_prototype_get_time (this_arg), ret_value);
-  ecma_number_t t = ecma_date_local_time (*ecma_get_number_from_value (this_time_value));
+  ecma_number_t t = ecma_date_local_time (ecma_get_number_from_value (this_time_value));
   if (ecma_number_is_nan (t))
   {
     t = ECMA_NUMBER_ZERO;

jerry-core/ecma/builtin-objects/ecma-builtin-date.c

@@ -81,14 +81,13 @@ ecma_date_construct_helper (const ecma_value_t *args, /**< arguments passed to t
                             ecma_length_t args_len) /**< number of arguments */
 {
   ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
-  ecma_number_t *prim_value_p = ecma_alloc_number ();
+  ecma_number_t prim_value = ecma_number_make_nan ();
-  *prim_value_p = ecma_number_make_nan ();
 
   ECMA_TRY_CATCH (year_value, ecma_op_to_number (args[0]), ret_value);
   ECMA_TRY_CATCH (month_value, ecma_op_to_number (args[1]), ret_value);
 
-  ecma_number_t year = *ecma_get_number_from_value (year_value);
+  ecma_number_t year = ecma_get_number_from_value (year_value);
-  ecma_number_t month = *ecma_get_number_from_value (month_value);
+  ecma_number_t month = ecma_get_number_from_value (month_value);
   ecma_number_t date = ECMA_NUMBER_ONE;
   ecma_number_t hours = ECMA_NUMBER_ZERO;
   ecma_number_t minutes = ECMA_NUMBER_ZERO;
@@ -99,7 +98,7 @@ ecma_date_construct_helper (const ecma_value_t *args, /**< arguments passed to t
   if (args_len >= 3 && ecma_is_value_empty (ret_value))
   {
     ECMA_TRY_CATCH (date_value, ecma_op_to_number (args[2]), ret_value);
-    date = *ecma_get_number_from_value (date_value);
+    date = ecma_get_number_from_value (date_value);
     ECMA_FINALIZE (date_value);
   }
 
@@ -107,7 +106,7 @@ ecma_date_construct_helper (const ecma_value_t *args, /**< arguments passed to t
   if (args_len >= 4 && ecma_is_value_empty (ret_value))
   {
     ECMA_TRY_CATCH (hours_value, ecma_op_to_number (args[3]), ret_value);
-    hours = *ecma_get_number_from_value (hours_value);
+    hours = ecma_get_number_from_value (hours_value);
     ECMA_FINALIZE (hours_value);
   }
 
@@ -115,7 +114,7 @@ ecma_date_construct_helper (const ecma_value_t *args, /**< arguments passed to t
   if (args_len >= 5 && ecma_is_value_empty (ret_value))
   {
     ECMA_TRY_CATCH (minutes_value, ecma_op_to_number (args[4]), ret_value);
-    minutes = *ecma_get_number_from_value (minutes_value);
+    minutes = ecma_get_number_from_value (minutes_value);
     ECMA_FINALIZE (minutes_value);
   }
 
@@ -123,7 +122,7 @@ ecma_date_construct_helper (const ecma_value_t *args, /**< arguments passed to t
   if (args_len >= 6 && ecma_is_value_empty (ret_value))
   {
     ECMA_TRY_CATCH (seconds_value, ecma_op_to_number (args[5]), ret_value);
-    seconds = *ecma_get_number_from_value (seconds_value);
+    seconds = ecma_get_number_from_value (seconds_value);
     ECMA_FINALIZE (seconds_value);
   }
 
@@ -131,7 +130,7 @@ ecma_date_construct_helper (const ecma_value_t *args, /**< arguments passed to t
   if (args_len >= 7 && ecma_is_value_empty (ret_value))
   {
     ECMA_TRY_CATCH (milliseconds_value, ecma_op_to_number (args[6]), ret_value);
-    milliseconds = *ecma_get_number_from_value (milliseconds_value);
+    milliseconds = ecma_get_number_from_value (milliseconds_value);
     ECMA_FINALIZE (milliseconds_value);
   }
 
@@ -152,13 +151,13 @@ ecma_date_construct_helper (const ecma_value_t *args, /**< arguments passed to t
       }
     }
 
-    *prim_value_p = ecma_date_make_date (ecma_date_make_day (year,
+    prim_value = ecma_date_make_date (ecma_date_make_day (year,
-                                                             month,
+                                                          month,
-                                                             date),
+                                                          date),
-                                         ecma_date_make_time (hours,
+                                      ecma_date_make_time (hours,
-                                                              minutes,
+                                                           minutes,
-                                                              seconds,
+                                                           seconds,
-                                                              milliseconds));
+                                                           milliseconds));
   }
 
   ECMA_FINALIZE (month_value);
@@ -166,11 +165,7 @@ ecma_date_construct_helper (const ecma_value_t *args, /**< arguments passed to t
 
   if (ecma_is_value_empty (ret_value))
   {
-    ret_value = ecma_make_number_value (prim_value_p);
+    ret_value = ecma_make_number_value (prim_value);
-  }
-  else
-  {
-    ecma_dealloc_number (prim_value_p);
   }
 
   return ret_value;
@@ -191,8 +186,7 @@ ecma_builtin_date_parse (ecma_value_t this_arg __attr_unused___, /**< this argum
                          ecma_value_t arg) /**< string */
 {
   ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
-  ecma_number_t *date_num_p = ecma_alloc_number ();
+  ecma_number_t date_num = ecma_number_make_nan ();
-  *date_num_p = ecma_number_make_nan ();
 
   /* Date Time String fromat (ECMA-262 v5, 15.9.1.15) */
   ECMA_TRY_CATCH (date_str_value,
@@ -382,11 +376,11 @@ ecma_builtin_date_parse (ecma_value_t this_arg __attr_unused___, /**< this argum
     if (date_str_curr_p >= date_str_end_p)
     {
       ecma_number_t date = ecma_date_make_day (year, month - 1, day);
-      *date_num_p = ecma_date_make_date (date, time);
+      date_num = ecma_date_make_date (date, time);
     }
   }
 
-  ret_value = ecma_make_number_value (date_num_p);
+  ret_value = ecma_make_number_value (date_num);
 
   ECMA_FINALIZE_UTF8_STRING (date_start_p, date_start_size);
   ECMA_FINALIZE (date_str_value);
@@ -416,17 +410,13 @@ ecma_builtin_date_utc (ecma_value_t this_arg __attr_unused___, /**< this argumen
      *      When the UTC function is called with fewer than two arguments,
      *      the behaviour is implementation-dependent, so just return NaN.
      */
-    ecma_number_t *nan_p = ecma_alloc_number ();
+    return ecma_make_number_value (ecma_number_make_nan ());
-    *nan_p = ecma_number_make_nan ();
-    return ecma_make_number_value (nan_p);
   }
 
   ECMA_TRY_CATCH (time_value, ecma_date_construct_helper (args, args_number), ret_value);
 
-  ecma_number_t *time_p = ecma_get_number_from_value (time_value);
+  ecma_number_t time = ecma_get_number_from_value (time_value);
-  ecma_number_t *time_clip_p = ecma_alloc_number ();
+  ret_value = ecma_make_number_value (ecma_date_time_clip (time));
-  *time_clip_p = ecma_date_time_clip (*time_p);
-  ret_value = ecma_make_number_value (time_clip_p);
 
   ECMA_FINALIZE (time_value);
 
@@ -445,11 +435,7 @@ ecma_builtin_date_utc (ecma_value_t this_arg __attr_unused___, /**< this argumen
 static ecma_value_t
 ecma_builtin_date_now (ecma_value_t this_arg __attr_unused___) /**< this argument */
 {
-  ecma_number_t *now_num_p = ecma_alloc_number ();
+  return ecma_make_number_value (DOUBLE_TO_ECMA_NUMBER_T (jerry_port_get_current_time ()));
-
-  *now_num_p = DOUBLE_TO_ECMA_NUMBER_T (jerry_port_get_current_time ());
-
-  return ecma_make_number_value (now_num_p);
 } /* ecma_builtin_date_now */
 
 /**
@@ -470,7 +456,7 @@ ecma_builtin_date_dispatch_call (const ecma_value_t *arguments_list_p __attr_unu
                   ecma_builtin_date_now (ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED)),
                   ret_value);
 
-  ret_value = ecma_date_value_to_string (*ecma_get_number_from_value (now_val));
+  ret_value = ecma_date_value_to_string (ecma_get_number_from_value (now_val));
 
   ECMA_FINALIZE (now_val);
 
@@ -490,7 +476,7 @@ ecma_builtin_date_dispatch_construct (const ecma_value_t *arguments_list_p, /**<
                                       ecma_length_t arguments_list_len) /**< number of arguments */
 {
   ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
-  ecma_number_t *prim_value_num_p = NULL;
+  ecma_number_t prim_value_num = ECMA_NUMBER_ZERO;
 
   ecma_object_t *prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_DATE_PROTOTYPE);
   ecma_object_t *obj_p = ecma_create_object (prototype_obj_p,
@@ -504,8 +490,7 @@ ecma_builtin_date_dispatch_construct (const ecma_value_t *arguments_list_p, /**<
                     ecma_builtin_date_now (ecma_make_object_value (obj_p)),
                     ret_value);
 
-    prim_value_num_p = ecma_alloc_number ();
+    prim_value_num = ecma_get_number_from_value (parse_res_value);
-    *prim_value_num_p = *ecma_get_number_from_value (parse_res_value);
 
     ECMA_FINALIZE (parse_res_value)
   }
@@ -521,8 +506,7 @@ ecma_builtin_date_dispatch_construct (const ecma_value_t *arguments_list_p, /**<
                       ecma_builtin_date_parse (ecma_make_object_value (obj_p), prim_comp_value),
                       ret_value);
 
-      prim_value_num_p = ecma_alloc_number ();
+      prim_value_num = ecma_get_number_from_value (parse_res_value);
-      *prim_value_num_p = *ecma_get_number_from_value (parse_res_value);
 
       ECMA_FINALIZE (parse_res_value);
     }
@@ -530,8 +514,7 @@ ecma_builtin_date_dispatch_construct (const ecma_value_t *arguments_list_p, /**<
     {
       ECMA_TRY_CATCH (prim_value, ecma_op_to_number (arguments_list_p[0]), ret_value);
 
-      prim_value_num_p = ecma_alloc_number ();
+      prim_value_num = ecma_date_time_clip (ecma_get_number_from_value (prim_value));
-      *prim_value_num_p = ecma_date_time_clip (*ecma_get_number_from_value (prim_value));
 
       ECMA_FINALIZE (prim_value);
     }
@@ -544,23 +527,21 @@ ecma_builtin_date_dispatch_construct (const ecma_value_t *arguments_list_p, /**<
                     ecma_date_construct_helper (arguments_list_p, arguments_list_len),
                     ret_value);
 
-    ecma_number_t *time_p = ecma_get_number_from_value (time_value);
+    ecma_number_t time = ecma_get_number_from_value (time_value);
-    prim_value_num_p = ecma_alloc_number ();
+    prim_value_num = ecma_date_time_clip (ecma_date_utc (time));
-    *prim_value_num_p = ecma_date_time_clip (ecma_date_utc (*time_p));
 
     ECMA_FINALIZE (time_value);
   }
   else
   {
-    prim_value_num_p = ecma_alloc_number ();
+    prim_value_num = ecma_number_make_nan ();
-    *prim_value_num_p = ecma_number_make_nan ();
   }
 
   if (ecma_is_value_empty (ret_value))
   {
-    if (!ecma_number_is_nan (*prim_value_num_p) && ecma_number_is_infinity (*prim_value_num_p))
+    if (!ecma_number_is_nan (prim_value_num) && ecma_number_is_infinity (prim_value_num))
     {
-      *prim_value_num_p = ecma_number_make_nan ();
+      prim_value_num = ecma_number_make_nan ();
     }
 
     ecma_property_t *class_prop_p = ecma_create_internal_property (obj_p,
@@ -569,6 +550,9 @@ ecma_builtin_date_dispatch_construct (const ecma_value_t *arguments_list_p, /**<
 
     ecma_property_t *prim_value_prop_p = ecma_create_internal_property (obj_p,
                                                                         ECMA_INTERNAL_PROPERTY_PRIMITIVE_NUMBER_VALUE);
+
+    ecma_number_t *prim_value_num_p = ecma_alloc_number ();
+    *prim_value_num_p = prim_value_num;
     ECMA_SET_INTERNAL_VALUE_POINTER (ECMA_PROPERTY_VALUE_PTR (prim_value_prop_p)->value, prim_value_num_p);
 
     ret_value = ecma_make_object_value (obj_p);

jerry-core/ecma/builtin-objects/ecma-builtin-function-prototype.c

@@ -281,7 +281,8 @@ ecma_builtin_function_prototype_object_bind (ecma_value_t this_arg, /**< this ar
      * See also: ecma_object_get_class_name
      */
 
-    ecma_number_t *length_p = ecma_alloc_number ();
+    /* 16. */
+    ecma_number_t length = ECMA_NUMBER_ZERO;
     ecma_string_t *magic_string_length_p = ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH);
 
     /* 15. */
@@ -294,25 +295,20 @@ ecma_builtin_function_prototype_object_bind (ecma_value_t this_arg, /**< this ar
       const ecma_length_t bound_arg_count = arg_count > 1 ? arg_count - 1 : 0;
 
       /* 15.a */
-      *length_p = *ecma_get_number_from_value (get_len_value) - ((ecma_number_t) bound_arg_count);
+      length = ecma_get_number_from_value (get_len_value) - ((ecma_number_t) bound_arg_count);
       ecma_free_value (get_len_value);
 
       /* 15.b */
-      if (ecma_number_is_negative (*length_p))
+      if (ecma_number_is_negative (length))
       {
-        *length_p = ECMA_NUMBER_ZERO;
+        length = ECMA_NUMBER_ZERO;
       }
     }
-    else
-    {
-      /* 16. */
-      *length_p = ECMA_NUMBER_ZERO;
-    }
 
     /* 17. */
     ecma_value_t completion = ecma_builtin_helper_def_prop (function_p,
                                                             magic_string_length_p,
-                                                            ecma_make_number_value (length_p),
+                                                            ecma_make_number_value (length),
                                                             false, /* Writable */
                                                             false, /* Enumerable */
                                                             false, /* Configurable */
@@ -321,7 +317,6 @@ ecma_builtin_function_prototype_object_bind (ecma_value_t this_arg, /**< this ar
     JERRY_ASSERT (ecma_is_value_boolean (completion));
 
     ecma_deref_ecma_string (magic_string_length_p);
-    ecma_dealloc_number (length_p);
 
     /* 19-21. */
     ecma_object_t *thrower_p = ecma_builtin_get (ECMA_BUILTIN_ID_TYPE_ERROR_THROWER);

jerry-core/ecma/builtin-objects/ecma-builtin-global.c

@@ -263,9 +263,7 @@ ecma_builtin_global_object_parse_int (ecma_value_t this_arg __attr_unused___, /*
         /* 8.a */
         if (rad < 2 || rad > 36)
         {
-          ecma_number_t *ret_num_p = ecma_alloc_number ();
+          ret_value = ecma_make_nan_value ();
-          *ret_num_p = ecma_number_make_nan ();
-          ret_value = ecma_make_number_value (ret_num_p);
         }
         /* 8.b */
         else if (rad != 16)
@@ -331,16 +329,13 @@ ecma_builtin_global_object_parse_int (ecma_value_t this_arg __attr_unused___, /*
         /* 12. */
         if (end_p == start_p)
         {
-          ecma_number_t *ret_num_p = ecma_alloc_number ();
+          ret_value = ecma_make_nan_value ();
-          *ret_num_p = ecma_number_make_nan ();
-          ret_value = ecma_make_number_value (ret_num_p);
         }
       }
 
       if (ecma_is_value_empty (ret_value))
       {
-        ecma_number_t *value_p = ecma_alloc_number ();
+        ecma_number_t value = ECMA_NUMBER_ZERO;
-        *value_p = 0;
         ecma_number_t multiplier = 1.0f;
 
         /* 13. and 14. */
@@ -368,34 +363,30 @@ ecma_builtin_global_object_parse_int (ecma_value_t this_arg __attr_unused___, /*
             JERRY_UNREACHABLE ();
           }
 
-          *value_p += current_number * multiplier;
+          value += current_number * multiplier;
           multiplier *= (ecma_number_t) rad;
         }
 
         /* 15. */
         if (sign < 0)
         {
-          *value_p *= (ecma_number_t) sign;
+          value *= (ecma_number_t) sign;
         }
 
-        ret_value = ecma_make_number_value (value_p);
+        ret_value = ecma_make_number_value (value);
       }
 
       ECMA_OP_TO_NUMBER_FINALIZE (radix_num);
     }
     else
     {
-      ecma_number_t *ret_num_p = ecma_alloc_number ();
+      ret_value = ecma_make_nan_value ();
-      *ret_num_p = ecma_number_make_nan ();
-      ret_value = ecma_make_number_value (ret_num_p);
     }
 
   }
   else
   {
-    ecma_number_t *ret_num_p = ecma_alloc_number ();
+    ret_value = ecma_make_nan_value ();
-    *ret_num_p = ecma_number_make_nan ();
-    ret_value = ecma_make_number_value (ret_num_p);
   }
 
   ECMA_FINALIZE_UTF8_STRING (string_buff, string_buff_size);
@@ -465,8 +456,6 @@ ecma_builtin_global_object_parse_float (ecma_value_t this_arg __attr_unused___,
       }
     }
 
-    ecma_number_t *ret_num_p = ecma_alloc_number ();
-
     const lit_utf8_byte_t *infinity_str_p = lit_get_magic_string_utf8 (LIT_MAGIC_STRING_INFINITY_UL);
     lit_utf8_byte_t *infinity_str_curr_p = (lit_utf8_byte_t *) infinity_str_p;
     lit_utf8_byte_t *infinity_str_end_p = infinity_str_curr_p + sizeof (*infinity_str_p);
@@ -478,8 +467,7 @@ ecma_builtin_global_object_parse_float (ecma_value_t this_arg __attr_unused___,
       if (infinity_str_curr_p == infinity_str_end_p)
       {
         /* String matched Infinity. */
-        *ret_num_p = ecma_number_make_infinity (sign);
+        ret_value = ecma_make_number_value (ecma_number_make_infinity (sign));
-        ret_value = ecma_make_number_value (ret_num_p);
         break;
       }
     }
@@ -590,36 +578,32 @@ ecma_builtin_global_object_parse_float (ecma_value_t this_arg __attr_unused___,
       /* String did not contain a valid number. */
       if (start_p == end_p)
       {
-        *ret_num_p = ecma_number_make_nan ();
+        ret_value = ecma_make_nan_value ();
-        ret_value = ecma_make_number_value (ret_num_p);
       }
       else
       {
         /* 5. */
-        *ret_num_p = ecma_utf8_string_to_number (start_p,
+        ecma_number_t ret_num = ecma_utf8_string_to_number (start_p,
-                                                 (lit_utf8_size_t) (end_p - start_p));
+                                                            (lit_utf8_size_t) (end_p - start_p));
 
         if (sign)
         {
-          *ret_num_p *= -1;
+          ret_num *= ECMA_NUMBER_MINUS_ONE;
         }
 
-        ret_value = ecma_make_number_value (ret_num_p);
+        ret_value = ecma_make_number_value (ret_num);
       }
     }
     /* String ended after sign character, or was empty after removing leading whitespace. */
     else if (ecma_is_value_empty (ret_value))
     {
-      *ret_num_p = ecma_number_make_nan ();
+      ret_value = ecma_make_nan_value ();
-      ret_value = ecma_make_number_value (ret_num_p);
     }
   }
   /* String length is zero. */
   else
   {
-    ecma_number_t *ret_num_p = ecma_alloc_number ();
+    ret_value = ecma_make_nan_value ();
-    *ret_num_p = ecma_number_make_nan ();
-    ret_value = ecma_make_number_value (ret_num_p);
   }
 
   ECMA_FINALIZE_UTF8_STRING (string_buff, string_buff_size);

jerry-core/ecma/builtin-objects/ecma-builtin-helpers-date.c

@@ -889,13 +889,13 @@ ecma_date_set_internal_property (ecma_value_t this_arg, /**< this argument */
 {
   JERRY_ASSERT (ecma_is_value_object (this_arg));
 
-  ecma_number_t *value_p = ecma_alloc_number ();
   ecma_number_t date = ecma_date_make_date (day, time);
   if (is_utc != ECMA_DATE_UTC)
   {
     date = ecma_date_utc (date);
   }
-  *value_p = ecma_date_time_clip (date);
+
+  ecma_number_t value = ecma_date_time_clip (date);
 
   ecma_object_t *obj_p = ecma_get_object_from_value (this_arg);
 
@@ -905,9 +905,9 @@ ecma_date_set_internal_property (ecma_value_t this_arg, /**< this argument */
   ecma_number_t *prim_value_num_p;
   prim_value_num_p = ECMA_GET_INTERNAL_VALUE_POINTER (ecma_number_t,
                                                       ecma_get_internal_property_value (prim_value_prop_p));
-  *prim_value_num_p = *value_p;
+  *prim_value_num_p = value;
 
-  return ecma_make_number_value (value_p);
+  return ecma_make_number_value (value);
 } /* ecma_date_set_internal_property */
 
 /**
@@ -1306,10 +1306,10 @@ ecma_date_get_primitive_value (ecma_value_t this_arg) /**< this argument */
                                                                      ECMA_INTERNAL_PROPERTY_PRIMITIVE_NUMBER_VALUE);
     JERRY_ASSERT (prim_value_prop_p != NULL);
 
-    ecma_number_t *prim_value_num_p = ecma_alloc_number ();
+    ecma_number_t prim_value_num;
-    *prim_value_num_p = *ECMA_GET_INTERNAL_VALUE_POINTER (ecma_number_t,
+    prim_value_num = *ECMA_GET_INTERNAL_VALUE_POINTER (ecma_number_t,
-                                                          ecma_get_internal_property_value (prim_value_prop_p));
+                                                       ecma_get_internal_property_value (prim_value_prop_p));
-    ret_value = ecma_make_number_value (prim_value_num_p);
+    ret_value = ecma_make_number_value (prim_value_num);
   }
 
   return ret_value;

jerry-core/ecma/builtin-objects/ecma-builtin-helpers.c

@@ -520,17 +520,16 @@ ecma_builtin_helper_string_prototype_object_index_of (ecma_value_t this_arg, /**
   /* 7 (indexOf) -- 8 (lastIndexOf) */
   ecma_string_t *search_str_p = ecma_get_string_from_value (search_str_val);
 
-  ecma_number_t *ret_num_p = ecma_alloc_number ();
+  ecma_number_t ret_num = ECMA_NUMBER_MINUS_ONE;
-  *ret_num_p = ECMA_NUMBER_MINUS_ONE;
 
   /* 8 (indexOf) -- 9 (lastIndexOf) */
   ecma_length_t index_of = 0;
   if (ecma_builtin_helper_string_find_index (original_str_p, search_str_p, first_index, start, &index_of))
   {
-    *ret_num_p = ((ecma_number_t) index_of);
+    ret_num = ((ecma_number_t) index_of);
   }
 
-  ret_value = ecma_make_number_value (ret_num_p);
+  ret_value = ecma_make_number_value (ret_num);
 
   ECMA_OP_TO_NUMBER_FINALIZE (pos_num);
   ECMA_FINALIZE (search_str_val);

jerry-core/ecma/builtin-objects/ecma-builtin-internal-routines-template.inc.h

@@ -251,10 +251,7 @@ TRY_TO_INSTANTIATE_PROPERTY_ROUTINE_NAME (ecma_object_t *obj_p, /**< object */
    }
 #define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable) case name: \
     { \
-      ecma_number_t *num_p = ecma_alloc_number (); \
+      value = ecma_make_number_value (number_value); \
-      *num_p = number_value; \
-      \
-      value = ecma_make_number_value (num_p); \
       \
       writable = prop_writable; \
       enumerable = prop_enumerable; \

jerry-core/ecma/builtin-objects/ecma-builtin-json.c

@@ -451,9 +451,7 @@ ecma_builtin_json_parse_value (ecma_json_token_t *token_p) /**< token argument *
   {
     case number_token:
     {
-      ecma_number_t *number_p = ecma_alloc_number ();
+      return ecma_make_number_value (token_p->u.number);
-      *number_p = token_p->u.number;
-      return ecma_make_number_value (number_p);
     }
     case string_token:
     {
@@ -1327,7 +1325,7 @@ ecma_builtin_json_str (ecma_string_t *key_p, /**< property key*/
     /* 9. */
     else if (ecma_is_value_number (my_val))
     {
-      ecma_number_t num_value_p = *ecma_get_number_from_value (my_val);
+      ecma_number_t num_value_p = ecma_get_number_from_value (my_val);
 
       /* 9.a */
       if (!ecma_number_is_nan (num_value_p) && !ecma_number_is_infinity (num_value_p))

jerry-core/ecma/builtin-objects/ecma-builtin-math.c

@@ -66,11 +66,7 @@ ecma_builtin_math_object_abs (ecma_value_t this_arg __attr_unused___, /**< 'this
 
   ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
 
-  ecma_number_t *num_p = ecma_alloc_number ();
+  ret_value = ecma_make_number_value (DOUBLE_TO_ECMA_NUMBER_T (fabs (arg_num)));
-
-  *num_p = DOUBLE_TO_ECMA_NUMBER_T (fabs (arg_num));
-
-  ret_value = ecma_make_number_value (num_p);
 
   ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
 
@@ -94,10 +90,7 @@ ecma_builtin_math_object_acos (ecma_value_t this_arg __attr_unused___, /**< 'thi
 
   ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
 
-  ecma_number_t *num_p = ecma_alloc_number ();
+  ret_value = ecma_make_number_value (DOUBLE_TO_ECMA_NUMBER_T (acos (arg_num)));
-  *num_p = DOUBLE_TO_ECMA_NUMBER_T (acos (arg_num));
-
-  ret_value = ecma_make_number_value (num_p);
 
   ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
   return ret_value;
@@ -120,10 +113,7 @@ ecma_builtin_math_object_asin (ecma_value_t this_arg __attr_unused___, /**< 'thi
 
   ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
 
-  ecma_number_t *num_p = ecma_alloc_number ();
+  ret_value = ecma_make_number_value (DOUBLE_TO_ECMA_NUMBER_T (asin (arg_num)));
-  *num_p = DOUBLE_TO_ECMA_NUMBER_T (asin (arg_num));
-
-  ret_value = ecma_make_number_value (num_p);
 
   ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
   return ret_value;
@@ -146,10 +136,7 @@ ecma_builtin_math_object_atan (ecma_value_t this_arg __attr_unused___, /**< 'thi
 
   ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
 
-  ecma_number_t *num_p = ecma_alloc_number ();
+  ret_value = ecma_make_number_value (DOUBLE_TO_ECMA_NUMBER_T (atan (arg_num)));
-  *num_p = DOUBLE_TO_ECMA_NUMBER_T (atan (arg_num));
-
-  ret_value = ecma_make_number_value (num_p);
 
   ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
   return ret_value;
@@ -174,10 +161,7 @@ ecma_builtin_math_object_atan2 (ecma_value_t this_arg __attr_unused___, /**< 'th
   ECMA_OP_TO_NUMBER_TRY_CATCH (x, arg1, ret_value);
   ECMA_OP_TO_NUMBER_TRY_CATCH (y, arg2, ret_value);
 
-  ecma_number_t *num_p = ecma_alloc_number ();
+  ret_value = ecma_make_number_value (DOUBLE_TO_ECMA_NUMBER_T (atan2 (x, y)));
-  *num_p = DOUBLE_TO_ECMA_NUMBER_T (atan2 (x, y));
-
-  ret_value = ecma_make_number_value (num_p);
 
   ECMA_OP_TO_NUMBER_FINALIZE (y);
   ECMA_OP_TO_NUMBER_FINALIZE (x);
@@ -201,9 +185,7 @@ ecma_builtin_math_object_ceil (ecma_value_t this_arg __attr_unused___, /**< 'thi
 
   ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
 
-  ecma_number_t *num_p = ecma_alloc_number ();
+  ret_value = ecma_make_number_value (DOUBLE_TO_ECMA_NUMBER_T (ceil (arg_num)));
-  *num_p = DOUBLE_TO_ECMA_NUMBER_T (ceil (arg_num));
-  ret_value = ecma_make_number_value (num_p);
 
   ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
   return ret_value;
@@ -226,9 +208,7 @@ ecma_builtin_math_object_cos (ecma_value_t this_arg __attr_unused___, /**< 'this
 
   ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
 
-  ecma_number_t *num_p = ecma_alloc_number ();
+  ret_value = ecma_make_number_value (DOUBLE_TO_ECMA_NUMBER_T (cos (arg_num)));
-  *num_p = DOUBLE_TO_ECMA_NUMBER_T (cos (arg_num));
-  ret_value = ecma_make_number_value (num_p);
 
   ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
   return ret_value;
@@ -251,11 +231,7 @@ ecma_builtin_math_object_exp (ecma_value_t this_arg __attr_unused___, /**< 'this
 
   ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
 
-  ecma_number_t *num_p = ecma_alloc_number ();
+  ret_value = ecma_make_number_value (DOUBLE_TO_ECMA_NUMBER_T (exp (arg_num)));
-
-  *num_p = DOUBLE_TO_ECMA_NUMBER_T (exp (arg_num));
-
-  ret_value = ecma_make_number_value (num_p);
 
   ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
 
@@ -279,9 +255,7 @@ ecma_builtin_math_object_floor (ecma_value_t this_arg __attr_unused___, /**< 'th
 
   ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
 
-  ecma_number_t *num_p = ecma_alloc_number ();
+  ret_value = ecma_make_number_value (DOUBLE_TO_ECMA_NUMBER_T (floor (arg_num)));
-  *num_p = DOUBLE_TO_ECMA_NUMBER_T (floor (arg_num));
-  ret_value = ecma_make_number_value (num_p);
 
   ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
   return ret_value;
@@ -304,11 +278,7 @@ ecma_builtin_math_object_log (ecma_value_t this_arg __attr_unused___, /**< 'this
 
   ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
 
-  ecma_number_t *num_p = ecma_alloc_number ();
+  ret_value = ecma_make_number_value (DOUBLE_TO_ECMA_NUMBER_T (log (arg_num)));
-
-  *num_p = DOUBLE_TO_ECMA_NUMBER_T (log (arg_num));
-
-  ret_value = ecma_make_number_value (num_p);
 
   ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
 
@@ -389,9 +359,7 @@ ecma_builtin_math_object_max (ecma_value_t this_arg __attr_unused___, /**< 'this
 
   if (ecma_is_value_empty (ret_value))
   {
-    ecma_number_t *num_p = ecma_alloc_number ();
+    ret_value = ecma_make_number_value (ret_num);
-    *num_p = ret_num;
-    ret_value = ecma_make_number_value (num_p);
   }
 
   return ret_value;
@@ -471,9 +439,7 @@ ecma_builtin_math_object_min (ecma_value_t this_arg __attr_unused___, /**< 'this
 
   if (ecma_is_value_empty (ret_value))
   {
-    ecma_number_t *num_p = ecma_alloc_number ();
+    ret_value = ecma_make_number_value (ret_num);
-    *num_p = ret_num;
-    ret_value = ecma_make_number_value (num_p);
   }
 
   return ret_value;
@@ -498,9 +464,7 @@ ecma_builtin_math_object_pow (ecma_value_t this_arg __attr_unused___, /**< 'this
   ECMA_OP_TO_NUMBER_TRY_CATCH (x, arg1, ret_value);
   ECMA_OP_TO_NUMBER_TRY_CATCH (y, arg2, ret_value);
 
-  ecma_number_t *num_p = ecma_alloc_number ();
+  ret_value = ecma_make_number_value (DOUBLE_TO_ECMA_NUMBER_T (pow (x, y)));
-  *num_p = DOUBLE_TO_ECMA_NUMBER_T (pow (x, y));
-  ret_value = ecma_make_number_value (num_p);
 
   ECMA_OP_TO_NUMBER_FINALIZE (y);
   ECMA_OP_TO_NUMBER_FINALIZE (x);
@@ -541,10 +505,7 @@ ecma_builtin_math_object_random (ecma_value_t this_arg __attr_unused___) /**< 't
   rand /= (ecma_number_t) max_uint32;
   rand *= (ecma_number_t) (max_uint32 - 1) / (ecma_number_t) max_uint32;
 
-  ecma_number_t *rand_p = ecma_alloc_number ();
+  return ecma_make_number_value (rand);
-  *rand_p = rand;
-
-  return ecma_make_number_value (rand_p);
 } /* ecma_builtin_math_object_random */
 
 /**
@@ -564,18 +525,18 @@ ecma_builtin_math_object_round (ecma_value_t this_arg __attr_unused___, /**< 'th
 
   ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
 
-  ecma_number_t *num_p = ecma_alloc_number ();
+  ecma_number_t num = ECMA_NUMBER_ZERO;
 
   if (ecma_number_is_nan (arg_num)
       || ecma_number_is_zero (arg_num)
       || ecma_number_is_infinity (arg_num))
   {
-    *num_p = arg_num;
+    num = arg_num;
   }
   else if (ecma_number_is_negative (arg_num)
            && arg_num >= -ECMA_NUMBER_HALF)
   {
-    *num_p = ecma_number_negate (ECMA_NUMBER_ZERO);
+    num = ecma_number_negate (ECMA_NUMBER_ZERO);
   }
   else
   {
@@ -586,15 +547,15 @@ ecma_builtin_math_object_round (ecma_value_t this_arg __attr_unused___, /**< 'th
 
     if (up_rounded - arg_num <= arg_num - down_rounded)
     {
-      *num_p = up_rounded;
+      num = up_rounded;
     }
     else
     {
-      *num_p = down_rounded;
+      num = down_rounded;
     }
   }
 
-  ret_value = ecma_make_number_value (num_p);
+  ret_value = ecma_make_number_value (num);
 
   ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
 
@@ -618,9 +579,7 @@ ecma_builtin_math_object_sin (ecma_value_t this_arg __attr_unused___, /**< 'this
 
   ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
 
-  ecma_number_t *num_p = ecma_alloc_number ();
+  ret_value = ecma_make_number_value (DOUBLE_TO_ECMA_NUMBER_T (sin (arg_num)));
-  *num_p = DOUBLE_TO_ECMA_NUMBER_T (sin (arg_num));
-  ret_value = ecma_make_number_value (num_p);
 
   ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
   return ret_value;
@@ -643,9 +602,7 @@ ecma_builtin_math_object_sqrt (ecma_value_t this_arg __attr_unused___, /**< 'thi
 
   ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
 
-  ecma_number_t *num_p = ecma_alloc_number ();
+  ret_value = ecma_make_number_value (DOUBLE_TO_ECMA_NUMBER_T (sqrt (arg_num)));
-  *num_p = DOUBLE_TO_ECMA_NUMBER_T (sqrt (arg_num));
-  ret_value = ecma_make_number_value (num_p);
 
   ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
   return ret_value;
@@ -668,10 +625,7 @@ ecma_builtin_math_object_tan (ecma_value_t this_arg __attr_unused___, /**< 'this
 
   ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
 
-  ecma_number_t *num_p = ecma_alloc_number ();
+  ret_value = ecma_make_number_value (DOUBLE_TO_ECMA_NUMBER_T (tan (arg_num)));
-  *num_p = DOUBLE_TO_ECMA_NUMBER_T (tan (arg_num));
-
-  ret_value = ecma_make_number_value (num_p);
 
   ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
   return ret_value;

jerry-core/ecma/builtin-objects/ecma-builtin-number-prototype.c

@@ -93,7 +93,7 @@ ecma_builtin_number_prototype_object_to_string (ecma_value_t this_arg, /**< this
   ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
 
   ECMA_TRY_CATCH (this_value, ecma_builtin_number_prototype_object_value_of (this_arg), ret_value);
-  ecma_number_t this_arg_number = *ecma_get_number_from_value (this_value);
+  ecma_number_t this_arg_number = ecma_get_number_from_value (this_value);
 
   if (arguments_list_len == 0
       || ecma_number_is_nan (this_arg_number)
@@ -362,10 +362,7 @@ ecma_builtin_number_prototype_object_value_of (ecma_value_t this_arg) /**< this
       prim_value_num_p = ECMA_GET_INTERNAL_VALUE_POINTER (ecma_number_t,
                                                           ecma_get_internal_property_value (prim_value_prop_p));
 
-      ecma_number_t *ret_num_p = ecma_alloc_number ();
+      return ecma_make_number_value (*prim_value_num_p);
-      *ret_num_p = *prim_value_num_p;
-
-      return ecma_make_number_value (ret_num_p);
     }
   }
 
@@ -388,7 +385,7 @@ ecma_builtin_number_prototype_object_to_fixed (ecma_value_t this_arg, /**< this
   ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
 
   ECMA_TRY_CATCH (this_value, ecma_builtin_number_prototype_object_value_of (this_arg), ret_value);
-  ecma_number_t this_num = *ecma_get_number_from_value (this_value);
+  ecma_number_t this_num = ecma_get_number_from_value (this_value);
 
   ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
 
@@ -592,7 +589,7 @@ ecma_builtin_number_prototype_object_to_exponential (ecma_value_t this_arg, /**<
 
   /* 1. */
   ECMA_TRY_CATCH (this_value, ecma_builtin_number_prototype_object_value_of (this_arg), ret_value);
-  ecma_number_t this_num = *ecma_get_number_from_value (this_value);
+  ecma_number_t this_num = ecma_get_number_from_value (this_value);
 
   ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
 
@@ -777,7 +774,7 @@ ecma_builtin_number_prototype_object_to_precision (ecma_value_t this_arg, /**< t
 
   /* 1. */
   ECMA_TRY_CATCH (this_value, ecma_builtin_number_prototype_object_value_of (this_arg), ret_value);
-  ecma_number_t this_num = *ecma_get_number_from_value (this_value);
+  ecma_number_t this_num = ecma_get_number_from_value (this_value);
 
   /* 2. */
   if (ecma_is_value_undefined (arg))

jerry-core/ecma/builtin-objects/ecma-builtin-number.c

@@ -59,10 +59,7 @@ ecma_builtin_number_dispatch_call (const ecma_value_t *arguments_list_p, /**< ar
 
   if (arguments_list_len == 0)
   {
-    ecma_number_t *zero_num_p = ecma_alloc_number ();
+    ret_value = ecma_make_integer_value (0);
-    *zero_num_p = ECMA_NUMBER_ZERO;
-
-    ret_value = ecma_make_number_value (zero_num_p);
   }
   else
   {
@@ -85,13 +82,7 @@ ecma_builtin_number_dispatch_construct (const ecma_value_t *arguments_list_p, /*
 
   if (arguments_list_len == 0)
   {
-    ecma_number_t *zero_num_p = ecma_alloc_number ();
+    ecma_value_t completion = ecma_op_create_number_object (ecma_make_integer_value (0));
-    *zero_num_p = ECMA_NUMBER_ZERO;
-
-    ecma_value_t completion = ecma_op_create_number_object (ecma_make_number_value (zero_num_p));
-
-    ecma_dealloc_number (zero_num_p);
-
     return completion;
   }
   else

jerry-core/ecma/builtin-objects/ecma-builtin-string-prototype.c

@@ -195,13 +195,11 @@ ecma_builtin_string_prototype_object_char_code_at (ecma_value_t this_arg, /**< t
   ecma_string_t *original_string_p = ecma_get_string_from_value (to_string_val);
   const ecma_length_t len = ecma_string_get_length (original_string_p);
 
-  ecma_number_t *ret_num_p = ecma_alloc_number ();
-
   /* 5 */
   // When index_num is NaN, then the first two comparisons are false
   if (index_num < 0 || index_num >= len || (ecma_number_is_nan (index_num) && !len))
   {
-    *ret_num_p = ecma_number_make_nan ();
+    ret_value = ecma_make_nan_value ();
   }
   else
   {
@@ -215,12 +213,9 @@ ecma_builtin_string_prototype_object_char_code_at (ecma_value_t this_arg, /**< t
     JERRY_ASSERT (ecma_number_is_nan (index_num) || ecma_number_to_uint32 (index_num) == ecma_number_trunc (index_num));
 
     ecma_char_t new_ecma_char = ecma_string_get_char_at_pos (original_string_p, ecma_number_to_uint32 (index_num));
-    *ret_num_p = ((ecma_number_t) new_ecma_char);
+    ret_value = ecma_make_uint32_value (new_ecma_char);
   }
 
-  ecma_value_t new_value = ecma_make_number_value (ret_num_p);
-  ret_value = new_value;
-
   ECMA_OP_TO_NUMBER_FINALIZE (index_num);
 
   ECMA_FINALIZE (to_string_val);
@@ -364,22 +359,22 @@ ecma_builtin_string_prototype_object_locale_compare (ecma_value_t this_arg, /**<
   ecma_string_t *this_string_p = ecma_get_string_from_value (this_to_string_val);
   ecma_string_t *arg_string_p = ecma_get_string_from_value (arg_to_string_val);
 
-  ecma_number_t *result_p = ecma_alloc_number ();
+  ecma_number_t result = ECMA_NUMBER_ZERO;
 
   if (ecma_compare_ecma_strings_relational (this_string_p, arg_string_p))
   {
-    *result_p = ECMA_NUMBER_MINUS_ONE;
+    result = ECMA_NUMBER_MINUS_ONE;
   }
   else if (!ecma_compare_ecma_strings (this_string_p, arg_string_p))
   {
-    *result_p = ECMA_NUMBER_ONE;
+    result = ECMA_NUMBER_ONE;
   }
   else
   {
-    *result_p = ECMA_NUMBER_ZERO;
+    result = ECMA_NUMBER_ZERO;
   }
 
-  ret_value = ecma_make_number_value (result_p);
+  ret_value = ecma_make_number_value (result);
 
   ECMA_FINALIZE (arg_to_string_val);
   ECMA_FINALIZE (this_to_string_val);
@@ -456,9 +451,6 @@ ecma_builtin_string_prototype_object_match (ecma_value_t this_arg, /**< this arg
     else
     {
       /* 8.a. */
-      ecma_number_t *zero_number_p = ecma_alloc_number ();
-      *zero_number_p = 0;
-
       ecma_string_t *index_zero_string_p = ecma_new_ecma_string_from_uint32 (0);
 
       ecma_string_t *last_index_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_LASTINDEX_UL);
@@ -466,7 +458,7 @@ ecma_builtin_string_prototype_object_match (ecma_value_t this_arg, /**< this arg
       ECMA_TRY_CATCH (put_value,
                       ecma_op_object_put (regexp_obj_p,
                                           last_index_string_p,
-                                          ecma_make_number_value (zero_number_p),
+                                          ecma_make_integer_value (0),
                                           true),
                       ret_value);
 
@@ -508,18 +500,16 @@ ecma_builtin_string_prototype_object_match (ecma_value_t this_arg, /**< this arg
                           ecma_op_to_number (this_index_value),
                           ret_value);
 
-          ecma_number_t this_index = *ecma_get_number_from_value (this_index_number);
+          ecma_number_t this_index = ecma_get_number_from_value (this_index_number);
 
           /* 8.f.iii.2. */
           if (this_index == previous_last_index)
           {
-            ecma_number_t *new_last_index_p = ecma_alloc_number ();
-            *new_last_index_p = this_index + 1;
             /* 8.f.iii.2.a. */
             ECMA_TRY_CATCH (index_put_value,
                             ecma_op_object_put (regexp_obj_p,
                                                 last_index_string_p,
-                                                ecma_make_number_value (new_last_index_p),
+                                                ecma_make_number_value (this_index + 1),
                                                 true),
                             ret_value);
 
@@ -527,8 +517,6 @@ ecma_builtin_string_prototype_object_match (ecma_value_t this_arg, /**< this arg
             previous_last_index = this_index + 1;
 
             ECMA_FINALIZE (index_put_value);
-
-            ecma_dealloc_number (new_last_index_p);
           }
           else
           {
@@ -595,7 +583,6 @@ ecma_builtin_string_prototype_object_match (ecma_value_t this_arg, /**< this arg
 
       ecma_deref_ecma_string (last_index_string_p);
       ecma_deref_ecma_string (index_zero_string_p);
-      ecma_dealloc_number (zero_number_p);
     }
 
     ECMA_FINALIZE (global_value);
@@ -727,12 +714,12 @@ ecma_builtin_string_prototype_object_replace_match (ecma_builtin_replace_search_
       /* We use the length of the result string to determine the
        * match end. This works regardless the global flag is set. */
       ecma_string_t *result_string_p = ecma_get_string_from_value (result_string_value);
-      ecma_number_t *index_number_p = ecma_get_number_from_value (index_value);
+      ecma_number_t index_number = ecma_get_number_from_value (index_value);
 
-      context_p->match_start = (ecma_length_t) (*index_number_p);
+      context_p->match_start = (ecma_length_t) (index_number);
       context_p->match_end = context_p->match_start + (ecma_length_t) ecma_string_get_length (result_string_p);
 
-      JERRY_ASSERT ((ecma_length_t) ecma_number_to_uint32 (*index_number_p) == context_p->match_start);
+      JERRY_ASSERT ((ecma_length_t) ecma_number_to_uint32 (index_number) == context_p->match_start);
 
       ret_value = ecma_copy_value (match_value);
 
@@ -800,10 +787,10 @@ ecma_builtin_string_prototype_object_replace_get_string (ecma_builtin_replace_se
 
   JERRY_ASSERT (ecma_is_value_number (match_length_value));
 
-  ecma_number_t *match_length_number_p = ecma_get_number_from_value (match_length_value);
+  ecma_number_t match_length_number = ecma_get_number_from_value (match_length_value);
-  ecma_length_t match_length = (ecma_length_t) (*match_length_number_p);
+  ecma_length_t match_length = (ecma_length_t) (match_length_number);
 
-  JERRY_ASSERT ((ecma_length_t) ecma_number_to_uint32 (*match_length_number_p) == match_length);
+  JERRY_ASSERT ((ecma_length_t) ecma_number_to_uint32 (match_length_number) == match_length);
   JERRY_ASSERT (match_length >= 1);
 
   if (context_p->is_replace_callable)
@@ -834,10 +821,7 @@ ecma_builtin_string_prototype_object_replace_get_string (ecma_builtin_replace_se
 
     if (ecma_is_value_empty (ret_value))
     {
-      ecma_number_t *index_number_p = ecma_alloc_number ();
+      arguments_list[match_length] = ecma_make_number_value (context_p->match_start);
-
-      *index_number_p = context_p->match_start;
-      arguments_list[match_length] = ecma_make_number_value (index_number_p);
       arguments_list[match_length + 1] = ecma_copy_value (context_p->input_string);
 
       ECMA_TRY_CATCH (result_value,
@@ -857,7 +841,6 @@ ecma_builtin_string_prototype_object_replace_get_string (ecma_builtin_replace_se
       ECMA_FINALIZE (result_value);
 
       ecma_free_value (arguments_list[match_length + 1]);
-      ecma_dealloc_number (index_number_p);
     }
 
     for (ecma_length_t i = 0; i < values_copied; i++)
@@ -1122,19 +1105,15 @@ ecma_builtin_string_prototype_object_replace_loop (ecma_builtin_replace_search_c
         {
           ecma_string_t *last_index_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_LASTINDEX_UL);
           ecma_object_t *regexp_obj_p = ecma_get_object_from_value (context_p->regexp_or_search_string);
-          ecma_number_t *zero_number_p = ecma_alloc_number ();
-
-          *zero_number_p = context_p->match_end + 1;
 
           ECMA_TRY_CATCH (put_value,
                           ecma_op_object_put (regexp_obj_p,
                                               last_index_string_p,
-                                              ecma_make_number_value (zero_number_p),
+                                              ecma_make_number_value (context_p->match_end + 1),
                                               true),
                           ret_value);
 
           ECMA_FINALIZE (put_value);
-          ecma_dealloc_number (zero_number_p);
           ecma_deref_ecma_string (last_index_string_p);
         }
       }
@@ -1286,18 +1265,15 @@ ecma_builtin_string_prototype_object_replace (ecma_value_t this_arg, /**< this a
     if (context.is_global)
     {
       ecma_string_t *last_index_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_LASTINDEX_UL);
-      ecma_number_t *zero_number_p = ecma_alloc_number ();
-      *zero_number_p = 0;
 
       ECMA_TRY_CATCH (put_value,
                       ecma_op_object_put (regexp_obj_p,
                                           last_index_string_p,
-                                          ecma_make_number_value (zero_number_p),
+                                          ecma_make_integer_value (0),
                                           true),
                       ret_value);
 
       ECMA_FINALIZE (put_value);
-      ecma_dealloc_number (zero_number_p);
       ecma_deref_ecma_string (last_index_string_p);
     }
 
@@ -1401,7 +1377,7 @@ ecma_builtin_string_prototype_object_search (ecma_value_t this_arg, /**< this ar
 
       JERRY_ASSERT (ecma_is_value_number (index_value));
 
-      offset = *ecma_get_number_from_value (index_value);
+      offset = ecma_get_number_from_value (index_value);
 
       ECMA_FINALIZE (index_value);
       ecma_deref_ecma_string (index_string_p);
@@ -1409,10 +1385,7 @@ ecma_builtin_string_prototype_object_search (ecma_value_t this_arg, /**< this ar
 
     if (ecma_is_value_empty (ret_value))
     {
-      ecma_number_t *offset_number_p = ecma_alloc_number ();
+      ret_value = ecma_make_number_value (offset);
-      *offset_number_p = offset;
-
-      ret_value = ecma_make_number_value (offset_number_p);
     }
 
     ECMA_FINALIZE (match_result);
@@ -1546,8 +1519,8 @@ ecma_builtin_helper_split_match (ecma_value_t input_string, /**< first argument
       ecma_string_t *magic_index_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_INDEX);
       ecma_property_t *index_prop_p = ecma_get_named_property (obj_p, magic_index_str_p);
 
-      ecma_number_t *index_num_p = ecma_get_number_from_value (ecma_get_named_data_property_value (index_prop_p));
+      ecma_number_t index_num = ecma_get_number_from_value (ecma_get_named_data_property_value (index_prop_p));
-      *index_num_p += start_idx;
+      ecma_value_assign_number (&ECMA_PROPERTY_VALUE_PTR (index_prop_p)->value, index_num + start_idx);
 
       ecma_deref_ecma_string (magic_index_str_p);
     }
@@ -1603,14 +1576,12 @@ ecma_builtin_helper_split_match (ecma_value_t input_string, /**< first argument
                                                                          true, false, false);
         ecma_deref_ecma_string (magic_index_str_p);
 
-        ecma_number_t *index_num_p = ecma_alloc_number ();
+        ecma_named_data_property_assign_value (match_array_p,
-        *index_num_p = ((ecma_number_t) start_idx);
+                                               index_prop_p,
-
+                                               ecma_make_uint32_value (start_idx));
-        ecma_named_data_property_assign_value (match_array_p, index_prop_p, ecma_make_number_value (index_num_p));
 
         ret_value = match_array;
 
-        ecma_dealloc_number (index_num_p);
         ecma_deref_ecma_string (zero_str_p);
       }
       else
@@ -1809,10 +1780,10 @@ ecma_builtin_string_prototype_object_split (ecma_value_t this_arg, /**< this arg
               ecma_property_t *index_prop_p = ecma_get_named_property (match_array_obj_p, magic_index_str_p);
 
               ecma_value_t index_value = ecma_get_named_data_property_value (index_prop_p);
-              ecma_number_t *index_num_p = ecma_get_number_from_value (index_value);
+              ecma_number_t index_num = ecma_get_number_from_value (index_value);
-              JERRY_ASSERT (*index_num_p >= 0);
+              JERRY_ASSERT (index_num >= 0);
 
-              uint32_t end_pos = ecma_number_to_uint32 (*index_num_p);
+              uint32_t end_pos = ecma_number_to_uint32 (index_num);
 
               if (separator_is_empty)
               {

jerry-core/ecma/builtin-objects/ecma-builtins.c

@@ -321,11 +321,7 @@ ecma_builtin_try_to_instantiate_property (ecma_object_t *object_p, /**< object *
                                                                      string_p,
                                                                      false, false, false);
 
-
+      ecma_set_named_data_property_value (len_prop_p, ecma_make_uint32_value (length_prop_value));
-      ecma_number_t *len_p = ecma_alloc_number ();
-      *len_p = length_prop_value;
-
-      ecma_set_named_data_property_value (len_prop_p, ecma_make_number_value (len_p));
 
       JERRY_ASSERT (!ecma_is_property_configurable (len_prop_p));
       return len_prop_p;

jerry-core/ecma/operations/ecma-array-object.c

@@ -64,9 +64,9 @@ ecma_op_create_array_object (const ecma_value_t *arguments_list_p, /**< list of
       && arguments_list_len == 1
       && ecma_is_value_number (arguments_list_p[0]))
   {
-    ecma_number_t *num_p = ecma_get_number_from_value (arguments_list_p[0]);
+    ecma_number_t num = ecma_get_number_from_value (arguments_list_p[0]);
-    uint32_t num_uint32 = ecma_number_to_uint32 (*num_p);
+    uint32_t num_uint32 = ecma_number_to_uint32 (num);
-    if (*num_p != ((ecma_number_t) num_uint32))
+    if (num != ((ecma_number_t) num_uint32))
     {
       return ecma_raise_range_error (ECMA_ERR_MSG (""));
     }
@@ -100,13 +100,11 @@ ecma_op_create_array_object (const ecma_value_t *arguments_list_p, /**< list of
    */
 
   ecma_string_t *length_magic_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH);
-  ecma_number_t *length_num_p = ecma_alloc_number ();
-  *length_num_p = ((ecma_number_t) length);
 
   ecma_property_t *length_prop_p = ecma_create_named_data_property (obj_p,
                                                                     length_magic_string_p,
                                                                     true, false, false);
-  ecma_set_named_data_property_value (length_prop_p, ecma_make_number_value (length_num_p));
+  ecma_set_named_data_property_value (length_prop_p, ecma_make_number_value ((ecma_number_t) length));
 
   ecma_deref_ecma_string (length_magic_string_p);
 
@@ -153,7 +151,6 @@ ecma_op_array_object_define_own_property (ecma_object_t *obj_p, /**< the array o
 {
   JERRY_ASSERT (ecma_get_object_type (obj_p) == ECMA_OBJECT_TYPE_ARRAY);
 
-
   // 1.
   ecma_string_t *magic_string_length_p = ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH);
   ecma_property_t *len_prop_p = ecma_op_object_get_own_property (obj_p, magic_string_length_p);
@@ -162,8 +159,7 @@ ecma_op_array_object_define_own_property (ecma_object_t *obj_p, /**< the array o
   // 2.
   ecma_value_t old_len_value = ecma_get_named_data_property_value (len_prop_p);
 
-  ecma_number_t *num_p = ecma_get_number_from_value (old_len_value);
+  uint32_t old_len_uint32 = ecma_get_uint32_from_value (old_len_value);
-  uint32_t old_len_uint32 = ecma_number_to_uint32 (*num_p);
 
   // 3.
   bool is_property_name_equal_length = ecma_compare_ecma_strings (property_name_p,
@@ -190,7 +186,7 @@ ecma_op_array_object_define_own_property (ecma_object_t *obj_p, /**< the array o
     JERRY_ASSERT (!ecma_is_value_error (completion)
                   && ecma_is_value_number (completion));
 
-    ecma_number_t new_len_num = *ecma_get_number_from_value (completion);
+    ecma_number_t new_len_num = ecma_get_number_from_value (completion);
 
     ecma_free_value (completion);
 
@@ -204,11 +200,8 @@ ecma_op_array_object_define_own_property (ecma_object_t *obj_p, /**< the array o
     else
     {
       // b., e.
-      ecma_number_t *new_len_num_p = ecma_alloc_number ();
-      *new_len_num_p = new_len_num;
-
       ecma_property_descriptor_t new_len_property_desc = *property_desc_p;
-      new_len_property_desc.value = ecma_make_number_value (new_len_num_p);
+      new_len_property_desc.value = ecma_make_number_value (new_len_num);
 
       ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
 
@@ -319,10 +312,9 @@ ecma_op_array_object_define_own_property (ecma_object_t *obj_p, /**< the array o
                 // iii.
                 new_len_uint32 = (index + 1u);
 
-                ecma_number_t *new_len_num_p = ecma_get_number_from_value (new_len_property_desc.value);
-
                 // 1.
-                *new_len_num_p = ((ecma_number_t) index + 1u);
+                ecma_number_t new_len_num = ((ecma_number_t) index + 1u);
+                ecma_value_assign_number (&new_len_property_desc.value, new_len_num);
 
                 // 2.
                 if (!new_writable)
@@ -381,7 +373,7 @@ ecma_op_array_object_define_own_property (ecma_object_t *obj_p, /**< the array o
         }
       }
 
-      ecma_dealloc_number (new_len_num_p);
+      ecma_free_value (new_len_property_desc.value);
 
       return ret_value;
     }
@@ -427,13 +419,14 @@ ecma_op_array_object_define_own_property (ecma_object_t *obj_p, /**< the array o
     // e.
     if (index >= old_len_uint32)
     {
+      ecma_property_value_t *len_prop_value_p = ECMA_PROPERTY_VALUE_PTR (len_prop_p);
+
       // i., ii.
-      ecma_number_t *num_p = ecma_alloc_number ();
+      if (index < UINT32_MAX)
-      *num_p = ecma_number_add (((ecma_number_t) index), ECMA_NUMBER_ONE);
+      {
-
+        /* Setting the length property is always successful. */
-      ecma_named_data_property_assign_value (obj_p, len_prop_p, ecma_make_number_value (num_p));
+        ecma_value_assign_uint32 (&len_prop_value_p->value, index + 1);
-
+      }
-      ecma_dealloc_number (num_p);
     }
 
     // f.

jerry-core/ecma/operations/ecma-comparison.c

@@ -73,8 +73,8 @@ ecma_op_abstract_equality_compare (ecma_value_t x, /**< first operand */
     }
     else if (is_x_number)
     { // c.
-      ecma_number_t x_num = *ecma_get_number_from_value (x);
+      ecma_number_t x_num = ecma_get_number_from_value (x);
-      ecma_number_t y_num = *ecma_get_number_from_value (y);
+      ecma_number_t y_num = ecma_get_number_from_value (y);
 
       bool is_x_equal_to_y = (x_num == y_num);
 
@@ -267,8 +267,8 @@ ecma_op_strict_equality_compare (ecma_value_t x, /**< first operand */
     // d. If x is +0 and y is -0, return true.
     // e. If x is -0 and y is +0, return true.
 
-    ecma_number_t x_num = *ecma_get_number_from_value (x);
+    ecma_number_t x_num = ecma_get_number_from_value (x);
-    ecma_number_t y_num = *ecma_get_number_from_value (y);
+    ecma_number_t y_num = ecma_get_number_from_value (y);
 
     bool is_x_equal_to_y = (x_num == y_num);
 

jerry-core/ecma/operations/ecma-conversion.c

@@ -109,11 +109,11 @@ ecma_op_same_value (ecma_value_t x, /**< ecma value */
   }
   else if (is_x_number)
   {
-    ecma_number_t *x_num_p = ecma_get_number_from_value (x);
+    ecma_number_t x_num = ecma_get_number_from_value (x);
-    ecma_number_t *y_num_p = ecma_get_number_from_value (y);
+    ecma_number_t y_num = ecma_get_number_from_value (y);
 
-    bool is_x_nan = ecma_number_is_nan (*x_num_p);
+    bool is_x_nan = ecma_number_is_nan (x_num);
-    bool is_y_nan = ecma_number_is_nan (*y_num_p);
+    bool is_y_nan = ecma_number_is_nan (y_num);
 
     if (is_x_nan || is_y_nan)
     {
@@ -126,15 +126,15 @@ ecma_op_same_value (ecma_value_t x, /**< ecma value */
        */
       return (is_x_nan && is_y_nan);
     }
-    else if (ecma_number_is_zero (*x_num_p)
+    else if (ecma_number_is_zero (x_num)
-             && ecma_number_is_zero (*y_num_p)
+             && ecma_number_is_zero (y_num)
-             && ecma_number_is_negative (*x_num_p) != ecma_number_is_negative (*y_num_p))
+             && ecma_number_is_negative (x_num) != ecma_number_is_negative (y_num))
     {
       return false;
     }
     else
     {
-      return (*x_num_p == *y_num_p);
+      return (x_num == y_num);
     }
   }
   else if (is_x_string)
@@ -212,10 +212,10 @@ ecma_op_to_boolean (ecma_value_t value) /**< ecma value */
   }
   else if (ecma_is_value_number (value))
   {
-    ecma_number_t *num_p = ecma_get_number_from_value (value);
+    ecma_number_t num = ecma_get_number_from_value (value);
 
-    if (ecma_number_is_nan (*num_p)
+    if (ecma_number_is_nan (num)
-        || ecma_number_is_zero (*num_p))
+        || ecma_number_is_zero (num))
     {
       ret_value = ECMA_SIMPLE_VALUE_FALSE;
     }
@@ -261,18 +261,18 @@ ecma_op_to_number (ecma_value_t value) /**< ecma value */
 {
   ecma_check_value_type_is_spec_defined (value);
 
-  if (ecma_is_value_number (value))
+  if (ecma_is_value_integer_number (value))
+  {
+    return value;
+  }
+  else if (ecma_is_value_float_number (value))
   {
     return ecma_copy_value (value);
   }
   else if (ecma_is_value_string (value))
   {
     ecma_string_t *str_p = ecma_get_string_from_value (value);
-
+    return ecma_make_number_value (ecma_string_to_number (str_p));
-    ecma_number_t *num_p = ecma_alloc_number ();
-    *num_p = ecma_string_to_number (str_p);
-
-    return ecma_make_number_value (num_p);
   }
   else if (ecma_is_value_object (value))
   {
@@ -290,15 +290,15 @@ ecma_op_to_number (ecma_value_t value) /**< ecma value */
   }
   else
   {
-    ecma_number_t *num_p = ecma_alloc_number ();
+    int16_t num = 0;
 
     if (ecma_is_value_undefined (value))
     {
-      *num_p = ecma_number_make_nan ();
+      return ecma_make_nan_value ();
     }
     else if (ecma_is_value_null (value))
     {
-      *num_p = ECMA_NUMBER_ZERO;
+      num = 0;
     }
     else
     {
@@ -306,15 +306,15 @@ ecma_op_to_number (ecma_value_t value) /**< ecma value */
 
       if (ecma_is_value_true (value))
       {
-        *num_p = ECMA_NUMBER_ONE;
+        num = 1;
       }
       else
       {
-        *num_p = ECMA_NUMBER_ZERO;
+        num = 0;
       }
     }
 
-    return ecma_make_number_value (num_p);
+    return ecma_make_integer_value (num);
   }
 } /* ecma_op_to_number */
 
@@ -357,8 +357,8 @@ ecma_op_to_string (ecma_value_t value) /**< ecma value */
     }
     else if (ecma_is_value_number (value))
     {
-      ecma_number_t *num_p = ecma_get_number_from_value (value);
+      ecma_number_t num = ecma_get_number_from_value (value);
-      res_p = ecma_new_ecma_string_from_number (*num_p);
+      res_p = ecma_new_ecma_string_from_number (num);
     }
     else if (ecma_is_value_undefined (value))
     {

jerry-core/ecma/operations/ecma-function-object.c

@@ -289,7 +289,7 @@ ecma_op_function_try_lazy_instantiate_property (ecma_object_t *obj_p, /**< the f
     /* ECMA-262 v5, 13.2, 14-15 */
 
     // 14
-    ecma_number_t *len_p = ecma_alloc_number ();
+    uint32_t len = 0;
 
     ecma_property_t *bytecode_prop_p = ecma_get_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_CODE_BYTECODE);
 
@@ -300,12 +300,12 @@ ecma_op_function_try_lazy_instantiate_property (ecma_object_t *obj_p, /**< the f
     if (bytecode_data_p->status_flags & CBC_CODE_FLAGS_UINT16_ARGUMENTS)
     {
       cbc_uint16_arguments_t *args_p = (cbc_uint16_arguments_t *) bytecode_data_p;
-      *len_p = args_p->argument_end;
+      len = args_p->argument_end;
     }
     else
     {
       cbc_uint8_arguments_t *args_p = (cbc_uint8_arguments_t *) bytecode_data_p;
-      *len_p = args_p->argument_end;
+      len = args_p->argument_end;
     }
 
     // 15
@@ -315,9 +315,7 @@ ecma_op_function_try_lazy_instantiate_property (ecma_object_t *obj_p, /**< the f
                                                                       false,
                                                                       false);
 
-    ecma_named_data_property_assign_value (obj_p, length_prop_p, ecma_make_number_value (len_p));
+    ecma_named_data_property_assign_value (obj_p, length_prop_p, ecma_make_uint32_value (len));
-
-    ecma_dealloc_number (len_p);
 
     JERRY_ASSERT (!ecma_is_property_configurable (length_prop_p));
     return length_prop_p;

jerry-core/ecma/operations/ecma-number-object.c

@@ -48,7 +48,7 @@ ecma_op_create_number_object (ecma_value_t arg) /**< argument passed to the Numb
     return conv_to_num_completion;
   }
 
-  ecma_number_t *prim_value_p = ecma_get_number_from_value (conv_to_num_completion);
+  ecma_number_t prim_value = ecma_get_number_from_value (conv_to_num_completion);
 
 #ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_NUMBER_BUILTIN
   ecma_object_t *prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_NUMBER_PROTOTYPE);
@@ -66,8 +66,11 @@ ecma_op_create_number_object (ecma_value_t arg) /**< argument passed to the Numb
 
   ecma_property_t *prim_value_prop_p = ecma_create_internal_property (obj_p,
                                                                       ECMA_INTERNAL_PROPERTY_PRIMITIVE_NUMBER_VALUE);
+  ecma_number_t *prim_value_p = ecma_alloc_number ();
+  *prim_value_p = prim_value;
   ECMA_SET_INTERNAL_VALUE_POINTER (ECMA_PROPERTY_VALUE_PTR (prim_value_prop_p)->value, prim_value_p);
 
+  ecma_free_value (conv_to_num_completion);
   return ecma_make_object_value (obj_p);
 } /* ecma_op_create_number_object */
 

jerry-core/ecma/operations/ecma-objects-arguments.c

@@ -79,8 +79,6 @@ ecma_op_create_arguments_object (ecma_object_t *func_obj_p, /**< callee function
   bool is_strict = (bytecode_data_p->status_flags & CBC_CODE_FLAGS_STRICT_MODE) != 0;
 
   // 1.
-  ecma_number_t *len_p = ecma_alloc_number ();
-  *len_p = ((ecma_number_t) arguments_number);
 
   // 4.
   ecma_property_t *class_prop_p = ecma_create_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_CLASS);
@@ -90,7 +88,7 @@ ecma_op_create_arguments_object (ecma_object_t *func_obj_p, /**< callee function
   ecma_string_t *length_magic_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH);
   ecma_value_t completion = ecma_builtin_helper_def_prop (obj_p,
                                                           length_magic_string_p,
-                                                          ecma_make_number_value (len_p),
+                                                          ecma_make_uint32_value (arguments_number),
                                                           true, /* Writable */
                                                           false, /* Enumerable */
                                                           true, /* Configurable */
@@ -99,8 +97,6 @@ ecma_op_create_arguments_object (ecma_object_t *func_obj_p, /**< callee function
   JERRY_ASSERT (ecma_is_value_true (completion));
   ecma_deref_ecma_string (length_magic_string_p);
 
-  ecma_dealloc_number (len_p);
-
   ecma_property_descriptor_t prop_desc = ecma_make_empty_property_descriptor ();
 
   if (bytecode_data_p != NULL)

jerry-core/ecma/operations/ecma-regexp-object.c

@@ -214,11 +214,7 @@ re_initialize_props (ecma_object_t *re_obj_p, /**< RegExp obejct */
 
   ecma_deref_ecma_string (magic_string_p);
 
-  ecma_number_t *lastindex_num_p = ecma_alloc_number ();
+  ecma_named_data_property_assign_value (re_obj_p, prop_p, ecma_make_integer_value (0));
-  *lastindex_num_p = ECMA_NUMBER_ZERO;
-  JERRY_ASSERT (ECMA_PROPERTY_GET_TYPE (prop_p) == ECMA_PROPERTY_TYPE_NAMEDDATA);
-  ecma_named_data_property_assign_value (re_obj_p, prop_p, ecma_make_number_value (lastindex_num_p));
-  ecma_dealloc_number (lastindex_num_p);
 } /* re_initialize_props */
 
 /**
@@ -1184,18 +1180,13 @@ re_set_result_array_properties (ecma_object_t *array_obj_p, /**< result array */
   /* Set index property of the result array */
   ecma_string_t *result_prop_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_INDEX);
   {
-    ecma_number_t *num_p = ecma_alloc_number ();
-    *num_p = (ecma_number_t) index;
-
     ecma_builtin_helper_def_prop (array_obj_p,
                                   result_prop_str_p,
-                                  ecma_make_number_value (num_p),
+                                  ecma_make_int32_value (index),
                                   true, /* Writable */
                                   true, /* Enumerable */
                                   true, /* Configurable */
                                   true); /* Failure handling */
-
-    ecma_dealloc_number (num_p);
   }
   ecma_deref_ecma_string (result_prop_str_p);
 
@@ -1215,20 +1206,15 @@ re_set_result_array_properties (ecma_object_t *array_obj_p, /**< result array */
   /* Set length property of the result array */
   result_prop_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH);
   {
-
     ecma_property_descriptor_t array_item_prop_desc = ecma_make_empty_property_descriptor ();
     array_item_prop_desc.is_value_defined = true;
 
-    ecma_number_t *num_p = ecma_alloc_number ();
+    array_item_prop_desc.value = ecma_make_uint32_value (num_of_elements);
-    *num_p = (ecma_number_t) (num_of_elements);
-    array_item_prop_desc.value = ecma_make_number_value (num_p);
 
     ecma_op_object_define_own_property (array_obj_p,
                                         result_prop_str_p,
                                         &array_item_prop_desc,
                                         true);
-
-    ecma_dealloc_number (num_p);
   }
   ecma_deref_ecma_string (result_prop_str_p);
 } /* re_set_result_array_properties */
@@ -1366,10 +1352,7 @@ ecma_regexp_exec_helper (ecma_value_t regexp_value, /**< RegExp object */
       if (re_ctx.flags & RE_FLAG_GLOBAL)
       {
         ecma_string_t *magic_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_LASTINDEX_UL);
-        ecma_number_t *lastindex_num_p = ecma_alloc_number ();
+        ecma_op_object_put (regexp_object_p, magic_str_p, ecma_make_integer_value (0), true);
-        *lastindex_num_p = ECMA_NUMBER_ZERO;
-        ecma_op_object_put (regexp_object_p, magic_str_p, ecma_make_number_value (lastindex_num_p), true);
-        ecma_dealloc_number (lastindex_num_p);
         ecma_deref_ecma_string (magic_str_p);
       }
 
@@ -1403,21 +1386,20 @@ ecma_regexp_exec_helper (ecma_value_t regexp_value, /**< RegExp object */
   if (input_curr_p && (re_ctx.flags & RE_FLAG_GLOBAL))
   {
     ecma_string_t *magic_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_LASTINDEX_UL);
-    ecma_number_t *lastindex_num_p = ecma_alloc_number ();
+    ecma_number_t lastindex_num;
 
     if (sub_str_p != NULL
         && input_buffer_p != NULL)
     {
-      *lastindex_num_p = lit_utf8_string_length (input_buffer_p,
+      lastindex_num = lit_utf8_string_length (input_buffer_p,
-                                                 (lit_utf8_size_t) (sub_str_p - input_buffer_p));
+                                              (lit_utf8_size_t) (sub_str_p - input_buffer_p));
     }
     else
     {
-      *lastindex_num_p = ECMA_NUMBER_ZERO;
+      lastindex_num = ECMA_NUMBER_ZERO;
     }
 
-    ecma_op_object_put (regexp_object_p, magic_str_p, ecma_make_number_value (lastindex_num_p), true);
+    ecma_op_object_put (regexp_object_p, magic_str_p, ecma_make_number_value (lastindex_num), true);
-    ecma_dealloc_number (lastindex_num_p);
     ecma_deref_ecma_string (magic_str_p);
   }
 

jerry-core/ecma/operations/ecma-string-object.c

@@ -102,9 +102,8 @@ ecma_op_create_string_object (const ecma_value_t *arguments_list_p, /**< list of
   ecma_property_t *length_prop_p = ecma_create_named_data_property (obj_p,
                                                                     length_magic_string_p,
                                                                     false, false, false);
-  ecma_number_t *length_prop_value_p = ecma_alloc_number ();
+
-  *length_prop_value_p = length_value;
+  ecma_set_named_data_property_value (length_prop_p, ecma_make_number_value (length_value));
-  ecma_set_named_data_property_value (length_prop_p, ecma_make_number_value (length_prop_value_p));
   ecma_deref_ecma_string (length_magic_string_p);
 
   return ecma_make_object_value (obj_p);

jerry-core/ecma/operations/ecma-try-catch-macro.h

@@ -68,7 +68,7 @@
   ecma_number_t num_var = ecma_number_make_nan (); \
   if (ecma_is_value_number (value)) \
   { \
-    num_var = *ecma_get_number_from_value (value); \
+    num_var = ecma_get_number_from_value (value); \
   } \
   else \
   { \
@@ -76,7 +76,7 @@
                     ecma_op_to_number (value), \
                     return_value); \
     \
-    num_var = *ecma_get_number_from_value (to_number_value); \
+    num_var = ecma_get_number_from_value (to_number_value); \
     \
     ECMA_FINALIZE (to_number_value); \
   } \

jerry-core/jerry.c

@@ -397,14 +397,14 @@ jerry_api_convert_ecma_value_to_api_value (jerry_api_value_t *out_value_p, /**<
   }
   else if (ecma_is_value_number (value))
   {
-    ecma_number_t *num = ecma_get_number_from_value (value);
+    ecma_number_t num = ecma_get_number_from_value (value);
 
 #if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32
     out_value_p->type = JERRY_API_DATA_TYPE_FLOAT32;
-    out_value_p->u.v_float32 = *num;
+    out_value_p->u.v_float32 = num;
 #elif CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT64
     out_value_p->type = JERRY_API_DATA_TYPE_FLOAT64;
-    out_value_p->u.v_float64 = *num;
+    out_value_p->u.v_float64 = num;
 #endif /* CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 */
   }
   else if (ecma_is_value_string (value))
@@ -461,28 +461,19 @@ jerry_api_convert_api_value_to_ecma_value (ecma_value_t *out_value_p, /**< [out]
     }
     case JERRY_API_DATA_TYPE_FLOAT32:
     {
-      ecma_number_t *num = ecma_alloc_number ();
+      *out_value_p = ecma_make_number_value ((ecma_number_t) (api_value_p->u.v_float32));
-      *num = (ecma_number_t) (api_value_p->u.v_float32);
-
-      *out_value_p = ecma_make_number_value (num);
 
       break;
     }
     case JERRY_API_DATA_TYPE_FLOAT64:
     {
-      ecma_number_t *num = ecma_alloc_number ();
+      *out_value_p = ecma_make_number_value ((ecma_number_t) (api_value_p->u.v_float64));
-      *num = (ecma_number_t) (api_value_p->u.v_float64);
-
-      *out_value_p = ecma_make_number_value (num);
 
       break;
     }
     case JERRY_API_DATA_TYPE_UINT32:
     {
-      ecma_number_t *num = ecma_alloc_number ();
+      *out_value_p = ecma_make_uint32_value ((uint32_t) (api_value_p->u.v_uint32));
-      *num = (ecma_number_t) (api_value_p->u.v_uint32);
-
-      *out_value_p = ecma_make_number_value (num);
 
       break;
     }
@@ -734,9 +725,7 @@ jerry_api_create_array_object (jerry_api_size_t size) /* size of array */
 {
   JERRY_ASSERT (size > 0);
 
-  ecma_number_t *length_num_p = ecma_alloc_number ();
+  ecma_value_t array_length = ecma_make_uint32_value (size);
-  *length_num_p = ((ecma_number_t) size);
-  ecma_value_t array_length = ecma_make_number_value (length_num_p);
 
   jerry_api_length_t argument_size = 1;
   ecma_value_t new_array_completion = ecma_op_create_array_object (&array_length, argument_size, true);

jerry-core/vm/opcodes-ecma-arithmetics.c

@@ -50,38 +50,38 @@ do_number_arithmetic (number_arithmetic_op op, /**< number arithmetic operation
   ECMA_OP_TO_NUMBER_TRY_CATCH (num_left, left_value, ret_value);
   ECMA_OP_TO_NUMBER_TRY_CATCH (num_right, right_value, ret_value);
 
-  ecma_number_t *res_p = ecma_alloc_number ();
+  ecma_number_t result = ECMA_NUMBER_ZERO;
 
   switch (op)
   {
     case NUMBER_ARITHMETIC_ADDITION:
     {
-      *res_p = ecma_number_add (num_left, num_right);
+      result = ecma_number_add (num_left, num_right);
       break;
     }
     case NUMBER_ARITHMETIC_SUBSTRACTION:
     {
-      *res_p = ecma_number_substract (num_left, num_right);
+      result = ecma_number_substract (num_left, num_right);
       break;
     }
     case NUMBER_ARITHMETIC_MULTIPLICATION:
     {
-      *res_p = ecma_number_multiply (num_left, num_right);
+      result = ecma_number_multiply (num_left, num_right);
       break;
     }
     case NUMBER_ARITHMETIC_DIVISION:
     {
-      *res_p = ecma_number_divide (num_left, num_right);
+      result = ecma_number_divide (num_left, num_right);
       break;
     }
     case NUMBER_ARITHMETIC_REMAINDER:
     {
-      *res_p = ecma_op_number_remainder (num_left, num_right);
+      result = ecma_op_number_remainder (num_left, num_right);
       break;
     }
   }
 
-  ret_value = ecma_make_number_value (res_p);
+  ret_value = ecma_make_number_value (result);
 
   ECMA_OP_TO_NUMBER_FINALIZE (num_right);
   ECMA_OP_TO_NUMBER_FINALIZE (num_left);
@@ -158,10 +158,7 @@ opfunc_unary_plus (ecma_value_t left_value) /**< left value */
                                left_value,
                                ret_value);
 
-  ecma_number_t *tmp_p = ecma_alloc_number ();
+  ret_value = ecma_make_number_value (num_var_value);
-
-  *tmp_p = num_var_value;
-  ret_value = ecma_make_number_value (tmp_p);
 
   ECMA_OP_TO_NUMBER_FINALIZE (num_var_value);
 
@@ -185,10 +182,7 @@ opfunc_unary_minus (ecma_value_t left_value) /**< left value */
                                left_value,
                                ret_value);
 
-  ecma_number_t *tmp_p = ecma_alloc_number ();
+  ret_value = ecma_make_number_value (ecma_number_negate (num_var_value));
-
-  *tmp_p = ecma_number_negate (num_var_value);
-  ret_value = ecma_make_number_value (tmp_p);
 
   ECMA_OP_TO_NUMBER_FINALIZE (num_var_value);
 

jerry-core/vm/opcodes-ecma-bitwise.c

@@ -48,7 +48,7 @@ do_number_bitwise_logic (number_bitwise_logic_op op, /**< number bitwise logic o
   ECMA_OP_TO_NUMBER_TRY_CATCH (num_left, left_value, ret_value);
   ECMA_OP_TO_NUMBER_TRY_CATCH (num_right, right_value, ret_value);
 
-  ecma_number_t *res_p = ecma_alloc_number ();
+  ecma_number_t result = ECMA_NUMBER_ZERO;
   uint32_t right_uint32 = ecma_number_to_uint32 (num_right);
 
   switch (op)
@@ -56,45 +56,45 @@ do_number_bitwise_logic (number_bitwise_logic_op op, /**< number bitwise logic o
     case NUMBER_BITWISE_LOGIC_AND:
     {
       uint32_t left_uint32 = ecma_number_to_uint32 (num_left);
-      *res_p = (ecma_number_t) ((int32_t) (left_uint32 & right_uint32));
+      result = (ecma_number_t) ((int32_t) (left_uint32 & right_uint32));
       break;
     }
     case NUMBER_BITWISE_LOGIC_OR:
     {
       uint32_t left_uint32 = ecma_number_to_uint32 (num_left);
-      *res_p = (ecma_number_t) ((int32_t) (left_uint32 | right_uint32));
+      result = (ecma_number_t) ((int32_t) (left_uint32 | right_uint32));
       break;
     }
     case NUMBER_BITWISE_LOGIC_XOR:
     {
       uint32_t left_uint32 = ecma_number_to_uint32 (num_left);
-      *res_p = (ecma_number_t) ((int32_t) (left_uint32 ^ right_uint32));
+      result = (ecma_number_t) ((int32_t) (left_uint32 ^ right_uint32));
       break;
     }
     case NUMBER_BITWISE_SHIFT_LEFT:
     {
-      *res_p = (ecma_number_t) (ecma_number_to_int32 (num_left) << (right_uint32 & 0x1F));
+      result = (ecma_number_t) (ecma_number_to_int32 (num_left) << (right_uint32 & 0x1F));
       break;
     }
     case NUMBER_BITWISE_SHIFT_RIGHT:
     {
-      *res_p = (ecma_number_t) (ecma_number_to_int32 (num_left) >> (right_uint32 & 0x1F));
+      result = (ecma_number_t) (ecma_number_to_int32 (num_left) >> (right_uint32 & 0x1F));
       break;
     }
     case NUMBER_BITWISE_SHIFT_URIGHT:
     {
       uint32_t left_uint32 = ecma_number_to_uint32 (num_left);
-      *res_p = (ecma_number_t) (left_uint32 >> (right_uint32 & 0x1F));
+      result = (ecma_number_t) (left_uint32 >> (right_uint32 & 0x1F));
       break;
     }
     case NUMBER_BITWISE_NOT:
     {
-      *res_p = (ecma_number_t) ((int32_t) ~right_uint32);
+      result = (ecma_number_t) ((int32_t) ~right_uint32);
       break;
     }
   }
 
-  ret_value = ecma_make_number_value (res_p);
+  ret_value = ecma_make_number_value (result);
 
   ECMA_OP_TO_NUMBER_FINALIZE (num_right);
   ECMA_OP_TO_NUMBER_FINALIZE (num_left);

jerry-core/vm/vm.c

@@ -517,9 +517,8 @@ enum
       lit_literal_t lit = lit_cpointer_decompress (lit_cpointer); \
       if (unlikely (LIT_RECORD_IS_NUMBER (lit))) \
       { \
-        ecma_number_t *number_p = ecma_alloc_number (); \
+        ecma_number_t number = lit_number_literal_get_number (lit); \
-        *number_p = lit_number_literal_get_number (lit); \
+        (target_value) = ecma_make_number_value (number); \
-        (target_value) = ecma_make_number_value (number_p); \
       } \
       else \
       { \
@@ -957,26 +956,25 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
         }
         case VM_OC_PUSH_NUMBER:
         {
-          ecma_number_t *number_p = ecma_alloc_number ();
+          int32_t number;
 
           if (opcode == CBC_PUSH_NUMBER_0)
           {
-            *number_p = 0;
+            number = 0;
           }
           else
           {
-            int value = *byte_code_p++;
+            number = *byte_code_p++;
 
             JERRY_ASSERT (opcode == CBC_PUSH_NUMBER_1);
 
-            if (value >= CBC_PUSH_NUMBER_1_RANGE_END)
+            if (number >= CBC_PUSH_NUMBER_1_RANGE_END)
             {
-              value = -(value - CBC_PUSH_NUMBER_1_RANGE_END);
+              number = -(number - CBC_PUSH_NUMBER_1_RANGE_END);
             }
-            *number_p = (ecma_number_t) value;
           }
 
-          result = ecma_make_number_value (number_p);
+          result = ecma_make_int32_value (number);
           break;
         }
         case VM_OC_PUSH_OBJECT:
@@ -1066,7 +1064,7 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
           ecma_object_t *array_obj_p;
           ecma_string_t *length_str_p;
           ecma_property_t *length_prop_p;
-          ecma_number_t *length_num_p;
+          uint32_t length_num;
           ecma_property_descriptor_t prop_desc;
 
           prop_desc = ecma_make_empty_property_descriptor ();
@@ -1090,7 +1088,7 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
           JERRY_ASSERT (length_prop_p != NULL);
 
           left_value = ecma_get_named_data_property_value (length_prop_p);
-          length_num_p = ecma_get_number_from_value (left_value);
+          length_num = ecma_get_uint32_from_value (left_value);
 
           ecma_deref_ecma_string (length_str_p);
 
@@ -1098,7 +1096,7 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
           {
             if (!ecma_is_value_array_hole (stack_top_p[i]))
             {
-              ecma_string_t *index_str_p = ecma_new_ecma_string_from_uint32 ((uint32_t) *length_num_p);
+              ecma_string_t *index_str_p = ecma_new_ecma_string_from_uint32 (length_num);
 
               prop_desc.value = stack_top_p[i];
 
@@ -1112,9 +1110,11 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
               ecma_free_value (stack_top_p[i]);
             }
 
-            (*length_num_p)++;
+            length_num++;
           }
 
+          ecma_value_assign_uint32 (&ECMA_PROPERTY_VALUE_PTR (length_prop_p)->value,
+                                    length_num);
           break;
         }
         case VM_OC_PUSH_UNDEFINED_BASE:
@@ -1228,8 +1228,6 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
         case VM_OC_POST_DECR:
         {
           uint32_t base = VM_OC_GROUP_GET_INDEX (opcode_data) - VM_OC_PROP_PRE_INCR;
-          ecma_number_t increase = ECMA_NUMBER_ONE;
-          ecma_number_t *result_p;
 
           last_completion_value = ecma_op_to_number (left_value);
 
@@ -1240,7 +1238,80 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
 
           byte_code_p = byte_code_start_p + 1;
           result = last_completion_value;
-          result_p = ecma_get_number_from_value (result);
+
+          if (ecma_is_value_integer_number (result))
+          {
+            ecma_integer_value_t int_value = (ecma_integer_value_t) result;
+            ecma_integer_value_t int_increase;
+
+            if (base & 0x2)
+            {
+              /* For decrement operators */
+              if (int_value <= (ECMA_INTEGER_NUMBER_MIN << ECMA_DIRECT_SHIFT))
+              {
+                int_increase = 0;
+              }
+              else
+              {
+                int_increase = -(1 << ECMA_DIRECT_SHIFT);
+              }
+            }
+            else
+            {
+              if (int_value >= (ECMA_INTEGER_NUMBER_MAX << ECMA_DIRECT_SHIFT))
+              {
+                int_increase = 0;
+              }
+              else
+              {
+                int_increase = 1 << ECMA_DIRECT_SHIFT;
+              }
+            }
+
+            if (int_increase != 0)
+            {
+              /* Post operators require the unmodifed number value. */
+              if (base & 0x4)
+              {
+                if (opcode_data & VM_OC_PUT_STACK)
+                {
+                  if (base & 0x1)
+                  {
+                    JERRY_ASSERT (opcode == CBC_POST_INCR_IDENT_PUSH_RESULT
+                                  || opcode == CBC_POST_DECR_IDENT_PUSH_RESULT);
+
+                    *stack_top_p++ = result;
+                  }
+                  else
+                  {
+                    /* The parser ensures there is enough space for the
+                     * extra value on the stack. See js-parser-expr.c. */
+
+                    JERRY_ASSERT (opcode == CBC_POST_INCR_PUSH_RESULT
+                                  || opcode == CBC_POST_DECR_PUSH_RESULT);
+
+                    stack_top_p++;
+                    stack_top_p[-1] = stack_top_p[-2];
+                    stack_top_p[-2] = stack_top_p[-3];
+                    stack_top_p[-3] = result;
+                  }
+                  opcode_data &= (uint32_t)~VM_OC_PUT_STACK;
+                }
+                else if (opcode_data & VM_OC_PUT_BLOCK)
+                {
+                  ecma_free_value (block_result);
+                  block_result = result;
+                  opcode_data &= (uint32_t) ~VM_OC_PUT_BLOCK;
+                }
+              }
+
+              result = (ecma_value_t) (int_value + int_increase);
+              break;
+            }
+          }
+
+          ecma_number_t increase = ECMA_NUMBER_ONE;
+          ecma_number_t result_number = ecma_get_number_from_value (result);
 
           if (base & 0x2)
           {
@@ -1283,7 +1354,7 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
             }
           }
 
-          *result_p = ecma_number_add (*result_p, increase);
+          ecma_value_assign_number (&result, result_number + increase);
           break;
         }
         case VM_OC_ASSIGN: