diff --git a/src/libcoreint/opcodes-agnostic.c b/src/libcoreint/opcodes-agnostic.c
index 17571ccf4..9aba7c133 100644
--- a/src/libcoreint/opcodes-agnostic.c
+++ b/src/libcoreint/opcodes-agnostic.c
@@ -1,4 +1,4 @@
-/* Copyright 2014 Samsung Electronics Co., Ltd.
+/* Copyright 2014-2015 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -33,9 +33,12 @@ opfunc_is_true_jmp_down (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  ECMA_TRY_CATCH (cond_value, get_variable_value (int_data, cond_var_idx, false), ret_value);
+  ECMA_TRY_CATCH_STACKED (cond_value,
+                          get_variable_value (int_data, cond_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
-  ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (ecma_get_completion_value_value (cond_value));
+  ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (cond_value);
   JERRY_ASSERT (ecma_is_completion_value_normal (to_bool_completion));
 
   if (ecma_is_value_true (ecma_get_completion_value_value (to_bool_completion)))
@@ -50,7 +53,7 @@ opfunc_is_true_jmp_down (opcode_t opdata, /**< operation data */
 
   ret_value = ecma_make_empty_completion_value ();
 
-  ECMA_FINALIZE (cond_value);
+  ECMA_FINALIZE_STACKED (cond_value, int_data->stack_frame_p);
 
   return ret_value;
 }
@@ -66,9 +69,12 @@ opfunc_is_true_jmp_up (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  ECMA_TRY_CATCH (cond_value, get_variable_value (int_data, cond_var_idx, false), ret_value);
+  ECMA_TRY_CATCH_STACKED (cond_value,
+                          get_variable_value (int_data, cond_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
-  ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (ecma_get_completion_value_value (cond_value));
+  ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (cond_value);
   JERRY_ASSERT (ecma_is_completion_value_normal (to_bool_completion));
 
   if (ecma_is_value_true (ecma_get_completion_value_value (to_bool_completion)))
@@ -83,7 +89,7 @@ opfunc_is_true_jmp_up (opcode_t opdata, /**< operation data */
 
   ret_value = ecma_make_empty_completion_value ();
 
-  ECMA_FINALIZE (cond_value);
+  ECMA_FINALIZE_STACKED (cond_value, int_data->stack_frame_p);
 
   return ret_value;
 }
@@ -105,9 +111,12 @@ opfunc_is_false_jmp_down (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  ECMA_TRY_CATCH (cond_value, get_variable_value (int_data, cond_var_idx, false), ret_value);
+  ECMA_TRY_CATCH_STACKED (cond_value,
+                          get_variable_value (int_data, cond_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
-  ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (ecma_get_completion_value_value (cond_value));
+  ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (cond_value);
   JERRY_ASSERT (ecma_is_completion_value_normal (to_bool_completion));
 
   if (!ecma_is_value_true (ecma_get_completion_value_value (to_bool_completion)))
@@ -122,7 +131,7 @@ opfunc_is_false_jmp_down (opcode_t opdata, /**< operation data */
 
   ret_value = ecma_make_empty_completion_value ();
 
-  ECMA_FINALIZE (cond_value);
+  ECMA_FINALIZE_STACKED (cond_value, int_data->stack_frame_p);
 
   return ret_value;
 }
@@ -138,9 +147,12 @@ opfunc_is_false_jmp_up (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  ECMA_TRY_CATCH (cond_value, get_variable_value (int_data, cond_var_idx, false), ret_value);
+  ECMA_TRY_CATCH_STACKED (cond_value,
+                          get_variable_value (int_data, cond_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
-  ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (ecma_get_completion_value_value (cond_value));
+  ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (cond_value);
   JERRY_ASSERT (ecma_is_completion_value_normal (to_bool_completion));
 
   if (!ecma_is_value_true (ecma_get_completion_value_value (to_bool_completion)))
@@ -155,7 +167,7 @@ opfunc_is_false_jmp_up (opcode_t opdata, /**< operation data */
 
   ret_value = ecma_make_empty_completion_value ();
 
-  ECMA_FINALIZE (cond_value);
+  ECMA_FINALIZE_STACKED (cond_value, int_data->stack_frame_p);
 
   return ret_value;
 }
diff --git a/src/libcoreint/opcodes-ecma-arithmetics.c b/src/libcoreint/opcodes-ecma-arithmetics.c
index 7566f5961..f0bbf2d41 100644
--- a/src/libcoreint/opcodes-ecma-arithmetics.c
+++ b/src/libcoreint/opcodes-ecma-arithmetics.c
@@ -1,4 +1,4 @@
-/* Copyright 2014 Samsung Electronics Co., Ltd.
+/* Copyright 2014-2015 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -112,14 +112,20 @@ opfunc_addition (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
   ECMA_TRY_CATCH (prim_left_value,
-                  ecma_op_to_primitive (ecma_get_completion_value_value (left_value),
+                  ecma_op_to_primitive (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_op_to_primitive (right_value,
                                         ECMA_PREFERRED_TYPE_NO),
                   ret_value);
 
@@ -152,8 +158,8 @@ opfunc_addition (opcode_t opdata, /**< operation data */
 
   ECMA_FINALIZE (prim_right_value);
   ECMA_FINALIZE (prim_left_value);
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -178,17 +184,23 @@ opfunc_substraction (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
   ret_value = do_number_arithmetic (int_data,
                                     dst_var_idx,
                                     number_arithmetic_substraction,
-                                    ecma_get_completion_value_value (left_value),
-                                    ecma_get_completion_value_value (right_value));
+                                    left_value,
+                                    right_value);
 
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -213,17 +225,23 @@ opfunc_multiplication (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
   ret_value = do_number_arithmetic (int_data,
                                     dst_var_idx,
                                     number_arithmetic_multiplication,
-                                    ecma_get_completion_value_value (left_value),
-                                    ecma_get_completion_value_value (right_value));
+                                    left_value,
+                                    right_value);
 
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -248,17 +266,23 @@ opfunc_division (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
   ret_value = do_number_arithmetic (int_data,
                                     dst_var_idx,
                                     number_arithmetic_division,
-                                    ecma_get_completion_value_value (left_value),
-                                    ecma_get_completion_value_value (right_value));
+                                    left_value,
+                                    right_value);
 
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -283,17 +307,23 @@ opfunc_remainder (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
   ret_value = do_number_arithmetic (int_data,
                                     dst_var_idx,
                                     number_arithmetic_remainder,
-                                    ecma_get_completion_value_value (left_value),
-                                    ecma_get_completion_value_value (right_value));
+                                    left_value,
+                                    right_value);
 
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -317,9 +347,12 @@ opfunc_unary_plus (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
-  ECMA_TRY_CATCH (var_value, get_variable_value (int_data, var_idx, false), ret_value);
+  ECMA_TRY_CATCH_STACKED (var_value,
+                          get_variable_value (int_data, var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
   ECMA_OP_TO_NUMBER_TRY_CATCH (num_var_value,
-                               ecma_get_completion_value_value (var_value),
+                               var_value,
                                ret_value);
 
   ecma_number_t *tmp_p = int_data->tmp_num_p;
@@ -330,7 +363,7 @@ opfunc_unary_plus (opcode_t opdata, /**< operation data */
                                   ecma_make_number_value (tmp_p));
 
   ECMA_OP_TO_NUMBER_FINALIZE (num_var_value);
-  ECMA_FINALIZE (var_value);
+  ECMA_FINALIZE_STACKED (var_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -354,9 +387,12 @@ opfunc_unary_minus (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
-  ECMA_TRY_CATCH (var_value, get_variable_value (int_data, var_idx, false), ret_value);
+  ECMA_TRY_CATCH_STACKED (var_value,
+                          get_variable_value (int_data, var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
   ECMA_OP_TO_NUMBER_TRY_CATCH (num_var_value,
-                               ecma_get_completion_value_value (var_value),
+                               var_value,
                                ret_value);
 
   ecma_number_t *tmp_p = int_data->tmp_num_p;
@@ -367,7 +403,7 @@ opfunc_unary_minus (opcode_t opdata, /**< operation data */
                                   ecma_make_number_value (tmp_p));
 
   ECMA_OP_TO_NUMBER_FINALIZE (num_var_value);
-  ECMA_FINALIZE (var_value);
+  ECMA_FINALIZE_STACKED (var_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
diff --git a/src/libcoreint/opcodes-ecma-bitwise.c b/src/libcoreint/opcodes-ecma-bitwise.c
index 6cfa9105e..f808fb1c5 100644
--- a/src/libcoreint/opcodes-ecma-bitwise.c
+++ b/src/libcoreint/opcodes-ecma-bitwise.c
@@ -1,4 +1,4 @@
-/* Copyright 2014 Samsung Electronics Co., Ltd.
+/* Copyright 2014-2015 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -128,17 +128,23 @@ opfunc_b_and (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
   ret_value = do_number_bitwise_logic (int_data,
                                        dst_var_idx,
                                        number_bitwise_logic_and,
-                                       ecma_get_completion_value_value (left_value),
-                                       ecma_get_completion_value_value (right_value));
+                                       left_value,
+                                       right_value);
 
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -163,17 +169,23 @@ opfunc_b_or (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
   ret_value = do_number_bitwise_logic (int_data,
                                        dst_var_idx,
                                        number_bitwise_logic_or,
-                                       ecma_get_completion_value_value (left_value),
-                                       ecma_get_completion_value_value (right_value));
+                                       left_value,
+                                       right_value);
 
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -198,17 +210,23 @@ opfunc_b_xor (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
   ret_value = do_number_bitwise_logic (int_data,
                                        dst_var_idx,
                                        number_bitwise_logic_xor,
-                                       ecma_get_completion_value_value (left_value),
-                                       ecma_get_completion_value_value (right_value));
+                                       left_value,
+                                       right_value);
 
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -233,17 +251,23 @@ opfunc_b_shift_left (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
   ret_value = do_number_bitwise_logic (int_data,
                                        dst_var_idx,
                                        number_bitwise_shift_left,
-                                       ecma_get_completion_value_value (left_value),
-                                       ecma_get_completion_value_value (right_value));
+                                       left_value,
+                                       right_value);
 
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -268,17 +292,23 @@ opfunc_b_shift_right (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
   ret_value = do_number_bitwise_logic (int_data,
                                        dst_var_idx,
                                        number_bitwise_shift_right,
-                                       ecma_get_completion_value_value (left_value),
-                                       ecma_get_completion_value_value (right_value));
+                                       left_value,
+                                       right_value);
 
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -303,17 +333,23 @@ opfunc_b_shift_uright (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
   ret_value = do_number_bitwise_logic (int_data,
                                        dst_var_idx,
                                        number_bitwise_shift_uright,
-                                       ecma_get_completion_value_value (left_value),
-                                       ecma_get_completion_value_value (right_value));
+                                       left_value,
+                                       right_value);
 
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -337,15 +373,18 @@ opfunc_b_not (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
   ret_value = do_number_bitwise_logic (int_data,
                                        dst_var_idx,
                                        number_bitwise_not,
-                                       ecma_get_completion_value_value (right_value),
-                                       ecma_get_completion_value_value (right_value));
+                                       right_value,
+                                       right_value);
 
-  ECMA_FINALIZE (right_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
diff --git a/src/libcoreint/opcodes-ecma-equality.c b/src/libcoreint/opcodes-ecma-equality.c
index 1a1c30385..9002d5aaa 100644
--- a/src/libcoreint/opcodes-ecma-equality.c
+++ b/src/libcoreint/opcodes-ecma-equality.c
@@ -1,4 +1,4 @@
-/* Copyright 2014 Samsung Electronics Co., Ltd.
+/* Copyright 2014-2015 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -34,11 +34,17 @@ opfunc_equal_value (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
   ECMA_TRY_CATCH (compare_result,
-                  ecma_op_abstract_equality_compare (ecma_get_completion_value_value (left_value),
-                                                     ecma_get_completion_value_value (right_value)),
+                  ecma_op_abstract_equality_compare (left_value,
+                                                     right_value),
                   ret_value);
 
   JERRY_ASSERT (ecma_is_completion_value_normal_true (compare_result)
@@ -48,8 +54,8 @@ opfunc_equal_value (opcode_t opdata, /**< operation data */
                                   ecma_get_completion_value_value (compare_result));
 
   ECMA_FINALIZE (compare_result);
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -74,11 +80,17 @@ opfunc_not_equal_value (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
   ECMA_TRY_CATCH (compare_result,
-                  ecma_op_abstract_equality_compare (ecma_get_completion_value_value (left_value),
-                                                     ecma_get_completion_value_value (right_value)),
+                  ecma_op_abstract_equality_compare (left_value,
+                                                     right_value),
                   ret_value);
 
   JERRY_ASSERT (ecma_is_completion_value_normal_true (compare_result)
@@ -91,8 +103,8 @@ opfunc_not_equal_value (opcode_t opdata, /**< operation data */
                                                           : ECMA_SIMPLE_VALUE_TRUE));
 
   ECMA_FINALIZE (compare_result);
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -117,18 +129,24 @@ opfunc_equal_value_type (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
-  bool is_equal = ecma_op_strict_equality_compare (ecma_get_completion_value_value (left_value),
-                                                   ecma_get_completion_value_value (right_value));
+  bool is_equal = ecma_op_strict_equality_compare (left_value,
+                                                   right_value);
 
   ret_value = set_variable_value (int_data, int_data->pos, dst_var_idx,
                                   ecma_make_simple_value (is_equal ? ECMA_SIMPLE_VALUE_TRUE
                                                           : ECMA_SIMPLE_VALUE_FALSE));
 
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -153,19 +171,25 @@ opfunc_not_equal_value_type (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
-  bool is_equal = ecma_op_strict_equality_compare (ecma_get_completion_value_value (left_value),
-                                                   ecma_get_completion_value_value (right_value));
+  bool is_equal = ecma_op_strict_equality_compare (left_value,
+                                                   right_value);
 
   ret_value = set_variable_value (int_data, int_data->pos, dst_var_idx,
                                   ecma_make_simple_value (is_equal ? ECMA_SIMPLE_VALUE_FALSE
                                                           : ECMA_SIMPLE_VALUE_TRUE));
 
 
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
diff --git a/src/libcoreint/opcodes-ecma-relational.c b/src/libcoreint/opcodes-ecma-relational.c
index 57761ebe9..7d19be7a8 100644
--- a/src/libcoreint/opcodes-ecma-relational.c
+++ b/src/libcoreint/opcodes-ecma-relational.c
@@ -1,4 +1,4 @@
-/* Copyright 2014 Samsung Electronics Co., Ltd.
+/* Copyright 2014-2015 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -34,11 +34,17 @@ opfunc_less_than (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
   ECMA_TRY_CATCH (compare_result,
-                  ecma_op_abstract_relational_compare (ecma_get_completion_value_value (left_value),
-                                                       ecma_get_completion_value_value (right_value),
+                  ecma_op_abstract_relational_compare (left_value,
+                                                       right_value,
                                                        true),
                   ret_value);
 
@@ -58,8 +64,8 @@ opfunc_less_than (opcode_t opdata, /**< operation data */
   ret_value = set_variable_value (int_data, int_data->pos, dst_var_idx, ecma_make_simple_value (res));
 
   ECMA_FINALIZE (compare_result);
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -84,11 +90,17 @@ opfunc_greater_than (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
   ECMA_TRY_CATCH (compare_result,
-                  ecma_op_abstract_relational_compare (ecma_get_completion_value_value (right_value),
-                                                       ecma_get_completion_value_value (left_value),
+                  ecma_op_abstract_relational_compare (right_value,
+                                                       left_value,
                                                        false),
                   ret_value);
 
@@ -108,8 +120,8 @@ opfunc_greater_than (opcode_t opdata, /**< operation data */
   ret_value = set_variable_value (int_data, int_data->pos, dst_var_idx, ecma_make_simple_value (res));
 
   ECMA_FINALIZE (compare_result);
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -134,11 +146,17 @@ opfunc_less_or_equal_than (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
   ECMA_TRY_CATCH (compare_result,
-                  ecma_op_abstract_relational_compare (ecma_get_completion_value_value (right_value),
-                                                       ecma_get_completion_value_value (left_value),
+                  ecma_op_abstract_relational_compare (right_value,
+                                                       left_value,
                                                        false),
                   ret_value);
 
@@ -165,8 +183,8 @@ opfunc_less_or_equal_than (opcode_t opdata, /**< operation data */
   ret_value = set_variable_value (int_data, int_data->pos, dst_var_idx, ecma_make_simple_value (res));
 
   ECMA_FINALIZE (compare_result);
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -191,11 +209,17 @@ opfunc_greater_or_equal_than (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
   ECMA_TRY_CATCH (compare_result,
-                  ecma_op_abstract_relational_compare (ecma_get_completion_value_value (left_value),
-                                                       ecma_get_completion_value_value (right_value),
+                  ecma_op_abstract_relational_compare (left_value,
+                                                       right_value,
                                                        true),
                   ret_value);
 
@@ -222,8 +246,8 @@ opfunc_greater_or_equal_than (opcode_t opdata, /**< operation data */
   ret_value = set_variable_value (int_data, int_data->pos, dst_var_idx, ecma_make_simple_value (res));
 
   ECMA_FINALIZE (compare_result);
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -248,20 +272,26 @@ opfunc_instanceof (opcode_t opdata __unused, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
-  if (!ecma_is_value_object (ecma_get_completion_value_value (right_value)))
+  if (!ecma_is_value_object (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_object_from_completion_value (right_value);
+    ecma_object_t *right_value_obj_p = ecma_get_object_from_value (right_value);
 
     ECMA_TRY_CATCH (is_instance_of,
                     ecma_op_object_has_instance (right_value_obj_p,
-                                                 ecma_get_completion_value_value (left_value)),
+                                                 left_value),
                     ret_value);
 
     ret_value = set_variable_value (int_data, int_data->pos, dst_idx, ecma_get_completion_value_value (is_instance_of));
@@ -269,8 +299,8 @@ opfunc_instanceof (opcode_t opdata __unused, /**< operation data */
     ECMA_FINALIZE (is_instance_of);
   }
 
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -295,20 +325,26 @@ opfunc_in (opcode_t opdata __unused, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  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_STACKED (left_value,
+                          get_variable_value (int_data, left_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
-  if (!ecma_is_value_object (ecma_get_completion_value_value (right_value)))
+  if (!ecma_is_value_object (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 (ecma_get_completion_value_value (left_value)), ret_value);
+    ECMA_TRY_CATCH (str_left_value, ecma_op_to_string (left_value), ret_value);
 
     ecma_simple_value_t is_in = ECMA_SIMPLE_VALUE_UNDEFINED;
     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);
+    ecma_object_t *right_value_obj_p = ecma_get_object_from_value (right_value);
 
     if (ecma_op_object_get_property (right_value_obj_p, left_value_prop_name_p) != NULL)
     {
@@ -326,8 +362,8 @@ opfunc_in (opcode_t opdata __unused, /**< operation data */
     ECMA_FINALIZE (str_left_value);
   }
 
-  ECMA_FINALIZE (right_value);
-  ECMA_FINALIZE (left_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (left_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
diff --git a/src/libcoreint/opcodes-ecma-support.h b/src/libcoreint/opcodes-ecma-support.h
index 99d989f24..2b6bd1703 100644
--- a/src/libcoreint/opcodes-ecma-support.h
+++ b/src/libcoreint/opcodes-ecma-support.h
@@ -1,4 +1,4 @@
-/* Copyright 2014 Samsung Electronics Co., Ltd.
+/* Copyright 2014-2015 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -34,7 +34,7 @@
 #include "deserializer.h"
 
 bool is_reg_variable (int_data_t *int_data, idx_t var_idx);
-ecma_completion_value_t get_variable_value (int_data_t *, idx_t, bool);
+ecma_completion_type_t get_variable_value (int_data_t *, idx_t, bool);
 ecma_completion_value_t set_variable_value (int_data_t *, opcode_counter_t, idx_t, ecma_value_t);
 ecma_completion_value_t fill_varg_list (int_data_t *int_data,
                                         ecma_length_t args_number,
diff --git a/src/libcoreint/opcodes-helpers-variables.c b/src/libcoreint/opcodes-helpers-variables.c
index e2d46973f..2a7a0296f 100644
--- a/src/libcoreint/opcodes-helpers-variables.c
+++ b/src/libcoreint/opcodes-helpers-variables.c
@@ -1,4 +1,4 @@
-/* Copyright 2014 Samsung Electronics Co., Ltd.
+/* Copyright 2014-2015 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -68,16 +68,15 @@ is_reg_variable (int_data_t *int_data, /**< interpreter context */
 /**
  * Get variable's value.
  *
- * @return completion value
- *         Returned value must be freed with ecma_free_completion_value
+ * @return /stack convention/
  */
-ecma_completion_value_t
+ecma_completion_type_t
 get_variable_value (int_data_t *int_data, /**< interpreter context */
                     idx_t var_idx, /**< variable identifier */
                     bool do_eval_or_arguments_check) /** run 'strict eval or arguments reference' check
                                                           See also: do_strict_eval_arguments_check */
 {
-  ecma_completion_value_t ret_value;
+  ecma_completion_type_t completion_type;
 
   if (is_reg_variable (int_data, var_idx))
   {
@@ -85,7 +84,10 @@ get_variable_value (int_data_t *int_data, /**< interpreter context */
 
     JERRY_ASSERT (!ecma_is_value_empty (reg_value));
 
-    ret_value = ecma_make_normal_completion_value (ecma_copy_value (reg_value, true));
+    ecma_stack_push_value (int_data->stack_frame_p,
+                           ecma_copy_value (reg_value, true));
+
+    completion_type = ECMA_COMPLETION_TYPE_NORMAL;
   }
   else
   {
@@ -106,14 +108,19 @@ get_variable_value (int_data_t *int_data, /**< interpreter context */
 #endif /* !JERRY_NDEBUG */
     }
 
-    ret_value = ecma_op_get_value_lex_env_base (ref_base_lex_env_p,
-                                                &var_name_string,
-                                                int_data->is_strict);
+    ecma_completion_value_t completion = ecma_op_get_value_lex_env_base (ref_base_lex_env_p,
+                                                                         &var_name_string,
+                                                                         int_data->is_strict);
+
+    ecma_stack_push_value (int_data->stack_frame_p,
+                           ecma_get_completion_value_value (completion));
 
     ecma_check_that_ecma_string_need_not_be_freed (&var_name_string);
+
+    completion_type = ecma_get_completion_value_type (completion);
   }
 
-  return ret_value;
+  return completion_type;
 } /* get_variable_value */
 
 /**
diff --git a/src/libcoreint/opcodes-varg.c b/src/libcoreint/opcodes-varg.c
index aa807b623..5b50dac08 100644
--- a/src/libcoreint/opcodes-varg.c
+++ b/src/libcoreint/opcodes-varg.c
@@ -1,4 +1,4 @@
-/* Copyright 2014 Samsung Electronics Co., Ltd.
+/* Copyright 2014-2015 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -31,7 +31,7 @@ fill_varg_list (int_data_t *int_data, /**< interpreter context */
                 ecma_length_t args_number, /**< number of arguments */
                 ecma_value_t arg_values[], /**< out: arguments' values */
                 ecma_length_t *out_arg_number_p) /**< out: number of arguments
-                                                      successfully read */
+                                                           successfully read */
 {
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
@@ -50,16 +50,14 @@ fill_varg_list (int_data_t *int_data, /**< interpreter context */
 
       const idx_t varg_var_idx = next_opcode.data.meta.data_1;
 
-      ecma_completion_value_t get_arg_completion = get_variable_value (int_data, varg_var_idx, false);
+      ECMA_TRY_CATCH_STACKED (arg,
+                              get_variable_value (int_data, varg_var_idx, false),
+                              ret_value,
+                              int_data->stack_frame_p);
 
-      if (ecma_is_completion_value_normal (get_arg_completion))
-      {
-        arg_values[arg_index] = ecma_get_completion_value_value (get_arg_completion);
-      }
-      else
-      {
-        ret_value = get_arg_completion;
-      }
+      arg_values[arg_index] = ecma_copy_value (arg, true);
+
+      ECMA_FINALIZE_STACKED (arg, int_data->stack_frame_p);
     }
     else
     {
diff --git a/src/libcoreint/opcodes.c b/src/libcoreint/opcodes.c
index 6751825e3..3c3d55c8e 100644
--- a/src/libcoreint/opcodes.c
+++ b/src/libcoreint/opcodes.c
@@ -1,4 +1,4 @@
-/* Copyright 2014 Samsung Electronics Co., Ltd.
+/* Copyright 2014-2015 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -110,18 +110,19 @@ opfunc_assignment (opcode_t opdata, /**< operation data */
   }
   else if (type_value_right == OPCODE_ARG_TYPE_VARIABLE)
   {
-    ECMA_TRY_CATCH (get_value_completion,
-                    get_variable_value (int_data,
-                                        src_val_descr,
-                                        false),
-                    ret_value);
+    ECMA_TRY_CATCH_STACKED (get_value_completion,
+                            get_variable_value (int_data,
+                                                src_val_descr,
+                                                false),
+                            ret_value,
+                            int_data->stack_frame_p);
 
     ret_value = set_variable_value (int_data,
                                     int_data->pos,
                                     dst_var_idx,
-                                    ecma_get_completion_value_value (get_value_completion));
+                                    get_value_completion);
 
-    ECMA_FINALIZE (get_value_completion);
+    ECMA_FINALIZE_STACKED (get_value_completion, int_data->stack_frame_p);
   }
   else if (type_value_right == OPCODE_ARG_TYPE_NUMBER)
   {
@@ -200,9 +201,12 @@ opfunc_pre_incr (opcode_t opdata, /**< operation data */
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
   // 1., 2., 3.
-  ECMA_TRY_CATCH (old_value, get_variable_value (int_data, incr_var_idx, true), ret_value);
+  ECMA_TRY_CATCH_STACKED (old_value,
+                          get_variable_value (int_data, incr_var_idx, true),
+                          ret_value,
+                          int_data->stack_frame_p);
   ECMA_OP_TO_NUMBER_TRY_CATCH (old_num,
-                               ecma_get_completion_value_value (old_value),
+                               old_value,
                                ret_value);
 
   // 4.
@@ -224,7 +228,7 @@ opfunc_pre_incr (opcode_t opdata, /**< operation data */
   JERRY_ASSERT (ecma_is_completion_value_empty (reg_assignment_res));
 
   ECMA_OP_TO_NUMBER_FINALIZE (old_num);
-  ECMA_FINALIZE (old_value);
+  ECMA_FINALIZE_STACKED (old_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -249,9 +253,12 @@ opfunc_pre_decr (opcode_t opdata, /**< operation data */
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
   // 1., 2., 3.
-  ECMA_TRY_CATCH (old_value, get_variable_value (int_data, decr_var_idx, true), ret_value);
+  ECMA_TRY_CATCH_STACKED (old_value,
+                          get_variable_value (int_data, decr_var_idx, true),
+                          ret_value,
+                          int_data->stack_frame_p);
   ECMA_OP_TO_NUMBER_TRY_CATCH (old_num,
-                               ecma_get_completion_value_value (old_value),
+                               old_value,
                                ret_value);
 
   // 4.
@@ -273,7 +280,7 @@ opfunc_pre_decr (opcode_t opdata, /**< operation data */
   JERRY_ASSERT (ecma_is_completion_value_empty (reg_assignment_res));
 
   ECMA_OP_TO_NUMBER_FINALIZE (old_num);
-  ECMA_FINALIZE (old_value);
+  ECMA_FINALIZE_STACKED (old_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -298,9 +305,12 @@ opfunc_post_incr (opcode_t opdata, /**< operation data */
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
   // 1., 2., 3.
-  ECMA_TRY_CATCH (old_value, get_variable_value (int_data, incr_var_idx, true), ret_value);
+  ECMA_TRY_CATCH_STACKED (old_value,
+                          get_variable_value (int_data, incr_var_idx, true),
+                          ret_value,
+                          int_data->stack_frame_p);
   ECMA_OP_TO_NUMBER_TRY_CATCH (old_num,
-                               ecma_get_completion_value_value (old_value),
+                               old_value,
                                ret_value);
 
   // 4.
@@ -323,7 +333,7 @@ opfunc_post_incr (opcode_t opdata, /**< operation data */
   JERRY_ASSERT (ecma_is_completion_value_empty (reg_assignment_res));
 
   ECMA_OP_TO_NUMBER_FINALIZE (old_num);
-  ECMA_FINALIZE (old_value);
+  ECMA_FINALIZE_STACKED (old_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -348,9 +358,12 @@ opfunc_post_decr (opcode_t opdata, /**< operation data */
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
   // 1., 2., 3.
-  ECMA_TRY_CATCH (old_value, get_variable_value (int_data, decr_var_idx, true), ret_value);
+  ECMA_TRY_CATCH_STACKED (old_value,
+                          get_variable_value (int_data, decr_var_idx, true),
+                          ret_value,
+                          int_data->stack_frame_p);
   ECMA_OP_TO_NUMBER_TRY_CATCH (old_num,
-                               ecma_get_completion_value_value (old_value),
+                               old_value,
                                ret_value);
 
   // 4.
@@ -373,7 +386,7 @@ opfunc_post_decr (opcode_t opdata, /**< operation data */
   JERRY_ASSERT (ecma_is_completion_value_empty (reg_assignment_res));
 
   ECMA_OP_TO_NUMBER_FINALIZE (old_num);
-  ECMA_FINALIZE (old_value);
+  ECMA_FINALIZE_STACKED (old_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -638,7 +651,10 @@ opfunc_call_n (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  ECMA_TRY_CATCH (func_value, get_variable_value (int_data, func_name_lit_idx, false), ret_value);
+  ECMA_TRY_CATCH_STACKED (func_value,
+                          get_variable_value (int_data, func_name_lit_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -681,7 +697,12 @@ opfunc_call_n (opcode_t opdata, /**< operation data */
 
     if (this_arg_var_idx_set)
     {
-      this_value = get_variable_value (int_data, this_arg_var_idx, false);
+      ecma_completion_type_t type = get_variable_value (int_data, this_arg_var_idx, false);
+      JERRY_ASSERT (type == ECMA_COMPLETION_TYPE_NORMAL);
+
+      this_value = ecma_make_normal_completion_value (ecma_copy_value (ecma_stack_top_value (int_data->stack_frame_p),
+                                                                       true));
+      ecma_stack_pop (int_data->stack_frame_p);
     }
     else
     {
@@ -689,13 +710,13 @@ opfunc_call_n (opcode_t opdata, /**< operation data */
     }
     JERRY_ASSERT (ecma_is_completion_value_normal (this_value));
 
-    if (!ecma_op_is_callable (ecma_get_completion_value_value (func_value)))
+    if (!ecma_op_is_callable (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_object_from_completion_value (func_value);
+      ecma_object_t *func_obj_p = ecma_get_object_from_value (func_value);
 
       ECMA_TRY_CATCH (call_completion,
                       ecma_op_function_call (func_obj_p,
@@ -730,7 +751,7 @@ opfunc_call_n (opcode_t opdata, /**< operation data */
 
   MEM_FINALIZE_LOCAL_ARRAY (arg_values);
 
-  ECMA_FINALIZE (func_value);
+  ECMA_FINALIZE_STACKED (func_value, int_data->stack_frame_p);
 
   return ret_value;
 } /* opfunc_call_n */
@@ -753,9 +774,10 @@ opfunc_construct_n (opcode_t opdata, /**< operation data */
   const opcode_counter_t lit_oc = int_data->pos;
 
   ecma_completion_value_t ret_value;
-  ECMA_TRY_CATCH (constructor_value,
-                  get_variable_value (int_data, constructor_name_lit_idx, false),
-                  ret_value);
+  ECMA_TRY_CATCH_STACKED (constructor_value,
+                          get_variable_value (int_data, constructor_name_lit_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
   MEM_DEFINE_LOCAL_ARRAY (arg_values, args_number, ecma_value_t);
 
@@ -771,13 +793,13 @@ opfunc_construct_n (opcode_t opdata, /**< operation data */
   {
     JERRY_ASSERT (args_read == args_number);
 
-    if (!ecma_is_constructor (ecma_get_completion_value_value (constructor_value)))
+    if (!ecma_is_constructor (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_object_from_completion_value (constructor_value);
+      ecma_object_t *constructor_obj_p = ecma_get_object_from_value (constructor_value);
 
       ECMA_TRY_CATCH (construction_completion,
                       ecma_op_function_construct (constructor_obj_p,
@@ -807,7 +829,7 @@ opfunc_construct_n (opcode_t opdata, /**< operation data */
 
   MEM_FINALIZE_LOCAL_ARRAY (arg_values);
 
-  ECMA_FINALIZE (constructor_value);
+  ECMA_FINALIZE_STACKED (constructor_value, int_data->stack_frame_p);
 
   return ret_value;
 } /* opfunc_construct_n */
@@ -919,105 +941,99 @@ opfunc_obj_decl (opcode_t opdata, /**< operation data */
       const idx_t prop_name_var_idx = next_opcode.data.meta.data_1;
       const idx_t value_for_prop_desc_var_idx = next_opcode.data.meta.data_2;
 
-      ecma_completion_value_t value_for_prop_desc = get_variable_value (int_data,
-                                                                        value_for_prop_desc_var_idx,
-                                                                        false);
+      ECMA_TRY_CATCH_STACKED (value_for_prop_desc,
+                              get_variable_value (int_data,
+                                                  value_for_prop_desc_var_idx,
+                                                  false),
+                              completion,
+                              int_data->stack_frame_p);
 
-      if (ecma_is_completion_value_normal (value_for_prop_desc))
+      JERRY_ASSERT (is_reg_variable (int_data, prop_name_var_idx));
+
+      ECMA_TRY_CATCH_STACKED (prop_name_value,
+                              get_variable_value (int_data,
+                                                  prop_name_var_idx,
+                                                  false),
+                              ret_value,
+                              int_data->stack_frame_p);
+      ECMA_TRY_CATCH (prop_name_str_value,
+                      ecma_op_to_string (prop_name_value),
+                      ret_value);
+
+      bool is_throw_syntax_error = false;
+
+      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);
+      const bool is_previous_data_desc = (!is_previous_undefined
+                                          && previous_p->type == ECMA_PROPERTY_NAMEDDATA);
+      const bool is_previous_accessor_desc = (!is_previous_undefined
+                                              && previous_p->type == ECMA_PROPERTY_NAMEDACCESSOR);
+      JERRY_ASSERT (is_previous_undefined || is_previous_data_desc || is_previous_accessor_desc);
+
+      ecma_property_descriptor_t prop_desc = ecma_make_empty_property_descriptor ();
       {
-        JERRY_ASSERT (is_reg_variable (int_data, prop_name_var_idx));
+        prop_desc.is_enumerable_defined = true;
+        prop_desc.is_enumerable = true;
 
-        ECMA_TRY_CATCH (prop_name_value,
-                        get_variable_value (int_data,
-                                            prop_name_var_idx,
-                                            false),
-                        ret_value);
-        ECMA_TRY_CATCH (prop_name_str_value,
-                        ecma_op_to_string (ecma_get_completion_value_value (prop_name_value)),
-                        ret_value);
+        prop_desc.is_configurable_defined = true;
+        prop_desc.is_configurable = true;
+      }
 
-        bool is_throw_syntax_error = false;
+      if (type == OPCODE_META_TYPE_VARG_PROP_DATA)
+      {
+        prop_desc.is_value_defined = true;
+        prop_desc.value = value_for_prop_desc;
 
-        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);
+        prop_desc.is_writable_defined = true;
+        prop_desc.is_writable = true;
 
-        const bool is_previous_undefined = (previous_p == NULL);
-        const bool is_previous_data_desc = (!is_previous_undefined
-                                            && previous_p->type == ECMA_PROPERTY_NAMEDDATA);
-        const bool is_previous_accessor_desc = (!is_previous_undefined
-                                                && previous_p->type == ECMA_PROPERTY_NAMEDACCESSOR);
-        JERRY_ASSERT (is_previous_undefined || is_previous_data_desc || is_previous_accessor_desc);
-
-        ecma_property_descriptor_t prop_desc = ecma_make_empty_property_descriptor ();
+        if (!is_previous_undefined
+            && ((is_previous_data_desc
+                 && int_data->is_strict)
+                || is_previous_accessor_desc))
         {
-          prop_desc.is_enumerable_defined = true;
-          prop_desc.is_enumerable = true;
-
-          prop_desc.is_configurable_defined = true;
-          prop_desc.is_configurable = true;
+          is_throw_syntax_error = true;
         }
+      }
+      else if (type == OPCODE_META_TYPE_VARG_PROP_GETTER)
+      {
+        prop_desc.is_get_defined = true;
+        prop_desc.get_p = ecma_get_object_from_value (value_for_prop_desc);
 
-        if (type == OPCODE_META_TYPE_VARG_PROP_DATA)
+        if (!is_previous_undefined
+            && is_previous_data_desc)
         {
-          prop_desc.is_value_defined = true;
-          prop_desc.value = ecma_get_completion_value_value (value_for_prop_desc);
-
-          prop_desc.is_writable_defined = true;
-          prop_desc.is_writable = true;
-
-          if (!is_previous_undefined
-              && ((is_previous_data_desc
-                   && int_data->is_strict)
-                  || is_previous_accessor_desc))
-          {
-            is_throw_syntax_error = true;
-          }
+          is_throw_syntax_error = true;
         }
-        else if (type == OPCODE_META_TYPE_VARG_PROP_GETTER)
-        {
-          prop_desc.is_get_defined = true;
-          prop_desc.get_p = ecma_get_object_from_completion_value (value_for_prop_desc);
-
-          if (!is_previous_undefined
-              && is_previous_data_desc)
-          {
-            is_throw_syntax_error = true;
-          }
-        }
-        else
-        {
-          prop_desc.is_set_defined = true;
-          prop_desc.set_p = ecma_get_object_from_completion_value (value_for_prop_desc);
-
-          if (!is_previous_undefined
-              && is_previous_data_desc)
-          {
-            is_throw_syntax_error = true;
-          }
-        }
-
-        /* The SyntaxError should be treated as an early error  */
-        JERRY_ASSERT (!is_throw_syntax_error);
-
-        ecma_completion_value_t define_prop_completion = ecma_op_object_define_own_property (obj_p,
-                                                                                             prop_name_string_p,
-                                                                                             &prop_desc,
-                                                                                             false);
-        JERRY_ASSERT (ecma_is_completion_value_normal_true (define_prop_completion)
-                      || ecma_is_completion_value_normal_false (define_prop_completion));
-
-        ecma_free_completion_value (value_for_prop_desc);
-
-        ECMA_FINALIZE (prop_name_str_value);
-        ECMA_FINALIZE (prop_name_value);
       }
       else
       {
-        completion = value_for_prop_desc;
+        prop_desc.is_set_defined = true;
+        prop_desc.set_p = ecma_get_object_from_value (value_for_prop_desc);
 
-        break;
+        if (!is_previous_undefined
+            && is_previous_data_desc)
+        {
+          is_throw_syntax_error = true;
+        }
       }
 
+      /* The SyntaxError should be treated as an early error  */
+      JERRY_ASSERT (!is_throw_syntax_error);
+
+      ecma_completion_value_t define_prop_completion = ecma_op_object_define_own_property (obj_p,
+                                                                                           prop_name_string_p,
+                                                                                           &prop_desc,
+                                                                                           false);
+      JERRY_ASSERT (ecma_is_completion_value_normal_true (define_prop_completion)
+                    || ecma_is_completion_value_normal_false (define_prop_completion));
+
+      ECMA_FINALIZE (prop_name_str_value);
+      ECMA_FINALIZE_STACKED (prop_name_value, int_data->stack_frame_p);
+      ECMA_FINALIZE_STACKED (value_for_prop_desc, int_data->stack_frame_p);
+
       int_data->pos++;
     }
     else
@@ -1074,11 +1090,14 @@ opfunc_retval (opcode_t opdata __unused, /**< operation data */
 {
   ecma_completion_value_t ret_value;
 
-  ECMA_TRY_CATCH (expr_val, get_variable_value (int_data, opdata.data.retval.ret_value, false), ret_value);
+  ECMA_TRY_CATCH_STACKED (expr_val,
+                          get_variable_value (int_data, opdata.data.retval.ret_value, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
-  ret_value = ecma_make_return_completion_value (ecma_copy_value (ecma_get_completion_value_value (expr_val), true));
+  ret_value = ecma_make_return_completion_value (ecma_copy_value (expr_val, true));
 
-  ECMA_FINALIZE (expr_val);
+  ECMA_FINALIZE_STACKED (expr_val, int_data->stack_frame_p);
 
   return ret_value;
 } /* opfunc_retval */
@@ -1102,21 +1121,23 @@ 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_STACKED (base_value,
+                          get_variable_value (int_data, base_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (prop_name_value,
+                          get_variable_value (int_data, prop_name_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
   ECMA_TRY_CATCH (check_coercible_ret,
-                  ecma_op_check_object_coercible (ecma_get_completion_value_value (base_value)),
+                  ecma_op_check_object_coercible (base_value),
                   ret_value);
   ECMA_TRY_CATCH (prop_name_str_value,
-                  ecma_op_to_string (ecma_get_completion_value_value (prop_name_value)),
+                  ecma_op_to_string (prop_name_value),
                   ret_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),
+  ecma_reference_t ref = ecma_make_reference (base_value,
                                               prop_name_string_p,
                                               int_data->is_strict);
 
@@ -1130,8 +1151,8 @@ opfunc_prop_getter (opcode_t opdata __unused, /**< operation data */
 
   ECMA_FINALIZE (prop_name_str_value);
   ECMA_FINALIZE (check_coercible_ret);
-  ECMA_FINALIZE (prop_name_value);
-  ECMA_FINALIZE (base_value);
+  ECMA_FINALIZE_STACKED (prop_name_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (base_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -1157,34 +1178,39 @@ 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_STACKED (base_value,
+                          get_variable_value (int_data, base_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (prop_name_value,
+                          get_variable_value (int_data, prop_name_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
   ECMA_TRY_CATCH (check_coercible_ret,
-                  ecma_op_check_object_coercible (ecma_get_completion_value_value (base_value)),
+                  ecma_op_check_object_coercible (base_value),
                   ret_value);
   ECMA_TRY_CATCH (prop_name_str_value,
-                  ecma_op_to_string (ecma_get_completion_value_value (prop_name_value)),
+                  ecma_op_to_string (prop_name_value),
                   ret_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),
+  ecma_reference_t ref = ecma_make_reference (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, ecma_get_completion_value_value (rhs_value));
-  ECMA_FINALIZE (rhs_value);
+  ECMA_TRY_CATCH_STACKED (rhs_value,
+                          get_variable_value (int_data, rhs_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ret_value = ecma_op_put_value_object_base (ref, rhs_value);
+  ECMA_FINALIZE_STACKED (rhs_value, int_data->stack_frame_p);
 
   ecma_free_reference (ref);
 
   ECMA_FINALIZE (prop_name_str_value);
   ECMA_FINALIZE (check_coercible_ret);
-  ECMA_FINALIZE (prop_name_value);
-  ECMA_FINALIZE (base_value);
+  ECMA_FINALIZE_STACKED (prop_name_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (base_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -1231,10 +1257,13 @@ opfunc_logical_not (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
+  ECMA_TRY_CATCH_STACKED (right_value,
+                          get_variable_value (int_data, right_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
   ecma_simple_value_t old_value = ECMA_SIMPLE_VALUE_TRUE;
-  ecma_completion_value_t to_bool_value = ecma_op_to_boolean (ecma_get_completion_value_value (right_value));
+  ecma_completion_value_t to_bool_value = ecma_op_to_boolean (right_value);
 
   if (ecma_is_value_true (ecma_get_completion_value_value (to_bool_value)))
   {
@@ -1245,7 +1274,7 @@ opfunc_logical_not (opcode_t opdata, /**< operation data */
                                   dst_var_idx,
                                   ecma_make_simple_value (old_value));
 
-  ECMA_FINALIZE (right_value);
+  ECMA_FINALIZE_STACKED (right_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -1294,13 +1323,14 @@ opfunc_with (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value;
 
-  ECMA_TRY_CATCH (expr_value,
-                  get_variable_value (int_data,
-                                      expr_var_idx,
-                                      false),
-                  ret_value);
+  ECMA_TRY_CATCH_STACKED (expr_value,
+                          get_variable_value (int_data,
+                                              expr_var_idx,
+                                              false),
+                          ret_value,
+                          int_data->stack_frame_p);
   ECMA_TRY_CATCH (obj_expr_value,
-                  ecma_op_to_object (ecma_get_completion_value_value (expr_value)),
+                  ecma_op_to_object (expr_value),
                   ret_value);
 
   int_data->pos++;
@@ -1337,7 +1367,7 @@ opfunc_with (opcode_t opdata, /**< operation data */
   ecma_deref_object (new_env_p);
 
   ECMA_FINALIZE (obj_expr_value);
-  ECMA_FINALIZE (expr_value);
+  ECMA_FINALIZE_STACKED (expr_value, int_data->stack_frame_p);
 
   return ret_value;
 } /* opfunc_with */
@@ -1358,15 +1388,16 @@ opfunc_throw (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_STACKED (var_value,
+                          get_variable_value (int_data,
+                                              var_idx,
+                                              false),
+                          ret_value,
+                          int_data->stack_frame_p);
 
-  ret_value = ecma_make_throw_completion_value (ecma_copy_value (ecma_get_completion_value_value (var_value), true));
+  ret_value = ecma_make_throw_completion_value (ecma_copy_value (var_value, true));
 
-  ECMA_FINALIZE (var_value);
+  ECMA_FINALIZE_STACKED (var_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
@@ -1390,10 +1421,13 @@ evaluate_arg_for_typeof (int_data_t *int_data, /**< interpreter context */
   if (is_reg_variable (int_data, var_idx))
   {
     // 2.b
-    ret_value = get_variable_value (int_data,
-                                    var_idx,
-                                    false);
-    JERRY_ASSERT (ecma_is_completion_value_normal (ret_value));
+    ecma_completion_type_t type = get_variable_value (int_data, var_idx, false);
+    JERRY_ASSERT (type == ECMA_COMPLETION_TYPE_NORMAL);
+
+    ret_value = ecma_make_normal_completion_value (ecma_copy_value (ecma_stack_top_value (int_data->stack_frame_p),
+                                                                    true));
+
+    ecma_stack_pop (int_data->stack_frame_p);
   }
   else
   {
@@ -1579,23 +1613,25 @@ 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_STACKED (base_value,
+                          get_variable_value (int_data, base_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
+  ECMA_TRY_CATCH_STACKED (name_value,
+                          get_variable_value (int_data, name_var_idx, false),
+                          ret_value,
+                          int_data->stack_frame_p);
   ECMA_TRY_CATCH (check_coercible_ret,
-                  ecma_op_check_object_coercible (ecma_get_completion_value_value (base_value)),
+                  ecma_op_check_object_coercible (base_value),
                   ret_value);
   ECMA_TRY_CATCH (str_name_value,
-                  ecma_op_to_string (ecma_get_completion_value_value (name_value)),
+                  ecma_op_to_string (name_value),
                   ret_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 (ecma_get_completion_value_value (base_value)))
+  if (ecma_is_value_undefined (base_value))
   {
     if (int_data->is_strict)
     {
@@ -1609,7 +1645,7 @@ opfunc_delete_prop (opcode_t opdata, /**< operation data */
   }
   else
   {
-    ECMA_TRY_CATCH (obj_value, ecma_op_to_object (ecma_get_completion_value_value (base_value)), ret_value);
+    ECMA_TRY_CATCH (obj_value, ecma_op_to_object (base_value), ret_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);
@@ -1628,8 +1664,8 @@ opfunc_delete_prop (opcode_t opdata, /**< operation data */
 
   ECMA_FINALIZE (str_name_value);
   ECMA_FINALIZE (check_coercible_ret);
-  ECMA_FINALIZE (name_value);
-  ECMA_FINALIZE (base_value);
+  ECMA_FINALIZE_STACKED (name_value, int_data->stack_frame_p);
+  ECMA_FINALIZE_STACKED (base_value, int_data->stack_frame_p);
 
   int_data->pos++;
 
diff --git a/src/libecmaobjects/ecma-helpers-value.c b/src/libecmaobjects/ecma-helpers-value.c
index 96fe78aa2..1690addd1 100644
--- a/src/libecmaobjects/ecma-helpers-value.c
+++ b/src/libecmaobjects/ecma-helpers-value.c
@@ -1,4 +1,4 @@
-/* Copyright 2014 Samsung Electronics Co., Ltd.
+/* Copyright 2014-2015 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -436,13 +436,13 @@ ecma_free_value (ecma_value_t value, /**< value description */
  *
  * @return type field
  */
-static ecma_completion_type_t __attribute_const__
-ecma_get_completion_value_type_field (ecma_completion_value_t completion_value) /**< completion value */
+ecma_completion_type_t __attribute_const__
+ecma_get_completion_value_type (ecma_completion_value_t completion_value) /**< completion value */
 {
   return jrt_extract_bit_field (completion_value,
                                 ECMA_COMPLETION_VALUE_TYPE_POS,
                                 ECMA_COMPLETION_VALUE_TYPE_WIDTH);
-} /* ecma_get_completion_value_type_field */
+} /* ecma_get_completion_value_type */
 
 /**
  * Get value field of completion value
@@ -702,7 +702,7 @@ ecma_make_meta_completion_value (void)
 inline ecma_value_t __attribute_const__ __attribute_always_inline__
 ecma_get_completion_value_value (ecma_completion_value_t completion_value) /**< completion value */
 {
-  const ecma_completion_type_t type = ecma_get_completion_value_type_field (completion_value);
+  const ecma_completion_type_t type = ecma_get_completion_value_type (completion_value);
 
   const bool is_type_ok = (type == ECMA_COMPLETION_TYPE_NORMAL
 #ifdef CONFIG_ECMA_EXCEPTION_SUPPORT
@@ -757,7 +757,7 @@ ecma_get_object_from_completion_value (ecma_completion_value_t completion_value)
 ecma_completion_value_t
 ecma_copy_completion_value (ecma_completion_value_t value) /**< completion value */
 {
-  const ecma_completion_type_t type = ecma_get_completion_value_type_field (value);
+  const ecma_completion_type_t type = ecma_get_completion_value_type (value);
   const bool is_type_ok = (type == ECMA_COMPLETION_TYPE_NORMAL
 #ifdef CONFIG_ECMA_EXCEPTION_SUPPORT
                            || type == ECMA_COMPLETION_TYPE_THROW
@@ -778,7 +778,7 @@ ecma_copy_completion_value (ecma_completion_value_t value) /**< completion value
 void
 ecma_free_completion_value (ecma_completion_value_t completion_value) /**< completion value */
 {
-  switch (ecma_get_completion_value_type_field (completion_value))
+  switch (ecma_get_completion_value_type (completion_value))
   {
     case ECMA_COMPLETION_TYPE_NORMAL:
 #ifdef CONFIG_ECMA_EXCEPTION_SUPPORT
@@ -816,7 +816,7 @@ ecma_free_completion_value (ecma_completion_value_t completion_value) /**< compl
 inline bool __attribute_const__ __attribute_always_inline__
 ecma_is_completion_value_normal (ecma_completion_value_t value) /**< completion value */
 {
-  return (ecma_get_completion_value_type_field (value) == ECMA_COMPLETION_TYPE_NORMAL);
+  return (ecma_get_completion_value_type (value) == ECMA_COMPLETION_TYPE_NORMAL);
 } /* ecma_is_completion_value_normal */
 
 /**
@@ -829,7 +829,7 @@ inline bool __attribute_const__ __attribute_always_inline__
 ecma_is_completion_value_throw (ecma_completion_value_t value) /**< completion value */
 {
 #ifdef CONFIG_ECMA_EXCEPTION_SUPPORT
-  return (ecma_get_completion_value_type_field (value) == ECMA_COMPLETION_TYPE_THROW);
+  return (ecma_get_completion_value_type (value) == ECMA_COMPLETION_TYPE_THROW);
 #else /* CONFIG_ECMA_EXCEPTION_SUPPORT */
   (void) value;
 
@@ -846,7 +846,7 @@ ecma_is_completion_value_throw (ecma_completion_value_t value) /**< completion v
 inline bool __attribute_const__ __attribute_always_inline__
 ecma_is_completion_value_return (ecma_completion_value_t value) /**< completion value */
 {
-  return (ecma_get_completion_value_type_field (value) == ECMA_COMPLETION_TYPE_RETURN);
+  return (ecma_get_completion_value_type (value) == ECMA_COMPLETION_TYPE_RETURN);
 } /* ecma_is_completion_value_return */
 
 /**
@@ -858,7 +858,7 @@ ecma_is_completion_value_return (ecma_completion_value_t value) /**< completion
 inline bool __attribute_const__ __attribute_always_inline__
 ecma_is_completion_value_exit (ecma_completion_value_t value) /**< completion value */
 {
-  if (ecma_get_completion_value_type_field (value) == ECMA_COMPLETION_TYPE_EXIT)
+  if (ecma_get_completion_value_type (value) == ECMA_COMPLETION_TYPE_EXIT)
   {
     JERRY_ASSERT (ecma_is_value_boolean (ecma_get_completion_value_value_field (value)));
 
@@ -879,7 +879,7 @@ ecma_is_completion_value_exit (ecma_completion_value_t value) /**< completion va
 inline bool __attribute_const__ __attribute_always_inline__
 ecma_is_completion_value_meta (ecma_completion_value_t value) /**< completion value */
 {
-  if (ecma_get_completion_value_type_field (value) == ECMA_COMPLETION_TYPE_META)
+  if (ecma_get_completion_value_type (value) == ECMA_COMPLETION_TYPE_META)
   {
     JERRY_ASSERT (ecma_is_value_empty (ecma_get_completion_value_value_field (value)));
 
@@ -900,7 +900,7 @@ ecma_is_completion_value_meta (ecma_completion_value_t value) /**< completion va
 inline bool __attribute_const__ __attribute_always_inline__
 ecma_is_completion_value_break (ecma_completion_value_t value) /**< completion value */
 {
-  return (ecma_get_completion_value_type_field (value) == ECMA_COMPLETION_TYPE_BREAK);
+  return (ecma_get_completion_value_type (value) == ECMA_COMPLETION_TYPE_BREAK);
 } /* ecma_is_completion_value_break */
 
 /**
@@ -912,7 +912,7 @@ ecma_is_completion_value_break (ecma_completion_value_t value) /**< completion v
 inline bool __attribute_const__ __attribute_always_inline__
 ecma_is_completion_value_continue (ecma_completion_value_t value) /**< completion value */
 {
-  return (ecma_get_completion_value_type_field (value) == ECMA_COMPLETION_TYPE_CONTINUE);
+  return (ecma_get_completion_value_type (value) == ECMA_COMPLETION_TYPE_CONTINUE);
 } /* ecma_is_completion_value_continue */
 
 /**
diff --git a/src/libecmaobjects/ecma-helpers.h b/src/libecmaobjects/ecma-helpers.h
index f2302065d..c20290d78 100644
--- a/src/libecmaobjects/ecma-helpers.h
+++ b/src/libecmaobjects/ecma-helpers.h
@@ -1,4 +1,4 @@
-/* Copyright 2014 Samsung Electronics Co., Ltd.
+/* Copyright 2014-2015 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -96,6 +96,8 @@ 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_completion_type_t __attribute_const__
+ecma_get_completion_value_type (ecma_completion_value_t completion_value);
 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);
diff --git a/src/libecmaobjects/ecma-stack.c b/src/libecmaobjects/ecma-stack.c
index ecfebb319..26fa19e0c 100644
--- a/src/libecmaobjects/ecma-stack.c
+++ b/src/libecmaobjects/ecma-stack.c
@@ -70,6 +70,10 @@ ecma_stack_add_frame (ecma_stack_frame_t *frame_p) /**< frame to initialize */
   frame_p->top_chunk_p = NULL;
   frame_p->dynamically_allocated_value_slots_p = frame_p->inlined_values;
   frame_p->current_slot_index = 0;
+
+#ifndef JERRY_NDEBUG
+  frame_p->items_number = 0;
+#endif /* !JERRY_NDEBUG */
 } /* ecma_stack_add_frame */
 
 /**
@@ -134,6 +138,10 @@ void
 ecma_stack_push_value (ecma_stack_frame_t *frame_p, /**< ecma-stack frame */
                        ecma_value_t value) /**< ecma-value */
 {
+#ifndef JERRY_NDEBUG
+  frame_p->items_number++;
+#endif /* !JERRY_NDEBUG */
+
   frame_p->current_slot_index++;
 
   if (frame_p->current_slot_index >= JERRY_MIN (ECMA_STACK_FRAME_INLINED_VALUES_NUMBER,
@@ -150,9 +158,13 @@ ecma_stack_push_value (ecma_stack_frame_t *frame_p, /**< ecma-stack frame */
 /**
  * Get top value from ecma-stack
  */
-inline ecma_value_t __attribute_always_inline__
+ecma_value_t
 ecma_stack_top_value (ecma_stack_frame_t *frame_p) /**< ecma-stack frame */
 {
+#ifndef JERRY_NDEBUG
+  JERRY_ASSERT (frame_p->items_number > 0);
+#endif /* !JERRY_NDEBUG */
+
   const size_t slots_in_top_chunk = ecma_stack_slots_in_top_chunk (frame_p);
 
   JERRY_ASSERT (frame_p->current_slot_index < slots_in_top_chunk);
@@ -205,6 +217,12 @@ ecma_stack_pop (ecma_stack_frame_t *frame_p) /**< ecma-stack frame */
     frame_p->current_slot_index--;
   }
 
+#ifndef JERRY_NDEBUG
+  JERRY_ASSERT (frame_p->items_number > 0);
+
+  frame_p->items_number--;
+#endif /* !JERRY_NDEBUG */
+
   ecma_free_value (value, true);
 } /* ecma_stack_pop */
 
diff --git a/src/libecmaobjects/ecma-stack.h b/src/libecmaobjects/ecma-stack.h
index cdaede590..279eb72bf 100644
--- a/src/libecmaobjects/ecma-stack.h
+++ b/src/libecmaobjects/ecma-stack.h
@@ -52,6 +52,10 @@ typedef struct ecma_stack_frame_t
   ecma_value_t inlined_values [ECMA_STACK_FRAME_INLINED_VALUES_NUMBER]; /**< place for values inlined in stack frame
                                                                          *   (instead of being dynamically allocated
                                                                          *   on the heap) */
+
+#ifndef JERRY_NDEBUG
+  uint32_t items_number; /**< number of items pushed on the current frame */
+#endif /* !JERRY_NDEBUG */
 } ecma_stack_frame_t;
 
 extern void ecma_stack_init (void);
diff --git a/src/libecmaoperations/ecma-try-catch-macro.h b/src/libecmaoperations/ecma-try-catch-macro.h
index c469433d4..d2cdd62ce 100644
--- a/src/libecmaoperations/ecma-try-catch-macro.h
+++ b/src/libecmaoperations/ecma-try-catch-macro.h
@@ -28,6 +28,9 @@
  * Note:
  *      Each ECMA_TRY_CATCH should have it's own corresponding ECMA_FINALIZE
  *      statement with same argument as corresponding ECMA_TRY_CATCH's first argument.
+ *
+ * See also:
+ *          ECMA_TRY_CATCH_STACKED
  */
 #define ECMA_TRY_CATCH(var, op, return_value) \
   ecma_completion_value_t var = op; \
@@ -46,10 +49,36 @@
  * Note:
  *      Each ECMA_TRY_CATCH should be followed by ECMA_FINALIZE with same argument
  *      as corresponding ECMA_TRY_CATCH's first argument.
+ *
+ * See also:
+ *          ECMA_FINALIZE_STACKED
  */
 #define ECMA_FINALIZE(var) ecma_free_completion_value (var); \
   }
 
+/**
+ * ECMA_TRY_CATCH for stack convention
+ */
+#define ECMA_TRY_CATCH_STACKED(var, op, return_value, frame_p) \
+  ecma_completion_type_t var ## completion_type = op; \
+  if (unlikely (var ## completion_type != ECMA_COMPLETION_TYPE_NORMAL)) \
+  { \
+    JERRY_ASSERT (var ## completion_type == ECMA_COMPLETION_TYPE_THROW); \
+    return_value = ecma_make_completion_value (var ## completion_type, \
+                                               ecma_copy_value (ecma_stack_top_value (frame_p), true)); \
+  } \
+  else \
+  { \
+    ecma_value_t var = ecma_stack_top_value (frame_p); \
+
+/**
+ * ECMA_FINALIZE for stack convention
+ */
+#define ECMA_FINALIZE_STACKED(var, frame_p) (void) var; \
+  } \
+  (void) var ## completion_type; \
+  ecma_stack_pop (frame_p) \
+
 /**
  * The macro defines try-block that tries to perform ToNumber operation on given value
  * and checks for exceptions that might be thrown during the operation.