archive-gh-me/jerryscript
1
0
Fork 0
mirror of https://github.com/jerryscript-project/jerryscript.git synced 2025-12-15 16:29:21 +00:00
Code Issues Projects Releases Wiki Activity

Rename int_data_t -> vm_frame_ctx_t, vm_frame_ctx_t* variables from int_data / int_data_p -> frame_ctx_p.

Browse Source 
JerryScript-DCO-1.0-Signed-off-by: Ruben Ayrapetyan r.ayrapetyan@samsung.com
This commit is contained in:
Ruben Ayrapetyan 2015-07-20 16:39:56 +03:00 committed by Evgeny Gavrin
parent a2c6663d43
commit 7dcaf06793
15 changed files with 459 additions and 459 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
jerry-core/vm/opcodes-agnostic.cpp
View File

@ -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));

78
jerry-core/vm/opcodes-ecma-arithmetics.cpp
View File

@ -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 */

74
jerry-core/vm/opcodes-ecma-bitwise.cpp
View File

@ -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 */

40
jerry-core/vm/opcodes-ecma-equality.cpp
View File

@ -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 */

60
jerry-core/vm/opcodes-ecma-relational.cpp
View File

@ -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 */

10
jerry-core/vm/opcodes-ecma-support.h
View File

@ -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 */

64
jerry-core/vm/opcodes-ecma-try-catch-finally.cpp
View File

@ -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);

2
jerry-core/vm/opcodes-for-in.cpp
View File

@ -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;

40
jerry-core/vm/opcodes-helpers-variables.cpp
View File

@ -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);

10
jerry-core/vm/opcodes-native-call.cpp
View File

@ -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);

20
jerry-core/vm/opcodes-varg.cpp
View File

@ -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);

404
jerry-core/vm/opcodes.cpp
View File

File diff suppressed because it is too large Load Diff

10
jerry-core/vm/opcodes.h
View File

@ -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);

48
jerry-core/vm/vm.cpp
View File

@ -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);

2
jerry-core/vm/vm.h
View File

@ -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,