From 713d90b5a0aa163bd1de4a792642a9eaadd74d1d Mon Sep 17 00:00:00 2001 From: Zoltan Herczeg Date: Tue, 20 Jul 2021 10:33:23 +0200 Subject: Support shared user data for scripts (#4710) The same data is returned for the script and all of its functions, including those which are created by an eval call. JerryScript-DCO-1.0-Signed-off-by: Zoltan Herczeg zherczeg.u-szeged@partner.samsung.com --- docs/02.API-REFERENCE.md | 116 ++++++++++++- jerry-core/api/jerry-snapshot.c | 83 +++++++--- jerry-core/api/jerry-snapshot.h | 3 +- jerry-core/api/jerry.c | 36 +++- jerry-core/ecma/base/ecma-gc.c | 24 ++- jerry-core/ecma/base/ecma-helpers.c | 106 +++++++++++- jerry-core/ecma/base/ecma-helpers.h | 1 + jerry-core/ecma/operations/ecma-function-object.c | 26 +-- jerry-core/include/jerryscript-core.h | 1 + jerry-core/include/jerryscript-snapshot.h | 23 ++- jerry-core/include/jerryscript-types.h | 3 + jerry-core/parser/js/byte-code.c | 12 +- jerry-core/parser/js/byte-code.h | 71 +++++++- jerry-core/parser/js/js-parser-internal.h | 9 +- jerry-core/parser/js/js-parser.c | 107 ++++++++---- jerry-core/parser/js/js-parser.h | 2 +- jerry-main/main-jerry.c | 3 +- tests/unit-core/CMakeLists.txt | 1 + tests/unit-core/test-script-user-value.c | 192 ++++++++++++++++++++++ tests/unit-core/test-snapshot.c | 85 +++++++++- 20 files changed, 779 insertions(+), 125 deletions(-) create mode 100644 tests/unit-core/test-script-user-value.c diff --git a/docs/02.API-REFERENCE.md b/docs/02.API-REFERENCE.md index 75023173..854c72df 100644 --- a/docs/02.API-REFERENCE.md +++ b/docs/02.API-REFERENCE.md @@ -243,6 +243,7 @@ Option bits for [jerry_parse_options_t](#jerry_parse_options_t). - JERRY_PARSE_MODULE - Parse source as an ECMAScript module - JERRY_PARSE_HAS_RESOURCE - `resource_name_p` and `resource_name_length` fields are valid - JERRY_PARSE_HAS_START - `start_line` and `start_column` fields are valid + - JERRY_PARSE_HAS_USER_VALUE - `user_value` field is valid *New in version [[NEXT_RELEASE]]*. @@ -310,6 +311,10 @@ Flags for [jerry_exec_snapshot](#jerry_exec_snapshot) functions: - JERRY_SNAPSHOT_EXEC_COPY_DATA - copy snapshot data into memory (see below) - JERRY_SNAPSHOT_EXEC_ALLOW_STATIC - allow executing static snapshots - JERRY_SNAPSHOT_EXEC_LOAD_AS_FUNCTION - load snapshot as function instead of executing it + - JERRY_SNAPSHOT_EXEC_HAS_RESOURCE - resource_name_p and resource_name_length fields are valid + in [jerry_exec_snapshot_option_values_t](#jerry_exec_snapshot_option_values_t) + - JERRY_SNAPSHOT_EXEC_HAS_USER_VALUE - user_value field is valid + in [jerry_exec_snapshot_option_values_t](#jerry_exec_snapshot_option_values_t) *Changed in version [[NEXT_RELEASE]]*: The `JERRY_SNAPSHOT_EXEC_LOAD_AS_FUNCTION` value is added, which replaces the `jerry_load_function_snapshot` function. @@ -536,6 +541,8 @@ typedef struct * if JERRY_PARSE_HAS_RESOURCE is set in options */ uint32_t start_line; /**< start line of the source code if JERRY_PARSE_HAS_START is set in options */ uint32_t start_column; /**< start column of the source code if JERRY_PARSE_HAS_START is set in options */ + jerry_value_t user_value; /**< user value assigned to all functions created by this script including eval + * calls executed by the script if JERRY_PARSE_HAS_USER_VALUE is set in options */ } jerry_parse_options_t; ``` @@ -547,6 +554,7 @@ typedef struct - [jerry_parse_function](#jerry_parse_function) - [jerry_generate_snapshot](#jerry_generate_snapshot) - [jerry_generate_function_snapshot](#jerry_generate_function_snapshot) +- [jerry_exec_snapshot](#jerry_exec_snapshot) - [jerry_parse_option_enable_feature_t](#jerry_parse_option_enable_feature_t) ## jerry_property_descriptor_t @@ -1231,6 +1239,33 @@ TypedArray support is not in the engine. - [jerry_get_typedarray_type](#jerry_get_typedarray_type) +## jerry_exec_snapshot_option_values_t + +**Summary** + +Various configuration options for [jerry_exec_snapshot](#jerry_exec_snapshot) + +**Prototype** + +```c +typedef struct +{ + const jerry_char_t *resource_name_p; /**< resource name (usually a file name) + * if JERRY_SNAPSHOT_EXEC_HAS_RESOURCE is set in exec_snapshot_opts */ + size_t resource_name_length; /**< length of resource name + * if JERRY_SNAPSHOT_EXEC_HAS_RESOURCE is set in exec_snapshot_opts */ + jerry_value_t user_value; /**< user value assigned to all functions created by this script including + * eval calls executed by the script if JERRY_SNAPSHOT_EXEC_HAS_USER_VALUE + * is set in exec_snapshot_opts */ +} jerry_exec_snapshot_option_values_t; +``` + +*New in version [[NEXT_RELEASE]]*. + +**See also** + +- [jerry_exec_snapshot](#jerry_exec_snapshot) + # General engine functions ## jerry_init @@ -10221,19 +10256,24 @@ jerry_value_t jerry_exec_snapshot (const uint32_t *snapshot_p, size_t snapshot_size, size_t func_index, - uint32_t exec_snapshot_opts); + uint32_t exec_snapshot_opts, + const jerry_exec_snapshot_option_values_t *options_values_p); ``` - `snapshot_p` - pointer to snapshot. - `snapshot_size` - size of snapshot in bytes. - `func_index` - index of executed function. - `exec_snapshot_opts` - any combination of [jerry_exec_snapshot_opts_t](#jerry_exec_snapshot_opts_t) flags. +- `options_values_p` - additional loadig options, can be NULL if not used. The fields are described in + [jerry_exec_snapshot_option_values_t](#jerry_exec_snapshot_option_values_t). - return value - result of bytecode, if run was successful. - thrown error, otherwise (an error is reported if the snapshot execution feature is not enabled). *Changed in version 2.0*: Added `func_index` and `exec_snapshot_opts` arguments. Removed the `copy_bytecode` last argument. +*Changed in version [[NEXT_RELEASE]]*: Added `options_p` argument. + **Example 1** [doctest]: # () @@ -10269,7 +10309,8 @@ main (void) jerry_value_t res = jerry_exec_snapshot (snapshot_buffer, snapshot_size, 0, - 0); + 0, + NULL); /* 'res' now contains 'string from snapshot' */ jerry_release_value (res); @@ -10317,7 +10358,8 @@ main (void) jerry_value_t func = jerry_exec_snapshot (snapshot_buffer, snapshot_size, 0, - JERRY_SNAPSHOT_EXEC_LOAD_AS_FUNCTION); + JERRY_SNAPSHOT_EXEC_LOAD_AS_FUNCTION, + NULL); /* 'func' can be used now as a function object. */ jerry_value_t this_value = jerry_create_undefined (); @@ -11141,6 +11183,74 @@ main (void) - [jerry_create_external_function](#jerry_create_external_function) +## jerry_get_user_value + +**Summary** + +Returns the user value assigned to a script / module / function. This value is +set by the parser when the JERRY_PARSE_HAS_USER_VALUE flag is set in the `options` +member of the [jerry_parse_options_t](#jerry_parse_options_t) structure. + +*Notes*: +- Returned value must be freed with [jerry_release_value](#jerry_release_value) when it +is no longer needed. + +**Prototype** + +```c +jerry_value_t +jerry_get_user_value (const jerry_value_t value); +``` +- `value` - script / module / function value which executes JavaScript + code (native modules / functions do not have user value). +- return + - user value - if available, + - undefined - otherwise + +*New in version [[NEXT_RELEASE]]*. + +**Example** + +```c +#include "jerryscript.h" + +int +main (void) +{ + jerry_init (JERRY_INIT_EMPTY); + + const jerry_char_t script[] = "function abc() {} abc"; + + jerry_value user_value = jerry_create_object (); + + jerry_parse_options_t parse_options; + parse_options.options = ECMA_PARSE_HAS_USER_VALUE; + parse_options.user_value = user_value; + + jerry_value_t parsed_code = jerry_parse (script, sizeof (script) - 1, &parse_options); + jerry_release_value (user_value); + + /* The jerry_get_user_value returns the object which + * was created by jerry_create_object before. */ + + jerry_value user_value = jerry_get_user_value (parsed_code); + jerry_release_value (parsed_code); + + jerry_release_value (user_value); + jerry_cleanup (); + return 0; +} +``` + +**See also** + +- [jerry_parse](#jerry_parse) +- [jerry_parse_function](#jerry_parse_function) +- [jerry_generate_snapshot](#jerry_generate_snapshot) +- [jerry_generate_function_snapshot](#jerry_generate_function_snapshot) +- [jerry_exec_snapshot](#jerry_exec_snapshot) + + # Functions for realm objects These APIs all depend on build option (`JERRY_BUILTIN_REALMS`). diff --git a/jerry-core/api/jerry-snapshot.c b/jerry-core/api/jerry-snapshot.c index 244712fe..52450593 100644 --- a/jerry-core/api/jerry-snapshot.c +++ b/jerry-core/api/jerry-snapshot.c @@ -50,9 +50,6 @@ snapshot_get_global_flags (bool has_regex, /**< regex literal is present */ #if JERRY_ESNEXT flags |= (has_class ? JERRY_SNAPSHOT_HAS_CLASS_LITERAL : 0); #endif /* JERRY_ESNEXT */ -#if JERRY_BUILTIN_REALMS - flags |= JERRY_SNAPSHOT_HAS_REALM_VALUE; -#endif /* JERRY_BUILTIN_REALMS */ return flags; } /* snapshot_get_global_flags */ @@ -71,9 +68,6 @@ snapshot_check_global_flags (uint32_t global_flags) /**< global flags */ #if JERRY_ESNEXT global_flags &= (uint32_t) ~JERRY_SNAPSHOT_HAS_CLASS_LITERAL; #endif /* JERRY_ESNEXT */ -#if JERRY_BUILTIN_REALMS - global_flags |= JERRY_SNAPSHOT_HAS_REALM_VALUE; -#endif /* JERRY_BUILTIN_REALMS */ return global_flags == snapshot_get_global_flags (false, false); } /* snapshot_check_global_flags */ @@ -395,9 +389,7 @@ static_snapshot_add_compiled_code (ecma_compiled_code_t *compiled_code_p, /**< c literal_end = (uint32_t) (args_p->literal_end - args_p->register_end); const_literal_end = (uint32_t) (args_p->const_literal_end - args_p->register_end); -#if JERRY_BUILTIN_REALMS - args_p->realm_value = JMEM_CP_NULL; -#endif /* JERRY_BUILTIN_REALMS */ + args_p->script_value = JMEM_CP_NULL; } else { @@ -407,9 +399,7 @@ static_snapshot_add_compiled_code (ecma_compiled_code_t *compiled_code_p, /**< c literal_end = (uint32_t) (args_p->literal_end - args_p->register_end); const_literal_end = (uint32_t) (args_p->const_literal_end - args_p->register_end); -#if JERRY_BUILTIN_REALMS - args_p->realm_value = JMEM_CP_NULL; -#endif /* JERRY_BUILTIN_REALMS */ + args_p->script_value = JMEM_CP_NULL; } for (uint32_t i = 0; i < const_literal_end; i++) @@ -569,6 +559,7 @@ static ecma_compiled_code_t * snapshot_load_compiled_code (const uint8_t *base_addr_p, /**< base address of the * current primary function */ const uint8_t *literal_base_p, /**< literal start */ + cbc_script_t *script_p, /**< script */ bool copy_bytecode) /**< byte code should be copied to memory */ { ecma_compiled_code_t *bytecode_p = (ecma_compiled_code_t *) base_addr_p; @@ -598,6 +589,14 @@ snapshot_load_compiled_code (const uint8_t *base_addr_p, /**< base address of th uint32_t const_literal_end; uint32_t literal_end; + if (JERRY_UNLIKELY (script_p->refs_and_type >= CBC_SCRIPT_REF_MAX)) + { + /* This is probably never happens in practice. */ + jerry_fatal (ERR_REF_COUNT_LIMIT); + } + + script_p->refs_and_type += CBC_SCRIPT_REF_ONE; + if (bytecode_p->status_flags & CBC_CODE_FLAGS_UINT16_ARGUMENTS) { uint8_t *byte_p = (uint8_t *) bytecode_p; @@ -608,9 +607,7 @@ snapshot_load_compiled_code (const uint8_t *base_addr_p, /**< base address of th literal_end = (uint32_t) (args_p->literal_end - args_p->register_end); header_size = sizeof (cbc_uint16_arguments_t); -#if JERRY_BUILTIN_REALMS - ECMA_SET_INTERNAL_VALUE_POINTER (args_p->realm_value, ecma_builtin_get_global ()); -#endif /* JERRY_BUILTIN_REALMS */ + ECMA_SET_INTERNAL_VALUE_POINTER (args_p->script_value, script_p); } else { @@ -622,9 +619,7 @@ snapshot_load_compiled_code (const uint8_t *base_addr_p, /**< base address of th literal_end = (uint32_t) (args_p->literal_end - args_p->register_end); header_size = sizeof (cbc_uint8_arguments_t); -#if JERRY_BUILTIN_REALMS - ECMA_SET_INTERNAL_VALUE_POINTER (args_p->realm_value, ecma_builtin_get_global ()); -#endif /* JERRY_BUILTIN_REALMS */ + ECMA_SET_INTERNAL_VALUE_POINTER (args_p->script_value, script_p); } if (copy_bytecode @@ -729,6 +724,7 @@ snapshot_load_compiled_code (const uint8_t *base_addr_p, /**< base address of th ecma_compiled_code_t *literal_bytecode_p; literal_bytecode_p = snapshot_load_compiled_code (base_addr_p + literal_offset, literal_base_p, + script_p, copy_bytecode); ECMA_SET_INTERNAL_VALUE_POINTER (literal_start_p[i], @@ -930,14 +926,18 @@ jerry_value_t jerry_exec_snapshot (const uint32_t *snapshot_p, /**< snapshot */ size_t snapshot_size, /**< size of snapshot */ size_t func_index, /**< index of primary function */ - uint32_t exec_snapshot_opts) /**< jerry_exec_snapshot_opts_t option bits */ + uint32_t exec_snapshot_opts, /**< jerry_exec_snapshot_opts_t option bits */ + const jerry_exec_snapshot_option_values_t *option_values_p) /**< additional option values, + * can be NULL if not used */ { #if JERRY_SNAPSHOT_EXEC JERRY_ASSERT (snapshot_p != NULL); uint32_t allowed_opts = (JERRY_SNAPSHOT_EXEC_COPY_DATA | JERRY_SNAPSHOT_EXEC_ALLOW_STATIC - | JERRY_SNAPSHOT_EXEC_LOAD_AS_FUNCTION); + | JERRY_SNAPSHOT_EXEC_LOAD_AS_FUNCTION + | JERRY_SNAPSHOT_EXEC_HAS_RESOURCE + | JERRY_SNAPSHOT_EXEC_HAS_USER_VALUE); if ((exec_snapshot_opts & ~(allowed_opts)) != 0) { @@ -998,16 +998,58 @@ jerry_exec_snapshot (const uint32_t *snapshot_p, /**< snapshot */ } else { + ecma_value_t user_value = ECMA_VALUE_EMPTY; + + if ((exec_snapshot_opts & JERRY_SNAPSHOT_EXEC_HAS_USER_VALUE) + && option_values_p != NULL) + { + user_value = option_values_p->user_value; + } + + uint32_t script_size = (user_value != ECMA_VALUE_EMPTY ? sizeof (cbc_script_user_t) + : sizeof (cbc_script_t)); + cbc_script_t *script_p = jmem_heap_alloc_block (script_size); + + CBC_SCRIPT_SET_TYPE (script_p, user_value, CBC_SCRIPT_REF_ONE); + +#if JERRY_BUILTIN_REALMS + script_p->realm_p = (ecma_object_t *) JERRY_CONTEXT (global_object_p); +#endif /* JERRY_BUILTIN_REALMS */ + +#if JERRY_RESOURCE_NAME + ecma_value_t resource_name = ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_ANON); + + if ((exec_snapshot_opts & JERRY_SNAPSHOT_EXEC_HAS_RESOURCE) + && option_values_p != NULL + && option_values_p->resource_name_length > 0) + { + resource_name = ecma_find_or_create_literal_string (option_values_p->resource_name_p, + (lit_utf8_size_t) option_values_p->resource_name_length); + } + + script_p->resource_name = resource_name; +#endif /* JERRY_RESOURCE_NAME */ + const uint8_t *literal_base_p = snapshot_data_p + header_p->lit_table_offset; bytecode_p = snapshot_load_compiled_code ((const uint8_t *) bytecode_p, literal_base_p, + script_p, (exec_snapshot_opts & JERRY_SNAPSHOT_EXEC_COPY_DATA) != 0); if (bytecode_p == NULL) { + JERRY_ASSERT (script_p->refs_and_type >= CBC_SCRIPT_REF_ONE); + jmem_heap_free_block (script_p, script_size); return ecma_raise_type_error (invalid_format_error_p); } + + script_p->refs_and_type -= CBC_SCRIPT_REF_ONE; + + if (user_value != ECMA_VALUE_EMPTY) + { + ((cbc_script_user_t *) script_p)->user_value = ecma_copy_value_if_not_object (user_value); + } } #if JERRY_PARSER_DUMP_BYTE_CODE @@ -1063,6 +1105,7 @@ jerry_exec_snapshot (const uint32_t *snapshot_p, /**< snapshot */ JERRY_UNUSED (snapshot_size); JERRY_UNUSED (func_index); JERRY_UNUSED (exec_snapshot_opts); + JERRY_UNUSED (option_values_p); return jerry_create_error (JERRY_ERROR_COMMON, (const jerry_char_t *) "Snapshot execution is not supported"); #endif /* JERRY_SNAPSHOT_EXEC */ diff --git a/jerry-core/api/jerry-snapshot.h b/jerry-core/api/jerry-snapshot.h index e8997eec..94d09178 100644 --- a/jerry-core/api/jerry-snapshot.h +++ b/jerry-core/api/jerry-snapshot.h @@ -45,8 +45,7 @@ typedef enum { /* 8 bits are reserved for dynamic features */ JERRY_SNAPSHOT_HAS_REGEX_LITERAL = (1u << 0), /**< byte code has regex literal */ - JERRY_SNAPSHOT_HAS_REALM_VALUE = (1u << 1), /**< byte code has realm value */ - JERRY_SNAPSHOT_HAS_CLASS_LITERAL = (1u << 2), /**< byte code has class literal */ + JERRY_SNAPSHOT_HAS_CLASS_LITERAL = (1u << 1), /**< byte code has class literal */ /* 24 bits are reserved for compile time features */ JERRY_SNAPSHOT_FOUR_BYTE_CPOINTER = (1u << 8) /**< deprecated, an unused placeholder now */ } jerry_snapshot_global_flags_t; diff --git a/jerry-core/api/jerry.c b/jerry-core/api/jerry.c index a81712df..4f6e7ec3 100644 --- a/jerry-core/api/jerry.c +++ b/jerry-core/api/jerry.c @@ -393,7 +393,8 @@ jerry_parse (const jerry_char_t *source_p, /**< script source */ uint32_t allowed_parse_options = (JERRY_PARSE_STRICT_MODE | JERRY_PARSE_MODULE | JERRY_PARSE_HAS_RESOURCE - | JERRY_PARSE_HAS_START); + | JERRY_PARSE_HAS_START + | JERRY_PARSE_HAS_USER_VALUE); if (options_p != NULL && (options_p->options & ~allowed_parse_options) != 0) { @@ -493,7 +494,8 @@ jerry_parse_function (const jerry_char_t *arg_list_p, /**< script source */ uint32_t allowed_parse_options = (JERRY_PARSE_STRICT_MODE | JERRY_PARSE_HAS_RESOURCE - | JERRY_PARSE_HAS_START); + | JERRY_PARSE_HAS_START + | JERRY_PARSE_HAS_USER_VALUE); if (options_p != NULL && (options_p->options & ~allowed_parse_options) != 0) { @@ -5381,6 +5383,36 @@ jerry_get_resource_name (const jerry_value_t value) /**< jerry api value */ return ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_ANON); } /* jerry_get_resource_name */ +/** + * Returns the user value assigned to a script / module / function. + * + * Note: + * This value is usually set by the parser when + * the JERRY_PARSE_HAS_USER_VALUE flag is passed. + * + * @return user value + */ +jerry_value_t +jerry_get_user_value (const jerry_value_t value) /**< jerry api value */ +{ + const ecma_compiled_code_t *bytecode_p = ecma_bytecode_get_from_value (value); + + if (bytecode_p == NULL) + { + return ECMA_VALUE_UNDEFINED; + } + + ecma_value_t script_value = ((cbc_uint8_arguments_t *) bytecode_p)->script_value; + cbc_script_t *script_p = ECMA_GET_INTERNAL_VALUE_POINTER (cbc_script_t, script_value); + + if (CBC_SCRIPT_GET_TYPE (script_p) == CBC_SCRIPT_GENERIC) + { + return ECMA_VALUE_UNDEFINED; + } + + return ecma_copy_value (((cbc_script_user_t *) script_p)->user_value); +} /* jerry_get_user_value */ + /** * Replaces the currently active realm with another realm. * diff --git a/jerry-core/ecma/base/ecma-gc.c b/jerry-core/ecma/base/ecma-gc.c index d9376213..75920cc0 100644 --- a/jerry-core/ecma/base/ecma-gc.c +++ b/jerry-core/ecma/base/ecma-gc.c @@ -1068,9 +1068,7 @@ ecma_gc_mark (ecma_object_t *object_p) /**< object to mark from */ ecma_gc_set_object_visited (ECMA_GET_NON_NULL_POINTER_FROM_POINTER_TAG (ecma_object_t, ext_func_p->u.function.scope_cp)); -#if JERRY_ESNEXT || JERRY_BUILTIN_REALMS const ecma_compiled_code_t *byte_code_p = ecma_op_function_get_compiled_code (ext_func_p); -#endif /* JERRY_ESNEXT || JERRY_BUILTIN_REALMS */ #if JERRY_ESNEXT if (CBC_FUNCTION_IS_ARROW (byte_code_p->status_flags)) @@ -1089,29 +1087,27 @@ ecma_gc_mark (ecma_object_t *object_p) /**< object to mark from */ } #endif /* JERRY_ESNEXT */ -#if JERRY_BUILTIN_REALMS #if JERRY_SNAPSHOT_EXEC - if (ext_func_p->u.function.bytecode_cp == JMEM_CP_NULL) + if (JERRY_UNLIKELY (byte_code_p->status_flags & CBC_CODE_FLAGS_STATIC_FUNCTION)) { /* Static snapshot functions have a global realm */ break; } #endif /* JERRY_SNAPSHOT_EXEC */ - ecma_object_t *realm_p; + ecma_value_t script_value = ((cbc_uint8_arguments_t *) byte_code_p)->script_value; + cbc_script_t *script_p = ECMA_GET_INTERNAL_VALUE_POINTER (cbc_script_t, script_value); - if (byte_code_p->status_flags & CBC_CODE_FLAGS_UINT16_ARGUMENTS) + if (CBC_SCRIPT_GET_TYPE (script_p) == CBC_SCRIPT_USER_OBJECT) { - cbc_uint16_arguments_t *args_p = (cbc_uint16_arguments_t *) byte_code_p; - realm_p = ECMA_GET_INTERNAL_VALUE_POINTER (ecma_object_t, args_p->realm_value); - } - else - { - cbc_uint8_arguments_t *args_p = (cbc_uint8_arguments_t *) byte_code_p; - realm_p = ECMA_GET_INTERNAL_VALUE_POINTER (ecma_object_t, args_p->realm_value); + cbc_script_user_t *script_user_p = (cbc_script_user_t *) script_p; + + JERRY_ASSERT (ecma_is_value_object (script_user_p->user_value)); + ecma_gc_set_object_visited (ecma_get_object_from_value (script_user_p->user_value)); } - ecma_gc_set_object_visited (realm_p); +#if JERRY_BUILTIN_REALMS + ecma_gc_set_object_visited (script_p->realm_p); #endif /* JERRY_BUILTIN_REALMS */ break; } diff --git a/jerry-core/ecma/base/ecma-helpers.c b/jerry-core/ecma/base/ecma-helpers.c index cc838fd9..0fc6e0c4 100644 --- a/jerry-core/ecma/base/ecma-helpers.c +++ b/jerry-core/ecma/base/ecma-helpers.c @@ -15,6 +15,7 @@ #include "ecma-alloc.h" #include "ecma-array-object.h" +#include "ecma-function-object.h" #include "ecma-gc.h" #include "ecma-globals.h" #include "ecma-helpers.h" @@ -1514,6 +1515,32 @@ ecma_bytecode_deref (ecma_compiled_code_t *bytecode_p) /**< byte code pointer */ } } + ecma_value_t script_value = ((cbc_uint8_arguments_t *) bytecode_p)->script_value; + cbc_script_t *script_p = ECMA_GET_INTERNAL_VALUE_POINTER (cbc_script_t, script_value); + script_p->refs_and_type -= CBC_SCRIPT_REF_ONE; + + if (script_p->refs_and_type < CBC_SCRIPT_REF_ONE) + { + size_t script_size = sizeof (cbc_script_t); + + uint32_t type = CBC_SCRIPT_GET_TYPE (script_p); + + if (type != CBC_SCRIPT_GENERIC) + { + script_size = sizeof (cbc_script_user_t); + + if (type == CBC_SCRIPT_USER_VALUE) + { + cbc_script_user_t *script_user_p = (cbc_script_user_t *) script_p; + + JERRY_ASSERT (!ecma_is_value_object (script_user_p->user_value)); + ecma_free_value (script_user_p->user_value); + } + } + + jmem_heap_free_block (script_p, script_size); + } + #if JERRY_ESNEXT if (bytecode_p->status_flags & CBC_CODE_FLAGS_HAS_TAGGED_LITERALS) { @@ -1584,6 +1611,72 @@ ecma_bytecode_deref (ecma_compiled_code_t *bytecode_p) /**< byte code pointer */ ((size_t) bytecode_p->size) << JMEM_ALIGNMENT_LOG); } /* ecma_bytecode_deref */ +/** + * Gets the byte code asigned to a script / module / function + * + * @return byte code - if available, NULL - otherwise + */ +const ecma_compiled_code_t * +ecma_bytecode_get_from_value (ecma_value_t value) /**< compiled code */ +{ + if (!ecma_is_value_object (value)) + { + return NULL; + } + + ecma_object_t *object_p = ecma_get_object_from_value (value); + + while (true) + { + switch (ecma_get_object_type (object_p)) + { + case ECMA_OBJECT_TYPE_CLASS: + { + ecma_extended_object_t *ext_object_p = (ecma_extended_object_t *) object_p; + + if (ext_object_p->u.cls.type == ECMA_OBJECT_CLASS_SCRIPT) + { + return ECMA_GET_INTERNAL_VALUE_POINTER (ecma_compiled_code_t, + ext_object_p->u.cls.u3.value); + } + +#if JERRY_MODULE_SYSTEM + if (ext_object_p->u.cls.type == ECMA_OBJECT_CLASS_MODULE) + { + ecma_module_t *module_p = (ecma_module_t *) object_p; + + if (!(module_p->header.u.cls.u2.module_flags & ECMA_MODULE_IS_NATIVE)) + { + return module_p->u.compiled_code_p; + } + } +#endif /* JERRY_MODULE_SYSTEM */ + return NULL; + } + case ECMA_OBJECT_TYPE_FUNCTION: + { + if (!ecma_get_object_is_builtin (object_p)) + { + return ecma_op_function_get_compiled_code ((ecma_extended_object_t *) object_p); + } + return NULL; + } + case ECMA_OBJECT_TYPE_BOUND_FUNCTION: + { + ecma_extended_object_t *ext_object_p = (ecma_extended_object_t *) object_p; + + object_p = ECMA_GET_NON_NULL_POINTER_FROM_POINTER_TAG (ecma_object_t, + ext_object_p->u.bound_function.target_function); + break; + } + default: + { + return NULL; + } + } + } +} /* ecma_bytecode_get_from_value */ + /** * Resolve the position of the arguments list start of the compiled code * @@ -1711,16 +1804,15 @@ ecma_value_t ecma_get_resource_name (const ecma_compiled_code_t *bytecode_p) /**< compiled code */ { #if JERRY_RESOURCE_NAME - if (bytecode_p->status_flags & CBC_CODE_FLAGS_UINT16_ARGUMENTS) +#if JERRY_SNAPSHOT_EXEC + if (JERRY_UNLIKELY (bytecode_p->status_flags & CBC_CODE_FLAGS_STATIC_FUNCTION)) { - cbc_uint16_arguments_t *args_p = (cbc_uint16_arguments_t *) bytecode_p; - ecma_value_t *lit_pool_p = (ecma_value_t *) ((uint8_t *) bytecode_p + sizeof (cbc_uint16_arguments_t)); - return lit_pool_p[args_p->const_literal_end - args_p->register_end - 1]; + return ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_ANON); } +#endif /* JERRY_SNAPSHOT_EXEC */ - cbc_uint8_arguments_t *args_p = (cbc_uint8_arguments_t *) bytecode_p; - ecma_value_t *lit_pool_p = (ecma_value_t *) ((uint8_t *) bytecode_p + sizeof (cbc_uint8_arguments_t)); - return lit_pool_p[args_p->const_literal_end - args_p->register_end - 1]; + ecma_value_t script_value = ((cbc_uint8_arguments_t *) bytecode_p)->script_value; + return ECMA_GET_INTERNAL_VALUE_POINTER (cbc_script_t, script_value)->resource_name; #else /* !JERRY_RESOURCE_NAME */ JERRY_UNUSED (bytecode_p); return ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_ANON); diff --git a/jerry-core/ecma/base/ecma-helpers.h b/jerry-core/ecma/base/ecma-helpers.h index 1ac80442..f7ac1e62 100644 --- a/jerry-core/ecma/base/ecma-helpers.h +++ b/jerry-core/ecma/base/ecma-helpers.h @@ -532,6 +532,7 @@ void ecma_raise_error_from_error_reference (ecma_value_t value); void ecma_bytecode_ref (ecma_compiled_code_t *bytecode_p); void ecma_bytecode_deref (ecma_compiled_code_t *bytecode_p); +const ecma_compiled_code_t *ecma_bytecode_get_from_value (ecma_value_t value); ecma_value_t *ecma_compiled_code_resolve_arguments_start (const ecma_compiled_code_t *bytecode_header_p); #if JERRY_ESNEXT ecma_value_t *ecma_compiled_code_resolve_function_name (const ecma_compiled_code_t *bytecode_header_p); diff --git a/jerry-core/ecma/operations/ecma-function-object.c b/jerry-core/ecma/operations/ecma-function-object.c index 92a4ee9b..1890605a 100644 --- a/jerry-core/ecma/operations/ecma-function-object.c +++ b/jerry-core/ecma/operations/ecma-function-object.c @@ -759,29 +759,17 @@ ecma_op_function_get_compiled_code (ecma_extended_object_t *function_p) /**< fun extern inline ecma_global_object_t * JERRY_ATTR_ALWAYS_INLINE ecma_op_function_get_realm (const ecma_compiled_code_t *bytecode_header_p) /**< byte code header */ { - ecma_value_t realm_value; - - if (bytecode_header_p->status_flags & CBC_CODE_FLAGS_UINT16_ARGUMENTS) - { - cbc_uint16_arguments_t *args_p = (cbc_uint16_arguments_t *) bytecode_header_p; - realm_value = args_p->realm_value; - } - else - { - cbc_uint8_arguments_t *args_p = (cbc_uint8_arguments_t *) bytecode_header_p; - realm_value = args_p->realm_value; - } - #if JERRY_SNAPSHOT_EXEC - if (JERRY_LIKELY (realm_value != JMEM_CP_NULL)) + if (JERRY_UNLIKELY (bytecode_header_p->status_flags & CBC_CODE_FLAGS_STATIC_FUNCTION)) { - return ECMA_GET_INTERNAL_VALUE_POINTER (ecma_global_object_t, realm_value); + return (ecma_global_object_t *) ecma_builtin_get_global (); } - - return (ecma_global_object_t *) ecma_builtin_get_global (); -#else /* !JERRY_SNAPSHOT_EXEC */ - return ECMA_GET_INTERNAL_VALUE_POINTER (ecma_global_object_t, realm_value); #endif /* JERRY_SNAPSHOT_EXEC */ + + ecma_value_t script_value = ((cbc_uint8_arguments_t *) bytecode_header_p)->script_value; + cbc_script_t *script_p = ECMA_GET_INTERNAL_VALUE_POINTER (cbc_script_t, script_value); + + return (ecma_global_object_t *) script_p->realm_p; } /* ecma_op_function_get_realm */ /** diff --git a/jerry-core/include/jerryscript-core.h b/jerry-core/include/jerryscript-core.h index 96034a56..c908855d 100644 --- a/jerry-core/include/jerryscript-core.h +++ b/jerry-core/include/jerryscript-core.h @@ -360,6 +360,7 @@ bool jerry_backtrace_is_strict (jerry_backtrace_frame_t *frame_p); */ void jerry_set_vm_exec_stop_callback (jerry_vm_exec_stop_callback_t stop_cb, void *user_p, uint32_t frequency); jerry_value_t jerry_get_resource_name (const jerry_value_t value); +jerry_value_t jerry_get_user_value (const jerry_value_t value); /** * Array buffer components. diff --git a/jerry-core/include/jerryscript-snapshot.h b/jerry-core/include/jerryscript-snapshot.h index c984ce54..9546c945 100644 --- a/jerry-core/include/jerryscript-snapshot.h +++ b/jerry-core/include/jerryscript-snapshot.h @@ -41,15 +41,33 @@ typedef enum } jerry_generate_snapshot_opts_t; /** - * Flags for jerry_exec_snapshot_at and jerry_load_function_snapshot_at. + * Flags for jerry_exec_snapshot. */ typedef enum { JERRY_SNAPSHOT_EXEC_COPY_DATA = (1u << 0), /**< copy snashot data */ JERRY_SNAPSHOT_EXEC_ALLOW_STATIC = (1u << 1), /**< static snapshots allowed */ JERRY_SNAPSHOT_EXEC_LOAD_AS_FUNCTION = (1u << 2), /**< load snapshot as function instead of executing it */ + JERRY_SNAPSHOT_EXEC_HAS_RESOURCE = (1u << 3), /**< resource_name_p and resource_name_length fields are valid + * in jerry_exec_snapshot_option_values_t */ + JERRY_SNAPSHOT_EXEC_HAS_USER_VALUE = (1u << 4), /**< user_value field is valid + * in jerry_exec_snapshot_option_values_t */ } jerry_exec_snapshot_opts_t; +/** + * Various configuration options for jerry_exec_snapshot. + */ +typedef struct +{ + const jerry_char_t *resource_name_p; /**< resource name (usually a file name) + * if JERRY_SNAPSHOT_EXEC_HAS_RESOURCE is set in exec_snapshot_opts */ + size_t resource_name_length; /**< length of resource name + * if JERRY_SNAPSHOT_EXEC_HAS_RESOURCE is set in exec_snapshot_opts */ + jerry_value_t user_value; /**< user value assigned to all functions created by this script including + * eval calls executed by the script if JERRY_SNAPSHOT_EXEC_HAS_USER_VALUE + * is set in exec_snapshot_opts */ +} jerry_exec_snapshot_option_values_t; + /** * Snapshot functions. */ @@ -63,7 +81,8 @@ jerry_value_t jerry_generate_function_snapshot (const jerry_char_t *source_p, si uint32_t *buffer_p, size_t buffer_size); jerry_value_t jerry_exec_snapshot (const uint32_t *snapshot_p, size_t snapshot_size, - size_t func_index, uint32_t exec_snapshot_opts); + size_t func_index, uint32_t exec_snapshot_opts, + const jerry_exec_snapshot_option_values_t *options_values_p); size_t jerry_merge_snapshots (const uint32_t **inp_buffers_p, size_t *inp_buffer_sizes_p, size_t number_of_snapshots, uint32_t *out_buffer_p, size_t out_buffer_size, const char **error_p); diff --git a/jerry-core/include/jerryscript-types.h b/jerry-core/include/jerryscript-types.h index 7733a613..31f23df6 100644 --- a/jerry-core/include/jerryscript-types.h +++ b/jerry-core/include/jerryscript-types.h @@ -168,6 +168,7 @@ typedef enum JERRY_PARSE_MODULE = (1 << 1), /**< parse source as an ECMAScript module */ JERRY_PARSE_HAS_RESOURCE = (1 << 2), /**< resource_name_p and resource_name_length fields are valid */ JERRY_PARSE_HAS_START = (1 << 3), /**< start_line and start_column fields are valid */ + JERRY_PARSE_HAS_USER_VALUE = (1 << 4), /**< user_value field is valid */ } jerry_parse_option_enable_feature_t; /** @@ -182,6 +183,8 @@ typedef struct * if JERRY_PARSE_HAS_RESOURCE is set in options */ uint32_t start_line; /**< start line of the source code if JERRY_PARSE_HAS_START is set in options */ uint32_t start_column; /**< start column of the source code if JERRY_PARSE_HAS_START is set in options */ + jerry_value_t user_value; /**< user value assigned to all functions created by this script including eval + * calls executed by the script if JERRY_PARSE_HAS_USER_VALUE is set in options */ } jerry_parse_options_t; /** diff --git a/jerry-core/parser/js/byte-code.c b/jerry-core/parser/js/byte-code.c index 3cff2e62..a8d969ca 100644 --- a/jerry-core/parser/js/byte-code.c +++ b/jerry-core/parser/js/byte-code.c @@ -15,11 +15,15 @@ #include "js-parser-internal.h" -JERRY_STATIC_ASSERT ((sizeof (cbc_uint8_arguments_t) % sizeof (jmem_cpointer_t)) == 0, - sizeof_cbc_uint8_arguments_t_must_be_divisible_by_sizeof_jmem_cpointer_t); +/* These two checks only checks the compiler, they have no effect on the code. */ +JERRY_STATIC_ASSERT (sizeof (cbc_uint8_arguments_t) == 16, + sizeof_cbc_uint8_arguments_t_must_be_16_byte_long); -JERRY_STATIC_ASSERT ((sizeof (cbc_uint16_arguments_t) % sizeof (jmem_cpointer_t)) == 0, - sizeof_cbc_uint16_arguments_t_must_be_divisible_by_sizeof_jmem_cpointer_t); +JERRY_STATIC_ASSERT (sizeof (cbc_uint16_arguments_t) == 24, + sizeof_cbc_uint16_arguments_t_must_be_24_byte_long); + +JERRY_STATIC_ASSERT (offsetof (cbc_uint8_arguments_t, script_value) == offsetof (cbc_uint16_arguments_t, script_value), + script_value_in_cbc_uint8_arguments_and_cbc_uint16_arguments_must_be_in_the_same_offset); /** * The reason of these two static asserts to notify the developer to increase the JERRY_SNAPSHOT_VERSION diff --git a/jerry-core/parser/js/byte-code.h b/jerry-core/parser/js/byte-code.h index d7a64c23..ce7b5080 100644 --- a/jerry-core/parser/js/byte-code.h +++ b/jerry-core/parser/js/byte-code.h @@ -848,13 +848,11 @@ typedef struct ecma_compiled_code_t header; /**< compiled code header */ uint8_t stack_limit; /**< maximum number of values stored on the stack */ uint8_t argument_end; /**< number of arguments expected by the function */ + ecma_value_t script_value; /**< script value */ uint8_t register_end; /**< end position of the register group */ uint8_t ident_end; /**< end position of the identifier group */ uint8_t const_literal_end; /**< end position of the const literal group */ uint8_t literal_end; /**< end position of the literal group */ -#if JERRY_BUILTIN_REALMS - ecma_value_t realm_value; /**< realm value */ -#endif /* JERRY_BUILTIN_REALMS */ } cbc_uint8_arguments_t; /** @@ -864,15 +862,13 @@ typedef struct { ecma_compiled_code_t header; /**< compiled code header */ uint16_t stack_limit; /**< maximum number of values stored on the stack */ + ecma_value_t script_value; /**< script value */ uint16_t argument_end; /**< number of arguments expected by the function */ uint16_t register_end; /**< end position of the register group */ uint16_t ident_end; /**< end position of the identifier group */ uint16_t const_literal_end; /**< end position of the const literal group */ uint16_t literal_end; /**< end position of the literal group */ uint16_t padding; /**< an unused value */ -#if JERRY_BUILTIN_REALMS - ecma_value_t realm_value; /**< realm value */ -#endif /* JERRY_BUILTIN_REALMS */ } cbc_uint16_arguments_t; /** @@ -968,6 +964,69 @@ typedef enum */ #define CBC_EXTENDED_INFO_GET_LENGTH(extended_info) (extended_info) +/** + * Shared script data. + */ +typedef enum +{ + CBC_SCRIPT_GENERIC, /**< script without user specific data */ + CBC_SCRIPT_USER_OBJECT, /**< script with a user object */ + CBC_SCRIPT_USER_VALUE, /**< script with a non-object user value */ +} cbc_script_type; + +/** + * Value for increasing or decreasing the script reference counter. + */ +#define CBC_SCRIPT_REF_ONE 0x4 + +/** + * Get the type of a script. + */ +#define CBC_SCRIPT_GET_TYPE(script_p) ((script_p)->refs_and_type & (CBC_SCRIPT_REF_ONE - 1)) + +/** + * Maximum value of script reference counter. + */ +#define CBC_SCRIPT_REF_MAX (UINT32_MAX - CBC_SCRIPT_REF_ONE + 1) + +/** + * Sets the type of a script using the user_value. + */ +#define CBC_SCRIPT_SET_TYPE(script_p, user_value, ref_count) \ + do \ + { \ + (script_p)->refs_and_type = ((ref_count) | CBC_SCRIPT_GENERIC); \ + if ((user_value) != ECMA_VALUE_EMPTY) \ + { \ + (script_p)->refs_and_type = (ecma_is_value_object (user_value) ? ((ref_count) | CBC_SCRIPT_USER_OBJECT) \ + : ((ref_count) | CBC_SCRIPT_USER_VALUE)); \ + } \ + } \ + while (false) + +/** + * Shared script data. + */ +typedef struct +{ +#if JERRY_BUILTIN_REALMS + ecma_object_t *realm_p; /**< realm object */ +#endif /* JERRY_BUILTIN_REALMS */ + uint32_t refs_and_type; /**< reference counter and type of the function */ +#if JERRY_RESOURCE_NAME + ecma_value_t resource_name; /**< resource name */ +#endif /* JERRY_RESOURCE_NAME */ +} cbc_script_t; + +/** + * Script data with user value. + */ +typedef struct +{ + cbc_script_t header; /**< script header */ + ecma_value_t user_value; /**< user value */ +} cbc_script_user_t; + #define CBC_OPCODE(arg1, arg2, arg3, arg4) arg1, /** diff --git a/jerry-core/parser/js/js-parser-internal.h b/jerry-core/parser/js/js-parser-internal.h index d581a317..d34f81f3 100644 --- a/jerry-core/parser/js/js-parser-internal.h +++ b/jerry-core/parser/js/js-parser-internal.h @@ -563,9 +563,12 @@ typedef struct uint32_t global_status_flags; /**< global status flags */ uint16_t stack_depth; /**< current stack depth */ uint16_t stack_limit; /**< maximum stack depth */ - const jerry_parse_options_t *options_p; /**< parse options */ + const jerry_parse_options_t *options_p; /**< parse options */ parser_saved_context_t *last_context_p; /**< last saved context */ parser_stack_iterator_t last_statement; /**< last statement position */ + cbc_script_t *script_p; /**< current script */ + ecma_value_t script_value; /**< current script as value */ + ecma_value_t user_value; /**< current user value */ #if JERRY_MODULE_SYSTEM ecma_module_names_t *module_names_p; /**< import / export names that is being processed */ @@ -630,10 +633,6 @@ typedef struct parser_line_counter_t last_breakpoint_line; /**< last line where breakpoint has been inserted */ #endif /* JERRY_DEBUGGER */ -#if JERRY_RESOURCE_NAME - ecma_value_t resource_name; /**< resource name */ -#endif /* JERRY_RESOURCE_NAME */ - #if JERRY_LINE_INFO parser_line_info_data_t line_info; /**< line info data */ parser_line_counter_t last_line_info_line; /**< last line where line info has been inserted */ diff --git a/jerry-core/parser/js/js-parser.c b/jerry-core/parser/js/js-parser.c index 5bf3b447..74aab36a 100644 --- a/jerry-core/parser/js/js-parser.c +++ b/jerry-core/parser/js/js-parser.c @@ -62,17 +62,6 @@ parser_compute_indicies (parser_context_t *context_p, /**< context */ uint16_t ident_count = 0; uint16_t const_literal_count = 0; -#if JERRY_RESOURCE_NAME - /* Resource name will be stored as the last const literal. */ - if (JERRY_UNLIKELY (context_p->literal_count >= PARSER_MAXIMUM_NUMBER_OF_LITERALS)) - { - parser_raise_error (context_p, PARSER_ERR_LITERAL_LIMIT_REACHED); - } - - const_literal_count++; - context_p->literal_count++; -#endif /* JERRY_RESOURCE_NAME */ - uint16_t ident_index; uint16_t const_literal_index; uint16_t literal_index; @@ -198,11 +187,6 @@ parser_compute_indicies (parser_context_t *context_p, /**< context */ } } -#if JERRY_RESOURCE_NAME - /* Resource name will be stored as the last const literal. */ - const_literal_index++; -#endif /* JERRY_RESOURCE_NAME */ - JERRY_ASSERT (ident_index == context_p->register_count + ident_count); JERRY_ASSERT (const_literal_index == ident_index + const_literal_count); JERRY_ASSERT (literal_index <= context_p->register_count + context_p->literal_count); @@ -663,6 +647,14 @@ parser_post_processing (parser_context_t *context_p) /**< context */ parser_raise_error (context_p, PARSER_ERR_STACK_LIMIT_REACHED); } + if (JERRY_UNLIKELY (context_p->script_p->refs_and_type >= CBC_SCRIPT_REF_MAX)) + { + /* This is probably never happens in practice. */ + jerry_fatal (ERR_REF_COUNT_LIMIT); + } + + context_p->script_p->refs_and_type += CBC_SCRIPT_REF_ONE; + JERRY_ASSERT (context_p->literal_count <= PARSER_MAXIMUM_NUMBER_OF_LITERALS); #if JERRY_DEBUGGER @@ -963,14 +955,12 @@ parser_post_processing (parser_context_t *context_p) /**< context */ cbc_uint16_arguments_t *args_p = (cbc_uint16_arguments_t *) compiled_code_p; args_p->stack_limit = context_p->stack_limit; + args_p->script_value = context_p->script_value; args_p->argument_end = context_p->argument_count; args_p->register_end = context_p->register_count; args_p->ident_end = ident_end; args_p->const_literal_end = const_literal_end; args_p->literal_end = context_p->literal_count; -#if JERRY_BUILTIN_REALMS - ECMA_SET_INTERNAL_VALUE_POINTER (args_p->realm_value, JERRY_CONTEXT (global_object_p)); -#endif /* JERRY_BUILTIN_REALMS */ compiled_code_p->status_flags |= CBC_CODE_FLAGS_UINT16_ARGUMENTS; byte_code_p += sizeof (cbc_uint16_arguments_t); @@ -981,13 +971,11 @@ parser_post_processing (parser_context_t *context_p) /**< context */ args_p->stack_limit = (uint8_t) context_p->stack_limit; args_p->argument_end = (uint8_t) context_p->argument_count; + args_p->script_value = context_p->script_value; args_p->register_end = (uint8_t) context_p->register_count; args_p->ident_end = (uint8_t) ident_end; args_p->const_literal_end = (uint8_t) const_literal_end; args_p->literal_end = (uint8_t) context_p->literal_count; -#if JERRY_BUILTIN_REALMS - ECMA_SET_INTERNAL_VALUE_POINTER (args_p->realm_value, JERRY_CONTEXT (global_object_p)); -#endif /* JERRY_BUILTIN_REALMS */ byte_code_p += sizeof (cbc_uint8_arguments_t); } @@ -1088,10 +1076,6 @@ parser_post_processing (parser_context_t *context_p) /**< context */ parser_init_literal_pool (context_p, literal_pool_p); -#if JERRY_RESOURCE_NAME - literal_pool_p[const_literal_end - 1] = context_p->resource_name; -#endif /* JERRY_RESOURCE_NAME */ - page_p = context_p->byte_code.first_p; offset = 0; real_offset = 0; @@ -1828,14 +1812,55 @@ parser_parse_source (const uint8_t *arg_list_p, /**< function argument list */ context.token.flags = 0; lexer_init_line_info (&context); -#if JERRY_RESOURCE_NAME - ecma_value_t resource_name = ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_ANON); + context.user_value = ECMA_VALUE_EMPTY; - if (context.global_status_flags & ECMA_PARSE_EVAL) + if ((context.global_status_flags & ECMA_PARSE_EVAL) + && JERRY_CONTEXT (vm_top_context_p) != NULL) { - resource_name = ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_EVAL); + const ecma_compiled_code_t *bytecode_header_p = JERRY_CONTEXT (vm_top_context_p)->shared_p->bytecode_header_p; + +#if JERRY_SNAPSHOT_EXEC + if (JERRY_LIKELY (!(bytecode_header_p->status_flags & CBC_CODE_FLAGS_STATIC_FUNCTION))) + { +#endif /* JERRY_SNAPSHOT_EXEC */ + ecma_value_t parent_script_value = ((cbc_uint8_arguments_t *) bytecode_header_p)->script_value;; + cbc_script_t *parent_script_p = ECMA_GET_INTERNAL_VALUE_POINTER (cbc_script_t, parent_script_value); + + if (CBC_SCRIPT_GET_TYPE (parent_script_p) != CBC_SCRIPT_GENERIC) + { + context.user_value = ((cbc_script_user_t *) parent_script_p)->user_value; + } +#if JERRY_SNAPSHOT_EXEC + } +#endif /* JERRY_SNAPSHOT_EXEC */ + } + else if (context.options_p != NULL + && (context.options_p->options & JERRY_PARSE_HAS_USER_VALUE)) + { + context.user_value = context.options_p->user_value; + } + + uint32_t script_size = (context.user_value != ECMA_VALUE_EMPTY ? sizeof (cbc_script_user_t) + : sizeof (cbc_script_t)); + context.script_p = jmem_heap_alloc_block_null_on_error (script_size); + + if (JERRY_UNLIKELY (context.script_p == NULL)) + { + /* It is unlikely that memory can be allocated in an out-of-memory + * situation. However, a simple value can still be thrown. */ + jcontext_raise_exception (ECMA_VALUE_NULL); + return NULL; } + CBC_SCRIPT_SET_TYPE (context.script_p, context.user_value, CBC_SCRIPT_REF_ONE); + +#if JERRY_BUILTIN_REALMS + context.script_p->realm_p = (ecma_object_t *) JERRY_CONTEXT (global_object_p); +#endif /* JERRY_BUILTIN_REALMS */ + +#if JERRY_RESOURCE_NAME + ecma_value_t resource_name = ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_ANON); + if (context.options_p != NULL && (context.options_p->options & JERRY_PARSE_HAS_RESOURCE) && context.options_p->resource_name_length > 0) @@ -1843,9 +1868,15 @@ parser_parse_source (const uint8_t *arg_list_p, /**< function argument list */ resource_name = ecma_find_or_create_literal_string (context.options_p->resource_name_p, (lit_utf8_size_t) context.options_p->resource_name_length); } + else if (context.global_status_flags & ECMA_PARSE_EVAL) + { + resource_name = ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_EVAL); + } - context.resource_name = resource_name; -#endif /* !JERRY_RESOURCE_NAME */ + context.script_p->resource_name = resource_name; +#endif /* JERRY_RESOURCE_NAME */ + + ECMA_SET_INTERNAL_VALUE_POINTER (context.script_value, context.script_p); scanner_info_t scanner_info_end; scanner_info_end.next_p = NULL; @@ -2030,6 +2061,13 @@ parser_parse_source (const uint8_t *arg_list_p, /**< function argument list */ JERRY_ASSERT (arg_list_p != NULL || !(context.status_flags & PARSER_ARGUMENTS_NEEDED)); + context.script_p->refs_and_type -= CBC_SCRIPT_REF_ONE; + + if (context.user_value != ECMA_VALUE_EMPTY) + { + ((cbc_script_user_t *) context.script_p)->user_value = ecma_copy_value_if_not_object (context.user_value); + } + #if JERRY_PARSER_DUMP_BYTE_CODE if (context.is_show_opcodes) { @@ -2061,6 +2099,9 @@ parser_parse_source (const uint8_t *arg_list_p, /**< function argument list */ compiled_code_p = NULL; parser_free_literals (&context.literal_pool); parser_cbc_stream_free (&context.byte_code); + + JERRY_ASSERT (context.script_p->refs_and_type >= CBC_SCRIPT_REF_ONE); + jmem_heap_free_block (context.script_p, script_size); } PARSER_TRY_END @@ -2130,7 +2171,7 @@ parser_parse_source (const uint8_t *arg_list_p, /**< function argument list */ ecma_raise_standard_error_with_format (JERRY_ERROR_SYNTAX, "% [%:%:%]", err_str_val, - context.resource_name, + resource_name, line_str_val, col_str_val); diff --git a/jerry-core/parser/js/js-parser.h b/jerry-core/parser/js/js-parser.h index 75f269da..ff78834b 100644 --- a/jerry-core/parser/js/js-parser.h +++ b/jerry-core/parser/js/js-parser.h @@ -56,7 +56,7 @@ typedef enum PARSER_ERR_INVALID_NUMBER, /**< invalid number literal */ PARSER_ERR_MISSING_EXPONENT, /**< missing exponent */ PARSER_ERR_IDENTIFIER_AFTER_NUMBER, /**< identifier start after number */ - PARSER_ERR_INVALID_UNDERSCORE_IN_NUMBER, /**< invalid use of underscore in number */ + PARSER_ERR_INVALID_UNDERSCORE_IN_NUMBER, /**< invalid use of underscore in number */ #if JERRY_BUILTIN_BIGINT PARSER_ERR_INVALID_BIGINT, /**< number is not a valid BigInt */ #endif /* JERRY_BUILTIN_BIGINT */ diff --git a/jerry-main/main-jerry.c b/jerry-main/main-jerry.c index e3942ae4..d6359372 100644 --- a/jerry-main/main-jerry.c +++ b/jerry-main/main-jerry.c @@ -137,7 +137,8 @@ restart: ret_value = jerry_exec_snapshot ((uint32_t *) source_p, source_size, source_file_p->snapshot_index, - JERRY_SNAPSHOT_EXEC_COPY_DATA); + JERRY_SNAPSHOT_EXEC_COPY_DATA, + NULL); jerry_port_release_source (source_p); break; diff --git a/tests/unit-core/CMakeLists.txt b/tests/unit-core/CMakeLists.txt index 45b646d5..9511a291 100644 --- a/tests/unit-core/CMakeLists.txt +++ b/tests/unit-core/CMakeLists.txt @@ -77,6 +77,7 @@ set(SOURCE_UNIT_TEST_MAIN_MODULES test-regexp.c test-regression-3588.c test-resource-name.c + test-script-user-value.c test-snapshot.c test-special-proxy.c test-string-to-number.c diff --git a/tests/unit-core/test-script-user-value.c b/tests/unit-core/test-script-user-value.c new file mode 100644 index 00000000..172f8b41 --- /dev/null +++ b/tests/unit-core/test-script-user-value.c @@ -0,0 +1,192 @@ +/* Copyright JS Foundation and other contributors, http://js.foundation + * + * 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 "config.h" +#include "jerryscript.h" + +#include "test-common.h" + +static jerry_value_t user_values[4]; + +#define USER_VALUES_SIZE (sizeof (user_values) / sizeof (jerry_value_t)) + +static void +test_parse (const char *source_p, /**< source code */ + jerry_parse_options_t *options_p, /**< options passed to jerry_parse */ + bool run_code) /**< run the code after parsing */ +{ + for (size_t i = 0; i < USER_VALUES_SIZE; i++) + { + options_p->user_value = user_values[i]; + + jerry_value_t result = jerry_parse ((const jerry_char_t *) source_p, + strlen (source_p), + options_p); + TEST_ASSERT (!jerry_value_is_error (result)); + + if (run_code) + { + jerry_value_t parse_result = result; + result = jerry_run (result); + jerry_release_value (parse_result); + TEST_ASSERT (!jerry_value_is_error (result)); + } + + jerry_value_t user_value = jerry_get_user_value (result); + jerry_value_t compare_value = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, + user_value, + user_values[i]); + + TEST_ASSERT (jerry_value_is_true (compare_value)); + + jerry_release_value (compare_value); + jerry_release_value (user_value); + jerry_release_value (result); + } +} /* test_parse */ + +static void +test_parse_function (const char *source_p, /**< source code */ + jerry_parse_options_t *options_p, /**< options passed to jerry_parse */ + bool run_code) /**< run the code after parsing */ +{ + for (size_t i = 0; i < USER_VALUES_SIZE; i++) + { + options_p->user_value = user_values[i]; + + jerry_value_t result = jerry_parse_function ((const jerry_char_t *) "", + 0, + (const jerry_char_t *) source_p, + strlen (source_p), + options_p); + TEST_ASSERT (!jerry_value_is_error (result)); + + if (run_code) + { + jerry_value_t parse_result = result; + jerry_value_t this_value = jerry_create_undefined (); + result = jerry_call_function (result, this_value, NULL, 0); + jerry_release_value (parse_result); + jerry_release_value (this_value); + TEST_ASSERT (!jerry_value_is_error (result)); + } + + jerry_value_t user_value = jerry_get_user_value (result); + jerry_value_t compare_value = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, + user_value, + user_values[i]); + + TEST_ASSERT (jerry_value_is_true (compare_value)); + + jerry_release_value (compare_value); + jerry_release_value (user_value); + jerry_release_value (result); + } +} /* test_parse_function */ + +int +main (void) +{ + TEST_INIT (); + + jerry_init (JERRY_INIT_EMPTY); + + user_values[0] = jerry_create_object (); + user_values[1] = jerry_create_null (); + user_values[2] = jerry_create_number (5.5); + user_values[3] = jerry_create_string ((const jerry_char_t *) "AnyString..."); + + jerry_parse_options_t parse_options; + const char *source_p = TEST_STRING_LITERAL (""); + + parse_options.options = JERRY_PARSE_HAS_USER_VALUE; + test_parse (source_p, &parse_options, false); + test_parse_function (source_p, &parse_options, false); + + if (jerry_is_feature_enabled (JERRY_FEATURE_MODULE)) + { + parse_options.options = JERRY_PARSE_MODULE | JERRY_PARSE_HAS_USER_VALUE; + test_parse (source_p, &parse_options, false); + } + + source_p = TEST_STRING_LITERAL ("function f() { }\n" + "f"); + parse_options.options = JERRY_PARSE_HAS_USER_VALUE; + test_parse (source_p, &parse_options, true); + + source_p = TEST_STRING_LITERAL ("function f() { return function() {} }\n" + "f()"); + parse_options.options = JERRY_PARSE_HAS_USER_VALUE; + test_parse (source_p, &parse_options, true); + + source_p = TEST_STRING_LITERAL ("return function() {}"); + parse_options.options = JERRY_PARSE_HAS_USER_VALUE; + test_parse_function (source_p, &parse_options, true); + + source_p = TEST_STRING_LITERAL ("eval('function f() {}')\n" + "f"); + parse_options.options = JERRY_PARSE_HAS_USER_VALUE; + test_parse (source_p, &parse_options, true); + + source_p = TEST_STRING_LITERAL ("eval('function f() { return eval(\\'(function () {})\\') }')\n" + "f()"); + parse_options.options = JERRY_PARSE_HAS_USER_VALUE; + test_parse (source_p, &parse_options, true); + + source_p = TEST_STRING_LITERAL ("eval('function f() {}')\n" + "return f"); + parse_options.options = JERRY_PARSE_HAS_USER_VALUE; + test_parse_function (source_p, &parse_options, true); + + source_p = TEST_STRING_LITERAL ("eval('function f() { return eval(\\'(function () {})\\') }')\n" + "return f()"); + parse_options.options = JERRY_PARSE_HAS_USER_VALUE; + test_parse_function (source_p, &parse_options, true); + + source_p = TEST_STRING_LITERAL ("function f() {}\n" + "f.bind(1)"); + parse_options.options = JERRY_PARSE_HAS_USER_VALUE; + test_parse (source_p, &parse_options, true); + + source_p = TEST_STRING_LITERAL ("function f() {}\n" + "f.bind(1).bind(2, 3)"); + parse_options.options = JERRY_PARSE_HAS_USER_VALUE; + test_parse (source_p, &parse_options, true); + + source_p = TEST_STRING_LITERAL ("function f() {}\n" + "return f.bind(1)"); + parse_options.options = JERRY_PARSE_HAS_USER_VALUE; + test_parse_function (source_p, &parse_options, true); + + source_p = TEST_STRING_LITERAL ("function f() {}\n" + "return f.bind(1).bind(2, 3)"); + parse_options.options = JERRY_PARSE_HAS_USER_VALUE; + test_parse_function (source_p, &parse_options, true); + + for (size_t i = 0; i < USER_VALUES_SIZE; i++) + { + jerry_value_t result = jerry_get_user_value (user_values[i]); + TEST_ASSERT (jerry_value_is_undefined (result)); + jerry_release_value (result); + } + + for (size_t i = 0; i < USER_VALUES_SIZE; i++) + { + jerry_release_value (user_values[i]); + } + + jerry_cleanup (); + return 0; +} /* main */ diff --git a/tests/unit-core/test-snapshot.c b/tests/unit-core/test-snapshot.c index 1e628054..bcfe25b0 100644 --- a/tests/unit-core/test-snapshot.c +++ b/tests/unit-core/test-snapshot.c @@ -89,7 +89,8 @@ static void test_function_snapshot (void) jerry_value_t function_obj = jerry_exec_snapshot (function_snapshot_buffer, function_snapshot_size, 0, - JERRY_SNAPSHOT_EXEC_LOAD_AS_FUNCTION); + JERRY_SNAPSHOT_EXEC_LOAD_AS_FUNCTION, + NULL); TEST_ASSERT (!jerry_value_is_error (function_obj)); TEST_ASSERT (jerry_value_is_function (function_obj)); @@ -117,7 +118,7 @@ static void test_function_snapshot (void) static void arguments_test_exec_snapshot (uint32_t *snapshot_p, size_t snapshot_size, uint32_t exec_snapshot_flags) { jerry_init (JERRY_INIT_EMPTY); - jerry_value_t res = jerry_exec_snapshot (snapshot_p, snapshot_size, 0, exec_snapshot_flags); + jerry_value_t res = jerry_exec_snapshot (snapshot_p, snapshot_size, 0, exec_snapshot_flags, NULL); TEST_ASSERT (!jerry_value_is_error (res)); TEST_ASSERT (jerry_value_is_number (res)); double raw_value = jerry_get_number_value (res); @@ -176,7 +177,7 @@ static void test_exec_snapshot (uint32_t *snapshot_p, size_t snapshot_size, uint sizeof (magic_string_lengths) / sizeof (jerry_length_t), magic_string_lengths); - jerry_value_t res = jerry_exec_snapshot (snapshot_p, snapshot_size, 0, exec_snapshot_flags); + jerry_value_t res = jerry_exec_snapshot (snapshot_p, snapshot_size, 0, exec_snapshot_flags, NULL); TEST_ASSERT (!jerry_value_is_error (res)); TEST_ASSERT (jerry_value_is_string (res)); @@ -190,6 +191,76 @@ static void test_exec_snapshot (uint32_t *snapshot_p, size_t snapshot_size, uint jerry_cleanup (); } /* test_exec_snapshot */ +static void test_snapshot_with_user (void) +{ + if (jerry_is_feature_enabled (JERRY_FEATURE_SNAPSHOT_SAVE) + && jerry_is_feature_enabled (JERRY_FEATURE_SNAPSHOT_EXEC)) + { + static uint32_t snapshot_buffer[SNAPSHOT_BUFFER_SIZE]; + + const jerry_char_t code_to_snapshot[] = TEST_STRING_LITERAL ( + "function f() {}\n" + "f" + ); + jerry_init (JERRY_INIT_EMPTY); + + jerry_value_t result = jerry_generate_snapshot (code_to_snapshot, + sizeof (code_to_snapshot) - 1, + NULL, + 0, + snapshot_buffer, + SNAPSHOT_BUFFER_SIZE); + + TEST_ASSERT (!jerry_value_is_error (result) + && jerry_value_is_number (result)); + + size_t snapshot_size = (size_t) jerry_get_number_value (result); + jerry_release_value (result); + + for (int i = 0; i < 3; i++) + { + jerry_exec_snapshot_option_values_t snapshot_exec_options; + + if (i == 0) + { + snapshot_exec_options.user_value = jerry_create_object (); + } + else if (i == 1) + { + snapshot_exec_options.user_value = jerry_create_number (-3.5); + } + else + { + snapshot_exec_options.user_value = jerry_create_string ((const jerry_char_t *) "AnyString..."); + } + + result = jerry_exec_snapshot (snapshot_buffer, + snapshot_size, + 0, + JERRY_SNAPSHOT_EXEC_HAS_USER_VALUE, + &snapshot_exec_options); + + TEST_ASSERT (!jerry_value_is_error (result) + && jerry_value_is_function (result)); + + jerry_value_t user_value = jerry_get_user_value (result); + jerry_release_value (result); + + result = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, + user_value, + snapshot_exec_options.user_value); + + TEST_ASSERT (jerry_value_is_true (result)); + + jerry_release_value (result); + jerry_release_value (user_value); + jerry_release_value (snapshot_exec_options.user_value); + } + + jerry_cleanup (); + } +} /* test_snapshot_with_user */ + int main (void) { @@ -227,7 +298,7 @@ main (void) jerry_release_value (generate_result); /* Static snapshots are not supported by default. */ - jerry_value_t exec_result = jerry_exec_snapshot (snapshot_buffer, snapshot_size, 0, 0); + jerry_value_t exec_result = jerry_exec_snapshot (snapshot_buffer, snapshot_size, 0, 0, NULL); TEST_ASSERT (jerry_value_is_error (exec_result)); jerry_release_value (exec_result); @@ -308,12 +379,12 @@ main (void) jerry_init (JERRY_INIT_EMPTY); - jerry_value_t res = jerry_exec_snapshot (merged_snapshot_buffer, merged_size, 0, 0); + jerry_value_t res = jerry_exec_snapshot (merged_snapshot_buffer, merged_size, 0, 0, NULL); TEST_ASSERT (!jerry_value_is_error (res)); TEST_ASSERT (jerry_get_number_value (res) == 123); jerry_release_value (res); - res = jerry_exec_snapshot (merged_snapshot_buffer, merged_size, 1, 0); + res = jerry_exec_snapshot (merged_snapshot_buffer, merged_size, 1, 0, NULL); TEST_ASSERT (!jerry_value_is_error (res)); TEST_ASSERT (jerry_get_number_value (res) == 456); jerry_release_value (res); @@ -393,5 +464,7 @@ main (void) test_function_arguments_snapshot (); + test_snapshot_with_user (); + return 0; } /* main */ -- cgit v1.2.3