Representing ecma_value_t as integer instead of structure with bit-fields, adding corresponding field accessors.

src/libcoreint/opcodes-ecma-relational.c

@@ -54,7 +54,7 @@ opfunc_less_than (opcode_t opdata, /**< operation data */
   {
     JERRY_ASSERT (ecma_is_value_boolean (ecma_get_completion_value_value (compare_result)));
 
-    res = ecma_get_completion_value_value (compare_result).value;
+    res = (ecma_is_completion_value_normal_true (compare_result) ? ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
   }
 
   ret_value = set_variable_value (int_data, dst_var_idx, ecma_make_simple_value (res));
@@ -104,7 +104,7 @@ opfunc_greater_than (opcode_t opdata, /**< operation data */
   {
     JERRY_ASSERT (ecma_is_value_boolean (ecma_get_completion_value_value (compare_result)));
 
-    res = ecma_get_completion_value_value (compare_result).value;
+    res = (ecma_is_completion_value_normal_true (compare_result) ? ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
   }
 
   ret_value = set_variable_value (int_data, dst_var_idx, ecma_make_simple_value (res));
@@ -154,7 +154,7 @@ opfunc_less_or_equal_than (opcode_t opdata, /**< operation data */
   {
     JERRY_ASSERT (ecma_is_value_boolean (ecma_get_completion_value_value (compare_result)));
 
-    if (ecma_get_completion_value_value (compare_result).value == ECMA_SIMPLE_VALUE_TRUE)
+    if (ecma_is_completion_value_normal_true (compare_result))
     {
       res = ECMA_SIMPLE_VALUE_FALSE;
     }
@@ -211,7 +211,7 @@ opfunc_greater_or_equal_than (opcode_t opdata, /**< operation data */
   {
     JERRY_ASSERT (ecma_is_value_boolean (ecma_get_completion_value_value (compare_result)));
 
-    if (ecma_get_completion_value_value (compare_result).value == ECMA_SIMPLE_VALUE_TRUE)
+    if (ecma_is_completion_value_normal_true (compare_result))
     {
       res = ECMA_SIMPLE_VALUE_FALSE;
     }

src/libcoreint/opcodes-native-call.c

@@ -62,8 +62,7 @@ opfunc_native_call (opcode_t opdata, /**< operation data */
       case OPCODE_NATIVE_CALL_LED_TOGGLE:
       {
         JERRY_ASSERT (args_number == 1);
-        JERRY_ASSERT (ecma_is_value_number (arg_values[0]));
+        ecma_number_t* num_p = ecma_get_number_from_value (arg_values[0]);
-        ecma_number_t* num_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg_values[0].value);
         uint32_t int_num = ecma_number_to_uint32 (*num_p);
         led_toggle (int_num);
 
@@ -73,8 +72,7 @@ opfunc_native_call (opcode_t opdata, /**< operation data */
       case OPCODE_NATIVE_CALL_LED_ON:
       {
         JERRY_ASSERT (args_number == 1);
-        JERRY_ASSERT (ecma_is_value_number (arg_values[0]));
+        ecma_number_t* num_p = ecma_get_number_from_value (arg_values[0]);
-        ecma_number_t* num_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg_values[0].value);
         uint32_t int_num = ecma_number_to_uint32 (*num_p);
         led_on (int_num);
 
@@ -84,8 +82,7 @@ opfunc_native_call (opcode_t opdata, /**< operation data */
       case OPCODE_NATIVE_CALL_LED_OFF:
       {
         JERRY_ASSERT (args_number == 1);
-        JERRY_ASSERT (ecma_is_value_number (arg_values[0]));
+        ecma_number_t* num_p = ecma_get_number_from_value (arg_values[0]);
-        ecma_number_t* num_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg_values[0].value);
         uint32_t int_num = ecma_number_to_uint32 (*num_p);
         led_off (int_num);
 
@@ -95,8 +92,7 @@ opfunc_native_call (opcode_t opdata, /**< operation data */
       case OPCODE_NATIVE_CALL_LED_ONCE:
       {
         JERRY_ASSERT (args_number == 1);
-        JERRY_ASSERT (ecma_is_value_number (arg_values[0]));
+        ecma_number_t* num_p = ecma_get_number_from_value (arg_values[0]);
-        ecma_number_t* num_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg_values[0].value);
         uint32_t int_num = ecma_number_to_uint32 (*num_p);
         led_blink_once (int_num);
 
@@ -106,8 +102,7 @@ opfunc_native_call (opcode_t opdata, /**< operation data */
       case OPCODE_NATIVE_CALL_WAIT:
       {
         JERRY_ASSERT (args_number == 1);
-        JERRY_ASSERT (ecma_is_value_number (arg_values[0]));
+        ecma_number_t* num_p = ecma_get_number_from_value (arg_values[0]);
-        ecma_number_t* num_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg_values[0].value);
         uint32_t int_num = ecma_number_to_uint32 (*num_p);
         wait_ms (int_num);
 

src/libcoreint/opcodes.c

@@ -1459,8 +1459,7 @@ opfunc_delete_var (opcode_t opdata, /**< operation data */
     }
     else
     {
-      JERRY_ASSERT (ecma_is_value_object (ref.base));
+      ecma_object_t *bindings_p = ecma_get_object_from_value (ref.base);
-      ecma_object_t *bindings_p = ECMA_GET_NON_NULL_POINTER (ref.base.value);
       JERRY_ASSERT (ecma_is_lexical_environment (bindings_p));
 
       ECMA_TRY_CATCH (delete_completion,

src/libecmabuiltins/ecma-builtin-array.c

@@ -61,7 +61,7 @@ ecma_builtin_array_object_is_array (ecma_value_t this_arg __unused, /**< 'this'
 
   if (ecma_is_value_object (arg))
   {
-    ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER (arg.value);
+    ecma_object_t *obj_p = ecma_get_object_from_value (arg);
 
     ecma_property_t *class_prop_p = ecma_get_internal_property (obj_p,
                                                                 ECMA_INTERNAL_PROPERTY_CLASS);

src/libecmabuiltins/ecma-builtin-boolean-prototype.c

@@ -100,7 +100,7 @@ ecma_builtin_boolean_prototype_object_value_of (ecma_value_t this) /**< this arg
   }
   else if (ecma_is_value_object (this))
   {
-    ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER (this.value);
+    ecma_object_t *obj_p = ecma_get_object_from_value (this);
 
     ecma_property_t *class_prop_p = ecma_get_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_CLASS);
 

src/libecmabuiltins/ecma-builtin-error-prototype.c

@@ -65,7 +65,7 @@ ecma_builtin_error_prototype_object_to_string (ecma_value_t this) /**< this argu
   }
   else
   {
-    ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER (this.value);
+    ecma_object_t *obj_p = ecma_get_object_from_value (this);
     ecma_string_t *name_magic_string_p = ecma_get_magic_string (ECMA_MAGIC_STRING_NAME);
 
     ECMA_TRY_CATCH (name_get_completion,

src/libecmabuiltins/ecma-builtin-number-prototype.c

@@ -62,13 +62,13 @@ ecma_builtin_number_prototype_object_to_string (ecma_value_t this, /**< this arg
 
   if (ecma_is_value_number (this))
   {
-    ecma_number_t *this_arg_number_p = ECMA_GET_NON_NULL_POINTER (this.value);
+    ecma_number_t *this_arg_number_p = ecma_get_number_from_value (this);
 
     this_arg_number = *this_arg_number_p;
   }
   else if (ecma_is_value_object (this))
   {
-    ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER (this.value);
+    ecma_object_t *obj_p = ecma_get_object_from_value (this);
 
     ecma_property_t *class_prop_p = ecma_get_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_CLASS);
 
@@ -134,7 +134,7 @@ ecma_builtin_number_prototype_object_value_of (ecma_value_t this) /**< this argu
   }
   else if (ecma_is_value_object (this))
   {
-    ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER (this.value);
+    ecma_object_t *obj_p = ecma_get_object_from_value (this);
 
     ecma_property_t *class_prop_p = ecma_get_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_CLASS);
 

src/libecmabuiltins/ecma-builtin-object.c

@@ -319,7 +319,7 @@ ecma_builtin_object_object_define_property (ecma_value_t this_arg __unused, /**<
   }
   else
   {
-    ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER (arg1.value);
+    ecma_object_t *obj_p = ecma_get_object_from_value (arg1);
 
     ECMA_TRY_CATCH (name_str_value,
                     ecma_op_to_string (arg2),

src/libecmabuiltins/ecma-builtin-string-prototype.c

@@ -62,7 +62,7 @@ ecma_builtin_string_prototype_object_to_string (ecma_value_t this) /**< this arg
   }
   else if (ecma_is_value_object (this))
   {
-    ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER (this.value);
+    ecma_object_t *obj_p = ecma_get_object_from_value (this);
 
     ecma_property_t *class_prop_p = ecma_get_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_CLASS);
 

src/libecmaobjects/ecma-gc.c

@@ -243,7 +243,7 @@ ecma_gc_update_may_ref_younger_object_flag_by_value (ecma_object_t *obj_p, /**<
     return;
   }
 
-  ecma_object_t *ref_obj_p = ECMA_GET_NON_NULL_POINTER(value.value);
+  ecma_object_t *ref_obj_p = ecma_get_object_from_value (value);
   JERRY_ASSERT(ref_obj_p != NULL);
 
   ecma_gc_update_may_ref_younger_object_flag_by_object (obj_p, ref_obj_p);
@@ -352,7 +352,7 @@ ecma_gc_mark (ecma_object_t *object_p, /**< start object */
 
           if (ecma_is_value_object (value))
           {
-            ecma_object_t *value_obj_p = ECMA_GET_NON_NULL_POINTER(value.value);
+            ecma_object_t *value_obj_p = ecma_get_object_from_value (value);
 
             if (ecma_gc_get_object_generation (value_obj_p) <= maximum_gen_to_traverse)
             {

src/libecmaobjects/ecma-globals.h

@@ -114,17 +114,28 @@ typedef enum
 
 /**
  * Description of an ecma-value
+ *
+ * Bit-field structure: type (2) | value (ECMA_POINTER_FIELD_WIDTH)
  */
-typedef struct
+typedef uint16_t ecma_value_t;
-{
-  /** Value type (ecma_type_t) */
-  unsigned int value_type : 2;
 
-  /**
+/**
-   * Simple value (ecma_simple_value_t) or compressed pointer to value (depending on value_type)
+ * Value type (ecma_type_t)
-   */
+ */
-  unsigned int value : ECMA_POINTER_FIELD_WIDTH;
+#define ECMA_VALUE_TYPE_POS (0)
-} __packed ecma_value_t;
+#define ECMA_VALUE_TYPE_WIDTH (2)
+
+/**
+ * Simple value (ecma_simple_value_t) or compressed pointer to value (depending on value_type)
+ */
+#define ECMA_VALUE_VALUE_POS (ECMA_VALUE_TYPE_POS + \
+                              ECMA_VALUE_TYPE_WIDTH)
+#define ECMA_VALUE_VALUE_WIDTH (ECMA_POINTER_FIELD_WIDTH)
+
+/**
+ * ecma_value_t size
+ */
+#define ECMA_VALUE_SIZE (ECMA_VALUE_VALUE_POS + ECMA_VALUE_VALUE_WIDTH)
 
 /**
  * Description of a block completion value

src/libecmaobjects/ecma-helpers-value.c

@@ -25,6 +25,65 @@
 #include "ecma-globals.h"
 #include "ecma-helpers.h"
 #include "globals.h"
+#include "jrt-bit-fields.h"
+
+JERRY_STATIC_ASSERT (sizeof (ecma_value_t) * JERRY_BITSINBYTE == ECMA_VALUE_SIZE);
+
+/**
+ * Get type field of ecma-value
+ *
+ * @return type field
+ */
+static ecma_type_t
+ecma_get_value_type_field (ecma_value_t value) /**< ecma-value */
+{
+  return jrt_extract_bit_field (value,
+                                ECMA_VALUE_TYPE_POS,
+                                ECMA_VALUE_TYPE_WIDTH);
+} /* ecma_get_value_type_field */
+
+/**
+ * Get value field of ecma-value
+ *
+ * @return value field
+ */
+static uintptr_t
+ecma_get_value_value_field (ecma_value_t value) /**< ecma-value */
+{
+  return (uintptr_t) jrt_extract_bit_field (value,
+                                            ECMA_VALUE_VALUE_POS,
+                                            ECMA_VALUE_VALUE_WIDTH);
+} /* ecma_get_value_value_field */
+
+/**
+ * Set type field of ecma-value
+ *
+ * @return ecma-value with updated field
+ */
+static ecma_value_t
+ecma_set_value_type_field (ecma_value_t value, /**< ecma-value to set field in */
+                           ecma_type_t type_field) /**< new field value */
+{
+  return (ecma_value_t) jrt_set_bit_field_value (value,
+                                                 type_field,
+                                                 ECMA_VALUE_TYPE_POS,
+                                                 ECMA_VALUE_TYPE_WIDTH);
+} /* ecma_set_value_type_field */
+
+/**
+ * Set value field of ecma-value
+ *
+ * @return ecma-value with updated field
+ */
+static ecma_value_t
+ecma_set_value_value_field (ecma_value_t value, /**< ecma-value to set field in */
+                            uintptr_t value_field) /**< new field value */
+{
+  return (ecma_value_t) jrt_set_bit_field_value (value,
+                                                 value_field,
+                                                 ECMA_VALUE_VALUE_POS,
+                                                 ECMA_VALUE_VALUE_WIDTH);
+} /* ecma_set_value_value_field */
 
 /**
  * Check if the value is empty.
@@ -35,22 +94,8 @@
 bool
 ecma_is_value_empty (ecma_value_t value) /**< ecma-value */
 {
-  JERRY_STATIC_ASSERT (ECMA_TYPE_SIMPLE == 0 && ECMA_SIMPLE_VALUE_EMPTY == 0);
+  return (ecma_get_value_type_field (value) == ECMA_TYPE_SIMPLE
-  const uint16_t simple_empty = 0; // (ECMA_TYPE_SIMPLE | (ECMA_SIMPLE_VALUE_EMPTY << 2u));
+          && ecma_get_value_value_field (value) == ECMA_SIMPLE_VALUE_EMPTY);
-
-  union
-  {
-    ecma_value_t value;
-    uint16_t uint16;
-  } u;
-
-  u.value = value;
-
-  bool is_empty = (u.uint16 == simple_empty);
-
-  JERRY_ASSERT (is_empty == (value.value_type == ECMA_TYPE_SIMPLE && value.value == ECMA_SIMPLE_VALUE_EMPTY));
-
-  return is_empty;
 } /* ecma_is_value_empty */
 
 /**
@@ -62,20 +107,8 @@ ecma_is_value_empty (ecma_value_t value) /**< ecma-value */
 bool
 ecma_is_value_undefined (ecma_value_t value) /**< ecma-value */
 {
-  const uint16_t simple_undefined = (ECMA_TYPE_SIMPLE | (ECMA_SIMPLE_VALUE_UNDEFINED << 2u));
+  return (ecma_get_value_type_field (value) == ECMA_TYPE_SIMPLE
-  union
+          && ecma_get_value_value_field (value) == ECMA_SIMPLE_VALUE_UNDEFINED);
-  {
-    ecma_value_t value;
-    uint16_t uint16;
-  } u;
-
-  u.value = value;
-
-  bool is_undefined = (u.uint16 == simple_undefined);
-
-  JERRY_ASSERT (is_undefined == (value.value_type == ECMA_TYPE_SIMPLE && value.value == ECMA_SIMPLE_VALUE_UNDEFINED));
-
-  return is_undefined;
 } /* ecma_is_value_undefined */
 
 /**
@@ -87,20 +120,8 @@ ecma_is_value_undefined (ecma_value_t value) /**< ecma-value */
 bool
 ecma_is_value_null (ecma_value_t value) /**< ecma-value */
 {
-  const uint16_t simple_null = (ECMA_TYPE_SIMPLE | (ECMA_SIMPLE_VALUE_NULL << 2u));
+  return (ecma_get_value_type_field (value) == ECMA_TYPE_SIMPLE
-  union
+          && ecma_get_value_value_field (value) == ECMA_SIMPLE_VALUE_NULL);
-  {
-    ecma_value_t value;
-    uint16_t uint16;
-  } u;
-
-  u.value = value;
-
-  bool is_null = (u.uint16 == simple_null);
-
-  JERRY_ASSERT (is_null == (value.value_type == ECMA_TYPE_SIMPLE && value.value == ECMA_SIMPLE_VALUE_NULL));
-
-  return is_null;
 } /* ecma_is_value_null */
 
 /**
@@ -112,22 +133,9 @@ ecma_is_value_null (ecma_value_t value) /**< ecma-value */
 bool
 ecma_is_value_boolean (ecma_value_t value) /**< ecma-value */
 {
-  const uint16_t simple_false = (ECMA_TYPE_SIMPLE | (ECMA_SIMPLE_VALUE_FALSE << 2u));
+  return (ecma_get_value_type_field (value) == ECMA_TYPE_SIMPLE
-  const uint16_t simple_true = (ECMA_TYPE_SIMPLE | (ECMA_SIMPLE_VALUE_TRUE << 2u));
+          && (ecma_get_value_value_field (value) == ECMA_SIMPLE_VALUE_TRUE
-  union
+              || ecma_get_value_value_field (value) == ECMA_SIMPLE_VALUE_FALSE));
-  {
-    ecma_value_t value;
-    uint16_t uint16;
-  } u;
-
-  u.value = value;
-
-  bool is_boolean = (u.uint16 == simple_false || u.uint16 == simple_true);
-
-  JERRY_ASSERT (is_boolean == ((value.value_type == ECMA_TYPE_SIMPLE && value.value == ECMA_SIMPLE_VALUE_FALSE)
-                               || (value.value_type == ECMA_TYPE_SIMPLE && value.value == ECMA_SIMPLE_VALUE_TRUE)));
-
-  return is_boolean;
 } /* ecma_is_value_boolean */
 
 /**
@@ -142,22 +150,8 @@ ecma_is_value_boolean (ecma_value_t value) /**< ecma-value */
 bool
 ecma_is_value_true (ecma_value_t value) /**< ecma-value */
 {
-  JERRY_ASSERT(ecma_is_value_boolean (value));
+  return (ecma_get_value_type_field (value) == ECMA_TYPE_SIMPLE
-
+          && ecma_get_value_value_field (value) == ECMA_SIMPLE_VALUE_TRUE);
-  const uint16_t simple_true = (ECMA_TYPE_SIMPLE | (ECMA_SIMPLE_VALUE_TRUE << 2u));
-  union
-  {
-    ecma_value_t value;
-    uint16_t uint16;
-  } u;
-
-  u.value = value;
-
-  bool is_true = (u.uint16 == simple_true);
-
-  JERRY_ASSERT (is_true == (value.value_type == ECMA_TYPE_SIMPLE && value.value == ECMA_SIMPLE_VALUE_TRUE));
-
-  return is_true;
 } /* ecma_is_value_true */
 
 /**
@@ -169,7 +163,7 @@ ecma_is_value_true (ecma_value_t value) /**< ecma-value */
 bool
 ecma_is_value_number (ecma_value_t value) /**< ecma-value */
 {
-  return (value.value_type == ECMA_TYPE_NUMBER);
+  return (ecma_get_value_type_field (value) == ECMA_TYPE_NUMBER);
 } /* ecma_is_value_number */
 
 /**
@@ -181,7 +175,7 @@ ecma_is_value_number (ecma_value_t value) /**< ecma-value */
 bool
 ecma_is_value_string (ecma_value_t value) /**< ecma-value */
 {
-  return (value.value_type == ECMA_TYPE_STRING);
+  return (ecma_get_value_type_field (value) == ECMA_TYPE_STRING);
 } /* ecma_is_value_string */
 
 /**
@@ -193,7 +187,7 @@ ecma_is_value_string (ecma_value_t value) /**< ecma-value */
 bool
 ecma_is_value_object (ecma_value_t value) /**< ecma-value */
 {
-  return (value.value_type == ECMA_TYPE_OBJECT);
+  return (ecma_get_value_type_field (value) == ECMA_TYPE_OBJECT);
 } /* ecma_is_value_object */
 
 /**
@@ -217,17 +211,12 @@ ecma_check_value_type_is_spec_defined (ecma_value_t value) /**< ecma-value */
 ecma_value_t
 ecma_make_simple_value (ecma_simple_value_t value) /**< simple value */
 {
-  union
+  ecma_value_t ret_value = 0;
-  {
-    ecma_value_t value;
-    uint16_t uint16;
-  } u;
 
-  u.uint16 = (uint16_t) (ECMA_TYPE_SIMPLE | (value << 2u));
+  ret_value = ecma_set_value_type_field (ret_value, ECMA_TYPE_SIMPLE);
+  ret_value = ecma_set_value_value_field (ret_value, value);
 
-  JERRY_ASSERT (u.value.value_type == ECMA_TYPE_SIMPLE && u.value.value == value);
+  return ret_value;
-
-  return u.value;
 } /* ecma_make_simple_value */
 
 /**
@@ -238,12 +227,15 @@ ecma_make_number_value (ecma_number_t* num_p) /**< number to reference in value
 {
   JERRY_ASSERT(num_p != NULL);
 
-  ecma_value_t number_value;
+  uint16_t num_cp;
+  ECMA_SET_NON_NULL_POINTER (num_cp, num_p);
 
-  number_value.value_type = ECMA_TYPE_NUMBER;
+  ecma_value_t ret_value = 0;
-  ECMA_SET_POINTER(number_value.value, num_p);
 
-  return number_value;
+  ret_value = ecma_set_value_type_field (ret_value, ECMA_TYPE_NUMBER);
+  ret_value = ecma_set_value_value_field (ret_value, num_cp);
+
+  return ret_value;
 } /* ecma_make_number_value */
 
 /**
@@ -254,12 +246,15 @@ ecma_make_string_value (ecma_string_t* ecma_string_p) /**< string to reference i
 {
   JERRY_ASSERT(ecma_string_p != NULL);
 
-  ecma_value_t string_value;
+  uint16_t string_cp;
+  ECMA_SET_NON_NULL_POINTER (string_cp, ecma_string_p);
 
-  string_value.value_type = ECMA_TYPE_STRING;
+  ecma_value_t ret_value = 0;
-  ECMA_SET_POINTER(string_value.value, ecma_string_p);
 
-  return string_value;
+  ret_value = ecma_set_value_type_field (ret_value, ECMA_TYPE_STRING);
+  ret_value = ecma_set_value_value_field (ret_value, string_cp);
+
+  return ret_value;
 } /* ecma_make_string_value */
 
 /**
@@ -270,12 +265,15 @@ ecma_make_object_value (ecma_object_t* object_p) /**< object to reference in val
 {
   JERRY_ASSERT(object_p != NULL);
 
-  ecma_value_t object_value;
+  uint16_t object_cp;
+  ECMA_SET_NON_NULL_POINTER (object_cp, object_p);
 
-  object_value.value_type = ECMA_TYPE_OBJECT;
+  ecma_value_t ret_value = 0;
-  ECMA_SET_POINTER(object_value.value, object_p);
 
-  return object_value;
+  ret_value = ecma_set_value_type_field (ret_value, ECMA_TYPE_OBJECT);
+  ret_value = ecma_set_value_value_field (ret_value, object_cp);
+
+  return ret_value;
 } /* ecma_make_object_value */
 
 /**
@@ -286,9 +284,9 @@ ecma_make_object_value (ecma_object_t* object_p) /**< object to reference in val
 ecma_number_t* __attribute_const__
 ecma_get_number_from_value (ecma_value_t value) /**< ecma-value */
 {
-  JERRY_ASSERT (value.value_type == ECMA_TYPE_NUMBER);
+  JERRY_ASSERT (ecma_get_value_type_field (value) == ECMA_TYPE_NUMBER);
 
-  return (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (value.value);
+  return (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (ecma_get_value_value_field (value));
 } /* ecma_get_number_from_value */
 
 /**
@@ -299,9 +297,9 @@ ecma_get_number_from_value (ecma_value_t value) /**< ecma-value */
 ecma_string_t* __attribute_const__
 ecma_get_string_from_value (ecma_value_t value) /**< ecma-value */
 {
-  JERRY_ASSERT (value.value_type == ECMA_TYPE_STRING);
+  JERRY_ASSERT (ecma_get_value_type_field (value) == ECMA_TYPE_STRING);
 
-  return (ecma_string_t*) ECMA_GET_NON_NULL_POINTER (value.value);
+  return (ecma_string_t*) ECMA_GET_NON_NULL_POINTER (ecma_get_value_value_field (value));
 } /* ecma_get_string_from_value */
 
 /**
@@ -312,9 +310,9 @@ ecma_get_string_from_value (ecma_value_t value) /**< ecma-value */
 ecma_object_t* __attribute_const__
 ecma_get_object_from_value (ecma_value_t value) /**< ecma-value */
 {
-  JERRY_ASSERT (value.value_type == ECMA_TYPE_OBJECT);
+  JERRY_ASSERT (ecma_get_value_type_field (value) == ECMA_TYPE_OBJECT);
 
-  return (ecma_object_t*) ECMA_GET_NON_NULL_POINTER (value.value);
+  return (ecma_object_t*) ECMA_GET_NON_NULL_POINTER (ecma_get_value_value_field (value));
 } /* ecma_get_object_from_value */
 
 /**
@@ -343,9 +341,9 @@ ecma_copy_value (const ecma_value_t value, /**< ecma-value */
                  bool do_ref_if_object) /**< if the value is object value,
                                              increment reference counter of the object */
 {
-  ecma_value_t value_copy;
+  ecma_value_t value_copy = 0;
 
-  switch ((ecma_type_t)value.value_type)
+  switch (ecma_get_value_type_field (value))
   {
     case ECMA_TYPE_SIMPLE:
     {
@@ -355,39 +353,28 @@ ecma_copy_value (const ecma_value_t value, /**< ecma-value */
     }
     case ECMA_TYPE_NUMBER:
     {
-      ecma_number_t *num_p = ECMA_GET_NON_NULL_POINTER(value.value);
+      ecma_number_t *num_p = ecma_get_number_from_value (value);
-      JERRY_ASSERT(num_p != NULL);
 
       ecma_number_t *number_copy_p = ecma_alloc_number ();
       *number_copy_p = *num_p;
 
-      value_copy = (ecma_value_t)
+      value_copy = ecma_make_number_value (number_copy_p);
-      {
-        .value_type = ECMA_TYPE_NUMBER
-      };
-      ECMA_SET_NON_NULL_POINTER(value_copy.value, number_copy_p);
 
       break;
     }
     case ECMA_TYPE_STRING:
     {
-      ecma_string_t *string_p = ECMA_GET_NON_NULL_POINTER(value.value);
+      ecma_string_t *string_p = ecma_get_string_from_value (value);
-      JERRY_ASSERT(string_p != NULL);
 
       string_p = ecma_copy_or_ref_ecma_string (string_p);
 
-      value_copy = (ecma_value_t)
+      value_copy = ecma_make_string_value (string_p);
-      {
-        .value_type = ECMA_TYPE_STRING
-      };
-      ECMA_SET_NON_NULL_POINTER(value_copy.value, string_p);
 
       break;
     }
     case ECMA_TYPE_OBJECT:
     {
-      ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER(value.value);
+      ecma_object_t *obj_p = ecma_get_object_from_value (value);
-      JERRY_ASSERT(obj_p != NULL);
 
       if (do_ref_if_object)
       {
@@ -411,7 +398,7 @@ ecma_free_value (ecma_value_t value, /**< value description */
                  bool do_deref_if_object) /**< if the value is object value,
                                                decrement reference counter of the object */
 {
-  switch ((ecma_type_t) value.value_type)
+  switch (ecma_get_value_type_field (value))
   {
     case ECMA_TYPE_SIMPLE:
     {
@@ -421,14 +408,14 @@ ecma_free_value (ecma_value_t value, /**< value description */
 
     case ECMA_TYPE_NUMBER:
     {
-      ecma_number_t *number_p = ECMA_GET_NON_NULL_POINTER(value.value);
+      ecma_number_t *number_p = ecma_get_number_from_value (value);
       ecma_dealloc_number (number_p);
       break;
     }
 
     case ECMA_TYPE_STRING:
     {
-      ecma_string_t *string_p = ECMA_GET_NON_NULL_POINTER(value.value);
+      ecma_string_t *string_p = ecma_get_string_from_value (value);
       ecma_deref_ecma_string (string_p);
       break;
     }
@@ -437,7 +424,7 @@ ecma_free_value (ecma_value_t value, /**< value description */
     {
       if (do_deref_if_object)
       {
-        ecma_deref_object (ECMA_GET_NON_NULL_POINTER(value.value));
+        ecma_deref_object (ecma_get_object_from_value (value));
       }
       break;
     }
@@ -464,26 +451,17 @@ ecma_make_completion_value (ecma_completion_type_t type, /**< type */
 
   JERRY_ASSERT (is_type_ok);
 
-  union
-  {
-    ecma_value_t value;
-    uint16_t uint16;
-  } u_v;
-
-  u_v.value = value;
-
   union
   {
     ecma_completion_value_t value;
     uint32_t uint32;
   } u_cv;
 
-  u_cv.uint32 = ((uint32_t) type | (uint32_t) (u_v.uint16 << 16u));
+  u_cv.uint32 = ((uint32_t) type | (uint32_t) (value << 16u));
 
   JERRY_ASSERT (u_cv.value.type == type &&
                 u_cv.value.padding == 0u &&
-                u_cv.value.u.value.value_type == value.value_type &&
+                u_cv.value.u.value == value);
-                u_cv.value.u.value.value == value.value);
 
   return u_cv.value;
 } /* ecma_make_completion_value */
@@ -723,7 +701,7 @@ ecma_free_completion_value (ecma_completion_value_t completion_value) /**< compl
     }
     case ECMA_COMPLETION_TYPE_EXIT:
     {
-      JERRY_ASSERT(completion_value.u.value.value_type == ECMA_TYPE_SIMPLE);
+      JERRY_ASSERT(ecma_get_value_type_field (ecma_get_completion_value_value (completion_value)) == ECMA_TYPE_SIMPLE);
       break;
     }
     case ECMA_COMPLETION_TYPE_CONTINUE:
@@ -836,8 +814,7 @@ ecma_is_completion_value_normal_simple_value (ecma_completion_value_t value, /**
                                                                                      for equality with */
 {
   return (ecma_is_completion_value_normal (value)
-          && value.u.value.value_type == ECMA_TYPE_SIMPLE
+          && value.u.value == ecma_make_simple_value (simple_value));
-          && value.u.value.value == simple_value);
 } /* ecma_is_completion_value_normal_simple_value */
 
 /**

src/libecmaoperations/ecma-array-object.c

@@ -81,7 +81,7 @@ ecma_op_create_array_object (ecma_value_t *arguments_list_p, /**< list of argume
       && arguments_list_len == 1
       && ecma_is_value_number (arguments_list_p[0]))
   {
-    ecma_number_t *num_p = ECMA_GET_NON_NULL_POINTER (arguments_list_p[0].value);
+    ecma_number_t *num_p = ecma_get_number_from_value (arguments_list_p[0]);
     uint32_t num_uint32 = ecma_number_to_uint32 (*num_p);
     if (*num_p != ecma_uint32_to_number (num_uint32))
     {
@@ -185,9 +185,7 @@ ecma_op_array_object_define_own_property (ecma_object_t *obj_p, /**< the array o
   // 2.
   ecma_value_t old_len_value = len_prop_p->u.named_data_property.value;
 
-  JERRY_ASSERT (ecma_is_value_number (old_len_value));
+  ecma_number_t *num_p = ecma_get_number_from_value (old_len_value);
-
-  ecma_number_t *num_p = ECMA_GET_NON_NULL_POINTER (old_len_value.value);
   uint32_t old_len_uint32 = ecma_number_to_uint32 (*num_p);
 
   // 3.
@@ -317,7 +315,7 @@ ecma_op_array_object_define_own_property (ecma_object_t *obj_p, /**< the array o
               {
                 JERRY_ASSERT (ecma_is_value_number (new_len_property_desc.value));
 
-                ecma_number_t *new_len_num_p = ECMA_GET_NON_NULL_POINTER (new_len_property_desc.value.value);
+                ecma_number_t *new_len_num_p = ecma_get_number_from_value (new_len_property_desc.value);
 
                 // 1.
                 *new_len_num_p = ecma_uint32_to_number (old_len_uint32 + 1);

src/libecmaoperations/ecma-boolean-object.c

@@ -48,9 +48,8 @@ ecma_op_create_boolean_object (ecma_value_t arg) /**< argument passed to the Boo
     return conv_to_boolean_completion;
   }
 
-  ecma_simple_value_t bool_value = ecma_get_completion_value_value (conv_to_boolean_completion).value;
+  ecma_simple_value_t bool_value = (ecma_is_value_true (ecma_get_completion_value_value (conv_to_boolean_completion)) ?
-
+                                    ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
-  JERRY_ASSERT (bool_value == ECMA_SIMPLE_VALUE_TRUE || bool_value == ECMA_SIMPLE_VALUE_FALSE);
 
 #ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_BOOLEAN_BUILTIN
   ecma_object_t *prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_BOOLEAN_PROTOTYPE);

src/libecmaoperations/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_number_t*)(ECMA_GET_NON_NULL_POINTER(x.value));
+      ecma_number_t x_num = *ecma_get_number_from_value (x);
-      ecma_number_t y_num = *(ecma_number_t*)(ECMA_GET_NON_NULL_POINTER(y.value));
+      ecma_number_t y_num = *ecma_get_number_from_value (y);
 
       bool is_equal;
 
@@ -98,8 +98,8 @@ ecma_op_abstract_equality_compare (ecma_value_t x, /**< first operand */
     }
     else if (is_x_string)
     { // d.
-      ecma_string_t* x_str_p = ECMA_GET_NON_NULL_POINTER(x.value);
+      ecma_string_t* x_str_p = ecma_get_string_from_value (x);
-      ecma_string_t* y_str_p = ECMA_GET_NON_NULL_POINTER(y.value);
+      ecma_string_t* y_str_p = ecma_get_string_from_value (y);
 
       bool is_equal = ecma_compare_ecma_strings (x_str_p, y_str_p);
 
@@ -107,7 +107,7 @@ ecma_op_abstract_equality_compare (ecma_value_t x, /**< first operand */
     }
     else if (is_x_boolean)
     { // e.
-      bool is_equal = (x.value == y.value);
+      bool is_equal = (ecma_is_value_true (x) == ecma_is_value_true (y));
 
       ret_value = ecma_make_simple_completion_value (is_equal ? ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
     }
@@ -115,7 +115,7 @@ ecma_op_abstract_equality_compare (ecma_value_t x, /**< first operand */
     { // f.
       JERRY_ASSERT(is_x_object);
 
-      bool is_equal = (x.value == y.value);
+      bool is_equal = (ecma_get_object_from_value (x) == ecma_get_object_from_value (y));
 
       ret_value = ecma_make_simple_completion_value (is_equal ? ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
     }
@@ -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_number_t*) (ECMA_GET_NON_NULL_POINTER (x.value));
+    ecma_number_t x_num = *ecma_get_number_from_value (x);
-    ecma_number_t y_num = *(ecma_number_t*) (ECMA_GET_NON_NULL_POINTER (y.value));
+    ecma_number_t y_num = *ecma_get_number_from_value (y);
 
     if (ecma_number_is_nan (x_num)
         || ecma_number_is_nan (y_num))
@@ -291,8 +291,8 @@ ecma_op_strict_equality_compare (ecma_value_t x, /**< first operand */
   // (same length and same characters in corresponding positions); otherwise, return false.
   if (is_x_string)
   {
-    ecma_string_t* x_str_p = ECMA_GET_NON_NULL_POINTER (x.value);
+    ecma_string_t* x_str_p = ecma_get_string_from_value (x);
-    ecma_string_t* y_str_p = ECMA_GET_NON_NULL_POINTER (y.value);
+    ecma_string_t* y_str_p = ecma_get_string_from_value (y);
 
     return ecma_compare_ecma_strings (x_str_p, y_str_p);
   }
@@ -300,13 +300,13 @@ ecma_op_strict_equality_compare (ecma_value_t x, /**< first operand */
   // 6. If Type (x) is Boolean, return true if x and y are both true or both false; otherwise, return false.
   if (is_x_boolean)
   {
-    return (x.value == y.value);
+    return (ecma_is_value_true (x) == ecma_is_value_true (y));
   }
 
   // 7. Return true if x and y refer to the same object. Otherwise, return false.
   JERRY_ASSERT (is_x_object);
 
-  return (ECMA_GET_NON_NULL_POINTER (x.value) == ECMA_GET_NON_NULL_POINTER (y.value));
+  return (ecma_get_object_from_value (x) == ecma_get_object_from_value (y));
 } /* ecma_op_strict_equality_compare */
 
 /**

src/libecmaoperations/ecma-conversion.c

@@ -111,8 +111,8 @@ ecma_op_same_value (ecma_value_t x, /**< ecma-value */
 
   if (is_x_number)
   {
-    ecma_number_t *x_num_p = (ecma_number_t*)ECMA_GET_NON_NULL_POINTER(x.value);
+    ecma_number_t *x_num_p = ecma_get_number_from_value (x);
-    ecma_number_t *y_num_p = (ecma_number_t*)ECMA_GET_NON_NULL_POINTER(y.value);
+    ecma_number_t *y_num_p = ecma_get_number_from_value (y);
 
     if (ecma_number_is_nan (*x_num_p)
         && ecma_number_is_nan (*y_num_p))
@@ -131,8 +131,8 @@ ecma_op_same_value (ecma_value_t x, /**< ecma-value */
 
   if (is_x_string)
   {
-    ecma_string_t* x_str_p = ECMA_GET_NON_NULL_POINTER(x.value);
+    ecma_string_t* x_str_p = ecma_get_string_from_value (x);
-    ecma_string_t* y_str_p = ECMA_GET_NON_NULL_POINTER(y.value);
+    ecma_string_t* y_str_p = ecma_get_string_from_value (y);
 
     return ecma_compare_ecma_strings (x_str_p, y_str_p);
   }
@@ -144,7 +144,7 @@ ecma_op_same_value (ecma_value_t x, /**< ecma-value */
 
   JERRY_ASSERT(is_x_object);
 
-  return (ECMA_GET_NON_NULL_POINTER(x.value) == ECMA_GET_NON_NULL_POINTER(y.value));
+  return (ecma_get_object_from_value (x) == ecma_get_object_from_value (y));
 } /* ecma_op_same_value */
 
 /**
@@ -164,7 +164,7 @@ ecma_op_to_primitive (ecma_value_t value, /**< ecma-value */
 
   if (ecma_is_value_object (value))
   {
-    ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER (value.value);
+    ecma_object_t *obj_p = ecma_get_object_from_value (value);
 
     return ecma_op_object_default_value (obj_p, preferred_type);
   }
@@ -193,7 +193,8 @@ ecma_op_to_boolean (ecma_value_t value) /**< ecma-value */
 
   if (ecma_is_value_boolean (value))
   {
-    ret_value = value.value;
+    ret_value = (ecma_is_value_true (value) ?
+                 ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
   }
   else if (ecma_is_value_undefined (value)
            || ecma_is_value_null (value))
@@ -202,7 +203,7 @@ ecma_op_to_boolean (ecma_value_t value) /**< ecma-value */
   }
   else if (ecma_is_value_number (value))
   {
-    ecma_number_t *num_p = ECMA_GET_NON_NULL_POINTER(value.value);
+    ecma_number_t *num_p = ecma_get_number_from_value (value);
 
     if (ecma_number_is_nan (*num_p)
         || ecma_number_is_zero (*num_p))
@@ -216,7 +217,7 @@ ecma_op_to_boolean (ecma_value_t value) /**< ecma-value */
   }
   else if (ecma_is_value_string (value))
   {
-    ecma_string_t *str_p = ECMA_GET_NON_NULL_POINTER(value.value);
+    ecma_string_t *str_p = ecma_get_string_from_value (value);
 
     if (ecma_string_get_length (str_p) == 0)
     {
@@ -257,7 +258,7 @@ ecma_op_to_number (ecma_value_t value) /**< ecma-value */
   }
   else if (ecma_is_value_string (value))
   {
-    ecma_string_t *str_p = ECMA_GET_NON_NULL_POINTER (value.value);
+    ecma_string_t *str_p = ecma_get_string_from_value (value);
 
     ecma_number_t *num_p = ecma_alloc_number ();
     *num_p = ecma_string_to_number (str_p);
@@ -342,12 +343,12 @@ ecma_op_to_string (ecma_value_t value) /**< ecma-value */
 
     if (ecma_is_value_string (value))
     {
-      res_p = ECMA_GET_NON_NULL_POINTER (value.value);
+      res_p = ecma_get_string_from_value (value);
       res_p = ecma_copy_or_ref_ecma_string (res_p);
     }
     else if (ecma_is_value_number (value))
     {
-      ecma_number_t *num_p = ECMA_GET_NON_NULL_POINTER (value.value);
+      ecma_number_t *num_p = ecma_get_number_from_value (value);
       res_p = ecma_new_ecma_string_from_number (*num_p);
     }
     else if (ecma_is_value_undefined (value))
@@ -570,7 +571,7 @@ ecma_op_to_property_descriptor (ecma_value_t obj_value, /**< object value */
   }
   else
   {
-    ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER (obj_value.value);
+    ecma_object_t *obj_p = ecma_get_object_from_value (obj_value);
 
     // 2.
     ecma_property_descriptor_t prop_desc = ecma_make_empty_property_descriptor ();

src/libecmaoperations/ecma-function-object.c

@@ -94,7 +94,7 @@ ecma_op_is_callable (ecma_value_t value) /**< ecma-value */
     return false;
   }
 
-  ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER(value.value);
+  ecma_object_t *obj_p = ecma_get_object_from_value (value);
 
   JERRY_ASSERT(obj_p != NULL);
   JERRY_ASSERT(!ecma_is_lexical_environment (obj_p));
@@ -118,7 +118,7 @@ ecma_is_constructor (ecma_value_t value) /**< ecma-value */
     return false;
   }
 
-  ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER(value.value);
+  ecma_object_t *obj_p = ecma_get_object_from_value (value);
 
   JERRY_ASSERT(obj_p != NULL);
   JERRY_ASSERT(!ecma_is_lexical_environment (obj_p));
@@ -338,8 +338,7 @@ ecma_function_call_setup_args_variables (ecma_object_t *func_obj_p, /**< Functio
     JERRY_ASSERT (is_moved);
 
     ecma_value_t formal_parameter_name_value = *formal_params_iterator.current_value_p;
-    JERRY_ASSERT (ecma_is_value_string (formal_parameter_name_value));
+    ecma_string_t *formal_parameter_name_string_p = ecma_get_string_from_value (formal_parameter_name_value);
-    ecma_string_t *formal_parameter_name_string_p = ECMA_GET_NON_NULL_POINTER (formal_parameter_name_value.value);
     
     bool arg_already_declared = ecma_op_has_binding (env_p, formal_parameter_name_string_p);
     if (!arg_already_declared)
@@ -395,8 +394,7 @@ ecma_op_function_has_instance (ecma_object_t *func_obj_p, /**< Function object *
       return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE);
     }
 
-    ecma_object_t* v_obj_p = ECMA_GET_NON_NULL_POINTER (value.value);
+    ecma_object_t* v_obj_p = ecma_get_object_from_value (value);
-    JERRY_ASSERT (v_obj_p != NULL);
 
     ecma_string_t *prototype_magic_string_p = ecma_get_magic_string (ECMA_MAGIC_STRING_PROTOTYPE);
 

src/libecmaoperations/ecma-get-put-value.c

@@ -83,7 +83,7 @@ ecma_op_get_value_object_base (ecma_reference_t ref) /**< ECMA-reference */
                                    || ecma_is_value_number (base)
                                    || ecma_is_value_string (base));
   const bool has_object_base = (ecma_is_value_object (base)
-                                && !(ecma_is_lexical_environment (ECMA_GET_NON_NULL_POINTER(base.value))));
+                                && !(ecma_is_lexical_environment (ecma_get_object_from_value (base))));
   const bool is_property_reference = has_primitive_base || has_object_base;
 
   JERRY_ASSERT (!is_unresolvable_reference);
@@ -94,7 +94,7 @@ ecma_op_get_value_object_base (ecma_reference_t ref) /**< ECMA-reference */
   {
     // 4.b case 1
 
-    ecma_object_t *obj_p = ECMA_GET_POINTER(base.value);
+    ecma_object_t *obj_p = ecma_get_object_from_value (base);
     JERRY_ASSERT(obj_p != NULL
                  && !ecma_is_lexical_environment (obj_p));
 
@@ -210,7 +210,7 @@ ecma_op_put_value_object_base (ecma_reference_t ref, /**< ECMA-reference */
                                    || ecma_is_value_number (base)
                                    || ecma_is_value_string (base));
   const bool has_object_base = (ecma_is_value_object (base)
-                                && !(ecma_is_lexical_environment (ECMA_GET_NON_NULL_POINTER(base.value))));
+                                && !(ecma_is_lexical_environment (ecma_get_object_from_value (base))));
   const bool is_property_reference = has_primitive_base || has_object_base;
 
   JERRY_ASSERT (!is_unresolvable_reference);
@@ -221,7 +221,7 @@ ecma_op_put_value_object_base (ecma_reference_t ref, /**< ECMA-reference */
   {
     // 4.b case 1
 
-    ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER(base.value);
+    ecma_object_t *obj_p = ecma_get_object_from_value (base);
     JERRY_ASSERT (obj_p != NULL
                   && !ecma_is_lexical_environment (obj_p));
 

src/libecmaoperations/ecma-objects-arguments.c

@@ -142,7 +142,7 @@ ecma_create_arguments_object (ecma_object_t *func_obj_p, /**< callee function */
       JERRY_ASSERT (param_index < formal_params_number);
 
       JERRY_ASSERT (ecma_is_value_string (*formal_params_iter_p->current_value_p));
-      formal_params[param_index] = ECMA_GET_NON_NULL_POINTER (formal_params_iter_p->current_value_p->value);
+      formal_params[param_index] = ecma_get_string_from_value (*formal_params_iter_p->current_value_p);
     }
     JERRY_ASSERT (param_index == formal_params_number);
 
@@ -285,8 +285,7 @@ ecma_arguments_get_mapped_arg_value (ecma_object_t *map_p, /**< [[ParametersMap]
 
   ecma_value_t arg_name_prop_value = arg_name_prop_p->u.named_data_property.value;
 
-  JERRY_ASSERT (ecma_is_value_string (arg_name_prop_value));
+  ecma_string_t *arg_name_p = ecma_get_string_from_value (arg_name_prop_value);
-  ecma_string_t *arg_name_p = ECMA_GET_NON_NULL_POINTER (arg_name_prop_value.value);
 
   ecma_completion_value_t completion = ecma_op_get_binding_value (lex_env_p,
                                                                   arg_name_p,