diff --git a/src/libcoreint/interpreter.c b/src/libcoreint/interpreter.c
index 9bef09dbf..05afa3459 100644
--- a/src/libcoreint/interpreter.c
+++ b/src/libcoreint/interpreter.c
@@ -85,7 +85,7 @@ run_int (void)
       ecma_finalize ();
       ecma_gc_run (ECMA_GC_GEN_COUNT - 1);
 
-      return ecma_is_value_true (completion.value);
+      return ecma_is_value_true (completion.u.value);
     }
     case ECMA_COMPLETION_TYPE_BREAK:
     case ECMA_COMPLETION_TYPE_CONTINUE:
@@ -120,13 +120,8 @@ run_int_loop (int_data_t *int_data)
     }
     while (completion.type == ECMA_COMPLETION_TYPE_NORMAL);
 
-    if (completion.type == ECMA_COMPLETION_TYPE_BREAK)
-    {
-      JERRY_UNIMPLEMENTED ();
-
-      continue;
-    }
-    else if (completion.type == ECMA_COMPLETION_TYPE_CONTINUE)
+    if (completion.type == ECMA_COMPLETION_TYPE_BREAK
+        || completion.type == ECMA_COMPLETION_TYPE_CONTINUE)
     {
       JERRY_UNIMPLEMENTED ();
 
@@ -136,7 +131,7 @@ run_int_loop (int_data_t *int_data)
     if (completion.type == ECMA_COMPLETION_TYPE_META)
     {
       completion.type = ECMA_COMPLETION_TYPE_NORMAL;
-      JERRY_ASSERT (ecma_is_completion_value_normal (completion));
+      JERRY_ASSERT (ecma_is_empty_completion_value (completion));
     }
 
     return completion;
diff --git a/src/libcoreint/opcodes-agnostic.c b/src/libcoreint/opcodes-agnostic.c
index 55d62c96c..7d2446238 100644
--- a/src/libcoreint/opcodes-agnostic.c
+++ b/src/libcoreint/opcodes-agnostic.c
@@ -34,10 +34,10 @@ opfunc_is_true_jmp (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.value);
+  ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (cond_value.u.value);
   JERRY_ASSERT (ecma_is_completion_value_normal (to_bool_completion));
 
-  if (ecma_is_value_true (to_bool_completion.value))
+  if (ecma_is_value_true (to_bool_completion.u.value))
   {
     int_data->pos = dst_opcode_idx;
   }
@@ -71,10 +71,10 @@ opfunc_is_false_jmp (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.value);
+  ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (cond_value.u.value);
   JERRY_ASSERT (ecma_is_completion_value_normal (to_bool_completion));
 
-  if (!ecma_is_value_true (to_bool_completion.value))
+  if (!ecma_is_value_true (to_bool_completion.u.value))
   {
     int_data->pos = dst_opcode_idx;
   }
diff --git a/src/libcoreint/opcodes-ecma-arithmetics.c b/src/libcoreint/opcodes-ecma-arithmetics.c
index 3db3857a5..ea2a42d40 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_POINTER (num_left_value.value.value);
-  right_p = (ecma_number_t*) ECMA_GET_POINTER (num_right_value.value.value);
+  left_p = (ecma_number_t*) ECMA_GET_POINTER (num_left_value.u.value.value);
+  right_p = (ecma_number_t*) ECMA_GET_POINTER (num_right_value.u.value.value);
 
   res_p = ecma_alloc_number ();
 
@@ -122,17 +122,17 @@ 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.value, ECMA_PREFERRED_TYPE_NO), ret_value);
-  ECMA_TRY_CATCH (prim_right_value, ecma_op_to_primitive (right_value.value, ECMA_PREFERRED_TYPE_NO), 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);
 
-  if (prim_left_value.value.value_type == ECMA_TYPE_STRING
-      || prim_right_value.value.value_type == ECMA_TYPE_STRING)
+  if (prim_left_value.u.value.value_type == ECMA_TYPE_STRING
+      || prim_right_value.u.value.value_type == ECMA_TYPE_STRING)
   {
-    ECMA_TRY_CATCH (str_left_value, ecma_op_to_string (prim_left_value.value), ret_value);
-    ECMA_TRY_CATCH (str_right_value, ecma_op_to_string (prim_right_value.value), ret_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_string_t *string1_p = ECMA_GET_POINTER (str_left_value.value.value);
-    ecma_string_t *string2_p = ECMA_GET_POINTER (str_right_value.value.value);
+    ecma_string_t *string1_p = ECMA_GET_POINTER (str_left_value.u.value.value);
+    ecma_string_t *string2_p = ECMA_GET_POINTER (str_right_value.u.value.value);
 
     ecma_string_t *concat_str_p = ecma_concat_ecma_strings (string1_p, string2_p);
 
@@ -148,8 +148,8 @@ opfunc_addition (opcode_t opdata, /**< operation data */
     ret_value = do_number_arithmetic (int_data,
                                       dst_var_idx,
                                       number_arithmetic_addition,
-                                      prim_left_value.value,
-                                      prim_right_value.value);
+                                      prim_left_value.u.value,
+                                      prim_right_value.u.value);
   }
 
   ECMA_FINALIZE (prim_right_value);
@@ -186,8 +186,8 @@ opfunc_substraction (opcode_t opdata, /**< operation data */
   ret_value = do_number_arithmetic (int_data,
                                     dst_var_idx,
                                     number_arithmetic_substraction,
-                                    left_value.value,
-                                    right_value.value);
+                                    left_value.u.value,
+                                    right_value.u.value);
 
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
@@ -221,8 +221,8 @@ opfunc_multiplication (opcode_t opdata, /**< operation data */
   ret_value = do_number_arithmetic (int_data,
                                     dst_var_idx,
                                     number_arithmetic_multiplication,
-                                    left_value.value,
-                                    right_value.value);
+                                    left_value.u.value,
+                                    right_value.u.value);
 
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
@@ -256,8 +256,8 @@ opfunc_division (opcode_t opdata, /**< operation data */
   ret_value = do_number_arithmetic (int_data,
                                     dst_var_idx,
                                     number_arithmetic_division,
-                                    left_value.value,
-                                    right_value.value);
+                                    left_value.u.value,
+                                    right_value.u.value);
 
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
@@ -291,8 +291,8 @@ opfunc_remainder (opcode_t opdata, /**< operation data */
   ret_value = do_number_arithmetic (int_data,
                                     dst_var_idx,
                                     number_arithmetic_remainder,
-                                    left_value.value,
-                                    right_value.value);
+                                    left_value.u.value,
+                                    right_value.u.value);
 
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
diff --git a/src/libcoreint/opcodes-ecma-bitwise.c b/src/libcoreint/opcodes-ecma-bitwise.c
index f8204a376..8227ff7c5 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_POINTER (num_left_value.value.value);
-  right_p = (ecma_number_t*) ECMA_GET_POINTER (num_right_value.value.value);
+  left_p = (ecma_number_t*) ECMA_GET_POINTER (num_left_value.u.value.value);
+  right_p = (ecma_number_t*) ECMA_GET_POINTER (num_right_value.u.value.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.value,
-                                       right_value.value);
+                                       left_value.u.value,
+                                       right_value.u.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.value,
-                                       right_value.value);
+                                       left_value.u.value,
+                                       right_value.u.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.value,
-                                       right_value.value);
+                                       left_value.u.value,
+                                       right_value.u.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.value,
-                                       right_value.value);
+                                       left_value.u.value,
+                                       right_value.u.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.value,
-                                       right_value.value);
+                                       left_value.u.value,
+                                       right_value.u.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.value,
-                                       right_value.value);
+                                       left_value.u.value,
+                                       right_value.u.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.value,
-                                       right_value.value);
+                                       right_value.u.value,
+                                       right_value.u.value);
 
   ECMA_FINALIZE (right_value);
 
diff --git a/src/libcoreint/opcodes-ecma-equality.c b/src/libcoreint/opcodes-ecma-equality.c
index 79842c2c1..7ac94a33e 100644
--- a/src/libcoreint/opcodes-ecma-equality.c
+++ b/src/libcoreint/opcodes-ecma-equality.c
@@ -39,7 +39,7 @@ 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);
 
-  bool is_equal = ecma_op_abstract_equality_compare (left_value.value, right_value.value);
+  bool is_equal = ecma_op_abstract_equality_compare (left_value.u.value, right_value.u.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));
@@ -73,7 +73,7 @@ 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);
 
-  bool is_equal = ecma_op_abstract_equality_compare (left_value.value, right_value.value);
+  bool is_equal = ecma_op_abstract_equality_compare (left_value.u.value, right_value.u.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));
@@ -108,7 +108,7 @@ 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.value, right_value.value);
+  bool is_equal = ecma_op_strict_equality_compare (left_value.u.value, right_value.u.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));
@@ -142,7 +142,7 @@ 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.value, right_value.value);
+  bool is_equal = ecma_op_strict_equality_compare (left_value.u.value, right_value.u.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 86479c748..8b1c30b3d 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.value,
-                                                       right_value.value,
+                  ecma_op_abstract_relational_compare (left_value.u.value,
+                                                       right_value.u.value,
                                                        true),
                   ret_value);
 
   ecma_simple_value_t res;
 
-  if (ecma_is_value_undefined (compare_result.value))
+  if (ecma_is_value_undefined (compare_result.u.value))
   {
     res = ECMA_SIMPLE_VALUE_FALSE;
   }
   else
   {
-    JERRY_ASSERT (ecma_is_value_boolean (compare_result.value));
+    JERRY_ASSERT (ecma_is_value_boolean (compare_result.u.value));
 
-    res = compare_result.value.value;
+    res = compare_result.u.value.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.value,
-                                                       left_value.value,
+                  ecma_op_abstract_relational_compare (right_value.u.value,
+                                                       left_value.u.value,
                                                        false),
                   ret_value);
 
   ecma_simple_value_t res;
 
-  if (ecma_is_value_undefined (compare_result.value))
+  if (ecma_is_value_undefined (compare_result.u.value))
   {
     res = ECMA_SIMPLE_VALUE_FALSE;
   }
   else
   {
-    JERRY_ASSERT (ecma_is_value_boolean (compare_result.value));
+    JERRY_ASSERT (ecma_is_value_boolean (compare_result.u.value));
 
-    res = compare_result.value.value;
+    res = compare_result.u.value.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.value,
-                                                       left_value.value,
+                  ecma_op_abstract_relational_compare (right_value.u.value,
+                                                       left_value.u.value,
                                                        false),
                   ret_value);
 
   ecma_simple_value_t res;
 
-  if (ecma_is_value_undefined (compare_result.value))
+  if (ecma_is_value_undefined (compare_result.u.value))
   {
     res = ECMA_SIMPLE_VALUE_FALSE;
   }
   else
   {
-    JERRY_ASSERT (ecma_is_value_boolean (compare_result.value));
+    JERRY_ASSERT (ecma_is_value_boolean (compare_result.u.value));
 
-    if (compare_result.value.value == ECMA_SIMPLE_VALUE_TRUE)
+    if (compare_result.u.value.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.value,
-                                                       right_value.value,
+                  ecma_op_abstract_relational_compare (left_value.u.value,
+                                                       right_value.u.value,
                                                        true),
                   ret_value);
 
   ecma_simple_value_t res;
 
-  if (ecma_is_value_undefined (compare_result.value))
+  if (ecma_is_value_undefined (compare_result.u.value))
   {
     res = ECMA_SIMPLE_VALUE_FALSE;
   }
   else
   {
-    JERRY_ASSERT (ecma_is_value_boolean (compare_result.value));
+    JERRY_ASSERT (ecma_is_value_boolean (compare_result.u.value));
 
-    if (compare_result.value.value == ECMA_SIMPLE_VALUE_TRUE)
+    if (compare_result.u.value.value == ECMA_SIMPLE_VALUE_TRUE)
     {
       res = ECMA_SIMPLE_VALUE_FALSE;
     }
@@ -251,20 +251,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 (right_value.value.value_type != ECMA_TYPE_OBJECT)
+  if (right_value.u.value.value_type != ECMA_TYPE_OBJECT)
   {
     ret_value = ecma_make_throw_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
   }
   else
   {
-    ecma_object_t *right_value_obj_p = ECMA_GET_POINTER (right_value.value.value);
+    ecma_object_t *right_value_obj_p = ECMA_GET_POINTER (right_value.u.value.value);
 
     ECMA_TRY_CATCH (is_instance_of,
                     ecma_op_object_has_instance (right_value_obj_p,
-                                                 left_value.value),
+                                                 left_value.u.value),
                     ret_value);
 
-    ret_value = set_variable_value (int_data, dst_idx, is_instance_of.value);
+    ret_value = set_variable_value (int_data, dst_idx, is_instance_of.u.value);
 
     ECMA_FINALIZE (is_instance_of);
   }
@@ -296,17 +296,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 (right_value.value.value_type != ECMA_TYPE_OBJECT)
+  if (right_value.u.value.value_type != ECMA_TYPE_OBJECT)
   {
     ret_value = ecma_make_throw_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
   }
   else
   {
-    ECMA_TRY_CATCH (str_left_value, ecma_op_to_string (left_value.value), ret_value);
+    ECMA_TRY_CATCH (str_left_value, ecma_op_to_string (left_value.u.value), ret_value);
 
     ecma_simple_value_t is_in = ECMA_SIMPLE_VALUE_UNDEFINED;
-    ecma_string_t *left_value_prop_name_p = ECMA_GET_POINTER (str_left_value.value.value);
-    ecma_object_t *right_value_obj_p = ECMA_GET_POINTER (right_value.value.value);
+    ecma_string_t *left_value_prop_name_p = ECMA_GET_POINTER (str_left_value.u.value.value);
+    ecma_object_t *right_value_obj_p = ECMA_GET_POINTER (right_value.u.value.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 9ded87bf6..6aa7745f0 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_empty_completion_value (completion));
       completion = ecma_op_set_mutable_binding (catch_env_p,
                                                 catch_exc_var_name_str_p,
-                                                try_completion.value,
+                                                try_completion.u.value,
                                                 false);
       JERRY_ASSERT (ecma_is_empty_completion_value (completion));
 
diff --git a/src/libcoreint/opcodes-helpers-variables.c b/src/libcoreint/opcodes-helpers-variables.c
index 0ed457271..7ff492ae5 100644
--- a/src/libcoreint/opcodes-helpers-variables.c
+++ b/src/libcoreint/opcodes-helpers-variables.c
@@ -88,8 +88,7 @@ get_variable_value (int_data_t *int_data, /**< interpreter context */
     JERRY_ASSERT (!ecma_is_value_empty (reg_value));
 
     ret_value = ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                            ecma_copy_value (reg_value, true),
-                                            ECMA_TARGET_ID_RESERVED);
+                                            ecma_copy_value (reg_value, true));
   }
   else
   {
diff --git a/src/libcoreint/opcodes-varg.c b/src/libcoreint/opcodes-varg.c
index 2faa97c7c..f2b2dbc20 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.value;
+        arg_values[arg_index] = get_arg_completion.u.value;
       }
       else
       {
diff --git a/src/libcoreint/opcodes.c b/src/libcoreint/opcodes.c
index e737f007a..218b3d71a 100644
--- a/src/libcoreint/opcodes.c
+++ b/src/libcoreint/opcodes.c
@@ -80,20 +80,20 @@ opfunc_call_1 (opcode_t opdata __unused, int_data_t *int_data)
   ECMA_TRY_CATCH (func_value, get_variable_value (int_data, func_name_lit_idx, false), ret_value);
   ECMA_TRY_CATCH (arg_value, get_variable_value (int_data, opdata.data.call_1.arg1_lit_idx, false), ret_value);
 
-  if (!ecma_op_is_callable (func_value.value))
+  if (!ecma_op_is_callable (func_value.u.value))
   {
     ret_value = ecma_make_throw_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
   }
   else
   {
-    ecma_object_t *func_obj_p = ECMA_GET_POINTER (func_value.value.value);
+    ecma_object_t *func_obj_p = ECMA_GET_POINTER (func_value.u.value.value);
 
     ECMA_TRY_CATCH (this_value, ecma_op_implicit_this_value (int_data->lex_env_p), ret_value);
     ECMA_FUNCTION_CALL (call_completion,
-                        ecma_op_function_call (func_obj_p, this_value.value, &arg_value.value, 1),
+                        ecma_op_function_call (func_obj_p, this_value.u.value, &arg_value.u.value, 1),
                         ret_value);
 
-    ret_value = set_variable_value (int_data, lhs_var_idx, call_completion.value);
+    ret_value = set_variable_value (int_data, lhs_var_idx, call_completion.u.value);
 
     ECMA_FINALIZE (call_completion);
     ECMA_FINALIZE (this_value);
@@ -135,8 +135,7 @@ opfunc_assignment (opcode_t opdata, /**< operation data */
     case OPCODE_ARG_TYPE_SIMPLE:
     {
       get_value_completion = ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                                         ecma_make_simple_value (src_val_descr),
-                                                         ECMA_TARGET_ID_RESERVED);
+                                                         ecma_make_simple_value (src_val_descr));
       break;
     }
     case OPCODE_ARG_TYPE_STRING:
@@ -144,8 +143,7 @@ opfunc_assignment (opcode_t opdata, /**< operation data */
       ecma_string_t *ecma_string_p = ecma_new_ecma_string_from_lit_index (src_val_descr);
 
       get_value_completion = ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                                         ecma_make_string_value (ecma_string_p),
-                                                         ECMA_TARGET_ID_RESERVED);
+                                                         ecma_make_string_value (ecma_string_p));
       break;
     }
     case OPCODE_ARG_TYPE_VARIABLE:
@@ -162,8 +160,7 @@ opfunc_assignment (opcode_t opdata, /**< operation data */
       *num_p = deserialize_num_by_id (src_val_descr);
 
       get_value_completion = ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                                         ecma_make_number_value (num_p),
-                                                         ECMA_TARGET_ID_RESERVED);
+                                                         ecma_make_number_value (num_p));
       break;
     }
     case OPCODE_ARG_TYPE_SMALLINT:
@@ -172,8 +169,7 @@ opfunc_assignment (opcode_t opdata, /**< operation data */
       *num_p = src_val_descr;
 
       get_value_completion = ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                                         ecma_make_number_value (num_p),
-                                                         ECMA_TARGET_ID_RESERVED);
+                                                         ecma_make_number_value (num_p));
       break;
     }
   }
@@ -188,7 +184,7 @@ opfunc_assignment (opcode_t opdata, /**< operation data */
 
     ecma_completion_value_t assignment_completion_value = set_variable_value (int_data,
                                                                               dst_var_idx,
-                                                                              get_value_completion.value);
+                                                                              get_value_completion.u.value);
 
     ecma_free_completion_value (get_value_completion);
 
@@ -217,12 +213,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.value), ret_value);
+  ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (old_value.u.value), ret_value);
 
   // 4.
   ecma_number_t* new_num_p = ecma_alloc_number ();
 
-  ecma_number_t* old_num_p = (ecma_number_t*) ECMA_GET_POINTER (old_num_value.value.value);
+  ecma_number_t* old_num_p = (ecma_number_t*) ECMA_GET_POINTER (old_num_value.u.value.value);
   *new_num_p = ecma_op_number_add (*old_num_p, ECMA_NUMBER_ONE);
 
   ecma_value_t new_num_value = ecma_make_number_value (new_num_p);
@@ -267,12 +263,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.value), ret_value);
+  ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (old_value.u.value), ret_value);
 
   // 4.
   ecma_number_t* new_num_p = ecma_alloc_number ();
 
-  ecma_number_t* old_num_p = (ecma_number_t*) ECMA_GET_POINTER (old_num_value.value.value);
+  ecma_number_t* old_num_p = (ecma_number_t*) ECMA_GET_POINTER (old_num_value.u.value.value);
   *new_num_p = ecma_op_number_substract (*old_num_p, ECMA_NUMBER_ONE);
 
   ecma_value_t new_num_value = ecma_make_number_value (new_num_p);
@@ -317,12 +313,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.value), ret_value);
+  ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (old_value.u.value), ret_value);
 
   // 4.
   ecma_number_t* new_num_p = ecma_alloc_number ();
 
-  ecma_number_t* old_num_p = (ecma_number_t*) ECMA_GET_POINTER (old_num_value.value.value);
+  ecma_number_t* old_num_p = (ecma_number_t*) ECMA_GET_POINTER (old_num_value.u.value.value);
   *new_num_p = ecma_op_number_add (*old_num_p, ECMA_NUMBER_ONE);
 
   // 5.
@@ -335,7 +331,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_value.value);
+                                                                   old_value.u.value);
   JERRY_ASSERT (ecma_is_empty_completion_value (reg_assignment_res));
 
   ECMA_FINALIZE (old_num_value);
@@ -365,12 +361,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.value), ret_value);
+  ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (old_value.u.value), ret_value);
 
   // 4.
   ecma_number_t* new_num_p = ecma_alloc_number ();
 
-  ecma_number_t* old_num_p = (ecma_number_t*) ECMA_GET_POINTER (old_num_value.value.value);
+  ecma_number_t* old_num_p = (ecma_number_t*) ECMA_GET_POINTER (old_num_value.u.value.value);
   *new_num_p = ecma_op_number_substract (*old_num_p, ECMA_NUMBER_ONE);
 
   // 5.
@@ -383,7 +379,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_value.value);
+                                                                   old_value.u.value);
   JERRY_ASSERT (ecma_is_empty_completion_value (reg_assignment_res));
 
   ECMA_FINALIZE (old_num_value);
@@ -694,20 +690,20 @@ opfunc_call_0 (opcode_t opdata, /**< operation data */
 
   ECMA_TRY_CATCH (func_value, get_variable_value (int_data, func_name_lit_idx, false), ret_value);
 
-  if (!ecma_op_is_callable (func_value.value))
+  if (!ecma_op_is_callable (func_value.u.value))
   {
     ret_value = ecma_make_throw_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
   }
   else
   {
-    ecma_object_t *func_obj_p = ECMA_GET_POINTER (func_value.value.value);
+    ecma_object_t *func_obj_p = ECMA_GET_POINTER (func_value.u.value.value);
 
     ECMA_TRY_CATCH (this_value, ecma_op_implicit_this_value (int_data->lex_env_p), ret_value);
     ECMA_FUNCTION_CALL (call_completion,
-                        ecma_op_function_call (func_obj_p, this_value.value, NULL, 0),
+                        ecma_op_function_call (func_obj_p, this_value.u.value, NULL, 0),
                         ret_value);
 
-    ret_value = set_variable_value (int_data, lhs_var_idx, call_completion.value);
+    ret_value = set_variable_value (int_data, lhs_var_idx, call_completion.u.value);
 
     ECMA_FINALIZE (call_completion);
     ECMA_FINALIZE (this_value);
@@ -769,19 +765,19 @@ opfunc_call_n (opcode_t opdata, /**< operation data */
     }
     JERRY_ASSERT (ecma_is_completion_value_normal (this_value));
 
-    if (!ecma_op_is_callable (func_value.value))
+    if (!ecma_op_is_callable (func_value.u.value))
     {
       ret_value = ecma_make_throw_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
     }
     else
     {
-      ecma_object_t *func_obj_p = ECMA_GET_POINTER (func_value.value.value);
+      ecma_object_t *func_obj_p = ECMA_GET_POINTER (func_value.u.value.value);
 
       ECMA_FUNCTION_CALL (call_completion,
-                          ecma_op_function_call (func_obj_p, this_value.value, arg_values, args_number),
+                          ecma_op_function_call (func_obj_p, this_value.u.value, arg_values, args_number),
                           ret_value);
 
-      ret_value = set_variable_value (int_data, lhs_var_idx, call_completion.value);
+      ret_value = set_variable_value (int_data, lhs_var_idx, call_completion.u.value);
 
       ECMA_FINALIZE (call_completion);
 
@@ -841,13 +837,13 @@ opfunc_construct_n (opcode_t opdata, /**< operation data */
   {
     JERRY_ASSERT (args_read == args_number);
 
-    if (!ecma_is_constructor (constructor_value.value))
+    if (!ecma_is_constructor (constructor_value.u.value))
     {
       ret_value = ecma_make_throw_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
     }
     else
     {
-      ecma_object_t *constructor_obj_p = ECMA_GET_POINTER (constructor_value.value.value);
+      ecma_object_t *constructor_obj_p = ECMA_GET_POINTER (constructor_value.u.value.value);
 
       ECMA_TRY_CATCH (construction_completion,
                       ecma_op_function_construct (constructor_obj_p,
@@ -855,7 +851,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.value);
+      ret_value = set_variable_value (int_data, lhs_var_idx, construction_completion.u.value);
 
       ECMA_FINALIZE (construction_completion);
     }
@@ -1005,7 +1001,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.value;
+          prop_desc.value = value_for_prop_desc.u.value;
           
           prop_desc.is_writable_defined = true;
           prop_desc.writable = ECMA_PROPERTY_WRITABLE;
@@ -1019,10 +1015,10 @@ opfunc_obj_decl (opcode_t opdata, /**< operation data */
         }
         else if (type == OPCODE_META_TYPE_VARG_PROP_GETTER)
         {
-          JERRY_ASSERT (value_for_prop_desc.value.value_type == ECMA_TYPE_OBJECT);
+          JERRY_ASSERT (value_for_prop_desc.u.value.value_type == ECMA_TYPE_OBJECT);
 
           prop_desc.is_get_defined = true;
-          prop_desc.get_p = ECMA_GET_POINTER (value_for_prop_desc.value.value);
+          prop_desc.get_p = ECMA_GET_POINTER (value_for_prop_desc.u.value.value);
 
           if (is_previous_data_desc)
           {
@@ -1031,10 +1027,10 @@ opfunc_obj_decl (opcode_t opdata, /**< operation data */
         }
         else
         {
-          JERRY_ASSERT (value_for_prop_desc.value.value_type == ECMA_TYPE_OBJECT);
+          JERRY_ASSERT (value_for_prop_desc.u.value.value_type == ECMA_TYPE_OBJECT);
 
           prop_desc.is_set_defined = true;
-          prop_desc.set_p = ECMA_GET_POINTER (value_for_prop_desc.value.value);
+          prop_desc.set_p = ECMA_GET_POINTER (value_for_prop_desc.u.value.value);
 
           if (is_previous_data_desc)
           {
@@ -1102,8 +1098,7 @@ opfunc_ret (opcode_t opdata __unused, /**< operation data */
             int_data_t *int_data __unused) /**< interpreter context */
 {
   return ecma_make_completion_value (ECMA_COMPLETION_TYPE_RETURN,
-                                     ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED),
-                                     ECMA_TARGET_ID_RESERVED);
+                                     ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED));
 } /* opfunc_ret */
 
 /**
@@ -1124,8 +1119,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_completion_value (ECMA_COMPLETION_TYPE_RETURN,
-                                          ecma_copy_value (expr_val.value, true),
-                                          ECMA_TARGET_ID_RESERVED);
+                                          ecma_copy_value (expr_val.u.value, true));
 
   ECMA_FINALIZE (expr_val);
 
@@ -1155,17 +1149,17 @@ opfunc_prop_getter (opcode_t opdata __unused, /**< operation data */
 
   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.value), ret_value);
-  ECMA_TRY_CATCH (prop_name_str_value, ecma_op_to_string (prop_name_value.value), 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_string_t *prop_name_string_p = ECMA_GET_POINTER (prop_name_str_value.value.value);
-  ecma_reference_t ref = ecma_make_reference (base_value.value,
+  ecma_string_t *prop_name_string_p = ECMA_GET_POINTER (prop_name_str_value.u.value.value);
+  ecma_reference_t ref = ecma_make_reference (base_value.u.value,
                                               prop_name_string_p,
                                               int_data->is_strict);
 
   ECMA_TRY_CATCH (prop_value, ecma_op_get_value (ref), ret_value);
 
-  ret_value = set_variable_value (int_data, lhs_var_idx, prop_value.value);
+  ret_value = set_variable_value (int_data, lhs_var_idx, prop_value.u.value);
 
   ECMA_FINALIZE (prop_value);
 
@@ -1202,16 +1196,16 @@ opfunc_prop_setter (opcode_t opdata __unused, /**< operation data */
 
   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.value), ret_value);
-  ECMA_TRY_CATCH (prop_name_str_value, ecma_op_to_string (prop_name_value.value), 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_string_t *prop_name_string_p = ECMA_GET_POINTER (prop_name_str_value.value.value);
-  ecma_reference_t ref = ecma_make_reference (base_value.value,
+  ecma_string_t *prop_name_string_p = ECMA_GET_POINTER (prop_name_str_value.u.value.value);
+  ecma_reference_t ref = ecma_make_reference (base_value.u.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 (ref, rhs_value.value);
+  ret_value = ecma_op_put_value (ref, rhs_value.u.value);
   ECMA_FINALIZE (rhs_value);
 
   ecma_free_reference (ref);
@@ -1247,8 +1241,7 @@ opfunc_exitval (opcode_t opdata, /**< operation data */
   ecma_value_t exit_status = ecma_make_simple_value (opdata.data.exitval.status_code == 0 ? ECMA_SIMPLE_VALUE_TRUE
                                                      : ECMA_SIMPLE_VALUE_FALSE);
   return ecma_make_completion_value (ECMA_COMPLETION_TYPE_EXIT,
-                                     exit_status,
-                                     ECMA_TARGET_ID_RESERVED);
+                                     exit_status);
 } /* opfunc_exitval */
 
 /**
@@ -1273,9 +1266,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.value);
+  ecma_completion_value_t to_bool_value = ecma_op_to_boolean (right_value.u.value);
 
-  if (ecma_is_value_true (to_bool_value.value))
+  if (ecma_is_value_true (to_bool_value.u.value))
   {
     old_value = ECMA_SIMPLE_VALUE_FALSE;
   }
@@ -1312,19 +1305,19 @@ opfunc_logical_or (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_completion_value_t to_bool_value = ecma_op_to_boolean (left_value.value);
+  ecma_completion_value_t to_bool_value = ecma_op_to_boolean (left_value.u.value);
 
-  if (ecma_is_value_true (to_bool_value.value))
+  if (ecma_is_value_true (to_bool_value.u.value))
   {
     ret_value = set_variable_value (int_data,
                                     dst_var_idx,
-                                    left_value.value);
+                                    left_value.u.value);
   }
   else
   {
     ret_value = set_variable_value (int_data,
                                     dst_var_idx,
-                                    right_value.value);
+                                    right_value.u.value);
   }
 
   ECMA_FINALIZE (right_value);
@@ -1356,19 +1349,19 @@ opfunc_logical_and (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_completion_value_t to_bool_value = ecma_op_to_boolean (left_value.value);
+  ecma_completion_value_t to_bool_value = ecma_op_to_boolean (left_value.u.value);
 
-  if (ecma_is_value_true (to_bool_value.value) == false)
+  if (ecma_is_value_true (to_bool_value.u.value) == false)
   {
     ret_value = set_variable_value (int_data,
                                     dst_var_idx,
-                                    left_value.value);
+                                    left_value.u.value);
   }
   else
   {
     ret_value = set_variable_value (int_data,
                                     dst_var_idx,
-                                    right_value.value);
+                                    right_value.u.value);
   }
 
   ECMA_FINALIZE (right_value);
@@ -1426,10 +1419,10 @@ opfunc_with (opcode_t opdata, /**< operation data */
                                       false),
                   ret_value);
   ECMA_TRY_CATCH (obj_expr_value,
-                  ecma_op_to_object (expr_value.value),
+                  ecma_op_to_object (expr_value.u.value),
                   ret_value);
 
-  ecma_object_t *obj_p = ECMA_GET_POINTER (obj_expr_value.value.value);
+  ecma_object_t *obj_p = ECMA_GET_POINTER (obj_expr_value.u.value.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,
@@ -1489,8 +1482,7 @@ opfunc_throw (opcode_t opdata, /**< operation data */
                   ret_value);
 
   return ecma_make_completion_value (ECMA_COMPLETION_TYPE_THROW,
-                                     ecma_copy_value (var_value.value, true),
-                                     ECMA_TARGET_ID_RESERVED);
+                                     ecma_copy_value (var_value.u.value, true));
 
   ECMA_FINALIZE (var_value);
 
@@ -1570,7 +1562,7 @@ opfunc_typeof (opcode_t opdata, /**< operation data */
                                            obj_var_idx),
                   ret_value);
 
-  ecma_value_t typeof_arg = typeof_evaluate_arg_completion.value;
+  ecma_value_t typeof_arg = typeof_evaluate_arg_completion.u.value;
 
   ecma_string_t *type_str_p = NULL;
 
@@ -1664,8 +1656,8 @@ opfunc_delete_var (opcode_t opdata, /**< operation data */
   ecma_completion_value_t ret_value;
 
   ECMA_TRY_CATCH (name_value, get_variable_value (int_data, name_var_idx, false), ret_value);
-  JERRY_ASSERT (name_value.value.value_type == ECMA_TYPE_STRING);
-  ecma_string_t *name_string_p = ECMA_GET_POINTER (name_value.value.value);
+  JERRY_ASSERT (name_value.u.value.value_type == ECMA_TYPE_STRING);
+  ecma_string_t *name_string_p = ECMA_GET_POINTER (name_value.u.value.value);
 
   ecma_reference_t ref = ecma_op_get_identifier_reference (int_data->lex_env_p,
                                                            name_string_p,
@@ -1687,7 +1679,7 @@ opfunc_delete_var (opcode_t opdata, /**< operation data */
 
     ecma_completion_value_t completion = ecma_op_delete_binding (bindings_p, ref.referenced_name_p);
 
-    ret_value = set_variable_value (int_data, dst_var_idx, completion.value);
+    ret_value = set_variable_value (int_data, dst_var_idx, completion.u.value);
   }
 
   ecma_free_reference (ref);
@@ -1720,13 +1712,13 @@ opfunc_delete_prop (opcode_t opdata, /**< operation data */
 
   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.value), ret_value);
-  ECMA_TRY_CATCH (str_name_value, ecma_op_to_string (name_value.value), 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);
 
-  JERRY_ASSERT (name_value.value.value_type == ECMA_TYPE_STRING);
-  ecma_string_t *name_string_p = ECMA_GET_POINTER (name_value.value.value);
+  JERRY_ASSERT (name_value.u.value.value_type == ECMA_TYPE_STRING);
+  ecma_string_t *name_string_p = ECMA_GET_POINTER (name_value.u.value.value);
 
-  if (ecma_is_value_undefined (base_value.value))
+  if (ecma_is_value_undefined (base_value.u.value))
   {
     if (int_data->is_strict)
     {
@@ -1739,17 +1731,17 @@ opfunc_delete_prop (opcode_t opdata, /**< operation data */
   }
   else
   {
-    ECMA_TRY_CATCH (obj_value, ecma_op_to_object (base_value.value), ret_value);
+    ECMA_TRY_CATCH (obj_value, ecma_op_to_object (base_value.u.value), ret_value);
 
-    JERRY_ASSERT (obj_value.value.value_type == ECMA_TYPE_OBJECT);
-    ecma_object_t *obj_p = ECMA_GET_POINTER (obj_value.value.value);
+    JERRY_ASSERT (obj_value.u.value.value_type == ECMA_TYPE_OBJECT);
+    ecma_object_t *obj_p = ECMA_GET_POINTER (obj_value.u.value.value);
     JERRY_ASSERT (!obj_p->is_lexical_environment);
 
     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.value);
+    ret_value = set_variable_value (int_data, dst_var_idx, delete_op_completion.u.value);
 
     ECMA_FINALIZE (delete_op_completion);
     ECMA_FINALIZE (obj_value);
@@ -1783,8 +1775,7 @@ opfunc_meta (opcode_t opdata, /**< operation data */
     case OPCODE_META_TYPE_END_TRY_CATCH_FINALLY:
     {
       return ecma_make_completion_value (ECMA_COMPLETION_TYPE_META,
-                                         ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY),
-                                         ECMA_TARGET_ID_RESERVED);
+                                         ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY));
     }
     case OPCODE_META_TYPE_UNDEFINED:
     case OPCODE_META_TYPE_THIS_ARG:
diff --git a/src/libecmaobjects/ecma-globals.h b/src/libecmaobjects/ecma-globals.h
index 69898cd93..a740ceba4 100644
--- a/src/libecmaobjects/ecma-globals.h
+++ b/src/libecmaobjects/ecma-globals.h
@@ -132,13 +132,31 @@ typedef struct
 typedef struct
 {
   /** Type (ecma_completion_type_t) */
-  unsigned int type : 3;
+  unsigned int type : 8;
 
-  /** Value */
-  ecma_value_t value;
+  union
+  {
+    /**
+      * Value
+      *
+      * Used for normal, return, throw and exit completion types.
+      */
+    ecma_value_t value;
 
-  /** Target */
-  unsigned int target : 8;
+    /**
+      * Label
+      *
+      * Used for break and continue completion types.
+      */
+    struct
+    {
+      /** Levels left */
+      uint8_t level;
+
+      /** Target's offset */
+      uint16_t offset;
+    } __packed target;
+  } __packed u;
 } __packed ecma_completion_value_t;
 
 /**
diff --git a/src/libecmaobjects/ecma-helpers-value.c b/src/libecmaobjects/ecma-helpers-value.c
index 003a1e9ca..80c94d4b4 100644
--- a/src/libecmaobjects/ecma-helpers-value.c
+++ b/src/libecmaobjects/ecma-helpers-value.c
@@ -285,14 +285,19 @@ ecma_free_value (ecma_value_t value, /**< value description */
  */
 ecma_completion_value_t
 ecma_make_completion_value (ecma_completion_type_t type, /**< type */
-                            ecma_value_t value, /**< value */
-                            uint8_t target) /**< target */
+                            ecma_value_t value) /**< value */
 {
+  JERRY_ASSERT (type == ECMA_COMPLETION_TYPE_NORMAL
+                || type == ECMA_COMPLETION_TYPE_THROW
+                || type == ECMA_COMPLETION_TYPE_RETURN
+                || type == ECMA_COMPLETION_TYPE_EXIT
+                || (type == ECMA_COMPLETION_TYPE_META
+                    && ecma_is_value_empty (value)));
+
   ecma_completion_value_t ret_value = (ecma_completion_value_t)
   {
     .type = type,
-    .value = value,
-    .target = target
+    .u.value = value,
   };
 
   return ret_value;
@@ -312,8 +317,7 @@ ecma_make_simple_completion_value (ecma_simple_value_t simple_value) /**< simple
                || simple_value == ECMA_SIMPLE_VALUE_TRUE);
 
   return ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                     ecma_make_simple_value (simple_value),
-                                     ECMA_TARGET_ID_RESERVED);
+                                     ecma_make_simple_value (simple_value));
 } /* ecma_make_simple_completion_value */
 
 /**
@@ -329,8 +333,7 @@ ecma_make_throw_value (ecma_object_t *exception_p) /**< an object */
   ecma_value_t exception = ecma_make_object_value (exception_p);
 
   return ecma_make_completion_value (ECMA_COMPLETION_TYPE_THROW,
-                                     exception,
-                                     ECMA_TARGET_ID_RESERVED);
+                                     exception);
 } /* ecma_make_throw_value */
 
 /**
@@ -342,8 +345,7 @@ ecma_completion_value_t
 ecma_make_empty_completion_value (void)
 {
   return ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                     ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY),
-                                     ECMA_TARGET_ID_RESERVED);
+                                     ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY));
 } /* ecma_make_empty_completion_value */
 
 /**
@@ -354,9 +356,13 @@ ecma_make_empty_completion_value (void)
 ecma_completion_value_t
 ecma_copy_completion_value (ecma_completion_value_t value) /**< completion value */
 {
+  JERRY_ASSERT (value.type == ECMA_COMPLETION_TYPE_NORMAL
+                || value.type == ECMA_COMPLETION_TYPE_THROW
+                || value.type == ECMA_COMPLETION_TYPE_RETURN
+                || value.type == ECMA_COMPLETION_TYPE_EXIT);
+
   return ecma_make_completion_value (value.type,
-                                     ecma_copy_value (value.value, true),
-                                     value.target);
+                                     ecma_copy_value (value.u.value, true));
 } /* ecma_copy_completion_value */
 
 /**
@@ -371,16 +377,16 @@ ecma_free_completion_value (ecma_completion_value_t completion_value) /**< compl
     case ECMA_COMPLETION_TYPE_THROW:
     case ECMA_COMPLETION_TYPE_RETURN:
     {
-      ecma_free_value (completion_value.value, true);
+      ecma_free_value (completion_value.u.value, true);
+      break;
+    }
+    case ECMA_COMPLETION_TYPE_EXIT:
+    {
+      JERRY_ASSERT(completion_value.u.value.value_type == ECMA_TYPE_SIMPLE);
       break;
     }
     case ECMA_COMPLETION_TYPE_CONTINUE:
     case ECMA_COMPLETION_TYPE_BREAK:
-    case ECMA_COMPLETION_TYPE_EXIT:
-    {
-      JERRY_ASSERT(completion_value.value.value_type == ECMA_TYPE_SIMPLE);
-      break;
-    }
     case ECMA_COMPLETION_TYPE_META:
     {
       JERRY_UNREACHABLE ();
@@ -437,8 +443,8 @@ ecma_is_completion_value_normal_simple_value (ecma_completion_value_t value, /**
                                                                                      for equality with */
 {
   return (value.type == ECMA_COMPLETION_TYPE_NORMAL
-          && value.value.value_type == ECMA_TYPE_SIMPLE
-          && value.value.value == simple_value);
+          && value.u.value.value_type == ECMA_TYPE_SIMPLE
+          && value.u.value.value == simple_value);
 } /* ecma_is_completion_value_normal_simple_value */
 
 /**
@@ -478,7 +484,7 @@ bool
 ecma_is_empty_completion_value (ecma_completion_value_t value) /**< completion value */
 {
   return (ecma_is_completion_value_normal (value)
-          && ecma_is_value_empty (value.value));
+          && ecma_is_value_empty (value.u.value));
 } /* ecma_is_empty_completion_value */
 
 /**
diff --git a/src/libecmaobjects/ecma-helpers.h b/src/libecmaobjects/ecma-helpers.h
index 0d9f290d2..35d95e9cd 100644
--- a/src/libecmaobjects/ecma-helpers.h
+++ b/src/libecmaobjects/ecma-helpers.h
@@ -69,8 +69,7 @@ extern ecma_value_t ecma_copy_value (const ecma_value_t value, bool do_ref_if_ob
 extern void ecma_free_value (const ecma_value_t value, bool do_deref_if_object);
 
 extern ecma_completion_value_t ecma_make_completion_value (ecma_completion_type_t type,
-                                                           ecma_value_t value,
-                                                           uint8_t target);
+                                                           ecma_value_t value);
 extern ecma_completion_value_t ecma_make_simple_completion_value (ecma_simple_value_t simple_value);
 extern ecma_completion_value_t ecma_make_throw_value (ecma_object_t *exception_p);
 extern ecma_completion_value_t ecma_make_empty_completion_value (void);
diff --git a/src/libecmaoperations/ecma-array-object.c b/src/libecmaoperations/ecma-array-object.c
index 4d0f7c33f..29765ab57 100644
--- a/src/libecmaoperations/ecma-array-object.c
+++ b/src/libecmaoperations/ecma-array-object.c
@@ -201,9 +201,9 @@ ecma_op_array_object_define_own_property (ecma_object_t *obj_p, /**< the array o
     }
 
     JERRY_ASSERT (ecma_is_completion_value_normal (completion)
-                  && completion.value.value_type == ECMA_TYPE_NUMBER);
+                  && completion.u.value.value_type == ECMA_TYPE_NUMBER);
 
-    new_len_num = *(ecma_number_t*) ECMA_GET_POINTER (completion.value.value);
+    new_len_num = *(ecma_number_t*) ECMA_GET_POINTER (completion.u.value.value);
 
     ecma_free_completion_value (completion);
 
diff --git a/src/libecmaoperations/ecma-comparison.c b/src/libecmaoperations/ecma-comparison.c
index e8cbf6ee1..a64a4fc4b 100644
--- a/src/libecmaoperations/ecma-comparison.c
+++ b/src/libecmaoperations/ecma-comparison.c
@@ -226,33 +226,31 @@ 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 = (px.value.value_type == ECMA_TYPE_STRING);
-  const bool is_py_string = (py.value.value_type == ECMA_TYPE_STRING);
+  const bool is_px_string = (px.u.value.value_type == ECMA_TYPE_STRING);
+  const bool is_py_string = (py.u.value.value_type == ECMA_TYPE_STRING);
 
   if (!(is_px_string && is_py_string))
   { // 3.
     // a.
-    ECMA_TRY_CATCH(nx, ecma_op_to_number (px.value), ret_value);
+    ECMA_TRY_CATCH(nx, ecma_op_to_number (px.u.value), ret_value);
 
     // b.
-    ECMA_TRY_CATCH(ny, ecma_op_to_number (py.value), ret_value);
+    ECMA_TRY_CATCH(ny, ecma_op_to_number (py.u.value), ret_value);
 
-    ecma_number_t* num_x_p = (ecma_number_t*)ECMA_GET_POINTER(nx.value.value);
-    ecma_number_t* num_y_p = (ecma_number_t*)ECMA_GET_POINTER(ny.value.value);
+    ecma_number_t* num_x_p = (ecma_number_t*)ECMA_GET_POINTER(nx.u.value.value);
+    ecma_number_t* num_y_p = (ecma_number_t*)ECMA_GET_POINTER(ny.u.value.value);
 
     TODO(/* Implement according to ECMA */);
 
     if (*num_x_p >= *num_y_p)
     {
       ret_value = ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                              ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE),
-                                              ECMA_TARGET_ID_RESERVED);
+                                              ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE));
     }
     else
     {
       ret_value = ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                              ecma_make_simple_value (ECMA_SIMPLE_VALUE_TRUE),
-                                              ECMA_TARGET_ID_RESERVED);
+                                              ecma_make_simple_value (ECMA_SIMPLE_VALUE_TRUE));
     }
 
     ECMA_FINALIZE(ny);
diff --git a/src/libecmaoperations/ecma-conversion.c b/src/libecmaoperations/ecma-conversion.c
index 23767e5a2..6bc22cc84 100644
--- a/src/libecmaoperations/ecma-conversion.c
+++ b/src/libecmaoperations/ecma-conversion.c
@@ -168,8 +168,7 @@ ecma_op_to_primitive (ecma_value_t value, /**< ecma-value */
     case ECMA_TYPE_STRING:
     {
       return ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                         ecma_copy_value (value, true),
-                                         ECMA_TARGET_ID_RESERVED);
+                                         ecma_copy_value (value, true));
     }
 
     case ECMA_TYPE_OBJECT:
@@ -262,8 +261,7 @@ ecma_op_to_number (ecma_value_t value) /**< ecma-value */
     case ECMA_TYPE_NUMBER:
     {
       return ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                         ecma_copy_value (value, true),
-                                         ECMA_TARGET_ID_RESERVED);
+                                         ecma_copy_value (value, true));
     }
     case ECMA_TYPE_SIMPLE:
     case ECMA_TYPE_STRING:
@@ -275,7 +273,7 @@ ecma_op_to_number (ecma_value_t value) /**< ecma-value */
       ecma_completion_value_t completion_to_primitive = ecma_op_to_primitive (value, ECMA_PREFERRED_TYPE_NUMBER);
       JERRY_ASSERT(ecma_is_completion_value_normal (completion_to_primitive));
 
-      ecma_completion_value_t completion_to_number = ecma_op_to_number (completion_to_primitive.value);
+      ecma_completion_value_t completion_to_number = ecma_op_to_number (completion_to_primitive.u.value);
       ecma_free_completion_value (completion_to_primitive);
 
       return completion_to_number;
@@ -305,7 +303,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.value);
+    ret_value = ecma_op_to_string (prim_value.u.value);
 
     ECMA_FINALIZE (prim_value);
 
@@ -375,8 +373,7 @@ ecma_op_to_string (ecma_value_t value) /**< ecma-value */
   }
 
   return ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                     ecma_make_string_value (res_p),
-                                     ECMA_TARGET_ID_RESERVED);
+                                     ecma_make_string_value (res_p));
 } /* ecma_op_to_string */
 
 /**
@@ -403,8 +400,7 @@ ecma_op_to_object (ecma_value_t value) /**< ecma-value */
     case ECMA_TYPE_OBJECT:
     {
       return ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                         ecma_copy_value (value, true),
-                                         ECMA_TARGET_ID_RESERVED);
+                                         ecma_copy_value (value, true));
     }
   }
 
diff --git a/src/libecmaoperations/ecma-function-object.c b/src/libecmaoperations/ecma-function-object.c
index 05adae95a..e2aa10f37 100644
--- a/src/libecmaoperations/ecma-function-object.c
+++ b/src/libecmaoperations/ecma-function-object.c
@@ -423,7 +423,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.value;
+      this_binding = completion.u.value;
     }
 
     // 5.
@@ -448,8 +448,7 @@ ecma_op_function_call (ecma_object_t *func_obj_p, /**< Function object */
       JERRY_ASSERT(ecma_is_empty_completion_value (completion));
 
       ret_value = ecma_make_completion_value (ECMA_COMPLETION_TYPE_RETURN,
-                                              ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED),
-                                              ECMA_TARGET_ID_RESERVED);
+                                              ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED));
     }
     else
     {
@@ -502,9 +501,9 @@ ecma_op_function_construct (ecma_object_t *func_obj_p, /**< Function object */
 
     //  6.
     ecma_object_t *prototype_p;
-    if (func_obj_prototype_prop_value.value.value_type == ECMA_TYPE_OBJECT)
+    if (func_obj_prototype_prop_value.u.value.value_type == ECMA_TYPE_OBJECT)
     {
-      prototype_p = ECMA_GET_POINTER (func_obj_prototype_prop_value.value.value);
+      prototype_p = ECMA_GET_POINTER (func_obj_prototype_prop_value.u.value.value);
       ecma_ref_object (prototype_p);
     }
     else
@@ -535,11 +534,11 @@ ecma_op_function_construct (ecma_object_t *func_obj_p, /**< Function object */
     ecma_value_t obj_value;
 
     // 9.
-    if (call_completion.value.value_type == ECMA_TYPE_OBJECT)
+    if (call_completion.u.value.value_type == ECMA_TYPE_OBJECT)
     {
       ecma_deref_object (obj_p);
 
-      obj_value = ecma_copy_value (call_completion.value, true);
+      obj_value = ecma_copy_value (call_completion.u.value, true);
     }
     else
     {
@@ -548,8 +547,7 @@ ecma_op_function_construct (ecma_object_t *func_obj_p, /**< Function object */
     }
 
     ret_value = ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                            obj_value,
-                                            ECMA_TARGET_ID_RESERVED);
+                                            obj_value);
 
     ECMA_FINALIZE (call_completion);
     ECMA_FINALIZE (func_obj_prototype_prop_value);
diff --git a/src/libecmaoperations/ecma-get-put-value.c b/src/libecmaoperations/ecma-get-put-value.c
index bdba6f2c6..2f34d82ac 100644
--- a/src/libecmaoperations/ecma-get-put-value.c
+++ b/src/libecmaoperations/ecma-get-put-value.c
@@ -81,7 +81,7 @@ ecma_op_get_value (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_POINTER (obj_base.value.value);
+      ecma_object_t *obj_p = ECMA_GET_POINTER (obj_base.u.value.value);
       JERRY_ASSERT (obj_p != NULL && !obj_p->is_lexical_environment);
       JERRY_ASSERT (obj_p->u.object.type == ECMA_OBJECT_TYPE_GENERAL);
 
@@ -189,7 +189,7 @@ ecma_op_put_value (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_POINTER (obj_base.value.value);
+      ecma_object_t *obj_p = ECMA_GET_POINTER (obj_base.u.value.value);
       JERRY_ASSERT (obj_p != NULL && !obj_p->is_lexical_environment);
       JERRY_ASSERT (obj_p->u.object.type == ECMA_OBJECT_TYPE_GENERAL);
 
diff --git a/src/libecmaoperations/ecma-lex-env.c b/src/libecmaoperations/ecma-lex-env.c
index 7d0060460..06d431244 100644
--- a/src/libecmaoperations/ecma-lex-env.c
+++ b/src/libecmaoperations/ecma-lex-env.c
@@ -95,8 +95,7 @@ ecma_op_has_binding (ecma_object_t *lex_env_p, /**< lexical environment */
   }
 
   return ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                     ecma_make_simple_value (has_binding),
-                                     ECMA_TARGET_ID_RESERVED);
+                                     ecma_make_simple_value (has_binding));
 } /* ecma_op_has_binding */
 
 /**
@@ -262,8 +261,7 @@ ecma_op_get_binding_value (ecma_object_t *lex_env_p, /**< lexical environment */
       if (property_p->u.named_data_property.writable == ECMA_PROPERTY_WRITABLE)
       {
         return ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                           ecma_copy_value (prop_value, true),
-                                           ECMA_TARGET_ID_RESERVED);
+                                           ecma_copy_value (prop_value, true));
       }
       else if (ecma_is_value_empty (prop_value))
       {
@@ -349,8 +347,7 @@ ecma_op_delete_binding (ecma_object_t *lex_env_p, /**< lexical environment */
       }
 
       return ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                         ecma_make_simple_value (ret_val),
-                                         ECMA_TARGET_ID_RESERVED);
+                                         ecma_make_simple_value (ret_val));
     }
     case ECMA_LEXICAL_ENVIRONMENT_OBJECTBOUND:
     {
@@ -395,8 +392,7 @@ ecma_op_implicit_this_value (ecma_object_t *lex_env_p) /**< lexical environment
         ecma_ref_object (binding_obj_p);
 
         return ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                           ecma_make_object_value (binding_obj_p),
-                                           ECMA_TARGET_ID_RESERVED);
+                                           ecma_make_object_value (binding_obj_p));
       }
       else
       {
diff --git a/src/libecmaoperations/ecma-objects-arguments.c b/src/libecmaoperations/ecma-objects-arguments.c
index 0056621a5..0e519d067 100644
--- a/src/libecmaoperations/ecma-objects-arguments.c
+++ b/src/libecmaoperations/ecma-objects-arguments.c
@@ -362,7 +362,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.value, false);
+    desc_p->u.named_data_property.value = ecma_copy_value (completion.u.value, false);
 
     ecma_free_completion_value (completion);
   }
diff --git a/src/libecmaoperations/ecma-objects-general.c b/src/libecmaoperations/ecma-objects-general.c
index 7390829f2..cd1d9d450 100644
--- a/src/libecmaoperations/ecma-objects-general.c
+++ b/src/libecmaoperations/ecma-objects-general.c
@@ -85,8 +85,7 @@ ecma_op_create_object_object_arg (ecma_value_t value) /**< argument of construct
     {
       // 1.a
       return ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                         ecma_copy_value (value, true),
-                                         ECMA_TARGET_ID_RESERVED);
+                                         ecma_copy_value (value, true));
     }
     case ECMA_TYPE_NUMBER:
     case ECMA_TYPE_STRING:
@@ -109,8 +108,7 @@ ecma_op_create_object_object_arg (ecma_value_t value) /**< argument of construct
       ecma_object_t *obj_p = ecma_op_create_object_object_noarg ();
 
       return ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                         ecma_make_object_value (obj_p),
-                                         ECMA_TARGET_ID_RESERVED);
+                                         ecma_make_object_value (obj_p));
     }
   }
 
@@ -147,8 +145,7 @@ ecma_op_general_object_get (ecma_object_t *obj_p, /**< the object */
   if (prop_p->type == ECMA_PROPERTY_NAMEDDATA)
   {
     return ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                       ecma_copy_value (prop_p->u.named_data_property.value, true),
-                                       ECMA_TARGET_ID_RESERVED);
+                                       ecma_copy_value (prop_p->u.named_data_property.value, true));
   }
   else
   {
@@ -172,8 +169,7 @@ ecma_op_general_object_get (ecma_object_t *obj_p, /**< the object */
                           ret_value);
 
       ret_value = ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
-                                              ecma_copy_value (call_completion.value, true),
-                                              ECMA_TARGET_ID_RESERVED);
+                                              ecma_copy_value (call_completion.u.value, true));
 
       ECMA_FINALIZE (call_completion);