diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-function.cpp b/jerry-core/ecma/builtin-objects/ecma-builtin-function.cpp index 541b6abed..ddb371162 100644 --- a/jerry-core/ecma/builtin-objects/ecma-builtin-function.cpp +++ b/jerry-core/ecma/builtin-objects/ecma-builtin-function.cpp @@ -271,13 +271,13 @@ ecma_builtin_function_dispatch_construct (const ecma_value_t *arguments_list_p, utf8_string_buffer_pos += sz; } - const vm_instr_t* instrs_p; + const bytecode_data_header_t* bytecode_data_p; jsp_status_t parse_status; parse_status = parser_parse_new_function ((const jerry_api_char_t **) utf8_string_params_p, utf8_string_params_size, params_count, - &instrs_p); + &bytecode_data_p); if (parse_status == JSP_STATUS_SYNTAX_ERROR) { @@ -293,7 +293,7 @@ ecma_builtin_function_dispatch_construct (const ecma_value_t *arguments_list_p, bool is_strict = false; bool do_instantiate_arguments_object = true; - opcode_scope_code_flags_t scope_flags = vm_get_scope_flags (instrs_p, + opcode_scope_code_flags_t scope_flags = vm_get_scope_flags (bytecode_data_p->instrs_p, 0); if (scope_flags & OPCODE_SCOPE_CODE_FLAGS_STRICT) @@ -321,7 +321,7 @@ ecma_builtin_function_dispatch_construct (const ecma_value_t *arguments_list_p, glob_lex_env_p, is_strict, do_instantiate_arguments_object, - instrs_p, + bytecode_data_p, 1); ecma_deref_object (glob_lex_env_p); diff --git a/jerry-core/ecma/operations/ecma-eval.cpp b/jerry-core/ecma/operations/ecma-eval.cpp index d48c2800d..cf2871f14 100644 --- a/jerry-core/ecma/operations/ecma-eval.cpp +++ b/jerry-core/ecma/operations/ecma-eval.cpp @@ -86,7 +86,7 @@ ecma_op_eval_chars_buffer (const jerry_api_char_t *code_p, /**< code characters ecma_completion_value_t completion; - const vm_instr_t *instrs_p; + const bytecode_data_header_t *bytecode_data_p; jsp_status_t parse_status; bool is_strict_call = (is_direct && is_called_from_strict_mode_code); @@ -95,7 +95,7 @@ ecma_op_eval_chars_buffer (const jerry_api_char_t *code_p, /**< code characters parse_status = parser_parse_eval (code_p, code_buffer_size, is_strict_call, - &instrs_p, + &bytecode_data_p, &code_contains_functions); if (parse_status == JSP_STATUS_SYNTAX_ERROR) @@ -110,11 +110,11 @@ ecma_op_eval_chars_buffer (const jerry_api_char_t *code_p, /**< code characters { JERRY_ASSERT (parse_status == JSP_STATUS_OK); - completion = vm_run_eval (instrs_p, is_direct); + completion = vm_run_eval (bytecode_data_p, is_direct); if (!code_contains_functions) { - serializer_remove_instructions (instrs_p); + serializer_remove_bytecode_data (bytecode_data_p); } } diff --git a/jerry-core/ecma/operations/ecma-function-object.cpp b/jerry-core/ecma/operations/ecma-function-object.cpp index 2b945f227..8203b8e6e 100644 --- a/jerry-core/ecma/operations/ecma-function-object.cpp +++ b/jerry-core/ecma/operations/ecma-function-object.cpp @@ -216,7 +216,7 @@ ecma_op_create_function_object (ecma_collection_header_t *formal_params_collecti bool is_strict, /**< 'strict' flag */ bool do_instantiate_arguments_object, /**< should an Arguments object be instantiated * for the function object upon call */ - const vm_instr_t *instrs_p, /**< byte-code array */ + const bytecode_data_header_t *bytecode_data_p, /**< byte-code array */ vm_instr_counter_t first_instr_pos) /**< position of first instruction * of function's body */ { @@ -252,7 +252,7 @@ ecma_op_create_function_object (ecma_collection_header_t *formal_params_collecti // 12. ecma_property_t *bytecode_prop_p = ecma_create_internal_property (f, ECMA_INTERNAL_PROPERTY_CODE_BYTECODE); - MEM_CP_SET_NON_NULL_POINTER (bytecode_prop_p->u.internal_property.value, instrs_p); + MEM_CP_SET_NON_NULL_POINTER (bytecode_prop_p->u.internal_property.value, bytecode_data_p); ecma_property_t *code_prop_p = ecma_create_internal_property (f, ECMA_INTERNAL_PROPERTY_CODE_FLAGS_AND_OFFSET); code_prop_p->u.internal_property.value = ecma_pack_code_internal_property_value (is_strict, @@ -824,7 +824,8 @@ ecma_op_function_call (ecma_object_t *func_obj_p, /**< Function object */ // 8. bool is_strict; bool do_instantiate_args_obj; - const vm_instr_t *instrs_p = MEM_CP_GET_POINTER (const vm_instr_t, bytecode_prop_p->u.internal_property.value); + const bytecode_data_header_t *bytecode_data_p; + bytecode_data_p = MEM_CP_GET_POINTER (const bytecode_data_header_t, bytecode_prop_p->u.internal_property.value); vm_instr_counter_t code_first_instr_pos = ecma_unpack_code_internal_property_value (code_prop_value, &is_strict, &do_instantiate_args_obj); @@ -862,7 +863,7 @@ ecma_op_function_call (ecma_object_t *func_obj_p, /**< Function object */ do_instantiate_args_obj), ret_value); - ecma_completion_value_t completion = vm_run_from_pos (instrs_p, + ecma_completion_value_t completion = vm_run_from_pos (bytecode_data_p, code_first_instr_pos, this_binding, local_env_p, @@ -1105,7 +1106,7 @@ ecma_op_function_construct (ecma_object_t *func_obj_p, /**< Function object */ ecma_completion_value_t ecma_op_function_declaration (ecma_object_t *lex_env_p, /**< lexical environment */ ecma_string_t *function_name_p, /**< function name */ - const vm_instr_t *instrs_p, /**< byte-code array */ + const bytecode_data_header_t *bytecode_data_p, /**< byte-code data */ vm_instr_counter_t function_first_instr_pos, /**< position of first instruction * of function code */ ecma_collection_header_t *formal_params_collection_p, /**< formal parameters collection @@ -1126,7 +1127,7 @@ ecma_op_function_declaration (ecma_object_t *lex_env_p, /**< lexical environment lex_env_p, is_strict, do_instantiate_arguments_object, - instrs_p, + bytecode_data_p, function_first_instr_pos); // c. diff --git a/jerry-core/ecma/operations/ecma-function-object.h b/jerry-core/ecma/operations/ecma-function-object.h index b9045532d..730600c7e 100644 --- a/jerry-core/ecma/operations/ecma-function-object.h +++ b/jerry-core/ecma/operations/ecma-function-object.h @@ -34,7 +34,7 @@ ecma_op_create_function_object (ecma_collection_header_t *formal_params_collecti ecma_object_t *scope_p, bool is_strict, bool do_instantiate_arguments_object, - const vm_instr_t *instrs_p, + const bytecode_data_header_t *bytecode_data_p, vm_instr_counter_t first_opcode_idx); extern ecma_object_t* ecma_op_create_external_function_object (ecma_external_pointer_t code_p); @@ -66,7 +66,7 @@ ecma_op_function_has_instance (ecma_object_t *func_obj_p, extern ecma_completion_value_t ecma_op_function_declaration (ecma_object_t *lex_env_p, ecma_string_t *function_name_p, - const vm_instr_t *instrs_p, + const bytecode_data_header_t *bytecode_data_p, vm_instr_counter_t function_code_opcode_idx, ecma_collection_header_t *formal_params_collection_p, bool is_strict, diff --git a/jerry-core/jerry.cpp b/jerry-core/jerry.cpp index 7000b40e8..ac9113b6d 100644 --- a/jerry-core/jerry.cpp +++ b/jerry-core/jerry.cpp @@ -1403,12 +1403,12 @@ jerry_parse (const jerry_api_char_t* source_p, /**< script source */ parser_set_show_instrs (is_show_instructions); - const vm_instr_t *instrs_p; + const bytecode_data_header_t *bytecode_data_p; jsp_status_t parse_status; parse_status = parser_parse_script (source_p, source_size, - &instrs_p); + &bytecode_data_p); if (parse_status != JSP_STATUS_OK) { @@ -1427,7 +1427,7 @@ jerry_parse (const jerry_api_char_t* source_p, /**< script source */ bool is_show_mem_stats_per_instruction = ((jerry_flags & JERRY_FLAG_MEM_STATS_PER_OPCODE) != 0); - vm_init (instrs_p, is_show_mem_stats_per_instruction); + vm_init (bytecode_data_p, is_show_mem_stats_per_instruction); return true; } /* jerry_parse */ diff --git a/jerry-core/parser/js/bytecode-data.h b/jerry-core/parser/js/bytecode-data.h index f641155a2..a03ff0461 100644 --- a/jerry-core/parser/js/bytecode-data.h +++ b/jerry-core/parser/js/bytecode-data.h @@ -17,7 +17,6 @@ #define BYTECODE_DATA_H #include "opcodes.h" -#include "lit-id-hash-table.h" #include "mem-allocator.h" /* @@ -33,36 +32,18 @@ * * To map uid to literal id 'lit_id_hash' table is used. */ -#define BLOCK_SIZE 64 +#define BLOCK_SIZE 64u /** * Header of byte-code memory region, containing byte-code array and literal identifiers hash table */ -typedef struct __attribute__ ((aligned (MEM_ALIGNMENT))) +typedef struct __attribute__ ((aligned (MEM_ALIGNMENT))) bytecode_data_header_t { + vm_instr_t *instrs_p; /**< pointer to the bytecode */ + vm_instr_counter_t instrs_count; /**< number of instructions in the byte-code array */ mem_cpointer_t lit_id_hash_cp; /**< pointer to literal identifiers hash table * See also: lit_id_hash_table_init */ - mem_cpointer_t next_instrs_cp; /**< pointer to next byte-code memory region */ - vm_instr_counter_t instructions_number; /**< number of instructions in the byte-code array */ -} insts_data_header_t; + mem_cpointer_t next_header_cp; /**< pointer to next instructions data header */ +} bytecode_data_header_t; -typedef struct -{ - const ecma_char_t *strings_buffer; - const vm_instr_t *instrs_p; - vm_instr_counter_t instrs_count; -} bytecode_data_t; - -/** - * Macros to get a pointer to bytecode header by pointer to instructions array start - */ -#define GET_BYTECODE_HEADER(instrs) ((insts_data_header_t *) (((uint8_t *) (instrs)) - sizeof (insts_data_header_t))) - -/** - * Macros to get a hash table corresponding to a bytecode region - */ -#define GET_HASH_TABLE_FOR_BYTECODE(instrs) (MEM_CP_GET_POINTER (lit_id_hash_table, \ - GET_BYTECODE_HEADER (instrs)->lit_id_hash_cp)) - - -#endif // BYTECODE_DATA_H +#endif /* BYTECODE_DATA_H */ diff --git a/jerry-core/parser/js/parser.cpp b/jerry-core/parser/js/parser.cpp index 9fcfe2c5b..ec4944c21 100644 --- a/jerry-core/parser/js/parser.cpp +++ b/jerry-core/parser/js/parser.cpp @@ -3101,13 +3101,13 @@ parser_parse_program (const jerry_api_char_t *source_p, /**< source code buffer bool in_eval, /**< flag indicating if we are parsing body of eval code */ bool is_strict, /**< flag, indicating whether current code * inherited strict mode from code of an outer scope */ - const vm_instr_t **out_instrs_p, /**< out: generated byte-code array - * (in case there were no syntax errors) */ + const bytecode_data_header_t **out_bytecode_data_p, /**< out: generated byte-code array + * (in case there were no syntax errors) */ bool *out_contains_functions_p) /**< out: optional (can be NULL, if the output is not needed) * flag, indicating whether the compiled byte-code * contains a function declaration / expression */ { - JERRY_ASSERT (out_instrs_p != NULL); + JERRY_ASSERT (out_bytecode_data_p != NULL); JERRY_ASSERT (!(in_dyn_constructed_function && in_eval)); @@ -3189,7 +3189,7 @@ parser_parse_program (const jerry_api_char_t *source_p, /**< source code buffer jsp_early_error_free (); - *out_instrs_p = serializer_merge_scopes_into_bytecode (); + *out_bytecode_data_p = serializer_merge_scopes_into_bytecode (); dumper_free (); @@ -3215,7 +3215,7 @@ parser_parse_program (const jerry_api_char_t *source_p, /**< source code buffer JERRY_ASSERT (!is_parse_finished); #endif /* !JERRY_NDEBUG */ - *out_instrs_p = NULL; + *out_bytecode_data_p = NULL; jsp_label_remove_all_labels (); jsp_mm_free_all (); @@ -3249,10 +3249,10 @@ parser_parse_program (const jerry_api_char_t *source_p, /**< source code buffer jsp_status_t parser_parse_script (const jerry_api_char_t *source, /**< source script */ size_t source_size, /**< source script size it bytes */ - const vm_instr_t **out_instrs_p) /**< out: generated byte-code array - * (in case there were no syntax errors) */ + const bytecode_data_header_t **out_bytecode_data_p) /**< out: generated byte-code array + * (in case there were no syntax errors) */ { - return parser_parse_program (source, source_size, false, false, false, out_instrs_p, NULL); + return parser_parse_program (source, source_size, false, false, false, out_bytecode_data_p, NULL); } /* parser_parse_script */ /** @@ -3266,14 +3266,20 @@ parser_parse_eval (const jerry_api_char_t *source, /**< string passed to eval() size_t source_size, /**< string size in bytes */ bool is_strict, /**< flag, indicating whether eval is called * from strict code in direct mode */ - const vm_instr_t **out_instrs_p, /**< out: generated byte-code array - * (in case there were no syntax errors) */ + const bytecode_data_header_t **out_bytecode_data_p, /**< out: generated byte-code array + * (in case there were no syntax errors) */ bool *out_contains_functions_p) /**< out: flag, indicating whether the compiled byte-code * contains a function declaration / expression */ { JERRY_ASSERT (out_contains_functions_p != NULL); - return parser_parse_program (source, source_size, false, true, is_strict, out_instrs_p, out_contains_functions_p); + return parser_parse_program (source, + source_size, + false, + true, + is_strict, + out_bytecode_data_p, + out_contains_functions_p); } /* parser_parse_eval */ /** @@ -3291,8 +3297,9 @@ parser_parse_new_function (const jerry_api_char_t **params, /**< array of argume * body) call */ const size_t *params_size, /**< sizes of arguments strings */ size_t params_count, /**< total number of arguments passed to new Function (...) */ - const vm_instr_t **out_instrs_p) /**< out: generated byte-code array - * (in case there were no syntax errors) */ + const bytecode_data_header_t **out_bytecode_data_p) /**< out: generated byte-code array + * (in case there were no syntax + * errors) */ { // Process arguments JERRY_ASSERT (params_count > 0); @@ -3306,7 +3313,7 @@ parser_parse_new_function (const jerry_api_char_t **params, /**< array of argume true, false, false, - out_instrs_p, + out_bytecode_data_p, NULL); } /* parser_parse_new_function */ diff --git a/jerry-core/parser/js/parser.h b/jerry-core/parser/js/parser.h index 091571542..72588ebed 100644 --- a/jerry-core/parser/js/parser.h +++ b/jerry-core/parser/js/parser.h @@ -29,8 +29,9 @@ typedef enum } jsp_status_t; void parser_set_show_instrs (bool); -jsp_status_t parser_parse_script (const jerry_api_char_t *, size_t, const vm_instr_t **); -jsp_status_t parser_parse_eval (const jerry_api_char_t *, size_t, bool, const vm_instr_t **, bool *); -jsp_status_t parser_parse_new_function (const jerry_api_char_t **, const size_t *, size_t, const vm_instr_t **); +jsp_status_t parser_parse_script (const jerry_api_char_t *, size_t, const bytecode_data_header_t **); +jsp_status_t parser_parse_eval (const jerry_api_char_t *, size_t, bool, const bytecode_data_header_t **, bool *); +jsp_status_t parser_parse_new_function (const jerry_api_char_t **, const size_t *, size_t, + const bytecode_data_header_t **); #endif /* PARSER_H */ diff --git a/jerry-core/parser/js/scopes-tree.cpp b/jerry-core/parser/js/scopes-tree.cpp index 2f14d495f..2bd9f662e 100644 --- a/jerry-core/parser/js/scopes-tree.cpp +++ b/jerry-core/parser/js/scopes-tree.cpp @@ -691,13 +691,11 @@ scopes_tree_raw_data (scopes_tree tree, /**< scopes tree to convert to byte-code global_oc = 0; /* Dump bytecode and fill literal indexes 'hash' table. */ - JERRY_ASSERT (instructions_array_size >= - sizeof (insts_data_header_t) + (size_t) (scopes_tree_count_instructions (tree)) * sizeof (vm_instr_t)); + JERRY_ASSERT (instructions_array_size >= (size_t) (scopes_tree_count_instructions (tree)) * sizeof (vm_instr_t)); - insts_data_header_t *opcodes_data = (insts_data_header_t *) buffer_p; - memset (opcodes_data, 0, instructions_array_size); + vm_instr_t *instrs = (vm_instr_t *) buffer_p; + memset (instrs, 0, instructions_array_size); - vm_instr_t *instrs = (vm_instr_t *)(((uint8_t*) opcodes_data) + sizeof (insts_data_header_t)); merge_subscopes (tree, instrs, lit_ids); if (lit_id_to_uid != null_hash) { @@ -705,8 +703,6 @@ scopes_tree_raw_data (scopes_tree tree, /**< scopes tree to convert to byte-code lit_id_to_uid = null_hash; } - MEM_CP_SET_POINTER (opcodes_data->lit_id_hash_cp, lit_ids); - return instrs; } /* scopes_tree_raw_data */ diff --git a/jerry-core/parser/js/serializer.cpp b/jerry-core/parser/js/serializer.cpp index 1399b212a..8bd8af696 100644 --- a/jerry-core/parser/js/serializer.cpp +++ b/jerry-core/parser/js/serializer.cpp @@ -19,13 +19,12 @@ #include "array-list.h" #include "scopes-tree.h" -static bytecode_data_t bytecode_data; +static bytecode_data_header_t *first_bytecode_header_p; static scopes_tree current_scope; static bool print_instrs; static void -serializer_print_instrs (const vm_instr_t *instrs_p, - size_t instrs_count); +serializer_print_instrs (const bytecode_data_header_t *); op_meta serializer_get_op_meta (vm_instr_counter_t oc) @@ -52,19 +51,19 @@ serializer_get_var_decl (vm_instr_counter_t oc) /**< index of variable declarati * @return byte-code instruction */ vm_instr_t -serializer_get_instr (const vm_instr_t *instrs_p, /**< pointer to byte-code array (or NULL, - * if instruction should be taken from - * instruction list of current scope) */ +serializer_get_instr (const bytecode_data_header_t *bytecode_data_p, /**< pointer to byte-code data (or NULL, + * if instruction should be taken from + * instruction list of current scope) */ vm_instr_counter_t oc) /**< position of the intruction */ { - if (instrs_p == NULL) + if (bytecode_data_p == NULL) { return serializer_get_op_meta (oc).op; } else { - JERRY_ASSERT (oc < GET_BYTECODE_HEADER (instrs_p)->instructions_number); - return instrs_p[oc]; + JERRY_ASSERT (oc < bytecode_data_p->instrs_count); + return bytecode_data_p->instrs_p[oc]; } } /* serializer_get_instr */ @@ -79,23 +78,27 @@ serializer_get_instr (const vm_instr_t *instrs_p, /**< pointer to byte-code arra */ lit_cpointer_t serializer_get_literal_cp_by_uid (uint8_t id, /**< literal idx */ - const vm_instr_t *instrs_p, /**< pointer to bytecode */ + const bytecode_data_header_t *bytecode_data_p, /**< pointer to bytecode */ vm_instr_counter_t oc) /**< position in the bytecode */ { - lit_id_hash_table *lit_id_hash = GET_HASH_TABLE_FOR_BYTECODE (instrs_p == NULL ? bytecode_data.instrs_p : instrs_p); + lit_id_hash_table *lit_id_hash = null_hash; + if (bytecode_data_p) + { + lit_id_hash = MEM_CP_GET_POINTER (lit_id_hash_table, bytecode_data_p->lit_id_hash_cp); + } + else + { + lit_id_hash = MEM_CP_GET_POINTER (lit_id_hash_table, first_bytecode_header_p->lit_id_hash_cp); + } + if (lit_id_hash == null_hash) { return INVALID_LITERAL; } + return lit_id_hash_table_lookup (lit_id_hash, id, oc); } /* serializer_get_literal_cp_by_uid */ -void -serializer_set_strings_buffer (const ecma_char_t *s) -{ - bytecode_data.strings_buffer = s; -} - void serializer_set_scope (scopes_tree new_scope) { @@ -145,43 +148,52 @@ serializer_dump_subscope (scopes_tree tree) /**< scope to dump */ } } /* serializer_dump_subscope */ -const vm_instr_t * + +/** + * Merge scopes tree into bytecode + * + * @return pointer to generated bytecode + */ +const bytecode_data_header_t * serializer_merge_scopes_into_bytecode (void) { - bytecode_data.instrs_count = scopes_tree_count_instructions (current_scope); - const size_t buckets_count = scopes_tree_count_literals_in_blocks (current_scope); - const size_t blocks_count = (size_t) bytecode_data.instrs_count / BLOCK_SIZE + 1; const vm_instr_counter_t instrs_count = scopes_tree_count_instructions (current_scope); + const size_t blocks_count = JERRY_ALIGNUP (instrs_count, BLOCK_SIZE) / BLOCK_SIZE; - const size_t bytecode_array_size = JERRY_ALIGNUP (sizeof (insts_data_header_t) + instrs_count * sizeof (vm_instr_t), - MEM_ALIGNMENT); - const size_t lit_id_hash_table_size = JERRY_ALIGNUP (lit_id_hash_table_get_size_for_table (buckets_count, - blocks_count), - MEM_ALIGNMENT); + const size_t bytecode_size = JERRY_ALIGNUP (instrs_count * sizeof (vm_instr_t), MEM_ALIGNMENT); + const size_t hash_table_size = lit_id_hash_table_get_size_for_table (buckets_count, blocks_count); + const size_t header_and_hash_table_size = JERRY_ALIGNUP (sizeof (bytecode_data_header_t) + hash_table_size, + MEM_ALIGNMENT); - uint8_t *buffer_p = (uint8_t*) mem_heap_alloc_block (bytecode_array_size + lit_id_hash_table_size, + uint8_t *buffer_p = (uint8_t*) mem_heap_alloc_block (bytecode_size + header_and_hash_table_size, MEM_HEAP_ALLOC_LONG_TERM); - lit_id_hash_table *lit_id_hash = lit_id_hash_table_init (buffer_p + bytecode_array_size, - lit_id_hash_table_size, + lit_id_hash_table *lit_id_hash = lit_id_hash_table_init (buffer_p + sizeof (bytecode_data_header_t), + hash_table_size, buckets_count, blocks_count); - const vm_instr_t *instrs_p = scopes_tree_raw_data (current_scope, buffer_p, bytecode_array_size, lit_id_hash); + vm_instr_t *bytecode_p = scopes_tree_raw_data (current_scope, + buffer_p + header_and_hash_table_size, + bytecode_size, + lit_id_hash); - insts_data_header_t *header_p = (insts_data_header_t*) buffer_p; - MEM_CP_SET_POINTER (header_p->next_instrs_cp, bytecode_data.instrs_p); - header_p->instructions_number = instrs_count; - bytecode_data.instrs_p = instrs_p; + bytecode_data_header_t *header_p = (bytecode_data_header_t *) buffer_p; + MEM_CP_SET_POINTER (header_p->lit_id_hash_cp, lit_id_hash); + header_p->instrs_p = bytecode_p; + header_p->instrs_count = instrs_count; + MEM_CP_SET_POINTER (header_p->next_header_cp, first_bytecode_header_p); + + first_bytecode_header_p = header_p; if (print_instrs) { lit_dump_literals (); - serializer_print_instrs (instrs_p, bytecode_data.instrs_count); + serializer_print_instrs (header_p); } - return instrs_p; -} + return header_p; +} /* serializer_merge_scopes_into_bytecode */ void serializer_dump_op_meta (op_meta op) @@ -252,25 +264,23 @@ serializer_rewrite_op_meta (const vm_instr_counter_t loc, op_meta op) } static void -serializer_print_instrs (const vm_instr_t *instrs_p, - size_t instrs_count) +serializer_print_instrs (const bytecode_data_header_t *bytecode_data_p) { #ifdef JERRY_ENABLE_PRETTY_PRINTER - for (vm_instr_counter_t loc = 0; loc < instrs_count; loc++) + for (vm_instr_counter_t loc = 0; loc < bytecode_data_p->instrs_count; loc++) { op_meta opm; - opm.op = instrs_p[loc]; + opm.op = bytecode_data_p->instrs_p[loc]; for (int i = 0; i < 3; i++) { opm.lit_id[i] = NOT_A_LITERAL; } - pp_op_meta (instrs_p, loc, opm, false); + pp_op_meta (bytecode_data_p, loc, opm, false); } #else - (void) instrs_p; - (void) instrs_count; + (void) bytecode_data_p; #endif } @@ -280,8 +290,7 @@ serializer_init () current_scope = NULL; print_instrs = false; - bytecode_data.strings_buffer = NULL; - bytecode_data.instrs_p = NULL; + first_bytecode_header_p = NULL; lit_init (); } @@ -295,47 +304,41 @@ void serializer_set_show_instrs (bool show_instrs) * Deletes bytecode and associated hash table */ void -serializer_remove_instructions (const vm_instr_t *instrs_p) /**< pointer to instructions which should be deleted */ +serializer_remove_bytecode_data (const bytecode_data_header_t *bytecode_data_p) /**< pointer to bytecode data which + * should be deleted */ { - insts_data_header_t *prev_header = NULL; - const vm_instr_t *cur_instrs_p = bytecode_data.instrs_p; - while (cur_instrs_p != NULL) - { - insts_data_header_t *cur_header_p = GET_BYTECODE_HEADER (cur_instrs_p); + bytecode_data_header_t *prev_header = NULL; + bytecode_data_header_t *cur_header_p = first_bytecode_header_p; - if (cur_instrs_p == instrs_p) + while (cur_header_p != NULL) + { + if (cur_header_p == bytecode_data_p) { if (prev_header) { - prev_header->next_instrs_cp = cur_header_p->next_instrs_cp; + prev_header->next_header_cp = cur_header_p->next_header_cp; } else { - bytecode_data.instrs_p = MEM_CP_GET_POINTER (vm_instr_t, cur_header_p->next_instrs_cp); + first_bytecode_header_p = MEM_CP_GET_POINTER (bytecode_data_header_t, cur_header_p->next_header_cp); } mem_heap_free_block (cur_header_p); break; } - prev_header = GET_BYTECODE_HEADER (cur_instrs_p); - cur_instrs_p = MEM_CP_GET_POINTER (vm_instr_t, cur_header_p->next_instrs_cp); + prev_header = cur_header_p; } } /* serializer_remove_instructions */ void serializer_free (void) { - if (bytecode_data.strings_buffer) - { - mem_heap_free_block ((uint8_t *) bytecode_data.strings_buffer); - } - lit_finalize (); - while (bytecode_data.instrs_p != NULL) + while (first_bytecode_header_p != NULL) { - insts_data_header_t *header_p = GET_BYTECODE_HEADER (bytecode_data.instrs_p); - bytecode_data.instrs_p = MEM_CP_GET_POINTER (vm_instr_t, header_p->next_instrs_cp); + bytecode_data_header_t *header_p = first_bytecode_header_p; + first_bytecode_header_p = MEM_CP_GET_POINTER (bytecode_data_header_t, header_p->next_header_cp); mem_heap_free_block (header_p); } diff --git a/jerry-core/parser/js/serializer.h b/jerry-core/parser/js/serializer.h index 1f2e39835..3e6f1fa88 100644 --- a/jerry-core/parser/js/serializer.h +++ b/jerry-core/parser/js/serializer.h @@ -16,6 +16,7 @@ #ifndef SERIALIZER_H #define SERIALIZER_H +#include "bytecode-data.h" #include "jrt.h" #include "ecma-globals.h" #include "opcodes.h" @@ -28,12 +29,11 @@ void serializer_init (); void serializer_set_show_instrs (bool show_instrs); op_meta serializer_get_op_meta (vm_instr_counter_t); op_meta serializer_get_var_decl (vm_instr_counter_t); -vm_instr_t serializer_get_instr (const vm_instr_t*, vm_instr_counter_t); -lit_cpointer_t serializer_get_literal_cp_by_uid (uint8_t, const vm_instr_t*, vm_instr_counter_t); -void serializer_set_strings_buffer (const ecma_char_t *); +vm_instr_t serializer_get_instr (const bytecode_data_header_t *, vm_instr_counter_t); +lit_cpointer_t serializer_get_literal_cp_by_uid (uint8_t, const bytecode_data_header_t *, vm_instr_counter_t); void serializer_set_scope (scopes_tree); void serializer_dump_subscope (scopes_tree); -const vm_instr_t *serializer_merge_scopes_into_bytecode (void); +const bytecode_data_header_t *serializer_merge_scopes_into_bytecode (void); void serializer_dump_op_meta (op_meta); void serializer_dump_var_decl (op_meta); vm_instr_counter_t serializer_get_current_instr_counter (void); @@ -41,7 +41,7 @@ vm_instr_counter_t serializer_get_current_var_decls_counter (void); vm_instr_counter_t serializer_count_instrs_in_subscopes (void); void serializer_set_writing_position (vm_instr_counter_t); void serializer_rewrite_op_meta (vm_instr_counter_t, op_meta); -void serializer_remove_instructions (const vm_instr_t *instrs_p); +void serializer_remove_bytecode_data (const bytecode_data_header_t *); void serializer_free (void); #endif // SERIALIZER_H diff --git a/jerry-core/vm/opcodes-ecma-try-catch-finally.cpp b/jerry-core/vm/opcodes-ecma-try-catch-finally.cpp index d066a2ca5..b3e23d18e 100644 --- a/jerry-core/vm/opcodes-ecma-try-catch-finally.cpp +++ b/jerry-core/vm/opcodes-ecma-try-catch-finally.cpp @@ -43,7 +43,7 @@ opfunc_try_block (vm_instr_t instr, /**< instruction */ || (ecma_is_completion_value_empty (try_completion) && frame_ctx_p->pos == try_end_oc)); frame_ctx_p->pos = try_end_oc; - vm_instr_t next_instr = vm_get_instr (frame_ctx_p->instrs_p, frame_ctx_p->pos); + vm_instr_t next_instr = vm_get_instr (frame_ctx_p->bytecode_header_p->instrs_p, frame_ctx_p->pos); JERRY_ASSERT (next_instr.op_idx == VM_OP_META); if (next_instr.data.meta.type == OPCODE_META_TYPE_CATCH) @@ -54,12 +54,12 @@ opfunc_try_block (vm_instr_t instr, /**< instruction */ if (ecma_is_completion_value_throw (try_completion)) { - next_instr = vm_get_instr (frame_ctx_p->instrs_p, frame_ctx_p->pos); + next_instr = vm_get_instr (frame_ctx_p->bytecode_header_p->instrs_p, frame_ctx_p->pos); JERRY_ASSERT (next_instr.op_idx == VM_OP_META); JERRY_ASSERT (next_instr.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_instr.data.meta.data_1, - frame_ctx_p->instrs_p, + frame_ctx_p->bytecode_header_p, frame_ctx_p->pos); frame_ctx_p->pos++; @@ -98,7 +98,7 @@ opfunc_try_block (vm_instr_t instr, /**< instruction */ frame_ctx_p->pos = catch_end_oc; } - next_instr = vm_get_instr (frame_ctx_p->instrs_p, frame_ctx_p->pos); + next_instr = vm_get_instr (frame_ctx_p->bytecode_header_p->instrs_p, frame_ctx_p->pos); JERRY_ASSERT (next_instr.op_idx == VM_OP_META); if (next_instr.data.meta.type == OPCODE_META_TYPE_FINALLY) @@ -121,7 +121,7 @@ opfunc_try_block (vm_instr_t instr, /**< instruction */ } } - next_instr = vm_get_instr (frame_ctx_p->instrs_p, frame_ctx_p->pos++); + next_instr = vm_get_instr (frame_ctx_p->bytecode_header_p->instrs_p, frame_ctx_p->pos++); JERRY_ASSERT (next_instr.op_idx == VM_OP_META); JERRY_ASSERT (next_instr.data.meta.type == OPCODE_META_TYPE_END_TRY_CATCH_FINALLY); diff --git a/jerry-core/vm/opcodes-for-in.cpp b/jerry-core/vm/opcodes-for-in.cpp index 2be929fc5..c4f34b9ca 100644 --- a/jerry-core/vm/opcodes-for-in.cpp +++ b/jerry-core/vm/opcodes-for-in.cpp @@ -203,7 +203,7 @@ opfunc_for_in (vm_instr_t instr, /**< instruction */ int_data_p->pos++; - vm_instr_t meta_instr = vm_get_instr (int_data_p->instrs_p, for_in_end_oc); + vm_instr_t meta_instr = vm_get_instr (int_data_p->bytecode_header_p->instrs_p, for_in_end_oc); JERRY_ASSERT (meta_instr.op_idx == VM_OP_META); JERRY_ASSERT (meta_instr.data.meta.type == OPCODE_META_TYPE_END_FOR_IN); diff --git a/jerry-core/vm/opcodes-helpers-variables.cpp b/jerry-core/vm/opcodes-helpers-variables.cpp index 3a648eba2..b14238fb9 100644 --- a/jerry-core/vm/opcodes-helpers-variables.cpp +++ b/jerry-core/vm/opcodes-helpers-variables.cpp @@ -14,6 +14,7 @@ */ #include "opcodes-ecma-support.h" +#include "opcodes.h" #ifndef JERRY_NDEBUG /** @@ -91,7 +92,9 @@ get_variable_value (vm_frame_ctx_t *frame_ctx_p, /**< interpreter context */ else { ecma_string_t var_name_string; - lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (var_idx, frame_ctx_p->instrs_p, frame_ctx_p->pos); + lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (var_idx, + frame_ctx_p->bytecode_header_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); @@ -158,7 +161,7 @@ set_variable_value (vm_frame_ctx_t *frame_ctx_p, /**< interpreter context */ else { ecma_string_t var_name_string; - lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (var_idx, frame_ctx_p->instrs_p, lit_oc); + lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (var_idx, frame_ctx_p->bytecode_header_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); diff --git a/jerry-core/vm/opcodes-varg.cpp b/jerry-core/vm/opcodes-varg.cpp index d0ba20e8c..3a7730dd8 100644 --- a/jerry-core/vm/opcodes-varg.cpp +++ b/jerry-core/vm/opcodes-varg.cpp @@ -42,7 +42,7 @@ vm_fill_varg_list (vm_frame_ctx_t *frame_ctx_p, /**< interpreter context */ vm_loop (frame_ctx_p, NULL), ret_value); - vm_instr_t next_instr = vm_get_instr (frame_ctx_p->instrs_p, frame_ctx_p->pos); + vm_instr_t next_instr = vm_get_instr (frame_ctx_p->bytecode_header_p->instrs_p, frame_ctx_p->pos); JERRY_ASSERT (next_instr.op_idx == VM_OP_META); JERRY_ASSERT (next_instr.data.meta.type == OPCODE_META_TYPE_VARG); @@ -80,12 +80,12 @@ vm_fill_params_list (vm_frame_ctx_t *frame_ctx_p, /**< interpreter context */ param_index < params_number; param_index++) { - vm_instr_t next_instr = vm_get_instr (frame_ctx_p->instrs_p, frame_ctx_p->pos); + vm_instr_t next_instr = vm_get_instr (frame_ctx_p->bytecode_header_p->instrs_p, frame_ctx_p->pos); JERRY_ASSERT (next_instr.op_idx == VM_OP_META); JERRY_ASSERT (next_instr.data.meta.type == OPCODE_META_TYPE_VARG); const lit_cpointer_t param_name_lit_idx = serializer_get_literal_cp_by_uid (next_instr.data.meta.data_1, - frame_ctx_p->instrs_p, + frame_ctx_p->bytecode_header_p, frame_ctx_p->pos); diff --git a/jerry-core/vm/opcodes.cpp b/jerry-core/vm/opcodes.cpp index 091d97231..d77f84537 100644 --- a/jerry-core/vm/opcodes.cpp +++ b/jerry-core/vm/opcodes.cpp @@ -77,7 +77,9 @@ opfunc_assignment (vm_instr_t instr, /**< instruction */ } else if (type_value_right == OPCODE_ARG_TYPE_STRING) { - lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (src_val_descr, frame_ctx_p->instrs_p, frame_ctx_p->pos); + lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (src_val_descr, + frame_ctx_p->bytecode_header_p, + frame_ctx_p->pos); ecma_string_t *string_p = ecma_new_ecma_string_from_lit_cp (lit_cp); ret_value = set_variable_value (frame_ctx_p, @@ -106,7 +108,9 @@ opfunc_assignment (vm_instr_t instr, /**< instruction */ { ecma_number_t *num_p = frame_ctx_p->tmp_num_p; - lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (src_val_descr, frame_ctx_p->instrs_p, frame_ctx_p->pos); + lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (src_val_descr, + frame_ctx_p->bytecode_header_p, + frame_ctx_p->pos); literal_t lit = lit_get_literal_by_cp (lit_cp); JERRY_ASSERT (lit->get_type () == LIT_NUMBER_T); @@ -121,7 +125,9 @@ opfunc_assignment (vm_instr_t instr, /**< instruction */ { ecma_number_t *num_p = frame_ctx_p->tmp_num_p; - lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (src_val_descr, frame_ctx_p->instrs_p, frame_ctx_p->pos); + lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (src_val_descr, + frame_ctx_p->bytecode_header_p, + frame_ctx_p->pos); literal_t lit = lit_get_literal_by_cp (lit_cp); JERRY_ASSERT (lit->get_type () == LIT_NUMBER_T); @@ -147,7 +153,7 @@ opfunc_assignment (vm_instr_t instr, /**< instruction */ { #ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_REGEXP_BUILTIN lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (src_val_descr, - frame_ctx_p->instrs_p, + frame_ctx_p->bytecode_header_p, frame_ctx_p->pos); ecma_string_t *string_p = ecma_new_ecma_string_from_lit_cp (lit_cp); @@ -438,7 +444,7 @@ opfunc_var_decl (vm_instr_t instr, /**< instruction */ vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */ { lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (instr.data.var_decl.variable_name, - frame_ctx_p->instrs_p, + frame_ctx_p->bytecode_header_p, frame_ctx_p->pos); JERRY_ASSERT (lit_cp.packed_value != MEM_CP_NULL); @@ -489,7 +495,8 @@ function_declaration (vm_frame_ctx_t *frame_ctx_p, /**< interpreter context */ vm_read_instr_counter_from_meta (OPCODE_META_TYPE_FUNCTION_END, frame_ctx_p) + frame_ctx_p->pos); frame_ctx_p->pos++; - opcode_scope_code_flags_t scope_flags = vm_get_scope_flags (frame_ctx_p->instrs_p, frame_ctx_p->pos++); + opcode_scope_code_flags_t scope_flags = vm_get_scope_flags (frame_ctx_p->bytecode_header_p->instrs_p, + frame_ctx_p->pos++); if (scope_flags & OPCODE_SCOPE_CODE_FLAGS_STRICT) { @@ -508,7 +515,7 @@ function_declaration (vm_frame_ctx_t *frame_ctx_p, /**< interpreter context */ ecma_completion_value_t ret_value = ecma_op_function_declaration (frame_ctx_p->lex_env_p, function_name_string_p, - frame_ctx_p->instrs_p, + frame_ctx_p->bytecode_header_p, frame_ctx_p->pos, formal_params_collection_p, is_strict, @@ -535,7 +542,7 @@ opfunc_func_decl_n (vm_instr_t instr, /**< instruction */ const ecma_length_t params_number = instr.data.func_decl_n.arg_list; lit_cpointer_t function_name_lit_cp = serializer_get_literal_cp_by_uid (function_name_idx, - frame_ctx_p->instrs_p, + frame_ctx_p->bytecode_header_p, frame_ctx_p->pos); frame_ctx_p->pos++; @@ -587,7 +594,7 @@ opfunc_func_expr_n (vm_instr_t instr, /**< instruction */ frame_ctx_p) + frame_ctx_p->pos); frame_ctx_p->pos++; - opcode_scope_code_flags_t scope_flags = vm_get_scope_flags (frame_ctx_p->instrs_p, + opcode_scope_code_flags_t scope_flags = vm_get_scope_flags (frame_ctx_p->bytecode_header_p->instrs_p, frame_ctx_p->pos++); if (scope_flags & OPCODE_SCOPE_CODE_FLAGS_STRICT) @@ -610,7 +617,7 @@ opfunc_func_expr_n (vm_instr_t instr, /**< instruction */ scope_p = ecma_create_decl_lex_env (frame_ctx_p->lex_env_p); lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (function_name_lit_idx, - frame_ctx_p->instrs_p, + frame_ctx_p->bytecode_header_p, lit_oc); JERRY_ASSERT (lit_cp.packed_value != MEM_CP_NULL); @@ -627,7 +634,7 @@ opfunc_func_expr_n (vm_instr_t instr, /**< instruction */ scope_p, is_strict, do_instantiate_arguments_object, - frame_ctx_p->instrs_p, + frame_ctx_p->bytecode_header_p, frame_ctx_p->pos); ret_value = set_variable_value (frame_ctx_p, lit_oc, @@ -673,7 +680,7 @@ vm_helper_call_get_call_flags_and_this_arg (vm_frame_ctx_t *int_data_p, /**< int opcode_call_flags_t call_flags = OPCODE_CALL_FLAGS__EMPTY; vm_idx_t this_arg_var_idx = VM_IDX_EMPTY; - vm_instr_t next_opcode = vm_get_instr (int_data_p->instrs_p, int_data_p->pos); + vm_instr_t next_opcode = vm_get_instr (int_data_p->bytecode_header_p->instrs_p, int_data_p->pos); if (next_opcode.op_idx == VM_OP_META && next_opcode.data.meta.type == OPCODE_META_TYPE_CALL_SITE_INFO) { @@ -732,7 +739,9 @@ vm_helper_call_get_call_flags_and_this_arg (vm_frame_ctx_t *int_data_p, /**< int /* 6.b.i */ ecma_string_t var_name_string; - lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (var_idx, int_data_p->instrs_p, var_idx_lit_oc); + lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (var_idx, + int_data_p->bytecode_header_p, + var_idx_lit_oc); 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_p->lex_env_p, @@ -1032,7 +1041,7 @@ opfunc_obj_decl (vm_instr_t instr, /**< instruction */ if (ecma_is_completion_value_empty (evaluate_prop_completion)) { - vm_instr_t next_opcode = vm_get_instr (frame_ctx_p->instrs_p, frame_ctx_p->pos); + vm_instr_t next_opcode = vm_get_instr (frame_ctx_p->bytecode_header_p->instrs_p, frame_ctx_p->pos); JERRY_ASSERT (next_opcode.op_idx == VM_OP_META); const opcode_meta_type type = (opcode_meta_type) next_opcode.data.meta.type; @@ -1407,7 +1416,7 @@ opfunc_with (vm_instr_t instr, /**< instruction */ frame_ctx_p->lex_env_p = new_env_p; #ifndef JERRY_NDEBUG - vm_instr_t meta_opcode = vm_get_instr (frame_ctx_p->instrs_p, with_end_oc); + vm_instr_t meta_opcode = vm_get_instr (frame_ctx_p->bytecode_header_p->instrs_p, with_end_oc); JERRY_ASSERT (meta_opcode.op_idx == VM_OP_META); JERRY_ASSERT (meta_opcode.data.meta.type == OPCODE_META_TYPE_END_WITH); #endif /* !JERRY_NDEBUG */ @@ -1496,7 +1505,9 @@ evaluate_arg_for_typeof (vm_frame_ctx_t *frame_ctx_p, /**< interpreter context * } else { - lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (var_idx, frame_ctx_p->instrs_p, frame_ctx_p->pos); + lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (var_idx, + frame_ctx_p->bytecode_header_p, + frame_ctx_p->pos); JERRY_ASSERT (lit_cp.packed_value != MEM_CP_NULL); ecma_string_t *var_name_string_p = ecma_new_ecma_string_from_lit_cp (lit_cp); @@ -1612,7 +1623,7 @@ opfunc_delete_var (vm_instr_t instr, /**< instruction */ ecma_completion_value_t ret_value = ecma_make_empty_completion_value (); - lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (name_lit_idx, frame_ctx_p->instrs_p, lit_oc); + lit_cpointer_t lit_cp = serializer_get_literal_cp_by_uid (name_lit_idx, frame_ctx_p->bytecode_header_p, lit_oc); JERRY_ASSERT (lit_cp.packed_value != MEM_CP_NULL); ecma_string_t *name_string_p = ecma_new_ecma_string_from_lit_cp (lit_cp); @@ -1798,7 +1809,7 @@ vm_instr_counter_t vm_read_instr_counter_from_meta (opcode_meta_type expected_type, /**< expected type of meta instruction */ vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */ { - vm_instr_t meta_opcode = vm_get_instr (frame_ctx_p->instrs_p, frame_ctx_p->pos); + vm_instr_t meta_opcode = vm_get_instr (frame_ctx_p->bytecode_header_p->instrs_p, frame_ctx_p->pos); JERRY_ASSERT (meta_opcode.data.meta.type == expected_type); const vm_idx_t data_1 = meta_opcode.data.meta.data_1; diff --git a/jerry-core/vm/opcodes.h b/jerry-core/vm/opcodes.h index 42fc91826..2c471cc0e 100644 --- a/jerry-core/vm/opcodes.h +++ b/jerry-core/vm/opcodes.h @@ -183,12 +183,17 @@ typedef enum */ struct vm_instr_t; +/** + * Forward declaration of bytecode data header structure + */ +struct bytecode_data_header_t; + /** * Context of interpreter, related to a JS stack frame */ typedef struct { - const vm_instr_t *instrs_p; /**< currently executed byte-code array */ + const bytecode_data_header_t *bytecode_header_p; /**< currently executed byte-code data */ vm_instr_counter_t pos; /**< current position instruction to execute */ ecma_value_t this_binding; /**< this binding for current context */ ecma_object_t *lex_env_p; /**< current lexical environment */ diff --git a/jerry-core/vm/pretty-printer.cpp b/jerry-core/vm/pretty-printer.cpp index 54b67d1d8..4ca17be6d 100644 --- a/jerry-core/vm/pretty-printer.cpp +++ b/jerry-core/vm/pretty-printer.cpp @@ -181,7 +181,7 @@ dump_asm (vm_instr_counter_t oc, vm_instr_t instr) } void -pp_op_meta (const vm_instr_t *instrs_p, +pp_op_meta (const bytecode_data_header_t *bytecode_data_p, vm_instr_counter_t oc, op_meta opm, bool rewrite) @@ -379,7 +379,7 @@ pp_op_meta (const vm_instr_t *instrs_p, while ((int16_t) start >= 0 && !found) { start--; - switch (serializer_get_instr (instrs_p, start).op_idx) + switch (serializer_get_instr (bytecode_data_p, start).op_idx) { case VM_OP_CALL_N: case VM_OP_CONSTRUCT_N: @@ -393,7 +393,7 @@ pp_op_meta (const vm_instr_t *instrs_p, } } } - vm_instr_t start_op = serializer_get_instr (instrs_p, start); + vm_instr_t start_op = serializer_get_instr (bytecode_data_p, start); switch (start_op.op_idx) { case VM_OP_CALL_N: @@ -440,7 +440,7 @@ pp_op_meta (const vm_instr_t *instrs_p, } for (vm_instr_counter_t counter = start; counter <= oc; counter++) { - vm_instr_t meta_op = serializer_get_instr (instrs_p, counter); + vm_instr_t meta_op = serializer_get_instr (bytecode_data_p, counter); switch (meta_op.op_idx) { diff --git a/jerry-core/vm/pretty-printer.h b/jerry-core/vm/pretty-printer.h index c6aa8d15e..9fb7a4fdd 100644 --- a/jerry-core/vm/pretty-printer.h +++ b/jerry-core/vm/pretty-printer.h @@ -18,10 +18,11 @@ #include "jrt.h" #ifdef JERRY_ENABLE_PRETTY_PRINTER +#include "bytecode-data.h" #include "vm.h" #include "scopes-tree.h" -void pp_op_meta (const vm_instr_t*, vm_instr_counter_t, op_meta, bool); +void pp_op_meta (const bytecode_data_header_t *, vm_instr_counter_t, op_meta, bool); #endif // JERRY_ENABLE_PRETTY_PRINTER #endif // PRETTY_PRINTER diff --git a/jerry-core/vm/vm.cpp b/jerry-core/vm/vm.cpp index 58b3a0914..9dfb07991 100644 --- a/jerry-core/vm/vm.cpp +++ b/jerry-core/vm/vm.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "bytecode-data.h" #include "ecma-alloc.h" #include "ecma-builtins.h" #include "ecma-gc.h" @@ -24,6 +25,7 @@ #include "mem-allocator.h" #include "vm.h" #include "vm-stack.h" +#include "opcodes.h" /** * Top (current) interpreter context @@ -46,7 +48,7 @@ static const opfunc __opfuncs[VM_OP__COUNT] = JERRY_STATIC_ASSERT (sizeof (vm_instr_t) <= 4); -const vm_instr_t *__program = NULL; +const bytecode_data_header_t *__program = NULL; #ifdef MEM_STATS static const char *__op_names[VM_OP__COUNT] = @@ -295,7 +297,7 @@ interp_mem_stats_opcode_exit (vm_frame_ctx_t *frame_ctx_p, frame_ctx_p->context_peak_allocated_pool_chunks = JERRY_MAX (frame_ctx_p->context_peak_allocated_pool_chunks, pools_stats_after.allocated_chunks); - vm_instr_t instr = vm_get_instr (frame_ctx_p->instrs_p, instr_position); + vm_instr_t instr = vm_get_instr (frame_ctx_p->bytecode_header_p->instrs_p, instr_position); printf ("%s Allocated heap bytes: %5u -> %5u (%+5d, local %5u, peak %5u)\n", indent_prefix, @@ -351,7 +353,7 @@ interp_mem_stats_opcode_exit (vm_frame_ctx_t *frame_ctx_p, * Initialize interpreter. */ void -vm_init (const vm_instr_t *program_p, /**< pointer to byte-code program */ +vm_init (const bytecode_data_header_t *program_p, /**< pointer to byte-code data */ bool dump_mem_stats) /** dump per-instruction memory usage change statistics */ { #ifdef MEM_STATS @@ -394,7 +396,7 @@ vm_run_global (void) bool is_strict = false; vm_instr_counter_t start_pos = 0; - opcode_scope_code_flags_t scope_flags = vm_get_scope_flags (__program, + opcode_scope_code_flags_t scope_flags = vm_get_scope_flags (__program->instrs_p, start_pos++); if (scope_flags & OPCODE_SCOPE_CODE_FLAGS_STRICT) @@ -443,11 +445,11 @@ vm_run_global (void) * @return completion value */ ecma_completion_value_t -vm_run_eval (const vm_instr_t *instrs_p, /**< instructions array */ +vm_run_eval (const bytecode_data_header_t *bytecode_data_p, /**< byte-code data header */ bool is_direct) /**< is eval called directly? */ { vm_instr_counter_t first_instr_index = 0u; - opcode_scope_code_flags_t scope_flags = vm_get_scope_flags (instrs_p, + opcode_scope_code_flags_t scope_flags = vm_get_scope_flags (bytecode_data_p->instrs_p, first_instr_index++); bool is_strict = ((scope_flags & OPCODE_SCOPE_CODE_FLAGS_STRICT) != 0); @@ -474,7 +476,7 @@ vm_run_eval (const vm_instr_t *instrs_p, /**< instructions array */ lex_env_p = strict_lex_env_p; } - ecma_completion_value_t completion = vm_run_from_pos (instrs_p, + ecma_completion_value_t completion = vm_run_from_pos (bytecode_data_p, first_instr_index, this_binding, lex_env_p, @@ -529,12 +531,12 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p, /**< interpreter context */ || (run_scope_p->start_oc <= frame_ctx_p->pos && frame_ctx_p->pos <= run_scope_p->end_oc)); - const vm_instr_t *curr = &frame_ctx_p->instrs_p[frame_ctx_p->pos]; + const vm_instr_t *curr = &frame_ctx_p->bytecode_header_p->instrs_p[frame_ctx_p->pos]; #ifdef MEM_STATS const vm_instr_counter_t instr_pos = frame_ctx_p->pos; - interp_mem_stats_opcode_enter (frame_ctx_p->instrs_p, + interp_mem_stats_opcode_enter (frame_ctx_p->bytecode_header_p->instrs_p, instr_pos, &heap_stats_before, &pools_stats_before); @@ -590,7 +592,7 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p, /**< interpreter context */ * Run the code, starting from specified instruction position */ ecma_completion_value_t -vm_run_from_pos (const vm_instr_t *instrs_p, /**< byte-code array */ +vm_run_from_pos (const bytecode_data_header_t *header_p, /**< byte-code data header */ vm_instr_counter_t start_pos, /**< position of starting instruction */ ecma_value_t this_binding_value, /**< value of 'ThisBinding' */ ecma_object_t *lex_env_p, /**< lexical environment to use */ @@ -599,6 +601,7 @@ vm_run_from_pos (const vm_instr_t *instrs_p, /**< byte-code array */ { ecma_completion_value_t completion; + const vm_instr_t *instrs_p = header_p->instrs_p; const vm_instr_t *curr = &instrs_p[start_pos]; JERRY_ASSERT (curr->op_idx == VM_OP_REG_VAR_DECL); @@ -612,7 +615,7 @@ vm_run_from_pos (const vm_instr_t *instrs_p, /**< byte-code array */ MEM_DEFINE_LOCAL_ARRAY (regs, regs_num, ecma_value_t); vm_frame_ctx_t frame_ctx; - frame_ctx.instrs_p = instrs_p; + frame_ctx.bytecode_header_p = header_p; frame_ctx.pos = (vm_instr_counter_t) (start_pos + 1); frame_ctx.this_binding = this_binding_value; frame_ctx.lex_env_p = lex_env_p; diff --git a/jerry-core/vm/vm.h b/jerry-core/vm/vm.h index c31dc4202..ab6df091c 100644 --- a/jerry-core/vm/vm.h +++ b/jerry-core/vm/vm.h @@ -16,17 +16,18 @@ #ifndef VM_H #define VM_H +#include "bytecode-data.h" #include "ecma-globals.h" #include "jrt.h" #include "opcodes.h" -extern void vm_init (const vm_instr_t* program_p, bool dump_mem_stats); +extern void vm_init (const bytecode_data_header_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_run_eval (const vm_instr_t *instrs_p, +extern ecma_completion_value_t vm_run_eval (const bytecode_data_header_t *bytecode_data_p, bool is_direct); 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 vm_instr_t *instrs_p, +extern ecma_completion_value_t vm_run_from_pos (const bytecode_data_header_t *header_p, vm_instr_counter_t start_pos, ecma_value_t this_binding_value, ecma_object_t *lex_env_p, diff --git a/tests/unit/test-parser.cpp b/tests/unit/test-parser.cpp index d66634840..e649589ae 100644 --- a/tests/unit/test-parser.cpp +++ b/tests/unit/test-parser.cpp @@ -101,7 +101,7 @@ main (int __attr_unused___ argc, { TEST_INIT (); - const vm_instr_t *instrs_p; + const bytecode_data_header_t *bytecode_data_p; jsp_status_t parse_status; mem_init (); @@ -111,9 +111,9 @@ main (int __attr_unused___ argc, serializer_init (); parser_set_show_instrs (true); - parse_status = parser_parse_script ((jerry_api_char_t *) program1, strlen (program1), &instrs_p); + parse_status = parser_parse_script ((jerry_api_char_t *) program1, strlen (program1), &bytecode_data_p); - JERRY_ASSERT (parse_status == JSP_STATUS_OK && instrs_p != NULL); + JERRY_ASSERT (parse_status == JSP_STATUS_OK && bytecode_data_p != NULL); vm_instr_t instrs[] = { @@ -128,7 +128,7 @@ main (int __attr_unused___ argc, getop_ret () // return; }; - JERRY_ASSERT (instrs_equal (instrs_p, instrs, 5)); + JERRY_ASSERT (instrs_equal (bytecode_data_p->instrs_p, instrs, 5)); serializer_free (); @@ -137,9 +137,9 @@ main (int __attr_unused___ argc, serializer_init (); parser_set_show_instrs (true); - parse_status = parser_parse_script ((jerry_api_char_t *) program2, strlen (program2), &instrs_p); + parse_status = parser_parse_script ((jerry_api_char_t *) program2, strlen (program2), &bytecode_data_p); - JERRY_ASSERT (parse_status == JSP_STATUS_SYNTAX_ERROR && instrs_p == NULL); + JERRY_ASSERT (parse_status == JSP_STATUS_SYNTAX_ERROR && bytecode_data_p == NULL); serializer_free ();