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
jerryscript/src/libcoreint/opcodes.c
Ruben Ayrapetyan bf5bda11ed Implementing 'construct_n' opcode handler.
2014-08-26 17:47:14 +04:00

1563 lines
50 KiB
C
Raw Blame History

/* Copyright 2014 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "opcodes-ecma-support.h"
#include "globals.h"
#include "interpreter.h"
#include "jerry-libc.h"
#include "mem-heap.h"
#include "opcodes.h"
#include "actuators.h"
#include "common-io.h"
#include "sensors.h"
#include "ecma-objects.h"
/**
* Note:
* The note describes exception handling in opcode handlers that perform operations,
* that can throw exceptions, and do not themself handle the exceptions.
*
* Generally, each opcode handler consists of sequence of operations.
* Some of these operations (exceptionable operations) can throw exceptions and other - cannot.
*
* 1. At the beginning of the handler there should be declared opcode handler's 'return value' variable.
*
* 2. All exceptionable operations except the last should be enclosed in ECMA_TRY_CATCH macro.
* All subsequent operations in the opcode handler should be placed into block between
* the ECMA_TRY_CATCH and corresponding ECMA_FINALIZE.
*
* 3. The last exceptionable's operation result should be assigned directly to opcode handler's
* 'return value' variable without using ECMA_TRY_CATCH macro.
*
* 4. After last ECMA_FINALIZE statement there should be only one operator.
* The operator should return from the opcode handler with it's 'return value'.
*
* 5. No other operations with opcode handler's 'return value' variable should be performed.
*/
/**
* String literal copy descriptor.
*/
typedef struct
{
ecma_char_t *str_p; /**< pointer to copied string literal */
ecma_char_t literal_copy[32]; /**< buffer with string literal,
if it is stored locally
(i.e. not in the heap) */
} string_literal_copy;
/**
* Initialize string literal copy.
*/
static void
init_string_literal_copy (idx_t idx, /**< literal identifier */
string_literal_copy *str_lit_descr_p) /**< pointer to string literal copy descriptor */
{
JERRY_ASSERT (str_lit_descr_p != NULL);
ssize_t sz = try_get_string_by_idx (idx,
str_lit_descr_p->literal_copy,
sizeof (str_lit_descr_p->literal_copy));
if (sz > 0)
{
str_lit_descr_p->str_p = str_lit_descr_p->literal_copy;
}
else
{
JERRY_ASSERT (sz < 0);
ssize_t req_sz = -sz;
str_lit_descr_p->str_p = mem_heap_alloc_block ((size_t) req_sz,
MEM_HEAP_ALLOC_SHORT_TERM);
sz = try_get_string_by_idx (idx,
str_lit_descr_p->str_p,
req_sz);
JERRY_ASSERT (sz > 0);
}
} /* init_string_literal */
/**
* Free string literal copy.
*/
static void
free_string_literal_copy (string_literal_copy *str_lit_descr_p) /**< string literal copy descriptor */
{
JERRY_ASSERT (str_lit_descr_p != NULL);
JERRY_ASSERT (str_lit_descr_p->str_p != NULL);
if (str_lit_descr_p->str_p == str_lit_descr_p->literal_copy)
{
/* copy is inside descriptor */
}
else
{
mem_heap_free_block (str_lit_descr_p->str_p);
}
str_lit_descr_p->str_p = NULL;
return;
} /* free_string_literal */
#define OP_UNIMPLEMENTED_LIST(op) \
op (native_call) \
op (func_expr_n) \
op (varg_list) \
op (array_decl) \
op (prop) \
op (prop_get_decl) \
op (prop_set_decl) \
op (obj_decl) \
op (delete) \
op (with) \
op (end_with) \
op (meta) \
static char __unused unimplemented_list_end
#define DEFINE_UNIMPLEMENTED_OP(op) \
ecma_completion_value_t opfunc_ ## op (opcode_t opdata, int_data_t *int_data) \
{ \
JERRY_UNIMPLEMENTED_REF_UNUSED_VARS (opdata, int_data); \
}
OP_UNIMPLEMENTED_LIST (DEFINE_UNIMPLEMENTED_OP);
#undef DEFINE_UNIMPLEMENTED_OP
/**
* 'Nop' opcode handler.
*/
ecma_completion_value_t
opfunc_nop (opcode_t opdata __unused, /**< operation data */
int_data_t *int_data) /**< interpreter context */
{
int_data->pos++;
return ecma_make_empty_completion_value ();
} /* opfunc_nop */
ecma_completion_value_t
opfunc_call_1 (opcode_t opdata __unused, int_data_t *int_data)
{
ecma_completion_value_t ret_value;
ret_value = ecma_make_empty_completion_value ();
int_data->pos++;
ECMA_TRY_CATCH (arg_value, get_variable_value (int_data, opdata.data.call_1.arg1_lit_idx, false), ret_value);
/**********************************************************/
FIXME (/* Native call, i.e. opfunc_native_call */);
bool is_native_call = true;
string_literal_copy function_name;
init_string_literal_copy (opdata.data.call_1.name_lit_idx, &function_name);
if (!__strcmp ((const char*) function_name.str_p, "LEDToggle"))
{
JERRY_ASSERT (arg_value.value.value_type == ECMA_TYPE_NUMBER);
ecma_number_t * num_p = (ecma_number_t*) ECMA_GET_POINTER (arg_value.value.value);
uint32_t int_num = (uint32_t) * num_p;
led_toggle (int_num);
ret_value = ecma_make_empty_completion_value ();
}
else if (!__strcmp ((const char*) function_name.str_p, "LEDOn"))
{
JERRY_ASSERT (arg_value.value.value_type == ECMA_TYPE_NUMBER);
ecma_number_t * num_p = (ecma_number_t*) ECMA_GET_POINTER (arg_value.value.value);
uint32_t int_num = (uint32_t) * num_p;
led_on (int_num);
ret_value = ecma_make_empty_completion_value ();
}
else if (!__strcmp ((const char*) function_name.str_p, "LEDOff"))
{
JERRY_ASSERT (arg_value.value.value_type == ECMA_TYPE_NUMBER);
ecma_number_t * num_p = (ecma_number_t*) ECMA_GET_POINTER (arg_value.value.value);
uint32_t int_num = (uint32_t) * num_p;
led_off (int_num);
ret_value = ecma_make_empty_completion_value ();
}
else if (!__strcmp ((const char*) function_name.str_p, "LEDOnce"))
{
JERRY_ASSERT (arg_value.value.value_type == ECMA_TYPE_NUMBER);
ecma_number_t * num_p = (ecma_number_t*) ECMA_GET_POINTER (arg_value.value.value);
uint32_t int_num = (uint32_t) * num_p;
led_blink_once (int_num);
ret_value = ecma_make_empty_completion_value ();
}
else if (!__strcmp ((const char*) function_name.str_p, "wait"))
{
JERRY_ASSERT (arg_value.value.value_type == ECMA_TYPE_NUMBER);
ecma_number_t * num_p = (ecma_number_t*) ECMA_GET_POINTER (arg_value.value.value);
uint32_t int_num = (uint32_t) * num_p;
wait_ms (int_num);
ret_value = ecma_make_empty_completion_value ();
}
else if (!__strcmp ((const char *) function_name.str_p, "exit"))
{
JERRY_ASSERT (arg_value.value.value_type == ECMA_TYPE_NUMBER);
ecma_number_t * num_p = (ecma_number_t*) ECMA_GET_POINTER (arg_value.value.value);
uint32_t int_num = (uint32_t) * num_p;
ecma_value_t exit_status = ecma_make_simple_value (int_num == 0 ? ECMA_SIMPLE_VALUE_TRUE
: ECMA_SIMPLE_VALUE_FALSE);
ret_value = ecma_make_completion_value (ECMA_COMPLETION_TYPE_EXIT,
exit_status,
ECMA_TARGET_ID_RESERVED);
}
else
{
is_native_call = false;
}
if (is_native_call)
{
#ifdef __TARGET_HOST_x64
__printf ("%d::op_call_1:idx:%d:%d\t",
int_data->pos,
opdata.data.call_1.name_lit_idx,
opdata.data.call_1.arg1_lit_idx);
__printf ("%s\n", function_name.str_p);
#endif
}
free_string_literal_copy (&function_name);
/**********************************************************/
if (!is_native_call)
{
const idx_t func_name_lit_idx = opdata.data.call_1.name_lit_idx;
const idx_t lhs_var_idx = opdata.data.call_1.lhs;
ECMA_TRY_CATCH (func_value, get_variable_value (int_data, func_name_lit_idx, false), ret_value);
if (!ecma_op_is_callable (func_value.value))
{
ret_value = ecma_make_throw_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
ecma_object_t *func_obj_p = ECMA_GET_POINTER (func_value.value.value);
ECMA_TRY_CATCH (this_value, ecma_op_implicit_this_value (int_data->lex_env_p), ret_value);
ECMA_FUNCTION_CALL (call_completion,
ecma_op_function_call (func_obj_p, this_value.value, &arg_value.value, 1),
ret_value);
ret_value = set_variable_value (int_data, lhs_var_idx, call_completion.value);
ECMA_FINALIZE (call_completion);
ECMA_FINALIZE (this_value);
}
ECMA_FINALIZE (func_value);
}
ECMA_FINALIZE (arg_value);
return ret_value;
}
/**
* 'Assignment' opcode handler.
*
* Note:
* This handler implements case of assignment of a literal's or a variable's
* value to a variable. Assignment to an object's property is not implemented
* by this opcode.
*
* FIXME: Add cross link with 'property accessor assignment` opcode.
*
* See also: ECMA-262 v5, 11.13.1
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
ecma_completion_value_t
opfunc_assignment (opcode_t opdata, /**< operation data */
int_data_t *int_data) /**< interpreter context */
{
const idx_t dst_var_idx = opdata.data.assignment.var_left;
const opcode_arg_type_operand type_value_right = opdata.data.assignment.type_value_right;
const idx_t src_val_descr = opdata.data.assignment.value_right;
int_data->pos++;
ecma_completion_value_t get_value_completion;
switch (type_value_right)
{
case OPCODE_ARG_TYPE_SIMPLE:
{
get_value_completion = ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
ecma_make_simple_value (src_val_descr),
ECMA_TARGET_ID_RESERVED);
break;
}
case OPCODE_ARG_TYPE_STRING:
{
ecma_string_t *ecma_string_p = ecma_new_ecma_string_from_lit_index (src_val_descr);
get_value_completion = ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
ecma_make_string_value (ecma_string_p),
ECMA_TARGET_ID_RESERVED);
break;
}
case OPCODE_ARG_TYPE_VARIABLE:
{
get_value_completion = get_variable_value (int_data,
src_val_descr,
false);
break;
}
case OPCODE_ARG_TYPE_NUMBER:
{
ecma_number_t *num_p = ecma_alloc_number ();
*num_p = get_number_by_idx (src_val_descr);
get_value_completion = ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
ecma_make_number_value (num_p),
ECMA_TARGET_ID_RESERVED);
break;
}
case OPCODE_ARG_TYPE_SMALLINT:
{
ecma_number_t *num_p = ecma_alloc_number ();
*num_p = src_val_descr;
get_value_completion = ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
ecma_make_number_value (num_p),
ECMA_TARGET_ID_RESERVED);
break;
}
}
if (unlikely (ecma_is_completion_value_throw (get_value_completion)))
{
return get_value_completion;
}
else
{
JERRY_ASSERT (ecma_is_completion_value_normal (get_value_completion));
ecma_completion_value_t assignment_completion_value = set_variable_value (int_data,
dst_var_idx,
get_value_completion.value);
ecma_free_completion_value (get_value_completion);
return assignment_completion_value;
}
} /* opfunc_assignment */
/**
* 'Pre increment' opcode handler.
*
* See also: ECMA-262 v5, 11.4.4
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
ecma_completion_value_t
opfunc_pre_incr (opcode_t opdata, /**< operation data */
int_data_t *int_data) /**< 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;
int_data->pos++;
ecma_completion_value_t ret_value;
// 1., 2., 3.
ECMA_TRY_CATCH (old_value, get_variable_value (int_data, incr_var_idx, true), ret_value);
ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (old_value.value), ret_value);
// 4.
ecma_number_t* new_num_p = ecma_alloc_number ();
ecma_number_t* old_num_p = (ecma_number_t*) ECMA_GET_POINTER (old_num_value.value.value);
*new_num_p = ecma_op_number_add (*old_num_p, ECMA_NUMBER_ONE);
ecma_value_t new_num_value = ecma_make_number_value (new_num_p);
// 5.
ret_value = set_variable_value (int_data,
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,
dst_var_idx,
new_num_value);
JERRY_ASSERT (ecma_is_empty_completion_value (reg_assignment_res));
ecma_dealloc_number (new_num_p);
ECMA_FINALIZE (old_num_value);
ECMA_FINALIZE (old_value);
return ret_value;
} /* opfunc_pre_incr */
/**
* 'Pre decrement' opcode handler.
*
* See also: ECMA-262 v5, 11.4.4
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
ecma_completion_value_t
opfunc_pre_decr (opcode_t opdata, /**< operation data */
int_data_t *int_data) /**< 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;
int_data->pos++;
ecma_completion_value_t ret_value;
// 1., 2., 3.
ECMA_TRY_CATCH (old_value, get_variable_value (int_data, decr_var_idx, true), ret_value);
ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (old_value.value), ret_value);
// 4.
ecma_number_t* new_num_p = ecma_alloc_number ();
ecma_number_t* old_num_p = (ecma_number_t*) ECMA_GET_POINTER (old_num_value.value.value);
*new_num_p = ecma_op_number_substract (*old_num_p, ECMA_NUMBER_ONE);
ecma_value_t new_num_value = ecma_make_number_value (new_num_p);
// 5.
ret_value = set_variable_value (int_data,
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,
dst_var_idx,
new_num_value);
JERRY_ASSERT (ecma_is_empty_completion_value (reg_assignment_res));
ecma_dealloc_number (new_num_p);
ECMA_FINALIZE (old_num_value);
ECMA_FINALIZE (old_value);
return ret_value;
} /* opfunc_pre_decr */
/**
* 'Post increment' opcode handler.
*
* See also: ECMA-262 v5, 11.3.1
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
ecma_completion_value_t
opfunc_post_incr (opcode_t opdata, /**< operation data */
int_data_t *int_data) /**< 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;
int_data->pos++;
ecma_completion_value_t ret_value;
// 1., 2., 3.
ECMA_TRY_CATCH (old_value, get_variable_value (int_data, incr_var_idx, true), ret_value);
ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (old_value.value), ret_value);
// 4.
ecma_number_t* new_num_p = ecma_alloc_number ();
ecma_number_t* old_num_p = (ecma_number_t*) ECMA_GET_POINTER (old_num_value.value.value);
*new_num_p = ecma_op_number_add (*old_num_p, ECMA_NUMBER_ONE);
// 5.
ret_value = set_variable_value (int_data,
incr_var_idx,
ecma_make_number_value (new_num_p));
ecma_dealloc_number (new_num_p);
// assignment of operator result to register variable
ecma_completion_value_t reg_assignment_res = set_variable_value (int_data,
dst_var_idx,
old_value.value);
JERRY_ASSERT (ecma_is_empty_completion_value (reg_assignment_res));
ECMA_FINALIZE (old_num_value);
ECMA_FINALIZE (old_value);
return ret_value;
} /* opfunc_post_incr */
/**
* 'Post decrement' opcode handler.
*
* See also: ECMA-262 v5, 11.3.2
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
ecma_completion_value_t
opfunc_post_decr (opcode_t opdata, /**< operation data */
int_data_t *int_data) /**< 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;
int_data->pos++;
ecma_completion_value_t ret_value;
// 1., 2., 3.
ECMA_TRY_CATCH (old_value, get_variable_value (int_data, decr_var_idx, true), ret_value);
ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (old_value.value), ret_value);
// 4.
ecma_number_t* new_num_p = ecma_alloc_number ();
ecma_number_t* old_num_p = (ecma_number_t*) ECMA_GET_POINTER (old_num_value.value.value);
*new_num_p = ecma_op_number_substract (*old_num_p, ECMA_NUMBER_ONE);
// 5.
ret_value = set_variable_value (int_data,
decr_var_idx,
ecma_make_number_value (new_num_p));
ecma_dealloc_number (new_num_p);
// assignment of operator result to register variable
ecma_completion_value_t reg_assignment_res = set_variable_value (int_data,
dst_var_idx,
old_value.value);
JERRY_ASSERT (ecma_is_empty_completion_value (reg_assignment_res));
ECMA_FINALIZE (old_num_value);
ECMA_FINALIZE (old_value);
return ret_value;
} /* opfunc_post_decr */
/**
* 'Register variable declaration' opcode handler.
*
* The opcode is meta-opcode that is not supposed to be executed.
*/
ecma_completion_value_t
opfunc_reg_var_decl (opcode_t opdata __unused, /**< operation data */
int_data_t *int_data __unused) /**< interpreter context */
{
JERRY_UNREACHABLE ();
} /* opfunc_reg_var_decl */
/**
* 'Variable declaration' opcode handler.
*
* See also: ECMA-262 v5, 10.5 - Declaration binding instantiation (block 8).
*
* @return completion value
* Returned value is simple and so need not be freed.
* However, ecma_free_completion_value may be called for it, but it is a no-op.
*/
ecma_completion_value_t
opfunc_var_decl (opcode_t opdata, /**< operation data */
int_data_t *int_data) /**< interpreter context */
{
ecma_string_t *var_name_string_p = ecma_new_ecma_string_from_lit_index (opdata.data.var_decl.variable_name);
if (ecma_is_completion_value_normal_false (ecma_op_has_binding (int_data->lex_env_p,
var_name_string_p)))
{
FIXME ("Pass configurableBindings that is true if and only if current code is eval code");
ecma_completion_value_t completion = ecma_op_create_mutable_binding (int_data->lex_env_p,
var_name_string_p,
false);
JERRY_ASSERT (ecma_is_empty_completion_value (completion));
/* 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,
var_name_string_p,
true),
ECMA_SIMPLE_VALUE_UNDEFINED));
}
ecma_deref_ecma_string (var_name_string_p);
int_data->pos++;
return ecma_make_empty_completion_value ();
} /* opfunc_var_decl */
/**
* Function declaration helper
*
* @return completion value
* returned value must be freed with ecma_free_completion_value.
*/
static ecma_completion_value_t
function_declaration (int_data_t *int_data, /**< interpreter context */
idx_t function_name_lit_idx, /**< identifier of literal with function name */
ecma_string_t* args_names[], /**< names of arguments */
ecma_length_t args_number) /**< number of arguments */
{
TODO ("Check if code of function itself is strict");
const bool is_strict = int_data->is_strict;
const bool is_configurable_bindings = int_data->is_eval_code;
const opcode_counter_t jmp_down_opcode_idx = (opcode_counter_t) (int_data->pos);
opcode_t jmp_down_opcode = read_opcode (jmp_down_opcode_idx);
JERRY_ASSERT (jmp_down_opcode.op_idx == __op__idx_jmp_down);
int_data->pos = (opcode_counter_t) (jmp_down_opcode_idx + jmp_down_opcode.data.jmp_down.opcode_count);
const opcode_counter_t function_code_opcode_idx = (opcode_counter_t) (jmp_down_opcode_idx + 1);
ecma_string_t *function_name_string_p = ecma_new_ecma_string_from_lit_index (function_name_lit_idx);
ecma_completion_value_t ret_value = ecma_op_function_declaration (int_data->lex_env_p,
function_name_string_p,
function_code_opcode_idx,
args_names,
args_number,
is_strict,
is_configurable_bindings);
ecma_deref_ecma_string (function_name_string_p);
return ret_value;
} /* function_declaration */
/**
* 'Function declaration with no parameters' opcode handler.
*
* @return completion value
* returned value must be freed with ecma_free_completion_value.
*/
ecma_completion_value_t
opfunc_func_decl_0 (opcode_t opdata, /**< operation data */
int_data_t *int_data) /**< interpreter context */
{
int_data->pos++;
return function_declaration (int_data,
opdata.data.func_decl_0.name_lit_idx,
NULL,
0);
} /* opfunc_func_decl_0 */
/**
* 'Function declaration with one parameter' opcode handler.
*
* @return completion value
* returned value must be freed with ecma_free_completion_value.
*/
ecma_completion_value_t
opfunc_func_decl_1 (opcode_t opdata, /**< operation data */
int_data_t *int_data) /**< interpreter context */
{
int_data->pos++;
ecma_string_t *arg_name_string_p = ecma_new_ecma_string_from_lit_index (opdata.data.func_decl_1.arg1_lit_idx);
ecma_completion_value_t ret_value = function_declaration (int_data,
opdata.data.func_decl_1.name_lit_idx,
&arg_name_string_p,
1);
ecma_deref_ecma_string (arg_name_string_p);
return ret_value;
} /* opfunc_func_decl_1 */
/**
* 'Function declaration with two parameters' opcode handler.
*
* @return completion value
* returned value must be freed with ecma_free_completion_value.
*/
ecma_completion_value_t
opfunc_func_decl_2 (opcode_t opdata, /**< operation data */
int_data_t *int_data) /**< interpreter context */
{
int_data->pos++;
ecma_string_t* arg_names_strings[2] =
{
ecma_new_ecma_string_from_lit_index (opdata.data.func_decl_2.arg1_lit_idx),
ecma_new_ecma_string_from_lit_index (opdata.data.func_decl_2.arg2_lit_idx)
};
ecma_completion_value_t ret_value = function_declaration (int_data,
opdata.data.func_decl_1.name_lit_idx,
arg_names_strings,
2);
ecma_deref_ecma_string (arg_names_strings[0]);
ecma_deref_ecma_string (arg_names_strings[1]);
return ret_value;
} /* opfunc_func_decl_2 */
/**
* 'Function declaration' opcode handler.
*
* @return completion value
* returned value must be freed with ecma_free_completion_value.
*/
ecma_completion_value_t
opfunc_func_decl_n (opcode_t opdata, /**< operation data */
int_data_t *int_data) /**< interpreter context */
{
int_data->pos++;
const idx_t function_name_idx = opdata.data.func_decl_n.name_lit_idx;
const ecma_length_t args_number = opdata.data.func_decl_n.arg_list;
ecma_string_t *arg_names[args_number + 1];
ecma_length_t arg_index = 0;
opcode_t next_opcode = read_opcode (int_data->pos);
while (next_opcode.op_idx == __op__idx_varg_list)
{
const idx_t arg1_lit_idx = next_opcode.data.varg_list.arg1_lit_idx;
const idx_t arg2_lit_idx = next_opcode.data.varg_list.arg2_lit_idx;
const idx_t arg3_lit_idx = next_opcode.data.varg_list.arg3_lit_idx;
arg_names[arg_index++] = ecma_new_ecma_string_from_lit_index (arg1_lit_idx);
if (arg_index < args_number)
{
arg_names[arg_index++] = ecma_new_ecma_string_from_lit_index (arg2_lit_idx);
}
if (arg_index < args_number)
{
arg_names[arg_index++] = ecma_new_ecma_string_from_lit_index (arg3_lit_idx);
}
JERRY_ASSERT (arg_index <= args_number);
int_data->pos++;
next_opcode = read_opcode (int_data->pos);
}
JERRY_ASSERT (arg_index == args_number);
ecma_completion_value_t ret_value = function_declaration (int_data,
function_name_idx,
arg_names,
args_number);
for (arg_index = 0;
arg_index < args_number;
arg_index++)
{
ecma_deref_ecma_string (arg_names[arg_index]);
}
return ret_value;
} /* opfunc_func_decl_n */
/**
* Function call with no arguments' opcode handler.
*
* See also: ECMA-262 v5, 11.2.3
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value.
*/
ecma_completion_value_t
opfunc_call_0 (opcode_t opdata, /**< operation data */
int_data_t *int_data) /**< interpreter context */
{
const idx_t func_name_lit_idx = opdata.data.call_0.name_lit_idx;
const idx_t lhs_var_idx = opdata.data.call_0.lhs;
int_data->pos++;
ecma_completion_value_t ret_value;
ECMA_TRY_CATCH (func_value, get_variable_value (int_data, func_name_lit_idx, false), ret_value);
if (!ecma_op_is_callable (func_value.value))
{
ret_value = ecma_make_throw_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
ecma_object_t *func_obj_p = ECMA_GET_POINTER (func_value.value.value);
ECMA_TRY_CATCH (this_value, ecma_op_implicit_this_value (int_data->lex_env_p), ret_value);
ECMA_FUNCTION_CALL (call_completion,
ecma_op_function_call (func_obj_p, this_value.value, NULL, 0),
ret_value);
ret_value = set_variable_value (int_data, lhs_var_idx, call_completion.value);
ECMA_FINALIZE (call_completion);
ECMA_FINALIZE (this_value);
}
ECMA_FINALIZE (func_value);
return ret_value;
} /* opfunc_call_0 */
/**
* 'Function call' opcode handler.
*
* See also: ECMA-262 v5, 11.2.3
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value.
*/
ecma_completion_value_t
opfunc_call_n (opcode_t opdata, /**< operation data */
int_data_t *int_data) /**< interpreter context */
{
const idx_t lhs_var_idx = opdata.data.call_n.lhs;
const idx_t func_name_lit_idx = opdata.data.call_n.name_lit_idx;
const idx_t args_number = opdata.data.call_n.arg_list;
int_data->pos++;
ecma_completion_value_t ret_value;
ECMA_TRY_CATCH (func_value, get_variable_value (int_data, func_name_lit_idx, false), ret_value);
ecma_completion_value_t get_arg_completion = ecma_make_empty_completion_value ();
ecma_value_t arg_values[args_number + 1];
ecma_length_t arg_index = 0;
opcode_t next_opcode = read_opcode (int_data->pos);
while (next_opcode.op_idx == __op__idx_varg_list
&& ecma_is_completion_value_normal (get_arg_completion))
{
const idx_t arg_lits[3] =
{
next_opcode.data.varg_list.arg1_lit_idx,
next_opcode.data.varg_list.arg2_lit_idx,
next_opcode.data.varg_list.arg3_lit_idx
};
ecma_length_t local_arg_index = 0;
while (local_arg_index < 3
&& arg_index < args_number)
{
get_arg_completion = get_variable_value (int_data, arg_lits[local_arg_index++], false);
if (unlikely (ecma_is_completion_value_throw (get_arg_completion)))
{
break;
}
else
{
JERRY_ASSERT (ecma_is_completion_value_normal (get_arg_completion));
arg_values[arg_index++] = get_arg_completion.value;
}
}
JERRY_ASSERT (arg_index <= args_number);
int_data->pos++;
next_opcode = read_opcode (int_data->pos);
}
JERRY_ASSERT (arg_index == args_number);
ecma_completion_value_t this_value;
if (next_opcode.op_idx == __op__idx_meta
&& next_opcode.data.meta.type == OPCODE_META_TYPE_THIS_ARG)
{
const idx_t this_arg_var_idx = next_opcode.data.meta.data_1;
JERRY_ASSERT (is_reg_variable (int_data, this_arg_var_idx));
this_value = get_variable_value (int_data, this_arg_var_idx, false);
}
else
{
this_value = ecma_op_implicit_this_value (int_data->lex_env_p);
JERRY_ASSERT (ecma_is_completion_value_normal (this_value));
}
if (ecma_is_completion_value_normal (get_arg_completion))
{
if (!ecma_op_is_callable (func_value.value))
{
ret_value = ecma_make_throw_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
ecma_object_t *func_obj_p = ECMA_GET_POINTER (func_value.value.value);
ECMA_FUNCTION_CALL (call_completion,
ecma_op_function_call (func_obj_p, this_value.value, arg_values, args_number),
ret_value);
ret_value = set_variable_value (int_data, lhs_var_idx, call_completion.value);
ECMA_FINALIZE (call_completion);
ecma_free_completion_value (this_value);
}
}
else
{
ret_value = get_arg_completion;
}
for (ecma_length_t arg_index = 0;
arg_index < args_number;
arg_index++)
{
ecma_free_value (arg_values[arg_index], true);
}
ECMA_FINALIZE (func_value);
return ret_value;
} /* opfunc_call_n */
/**
* 'Constructor call' opcode handler.
*
* See also: ECMA-262 v5, 11.2.2
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value.
*/
ecma_completion_value_t
opfunc_construct_n (opcode_t opdata, /**< operation data */
int_data_t *int_data) /**< 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;
int_data->pos++;
ecma_completion_value_t ret_value;
ECMA_TRY_CATCH (constructor_value, get_variable_value (int_data, constructor_name_lit_idx, false), ret_value);
ecma_completion_value_t get_arg_completion = ecma_make_empty_completion_value ();
ecma_value_t arg_values[args_number + 1];
ecma_length_t arg_index = 0;
opcode_t next_opcode = read_opcode (int_data->pos);
while (next_opcode.op_idx == __op__idx_varg_list
&& ecma_is_completion_value_normal (get_arg_completion))
{
const idx_t arg_lits[3] =
{
next_opcode.data.varg_list.arg1_lit_idx,
next_opcode.data.varg_list.arg2_lit_idx,
next_opcode.data.varg_list.arg3_lit_idx
};
ecma_length_t local_arg_index = 0;
while (local_arg_index < 3
&& arg_index < args_number)
{
get_arg_completion = get_variable_value (int_data, arg_lits[local_arg_index++], false);
if (unlikely (ecma_is_completion_value_throw (get_arg_completion)))
{
break;
}
else
{
JERRY_ASSERT (ecma_is_completion_value_normal (get_arg_completion));
arg_values[arg_index++] = get_arg_completion.value;
}
}
JERRY_ASSERT (arg_index <= args_number);
int_data->pos++;
next_opcode = read_opcode (int_data->pos);
}
JERRY_ASSERT (arg_index == args_number);
ecma_completion_value_t this_value;
if (next_opcode.op_idx == __op__idx_meta
&& next_opcode.data.meta.type == OPCODE_META_TYPE_THIS_ARG)
{
const idx_t this_arg_var_idx = next_opcode.data.meta.data_1;
JERRY_ASSERT (is_reg_variable (int_data, this_arg_var_idx));
this_value = get_variable_value (int_data, this_arg_var_idx, false);
}
else
{
this_value = ecma_op_implicit_this_value (int_data->lex_env_p);
JERRY_ASSERT (ecma_is_completion_value_normal (this_value));
}
if (ecma_is_completion_value_normal (get_arg_completion))
{
if (!ecma_is_constructor (constructor_value.value))
{
ret_value = ecma_make_throw_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
ecma_object_t *constructor_obj_p = ECMA_GET_POINTER (constructor_value.value.value);
ECMA_TRY_CATCH (construction_completion,
ecma_op_function_construct (constructor_obj_p,
arg_values,
args_number),
ret_value);
ret_value = set_variable_value (int_data, lhs_var_idx, construction_completion.value);
ECMA_FINALIZE (construction_completion);
ecma_free_completion_value (this_value);
}
}
else
{
ret_value = get_arg_completion;
}
for (ecma_length_t arg_index = 0;
arg_index < args_number;
arg_index++)
{
ecma_free_value (arg_values[arg_index], true);
}
ECMA_FINALIZE (constructor_value);
return ret_value;
} /* opfunc_construct_n */
/**
* 'Return with no expression' opcode handler.
*
* See also: ECMA-262 v5, 12.9
*
* @return completion value
* Returned value is simple and so need not be freed.
* However, ecma_free_completion_value may be called for it, but it is a no-op.
*/
ecma_completion_value_t
opfunc_ret (opcode_t opdata __unused, /**< operation data */
int_data_t *int_data __unused) /**< interpreter context */
{
return ecma_make_completion_value (ECMA_COMPLETION_TYPE_RETURN,
ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED),
ECMA_TARGET_ID_RESERVED);
} /* opfunc_ret */
/**
* 'Return with expression' opcode handler.
*
* See also: ECMA-262 v5, 12.9
*
* @return completion value
* Returned value is simple and so need not be freed.
* However, ecma_free_completion_value may be called for it, but it is a no-op.
*/
ecma_completion_value_t
opfunc_retval (opcode_t opdata __unused, /**< operation data */
int_data_t *int_data __unused) /**< interpreter context */
{
ecma_completion_value_t ret_value;
ECMA_TRY_CATCH (expr_val, get_variable_value (int_data, opdata.data.retval.ret_value, false), ret_value);
ret_value = ecma_make_completion_value (ECMA_COMPLETION_TYPE_RETURN,
ecma_copy_value (expr_val.value, true),
ECMA_TARGET_ID_RESERVED);
ECMA_FINALIZE (expr_val);
return ret_value;
} /* opfunc_retval */
/**
* 'Property getter' opcode handler.
*
* See also: ECMA-262 v5, 11.2.1
* ECMA-262 v5, 11.13.1
*
* @return completion value
* returned value must be freed with ecma_free_completion_value.
*/
ecma_completion_value_t
opfunc_prop_getter (opcode_t opdata __unused, /**< operation data */
int_data_t *int_data __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;
const idx_t prop_name_var_idx = opdata.data.prop_getter.prop;
int_data->pos++;
ecma_completion_value_t ret_value;
ECMA_TRY_CATCH (base_value, get_variable_value (int_data, base_var_idx, false), ret_value);
ECMA_TRY_CATCH (prop_name_value, get_variable_value (int_data, prop_name_var_idx, false), ret_value);
ECMA_TRY_CATCH (check_coercible_ret, ecma_op_check_object_coercible (base_value.value), ret_value);
ECMA_TRY_CATCH (prop_name_str_value, ecma_op_to_string (prop_name_value.value), ret_value);
ecma_string_t *prop_name_string_p = ECMA_GET_POINTER (prop_name_str_value.value.value);
ecma_reference_t ref = ecma_make_reference (base_value.value,
prop_name_string_p,
int_data->is_strict);
ECMA_TRY_CATCH (prop_value, ecma_op_get_value (ref), ret_value);
ret_value = set_variable_value (int_data, lhs_var_idx, prop_value.value);
ECMA_FINALIZE (prop_value);
ecma_free_reference (ref);
ECMA_FINALIZE (prop_name_str_value);
ECMA_FINALIZE (check_coercible_ret);
ECMA_FINALIZE (prop_name_value);
ECMA_FINALIZE (base_value);
return ret_value;
} /* opfunc_prop_getter */
/**
* 'Property setter' opcode handler.
*
* See also: ECMA-262 v5, 11.2.1
* ECMA-262 v5, 11.13.1
*
* @return completion value
* returned value must be freed with ecma_free_completion_value.
*/
ecma_completion_value_t
opfunc_prop_setter (opcode_t opdata __unused, /**< operation data */
int_data_t *int_data __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;
const idx_t rhs_var_idx = opdata.data.prop_setter.rhs;
int_data->pos++;
ecma_completion_value_t ret_value;
ECMA_TRY_CATCH (base_value, get_variable_value (int_data, base_var_idx, false), ret_value);
ECMA_TRY_CATCH (prop_name_value, get_variable_value (int_data, prop_name_var_idx, false), ret_value);
ECMA_TRY_CATCH (check_coercible_ret, ecma_op_check_object_coercible (base_value.value), ret_value);
ECMA_TRY_CATCH (prop_name_str_value, ecma_op_to_string (prop_name_value.value), ret_value);
ecma_string_t *prop_name_string_p = ECMA_GET_POINTER (prop_name_str_value.value.value);
ecma_reference_t ref = ecma_make_reference (base_value.value,
prop_name_string_p,
int_data->is_strict);
ECMA_TRY_CATCH (rhs_value, get_variable_value (int_data, rhs_var_idx, false), ret_value);
ret_value = ecma_op_put_value (ref, rhs_value.value);
ECMA_FINALIZE (rhs_value);
ecma_free_reference (ref);
ECMA_FINALIZE (prop_name_str_value);
ECMA_FINALIZE (check_coercible_ret);
ECMA_FINALIZE (prop_name_value);
ECMA_FINALIZE (base_value);
return ret_value;
} /* opfunc_prop_setter */
/**
* Exit from script with specified status code:
* 0 - for successful completion
* 1 - to indicate failure.
*
* Note: this is not ECMA specification-defined, but internal
* implementation-defined opcode for end of script
* and assertions inside of unit tests.
*
* @return completion value
* Returned value is simple and so need not be freed.
* However, ecma_free_completion_value may be called for it, but it is a no-op.
*/
ecma_completion_value_t
opfunc_exitval (opcode_t opdata, /**< operation data */
int_data_t *int_data __unused) /**< interpreter context */
{
JERRY_ASSERT (opdata.data.exitval.status_code == 0
|| opdata.data.exitval.status_code == 1);
ecma_value_t exit_status = ecma_make_simple_value (opdata.data.exitval.status_code == 0 ? ECMA_SIMPLE_VALUE_TRUE
: ECMA_SIMPLE_VALUE_FALSE);
return ecma_make_completion_value (ECMA_COMPLETION_TYPE_EXIT,
exit_status,
ECMA_TARGET_ID_RESERVED);
} /* opfunc_exitval */
/**
* 'Logical NOT Operator' opcode handler.
*
* See also: ECMA-262 v5, 11.4.9
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
ecma_completion_value_t
opfunc_logical_not (opcode_t opdata, /**< operation data */
int_data_t *int_data) /**< 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;
int_data->pos++;
ecma_completion_value_t ret_value;
ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
ecma_simple_value_t old_value = ECMA_SIMPLE_VALUE_TRUE;
ecma_completion_value_t to_bool_value = ecma_op_to_boolean (right_value.value);
if (ecma_is_value_true (to_bool_value.value))
{
old_value = ECMA_SIMPLE_VALUE_FALSE;
}
ret_value = set_variable_value (int_data,
dst_var_idx,
ecma_make_simple_value (old_value));
ECMA_FINALIZE (right_value);
return ret_value;
} /* opfunc_logical_not */
/**
* 'Logical OR Operator' opcode handler.
*
* See also: ECMA-262 v5, 11.11
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
ecma_completion_value_t
opfunc_logical_or (opcode_t opdata, /**< operation data */
int_data_t *int_data) /**< interpreter context */
{
const idx_t dst_var_idx = opdata.data.logical_or.dst;
const idx_t left_var_idx = opdata.data.logical_or.var_left;
const idx_t right_var_idx = opdata.data.logical_or.var_right;
int_data->pos++;
ecma_completion_value_t ret_value;
ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
ecma_completion_value_t to_bool_value = ecma_op_to_boolean (left_value.value);
if (ecma_is_value_true (to_bool_value.value))
{
ret_value = set_variable_value (int_data,
dst_var_idx,
left_value.value);
}
else
{
ret_value = set_variable_value (int_data,
dst_var_idx,
right_value.value);
}
ECMA_FINALIZE (right_value);
ECMA_FINALIZE (left_value);
return ret_value;
} /* opfunc_logical_or */
/**
* 'Logical AND Operator' opcode handler.
*
* See also: ECMA-262 v5, 11.11
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
ecma_completion_value_t
opfunc_logical_and (opcode_t opdata, /**< operation data */
int_data_t *int_data) /**< interpreter context */
{
const idx_t dst_var_idx = opdata.data.logical_and.dst;
const idx_t left_var_idx = opdata.data.logical_and.var_left;
const idx_t right_var_idx = opdata.data.logical_and.var_right;
int_data->pos++;
ecma_completion_value_t ret_value;
ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
ecma_completion_value_t to_bool_value = ecma_op_to_boolean (left_value.value);
if (ecma_is_value_true (to_bool_value.value) == false)
{
ret_value = set_variable_value (int_data,
dst_var_idx,
left_value.value);
}
else
{
ret_value = set_variable_value (int_data,
dst_var_idx,
right_value.value);
}
ECMA_FINALIZE (right_value);
ECMA_FINALIZE (left_value);
return ret_value;
} /* opfunc_logical_and */
/**
* 'This' opcode handler.
*
* See also: ECMA-262 v5, 11.1.1
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
ecma_completion_value_t
opfunc_this (opcode_t opdata, /**< operation data */
int_data_t *int_data) /**< interpreter context */
{
const idx_t dst_var_idx = opdata.data.this.lhs;
int_data->pos++;
ecma_completion_value_t ret_value;
ret_value = set_variable_value (int_data,
dst_var_idx,
int_data->this_binding);
return ret_value;
} /* opfunc_this */
/**
* Evaluate argument of typeof.
*
* See also: ECMA-262 v5, 11.4.3
*
* @return completion value
* 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 */
idx_t var_idx) /**< arg variable identifier */
{
ecma_completion_value_t ret_value;
if (is_reg_variable (int_data, var_idx))
{
// 2.b
ret_value = get_variable_value (int_data,
var_idx,
false);
JERRY_ASSERT (ecma_is_completion_value_normal (ret_value));
}
else
{
ecma_string_t *var_name_string_p = ecma_new_ecma_string_from_lit_index (var_idx);
ecma_reference_t ref = ecma_op_get_identifier_reference (int_data->lex_env_p,
var_name_string_p,
int_data->is_strict);
ecma_deref_ecma_string (var_name_string_p);
const bool is_unresolvable_reference = ecma_is_value_undefined (ref.base);
if (is_unresolvable_reference)
{
ret_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_UNDEFINED);
}
else
{
ret_value = ecma_op_get_value (ref);
}
ecma_free_reference (ref);
}
return ret_value;
} /* evaluate_arg_for_typeof */
/**
* 'typeof' opcode handler.
*
* See also: ECMA-262 v5, 11.4.3
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
ecma_completion_value_t
opfunc_typeof (opcode_t opdata, /**< operation data */
int_data_t *int_data) /**< interpreter context */
{
const idx_t dst_var_idx = opdata.data.typeof.lhs;
const idx_t obj_var_idx = opdata.data.typeof.obj;
int_data->pos++;
ecma_completion_value_t ret_value;
ECMA_TRY_CATCH (typeof_evaluate_arg_completion,
evaluate_arg_for_typeof (int_data,
obj_var_idx),
ret_value);
ecma_value_t typeof_arg = typeof_evaluate_arg_completion.value;
ecma_string_t *type_str_p = NULL;
switch ((ecma_type_t)typeof_arg.value_type)
{
case ECMA_TYPE_SIMPLE:
{
switch ((ecma_simple_value_t)typeof_arg.value)
{
case ECMA_SIMPLE_VALUE_UNDEFINED:
{
type_str_p = ecma_get_magic_string (ECMA_MAGIC_STRING_UNDEFINED);
break;
}
case ECMA_SIMPLE_VALUE_NULL:
{
type_str_p = ecma_get_magic_string (ECMA_MAGIC_STRING_NULL);
break;
}
case ECMA_SIMPLE_VALUE_FALSE:
{
type_str_p = ecma_get_magic_string (ECMA_MAGIC_STRING_FALSE);
break;
}
case ECMA_SIMPLE_VALUE_TRUE:
{
type_str_p = ecma_get_magic_string (ECMA_MAGIC_STRING_TRUE);
break;
}
case ECMA_SIMPLE_VALUE_EMPTY:
case ECMA_SIMPLE_VALUE_ARRAY_REDIRECT:
case ECMA_SIMPLE_VALUE__COUNT:
{
JERRY_UNREACHABLE ();
}
}
break;
}
case ECMA_TYPE_NUMBER:
{
type_str_p = ecma_get_magic_string (ECMA_MAGIC_STRING_NUMBER);
break;
}
case ECMA_TYPE_STRING:
{
type_str_p = ecma_get_magic_string (ECMA_MAGIC_STRING_STRING);
break;
}
case ECMA_TYPE_OBJECT:
{
if (ecma_op_is_callable (typeof_arg))
{
type_str_p = ecma_get_magic_string (ECMA_MAGIC_STRING_FUNCTION);
}
else
{
type_str_p = ecma_get_magic_string (ECMA_MAGIC_STRING_OBJECT);
}
break;
}
}
ret_value = set_variable_value (int_data,
dst_var_idx,
ecma_make_string_value (type_str_p));
ecma_deref_ecma_string (type_str_p);
ECMA_FINALIZE (typeof_evaluate_arg_completion);
return ret_value;
} /* opfunc_typeof */
#define GETOP_DEF_1(a, name, field1) \
inline opcode_t getop_##name (idx_t arg1) \
{ \
opcode_t opdata; \
opdata.op_idx = __op__idx_##name; \
opdata.data.name.field1 = arg1; \
return opdata; \
}
#define GETOP_DEF_2(a, name, field1, field2) \
inline opcode_t getop_##name (idx_t arg1, idx_t arg2) \
{ \
opcode_t opdata; \
opdata.op_idx = __op__idx_##name; \
opdata.data.name.field1 = arg1; \
opdata.data.name.field2 = arg2; \
return opdata; \
}
#define GETOP_DEF_3(a, name, field1, field2, field3) \
inline opcode_t getop_##name (idx_t arg1, idx_t arg2, idx_t arg3) \
{ \
opcode_t opdata; \
opdata.op_idx = __op__idx_##name; \
opdata.data.name.field1 = arg1; \
opdata.data.name.field2 = arg2; \
opdata.data.name.field3 = arg3; \
return opdata; \
}
OP_ARGS_LIST (GETOP_DEF)
Reference in New Issue View Git Blame Copy Permalink