diff --git a/jerry-core/vm/opcodes-agnostic.cpp b/jerry-core/vm/opcodes-agnostic.cpp
index 8694db8f2..51ee60ede 100644
--- a/jerry-core/vm/opcodes-agnostic.cpp
+++ b/jerry-core/vm/opcodes-agnostic.cpp
@@ -25,7 +25,7 @@
  */
 ecma_completion_value_t
 opfunc_is_true_jmp_down (opcode_t opdata, /**< operation data */
-                         int_data_t *int_data) /**< interpreter context */
+                         vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t cond_var_idx = opdata.data.is_true_jmp_down.value;
   const opcode_counter_t offset = calc_opcode_counter_from_idx_idx (opdata.data.is_true_jmp_down.opcode_1,
@@ -33,19 +33,19 @@ opfunc_is_true_jmp_down (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
-  ECMA_TRY_CATCH (cond_value, get_variable_value (int_data, cond_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (cond_value, get_variable_value (frame_ctx_p, cond_var_idx, false), ret_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_completion_value_normal_true (to_bool_completion))
   {
-    JERRY_ASSERT ((uint32_t) int_data->pos + offset < MAX_OPCODES);
-    int_data->pos = (opcode_counter_t) (int_data->pos + offset);
+    JERRY_ASSERT ((uint32_t) frame_ctx_p->pos + offset < MAX_OPCODES);
+    frame_ctx_p->pos = (opcode_counter_t) (frame_ctx_p->pos + offset);
   }
   else
   {
-    int_data->pos++;
+    frame_ctx_p->pos++;
   }
 
   ret_value = ecma_make_empty_completion_value ();
@@ -58,7 +58,7 @@ opfunc_is_true_jmp_down (opcode_t opdata, /**< operation data */
 /* Likewise to opfunc_is_true_jmp_down, but jumps up.  */
 ecma_completion_value_t
 opfunc_is_true_jmp_up (opcode_t opdata, /**< operation data */
-                       int_data_t *int_data) /**< interpreter context */
+                       vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t cond_var_idx = opdata.data.is_true_jmp_up.value;
   const opcode_counter_t offset = calc_opcode_counter_from_idx_idx (opdata.data.is_true_jmp_up.opcode_1,
@@ -66,19 +66,19 @@ opfunc_is_true_jmp_up (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
-  ECMA_TRY_CATCH (cond_value, get_variable_value (int_data, cond_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (cond_value, get_variable_value (frame_ctx_p, cond_var_idx, false), ret_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_completion_value_normal_true (to_bool_completion))
   {
-    JERRY_ASSERT ((uint32_t) int_data->pos >= offset);
-    int_data->pos = (opcode_counter_t) (int_data->pos - offset);
+    JERRY_ASSERT ((uint32_t) frame_ctx_p->pos >= offset);
+    frame_ctx_p->pos = (opcode_counter_t) (frame_ctx_p->pos - offset);
   }
   else
   {
-    int_data->pos++;
+    frame_ctx_p->pos++;
   }
 
   ret_value = ecma_make_empty_completion_value ();
@@ -97,7 +97,7 @@ opfunc_is_true_jmp_up (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_is_false_jmp_down (opcode_t opdata, /**< operation data */
-                          int_data_t *int_data) /**< interpreter context */
+                          vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t cond_var_idx = opdata.data.is_false_jmp_down.value;
   const opcode_counter_t offset = calc_opcode_counter_from_idx_idx (opdata.data.is_false_jmp_down.opcode_1,
@@ -105,19 +105,19 @@ opfunc_is_false_jmp_down (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
-  ECMA_TRY_CATCH (cond_value, get_variable_value (int_data, cond_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (cond_value, get_variable_value (frame_ctx_p, cond_var_idx, false), ret_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_completion_value_normal_true (to_bool_completion))
   {
-    JERRY_ASSERT ((uint32_t) int_data->pos + offset < MAX_OPCODES);
-    int_data->pos = (opcode_counter_t) (int_data->pos + offset);
+    JERRY_ASSERT ((uint32_t) frame_ctx_p->pos + offset < MAX_OPCODES);
+    frame_ctx_p->pos = (opcode_counter_t) (frame_ctx_p->pos + offset);
   }
   else
   {
-    int_data->pos++;
+    frame_ctx_p->pos++;
   }
 
   ret_value = ecma_make_empty_completion_value ();
@@ -130,7 +130,7 @@ opfunc_is_false_jmp_down (opcode_t opdata, /**< operation data */
 /* Likewise to opfunc_is_false_jmp_down, but jumps up.  */
 ecma_completion_value_t
 opfunc_is_false_jmp_up (opcode_t opdata, /**< operation data */
-                        int_data_t *int_data) /**< interpreter context */
+                        vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t cond_var_idx = opdata.data.is_false_jmp_up.value;
   const opcode_counter_t offset = calc_opcode_counter_from_idx_idx (opdata.data.is_false_jmp_up.opcode_1,
@@ -138,19 +138,19 @@ opfunc_is_false_jmp_up (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
-  ECMA_TRY_CATCH (cond_value, get_variable_value (int_data, cond_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (cond_value, get_variable_value (frame_ctx_p, cond_var_idx, false), ret_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_completion_value_normal_true (to_bool_completion))
   {
-    JERRY_ASSERT ((uint32_t) int_data->pos >= offset);
-    int_data->pos = (opcode_counter_t) (int_data->pos - offset);
+    JERRY_ASSERT ((uint32_t) frame_ctx_p->pos >= offset);
+    frame_ctx_p->pos = (opcode_counter_t) (frame_ctx_p->pos - offset);
   }
   else
   {
-    int_data->pos++;
+    frame_ctx_p->pos++;
   }
 
   ret_value = ecma_make_empty_completion_value ();
@@ -168,14 +168,14 @@ opfunc_is_false_jmp_up (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_jmp_down (opcode_t opdata, /**< operation data */
-                 int_data_t *int_data) /**< interpreter context */
+                 vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const opcode_counter_t offset = calc_opcode_counter_from_idx_idx (opdata.data.jmp_down.opcode_1,
                                                                     opdata.data.jmp_down.opcode_2);
 
-  JERRY_ASSERT (((uint32_t) int_data->pos + offset < MAX_OPCODES));
+  JERRY_ASSERT (((uint32_t) frame_ctx_p->pos + offset < MAX_OPCODES));
 
-  int_data->pos = (opcode_counter_t) (int_data->pos + offset);
+  frame_ctx_p->pos = (opcode_counter_t) (frame_ctx_p->pos + offset);
 
   return ecma_make_empty_completion_value ();
 }
@@ -188,13 +188,13 @@ opfunc_jmp_down (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_jmp_up (opcode_t opdata, /**< operation data */
-               int_data_t *int_data) /**< interpreter context */
+               vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const opcode_counter_t offset = calc_opcode_counter_from_idx_idx (opdata.data.jmp_up.opcode_1,
                                                                     opdata.data.jmp_up.opcode_2);
-  JERRY_ASSERT ((uint32_t) int_data->pos >= offset);
+  JERRY_ASSERT ((uint32_t) frame_ctx_p->pos >= offset);
 
-  int_data->pos = (opcode_counter_t) (int_data->pos - offset);
+  frame_ctx_p->pos = (opcode_counter_t) (frame_ctx_p->pos - offset);
 
   return ecma_make_empty_completion_value ();
 }
@@ -207,9 +207,9 @@ opfunc_jmp_up (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_jmp_break_continue (opcode_t opdata, /**< operation data */
-                           int_data_t *int_data) /**< interpreter context */
+                           vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
-  opcode_counter_t target = int_data->pos;
+  opcode_counter_t target = frame_ctx_p->pos;
   target = (opcode_counter_t) (target + calc_opcode_counter_from_idx_idx (opdata.data.jmp_down.opcode_1,
                                                                           opdata.data.jmp_down.opcode_2));
 
diff --git a/jerry-core/vm/opcodes-ecma-arithmetics.cpp b/jerry-core/vm/opcodes-ecma-arithmetics.cpp
index d87571e55..ae7ea8f85 100644
--- a/jerry-core/vm/opcodes-ecma-arithmetics.cpp
+++ b/jerry-core/vm/opcodes-ecma-arithmetics.cpp
@@ -42,7 +42,7 @@ typedef enum
  *         Returned value must be freed with ecma_free_completion_value
  */
 static ecma_completion_value_t
-do_number_arithmetic (int_data_t *int_data, /**< interpreter context */
+do_number_arithmetic (vm_frame_ctx_t *frame_ctx_p, /**< interpreter context */
                       idx_t dst_var_idx, /**< destination variable identifier */
                       number_arithmetic_op op, /**< number arithmetic operation */
                       ecma_value_t left_value, /**< left value */
@@ -53,7 +53,7 @@ do_number_arithmetic (int_data_t *int_data, /**< interpreter context */
   ECMA_OP_TO_NUMBER_TRY_CATCH (num_left, left_value, ret_value);
   ECMA_OP_TO_NUMBER_TRY_CATCH (num_right, right_value, ret_value);
 
-  ecma_number_t *res_p = int_data->tmp_num_p;
+  ecma_number_t *res_p = frame_ctx_p->tmp_num_p;
 
   switch (op)
   {
@@ -84,7 +84,7 @@ do_number_arithmetic (int_data_t *int_data, /**< interpreter context */
     }
   }
 
-  ret_value = set_variable_value (int_data, int_data->pos,
+  ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos,
                                   dst_var_idx,
                                   ecma_make_number_value (res_p));
 
@@ -104,7 +104,7 @@ do_number_arithmetic (int_data_t *int_data, /**< interpreter context */
  */
 ecma_completion_value_t
 opfunc_addition (opcode_t opdata, /**< operation data */
-                 int_data_t *int_data) /**< interpreter context */
+                 vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.addition.dst;
   const idx_t left_var_idx = opdata.data.addition.var_left;
@@ -112,8 +112,8 @@ opfunc_addition (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_value);
   ECMA_TRY_CATCH (prim_left_value,
                   ecma_op_to_primitive (left_value,
                                         ECMA_PREFERRED_TYPE_NO),
@@ -134,7 +134,7 @@ opfunc_addition (opcode_t opdata, /**< operation data */
 
     ecma_string_t *concat_str_p = ecma_concat_ecma_strings (string1_p, string2_p);
 
-    ret_value = set_variable_value (int_data, int_data->pos, dst_var_idx, ecma_make_string_value (concat_str_p));
+    ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos, dst_var_idx, ecma_make_string_value (concat_str_p));
 
     ecma_deref_ecma_string (concat_str_p);
 
@@ -143,7 +143,7 @@ opfunc_addition (opcode_t opdata, /**< operation data */
   }
   else
   {
-    ret_value = do_number_arithmetic (int_data,
+    ret_value = do_number_arithmetic (frame_ctx_p,
                                       dst_var_idx,
                                       number_arithmetic_addition,
                                       prim_left_value,
@@ -155,7 +155,7 @@ opfunc_addition (opcode_t opdata, /**< operation data */
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_addition */
@@ -170,7 +170,7 @@ opfunc_addition (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_substraction (opcode_t opdata, /**< operation data */
-                     int_data_t *int_data) /**< interpreter context */
+                     vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.substraction.dst;
   const idx_t left_var_idx = opdata.data.substraction.var_left;
@@ -178,10 +178,10 @@ opfunc_substraction (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_value);
 
-  ret_value = do_number_arithmetic (int_data,
+  ret_value = do_number_arithmetic (frame_ctx_p,
                                     dst_var_idx,
                                     number_arithmetic_substraction,
                                     left_value,
@@ -190,7 +190,7 @@ opfunc_substraction (opcode_t opdata, /**< operation data */
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_substraction */
@@ -205,7 +205,7 @@ opfunc_substraction (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_multiplication (opcode_t opdata, /**< operation data */
-                       int_data_t *int_data) /**< interpreter context */
+                       vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.multiplication.dst;
   const idx_t left_var_idx = opdata.data.multiplication.var_left;
@@ -213,10 +213,10 @@ opfunc_multiplication (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_value);
 
-  ret_value = do_number_arithmetic (int_data,
+  ret_value = do_number_arithmetic (frame_ctx_p,
                                     dst_var_idx,
                                     number_arithmetic_multiplication,
                                     left_value,
@@ -225,7 +225,7 @@ opfunc_multiplication (opcode_t opdata, /**< operation data */
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_multiplication */
@@ -240,7 +240,7 @@ opfunc_multiplication (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_division (opcode_t opdata, /**< operation data */
-                 int_data_t *int_data) /**< interpreter context */
+                 vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.division.dst;
   const idx_t left_var_idx = opdata.data.division.var_left;
@@ -248,10 +248,10 @@ opfunc_division (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_value);
 
-  ret_value = do_number_arithmetic (int_data,
+  ret_value = do_number_arithmetic (frame_ctx_p,
                                     dst_var_idx,
                                     number_arithmetic_division,
                                     left_value,
@@ -260,7 +260,7 @@ opfunc_division (opcode_t opdata, /**< operation data */
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_division */
@@ -275,7 +275,7 @@ opfunc_division (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_remainder (opcode_t opdata, /**< operation data */
-                  int_data_t *int_data) /**< interpreter context */
+                  vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.remainder.dst;
   const idx_t left_var_idx = opdata.data.remainder.var_left;
@@ -283,10 +283,10 @@ opfunc_remainder (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_value);
 
-  ret_value = do_number_arithmetic (int_data,
+  ret_value = do_number_arithmetic (frame_ctx_p,
                                     dst_var_idx,
                                     number_arithmetic_remainder,
                                     left_value,
@@ -295,7 +295,7 @@ opfunc_remainder (opcode_t opdata, /**< operation data */
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_remainder */
@@ -310,29 +310,29 @@ opfunc_remainder (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_unary_plus (opcode_t opdata, /**< operation data */
-                   int_data_t *int_data) /**< interpreter context */
+                   vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.remainder.dst;
   const idx_t var_idx = opdata.data.remainder.var_left;
 
   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 (var_value, get_variable_value (frame_ctx_p, var_idx, false), ret_value);
   ECMA_OP_TO_NUMBER_TRY_CATCH (num_var_value,
                                var_value,
                                ret_value);
 
-  ecma_number_t *tmp_p = int_data->tmp_num_p;
+  ecma_number_t *tmp_p = frame_ctx_p->tmp_num_p;
 
   *tmp_p = num_var_value;
-  ret_value = set_variable_value (int_data, int_data->pos,
+  ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos,
                                   dst_var_idx,
                                   ecma_make_number_value (tmp_p));
 
   ECMA_OP_TO_NUMBER_FINALIZE (num_var_value);
   ECMA_FINALIZE (var_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_unary_plus */
@@ -347,29 +347,29 @@ opfunc_unary_plus (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_unary_minus (opcode_t opdata, /**< operation data */
-                    int_data_t *int_data) /**< interpreter context */
+                    vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.remainder.dst;
   const idx_t var_idx = opdata.data.remainder.var_left;
 
   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 (var_value, get_variable_value (frame_ctx_p, var_idx, false), ret_value);
   ECMA_OP_TO_NUMBER_TRY_CATCH (num_var_value,
                                var_value,
                                ret_value);
 
-  ecma_number_t *tmp_p = int_data->tmp_num_p;
+  ecma_number_t *tmp_p = frame_ctx_p->tmp_num_p;
 
   *tmp_p = ecma_number_negate (num_var_value);
-  ret_value = set_variable_value (int_data, int_data->pos,
+  ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos,
                                   dst_var_idx,
                                   ecma_make_number_value (tmp_p));
 
   ECMA_OP_TO_NUMBER_FINALIZE (num_var_value);
   ECMA_FINALIZE (var_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_unary_minus */
diff --git a/jerry-core/vm/opcodes-ecma-bitwise.cpp b/jerry-core/vm/opcodes-ecma-bitwise.cpp
index aa2462985..2d3e19426 100644
--- a/jerry-core/vm/opcodes-ecma-bitwise.cpp
+++ b/jerry-core/vm/opcodes-ecma-bitwise.cpp
@@ -42,7 +42,7 @@ typedef enum
  *         Returned value must be freed with ecma_free_completion_value
  */
 static ecma_completion_value_t
-do_number_bitwise_logic (int_data_t *int_data, /**< interpreter context */
+do_number_bitwise_logic (vm_frame_ctx_t *frame_ctx_p, /**< interpreter context */
                          idx_t dst_var_idx, /**< destination variable identifier */
                          number_bitwise_logic_op op, /**< number bitwise logic operation */
                          ecma_value_t left_value, /**< left value */
@@ -53,7 +53,7 @@ do_number_bitwise_logic (int_data_t *int_data, /**< interpreter context */
   ECMA_OP_TO_NUMBER_TRY_CATCH (num_left, left_value, ret_value);
   ECMA_OP_TO_NUMBER_TRY_CATCH (num_right, right_value, ret_value);
 
-  ecma_number_t* res_p = int_data->tmp_num_p;
+  ecma_number_t* res_p = frame_ctx_p->tmp_num_p;
 
   int32_t left_int32 = ecma_number_to_int32 (num_left);
   // int32_t right_int32 = ecma_number_to_int32 (num_right);
@@ -100,7 +100,7 @@ do_number_bitwise_logic (int_data_t *int_data, /**< interpreter context */
     }
   }
 
-  ret_value = set_variable_value (int_data, int_data->pos,
+  ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos,
                                   dst_var_idx,
                                   ecma_make_number_value (res_p));
 
@@ -120,7 +120,7 @@ do_number_bitwise_logic (int_data_t *int_data, /**< interpreter context */
  */
 ecma_completion_value_t
 opfunc_b_and (opcode_t opdata, /**< operation data */
-              int_data_t *int_data) /**< interpreter context */
+              vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.b_and.dst;
   const idx_t left_var_idx = opdata.data.b_and.var_left;
@@ -128,10 +128,10 @@ opfunc_b_and (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_value);
 
-  ret_value = do_number_bitwise_logic (int_data,
+  ret_value = do_number_bitwise_logic (frame_ctx_p,
                                        dst_var_idx,
                                        number_bitwise_logic_and,
                                        left_value,
@@ -140,7 +140,7 @@ opfunc_b_and (opcode_t opdata, /**< operation data */
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_b_and */
@@ -155,7 +155,7 @@ opfunc_b_and (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_b_or (opcode_t opdata, /**< operation data */
-             int_data_t *int_data) /**< interpreter context */
+             vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.b_or.dst;
   const idx_t left_var_idx = opdata.data.b_or.var_left;
@@ -163,10 +163,10 @@ opfunc_b_or (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_value);
 
-  ret_value = do_number_bitwise_logic (int_data,
+  ret_value = do_number_bitwise_logic (frame_ctx_p,
                                        dst_var_idx,
                                        number_bitwise_logic_or,
                                        left_value,
@@ -175,7 +175,7 @@ opfunc_b_or (opcode_t opdata, /**< operation data */
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_b_or */
@@ -190,7 +190,7 @@ opfunc_b_or (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_b_xor (opcode_t opdata, /**< operation data */
-              int_data_t *int_data) /**< interpreter context */
+              vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.b_xor.dst;
   const idx_t left_var_idx = opdata.data.b_xor.var_left;
@@ -198,10 +198,10 @@ opfunc_b_xor (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_value);
 
-  ret_value = do_number_bitwise_logic (int_data,
+  ret_value = do_number_bitwise_logic (frame_ctx_p,
                                        dst_var_idx,
                                        number_bitwise_logic_xor,
                                        left_value,
@@ -210,7 +210,7 @@ opfunc_b_xor (opcode_t opdata, /**< operation data */
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_b_xor */
@@ -225,7 +225,7 @@ opfunc_b_xor (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_b_shift_left (opcode_t opdata, /**< operation data */
-                     int_data_t *int_data) /**< interpreter context */
+                     vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.b_shift_left.dst;
   const idx_t left_var_idx = opdata.data.b_shift_left.var_left;
@@ -233,10 +233,10 @@ opfunc_b_shift_left (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_value);
 
-  ret_value = do_number_bitwise_logic (int_data,
+  ret_value = do_number_bitwise_logic (frame_ctx_p,
                                        dst_var_idx,
                                        number_bitwise_shift_left,
                                        left_value,
@@ -245,7 +245,7 @@ opfunc_b_shift_left (opcode_t opdata, /**< operation data */
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_b_shift_left */
@@ -260,7 +260,7 @@ opfunc_b_shift_left (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_b_shift_right (opcode_t opdata, /**< operation data */
-                      int_data_t *int_data) /**< interpreter context */
+                      vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.b_shift_right.dst;
   const idx_t left_var_idx = opdata.data.b_shift_right.var_left;
@@ -268,10 +268,10 @@ opfunc_b_shift_right (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_value);
 
-  ret_value = do_number_bitwise_logic (int_data,
+  ret_value = do_number_bitwise_logic (frame_ctx_p,
                                        dst_var_idx,
                                        number_bitwise_shift_right,
                                        left_value,
@@ -280,7 +280,7 @@ opfunc_b_shift_right (opcode_t opdata, /**< operation data */
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_b_shift_right */
@@ -295,7 +295,7 @@ opfunc_b_shift_right (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_b_shift_uright (opcode_t opdata, /**< operation data */
-                      int_data_t *int_data) /**< interpreter context */
+                      vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.b_shift_uright.dst;
   const idx_t left_var_idx = opdata.data.b_shift_uright.var_left;
@@ -303,10 +303,10 @@ opfunc_b_shift_uright (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_value);
 
-  ret_value = do_number_bitwise_logic (int_data,
+  ret_value = do_number_bitwise_logic (frame_ctx_p,
                                        dst_var_idx,
                                        number_bitwise_shift_uright,
                                        left_value,
@@ -315,7 +315,7 @@ opfunc_b_shift_uright (opcode_t opdata, /**< operation data */
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_b_shift_uright */
@@ -330,16 +330,16 @@ opfunc_b_shift_uright (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_b_not (opcode_t opdata, /**< operation data */
-              int_data_t *int_data) /**< interpreter context */
+              vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.b_not.dst;
   const idx_t right_var_idx = opdata.data.b_not.var_right;
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
-  ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_value);
 
-  ret_value = do_number_bitwise_logic (int_data,
+  ret_value = do_number_bitwise_logic (frame_ctx_p,
                                        dst_var_idx,
                                        number_bitwise_not,
                                        right_value,
@@ -347,7 +347,7 @@ opfunc_b_not (opcode_t opdata, /**< operation data */
 
   ECMA_FINALIZE (right_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_b_not */
diff --git a/jerry-core/vm/opcodes-ecma-equality.cpp b/jerry-core/vm/opcodes-ecma-equality.cpp
index fc1c309d9..860872556 100644
--- a/jerry-core/vm/opcodes-ecma-equality.cpp
+++ b/jerry-core/vm/opcodes-ecma-equality.cpp
@@ -26,7 +26,7 @@
  */
 ecma_completion_value_t
 opfunc_equal_value (opcode_t opdata, /**< operation data */
-                    int_data_t *int_data) /**< interpreter context */
+                    vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.equal_value.dst;
   const idx_t left_var_idx = opdata.data.equal_value.var_left;
@@ -34,8 +34,8 @@ opfunc_equal_value (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_value);
   ECMA_TRY_CATCH (compare_result,
                   ecma_op_abstract_equality_compare (left_value,
                                                      right_value),
@@ -43,14 +43,14 @@ opfunc_equal_value (opcode_t opdata, /**< operation data */
 
   JERRY_ASSERT (ecma_is_value_boolean (compare_result));
 
-  ret_value = set_variable_value (int_data, int_data->pos, dst_var_idx,
+  ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos, dst_var_idx,
                                   compare_result);
 
   ECMA_FINALIZE (compare_result);
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_equal_value */
@@ -65,7 +65,7 @@ opfunc_equal_value (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_not_equal_value (opcode_t opdata, /**< operation data */
-                        int_data_t *int_data) /**< interpreter context */
+                        vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.not_equal_value.dst;
   const idx_t left_var_idx = opdata.data.not_equal_value.var_left;
@@ -73,8 +73,8 @@ opfunc_not_equal_value (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_value);
   ECMA_TRY_CATCH (compare_result,
                   ecma_op_abstract_equality_compare (left_value, right_value),
                   ret_value);
@@ -83,7 +83,7 @@ opfunc_not_equal_value (opcode_t opdata, /**< operation data */
 
   bool is_equal = ecma_is_value_true (compare_result);
 
-  ret_value = set_variable_value (int_data, int_data->pos, dst_var_idx,
+  ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos, dst_var_idx,
                                   ecma_make_simple_value (is_equal ? ECMA_SIMPLE_VALUE_FALSE
                                                           : ECMA_SIMPLE_VALUE_TRUE));
 
@@ -91,7 +91,7 @@ opfunc_not_equal_value (opcode_t opdata, /**< operation data */
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_not_equal_value */
@@ -106,7 +106,7 @@ opfunc_not_equal_value (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_equal_value_type (opcode_t opdata, /**< operation data */
-                         int_data_t *int_data) /**< interpreter context */
+                         vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.equal_value_type.dst;
   const idx_t left_var_idx = opdata.data.equal_value_type.var_left;
@@ -114,19 +114,19 @@ opfunc_equal_value_type (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_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,
+  ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->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);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_equal_value_type */
@@ -141,7 +141,7 @@ opfunc_equal_value_type (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_not_equal_value_type (opcode_t opdata, /**< operation data */
-                             int_data_t *int_data) /**< interpreter context */
+                             vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.not_equal_value_type.dst;
   const idx_t left_var_idx = opdata.data.not_equal_value_type.var_left;
@@ -149,12 +149,12 @@ opfunc_not_equal_value_type (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_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,
+  ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos, dst_var_idx,
                                   ecma_make_simple_value (is_equal ? ECMA_SIMPLE_VALUE_FALSE
                                                           : ECMA_SIMPLE_VALUE_TRUE));
 
@@ -162,7 +162,7 @@ opfunc_not_equal_value_type (opcode_t opdata, /**< operation data */
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_not_equal_value_type */
diff --git a/jerry-core/vm/opcodes-ecma-relational.cpp b/jerry-core/vm/opcodes-ecma-relational.cpp
index 9de9b02e2..e0862559d 100644
--- a/jerry-core/vm/opcodes-ecma-relational.cpp
+++ b/jerry-core/vm/opcodes-ecma-relational.cpp
@@ -26,7 +26,7 @@
  */
 ecma_completion_value_t
 opfunc_less_than (opcode_t opdata, /**< operation data */
-                  int_data_t *int_data) /**< interpreter context */
+                  vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.less_than.dst;
   const idx_t left_var_idx = opdata.data.less_than.var_left;
@@ -34,8 +34,8 @@ opfunc_less_than (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_value);
   ECMA_TRY_CATCH (compare_result,
                   ecma_op_abstract_relational_compare (left_value, right_value, true),
                   ret_value);
@@ -53,13 +53,13 @@ opfunc_less_than (opcode_t opdata, /**< operation data */
     res = (ecma_is_value_true (compare_result) ? ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
   }
 
-  ret_value = set_variable_value (int_data, int_data->pos, dst_var_idx, ecma_make_simple_value (res));
+  ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos, dst_var_idx, ecma_make_simple_value (res));
 
   ECMA_FINALIZE (compare_result);
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_less_than */
@@ -74,7 +74,7 @@ opfunc_less_than (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_greater_than (opcode_t opdata, /**< operation data */
-                     int_data_t *int_data) /**< interpreter context */
+                     vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.greater_than.dst;
   const idx_t left_var_idx = opdata.data.greater_than.var_left;
@@ -82,8 +82,8 @@ opfunc_greater_than (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_value);
   ECMA_TRY_CATCH (compare_result,
                   ecma_op_abstract_relational_compare (right_value, left_value, false),
                   ret_value);
@@ -101,13 +101,13 @@ opfunc_greater_than (opcode_t opdata, /**< operation data */
     res = (ecma_is_value_true (compare_result) ? ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
   }
 
-  ret_value = set_variable_value (int_data, int_data->pos, dst_var_idx, ecma_make_simple_value (res));
+  ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos, dst_var_idx, ecma_make_simple_value (res));
 
   ECMA_FINALIZE (compare_result);
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_greater_than */
@@ -122,7 +122,7 @@ opfunc_greater_than (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_less_or_equal_than (opcode_t opdata, /**< operation data */
-                           int_data_t *int_data) /**< interpreter context */
+                           vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.less_or_equal_than.dst;
   const idx_t left_var_idx = opdata.data.less_or_equal_than.var_left;
@@ -130,8 +130,8 @@ opfunc_less_or_equal_than (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_value);
   ECMA_TRY_CATCH (compare_result,
                   ecma_op_abstract_relational_compare (right_value, left_value, false),
                   ret_value);
@@ -156,13 +156,13 @@ 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));
+  ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos, dst_var_idx, ecma_make_simple_value (res));
 
   ECMA_FINALIZE (compare_result);
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_less_or_equal_than */
@@ -177,7 +177,7 @@ opfunc_less_or_equal_than (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_greater_or_equal_than (opcode_t opdata, /**< operation data */
-                              int_data_t *int_data) /**< interpreter context */
+                              vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.greater_or_equal_than.dst;
   const idx_t left_var_idx = opdata.data.greater_or_equal_than.var_left;
@@ -185,8 +185,8 @@ opfunc_greater_or_equal_than (opcode_t opdata, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_value);
   ECMA_TRY_CATCH (compare_result,
                   ecma_op_abstract_relational_compare (left_value, right_value, true),
                   ret_value);
@@ -211,13 +211,13 @@ 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));
+  ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos, dst_var_idx, ecma_make_simple_value (res));
 
   ECMA_FINALIZE (compare_result);
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_greater_or_equal_than */
@@ -232,7 +232,7 @@ opfunc_greater_or_equal_than (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_instanceof (opcode_t opdata __attr_unused___, /**< operation data */
-                   int_data_t *int_data __attr_unused___) /**< interpreter context */
+                   vm_frame_ctx_t *frame_ctx_p __attr_unused___) /**< interpreter context */
 {
   const idx_t dst_idx = opdata.data.instanceof.dst;
   const idx_t left_var_idx = opdata.data.instanceof.var_left;
@@ -240,8 +240,8 @@ opfunc_instanceof (opcode_t opdata __attr_unused___, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_value);
 
   if (!ecma_is_value_object (right_value))
   {
@@ -255,7 +255,7 @@ opfunc_instanceof (opcode_t opdata __attr_unused___, /**< operation data */
                     ecma_op_object_has_instance (right_value_obj_p, left_value),
                     ret_value);
 
-    ret_value = set_variable_value (int_data, int_data->pos, dst_idx, is_instance_of);
+    ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos, dst_idx, is_instance_of);
 
     ECMA_FINALIZE (is_instance_of);
   }
@@ -263,7 +263,7 @@ opfunc_instanceof (opcode_t opdata __attr_unused___, /**< operation data */
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_instanceof */
@@ -278,7 +278,7 @@ opfunc_instanceof (opcode_t opdata __attr_unused___, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_in (opcode_t opdata __attr_unused___, /**< operation data */
-           int_data_t *int_data __attr_unused___) /**< interpreter context */
+           vm_frame_ctx_t *frame_ctx_p __attr_unused___) /**< interpreter context */
 {
   const idx_t dst_idx = opdata.data.in.dst;
   const idx_t left_var_idx = opdata.data.in.var_left;
@@ -286,8 +286,8 @@ opfunc_in (opcode_t opdata __attr_unused___, /**< operation data */
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_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 (left_value, get_variable_value (frame_ctx_p, left_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, right_var_idx, false), ret_value);
 
   if (!ecma_is_value_object (right_value))
   {
@@ -310,7 +310,7 @@ opfunc_in (opcode_t opdata __attr_unused___, /**< operation data */
       is_in = ECMA_SIMPLE_VALUE_FALSE;
     }
 
-    ret_value = set_variable_value (int_data, int_data->pos,
+    ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos,
                                     dst_idx,
                                     ecma_make_simple_value (is_in));
 
@@ -320,7 +320,7 @@ opfunc_in (opcode_t opdata __attr_unused___, /**< operation data */
   ECMA_FINALIZE (right_value);
   ECMA_FINALIZE (left_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_in */
diff --git a/jerry-core/vm/opcodes-ecma-support.h b/jerry-core/vm/opcodes-ecma-support.h
index 9826c63d2..e0b71e150 100644
--- a/jerry-core/vm/opcodes-ecma-support.h
+++ b/jerry-core/vm/opcodes-ecma-support.h
@@ -33,14 +33,14 @@
 #include "ecma-try-catch-macro.h"
 #include "serializer.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_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,
+bool is_reg_variable (vm_frame_ctx_t *frame_ctx_p, idx_t var_idx);
+ecma_completion_value_t get_variable_value (vm_frame_ctx_t *, idx_t, bool);
+ecma_completion_value_t set_variable_value (vm_frame_ctx_t *, opcode_counter_t, idx_t, ecma_value_t);
+ecma_completion_value_t fill_varg_list (vm_frame_ctx_t *frame_ctx_p,
                                         ecma_length_t args_number,
                                         ecma_value_t args_values[],
                                         ecma_length_t *out_arg_number_p);
-void fill_params_list (int_data_t *int_data,
+void fill_params_list (vm_frame_ctx_t *frame_ctx_p,
                        ecma_length_t params_number,
                        ecma_string_t* params_names[]);
 #endif /* OPCODES_ECMA_SUPPORT_H */
diff --git a/jerry-core/vm/opcodes-ecma-try-catch-finally.cpp b/jerry-core/vm/opcodes-ecma-try-catch-finally.cpp
index bdec9a181..00b0fa384 100644
--- a/jerry-core/vm/opcodes-ecma-try-catch-finally.cpp
+++ b/jerry-core/vm/opcodes-ecma-try-catch-finally.cpp
@@ -28,44 +28,44 @@
  */
 ecma_completion_value_t
 opfunc_try_block (opcode_t opdata, /**< operation data */
-                  int_data_t *int_data) /**< interpreter context */
+                  vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t block_end_oc_idx_1 = opdata.data.try_block.oc_idx_1;
   const idx_t block_end_oc_idx_2 = opdata.data.try_block.oc_idx_2;
   const opcode_counter_t try_end_oc = (opcode_counter_t) (
-    calc_opcode_counter_from_idx_idx (block_end_oc_idx_1, block_end_oc_idx_2) + int_data->pos);
+    calc_opcode_counter_from_idx_idx (block_end_oc_idx_1, block_end_oc_idx_2) + frame_ctx_p->pos);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
-  vm_run_scope_t run_scope_try = { int_data->pos, try_end_oc };
-  ecma_completion_value_t try_completion = vm_loop (int_data, &run_scope_try);
-  JERRY_ASSERT ((!ecma_is_completion_value_empty (try_completion) && int_data->pos <= try_end_oc)
-                || (ecma_is_completion_value_empty (try_completion) && int_data->pos == try_end_oc));
-  int_data->pos = try_end_oc;
+  vm_run_scope_t run_scope_try = { frame_ctx_p->pos, try_end_oc };
+  ecma_completion_value_t try_completion = vm_loop (frame_ctx_p, &run_scope_try);
+  JERRY_ASSERT ((!ecma_is_completion_value_empty (try_completion) && frame_ctx_p->pos <= try_end_oc)
+                || (ecma_is_completion_value_empty (try_completion) && frame_ctx_p->pos == try_end_oc));
+  frame_ctx_p->pos = try_end_oc;
 
-  opcode_t next_opcode = vm_get_opcode (int_data->opcodes_p, int_data->pos);
+  opcode_t next_opcode = vm_get_opcode (frame_ctx_p->opcodes_p, frame_ctx_p->pos);
   JERRY_ASSERT (next_opcode.op_idx == __op__idx_meta);
 
   if (next_opcode.data.meta.type == OPCODE_META_TYPE_CATCH)
   {
     const opcode_counter_t catch_end_oc = (opcode_counter_t) (
-      read_meta_opcode_counter (OPCODE_META_TYPE_CATCH, int_data) + int_data->pos);
-    int_data->pos++;
+      read_meta_opcode_counter (OPCODE_META_TYPE_CATCH, frame_ctx_p) + frame_ctx_p->pos);
+    frame_ctx_p->pos++;
 
     if (ecma_is_completion_value_throw (try_completion))
     {
-      next_opcode = vm_get_opcode (int_data->opcodes_p, int_data->pos);
+      next_opcode = vm_get_opcode (frame_ctx_p->opcodes_p, frame_ctx_p->pos);
       JERRY_ASSERT (next_opcode.op_idx == __op__idx_meta);
       JERRY_ASSERT (next_opcode.data.meta.type == OPCODE_META_TYPE_CATCH_EXCEPTION_IDENTIFIER);
 
       lit_cpointer_t catch_exc_val_var_name_lit_cp = serializer_get_literal_cp_by_uid (next_opcode.data.meta.data_1,
-                                                                                       int_data->opcodes_p,
-                                                                                       int_data->pos);
-      int_data->pos++;
+                                                                                       frame_ctx_p->opcodes_p,
+                                                                                       frame_ctx_p->pos);
+      frame_ctx_p->pos++;
 
       ecma_string_t *catch_exc_var_name_str_p = ecma_new_ecma_string_from_lit_cp (catch_exc_val_var_name_lit_cp);
 
-      ecma_object_t *old_env_p = int_data->lex_env_p;
+      ecma_object_t *old_env_p = frame_ctx_p->lex_env_p;
       ecma_object_t *catch_env_p = ecma_create_decl_lex_env (old_env_p);
       ecma_completion_value_t completion = ecma_op_create_mutable_binding (catch_env_p,
                                                                            catch_exc_var_name_str_p,
@@ -80,39 +80,39 @@ opfunc_try_block (opcode_t opdata, /**< operation data */
 
       ecma_deref_ecma_string (catch_exc_var_name_str_p);
 
-      int_data->lex_env_p = catch_env_p;
+      frame_ctx_p->lex_env_p = catch_env_p;
 
       ecma_free_completion_value (try_completion);
 
-      vm_run_scope_t run_scope_catch = { int_data->pos, catch_end_oc };
-      try_completion = vm_loop (int_data, &run_scope_catch);
+      vm_run_scope_t run_scope_catch = { frame_ctx_p->pos, catch_end_oc };
+      try_completion = vm_loop (frame_ctx_p, &run_scope_catch);
 
-      int_data->lex_env_p = old_env_p;
+      frame_ctx_p->lex_env_p = old_env_p;
 
       ecma_deref_object (catch_env_p);
 
-      JERRY_ASSERT ((!ecma_is_completion_value_empty (try_completion) && int_data->pos <= catch_end_oc)
-                    || (ecma_is_completion_value_empty (try_completion) && int_data->pos == catch_end_oc));
+      JERRY_ASSERT ((!ecma_is_completion_value_empty (try_completion) && frame_ctx_p->pos <= catch_end_oc)
+                    || (ecma_is_completion_value_empty (try_completion) && frame_ctx_p->pos == catch_end_oc));
     }
 
-    int_data->pos = catch_end_oc;
+    frame_ctx_p->pos = catch_end_oc;
   }
 
-  next_opcode = vm_get_opcode (int_data->opcodes_p, int_data->pos);
+  next_opcode = vm_get_opcode (frame_ctx_p->opcodes_p, frame_ctx_p->pos);
   JERRY_ASSERT (next_opcode.op_idx == __op__idx_meta);
 
   if (next_opcode.data.meta.type == OPCODE_META_TYPE_FINALLY)
   {
     const opcode_counter_t finally_end_oc = (opcode_counter_t) (
-      read_meta_opcode_counter (OPCODE_META_TYPE_FINALLY, int_data) + int_data->pos);
-    int_data->pos++;
+      read_meta_opcode_counter (OPCODE_META_TYPE_FINALLY, frame_ctx_p) + frame_ctx_p->pos);
+    frame_ctx_p->pos++;
 
-    vm_run_scope_t run_scope_finally = { int_data->pos, finally_end_oc };
-    ecma_completion_value_t finally_completion = vm_loop (int_data, &run_scope_finally);
+    vm_run_scope_t run_scope_finally = { frame_ctx_p->pos, finally_end_oc };
+    ecma_completion_value_t finally_completion = vm_loop (frame_ctx_p, &run_scope_finally);
 
-    JERRY_ASSERT ((!ecma_is_completion_value_empty (finally_completion) && int_data->pos <= finally_end_oc)
-                  || (ecma_is_completion_value_empty (finally_completion) && int_data->pos == finally_end_oc));
-    int_data->pos = finally_end_oc;
+    JERRY_ASSERT ((!ecma_is_completion_value_empty (finally_completion) && frame_ctx_p->pos <= finally_end_oc)
+                  || (ecma_is_completion_value_empty (finally_completion) && frame_ctx_p->pos == finally_end_oc));
+    frame_ctx_p->pos = finally_end_oc;
 
     if (!ecma_is_completion_value_empty (finally_completion))
     {
@@ -121,7 +121,7 @@ opfunc_try_block (opcode_t opdata, /**< operation data */
     }
   }
 
-  next_opcode = vm_get_opcode (int_data->opcodes_p, int_data->pos++);
+  next_opcode = vm_get_opcode (frame_ctx_p->opcodes_p, frame_ctx_p->pos++);
   JERRY_ASSERT (next_opcode.op_idx == __op__idx_meta);
   JERRY_ASSERT (next_opcode.data.meta.type == OPCODE_META_TYPE_END_TRY_CATCH_FINALLY);
 
diff --git a/jerry-core/vm/opcodes-for-in.cpp b/jerry-core/vm/opcodes-for-in.cpp
index b388fb8dd..10cae8c03 100644
--- a/jerry-core/vm/opcodes-for-in.cpp
+++ b/jerry-core/vm/opcodes-for-in.cpp
@@ -183,7 +183,7 @@ vm_helper_for_in_enumerate_properties_names (ecma_object_t *obj_p) /**< starting
  */
 ecma_completion_value_t
 opfunc_for_in (opcode_t opdata, /**< operation data */
-               int_data_t *int_data_p) /**< interpreter context */
+               vm_frame_ctx_t *int_data_p) /**< interpreter context */
 {
   const idx_t expr_idx = opdata.data.for_in.expr;
   const idx_t block_end_oc_idx_1 = opdata.data.for_in.oc_idx_1;
diff --git a/jerry-core/vm/opcodes-helpers-variables.cpp b/jerry-core/vm/opcodes-helpers-variables.cpp
index 5137ff25d..a9e108087 100644
--- a/jerry-core/vm/opcodes-helpers-variables.cpp
+++ b/jerry-core/vm/opcodes-helpers-variables.cpp
@@ -59,10 +59,10 @@ do_strict_eval_arguments_check (ecma_object_t *ref_base_lex_env_p, /**< base of
  *         false - otherwise.
  */
 bool
-is_reg_variable (int_data_t *int_data, /**< interpreter context */
+is_reg_variable (vm_frame_ctx_t *frame_ctx_p, /**< interpreter context */
                  idx_t var_idx) /**< variable identifier */
 {
-  return (var_idx >= int_data->min_reg_num && var_idx <= int_data->max_reg_num);
+  return (var_idx >= frame_ctx_p->min_reg_num && var_idx <= frame_ctx_p->max_reg_num);
 } /* is_reg_variable */
 
 /**
@@ -72,17 +72,17 @@ is_reg_variable (int_data_t *int_data, /**< interpreter context */
  *         Returned value must be freed with ecma_free_completion_value
  */
 ecma_completion_value_t
-get_variable_value (int_data_t *int_data, /**< interpreter context */
+get_variable_value (vm_frame_ctx_t *frame_ctx_p, /**< 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_make_empty_completion_value ();
 
-  if (is_reg_variable (int_data, var_idx))
+  if (is_reg_variable (frame_ctx_p, var_idx))
   {
-    ecma_value_t reg_value = ecma_stack_frame_get_reg_value (&int_data->stack_frame,
-                                                             var_idx - int_data->min_reg_num);
+    ecma_value_t reg_value = ecma_stack_frame_get_reg_value (&frame_ctx_p->stack_frame,
+                                                             var_idx - frame_ctx_p->min_reg_num);
 
     JERRY_ASSERT (!ecma_is_value_empty (reg_value));
 
@@ -91,11 +91,11 @@ get_variable_value (int_data_t *int_data, /**< interpreter context */
   else
   {
     ecma_string_t var_name_string;
-    lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (var_idx, int_data->opcodes_p, int_data->pos);
+    lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (var_idx, frame_ctx_p->opcodes_p, frame_ctx_p->pos);
     JERRY_ASSERT (lit_cp.packed_value != MEM_CP_NULL);
     ecma_new_ecma_string_on_stack_from_lit_cp (&var_name_string, lit_cp);
 
-    ecma_object_t *ref_base_lex_env_p = ecma_op_resolve_reference_base (int_data->lex_env_p,
+    ecma_object_t *ref_base_lex_env_p = ecma_op_resolve_reference_base (frame_ctx_p->lex_env_p,
                                                                         &var_name_string);
 
     if (do_eval_or_arguments_check)
@@ -103,13 +103,13 @@ get_variable_value (int_data_t *int_data, /**< interpreter context */
 #ifndef JERRY_NDEBUG
       do_strict_eval_arguments_check (ref_base_lex_env_p,
                                       &var_name_string,
-                                      int_data->is_strict);
+                                      frame_ctx_p->is_strict);
 #endif /* !JERRY_NDEBUG */
     }
 
     ret_value = ecma_op_get_value_lex_env_base (ref_base_lex_env_p,
                                                 &var_name_string,
-                                                int_data->is_strict);
+                                                frame_ctx_p->is_strict);
 
     ecma_check_that_ecma_string_need_not_be_freed (&var_name_string);
   }
@@ -124,19 +124,19 @@ get_variable_value (int_data_t *int_data, /**< interpreter context */
  *         Returned value must be freed with ecma_free_completion_value
  */
 ecma_completion_value_t
-set_variable_value (int_data_t *int_data, /**< interpreter context */
+set_variable_value (vm_frame_ctx_t *frame_ctx_p, /**< interpreter context */
                     opcode_counter_t lit_oc, /**< opcode counter for literal */
                     idx_t var_idx, /**< variable identifier */
                     ecma_value_t value) /**< value to set */
 {
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
-  if (is_reg_variable (int_data, var_idx))
+  if (is_reg_variable (frame_ctx_p, var_idx))
   {
     ret_value = ecma_make_empty_completion_value ();
 
-    ecma_value_t reg_value = ecma_stack_frame_get_reg_value (&int_data->stack_frame,
-                                                             var_idx - int_data->min_reg_num);
+    ecma_value_t reg_value = ecma_stack_frame_get_reg_value (&frame_ctx_p->stack_frame,
+                                                             var_idx - frame_ctx_p->min_reg_num);
 
     if (ecma_is_value_number (reg_value)
         && ecma_is_value_number (value))
@@ -150,30 +150,30 @@ set_variable_value (int_data_t *int_data, /**< interpreter context */
         ecma_free_value (reg_value, false);
       }
 
-      ecma_stack_frame_set_reg_value (&int_data->stack_frame,
-                                      var_idx - int_data->min_reg_num,
+      ecma_stack_frame_set_reg_value (&frame_ctx_p->stack_frame,
+                                      var_idx - frame_ctx_p->min_reg_num,
                                       ecma_copy_value (value, false));
     }
   }
   else
   {
     ecma_string_t var_name_string;
-    lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (var_idx, int_data->opcodes_p, lit_oc);
+    lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (var_idx, frame_ctx_p->opcodes_p, lit_oc);
     JERRY_ASSERT (lit_cp.packed_value != MEM_CP_NULL);
     ecma_new_ecma_string_on_stack_from_lit_cp (&var_name_string, lit_cp);
 
-    ecma_object_t *ref_base_lex_env_p = ecma_op_resolve_reference_base (int_data->lex_env_p,
+    ecma_object_t *ref_base_lex_env_p = ecma_op_resolve_reference_base (frame_ctx_p->lex_env_p,
                                                                         &var_name_string);
 
 #ifndef JERRY_NDEBUG
     do_strict_eval_arguments_check (ref_base_lex_env_p,
                                     &var_name_string,
-                                    int_data->is_strict);
+                                    frame_ctx_p->is_strict);
 #endif /* !JERRY_NDEBUG */
 
     ret_value = ecma_op_put_value_lex_env_base (ref_base_lex_env_p,
                                                 &var_name_string,
-                                                int_data->is_strict,
+                                                frame_ctx_p->is_strict,
                                                 value);
 
     ecma_check_that_ecma_string_need_not_be_freed (&var_name_string);
diff --git a/jerry-core/vm/opcodes-native-call.cpp b/jerry-core/vm/opcodes-native-call.cpp
index 2befdc4a4..4caa6d0f1 100644
--- a/jerry-core/vm/opcodes-native-call.cpp
+++ b/jerry-core/vm/opcodes-native-call.cpp
@@ -29,16 +29,16 @@
  */
 ecma_completion_value_t
 opfunc_native_call (opcode_t opdata, /**< operation data */
-                    int_data_t *int_data) /**< interpreter context */
+                    vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.native_call.lhs;
   const idx_t native_call_id_idx = opdata.data.native_call.name;
   const idx_t args_number = opdata.data.native_call.arg_list;
-  const opcode_counter_t lit_oc = int_data->pos;
+  const opcode_counter_t lit_oc = frame_ctx_p->pos;
 
   JERRY_ASSERT (native_call_id_idx < OPCODE_NATIVE_CALL__COUNT);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   JERRY_STATIC_ASSERT (OPCODE_NATIVE_CALL__COUNT < (1u << (sizeof (native_call_id_idx) * JERRY_BITSINBYTE)));
 
@@ -47,7 +47,7 @@ opfunc_native_call (opcode_t opdata, /**< operation data */
   MEM_DEFINE_LOCAL_ARRAY (arg_values, args_number, ecma_value_t);
 
   ecma_length_t args_read;
-  ecma_completion_value_t get_arg_completion = fill_varg_list (int_data,
+  ecma_completion_value_t get_arg_completion = fill_varg_list (frame_ctx_p,
                                                                args_number,
                                                                arg_values,
                                                                &args_read);
@@ -104,7 +104,7 @@ opfunc_native_call (opcode_t opdata, /**< operation data */
 
           mem_heap_free_block (utf8_str_p);
 
-          ret_value = set_variable_value (int_data, lit_oc, dst_var_idx,
+          ret_value = set_variable_value (frame_ctx_p, lit_oc, dst_var_idx,
                                           ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED));
 
           ECMA_FINALIZE (str_value);
diff --git a/jerry-core/vm/opcodes-varg.cpp b/jerry-core/vm/opcodes-varg.cpp
index 84da3b960..9ec8c9204 100644
--- a/jerry-core/vm/opcodes-varg.cpp
+++ b/jerry-core/vm/opcodes-varg.cpp
@@ -27,7 +27,7 @@
  *         of last expression evaluated
  */
 ecma_completion_value_t
-fill_varg_list (int_data_t *int_data, /**< interpreter context */
+fill_varg_list (vm_frame_ctx_t *frame_ctx_p, /**< 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
@@ -40,17 +40,17 @@ fill_varg_list (int_data_t *int_data, /**< interpreter context */
        arg_index < args_number && ecma_is_completion_value_empty (ret_value);
        )
   {
-    ecma_completion_value_t evaluate_arg_completion = vm_loop (int_data, NULL);
+    ecma_completion_value_t evaluate_arg_completion = vm_loop (frame_ctx_p, NULL);
 
     if (ecma_is_completion_value_empty (evaluate_arg_completion))
     {
-      opcode_t next_opcode = vm_get_opcode (int_data->opcodes_p, int_data->pos);
+      opcode_t next_opcode = vm_get_opcode (frame_ctx_p->opcodes_p, frame_ctx_p->pos);
       JERRY_ASSERT (next_opcode.op_idx == __op__idx_meta);
       JERRY_ASSERT (next_opcode.data.meta.type == OPCODE_META_TYPE_VARG);
 
       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_completion_value_t get_arg_completion = get_variable_value (frame_ctx_p, varg_var_idx, false);
 
       if (ecma_is_completion_value_normal (get_arg_completion))
       {
@@ -70,7 +70,7 @@ fill_varg_list (int_data_t *int_data, /**< interpreter context */
       ret_value = evaluate_arg_completion;
     }
 
-    int_data->pos++;
+    frame_ctx_p->pos++;
   }
 
   *out_arg_number_p = arg_index;
@@ -82,7 +82,7 @@ fill_varg_list (int_data_t *int_data, /**< interpreter context */
  * Fill parameters' list
  */
 void
-fill_params_list (int_data_t *int_data, /**< interpreter context */
+fill_params_list (vm_frame_ctx_t *frame_ctx_p, /**< interpreter context */
                   ecma_length_t params_number, /**< number of parameters */
                   ecma_string_t* params_names[]) /**< out: parameters' names */
 {
@@ -91,17 +91,17 @@ fill_params_list (int_data_t *int_data, /**< interpreter context */
        param_index < params_number;
        param_index++)
   {
-    opcode_t next_opcode = vm_get_opcode (int_data->opcodes_p, int_data->pos);
+    opcode_t next_opcode = vm_get_opcode (frame_ctx_p->opcodes_p, frame_ctx_p->pos);
     JERRY_ASSERT (next_opcode.op_idx == __op__idx_meta);
     JERRY_ASSERT (next_opcode.data.meta.type == OPCODE_META_TYPE_VARG);
 
     const lit_cpointer_t param_name_lit_idx = serializer_get_literal_cp_by_uid (next_opcode.data.meta.data_1,
-                                                                                int_data->opcodes_p,
-                                                                                int_data->pos);
+                                                                                frame_ctx_p->opcodes_p,
+                                                                                frame_ctx_p->pos);
 
     params_names[param_index] = ecma_new_ecma_string_from_lit_cp (param_name_lit_idx);
 
-    int_data->pos++;
+    frame_ctx_p->pos++;
   }
 
   JERRY_ASSERT (param_index == params_number);
diff --git a/jerry-core/vm/opcodes.cpp b/jerry-core/vm/opcodes.cpp
index f8d0d497c..960c3c1ba 100644
--- a/jerry-core/vm/opcodes.cpp
+++ b/jerry-core/vm/opcodes.cpp
@@ -49,9 +49,9 @@
     static char __attr_unused___ unimplemented_list_end
 
 #define DEFINE_UNIMPLEMENTED_OP(op) \
-  ecma_completion_value_t opfunc_ ## op (opcode_t opdata, int_data_t *int_data) \
+  ecma_completion_value_t opfunc_ ## op (opcode_t opdata, vm_frame_ctx_t *frame_ctx_p) \
   { \
-    JERRY_UNIMPLEMENTED_REF_UNUSED_VARS (opdata, int_data); \
+    JERRY_UNIMPLEMENTED_REF_UNUSED_VARS (opdata, frame_ctx_p); \
   }
 
 OP_UNIMPLEMENTED_LIST (DEFINE_UNIMPLEMENTED_OP);
@@ -62,9 +62,9 @@ OP_UNIMPLEMENTED_LIST (DEFINE_UNIMPLEMENTED_OP);
  */
 ecma_completion_value_t
 opfunc_nop (opcode_t opdata __attr_unused___, /**< operation data */
-            int_data_t *int_data) /**< interpreter context */
+            vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ecma_make_empty_completion_value ();
 } /* opfunc_nop */
@@ -84,7 +84,7 @@ opfunc_nop (opcode_t opdata __attr_unused___, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_assignment (opcode_t opdata, /**< operation data */
-                   int_data_t *int_data) /**< interpreter context */
+                   vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.assignment.var_left;
   const opcode_arg_type_operand type_value_right = (opcode_arg_type_operand) opdata.data.assignment.type_value_right;
@@ -94,18 +94,18 @@ opfunc_assignment (opcode_t opdata, /**< operation data */
 
   if (type_value_right == OPCODE_ARG_TYPE_SIMPLE)
   {
-    ret_value = set_variable_value (int_data,
-                                    int_data->pos,
+    ret_value = set_variable_value (frame_ctx_p,
+                                    frame_ctx_p->pos,
                                     dst_var_idx,
                                     ecma_make_simple_value ((ecma_simple_value_t) src_val_descr));
   }
   else if (type_value_right == OPCODE_ARG_TYPE_STRING)
   {
-    lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (src_val_descr, int_data->opcodes_p, int_data->pos);
+    lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (src_val_descr, frame_ctx_p->opcodes_p, frame_ctx_p->pos);
     ecma_string_t *string_p = ecma_new_ecma_string_from_lit_cp (lit_cp);
 
-    ret_value = set_variable_value (int_data,
-                                    int_data->pos,
+    ret_value = set_variable_value (frame_ctx_p,
+                                    frame_ctx_p->pos,
                                     dst_var_idx,
                                     ecma_make_string_value (string_p));
 
@@ -114,13 +114,13 @@ opfunc_assignment (opcode_t opdata, /**< operation data */
   else if (type_value_right == OPCODE_ARG_TYPE_VARIABLE)
   {
     ECMA_TRY_CATCH (var_value,
-                    get_variable_value (int_data,
+                    get_variable_value (frame_ctx_p,
                                         src_val_descr,
                                         false),
                     ret_value);
 
-    ret_value = set_variable_value (int_data,
-                                    int_data->pos,
+    ret_value = set_variable_value (frame_ctx_p,
+                                    frame_ctx_p->pos,
                                     dst_var_idx,
                                     var_value);
 
@@ -128,42 +128,42 @@ opfunc_assignment (opcode_t opdata, /**< operation data */
   }
   else if (type_value_right == OPCODE_ARG_TYPE_NUMBER)
   {
-    ecma_number_t *num_p = int_data->tmp_num_p;
+    ecma_number_t *num_p = frame_ctx_p->tmp_num_p;
 
-    lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (src_val_descr, int_data->opcodes_p, int_data->pos);
+    lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (src_val_descr, frame_ctx_p->opcodes_p, frame_ctx_p->pos);
     literal_t lit = lit_get_literal_by_cp (lit_cp);
     JERRY_ASSERT (lit->get_type () == LIT_NUMBER_T);
 
     *num_p = lit_charset_literal_get_number (lit);
 
-    ret_value = set_variable_value (int_data,
-                                    int_data->pos,
+    ret_value = set_variable_value (frame_ctx_p,
+                                    frame_ctx_p->pos,
                                     dst_var_idx,
                                     ecma_make_number_value (num_p));
   }
   else if (type_value_right == OPCODE_ARG_TYPE_NUMBER_NEGATE)
   {
-    ecma_number_t *num_p = int_data->tmp_num_p;
+    ecma_number_t *num_p = frame_ctx_p->tmp_num_p;
 
-    lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (src_val_descr, int_data->opcodes_p, int_data->pos);
+    lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (src_val_descr, frame_ctx_p->opcodes_p, frame_ctx_p->pos);
     literal_t lit = lit_get_literal_by_cp (lit_cp);
     JERRY_ASSERT (lit->get_type () == LIT_NUMBER_T);
 
     *num_p = lit_charset_literal_get_number (lit);
 
-    ret_value = set_variable_value (int_data,
-                                    int_data->pos,
+    ret_value = set_variable_value (frame_ctx_p,
+                                    frame_ctx_p->pos,
                                     dst_var_idx,
                                     ecma_make_number_value (num_p));
   }
   else if (type_value_right == OPCODE_ARG_TYPE_SMALLINT)
   {
-    ecma_number_t *num_p = int_data->tmp_num_p;
+    ecma_number_t *num_p = frame_ctx_p->tmp_num_p;
 
     *num_p = src_val_descr;
 
-    ret_value = set_variable_value (int_data,
-                                    int_data->pos,
+    ret_value = set_variable_value (frame_ctx_p,
+                                    frame_ctx_p->pos,
                                     dst_var_idx,
                                     ecma_make_number_value (num_p));
   }
@@ -171,8 +171,8 @@ opfunc_assignment (opcode_t opdata, /**< operation data */
   {
 #ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_REGEXP_BUILTIN
     lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (src_val_descr,
-                                                              int_data->opcodes_p,
-                                                              int_data->pos);
+                                                              frame_ctx_p->opcodes_p,
+                                                              frame_ctx_p->pos);
     ecma_string_t *string_p = ecma_new_ecma_string_from_lit_cp (lit_cp);
 
     lit_utf8_size_t re_utf8_buffer_size = ecma_string_get_size (string_p);
@@ -208,8 +208,8 @@ opfunc_assignment (opcode_t opdata, /**< operation data */
                     ecma_op_create_regexp_object (pattern_p, flags_p),
                     ret_value);
 
-    ret_value = set_variable_value (int_data,
-                                    int_data->pos,
+    ret_value = set_variable_value (frame_ctx_p,
+                                    frame_ctx_p->pos,
                                     dst_var_idx,
                                     regexp_obj_value);
 
@@ -230,17 +230,17 @@ opfunc_assignment (opcode_t opdata, /**< operation data */
   else
   {
     JERRY_ASSERT (type_value_right == OPCODE_ARG_TYPE_SMALLINT_NEGATE);
-    ecma_number_t *num_p = int_data->tmp_num_p;
+    ecma_number_t *num_p = frame_ctx_p->tmp_num_p;
 
     *num_p = ecma_number_negate (src_val_descr);
 
-    ret_value = set_variable_value (int_data,
-                                    int_data->pos,
+    ret_value = set_variable_value (frame_ctx_p,
+                                    frame_ctx_p->pos,
                                     dst_var_idx,
                                     ecma_make_number_value (num_p));
   }
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_assignment */
@@ -255,7 +255,7 @@ opfunc_assignment (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_pre_incr (opcode_t opdata, /**< operation data */
-                 int_data_t *int_data) /**< interpreter context */
+                 vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.pre_incr.dst;
   const idx_t incr_var_idx = opdata.data.pre_incr.var_right;
@@ -263,23 +263,23 @@ 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 (old_value, get_variable_value (frame_ctx_p, incr_var_idx, true), ret_value);
   ECMA_OP_TO_NUMBER_TRY_CATCH (old_num, old_value, ret_value);
 
   // 4.
-  ecma_number_t* new_num_p = int_data->tmp_num_p;
+  ecma_number_t* new_num_p = frame_ctx_p->tmp_num_p;
 
   *new_num_p = ecma_number_add (old_num, ECMA_NUMBER_ONE);
 
   ecma_value_t new_num_value = ecma_make_number_value (new_num_p);
 
   // 5.
-  ret_value = set_variable_value (int_data, int_data->pos,
+  ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos,
                                   incr_var_idx,
                                   new_num_value);
 
   // assignment of operator result to register variable
-  ecma_completion_value_t reg_assignment_res = set_variable_value (int_data, int_data->pos,
+  ecma_completion_value_t reg_assignment_res = set_variable_value (frame_ctx_p, frame_ctx_p->pos,
                                                                    dst_var_idx,
                                                                    new_num_value);
   JERRY_ASSERT (ecma_is_completion_value_empty (reg_assignment_res));
@@ -287,7 +287,7 @@ opfunc_pre_incr (opcode_t opdata, /**< operation data */
   ECMA_OP_TO_NUMBER_FINALIZE (old_num);
   ECMA_FINALIZE (old_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_pre_incr */
@@ -302,7 +302,7 @@ opfunc_pre_incr (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_pre_decr (opcode_t opdata, /**< operation data */
-                 int_data_t *int_data) /**< interpreter context */
+                 vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.pre_decr.dst;
   const idx_t decr_var_idx = opdata.data.pre_decr.var_right;
@@ -310,23 +310,23 @@ 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 (old_value, get_variable_value (frame_ctx_p, decr_var_idx, true), ret_value);
   ECMA_OP_TO_NUMBER_TRY_CATCH (old_num, old_value, ret_value);
 
   // 4.
-  ecma_number_t* new_num_p = int_data->tmp_num_p;
+  ecma_number_t* new_num_p = frame_ctx_p->tmp_num_p;
 
   *new_num_p = ecma_number_substract (old_num, ECMA_NUMBER_ONE);
 
   ecma_value_t new_num_value = ecma_make_number_value (new_num_p);
 
   // 5.
-  ret_value = set_variable_value (int_data, int_data->pos,
+  ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos,
                                   decr_var_idx,
                                   new_num_value);
 
   // assignment of operator result to register variable
-  ecma_completion_value_t reg_assignment_res = set_variable_value (int_data, int_data->pos,
+  ecma_completion_value_t reg_assignment_res = set_variable_value (frame_ctx_p, frame_ctx_p->pos,
                                                                    dst_var_idx,
                                                                    new_num_value);
   JERRY_ASSERT (ecma_is_completion_value_empty (reg_assignment_res));
@@ -334,7 +334,7 @@ opfunc_pre_decr (opcode_t opdata, /**< operation data */
   ECMA_OP_TO_NUMBER_FINALIZE (old_num);
   ECMA_FINALIZE (old_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_pre_decr */
@@ -349,7 +349,7 @@ opfunc_pre_decr (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_post_incr (opcode_t opdata, /**< operation data */
-                  int_data_t *int_data) /**< interpreter context */
+                  vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.post_incr.dst;
   const idx_t incr_var_idx = opdata.data.post_incr.var_right;
@@ -357,24 +357,24 @@ 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 (old_value, get_variable_value (frame_ctx_p, incr_var_idx, true), ret_value);
   ECMA_OP_TO_NUMBER_TRY_CATCH (old_num, old_value, ret_value);
 
   // 4.
-  ecma_number_t* new_num_p = int_data->tmp_num_p;
+  ecma_number_t* new_num_p = frame_ctx_p->tmp_num_p;
 
   *new_num_p = ecma_number_add (old_num, ECMA_NUMBER_ONE);
 
   // 5.
-  ret_value = set_variable_value (int_data, int_data->pos,
+  ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos,
                                   incr_var_idx,
                                   ecma_make_number_value (new_num_p));
 
-  ecma_number_t *tmp_p = int_data->tmp_num_p;
+  ecma_number_t *tmp_p = frame_ctx_p->tmp_num_p;
   *tmp_p = old_num;
 
   // assignment of operator result to register variable
-  ecma_completion_value_t reg_assignment_res = set_variable_value (int_data, int_data->pos,
+  ecma_completion_value_t reg_assignment_res = set_variable_value (frame_ctx_p, frame_ctx_p->pos,
                                                                    dst_var_idx,
                                                                    ecma_make_number_value (tmp_p));
   JERRY_ASSERT (ecma_is_completion_value_empty (reg_assignment_res));
@@ -382,7 +382,7 @@ opfunc_post_incr (opcode_t opdata, /**< operation data */
   ECMA_OP_TO_NUMBER_FINALIZE (old_num);
   ECMA_FINALIZE (old_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_post_incr */
@@ -397,7 +397,7 @@ opfunc_post_incr (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_post_decr (opcode_t opdata, /**< operation data */
-                  int_data_t *int_data) /**< interpreter context */
+                  vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.post_decr.dst;
   const idx_t decr_var_idx = opdata.data.post_decr.var_right;
@@ -405,24 +405,24 @@ 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 (old_value, get_variable_value (frame_ctx_p, decr_var_idx, true), ret_value);
   ECMA_OP_TO_NUMBER_TRY_CATCH (old_num, old_value, ret_value);
 
   // 4.
-  ecma_number_t* new_num_p = int_data->tmp_num_p;
+  ecma_number_t* new_num_p = frame_ctx_p->tmp_num_p;
 
   *new_num_p = ecma_number_substract (old_num, ECMA_NUMBER_ONE);
 
   // 5.
-  ret_value = set_variable_value (int_data, int_data->pos,
+  ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos,
                                   decr_var_idx,
                                   ecma_make_number_value (new_num_p));
 
-  ecma_number_t *tmp_p = int_data->tmp_num_p;
+  ecma_number_t *tmp_p = frame_ctx_p->tmp_num_p;
   *tmp_p = old_num;
 
   // assignment of operator result to register variable
-  ecma_completion_value_t reg_assignment_res = set_variable_value (int_data, int_data->pos,
+  ecma_completion_value_t reg_assignment_res = set_variable_value (frame_ctx_p, frame_ctx_p->pos,
                                                                    dst_var_idx,
                                                                    ecma_make_number_value (tmp_p));
   JERRY_ASSERT (ecma_is_completion_value_empty (reg_assignment_res));
@@ -430,7 +430,7 @@ opfunc_post_decr (opcode_t opdata, /**< operation data */
   ECMA_OP_TO_NUMBER_FINALIZE (old_num);
   ECMA_FINALIZE (old_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_post_decr */
@@ -442,7 +442,7 @@ opfunc_post_decr (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_reg_var_decl (opcode_t opdata __attr_unused___, /**< operation data */
-                     int_data_t *int_data __attr_unused___) /**< interpreter context */
+                     vm_frame_ctx_t *frame_ctx_p __attr_unused___) /**< interpreter context */
 {
   JERRY_UNREACHABLE ();
 } /* opfunc_reg_var_decl */
@@ -458,20 +458,20 @@ opfunc_reg_var_decl (opcode_t opdata __attr_unused___, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_var_decl (opcode_t opdata, /**< operation data */
-                 int_data_t *int_data) /**< interpreter context */
+                 vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (opdata.data.var_decl.variable_name,
-                                                            int_data->opcodes_p,
-                                                            int_data->pos);
+                                                            frame_ctx_p->opcodes_p,
+                                                            frame_ctx_p->pos);
   JERRY_ASSERT (lit_cp.packed_value != MEM_CP_NULL);
 
   ecma_string_t *var_name_string_p = ecma_new_ecma_string_from_lit_cp (lit_cp);
 
-  if (!ecma_op_has_binding (int_data->lex_env_p, var_name_string_p))
+  if (!ecma_op_has_binding (frame_ctx_p->lex_env_p, var_name_string_p))
   {
-    const bool is_configurable_bindings = int_data->is_eval_code;
+    const bool is_configurable_bindings = frame_ctx_p->is_eval_code;
 
-    ecma_completion_value_t completion = ecma_op_create_mutable_binding (int_data->lex_env_p,
+    ecma_completion_value_t completion = ecma_op_create_mutable_binding (frame_ctx_p->lex_env_p,
                                                                          var_name_string_p,
                                                                          is_configurable_bindings);
 
@@ -480,7 +480,7 @@ opfunc_var_decl (opcode_t opdata, /**< operation data */
     /* Skipping SetMutableBinding as we have already checked that there were not
      * any binding with specified name in current lexical environment
      * and CreateMutableBinding sets the created binding's value to undefined */
-    JERRY_ASSERT (ecma_is_completion_value_normal_simple_value (ecma_op_get_binding_value (int_data->lex_env_p,
+    JERRY_ASSERT (ecma_is_completion_value_normal_simple_value (ecma_op_get_binding_value (frame_ctx_p->lex_env_p,
                                                                                            var_name_string_p,
                                                                                            true),
                                                                 ECMA_SIMPLE_VALUE_UNDEFINED));
@@ -488,7 +488,7 @@ opfunc_var_decl (opcode_t opdata, /**< operation data */
 
   ecma_deref_ecma_string (var_name_string_p);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ecma_make_empty_completion_value ();
 } /* opfunc_var_decl */
@@ -500,20 +500,20 @@ opfunc_var_decl (opcode_t opdata, /**< operation data */
  *         returned value must be freed with ecma_free_completion_value.
  */
 static ecma_completion_value_t
-function_declaration (int_data_t *int_data, /**< interpreter context */
+function_declaration (vm_frame_ctx_t *frame_ctx_p, /**< interpreter context */
                       lit_cpointer_t function_name_lit_cp, /**< compressed pointer to literal with function name */
                       ecma_string_t* args_names[], /**< names of arguments */
                       ecma_length_t args_number) /**< number of arguments */
 {
-  bool is_strict = int_data->is_strict;
+  bool is_strict = frame_ctx_p->is_strict;
   bool do_instantiate_arguments_object = true;
-  const bool is_configurable_bindings = int_data->is_eval_code;
+  const bool is_configurable_bindings = frame_ctx_p->is_eval_code;
 
   const opcode_counter_t function_code_end_oc = (opcode_counter_t) (
-    read_meta_opcode_counter (OPCODE_META_TYPE_FUNCTION_END, int_data) + int_data->pos);
-  int_data->pos++;
+    read_meta_opcode_counter (OPCODE_META_TYPE_FUNCTION_END, frame_ctx_p) + frame_ctx_p->pos);
+  frame_ctx_p->pos++;
 
-  opcode_scope_code_flags_t scope_flags = vm_get_scope_flags (int_data->opcodes_p, int_data->pos++);
+  opcode_scope_code_flags_t scope_flags = vm_get_scope_flags (frame_ctx_p->opcodes_p, frame_ctx_p->pos++);
 
   if (scope_flags & OPCODE_SCOPE_CODE_FLAGS_STRICT)
   {
@@ -530,10 +530,10 @@ function_declaration (int_data_t *int_data, /**< interpreter context */
 
   ecma_string_t *function_name_string_p = ecma_new_ecma_string_from_lit_cp (function_name_lit_cp);
 
-  ecma_completion_value_t ret_value = ecma_op_function_declaration (int_data->lex_env_p,
+  ecma_completion_value_t ret_value = ecma_op_function_declaration (frame_ctx_p->lex_env_p,
                                                                     function_name_string_p,
-                                                                    int_data->opcodes_p,
-                                                                    int_data->pos,
+                                                                    frame_ctx_p->opcodes_p,
+                                                                    frame_ctx_p->pos,
                                                                     args_names,
                                                                     args_number,
                                                                     is_strict,
@@ -541,7 +541,7 @@ function_declaration (int_data_t *int_data, /**< interpreter context */
                                                                     is_configurable_bindings);
   ecma_deref_ecma_string (function_name_string_p);
 
-  int_data->pos = function_code_end_oc;
+  frame_ctx_p->pos = function_code_end_oc;
 
   return ret_value;
 } /* function_declaration */
@@ -554,24 +554,24 @@ function_declaration (int_data_t *int_data, /**< interpreter context */
  */
 ecma_completion_value_t
 opfunc_func_decl_n (opcode_t opdata, /**< operation data */
-                    int_data_t *int_data) /**< interpreter context */
+                    vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t function_name_idx = opdata.data.func_decl_n.name_lit_idx;
   const ecma_length_t params_number = opdata.data.func_decl_n.arg_list;
 
   lit_cpointer_t function_name_lit_cp = serializer_get_literal_cp_by_uid (function_name_idx,
-                                                                          int_data->opcodes_p,
-                                                                          int_data->pos);
+                                                                          frame_ctx_p->opcodes_p,
+                                                                          frame_ctx_p->pos);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   ecma_completion_value_t ret_value;
 
   MEM_DEFINE_LOCAL_ARRAY (params_names, params_number, ecma_string_t*);
 
-  fill_params_list (int_data, params_number, params_names);
+  fill_params_list (frame_ctx_p, params_number, params_names);
 
-  ret_value = function_declaration (int_data,
+  ret_value = function_declaration (frame_ctx_p,
                                     function_name_lit_cp,
                                     params_names,
                                     params_number);
@@ -596,11 +596,11 @@ opfunc_func_decl_n (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_func_expr_n (opcode_t opdata, /**< operation data */
-                    int_data_t *int_data) /**< interpreter context */
+                    vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
-  const opcode_counter_t lit_oc = int_data->pos;
+  const opcode_counter_t lit_oc = frame_ctx_p->pos;
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   const idx_t dst_var_idx = opdata.data.func_expr_n.lhs;
   const idx_t function_name_lit_idx = opdata.data.func_expr_n.name_lit_idx;
@@ -613,17 +613,17 @@ opfunc_func_expr_n (opcode_t opdata, /**< operation data */
 
   MEM_DEFINE_LOCAL_ARRAY (params_names, params_number, ecma_string_t*);
 
-  fill_params_list (int_data, params_number, params_names);
+  fill_params_list (frame_ctx_p, params_number, params_names);
 
-  bool is_strict = int_data->is_strict;
+  bool is_strict = frame_ctx_p->is_strict;
   bool do_instantiate_arguments_object = true;
 
   function_code_end_oc = (opcode_counter_t) (read_meta_opcode_counter (OPCODE_META_TYPE_FUNCTION_END,
-                                                                       int_data) + int_data->pos);
-  int_data->pos++;
+                                                                       frame_ctx_p) + frame_ctx_p->pos);
+  frame_ctx_p->pos++;
 
-  opcode_scope_code_flags_t scope_flags = vm_get_scope_flags (int_data->opcodes_p,
-                                                              int_data->pos++);
+  opcode_scope_code_flags_t scope_flags = vm_get_scope_flags (frame_ctx_p->opcodes_p,
+                                                              frame_ctx_p->pos++);
 
   if (scope_flags & OPCODE_SCOPE_CODE_FLAGS_STRICT)
   {
@@ -642,10 +642,10 @@ opfunc_func_expr_n (opcode_t opdata, /**< operation data */
   ecma_string_t *function_name_string_p = NULL;
   if (is_named_func_expr)
   {
-    scope_p = ecma_create_decl_lex_env (int_data->lex_env_p);
+    scope_p = ecma_create_decl_lex_env (frame_ctx_p->lex_env_p);
 
     lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (function_name_lit_idx,
-                                                              int_data->opcodes_p,
+                                                              frame_ctx_p->opcodes_p,
                                                               lit_oc);
     JERRY_ASSERT (lit_cp.packed_value != MEM_CP_NULL);
 
@@ -654,7 +654,7 @@ opfunc_func_expr_n (opcode_t opdata, /**< operation data */
   }
   else
   {
-    scope_p = int_data->lex_env_p;
+    scope_p = frame_ctx_p->lex_env_p;
     ecma_ref_object (scope_p);
   }
 
@@ -663,10 +663,10 @@ opfunc_func_expr_n (opcode_t opdata, /**< operation data */
                                                               scope_p,
                                                               is_strict,
                                                               do_instantiate_arguments_object,
-                                                              int_data->opcodes_p,
-                                                              int_data->pos);
+                                                              frame_ctx_p->opcodes_p,
+                                                              frame_ctx_p->pos);
 
-  ret_value = set_variable_value (int_data, lit_oc,
+  ret_value = set_variable_value (frame_ctx_p, lit_oc,
                                   dst_var_idx,
                                   ecma_make_object_value (func_obj_p));
 
@@ -690,7 +690,7 @@ opfunc_func_expr_n (opcode_t opdata, /**< operation data */
 
   MEM_FINALIZE_LOCAL_ARRAY (params_names);
 
-  int_data->pos = function_code_end_oc;
+  frame_ctx_p->pos = function_code_end_oc;
 
   return ret_value;
 } /* opfunc_func_expr_n */
@@ -705,7 +705,7 @@ opfunc_func_expr_n (opcode_t opdata, /**< operation data */
  *         Returned value must be freed with ecma_free_value
  */
 static ecma_value_t
-vm_helper_call_get_call_flags_and_this_arg (int_data_t *int_data_p, /**< interpreter context */
+vm_helper_call_get_call_flags_and_this_arg (vm_frame_ctx_t *int_data_p, /**< interpreter context */
                                             opcode_counter_t var_idx_lit_oc, /**< opcode counter, corresponding to
                                                                               *   instruction with function_var_idx */
                                             idx_t var_idx, /**< idx, used to retrieve the called function object */
@@ -817,23 +817,23 @@ vm_helper_call_get_call_flags_and_this_arg (int_data_t *int_data_p, /**< interpr
  */
 ecma_completion_value_t
 opfunc_call_n (opcode_t opdata, /**< operation data */
-               int_data_t *int_data) /**< interpreter context */
+               vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t lhs_var_idx = opdata.data.call_n.lhs;
   const idx_t function_var_idx = opdata.data.call_n.function_var_idx;
   const idx_t args_number_idx = opdata.data.call_n.arg_list;
-  const opcode_counter_t lit_oc = int_data->pos;
+  const opcode_counter_t lit_oc = frame_ctx_p->pos;
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
-  ECMA_TRY_CATCH (func_value, get_variable_value (int_data, function_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (func_value, get_variable_value (frame_ctx_p, function_var_idx, false), ret_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
-  JERRY_ASSERT (!int_data->is_call_in_direct_eval_form);
+  JERRY_ASSERT (!frame_ctx_p->is_call_in_direct_eval_form);
 
   opcode_call_flags_t call_flags;
-  ecma_value_t this_value = vm_helper_call_get_call_flags_and_this_arg (int_data,
+  ecma_value_t this_value = vm_helper_call_get_call_flags_and_this_arg (frame_ctx_p,
                                                                         lit_oc,
                                                                         function_var_idx,
                                                                         &call_flags);
@@ -841,7 +841,7 @@ opfunc_call_n (opcode_t opdata, /**< operation data */
   MEM_DEFINE_LOCAL_ARRAY (arg_values, args_number_idx, ecma_value_t);
 
   ecma_length_t args_read;
-  ecma_completion_value_t get_arg_completion = fill_varg_list (int_data,
+  ecma_completion_value_t get_arg_completion = fill_varg_list (frame_ctx_p,
                                                                args_number_idx,
                                                                arg_values,
                                                                &args_read);
@@ -858,7 +858,7 @@ opfunc_call_n (opcode_t opdata, /**< operation data */
     {
       if (call_flags & OPCODE_CALL_FLAGS_DIRECT_CALL_TO_EVAL_FORM)
       {
-        int_data->is_call_in_direct_eval_form = true;
+        frame_ctx_p->is_call_in_direct_eval_form = true;
       }
 
       ecma_object_t *func_obj_p = ecma_get_object_from_value (func_value);
@@ -870,7 +870,7 @@ opfunc_call_n (opcode_t opdata, /**< operation data */
                                              args_number_idx),
                       ret_value);
 
-      ret_value = set_variable_value (int_data, lit_oc,
+      ret_value = set_variable_value (frame_ctx_p, lit_oc,
                                       lhs_var_idx,
                                       call_ret_value);
 
@@ -878,12 +878,12 @@ opfunc_call_n (opcode_t opdata, /**< operation data */
 
       if (call_flags & OPCODE_CALL_FLAGS_DIRECT_CALL_TO_EVAL_FORM)
       {
-        JERRY_ASSERT (int_data->is_call_in_direct_eval_form);
-        int_data->is_call_in_direct_eval_form = false;
+        JERRY_ASSERT (frame_ctx_p->is_call_in_direct_eval_form);
+        frame_ctx_p->is_call_in_direct_eval_form = false;
       }
       else
       {
-        JERRY_ASSERT (!int_data->is_call_in_direct_eval_form);
+        JERRY_ASSERT (!frame_ctx_p->is_call_in_direct_eval_form);
       }
     }
   }
@@ -920,24 +920,24 @@ opfunc_call_n (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_construct_n (opcode_t opdata, /**< operation data */
-                    int_data_t *int_data) /**< interpreter context */
+                    vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t lhs_var_idx = opdata.data.construct_n.lhs;
   const idx_t constructor_name_lit_idx = opdata.data.construct_n.name_lit_idx;
   const idx_t args_number = opdata.data.construct_n.arg_list;
-  const opcode_counter_t lit_oc = int_data->pos;
+  const opcode_counter_t lit_oc = frame_ctx_p->pos;
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
   ECMA_TRY_CATCH (constructor_value,
-                  get_variable_value (int_data, constructor_name_lit_idx, false),
+                  get_variable_value (frame_ctx_p, constructor_name_lit_idx, false),
                   ret_value);
 
   MEM_DEFINE_LOCAL_ARRAY (arg_values, args_number, ecma_value_t);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   ecma_length_t args_read;
-  ecma_completion_value_t get_arg_completion = fill_varg_list (int_data,
+  ecma_completion_value_t get_arg_completion = fill_varg_list (frame_ctx_p,
                                                                args_number,
                                                                arg_values,
                                                                &args_read);
@@ -960,7 +960,7 @@ opfunc_construct_n (opcode_t opdata, /**< operation data */
                                                   args_number),
                       ret_value);
 
-      ret_value = set_variable_value (int_data, lit_oc, lhs_var_idx,
+      ret_value = set_variable_value (frame_ctx_p, lit_oc, lhs_var_idx,
                                       construction_ret_value);
 
       ECMA_FINALIZE (construction_ret_value);
@@ -997,20 +997,20 @@ opfunc_construct_n (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_array_decl (opcode_t opdata, /**< operation data */
-                   int_data_t *int_data) /**< interpreter context */
+                   vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t lhs_var_idx = opdata.data.array_decl.lhs;
   const idx_t args_number = opdata.data.array_decl.list;
-  const opcode_counter_t lit_oc = int_data->pos;
+  const opcode_counter_t lit_oc = frame_ctx_p->pos;
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
   MEM_DEFINE_LOCAL_ARRAY (arg_values, args_number, ecma_value_t);
 
   ecma_length_t args_read;
-  ecma_completion_value_t get_arg_completion = fill_varg_list (int_data,
+  ecma_completion_value_t get_arg_completion = fill_varg_list (frame_ctx_p,
                                                                args_number,
                                                                arg_values,
                                                                &args_read);
@@ -1025,7 +1025,7 @@ opfunc_array_decl (opcode_t opdata, /**< operation data */
                                                  false),
                     ret_value);
 
-    ret_value = set_variable_value (int_data, lit_oc,
+    ret_value = set_variable_value (frame_ctx_p, lit_oc,
                                     lhs_var_idx,
                                     array_obj_value);
 
@@ -1060,13 +1060,13 @@ opfunc_array_decl (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_obj_decl (opcode_t opdata, /**< operation data */
-                 int_data_t *int_data) /**< interpreter context */
+                 vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t lhs_var_idx = opdata.data.obj_decl.lhs;
   const idx_t args_number = opdata.data.obj_decl.list;
-  const opcode_counter_t obj_lit_oc = int_data->pos;
+  const opcode_counter_t obj_lit_oc = frame_ctx_p->pos;
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
@@ -1076,11 +1076,11 @@ opfunc_obj_decl (opcode_t opdata, /**< operation data */
        prop_index < args_number && ecma_is_completion_value_empty (ret_value);
        prop_index++)
   {
-    ecma_completion_value_t evaluate_prop_completion = vm_loop (int_data, NULL);
+    ecma_completion_value_t evaluate_prop_completion = vm_loop (frame_ctx_p, NULL);
 
     if (ecma_is_completion_value_empty (evaluate_prop_completion))
     {
-      opcode_t next_opcode = vm_get_opcode (int_data->opcodes_p, int_data->pos);
+      opcode_t next_opcode = vm_get_opcode (frame_ctx_p->opcodes_p, frame_ctx_p->pos);
       JERRY_ASSERT (next_opcode.op_idx == __op__idx_meta);
 
       const opcode_meta_type type = (opcode_meta_type) next_opcode.data.meta.type;
@@ -1089,17 +1089,17 @@ opfunc_obj_decl (opcode_t opdata, /**< operation data */
                     || type == OPCODE_META_TYPE_VARG_PROP_SETTER);
 
       const idx_t prop_name_var_idx = next_opcode.data.meta.data_1;
-      JERRY_ASSERT (is_reg_variable (int_data, prop_name_var_idx));
+      JERRY_ASSERT (is_reg_variable (frame_ctx_p, prop_name_var_idx));
 
       const idx_t value_for_prop_desc_var_idx = next_opcode.data.meta.data_2;
 
       ECMA_TRY_CATCH (value_for_prop_desc,
-                      get_variable_value (int_data,
+                      get_variable_value (frame_ctx_p,
                                           value_for_prop_desc_var_idx,
                                           false),
                       ret_value);
       ECMA_TRY_CATCH (prop_name_value,
-                      get_variable_value (int_data,
+                      get_variable_value (frame_ctx_p,
                                           prop_name_var_idx,
                                           false),
                       ret_value);
@@ -1138,7 +1138,7 @@ opfunc_obj_decl (opcode_t opdata, /**< operation data */
 
         if (!is_previous_undefined
             && ((is_previous_data_desc
-                 && int_data->is_strict)
+                 && frame_ctx_p->is_strict)
                 || is_previous_accessor_desc))
         {
           is_throw_syntax_error = true;
@@ -1182,7 +1182,7 @@ opfunc_obj_decl (opcode_t opdata, /**< operation data */
 
       ECMA_FINALIZE (value_for_prop_desc);
 
-      int_data->pos++;
+      frame_ctx_p->pos++;
     }
     else
     {
@@ -1194,7 +1194,7 @@ opfunc_obj_decl (opcode_t opdata, /**< operation data */
 
   if (ecma_is_completion_value_empty (ret_value))
   {
-    ret_value = set_variable_value (int_data, obj_lit_oc, lhs_var_idx, ecma_make_object_value (obj_p));
+    ret_value = set_variable_value (frame_ctx_p, obj_lit_oc, lhs_var_idx, ecma_make_object_value (obj_p));
   }
   else
   {
@@ -1216,7 +1216,7 @@ opfunc_obj_decl (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_ret (opcode_t opdata __attr_unused___, /**< operation data */
-            int_data_t *int_data __attr_unused___) /**< interpreter context */
+            vm_frame_ctx_t *frame_ctx_p __attr_unused___) /**< interpreter context */
 {
   return ecma_make_return_completion_value (ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED));
 } /* opfunc_ret */
@@ -1232,11 +1232,11 @@ opfunc_ret (opcode_t opdata __attr_unused___, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_retval (opcode_t opdata __attr_unused___, /**< operation data */
-               int_data_t *int_data __attr_unused___) /**< interpreter context */
+               vm_frame_ctx_t *frame_ctx_p __attr_unused___) /**< interpreter context */
 {
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
-  ECMA_TRY_CATCH (expr_val, get_variable_value (int_data, opdata.data.retval.ret_value, false), ret_value);
+  ECMA_TRY_CATCH (expr_val, get_variable_value (frame_ctx_p, opdata.data.retval.ret_value, false), ret_value);
 
   ret_value = ecma_make_return_completion_value (ecma_copy_value (expr_val, true));
 
@@ -1256,7 +1256,7 @@ opfunc_retval (opcode_t opdata __attr_unused___, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_prop_getter (opcode_t opdata __attr_unused___, /**< operation data */
-                    int_data_t *int_data __attr_unused___) /**< interpreter context */
+                    vm_frame_ctx_t *frame_ctx_p __attr_unused___) /**< interpreter context */
 {
   const idx_t lhs_var_idx = opdata.data.prop_getter.lhs;
   const idx_t base_var_idx = opdata.data.prop_getter.obj;
@@ -1265,10 +1265,10 @@ opfunc_prop_getter (opcode_t opdata __attr_unused___, /**< operation data */
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
   ECMA_TRY_CATCH (base_value,
-                  get_variable_value (int_data, base_var_idx, false),
+                  get_variable_value (frame_ctx_p, base_var_idx, false),
                   ret_value);
   ECMA_TRY_CATCH (prop_name_value,
-                  get_variable_value (int_data, prop_name_var_idx, false),
+                  get_variable_value (frame_ctx_p, prop_name_var_idx, false),
                   ret_value);
   ECMA_TRY_CATCH (check_coercible_ret,
                   ecma_op_check_object_coercible (base_value),
@@ -1278,11 +1278,11 @@ opfunc_prop_getter (opcode_t opdata __attr_unused___, /**< operation data */
                   ret_value);
 
   ecma_string_t *prop_name_string_p = ecma_get_string_from_value (prop_name_str_value);
-  ecma_reference_t ref = ecma_make_reference (base_value, prop_name_string_p, int_data->is_strict);
+  ecma_reference_t ref = ecma_make_reference (base_value, prop_name_string_p, frame_ctx_p->is_strict);
 
   ECMA_TRY_CATCH (prop_value, ecma_op_get_value_object_base (ref), ret_value);
 
-  ret_value = set_variable_value (int_data, int_data->pos, lhs_var_idx, prop_value);
+  ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos, lhs_var_idx, prop_value);
 
   ECMA_FINALIZE (prop_value);
 
@@ -1293,7 +1293,7 @@ opfunc_prop_getter (opcode_t opdata __attr_unused___, /**< operation data */
   ECMA_FINALIZE (prop_name_value);
   ECMA_FINALIZE (base_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_prop_getter */
@@ -1309,7 +1309,7 @@ opfunc_prop_getter (opcode_t opdata __attr_unused___, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_prop_setter (opcode_t opdata __attr_unused___, /**< operation data */
-                    int_data_t *int_data __attr_unused___) /**< interpreter context */
+                    vm_frame_ctx_t *frame_ctx_p __attr_unused___) /**< interpreter context */
 {
   const idx_t base_var_idx = opdata.data.prop_setter.obj;
   const idx_t prop_name_var_idx = opdata.data.prop_setter.prop;
@@ -1318,10 +1318,10 @@ opfunc_prop_setter (opcode_t opdata __attr_unused___, /**< operation data */
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
   ECMA_TRY_CATCH (base_value,
-                  get_variable_value (int_data, base_var_idx, false),
+                  get_variable_value (frame_ctx_p, base_var_idx, false),
                   ret_value);
   ECMA_TRY_CATCH (prop_name_value,
-                  get_variable_value (int_data, prop_name_var_idx, false),
+                  get_variable_value (frame_ctx_p, prop_name_var_idx, false),
                   ret_value);
   ECMA_TRY_CATCH (check_coercible_ret,
                   ecma_op_check_object_coercible (base_value),
@@ -1333,9 +1333,9 @@ opfunc_prop_setter (opcode_t opdata __attr_unused___, /**< operation data */
   ecma_string_t *prop_name_string_p = ecma_get_string_from_value (prop_name_str_value);
   ecma_reference_t ref = ecma_make_reference (base_value,
                                               prop_name_string_p,
-                                              int_data->is_strict);
+                                              frame_ctx_p->is_strict);
 
-  ECMA_TRY_CATCH (rhs_value, get_variable_value (int_data, rhs_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (rhs_value, get_variable_value (frame_ctx_p, rhs_var_idx, false), ret_value);
   ret_value = ecma_op_put_value_object_base (ref, rhs_value);
   ECMA_FINALIZE (rhs_value);
 
@@ -1346,7 +1346,7 @@ opfunc_prop_setter (opcode_t opdata __attr_unused___, /**< operation data */
   ECMA_FINALIZE (prop_name_value);
   ECMA_FINALIZE (base_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_prop_setter */
@@ -1361,14 +1361,14 @@ opfunc_prop_setter (opcode_t opdata __attr_unused___, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_logical_not (opcode_t opdata, /**< operation data */
-                    int_data_t *int_data) /**< interpreter context */
+                    vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.logical_not.dst;
   const idx_t right_var_idx = opdata.data.logical_not.var_right;
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
-  ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
+  ECMA_TRY_CATCH (right_value, get_variable_value (frame_ctx_p, 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);
@@ -1378,13 +1378,13 @@ opfunc_logical_not (opcode_t opdata, /**< operation data */
     old_value = ECMA_SIMPLE_VALUE_FALSE;
   }
 
-  ret_value = set_variable_value (int_data, int_data->pos,
+  ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos,
                                   dst_var_idx,
                                   ecma_make_simple_value (old_value));
 
   ECMA_FINALIZE (right_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_logical_not */
@@ -1399,18 +1399,18 @@ opfunc_logical_not (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_this_binding (opcode_t opdata, /**< operation data */
-                     int_data_t *int_data) /**< interpreter context */
+                     vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.this_binding.lhs;
-  const opcode_counter_t lit_oc = int_data->pos;
+  const opcode_counter_t lit_oc = frame_ctx_p->pos;
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   ecma_completion_value_t ret_value;
 
-  ret_value = set_variable_value (int_data, lit_oc,
+  ret_value = set_variable_value (frame_ctx_p, lit_oc,
                                   dst_var_idx,
-                                  int_data->this_binding);
+                                  frame_ctx_p->this_binding);
 
   return ret_value;
 } /* opfunc_this_binding */
@@ -1425,18 +1425,18 @@ opfunc_this_binding (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_with (opcode_t opdata, /**< operation data */
-             int_data_t *int_data) /**< interpreter context */
+             vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t expr_var_idx = opdata.data.with.expr;
   const idx_t block_end_oc_idx_1 = opdata.data.with.oc_idx_1;
   const idx_t block_end_oc_idx_2 = opdata.data.with.oc_idx_2;
   const opcode_counter_t with_end_oc = (opcode_counter_t) (
-    calc_opcode_counter_from_idx_idx (block_end_oc_idx_1, block_end_oc_idx_2) + int_data->pos);
+    calc_opcode_counter_from_idx_idx (block_end_oc_idx_1, block_end_oc_idx_2) + frame_ctx_p->pos);
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
   ECMA_TRY_CATCH (expr_value,
-                  get_variable_value (int_data,
+                  get_variable_value (frame_ctx_p,
                                       expr_var_idx,
                                       false),
                   ret_value);
@@ -1444,42 +1444,42 @@ opfunc_with (opcode_t opdata, /**< operation data */
                   ecma_op_to_object (expr_value),
                   ret_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   ecma_object_t *obj_p = ecma_get_object_from_value (obj_expr_value);
 
-  ecma_object_t *old_env_p = int_data->lex_env_p;
+  ecma_object_t *old_env_p = frame_ctx_p->lex_env_p;
   ecma_object_t *new_env_p = ecma_create_object_lex_env (old_env_p,
                                                          obj_p,
                                                          true);
-  int_data->lex_env_p = new_env_p;
+  frame_ctx_p->lex_env_p = new_env_p;
 
 #ifndef JERRY_NDEBUG
-  opcode_t meta_opcode = vm_get_opcode (int_data->opcodes_p, with_end_oc);
+  opcode_t meta_opcode = vm_get_opcode (frame_ctx_p->opcodes_p, with_end_oc);
   JERRY_ASSERT (meta_opcode.op_idx == __op__idx_meta);
   JERRY_ASSERT (meta_opcode.data.meta.type == OPCODE_META_TYPE_END_WITH);
 #endif /* !JERRY_NDEBUG */
 
-  vm_run_scope_t run_scope_with = { int_data->pos, with_end_oc };
-  ecma_completion_value_t with_completion = vm_loop (int_data, &run_scope_with);
+  vm_run_scope_t run_scope_with = { frame_ctx_p->pos, with_end_oc };
+  ecma_completion_value_t with_completion = vm_loop (frame_ctx_p, &run_scope_with);
 
   if (ecma_is_completion_value_empty (with_completion))
   {
-    JERRY_ASSERT (int_data->pos == with_end_oc);
+    JERRY_ASSERT (frame_ctx_p->pos == with_end_oc);
 
-    int_data->pos++;
+    frame_ctx_p->pos++;
   }
   else
   {
     JERRY_ASSERT (ecma_is_completion_value_throw (with_completion)
                   || ecma_is_completion_value_return (with_completion)
                   || ecma_is_completion_value_jump (with_completion));
-    JERRY_ASSERT (int_data->pos <= with_end_oc);
+    JERRY_ASSERT (frame_ctx_p->pos <= with_end_oc);
   }
 
   ret_value = with_completion;
 
-  int_data->lex_env_p = old_env_p;
+  frame_ctx_p->lex_env_p = old_env_p;
 
   ecma_deref_object (new_env_p);
 
@@ -1499,14 +1499,14 @@ opfunc_with (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_throw_value (opcode_t opdata, /**< operation data */
-                    int_data_t *int_data) /**< interpreter context */
+                    vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t var_idx = opdata.data.throw_value.var;
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
   ECMA_TRY_CATCH (var_value,
-                  get_variable_value (int_data,
+                  get_variable_value (frame_ctx_p,
                                       var_idx,
                                       false),
                   ret_value);
@@ -1515,7 +1515,7 @@ opfunc_throw_value (opcode_t opdata, /**< operation data */
 
   ECMA_FINALIZE (var_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_throw_value */
@@ -1529,27 +1529,27 @@ opfunc_throw_value (opcode_t opdata, /**< operation data */
  *         Returned value must be freed with ecma_free_completion_value
  */
 static ecma_completion_value_t
-evaluate_arg_for_typeof (int_data_t *int_data, /**< interpreter context */
+evaluate_arg_for_typeof (vm_frame_ctx_t *frame_ctx_p, /**< interpreter context */
                          idx_t var_idx) /**< arg variable identifier */
 {
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
-  if (is_reg_variable (int_data, var_idx))
+  if (is_reg_variable (frame_ctx_p, var_idx))
   {
     // 2.b
-    ret_value = get_variable_value (int_data,
+    ret_value = get_variable_value (frame_ctx_p,
                                     var_idx,
                                     false);
     JERRY_ASSERT (ecma_is_completion_value_normal (ret_value));
   }
   else
   {
-    lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (var_idx, int_data->opcodes_p, int_data->pos);
+    lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (var_idx, frame_ctx_p->opcodes_p, frame_ctx_p->pos);
     JERRY_ASSERT (lit_cp.packed_value != MEM_CP_NULL);
 
     ecma_string_t *var_name_string_p = ecma_new_ecma_string_from_lit_cp (lit_cp);
 
-    ecma_object_t *ref_base_lex_env_p = ecma_op_resolve_reference_base (int_data->lex_env_p,
+    ecma_object_t *ref_base_lex_env_p = ecma_op_resolve_reference_base (frame_ctx_p->lex_env_p,
                                                                         var_name_string_p);
     if (ref_base_lex_env_p == NULL)
     {
@@ -1559,7 +1559,7 @@ evaluate_arg_for_typeof (int_data_t *int_data, /**< interpreter context */
     {
       ret_value = ecma_op_get_value_lex_env_base (ref_base_lex_env_p,
                                                   var_name_string_p,
-                                                  int_data->is_strict);
+                                                  frame_ctx_p->is_strict);
     }
 
     ecma_deref_ecma_string (var_name_string_p);
@@ -1578,7 +1578,7 @@ evaluate_arg_for_typeof (int_data_t *int_data, /**< interpreter context */
  */
 ecma_completion_value_t
 opfunc_typeof (opcode_t opdata, /**< operation data */
-               int_data_t *int_data) /**< interpreter context */
+               vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.typeof.lhs;
   const idx_t obj_var_idx = opdata.data.typeof.obj;
@@ -1586,7 +1586,7 @@ opfunc_typeof (opcode_t opdata, /**< operation data */
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
   ECMA_TRY_CATCH (typeof_arg,
-                  evaluate_arg_for_typeof (int_data,
+                  evaluate_arg_for_typeof (frame_ctx_p,
                                            obj_var_idx),
                   ret_value);
 
@@ -1627,7 +1627,7 @@ opfunc_typeof (opcode_t opdata, /**< operation data */
     }
   }
 
-  ret_value = set_variable_value (int_data, int_data->pos,
+  ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos,
                                   dst_var_idx,
                                   ecma_make_string_value (type_str_p));
 
@@ -1635,7 +1635,7 @@ opfunc_typeof (opcode_t opdata, /**< operation data */
 
   ECMA_FINALIZE (typeof_arg);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_typeof */
@@ -1650,24 +1650,24 @@ opfunc_typeof (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_delete_var (opcode_t opdata, /**< operation data */
-                   int_data_t *int_data) /**< interpreter context */
+                   vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.delete_var.lhs;
   const idx_t name_lit_idx = opdata.data.delete_var.name;
-  const opcode_counter_t lit_oc = int_data->pos;
+  const opcode_counter_t lit_oc = frame_ctx_p->pos;
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
-  lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (name_lit_idx, int_data->opcodes_p, lit_oc);
+  lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (name_lit_idx, frame_ctx_p->opcodes_p, lit_oc);
   JERRY_ASSERT (lit_cp.packed_value != MEM_CP_NULL);
 
   ecma_string_t *name_string_p = ecma_new_ecma_string_from_lit_cp (lit_cp);
 
-  ecma_reference_t ref = ecma_op_get_identifier_reference (int_data->lex_env_p,
+  ecma_reference_t ref = ecma_op_get_identifier_reference (frame_ctx_p->lex_env_p,
                                                            name_string_p,
-                                                           int_data->is_strict);
+                                                           frame_ctx_p->is_strict);
 
   if (ref.is_strict)
   {
@@ -1678,7 +1678,7 @@ opfunc_delete_var (opcode_t opdata, /**< operation data */
   {
     if (ecma_is_value_undefined (ref.base))
     {
-      ret_value = set_variable_value (int_data, lit_oc,
+      ret_value = set_variable_value (frame_ctx_p, lit_oc,
                                       dst_var_idx,
                                       ecma_make_simple_value (ECMA_SIMPLE_VALUE_TRUE));
     }
@@ -1693,7 +1693,7 @@ opfunc_delete_var (opcode_t opdata, /**< operation data */
                                                                          ref.referenced_name_cp)),
                       ret_value);
 
-      ret_value = set_variable_value (int_data, lit_oc, dst_var_idx, delete_completion);
+      ret_value = set_variable_value (frame_ctx_p, lit_oc, dst_var_idx, delete_completion);
 
       ECMA_FINALIZE (delete_completion);
     }
@@ -1717,7 +1717,7 @@ opfunc_delete_var (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_delete_prop (opcode_t opdata, /**< operation data */
-                    int_data_t *int_data) /**< interpreter context */
+                    vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
   const idx_t dst_var_idx = opdata.data.delete_prop.lhs;
   const idx_t base_var_idx = opdata.data.delete_prop.base;
@@ -1726,10 +1726,10 @@ opfunc_delete_prop (opcode_t opdata, /**< operation data */
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
   ECMA_TRY_CATCH (base_value,
-                  get_variable_value (int_data, base_var_idx, false),
+                  get_variable_value (frame_ctx_p, base_var_idx, false),
                   ret_value);
   ECMA_TRY_CATCH (name_value,
-                  get_variable_value (int_data, name_var_idx, false),
+                  get_variable_value (frame_ctx_p, name_var_idx, false),
                   ret_value);
   ECMA_TRY_CATCH (check_coercible_ret,
                   ecma_op_check_object_coercible (base_value),
@@ -1743,7 +1743,7 @@ opfunc_delete_prop (opcode_t opdata, /**< operation data */
 
   if (ecma_is_value_undefined (base_value))
   {
-    if (int_data->is_strict)
+    if (frame_ctx_p->is_strict)
     {
       /* SyntaxError should be treated as an early error */
       JERRY_UNREACHABLE ();
@@ -1762,10 +1762,10 @@ opfunc_delete_prop (opcode_t opdata, /**< operation data */
     JERRY_ASSERT (!ecma_is_lexical_environment (obj_p));
 
     ECMA_TRY_CATCH (delete_op_ret_val,
-                    ecma_op_object_delete (obj_p, name_string_p, int_data->is_strict),
+                    ecma_op_object_delete (obj_p, name_string_p, frame_ctx_p->is_strict),
                     ret_value);
 
-    ret_value = set_variable_value (int_data, int_data->pos, dst_var_idx, delete_op_ret_val);
+    ret_value = set_variable_value (frame_ctx_p, frame_ctx_p->pos, dst_var_idx, delete_op_ret_val);
 
     ECMA_FINALIZE (delete_op_ret_val);
     ECMA_FINALIZE (obj_value);
@@ -1776,7 +1776,7 @@ opfunc_delete_prop (opcode_t opdata, /**< operation data */
   ECMA_FINALIZE (name_value);
   ECMA_FINALIZE (base_value);
 
-  int_data->pos++;
+  frame_ctx_p->pos++;
 
   return ret_value;
 } /* opfunc_delete_prop */
@@ -1788,7 +1788,7 @@ opfunc_delete_prop (opcode_t opdata, /**< operation data */
  */
 ecma_completion_value_t
 opfunc_meta (opcode_t opdata, /**< operation data */
-             int_data_t *int_data __attr_unused___) /**< interpreter context */
+             vm_frame_ctx_t *frame_ctx_p __attr_unused___) /**< interpreter context */
 {
   const opcode_meta_type type = (opcode_meta_type) opdata.data.meta.type;
 
@@ -1844,9 +1844,9 @@ calc_opcode_counter_from_idx_idx (const idx_t oc_idx_1, /**< first idx */
  */
 opcode_counter_t
 read_meta_opcode_counter (opcode_meta_type expected_type, /**< expected type of meta opcode */
-                          int_data_t *int_data) /**< interpreter context */
+                          vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
 {
-  opcode_t meta_opcode = vm_get_opcode (int_data->opcodes_p, int_data->pos);
+  opcode_t meta_opcode = vm_get_opcode (frame_ctx_p->opcodes_p, frame_ctx_p->pos);
   JERRY_ASSERT (meta_opcode.data.meta.type == expected_type);
 
   const idx_t data_1 = meta_opcode.data.meta.data_1;
diff --git a/jerry-core/vm/opcodes.h b/jerry-core/vm/opcodes.h
index 4b0dcb0c2..5cf30e266 100644
--- a/jerry-core/vm/opcodes.h
+++ b/jerry-core/vm/opcodes.h
@@ -123,7 +123,7 @@ typedef enum : idx_t
 struct opcode_t;
 
 /**
- * Interpreter context
+ * Context of interpreter, related to a JS stack frame
  */
 typedef struct
 {
@@ -149,7 +149,7 @@ typedef struct
   mem_heap_stats_t heap_stats_context_enter;
   mem_pools_stats_t pools_stats_context_enter;
 #endif /* MEM_STATS */
-} int_data_t;
+} vm_frame_ctx_t;
 
 /**
  * Description of a run scope
@@ -168,7 +168,7 @@ typedef struct
 } vm_run_scope_t;
 
 opcode_counter_t calc_opcode_counter_from_idx_idx (const idx_t oc_idx_1, const idx_t oc_idx_2);
-opcode_counter_t read_meta_opcode_counter (opcode_meta_type expected_type, int_data_t *int_data);
+opcode_counter_t read_meta_opcode_counter (opcode_meta_type expected_type, vm_frame_ctx_t *frame_ctx_p);
 
 #define OP_CALLS_AND_ARGS(p, a)                                              \
         p##_3 (a, call_n, lhs, function_var_idx, arg_list)                   \
@@ -313,11 +313,11 @@ enum __opcode_idx
 };
 #undef __OP_ENUM_FIELD
 
-#define __OP_FUNC_DECL(name, arg1, arg2, arg3) ecma_completion_value_t opfunc_##name (opcode_t, int_data_t*);
+#define __OP_FUNC_DECL(name, arg1, arg2, arg3) ecma_completion_value_t opfunc_##name (opcode_t, vm_frame_ctx_t*);
 OP_LIST (OP_FUNC_DECL)
 #undef __OP_FUNC_DECL
 
-typedef ecma_completion_value_t (*opfunc) (opcode_t, int_data_t *);
+typedef ecma_completion_value_t (*opfunc) (opcode_t, vm_frame_ctx_t *);
 
 #define GETOP_DECL_0(a, name) \
         opcode_t getop_##name (void);
diff --git a/jerry-core/vm/vm.cpp b/jerry-core/vm/vm.cpp
index d8a8c554a..e5dd28024 100644
--- a/jerry-core/vm/vm.cpp
+++ b/jerry-core/vm/vm.cpp
@@ -28,7 +28,7 @@
 /**
  * Top (current) interpreter context
  */
-int_data_t *vm_top_context_p = NULL;
+vm_frame_ctx_t *vm_top_context_p = NULL;
 
 #define __INIT_OP_FUNC(name, arg1, arg2, arg3) [ __op__idx_##name ] = opfunc_##name,
 static const opfunc __opfuncs[LAST_OP] =
@@ -106,7 +106,7 @@ interp_mem_get_stats (mem_heap_stats_t *out_heap_stats_p,
 }
 
 static void
-interp_mem_stats_context_enter (int_data_t *int_data_p,
+interp_mem_stats_context_enter (vm_frame_ctx_t *int_data_p,
                                 opcode_counter_t block_position)
 {
   if (likely (!interp_mem_stats_enabled))
@@ -144,7 +144,7 @@ interp_mem_stats_context_enter (int_data_t *int_data_p,
 }
 
 static void
-interp_mem_stats_context_exit (int_data_t *int_data_p,
+interp_mem_stats_context_exit (vm_frame_ctx_t *int_data_p,
                                opcode_counter_t block_position)
 {
   if (likely (!interp_mem_stats_enabled))
@@ -245,7 +245,7 @@ interp_mem_stats_opcode_enter (const opcode_t *opcodes_p,
 }
 
 static void
-interp_mem_stats_opcode_exit (int_data_t *int_data_p,
+interp_mem_stats_opcode_exit (vm_frame_ctx_t *int_data_p,
                               opcode_counter_t opcode_position,
                               mem_heap_stats_t *heap_stats_before_p,
                               mem_pools_stats_t *pools_stats_before_p)
@@ -430,7 +430,7 @@ vm_run_global (void)
  *         Otherwise - the completion value is discarded and normal empty completion value is returned.
  */
 ecma_completion_value_t
-vm_loop (int_data_t *int_data_p, /**< interpreter context */
+vm_loop (vm_frame_ctx_t *int_data_p, /**< interpreter context */
          vm_run_scope_t *run_scope_p) /**< current run scope,
                                        *   or NULL - if there is no active run scope */
 {
@@ -533,39 +533,39 @@ vm_run_from_pos (const opcode_t *opcodes_p, /**< byte-code array */
 
   MEM_DEFINE_LOCAL_ARRAY (regs, regs_num, ecma_value_t);
 
-  int_data_t int_data;
-  int_data.opcodes_p = opcodes_p;
-  int_data.pos = (opcode_counter_t) (start_pos + 1);
-  int_data.this_binding = this_binding_value;
-  int_data.lex_env_p = lex_env_p;
-  int_data.is_strict = is_strict;
-  int_data.is_eval_code = is_eval_code;
-  int_data.is_call_in_direct_eval_form = false;
-  int_data.min_reg_num = min_reg_num;
-  int_data.max_reg_num = max_reg_num;
-  int_data.tmp_num_p = ecma_alloc_number ();
-  ecma_stack_add_frame (&int_data.stack_frame, regs, regs_num);
+  vm_frame_ctx_t frame_ctx;
+  frame_ctx.opcodes_p = opcodes_p;
+  frame_ctx.pos = (opcode_counter_t) (start_pos + 1);
+  frame_ctx.this_binding = this_binding_value;
+  frame_ctx.lex_env_p = lex_env_p;
+  frame_ctx.is_strict = is_strict;
+  frame_ctx.is_eval_code = is_eval_code;
+  frame_ctx.is_call_in_direct_eval_form = false;
+  frame_ctx.min_reg_num = min_reg_num;
+  frame_ctx.max_reg_num = max_reg_num;
+  frame_ctx.tmp_num_p = ecma_alloc_number ();
+  ecma_stack_add_frame (&frame_ctx.stack_frame, regs, regs_num);
 
-  int_data_t *prev_context_p = vm_top_context_p;
-  vm_top_context_p = &int_data;
+  vm_frame_ctx_t *prev_context_p = vm_top_context_p;
+  vm_top_context_p = &frame_ctx;
 
 #ifdef MEM_STATS
-  interp_mem_stats_context_enter (&int_data, start_pos);
+  interp_mem_stats_context_enter (&frame_ctx, start_pos);
 #endif /* MEM_STATS */
 
-  completion = vm_loop (&int_data, NULL);
+  completion = vm_loop (&frame_ctx, NULL);
 
   JERRY_ASSERT (ecma_is_completion_value_throw (completion)
                 || ecma_is_completion_value_return (completion));
 
   vm_top_context_p = prev_context_p;
 
-  ecma_stack_free_frame (&int_data.stack_frame);
+  ecma_stack_free_frame (&frame_ctx.stack_frame);
 
-  ecma_dealloc_number (int_data.tmp_num_p);
+  ecma_dealloc_number (frame_ctx.tmp_num_p);
 
 #ifdef MEM_STATS
-  interp_mem_stats_context_exit (&int_data, start_pos);
+  interp_mem_stats_context_exit (&frame_ctx, start_pos);
 #endif /* MEM_STATS */
 
   MEM_FINALIZE_LOCAL_ARRAY (regs);
diff --git a/jerry-core/vm/vm.h b/jerry-core/vm/vm.h
index 9934d2e4e..44cc75dd9 100644
--- a/jerry-core/vm/vm.h
+++ b/jerry-core/vm/vm.h
@@ -23,7 +23,7 @@
 extern void vm_init (const opcode_t* program_p, bool dump_mem_stats);
 extern void vm_finalize (void);
 extern jerry_completion_code_t vm_run_global (void);
-extern ecma_completion_value_t vm_loop (int_data_t *int_data, vm_run_scope_t *run_scope_p);
+extern ecma_completion_value_t vm_loop (vm_frame_ctx_t *frame_ctx_p, vm_run_scope_t *run_scope_p);
 extern ecma_completion_value_t vm_run_from_pos (const opcode_t *opcodes_p,
                                                 opcode_counter_t start_pos,
                                                 ecma_value_t this_binding_value,