diff --git a/src/libcoreint/interpreter.c b/src/libcoreint/interpreter.c
index 3ce738cad..ad5c16b7c 100644
--- a/src/libcoreint/interpreter.c
+++ b/src/libcoreint/interpreter.c
@@ -375,7 +375,7 @@ run_int (void)
       ecma_finalize ();
       ecma_gc_run (ECMA_GC_GEN_COUNT - 1);
 
-      return ecma_is_value_true (completion.u.value);
+      return ecma_is_value_true (ecma_get_completion_value_value (completion));
     }
     case ECMA_COMPLETION_TYPE_BREAK:
     case ECMA_COMPLETION_TYPE_CONTINUE:
diff --git a/src/libcoreint/opcodes-agnostic.c b/src/libcoreint/opcodes-agnostic.c
index 01dc10eae..17571ccf4 100644
--- a/src/libcoreint/opcodes-agnostic.c
+++ b/src/libcoreint/opcodes-agnostic.c
@@ -35,10 +35,10 @@ opfunc_is_true_jmp_down (opcode_t opdata, /**< operation data */
 
   ECMA_TRY_CATCH (cond_value, get_variable_value (int_data, cond_var_idx, false), ret_value);
 
-  ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (cond_value.u.value);
+  ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (ecma_get_completion_value_value (cond_value));
   JERRY_ASSERT (ecma_is_completion_value_normal (to_bool_completion));
 
-  if (ecma_is_value_true (to_bool_completion.u.value))
+  if (ecma_is_value_true (ecma_get_completion_value_value (to_bool_completion)))
   {
     JERRY_ASSERT (offset != 0 && ((uint32_t) int_data->pos + offset < MAX_OPCODES));
     int_data->pos = (opcode_counter_t) (int_data->pos + offset);
@@ -68,10 +68,10 @@ opfunc_is_true_jmp_up (opcode_t opdata, /**< operation data */
 
   ECMA_TRY_CATCH (cond_value, get_variable_value (int_data, cond_var_idx, false), ret_value);
 
-  ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (cond_value.u.value);
+  ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (ecma_get_completion_value_value (cond_value));
   JERRY_ASSERT (ecma_is_completion_value_normal (to_bool_completion));
 
-  if (ecma_is_value_true (to_bool_completion.u.value))
+  if (ecma_is_value_true (ecma_get_completion_value_value (to_bool_completion)))
   {
     JERRY_ASSERT (offset != 0 && (uint32_t) int_data->pos >= offset);
     int_data->pos = (opcode_counter_t) (int_data->pos - offset);
@@ -107,10 +107,10 @@ opfunc_is_false_jmp_down (opcode_t opdata, /**< operation data */
 
   ECMA_TRY_CATCH (cond_value, get_variable_value (int_data, cond_var_idx, false), ret_value);
 
-  ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (cond_value.u.value);
+  ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (ecma_get_completion_value_value (cond_value));
   JERRY_ASSERT (ecma_is_completion_value_normal (to_bool_completion));
 
-  if (!ecma_is_value_true (to_bool_completion.u.value))
+  if (!ecma_is_value_true (ecma_get_completion_value_value (to_bool_completion)))
   {
     JERRY_ASSERT (offset != 0 && ((uint32_t) int_data->pos + offset < MAX_OPCODES));
     int_data->pos = (opcode_counter_t) (int_data->pos + offset);
@@ -140,10 +140,10 @@ opfunc_is_false_jmp_up (opcode_t opdata, /**< operation data */
 
   ECMA_TRY_CATCH (cond_value, get_variable_value (int_data, cond_var_idx, false), ret_value);
 
-  ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (cond_value.u.value);
+  ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (ecma_get_completion_value_value (cond_value));
   JERRY_ASSERT (ecma_is_completion_value_normal (to_bool_completion));
 
-  if (!ecma_is_value_true (to_bool_completion.u.value))
+  if (!ecma_is_value_true (ecma_get_completion_value_value (to_bool_completion)))
   {
     JERRY_ASSERT (offset != 0 && (uint32_t) int_data->pos >= offset);
     int_data->pos = (opcode_counter_t) (int_data->pos - offset);
diff --git a/src/libcoreint/opcodes-ecma-arithmetics.c b/src/libcoreint/opcodes-ecma-arithmetics.c
index 9034fb619..c917ef79a 100644
--- a/src/libcoreint/opcodes-ecma-arithmetics.c
+++ b/src/libcoreint/opcodes-ecma-arithmetics.c
@@ -54,8 +54,8 @@ do_number_arithmetic (int_data_t *int_data, /**< interpreter context */
   ECMA_TRY_CATCH (num_right_value, ecma_op_to_number (right_value), ret_value);
 
   ecma_number_t *left_p, *right_p, *res_p;
-  left_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (num_left_value.u.value.value);
-  right_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (num_right_value.u.value.value);
+  left_p = ecma_get_number_from_completion_value (num_left_value);
+  right_p = ecma_get_number_from_completion_value (num_right_value);
 
   res_p = ecma_alloc_number ();
 
@@ -122,17 +122,23 @@ opfunc_addition (opcode_t opdata, /**< operation data */
 
   ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
   ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
-  ECMA_TRY_CATCH (prim_left_value, ecma_op_to_primitive (left_value.u.value, ECMA_PREFERRED_TYPE_NO), ret_value);
-  ECMA_TRY_CATCH (prim_right_value, ecma_op_to_primitive (right_value.u.value, ECMA_PREFERRED_TYPE_NO), ret_value);
+  ECMA_TRY_CATCH (prim_left_value,
+                  ecma_op_to_primitive (ecma_get_completion_value_value (left_value),
+                                        ECMA_PREFERRED_TYPE_NO),
+                  ret_value);
+  ECMA_TRY_CATCH (prim_right_value,
+                  ecma_op_to_primitive (ecma_get_completion_value_value (right_value),
+                                        ECMA_PREFERRED_TYPE_NO),
+                  ret_value);
 
-  if (ecma_is_value_string (prim_left_value.u.value)
-      || ecma_is_value_string (prim_right_value.u.value))
+  if (ecma_is_value_string (ecma_get_completion_value_value (prim_left_value))
+      || ecma_is_value_string (ecma_get_completion_value_value (prim_right_value)))
   {
-    ECMA_TRY_CATCH (str_left_value, ecma_op_to_string (prim_left_value.u.value), ret_value);
-    ECMA_TRY_CATCH (str_right_value, ecma_op_to_string (prim_right_value.u.value), ret_value);
+    ECMA_TRY_CATCH (str_left_value, ecma_op_to_string (ecma_get_completion_value_value (prim_left_value)), ret_value);
+    ECMA_TRY_CATCH (str_right_value, ecma_op_to_string (ecma_get_completion_value_value (prim_right_value)), ret_value);
 
-    ecma_string_t *string1_p = ECMA_GET_NON_NULL_POINTER (str_left_value.u.value.value);
-    ecma_string_t *string2_p = ECMA_GET_NON_NULL_POINTER (str_right_value.u.value.value);
+    ecma_string_t *string1_p = ecma_get_string_from_completion_value (str_left_value);
+    ecma_string_t *string2_p = ecma_get_string_from_completion_value (str_right_value);
 
     ecma_string_t *concat_str_p = ecma_concat_ecma_strings (string1_p, string2_p);
 
@@ -148,8 +154,8 @@ opfunc_addition (opcode_t opdata, /**< operation data */
     ret_value = do_number_arithmetic (int_data,
                                       dst_var_idx,
                                       number_arithmetic_addition,
-                                      prim_left_value.u.value,
-                                      prim_right_value.u.value);
+                                      ecma_get_completion_value_value (prim_left_value),
+                                      ecma_get_completion_value_value (prim_right_value));
   }
 
   ECMA_FINALIZE (prim_right_value);
@@ -186,8 +192,8 @@ opfunc_substraction (opcode_t opdata, /**< operation data */
   ret_value = do_number_arithmetic (int_data,
                                     dst_var_idx,
                                     number_arithmetic_substraction,
-                                    left_value.u.value,
-                                    right_value.u.value);
+                                    ecma_get_completion_value_value (left_value),
+                                    ecma_get_completion_value_value (right_value));
 
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
@@ -221,8 +227,8 @@ opfunc_multiplication (opcode_t opdata, /**< operation data */
   ret_value = do_number_arithmetic (int_data,
                                     dst_var_idx,
                                     number_arithmetic_multiplication,
-                                    left_value.u.value,
-                                    right_value.u.value);
+                                    ecma_get_completion_value_value (left_value),
+                                    ecma_get_completion_value_value (right_value));
 
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
@@ -256,8 +262,8 @@ opfunc_division (opcode_t opdata, /**< operation data */
   ret_value = do_number_arithmetic (int_data,
                                     dst_var_idx,
                                     number_arithmetic_division,
-                                    left_value.u.value,
-                                    right_value.u.value);
+                                    ecma_get_completion_value_value (left_value),
+                                    ecma_get_completion_value_value (right_value));
 
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
@@ -291,8 +297,8 @@ opfunc_remainder (opcode_t opdata, /**< operation data */
   ret_value = do_number_arithmetic (int_data,
                                     dst_var_idx,
                                     number_arithmetic_remainder,
-                                    left_value.u.value,
-                                    right_value.u.value);
+                                    ecma_get_completion_value_value (left_value),
+                                    ecma_get_completion_value_value (right_value));
 
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
@@ -320,9 +326,9 @@ opfunc_unary_plus (opcode_t opdata, /**< operation data */
   ecma_completion_value_t ret_value;
 
   ECMA_TRY_CATCH (var_value, get_variable_value (int_data, var_idx, false), ret_value);
-  ECMA_TRY_CATCH (num_value, ecma_op_to_number (var_value.u.value), ret_value);
+  ECMA_TRY_CATCH (num_value, ecma_op_to_number (ecma_get_completion_value_value (var_value)), ret_value);
 
-  ecma_number_t *var_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (num_value.u.value.value);
+  ecma_number_t *var_p = ecma_get_number_from_completion_value (num_value);
   ret_value = set_variable_value (int_data,
                                   dst_var_idx,
                                   ecma_make_number_value (var_p));
@@ -353,10 +359,10 @@ opfunc_unary_minus (opcode_t opdata, /**< operation data */
   ecma_completion_value_t ret_value;
 
   ECMA_TRY_CATCH (var_value, get_variable_value (int_data, var_idx, false), ret_value);
-  ECMA_TRY_CATCH (num_value, ecma_op_to_number (var_value.u.value), ret_value);
+  ECMA_TRY_CATCH (num_value, ecma_op_to_number (ecma_get_completion_value_value (var_value)), ret_value);
 
   ecma_number_t *var_p, *res_p;
-  var_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (num_value.u.value.value);
+  var_p = ecma_get_number_from_completion_value (num_value);
 
   res_p = ecma_alloc_number ();
   *res_p = ecma_number_negate (*var_p);
diff --git a/src/libcoreint/opcodes-ecma-bitwise.c b/src/libcoreint/opcodes-ecma-bitwise.c
index 4d14d53de..4483e4c40 100644
--- a/src/libcoreint/opcodes-ecma-bitwise.c
+++ b/src/libcoreint/opcodes-ecma-bitwise.c
@@ -54,8 +54,8 @@ do_number_bitwise_logic (int_data_t *int_data, /**< interpreter context */
   ECMA_TRY_CATCH (num_right_value, ecma_op_to_number (right_value), ret_value);
 
   ecma_number_t *left_p, *right_p;
-  left_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (num_left_value.u.value.value);
-  right_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (num_right_value.u.value.value);
+  left_p = ecma_get_number_from_completion_value (num_left_value);
+  right_p = ecma_get_number_from_completion_value (num_right_value);
 
   ecma_number_t* res_p = ecma_alloc_number ();
 
@@ -142,8 +142,8 @@ opfunc_b_and (opcode_t opdata, /**< operation data */
   ret_value = do_number_bitwise_logic (int_data,
                                        dst_var_idx,
                                        number_bitwise_logic_and,
-                                       left_value.u.value,
-                                       right_value.u.value);
+                                       ecma_get_completion_value_value (left_value),
+                                       ecma_get_completion_value_value (right_value));
 
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
@@ -177,8 +177,8 @@ opfunc_b_or (opcode_t opdata, /**< operation data */
   ret_value = do_number_bitwise_logic (int_data,
                                        dst_var_idx,
                                        number_bitwise_logic_or,
-                                       left_value.u.value,
-                                       right_value.u.value);
+                                       ecma_get_completion_value_value (left_value),
+                                       ecma_get_completion_value_value (right_value));
 
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
@@ -212,8 +212,8 @@ opfunc_b_xor (opcode_t opdata, /**< operation data */
   ret_value = do_number_bitwise_logic (int_data,
                                        dst_var_idx,
                                        number_bitwise_logic_xor,
-                                       left_value.u.value,
-                                       right_value.u.value);
+                                       ecma_get_completion_value_value (left_value),
+                                       ecma_get_completion_value_value (right_value));
 
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
@@ -247,8 +247,8 @@ opfunc_b_shift_left (opcode_t opdata, /**< operation data */
   ret_value = do_number_bitwise_logic (int_data,
                                        dst_var_idx,
                                        number_bitwise_shift_left,
-                                       left_value.u.value,
-                                       right_value.u.value);
+                                       ecma_get_completion_value_value (left_value),
+                                       ecma_get_completion_value_value (right_value));
 
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
@@ -282,8 +282,8 @@ opfunc_b_shift_right (opcode_t opdata, /**< operation data */
   ret_value = do_number_bitwise_logic (int_data,
                                        dst_var_idx,
                                        number_bitwise_shift_right,
-                                       left_value.u.value,
-                                       right_value.u.value);
+                                       ecma_get_completion_value_value (left_value),
+                                       ecma_get_completion_value_value (right_value));
 
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
@@ -317,8 +317,8 @@ opfunc_b_shift_uright (opcode_t opdata, /**< operation data */
   ret_value = do_number_bitwise_logic (int_data,
                                        dst_var_idx,
                                        number_bitwise_shift_uright,
-                                       left_value.u.value,
-                                       right_value.u.value);
+                                       ecma_get_completion_value_value (left_value),
+                                       ecma_get_completion_value_value (right_value));
 
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
@@ -350,8 +350,8 @@ opfunc_b_not (opcode_t opdata, /**< operation data */
   ret_value = do_number_bitwise_logic (int_data,
                                        dst_var_idx,
                                        number_bitwise_not,
-                                       right_value.u.value,
-                                       right_value.u.value);
+                                       ecma_get_completion_value_value (right_value),
+                                       ecma_get_completion_value_value (right_value));
 
   ECMA_FINALIZE (right_value);
 
diff --git a/src/libcoreint/opcodes-ecma-equality.c b/src/libcoreint/opcodes-ecma-equality.c
index 33cfce797..96bbbbd6b 100644
--- a/src/libcoreint/opcodes-ecma-equality.c
+++ b/src/libcoreint/opcodes-ecma-equality.c
@@ -39,13 +39,14 @@ opfunc_equal_value (opcode_t opdata, /**< operation data */
   ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
   ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
   ECMA_TRY_CATCH (compare_result,
-                  ecma_op_abstract_equality_compare (left_value.u.value, right_value.u.value),
+                  ecma_op_abstract_equality_compare (ecma_get_completion_value_value (left_value),
+                                                     ecma_get_completion_value_value (right_value)),
                   ret_value);
 
   JERRY_ASSERT (ecma_is_completion_value_normal_true (compare_result)
                 || ecma_is_completion_value_normal_false (compare_result));
 
-  ret_value = set_variable_value (int_data, dst_var_idx, compare_result.u.value);
+  ret_value = set_variable_value (int_data, dst_var_idx, ecma_get_completion_value_value (compare_result));
 
   ECMA_FINALIZE (compare_result);
   ECMA_FINALIZE (right_value);
@@ -77,7 +78,8 @@ opfunc_not_equal_value (opcode_t opdata, /**< operation data */
   ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
   ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
   ECMA_TRY_CATCH (compare_result,
-                  ecma_op_abstract_equality_compare (left_value.u.value, right_value.u.value),
+                  ecma_op_abstract_equality_compare (ecma_get_completion_value_value (left_value),
+                                                     ecma_get_completion_value_value (right_value)),
                   ret_value);
 
   JERRY_ASSERT (ecma_is_completion_value_normal_true (compare_result)
@@ -118,7 +120,8 @@ opfunc_equal_value_type (opcode_t opdata, /**< operation data */
   ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
   ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
 
-  bool is_equal = ecma_op_strict_equality_compare (left_value.u.value, right_value.u.value);
+  bool is_equal = ecma_op_strict_equality_compare (ecma_get_completion_value_value (left_value),
+                                                   ecma_get_completion_value_value (right_value));
 
   ret_value = set_variable_value (int_data, dst_var_idx, ecma_make_simple_value (is_equal ? ECMA_SIMPLE_VALUE_TRUE
                                                                                  : ECMA_SIMPLE_VALUE_FALSE));
@@ -152,7 +155,8 @@ opfunc_not_equal_value_type (opcode_t opdata, /**< operation data */
   ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
   ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
 
-  bool is_equal = ecma_op_strict_equality_compare (left_value.u.value, right_value.u.value);
+  bool is_equal = ecma_op_strict_equality_compare (ecma_get_completion_value_value (left_value),
+                                                   ecma_get_completion_value_value (right_value));
 
   ret_value = set_variable_value (int_data, dst_var_idx, ecma_make_simple_value (is_equal ? ECMA_SIMPLE_VALUE_FALSE
                                                                                  : ECMA_SIMPLE_VALUE_TRUE));
diff --git a/src/libcoreint/opcodes-ecma-relational.c b/src/libcoreint/opcodes-ecma-relational.c
index 72c5b4395..7080b58a7 100644
--- a/src/libcoreint/opcodes-ecma-relational.c
+++ b/src/libcoreint/opcodes-ecma-relational.c
@@ -39,22 +39,22 @@ opfunc_less_than (opcode_t opdata, /**< operation data */
   ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
   ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
   ECMA_TRY_CATCH (compare_result,
-                  ecma_op_abstract_relational_compare (left_value.u.value,
-                                                       right_value.u.value,
+                  ecma_op_abstract_relational_compare (ecma_get_completion_value_value (left_value),
+                                                       ecma_get_completion_value_value (right_value),
                                                        true),
                   ret_value);
 
   ecma_simple_value_t res;
 
-  if (ecma_is_value_undefined (compare_result.u.value))
+  if (ecma_is_value_undefined (ecma_get_completion_value_value (compare_result)))
   {
     res = ECMA_SIMPLE_VALUE_FALSE;
   }
   else
   {
-    JERRY_ASSERT (ecma_is_value_boolean (compare_result.u.value));
+    JERRY_ASSERT (ecma_is_value_boolean (ecma_get_completion_value_value (compare_result)));
 
-    res = compare_result.u.value.value;
+    res = ecma_get_completion_value_value (compare_result).value;
   }
 
   ret_value = set_variable_value (int_data, dst_var_idx, ecma_make_simple_value (res));
@@ -89,22 +89,22 @@ opfunc_greater_than (opcode_t opdata, /**< operation data */
   ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
   ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
   ECMA_TRY_CATCH (compare_result,
-                  ecma_op_abstract_relational_compare (right_value.u.value,
-                                                       left_value.u.value,
+                  ecma_op_abstract_relational_compare (ecma_get_completion_value_value (right_value),
+                                                       ecma_get_completion_value_value (left_value),
                                                        false),
                   ret_value);
 
   ecma_simple_value_t res;
 
-  if (ecma_is_value_undefined (compare_result.u.value))
+  if (ecma_is_value_undefined (ecma_get_completion_value_value (compare_result)))
   {
     res = ECMA_SIMPLE_VALUE_FALSE;
   }
   else
   {
-    JERRY_ASSERT (ecma_is_value_boolean (compare_result.u.value));
+    JERRY_ASSERT (ecma_is_value_boolean (ecma_get_completion_value_value (compare_result)));
 
-    res = compare_result.u.value.value;
+    res = ecma_get_completion_value_value (compare_result).value;
   }
 
   ret_value = set_variable_value (int_data, dst_var_idx, ecma_make_simple_value (res));
@@ -139,22 +139,22 @@ opfunc_less_or_equal_than (opcode_t opdata, /**< operation data */
   ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
   ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
   ECMA_TRY_CATCH (compare_result,
-                  ecma_op_abstract_relational_compare (right_value.u.value,
-                                                       left_value.u.value,
+                  ecma_op_abstract_relational_compare (ecma_get_completion_value_value (right_value),
+                                                       ecma_get_completion_value_value (left_value),
                                                        false),
                   ret_value);
 
   ecma_simple_value_t res;
 
-  if (ecma_is_value_undefined (compare_result.u.value))
+  if (ecma_is_value_undefined (ecma_get_completion_value_value (compare_result)))
   {
     res = ECMA_SIMPLE_VALUE_FALSE;
   }
   else
   {
-    JERRY_ASSERT (ecma_is_value_boolean (compare_result.u.value));
+    JERRY_ASSERT (ecma_is_value_boolean (ecma_get_completion_value_value (compare_result)));
 
-    if (compare_result.u.value.value == ECMA_SIMPLE_VALUE_TRUE)
+    if (ecma_get_completion_value_value (compare_result).value == ECMA_SIMPLE_VALUE_TRUE)
     {
       res = ECMA_SIMPLE_VALUE_FALSE;
     }
@@ -196,22 +196,22 @@ opfunc_greater_or_equal_than (opcode_t opdata, /**< operation data */
   ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
   ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
   ECMA_TRY_CATCH (compare_result,
-                  ecma_op_abstract_relational_compare (left_value.u.value,
-                                                       right_value.u.value,
+                  ecma_op_abstract_relational_compare (ecma_get_completion_value_value (left_value),
+                                                       ecma_get_completion_value_value (right_value),
                                                        true),
                   ret_value);
 
   ecma_simple_value_t res;
 
-  if (ecma_is_value_undefined (compare_result.u.value))
+  if (ecma_is_value_undefined (ecma_get_completion_value_value (compare_result)))
   {
     res = ECMA_SIMPLE_VALUE_FALSE;
   }
   else
   {
-    JERRY_ASSERT (ecma_is_value_boolean (compare_result.u.value));
+    JERRY_ASSERT (ecma_is_value_boolean (ecma_get_completion_value_value (compare_result)));
 
-    if (compare_result.u.value.value == ECMA_SIMPLE_VALUE_TRUE)
+    if (ecma_get_completion_value_value (compare_result).value == ECMA_SIMPLE_VALUE_TRUE)
     {
       res = ECMA_SIMPLE_VALUE_FALSE;
     }
@@ -253,20 +253,20 @@ opfunc_instanceof (opcode_t opdata __unused, /**< operation data */
   ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
   ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
 
-  if (!ecma_is_value_object (right_value.u.value))
+  if (!ecma_is_value_object (ecma_get_completion_value_value (right_value)))
   {
     ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
   }
   else
   {
-    ecma_object_t *right_value_obj_p = ECMA_GET_NON_NULL_POINTER (right_value.u.value.value);
+    ecma_object_t *right_value_obj_p = ecma_get_object_from_completion_value (right_value);
 
     ECMA_TRY_CATCH (is_instance_of,
                     ecma_op_object_has_instance (right_value_obj_p,
-                                                 left_value.u.value),
+                                                 ecma_get_completion_value_value (left_value)),
                     ret_value);
 
-    ret_value = set_variable_value (int_data, dst_idx, is_instance_of.u.value);
+    ret_value = set_variable_value (int_data, dst_idx, ecma_get_completion_value_value (is_instance_of));
 
     ECMA_FINALIZE (is_instance_of);
   }
@@ -300,17 +300,17 @@ opfunc_in (opcode_t opdata __unused, /**< operation data */
   ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
   ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
 
-  if (!ecma_is_value_object (right_value.u.value))
+  if (!ecma_is_value_object (ecma_get_completion_value_value (right_value)))
   {
     ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
   }
   else
   {
-    ECMA_TRY_CATCH (str_left_value, ecma_op_to_string (left_value.u.value), ret_value);
+    ECMA_TRY_CATCH (str_left_value, ecma_op_to_string (ecma_get_completion_value_value (left_value)), ret_value);
 
     ecma_simple_value_t is_in = ECMA_SIMPLE_VALUE_UNDEFINED;
-    ecma_string_t *left_value_prop_name_p = ECMA_GET_NON_NULL_POINTER (str_left_value.u.value.value);
-    ecma_object_t *right_value_obj_p = ECMA_GET_NON_NULL_POINTER (right_value.u.value.value);
+    ecma_string_t *left_value_prop_name_p = ecma_get_string_from_completion_value (str_left_value);
+    ecma_object_t *right_value_obj_p = ecma_get_object_from_completion_value (right_value);
 
     if (ecma_op_object_has_property (right_value_obj_p, left_value_prop_name_p))
     {
diff --git a/src/libcoreint/opcodes-ecma-try-catch-finally.c b/src/libcoreint/opcodes-ecma-try-catch-finally.c
index 0f3e6e5f2..4f97b6213 100644
--- a/src/libcoreint/opcodes-ecma-try-catch-finally.c
+++ b/src/libcoreint/opcodes-ecma-try-catch-finally.c
@@ -73,7 +73,7 @@ opfunc_try (opcode_t opdata, /**< operation data */
       JERRY_ASSERT (ecma_is_completion_value_empty (completion));
       completion = ecma_op_set_mutable_binding (catch_env_p,
                                                 catch_exc_var_name_str_p,
-                                                try_completion.u.value,
+                                                ecma_get_completion_value_value (try_completion),
                                                 false);
       JERRY_ASSERT (ecma_is_completion_value_empty (completion));
 
diff --git a/src/libcoreint/opcodes-native-call.c b/src/libcoreint/opcodes-native-call.c
index 9de8d1aca..41d992a8e 100644
--- a/src/libcoreint/opcodes-native-call.c
+++ b/src/libcoreint/opcodes-native-call.c
@@ -123,7 +123,7 @@ opfunc_native_call (opcode_t opdata, /**< operation data */
                         ecma_op_to_string (arg_values[0]),
                         ret_value);
 
-        ecma_string_t *str_p = ECMA_GET_NON_NULL_POINTER (str_value.u.value.value);
+        ecma_string_t *str_p = ecma_get_string_from_completion_value (str_value);
 
         int32_t chars = ecma_string_get_length (str_p);
         JERRY_ASSERT (chars >= 0);
diff --git a/src/libcoreint/opcodes-varg.c b/src/libcoreint/opcodes-varg.c
index fa8ff4078..2c909bb1c 100644
--- a/src/libcoreint/opcodes-varg.c
+++ b/src/libcoreint/opcodes-varg.c
@@ -54,7 +54,7 @@ fill_varg_list (int_data_t *int_data, /**< interpreter context */
 
       if (ecma_is_completion_value_normal (get_arg_completion))
       {
-        arg_values[arg_index] = get_arg_completion.u.value;
+        arg_values[arg_index] = ecma_get_completion_value_value (get_arg_completion);
       }
       else
       {
diff --git a/src/libcoreint/opcodes.c b/src/libcoreint/opcodes.c
index 53267936f..85489e37a 100644
--- a/src/libcoreint/opcodes.c
+++ b/src/libcoreint/opcodes.c
@@ -141,9 +141,10 @@ opfunc_assignment (opcode_t opdata, /**< operation data */
   {
     JERRY_ASSERT (ecma_is_completion_value_normal (get_value_completion));
 
+    ecma_value_t value_to_assign = ecma_get_completion_value_value (get_value_completion);
     ecma_completion_value_t assignment_completion_value = set_variable_value (int_data,
                                                                               dst_var_idx,
-                                                                              get_value_completion.u.value);
+                                                                              value_to_assign);
 
     ecma_free_completion_value (get_value_completion);
 
@@ -172,12 +173,12 @@ opfunc_pre_incr (opcode_t opdata, /**< operation data */
 
   // 1., 2., 3.
   ECMA_TRY_CATCH (old_value, get_variable_value (int_data, incr_var_idx, true), ret_value);
-  ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (old_value.u.value), ret_value);
+  ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (ecma_get_completion_value_value (old_value)), ret_value);
 
   // 4.
   ecma_number_t* new_num_p = ecma_alloc_number ();
 
-  ecma_number_t* old_num_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (old_num_value.u.value.value);
+  ecma_number_t* old_num_p = ecma_get_number_from_completion_value (old_num_value);
   *new_num_p = ecma_number_add (*old_num_p, ECMA_NUMBER_ONE);
 
   ecma_value_t new_num_value = ecma_make_number_value (new_num_p);
@@ -222,12 +223,12 @@ opfunc_pre_decr (opcode_t opdata, /**< operation data */
 
   // 1., 2., 3.
   ECMA_TRY_CATCH (old_value, get_variable_value (int_data, decr_var_idx, true), ret_value);
-  ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (old_value.u.value), ret_value);
+  ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (ecma_get_completion_value_value (old_value)), ret_value);
 
   // 4.
   ecma_number_t* new_num_p = ecma_alloc_number ();
 
-  ecma_number_t* old_num_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (old_num_value.u.value.value);
+  ecma_number_t* old_num_p = ecma_get_number_from_completion_value (old_num_value);
   *new_num_p = ecma_number_substract (*old_num_p, ECMA_NUMBER_ONE);
 
   ecma_value_t new_num_value = ecma_make_number_value (new_num_p);
@@ -272,12 +273,12 @@ opfunc_post_incr (opcode_t opdata, /**< operation data */
 
   // 1., 2., 3.
   ECMA_TRY_CATCH (old_value, get_variable_value (int_data, incr_var_idx, true), ret_value);
-  ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (old_value.u.value), ret_value);
+  ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (ecma_get_completion_value_value (old_value)), ret_value);
 
   // 4.
   ecma_number_t* new_num_p = ecma_alloc_number ();
 
-  ecma_number_t* old_num_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (old_num_value.u.value.value);
+  ecma_number_t* old_num_p = ecma_get_number_from_completion_value (old_num_value);
   *new_num_p = ecma_number_add (*old_num_p, ECMA_NUMBER_ONE);
 
   // 5.
@@ -290,7 +291,7 @@ opfunc_post_incr (opcode_t opdata, /**< operation data */
   // assignment of operator result to register variable
   ecma_completion_value_t reg_assignment_res = set_variable_value (int_data,
                                                                    dst_var_idx,
-                                                                   old_num_value.u.value);
+                                                                   ecma_get_completion_value_value (old_num_value));
   JERRY_ASSERT (ecma_is_completion_value_empty (reg_assignment_res));
 
   ECMA_FINALIZE (old_num_value);
@@ -320,12 +321,12 @@ opfunc_post_decr (opcode_t opdata, /**< operation data */
 
   // 1., 2., 3.
   ECMA_TRY_CATCH (old_value, get_variable_value (int_data, decr_var_idx, true), ret_value);
-  ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (old_value.u.value), ret_value);
+  ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (ecma_get_completion_value_value (old_value)), ret_value);
 
   // 4.
   ecma_number_t* new_num_p = ecma_alloc_number ();
 
-  ecma_number_t* old_num_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (old_num_value.u.value.value);
+  ecma_number_t* old_num_p = ecma_get_number_from_completion_value (old_num_value);
   *new_num_p = ecma_number_substract (*old_num_p, ECMA_NUMBER_ONE);
 
   // 5.
@@ -338,7 +339,7 @@ opfunc_post_decr (opcode_t opdata, /**< operation data */
   // assignment of operator result to register variable
   ecma_completion_value_t reg_assignment_res = set_variable_value (int_data,
                                                                    dst_var_idx,
-                                                                   old_num_value.u.value);
+                                                                   ecma_get_completion_value_value (old_num_value));
   JERRY_ASSERT (ecma_is_completion_value_empty (reg_assignment_res));
 
   ECMA_FINALIZE (old_num_value);
@@ -629,19 +630,24 @@ opfunc_call_n (opcode_t opdata, /**< operation data */
     }
     JERRY_ASSERT (ecma_is_completion_value_normal (this_value));
 
-    if (!ecma_op_is_callable (func_value.u.value))
+    if (!ecma_op_is_callable (ecma_get_completion_value_value (func_value)))
     {
       ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
     }
     else
     {
-      ecma_object_t *func_obj_p = ECMA_GET_NON_NULL_POINTER (func_value.u.value.value);
+      ecma_object_t *func_obj_p = ecma_get_object_from_completion_value (func_value);
 
       ECMA_TRY_CATCH (call_completion,
-                      ecma_op_function_call (func_obj_p, this_value.u.value, arg_values, args_number),
+                      ecma_op_function_call (func_obj_p,
+                                             ecma_get_completion_value_value (this_value),
+                                             arg_values,
+                                             args_number),
                       ret_value);
 
-      ret_value = set_variable_value (int_data, lhs_var_idx, call_completion.u.value);
+      ret_value = set_variable_value (int_data,
+                                      lhs_var_idx,
+                                      ecma_get_completion_value_value (call_completion));
 
       ECMA_FINALIZE (call_completion);
 
@@ -701,13 +707,13 @@ opfunc_construct_n (opcode_t opdata, /**< operation data */
   {
     JERRY_ASSERT (args_read == args_number);
 
-    if (!ecma_is_constructor (constructor_value.u.value))
+    if (!ecma_is_constructor (ecma_get_completion_value_value (constructor_value)))
     {
       ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
     }
     else
     {
-      ecma_object_t *constructor_obj_p = ECMA_GET_NON_NULL_POINTER (constructor_value.u.value.value);
+      ecma_object_t *constructor_obj_p = ecma_get_object_from_completion_value (constructor_value);
 
       ECMA_TRY_CATCH (construction_completion,
                       ecma_op_function_construct (constructor_obj_p,
@@ -715,7 +721,7 @@ opfunc_construct_n (opcode_t opdata, /**< operation data */
                                                   args_number),
                       ret_value);
 
-      ret_value = set_variable_value (int_data, lhs_var_idx, construction_completion.u.value);
+      ret_value = set_variable_value (int_data, lhs_var_idx, ecma_get_completion_value_value (construction_completion));
 
       ECMA_FINALIZE (construction_completion);
     }
@@ -778,7 +784,7 @@ opfunc_array_decl (opcode_t opdata, /**< operation data */
 
     ret_value = set_variable_value (int_data,
                                     lhs_var_idx,
-                                    array_obj_value.u.value);
+                                    ecma_get_completion_value_value (array_obj_value));
 
     ECMA_FINALIZE (array_obj_value);
   }
@@ -856,12 +862,12 @@ opfunc_obj_decl (opcode_t opdata, /**< operation data */
                                             false),
                         ret_value);
         ECMA_TRY_CATCH (prop_name_str_value,
-                        ecma_op_to_string (prop_name_value.u.value),
+                        ecma_op_to_string (ecma_get_completion_value_value (prop_name_value)),
                         ret_value);
 
         bool is_throw_syntax_error = false;
 
-        ecma_string_t *prop_name_string_p = ECMA_GET_NON_NULL_POINTER (prop_name_str_value.u.value.value);
+        ecma_string_t *prop_name_string_p = ecma_get_string_from_completion_value (prop_name_str_value);
         ecma_property_t *previous_p = ecma_op_object_get_own_property (obj_p, prop_name_string_p);
 
         const bool is_previous_undefined = (previous_p == NULL);
@@ -883,7 +889,7 @@ opfunc_obj_decl (opcode_t opdata, /**< operation data */
         if (type == OPCODE_META_TYPE_VARG_PROP_DATA)
         {
           prop_desc.is_value_defined = true;
-          prop_desc.value = value_for_prop_desc.u.value;
+          prop_desc.value = ecma_get_completion_value_value (value_for_prop_desc);
           
           prop_desc.is_writable_defined = true;
           prop_desc.writable = ECMA_PROPERTY_WRITABLE;
@@ -898,10 +904,8 @@ opfunc_obj_decl (opcode_t opdata, /**< operation data */
         }
         else if (type == OPCODE_META_TYPE_VARG_PROP_GETTER)
         {
-          JERRY_ASSERT (ecma_is_value_object (value_for_prop_desc.u.value));
-
           prop_desc.is_get_defined = true;
-          prop_desc.get_p = ECMA_GET_NON_NULL_POINTER (value_for_prop_desc.u.value.value);
+          prop_desc.get_p = ecma_get_object_from_completion_value (value_for_prop_desc);
 
           if (!is_previous_undefined
               && is_previous_data_desc)
@@ -911,10 +915,8 @@ opfunc_obj_decl (opcode_t opdata, /**< operation data */
         }
         else
         {
-          JERRY_ASSERT (ecma_is_value_object (value_for_prop_desc.u.value));
-
           prop_desc.is_set_defined = true;
-          prop_desc.set_p = ECMA_GET_NON_NULL_POINTER (value_for_prop_desc.u.value.value);
+          prop_desc.set_p = ecma_get_object_from_completion_value (value_for_prop_desc);
 
           if (!is_previous_undefined
               && is_previous_data_desc)
@@ -1003,7 +1005,7 @@ opfunc_retval (opcode_t opdata __unused, /**< operation data */
 
   ECMA_TRY_CATCH (expr_val, get_variable_value (int_data, opdata.data.retval.ret_value, false), ret_value);
 
-  ret_value = ecma_make_return_completion_value (ecma_copy_value (expr_val.u.value, true));
+  ret_value = ecma_make_return_completion_value (ecma_copy_value (ecma_get_completion_value_value (expr_val), true));
 
   ECMA_FINALIZE (expr_val);
 
@@ -1031,19 +1033,27 @@ opfunc_prop_getter (opcode_t opdata __unused, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  ECMA_TRY_CATCH (base_value, get_variable_value (int_data, base_var_idx, false), ret_value);
-  ECMA_TRY_CATCH (prop_name_value, get_variable_value (int_data, prop_name_var_idx, false), ret_value);
-  ECMA_TRY_CATCH (check_coercible_ret, ecma_op_check_object_coercible (base_value.u.value), ret_value);
-  ECMA_TRY_CATCH (prop_name_str_value, ecma_op_to_string (prop_name_value.u.value), ret_value);
+  ECMA_TRY_CATCH (base_value,
+                  get_variable_value (int_data, base_var_idx, false),
+                  ret_value);
+  ECMA_TRY_CATCH (prop_name_value,
+                  get_variable_value (int_data, prop_name_var_idx, false),
+                  ret_value);
+  ECMA_TRY_CATCH (check_coercible_ret,
+                  ecma_op_check_object_coercible (ecma_get_completion_value_value (base_value)),
+                  ret_value);
+  ECMA_TRY_CATCH (prop_name_str_value,
+                  ecma_op_to_string (ecma_get_completion_value_value (prop_name_value)),
+                  ret_value);
 
-  ecma_string_t *prop_name_string_p = ECMA_GET_NON_NULL_POINTER (prop_name_str_value.u.value.value);
-  ecma_reference_t ref = ecma_make_reference (base_value.u.value,
+  ecma_string_t *prop_name_string_p = ecma_get_string_from_completion_value (prop_name_str_value);
+  ecma_reference_t ref = ecma_make_reference (ecma_get_completion_value_value (base_value),
                                               prop_name_string_p,
                                               int_data->is_strict);
 
   ECMA_TRY_CATCH (prop_value, ecma_op_get_value_object_base (ref), ret_value);
 
-  ret_value = set_variable_value (int_data, lhs_var_idx, prop_value.u.value);
+  ret_value = set_variable_value (int_data, lhs_var_idx, ecma_get_completion_value_value (prop_value));
 
   ECMA_FINALIZE (prop_value);
 
@@ -1078,18 +1088,26 @@ opfunc_prop_setter (opcode_t opdata __unused, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  ECMA_TRY_CATCH (base_value, get_variable_value (int_data, base_var_idx, false), ret_value);
-  ECMA_TRY_CATCH (prop_name_value, get_variable_value (int_data, prop_name_var_idx, false), ret_value);
-  ECMA_TRY_CATCH (check_coercible_ret, ecma_op_check_object_coercible (base_value.u.value), ret_value);
-  ECMA_TRY_CATCH (prop_name_str_value, ecma_op_to_string (prop_name_value.u.value), ret_value);
+  ECMA_TRY_CATCH (base_value,
+                  get_variable_value (int_data, base_var_idx, false),
+                  ret_value);
+  ECMA_TRY_CATCH (prop_name_value,
+                  get_variable_value (int_data, prop_name_var_idx, false),
+                  ret_value);
+  ECMA_TRY_CATCH (check_coercible_ret,
+                  ecma_op_check_object_coercible (ecma_get_completion_value_value (base_value)),
+                  ret_value);
+  ECMA_TRY_CATCH (prop_name_str_value,
+                  ecma_op_to_string (ecma_get_completion_value_value (prop_name_value)),
+                  ret_value);
 
-  ecma_string_t *prop_name_string_p = ECMA_GET_NON_NULL_POINTER (prop_name_str_value.u.value.value);
-  ecma_reference_t ref = ecma_make_reference (base_value.u.value,
+  ecma_string_t *prop_name_string_p = ecma_get_string_from_completion_value (prop_name_str_value);
+  ecma_reference_t ref = ecma_make_reference (ecma_get_completion_value_value (base_value),
                                               prop_name_string_p,
                                               int_data->is_strict);
 
   ECMA_TRY_CATCH (rhs_value, get_variable_value (int_data, rhs_var_idx, false), ret_value);
-  ret_value = ecma_op_put_value_object_base (ref, rhs_value.u.value);
+  ret_value = ecma_op_put_value_object_base (ref, ecma_get_completion_value_value (rhs_value));
   ECMA_FINALIZE (rhs_value);
 
   ecma_free_reference (ref);
@@ -1147,9 +1165,9 @@ opfunc_logical_not (opcode_t opdata, /**< operation data */
   ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
 
   ecma_simple_value_t old_value = ECMA_SIMPLE_VALUE_TRUE;
-  ecma_completion_value_t to_bool_value = ecma_op_to_boolean (right_value.u.value);
+  ecma_completion_value_t to_bool_value = ecma_op_to_boolean (ecma_get_completion_value_value (right_value));
 
-  if (ecma_is_value_true (to_bool_value.u.value))
+  if (ecma_is_value_true (ecma_get_completion_value_value (to_bool_value)))
   {
     old_value = ECMA_SIMPLE_VALUE_FALSE;
   }
@@ -1212,10 +1230,10 @@ opfunc_with (opcode_t opdata, /**< operation data */
                                       false),
                   ret_value);
   ECMA_TRY_CATCH (obj_expr_value,
-                  ecma_op_to_object (expr_value.u.value),
+                  ecma_op_to_object (ecma_get_completion_value_value (expr_value)),
                   ret_value);
 
-  ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER (obj_expr_value.u.value.value);
+  ecma_object_t *obj_p = ecma_get_object_from_completion_value (obj_expr_value);
 
   ecma_object_t *old_env_p = int_data->lex_env_p;
   ecma_object_t *new_env_p = ecma_create_object_lex_env (old_env_p,
@@ -1276,7 +1294,7 @@ opfunc_throw (opcode_t opdata, /**< operation data */
                                       false),
                   ret_value);
 
-  ret_value = ecma_make_throw_completion_value (ecma_copy_value (var_value.u.value, true));
+  ret_value = ecma_make_throw_completion_value (ecma_copy_value (ecma_get_completion_value_value (var_value), true));
 
   ECMA_FINALIZE (var_value);
 
@@ -1352,7 +1370,7 @@ opfunc_typeof (opcode_t opdata, /**< operation data */
                                            obj_var_idx),
                   ret_value);
 
-  ecma_value_t typeof_arg = typeof_evaluate_arg_completion.u.value;
+  ecma_value_t typeof_arg = ecma_get_completion_value_value (typeof_evaluate_arg_completion);
 
   ecma_string_t *type_str_p = NULL;
 
@@ -1450,7 +1468,7 @@ opfunc_delete_var (opcode_t opdata, /**< operation data */
                                               ECMA_GET_NON_NULL_POINTER (ref.referenced_name_cp)),
                       ret_value);
 
-      ret_value = set_variable_value (int_data, dst_var_idx, delete_completion.u.value);
+      ret_value = set_variable_value (int_data, dst_var_idx, ecma_get_completion_value_value (delete_completion));
 
       ECMA_FINALIZE (delete_completion);
     }
@@ -1484,15 +1502,23 @@ opfunc_delete_prop (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  ECMA_TRY_CATCH (base_value, get_variable_value (int_data, base_var_idx, false), ret_value);
-  ECMA_TRY_CATCH (name_value, get_variable_value (int_data, name_var_idx, false), ret_value);
-  ECMA_TRY_CATCH (check_coercible_ret, ecma_op_check_object_coercible (base_value.u.value), ret_value);
-  ECMA_TRY_CATCH (str_name_value, ecma_op_to_string (name_value.u.value), ret_value);
+  ECMA_TRY_CATCH (base_value,
+                  get_variable_value (int_data, base_var_idx, false),
+                  ret_value);
+  ECMA_TRY_CATCH (name_value,
+                  get_variable_value (int_data, name_var_idx, false),
+                  ret_value);
+  ECMA_TRY_CATCH (check_coercible_ret,
+                  ecma_op_check_object_coercible (ecma_get_completion_value_value (base_value)),
+                  ret_value);
+  ECMA_TRY_CATCH (str_name_value,
+                  ecma_op_to_string (ecma_get_completion_value_value (name_value)),
+                  ret_value);
 
-  JERRY_ASSERT (ecma_is_value_string (str_name_value.u.value));
-  ecma_string_t *name_string_p = ECMA_GET_NON_NULL_POINTER (str_name_value.u.value.value);
+  JERRY_ASSERT (ecma_is_value_string (ecma_get_completion_value_value (str_name_value)));
+  ecma_string_t *name_string_p = ecma_get_string_from_completion_value (str_name_value);
 
-  if (ecma_is_value_undefined (base_value.u.value))
+  if (ecma_is_value_undefined (ecma_get_completion_value_value (base_value)))
   {
     if (int_data->is_strict)
     {
@@ -1506,17 +1532,17 @@ opfunc_delete_prop (opcode_t opdata, /**< operation data */
   }
   else
   {
-    ECMA_TRY_CATCH (obj_value, ecma_op_to_object (base_value.u.value), ret_value);
+    ECMA_TRY_CATCH (obj_value, ecma_op_to_object (ecma_get_completion_value_value (base_value)), ret_value);
 
-    JERRY_ASSERT (ecma_is_value_object (obj_value.u.value));
-    ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER (obj_value.u.value.value);
+    JERRY_ASSERT (ecma_is_value_object (ecma_get_completion_value_value (obj_value)));
+    ecma_object_t *obj_p = ecma_get_object_from_completion_value (obj_value);
     JERRY_ASSERT (!ecma_is_lexical_environment (obj_p));
 
     ECMA_TRY_CATCH (delete_op_completion,
                     ecma_op_object_delete (obj_p, name_string_p, int_data->is_strict),
                     ret_value);
 
-    ret_value = set_variable_value (int_data, dst_var_idx, delete_op_completion.u.value);
+    ret_value = set_variable_value (int_data, dst_var_idx, ecma_get_completion_value_value (delete_op_completion));
 
     ECMA_FINALIZE (delete_op_completion);
     ECMA_FINALIZE (obj_value);
diff --git a/src/libecmabuiltins/ecma-builtin-error-prototype.c b/src/libecmabuiltins/ecma-builtin-error-prototype.c
index 80db82d24..addabc74e 100644
--- a/src/libecmabuiltins/ecma-builtin-error-prototype.c
+++ b/src/libecmabuiltins/ecma-builtin-error-prototype.c
@@ -82,7 +82,7 @@ ecma_builtin_error_prototype_object_to_string (ecma_value_t this) /**< this argu
     }
     else
     {
-      name_to_str_completion = ecma_op_to_string (name_get_completion.u.value);
+      name_to_str_completion = ecma_op_to_string (ecma_get_completion_value_value (name_get_completion));
     }
 
     if (unlikely (!ecma_is_completion_value_normal (name_to_str_completion)))
@@ -107,7 +107,7 @@ ecma_builtin_error_prototype_object_to_string (ecma_value_t this) /**< this argu
       }
       else
       {
-        msg_to_str_completion = ecma_op_to_string (msg_get_completion.u.value);
+        msg_to_str_completion = ecma_op_to_string (ecma_get_completion_value_value (msg_get_completion));
       }
 
       if (unlikely (!ecma_is_completion_value_normal (msg_to_str_completion)))
@@ -116,11 +116,11 @@ ecma_builtin_error_prototype_object_to_string (ecma_value_t this) /**< this argu
       }
       else
       {
-        JERRY_ASSERT (ecma_is_value_string (name_to_str_completion.u.value));
-        JERRY_ASSERT (ecma_is_value_string (msg_to_str_completion.u.value));
+        JERRY_ASSERT (ecma_is_value_string (ecma_get_completion_value_value (name_to_str_completion)));
+        JERRY_ASSERT (ecma_is_value_string (ecma_get_completion_value_value (msg_to_str_completion)));
 
-        ecma_string_t *name_string_p = ECMA_GET_NON_NULL_POINTER (name_to_str_completion.u.value.value);
-        ecma_string_t *msg_string_p = ECMA_GET_NON_NULL_POINTER (msg_to_str_completion.u.value.value);
+        ecma_string_t *name_string_p = ecma_get_string_from_completion_value (name_to_str_completion);
+        ecma_string_t *msg_string_p = ecma_get_string_from_completion_value (msg_to_str_completion);
 
         ecma_string_t *ret_str_p;
         
diff --git a/src/libecmabuiltins/ecma-builtin-error.c b/src/libecmabuiltins/ecma-builtin-error.c
index 944f9ec39..7567adb18 100644
--- a/src/libecmabuiltins/ecma-builtin-error.c
+++ b/src/libecmabuiltins/ecma-builtin-error.c
@@ -63,7 +63,7 @@ ecma_builtin_error_dispatch_call (ecma_value_t *arguments_list_p, /**< arguments
                     ecma_op_to_string (arguments_list_p[0]),
                     ret_value);
 
-    ecma_string_t *message_string_p = ECMA_GET_NON_NULL_POINTER (msg_to_str_completion.u.value.value);
+    ecma_string_t *message_string_p = ecma_get_string_from_completion_value (msg_to_str_completion);
     ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_COMMON,
                                                                               message_string_p);
     ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
diff --git a/src/libecmabuiltins/ecma-builtin-evalerror.c b/src/libecmabuiltins/ecma-builtin-evalerror.c
index 98ee87e6c..2663ad549 100644
--- a/src/libecmabuiltins/ecma-builtin-evalerror.c
+++ b/src/libecmabuiltins/ecma-builtin-evalerror.c
@@ -63,7 +63,7 @@ ecma_builtin_eval_error_dispatch_call (ecma_value_t *arguments_list_p, /**< argu
                     ecma_op_to_string (arguments_list_p[0]),
                     ret_value);
 
-    ecma_string_t *message_string_p = ECMA_GET_NON_NULL_POINTER (msg_to_str_completion.u.value.value);
+    ecma_string_t *message_string_p = ecma_get_string_from_completion_value (msg_to_str_completion);
     ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_EVAL,
                                                                               message_string_p);
     ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
diff --git a/src/libecmabuiltins/ecma-builtin-global.c b/src/libecmabuiltins/ecma-builtin-global.c
index 5fc8abd16..bc13c14da 100644
--- a/src/libecmabuiltins/ecma-builtin-global.c
+++ b/src/libecmabuiltins/ecma-builtin-global.c
@@ -105,7 +105,7 @@ ecma_builtin_global_object_is_nan (ecma_value_t this_arg __unused, /**< this arg
 
   ECMA_TRY_CATCH (num_value, ecma_op_to_number (arg), ret_value);
 
-  ecma_number_t *num_p = ECMA_GET_NON_NULL_POINTER (num_value.u.value.value);
+  ecma_number_t *num_p = ecma_get_number_from_completion_value (num_value);
 
   bool is_nan = ecma_number_is_nan (*num_p);
 
@@ -134,7 +134,7 @@ ecma_builtin_global_object_is_finite (ecma_value_t this_arg __unused, /**< this
 
   ECMA_TRY_CATCH (num_value, ecma_op_to_number (arg), ret_value);
 
-  ecma_number_t *num_p = ECMA_GET_NON_NULL_POINTER (num_value.u.value.value);
+  ecma_number_t *num_p = ecma_get_number_from_completion_value (num_value);
 
   bool is_finite = !(ecma_number_is_nan (*num_p)
                      || ecma_number_is_infinity (*num_p));
diff --git a/src/libecmabuiltins/ecma-builtin-math.c b/src/libecmabuiltins/ecma-builtin-math.c
index 375b82822..a58aac898 100644
--- a/src/libecmabuiltins/ecma-builtin-math.c
+++ b/src/libecmabuiltins/ecma-builtin-math.c
@@ -66,7 +66,7 @@ ecma_builtin_math_object_abs (ecma_value_t this_arg __unused, /**< 'this' argume
 
   ecma_number_t *num_p = ecma_alloc_number ();
 
-  const ecma_number_t arg_num = *(ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg_num_value.u.value.value);
+  const ecma_number_t arg_num = *ecma_get_number_from_completion_value (arg_num_value);
 
   if (ecma_number_is_nan (arg_num))
   {
@@ -202,7 +202,7 @@ ecma_builtin_math_object_exp (ecma_value_t this_arg __unused, /**< 'this' argume
 
   ecma_number_t *num_p = ecma_alloc_number ();
 
-  const ecma_number_t arg_num = *(ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg_num_value.u.value.value);
+  const ecma_number_t arg_num = *ecma_get_number_from_completion_value (arg_num_value);
 
   if (ecma_number_is_nan (arg_num))
   {
@@ -272,7 +272,7 @@ ecma_builtin_math_object_log (ecma_value_t this_arg __unused, /**< 'this' argume
 
   ecma_number_t *num_p = ecma_alloc_number ();
 
-  const ecma_number_t arg_num = *(ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg_num_value.u.value.value);
+  const ecma_number_t arg_num = *ecma_get_number_from_completion_value (arg_num_value);
 
   if (ecma_number_is_nan (arg_num))
   {
@@ -332,7 +332,7 @@ ecma_builtin_math_object_max (ecma_value_t this_arg __unused, /**< 'this' argume
 
     if (!is_just_convert)
     {
-      ecma_number_t arg_num = *(ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg_num_value.u.value.value);
+      ecma_number_t arg_num = *ecma_get_number_from_completion_value (arg_num_value);
 
       if (unlikely (ecma_number_is_nan (arg_num)))
       {
@@ -423,7 +423,7 @@ ecma_builtin_math_object_min (ecma_value_t this_arg __unused, /**< 'this' argume
 
     if (!is_just_convert)
     {
-      ecma_number_t arg_num = *(ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg_num_value.u.value.value);
+      ecma_number_t arg_num = *ecma_get_number_from_completion_value (arg_num_value);
 
       if (unlikely (ecma_number_is_nan (arg_num)))
       {
@@ -509,8 +509,8 @@ ecma_builtin_math_object_pow (ecma_value_t this_arg __unused, /**< 'this' argume
 
   ecma_number_t *num_p = ecma_alloc_number ();
 
-  const ecma_number_t x = *(ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg1_num_value.u.value.value);
-  const ecma_number_t y = *(ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg2_num_value.u.value.value);
+  const ecma_number_t x = *ecma_get_number_from_completion_value (arg1_num_value);
+  const ecma_number_t y = *ecma_get_number_from_completion_value (arg2_num_value);
 
   if (ecma_number_is_nan (y)
       || (ecma_number_is_nan (x)
@@ -787,7 +787,7 @@ ecma_builtin_math_object_round (ecma_value_t this_arg __unused, /**< 'this' argu
 
   ecma_number_t *num_p = ecma_alloc_number ();
 
-  const ecma_number_t arg_num = *(ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg_num_value.u.value.value);
+  const ecma_number_t arg_num = *ecma_get_number_from_completion_value (arg_num_value);
 
   if (ecma_number_is_nan (arg_num)
       || ecma_number_is_zero (arg_num)
@@ -859,7 +859,7 @@ ecma_builtin_math_object_sqrt (ecma_value_t this_arg __unused, /**< 'this' argum
                   ecma_op_to_number (arg),
                   ret_value);
 
-  const ecma_number_t arg_num = *(ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg_num_value.u.value.value);
+  const ecma_number_t arg_num = *ecma_get_number_from_completion_value (arg_num_value);
   ecma_number_t ret_num;
 
   if (ecma_number_is_nan (arg_num)
diff --git a/src/libecmabuiltins/ecma-builtin-object-prototype.c b/src/libecmabuiltins/ecma-builtin-object-prototype.c
index 83a4cc7ac..341cbe9d7 100644
--- a/src/libecmabuiltins/ecma-builtin-object-prototype.c
+++ b/src/libecmabuiltins/ecma-builtin-object-prototype.c
@@ -73,9 +73,9 @@ ecma_builtin_object_prototype_object_to_string (ecma_value_t this) /**< this arg
       return obj_this;
     }
 
-    JERRY_ASSERT (ecma_is_value_object (obj_this.u.value));
+    JERRY_ASSERT (ecma_is_value_object (ecma_get_completion_value_value (obj_this)));
 
-    ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER (obj_this.u.value.value);
+    ecma_object_t *obj_p = ecma_get_object_from_completion_value (obj_this);
 
     ecma_property_t *class_prop_p = ecma_get_internal_property (obj_p,
                                                                 ECMA_INTERNAL_PROPERTY_CLASS);
diff --git a/src/libecmabuiltins/ecma-builtin-object.c b/src/libecmabuiltins/ecma-builtin-object.c
index f2b4a2afa..516e62613 100644
--- a/src/libecmabuiltins/ecma-builtin-object.c
+++ b/src/libecmabuiltins/ecma-builtin-object.c
@@ -96,7 +96,7 @@ ecma_builtin_object_dispatch_construct (ecma_value_t *arguments_list_p, /**< arg
     }
     else
     {
-      return ecma_make_normal_completion_value (new_obj_value.u.value);
+      return ecma_make_normal_completion_value (ecma_get_completion_value_value (new_obj_value));
     }
   }
 } /* ecma_builtin_object_dispatch_construct */
@@ -325,7 +325,7 @@ ecma_builtin_object_object_define_property (ecma_value_t this_arg __unused, /**<
                     ecma_op_to_string (arg2),
                     ret_value);
 
-    ecma_string_t *name_str_p = ECMA_GET_NON_NULL_POINTER (name_str_value.u.value.value);
+    ecma_string_t *name_str_p = ecma_get_string_from_completion_value (name_str_value);
 
     ecma_property_descriptor_t prop_desc;
 
diff --git a/src/libecmabuiltins/ecma-builtin-rangeerror.c b/src/libecmabuiltins/ecma-builtin-rangeerror.c
index 395c35919..9842bc3e2 100644
--- a/src/libecmabuiltins/ecma-builtin-rangeerror.c
+++ b/src/libecmabuiltins/ecma-builtin-rangeerror.c
@@ -63,7 +63,7 @@ ecma_builtin_range_error_dispatch_call (ecma_value_t *arguments_list_p, /**< arg
                     ecma_op_to_string (arguments_list_p[0]),
                     ret_value);
 
-    ecma_string_t *message_string_p = ECMA_GET_NON_NULL_POINTER (msg_to_str_completion.u.value.value);
+    ecma_string_t *message_string_p = ecma_get_string_from_completion_value (msg_to_str_completion);
     ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_RANGE,
                                                                               message_string_p);
     ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
diff --git a/src/libecmabuiltins/ecma-builtin-referenceerror.c b/src/libecmabuiltins/ecma-builtin-referenceerror.c
index 11dc94a08..64a424504 100644
--- a/src/libecmabuiltins/ecma-builtin-referenceerror.c
+++ b/src/libecmabuiltins/ecma-builtin-referenceerror.c
@@ -63,7 +63,7 @@ ecma_builtin_reference_error_dispatch_call (ecma_value_t *arguments_list_p, /**<
                     ecma_op_to_string (arguments_list_p[0]),
                     ret_value);
 
-    ecma_string_t *message_string_p = ECMA_GET_NON_NULL_POINTER (msg_to_str_completion.u.value.value);
+    ecma_string_t *message_string_p = ecma_get_string_from_completion_value (msg_to_str_completion);
     ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_REFERENCE,
                                                                               message_string_p);
     ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
diff --git a/src/libecmabuiltins/ecma-builtin-string.c b/src/libecmabuiltins/ecma-builtin-string.c
index e9262e9a7..c315ea959 100644
--- a/src/libecmabuiltins/ecma-builtin-string.c
+++ b/src/libecmabuiltins/ecma-builtin-string.c
@@ -74,8 +74,8 @@ ecma_builtin_string_object_from_char_code (ecma_value_t this_arg __unused, /**<
                     ecma_op_to_number (args[arg_index]),
                     ret_value);
 
-    JERRY_ASSERT (ecma_is_value_number (arg_num_value.u.value));
-    ecma_number_t *arg_num_p = ECMA_GET_NON_NULL_POINTER (arg_num_value.u.value.value);
+    JERRY_ASSERT (ecma_is_value_number (ecma_get_completion_value_value (arg_num_value)));
+    ecma_number_t *arg_num_p = ecma_get_number_from_completion_value (arg_num_value);
 
     uint32_t uint32_char_code = ecma_number_to_uint32 (*arg_num_p);
     uint16_t uint16_char_code = (uint16_t) uint32_char_code;
diff --git a/src/libecmabuiltins/ecma-builtin-syntaxerror.c b/src/libecmabuiltins/ecma-builtin-syntaxerror.c
index 51169a84f..da58b52e5 100644
--- a/src/libecmabuiltins/ecma-builtin-syntaxerror.c
+++ b/src/libecmabuiltins/ecma-builtin-syntaxerror.c
@@ -63,7 +63,7 @@ ecma_builtin_syntax_error_dispatch_call (ecma_value_t *arguments_list_p, /**< ar
                     ecma_op_to_string (arguments_list_p[0]),
                     ret_value);
 
-    ecma_string_t *message_string_p = ECMA_GET_NON_NULL_POINTER (msg_to_str_completion.u.value.value);
+    ecma_string_t *message_string_p = ecma_get_string_from_completion_value (msg_to_str_completion);
     ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_SYNTAX,
                                                                               message_string_p);
     ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
diff --git a/src/libecmabuiltins/ecma-builtin-typeerror.c b/src/libecmabuiltins/ecma-builtin-typeerror.c
index f9e2a2d38..35ce91993 100644
--- a/src/libecmabuiltins/ecma-builtin-typeerror.c
+++ b/src/libecmabuiltins/ecma-builtin-typeerror.c
@@ -63,7 +63,7 @@ ecma_builtin_type_error_dispatch_call (ecma_value_t *arguments_list_p, /**< argu
                     ecma_op_to_string (arguments_list_p[0]),
                     ret_value);
 
-    ecma_string_t *message_string_p = ECMA_GET_NON_NULL_POINTER (msg_to_str_completion.u.value.value);
+    ecma_string_t *message_string_p = ecma_get_string_from_completion_value (msg_to_str_completion);
     ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_TYPE,
                                                                               message_string_p);
     ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
diff --git a/src/libecmabuiltins/ecma-builtin-urierror.c b/src/libecmabuiltins/ecma-builtin-urierror.c
index 111bfae4f..18b96386e 100644
--- a/src/libecmabuiltins/ecma-builtin-urierror.c
+++ b/src/libecmabuiltins/ecma-builtin-urierror.c
@@ -63,7 +63,7 @@ ecma_builtin_uri_error_dispatch_call (ecma_value_t *arguments_list_p, /**< argum
                     ecma_op_to_string (arguments_list_p[0]),
                     ret_value);
 
-    ecma_string_t *message_string_p = ECMA_GET_NON_NULL_POINTER (msg_to_str_completion.u.value.value);
+    ecma_string_t *message_string_p = ecma_get_string_from_completion_value (msg_to_str_completion);
     ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_URI,
                                                                               message_string_p);
     ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
diff --git a/src/libecmaobjects/ecma-helpers-value.c b/src/libecmaobjects/ecma-helpers-value.c
index a408683d6..4a5d84c5a 100644
--- a/src/libecmaobjects/ecma-helpers-value.c
+++ b/src/libecmaobjects/ecma-helpers-value.c
@@ -278,6 +278,45 @@ ecma_make_object_value (ecma_object_t* object_p) /**< object to reference in val
   return object_value;
 } /* ecma_make_object_value */
 
+/**
+ * Get pointer to ecma-number from ecma-value
+ *
+ * @return the pointer
+ */
+ecma_number_t* __attribute_const__
+ecma_get_number_from_value (ecma_value_t value) /**< ecma-value */
+{
+  JERRY_ASSERT (value.value_type == ECMA_TYPE_NUMBER);
+
+  return (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (value.value);
+} /* ecma_get_number_from_value */
+
+/**
+ * Get pointer to ecma-string from ecma-value
+ *
+ * @return the pointer
+ */
+ecma_string_t* __attribute_const__
+ecma_get_string_from_value (ecma_value_t value) /**< ecma-value */
+{
+  JERRY_ASSERT (value.value_type == ECMA_TYPE_STRING);
+
+  return (ecma_string_t*) ECMA_GET_NON_NULL_POINTER (value.value);
+} /* ecma_get_string_from_value */
+
+/**
+ * Get pointer to ecma-object from ecma-value
+ *
+ * @return the pointer
+ */
+ecma_object_t* __attribute_const__
+ecma_get_object_from_value (ecma_value_t value) /**< ecma-value */
+{
+  JERRY_ASSERT (value.value_type == ECMA_TYPE_OBJECT);
+
+  return (ecma_object_t*) ECMA_GET_NON_NULL_POINTER (value.value);
+} /* ecma_get_object_from_value */
+
 /**
  * Copy ecma-value.
  *
@@ -589,6 +628,61 @@ ecma_make_meta_completion_value (void)
                                      ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY));
 } /* ecma_make_meta_completion_value */
 
+/**
+ * Get ecma-value from specified completion value
+ *
+ * @return ecma-value
+ */
+ecma_value_t __attribute_const__
+ecma_get_completion_value_value (ecma_completion_value_t completion_value) /**< completion value */
+{
+  const ecma_completion_type_t type = completion_value.type;
+
+  const bool is_type_ok = (type == ECMA_COMPLETION_TYPE_NORMAL
+#ifdef CONFIG_ECMA_EXCEPTION_SUPPORT
+                           || type == ECMA_COMPLETION_TYPE_THROW
+#endif /* CONFIG_ECMA_EXCEPTION_SUPPORT */
+                           || type == ECMA_COMPLETION_TYPE_RETURN
+                           || type == ECMA_COMPLETION_TYPE_EXIT);
+
+  JERRY_ASSERT (is_type_ok);
+
+  return completion_value.u.value;
+} /* ecma_get_completion_value_value */
+
+/**
+ * Get pointer to ecma-number from completion value
+ *
+ * @return pointer
+ */
+ecma_number_t* __attribute_const__
+ecma_get_number_from_completion_value (ecma_completion_value_t completion_value) /**< completion value */
+{
+  return ecma_get_number_from_value (ecma_get_completion_value_value (completion_value));
+} /* ecma_get_number_from_completion_value */
+
+/**
+ * Get pointer to ecma-string from completion value
+ *
+ * @return pointer
+ */
+ecma_string_t* __attribute_const__
+ecma_get_string_from_completion_value (ecma_completion_value_t completion_value) /**< completion value */
+{
+  return ecma_get_string_from_value (ecma_get_completion_value_value (completion_value));
+} /* ecma_get_string_from_completion_value */
+
+/**
+ * Get pointer to ecma-object from completion value
+ *
+ * @return pointer
+ */
+ecma_object_t* __attribute_const__
+ecma_get_object_from_completion_value (ecma_completion_value_t completion_value) /**< completion value */
+{
+  return ecma_get_object_from_value (ecma_get_completion_value_value (completion_value));
+} /* ecma_get_object_from_completion_value */
+
 /**
  * Copy ecma-completion value.
  *
diff --git a/src/libecmaobjects/ecma-helpers.h b/src/libecmaobjects/ecma-helpers.h
index d87876417..d16dadcd3 100644
--- a/src/libecmaobjects/ecma-helpers.h
+++ b/src/libecmaobjects/ecma-helpers.h
@@ -77,6 +77,9 @@ extern ecma_value_t ecma_make_simple_value (ecma_simple_value_t value);
 extern ecma_value_t ecma_make_number_value (ecma_number_t* num_p);
 extern ecma_value_t ecma_make_string_value (ecma_string_t* ecma_string_p);
 extern ecma_value_t ecma_make_object_value (ecma_object_t* object_p);
+extern ecma_number_t* __attribute_const__ ecma_get_number_from_value (ecma_value_t value);
+extern ecma_string_t* __attribute_const__ ecma_get_string_from_value (ecma_value_t value);
+extern ecma_object_t* __attribute_const__ ecma_get_object_from_value (ecma_value_t value);
 extern ecma_value_t ecma_copy_value (const ecma_value_t value, bool do_ref_if_object);
 extern void ecma_free_value (const ecma_value_t value, bool do_deref_if_object);
 
@@ -93,6 +96,13 @@ extern ecma_completion_value_t ecma_make_empty_completion_value (void);
 extern ecma_completion_value_t ecma_make_return_completion_value (ecma_value_t value);
 extern ecma_completion_value_t ecma_make_exit_completion_value (bool is_successful);
 extern ecma_completion_value_t ecma_make_meta_completion_value (void);
+extern ecma_value_t ecma_get_completion_value_value (ecma_completion_value_t completion_value);
+extern ecma_number_t* __attribute_const__
+ecma_get_number_from_completion_value (ecma_completion_value_t completion_value);
+extern ecma_string_t* __attribute_const__
+ecma_get_string_from_completion_value (ecma_completion_value_t completion_value);
+extern ecma_object_t* __attribute_const__
+ecma_get_object_from_completion_value (ecma_completion_value_t completion_value);
 extern ecma_completion_value_t ecma_copy_completion_value (ecma_completion_value_t value);
 extern void ecma_free_completion_value (ecma_completion_value_t completion_value);
 
diff --git a/src/libecmaoperations/ecma-array-object.c b/src/libecmaoperations/ecma-array-object.c
index e978f2f4b..375d1caa5 100644
--- a/src/libecmaoperations/ecma-array-object.c
+++ b/src/libecmaoperations/ecma-array-object.c
@@ -215,9 +215,9 @@ ecma_op_array_object_define_own_property (ecma_object_t *obj_p, /**< the array o
     }
 
     JERRY_ASSERT (ecma_is_completion_value_normal (completion)
-                  && ecma_is_value_number (completion.u.value));
+                  && ecma_is_value_number (ecma_get_completion_value_value (completion)));
 
-    new_len_num = *(ecma_number_t*) ECMA_GET_NON_NULL_POINTER (completion.u.value.value);
+    new_len_num = *ecma_get_number_from_completion_value (completion);
 
     ecma_free_completion_value (completion);
 
diff --git a/src/libecmaoperations/ecma-boolean-object.c b/src/libecmaoperations/ecma-boolean-object.c
index 07e377b48..17fa72629 100644
--- a/src/libecmaoperations/ecma-boolean-object.c
+++ b/src/libecmaoperations/ecma-boolean-object.c
@@ -48,7 +48,7 @@ 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 = conv_to_boolean_completion.u.value.value;
+  ecma_simple_value_t bool_value = ecma_get_completion_value_value (conv_to_boolean_completion).value;
 
   JERRY_ASSERT (bool_value == ECMA_SIMPLE_VALUE_TRUE || bool_value == ECMA_SIMPLE_VALUE_FALSE);
 
diff --git a/src/libecmaoperations/ecma-comparison.c b/src/libecmaoperations/ecma-comparison.c
index e32aa8e53..a73ef65ce 100644
--- a/src/libecmaoperations/ecma-comparison.c
+++ b/src/libecmaoperations/ecma-comparison.c
@@ -133,7 +133,7 @@ ecma_op_abstract_equality_compare (ecma_value_t x, /**< first operand */
                     ret_value);
 
     ret_value = ecma_op_abstract_equality_compare (x,
-                                                   y_num_value.u.value);
+                                                   ecma_get_completion_value_value (y_num_value));
 
     ECMA_FINALIZE (y_num_value);
   }
@@ -144,7 +144,7 @@ ecma_op_abstract_equality_compare (ecma_value_t x, /**< first operand */
                     ecma_op_to_number (x),
                     ret_value);
 
-    ret_value = ecma_op_abstract_equality_compare (x_num_value.u.value,
+    ret_value = ecma_op_abstract_equality_compare (ecma_get_completion_value_value (x_num_value),
                                                    y);
 
     ECMA_FINALIZE (x_num_value);
@@ -156,7 +156,7 @@ ecma_op_abstract_equality_compare (ecma_value_t x, /**< first operand */
                     ecma_op_to_number (x),
                     ret_value);
 
-    ret_value = ecma_op_abstract_equality_compare (x_num_value.u.value,
+    ret_value = ecma_op_abstract_equality_compare (ecma_get_completion_value_value (x_num_value),
                                                    y);
 
     ECMA_FINALIZE (x_num_value);
@@ -169,7 +169,7 @@ ecma_op_abstract_equality_compare (ecma_value_t x, /**< first operand */
                     ret_value);
 
     ret_value = ecma_op_abstract_equality_compare (x,
-                                                   y_num_value.u.value);
+                                                   ecma_get_completion_value_value (y_num_value));
 
     ECMA_FINALIZE (y_num_value);
   }
@@ -182,7 +182,7 @@ ecma_op_abstract_equality_compare (ecma_value_t x, /**< first operand */
                     ret_value);
 
     ret_value = ecma_op_abstract_equality_compare (x,
-                                                   y_prim_value.u.value);
+                                                   ecma_get_completion_value_value (y_prim_value));
 
     ECMA_FINALIZE (y_prim_value);
   }
@@ -194,7 +194,7 @@ ecma_op_abstract_equality_compare (ecma_value_t x, /**< first operand */
                     ecma_op_to_primitive (x, ECMA_PREFERRED_TYPE_NO),
                     ret_value);
 
-    ret_value = ecma_op_abstract_equality_compare (x_prim_value.u.value,
+    ret_value = ecma_op_abstract_equality_compare (ecma_get_completion_value_value (x_prim_value),
                                                    y);
 
     ECMA_FINALIZE (x_prim_value);
@@ -338,21 +338,21 @@ ecma_op_abstract_relational_compare (ecma_value_t x, /**< first operand */
   px = left_first ? prim_first_converted_value : prim_second_converted_value;
   py = left_first ? prim_second_converted_value : prim_first_converted_value;
 
-  const bool is_px_string = ecma_is_value_string (px.u.value);
-  const bool is_py_string = ecma_is_value_string (py.u.value);
+  const bool is_px_string = ecma_is_value_string (ecma_get_completion_value_value (px));
+  const bool is_py_string = ecma_is_value_string (ecma_get_completion_value_value (py));
 
   if (!(is_px_string && is_py_string))
   {
     // 3.
 
     // a.
-    ECMA_TRY_CATCH(nx, ecma_op_to_number (px.u.value), ret_value);
+    ECMA_TRY_CATCH(nx, ecma_op_to_number (ecma_get_completion_value_value (px)), ret_value);
 
     // b.
-    ECMA_TRY_CATCH(ny, ecma_op_to_number (py.u.value), ret_value);
+    ECMA_TRY_CATCH(ny, ecma_op_to_number (ecma_get_completion_value_value (py)), ret_value);
 
-    ecma_number_t* num_x_p = (ecma_number_t*)ECMA_GET_NON_NULL_POINTER(nx.u.value.value);
-    ecma_number_t* num_y_p = (ecma_number_t*)ECMA_GET_NON_NULL_POINTER(ny.u.value.value);
+    ecma_number_t* num_x_p = ecma_get_number_from_completion_value (nx);
+    ecma_number_t* num_y_p = ecma_get_number_from_completion_value (ny);
 
     if (ecma_number_is_nan (*num_x_p)
         || ecma_number_is_nan (*num_y_p))
@@ -418,8 +418,8 @@ ecma_op_abstract_relational_compare (ecma_value_t x, /**< first operand */
   { // 4.
     JERRY_ASSERT (is_px_string && is_py_string);
 
-    ecma_string_t *str_x_p = ECMA_GET_NON_NULL_POINTER (px.u.value.value);
-    ecma_string_t *str_y_p = ECMA_GET_NON_NULL_POINTER (py.u.value.value);
+    ecma_string_t *str_x_p = ecma_get_string_from_completion_value (px);
+    ecma_string_t *str_y_p = ecma_get_string_from_completion_value (py);
 
     bool is_px_less = ecma_compare_ecma_strings_relational (str_x_p, str_y_p);
 
diff --git a/src/libecmaoperations/ecma-conversion.c b/src/libecmaoperations/ecma-conversion.c
index 8459844bf..8826501b0 100644
--- a/src/libecmaoperations/ecma-conversion.c
+++ b/src/libecmaoperations/ecma-conversion.c
@@ -272,7 +272,7 @@ ecma_op_to_number (ecma_value_t value) /**< ecma-value */
                     ecma_op_to_primitive (value, ECMA_PREFERRED_TYPE_NUMBER),
                     ret_value);
 
-    ret_value = ecma_op_to_number (completion_to_primitive.u.value);
+    ret_value = ecma_op_to_number (ecma_get_completion_value_value (completion_to_primitive));
 
     ECMA_FINALIZE (completion_to_primitive);
 
@@ -330,7 +330,7 @@ ecma_op_to_string (ecma_value_t value) /**< ecma-value */
                     ecma_op_to_primitive (value, ECMA_PREFERRED_TYPE_STRING),
                     ret_value);
 
-    ret_value = ecma_op_to_string (prim_value.u.value);
+    ret_value = ecma_op_to_string (ecma_get_completion_value_value (prim_value));
 
     ECMA_FINALIZE (prim_value);
 
@@ -584,7 +584,7 @@ ecma_op_to_property_descriptor (ecma_value_t obj_value, /**< object value */
                       ecma_op_object_get (obj_p, enumerable_magic_string_p),
                       ret_value);
       ECMA_TRY_CATCH (boolean_enumerable_prop_value,
-                      ecma_op_to_boolean (enumerable_prop_value.u.value),
+                      ecma_op_to_boolean (ecma_get_completion_value_value (enumerable_prop_value)),
                       ret_value);
 
       prop_desc.is_enumerable_defined = true;
@@ -618,7 +618,7 @@ ecma_op_to_property_descriptor (ecma_value_t obj_value, /**< object value */
                         ecma_op_object_get (obj_p, configurable_magic_string_p),
                         ret_value);
         ECMA_TRY_CATCH (boolean_configurable_prop_value,
-                        ecma_op_to_boolean (configurable_prop_value.u.value),
+                        ecma_op_to_boolean (ecma_get_completion_value_value (configurable_prop_value)),
                         ret_value);
 
         prop_desc.is_configurable_defined = true;
@@ -654,7 +654,7 @@ ecma_op_to_property_descriptor (ecma_value_t obj_value, /**< object value */
                         ret_value);
 
         prop_desc.is_value_defined = true;
-        prop_desc.value = ecma_copy_value (value_prop_value.u.value, true);
+        prop_desc.value = ecma_copy_value (ecma_get_completion_value_value (value_prop_value), true);
 
         ECMA_FINALIZE (value_prop_value);
       }
@@ -675,7 +675,7 @@ ecma_op_to_property_descriptor (ecma_value_t obj_value, /**< object value */
                         ecma_op_object_get (obj_p, writable_magic_string_p),
                         ret_value);
         ECMA_TRY_CATCH (boolean_writable_prop_value,
-                        ecma_op_to_boolean (writable_prop_value.u.value),
+                        ecma_op_to_boolean (ecma_get_completion_value_value (writable_prop_value)),
                         ret_value);
 
         prop_desc.is_writable_defined = true;
@@ -710,8 +710,8 @@ ecma_op_to_property_descriptor (ecma_value_t obj_value, /**< object value */
                         ecma_op_object_get (obj_p, get_magic_string_p),
                         ret_value);
 
-        if (!ecma_op_is_callable (get_prop_value.u.value)
-            && !ecma_is_value_undefined (get_prop_value.u.value))
+        if (!ecma_op_is_callable (ecma_get_completion_value_value (get_prop_value))
+            && !ecma_is_value_undefined (ecma_get_completion_value_value (get_prop_value)))
         {
           ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
         }
@@ -719,15 +719,15 @@ ecma_op_to_property_descriptor (ecma_value_t obj_value, /**< object value */
         {
           prop_desc.is_get_defined = true;
 
-          if (ecma_is_value_undefined (get_prop_value.u.value))
+          if (ecma_is_value_undefined (ecma_get_completion_value_value (get_prop_value)))
           {
             prop_desc.get_p = NULL;
           }
           else
           {
-            JERRY_ASSERT (ecma_is_value_object (get_prop_value.u.value));
+            JERRY_ASSERT (ecma_is_value_object (ecma_get_completion_value_value (get_prop_value)));
 
-            ecma_object_t *get_p = ECMA_GET_NON_NULL_POINTER (get_prop_value.u.value.value);
+            ecma_object_t *get_p = ecma_get_object_from_completion_value (get_prop_value);
             ecma_ref_object (get_p);
 
             prop_desc.get_p = get_p;
@@ -754,8 +754,8 @@ ecma_op_to_property_descriptor (ecma_value_t obj_value, /**< object value */
                         ecma_op_object_get (obj_p, set_magic_string_p),
                         ret_value);
 
-        if (!ecma_op_is_callable (set_prop_value.u.value)
-            && !ecma_is_value_undefined (set_prop_value.u.value))
+        if (!ecma_op_is_callable (ecma_get_completion_value_value (set_prop_value))
+            && !ecma_is_value_undefined (ecma_get_completion_value_value (set_prop_value)))
         {
           ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
         }
@@ -763,15 +763,15 @@ ecma_op_to_property_descriptor (ecma_value_t obj_value, /**< object value */
         {
           prop_desc.is_set_defined = true;
 
-          if (ecma_is_value_undefined (set_prop_value.u.value))
+          if (ecma_is_value_undefined (ecma_get_completion_value_value (set_prop_value)))
           {
             prop_desc.set_p = NULL;
           }
           else
           {
-            JERRY_ASSERT (ecma_is_value_object (set_prop_value.u.value));
+            JERRY_ASSERT (ecma_is_value_object (ecma_get_completion_value_value (set_prop_value)));
 
-            ecma_object_t *set_p = ECMA_GET_NON_NULL_POINTER (set_prop_value.u.value.value);
+            ecma_object_t *set_p = ecma_get_object_from_completion_value (set_prop_value);
             ecma_ref_object (set_p);
 
             prop_desc.set_p = set_p;
diff --git a/src/libecmaoperations/ecma-function-object.c b/src/libecmaoperations/ecma-function-object.c
index b7ea0c061..756226cf4 100644
--- a/src/libecmaoperations/ecma-function-object.c
+++ b/src/libecmaoperations/ecma-function-object.c
@@ -406,13 +406,13 @@ ecma_op_function_has_instance (ecma_object_t *func_obj_p, /**< Function object *
                     ecma_op_object_get (func_obj_p, prototype_magic_string_p),
                     ret_value);
 
-    if (!ecma_is_value_object (prototype_obj_value.u.value))
+    if (!ecma_is_value_object (ecma_get_completion_value_value (prototype_obj_value)))
     {
       ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
     }
     else
     {
-      ecma_object_t *prototype_obj_p = ECMA_GET_NON_NULL_POINTER (prototype_obj_value.u.value.value);
+      ecma_object_t *prototype_obj_p = ecma_get_object_from_completion_value (prototype_obj_value);
       JERRY_ASSERT (prototype_obj_p != NULL);
 
       do
@@ -512,7 +512,7 @@ ecma_op_function_call (ecma_object_t *func_obj_p, /**< Function object */
       ecma_completion_value_t completion = ecma_op_to_object (this_arg_value);
       JERRY_ASSERT (ecma_is_completion_value_normal (completion));
 
-      this_binding = completion.u.value;
+      this_binding = ecma_get_completion_value_value (completion);
     }
 
     // 5.
@@ -534,7 +534,7 @@ ecma_op_function_call (ecma_object_t *func_obj_p, /**< Function object */
                                                            false);
     if (ecma_is_completion_value_return (completion))
     {
-      ret_value = ecma_make_normal_completion_value (completion.u.value);
+      ret_value = ecma_make_normal_completion_value (ecma_get_completion_value_value (completion));
     }
     else
     {
@@ -597,9 +597,9 @@ ecma_op_function_construct (ecma_object_t *func_obj_p, /**< Function object */
 
     //  6.
     ecma_object_t *prototype_p;
-    if (ecma_is_value_object (func_obj_prototype_prop_value.u.value))
+    if (ecma_is_value_object (ecma_get_completion_value_value (func_obj_prototype_prop_value)))
     {
-      prototype_p = ECMA_GET_NON_NULL_POINTER (func_obj_prototype_prop_value.u.value.value);
+      prototype_p = ecma_get_object_from_completion_value (func_obj_prototype_prop_value);
       ecma_ref_object (prototype_p);
     }
     else
@@ -628,11 +628,11 @@ ecma_op_function_construct (ecma_object_t *func_obj_p, /**< Function object */
     ecma_value_t obj_value;
 
     // 9.
-    if (ecma_is_value_object (call_completion.u.value))
+    if (ecma_is_value_object (ecma_get_completion_value_value (call_completion)))
     {
       ecma_deref_object (obj_p);
 
-      obj_value = ecma_copy_value (call_completion.u.value, true);
+      obj_value = ecma_copy_value (ecma_get_completion_value_value (call_completion), true);
     }
     else
     {
diff --git a/src/libecmaoperations/ecma-get-put-value.c b/src/libecmaoperations/ecma-get-put-value.c
index 0e35d7567..3c4e7f13e 100644
--- a/src/libecmaoperations/ecma-get-put-value.c
+++ b/src/libecmaoperations/ecma-get-put-value.c
@@ -107,7 +107,7 @@ ecma_op_get_value_object_base (ecma_reference_t ref) /**< ECMA-reference */
 
     ECMA_TRY_CATCH (obj_base, ecma_op_to_object (base), ret_value);
 
-    ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER (obj_base.u.value.value);
+    ecma_object_t *obj_p = ecma_get_object_from_completion_value (obj_base);
     JERRY_ASSERT (obj_p != NULL
                   && !ecma_is_lexical_environment (obj_p));
 
@@ -248,7 +248,7 @@ ecma_op_put_value_object_base (ecma_reference_t ref, /**< ECMA-reference */
     // sub_1.
     ECMA_TRY_CATCH (obj_base, ecma_op_to_object (base), ret_value);
 
-    ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER (obj_base.u.value.value);
+    ecma_object_t *obj_p = ecma_get_object_from_completion_value (obj_base);
     JERRY_ASSERT (obj_p != NULL
                   && !ecma_is_lexical_environment (obj_p));
 
diff --git a/src/libecmaoperations/ecma-number-object.c b/src/libecmaoperations/ecma-number-object.c
index f258988df..a11edf531 100644
--- a/src/libecmaoperations/ecma-number-object.c
+++ b/src/libecmaoperations/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_NON_NULL_POINTER (conv_to_num_completion.u.value.value);
+  ecma_number_t *prim_value_p = ecma_get_number_from_completion_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);
diff --git a/src/libecmaoperations/ecma-objects-arguments.c b/src/libecmaoperations/ecma-objects-arguments.c
index cc786f4fa..ca8bcfc21 100644
--- a/src/libecmaoperations/ecma-objects-arguments.c
+++ b/src/libecmaoperations/ecma-objects-arguments.c
@@ -369,7 +369,7 @@ ecma_op_arguments_object_get_own_property (ecma_object_t *obj_p, /**< the object
     ecma_completion_value_t completion = ecma_arguments_get_mapped_arg_value (map_p, mapped_prop_p);
 
     ecma_free_value (desc_p->u.named_data_property.value, false);
-    desc_p->u.named_data_property.value = ecma_copy_value (completion.u.value, false);
+    desc_p->u.named_data_property.value = ecma_copy_value (ecma_get_completion_value_value (completion), false);
     ecma_gc_update_may_ref_younger_object_flag_by_value (obj_p, desc_p->u.named_data_property.value);
 
     ecma_free_completion_value (completion);
diff --git a/src/libecmaoperations/ecma-objects-general.c b/src/libecmaoperations/ecma-objects-general.c
index 539419345..db9ce0528 100644
--- a/src/libecmaoperations/ecma-objects-general.c
+++ b/src/libecmaoperations/ecma-objects-general.c
@@ -148,20 +148,10 @@ ecma_op_general_object_get (ecma_object_t *obj_p, /**< the object */
     }
     else
     {
-      ecma_completion_value_t ret_value;
-
-      ECMA_TRY_CATCH (call_completion,
-                      ecma_op_function_call (getter_p,
-                                             ecma_make_object_value (obj_p),
-                                             NULL,
-                                             0),
-                      ret_value);
-
-      ret_value = ecma_make_normal_completion_value (ecma_copy_value (call_completion.u.value, true));
-
-      ECMA_FINALIZE (call_completion);
-
-      return ret_value;
+      return ecma_op_function_call (getter_p,
+                                    ecma_make_object_value (obj_p),
+                                    NULL,
+                                    0);
     }
   }
 
@@ -592,9 +582,9 @@ ecma_op_general_object_default_value (ecma_object_t *obj_p, /**< the object */
 
     ecma_completion_value_t call_completion = ecma_make_empty_completion_value ();
 
-    if (ecma_op_is_callable (function_value_get_completion.u.value))
+    if (ecma_op_is_callable (ecma_get_completion_value_value (function_value_get_completion)))
     {
-      ecma_object_t *func_obj_p = ECMA_GET_NON_NULL_POINTER (function_value_get_completion.u.value.value);
+      ecma_object_t *func_obj_p = ecma_get_object_from_completion_value (function_value_get_completion);
 
       call_completion = ecma_op_function_call (func_obj_p,
                                                ecma_make_object_value (obj_p),
@@ -609,7 +599,7 @@ ecma_op_general_object_default_value (ecma_object_t *obj_p, /**< the object */
     }
 
     if (!ecma_is_completion_value_empty (call_completion)
-        && !ecma_is_value_object (call_completion.u.value))
+        && !ecma_is_value_object (ecma_get_completion_value_value (call_completion)))
     {
       return call_completion;
     }
diff --git a/src/libecmaoperations/ecma-string-object.c b/src/libecmaoperations/ecma-string-object.c
index d492a00cc..370f9b1e2 100644
--- a/src/libecmaoperations/ecma-string-object.c
+++ b/src/libecmaoperations/ecma-string-object.c
@@ -67,8 +67,8 @@ ecma_op_create_string_object (ecma_value_t *arguments_list_p, /**< list of argum
     {
       JERRY_ASSERT (ecma_is_completion_value_normal (to_str_arg_value));
 
-      JERRY_ASSERT (ecma_is_value_string (to_str_arg_value.u.value));
-      prim_prop_str_value_p = ECMA_GET_NON_NULL_POINTER (to_str_arg_value.u.value.value);
+      JERRY_ASSERT (ecma_is_value_string (ecma_get_completion_value_value (to_str_arg_value)));
+      prim_prop_str_value_p = ecma_get_string_from_completion_value (to_str_arg_value);
 
       int32_t string_len = ecma_string_get_length (prim_prop_str_value_p);
       JERRY_ASSERT (string_len >= 0);