diff --git a/jerry-core/api/jerryscript.c b/jerry-core/api/jerryscript.c index 6f78dca5c..b1ea96582 100644 --- a/jerry-core/api/jerryscript.c +++ b/jerry-core/api/jerryscript.c @@ -35,6 +35,7 @@ #include "ecma-extended-info.h" #include "ecma-function-object.h" #include "ecma-gc.h" +#include "ecma-globals.h" #include "ecma-helpers.h" #include "ecma-init-finalize.h" #include "ecma-iterator-object.h" @@ -5950,7 +5951,7 @@ jerry_arraybuffer_allocate_buffer_no_throw (ecma_object_t *arraybuffer_p) /**< A return false; } - return ecma_arraybuffer_allocate_buffer (arraybuffer_p) != NULL; + return ecma_arraybuffer_allocate_buffer (arraybuffer_p) != ECMA_VALUE_ERROR; } /* jerry_arraybuffer_allocate_buffer_no_throw */ #endif /* JERRY_BUILTIN_TYPEDARRAY */ diff --git a/jerry-core/ecma/builtin-objects/typedarray/ecma-builtin-typedarray-prototype.c b/jerry-core/ecma/builtin-objects/typedarray/ecma-builtin-typedarray-prototype.c index 52f72fadf..553cffda7 100644 --- a/jerry-core/ecma/builtin-objects/typedarray/ecma-builtin-typedarray-prototype.c +++ b/jerry-core/ecma/builtin-objects/typedarray/ecma-builtin-typedarray-prototype.c @@ -130,6 +130,19 @@ ecma_builtin_typedarray_prototype_exec_routine (ecma_value_t this_arg, /**< this { JERRY_ASSERT (mode < TYPEDARRAY_ROUTINE__COUNT); + ecma_object_t *typedarray_p = ecma_get_object_from_value (this_arg); + ecma_typedarray_info_t info = ecma_typedarray_get_info (typedarray_p); + + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (info.array_buffer_p)) + { + return ECMA_VALUE_ERROR; + } + + if (ecma_arraybuffer_is_detached (info.array_buffer_p)) + { + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + ecma_typedarray_getter_fn_t typedarray_getter_cb = ecma_get_typedarray_getter_fn (info_p->id); ecma_object_t *func_object_p = ecma_get_object_from_value (cb_func_val); uint8_t *buffer_p = ecma_arraybuffer_get_buffer (info_p->array_buffer_p) + info_p->offset; @@ -210,6 +223,16 @@ ecma_builtin_typedarray_prototype_map (ecma_value_t this_arg, /**< this object * { ecma_object_t *func_object_p = ecma_get_object_from_value (cb_func_val); + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (src_info_p->array_buffer_p)) + { + return ECMA_VALUE_ERROR; + } + + if (ecma_arraybuffer_is_detached (src_info_p->array_buffer_p)) + { + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + // TODO: 22.2.3.18, 7-8. ecma_value_t len = ecma_make_number_value (src_info_p->length); ecma_value_t new_typedarray = ecma_typedarray_species_create (this_arg, &len, 1); @@ -221,23 +244,25 @@ ecma_builtin_typedarray_prototype_map (ecma_value_t this_arg, /**< this object * } ecma_object_t *target_obj_p = ecma_get_object_from_value (new_typedarray); + uint8_t *src_buffer_p = ecma_typedarray_get_buffer (src_info_p); - if (JERRY_UNLIKELY (src_buffer_p == NULL)) - { - ecma_deref_object (target_obj_p); - return ECMA_VALUE_ERROR; - } - ecma_typedarray_info_t target_info = ecma_typedarray_get_info (target_obj_p); - uint8_t *target_buffer_p = ecma_typedarray_get_buffer (&target_info); - if (JERRY_UNLIKELY (target_buffer_p == NULL)) + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (target_info.array_buffer_p)) { ecma_deref_object (target_obj_p); return ECMA_VALUE_ERROR; } + if (ecma_arraybuffer_is_detached (target_info.array_buffer_p)) + { + ecma_deref_object (target_obj_p); + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + + uint8_t *target_buffer_p = ecma_typedarray_get_buffer (&target_info); + ecma_typedarray_getter_fn_t src_typedarray_getter_cb = ecma_get_typedarray_getter_fn (src_info_p->id); ecma_typedarray_setter_fn_t target_typedarray_setter_cb = ecma_get_typedarray_setter_fn (target_info.id); @@ -294,6 +319,11 @@ ecma_builtin_typedarray_prototype_reduce_with_direction (ecma_value_t this_arg, uint32_t arguments_number, /**< length of arguments' list*/ bool is_right) /**< choose order, true is reduceRight */ { + if (ecma_arraybuffer_is_detached (info_p->array_buffer_p)) + { + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + ecma_typedarray_getter_fn_t getter_cb = ecma_get_typedarray_getter_fn (info_p->id); uint32_t byte_pos; @@ -411,6 +441,11 @@ ecma_builtin_typedarray_prototype_filter (ecma_value_t this_arg, /**< this objec ecma_value_t cb_func_val, /**< callback function */ ecma_value_t cb_this_arg) /**< 'this' of the callback function */ { + if (ecma_arraybuffer_is_detached (info_p->array_buffer_p)) + { + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + ecma_typedarray_getter_fn_t getter_cb = ecma_get_typedarray_getter_fn (info_p->id); ecma_object_t *func_object_p = ecma_get_object_from_value (cb_func_val); @@ -478,13 +513,6 @@ ecma_builtin_typedarray_prototype_filter (ecma_value_t this_arg, /**< this objec uint8_t *target_buffer_p = ecma_typedarray_get_buffer (&target_info); - if (JERRY_UNLIKELY (target_buffer_p == NULL)) - { - ecma_deref_object (new_typedarray_p); - ret_value = ECMA_VALUE_ERROR; - goto cleanup; - } - ecma_typedarray_setter_fn_t target_typedarray_setter_cb = ecma_get_typedarray_setter_fn (target_info.id); for (uint32_t idx = 0; idx < collected_p->item_count; idx++) @@ -521,6 +549,11 @@ static ecma_value_t ecma_builtin_typedarray_prototype_reverse (ecma_value_t this_arg, /**< this argument */ ecma_typedarray_info_t *info_p) /**< object info */ { + if (ecma_arraybuffer_is_detached (info_p->array_buffer_p)) + { + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + uint8_t *buffer_p = ecma_arraybuffer_get_buffer (info_p->array_buffer_p) + info_p->offset; uint32_t middle = (info_p->length / 2) << info_p->shift; uint32_t buffer_last = (info_p->length << info_p->shift) - info_p->element_size; @@ -568,22 +601,34 @@ ecma_op_typedarray_set_with_typedarray (ecma_value_t this_arg, /**< this argumen ecma_object_t *target_typedarray_p = ecma_get_object_from_value (this_arg); ecma_typedarray_info_t target_info = ecma_typedarray_get_info (target_typedarray_p); - uint8_t *target_buffer_p = ecma_typedarray_get_buffer (&target_info); - if (JERRY_UNLIKELY (target_buffer_p == NULL)) + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (target_info.array_buffer_p)) { return ECMA_VALUE_ERROR; } + if (ecma_arraybuffer_is_detached (target_info.array_buffer_p)) + { + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + + uint8_t *target_buffer_p = ecma_typedarray_get_buffer (&target_info); + ecma_object_t *src_typedarray_p = ecma_get_object_from_value (arr_val); ecma_typedarray_info_t src_info = ecma_typedarray_get_info (src_typedarray_p); - uint8_t *src_buffer_p = ecma_typedarray_get_buffer (&src_info); - if (JERRY_UNLIKELY (src_buffer_p == NULL)) + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (src_info.array_buffer_p)) { return ECMA_VALUE_ERROR; } + if (ecma_arraybuffer_is_detached (src_info.array_buffer_p)) + { + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + + uint8_t *src_buffer_p = ecma_typedarray_get_buffer (&src_info); + uint32_t target_offset_uint32 = ecma_number_to_uint32 (target_offset_num); if ((int64_t) src_info.length + target_offset_uint32 > target_info.length) @@ -670,13 +715,19 @@ ecma_builtin_typedarray_prototype_set (ecma_value_t this_arg, /**< this argument /* 11. ~ 15. */ ecma_object_t *typedarray_p = ecma_get_object_from_value (this_arg); ecma_typedarray_info_t target_info = ecma_typedarray_get_info (typedarray_p); - uint8_t *target_buffer_p = ecma_typedarray_get_buffer (&target_info); - if (JERRY_UNLIKELY (target_buffer_p == NULL)) + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (target_info.array_buffer_p)) { return ECMA_VALUE_ERROR; } + if (ecma_arraybuffer_is_detached (target_info.array_buffer_p)) + { + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + + uint8_t *target_buffer_p = ecma_typedarray_get_buffer (&target_info); + /* 16.~ 17. */ ecma_value_t source_obj = ecma_op_to_object (arr_val); @@ -846,6 +897,13 @@ static ecma_value_t ecma_builtin_typedarray_prototype_join (ecma_object_t *obj_p, /**< this object */ ecma_value_t separator_arg) /**< separator argument */ { + ecma_typedarray_info_t info = ecma_typedarray_get_info (obj_p); + + if (ecma_arraybuffer_is_detached (info.array_buffer_p)) + { + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + /* 2. */ uint32_t length = ecma_typedarray_get_length (obj_p); ecma_string_t *separator_string_p = ecma_op_typedarray_get_separator_string (separator_arg); @@ -975,6 +1033,11 @@ ecma_builtin_typedarray_prototype_fill (ecma_value_t this_arg, /**< this object { ecma_value_t value_to_set; + if (ecma_arraybuffer_is_detached (info_p->array_buffer_p)) + { + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + #if JERRY_BUILTIN_BIGINT if (ECMA_TYPEDARRAY_IS_BIGINT_TYPE (info_p->id)) { @@ -1027,13 +1090,13 @@ ecma_builtin_typedarray_prototype_fill (ecma_value_t this_arg, /**< this object subarray_length = end_index_uint32 - begin_index_uint32; } - uint8_t *buffer_p = ecma_typedarray_get_buffer (info_p); - - if (JERRY_UNLIKELY (buffer_p == NULL)) + if (ecma_arraybuffer_is_detached (info_p->array_buffer_p)) { - return ECMA_VALUE_ERROR; + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); } + uint8_t *buffer_p = ecma_typedarray_get_buffer (info_p); + buffer_p += begin_index_uint32 << info_p->shift; uint8_t *limit_p = buffer_p + (subarray_length << info_p->shift); @@ -1171,6 +1234,11 @@ ecma_builtin_typedarray_prototype_sort (ecma_value_t this_arg, /**< this argumen JERRY_ASSERT (ecma_is_typedarray (this_arg)); JERRY_ASSERT (ecma_is_value_undefined (compare_func) || ecma_op_is_callable (compare_func)); + if (ecma_arraybuffer_is_detached (info_p->array_buffer_p)) + { + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + if (!info_p->length) { return ecma_copy_value (this_arg); @@ -1269,6 +1337,11 @@ ecma_builtin_typedarray_prototype_find_helper (ecma_value_t this_arg, /**< this bool is_find) /**< true - find routine * false - findIndex routine */ { + if (ecma_arraybuffer_is_detached (info_p->array_buffer_p)) + { + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + JERRY_ASSERT (ecma_is_value_object (predicate)); ecma_object_t *func_object_p = ecma_get_object_from_value (predicate); uint8_t *buffer_p = ecma_arraybuffer_get_buffer (info_p->array_buffer_p) + info_p->offset; @@ -1364,6 +1437,11 @@ ecma_builtin_typedarray_prototype_index_of (ecma_typedarray_info_t *info_p, /**< const ecma_value_t args[], /**< arguments list */ uint32_t args_number) /**< number of arguments */ { + if (ecma_arraybuffer_is_detached (info_p->array_buffer_p)) + { + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + #if JERRY_BUILTIN_BIGINT bool is_bigint = ECMA_TYPEDARRAY_IS_BIGINT_TYPE (info_p->id); #else /* !JERRY_BUILTIN_BIGINT */ @@ -1391,11 +1469,6 @@ ecma_builtin_typedarray_prototype_index_of (ecma_typedarray_info_t *info_p, /**< uint8_t *buffer_p = ecma_typedarray_get_buffer (info_p); - if (JERRY_UNLIKELY (buffer_p == NULL)) - { - return ECMA_VALUE_ERROR; - } - uint8_t *limit_p = buffer_p + (info_p->length << info_p->shift); ecma_typedarray_getter_fn_t getter_cb = ecma_get_typedarray_getter_fn (info_p->id); @@ -1435,6 +1508,11 @@ ecma_builtin_typedarray_prototype_last_index_of (ecma_typedarray_info_t *info_p, const ecma_value_t args[], /**< arguments list */ uint32_t args_number) /**< number of arguments */ { + if (ecma_arraybuffer_is_detached (info_p->array_buffer_p)) + { + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + #if JERRY_BUILTIN_BIGINT bool is_bigint = ECMA_TYPEDARRAY_IS_BIGINT_TYPE (info_p->id); #else /* !JERRY_BUILTIN_BIGINT */ @@ -1514,6 +1592,11 @@ ecma_builtin_typedarray_prototype_copy_within (ecma_value_t this_arg, /**< this const ecma_value_t args[], /**< arguments list */ uint32_t args_number) /**< number of arguments */ { + if (ecma_arraybuffer_is_detached (info_p->array_buffer_p)) + { + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + uint32_t relative_target = 0; uint32_t relative_start = 0; uint32_t relative_end = info_p->length; @@ -1547,13 +1630,13 @@ ecma_builtin_typedarray_prototype_copy_within (ecma_value_t this_arg, /**< this return ecma_copy_value (this_arg); } - uint8_t *buffer_p = ecma_typedarray_get_buffer (info_p); - - if (JERRY_UNLIKELY (buffer_p == NULL)) + if (ecma_arraybuffer_is_detached (info_p->array_buffer_p)) { - return ECMA_VALUE_ERROR; + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); } + uint8_t *buffer_p = ecma_typedarray_get_buffer (info_p); + uint32_t distance = relative_end - relative_start; uint32_t offset = info_p->length - relative_target; uint32_t count = JERRY_MIN (distance, offset); @@ -1583,6 +1666,11 @@ ecma_builtin_typedarray_prototype_slice (ecma_value_t this_arg, /**< this argume uint32_t relative_start = 0; uint32_t relative_end = info_p->length; + if (ecma_arraybuffer_is_detached (info_p->array_buffer_p)) + { + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + if (args_number > 0) { if (ECMA_IS_VALUE_ERROR (ecma_builtin_helper_uint32_index_normalize (args[0], info_p->length, &relative_start))) @@ -1597,6 +1685,8 @@ ecma_builtin_typedarray_prototype_slice (ecma_value_t this_arg, /**< this argume } } + uint8_t *src_buffer_p = ecma_typedarray_get_buffer (info_p); + int32_t distance = (int32_t) (relative_end - relative_start); uint32_t count = distance > 0 ? (uint32_t) distance : 0; @@ -1611,23 +1701,16 @@ ecma_builtin_typedarray_prototype_slice (ecma_value_t this_arg, /**< this argume } ecma_object_t *new_typedarray_p = ecma_get_object_from_value (new_typedarray); - uint8_t *src_buffer_p = ecma_typedarray_get_buffer (info_p); - - if (JERRY_UNLIKELY (src_buffer_p == NULL)) - { - ecma_deref_object (new_typedarray_p); - return ECMA_VALUE_ERROR; - } - ecma_typedarray_info_t new_typedarray_info = ecma_typedarray_get_info (new_typedarray_p); - uint8_t *dst_buffer_p = ecma_typedarray_get_buffer (&new_typedarray_info); - if (JERRY_UNLIKELY (dst_buffer_p == NULL)) + if (ecma_arraybuffer_is_detached (info_p->array_buffer_p)) { ecma_deref_object (new_typedarray_p); - return ECMA_VALUE_ERROR; + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); } + uint8_t *dst_buffer_p = ecma_typedarray_get_buffer (&new_typedarray_info); + JERRY_ASSERT (new_typedarray_info.offset == 0); src_buffer_p += relative_start << info_p->shift; @@ -1678,6 +1761,11 @@ ecma_builtin_typedarray_prototype_to_locale_string_helper (ecma_typedarray_info_ { ecma_value_t element_value = ecma_get_typedarray_element (info_p, index); + if (ECMA_IS_VALUE_ERROR (element_value)) + { + return element_value; + } + ecma_value_t call_value = ecma_op_invoke_by_magic_id (element_value, LIT_MAGIC_STRING_TO_LOCALE_STRING_UL, NULL, 0); ecma_free_value (element_value); @@ -1763,6 +1851,11 @@ ecma_builtin_typedarray_prototype_includes (ecma_typedarray_info_t *info_p, /**< bool is_bigint = false; #endif /* JERRRY_BUILTIN_BIGINT */ + if (ecma_arraybuffer_is_detached (info_p->array_buffer_p)) + { + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + if (args_number == 0 || (!ecma_is_value_number (args[0]) && !is_bigint) || info_p->length == 0) { return ECMA_VALUE_FALSE; @@ -1780,11 +1873,6 @@ ecma_builtin_typedarray_prototype_includes (ecma_typedarray_info_t *info_p, /**< uint8_t *buffer_p = ecma_typedarray_get_buffer (info_p); - if (JERRY_UNLIKELY (buffer_p == NULL)) - { - return ECMA_VALUE_ERROR; - } - ecma_typedarray_getter_fn_t getter_cb = ecma_get_typedarray_getter_fn (info_p->id); uint8_t *limit_p = buffer_p + (info_p->length << info_p->shift); @@ -1838,7 +1926,7 @@ ecma_builtin_typedarray_prototype_dispatch_routine (uint8_t builtin_routine_id, info = ecma_typedarray_get_info (typedarray_p); if (builtin_routine_id != ECMA_TYPEDARRAY_PROTOTYPE_ROUTINE_SUBARRAY - && ECMA_ARRAYBUFFER_CHECK_BUFFER_ERROR (info.array_buffer_p)) + && ECMA_ARRAYBUFFER_LAZY_ALLOC (info.array_buffer_p)) { return ECMA_VALUE_ERROR; } diff --git a/jerry-core/ecma/builtin-objects/typedarray/ecma-builtin-typedarray.c b/jerry-core/ecma/builtin-objects/typedarray/ecma-builtin-typedarray.c index 1aa3ecf6d..c91f97649 100644 --- a/jerry-core/ecma/builtin-objects/typedarray/ecma-builtin-typedarray.c +++ b/jerry-core/ecma/builtin-objects/typedarray/ecma-builtin-typedarray.c @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "ecma-arraybuffer-object.h" #include "ecma-builtins.h" #include "ecma-exceptions.h" #include "ecma-function-object.h" @@ -127,14 +128,21 @@ ecma_builtin_typedarray_of (ecma_value_t this_arg, /**< 'this' argument */ ecma_object_t *ret_obj_p = ecma_get_object_from_value (ret_val); ecma_typedarray_info_t info = ecma_typedarray_get_info (ret_obj_p); ecma_typedarray_setter_fn_t setter_cb = ecma_get_typedarray_setter_fn (info.id); - lit_utf8_byte_t *buffer_p = ecma_typedarray_get_buffer (&info); - if (JERRY_UNLIKELY (buffer_p == NULL)) + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (info.array_buffer_p)) { ecma_deref_object (ret_obj_p); return ECMA_VALUE_ERROR; } + if (ecma_arraybuffer_is_detached (info.array_buffer_p)) + { + ecma_deref_object (ret_obj_p); + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + + lit_utf8_byte_t *buffer_p = ecma_typedarray_get_buffer (&info); + while (k < arguments_list_len) { ecma_value_t set_element = setter_cb (buffer_p, arguments_list_p[k]); diff --git a/jerry-core/ecma/operations/ecma-arraybuffer-object.c b/jerry-core/ecma/operations/ecma-arraybuffer-object.c index e20a59bc8..3a436d1f8 100644 --- a/jerry-core/ecma/operations/ecma-arraybuffer-object.c +++ b/jerry-core/ecma/operations/ecma-arraybuffer-object.c @@ -130,14 +130,19 @@ ecma_arraybuffer_new_object (uint32_t length) /**< length of the arraybuffer */ * @return buffer pointer on success, * NULL otherwise */ -uint8_t * +ecma_value_t ecma_arraybuffer_allocate_buffer (ecma_object_t *arraybuffer_p) /**< ArrayBuffer object */ { JERRY_ASSERT (!(ECMA_ARRAYBUFFER_GET_FLAGS (arraybuffer_p) & ECMA_ARRAYBUFFER_ALLOCATED)); - JERRY_ASSERT (!(ECMA_ARRAYBUFFER_GET_FLAGS (arraybuffer_p) & ECMA_ARRAYBUFFER_DETACHED)); - JERRY_ASSERT (ECMA_ARRAYBUFFER_GET_FLAGS (arraybuffer_p) & ECMA_ARRAYBUFFER_HAS_POINTER); ecma_extended_object_t *extended_object_p = (ecma_extended_object_t *) arraybuffer_p; + + if (ECMA_ARRAYBUFFER_GET_FLAGS (arraybuffer_p) & ECMA_ARRAYBUFFER_DETACHED) + { + extended_object_p->u.cls.u1.array_buffer_flags |= ECMA_ARRAYBUFFER_ALLOCATED; + return ECMA_VALUE_UNDEFINED; + } + uint32_t arraybuffer_length = extended_object_p->u.cls.u3.length; ecma_arraybuffer_pointer_t *arraybuffer_pointer_p = (ecma_arraybuffer_pointer_t *) arraybuffer_p; jerry_arraybuffer_allocate_cb_t arraybuffer_allocate_callback = JERRY_CONTEXT (arraybuffer_allocate_callback); @@ -166,15 +171,14 @@ ecma_arraybuffer_allocate_buffer (ecma_object_t *arraybuffer_p) /**< ArrayBuffer if (buffer_p == NULL) { - extended_object_p->u.cls.u1.array_buffer_flags |= ECMA_ARRAYBUFFER_DETACHED; - return NULL; + return ecma_raise_range_error (ECMA_ERR_ALLOCATE_ARRAY_BUFFER); } arraybuffer_pointer_p->buffer_p = buffer_p; extended_object_p->u.cls.u1.array_buffer_flags |= ECMA_ARRAYBUFFER_ALLOCATED; memset (buffer_p, 0, arraybuffer_length); - return buffer_p; + return ECMA_VALUE_UNDEFINED; } /* ecma_arraybuffer_allocate_buffer */ /** @@ -183,24 +187,12 @@ ecma_arraybuffer_allocate_buffer (ecma_object_t *arraybuffer_p) /**< ArrayBuffer * @return ECMA_VALUE_UNDEFINED on success, * ECMA_VALUE_ERROR otherwise */ -ecma_value_t +extern inline ecma_value_t ecma_arraybuffer_allocate_buffer_throw (ecma_object_t *arraybuffer_p) { JERRY_ASSERT (!(ECMA_ARRAYBUFFER_GET_FLAGS (arraybuffer_p) & ECMA_ARRAYBUFFER_ALLOCATED)); - if (ECMA_ARRAYBUFFER_GET_FLAGS (arraybuffer_p) & ECMA_ARRAYBUFFER_DETACHED) - { - return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); - } - - uint8_t *buffer_p = ecma_arraybuffer_allocate_buffer (arraybuffer_p); - - if (buffer_p == NULL) - { - return ecma_raise_range_error (ECMA_ERR_ALLOCATE_ARRAY_BUFFER); - } - - return ECMA_VALUE_UNDEFINED; + return ecma_arraybuffer_allocate_buffer (arraybuffer_p); } /* ecma_arraybuffer_allocate_buffer_throw */ /** @@ -214,6 +206,12 @@ ecma_arraybuffer_release_buffer (ecma_object_t *arraybuffer_p) /**< ArrayBuffer jerry_arraybuffer_free_cb_t free_callback = JERRY_CONTEXT (arraybuffer_free_callback); ecma_arraybuffer_pointer_t *arraybuffer_pointer_p = (ecma_arraybuffer_pointer_t *) arraybuffer_p; + + if (arraybuffer_pointer_p->buffer_p == NULL) + { + return; + } + uint32_t arraybuffer_length = arraybuffer_pointer_p->extended_object.u.cls.u3.length; if (free_callback == NULL) @@ -345,8 +343,6 @@ ecma_arraybuffer_get_buffer (ecma_object_t *object_p) /**< pointer to the ArrayB JERRY_ASSERT (ecma_object_class_is (object_p, ECMA_OBJECT_CLASS_ARRAY_BUFFER) || ecma_object_is_shared_arraybuffer (object_p)); - JERRY_ASSERT (ECMA_ARRAYBUFFER_GET_FLAGS (object_p) & ECMA_ARRAYBUFFER_ALLOCATED); - if (!(ECMA_ARRAYBUFFER_GET_FLAGS (object_p) & ECMA_ARRAYBUFFER_HAS_POINTER)) { return (uint8_t *) object_p + sizeof (ecma_extended_object_t); @@ -423,11 +419,16 @@ ecma_builtin_arraybuffer_slice (ecma_value_t this_arg, const ecma_value_t *argum ecma_object_t *object_p = ecma_get_object_from_value (this_arg); /* 3-4. */ - if (ECMA_ARRAYBUFFER_CHECK_BUFFER_ERROR (object_p)) + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (object_p)) { return ECMA_VALUE_ERROR; } + if (ecma_arraybuffer_is_detached (object_p)) + { + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + /* 5. */ uint32_t len = ecma_arraybuffer_get_length (object_p); @@ -496,9 +497,15 @@ ecma_builtin_arraybuffer_slice (ecma_value_t this_arg, const ecma_value_t *argum } /* 14-15. */ - if (ECMA_ARRAYBUFFER_CHECK_BUFFER_ERROR (new_arraybuffer_p)) + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (new_arraybuffer_p)) { - ret_value = ecma_raise_type_error (ECMA_ERR_RETURNED_ARRAYBUFFER_HAS_BEEN_DETACHED); + ret_value = ECMA_VALUE_ERROR; + goto free_new_arraybuffer; + } + + if (ecma_arraybuffer_is_detached (new_arraybuffer_p)) + { + ret_value = ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); goto free_new_arraybuffer; } diff --git a/jerry-core/ecma/operations/ecma-arraybuffer-object.h b/jerry-core/ecma/operations/ecma-arraybuffer-object.h index df1f3b3f8..6dc28b59b 100644 --- a/jerry-core/ecma/operations/ecma-arraybuffer-object.h +++ b/jerry-core/ecma/operations/ecma-arraybuffer-object.h @@ -36,7 +36,7 @@ /** * Check whether the backing store is allocated for an array buffer. */ -#define ECMA_ARRAYBUFFER_CHECK_BUFFER_ERROR(arraybuffer_p) \ +#define ECMA_ARRAYBUFFER_LAZY_ALLOC(arraybuffer_p) \ (JERRY_UNLIKELY (!(ECMA_ARRAYBUFFER_GET_FLAGS (arraybuffer_p) & ECMA_ARRAYBUFFER_ALLOCATED)) \ && ecma_arraybuffer_allocate_buffer_throw (arraybuffer_p) == ECMA_VALUE_ERROR) @@ -48,7 +48,7 @@ ecma_value_t ecma_op_create_arraybuffer_object (const ecma_value_t *, uint32_t); ecma_object_t *ecma_arraybuffer_create_object (uint8_t type, uint32_t length); ecma_object_t *ecma_arraybuffer_create_object_with_buffer (uint8_t type, uint32_t length); ecma_object_t *ecma_arraybuffer_new_object (uint32_t length); -uint8_t *ecma_arraybuffer_allocate_buffer (ecma_object_t *arraybuffer_p); +ecma_value_t ecma_arraybuffer_allocate_buffer (ecma_object_t *arraybuffer_p); ecma_value_t ecma_arraybuffer_allocate_buffer_throw (ecma_object_t *arraybuffer_p); void ecma_arraybuffer_release_buffer (ecma_object_t *arraybuffer_p); uint8_t *JERRY_ATTR_PURE ecma_arraybuffer_get_buffer (ecma_object_t *obj_p); diff --git a/jerry-core/ecma/operations/ecma-dataview-object.c b/jerry-core/ecma/operations/ecma-dataview-object.c index 1629867b8..db2ae0a68 100644 --- a/jerry-core/ecma/operations/ecma-dataview-object.c +++ b/jerry-core/ecma/operations/ecma-dataview-object.c @@ -299,11 +299,18 @@ ecma_op_dataview_get_set_view_value (ecma_value_t view, /**< the operation's 'vi /* GetViewValue 4., SetViewValue 6. */ bool is_little_endian = ecma_op_to_boolean (is_little_endian_value); - if (ECMA_ARRAYBUFFER_CHECK_BUFFER_ERROR (buffer_p)) + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (buffer_p)) { + ecma_free_value (value_to_set); return ECMA_VALUE_ERROR; } + if (ecma_arraybuffer_is_detached (buffer_p)) + { + ecma_free_value (value_to_set); + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + /* GetViewValue 7., SetViewValue 9. */ uint32_t view_offset = view_p->byte_offset; @@ -320,11 +327,18 @@ ecma_op_dataview_get_set_view_value (ecma_value_t view, /**< the operation's 'vi return ecma_raise_range_error (ECMA_ERR_START_OFFSET_IS_OUTSIDE_THE_BOUNDS_OF_THE_BUFFER); } - if (ECMA_ARRAYBUFFER_CHECK_BUFFER_ERROR (buffer_p)) + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (buffer_p)) { + ecma_free_value (value_to_set); return ECMA_VALUE_ERROR; } + if (ecma_arraybuffer_is_detached (buffer_p)) + { + ecma_free_value (value_to_set); + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + /* GetViewValue 11., SetViewValue 13. */ bool system_is_little_endian = ecma_dataview_check_little_endian (); diff --git a/jerry-core/ecma/operations/ecma-typedarray-object.c b/jerry-core/ecma/operations/ecma-typedarray-object.c index cd8c4f6e6..c4c4f4105 100644 --- a/jerry-core/ecma/operations/ecma-typedarray-object.c +++ b/jerry-core/ecma/operations/ecma-typedarray-object.c @@ -633,18 +633,18 @@ extern inline ecma_value_t JERRY_ATTR_ALWAYS_INLINE ecma_get_typedarray_element (ecma_typedarray_info_t *info_p, /**< typedarray info */ uint32_t index) /**< element index */ { - uint8_t *buffer_p = ecma_typedarray_get_buffer (info_p); - - if (JERRY_UNLIKELY (buffer_p == NULL)) + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (info_p->array_buffer_p)) { return ECMA_VALUE_ERROR; } - if (index >= info_p->length) + if (ecma_arraybuffer_is_detached (info_p->array_buffer_p) || index >= info_p->length) { return ECMA_VALUE_UNDEFINED; } + uint8_t *buffer_p = ecma_typedarray_get_buffer (info_p); + return ecma_typedarray_getters[info_p->id](buffer_p + (index << info_p->shift)); } /* ecma_get_typedarray_element */ @@ -688,20 +688,20 @@ ecma_set_typedarray_element (ecma_typedarray_info_t *info_p, /**< typedarray inf } } - uint8_t *buffer_p = ecma_typedarray_get_buffer (info_p); - - if (JERRY_UNLIKELY (buffer_p == NULL)) + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (info_p->array_buffer_p)) { ecma_free_value (to_num); return ECMA_VALUE_ERROR; } - if (index >= info_p->length) + if (ecma_arraybuffer_is_detached (info_p->array_buffer_p) || index >= info_p->length) { ecma_free_value (to_num); return ECMA_VALUE_FALSE; } + uint8_t *buffer_p = ecma_typedarray_get_buffer (info_p); + ecma_free_value (to_num); return ecma_typedarray_setters[info_p->id](buffer_p + (index << info_p->shift), value); @@ -886,11 +886,16 @@ ecma_typedarray_create_object_with_typedarray (ecma_object_t *typedarray_p, /**< uint32_t array_length = ecma_typedarray_get_length (typedarray_p); ecma_object_t *src_arraybuffer_p = ecma_typedarray_get_arraybuffer (typedarray_p); - if (ECMA_ARRAYBUFFER_CHECK_BUFFER_ERROR (src_arraybuffer_p)) + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (src_arraybuffer_p)) { return ECMA_VALUE_ERROR; } + if (ecma_arraybuffer_is_detached (src_arraybuffer_p)) + { + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + ecma_value_t new_typedarray = ecma_typedarray_create_object_with_length (array_length, src_arraybuffer_p, proto_p, @@ -905,11 +910,18 @@ ecma_typedarray_create_object_with_typedarray (ecma_object_t *typedarray_p, /**< ecma_object_t *new_typedarray_p = ecma_get_object_from_value (new_typedarray); ecma_object_t *dst_arraybuffer_p = ecma_typedarray_get_arraybuffer (new_typedarray_p); - if (ECMA_ARRAYBUFFER_CHECK_BUFFER_ERROR (dst_arraybuffer_p)) + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (dst_arraybuffer_p)) { + ecma_deref_object (new_typedarray_p); return ECMA_VALUE_ERROR; } + if (ecma_arraybuffer_is_detached (dst_arraybuffer_p)) + { + ecma_deref_object (new_typedarray_p); + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + lit_utf8_byte_t *src_buf_p = ecma_arraybuffer_get_buffer (src_arraybuffer_p); lit_utf8_byte_t *dst_buf_p = ecma_arraybuffer_get_buffer (dst_arraybuffer_p); @@ -1094,34 +1106,44 @@ ecma_typedarray_create_object_with_object (ecma_value_t items_val, /**< the sour ecma_object_t *new_typedarray_p = ecma_get_object_from_value (new_typedarray); ecma_typedarray_info_t info = ecma_typedarray_get_info (new_typedarray_p); ecma_value_t *next_value_p = values_p->buffer_p; - uint8_t *buffer_p = ecma_typedarray_get_buffer (&info); ret_value = ECMA_VALUE_ERROR; - if (buffer_p != NULL) + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (info.array_buffer_p)) { - ecma_typedarray_setter_fn_t setter_cb = ecma_get_typedarray_setter_fn (info.id); - uint8_t *limit_p = buffer_p + (values_p->item_count << info.shift); - - ret_value = ecma_make_object_value (new_typedarray_p); - - /* 8.e */ - while (buffer_p < limit_p) - { - ecma_value_t value = *next_value_p++; - ecma_value_t set_value = setter_cb (buffer_p, value); - ecma_free_value (value); - - if (ECMA_IS_VALUE_ERROR (set_value)) - { - ret_value = set_value; - break; - } - - buffer_p += info.element_size; - } + goto free_collection; } + if (ecma_arraybuffer_is_detached (info.array_buffer_p)) + { + ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + goto free_collection; + } + + uint8_t *buffer_p = ecma_typedarray_get_buffer (&info); + + ecma_typedarray_setter_fn_t setter_cb = ecma_get_typedarray_setter_fn (info.id); + uint8_t *limit_p = buffer_p + (values_p->item_count << info.shift); + + ret_value = ecma_make_object_value (new_typedarray_p); + + /* 8.e */ + while (buffer_p < limit_p) + { + ecma_value_t value = *next_value_p++; + ecma_value_t set_value = setter_cb (buffer_p, value); + ecma_free_value (value); + + if (ECMA_IS_VALUE_ERROR (set_value)) + { + ret_value = set_value; + break; + } + + buffer_p += info.element_size; + } + +free_collection: if (ECMA_IS_VALUE_ERROR (ret_value)) { ecma_value_t *last_value_p = values_p->buffer_p + values_p->item_count; @@ -1178,44 +1200,55 @@ ecma_typedarray_create_object_with_object (ecma_value_t items_val, /**< the sour ecma_object_t *new_typedarray_p = ecma_get_object_from_value (new_typedarray); ecma_typedarray_info_t info = ecma_typedarray_get_info (new_typedarray_p); - uint8_t *buffer_p = ecma_typedarray_get_buffer (&info); + ecma_value_t ret_value = ECMA_VALUE_ERROR; - if (buffer_p != NULL) + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (info.array_buffer_p)) { - ecma_typedarray_setter_fn_t setter_cb = ecma_get_typedarray_setter_fn (info.id); - - ret_value = ecma_make_object_value (new_typedarray_p); - - /* 12 */ - for (uint32_t index = 0; index < len; index++) - { - ecma_value_t value = ecma_op_object_find_by_index (arraylike_object_p, index); - - if (ECMA_IS_VALUE_ERROR (value)) - { - ret_value = value; - break; - } - - if (!ecma_is_value_found (value)) - { - value = ECMA_VALUE_UNDEFINED; - } - - ecma_value_t set_value = setter_cb (buffer_p, value); - ecma_free_value (value); - - if (ECMA_IS_VALUE_ERROR (set_value)) - { - ret_value = set_value; - break; - } - - buffer_p += info.element_size; - } + goto free_object; } + if (ecma_arraybuffer_is_detached (info.array_buffer_p)) + { + ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + goto free_object; + } + + uint8_t *buffer_p = ecma_typedarray_get_buffer (&info); + + ecma_typedarray_setter_fn_t setter_cb = ecma_get_typedarray_setter_fn (info.id); + + ret_value = ecma_make_object_value (new_typedarray_p); + + /* 12 */ + for (uint32_t index = 0; index < len; index++) + { + ecma_value_t value = ecma_op_object_find_by_index (arraylike_object_p, index); + + if (ECMA_IS_VALUE_ERROR (value)) + { + ret_value = value; + break; + } + + if (!ecma_is_value_found (value)) + { + value = ECMA_VALUE_UNDEFINED; + } + + ecma_value_t set_value = setter_cb (buffer_p, value); + ecma_free_value (value); + + if (ECMA_IS_VALUE_ERROR (set_value)) + { + ret_value = set_value; + break; + } + + buffer_p += info.element_size; + } + +free_object: ecma_deref_object (arraylike_object_p); if (ECMA_IS_VALUE_ERROR (ret_value)) @@ -1331,30 +1364,40 @@ ecma_op_typedarray_from (ecma_value_t this_val, /**< this value */ ecma_typedarray_info_t info = ecma_typedarray_get_info (new_typedarray_p); ecma_typedarray_setter_fn_t setter_cb = ecma_get_typedarray_setter_fn (info.id); ecma_value_t *next_value_p = values_p->buffer_p; - uint8_t *buffer_p = ecma_typedarray_get_buffer (&info); ret_value = ECMA_VALUE_ERROR; - if (buffer_p != NULL) + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (info.array_buffer_p)) { - ret_value = ecma_make_object_value (new_typedarray_p); - - /* 6.e */ - for (uint32_t index = 0; index < values_p->item_count; index++) - { - ecma_value_t set_value = - ecma_op_typedarray_from_helper (this_arg, *next_value_p++, index, func_object_p, buffer_p, setter_cb); - - if (ECMA_IS_VALUE_ERROR (set_value)) - { - ret_value = set_value; - break; - } - - buffer_p += info.element_size; - } + goto free_collection; } + if (ecma_arraybuffer_is_detached (info.array_buffer_p)) + { + ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + goto free_collection; + } + + uint8_t *buffer_p = ecma_typedarray_get_buffer (&info); + + ret_value = ecma_make_object_value (new_typedarray_p); + + /* 6.e */ + for (uint32_t index = 0; index < values_p->item_count; index++) + { + ecma_value_t set_value = + ecma_op_typedarray_from_helper (this_arg, *next_value_p++, index, func_object_p, buffer_p, setter_cb); + + if (ECMA_IS_VALUE_ERROR (set_value)) + { + ret_value = set_value; + break; + } + + buffer_p += info.element_size; + } + +free_collection: if (ECMA_IS_VALUE_ERROR (ret_value)) { ecma_value_t *last_value_p = values_p->buffer_p + values_p->item_count; @@ -1413,44 +1456,55 @@ ecma_op_typedarray_from (ecma_value_t this_val, /**< this value */ ecma_object_t *new_typedarray_p = ecma_get_object_from_value (new_typedarray); ecma_typedarray_info_t info = ecma_typedarray_get_info (new_typedarray_p); - uint8_t *buffer_p = ecma_typedarray_get_buffer (&info); + ecma_value_t ret_value = ECMA_VALUE_ERROR; - if (buffer_p != NULL) + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (info.array_buffer_p)) { - ecma_typedarray_setter_fn_t setter_cb = ecma_get_typedarray_setter_fn (info.id); - - ret_value = ecma_make_object_value (new_typedarray_p); - - /* 12 */ - for (uint32_t index = 0; index < len; index++) - { - ecma_value_t value = ecma_op_object_find_by_index (arraylike_object_p, index); - - if (ECMA_IS_VALUE_ERROR (value)) - { - ret_value = value; - break; - } - - if (!ecma_is_value_found (value)) - { - value = ECMA_VALUE_UNDEFINED; - } - - ecma_value_t set_value = - ecma_op_typedarray_from_helper (this_arg, value, index, func_object_p, buffer_p, setter_cb); - - if (ECMA_IS_VALUE_ERROR (set_value)) - { - ret_value = set_value; - break; - } - - buffer_p += info.element_size; - } + goto free_object; } + if (ecma_arraybuffer_is_detached (info.array_buffer_p)) + { + ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + goto free_object; + } + + uint8_t *buffer_p = ecma_typedarray_get_buffer (&info); + + ecma_typedarray_setter_fn_t setter_cb = ecma_get_typedarray_setter_fn (info.id); + + ret_value = ecma_make_object_value (new_typedarray_p); + + /* 12 */ + for (uint32_t index = 0; index < len; index++) + { + ecma_value_t value = ecma_op_object_find_by_index (arraylike_object_p, index); + + if (ECMA_IS_VALUE_ERROR (value)) + { + ret_value = value; + break; + } + + if (!ecma_is_value_found (value)) + { + value = ECMA_VALUE_UNDEFINED; + } + + ecma_value_t set_value = + ecma_op_typedarray_from_helper (this_arg, value, index, func_object_p, buffer_p, setter_cb); + + if (ECMA_IS_VALUE_ERROR (set_value)) + { + ret_value = set_value; + break; + } + + buffer_p += info.element_size; + } + +free_object: ecma_deref_object (arraylike_object_p); if (ECMA_IS_VALUE_ERROR (ret_value)) @@ -1558,17 +1612,10 @@ ecma_typedarray_get_offset (ecma_object_t *typedarray_p) /**< the pointer to the * @return pointer to the data buffer if successfull, * NULL otherwise */ -uint8_t * +extern inline uint8_t * ecma_typedarray_get_buffer (ecma_typedarray_info_t *info_p) /**< typedarray info */ { - ecma_object_t *array_buffer_p = info_p->array_buffer_p; - - if (ECMA_ARRAYBUFFER_CHECK_BUFFER_ERROR (array_buffer_p)) - { - return NULL; - } - - return ecma_arraybuffer_get_buffer (array_buffer_p) + info_p->offset; + return ecma_arraybuffer_get_buffer (info_p->array_buffer_p) + info_p->offset; } /* ecma_typedarray_get_buffer */ /** @@ -1756,6 +1803,20 @@ ecma_typedarray_iterators_helper (ecma_value_t this_arg, /**< this argument */ ecma_iterator_kind_t kind) /**< iterator kind */ { JERRY_ASSERT (ecma_is_typedarray (this_arg)); + + ecma_object_t *typedarray_p = ecma_get_object_from_value (this_arg); + ecma_typedarray_info_t info = ecma_typedarray_get_info (typedarray_p); + + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (info.array_buffer_p)) + { + return ECMA_VALUE_ERROR; + } + + if (ecma_arraybuffer_is_detached (info.array_buffer_p)) + { + return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); + } + ecma_object_t *prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_ARRAY_ITERATOR_PROTOTYPE); return ecma_op_create_iterator_object (this_arg, prototype_obj_p, ECMA_OBJECT_CLASS_ARRAY_ITERATOR, kind); @@ -1882,7 +1943,7 @@ ecma_op_typedarray_define_own_property (ecma_object_t *obj_p, /**< TypedArray ob ecma_typedarray_info_t info = ecma_typedarray_get_info (obj_p); - if (index == ECMA_STRING_NOT_ARRAY_INDEX || index >= info.length) + if (index >= info.length || ecma_arraybuffer_is_detached (info.array_buffer_p)) { return ECMA_VALUE_FALSE; } @@ -1931,10 +1992,15 @@ ecma_typedarray_create (ecma_object_t *constructor_p, /**< constructor function } ecma_object_t *typedarray_p = ecma_get_object_from_value (ret_val); + ecma_typedarray_info_t info = ecma_typedarray_get_info (typedarray_p); - ecma_object_t *arraybuffer_p = ecma_typedarray_get_arraybuffer (ecma_get_object_from_value (ret_val)); + if (ECMA_ARRAYBUFFER_LAZY_ALLOC (info.array_buffer_p)) + { + ecma_deref_object (typedarray_p); + return ECMA_VALUE_ERROR; + } - if (ecma_arraybuffer_is_detached (arraybuffer_p)) + if (ecma_arraybuffer_is_detached (info.array_buffer_p)) { ecma_deref_object (typedarray_p); return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED); @@ -1943,7 +2009,6 @@ ecma_typedarray_create (ecma_object_t *constructor_p, /**< constructor function if ((arguments_list_len == 1) && (ecma_is_value_number (arguments_list_p[0]))) { ecma_number_t num = ecma_get_number_from_value (arguments_list_p[0]); - ecma_typedarray_info_t info = ecma_typedarray_get_info (typedarray_p); if (info.length < num) { diff --git a/jerry-core/vm/vm.c b/jerry-core/vm/vm.c index 9a2aa927c..a837c72fc 100644 --- a/jerry-core/vm/vm.c +++ b/jerry-core/vm/vm.c @@ -2185,7 +2185,7 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */ if (opcode == CBC_EXT_SET_NEXT_COMPUTED_FIELD_ANONYMOUS_FUNC) { - ecma_object_t *func_obj_p = ecma_get_object_from_value (result); + ecma_object_t *func_obj_p = ecma_get_object_from_value (stack_top_p[-1]); JERRY_ASSERT (ecma_find_named_property (func_obj_p, ecma_get_magic_string (LIT_MAGIC_STRING_NAME)) == NULL); ecma_property_value_t *value_p; diff --git a/tests/test262-esnext-excludelist.xml b/tests/test262-esnext-excludelist.xml index 2d476119e..fb3720040 100644 --- a/tests/test262-esnext-excludelist.xml +++ b/tests/test262-esnext-excludelist.xml @@ -79,6 +79,155 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -161,7 +310,38 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -202,7 +382,28 @@ + + + + + + + + + + + + + + + + + + + + + @@ -304,6 +505,29 @@ + + + + + + + + + + + + + + + + + + + + + + + @@ -312,7 +536,6 @@ - @@ -405,6 +628,160 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tools/runners/run-test-suite-test262.py b/tools/runners/run-test-suite-test262.py index f8436b97f..6f1eb91c8 100755 --- a/tools/runners/run-test-suite-test262.py +++ b/tools/runners/run-test-suite-test262.py @@ -65,7 +65,7 @@ def get_arguments(): elif args.esnext: args.test_dir = os.path.join(args.test_dir, 'esnext') args.test262_harness_dir = os.path.abspath(os.path.dirname(__file__)) - args.test262_git_hash = '281eb10b2844929a7c0ac04527f5b42ce56509fd' + args.test262_git_hash = '9f2814f00ff7612f74024c15c165853b6765c7ab' args.excludelist_path = os.path.join('tests', 'test262-esnext-excludelist.xml') else: args.test_dir = os.path.join(args.test_dir, 'es51')