From 35e2f92fbbc29b5ffc025a5446461802adb6c10b Mon Sep 17 00:00:00 2001 From: wengchangcheng Date: Tue, 16 Aug 2022 23:48:09 +0800 Subject: [PATCH] Descriptor: support first level instruction Details: 1. Add old Opcode defines 2. Add new inst handler of throw & wide & deprecated 3. Modify interpreter for new inst 4. Modify typeinfer for new inst 5. Modify asm interpreter for new inst 6. Modify aot circuit builder for new inst 7. Translate old inst to first level inst Issue: https://gitee.com/openharmony/arkcompiler_ets_runtime/issues/I5LPNL Signed-off-by: wengchangcheng Change-Id: If9e0b60cafc32a662a5fb1676887939d5a2b9ebf --- docs/development-example-zh.md | 12 +- docs/development-example.md | 12 +- ecmascript/base/config.h | 2 +- ecmascript/builtins.cpp | 808 +- ecmascript/builtins.h | 90 +- ecmascript/builtins/builtins_string.cpp | 4 +- .../builtins/tests/builtins_array_test.cpp | 4 +- .../builtins/tests/builtins_object_test.cpp | 4 +- .../builtins/tests/builtins_regexp_test.cpp | 2 +- .../builtins/tests/builtins_string_test.cpp | 2 +- .../tests/builtins_typedarray_test.cpp | 4 +- .../assembler/tests/assembler_x64_test.cpp | 1 - ecmascript/compiler/assembler_module.cpp | 10 +- .../compiler/async_function_lowering.cpp | 2 +- ecmascript/compiler/bc_call_signature.h | 340 +- .../compiler/builtins/builtins_stubs.cpp | 2 +- .../compiler/bytecode_circuit_builder.cpp | 954 +-- .../compiler/bytecode_circuit_builder.h | 84 +- .../compiler/bytecode_info_collector.cpp | 790 +- ecmascript/compiler/bytecode_info_collector.h | 14 +- ecmascript/compiler/call_signature.cpp | 48 +- ecmascript/compiler/call_signature.h | 18 +- ecmascript/compiler/circuit_builder-inl.h | 4 +- ecmascript/compiler/interpreter_stub-inl.h | 18 + ecmascript/compiler/interpreter_stub.cpp | 1416 ++-- ecmascript/compiler/interpreter_stub.h | 2 + ecmascript/compiler/slowpath_lowering.cpp | 754 +- ecmascript/compiler/slowpath_lowering.h | 82 +- ecmascript/compiler/stub_builder-inl.h | 16 +- ecmascript/compiler/stub_builder.cpp | 78 +- ecmascript/compiler/stub_builder.h | 12 +- ecmascript/compiler/test_stubs.cpp | 6 +- ecmascript/compiler/tests/stub_tests.cpp | 2 +- .../aarch64/asm_interpreter_call.cpp | 26 +- .../trampoline/aarch64/common_call.cpp | 2 - .../compiler/trampoline/aarch64/common_call.h | 8 +- .../trampoline/x64/asm_interpreter_call.cpp | 26 +- .../compiler/trampoline/x64/common_call.cpp | 2 - .../compiler/trampoline/x64/common_call.h | 6 +- .../compiler/type_inference/type_infer.cpp | 170 +- .../compiler/type_inference/type_infer.h | 14 +- ecmascript/compiler/type_lowering.cpp | 6 +- ecmascript/compiler/type_lowering.h | 2 +- ecmascript/containers/containers_private.cpp | 192 +- ecmascript/dump.cpp | 14 +- ecmascript/ecma_macros.h | 26 +- ecmascript/ecma_vm.cpp | 10 +- ecmascript/free_object.h | 2 +- ecmascript/generator_helper.cpp | 2 - ecmascript/global_env.h | 8 +- ecmascript/global_env_constants.cpp | 150 +- ecmascript/global_env_constants.h | 8 +- ecmascript/ic/ic_binary_op.h | 4 +- ecmascript/ic/ic_compare_op.cpp | 16 +- ecmascript/ic/ic_compare_op.h | 8 +- ecmascript/ic/profile_type_info.cpp | 26 +- ecmascript/ic/profile_type_info.h | 6 +- ecmascript/ic/tests/ic_binaryop_test.cpp | 48 +- ecmascript/ic/tests/ic_compareop_test.cpp | 148 +- ecmascript/ic/tests/ic_handler_test.cpp | 10 +- .../ic/tests/profile_type_info_test.cpp | 20 +- ecmascript/ic/tests/properties_cache_test.cpp | 22 +- .../ic/tests/proto_change_details_test.cpp | 18 +- .../interpreter/fast_runtime_stub-inl.h | 4 +- ecmascript/interpreter/fast_runtime_stub.h | 2 +- ecmascript/interpreter/frame_handler.cpp | 1 - ecmascript/interpreter/interpreter-inl.h | 6990 +++++++++++------ ecmascript/interpreter/interpreter.h | 165 +- .../interpreter/interpreter_assembly.cpp | 1365 ++-- ecmascript/interpreter/interpreter_assembly.h | 36 - ecmascript/interpreter/slow_runtime_stub.cpp | 218 +- ecmascript/interpreter/slow_runtime_stub.h | 65 +- ...bugger_deprecated_instruction_dispatch.inl | 66 + .../debugger_instruction_dispatch.inl | 420 +- .../debugger_instruction_handler.inl | 1308 ++- .../debugger_throw_instruction_dispatch.inl | 24 + .../debugger_wide_instruction_dispatch.inl | 33 + .../deprecated_instruction_dispatch.inl | 66 + .../templates/instruction_dispatch.inl | 422 +- .../templates/throw_instruction_dispatch.inl | 24 + .../templates/wide_instruction_dispatch.inl | 33 + ecmascript/js_bigint.h | 4 +- ecmascript/js_function.cpp | 40 +- ecmascript/js_function.h | 24 +- ecmascript/js_hclass.cpp | 134 +- ecmascript/js_object.cpp | 24 +- ecmascript/js_object.h | 2 +- ecmascript/js_serializer.cpp | 4 +- .../jspandafile/bytecode_inst/instruction.h | 145 + .../bytecode_inst/old_instruction.h | 2033 +++++ .../bytecode_inst/old_instruction_enum.h | 472 ++ .../jspandafile/class_info_extractor.cpp | 12 +- .../jspandafile/literal_data_extractor.cpp | 4 +- .../jspandafile/panda_file_translator.cpp | 1287 ++- .../jspandafile/panda_file_translator.h | 11 +- ecmascript/log.h | 7 +- ecmascript/mem/barriers-inl.h | 2 +- ecmascript/mem/barriers.h | 8 +- ecmascript/mem/heap-inl.h | 4 +- ecmascript/mem/heap.h | 2 +- ecmascript/mem/object_xray.h | 2 +- ecmascript/mem/parallel_evacuator.cpp | 2 +- ecmascript/mem/parallel_marker-inl.h | 6 +- ecmascript/mem/tagged_object-inl.h | 2 +- ecmascript/napi/jsnapi.cpp | 6 +- ecmascript/napi/test/jsnapi_tests.cpp | 34 +- ecmascript/object_factory.cpp | 378 +- ecmascript/object_factory.h | 36 +- ecmascript/runtime_call_id.h | 124 +- ecmascript/stubs/runtime_stubs-inl.h | 96 +- ecmascript/stubs/runtime_stubs.cpp | 238 +- ecmascript/stubs/runtime_stubs.h | 160 +- ecmascript/stubs/test_runtime_stubs.cpp | 8 +- ecmascript/tagged_array-inl.h | 12 +- ecmascript/tests/accessor_data_test.cpp | 44 +- ecmascript/tests/dump_test.cpp | 50 +- .../tests/js_api_deque_iterator_test.cpp | 2 +- ecmascript/tests/js_function_test.cpp | 6 +- ecmascript/tests/js_generator_object_test.cpp | 4 +- ecmascript/tests/js_hclass_test.cpp | 200 +- ecmascript/tests/js_object_test.cpp | 178 +- ecmascript/tests/js_proxy_test.cpp | 92 +- ecmascript/tests/object_factory_test.cpp | 2 +- ecmascript/tests/weak_ref_old_gc_test.cpp | 4 +- ecmascript/tests/weak_ref_semi_gc_test.cpp | 4 +- ecmascript/tests/weak_vector_test.cpp | 16 +- ecmascript/tooling/agent/runtime_impl.cpp | 2 +- ecmascript/ts_types/ts_type.cpp | 2 +- 128 files changed, 15603 insertions(+), 8165 deletions(-) create mode 100644 ecmascript/interpreter/templates/debugger_deprecated_instruction_dispatch.inl create mode 100644 ecmascript/interpreter/templates/debugger_throw_instruction_dispatch.inl create mode 100644 ecmascript/interpreter/templates/debugger_wide_instruction_dispatch.inl create mode 100644 ecmascript/interpreter/templates/deprecated_instruction_dispatch.inl create mode 100644 ecmascript/interpreter/templates/throw_instruction_dispatch.inl create mode 100644 ecmascript/interpreter/templates/wide_instruction_dispatch.inl create mode 100644 ecmascript/jspandafile/bytecode_inst/instruction.h create mode 100644 ecmascript/jspandafile/bytecode_inst/old_instruction.h create mode 100644 ecmascript/jspandafile/bytecode_inst/old_instruction_enum.h diff --git a/docs/development-example-zh.md b/docs/development-example-zh.md index ff42871fe2..88d7f4d9d8 100644 --- a/docs/development-example-zh.md +++ b/docs/development-example-zh.md @@ -118,15 +118,15 @@ hello-world.abc反汇编结果如下： # METHODS .function any func_main_0_any_any_any_any_(any a0, any a1, any a2) { - mov.dyn v2, a2 - mov.dyn v1, a1 - mov.dyn v0, a0 + mov v2, a2 + mov v1, a1 + mov v0, a0 builtin.acc - sta.dyn v5 + sta v5 builtin.idi "print", 0x0 // 加载print函数 - sta.dyn v3 + sta v3 lda.str "Hello World!!!" // 加载Hello World!!!字符串 - sta.dyn v4 + sta v4 builtin.tern3 v3, v4 // 调用print函数 builtin.acc } diff --git a/docs/development-example.md b/docs/development-example.md index 9ea827c8d4..c68fa6fa41 100644 --- a/docs/development-example.md +++ b/docs/development-example.md @@ -103,15 +103,15 @@ The output is as follows: # METHODS .function any func_main_0_any_any_any_any_(any a0, any a1, any a2) { - mov.dyn v2, a2 - mov.dyn v1, a1 - mov.dyn v0, a0 + mov v2, a2 + mov v1, a1 + mov v0, a0 builtin.acc - sta.dyn v5 + sta v5 builtin.idi "print", 0x0 // Load the print function. - sta.dyn v3 + sta v3 lda.str "Hello World!!!" // Load the Hello World!!! string. - sta.dyn v4 + sta v4 builtin.tern3 v3, v4 // Call the print function. builtin.acc } diff --git a/ecmascript/base/config.h b/ecmascript/base/config.h index 24dbd6b913..9680de4ec9 100644 --- a/ecmascript/base/config.h +++ b/ecmascript/base/config.h @@ -24,7 +24,7 @@ namespace panda::ecmascript { #define ECMASCRIPT_ENABLE_ARK_CONTAINER 1 #define ECMASCRIPT_ENABLE_ASM_INTERPRETER_LOG 0 #define ECMASCRIPT_ENABLE_VERBOSE_LEVEL_LOG 0 -#define ECMASCRIPT_ENABLE_INTERPRETER_LOG 0 +#define ECMASCRIPT_ENABLE_INTERPRETER_LOG 1 #define ECMASCRIPT_ENABLE_RUNTIME_STAT 0 // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) #define ECMASCRIPT_ENABLE_INTERPRETER_RUNTIME_STAT 0 diff --git a/ecmascript/builtins.cpp b/ecmascript/builtins.cpp index 79b8a535b9..6ea90bf07a 100644 --- a/ecmascript/builtins.cpp +++ b/ecmascript/builtins.cpp @@ -189,36 +189,36 @@ void Builtins::Initialize(const JSHandle &env, JSThread *thread) [[maybe_unused]] EcmaHandleScope scope(thread_); JSHandle nullHandle(thread, JSTaggedValue::Null()); - // Object.prototype[dynclass] - JSHandle objPrototypeDynclass = factory_->NewEcmaDynClass(JSObject::SIZE, JSType::JS_OBJECT, nullHandle); + // Object.prototype[hclass] + JSHandle objPrototypeHClass = factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, nullHandle); // Object.prototype - JSHandle objFuncPrototype = factory_->NewJSObject(objPrototypeDynclass); + JSHandle objFuncPrototype = factory_->NewJSObject(objPrototypeHClass); JSHandle objFuncPrototypeVal(objFuncPrototype); - // Object.prototype_or_dynclass - JSHandle objFuncDynclass = - factory_->NewEcmaDynClass(JSObject::SIZE, JSType::JS_OBJECT, objFuncPrototypeVal); + // Object.prototype_or_hclass + JSHandle objFuncClass = + factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, objFuncPrototypeVal); - // GLobalObject.prototype_or_dynclass - JSHandle globalObjFuncDynclass = - factory_->NewEcmaDynClass(JSObject::SIZE, JSType::JS_GLOBAL_OBJECT, 0); - globalObjFuncDynclass->SetPrototype(thread_, objFuncPrototypeVal.GetTaggedValue()); - globalObjFuncDynclass->SetIsDictionaryMode(true); - // Function.prototype_or_dynclass - JSHandle emptyFuncDynclass( - factory_->NewEcmaDynClass(JSFunction::SIZE, JSType::JS_FUNCTION, objFuncPrototypeVal)); + // GLobalObject.prototype_or_hclass + JSHandle globalObjFuncClass = + factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_GLOBAL_OBJECT, 0); + globalObjFuncClass->SetPrototype(thread_, objFuncPrototypeVal.GetTaggedValue()); + globalObjFuncClass->SetIsDictionaryMode(true); + // Function.prototype_or_hclass + JSHandle emptyFuncClass( + factory_->NewEcmaHClass(JSFunction::SIZE, JSType::JS_FUNCTION, objFuncPrototypeVal)); - // PrimitiveRef.prototype_or_dynclass - JSHandle primRefObjDynclass = - factory_->NewEcmaDynClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, objFuncPrototypeVal); + // PrimitiveRef.prototype_or_hclass + JSHandle primRefObjHClass = + factory_->NewEcmaHClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, objFuncPrototypeVal); // init global object - JSHandle globalObject = factory_->NewNonMovableJSObject(globalObjFuncDynclass); + JSHandle globalObject = factory_->NewNonMovableJSObject(globalObjFuncClass); env->SetJSGlobalObject(thread_, globalObject); // initialize Function, forbidden change order - InitializeFunction(env, emptyFuncDynclass); + InitializeFunction(env, emptyFuncClass); JSHandle asyncAwaitStatusFuncClass = factory_->CreateFunctionClass(FunctionKind::NORMAL_FUNCTION, JSAsyncAwaitStatusFunction::SIZE, @@ -226,14 +226,14 @@ void Builtins::Initialize(const JSHandle &env, JSThread *thread) env->SetAsyncAwaitStatusFunctionClass(thread_, asyncAwaitStatusFuncClass); JSHandle asyncGeneratorResNextRetProRstFtnClass = - factory_->NewEcmaDynClass(JSAsyncGeneratorResNextRetProRstFtn::SIZE, + factory_->NewEcmaHClass(JSAsyncGeneratorResNextRetProRstFtn::SIZE, JSType::JS_ASYNC_GENERATOR_RESUME_NEXT_RETURN_PROCESSOR_RST_FTN, env->GetFunctionPrototype()); asyncGeneratorResNextRetProRstFtnClass->SetCallable(true); asyncGeneratorResNextRetProRstFtnClass->SetExtensible(true); env->SetAsyncGeneratorResNextRetProRstFtnClass(thread_, asyncGeneratorResNextRetProRstFtnClass); - JSHandle proxyRevocFuncClass = factory_->NewEcmaDynClass( + JSHandle proxyRevocFuncClass = factory_->NewEcmaHClass( JSProxyRevocFunction::SIZE, JSType::JS_PROXY_REVOC_FUNCTION, env->GetFunctionPrototype()); proxyRevocFuncClass->SetCallable(true); proxyRevocFuncClass->SetExtensible(true); @@ -242,68 +242,68 @@ void Builtins::Initialize(const JSHandle &env, JSThread *thread) // Object = new Function() JSHandle objectFunction( NewBuiltinConstructor(env, objFuncPrototype, Object::ObjectConstructor, "Object", FunctionLength::ONE)); - objectFunction.GetObject()->SetFunctionPrototype(thread_, objFuncDynclass.GetTaggedValue()); + objectFunction.GetObject()->SetFunctionPrototype(thread_, objFuncClass.GetTaggedValue()); // initialize object method. env->SetObjectFunction(thread_, objectFunction); env->SetObjectFunctionPrototype(thread_, objFuncPrototype); - JSHandle functionClass = factory_->CreateFunctionClass(FunctionKind::BASE_CONSTRUCTOR, JSFunction::SIZE, + JSHandle FunctionClass = factory_->CreateFunctionClass(FunctionKind::BASE_CONSTRUCTOR, JSFunction::SIZE, JSType::JS_FUNCTION, env->GetFunctionPrototype()); - env->SetFunctionClassWithProto(thread_, functionClass); - functionClass = factory_->CreateFunctionClass(FunctionKind::NORMAL_FUNCTION, JSFunction::SIZE, JSType::JS_FUNCTION, + env->SetFunctionClassWithProto(thread_, FunctionClass); + FunctionClass = factory_->CreateFunctionClass(FunctionKind::NORMAL_FUNCTION, JSFunction::SIZE, JSType::JS_FUNCTION, env->GetFunctionPrototype()); - env->SetFunctionClassWithoutProto(thread_, functionClass); - functionClass = factory_->CreateFunctionClass(FunctionKind::CLASS_CONSTRUCTOR, JSFunction::SIZE, + env->SetFunctionClassWithoutProto(thread_, FunctionClass); + FunctionClass = factory_->CreateFunctionClass(FunctionKind::CLASS_CONSTRUCTOR, JSFunction::SIZE, JSType::JS_FUNCTION, env->GetFunctionPrototype()); - env->SetFunctionClassWithoutName(thread_, functionClass); + env->SetFunctionClassWithoutName(thread_, FunctionClass); if (env == vm_->GetGlobalEnv()) { - InitializeAllTypeError(env, objFuncDynclass); - InitializeSymbol(env, primRefObjDynclass); - InitializeBigInt(env, primRefObjDynclass); + InitializeAllTypeError(env, objFuncClass); + InitializeSymbol(env, primRefObjHClass); + InitializeBigInt(env, primRefObjHClass); } else { // error and symbol need to be shared when initialize realm InitializeAllTypeErrorWithRealm(env); - InitializeSymbolWithRealm(env, primRefObjDynclass); + InitializeSymbolWithRealm(env, primRefObjHClass); InitializeBigIntWithRealm(env); } - InitializeNumber(env, globalObject, primRefObjDynclass); - InitializeDate(env, objFuncDynclass); + InitializeNumber(env, globalObject, primRefObjHClass); + InitializeDate(env, objFuncClass); InitializeObject(env, objFuncPrototype, objectFunction); - InitializeBoolean(env, primRefObjDynclass); + InitializeBoolean(env, primRefObjHClass); InitializeRegExp(env); - InitializeSet(env, objFuncDynclass); - InitializeMap(env, objFuncDynclass); - InitializeWeakMap(env, objFuncDynclass); - InitializeWeakSet(env, objFuncDynclass); - InitializeWeakRef(env, objFuncDynclass); - InitializeFinalizationRegistry(env, objFuncDynclass); + InitializeSet(env, objFuncClass); + InitializeMap(env, objFuncClass); + InitializeWeakMap(env, objFuncClass); + InitializeWeakSet(env, objFuncClass); + InitializeWeakRef(env, objFuncClass); + InitializeFinalizationRegistry(env, objFuncClass); InitializeArray(env, objFuncPrototypeVal); - InitializeTypedArray(env, objFuncDynclass); - InitializeString(env, primRefObjDynclass); - InitializeArrayBuffer(env, objFuncDynclass); - InitializeDataView(env, objFuncDynclass); - InitializeSharedArrayBuffer(env, objFuncDynclass); - - JSHandle argumentsDynclass = factory_->CreateJSArguments(); - env->SetArgumentsClass(thread_, argumentsDynclass); + InitializeTypedArray(env, objFuncClass); + InitializeString(env, primRefObjHClass); + InitializeArrayBuffer(env, objFuncClass); + InitializeDataView(env, objFuncClass); + InitializeSharedArrayBuffer(env, objFuncClass); + + JSHandle argumentsClass = factory_->CreateJSArguments(); + env->SetArgumentsClass(thread_, argumentsClass); SetArgumentsSharedAccessor(env); InitializeGlobalObject(env, globalObject); InitializeMath(env, objFuncPrototypeVal); InitializeAtomics(env, objFuncPrototypeVal); InitializeJson(env, objFuncPrototypeVal); - InitializeIterator(env, objFuncDynclass); + InitializeIterator(env, objFuncClass); InitializeProxy(env); InitializeReflect(env, objFuncPrototypeVal); - InitializeAsyncFunction(env, objFuncDynclass); - InitializeGenerator(env, objFuncDynclass); - InitializeAsyncGenerator(env, objFuncDynclass); - InitializeGeneratorFunction(env, objFuncDynclass); - InitializeAsyncGeneratorFunction(env, objFuncDynclass); - InitializePromise(env, objFuncDynclass); + InitializeAsyncFunction(env, objFuncClass); + InitializeGenerator(env, objFuncClass); + InitializeAsyncGenerator(env, objFuncClass); + InitializeGeneratorFunction(env, objFuncClass); + InitializeAsyncGeneratorFunction(env, objFuncClass); + InitializePromise(env, objFuncClass); InitializePromiseJob(env); InitializeIntl(env, objFuncPrototypeVal); InitializeLocale(env); @@ -315,7 +315,7 @@ void Builtins::Initialize(const JSHandle &env, JSThread *thread) InitializeDisplayNames(env); InitializeListFormat(env); - InitializeModuleNamespace(env, objFuncDynclass); + InitializeModuleNamespace(env, objFuncClass); InitializeCjsModule(env); InitializeCjsExports(env); InitializeCjsRequire(env); @@ -389,13 +389,13 @@ void Builtins::InitializeGlobalObject(const JSHandle &env, const JSHa SetConstant(globalObject, "undefined", JSTaggedValue::Undefined()); } -void Builtins::InitializeFunction(const JSHandle &env, const JSHandle &emptyFuncDynclass) const +void Builtins::InitializeFunction(const JSHandle &env, const JSHandle &emptyFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Initialize Function.prototype - JSHandle funcFuncPrototype = factory_->NewJSFunctionByDynClass( + JSHandle funcFuncPrototype = factory_->NewJSFunctionByHClass( reinterpret_cast(Function::FunctionPrototypeInvokeSelf), - emptyFuncDynclass); + emptyFuncClass); // ecma 19.2.3 The value of the name property of the Function prototype object is the empty String. JSHandle emptyString(thread_->GlobalConstants()->GetHandledEmptyString()); JSHandle undefinedString(thread_, JSTaggedValue::Undefined()); @@ -404,25 +404,25 @@ void Builtins::InitializeFunction(const JSHandle &env, const JSHandle JSFunction::SetFunctionLength(thread_, funcFuncPrototype, JSTaggedValue(FunctionLength::ZERO)); JSHandle funcFuncPrototypeValue(funcFuncPrototype); - // Function.prototype_or_dynclass - JSHandle funcFuncIntanceDynclass = - factory_->NewEcmaDynClass(JSFunction::SIZE, JSType::JS_FUNCTION, funcFuncPrototypeValue); - funcFuncIntanceDynclass->SetConstructor(true); + // Function.prototype_or_hclass + JSHandle funcFuncIntanceHClass = + factory_->NewEcmaHClass(JSFunction::SIZE, JSType::JS_FUNCTION, funcFuncPrototypeValue); + funcFuncIntanceHClass->SetConstructor(true); // Function = new Function() (forbidden use NewBuiltinConstructor) JSHandle funcFunc = - factory_->NewJSFunctionByDynClass(reinterpret_cast(Function::FunctionConstructor), - funcFuncIntanceDynclass, FunctionKind::BUILTIN_CONSTRUCTOR); + factory_->NewJSFunctionByHClass(reinterpret_cast(Function::FunctionConstructor), + funcFuncIntanceHClass, FunctionKind::BUILTIN_CONSTRUCTOR); auto funcFuncPrototypeObj = JSHandle(funcFuncPrototype); InitializeCtor(env, funcFuncPrototypeObj, funcFunc, "Function", FunctionLength::ONE); - funcFunc->SetFunctionPrototype(thread_, funcFuncIntanceDynclass.GetTaggedValue()); + funcFunc->SetFunctionPrototype(thread_, funcFuncIntanceHClass.GetTaggedValue()); env->SetFunctionFunction(thread_, funcFunc); env->SetFunctionPrototype(thread_, funcFuncPrototype); JSHandle normalFuncClass = - factory_->NewEcmaDynClass(JSFunction::SIZE, JSType::JS_FUNCTION, env->GetFunctionPrototype()); + factory_->NewEcmaHClass(JSFunction::SIZE, JSType::JS_FUNCTION, env->GetFunctionPrototype()); env->SetNormalFunctionClass(thread_, normalFuncClass); JSHandle jSIntlBoundFunctionClass = @@ -431,7 +431,7 @@ void Builtins::InitializeFunction(const JSHandle &env, const JSHandle env->SetJSIntlBoundFunctionClass(thread_, jSIntlBoundFunctionClass); JSHandle constructorFunctionClass = - factory_->NewEcmaDynClass(JSFunction::SIZE, JSType::JS_FUNCTION, env->GetFunctionPrototype()); + factory_->NewEcmaHClass(JSFunction::SIZE, JSType::JS_FUNCTION, env->GetFunctionPrototype()); constructorFunctionClass->SetConstructor(true); env->SetConstructorFunctionClass(thread_, constructorFunctionClass); @@ -520,22 +520,22 @@ void Builtins::InitializeObject(const JSHandle &env, const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeSymbol(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); // Symbol.prototype - JSHandle symbolFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle symbolFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle symbolFuncPrototypeValue(symbolFuncPrototype); - // Symbol.prototype_or_dynclass - JSHandle symbolFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, symbolFuncPrototypeValue); + // Symbol.prototype_or_hclass + JSHandle symbolFuncInstanceHClass = + factory_->NewEcmaHClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, symbolFuncPrototypeValue); // Symbol = new Function() JSHandle symbolFunction( NewBuiltinConstructor(env, symbolFuncPrototype, Symbol::SymbolConstructor, "Symbol", FunctionLength::ZERO)); - JSHandle(symbolFunction)->SetFunctionPrototype(thread_, symbolFuncInstanceDynclass.GetTaggedValue()); + JSHandle(symbolFunction)->SetFunctionPrototype(thread_, symbolFuncInstanceHClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); @@ -622,22 +622,22 @@ void Builtins::InitializeSymbol(const JSHandle &env, const JSHandle &realm, - const JSHandle &objFuncInstanceDynclass) + const JSHandle &objFuncInstanceHClass) { [[maybe_unused]] EcmaHandleScope scope(thread_); JSHandle env = vm_->GetGlobalEnv(); // Symbol.prototype - JSHandle symbolFuncPrototype = factory_->NewJSObjectWithInit(objFuncInstanceDynclass); + JSHandle symbolFuncPrototype = factory_->NewJSObjectWithInit(objFuncInstanceHClass); JSHandle symbolFuncPrototypeValue(symbolFuncPrototype); - // Symbol.prototype_or_dynclass - JSHandle symbolFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, symbolFuncPrototypeValue); + // Symbol.prototype_or_hclass + JSHandle symbolFuncInstanceHClass = + factory_->NewEcmaHClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, symbolFuncPrototypeValue); // Symbol = new Function() JSHandle symbolFunction( NewBuiltinConstructor(realm, symbolFuncPrototype, Symbol::SymbolConstructor, "Symbol", FunctionLength::ZERO)); - JSHandle(symbolFunction)->SetFunctionPrototype(thread_, symbolFuncInstanceDynclass.GetTaggedValue()); + JSHandle(symbolFunction)->SetFunctionPrototype(thread_, symbolFuncInstanceHClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = thread_->GlobalConstants()->GetHandledConstructorString(); @@ -711,23 +711,23 @@ void Builtins::InitializeSymbolWithRealm(const JSHandle &realm, } void Builtins::InitializeNumber(const JSHandle &env, const JSHandle &globalObject, - const JSHandle &primRefObjDynclass) + const JSHandle &primRefObjHClass) { [[maybe_unused]] EcmaHandleScope scope(thread_); // Number.prototype JSHandle toObject(thread_, JSTaggedValue(FunctionLength::ZERO)); JSHandle numFuncPrototype = - JSHandle::Cast(factory_->NewJSPrimitiveRef(primRefObjDynclass, toObject)); + JSHandle::Cast(factory_->NewJSPrimitiveRef(primRefObjHClass, toObject)); JSHandle numFuncPrototypeValue(numFuncPrototype); - // Number.prototype_or_dynclass - JSHandle numFuncInstanceClass = - factory_->NewEcmaDynClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, numFuncPrototypeValue); + // Number.prototype_or_hclass + JSHandle numFuncInstanceHClass = + factory_->NewEcmaHClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, numFuncPrototypeValue); // Number = new Function() JSHandle numFunction( NewBuiltinConstructor(env, numFuncPrototype, Number::NumberConstructor, "Number", FunctionLength::ONE)); - numFunction.GetObject()->SetFunctionPrototype(thread_, numFuncInstanceClass.GetTaggedValue()); + numFunction.GetObject()->SetFunctionPrototype(thread_, numFuncInstanceHClass.GetTaggedValue()); // Number.prototype method SetFunction(env, numFuncPrototype, "toExponential", Number::ToExponential, FunctionLength::ONE); @@ -776,21 +776,21 @@ void Builtins::InitializeBigIntWithRealm(const JSHandle &realm) const JSObject::DefineOwnProperty(thread_, globalObject, nameString, descriptor); } -void Builtins::InitializeBigInt(const JSHandle &env, const JSHandle &primRefObjDynclass) const +void Builtins::InitializeBigInt(const JSHandle &env, const JSHandle &primRefObjHClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // BigInt.prototype - JSHandle bigIntFuncPrototype = factory_->NewJSObjectWithInit(primRefObjDynclass); + JSHandle bigIntFuncPrototype = factory_->NewJSObjectWithInit(primRefObjHClass); JSHandle bigIntFuncPrototypeValue(bigIntFuncPrototype); - // BigInt.prototype_or_dynclass - JSHandle bigIntFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, bigIntFuncPrototypeValue); + // BigInt.prototype_or_hclass + JSHandle bigIntFuncInstanceHClass = + factory_->NewEcmaHClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, bigIntFuncPrototypeValue); // BigInt = new Function() JSHandle bigIntFunction( NewBuiltinConstructor(env, bigIntFuncPrototype, BuiltinsBigInt::BigIntConstructor, "BigInt", FunctionLength::ONE)); - JSHandle(bigIntFunction)->SetFunctionPrototype(thread_, bigIntFuncInstanceDynclass.GetTaggedValue()); + JSHandle(bigIntFunction)->SetFunctionPrototype(thread_, bigIntFuncInstanceHClass.GetTaggedValue()); // BigInt.prototype method SetFunction(env, bigIntFuncPrototype, "toLocaleString", BuiltinsBigInt::ToLocaleString, FunctionLength::ZERO); @@ -806,22 +806,22 @@ void Builtins::InitializeBigInt(const JSHandle &env, const JSHandleSetBigIntFunction(thread_, bigIntFunction); } -void Builtins::InitializeDate(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeDate(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); constexpr int utcLength = 7; // Date.prototype - JSHandle dateFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle dateFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle dateFuncPrototypeValue(dateFuncPrototype); - // Date.prototype_or_dynclass - JSHandle dateFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSDate::SIZE, JSType::JS_DATE, dateFuncPrototypeValue); + // Date.prototype_or_hclass + JSHandle dateFuncInstanceHClass = + factory_->NewEcmaHClass(JSDate::SIZE, JSType::JS_DATE, dateFuncPrototypeValue); // Date = new Function() JSHandle dateFunction( NewBuiltinConstructor(env, dateFuncPrototype, Date::DateConstructor, "Date", FunctionLength::ONE)); - JSHandle(dateFunction)->SetFunctionPrototype(thread_, dateFuncInstanceDynclass.GetTaggedValue()); + JSHandle(dateFunction)->SetFunctionPrototype(thread_, dateFuncInstanceHClass.GetTaggedValue()); // Date.prototype method SetFunction(env, dateFuncPrototype, "getDate", Date::GetDate, FunctionLength::ZERO); @@ -886,23 +886,23 @@ void Builtins::InitializeDate(const JSHandle &env, const JSHandleSetDateFunction(thread_, dateFunction); } -void Builtins::InitializeBoolean(const JSHandle &env, const JSHandle &primRefObjDynclass) const +void Builtins::InitializeBoolean(const JSHandle &env, const JSHandle &primRefObjHClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Boolean.prototype JSHandle toObject(thread_, JSTaggedValue::False()); JSHandle booleanFuncPrototype = - JSHandle::Cast(factory_->NewJSPrimitiveRef(primRefObjDynclass, toObject)); + JSHandle::Cast(factory_->NewJSPrimitiveRef(primRefObjHClass, toObject)); JSHandle booleanFuncPrototypeValue(booleanFuncPrototype); - // Boolean.prototype_or_dynclass - JSHandle booleanFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, booleanFuncPrototypeValue); + // Boolean.prototype_or_hclass + JSHandle booleanFuncInstanceHClass = + factory_->NewEcmaHClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, booleanFuncPrototypeValue); // new Boolean Function() JSHandle booleanFunction( NewBuiltinConstructor(env, booleanFuncPrototype, Boolean::BooleanConstructor, "Boolean", FunctionLength::ONE)); - booleanFunction->SetFunctionPrototype(thread_, booleanFuncInstanceDynclass.GetTaggedValue()); + booleanFunction->SetFunctionPrototype(thread_, booleanFuncInstanceHClass.GetTaggedValue()); // Boolean.prototype method SetFunction(env, booleanFuncPrototype, thread_->GlobalConstants()->GetHandledToStringString(), @@ -939,18 +939,18 @@ JSHandle Builtins::InitializeExoticConstructor(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeAsyncFunction(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); // AsyncFunction.prototype - JSHandle asyncFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle asyncFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSObject::SetPrototype(thread_, asyncFuncPrototype, env->GetFunctionPrototype()); JSHandle async_func_prototype_value(asyncFuncPrototype); - // AsyncFunction.prototype_or_dynclass - JSHandle asyncFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSAsyncFunction::SIZE, JSType::JS_ASYNC_FUNCTION, async_func_prototype_value); + // AsyncFunction.prototype_or_hclass + JSHandle asyncFuncInstanceHClass = + factory_->NewEcmaHClass(JSAsyncFunction::SIZE, JSType::JS_ASYNC_FUNCTION, async_func_prototype_value); // AsyncFunction = new Function() JSHandle asyncFunction = NewBuiltinConstructor( @@ -959,7 +959,7 @@ void Builtins::InitializeAsyncFunction(const JSHandle &env, const JSH JSHandle constructorKey = globalConst->GetHandledConstructorString(); PropertyDescriptor asyncDesc(thread_, JSHandle::Cast(asyncFunction), false, false, true); JSObject::DefineOwnProperty(thread_, asyncFuncPrototype, constructorKey, asyncDesc); - asyncFunction->SetProtoOrDynClass(thread_, asyncFuncInstanceDynclass.GetTaggedValue()); + asyncFunction->SetProtoOrHClass(thread_, asyncFuncInstanceHClass.GetTaggedValue()); // AsyncFunction.prototype property SetStringTagSymbol(env, asyncFuncPrototype, "AsyncFunction"); @@ -967,18 +967,18 @@ void Builtins::InitializeAsyncFunction(const JSHandle &env, const JSH env->SetAsyncFunctionPrototype(thread_, asyncFuncPrototype); } -void Builtins::InitializeAllTypeError(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeAllTypeError(const JSHandle &env, const JSHandle &objFuncClass) const { // Error.prototype - JSHandle errorFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle errorFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle errorFuncPrototypeValue(errorFuncPrototype); - // Error.prototype_or_dynclass - JSHandle errorFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSObject::SIZE, JSType::JS_ERROR, errorFuncPrototypeValue); + // Error.prototype_or_hclass + JSHandle errorFuncInstanceHClass = + factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_ERROR, errorFuncPrototypeValue); // Error() = new Function() JSHandle errorFunction( NewBuiltinConstructor(env, errorFuncPrototype, Error::ErrorConstructor, "Error", FunctionLength::ONE)); - errorFunction->SetFunctionPrototype(thread_, errorFuncInstanceDynclass.GetTaggedValue()); + errorFunction->SetFunctionPrototype(thread_, errorFuncInstanceHClass.GetTaggedValue()); // Error.prototype method SetFunction(env, errorFuncPrototype, thread_->GlobalConstants()->GetHandledToStringString(), Error::ToString, @@ -990,19 +990,19 @@ void Builtins::InitializeAllTypeError(const JSHandle &env, const JSHa env->SetErrorFunction(thread_, errorFunction); JSHandle nativeErrorFuncClass = - factory_->NewEcmaDynClass(JSFunction::SIZE, JSType::JS_FUNCTION, env->GetErrorFunction()); + factory_->NewEcmaHClass(JSFunction::SIZE, JSType::JS_FUNCTION, env->GetErrorFunction()); nativeErrorFuncClass->SetConstructor(true); env->SetNativeErrorFunctionClass(thread_, nativeErrorFuncClass); - JSHandle errorNativeFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSObject::SIZE, JSType::JS_OBJECT, errorFuncPrototypeValue); - InitializeError(env, errorNativeFuncInstanceDynclass, JSType::JS_RANGE_ERROR); - InitializeError(env, errorNativeFuncInstanceDynclass, JSType::JS_REFERENCE_ERROR); - InitializeError(env, errorNativeFuncInstanceDynclass, JSType::JS_TYPE_ERROR); - InitializeError(env, errorNativeFuncInstanceDynclass, JSType::JS_AGGREGATE_ERROR); - InitializeError(env, errorNativeFuncInstanceDynclass, JSType::JS_URI_ERROR); - InitializeError(env, errorNativeFuncInstanceDynclass, JSType::JS_SYNTAX_ERROR); - InitializeError(env, errorNativeFuncInstanceDynclass, JSType::JS_EVAL_ERROR); + JSHandle errorNativeFuncInstanceHClass = + factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, errorFuncPrototypeValue); + InitializeError(env, errorNativeFuncInstanceHClass, JSType::JS_RANGE_ERROR); + InitializeError(env, errorNativeFuncInstanceHClass, JSType::JS_REFERENCE_ERROR); + InitializeError(env, errorNativeFuncInstanceHClass, JSType::JS_TYPE_ERROR); + InitializeError(env, errorNativeFuncInstanceHClass, JSType::JS_AGGREGATE_ERROR); + InitializeError(env, errorNativeFuncInstanceHClass, JSType::JS_URI_ERROR); + InitializeError(env, errorNativeFuncInstanceHClass, JSType::JS_SYNTAX_ERROR); + InitializeError(env, errorNativeFuncInstanceHClass, JSType::JS_EVAL_ERROR); } void Builtins::InitializeAllTypeErrorWithRealm(const JSHandle &realm) const @@ -1080,11 +1080,11 @@ void Builtins::GeneralUpdateError(ErrorParameter *error, EcmaEntrypoint construc error->nativeJstype = type; } -void Builtins::InitializeError(const JSHandle &env, const JSHandle &objFuncDynclass, +void Builtins::InitializeError(const JSHandle &env, const JSHandle &objFuncClass, const JSType &errorTag) const { // NativeError.prototype - JSHandle nativeErrorFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle nativeErrorFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle nativeErrorFuncPrototypeValue(nativeErrorFuncPrototype); ErrorParameter errorParameter{RangeError::RangeErrorConstructor, RangeError::ToString, "RangeError", @@ -1122,9 +1122,9 @@ void Builtins::InitializeError(const JSHandle &env, const JSHandle nativeErrorFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSObject::SIZE, errorParameter.nativeJstype, nativeErrorFuncPrototypeValue); + // NativeError.prototype_or_hclass + JSHandle nativeErrorFuncInstanceHClass = + factory_->NewEcmaHClass(JSObject::SIZE, errorParameter.nativeJstype, nativeErrorFuncPrototypeValue); // NativeError() = new Error() FunctionLength functionLength = FunctionLength::ONE; @@ -1136,7 +1136,7 @@ void Builtins::InitializeError(const JSHandle &env, const JSHandleSetFunctionPrototype(thread_, nativeErrorFuncInstanceDynclass.GetTaggedValue()); + nativeErrorFunction->SetFunctionPrototype(thread_, nativeErrorFuncInstanceHClass.GetTaggedValue()); // NativeError.prototype method SetFunction(env, nativeErrorFuncPrototype, thread_->GlobalConstants()->GetHandledToStringString(), @@ -1190,20 +1190,20 @@ void Builtins::InitializeCtor(const JSHandle &env, const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeSet(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); // Set.prototype - JSHandle setFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle setFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle setFuncPrototypeValue(setFuncPrototype); - // Set.prototype_or_dynclass - JSHandle setFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSSet::SIZE, JSType::JS_SET, setFuncPrototypeValue); + // Set.prototype_or_hclass + JSHandle setFuncInstanceHClass = + factory_->NewEcmaHClass(JSSet::SIZE, JSType::JS_SET, setFuncPrototypeValue); // Set() = new Function() JSHandle setFunction( NewBuiltinConstructor(env, setFuncPrototype, BuiltinsSet::SetConstructor, "Set", FunctionLength::ZERO)); - JSHandle(setFunction)->SetFunctionPrototype(thread_, setFuncInstanceDynclass.GetTaggedValue()); + JSHandle(setFunction)->SetFunctionPrototype(thread_, setFuncInstanceHClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); @@ -1251,22 +1251,22 @@ void Builtins::InitializeSet(const JSHandle &env, const JSHandleSetBuiltinsSetFunction(thread_, setFunction); } -void Builtins::InitializeMap(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeMap(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); // Map.prototype - JSHandle mapFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle mapFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle mapFuncPrototypeValue(mapFuncPrototype); - // Map.prototype_or_dynclass - JSHandle mapFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSMap::SIZE, JSType::JS_MAP, mapFuncPrototypeValue); + // Map.prototype_or_hclass + JSHandle mapFuncInstanceHClass = + factory_->NewEcmaHClass(JSMap::SIZE, JSType::JS_MAP, mapFuncPrototypeValue); // Map() = new Function() JSHandle mapFunction( NewBuiltinConstructor(env, mapFuncPrototype, BuiltinsMap::MapConstructor, "Map", FunctionLength::ZERO)); // Map().prototype = Map.Prototype & Map.prototype.constructor = Map() JSFunction::Cast(mapFunction->GetTaggedObject()) - ->SetFunctionPrototype(thread_, mapFuncInstanceDynclass.GetTaggedValue()); + ->SetFunctionPrototype(thread_, mapFuncInstanceHClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); @@ -1316,22 +1316,22 @@ void Builtins::InitializeMap(const JSHandle &env, const JSHandleSetMapPrototype(thread_, mapFuncPrototype); } -void Builtins::InitializeWeakMap(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeWeakMap(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); // WeakMap.prototype - JSHandle weakMapFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle weakMapFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle weakMapFuncPrototypeValue(weakMapFuncPrototype); - // WeakMap.prototype_or_dynclass - JSHandle weakMapFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSWeakMap::SIZE, JSType::JS_WEAK_MAP, weakMapFuncPrototypeValue); + // WeakMap.prototype_or_hclass + JSHandle weakMapFuncInstanceHClass = + factory_->NewEcmaHClass(JSWeakMap::SIZE, JSType::JS_WEAK_MAP, weakMapFuncPrototypeValue); // WeakMap() = new Function() JSHandle weakMapFunction(NewBuiltinConstructor( env, weakMapFuncPrototype, BuiltinsWeakMap::WeakMapConstructor, "WeakMap", FunctionLength::ZERO)); // WeakMap().prototype = WeakMap.Prototype & WeakMap.prototype.constructor = WeakMap() JSFunction::Cast(weakMapFunction->GetTaggedObject()) - ->SetProtoOrDynClass(thread_, weakMapFuncInstanceDynclass.GetTaggedValue()); + ->SetProtoOrHClass(thread_, weakMapFuncInstanceHClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); @@ -1352,20 +1352,20 @@ void Builtins::InitializeWeakMap(const JSHandle &env, const JSHandle< env->SetBuiltinsWeakMapFunction(thread_, weakMapFunction); } -void Builtins::InitializeWeakSet(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeWeakSet(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); // Set.prototype - JSHandle weakSetFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle weakSetFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle weakSetFuncPrototypeValue(weakSetFuncPrototype); - // Set.prototype_or_dynclass - JSHandle weakSetFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSWeakSet::SIZE, JSType::JS_WEAK_SET, weakSetFuncPrototypeValue); + // Set.prototype_or_hclass + JSHandle weakSetFuncInstanceHClass = + factory_->NewEcmaHClass(JSWeakSet::SIZE, JSType::JS_WEAK_SET, weakSetFuncPrototypeValue); // Set() = new Function() JSHandle weakSetFunction(NewBuiltinConstructor( env, weakSetFuncPrototype, BuiltinsWeakSet::WeakSetConstructor, "WeakSet", FunctionLength::ZERO)); - JSHandle(weakSetFunction)->SetProtoOrDynClass(thread_, weakSetFuncInstanceDynclass.GetTaggedValue()); + JSHandle(weakSetFunction)->SetProtoOrHClass(thread_, weakSetFuncInstanceHClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); @@ -1387,9 +1387,9 @@ void Builtins::InitializeAtomics(const JSHandle &env, const JSHandle &objFuncPrototypeVal) const { [[maybe_unused]] EcmaHandleScope scope(thread_); - JSHandle atomicsDynclass = factory_->NewEcmaDynClass(JSObject::SIZE, JSType::JS_OBJECT, + JSHandle atomicsHClass = factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, objFuncPrototypeVal); - JSHandle atomicsObject = factory_->NewJSObject(atomicsDynclass); + JSHandle atomicsObject = factory_->NewJSObject(atomicsHClass); SetFunction(env, atomicsObject, "add", Atomics::Add, FunctionLength::THREE); SetFunction(env, atomicsObject, "and", Atomics::And, FunctionLength::THREE); SetFunction(env, atomicsObject, "sub", Atomics::Sub, FunctionLength::THREE); @@ -1411,20 +1411,20 @@ void Builtins::InitializeAtomics(const JSHandle &env, env->SetAtomicsFunction(thread_, atomicsObject); } -void Builtins::InitializeWeakRef(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeWeakRef(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); // WeakRef.prototype - JSHandle weakRefFuncPrototype = factory_->NewJSObject(objFuncDynclass); + JSHandle weakRefFuncPrototype = factory_->NewJSObject(objFuncClass); JSHandle weakRefFuncPrototypeValue(weakRefFuncPrototype); - // WeakRef.prototype_or_dynclass - JSHandle weakRefFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSWeakRef::SIZE, JSType::JS_WEAK_REF, weakRefFuncPrototypeValue); + // WeakRef.prototype_or_hclass + JSHandle weakRefFuncInstanceHClass = + factory_->NewEcmaHClass(JSWeakRef::SIZE, JSType::JS_WEAK_REF, weakRefFuncPrototypeValue); // WeakRef() = new Function() JSHandle weakRefFunction(NewBuiltinConstructor( env, weakRefFuncPrototype, BuiltinsWeakRef::WeakRefConstructor, "WeakRef", FunctionLength::ONE)); - JSHandle(weakRefFunction)->SetProtoOrDynClass(thread_, weakRefFuncInstanceDynclass.GetTaggedValue()); + JSHandle(weakRefFunction)->SetProtoOrHClass(thread_, weakRefFuncInstanceHClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); @@ -1439,23 +1439,23 @@ void Builtins::InitializeWeakRef(const JSHandle &env, const JSHandle< } void Builtins::InitializeFinalizationRegistry(const JSHandle &env, - const JSHandle &objFuncDynclass) const + const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); // FinalizationRegistry.prototype - JSHandle finalizationRegistryFuncPrototype = factory_->NewJSObject(objFuncDynclass); + JSHandle finalizationRegistryFuncPrototype = factory_->NewJSObject(objFuncClass); JSHandle finalizationRegistryFuncPrototypeValue(finalizationRegistryFuncPrototype); - // FinalizationRegistry.prototype_or_dynclass - JSHandle finalizationRegistryFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSFinalizationRegistry::SIZE, JSType::JS_FINALIZATION_REGISTRY, + // FinalizationRegistry.prototype_or_hclass + JSHandle finalizationRegistryFuncInstanceHClass = + factory_->NewEcmaHClass(JSFinalizationRegistry::SIZE, JSType::JS_FINALIZATION_REGISTRY, finalizationRegistryFuncPrototypeValue); // FinalizationRegistry() = new Function() JSHandle finalizationRegistryFunction(NewBuiltinConstructor( env, finalizationRegistryFuncPrototype, BuiltinsFinalizationRegistry::FinalizationRegistryConstructor, "FinalizationRegistry", FunctionLength::ONE)); - JSHandle(finalizationRegistryFunction)->SetProtoOrDynClass( - thread_, finalizationRegistryFuncInstanceDynclass.GetTaggedValue()); + JSHandle(finalizationRegistryFunction)->SetProtoOrHClass( + thread_, finalizationRegistryFuncInstanceHClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); @@ -1475,8 +1475,8 @@ void Builtins::InitializeFinalizationRegistry(const JSHandle &env, void Builtins::InitializeMath(const JSHandle &env, const JSHandle &objFuncPrototypeVal) const { [[maybe_unused]] EcmaHandleScope scope(thread_); - JSHandle mathDynclass = factory_->NewEcmaDynClass(JSObject::SIZE, JSType::JS_OBJECT, objFuncPrototypeVal); - JSHandle mathObject = factory_->NewJSObjectWithInit(mathDynclass); + JSHandle mathClass = factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, objFuncPrototypeVal); + JSHandle mathObject = factory_->NewJSObjectWithInit(mathClass); SetFunction(env, mathObject, "abs", Math::Abs, FunctionLength::ONE); SetFunction(env, mathObject, "acos", Math::Acos, FunctionLength::ONE); SetFunction(env, mathObject, "acosh", Math::Acosh, FunctionLength::ONE); @@ -1534,8 +1534,8 @@ void Builtins::InitializeMath(const JSHandle &env, const JSHandle &env, const JSHandle &objFuncPrototypeVal) const { [[maybe_unused]] EcmaHandleScope scope(thread_); - JSHandle jsonDynclass = factory_->NewEcmaDynClass(JSObject::SIZE, JSType::JS_OBJECT, objFuncPrototypeVal); - JSHandle jsonObject = factory_->NewJSObjectWithInit(jsonDynclass); + JSHandle jsonHClass = factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, objFuncPrototypeVal); + JSHandle jsonObject = factory_->NewJSObjectWithInit(jsonHClass); SetFunction(env, jsonObject, "parse", Json::Parse, FunctionLength::TWO); SetFunction(env, jsonObject, "stringify", Json::Stringify, FunctionLength::THREE); @@ -1549,23 +1549,23 @@ void Builtins::InitializeJson(const JSHandle &env, const JSHandleSetJsonFunction(thread_, jsonObject); } -void Builtins::InitializeString(const JSHandle &env, const JSHandle &primRefObjDynclass) const +void Builtins::InitializeString(const JSHandle &env, const JSHandle &primRefObjHClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // String.prototype JSHandle toObject(factory_->GetEmptyString()); JSHandle stringFuncPrototype = - JSHandle::Cast(factory_->NewJSPrimitiveRef(primRefObjDynclass, toObject)); + JSHandle::Cast(factory_->NewJSPrimitiveRef(primRefObjHClass, toObject)); JSHandle stringFuncPrototypeValue(stringFuncPrototype); - // String.prototype_or_dynclass - JSHandle stringFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, stringFuncPrototypeValue); + // String.prototype_or_hclass + JSHandle stringFuncInstanceHClass = + factory_->NewEcmaHClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, stringFuncPrototypeValue); // String = new Function() JSHandle stringFunction(NewBuiltinConstructor(env, stringFuncPrototype, BuiltinsString::StringConstructor, "String", FunctionLength::ONE)); - stringFunction.GetObject()->SetFunctionPrototype(thread_, stringFuncInstanceDynclass.GetTaggedValue()); + stringFunction.GetObject()->SetFunctionPrototype(thread_, stringFuncInstanceHClass.GetTaggedValue()); // String.prototype method SetFunction(env, stringFuncPrototype, "charAt", BuiltinsString::CharAt, FunctionLength::ONE); @@ -1623,18 +1623,18 @@ void Builtins::InitializeString(const JSHandle &env, const JSHandle &env, - const JSHandle &iteratorFuncDynclass) const + const JSHandle &iteratorFuncClass) const { // StringIterator.prototype - JSHandle strIterPrototype(factory_->NewJSObjectWithInit(iteratorFuncDynclass)); + JSHandle strIterPrototype(factory_->NewJSObjectWithInit(iteratorFuncClass)); - // StringIterator.prototype_or_dynclass - JSHandle strIterFuncInstanceDynclass = factory_->NewEcmaDynClass( + // StringIterator.prototype_or_hclass + JSHandle strIterFuncInstanceHClass = factory_->NewEcmaHClass( JSStringIterator::SIZE, JSType::JS_STRING_ITERATOR, JSHandle(strIterPrototype)); JSHandle strIterFunction( factory_->NewJSFunction(env, static_cast(nullptr), FunctionKind::BASE_CONSTRUCTOR)); - strIterFunction->SetFunctionPrototype(thread_, strIterFuncInstanceDynclass.GetTaggedValue()); + strIterFunction->SetFunctionPrototype(thread_, strIterFuncInstanceHClass.GetTaggedValue()); SetFunction(env, strIterPrototype, "next", StringIterator::Next, FunctionLength::ZERO); SetStringTagSymbol(env, strIterPrototype, "String Iterator"); @@ -1643,11 +1643,11 @@ void Builtins::InitializeStringIterator(const JSHandle &env, env->SetStringIteratorPrototype(thread_, strIterPrototype); } -void Builtins::InitializeIterator(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeIterator(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Iterator.prototype - JSHandle iteratorPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle iteratorPrototype = factory_->NewJSObjectWithInit(objFuncClass); // Iterator.prototype.next() SetFunction(env, iteratorPrototype, "next", BuiltinsIterator::Next, FunctionLength::ONE); // Iterator.prototype.return() @@ -1659,50 +1659,50 @@ void Builtins::InitializeIterator(const JSHandle &env, const JSHandle BuiltinsIterator::GetIteratorObj, FunctionLength::ZERO); env->SetIteratorPrototype(thread_, iteratorPrototype); - // Iterator.dynclass - JSHandle iteratorFuncDynclass = - factory_->NewEcmaDynClass(JSObject::SIZE, JSType::JS_ITERATOR, JSHandle(iteratorPrototype)); + // Iterator.hclass + JSHandle iteratorFuncClass = + factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_ITERATOR, JSHandle(iteratorPrototype)); auto globalConst = const_cast(thread_->GlobalConstants()); - globalConst->SetConstant(ConstantIndex::JS_API_ITERATOR_FUNC_DYN_CLASS_INDEX, iteratorFuncDynclass); + globalConst->SetConstant(ConstantIndex::JS_API_ITERATOR_FUNC_DYN_CLASS_INDEX, iteratorFuncClass); - // Iterator result dynclass - JSHandle iterResultClass = factory_->CreateIteratorResultInstanceClass(); - globalConst->SetConstant(ConstantIndex::ITERATOR_RESULT_CLASS, iterResultClass); + // Iterator result hclass + JSHandle iterResultHClass = factory_->CreateIteratorResultInstanceClass(); + globalConst->SetConstant(ConstantIndex::ITERATOR_RESULT_CLASS, iterResultHClass); // ues for CloseIterator JSHandle record = factory_->NewCompletionRecord(CompletionRecordType::NORMAL, globalConst->GetHandledUndefined()); globalConst->SetConstant(ConstantIndex::UNDEFINED_COMPLRTION_RECORD_INDEX, record); - InitializeForinIterator(env, iteratorFuncDynclass); - InitializeSetIterator(env, iteratorFuncDynclass); - InitializeMapIterator(env, iteratorFuncDynclass); - InitializeArrayIterator(env, iteratorFuncDynclass); - InitializeStringIterator(env, iteratorFuncDynclass); - InitializeRegexpIterator(env, iteratorFuncDynclass); + InitializeForinIterator(env, iteratorFuncClass); + InitializeSetIterator(env, iteratorFuncClass); + InitializeMapIterator(env, iteratorFuncClass); + InitializeArrayIterator(env, iteratorFuncClass); + InitializeStringIterator(env, iteratorFuncClass); + InitializeRegexpIterator(env, iteratorFuncClass); } void Builtins::InitializeForinIterator(const JSHandle &env, - const JSHandle &iteratorFuncDynclass) const + const JSHandle &iteratorFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Iterator.prototype - JSHandle forinIteratorPrototype = factory_->NewJSObjectWithInit(iteratorFuncDynclass); - JSHandle dynclass = factory_->NewEcmaDynClass(JSForInIterator::SIZE, JSType::JS_FORIN_ITERATOR, + JSHandle forinIteratorPrototype = factory_->NewJSObjectWithInit(iteratorFuncClass); + JSHandle hclass = factory_->NewEcmaHClass(JSForInIterator::SIZE, JSType::JS_FORIN_ITERATOR, JSHandle(forinIteratorPrototype)); // Iterator.prototype.next() SetFunction(env, forinIteratorPrototype, "next", JSForInIterator::Next, FunctionLength::ONE); env->SetForinIteratorPrototype(thread_, forinIteratorPrototype); - env->SetForinIteratorClass(thread_, dynclass); + env->SetForinIteratorClass(thread_, hclass); } void Builtins::InitializeSetIterator(const JSHandle &env, - const JSHandle &iteratorFuncDynclass) const + const JSHandle &iteratorFuncClass) const { // SetIterator.prototype - JSHandle setIteratorPrototype(factory_->NewJSObjectWithInit(iteratorFuncDynclass)); + JSHandle setIteratorPrototype(factory_->NewJSObjectWithInit(iteratorFuncClass)); // Iterator.prototype.next() SetFunction(env, setIteratorPrototype, "next", JSSetIterator::Next, FunctionLength::ZERO); SetStringTagSymbol(env, setIteratorPrototype, "Set Iterator"); @@ -1710,20 +1710,20 @@ void Builtins::InitializeSetIterator(const JSHandle &env, } void Builtins::InitializeMapIterator(const JSHandle &env, - const JSHandle &iteratorFuncDynclass) const + const JSHandle &iteratorFuncClass) const { // MapIterator.prototype - JSHandle mapIteratorPrototype(factory_->NewJSObjectWithInit(iteratorFuncDynclass)); + JSHandle mapIteratorPrototype(factory_->NewJSObjectWithInit(iteratorFuncClass)); // Iterator.prototype.next() SetFunction(env, mapIteratorPrototype, "next", JSMapIterator::Next, FunctionLength::ZERO); SetStringTagSymbol(env, mapIteratorPrototype, "Map Iterator"); env->SetMapIteratorPrototype(thread_, mapIteratorPrototype); } void Builtins::InitializeArrayIterator(const JSHandle &env, - const JSHandle &iteratorFuncDynclass) const + const JSHandle &iteratorFuncClass) const { // ArrayIterator.prototype - JSHandle arrayIteratorPrototype(factory_->NewJSObjectWithInit(iteratorFuncDynclass)); + JSHandle arrayIteratorPrototype(factory_->NewJSObjectWithInit(iteratorFuncClass)); // Iterator.prototype.next() SetFunction(env, arrayIteratorPrototype, "next", JSArrayIterator::Next, FunctionLength::ZERO); SetStringTagSymbol(env, arrayIteratorPrototype, "Array Iterator"); @@ -1731,10 +1731,10 @@ void Builtins::InitializeArrayIterator(const JSHandle &env, } void Builtins::InitializeRegexpIterator(const JSHandle &env, - const JSHandle &iteratorFuncDynclass) const + const JSHandle &iteratorFuncClass) const { // RegExpIterator.prototype - JSHandle regExpIteratorPrototype(factory_->NewJSObject(iteratorFuncDynclass)); + JSHandle regExpIteratorPrototype(factory_->NewJSObject(iteratorFuncClass)); // Iterator.prototype.next() SetFunction(env, regExpIteratorPrototype, "next", JSRegExpIterator::Next, FunctionLength::ZERO); SetStringTagSymbol(env, regExpIteratorPrototype, "RegExp String Iterator"); @@ -1749,14 +1749,14 @@ void Builtins::InitializeRegExp(const JSHandle &env) JSHandle regPrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle regPrototypeValue(regPrototype); - // RegExp.prototype_or_dynclass - JSHandle regexpFuncInstanceDynclass = factory_->CreateJSRegExpInstanceClass(regPrototypeValue); + // RegExp.prototype_or_hclass + JSHandle regexpFuncInstanceHClass = factory_->CreateJSRegExpInstanceClass(regPrototypeValue); // RegExp = new Function() JSHandle regexpFunction( NewBuiltinConstructor(env, regPrototype, RegExp::RegExpConstructor, "RegExp", FunctionLength::TWO)); - JSHandle(regexpFunction)->SetFunctionPrototype(thread_, regexpFuncInstanceDynclass.GetTaggedValue()); + JSHandle(regexpFunction)->SetFunctionPrototype(thread_, regexpFuncInstanceHClass.GetTaggedValue()); const GlobalEnvConstants *globalConstants = thread_->GlobalConstants(); // RegExp.prototype method @@ -1821,24 +1821,24 @@ void Builtins::InitializeRegExp(const JSHandle &env) env->SetRegExpFunction(thread_, regexpFunction); auto globalConst = const_cast(thread_->GlobalConstants()); - globalConst->SetConstant(ConstantIndex::JS_REGEXP_CLASS_INDEX, regexpFuncInstanceDynclass.GetTaggedValue()); + globalConst->SetConstant(ConstantIndex::JS_REGEXP_CLASS_INDEX, regexpFuncInstanceHClass.GetTaggedValue()); } void Builtins::InitializeArray(const JSHandle &env, const JSHandle &objFuncPrototypeVal) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Arraybase.prototype - JSHandle arrBaseFuncInstanceDynclass = factory_->CreateJSArrayInstanceClass(objFuncPrototypeVal); + JSHandle arrBaseFuncInstanceHClass = factory_->CreateJSArrayInstanceClass(objFuncPrototypeVal); // Array.prototype - JSHandle arrFuncPrototype = factory_->NewJSObjectWithInit(arrBaseFuncInstanceDynclass); + JSHandle arrFuncPrototype = factory_->NewJSObjectWithInit(arrBaseFuncInstanceHClass); JSHandle::Cast(arrFuncPrototype)->SetLength(thread_, JSTaggedValue(FunctionLength::ZERO)); auto accessor = thread_->GlobalConstants()->GetArrayLengthAccessor(); JSArray::Cast(*arrFuncPrototype)->SetPropertyInlinedProps(thread_, JSArray::LENGTH_INLINE_PROPERTY_INDEX, accessor); JSHandle arrFuncPrototypeValue(arrFuncPrototype); - // Array.prototype_or_dynclass - JSHandle arrFuncInstanceDynclass = factory_->CreateJSArrayInstanceClass(arrFuncPrototypeValue); + // Array.prototype_or_hclass + JSHandle arrFuncInstanceHClass = factory_->CreateJSArrayInstanceClass(arrFuncPrototypeValue); // Array = new Function() JSHandle arrayFunction( @@ -1850,7 +1850,7 @@ void Builtins::InitializeArray(const JSHandle &env, const JSHandleSetParentEnv(thread_, env.GetTaggedValue()); arrayFuncFunction->SetLexicalEnv(thread_, lexicalEnv.GetTaggedValue()); - arrayFuncFunction->SetFunctionPrototype(thread_, arrFuncInstanceDynclass.GetTaggedValue()); + arrayFuncFunction->SetFunctionPrototype(thread_, arrFuncInstanceHClass.GetTaggedValue()); // Array.prototype method SetFunction(env, arrFuncPrototype, "concat", BuiltinsArray::Concat, FunctionLength::ONE); @@ -1927,15 +1927,15 @@ void Builtins::InitializeArray(const JSHandle &env, const JSHandleSetArrayPrototype(thread_, arrFuncPrototype); } -void Builtins::InitializeTypedArray(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeTypedArray(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // TypedArray.prototype - JSHandle typedArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle typedArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle typedArrFuncPrototypeValue(typedArrFuncPrototype); - // TypedArray.prototype_or_dynclass - JSHandle typedArrFuncInstanceDynclass = factory_->NewEcmaDynClass( + // TypedArray.prototype_or_hclass + JSHandle typedArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_TYPED_ARRAY, typedArrFuncPrototypeValue); // TypedArray = new Function() @@ -1943,7 +1943,7 @@ void Builtins::InitializeTypedArray(const JSHandle &env, const JSHand env, typedArrFuncPrototype, BuiltinsTypedArray::TypedArrayBaseConstructor, "TypedArray", FunctionLength::ZERO)); JSHandle(typedArrayFunction) - ->SetProtoOrDynClass(thread_, typedArrFuncInstanceDynclass.GetTaggedValue()); + ->SetProtoOrHClass(thread_, typedArrFuncInstanceHClass.GetTaggedValue()); // TypedArray.prototype method SetFunction(env, typedArrFuncPrototype, "copyWithin", BuiltinsTypedArray::CopyWithin, FunctionLength::TWO); @@ -2028,32 +2028,32 @@ void Builtins::InitializeTypedArray(const JSHandle &env, const JSHand env->SetTypedArrayPrototype(thread_, typedArrFuncPrototype); JSHandle specificTypedArrayFuncClass = - factory_->NewEcmaDynClass(JSFunction::SIZE, JSType::JS_FUNCTION, env->GetTypedArrayFunction()); + factory_->NewEcmaHClass(JSFunction::SIZE, JSType::JS_FUNCTION, env->GetTypedArrayFunction()); specificTypedArrayFuncClass->SetConstructor(true); env->SetSpecificTypedArrayFunctionClass(thread_, specificTypedArrayFuncClass); - InitializeInt8Array(env, typedArrFuncInstanceDynclass); - InitializeUint8Array(env, typedArrFuncInstanceDynclass); - InitializeUint8ClampedArray(env, typedArrFuncInstanceDynclass); - InitializeInt16Array(env, typedArrFuncInstanceDynclass); - InitializeUint16Array(env, typedArrFuncInstanceDynclass); - InitializeInt32Array(env, typedArrFuncInstanceDynclass); - InitializeUint32Array(env, typedArrFuncInstanceDynclass); - InitializeFloat32Array(env, typedArrFuncInstanceDynclass); - InitializeFloat64Array(env, typedArrFuncInstanceDynclass); - InitializeBigInt64Array(env, typedArrFuncInstanceDynclass); - InitializeBigUint64Array(env, typedArrFuncInstanceDynclass); + InitializeInt8Array(env, typedArrFuncInstanceHClass); + InitializeUint8Array(env, typedArrFuncInstanceHClass); + InitializeUint8ClampedArray(env, typedArrFuncInstanceHClass); + InitializeInt16Array(env, typedArrFuncInstanceHClass); + InitializeUint16Array(env, typedArrFuncInstanceHClass); + InitializeInt32Array(env, typedArrFuncInstanceHClass); + InitializeUint32Array(env, typedArrFuncInstanceHClass); + InitializeFloat32Array(env, typedArrFuncInstanceHClass); + InitializeFloat64Array(env, typedArrFuncInstanceHClass); + InitializeBigInt64Array(env, typedArrFuncInstanceHClass); + InitializeBigUint64Array(env, typedArrFuncInstanceHClass); } -void Builtins::InitializeInt8Array(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeInt8Array(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Int8Array.prototype - JSHandle int8ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle int8ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle int8ArrFuncPrototypeValue(int8ArrFuncPrototype); - // Int8Array.prototype_or_dynclass - JSHandle int8ArrFuncInstanceDynclass = factory_->NewEcmaDynClass( + // Int8Array.prototype_or_hclass + JSHandle int8ArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_INT8_ARRAY, int8ArrFuncPrototypeValue); // Int8Array = new Function() @@ -2061,7 +2061,7 @@ void Builtins::InitializeInt8Array(const JSHandle &env, const JSHandl env, reinterpret_cast(BuiltinsTypedArray::Int8ArrayConstructor)); InitializeCtor(env, int8ArrFuncPrototype, int8ArrayFunction, "Int8Array", FunctionLength::THREE); - int8ArrayFunction->SetProtoOrDynClass(thread_, int8ArrFuncInstanceDynclass.GetTaggedValue()); + int8ArrayFunction->SetProtoOrHClass(thread_, int8ArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 1; SetConstant(int8ArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); @@ -2069,15 +2069,15 @@ void Builtins::InitializeInt8Array(const JSHandle &env, const JSHandl env->SetInt8ArrayFunction(thread_, int8ArrayFunction); } -void Builtins::InitializeUint8Array(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeUint8Array(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Uint8Array.prototype - JSHandle uint8ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle uint8ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle uint8ArrFuncPrototypeValue(uint8ArrFuncPrototype); - // Uint8Array.prototype_or_dynclass - JSHandle uint8ArrFuncInstanceDynclass = factory_->NewEcmaDynClass( + // Uint8Array.prototype_or_hclass + JSHandle uint8ArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_UINT8_ARRAY, uint8ArrFuncPrototypeValue); // Uint8Array = new Function() @@ -2085,7 +2085,7 @@ void Builtins::InitializeUint8Array(const JSHandle &env, const JSHand env, reinterpret_cast(BuiltinsTypedArray::Uint8ArrayConstructor)); InitializeCtor(env, uint8ArrFuncPrototype, uint8ArrayFunction, "Uint8Array", FunctionLength::THREE); - uint8ArrayFunction->SetProtoOrDynClass(thread_, uint8ArrFuncInstanceDynclass.GetTaggedValue()); + uint8ArrayFunction->SetProtoOrHClass(thread_, uint8ArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 1; SetConstant(uint8ArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); @@ -2094,16 +2094,16 @@ void Builtins::InitializeUint8Array(const JSHandle &env, const JSHand } void Builtins::InitializeUint8ClampedArray(const JSHandle &env, - const JSHandle &objFuncDynclass) const + const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Uint8ClampedArray.prototype - JSHandle uint8ClampedArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle uint8ClampedArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle uint8ClampedArrFuncPrototypeValue(uint8ClampedArrFuncPrototype); - // Uint8ClampedArray.prototype_or_dynclass - JSHandle uint8ClampedArrFuncInstanceDynclass = - factory_->NewEcmaDynClass(panda::ecmascript::JSTypedArray::SIZE, JSType::JS_UINT8_CLAMPED_ARRAY, + // Uint8ClampedArray.prototype_or_hclass + JSHandle uint8ClampedArrFuncInstanceHClass = + factory_->NewEcmaHClass(panda::ecmascript::JSTypedArray::SIZE, JSType::JS_UINT8_CLAMPED_ARRAY, uint8ClampedArrFuncPrototypeValue); // Uint8ClampedArray = new Function() @@ -2112,7 +2112,7 @@ void Builtins::InitializeUint8ClampedArray(const JSHandle &env, InitializeCtor(env, uint8ClampedArrFuncPrototype, uint8ClampedArrayFunction, "Uint8ClampedArray", FunctionLength::THREE); - uint8ClampedArrayFunction->SetProtoOrDynClass(thread_, uint8ClampedArrFuncInstanceDynclass.GetTaggedValue()); + uint8ClampedArrayFunction->SetProtoOrHClass(thread_, uint8ClampedArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 1; SetConstant(uint8ClampedArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); @@ -2120,15 +2120,15 @@ void Builtins::InitializeUint8ClampedArray(const JSHandle &env, env->SetUint8ClampedArrayFunction(thread_, uint8ClampedArrayFunction); } -void Builtins::InitializeInt16Array(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeInt16Array(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Int16Array.prototype - JSHandle int16ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle int16ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle int16ArrFuncPrototypeValue(int16ArrFuncPrototype); - // Int16Array.prototype_or_dynclass - JSHandle int16ArrFuncInstanceDynclass = factory_->NewEcmaDynClass( + // Int16Array.prototype_or_hclass + JSHandle int16ArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_INT16_ARRAY, int16ArrFuncPrototypeValue); // Int16Array = new Function() @@ -2136,7 +2136,7 @@ void Builtins::InitializeInt16Array(const JSHandle &env, const JSHand env, reinterpret_cast(BuiltinsTypedArray::Int16ArrayConstructor)); InitializeCtor(env, int16ArrFuncPrototype, int16ArrayFunction, "Int16Array", FunctionLength::THREE); - int16ArrayFunction->SetProtoOrDynClass(thread_, int16ArrFuncInstanceDynclass.GetTaggedValue()); + int16ArrayFunction->SetProtoOrHClass(thread_, int16ArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 2; SetConstant(int16ArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); @@ -2144,15 +2144,15 @@ void Builtins::InitializeInt16Array(const JSHandle &env, const JSHand env->SetInt16ArrayFunction(thread_, int16ArrayFunction); } -void Builtins::InitializeUint16Array(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeUint16Array(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Uint16Array.prototype - JSHandle uint16ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle uint16ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle uint16ArrFuncPrototypeValue(uint16ArrFuncPrototype); - // Uint16Array.prototype_or_dynclass - JSHandle uint16ArrFuncInstanceDynclass = factory_->NewEcmaDynClass( + // Uint16Array.prototype_or_hclass + JSHandle uint16ArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_UINT16_ARRAY, uint16ArrFuncPrototypeValue); // Uint16Array = new Function() @@ -2160,7 +2160,7 @@ void Builtins::InitializeUint16Array(const JSHandle &env, const JSHan env, reinterpret_cast(BuiltinsTypedArray::Uint16ArrayConstructor)); InitializeCtor(env, uint16ArrFuncPrototype, uint16ArrayFunction, "Uint16Array", FunctionLength::THREE); - uint16ArrayFunction->SetProtoOrDynClass(thread_, uint16ArrFuncInstanceDynclass.GetTaggedValue()); + uint16ArrayFunction->SetProtoOrHClass(thread_, uint16ArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 2; SetConstant(uint16ArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); @@ -2168,15 +2168,15 @@ void Builtins::InitializeUint16Array(const JSHandle &env, const JSHan env->SetUint16ArrayFunction(thread_, uint16ArrayFunction); } -void Builtins::InitializeInt32Array(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeInt32Array(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Int32Array.prototype - JSHandle int32ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle int32ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle int32ArrFuncPrototypeValue(int32ArrFuncPrototype); - // Int32Array.prototype_or_dynclass - JSHandle int32ArrFuncInstanceDynclass = factory_->NewEcmaDynClass( + // Int32Array.prototype_or_hclass + JSHandle int32ArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_INT32_ARRAY, int32ArrFuncPrototypeValue); // Int32Array = new Function() @@ -2184,7 +2184,7 @@ void Builtins::InitializeInt32Array(const JSHandle &env, const JSHand env, reinterpret_cast(BuiltinsTypedArray::Int32ArrayConstructor)); InitializeCtor(env, int32ArrFuncPrototype, int32ArrayFunction, "Int32Array", FunctionLength::THREE); - int32ArrayFunction->SetProtoOrDynClass(thread_, int32ArrFuncInstanceDynclass.GetTaggedValue()); + int32ArrayFunction->SetProtoOrHClass(thread_, int32ArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 4; SetConstant(int32ArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); @@ -2192,15 +2192,15 @@ void Builtins::InitializeInt32Array(const JSHandle &env, const JSHand env->SetInt32ArrayFunction(thread_, int32ArrayFunction); } -void Builtins::InitializeUint32Array(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeUint32Array(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Uint32Array.prototype - JSHandle uint32ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle uint32ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle uint32ArrFuncPrototypeValue(uint32ArrFuncPrototype); - // Uint32Array.prototype_or_dynclass - JSHandle uint32ArrFuncInstanceDynclass = factory_->NewEcmaDynClass( + // Uint32Array.prototype_or_hclass + JSHandle uint32ArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_UINT32_ARRAY, uint32ArrFuncPrototypeValue); // Uint32Array = new Function() @@ -2208,7 +2208,7 @@ void Builtins::InitializeUint32Array(const JSHandle &env, const JSHan env, reinterpret_cast(BuiltinsTypedArray::Uint32ArrayConstructor)); InitializeCtor(env, uint32ArrFuncPrototype, uint32ArrayFunction, "Uint32Array", FunctionLength::THREE); - uint32ArrayFunction->SetProtoOrDynClass(thread_, uint32ArrFuncInstanceDynclass.GetTaggedValue()); + uint32ArrayFunction->SetProtoOrHClass(thread_, uint32ArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 4; SetConstant(uint32ArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); @@ -2216,15 +2216,15 @@ void Builtins::InitializeUint32Array(const JSHandle &env, const JSHan env->SetUint32ArrayFunction(thread_, uint32ArrayFunction); } -void Builtins::InitializeFloat32Array(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeFloat32Array(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Float32Array.prototype - JSHandle float32ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle float32ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle float32ArrFuncPrototypeValue(float32ArrFuncPrototype); - // Float32Array.prototype_or_dynclass - JSHandle float32ArrFuncInstanceDynclass = factory_->NewEcmaDynClass( + // Float32Array.prototype_or_hclass + JSHandle float32ArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_FLOAT32_ARRAY, float32ArrFuncPrototypeValue); // Float32Array = new Function() @@ -2232,7 +2232,7 @@ void Builtins::InitializeFloat32Array(const JSHandle &env, const JSHa env, reinterpret_cast(BuiltinsTypedArray::Float32ArrayConstructor)); InitializeCtor(env, float32ArrFuncPrototype, float32ArrayFunction, "Float32Array", FunctionLength::THREE); - float32ArrayFunction->SetProtoOrDynClass(thread_, float32ArrFuncInstanceDynclass.GetTaggedValue()); + float32ArrayFunction->SetProtoOrHClass(thread_, float32ArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 4; SetConstant(float32ArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); @@ -2240,15 +2240,15 @@ void Builtins::InitializeFloat32Array(const JSHandle &env, const JSHa env->SetFloat32ArrayFunction(thread_, float32ArrayFunction); } -void Builtins::InitializeFloat64Array(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeFloat64Array(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Float64Array.prototype - JSHandle float64ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle float64ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle float64ArrFuncPrototypeValue(float64ArrFuncPrototype); - // Float64Array.prototype_or_dynclass - JSHandle float64ArrFuncInstanceDynclass = factory_->NewEcmaDynClass( + // Float64Array.prototype_or_hclass + JSHandle float64ArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_FLOAT64_ARRAY, float64ArrFuncPrototypeValue); // Float64Array = new Function() @@ -2256,7 +2256,7 @@ void Builtins::InitializeFloat64Array(const JSHandle &env, const JSHa env, reinterpret_cast(BuiltinsTypedArray::Float64ArrayConstructor)); InitializeCtor(env, float64ArrFuncPrototype, float64ArrayFunction, "Float64Array", FunctionLength::THREE); - float64ArrayFunction->SetProtoOrDynClass(thread_, float64ArrFuncInstanceDynclass.GetTaggedValue()); + float64ArrayFunction->SetProtoOrHClass(thread_, float64ArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 8; SetConstant(float64ArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); @@ -2264,15 +2264,15 @@ void Builtins::InitializeFloat64Array(const JSHandle &env, const JSHa env->SetFloat64ArrayFunction(thread_, float64ArrayFunction); } -void Builtins::InitializeBigInt64Array(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeBigInt64Array(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // BigInt64Array.prototype - JSHandle bigInt64ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle bigInt64ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle bigInt64ArrFuncPrototypeValue(bigInt64ArrFuncPrototype); - // BigInt64Array.prototype_or_dynclass - JSHandle bigInt64ArrFuncInstanceDynclass = factory_->NewEcmaDynClass( + // BigInt64Array.prototype_or_hclass + JSHandle bigInt64ArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_BIGINT64_ARRAY, bigInt64ArrFuncPrototypeValue); // BigInt64Array = new Function() @@ -2280,7 +2280,7 @@ void Builtins::InitializeBigInt64Array(const JSHandle &env, const JSH env, reinterpret_cast(BuiltinsTypedArray::BigInt64ArrayConstructor)); InitializeCtor(env, bigInt64ArrFuncPrototype, bigInt64ArrayFunction, "BigInt64Array", FunctionLength::THREE); - bigInt64ArrayFunction->SetProtoOrDynClass(thread_, bigInt64ArrFuncInstanceDynclass.GetTaggedValue()); + bigInt64ArrayFunction->SetProtoOrHClass(thread_, bigInt64ArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 8; SetConstant(bigInt64ArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); @@ -2288,15 +2288,15 @@ void Builtins::InitializeBigInt64Array(const JSHandle &env, const JSH env->SetBigInt64ArrayFunction(thread_, bigInt64ArrayFunction); } -void Builtins::InitializeBigUint64Array(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeBigUint64Array(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // BigUint64Array.prototype - JSHandle bigUint64ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle bigUint64ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle bigUint64ArrFuncPrototypeValue(bigUint64ArrFuncPrototype); - // BigUint64Array.prototype_or_dynclass - JSHandle bigUint64ArrFuncInstanceDynclass = factory_->NewEcmaDynClass( + // BigUint64Array.prototype_or_hclass + JSHandle bigUint64ArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_BIGUINT64_ARRAY, bigUint64ArrFuncPrototypeValue); // BigUint64Array = new Function() @@ -2304,7 +2304,7 @@ void Builtins::InitializeBigUint64Array(const JSHandle &env, const JS env, reinterpret_cast(BuiltinsTypedArray::BigUint64ArrayConstructor)); InitializeCtor(env, bigUint64ArrFuncPrototype, bigUint64ArrayFunction, "BigUint64Array", FunctionLength::THREE); - bigUint64ArrayFunction->SetProtoOrDynClass(thread_, bigUint64ArrFuncInstanceDynclass.GetTaggedValue()); + bigUint64ArrayFunction->SetProtoOrHClass(thread_, bigUint64ArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 8; SetConstant(bigUint64ArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); @@ -2312,23 +2312,23 @@ void Builtins::InitializeBigUint64Array(const JSHandle &env, const JS env->SetBigUint64ArrayFunction(thread_, bigUint64ArrayFunction); } -void Builtins::InitializeArrayBuffer(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeArrayBuffer(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // ArrayBuffer.prototype - JSHandle arrayBufferFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle arrayBufferFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle arrayBufferFuncPrototypeValue(arrayBufferFuncPrototype); - // ArrayBuffer.prototype_or_dynclass - JSHandle arrayBufferFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSArrayBuffer::SIZE, JSType::JS_ARRAY_BUFFER, arrayBufferFuncPrototypeValue); + // ArrayBuffer.prototype_or_hclass + JSHandle arrayBufferFuncInstanceHClass = + factory_->NewEcmaHClass(JSArrayBuffer::SIZE, JSType::JS_ARRAY_BUFFER, arrayBufferFuncPrototypeValue); // ArrayBuffer = new Function() JSHandle arrayBufferFunction(NewBuiltinConstructor( env, arrayBufferFuncPrototype, ArrayBuffer::ArrayBufferConstructor, "ArrayBuffer", FunctionLength::ONE)); JSHandle(arrayBufferFunction) - ->SetFunctionPrototype(thread_, arrayBufferFuncInstanceDynclass.GetTaggedValue()); + ->SetFunctionPrototype(thread_, arrayBufferFuncInstanceHClass.GetTaggedValue()); // ArrayBuffer prototype method SetFunction(env, arrayBufferFuncPrototype, "slice", ArrayBuffer::Slice, FunctionLength::TWO); @@ -2358,9 +2358,9 @@ void Builtins::InitializeReflect(const JSHandle &env, const JSHandle &objFuncPrototypeVal) const { [[maybe_unused]] EcmaHandleScope scope(thread_); - JSHandle reflectDynclass = - factory_->NewEcmaDynClass(JSObject::SIZE, JSType::JS_OBJECT, objFuncPrototypeVal); - JSHandle reflectObject = factory_->NewJSObjectWithInit(reflectDynclass); + JSHandle reflectHClass = + factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, objFuncPrototypeVal); + JSHandle reflectObject = factory_->NewJSObjectWithInit(reflectHClass); SetFunction(env, reflectObject, "apply", Reflect::ReflectApply, FunctionLength::THREE); SetFunction(env, reflectObject, "construct", Reflect::ReflectConstruct, FunctionLength::TWO); @@ -2389,16 +2389,16 @@ void Builtins::InitializeReflect(const JSHandle &env, } void Builtins::InitializeSharedArrayBuffer(const JSHandle &env, - const JSHandle &objFuncDynclass) const + const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // SharedArrayBuffer.prototype - JSHandle sharedArrayBufferFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle sharedArrayBufferFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle sharedArrayBufferFuncPrototypeValue(sharedArrayBufferFuncPrototype); - // SharedArrayBuffer.prototype_or_dynclass - JSHandle sharedArrayBufferFuncInstanceDynclass = - factory_->NewEcmaDynClass( + // SharedArrayBuffer.prototype_or_hclass + JSHandle sharedArrayBufferFuncInstanceHClass = + factory_->NewEcmaHClass( JSArrayBuffer::SIZE, JSType::JS_SHARED_ARRAY_BUFFER, sharedArrayBufferFuncPrototypeValue); // SharedArrayBuffer = new Function() @@ -2406,7 +2406,7 @@ void Builtins::InitializeSharedArrayBuffer(const JSHandle &env, SharedArrayBuffer::SharedArrayBufferConstructor, "SharedArrayBuffer", FunctionLength::ONE)); JSHandle(SharedArrayBufferFunction) - ->SetFunctionPrototype(thread_, sharedArrayBufferFuncInstanceDynclass.GetTaggedValue()); + ->SetFunctionPrototype(thread_, sharedArrayBufferFuncInstanceHClass.GetTaggedValue()); // SharedArrayBuffer prototype method SetFunction(env, sharedArrayBufferFuncPrototype, "slice", SharedArrayBuffer::Slice, FunctionLength::TWO); @@ -2433,19 +2433,19 @@ void Builtins::InitializeSharedArrayBuffer(const JSHandle &env, env->SetSharedArrayBufferFunction(thread_, SharedArrayBufferFunction.GetTaggedValue()); } -void Builtins::InitializePromise(const JSHandle &env, const JSHandle &promiseFuncDynclass) +void Builtins::InitializePromise(const JSHandle &env, const JSHandle &promiseFuncClass) { [[maybe_unused]] EcmaHandleScope scope(thread_); // Promise.prototype - JSHandle promiseFuncPrototype = factory_->NewJSObjectWithInit(promiseFuncDynclass); + JSHandle promiseFuncPrototype = factory_->NewJSObjectWithInit(promiseFuncClass); JSHandle promiseFuncPrototypeValue(promiseFuncPrototype); - // Promise.prototype_or_dynclass - JSHandle promiseFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSPromise::SIZE, JSType::JS_PROMISE, promiseFuncPrototypeValue); + // Promise.prototype_or_hclass + JSHandle promiseFuncInstanceHClass = + factory_->NewEcmaHClass(JSPromise::SIZE, JSType::JS_PROMISE, promiseFuncPrototypeValue); // Promise() = new Function() JSHandle promiseFunction( NewBuiltinConstructor(env, promiseFuncPrototype, Promise::PromiseConstructor, "Promise", FunctionLength::ONE)); - JSHandle(promiseFunction)->SetFunctionPrototype(thread_, promiseFuncInstanceDynclass.GetTaggedValue()); + JSHandle(promiseFunction)->SetFunctionPrototype(thread_, promiseFuncInstanceHClass.GetTaggedValue()); // Promise method SetFunction(env, promiseFunction, "all", Promise::All, FunctionLength::ONE); @@ -2479,48 +2479,48 @@ void Builtins::InitializeForPromiseFuncClass(const JSHandle &env) vm_ = thread_->GetEcmaVM(); factory_ = vm_->GetFactory(); - JSHandle promiseReactionFuncClass = factory_->NewEcmaDynClass( + JSHandle promiseReactionFuncClass = factory_->NewEcmaHClass( JSPromiseReactionsFunction::SIZE, JSType::JS_PROMISE_REACTIONS_FUNCTION, env->GetFunctionPrototype()); promiseReactionFuncClass->SetCallable(true); promiseReactionFuncClass->SetExtensible(true); env->SetPromiseReactionFunctionClass(thread_, promiseReactionFuncClass); - JSHandle promiseExecutorFuncClass = factory_->NewEcmaDynClass( + JSHandle promiseExecutorFuncClass = factory_->NewEcmaHClass( JSPromiseExecutorFunction::SIZE, JSType::JS_PROMISE_EXECUTOR_FUNCTION, env->GetFunctionPrototype()); promiseExecutorFuncClass->SetCallable(true); promiseExecutorFuncClass->SetExtensible(true); env->SetPromiseExecutorFunctionClass(thread_, promiseExecutorFuncClass); JSHandle promiseAllResolveElementFunctionClass = - factory_->NewEcmaDynClass(JSPromiseAllResolveElementFunction::SIZE, + factory_->NewEcmaHClass(JSPromiseAllResolveElementFunction::SIZE, JSType::JS_PROMISE_ALL_RESOLVE_ELEMENT_FUNCTION, env->GetFunctionPrototype()); promiseAllResolveElementFunctionClass->SetCallable(true); promiseAllResolveElementFunctionClass->SetExtensible(true); env->SetPromiseAllResolveElementFunctionClass(thread_, promiseAllResolveElementFunctionClass); JSHandle promiseAnyRejectElementFunctionClass = - factory_->NewEcmaDynClass(JSPromiseAnyRejectElementFunction::SIZE, + factory_->NewEcmaHClass(JSPromiseAnyRejectElementFunction::SIZE, JSType::JS_PROMISE_ANY_REJECT_ELEMENT_FUNCTION, env->GetFunctionPrototype()); promiseAnyRejectElementFunctionClass->SetCallable(true); promiseAnyRejectElementFunctionClass->SetExtensible(true); env->SetPromiseAnyRejectElementFunctionClass(thread_, promiseAnyRejectElementFunctionClass); JSHandle promiseAllSettledElementFunctionClass = - factory_->NewEcmaDynClass(JSPromiseAllSettledElementFunction::SIZE, + factory_->NewEcmaHClass(JSPromiseAllSettledElementFunction::SIZE, JSType::JS_PROMISE_ALL_SETTLED_ELEMENT_FUNCTION, env->GetFunctionPrototype()); promiseAllSettledElementFunctionClass->SetCallable(true); promiseAllSettledElementFunctionClass->SetExtensible(true); env->SetPromiseAllSettledElementFunctionClass(thread_, promiseAllSettledElementFunctionClass); JSHandle promiseFinallyFunctionClass = - factory_->NewEcmaDynClass(JSPromiseFinallyFunction::SIZE, + factory_->NewEcmaHClass(JSPromiseFinallyFunction::SIZE, JSType::JS_PROMISE_FINALLY_FUNCTION, env->GetFunctionPrototype()); promiseFinallyFunctionClass->SetCallable(true); promiseFinallyFunctionClass->SetExtensible(true); env->SetPromiseFinallyFunctionClass(thread_, promiseFinallyFunctionClass); JSHandle promiseValueThunkOrThrowerFunctionClass = - factory_->NewEcmaDynClass(JSPromiseValueThunkOrThrowerFunction::SIZE, + factory_->NewEcmaHClass(JSPromiseValueThunkOrThrowerFunction::SIZE, JSType::JS_PROMISE_VALUE_THUNK_OR_THROWER_FUNCTION, env->GetFunctionPrototype()); promiseValueThunkOrThrowerFunctionClass->SetCallable(true); promiseValueThunkOrThrowerFunctionClass->SetExtensible(true); @@ -2536,22 +2536,22 @@ void Builtins::InitializePromiseJob(const JSHandle &env) env->SetPromiseResolveThenableJob(thread_, func); } -void Builtins::InitializeDataView(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeDataView(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // ArrayBuffer.prototype - JSHandle dataViewFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle dataViewFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle dataViewFuncPrototypeValue(dataViewFuncPrototype); - // ArrayBuffer.prototype_or_dynclass - JSHandle dataViewFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSDataView::SIZE, JSType::JS_DATA_VIEW, dataViewFuncPrototypeValue); + // ArrayBuffer.prototype_or_hclass + JSHandle dataViewFuncInstanceHClass = + factory_->NewEcmaHClass(JSDataView::SIZE, JSType::JS_DATA_VIEW, dataViewFuncPrototypeValue); // ArrayBuffer = new Function() JSHandle dataViewFunction(NewBuiltinConstructor(env, dataViewFuncPrototype, DataView::DataViewConstructor, "DataView", FunctionLength::ONE)); - JSHandle(dataViewFunction)->SetProtoOrDynClass(thread_, dataViewFuncInstanceDynclass.GetTaggedValue()); + JSHandle(dataViewFunction)->SetProtoOrHClass(thread_, dataViewFuncInstanceHClass.GetTaggedValue()); // DataView.prototype method SetFunction(env, dataViewFuncPrototype, "getFloat32", DataView::GetFloat32, FunctionLength::ONE); SetFunction(env, dataViewFuncPrototype, "getFloat64", DataView::GetFloat64, FunctionLength::ONE); @@ -2790,19 +2790,19 @@ void Builtins::StrictModeForbiddenAccessCallerArguments(const JSHandle &env, - const JSHandle &objFuncDynclass) const + const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle generatorFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle generatorFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle generatorFuncPrototypeValue(generatorFuncPrototype); // 26.3.3.1 GeneratorFunction.prototype.constructor - // GeneratorFunction.prototype_or_dynclass - JSHandle generatorFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSFunction::SIZE, JSType::JS_GENERATOR_FUNCTION, generatorFuncPrototypeValue); - generatorFuncInstanceDynclass->SetCallable(true); - generatorFuncInstanceDynclass->SetExtensible(true); + // GeneratorFunction.prototype_or_hclass + JSHandle generatorFuncInstanceHClass = + factory_->NewEcmaHClass(JSFunction::SIZE, JSType::JS_GENERATOR_FUNCTION, generatorFuncPrototypeValue); + generatorFuncInstanceHClass->SetCallable(true); + generatorFuncInstanceHClass->SetExtensible(true); // GeneratorFunction = new GeneratorFunction() JSHandle generatorFunction = NewBuiltinConstructor(env, generatorFuncPrototype, GeneratorObject::GeneratorFunctionConstructor, @@ -2810,7 +2810,7 @@ void Builtins::InitializeGeneratorFunction(const JSHandle &env, JSHandle constructorKey = globalConst->GetHandledConstructorString(); PropertyDescriptor generatorDesc(thread_, JSHandle::Cast(generatorFunction), false, false, true); JSObject::DefineOwnProperty(thread_, generatorFuncPrototype, constructorKey, generatorDesc); - generatorFunction->SetProtoOrDynClass(thread_, generatorFuncInstanceDynclass.GetTaggedValue()); + generatorFunction->SetProtoOrHClass(thread_, generatorFuncInstanceHClass.GetTaggedValue()); env->SetGeneratorFunctionFunction(thread_, generatorFunction); // 26.3.3.2 GeneratorFunction.prototype.prototype -> Generator prototype object. @@ -2837,18 +2837,18 @@ void Builtins::InitializeGeneratorFunction(const JSHandle &env, } void Builtins::InitializeAsyncGeneratorFunction(const JSHandle &env, - const JSHandle &objFuncDynclass) const + const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle asyncGeneratorFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle asyncGeneratorFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle asyncGeneratorFuncPrototypeValue(asyncGeneratorFuncPrototype); // 27.4.3.1 AsyncGeneratorFunction.prototype.constructor - JSHandle asyncGeneratorFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSFunction::SIZE, JSType::JS_ASYNC_GENERATOR_FUNCTION, + JSHandle asyncGeneratorFuncInstanceHClass = + factory_->NewEcmaHClass(JSFunction::SIZE, JSType::JS_ASYNC_GENERATOR_FUNCTION, asyncGeneratorFuncPrototypeValue); - asyncGeneratorFuncInstanceDynclass->SetCallable(true); - asyncGeneratorFuncInstanceDynclass->SetExtensible(true); + asyncGeneratorFuncInstanceHClass->SetCallable(true); + asyncGeneratorFuncInstanceHClass->SetExtensible(true); JSHandle asyncGeneratorFunction = NewBuiltinConstructor(env, asyncGeneratorFuncPrototype, AsyncGeneratorObject::AsyncGeneratorFunctionConstructor, "AsyncGeneratorFunction", @@ -2857,7 +2857,7 @@ void Builtins::InitializeAsyncGeneratorFunction(const JSHandle &env, PropertyDescriptor asyncGeneratorDesc(thread_, JSHandle::Cast(asyncGeneratorFunction), false, false, true); JSObject::DefineOwnProperty(thread_, asyncGeneratorFuncPrototype, constructorKey, asyncGeneratorDesc); - asyncGeneratorFunction->SetProtoOrDynClass(thread_, asyncGeneratorFuncInstanceDynclass.GetTaggedValue()); + asyncGeneratorFunction->SetProtoOrHClass(thread_, asyncGeneratorFuncInstanceHClass.GetTaggedValue()); env->SetAsyncGeneratorFunctionFunction(thread_, asyncGeneratorFunction); // 27.4.3.2 AsyncGeneratorFunction.prototype.prototype @@ -2881,11 +2881,11 @@ void Builtins::InitializeAsyncGeneratorFunction(const JSHandle &env, env->SetAsyncGeneratorFunctionPrototype(thread_, asyncGeneratorFuncPrototype); } -void Builtins::InitializeGenerator(const JSHandle &env, const JSHandle &objFuncDynclass) const +void Builtins::InitializeGenerator(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle generatorFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle generatorFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); // GeneratorObject.prototype method // 26.5.1.2 Generator.prototype.next(value) @@ -2905,17 +2905,17 @@ void Builtins::InitializeGenerator(const JSHandle &env, const JSHandl JSObject::SetPrototype(thread_, generatorFuncPrototype, env->GetIteratorPrototype()); // Generator {} - JSHandle initialGeneratorFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle initialGeneratorFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSObject::SetPrototype(thread_, initialGeneratorFuncPrototype, JSHandle(generatorFuncPrototype)); env->SetInitialGenerator(thread_, initialGeneratorFuncPrototype); } void Builtins::InitializeAsyncGenerator(const JSHandle &env, - const JSHandle &objFuncDynclass) const + const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); - JSHandle asyncGeneratorFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle asyncGeneratorFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); // GeneratorObject.prototype method // 27.6.1.2 AsyncGenerator.prototype.next ( value ) @@ -2932,7 +2932,7 @@ void Builtins::InitializeAsyncGenerator(const JSHandle &env, SetStringTagSymbol(env, asyncGeneratorFuncPrototype, "AsyncGenerator"); env->SetAsyncGeneratorPrototype(thread_, asyncGeneratorFuncPrototype); - JSHandle initialAsyncGeneratorFuncPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle initialAsyncGeneratorFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSObject::SetPrototype(thread_, initialAsyncGeneratorFuncPrototype, JSHandle(asyncGeneratorFuncPrototype)); env->SetInitialAsyncGenerator(thread_, initialAsyncGeneratorFuncPrototype); @@ -3006,8 +3006,8 @@ void Builtins::InitializeIntlCtor(const JSHandle &env, const JSHandle void Builtins::InitializeIntl(const JSHandle &env, const JSHandle &objFuncPrototypeValue) { [[maybe_unused]] EcmaHandleScope scope(thread_); - JSHandle intlDynclass = factory_->NewEcmaDynClass(JSIntl::SIZE, JSType::JS_INTL, objFuncPrototypeValue); - JSHandle intlObject = factory_->NewJSObjectWithInit(intlDynclass); + JSHandle intlHClass = factory_->NewEcmaHClass(JSIntl::SIZE, JSType::JS_INTL, objFuncPrototypeValue); + JSHandle intlObject = factory_->NewJSObjectWithInit(intlHClass); JSHandle initIntlSymbol(factory_->NewPublicSymbolWithChar("Symbol.IntlLegacyConstructedSymbol")); SetNoneAttributeProperty(intlObject, "fallbackSymbol", initIntlSymbol); @@ -3033,15 +3033,15 @@ void Builtins::InitializeDateTimeFormat(const JSHandle &env) JSHandle dtfPrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle dtfPrototypeValue(dtfPrototype); - // DateTimeFormat.prototype_or_dynclass - JSHandle dtfFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSDateTimeFormat::SIZE, JSType::JS_DATE_TIME_FORMAT, dtfPrototypeValue); + // DateTimeFormat.prototype_or_hclass + JSHandle dtfFuncInstanceHClass = + factory_->NewEcmaHClass(JSDateTimeFormat::SIZE, JSType::JS_DATE_TIME_FORMAT, dtfPrototypeValue); // DateTimeFormat = new Function() // 13.4.1 Intl.DateTimeFormat.prototype.constructor JSHandle dtfFunction(NewIntlConstructor(env, dtfPrototype, DateTimeFormat::DateTimeFormatConstructor, "DateTimeFormat", FunctionLength::ZERO)); - JSHandle(dtfFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*dtfFuncInstanceDynclass)); + JSHandle(dtfFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*dtfFuncInstanceHClass)); // 13.3.2 Intl.DateTimeFormat.supportedLocalesOf ( locales [ , options ] ) SetFunction(env, dtfFunction, "supportedLocalesOf", DateTimeFormat::SupportedLocalesOf, FunctionLength::ONE); @@ -3075,16 +3075,16 @@ void Builtins::InitializeRelativeTimeFormat(const JSHandle &env) JSHandle rtfPrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle rtfPrototypeValue(rtfPrototype); - // RelativeTimeFormat.prototype_or_dynclass - JSHandle rtfFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSRelativeTimeFormat::SIZE, JSType::JS_RELATIVE_TIME_FORMAT, rtfPrototypeValue); + // RelativeTimeFormat.prototype_or_hclass + JSHandle rtfFuncInstanceHClass = + factory_->NewEcmaHClass(JSRelativeTimeFormat::SIZE, JSType::JS_RELATIVE_TIME_FORMAT, rtfPrototypeValue); // RelativeTimeFormat = new Function() // 14.2.1 Intl.RelativeTimeFormat.prototype.constructor JSHandle rtfFunction(NewIntlConstructor(env, rtfPrototype, RelativeTimeFormat::RelativeTimeFormatConstructor, "RelativeTimeFormat", FunctionLength::ZERO)); - JSHandle(rtfFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*rtfFuncInstanceDynclass)); + JSHandle(rtfFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*rtfFuncInstanceHClass)); // 14.3.2 Intl.RelativeTimeFormat.supportedLocalesOf ( locales [ , options ] ) SetFunction(env, rtfFunction, "supportedLocalesOf", RelativeTimeFormat::SupportedLocalesOf, FunctionLength::ONE); @@ -3112,15 +3112,15 @@ void Builtins::InitializeNumberFormat(const JSHandle &env) JSHandle nfPrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle nfPrototypeValue(nfPrototype); - // NumberFormat.prototype_or_dynclass - JSHandle nfFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSNumberFormat::SIZE, JSType::JS_NUMBER_FORMAT, nfPrototypeValue); + // NumberFormat.prototype_or_hclass + JSHandle nfFuncInstanceHClass = + factory_->NewEcmaHClass(JSNumberFormat::SIZE, JSType::JS_NUMBER_FORMAT, nfPrototypeValue); // NumberFormat = new Function() // 12.4.1 Intl.NumberFormat.prototype.constructor JSHandle nfFunction(NewIntlConstructor(env, nfPrototype, NumberFormat::NumberFormatConstructor, "NumberFormat", FunctionLength::ZERO)); - JSHandle(nfFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*nfFuncInstanceDynclass)); + JSHandle(nfFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*nfFuncInstanceHClass)); // 12.3.2 Intl.NumberFormat.supportedLocalesOf ( locales [ , options ] ) SetFunction(env, nfFunction, "supportedLocalesOf", NumberFormat::SupportedLocalesOf, FunctionLength::ONE); @@ -3150,14 +3150,14 @@ void Builtins::InitializeLocale(const JSHandle &env) JSHandle localePrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle localePrototypeValue(localePrototype); - // Locale.prototype_or_dynclass - JSHandle localeFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSLocale::SIZE, JSType::JS_LOCALE, localePrototypeValue); + // Locale.prototype_or_hclass + JSHandle localeFuncInstanceHClass = + factory_->NewEcmaHClass(JSLocale::SIZE, JSType::JS_LOCALE, localePrototypeValue); // Locale = new Function() JSHandle localeFunction( NewIntlConstructor(env, localePrototype, Locale::LocaleConstructor, "Locale", FunctionLength::ONE)); - JSHandle(localeFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*localeFuncInstanceDynclass)); + JSHandle(localeFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*localeFuncInstanceHClass)); // Locale.prototype method SetFunction(env, localePrototype, "maximize", Locale::Maximize, FunctionLength::ZERO); @@ -3211,15 +3211,15 @@ void Builtins::InitializeCollator(const JSHandle &env) JSHandle collatorPrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle collatorPrototypeValue(collatorPrototype); - // Collator.prototype_or_dynclass - JSHandle collatorFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSCollator::SIZE, JSType::JS_COLLATOR, collatorPrototypeValue); + // Collator.prototype_or_hclass + JSHandle collatorFuncInstanceHClass = + factory_->NewEcmaHClass(JSCollator::SIZE, JSType::JS_COLLATOR, collatorPrototypeValue); // Collator = new Function() // 11.1.2 Intl.Collator.prototype.constructor JSHandle collatorFunction( NewIntlConstructor(env, collatorPrototype, Collator::CollatorConstructor, "Collator", FunctionLength::ZERO)); - JSHandle(collatorFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*collatorFuncInstanceDynclass)); + JSHandle(collatorFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*collatorFuncInstanceHClass)); // 11.2.2 Intl.Collator.supportedLocalesOf ( locales [ , options ] ) SetFunction(env, collatorFunction, "supportedLocalesOf", Collator::SupportedLocalesOf, FunctionLength::ONE); @@ -3246,15 +3246,15 @@ void Builtins::InitializePluralRules(const JSHandle &env) JSHandle prPrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle prPrototypeValue(prPrototype); - // PluralRules.prototype_or_dynclass - JSHandle prFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSPluralRules::SIZE, JSType::JS_PLURAL_RULES, prPrototypeValue); + // PluralRules.prototype_or_hclass + JSHandle prFuncInstanceHClass = + factory_->NewEcmaHClass(JSPluralRules::SIZE, JSType::JS_PLURAL_RULES, prPrototypeValue); // PluralRules = new Function() // 15.2.1 Intl.PluralRules.prototype.constructor JSHandle prFunction( NewIntlConstructor(env, prPrototype, PluralRules::PluralRulesConstructor, "PluralRules", FunctionLength::ZERO)); - JSHandle(prFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*prFuncInstanceDynclass)); + JSHandle(prFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*prFuncInstanceHClass)); // 15.3.2 Intl.PluralRules.supportedLocalesOf ( locales [ , options ] ) SetFunction(env, prFunction, "supportedLocalesOf", PluralRules::SupportedLocalesOf, FunctionLength::ONE); @@ -3279,15 +3279,15 @@ void Builtins::InitializeDisplayNames(const JSHandle &env) JSHandle dnPrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle dnPrototypeValue(dnPrototype); - // DisplayNames.prototype_or_dynclass - JSHandle dnFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSDisplayNames::SIZE, JSType::JS_DISPLAYNAMES, dnPrototypeValue); + // DisplayNames.prototype_or_hclass + JSHandle dnFuncInstanceHClass = + factory_->NewEcmaHClass(JSDisplayNames::SIZE, JSType::JS_DISPLAYNAMES, dnPrototypeValue); // DisplayNames = new Function() // 12.4.1 Intl.DisplayNames.prototype.constructor JSHandle dnFunction(NewIntlConstructor(env, dnPrototype, DisplayNames::DisplayNamesConstructor, "DisplayNames", FunctionLength::TWO)); - JSHandle(dnFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*dnFuncInstanceDynclass)); + JSHandle(dnFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*dnFuncInstanceHClass)); // 12.3.2 Intl.DisplayNames.supportedLocalesOf ( locales [ , options ] ) SetFunction(env, dnFunction, "supportedLocalesOf", DisplayNames::SupportedLocalesOf, FunctionLength::ONE); @@ -3312,15 +3312,15 @@ void Builtins::InitializeListFormat(const JSHandle &env) JSHandle lfPrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle lfPrototypeValue(lfPrototype); - // JSListFormat.prototype_or_dynclass - JSHandle lfFuncInstanceDynclass = - factory_->NewEcmaDynClass(JSListFormat::SIZE, JSType::JS_LIST_FORMAT, lfPrototypeValue); + // JSListFormat.prototype_or_hclass + JSHandle lfFuncInstanceHClass = + factory_->NewEcmaHClass(JSListFormat::SIZE, JSType::JS_LIST_FORMAT, lfPrototypeValue); // JSListFormat = new Function() // 13.4.1 Intl.ListFormat.prototype.constructor JSHandle lfFunction(NewIntlConstructor(env, lfPrototype, ListFormat::ListFormatConstructor, "ListFormat", FunctionLength::ZERO)); - JSHandle(lfFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*lfFuncInstanceDynclass)); + JSHandle(lfFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*lfFuncInstanceHClass)); // 13.3.2 Intl.ListFormat.supportedLocalesOf ( locales [ , options ] ) SetFunction(env, lfFunction, "supportedLocalesOf", ListFormat::SupportedLocalesOf, FunctionLength::ONE); @@ -3377,18 +3377,18 @@ JSHandle Builtins::InitializeArkPrivate(const JSHandle &env } void Builtins::InitializeModuleNamespace(const JSHandle &env, - const JSHandle &objFuncDynclass) const + const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // ModuleNamespace.prototype - JSHandle moduleNamespacePrototype = factory_->NewJSObjectWithInit(objFuncDynclass); + JSHandle moduleNamespacePrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle moduleNamespacePrototypeValue(moduleNamespacePrototype); - // ModuleNamespace.prototype_or_dynclass - JSHandle moduleNamespaceDynclass = - factory_->NewEcmaDynClass(ModuleNamespace::SIZE, JSType::JS_MODULE_NAMESPACE, moduleNamespacePrototypeValue); - moduleNamespaceDynclass->SetPrototype(thread_, JSTaggedValue::Null()); - env->SetModuleNamespaceClass(thread_, moduleNamespaceDynclass.GetTaggedValue()); + // ModuleNamespace.prototype_or_hclass + JSHandle moduleNamespaceHClass = + factory_->NewEcmaHClass(ModuleNamespace::SIZE, JSType::JS_MODULE_NAMESPACE, moduleNamespacePrototypeValue); + moduleNamespaceHClass->SetPrototype(thread_, JSTaggedValue::Null()); + env->SetModuleNamespaceClass(thread_, moduleNamespaceHClass.GetTaggedValue()); } void Builtins::InitializeCjsModule(const JSHandle &env) const @@ -3399,16 +3399,16 @@ void Builtins::InitializeCjsModule(const JSHandle &env) const JSHandle cjsModulePrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle cjsModulePrototypeValue(cjsModulePrototype); - // CjsModule.prototype_or_dynclass - JSHandle cjsModuleDynclass = - factory_->NewEcmaDynClass(CjsModule::SIZE, JSType::JS_CJS_MODULE, cjsModulePrototypeValue); + // CjsModule.prototype_or_hclass + JSHandle cjsModuleHClass = + factory_->NewEcmaHClass(CjsModule::SIZE, JSType::JS_CJS_MODULE, cjsModulePrototypeValue); // CjsModule.prototype.Constructor JSHandle cjsModuleFunction( NewBuiltinCjsCtor(env, cjsModulePrototype, BuiltinsCjsModule::CjsModuleConstructor, "Module", FunctionLength::TWO)); - JSHandle(cjsModuleFunction)->SetFunctionPrototype(thread_, cjsModuleDynclass.GetTaggedValue()); + JSHandle(cjsModuleFunction)->SetFunctionPrototype(thread_, cjsModuleHClass.GetTaggedValue()); // CjsModule method SetFunction(env, cjsModuleFunction, "_load", BuiltinsCjsModule::Load, FunctionLength::ONE); @@ -3454,16 +3454,16 @@ void Builtins::InitializeCjsExports(const JSHandle &env) const JSHandle cjsExportsPrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle cjsExportsPrototypeValue(cjsExportsPrototype); - // CjsExports.prototype_or_dynclass - JSHandle cjsExportsDynclass = - factory_->NewEcmaDynClass(CjsExports::SIZE, JSType::JS_CJS_EXPORTS, cjsExportsPrototypeValue); + // CjsExports.prototype_or_hclass + JSHandle cjsExportsHClass = + factory_->NewEcmaHClass(CjsExports::SIZE, JSType::JS_CJS_EXPORTS, cjsExportsPrototypeValue); // CjsExports.prototype.Constructor JSHandle cjsExportsFunction( NewBuiltinCjsCtor(env, cjsExportsPrototype, BuiltinsCjsExports::CjsExportsConstructor, "Exports", FunctionLength::TWO)); - JSHandle(cjsExportsFunction)->SetFunctionPrototype(thread_, cjsExportsDynclass.GetTaggedValue()); + JSHandle(cjsExportsFunction)->SetFunctionPrototype(thread_, cjsExportsHClass.GetTaggedValue()); env->SetCjsExportsFunction(thread_, cjsExportsFunction); } @@ -3476,15 +3476,15 @@ void Builtins::InitializeCjsRequire(const JSHandle &env) const JSHandle cjsRequirePrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle cjsRequirePrototypeValue(cjsRequirePrototype); - // CjsExports.prototype_or_dynclass - JSHandle cjsRequireDynclass = - factory_->NewEcmaDynClass(CjsRequire::SIZE, JSType::JS_CJS_REQUIRE, cjsRequirePrototypeValue); + // CjsExports.prototype_or_hclass + JSHandle cjsRequireHClass = + factory_->NewEcmaHClass(CjsRequire::SIZE, JSType::JS_CJS_REQUIRE, cjsRequirePrototypeValue); // CjsExports.prototype.Constructor JSHandle cjsRequireFunction = NewBuiltinCjsCtor(env, cjsRequirePrototype, BuiltinsCjsRequire::CjsRequireConstructor, "require", FunctionLength::ONE); - JSHandle(cjsRequireFunction)->SetFunctionPrototype(thread_, cjsRequireDynclass.GetTaggedValue()); + JSHandle(cjsRequireFunction)->SetFunctionPrototype(thread_, cjsRequireHClass.GetTaggedValue()); // CjsModule.prototype method SetFunction(env, cjsRequirePrototype, "Main", BuiltinsCjsRequire::Main, FunctionLength::ONE); diff --git a/ecmascript/builtins.h b/ecmascript/builtins.h index 5865b9877b..2890b07dbb 100644 --- a/ecmascript/builtins.h +++ b/ecmascript/builtins.h @@ -64,57 +64,57 @@ private: void InitializeGlobalObject(const JSHandle &env, const JSHandle &globalObject); - void InitializeFunction(const JSHandle &env, const JSHandle &emptyFuncDynclass) const; + void InitializeFunction(const JSHandle &env, const JSHandle &emptyFuncClass) const; void InitializeObject(const JSHandle &env, const JSHandle &objFuncPrototype, const JSHandle &objFunc); void InitializeNumber(const JSHandle &env, const JSHandle &globalObject, - const JSHandle &primRefObjDynclass); + const JSHandle &primRefObjClass); - void InitializeBigInt(const JSHandle &env, const JSHandle &primRefObjDynclass) const; + void InitializeBigInt(const JSHandle &env, const JSHandle &primRefObjClass) const; void InitializeBigIntWithRealm(const JSHandle &realm) const; - void InitializeDate(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeDate(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeBoolean(const JSHandle &env, const JSHandle &primRefObjDynclass) const; + void InitializeBoolean(const JSHandle &env, const JSHandle &primRefObjClass) const; - void InitializeSymbol(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeSymbol(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeSymbolWithRealm(const JSHandle &realm, const JSHandle &objFuncInstanceDynclass); + void InitializeSymbolWithRealm(const JSHandle &realm, const JSHandle &objFuncInstanceHClass); void InitializeArray(const JSHandle &env, const JSHandle &objFuncPrototypeVal) const; - void InitializeTypedArray(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeTypedArray(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeInt8Array(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeInt8Array(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeUint8Array(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeUint8Array(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeUint8ClampedArray(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeUint8ClampedArray(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeInt16Array(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeInt16Array(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeUint16Array(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeUint16Array(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeInt32Array(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeInt32Array(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeUint32Array(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeUint32Array(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeFloat32Array(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeFloat32Array(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeFloat64Array(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeFloat64Array(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeBigInt64Array(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeBigInt64Array(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeBigUint64Array(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeBigUint64Array(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeAllTypeError(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeAllTypeError(const JSHandle &env, const JSHandle &objFuncClass) const; void InitializeAllTypeErrorWithRealm(const JSHandle &realm) const; - void InitializeError(const JSHandle &env, const JSHandle &objFuncDynclass, + void InitializeError(const JSHandle &env, const JSHandle &objFuncClass, const JSType &errorTag) const; void SetErrorWithRealm(const JSHandle &realm, const JSType &errorTag) const; @@ -139,18 +139,18 @@ private: void GeneralUpdateError(ErrorParameter *error, EcmaEntrypoint constructor, EcmaEntrypoint method, const char *name, JSType type) const; - void InitializeSet(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeSet(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeMap(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeMap(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeWeakMap(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeWeakMap(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeWeakSet(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeWeakSet(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeWeakRef(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeWeakRef(const JSHandle &env, const JSHandle &objFuncClass) const; void InitializeFinalizationRegistry(const JSHandle &env, - const JSHandle &objFuncDynclass) const; + const JSHandle &objFuncClass) const; void InitializeMath(const JSHandle &env, const JSHandle &objFuncPrototypeVal) const; @@ -158,27 +158,27 @@ private: void InitializeJson(const JSHandle &env, const JSHandle &objFuncPrototypeVal) const; - void InitializeString(const JSHandle &env, const JSHandle &primRefObjDynclass) const; + void InitializeString(const JSHandle &env, const JSHandle &primRefObjHClass) const; - void InitializeIterator(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeIterator(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeRegexpIterator(const JSHandle &env, const JSHandle &iteratorFuncDynclass) const; + void InitializeRegexpIterator(const JSHandle &env, const JSHandle &iteratorFuncClass) const; - void InitializeStringIterator(const JSHandle &env, const JSHandle &iteratorFuncDynclass) const; + void InitializeStringIterator(const JSHandle &env, const JSHandle &iteratorFuncClass) const; - void InitializeForinIterator(const JSHandle &env, const JSHandle &iteratorFuncDynclass) const; + void InitializeForinIterator(const JSHandle &env, const JSHandle &iteratorFuncClass) const; - void InitializeMapIterator(const JSHandle &env, const JSHandle &iteratorFuncDynclass) const; + void InitializeMapIterator(const JSHandle &env, const JSHandle &iteratorFuncClass) const; - void InitializeSetIterator(const JSHandle &env, const JSHandle &iteratorFuncDynclass) const; + void InitializeSetIterator(const JSHandle &env, const JSHandle &iteratorFuncClass) const; - void InitializeArrayIterator(const JSHandle &env, const JSHandle &iteratorFuncDynclass) const; + void InitializeArrayIterator(const JSHandle &env, const JSHandle &iteratorFuncClass) const; - void InitializeArrayBuffer(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeArrayBuffer(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeSharedArrayBuffer(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeSharedArrayBuffer(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeDataView(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeDataView(const JSHandle &env, const JSHandle &objFuncClass) const; void InitializeForPromiseFuncClass(const JSHandle &env); @@ -186,25 +186,25 @@ private: void InitializeReflect(const JSHandle &env, const JSHandle &objFuncPrototypeVal) const; - void InitializeAsyncFunction(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeAsyncFunction(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeGeneratorFunction(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeGeneratorFunction(const JSHandle &env, const JSHandle &objFuncClass) const; void InitializeAsyncGeneratorFunction(const JSHandle &env, - const JSHandle &objFuncDynclass) const; + const JSHandle &objFuncClass) const; - void InitializeAsyncGenerator(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeAsyncGenerator(const JSHandle &env, const JSHandle &objFuncClass) const; - void InitializeGenerator(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeGenerator(const JSHandle &env, const JSHandle &objFuncClass) const; JSHandle InitializeExoticConstructor(const JSHandle &env, EcmaEntrypoint ctorFunc, const char *name, int length); - void InitializePromise(const JSHandle &env, const JSHandle &promiseFuncDynclass); + void InitializePromise(const JSHandle &env, const JSHandle &promiseFuncClass); void InitializePromiseJob(const JSHandle &env); - void InitializeModuleNamespace(const JSHandle &env, const JSHandle &objFuncDynclass) const; + void InitializeModuleNamespace(const JSHandle &env, const JSHandle &objFuncClass) const; void InitializeCjsModule(const JSHandle &env) const; diff --git a/ecmascript/builtins/builtins_string.cpp b/ecmascript/builtins/builtins_string.cpp index 37cac055b6..f8a61226c3 100644 --- a/ecmascript/builtins/builtins_string.cpp +++ b/ecmascript/builtins/builtins_string.cpp @@ -2119,8 +2119,8 @@ JSTaggedValue BuiltinsString::ThisStringValue(JSThread *thread, JSTaggedValue va return value; } if (value.IsECMAObject()) { - auto jshClass = value.GetTaggedObject()->GetClass(); - if (jshClass->GetObjectType() == JSType::JS_PRIMITIVE_REF) { + auto jshclass = value.GetTaggedObject()->GetClass(); + if (jshclass->GetObjectType() == JSType::JS_PRIMITIVE_REF) { JSTaggedValue primitive = JSPrimitiveRef::Cast(value.GetTaggedObject())->GetValue(); if (primitive.IsString()) { return primitive; diff --git a/ecmascript/builtins/tests/builtins_array_test.cpp b/ecmascript/builtins/tests/builtins_array_test.cpp index 22af3b6dac..7d68dbf99d 100644 --- a/ecmascript/builtins/tests/builtins_array_test.cpp +++ b/ecmascript/builtins/tests/builtins_array_test.cpp @@ -173,10 +173,10 @@ JSTaggedValue CreateBuiltinsArrayJSObject(JSThread *thread, const CString keyCSt EcmaVM *ecmaVM = thread->GetEcmaVM(); JSHandle globalEnv = ecmaVM->GetGlobalEnv(); - JSHandle dynclass = globalEnv->GetObjectFunction(); + JSHandle hclass = globalEnv->GetObjectFunction(); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHandle obj(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle obj(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); JSHandle key(factory->NewFromASCII(&keyCStr[0])); JSHandle value(thread, JSTaggedValue(1)); JSObject::SetProperty(thread, obj, key, value); diff --git a/ecmascript/builtins/tests/builtins_object_test.cpp b/ecmascript/builtins/tests/builtins_object_test.cpp index ca3b983f90..7b57436281 100644 --- a/ecmascript/builtins/tests/builtins_object_test.cpp +++ b/ecmascript/builtins/tests/builtins_object_test.cpp @@ -80,10 +80,10 @@ JSFunction *BuiltinsObjectTestCreate(JSThread *thread) return globalEnv->GetObjectFunction().GetObject(); } -JSObject *TestNewJSObject(JSThread *thread, const JSHandle &dynClass) +JSObject *TestNewJSObject(JSThread *thread, const JSHandle &hclass) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSObject *obj = JSObject::Cast(factory->NewDynObject(dynClass)); + JSObject *obj = JSObject::Cast(factory->NewObject(hclass)); obj->SetElements(thread, factory->EmptyArray().GetTaggedValue(), SKIP_BARRIER); return obj; diff --git a/ecmascript/builtins/tests/builtins_regexp_test.cpp b/ecmascript/builtins/tests/builtins_regexp_test.cpp index 93b4774a8d..9a4abe7743 100644 --- a/ecmascript/builtins/tests/builtins_regexp_test.cpp +++ b/ecmascript/builtins/tests/builtins_regexp_test.cpp @@ -66,7 +66,7 @@ JSTaggedValue CreateBuiltinsRegExpObjByPatternAndFlags(JSThread *thread, const J JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); JSHandle regexp(env->GetRegExpFunction()); JSHandle globalObject(thread, env->GetGlobalObject()); - // make dyn_runtime_call_info + // make ecma_runtime_call_info // 8 : test case auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*regexp), 8); ecmaRuntimeCallInfo->SetFunction(regexp.GetTaggedValue()); diff --git a/ecmascript/builtins/tests/builtins_string_test.cpp b/ecmascript/builtins/tests/builtins_string_test.cpp index d32c05ba73..f452084f0e 100644 --- a/ecmascript/builtins/tests/builtins_string_test.cpp +++ b/ecmascript/builtins/tests/builtins_string_test.cpp @@ -1155,7 +1155,7 @@ HWTEST_F_L0(BuiltinsStringTest, Replace4) JSHandle expected = thread->GetEcmaVM()->GetFactory()->NewFromASCII( "The Quick Brown Fox Jumpsa The Over The Lazy Dog Jumps Brown $1 Jumps1 $32 a Over The Lazy Dog"); - // make dyn_runtime_call_info2 + // make ecma_runtime_call_info2 JSHandle thisStr = thread->GetEcmaVM()->GetFactory()->NewFromASCII("The Quick Brown Fox Jumps Over The Lazy Dog"); JSHandle replaceStr = diff --git a/ecmascript/builtins/tests/builtins_typedarray_test.cpp b/ecmascript/builtins/tests/builtins_typedarray_test.cpp index 58cc111c8f..c43145fdf1 100644 --- a/ecmascript/builtins/tests/builtins_typedarray_test.cpp +++ b/ecmascript/builtins/tests/builtins_typedarray_test.cpp @@ -175,10 +175,10 @@ JSTaggedValue CreateBuiltinsTypeArrayJSObject(JSThread *thread, const CString ke { auto ecmaVM = thread->GetEcmaVM(); JSHandle env = ecmaVM->GetGlobalEnv(); - JSHandle dynclass = env->GetObjectFunction(); + JSHandle hclass = env->GetObjectFunction(); ObjectFactory *factory = ecmaVM->GetFactory(); - JSHandle obj(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle obj(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); JSHandle key(factory->NewFromASCII(&keyCStr[0])); JSHandle value(thread, JSTaggedValue(1)); JSObject::SetProperty(thread, obj, key, value); diff --git a/ecmascript/compiler/assembler/tests/assembler_x64_test.cpp b/ecmascript/compiler/assembler/tests/assembler_x64_test.cpp index 13e63eded8..d238e7835d 100644 --- a/ecmascript/compiler/assembler/tests/assembler_x64_test.cpp +++ b/ecmascript/compiler/assembler/tests/assembler_x64_test.cpp @@ -236,7 +236,6 @@ HWTEST_F_L0(AssemblerX64Test, Emit1) value = masm.GetU8(current++); ASSERT_EQ(value, 0x00U); - // ba 05 00 00 00 movq $JUMP_SIZE_PREF_IMM16_V8, %rdx __ Movq(0x5, rdx); value = masm.GetU8(current++); ASSERT_EQ(value, 0xBAU); diff --git a/ecmascript/compiler/assembler_module.cpp b/ecmascript/compiler/assembler_module.cpp index e3a35d8333..143e0e5d78 100644 --- a/ecmascript/compiler/assembler_module.cpp +++ b/ecmascript/compiler/assembler_module.cpp @@ -111,18 +111,18 @@ int AssemblerModule::GetJumpSizeFromJSCallMode(JSCallMode mode) { switch (mode) { case JSCallMode::CALL_ARG0: - return BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_V8); + return BytecodeInstruction::Size(BytecodeInstruction::Format::IMM8); case JSCallMode::CALL_ARG1: - return BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_V8_V8); + return BytecodeInstruction::Size(BytecodeInstruction::Format::IMM8_V8); case JSCallMode::CALL_ARG2: - return BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_V8_V8_V8); + return BytecodeInstruction::Size(BytecodeInstruction::Format::IMM8_V8_V8); case JSCallMode::CALL_ARG3: - return BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_V8_V8_V8_V8); + return BytecodeInstruction::Size(BytecodeInstruction::Format::IMM8_V8_V8_V8); case JSCallMode::CALL_THIS_WITH_ARGV: case JSCallMode::CALL_WITH_ARGV: case JSCallMode::CALL_CONSTRUCTOR_WITH_ARGV: case JSCallMode::CALL_SUPER_CALL_WITH_ARGV: - return BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_IMM16_V8); + return BytecodeInstruction::Size(BytecodeInstruction::Format::IMM8_IMM8_V8); case JSCallMode::CALL_GETTER: case JSCallMode::CALL_SETTER: case JSCallMode::CALL_ENTRY: diff --git a/ecmascript/compiler/async_function_lowering.cpp b/ecmascript/compiler/async_function_lowering.cpp index abd9494202..58a21337f5 100644 --- a/ecmascript/compiler/async_function_lowering.cpp +++ b/ecmascript/compiler/async_function_lowering.cpp @@ -44,7 +44,7 @@ void AsyncFunctionLowering::ProcessJumpTable() const auto &suspendAndResumeGates = bcBuilder_->GetAsyncRelatedGates(); for (const auto &gate : suspendAndResumeGates) { auto curInfo = bcBuilder_->GetByteCodeInfo(gate); - if (curInfo.IsBc(EcmaOpcode::RESUMEGENERATOR_PREF_V8)) { + if (curInfo.IsBc(EcmaOpcode::RESUMEGENERATOR)) { RebuildGeneratorCfg(gate, restoreOffsetGate, ifFalseCondition, newTarget, firstState); } } diff --git a/ecmascript/compiler/bc_call_signature.h b/ecmascript/compiler/bc_call_signature.h index d495898d12..b0beb724f7 100644 --- a/ecmascript/compiler/bc_call_signature.h +++ b/ecmascript/compiler/bc_call_signature.h @@ -23,172 +23,212 @@ namespace panda::ecmascript::kungfu { #define IGNORE_BC_STUB(...) // V: Not Enabled, T: Enabled, D: Always Disable SingleStepDebugging #define ASM_INTERPRETER_BC_STUB_LIST(V, T, D) \ - T(HandleLdNanPref) \ - T(HandleLdInfinityPref) \ - T(HandleLdGlobalThisPref) \ - T(HandleLdUndefinedPref) \ - T(HandleLdNullPref) \ - T(HandleLdSymbolPref) \ - T(HandleLdGlobalPref) \ - T(HandleLdTruePref) \ - T(HandleLdFalsePref) \ - D(HandleThrowDynPref) \ - T(HandleTypeOfDynPref) \ - T(HandleLdLexEnvDynPref) \ - T(HandlePopLexEnvDynPref) \ - T(HandleGetUnmappedArgsPref) \ - T(HandleGetPropIteratorPref) \ - T(HandleAsyncFunctionEnterPref) \ - T(HandleLdHolePref) \ - D(HandleReturnUndefinedPref) \ - T(HandleCreateEmptyObjectPref) \ - T(HandleCreateEmptyArrayPref) \ - T(HandleGetIteratorPref) \ - D(HandleThrowThrowNotExistsPref) \ - D(HandleThrowPatternNonCoerciblePref) \ - T(HandleLdHomeObjectPref) \ - D(HandleThrowDeleteSuperPropertyPref) \ - T(HandleDebuggerPref) \ - T(HandleAdd2DynPrefV8) \ - T(HandleSub2DynPrefV8) \ - T(HandleMul2DynPrefV8) \ - T(HandleDiv2DynPrefV8) \ - T(HandleMod2DynPrefV8) \ - T(HandleEqDynPrefV8) \ - T(HandleNotEqDynPrefV8) \ - T(HandleLessDynPrefV8) \ - T(HandleLessEqDynPrefV8) \ - T(HandleGreaterDynPrefV8) \ - T(HandleGreaterEqDynPrefV8) \ - T(HandleShl2DynPrefV8) \ - T(HandleAshr2DynPrefV8) \ - T(HandleShr2DynPrefV8) \ - T(HandleAnd2DynPrefV8) \ - T(HandleOr2DynPrefV8) \ - T(HandleXOr2DynPrefV8) \ - T(HandleToNumberPrefV8) \ - T(HandleNegDynPrefV8) \ - T(HandleNotDynPrefV8) \ - T(HandleIncDynPrefV8) \ - T(HandleDecDynPrefV8) \ - T(HandleExpDynPrefV8) \ - T(HandleIsInDynPrefV8) \ - T(HandleInstanceOfDynPrefV8) \ - T(HandleStrictNotEqDynPrefV8) \ - T(HandleStrictEqDynPrefV8) \ - D(HandleResumeGeneratorPrefV8) \ - T(HandleGetResumeModePrefV8) \ - D(HandleCreateGeneratorObjPrefV8) \ - D(HandleThrowConstAssignmentPrefV8) \ - T(HandleGetTemplateObjectPrefV8) \ - T(HandleGetNextPropNamePrefV8) \ - D(HandleCallArg0DynPrefV8) \ - D(HandleThrowIfNotObjectPrefV8) \ - T(HandleIterNextPrefV8) \ - T(HandleCloseIteratorPrefV8) \ - T(HandleCopyModulePrefV8) \ - D(HandleSuperCallSpreadPrefV8) \ - T(HandleDelObjPropPrefV8V8) \ - D(HandleNewObjSpreadDynPrefV8V8) \ - T(HandleCreateIterResultObjPrefV8V8) \ - D(HandleSuspendGeneratorPrefV8V8) \ - T(HandleAsyncFunctionAwaitUncaughtPrefV8V8) \ - D(HandleThrowUndefinedIfHolePrefV8V8) \ - D(HandleCallArg1DynPrefV8V8) \ - T(HandleCopyDataPropertiesPrefV8V8) \ - T(HandleStArraySpreadPrefV8V8) \ - T(HandleGetIteratorNextPrefV8V8) \ - T(HandleSetObjectWithProtoPrefV8V8) \ - T(HandleLdObjByValuePrefV8V8) \ - T(HandleStObjByValuePrefV8V8) \ - T(HandleStOwnByValuePrefV8V8) \ - T(HandleLdSuperByValuePrefV8V8) \ - T(HandleStSuperByValuePrefV8V8) \ - T(HandleLdObjByIndexPrefV8Imm32) \ - T(HandleStObjByIndexPrefV8Imm32) \ - T(HandleStOwnByIndexPrefV8Imm32) \ - D(HandleCallSpreadDynPrefV8V8V8) \ - T(HandleAsyncFunctionResolvePrefV8V8V8) \ - T(HandleAsyncFunctionRejectPrefV8V8V8) \ - D(HandleCallArgs2DynPrefV8V8V8) \ - D(HandleCallArgs3DynPrefV8V8V8V8) \ - T(HandleDefineGetterSetterByValuePrefV8V8V8V8) \ - D(HandleNewObjDynRangePrefImm16V8) \ - D(HandleCallIRangeDynPrefImm16V8) \ - D(HandleCallIThisRangeDynPrefImm16V8) \ - D(HandleSuperCallPrefImm16V8) \ - T(HandleCreateObjectWithExcludedKeysPrefImm16V8V8) \ - T(HandleDefineFuncDynPrefId16Imm16V8) \ - T(HandleDefineNCFuncDynPrefId16Imm16V8) \ - T(HandleDefineGeneratorFuncPrefId16Imm16V8) \ - T(HandleDefineAsyncFuncPrefId16Imm16V8) \ - T(HandleDefineMethodPrefId16Imm16V8) \ - T(HandleNewLexEnvDynPrefImm16) \ - T(HandleCopyRestArgsPrefImm16) \ - T(HandleCreateArrayWithBufferPrefImm16) \ - T(HandleCreateObjectHavingMethodPrefImm16) \ - D(HandleThrowIfSuperNotCorrectCallPrefImm16) \ - T(HandleCreateObjectWithBufferPrefImm16) \ - T(HandleLdLexVarDynPrefImm4Imm4) \ - T(HandleLdLexVarDynPrefImm8Imm8) \ - T(HandleLdLexVarDynPrefImm16Imm16) \ - T(HandleStLexVarDynPrefImm4Imm4V8) \ - T(HandleStLexVarDynPrefImm8Imm8V8) \ - T(HandleStLexVarDynPrefImm16Imm16V8) \ - T(HandleDefineClassWithBufferPrefId16Imm16Imm16V8V8) \ - T(HandleGetModuleNamespacePrefId32) \ - T(HandleStModuleVarPrefId32) \ - T(HandleTryLdGlobalByNamePrefId32) \ - T(HandleTryStGlobalByNamePrefId32) \ - T(HandleLdGlobalVarPrefId32) \ - T(HandleStGlobalVarPrefId32) \ - T(HandleLdObjByNamePrefId32V8) \ - T(HandleStObjByNamePrefId32V8) \ - T(HandleStOwnByNamePrefId32V8) \ - T(HandleLdSuperByNamePrefId32V8) \ - T(HandleStSuperByNamePrefId32V8) \ - T(HandleLdModuleVarPrefId32Imm8) \ - T(HandleCreateRegExpWithLiteralPrefId32Imm8) \ - T(HandleIsTruePref) \ - T(HandleIsFalsePref) \ - T(HandleStConstToGlobalRecordPrefId32) \ - T(HandleStLetToGlobalRecordPrefId32) \ - T(HandleStClassToGlobalRecordPrefId32) \ - T(HandleStOwnByValueWithNameSetPrefV8V8) \ - T(HandleStOwnByNameWithNameSetPrefId32V8) \ - T(HandleLdFunctionPref) \ - T(HandleNewLexEnvWithNameDynPrefImm16Imm16) \ - T(HandleLdBigIntPrefId32) \ - T(HandleToNumericPrefV8) \ - T(HandleCreateAsyncGeneratorObjPrefV8) \ - T(HandleAsyncGeneratorResolvePrefV8V8V8) \ - T(HandleDefineAsyncGeneratorFuncPrefId16Imm16V8) \ - T(HandleMovDynV8V8) \ - T(HandleMovDynV16V16) \ - T(HandleLdaStrId32) \ - T(HandleLdaiDynImm32) \ - T(HandleFldaiDynImm64) \ + D(ExceptionHandler) +/* +#define ASM_INTERPRETER_BC_STUB_LIST(V, T, D) \ + T(HandleLdNan) \ + T(HandleLdInfinity) \ + T(HandleLdGlobalThis) \ + T(HandleLdUndefined) \ + T(HandleLdNull) \ + T(HandleLdSymbol) \ + T(HandleLdGlobal) \ + T(HandleLdTrue) \ + T(HandleLdFalse) \ + D(HandleThrow) \ + T(HandleTypeofImm8) \ + T(HandleLdLexEnv) \ + T(HandlePopLexEnv) \ + T(HandleGetUnmappedArgs) \ + T(HandleGetPropIterator) \ + T(HandleAsyncFunctionEnter) \ + T(HandleLdHole) \ + D(HandleReturnUndefined) \ + T(HandleCreateEmptyObject) \ + T(HandleCreateEmptyArrayImm8) \ + T(HandleGetIteratorImm8) \ + D(HandleThrowThrowNotExists) \ + D(HandleThrowPatternNonCoercible) \ + T(HandleLdHomeObject) \ + D(HandleThrowDeleteSuperProperty) \ + T(HandleDebugger) \ + T(HandleAdd2Imm8V8) \ + T(HandleSub2Imm8V8) \ + T(HandleMul2Imm8V8) \ + T(HandleDiv2Imm8V8) \ + T(HandleMod2Imm8V8) \ + T(HandleEqImm8V8) \ + T(HandleNotEqImm8V8) \ + T(HandleLessImm8V8) \ + T(HandleLessEqImm8V8) \ + T(HandleGreaterImm8V8) \ + T(HandleGreaterEqImm8V8) \ + T(HandleShl2Imm8V8) \ + T(HandleAshr2Imm8V8) \ + T(HandleShr2Imm8V8) \ + T(HandleAnd2Imm8V8) \ + T(HandleOr2Imm8V8) \ + T(HandleXOr2Imm8V8) \ + T(HandleToNumberImm8V8) \ + T(HandleNegImm8V8) \ + T(HandleNotImm8V8) \ + T(HandleIncImm8V8) \ + T(HandleDecImm8V8) \ + T(HandleExpImm8V8) \ + T(HandleIsInImm8V8) \ + T(HandleInstanceOfImm8V8) \ + T(HandleStrictNotEqImm8V8) \ + T(HandleStrictEqImm8V8) \ + D(HandleResumeGeneratorV8) \ + T(HandleGetResumeModeV8) \ + D(HandleCreateGeneratorObjV8) \ + D(HandleThrowConstAssignmentV8) \ + T(HandleGetTemplateObjectImm8V8) \ + T(HandleGetNextPropNameV8) \ + D(HandleCallArg0Imm8V8) \ + D(HandleThrowIfNotObjectV8) \ + T(HandleIterNextImm8V8) \ + T(HandleCloseIteratorImm8V8) \ + T(HandleNop1) \ + D(HandleSuperCallSpreadImm8V8) \ + T(HandleDelObjPropV8V8) \ + D(HandleNewObjApplyImm8V8) \ + T(HandleCreateIterResultObjV8V8) \ + D(HandleSuspendGeneratorV8V8) \ + T(HandleAsyncFunctionAwaitUncaughtV8V8) \ + D(HandleThrowUndefinedIfHoleV8V8) \ + D(HandleCallArg1Imm8V8V8) \ + T(HandleCopyDataPropertiesV8V8) \ + T(HandleStArraySpreadV8V8) \ + T(HandleGetIteratorNextV8V8) \ + T(HandleSetObjectWithProtoImm8V8V8) \ + T(HandleLdObjByValueImm8V8V8) \ + T(HandleStObjByValueImm8V8V8) \ + T(HandleStOwnByValueImm8V8V8) \ + T(HandleLdSuperByValueImm8V8V8) \ + T(HandleStSuperByValueImm8V8V8) \ + T(HandleLdObjByIndexImm8V8Imm32) \ + T(HandleStObjByIndexImm8V8Imm32) \ + T(HandleStOwnByIndexImm8V8Imm32) \ + D(HandleCallSpreadImm8V8V8V8) \ + T(HandleAsyncFunctionResolveV8V8V8) \ + T(HandleAsyncFunctionRejectV8V8V8) \ + D(HandleCallArgs2Imm8V8V8V8) \ + D(HandleCallArgs3Imm8V8V8V8V8) \ + T(HandleDefineGetterSetterByValueV8V8V8V8) \ + D(HandleNewObjRangeImm8Imm16V8) \ + D(HandleCallRangeImm8Imm16V8) \ + D(HandleCallThisRangeImm8Imm16V8) \ + D(HandleSuperCallImm8Imm16V8) \ + T(HandleCreateObjectWithExcludedKeysImm8V8V8) \ + T(HandleDefineFuncImm8Id16Imm16V8) \ + T(HandleDefineNCFuncImm8Id16Imm16V8) \ + T(HandleDefineGeneratorFuncImm8Id16Imm16V8) \ + T(HandleDefineAsyncFuncImm8Id16Imm16V8) \ + T(HandleDefineMethodImm8Id16Imm16V8) \ + T(HandleNewLexEnvImm8) \ + T(HandleCopyRestArgsImm16) \ + T(HandleCreateArrayWithBufferImm8Imm16) \ + T(HandleCreateObjectHavingMethodImm8Imm16) \ + D(HandleThrowIfSuperNotCorrectCallImm16) \ + T(HandleCreateObjectWithBufferImm8Imm16) \ + T(HandleLdLexVarImm4Imm4) \ + T(HandleLdLexVarImm8Imm8) \ + T(HandleLdLexVarImm16Imm16) \ + T(HandleStLexVarImm4Imm4V8) \ + T(HandleStLexVarImm8Imm8V8) \ + T(HandleStLexVarImm16Imm16V8) \ + T(HandleDefineClassWithBufferImm8Id16Imm16Imm16V8V8) \ + T(HandleGetModuleNamespaceId16) \ + T(HandleStModuleVarId16) \ + T(HandleTryLdGlobalByNameImm8Id16) \ + T(HandleTryStGlobalByNameImm8Id16) \ + T(HandleLdGlobalVarId16) \ + T(HandleStGlobalVarId16) \ + T(HandleLdObjByNameImm8Id16V8) \ + T(HandleStObjByNameImm8Id16V8) \ + T(HandleStOwnByNameImm8Id16V8) \ + T(HandleLdSuperByNameImm8Id16V8) \ + T(HandleStSuperByNameImm8Id16V8) \ + T(HandleLdModuleVarId16Imm8) \ + T(HandleCreateRegExpWithLiteralImm8Id16Imm8) \ + T(HandleIsTrue) \ + T(HandleIsFalse) \ + T(HandleStConstToGlobalRecordId16) \ + T(HandleStLetToGlobalRecordId16) \ + T(HandleStClassToGlobalRecordId16) \ + T(HandleStOwnByValueWithNameSetImm8V8V8) \ + T(HandleStOwnByNameWithNameSetImm8Id16V8) \ + T(HandleLdThisFunction) \ + T(HandleNewLexEnvWithNameImm16Imm16) \ + T(HandleLdBigIntId16) \ + T(HandleToNumericImm8V8) \ + T(HandleCreateAsyncGeneratorObjV8) \ + T(HandleAsyncGeneratorResolveV8V8V8) \ + T(HandleDefineAsyncGeneratorFuncImm8Id16Imm16V8) \ + T(HandleMovV8V8) \ + T(HandleMovV16V16) \ + T(HandleLdaStrId16) \ + T(HandleLdaiImm32) \ + T(HandleFldaiImm64) \ T(HandleJmpImm8) \ T(HandleJmpImm16) \ T(HandleJmpImm32) \ T(HandleJeqzImm8) \ T(HandleJeqzImm16) \ - T(HandleLdaDynV8) \ - T(HandleStaDynV8) \ - D(HandleReturnDyn) \ + T(HandleLdaV8) \ + T(HandleStaV8) \ + D(HandleReturn) \ T(HandleMovV4V4) \ T(HandleJnezImm8) \ T(HandleJnezImm16) \ + T(HandleTypeofImm16) \ + T(HandleCreateemptyarrayImm16) \ + T(HandleGetiteratorImm16) \ + T(HandleGettemplateobjectImm16V8) \ + T(HandleCloseiteratorImm16V8) \ + T(HandleNewobjsApplyImm16V8V8) \ + T(HandleSetobjectwithprotoImm16V8V8) \ + T(HandleLdobjbyvalueImm16V8V8) \ + T(HandleStobjbyvalueImm16V8V8) \ + T(HandleStownbyvalueImm16V8V8) \ + T(HandleLdsuperbyvalueImm16V8V8) \ + T(HandleStsuperbyvalueImm16V8V8) \ + T(HandleLdobjbyindexImm16V8Imm32) \ + T(HandleStobjbyindexImm16V8Imm32) \ + T(HandleStownbyindexImm16V8Imm32) \ + T(HandleNewobjrangeImm16Imm16V8) \ + T(HandleDefinefuncImm16Id16Imm16V8) \ + T(HandleDefinencfuncImm16Id16Imm16V8) \ + T(HandleDefinegeneratorfuncImm16Id16Imm16V8) \ + T(HandleDefineasyncfuncImm16Id16Imm16V8) \ + T(HandleDefinemethodImm16Id16Imm16V8) \ + T(HandleCreatearraywithbufferImm16Imm16) \ + T(HandleCreateobjecthavingmethodImm16Imm16) \ + T(HandleCreateobjectwithbufferImm16Imm16) \ + T(HandleDefineclasswithbufferImm16Id16Imm16Imm16V8V8) \ + T(HandleTryldglobalbynameImm16Id16) \ + T(HandleTrystglobalbynameImm16Id16) \ + T(HandleLdobjbynameImm16Id16V8) \ + T(HandleStobjbynameImm16Id16V8) \ + T(HandleStownbynameImm16Id16V8) \ + T(HandleLdsuperbynameImm16Id16V8) \ + T(HandleStsuperbynameImm16Id16V8) \ + T(HandleStownbyvaluewithnamesetImm16V8V8) \ + T(HandleStownbynamewithnamesetImm16Id16V8) \ + T(HandleDefineasyncgeneratorfuncImm16Id16Imm16V8) \ + T(HandleNop) \ D(ExceptionHandler) +*/ #define ASM_INTERPRETER_BC_HELPER_STUB_LIST(V) \ V(SingleStepDebugging) \ V(HandleOverflow) \ V(BCDebuggerEntry) \ V(BCDebuggerExceptionEntry) \ - V(NewObjectDynRangeThrowException) \ + V(NewObjectRangeThrowException) \ V(ThrowStackOverflowException) \ - V(InterpreterGetPropertyByName) \ + // V(InterpreterGetPropertyByName) #define INTERPRETER_DISABLE_SINGLE_STEP_DEBUGGING_BC_STUB_LIST(V) \ ASM_INTERPRETER_BC_STUB_LIST(IGNORE_BC_STUB, IGNORE_BC_STUB, V) diff --git a/ecmascript/compiler/builtins/builtins_stubs.cpp b/ecmascript/compiler/builtins/builtins_stubs.cpp index 4be933359b..4de432b9ab 100644 --- a/ecmascript/compiler/builtins/builtins_stubs.cpp +++ b/ecmascript/compiler/builtins/builtins_stubs.cpp @@ -55,7 +55,7 @@ void name##StubBuilder::GenerateCircuitImpl(GateRef glue, GateRef nativeCode, Ga #endif #define CALLSLOWPATH() \ - CallNGCRuntime(glue, RTSTUB_ID(PushCallIRangeAndDispatchNative), \ + CallNGCRuntime(glue, RTSTUB_ID(PushCallRangeAndDispatchNative), \ { glue, nativeCode, func, thisValue, numArgs, argv }) GateRef BuiltinsStubBuilder::StringIndexOf(GateRef lhsData, bool lhsIsUtf8, GateRef rhsData, bool rhsIsUtf8, diff --git a/ecmascript/compiler/bytecode_circuit_builder.cpp b/ecmascript/compiler/bytecode_circuit_builder.cpp index fd12d3549b..19995ce487 100644 --- a/ecmascript/compiler/bytecode_circuit_builder.cpp +++ b/ecmascript/compiler/bytecode_circuit_builder.cpp @@ -36,101 +36,113 @@ void BytecodeCircuitBuilder::BytecodeToCircuit() void BytecodeCircuitBuilder::CollectBytecodeBlockInfo(uint8_t *pc, std::vector &bytecodeBlockInfos) { + // TODO + (void)pc; + (void)bytecodeBlockInfos; + /* auto opcode = static_cast(*pc); switch (opcode) { case EcmaOpcode::JMP_IMM8: { int8_t offset = static_cast(READ_INST_8_0()); + constexpr size_t defaultOffset = BytecodeInstruction::Size(EcmaOpcode::JMP_IMM8); std::vector temp; temp.emplace_back(pc + offset); // current basic block end bytecodeBlockInfos.emplace_back(pc, SplitKind::END, temp); - bytecodeBlockInfos.emplace_back(pc + BytecodeOffset::TWO, SplitKind::START, - std::vector(1, pc + BytecodeOffset::TWO)); + bytecodeBlockInfos.emplace_back(pc + defaultOffset, SplitKind::START, + std::vector(1, pc + defaultOffset)); // jump basic block start bytecodeBlockInfos.emplace_back(pc + offset, SplitKind::START, std::vector(1, pc + offset)); - } break; + } case EcmaOpcode::JMP_IMM16: { int16_t offset = static_cast(READ_INST_16_0()); + constexpr size_t defaultOffset = BytecodeInstruction::Size(EcmaOpcode::JMP_IMM16); std::vector temp; temp.emplace_back(pc + offset); bytecodeBlockInfos.emplace_back(pc, SplitKind::END, temp); - bytecodeBlockInfos.emplace_back(pc + BytecodeOffset::THREE, SplitKind::START, - std::vector(1, pc + BytecodeOffset::THREE)); + bytecodeBlockInfos.emplace_back(pc + defaultOffset, SplitKind::START, + std::vector(1, pc + defaultOffset)); bytecodeBlockInfos.emplace_back(pc + offset, SplitKind::START, std::vector(1, pc + offset)); - } break; + } case EcmaOpcode::JMP_IMM32: { int32_t offset = static_cast(READ_INST_32_0()); + constexpr size_t defaultOffset = BytecodeInstruction::Size(EcmaOpcode::JMP_IMM32); std::vector temp; temp.emplace_back(pc + offset); bytecodeBlockInfos.emplace_back(pc, SplitKind::END, temp); - bytecodeBlockInfos.emplace_back(pc + BytecodeOffset::FIVE, SplitKind::START, - std::vector(1, pc + BytecodeOffset::FIVE)); + bytecodeBlockInfos.emplace_back(pc + defaultOffset, SplitKind::START, + std::vector(1, pc + defaultOffset)); bytecodeBlockInfos.emplace_back(pc + offset, SplitKind::START, std::vector(1, pc + offset)); - } break; + } case EcmaOpcode::JEQZ_IMM8: { + constexpr size_t defaultOffset = BytecodeInstruction::Size(EcmaOpcode::JEQZ_IMM8); std::vector temp; - temp.emplace_back(pc + BytecodeOffset::TWO); // first successor + temp.emplace_back(pc + defaultOffset); // first successor int8_t offset = static_cast(READ_INST_8_0()); temp.emplace_back(pc + offset); // second successor // condition branch current basic block end bytecodeBlockInfos.emplace_back(pc, SplitKind::END, temp); // first branch basic block start - bytecodeBlockInfos.emplace_back(pc + BytecodeOffset::TWO, SplitKind::START, - std::vector(1, pc + BytecodeOffset::TWO)); + bytecodeBlockInfos.emplace_back(pc + defaultOffset, SplitKind::START, + std::vector(1, pc + defaultOffset)); // second branch basic block start bytecodeBlockInfos.emplace_back(pc + offset, SplitKind::START, std::vector(1, pc + offset)); - } break; + } case EcmaOpcode::JEQZ_IMM16: { + constexpr size_t defaultOffset = BytecodeInstruction::Size(EcmaOpcode::JEQZ_IMM16); std::vector temp; - temp.emplace_back(pc + BytecodeOffset::THREE); // first successor + temp.emplace_back(pc + defaultOffset); // first successor int16_t offset = static_cast(READ_INST_16_0()); temp.emplace_back(pc + offset); // second successor bytecodeBlockInfos.emplace_back(pc, SplitKind::END, temp); // end - bytecodeBlockInfos.emplace_back(pc + BytecodeOffset::THREE, SplitKind::START, - std::vector(1, pc + BytecodeOffset::THREE)); + bytecodeBlockInfos.emplace_back(pc + defaultOffset, SplitKind::START, + std::vector(1, pc + defaultOffset)); bytecodeBlockInfos.emplace_back(pc + offset, SplitKind::START, std::vector(1, pc + offset)); - } break; + } case EcmaOpcode::JNEZ_IMM8: { + constexpr size_t defaultOffset = BytecodeInstruction::Size(EcmaOpcode::JNEZ_IMM8); std::vector temp; - temp.emplace_back(pc + BytecodeOffset::TWO); // first successor + temp.emplace_back(pc + defaultOffset); // first successor int8_t offset = static_cast(READ_INST_8_0()); temp.emplace_back(pc + offset); // second successor bytecodeBlockInfos.emplace_back(pc, SplitKind::END, temp); - bytecodeBlockInfos.emplace_back(pc + BytecodeOffset::TWO, SplitKind::START, - std::vector(1, pc + BytecodeOffset::TWO)); + bytecodeBlockInfos.emplace_back(pc + defaultOffset, SplitKind::START, + std::vector(1, pc + defaultOffset)); bytecodeBlockInfos.emplace_back(pc + offset, SplitKind::START, std::vector(1, pc + offset)); - } break; + } case EcmaOpcode::JNEZ_IMM16: { + constexpr size_t defaultOffset = BytecodeInstruction::Size(EcmaOpcode::JNEZ_IMM16); std::vector temp; - temp.emplace_back(pc + BytecodeOffset::THREE); // first successor + temp.emplace_back(pc + defaultOffset); // first successor int16_t offset = static_cast(READ_INST_16_0()); temp.emplace_back(pc + offset); // second successor bytecodeBlockInfos.emplace_back(pc, SplitKind::END, temp); - bytecodeBlockInfos.emplace_back(pc + BytecodeOffset::THREE, SplitKind::START, - std::vector(1, pc + BytecodeOffset::THREE)); + bytecodeBlockInfos.emplace_back(pc + defaultOffset, SplitKind::START, + std::vector(1, pc + defaultOffset)); bytecodeBlockInfos.emplace_back(pc + offset, SplitKind::START, std::vector(1, pc + offset)); - } break; - case EcmaOpcode::RETURN_DYN: - case EcmaOpcode::RETURNUNDEFINED_PREF: - case EcmaOpcode::THROWDYN_PREF: - case EcmaOpcode::THROWCONSTASSIGNMENT_PREF_V8: - case EcmaOpcode::THROWTHROWNOTEXISTS_PREF: - case EcmaOpcode::THROWPATTERNNONCOERCIBLE_PREF: - case EcmaOpcode::THROWDELETESUPERPROPERTY_PREF: { + } + case EcmaOpcode::RETURN: + case EcmaOpcode::RETURNUNDEFINED: + case EcmaOpcode::THROW: + case EcmaOpcode::THROWCONSTASSIGNMENT_V8: + case EcmaOpcode::THROWTHROWNOTEXISTS: + case EcmaOpcode::THROWPATTERNNONCOERCIBLE: + case EcmaOpcode::THROWDELETESUPERPROPERTY: { bytecodeBlockInfos.emplace_back(pc, SplitKind::END, std::vector(1, pc)); break; } default: break; } + */ } void BytecodeCircuitBuilder::CollectTryCatchBlockInfo(std::map, @@ -192,9 +204,9 @@ void BytecodeCircuitBuilder::CollectTryCatchBlockInfo(std::map(1, *(iter + 1))); + std::vector(1, *(iter + 1))); } // Supplementary start block info for (auto iter = startBlockPc.cbegin(); iter != startBlockPc.cend(); iter++) { @@ -570,530 +582,372 @@ void BytecodeCircuitBuilder::RemoveDeadRegions(const std::map &b BytecodeInfo BytecodeCircuitBuilder::GetBytecodeInfo(const uint8_t *pc) { BytecodeInfo info; - auto opcode = static_cast(*pc); - info.opcode = opcode; + BytecodeInstruction inst(pc); + auto opcode = inst.GetOpcode(); + info.opcode = static_cast(opcode); + info.offset = BytecodeInstruction::Size(opcode); + info.accIn = inst.HasFlag(BytecodeInstruction::Flags::ACC_READ); + info.accOut = inst.HasFlag(BytecodeInstruction::Flags::ACC_WRITE); + // TODO + /* switch (opcode) { case EcmaOpcode::MOV_V4_V4: { uint16_t vdst = READ_INST_4_0(); uint16_t vsrc = READ_INST_4_1(); info.vregOut.emplace_back(vdst); - info.offset = BytecodeOffset::TWO; info.inputs.emplace_back(VirtualRegister(vsrc)); break; } - case EcmaOpcode::MOV_DYN_V8_V8: { + case EcmaOpcode::MOV_V8_V8: { uint16_t vdst = READ_INST_8_0(); uint16_t vsrc = READ_INST_8_1(); info.vregOut.emplace_back(vdst); - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(vsrc)); break; } - case EcmaOpcode::MOV_DYN_V16_V16: { + case EcmaOpcode::MOV_V16_V16: { uint16_t vdst = READ_INST_16_0(); uint16_t vsrc = READ_INST_16_2(); info.vregOut.emplace_back(vdst); - info.offset = BytecodeOffset::FIVE; info.inputs.emplace_back(VirtualRegister(vsrc)); break; } - case EcmaOpcode::LDA_STR_ID32: { - info.accOut = true; - info.offset = BytecodeOffset::FIVE; - uint64_t imm = READ_INST_32_0(); + case EcmaOpcode::LDA_STR_ID16: { + uint16_t imm = READ_INST_16_0(); info.inputs.emplace_back(StringId(imm)); break; } case EcmaOpcode::JMP_IMM8: { - info.offset = BytecodeOffset::TWO; break; } case EcmaOpcode::JMP_IMM16: { - info.offset = BytecodeOffset::THREE; break; } case EcmaOpcode::JMP_IMM32: { - info.offset = BytecodeOffset::FIVE; break; } case EcmaOpcode::JEQZ_IMM8: { - info.accIn = true; - info.offset = BytecodeOffset::TWO; break; } case EcmaOpcode::JEQZ_IMM16: { - info.accIn = true; - info.offset = BytecodeOffset::THREE; break; } case EcmaOpcode::JNEZ_IMM8: { - info.accIn = true; - info.offset = BytecodeOffset::TWO; break; } case EcmaOpcode::JNEZ_IMM16: { - info.accIn = true; - info.offset = BytecodeOffset::THREE; break; } - case EcmaOpcode::LDA_DYN_V8: { + case EcmaOpcode::LDA_V8: { uint16_t vsrc = READ_INST_8_0(); - info.accOut = true; - info.offset = BytecodeOffset::TWO; info.inputs.emplace_back(VirtualRegister(vsrc)); break; } - case EcmaOpcode::STA_DYN_V8: { + case EcmaOpcode::STA_V8: { uint16_t vdst = READ_INST_8_0(); info.vregOut.emplace_back(vdst); - info.accIn = true; - info.offset = BytecodeOffset::TWO; break; } - case EcmaOpcode::LDAI_DYN_IMM32: { - info.accOut = true; - info.offset = BytecodeOffset::FIVE; + case EcmaOpcode::LDAI_IMM32: { info.inputs.emplace_back(Immediate(READ_INST_32_0())); break; } - case EcmaOpcode::FLDAI_DYN_IMM64: { - info.accOut = true; - info.offset = BytecodeOffset::NINE; + case EcmaOpcode::FLDAI_IMM64: { info.inputs.emplace_back(Immediate(READ_INST_64_0())); break; } - case EcmaOpcode::CALLARG0DYN_PREF_V8: { + case EcmaOpcode::CALLARG0_IMM8_V8: { uint32_t funcReg = READ_INST_8_1(); - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(funcReg)); break; } - case EcmaOpcode::CALLARG1DYN_PREF_V8_V8: { + case EcmaOpcode::CALLARG1_IMM8_V8_V8: { uint32_t funcReg = READ_INST_8_1(); uint32_t reg = READ_INST_8_2(); - info.accOut = true; - info.offset = BytecodeOffset::FOUR; info.inputs.emplace_back(VirtualRegister(funcReg)); info.inputs.emplace_back(VirtualRegister(reg)); break; } - case EcmaOpcode::CALLARGS2DYN_PREF_V8_V8_V8: { + case EcmaOpcode::CALLARGS2_IMM8_V8_V8_V8: { uint32_t funcReg = READ_INST_8_1(); uint32_t reg0 = READ_INST_8_2(); uint32_t reg1 = READ_INST_8_3(); - info.accOut = true; - info.offset = BytecodeOffset::FIVE; info.inputs.emplace_back(VirtualRegister(funcReg)); info.inputs.emplace_back(VirtualRegister(reg0)); info.inputs.emplace_back(VirtualRegister(reg1)); break; } - case EcmaOpcode::CALLARGS3DYN_PREF_V8_V8_V8_V8: { + case EcmaOpcode::CALLARGS3_IMM8_V8_V8_V8_V8: { uint32_t funcReg = READ_INST_8_1(); uint32_t reg0 = READ_INST_8_2(); uint32_t reg1 = READ_INST_8_3(); uint32_t reg2 = READ_INST_8_4(); - info.accOut = true; - info.offset = BytecodeOffset::SIX; info.inputs.emplace_back(VirtualRegister(funcReg)); info.inputs.emplace_back(VirtualRegister(reg0)); info.inputs.emplace_back(VirtualRegister(reg1)); info.inputs.emplace_back(VirtualRegister(reg2)); break; } - case EcmaOpcode::CALLITHISRANGEDYN_PREF_IMM16_V8: { + case EcmaOpcode::CALLTHISRANGE_IMM8_IMM16_V8: { uint32_t funcReg = READ_INST_8_3(); uint32_t actualNumArgs = READ_INST_16_1(); info.inputs.emplace_back(VirtualRegister(funcReg)); for (size_t i = 1; i <= actualNumArgs; i++) { info.inputs.emplace_back(VirtualRegister(funcReg + i)); } - info.accOut = true; - info.offset = BytecodeOffset::FIVE; break; } - case EcmaOpcode::CALLSPREADDYN_PREF_V8_V8_V8: { + case EcmaOpcode::CALLSPREAD_IMM8_V8_V8_V8: { uint16_t v0 = READ_INST_8_1(); uint16_t v1 = READ_INST_8_2(); uint16_t v2 = READ_INST_8_3(); - info.accOut = true; - info.offset = BytecodeOffset::FIVE; info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v1)); info.inputs.emplace_back(VirtualRegister(v2)); break; } - case EcmaOpcode::CALLIRANGEDYN_PREF_IMM16_V8: { + case EcmaOpcode::CALLRANGE_IMM8_IMM16_V8: { uint32_t funcReg = READ_INST_8_3(); uint32_t actualNumArgs = READ_INST_16_1(); info.inputs.emplace_back(VirtualRegister(funcReg)); for (size_t i = 1; i <= actualNumArgs; i++) { info.inputs.emplace_back(VirtualRegister(funcReg + i)); } - info.accOut = true; - info.offset = BytecodeOffset::FIVE; break; } - case EcmaOpcode::RETURN_DYN: { - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::ONE; + case EcmaOpcode::RETURN: { break; } - case EcmaOpcode::RETURNUNDEFINED_PREF: { - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::RETURNUNDEFINED: { break; } - case EcmaOpcode::LDNAN_PREF: { - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::LDNAN: { break; } - case EcmaOpcode::LDINFINITY_PREF: { - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::LDINFINITY: { break; } - case EcmaOpcode::LDGLOBALTHIS_PREF: { - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::LDGLOBALTHIS: { break; } - case EcmaOpcode::LDUNDEFINED_PREF: { - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::LDUNDEFINED: { break; } - case EcmaOpcode::LDNULL_PREF: { - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::LDNULL: { break; } - case EcmaOpcode::LDSYMBOL_PREF: { - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::LDSYMBOL: { break; } - case EcmaOpcode::LDGLOBAL_PREF: { - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::LDGLOBAL: { break; } - case EcmaOpcode::LDTRUE_PREF: { - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::LDTRUE: { break; } - case EcmaOpcode::LDFALSE_PREF: { - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::LDFALSE: { break; } - case EcmaOpcode::LDLEXENVDYN_PREF: { - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::LDLEXENV: { break; } - case EcmaOpcode::GETUNMAPPEDARGS_PREF: { - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::GETUNMAPPEDARGS: { break; } - case EcmaOpcode::ASYNCFUNCTIONENTER_PREF: { - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::ASYNCFUNCTIONENTER: { break; } - case EcmaOpcode::TONUMBER_PREF_V8: { + case EcmaOpcode::TONUMBER_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::NEGDYN_PREF_V8: { + case EcmaOpcode::NEG_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::NOTDYN_PREF_V8: { + case EcmaOpcode::NOT_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::INCDYN_PREF_V8: { + case EcmaOpcode::INC_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::DECDYN_PREF_V8: { + case EcmaOpcode::DEC_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::THROWDYN_PREF: { - info.accIn = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::THROW: { break; } - case EcmaOpcode::TYPEOFDYN_PREF: { - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::TYPEOF_IMM8: { break; } - case EcmaOpcode::GETPROPITERATOR_PREF: { - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::GETPROPITERATOR: { break; } - case EcmaOpcode::RESUMEGENERATOR_PREF_V8: { - uint16_t vs = READ_INST_8_1(); - info.accOut = true; - info.offset = BytecodeOffset::THREE; + case EcmaOpcode::RESUMEGENERATOR_V8: { + uint16_t vs = READ_INST_8_0(); info.inputs.emplace_back(VirtualRegister(vs)); break; } - case EcmaOpcode::GETRESUMEMODE_PREF_V8: { - uint16_t vs = READ_INST_8_1(); - info.accOut = true; - info.offset = BytecodeOffset::THREE; + case EcmaOpcode::GETRESUMEMODE_V8: { + uint16_t vs = READ_INST_8_0(); info.inputs.emplace_back(VirtualRegister(vs)); break; } - case EcmaOpcode::GETITERATOR_PREF: { - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::GETITERATOR_IMM8: { break; } - case EcmaOpcode::THROWCONSTASSIGNMENT_PREF_V8: { - uint16_t v0 = READ_INST_8_1(); - info.offset = BytecodeOffset::THREE; + case EcmaOpcode::THROWCONSTASSIGNMENT_V8: { + uint16_t v0 = READ_INST_8_0(); info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::THROWTHROWNOTEXISTS_PREF: { - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::THROWTHROWNOTEXISTS: { break; } - case EcmaOpcode::THROWPATTERNNONCOERCIBLE_PREF: { - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::THROWPATTERNNONCOERCIBLE: { break; } - case EcmaOpcode::THROWIFNOTOBJECT_PREF_V8: { - uint16_t v0 = READ_INST_8_1(); - info.offset = BytecodeOffset::THREE; + case EcmaOpcode::THROWIFNOTOBJECT_V8: { + uint16_t v0 = READ_INST_8_0(); info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::ITERNEXT_PREF_V8: { + case EcmaOpcode::ITERNEXT_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::CLOSEITERATOR_PREF_V8: { + case EcmaOpcode::CLOSEITERATOR_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::ADD2DYN_PREF_V8: { + case EcmaOpcode::ADD2_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::SUB2DYN_PREF_V8: { + case EcmaOpcode::SUB2_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::MUL2DYN_PREF_V8: { + case EcmaOpcode::MUL2_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::DIV2DYN_PREF_V8: { + case EcmaOpcode::DIV2_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::MOD2DYN_PREF_V8: { + case EcmaOpcode::MOD2_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::EQDYN_PREF_V8: { + case EcmaOpcode::EQ_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::NOTEQDYN_PREF_V8: { + case EcmaOpcode::NOTEQ_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::LESSDYN_PREF_V8: { + case EcmaOpcode::LESS_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::LESSEQDYN_PREF_V8: { + case EcmaOpcode::LESSEQ_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::GREATERDYN_PREF_V8: { + case EcmaOpcode::GREATER_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::GREATEREQDYN_PREF_V8: { + case EcmaOpcode::GREATEREQ_IMM8_V8: { uint16_t vs = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(vs)); break; } - case EcmaOpcode::SHL2DYN_PREF_V8: { + case EcmaOpcode::SHL2_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::SHR2DYN_PREF_V8: { + case EcmaOpcode::SHR2_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::ASHR2DYN_PREF_V8: { + case EcmaOpcode::ASHR2_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::AND2DYN_PREF_V8: { + case EcmaOpcode::AND2_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::OR2DYN_PREF_V8: { + case EcmaOpcode::OR2_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::XOR2DYN_PREF_V8: { + case EcmaOpcode::XOR2_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::DELOBJPROP_PREF_V8_V8: { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - info.accOut = true; - info.offset = BytecodeOffset::FOUR; + case EcmaOpcode::DELOBJPROP_V8_V8: { + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v1)); break; } - case EcmaOpcode::DEFINEFUNCDYN_PREF_ID16_IMM16_V8: { + case EcmaOpcode::DEFINEFUNC_IMM8_ID16_IMM16_V8: { uint16_t v0 = READ_INST_8_5(); - info.accOut = true; - info.offset = BytecodeOffset::SEVEN; info.inputs.emplace_back(MethodId(READ_INST_16_1())); info.inputs.emplace_back(Immediate(READ_INST_16_3())); info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::DEFINENCFUNCDYN_PREF_ID16_IMM16_V8: { + case EcmaOpcode::DEFINENCFUNC_IMM8_ID16_IMM16_V8: { uint16_t methodId = READ_INST_16_1(); uint16_t length = READ_INST_16_3(); uint16_t v0 = READ_INST_8_5(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::SEVEN; info.inputs.emplace_back(MethodId(methodId)); info.inputs.emplace_back(Immediate(length)); info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::DEFINEMETHOD_PREF_ID16_IMM16_V8: { + case EcmaOpcode::DEFINEMETHOD_IMM8_ID16_IMM16_V8: { uint16_t methodId = READ_INST_16_1(); uint16_t length = READ_INST_16_3(); uint16_t v0 = READ_INST_8_5(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::SEVEN; info.inputs.emplace_back(MethodId(methodId)); info.inputs.emplace_back(Immediate(length)); info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::NEWOBJDYNRANGE_PREF_IMM16_V8: { - info.accOut = true; - info.offset = BytecodeOffset::FIVE; + case EcmaOpcode::NEWOBJRANGE_IMM8_IMM16_V8: { uint16_t range = READ_INST_16_1(); uint16_t firstArgRegIdx = READ_INST_8_3(); for (uint16_t i = 0; i < range; ++i) { @@ -1101,584 +955,467 @@ BytecodeInfo BytecodeCircuitBuilder::GetBytecodeInfo(const uint8_t *pc) } break; } - case EcmaOpcode::EXPDYN_PREF_V8: { + case EcmaOpcode::EXP_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::ISINDYN_PREF_V8: { + case EcmaOpcode::ISIN_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::INSTANCEOFDYN_PREF_V8: { + case EcmaOpcode::INSTANCEOF_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::STRICTNOTEQDYN_PREF_V8: { + case EcmaOpcode::STRICTNOTEQ_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::STRICTEQDYN_PREF_V8: { + case EcmaOpcode::STRICTEQ_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::LDLEXVARDYN_PREF_IMM16_IMM16: { - uint16_t level = READ_INST_16_1(); - uint16_t slot = READ_INST_16_3(); - info.accOut = true; - info.offset = BytecodeOffset::SIX; + case EcmaOpcode::LDLEXVAR_IMM16_IMM16: { + uint16_t level = READ_INST_16_0(); + uint16_t slot = READ_INST_16_2(); info.inputs.emplace_back(Immediate(level)); info.inputs.emplace_back(Immediate(slot)); break; } - case EcmaOpcode::LDLEXVARDYN_PREF_IMM8_IMM8: { - uint16_t level = READ_INST_8_1(); - uint16_t slot = READ_INST_8_2(); - info.accOut = true; - info.offset = BytecodeOffset::FOUR; + case EcmaOpcode::LDLEXVAR_IMM8_IMM8: { + uint16_t level = READ_INST_8_0(); + uint16_t slot = READ_INST_8_1(); info.inputs.emplace_back(Immediate(level)); info.inputs.emplace_back(Immediate(slot)); break; } - case EcmaOpcode::LDLEXVARDYN_PREF_IMM4_IMM4: { - uint16_t level = READ_INST_4_2(); - uint16_t slot = READ_INST_4_3(); - info.accOut = true; - info.offset = BytecodeOffset::THREE; + case EcmaOpcode::LDLEXVAR_IMM4_IMM4: { + uint16_t level = READ_INST_4_0(); + uint16_t slot = READ_INST_4_1(); info.inputs.emplace_back(Immediate(level)); info.inputs.emplace_back(Immediate(slot)); break; } - case EcmaOpcode::STLEXVARDYN_PREF_IMM16_IMM16_V8: { + case EcmaOpcode::STLEXVAR_IMM16_IMM16_V8: { uint16_t level = READ_INST_16_1(); uint16_t slot = READ_INST_16_3(); uint16_t v0 = READ_INST_8_5(); - info.offset = BytecodeOffset::SEVEN; info.inputs.emplace_back(Immediate(level)); info.inputs.emplace_back(Immediate(slot)); info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::STLEXVARDYN_PREF_IMM8_IMM8_V8: { - uint16_t level = READ_INST_8_1(); - uint16_t slot = READ_INST_8_2(); - uint16_t v0 = READ_INST_8_3(); - info.offset = BytecodeOffset::FIVE; + case EcmaOpcode::STLEXVAR_IMM8_IMM8_V8: { + uint16_t level = READ_INST_8_0(); + uint16_t slot = READ_INST_8_1(); + uint16_t v0 = READ_INST_8_2(); info.inputs.emplace_back(Immediate(level)); info.inputs.emplace_back(Immediate(slot)); info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::STLEXVARDYN_PREF_IMM4_IMM4_V8: { - uint16_t level = READ_INST_4_2(); - uint16_t slot = READ_INST_4_3(); - uint16_t v0 = READ_INST_8_2(); - info.offset = BytecodeOffset::FOUR; + case EcmaOpcode::STLEXVAR_IMM4_IMM4_V8: { + uint16_t level = READ_INST_4_0(); + uint16_t slot = READ_INST_4_1(); + uint16_t v0 = READ_INST_8_1(); info.inputs.emplace_back(Immediate(level)); info.inputs.emplace_back(Immediate(slot)); info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::NEWLEXENVDYN_PREF_IMM16: { - uint16_t numVars = READ_INST_16_1(); - info.accOut = true; - info.offset = BytecodeOffset::FOUR; + case EcmaOpcode::NEWLEXENV_IMM8: { + uint8_t numVars = READ_INST_8_0(); info.inputs.emplace_back(Immediate(numVars)); break; } - case EcmaOpcode::NEWLEXENVWITHNAMEDYN_PREF_IMM16_IMM16: { + case EcmaOpcode::WIDE_NEWLEXENV_PREF_IMM16: { uint16_t numVars = READ_INST_16_1(); - uint16_t scopeId = READ_INST_16_3(); - info.accOut = true; - info.offset = BytecodeOffset::SIX; + info.inputs.emplace_back(Immediate(numVars)); + break; + } + case EcmaOpcode::NEWLEXENVWITHNAME_IMM16_IMM16: { + uint16_t numVars = READ_INST_16_0(); + uint16_t scopeId = READ_INST_16_2(); info.inputs.emplace_back(Immediate(numVars)); info.inputs.emplace_back(Immediate(scopeId)); break; } - case EcmaOpcode::POPLEXENVDYN_PREF: { - info.accOut = false; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::POPLEXENV: { break; } - case EcmaOpcode::CREATEITERRESULTOBJ_PREF_V8_V8: { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - info.accOut = true; - info.offset = BytecodeOffset::FOUR; + case EcmaOpcode::CREATEITERRESULTOBJ_V8_V8: { + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v1)); break; } - case EcmaOpcode::SUSPENDGENERATOR_PREF_V8_V8: { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::FOUR; + case EcmaOpcode::SUSPENDGENERATOR_V8_V8: { + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); uint32_t offset = pc - method_->GetBytecodeArray(); info.inputs.emplace_back(Immediate(offset)); // Save the pc offset when suspend info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v1)); break; } - case EcmaOpcode::ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8: { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - info.accOut = true; - info.offset = BytecodeOffset::FOUR; + case EcmaOpcode::ASYNCFUNCTIONAWAITUNCAUGHT_V8_V8: { + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v1)); break; } - case EcmaOpcode::ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8: { - uint16_t v0 = READ_INST_8_1(); - uint16_t v2 = READ_INST_8_3(); - info.accOut = true; - info.offset = BytecodeOffset::FIVE; + case EcmaOpcode::ASYNCFUNCTIONRESOLVE_V8_V8_V8: { + uint16_t v0 = READ_INST_8_0(); + uint16_t v2 = READ_INST_8_2(); info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v2)); break; } - case EcmaOpcode::ASYNCFUNCTIONREJECT_PREF_V8_V8_V8: { - uint16_t v0 = READ_INST_8_1(); - uint16_t v2 = READ_INST_8_3(); - info.accOut = true; - info.offset = BytecodeOffset::FIVE; + case EcmaOpcode::ASYNCFUNCTIONREJECT_V8_V8_V8: { + uint16_t v0 = READ_INST_8_0(); + uint16_t v2 = READ_INST_8_2(); info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v2)); break; } - case EcmaOpcode::NEWOBJSPREADDYN_PREF_V8_V8: { + case EcmaOpcode::NEWOBJSPREAD_IMM8_V8_V8: { uint16_t v0 = READ_INST_8_1(); uint16_t v1 = READ_INST_8_2(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::FOUR; info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v1)); break; } - case EcmaOpcode::THROWUNDEFINEDIFHOLE_PREF_V8_V8: { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - info.offset = BytecodeOffset::FOUR; + case EcmaOpcode::THROWUNDEFINEDIFHOLE_V8_V8: { + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v1)); break; } - case EcmaOpcode::STOWNBYNAME_PREF_ID32_V8: { - uint32_t stringId = READ_INST_32_1(); - uint32_t v0 = READ_INST_8_5(); - info.accIn = true; - info.offset = BytecodeOffset::SEVEN; + case EcmaOpcode::STOWNBYNAME_IMM8_ID16_V8: { + uint16_t stringId = READ_INST_16_1(); + uint32_t v0 = READ_INST_8_3(); info.inputs.emplace_back(StringId(stringId)); info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::CREATEEMPTYARRAY_PREF: { - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::CREATEEMPTYARRAY_IMM8: { break; } - case EcmaOpcode::CREATEEMPTYOBJECT_PREF: { - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::CREATEEMPTYOBJECT: { break; } - case EcmaOpcode::CREATEOBJECTWITHBUFFER_PREF_IMM16: { + case EcmaOpcode::CREATEOBJECTWITHBUFFER_IMM8_IMM16: { uint16_t imm = READ_INST_16_1(); - info.accOut = true; - info.offset = BytecodeOffset::FOUR; info.inputs.emplace_back(Immediate(imm)); break; } - case EcmaOpcode::SETOBJECTWITHPROTO_PREF_V8_V8: { + case EcmaOpcode::SETOBJECTWITHPROTO_IMM8_V8_V8: { uint16_t v0 = READ_INST_8_1(); uint16_t v1 = READ_INST_8_2(); - info.offset = BytecodeOffset::FOUR; info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v1)); break; } - case EcmaOpcode::CREATEARRAYWITHBUFFER_PREF_IMM16: { + case EcmaOpcode::CREATEARRAYWITHBUFFER_IMM8_IMM16: { uint16_t imm = READ_INST_16_1(); - info.accOut = true; - info.offset = BytecodeOffset::FOUR; info.inputs.emplace_back(Immediate(imm)); break; } - case EcmaOpcode::GETMODULENAMESPACE_PREF_ID32: { - uint32_t stringId = READ_INST_32_1(); - info.accOut = true; - info.offset = BytecodeOffset::SIX; + case EcmaOpcode::GETMODULENAMESPACE_ID16: { + uint16_t stringId = READ_INST_16_0(); info.inputs.emplace_back(StringId(stringId)); break; } - case EcmaOpcode::STMODULEVAR_PREF_ID32: { - uint32_t stringId = READ_INST_32_1(); - info.accIn = true; - info.offset = BytecodeOffset::SIX; + case EcmaOpcode::STMODULEVAR_ID16: { + uint16_t stringId = READ_INST_16_0(); info.inputs.emplace_back(StringId(stringId)); break; } - case EcmaOpcode::COPYMODULE_PREF_V8: { - uint16_t v0 = READ_INST_8_1(); - info.offset = BytecodeOffset::THREE; - info.inputs.emplace_back(VirtualRegister(v0)); - break; - } - case EcmaOpcode::LDMODULEVAR_PREF_ID32_IMM8: { - uint32_t stringId = READ_INST_32_1(); - uint8_t innerFlag = READ_INST_8_5(); - info.accOut = true; - info.offset = BytecodeOffset::SEVEN; + case EcmaOpcode::LDMODULEVAR_ID16_IMM8: { + uint16_t stringId = READ_INST_16_0(); + uint8_t innerFlag = READ_INST_8_2(); info.inputs.emplace_back(StringId(stringId)); info.inputs.emplace_back(Immediate(innerFlag)); break; } - case EcmaOpcode::CREATEREGEXPWITHLITERAL_PREF_ID32_IMM8: { - uint32_t stringId = READ_INST_32_1(); - uint8_t flags = READ_INST_8_5(); - info.accOut = true; - info.offset = BytecodeOffset::SEVEN; + case EcmaOpcode::CREATEREGEXPWITHLITERAL_IMM8_ID16_IMM8: { + uint16_t stringId = READ_INST_16_1(); + uint8_t flags = READ_INST_8_3(); info.inputs.emplace_back(StringId(stringId)); info.inputs.emplace_back(Immediate(flags)); break; } - case EcmaOpcode::GETTEMPLATEOBJECT_PREF_V8: { + case EcmaOpcode::GETTEMPLATEOBJECT_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::GETNEXTPROPNAME_PREF_V8: { - uint16_t v0 = READ_INST_8_1(); - info.accOut = true; - info.offset = BytecodeOffset::THREE; + case EcmaOpcode::GETNEXTPROPNAME_V8: { + uint16_t v0 = READ_INST_8_0(); info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::COPYDATAPROPERTIES_PREF_V8_V8: { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - info.accOut = true; - info.offset = BytecodeOffset::FOUR; + case EcmaOpcode::COPYDATAPROPERTIES_V8_V8: { + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v1)); break; } - case EcmaOpcode::STOWNBYINDEX_PREF_V8_IMM32: { + case EcmaOpcode::STOWNBYINDEX_IMM8_V8_IMM32: { uint32_t v0 = READ_INST_8_1(); uint32_t index = READ_INST_32_2(); - info.accIn = true; - info.offset = BytecodeOffset::SEVEN; info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(Immediate(index)); break; } - case EcmaOpcode::STOWNBYVALUE_PREF_V8_V8: { + case EcmaOpcode::STOWNBYVALUE_IMM8_V8_V8: { uint32_t v0 = READ_INST_8_1(); uint32_t v1 = READ_INST_8_2(); - info.accIn = true; - info.offset = BytecodeOffset::FOUR; info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v1)); break; } - case EcmaOpcode::CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8: { + case EcmaOpcode::CREATEOBJECTWITHEXCLUDEDKEYS_IMM8_V8_V8: { + uint8_t numKeys = READ_INST_8_0(); + uint16_t v0 = READ_INST_8_1(); + uint16_t firstArgRegIdx = READ_INST_8_2(); + info.inputs.emplace_back(Immediate(numKeys)); + info.inputs.emplace_back(VirtualRegister(v0)); + info.inputs.emplace_back(Immediate(firstArgRegIdx)); + break; + } + case EcmaOpcode::WIDE_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8: { uint16_t numKeys = READ_INST_16_1(); uint16_t v0 = READ_INST_8_3(); uint16_t firstArgRegIdx = READ_INST_8_4(); - info.accOut = true; - info.offset = BytecodeOffset::SIX; info.inputs.emplace_back(Immediate(numKeys)); info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(Immediate(firstArgRegIdx)); break; } - case EcmaOpcode::DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8: { + case EcmaOpcode::DEFINEGENERATORFUNC_IMM8_ID16_IMM16_V8: { uint16_t methodId = READ_INST_16_1(); uint16_t length = READ_INST_16_3(); uint16_t v0 = READ_INST_8_5(); - info.accOut = true; - info.offset = BytecodeOffset::SEVEN; info.inputs.emplace_back(MethodId(methodId)); info.inputs.emplace_back(Immediate(length)); info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8: { + case EcmaOpcode::DEFINEASYNCGENERATORFUNC_IMM8_ID16_IMM16_V8: { uint16_t methodId = READ_INST_16_1(); uint16_t length = READ_INST_16_3(); uint16_t v0 = READ_INST_8_5(); - info.accOut = true; - info.offset = BytecodeOffset::SEVEN; info.inputs.emplace_back(MethodId(methodId)); info.inputs.emplace_back(Immediate(length)); info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::DEFINEASYNCFUNC_PREF_ID16_IMM16_V8: { + case EcmaOpcode::DEFINEASYNCFUNC_IMM8_ID16_IMM16_V8: { uint16_t methodId = READ_INST_16_1(); uint16_t length = READ_INST_16_3(); uint16_t v0 = READ_INST_8_5(); - info.accOut = true; - info.offset = BytecodeOffset::SEVEN; info.inputs.emplace_back(MethodId(methodId)); info.inputs.emplace_back(Immediate(length)); info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::LDHOLE_PREF: { - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::LDHOLE: { break; } - case EcmaOpcode::COPYRESTARGS_PREF_IMM16: { - uint16_t restIdx = READ_INST_16_1(); - info.accOut = true; - info.offset = BytecodeOffset::FOUR; + case EcmaOpcode::COPYRESTARGS_IMM16: { + uint16_t restIdx = READ_INST_16_0(); info.inputs.emplace_back(Immediate(restIdx)); break; } - case EcmaOpcode::DEFINEGETTERSETTERBYVALUE_PREF_V8_V8_V8_V8: { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - uint16_t v2 = READ_INST_8_3(); - uint16_t v3 = READ_INST_8_4(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::SIX; + case EcmaOpcode::DEFINEGETTERSETTERBYVALUE_V8_V8_V8_V8: { + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); + uint16_t v2 = READ_INST_8_2(); + uint16_t v3 = READ_INST_8_3(); info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v1)); info.inputs.emplace_back(VirtualRegister(v2)); info.inputs.emplace_back(VirtualRegister(v3)); break; } - case EcmaOpcode::LDOBJBYINDEX_PREF_V8_IMM32: { + case EcmaOpcode::LDOBJBYINDEX_IMM8_IMM16: { + uint16_t idx = READ_INST_16_1(); + info.inputs.emplace_back(Immediate(idx)); + break; + } + case EcmaOpcode::LDOBJBYINDEX_IMM16_IMM16: { + uint16_t idx = READ_INST_16_2(); + info.inputs.emplace_back(Immediate(idx)); + break; + } + case EcmaOpcode::WIDE_LDOBJBYINDEX_PREF_IMM32: { + uint32_t idx = READ_INST_32_1(); + info.inputs.emplace_back(Immediate(idx)); + break; + } + case EcmaOpcode::DEPRECATED_LDOBJBYINDEX_PREF_V8_IMM32: { uint16_t v0 = READ_INST_8_1(); uint32_t idx = READ_INST_32_2(); - info.accOut = true; - info.offset = BytecodeOffset::SEVEN; info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(Immediate(idx)); break; } - case EcmaOpcode::STOBJBYINDEX_PREF_V8_IMM32: { + case EcmaOpcode::STOBJBYINDEX_IMM8_V8_IMM32: { uint16_t v0 = READ_INST_8_1(); uint32_t index = READ_INST_32_2(); - info.accIn = true; - info.offset = BytecodeOffset::SEVEN; info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(Immediate(index)); break; } - case EcmaOpcode::LDOBJBYVALUE_PREF_V8_V8: { + case EcmaOpcode::LDOBJBYVALUE_IMM8_V8_V8: { uint32_t v0 = READ_INST_8_1(); uint32_t v1 = READ_INST_8_2(); - info.accOut = true; - info.offset = BytecodeOffset::FOUR; info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v1)); break; } - case EcmaOpcode::STOBJBYVALUE_PREF_V8_V8: { + case EcmaOpcode::STOBJBYVALUE_IMM8_V8_V8: { uint32_t v0 = READ_INST_8_1(); uint32_t v1 = READ_INST_8_2(); - info.accIn = true; - info.offset = BytecodeOffset::FOUR; info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v1)); break; } - case EcmaOpcode::LDSUPERBYVALUE_PREF_V8_V8: { + case EcmaOpcode::LDSUPERBYVALUE_IMM8_V8_V8: { uint32_t v0 = READ_INST_8_1(); uint32_t v1 = READ_INST_8_2(); - info.accOut = true; - info.offset = BytecodeOffset::FOUR; info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v1)); break; } - case EcmaOpcode::STSUPERBYVALUE_PREF_V8_V8: { + case EcmaOpcode::STSUPERBYVALUE_IMM8_V8_V8: { uint32_t v0 = READ_INST_8_1(); uint32_t v1 = READ_INST_8_2(); - info.accIn = true; - info.offset = BytecodeOffset::FOUR; info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v1)); break; } - case EcmaOpcode::TRYLDGLOBALBYNAME_PREF_ID32: { - info.accOut = true; - info.offset = BytecodeOffset::SIX; - info.inputs.emplace_back(StringId(READ_INST_32_1())); + case EcmaOpcode::TRYLDGLOBALBYNAME_IMM8_ID16: { + info.inputs.emplace_back(StringId(READ_INST_16_1())); break; } - case EcmaOpcode::TRYSTGLOBALBYNAME_PREF_ID32: { - info.accIn = true; - info.offset = BytecodeOffset::SIX; - info.inputs.emplace_back(StringId(READ_INST_32_1())); + case EcmaOpcode::TRYSTGLOBALBYNAME_IMM8_ID16: { + info.inputs.emplace_back(StringId(READ_INST_16_1())); break; } - case EcmaOpcode::STCONSTTOGLOBALRECORD_PREF_ID32: { - info.accIn = true; - info.offset = BytecodeOffset::SIX; - info.inputs.emplace_back(StringId(READ_INST_32_1())); + case EcmaOpcode::STCONSTTOGLOBALRECORD_ID16: { + info.inputs.emplace_back(StringId(READ_INST_16_0())); break; } - case EcmaOpcode::STLETTOGLOBALRECORD_PREF_ID32: { - info.accIn = true; - info.offset = BytecodeOffset::SIX; - info.inputs.emplace_back(StringId(READ_INST_32_1())); + case EcmaOpcode::STLETTOGLOBALRECORD_ID16: { + info.inputs.emplace_back(StringId(READ_INST_16_0())); break; } - case EcmaOpcode::STCLASSTOGLOBALRECORD_PREF_ID32: { - info.accIn = true; - info.offset = BytecodeOffset::SIX; - info.inputs.emplace_back(StringId(READ_INST_32_1())); + case EcmaOpcode::STCLASSTOGLOBALRECORD_ID16: { + info.inputs.emplace_back(StringId(READ_INST_16_0())); break; } - case EcmaOpcode::STOWNBYVALUEWITHNAMESET_PREF_V8_V8: { + case EcmaOpcode::STOWNBYVALUEWITHNAMESET_IMM8_V8_V8: { uint32_t v0 = READ_INST_8_1(); uint32_t v1 = READ_INST_8_2(); - info.accIn = true; - info.offset = BytecodeOffset::FOUR; info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v1)); break; } - case EcmaOpcode::STOWNBYNAMEWITHNAMESET_PREF_ID32_V8: { - uint32_t stringId = READ_INST_32_1(); - uint32_t v0 = READ_INST_8_5(); - info.accIn = true; - info.offset = BytecodeOffset::SEVEN; + case EcmaOpcode::STOWNBYNAMEWITHNAMESET_IMM8_ID16_V8: { + uint16_t stringId = READ_INST_16_1(); + uint32_t v0 = READ_INST_8_3(); info.inputs.emplace_back(StringId(stringId)); info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::LDGLOBALVAR_PREF_ID32: { - uint32_t stringId = READ_INST_32_1(); - info.accOut = true; - info.offset = BytecodeOffset::SIX; + case EcmaOpcode::LDGLOBALVAR_ID16: { + uint16_t stringId = READ_INST_16_0(); info.inputs.emplace_back(StringId(stringId)); break; } - case EcmaOpcode::LDOBJBYNAME_PREF_ID32_V8: { - uint32_t stringId = READ_INST_32_1(); - uint32_t v0 = READ_INST_8_5(); - info.accOut = true; - info.offset = BytecodeOffset::SEVEN; + case EcmaOpcode::LDOBJBYNAME_IMM8_ID16_V8: { + uint16_t stringId = READ_INST_16_1(); + uint32_t v0 = READ_INST_8_3(); info.inputs.emplace_back(StringId(stringId)); info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::STOBJBYNAME_PREF_ID32_V8: { - uint32_t stringId = READ_INST_32_1(); - uint32_t v0 = READ_INST_8_5(); - info.accIn = true; - info.offset = BytecodeOffset::SEVEN; + case EcmaOpcode::STOBJBYNAME_IMM8_ID16_V8: { + uint16_t stringId = READ_INST_16_1(); + uint32_t v0 = READ_INST_8_3(); info.inputs.emplace_back(StringId(stringId)); info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::LDSUPERBYNAME_PREF_ID32_V8: { - uint32_t stringId = READ_INST_32_1(); - uint32_t v0 = READ_INST_8_5(); - info.accOut = true; - info.offset = BytecodeOffset::SEVEN; + case EcmaOpcode::LDSUPERBYNAME_IMM8_ID16_V8: { + uint16_t stringId = READ_INST_16_1(); + uint32_t v0 = READ_INST_8_3(); info.inputs.emplace_back(StringId(stringId)); info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::STSUPERBYNAME_PREF_ID32_V8: { - uint32_t stringId = READ_INST_32_1(); - uint32_t v0 = READ_INST_8_5(); - info.accIn = true; - info.offset = BytecodeOffset::SEVEN; + case EcmaOpcode::STSUPERBYNAME_IMM8_ID16_V8: { + uint16_t stringId = READ_INST_16_1(); + uint32_t v0 = READ_INST_8_3(); info.inputs.emplace_back(StringId(stringId)); info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::STGLOBALVAR_PREF_ID32: { - uint32_t stringId = READ_INST_32_1(); - info.accIn = true; - info.offset = BytecodeOffset::SIX; + case EcmaOpcode::STGLOBALVAR_ID16: { + uint16_t stringId = READ_INST_16_0(); info.inputs.emplace_back(StringId(stringId)); break; } - case EcmaOpcode::CREATEGENERATOROBJ_PREF_V8: { - uint16_t v0 = READ_INST_8_1(); - info.accOut = true; - info.offset = BytecodeOffset::THREE; + case EcmaOpcode::CREATEGENERATOROBJ_V8: { + uint16_t v0 = READ_INST_8_0(); info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::CREATEASYNCGENERATOROBJ_PREF_V8: { - uint16_t v0 = READ_INST_8_1(); - info.accOut = true; - info.offset = BytecodeOffset::THREE; + case EcmaOpcode::CREATEASYNCGENERATOROBJ_V8: { + uint16_t v0 = READ_INST_8_0(); info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::ASYNCGENERATORRESOLVE_PREF_V8_V8_V8: { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - uint16_t v2 = READ_INST_8_3(); - info.accOut = true; - info.offset = BytecodeOffset::FIVE; + case EcmaOpcode::ASYNCGENERATORRESOLVE_V8_V8_V8: { + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); + uint16_t v2 = READ_INST_8_2(); info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v1)); info.inputs.emplace_back(VirtualRegister(v2)); break; } - case EcmaOpcode::STARRAYSPREAD_PREF_V8_V8: { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::FOUR; + case EcmaOpcode::STARRAYSPREAD_V8_V8: { + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v1)); break; } - case EcmaOpcode::GETITERATORNEXT_PREF_V8_V8: { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - info.accOut = true; - info.offset = BytecodeOffset::FOUR; + case EcmaOpcode::GETITERATORNEXT_V8_V8: { + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); info.inputs.emplace_back(VirtualRegister(v0)); info.inputs.emplace_back(VirtualRegister(v1)); break; } - case EcmaOpcode::DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8: { + case EcmaOpcode::DEFINECLASSWITHBUFFER_IMM8_ID16_IMM16_IMM16_V8_V8: { uint16_t methodId = READ_INST_16_1(); uint16_t imm = READ_INST_16_3(); uint16_t length = READ_INST_16_5(); uint16_t v0 = READ_INST_8_7(); uint16_t v1 = READ_INST_8_8(); - info.accOut = true; - info.offset = BytecodeOffset::TEN; info.inputs.emplace_back(MethodId(methodId)); info.inputs.emplace_back(Immediate(imm)); info.inputs.emplace_back(Immediate(length)); @@ -1686,82 +1423,58 @@ BytecodeInfo BytecodeCircuitBuilder::GetBytecodeInfo(const uint8_t *pc) info.inputs.emplace_back(VirtualRegister(v1)); break; } - case EcmaOpcode::LDFUNCTION_PREF: { - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::LDFUNCTION: { break; } - case EcmaOpcode::LDBIGINT_PREF_ID32: { - uint32_t stringId = READ_INST_32_1(); - info.accOut = true; - info.offset = BytecodeOffset::SIX; + case EcmaOpcode::LDBIGINT_ID16: { + uint16_t stringId = READ_INST_16_0(); info.inputs.emplace_back(StringId(stringId)); break; } - case EcmaOpcode::TONUMERIC_PREF_V8: { + case EcmaOpcode::TONUMERIC_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::SUPERCALL_PREF_IMM16_V8: { + case EcmaOpcode::SUPERCALL_IMM8_IMM16_V8: { uint16_t range = READ_INST_16_1(); uint16_t v0 = READ_INST_8_3(); - info.accIn = true; for (size_t i = 0; i < range; i++) { info.inputs.emplace_back(VirtualRegister(v0 + i)); } - info.accOut = true; - info.offset = BytecodeOffset::FIVE; break; } - case EcmaOpcode::SUPERCALLSPREAD_PREF_V8: { + case EcmaOpcode::SUPERCALLSPREAD_IMM8_V8: { uint16_t v0 = READ_INST_8_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::THREE; info.inputs.emplace_back(VirtualRegister(v0)); break; } - case EcmaOpcode::CREATEOBJECTHAVINGMETHOD_PREF_IMM16: { + case EcmaOpcode::CREATEOBJECTHAVINGMETHOD_IMM8_IMM16: { uint16_t imm = READ_INST_16_1(); - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::FOUR; info.inputs.emplace_back(Immediate(imm)); break; } - case EcmaOpcode::THROWIFSUPERNOTCORRECTCALL_PREF_IMM16: { - uint16_t imm = READ_INST_16_1(); - info.accIn = true; - info.offset = BytecodeOffset::FOUR; + case EcmaOpcode::THROWIFSUPERNOTCORRECTCALL_IMM16: { + uint16_t imm = READ_INST_16_0(); info.inputs.emplace_back(Immediate(imm)); break; } - case EcmaOpcode::LDHOMEOBJECT_PREF: { - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::LDHOMEOBJECT: { break; } - case EcmaOpcode::THROWDELETESUPERPROPERTY_PREF: { - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::THROWDELETESUPERPROPERTY: { break; } - case EcmaOpcode::DEBUGGER_PREF: { - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::DEBUGGER: { break; } - case EcmaOpcode::ISTRUE_PREF: { - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::ISTRUE: { break; } - case EcmaOpcode::ISFALSE_PREF: { - info.accIn = true; - info.accOut = true; - info.offset = BytecodeOffset::TWO; + case EcmaOpcode::ISFALSE: { + break; + } + case EcmaOpcode::NOP: { break; } default: { @@ -1770,6 +1483,7 @@ BytecodeInfo BytecodeCircuitBuilder::GetBytecodeInfo(const uint8_t *pc) break; } } + */ return info; } @@ -1782,7 +1496,7 @@ void BytecodeCircuitBuilder::InsertPhi() } EnumerateBlock(bb, [this, &defsitesInfo, &bb] ([[maybe_unused]]uint8_t * pc, BytecodeInfo &bytecodeInfo) -> bool { - if (bytecodeInfo.IsBc(EcmaOpcode::RESUMEGENERATOR_PREF_V8)) { + if (bytecodeInfo.IsBc(EcmaOpcode::RESUMEGENERATOR)) { auto numVRegs = MethodLiteral::GetNumVregs(file_, method_) + method_->GetNumArgs(); for (size_t i = 0; i < numVRegs; i++) { bytecodeInfo.vregOut.emplace_back(i); @@ -1839,7 +1553,7 @@ void BytecodeCircuitBuilder::InsertExceptionPhi(std::map vregs; EnumerateBlock(bb, [this, &vregs] ([[maybe_unused]]uint8_t * pc, BytecodeInfo &bytecodeInfo) -> bool { - if (bytecodeInfo.IsBc(EcmaOpcode::RESUMEGENERATOR_PREF_V8)) { + if (bytecodeInfo.IsBc(EcmaOpcode::RESUMEGENERATOR)) { auto numVRegs = MethodLiteral::GetNumVregs(file_, method_) + method_->GetNumArgs(); for (size_t i = 0; i < numVRegs; i++) { vregs.insert(i); @@ -2098,56 +1812,56 @@ GateRef BytecodeCircuitBuilder::NewConst(const BytecodeInfo &info) auto opcode = static_cast(info.opcode); GateRef gate = 0; switch (opcode) { - case EcmaOpcode::LDNAN_PREF: + case EcmaOpcode::LDNAN: gate = circuit_.NewGate(OpCode(OpCode::CONSTANT), MachineType::I64, base::NumberHelper::GetNaN(), {Circuit::GetCircuitRoot(OpCode(OpCode::CONSTANT_LIST))}, GateType::TaggedValue()); break; - case EcmaOpcode::LDINFINITY_PREF: + case EcmaOpcode::LDINFINITY: gate = circuit_.NewGate(OpCode(OpCode::CONSTANT), MachineType::I64, base::NumberHelper::GetPositiveInfinity(), {Circuit::GetCircuitRoot(OpCode(OpCode::CONSTANT_LIST))}, GateType::TaggedValue()); break; - case EcmaOpcode::LDUNDEFINED_PREF: + case EcmaOpcode::LDUNDEFINED: gate = circuit_.NewGate(OpCode(OpCode::CONSTANT), MachineType::I64, JSTaggedValue::VALUE_UNDEFINED, {Circuit::GetCircuitRoot(OpCode(OpCode::CONSTANT_LIST))}, GateType::TaggedValue()); break; - case EcmaOpcode::LDNULL_PREF: + case EcmaOpcode::LDNULL: gate = circuit_.NewGate(OpCode(OpCode::CONSTANT), MachineType::I64, JSTaggedValue::VALUE_NULL, {Circuit::GetCircuitRoot(OpCode(OpCode::CONSTANT_LIST))}, GateType::TaggedValue()); break; - case EcmaOpcode::LDTRUE_PREF: + case EcmaOpcode::LDTRUE: gate = circuit_.NewGate(OpCode(OpCode::CONSTANT), MachineType::I64, JSTaggedValue::VALUE_TRUE, {Circuit::GetCircuitRoot(OpCode(OpCode::CONSTANT_LIST))}, GateType::TaggedValue()); break; - case EcmaOpcode::LDFALSE_PREF: + case EcmaOpcode::LDFALSE: gate = circuit_.NewGate(OpCode(OpCode::CONSTANT), MachineType::I64, JSTaggedValue::VALUE_FALSE, {Circuit::GetCircuitRoot(OpCode(OpCode::CONSTANT_LIST))}, GateType::TaggedValue()); break; - case EcmaOpcode::LDHOLE_PREF: + case EcmaOpcode::LDHOLE: gate = circuit_.NewGate(OpCode(OpCode::CONSTANT), MachineType::I64, JSTaggedValue::VALUE_HOLE, {Circuit::GetCircuitRoot(OpCode(OpCode::CONSTANT_LIST))}, GateType::TaggedNPointer()); break; - case EcmaOpcode::LDAI_DYN_IMM32: + case EcmaOpcode::LDAI_IMM32: gate = circuit_.NewGate(OpCode(OpCode::CONSTANT), MachineType::I64, std::get(info.inputs[0]).ToJSTaggedValueInt(), {Circuit::GetCircuitRoot(OpCode(OpCode::CONSTANT_LIST))}, GateType::TaggedValue()); break; - case EcmaOpcode::FLDAI_DYN_IMM64: + case EcmaOpcode::FLDAI_IMM64: gate = circuit_.NewGate(OpCode(OpCode::CONSTANT), MachineType::I64, std::get(info.inputs.at(0)).ToJSTaggedValueDouble(), {Circuit::GetCircuitRoot(OpCode(OpCode::CONSTANT_LIST))}, GateType::TaggedValue()); break; - case EcmaOpcode::LDFUNCTION_PREF: + case EcmaOpcode::LDFUNCTION: gate = argAcc_.GetCommonArgGate(CommonArgIdx::FUNC); break; default: @@ -2280,14 +1994,14 @@ void BytecodeCircuitBuilder::NewReturn(BytecodeRegion &bb, const uint8_t *pc, Ga { ASSERT(bb.succs.empty()); auto bytecodeInfo = GetBytecodeInfo(pc); - if (static_cast(bytecodeInfo.opcode) == EcmaOpcode::RETURN_DYN) { - // handle return.dyn bytecode + if (static_cast(bytecodeInfo.opcode) == EcmaOpcode::RETURN) { + // handle return bytecode auto gate = circuit_.NewGate(OpCode(OpCode::RETURN), 0, { state, depend, Circuit::NullGate(), Circuit::GetCircuitRoot(OpCode(OpCode::RETURN_LIST)) }, GateType::AnyType()); jsgateToBytecode_[gate] = {bb.id, pc}; - } else if (static_cast(bytecodeInfo.opcode) == EcmaOpcode::RETURNUNDEFINED_PREF) { + } else if (static_cast(bytecodeInfo.opcode) == EcmaOpcode::RETURNUNDEFINED) { // handle returnundefined bytecode auto constant = circuit_.NewGate(OpCode(OpCode::CONSTANT), MachineType::I64, JSTaggedValue::VALUE_UNDEFINED, @@ -2324,10 +2038,10 @@ void BytecodeCircuitBuilder::NewByteCode(BytecodeRegion &bb, const uint8_t *pc, // handle conditional jump and unconditional jump bytecodes NewJump(bb, pc, state, depend); } else if (bytecodeInfo.IsReturn()) { - // handle return.dyn and returnundefined bytecodes + // handle return and returnundefined bytecodes NewReturn(bb, pc, state, depend); } else if (bytecodeInfo.IsMov()) { - // handle mov.dyn lda.dyn sta.dyn bytecodes + // handle mov lda sta bytecodes if (pc == bb.end) { auto &bbNext = graph_[bb.id + 1]; auto isLoopBack = bbNext.loopbackBlocks.count(bb.id); @@ -2455,7 +2169,7 @@ GateRef BytecodeCircuitBuilder::RenameVariable(const size_t bbId, const uint8_t break; } } - if (static_cast(curInfo.opcode) != EcmaOpcode::RESUMEGENERATOR_PREF_V8) { + if (static_cast(curInfo.opcode) != EcmaOpcode::RESUMEGENERATOR) { continue; } // New RESTORE_REGISTER HIR, used to restore the register content when processing resume instruction. @@ -2468,7 +2182,11 @@ GateRef BytecodeCircuitBuilder::RenameVariable(const size_t bbId, const uint8_t auto saveRegGate = RenameVariable(bbId, *pcIter - 1, tmpReg, tmpAcc); auto nextPcIter = pcIter; nextPcIter++; - ASSERT(GetBytecodeInfo(*nextPcIter).opcode == EcmaOpcode::SUSPENDGENERATOR_PREF_V8_V8); + // TODO: delete after first level inst enabled + while (static_cast(GetBytecodeInfo(*nextPcIter).opcode) == EcmaOpcode::NOP) { + nextPcIter++; + } + ASSERT(static_cast(GetBytecodeInfo(*nextPcIter).opcode) == EcmaOpcode::SUSPENDGENERATOR_V8); GateRef suspendGate = byteCodeToJSGate_.at(*nextPcIter); auto dependGate = gateAcc_.GetDep(suspendGate); auto newDependGate = circuit_.NewGate(OpCode(OpCode::SAVE_REGISTER), tmpReg, {dependGate, saveRegGate}, diff --git a/ecmascript/compiler/bytecode_circuit_builder.h b/ecmascript/compiler/bytecode_circuit_builder.h index 54ed3b5d0b..e773a01220 100644 --- a/ecmascript/compiler/bytecode_circuit_builder.h +++ b/ecmascript/compiler/bytecode_circuit_builder.h @@ -256,7 +256,7 @@ struct BytecodeInfo { std::vector vregOut {}; // write register bool accIn {false}; // read acc bool accOut {false}; // write acc - uint8_t opcode {0}; + uint16_t opcode {0}; uint16_t offset {0}; bool IsOut(VRegIDType reg, uint32_t index) const @@ -270,10 +270,10 @@ struct BytecodeInfo { auto ecmaOpcode = static_cast(opcode); switch (ecmaOpcode) { case EcmaOpcode::MOV_V4_V4: - case EcmaOpcode::MOV_DYN_V8_V8: - case EcmaOpcode::MOV_DYN_V16_V16: - case EcmaOpcode::LDA_DYN_V8: - case EcmaOpcode::STA_DYN_V8: + case EcmaOpcode::MOV_V8_V8: + case EcmaOpcode::MOV_V16_V16: + case EcmaOpcode::LDA_V8: + case EcmaOpcode::STA_V8: return true; default: return false; @@ -315,8 +315,8 @@ struct BytecodeInfo { { auto ecmaOpcode = static_cast(opcode); switch (ecmaOpcode) { - case EcmaOpcode::RETURN_DYN: - case EcmaOpcode::RETURNUNDEFINED_PREF: + case EcmaOpcode::RETURN: + case EcmaOpcode::RETURNUNDEFINED: return true; default: return false; @@ -327,11 +327,11 @@ struct BytecodeInfo { { auto ecmaOpcode = static_cast(opcode); switch (ecmaOpcode) { - case EcmaOpcode::THROWDYN_PREF: - case EcmaOpcode::THROWCONSTASSIGNMENT_PREF_V8: - case EcmaOpcode::THROWTHROWNOTEXISTS_PREF: - case EcmaOpcode::THROWPATTERNNONCOERCIBLE_PREF: - case EcmaOpcode::THROWDELETESUPERPROPERTY_PREF: + case EcmaOpcode::THROW_PREF_NONE: + case EcmaOpcode::THROW_NOTEXISTS_PREF_NONE: + case EcmaOpcode::THROW_PATTERNNONCOERCIBLE_PREF_NONE: + case EcmaOpcode::THROW_DELETESUPERPROPERTY_PREF_NONE: + case EcmaOpcode::THROW_CONSTASSIGNMENT_PREF_V8: return true; default: return false; @@ -342,8 +342,8 @@ struct BytecodeInfo { { auto ecmaOpcode = static_cast(opcode); switch (ecmaOpcode) { - case EcmaOpcode::COPYMODULE_PREF_V8: - case EcmaOpcode::DEBUGGER_PREF: + case EcmaOpcode::DEBUGGER: + case EcmaOpcode::NOP: return true; default: return false; @@ -354,16 +354,16 @@ struct BytecodeInfo { { auto ecmaOpcode = static_cast(opcode); switch (ecmaOpcode) { - case EcmaOpcode::LDNAN_PREF: - case EcmaOpcode::LDINFINITY_PREF: - case EcmaOpcode::LDUNDEFINED_PREF: - case EcmaOpcode::LDNULL_PREF: - case EcmaOpcode::LDTRUE_PREF: - case EcmaOpcode::LDFALSE_PREF: - case EcmaOpcode::LDHOLE_PREF: - case EcmaOpcode::LDAI_DYN_IMM32: - case EcmaOpcode::FLDAI_DYN_IMM64: - case EcmaOpcode::LDFUNCTION_PREF: + case EcmaOpcode::LDNAN: + case EcmaOpcode::LDINFINITY: + case EcmaOpcode::LDUNDEFINED: + case EcmaOpcode::LDNULL: + case EcmaOpcode::LDTRUE: + case EcmaOpcode::LDFALSE: + case EcmaOpcode::LDHOLE: + case EcmaOpcode::LDAI_IMM32: + case EcmaOpcode::FLDAI_IMM64: + case EcmaOpcode::LDFUNCTION: return true; default: return false; @@ -379,12 +379,12 @@ struct BytecodeInfo { { auto ecmaOpcode = static_cast(opcode); switch (ecmaOpcode) { - case EcmaOpcode::CALLARG0DYN_PREF_V8: - case EcmaOpcode::CALLARG1DYN_PREF_V8_V8: - case EcmaOpcode::CALLARGS2DYN_PREF_V8_V8_V8: - case EcmaOpcode::CALLARGS3DYN_PREF_V8_V8_V8_V8: - case EcmaOpcode::CALLITHISRANGEDYN_PREF_IMM16_V8: - case EcmaOpcode::CALLIRANGEDYN_PREF_IMM16_V8: + case EcmaOpcode::CALLARG0_IMM8: + case EcmaOpcode::CALLARG1_IMM8_V8: + case EcmaOpcode::CALLARGS2_IMM8_V8_V8: + case EcmaOpcode::CALLARGS3_IMM8_V8_V8_V8: + case EcmaOpcode::CALLTHISRANGE_IMM8_IMM8_V8: + case EcmaOpcode::CALLRANGE_IMM8_IMM8_V8: return true; default: return false; @@ -415,8 +415,8 @@ struct BytecodeInfo { { auto ecmaOpcode = static_cast(opcode); switch (ecmaOpcode) { - case EcmaOpcode::SUSPENDGENERATOR_PREF_V8_V8: - case EcmaOpcode::RESUMEGENERATOR_PREF_V8: + case EcmaOpcode::SUSPENDGENERATOR_V8: + case EcmaOpcode::RESUMEGENERATOR: return true; default: return false; @@ -425,23 +425,10 @@ struct BytecodeInfo { bool IsBc(EcmaOpcode ecmaOpcode) const { - return opcode == ecmaOpcode; + return static_cast(opcode) == ecmaOpcode; } }; -enum BytecodeOffset { - ONE = 1, - TWO, - THREE, - FOUR, - FIVE, - SIX, - SEVEN, - EIGHT, - NINE, - TEN -}; - class BytecodeCircuitBuilder { public: explicit BytecodeCircuitBuilder(const JSPandaFile *jsPandaFile, @@ -479,14 +466,13 @@ public: [[nodiscard]] std::string GetBytecodeStr(kungfu::GateRef gate) const { - auto pc = jsgateToBytecode_.at(gate).second; - return GetEcmaOpcodeStr(static_cast(*pc)); + return GetEcmaOpcodeStr(GetByteCodeOpcode(gate)); } [[nodiscard]] EcmaOpcode GetByteCodeOpcode(kungfu::GateRef gate) const { auto pc = jsgateToBytecode_.at(gate).second; - return static_cast(*pc); + return BytecodeInstruction(pc).GetOpcode(); } [[nodiscard]] const uint8_t* GetJSBytecode(GateRef gate) const diff --git a/ecmascript/compiler/bytecode_info_collector.cpp b/ecmascript/compiler/bytecode_info_collector.cpp index f7d9337b1b..dbe99d674c 100644 --- a/ecmascript/compiler/bytecode_info_collector.cpp +++ b/ecmascript/compiler/bytecode_info_collector.cpp @@ -93,113 +93,621 @@ void BytecodeInfoCollector::ProcessClasses(JSPandaFile *jsPandaFile, const CStri } } -void BytecodeInfoCollector::FixOpcode(uint8_t *pc) +void BytecodeInfoCollector::CollectMethodPcs(JSPandaFile *jsPandaFile, const uint32_t insSz, const uint8_t *insArr, + const MethodLiteral* method, std::vector &methodPcInfos) +{ + (void)jsPandaFile; + auto bcIns = OldBytecodeInst(insArr); + auto bcInsLast = bcIns.JumpTo(insSz); + + methodPcInfos.emplace_back(MethodPcInfo { std::vector(1, method), {}, {}, {} }); + + int32_t offsetIndex = 1; + uint8_t *curPc = nullptr; + uint8_t *prePc = nullptr; + while (bcIns.GetAddress() != bcInsLast.GetAddress()) { + auto pc = const_cast(bcIns.GetAddress()); +#ifdef ENABLE_OLD_BYTECODE_AOT + TranslateBCIns(jsPandaFile, bcIns, method); + + auto nextInst = bcIns.GetNext(); + FixOpcode(const_cast(method), bcIns); + bcIns = nextInst; +#endif + auto &bytecodeBlockInfos = methodPcInfos.back().bytecodeBlockInfos; + auto &byteCodeCurPrePc = methodPcInfos.back().byteCodeCurPrePc; + auto &pcToBCOffset = methodPcInfos.back().pcToBCOffset; + + if (offsetIndex == 1) { + curPc = prePc = pc; + bytecodeBlockInfos.emplace_back(curPc, SplitKind::START, std::vector(1, curPc)); + byteCodeCurPrePc[curPc] = prePc; + pcToBCOffset[curPc] = offsetIndex++; + } else { + curPc = pc; + byteCodeCurPrePc[curPc] = prePc; + pcToBCOffset[curPc] = offsetIndex++; + prePc = curPc; + BytecodeCircuitBuilder::CollectBytecodeBlockInfo(curPc, bytecodeBlockInfos); + } + } + auto emptyPc = const_cast(bcInsLast.GetAddress()); + methodPcInfos.back().byteCodeCurPrePc[emptyPc] = prePc; + methodPcInfos.back().pcToBCOffset[emptyPc] = offsetIndex++; +} + +#ifdef ENABLE_OLD_BYTECODE_AOT +void BytecodeInfoCollector::AddNopInst(uint8_t *pc, int number) { - auto opcode = static_cast(*pc); + for (int i = 0; i < number; i++) { + *(pc + i) = static_cast(EcmaOpcode::NOP); + } +} +void BytecodeInfoCollector::FixOpcode(MethodLiteral *method, const OldBytecodeInst &inst) +{ + auto opcode = inst.GetOpcode(); + auto oldLen = OldBytecodeInst::Size(OldBytecodeInst::GetFormat(opcode)); + auto pc = const_cast(inst.GetAddress()); + + // First level opcode + if (static_cast(opcode) < 236) { // 236: second level bytecode index + switch (opcode) { + case OldBytecodeInst::Opcode::MOV_V4_V4: + *pc = static_cast(EcmaOpcode::MOV_V4_V4); + break; + case OldBytecodeInst::Opcode::MOV_DYN_V8_V8: + *pc = static_cast(EcmaOpcode::MOV_V8_V8); + break; + case OldBytecodeInst::Opcode::MOV_DYN_V16_V16: + *pc = static_cast(EcmaOpcode::MOV_V16_V16); + break; + case OldBytecodeInst::Opcode::LDA_STR_ID32: { + *pc = static_cast(EcmaOpcode::LDA_STR_ID16); + uint32_t id = inst.GetId(); + LOG_ECMA_IF(id > std::numeric_limits::max(), FATAL) << "Cannot translate to 16 bits: " << id; + uint16_t newId = static_cast(id); + if (memcpy_s(pc + 1, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { + LOG_FULL(FATAL) << "FixOpcode memcpy_s fail"; + UNREACHABLE(); + } + auto newLen = BytecodeInstruction::Size(EcmaOpcode::LDA_STR_ID16); + AddNopInst(pc + newLen, oldLen - newLen); + break; + } + case OldBytecodeInst::Opcode::JMP_IMM8: + *pc = static_cast(EcmaOpcode::JMP_IMM8); + break; + case OldBytecodeInst::Opcode::JMP_IMM16: + *pc = static_cast(EcmaOpcode::JMP_IMM16); + break; + case OldBytecodeInst::Opcode::JMP_IMM32: + *pc = static_cast(EcmaOpcode::JMP_IMM32); + break; + case OldBytecodeInst::Opcode::JEQZ_IMM8: + *pc = static_cast(EcmaOpcode::JEQZ_IMM8); + break; + case OldBytecodeInst::Opcode::JEQZ_IMM16: + *pc = static_cast(EcmaOpcode::JEQZ_IMM16); + break; + case OldBytecodeInst::Opcode::JNEZ_IMM8: + *pc = static_cast(EcmaOpcode::JNEZ_IMM8); + break; + case OldBytecodeInst::Opcode::JNEZ_IMM16: + *pc = static_cast(EcmaOpcode::JNEZ_IMM16); + break; + case OldBytecodeInst::Opcode::LDA_DYN_V8: + *pc = static_cast(EcmaOpcode::LDA_V8); + break; + case OldBytecodeInst::Opcode::STA_DYN_V8: + *pc = static_cast(EcmaOpcode::STA_V8); + break; + case OldBytecodeInst::Opcode::LDAI_DYN_IMM32: + *pc = static_cast(EcmaOpcode::LDAI_IMM32); + break; + case OldBytecodeInst::Opcode::FLDAI_DYN_IMM64: + *pc = static_cast(EcmaOpcode::FLDAI_IMM64); + break; + case OldBytecodeInst::Opcode::RETURN_DYN: + *pc = static_cast(EcmaOpcode::RETURN); + break; + default: + LOG_FULL(FATAL) << "FixOpcode fail: " << static_cast(opcode); + UNREACHABLE(); + } + return; + } + + // New second level bytecode translate + int secondLevelIndex = 0; switch (opcode) { - case BytecodeInstruction::Opcode::MOV_V4_V4: - *pc = static_cast(EcmaOpcode::MOV_V4_V4); - break; - case BytecodeInstruction::Opcode::MOV_DYN_V8_V8: - *pc = static_cast(EcmaOpcode::MOV_DYN_V8_V8); - break; - case BytecodeInstruction::Opcode::MOV_DYN_V16_V16: - *pc = static_cast(EcmaOpcode::MOV_DYN_V16_V16); - break; - case BytecodeInstruction::Opcode::LDA_STR_ID32: - *pc = static_cast(EcmaOpcode::LDA_STR_ID32); - break; - case BytecodeInstruction::Opcode::JMP_IMM8: - *pc = static_cast(EcmaOpcode::JMP_IMM8); - break; - case BytecodeInstruction::Opcode::JMP_IMM16: - *pc = static_cast(EcmaOpcode::JMP_IMM16); - break; - case BytecodeInstruction::Opcode::JMP_IMM32: - *pc = static_cast(EcmaOpcode::JMP_IMM32); - break; - case BytecodeInstruction::Opcode::JEQZ_IMM8: - *pc = static_cast(EcmaOpcode::JEQZ_IMM8); - break; - case BytecodeInstruction::Opcode::JEQZ_IMM16: - *pc = static_cast(EcmaOpcode::JEQZ_IMM16); - break; - case BytecodeInstruction::Opcode::JNEZ_IMM8: - *pc = static_cast(EcmaOpcode::JNEZ_IMM8); - break; - case BytecodeInstruction::Opcode::JNEZ_IMM16: - *pc = static_cast(EcmaOpcode::JNEZ_IMM16); - break; - case BytecodeInstruction::Opcode::LDA_DYN_V8: - *pc = static_cast(EcmaOpcode::LDA_DYN_V8); + // throw + case OldBytecodeInst::Opcode::ECMA_THROWIFSUPERNOTCORRECTCALL_PREF_IMM16: + secondLevelIndex += 2; // 2: skip extra one new instruction + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_THROWUNDEFINEDIFHOLE_PREF_V8_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_THROWIFNOTOBJECT_PREF_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_THROWCONSTASSIGNMENT_PREF_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_THROWDELETESUPERPROPERTY_PREF_NONE: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_THROWPATTERNNONCOERCIBLE_PREF_NONE: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_THROWTHROWNOTEXISTS_PREF_NONE: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_THROWDYN_PREF_NONE: { + *pc = EcmaOpcode::THROW_PREF_NONE; + *(pc + 1) = secondLevelIndex; + return; + } + // wide + case OldBytecodeInst::Opcode::ECMA_LDLEXVARDYN_PREF_IMM16_IMM16: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_COPYRESTARGS_PREF_IMM16: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_STOWNBYINDEX_PREF_V8_IMM32: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_STOBJBYINDEX_PREF_V8_IMM32: + secondLevelIndex += 4; // 4: skip three wide inst + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_CALLTHISRANGEDYN_PREF_IMM16_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_CALLRANGEDYN_PREF_IMM16_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_NEWLEXENVWITHNAMEDYN_PREF_IMM16_IMM16: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_NEWLEXENVDYN_PREF_IMM16: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_NEWOBJDYNRANGE_PREF_IMM16_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8: { + *pc = EcmaOpcode::WIDE_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8; + *(pc + 1) = secondLevelIndex; + return; + } + // Deprecated + case OldBytecodeInst::Opcode::ECMA_STCLASSTOGLOBALRECORD_PREF_ID32: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_STLETTOGLOBALRECORD_PREF_ID32: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_STCONSTTOGLOBALRECORD_PREF_ID32: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDMODULEVAR_PREF_ID32_IMM8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDSUPERBYNAME_PREF_ID32_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDOBJBYNAME_PREF_ID32_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_STMODULEVAR_PREF_ID32: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_GETMODULENAMESPACE_PREF_ID32: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_STLEXVARDYN_PREF_IMM16_IMM16_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_STLEXVARDYN_PREF_IMM8_IMM8_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_STLEXVARDYN_PREF_IMM4_IMM4_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDOBJBYINDEX_PREF_V8_IMM32: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDSUPERBYVALUE_PREF_V8_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDOBJBYVALUE_PREF_V8_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_SETOBJECTWITHPROTO_PREF_V8_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_COPYDATAPROPERTIES_PREF_V8_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_SUSPENDGENERATOR_PREF_V8_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_DELOBJPROP_PREF_V8_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_GETTEMPLATEOBJECT_PREF_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_GETRESUMEMODE_PREF_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_RESUMEGENERATOR_PREF_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_DEFINEMETHOD_PREF_ID16_IMM16_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_DEFINENCFUNCDYN_PREF_ID16_IMM16_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_DEFINEFUNCDYN_PREF_ID16_IMM16_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_CALLSPREADDYN_PREF_V8_V8_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_CALLARGS3DYN_PREF_V8_V8_V8_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_CALLARGS2DYN_PREF_V8_V8_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_CALLARG1DYN_PREF_V8_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_CALLARG0DYN_PREF_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_DECDYN_PREF_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_INCDYN_PREF_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_NOTDYN_PREF_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_NEGDYN_PREF_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_TONUMERIC_PREF_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_TONUMBER_PREF_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_CREATEOBJECTWITHBUFFER_PREF_IMM16: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_CREATEARRAYWITHBUFFER_PREF_IMM16: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_GETITERATORNEXT_PREF_V8_V8: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_POPLEXENVDYN_PREF_NONE: + secondLevelIndex++; + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDLEXENVDYN_PREF_NONE: { + *pc = EcmaOpcode::DEPRECATED_LDLEXENV_PREF_NONE; + *(pc + 1) = secondLevelIndex; + return; + } + default: break; - case BytecodeInstruction::Opcode::STA_DYN_V8: - *pc = static_cast(EcmaOpcode::STA_DYN_V8); + } + // Second level opcode to first level + auto newOpcode = static_cast(*(pc + 1)); + auto newLen = BytecodeInstruction::Size(newOpcode); + switch (opcode) { + // The same format has IC + case OldBytecodeInst::Opcode::ECMA_TYPEOFDYN_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_INSTANCEOFDYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_CREATEEMPTYARRAY_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_GETITERATOR_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_ADD2DYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_SUB2DYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_MUL2DYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_DIV2DYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_MOD2DYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_EQDYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_NOTEQDYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LESSDYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LESSEQDYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_GREATERDYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_GREATEREQDYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_SHL2DYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_ASHR2DYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_SHR2DYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_AND2DYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_OR2DYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_XOR2DYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_EXPDYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_ISINDYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_STRICTNOTEQDYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_STRICTEQDYN_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_ITERNEXT_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_CLOSEITERATOR_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_SUPERCALLSPREAD_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_SUPERCALL_PREF_IMM16_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_CREATEOBJECTHAVINGMETHOD_PREF_IMM16: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_STOBJBYVALUE_PREF_V8_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_STOWNBYVALUE_PREF_V8_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_STSUPERBYVALUE_PREF_V8_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_STOWNBYVALUEWITHNAMESET_PREF_V8_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_NEWOBJSPREADDYN_PREF_V8_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8: { + ASSERT(newLen == oldLen); + *pc = newOpcode; + *(pc + 1) = 0x00; break; - case BytecodeInstruction::Opcode::LDAI_DYN_IMM32: - *pc = static_cast(EcmaOpcode::LDAI_DYN_IMM32); + } + // The same format no IC + case OldBytecodeInst::Opcode::ECMA_ASYNCFUNCTIONENTER_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_ASYNCGENERATORRESOLVE_PREF_V8_V8_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_CREATEASYNCGENERATOROBJ_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_CREATEEMPTYOBJECT_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_CREATEGENERATOROBJ_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_CREATEITERRESULTOBJ_PREF_V8_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_DEBUGGER_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_DEFINEGETTERSETTERBYVALUE_PREF_V8_V8_V8_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_GETNEXTPROPNAME_PREF_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_GETPROPITERATOR_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_GETUNMAPPEDARGS_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_ISFALSE_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_ISTRUE_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDFALSE_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDFUNCTION_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDGLOBALTHIS_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDGLOBAL_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDHOLE_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDHOMEOBJECT_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDLEXVARDYN_PREF_IMM4_IMM4: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDLEXVARDYN_PREF_IMM8_IMM8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDNULL_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDSYMBOL_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDTRUE_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDUNDEFINED_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDNAN_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDINFINITY_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_RETURNUNDEFINED_PREF_NONE: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_STARRAYSPREAD_PREF_V8_V8: { + ASSERT(newLen == oldLen - 1); + *pc = newOpcode; + // 2: skip opcode and second level pref + if (newLen > 1 && memmove_s(pc + 1, newLen - 1, pc + 2, oldLen - 2) != EOK) { + LOG_FULL(FATAL) << "FixOpcode memmove_s fail"; + UNREACHABLE(); + } break; - case BytecodeInstruction::Opcode::FLDAI_DYN_IMM64: - *pc = static_cast(EcmaOpcode::FLDAI_DYN_IMM64); + } + // ID32 to ID16 has IC (PREF_ID32) + case OldBytecodeInst::Opcode::ECMA_TRYLDGLOBALBYNAME_PREF_ID32: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_TRYSTGLOBALBYNAME_PREF_ID32: { + ASSERT(newLen == oldLen - 2); // 2: ID32 to ID16 will decrease 2 bytes + uint32_t id = inst.GetId(); + LOG_ECMA_IF(id > std::numeric_limits::max(), FATAL) << "Cannot translate to 16 bits: " << id; + *pc = newOpcode; + *(pc + 1) = 0x00; + uint16_t newId = static_cast(id); + if (memcpy_s(pc + 2, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { // 2: skip opcode and ic slot + LOG_FULL(FATAL) << "FixOpcode memcpy_s fail"; + UNREACHABLE(); + } break; - case BytecodeInstruction::Opcode::RETURN_DYN: - *pc = static_cast(EcmaOpcode::RETURN_DYN); + } + // ID32 to ID16 has IC (ID32_V8 & ID32_IMM8) + case OldBytecodeInst::Opcode::ECMA_STOBJBYNAME_PREF_ID32_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_STOWNBYNAME_PREF_ID32_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_STSUPERBYNAME_PREF_ID32_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_STOWNBYNAMEWITHNAMESET_PREF_ID32_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_CREATEREGEXPWITHLITERAL_PREF_ID32_IMM8: { + ASSERT(newLen == oldLen - 2); // 2: ID32 to ID16 will decrease 2 bytes + uint32_t id = inst.GetId(); + LOG_ECMA_IF(id > std::numeric_limits::max(), FATAL) << "Cannot translate to 16 bits: " << id; + *pc = newOpcode; + *(pc + 1) = 0x00; + uint16_t newId = static_cast(id); + if (memcpy_s(pc + 2, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { // 2: skip opcode and ic slot + LOG_FULL(FATAL) << "FixOpcode memcpy_s fail"; + UNREACHABLE(); + } + *(pc + 4) = *(pc + 6); // 4: index of new opcode; 6: index of old opcode break; - default: - if (*pc != static_cast(BytecodeInstruction::Opcode::ECMA_LDNAN_PREF_NONE)) { - LOG_FULL(FATAL) << "Is not an Ecma Opcode opcode: " << static_cast(opcode); + } + // ID32 to ID16 no IC (PREF_ID32) + case OldBytecodeInst::Opcode::ECMA_LDBIGINT_PREF_ID32: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_LDGLOBALVAR_PREF_ID32: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_STGLOBALVAR_PREF_ID32: { + ASSERT(newLen == oldLen - 3); // 3: ID32 to ID16 and no ic slot will decrease 3 bytes + uint32_t id = inst.GetId(); + LOG_ECMA_IF(id > std::numeric_limits::max(), FATAL) << "Cannot translate to 16 bits: " << id; + *pc = newOpcode; + uint16_t newId = static_cast(id); + if (memcpy_s(pc + 1, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { + LOG_FULL(FATAL) << "FixOpcode memcpy_s fail"; UNREACHABLE(); } - *pc = *(pc + 1); - *(pc + 1) = 0xFF; + break; + } + default: + LOG_FULL(FATAL) << "Is not an Ecma Opcode opcode: " << static_cast(opcode); + UNREACHABLE(); break; } + AddNopInst(pc + newLen, oldLen - newLen); + UpdateICOffset(method, pc); } +// reuse prefix 8bits to store slotid void BytecodeInfoCollector::UpdateICOffset(MethodLiteral* method, uint8_t *pc) { uint8_t offset = MethodLiteral::MAX_SLOT_SIZE; auto opcode = static_cast(*pc); switch (opcode) { - case EcmaOpcode::TRYLDGLOBALBYNAME_PREF_ID32: - case EcmaOpcode::TRYSTGLOBALBYNAME_PREF_ID32: - case EcmaOpcode::LDGLOBALVAR_PREF_ID32: - case EcmaOpcode::STGLOBALVAR_PREF_ID32: - case EcmaOpcode::ADD2DYN_PREF_V8: - case EcmaOpcode::SUB2DYN_PREF_V8: - case EcmaOpcode::MUL2DYN_PREF_V8: - case EcmaOpcode::DIV2DYN_PREF_V8: - case EcmaOpcode::MOD2DYN_PREF_V8: - case EcmaOpcode::SHL2DYN_PREF_V8: - case EcmaOpcode::SHR2DYN_PREF_V8: - case EcmaOpcode::ASHR2DYN_PREF_V8: - case EcmaOpcode::AND2DYN_PREF_V8: - case EcmaOpcode::OR2DYN_PREF_V8: - case EcmaOpcode::XOR2DYN_PREF_V8: - case EcmaOpcode::EQDYN_PREF_V8: - case EcmaOpcode::NOTEQDYN_PREF_V8: - case EcmaOpcode::LESSDYN_PREF_V8: - case EcmaOpcode::LESSEQDYN_PREF_V8: - case EcmaOpcode::GREATERDYN_PREF_V8: - case EcmaOpcode::GREATEREQDYN_PREF_V8: + case EcmaOpcode::TRYLDGLOBALBYNAME_IMM8_ID16: + // fall through + case EcmaOpcode::TRYSTGLOBALBYNAME_IMM8_ID16: + // fall through + case EcmaOpcode::ADD2_IMM8_V8: + // fall through + case EcmaOpcode::SUB2_IMM8_V8: + // fall through + case EcmaOpcode::MUL2_IMM8_V8: + // fall through + case EcmaOpcode::DIV2_IMM8_V8: + // fall through + case EcmaOpcode::MOD2_IMM8_V8: + // fall through + case EcmaOpcode::SHL2_IMM8_V8: + // fall through + case EcmaOpcode::SHR2_IMM8_V8: + // fall through + case EcmaOpcode::ASHR2_IMM8_V8: + // fall through + case EcmaOpcode::AND2_IMM8_V8: + // fall through + case EcmaOpcode::OR2_IMM8_V8: + // fall through + case EcmaOpcode::XOR2_IMM8_V8: + // fall through + case EcmaOpcode::EQ_IMM8_V8: + // fall through + case EcmaOpcode::NOTEQ_IMM8_V8: + // fall through + case EcmaOpcode::LESS_IMM8_V8: + // fall through + case EcmaOpcode::LESSEQ_IMM8_V8: + // fall through + case EcmaOpcode::GREATER_IMM8_V8: + // fall through + case EcmaOpcode::GREATEREQ_IMM8_V8: offset = method->UpdateSlotSize(1); break; - case EcmaOpcode::LDOBJBYVALUE_PREF_V8_V8: - case EcmaOpcode::STOBJBYVALUE_PREF_V8_V8: - case EcmaOpcode::STOWNBYVALUE_PREF_V8_V8: - case EcmaOpcode::LDOBJBYNAME_PREF_ID32_V8: - case EcmaOpcode::STOBJBYNAME_PREF_ID32_V8: - case EcmaOpcode::STOWNBYNAME_PREF_ID32_V8: - case EcmaOpcode::LDOBJBYINDEX_PREF_V8_IMM32: - case EcmaOpcode::STOBJBYINDEX_PREF_V8_IMM32: - case EcmaOpcode::STOWNBYINDEX_PREF_V8_IMM32: - case EcmaOpcode::LDSUPERBYVALUE_PREF_V8_V8: - case EcmaOpcode::STSUPERBYVALUE_PREF_V8_V8: - case EcmaOpcode::LDSUPERBYNAME_PREF_ID32_V8: - case EcmaOpcode::STSUPERBYNAME_PREF_ID32_V8: - case EcmaOpcode::LDMODULEVAR_PREF_ID32_IMM8: - case EcmaOpcode::STMODULEVAR_PREF_ID32: + case EcmaOpcode::LDOBJBYVALUE_IMM8_V8_V8: + // fall through + case EcmaOpcode::STOBJBYVALUE_IMM8_V8_V8: + // fall through + case EcmaOpcode::STOWNBYVALUE_IMM8_V8_V8: + // fall through + case EcmaOpcode::LDOBJBYNAME_IMM8_ID16_V8: + // fall through + case EcmaOpcode::STOBJBYNAME_IMM8_ID16_V8: + // fall through + case EcmaOpcode::STOWNBYNAME_IMM8_ID16_V8: + // fall through + case EcmaOpcode::LDOBJBYINDEX_IMM8_V8_IMM32: + // fall through + case EcmaOpcode::STOBJBYINDEX_IMM8_V8_IMM32: + // fall through + case EcmaOpcode::STOWNBYINDEX_IMM8_V8_IMM32: + // fall through + case EcmaOpcode::LDSUPERBYVALUE_IMM8_V8_V8: + // fall through + case EcmaOpcode::STSUPERBYVALUE_IMM8_V8_V8: + // fall through + case EcmaOpcode::LDSUPERBYNAME_IMM8_ID16_V8: + // fall through + case EcmaOpcode::STSUPERBYNAME_IMM8_ID16_V8: offset = method->UpdateSlotSize(2); // 2: occupy two ic slot break; default: @@ -209,13 +717,12 @@ void BytecodeInfoCollector::UpdateICOffset(MethodLiteral* method, uint8_t *pc) *(pc + 1) = offset; } -void BytecodeInfoCollector::FixInstructionId32(const BytecodeInstruction &inst, uint32_t index, - uint32_t fixOrder) +void BytecodeInfoCollector::FixInstructionId32(const OldBytecodeInst &inst, uint32_t index, uint32_t fixOrder) { // NOLINTNEXTLINE(hicpp-use-auto) auto pc = const_cast(inst.GetAddress()); - switch (inst.GetFormat()) { - case BytecodeInstruction::Format::ID32: { + switch (OldBytecodeInst::GetFormat(inst.GetOpcode())) { + case OldBytecodeInst::Format::ID32: { uint8_t size = sizeof(uint32_t); // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) if (memcpy_s(pc + FixInsIndex::FIX_ONE, size, &index, size) != EOK) { @@ -224,7 +731,7 @@ void BytecodeInfoCollector::FixInstructionId32(const BytecodeInstruction &inst, } break; } - case BytecodeInstruction::Format::PREF_ID16_IMM16_V8: { + case OldBytecodeInst::Format::PREF_ID16_IMM16_V8: { uint16_t u16Index = index; uint8_t size = sizeof(uint16_t); // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) @@ -234,9 +741,11 @@ void BytecodeInfoCollector::FixInstructionId32(const BytecodeInstruction &inst, } break; } - case BytecodeInstruction::Format::PREF_ID32: - case BytecodeInstruction::Format::PREF_ID32_V8: - case BytecodeInstruction::Format::PREF_ID32_IMM8: { + case OldBytecodeInst::Format::PREF_ID32: + // fall through + case OldBytecodeInst::Format::PREF_ID32_V8: + // fall through + case OldBytecodeInst::Format::PREF_ID32_IMM8: { uint8_t size = sizeof(uint32_t); // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) if (memcpy_s(pc + FixInsIndex::FIX_TWO, size, &index, size) != EOK) { @@ -245,7 +754,7 @@ void BytecodeInfoCollector::FixInstructionId32(const BytecodeInstruction &inst, } break; } - case BytecodeInstruction::Format::PREF_IMM16: { + case OldBytecodeInst::Format::PREF_IMM16: { ASSERT(static_cast(index) == index); uint16_t u16Index = index; uint8_t size = sizeof(uint16_t); @@ -256,7 +765,7 @@ void BytecodeInfoCollector::FixInstructionId32(const BytecodeInstruction &inst, } break; } - case BytecodeInstruction::Format::PREF_ID16_IMM16_IMM16_V8_V8: { + case OldBytecodeInst::Format::PREF_ID16_IMM16_IMM16_V8_V8: { // Usually, we fix one part of instruction one time. But as for instruction DefineClassWithBuffer, // which use both method id and literal buffer id.Using fixOrder indicates fix Location. if (fixOrder == 0) { @@ -287,65 +796,65 @@ void BytecodeInfoCollector::FixInstructionId32(const BytecodeInstruction &inst, } } -void BytecodeInfoCollector::TranslateBCIns(JSPandaFile *jsPandaFile, const panda::BytecodeInstruction &bcIns, +void BytecodeInfoCollector::TranslateBCIns(JSPandaFile *jsPandaFile, const OldBytecodeInst &bcIns, const MethodLiteral *method) { const panda_file::File *pf = jsPandaFile->GetPandaFile(); - if (bcIns.HasFlag(BytecodeInstruction::Flags::STRING_ID) && - BytecodeInstruction::HasId(bcIns.GetFormat(), 0)) { + if (bcIns.HasFlag(OldBytecodeInst::Flags::STRING_ID) && + OldBytecodeInst::HasId(OldBytecodeInst::GetFormat(bcIns.GetOpcode()), 0)) { auto index = jsPandaFile->GetOrInsertConstantPool( - ConstPoolType::STRING, bcIns.GetId().AsFileId().GetOffset()); + ConstPoolType::STRING, bcIns.GetId()); FixInstructionId32(bcIns, index); } else { - BytecodeInstruction::Opcode opcode = static_cast(bcIns.GetOpcode()); + OldBytecodeInst::Opcode opcode = static_cast(bcIns.GetOpcode()); switch (opcode) { uint32_t index; uint32_t methodId; - case BytecodeInstruction::Opcode::ECMA_DEFINEFUNCDYN_PREF_ID16_IMM16_V8: - methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId().AsIndex()).GetOffset(); + case OldBytecodeInst::Opcode::ECMA_DEFINEFUNCDYN_PREF_ID16_IMM16_V8: + methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId()).GetOffset(); index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::BASE_FUNCTION, methodId); FixInstructionId32(bcIns, index); break; - case BytecodeInstruction::Opcode::ECMA_DEFINENCFUNCDYN_PREF_ID16_IMM16_V8: - methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId().AsIndex()).GetOffset(); + case OldBytecodeInst::Opcode::ECMA_DEFINENCFUNCDYN_PREF_ID16_IMM16_V8: + methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId()).GetOffset(); index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::NC_FUNCTION, methodId); FixInstructionId32(bcIns, index); break; - case BytecodeInstruction::Opcode::ECMA_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8: - methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId().AsIndex()).GetOffset(); + case OldBytecodeInst::Opcode::ECMA_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8: + methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId()).GetOffset(); index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::GENERATOR_FUNCTION, methodId); FixInstructionId32(bcIns, index); break; - case BytecodeInstruction::Opcode::ECMA_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8: - methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId().AsIndex()).GetOffset(); + case OldBytecodeInst::Opcode::ECMA_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8: + methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId()).GetOffset(); index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::ASYNC_FUNCTION, methodId); FixInstructionId32(bcIns, index); break; - case BytecodeInstruction::Opcode::ECMA_DEFINEMETHOD_PREF_ID16_IMM16_V8: - methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId().AsIndex()).GetOffset(); + case OldBytecodeInst::Opcode::ECMA_DEFINEMETHOD_PREF_ID16_IMM16_V8: + methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId()).GetOffset(); index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::METHOD, methodId); FixInstructionId32(bcIns, index); break; - case BytecodeInstruction::Opcode::ECMA_CREATEOBJECTWITHBUFFER_PREF_IMM16: - case BytecodeInstruction::Opcode::ECMA_CREATEOBJECTHAVINGMETHOD_PREF_IMM16: { - auto imm = bcIns.GetImm(); + case OldBytecodeInst::Opcode::ECMA_CREATEOBJECTWITHBUFFER_PREF_IMM16: + case OldBytecodeInst::Opcode::ECMA_CREATEOBJECTHAVINGMETHOD_PREF_IMM16: { + auto imm = bcIns.GetImm(); index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::OBJECT_LITERAL, static_cast(imm)); FixInstructionId32(bcIns, index); break; } - case BytecodeInstruction::Opcode::ECMA_CREATEARRAYWITHBUFFER_PREF_IMM16: { - auto imm = bcIns.GetImm(); + case OldBytecodeInst::Opcode::ECMA_CREATEARRAYWITHBUFFER_PREF_IMM16: { + auto imm = bcIns.GetImm(); index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::ARRAY_LITERAL, static_cast(imm)); FixInstructionId32(bcIns, index); break; } - case BytecodeInstruction::Opcode::ECMA_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8: { - methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId().AsIndex()).GetOffset(); + case OldBytecodeInst::Opcode::ECMA_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8: { + methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId()).GetOffset(); index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::CLASS_FUNCTION, methodId); FixInstructionId32(bcIns, index); - auto imm = bcIns.GetImm(); + auto imm = bcIns.GetImm(); index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::CLASS_LITERAL, static_cast(imm)); FixInstructionId32(bcIns, index, 1); @@ -356,46 +865,5 @@ void BytecodeInfoCollector::TranslateBCIns(JSPandaFile *jsPandaFile, const panda } } } - -void BytecodeInfoCollector::CollectMethodPcs(JSPandaFile *jsPandaFile, const uint32_t insSz, const uint8_t *insArr, - const MethodLiteral* method, std::vector &methodPcInfos) -{ - auto bcIns = BytecodeInstruction(insArr); - auto bcInsLast = bcIns.JumpTo(insSz); - - methodPcInfos.emplace_back(MethodPcInfo { std::vector(1, method), {}, {}, {} }); - - int32_t offsetIndex = 1; - uint8_t *curPc = nullptr; - uint8_t *prePc = nullptr; - while (bcIns.GetAddress() != bcInsLast.GetAddress()) { - TranslateBCIns(jsPandaFile, bcIns, method); - - auto pc = const_cast(bcIns.GetAddress()); - bcIns = bcIns.GetNext(); - - FixOpcode(pc); - UpdateICOffset(const_cast(method), pc); - - auto &bytecodeBlockInfos = methodPcInfos.back().bytecodeBlockInfos; - auto &byteCodeCurPrePc = methodPcInfos.back().byteCodeCurPrePc; - auto &pcToBCOffset = methodPcInfos.back().pcToBCOffset; - - if (offsetIndex == 1) { - curPc = prePc = pc; - bytecodeBlockInfos.emplace_back(curPc, SplitKind::START, std::vector(1, curPc)); - byteCodeCurPrePc[curPc] = prePc; - pcToBCOffset[curPc] = offsetIndex++; - } else { - curPc = pc; - byteCodeCurPrePc[curPc] = prePc; - pcToBCOffset[curPc] = offsetIndex++; - prePc = curPc; - BytecodeCircuitBuilder::CollectBytecodeBlockInfo(curPc, bytecodeBlockInfos); - } - } - auto emptyPc = const_cast(bcInsLast.GetAddress()); - methodPcInfos.back().byteCodeCurPrePc[emptyPc] = prePc; - methodPcInfos.back().pcToBCOffset[emptyPc] = offsetIndex++; -} +#endif } // namespace panda::ecmascript::kungfu \ No newline at end of file diff --git a/ecmascript/compiler/bytecode_info_collector.h b/ecmascript/compiler/bytecode_info_collector.h index 0707ad4f94..8ae0ef40bf 100644 --- a/ecmascript/compiler/bytecode_info_collector.h +++ b/ecmascript/compiler/bytecode_info_collector.h @@ -19,7 +19,9 @@ #include "ecmascript/ecma_vm.h" #include "ecmascript/jspandafile/method_literal.h" -#include "libpandafile/bytecode_instruction-inl.h" +#ifdef ENABLE_OLD_BYTECODE_AOT +#include "ecmascript/jspandafile/bytecode_inst/old_instruction.h" +#endif namespace panda::ecmascript::kungfu { struct CfgInfo; @@ -56,17 +58,21 @@ private: static void ProcessClasses(JSPandaFile *jsPandaFile, const CString &methodName, std::vector &methodPcInfos); +#ifdef ENABLE_OLD_BYTECODE_AOT + static void AddNopInst(uint8_t *pc, int number); + // need to remove in the future - static void FixOpcode(uint8_t *pc); + static void FixOpcode(MethodLiteral *method, const OldBytecodeInst &inst); // need to remove in the future static void UpdateICOffset(MethodLiteral *method, uint8_t *pc); // need to remove in the future - static void FixInstructionId32(const BytecodeInstruction &inst, uint32_t index, uint32_t fixOrder = 0); + static void FixInstructionId32(const OldBytecodeInst &inst, uint32_t index, uint32_t fixOrder = 0); // need to remove in the future - static void TranslateBCIns(JSPandaFile *jsPandaFile, const BytecodeInstruction &bcIns, const MethodLiteral *method); + static void TranslateBCIns(JSPandaFile *jsPandaFile, const OldBytecodeInst &bcIns, const MethodLiteral *method); +#endif static void CollectMethodPcs(JSPandaFile *jsPandaFile, const uint32_t insSz, const uint8_t *insArr, const MethodLiteral *method, std::vector &methodPcInfos); diff --git a/ecmascript/compiler/call_signature.cpp b/ecmascript/compiler/call_signature.cpp index a30d9ee187..9edcc2456d 100644 --- a/ecmascript/compiler/call_signature.cpp +++ b/ecmascript/compiler/call_signature.cpp @@ -786,9 +786,9 @@ DEF_CALL_SIGNATURE(PushCallArgs3AndDispatch) PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallArgs3AndDispatch) } -DEF_CALL_SIGNATURE(PushCallIRangeAndDispatchNative) +DEF_CALL_SIGNATURE(PushCallRangeAndDispatchNative) { - PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(PushCallIRangeAndDispatchNative) + PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(PushCallRangeAndDispatchNative) } DEF_CALL_SIGNATURE(PushCallNewAndDispatchNative) @@ -801,14 +801,14 @@ DEF_CALL_SIGNATURE(PushCallNewAndDispatch) PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallNewAndDispatch) } -DEF_CALL_SIGNATURE(PushCallIRangeAndDispatch) +DEF_CALL_SIGNATURE(PushCallRangeAndDispatch) { - PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallIRangeAndDispatch) + PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallRangeAndDispatch) } -DEF_CALL_SIGNATURE(PushCallIThisRangeAndDispatch) +DEF_CALL_SIGNATURE(PushCallThisRangeAndDispatch) { - PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallIThisRangeAndDispatch) + PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallThisRangeAndDispatch) } DEF_CALL_SIGNATURE(CallGetter) @@ -973,12 +973,12 @@ DEF_CALL_SIGNATURE(MarkingBarrier) callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC); } -DEF_CALL_SIGNATURE(CallArg0Dyn) +DEF_CALL_SIGNATURE(CallArg0) { // 2 : 2 input parameters - CallSignature callArg0Dyn("callArg0Dyn", 0, 2, + CallSignature callArg0("callArg0", 0, 2, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); - *callSign = callArg0Dyn; + *callSign = callArg0; // 2 : 2 input parameters std::array params = { VariableType::NATIVE_POINTER(), @@ -988,12 +988,12 @@ DEF_CALL_SIGNATURE(CallArg0Dyn) callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB); } -DEF_CALL_SIGNATURE(CallArg1Dyn) +DEF_CALL_SIGNATURE(CallArg1) { // 3 : 3 input parameters - CallSignature callArg1Dyn("callArg1Dyn", 0, 3, + CallSignature callArg1("callArg1", 0, 3, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); - *callSign = callArg1Dyn; + *callSign = callArg1; // 3 : 3 input parameters std::array params = { VariableType::NATIVE_POINTER(), @@ -1004,12 +1004,12 @@ DEF_CALL_SIGNATURE(CallArg1Dyn) callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB); } -DEF_CALL_SIGNATURE(CallArgs2Dyn) +DEF_CALL_SIGNATURE(CallArgs2) { // 4 : 4 input parameters - CallSignature callArgs2Dyn("callArgs2Dyn", 0, 4, + CallSignature callArgs2("callArgs2", 0, 4, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); - *callSign = callArgs2Dyn; + *callSign = callArgs2; // 4 : 4 input parameters std::array params = { VariableType::NATIVE_POINTER(), @@ -1021,12 +1021,12 @@ DEF_CALL_SIGNATURE(CallArgs2Dyn) callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB); } -DEF_CALL_SIGNATURE(CallArgs3Dyn) +DEF_CALL_SIGNATURE(CallArgs3) { // 5 : 5 input parameters - CallSignature callArgs3Dyn("callArgs3Dyn", 0, 5, + CallSignature callArgs3("callArgs3", 0, 5, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); - *callSign = callArgs3Dyn; + *callSign = callArgs3; // 5 : 5 input parameters std::array params = { VariableType::NATIVE_POINTER(), @@ -1039,12 +1039,12 @@ DEF_CALL_SIGNATURE(CallArgs3Dyn) callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB); } -DEF_CALL_SIGNATURE(CallIThisRangeDyn) +DEF_CALL_SIGNATURE(CallThisRange) { // 3 : 3 input parameters - CallSignature callIThisRangeDyn("callIThisRangeDyn", 0, 3, + CallSignature callThisRange("callThisRange", 0, 3, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); - *callSign = callIThisRangeDyn; + *callSign = callThisRange; // 3 : 3 input parameters std::array params = { VariableType::NATIVE_POINTER(), @@ -1056,12 +1056,12 @@ DEF_CALL_SIGNATURE(CallIThisRangeDyn) callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB); } -DEF_CALL_SIGNATURE(CallIRangeDyn) +DEF_CALL_SIGNATURE(CallRange) { // 2 : 2 input parameters - CallSignature callIRangeDyn("callIRangeDyn", 0, 2, + CallSignature callRange("callRange", 0, 2, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); - *callSign = callIRangeDyn; + *callSign = callRange; // 2 : 2 input parameters std::array params = { VariableType::NATIVE_POINTER(), diff --git a/ecmascript/compiler/call_signature.h b/ecmascript/compiler/call_signature.h index 94b0ef6313..d125ae5aa3 100644 --- a/ecmascript/compiler/call_signature.h +++ b/ecmascript/compiler/call_signature.h @@ -329,9 +329,9 @@ private: V(PushCallArgs1AndDispatch) \ V(PushCallArgs2AndDispatch) \ V(PushCallArgs3AndDispatch) \ - V(PushCallIRangeAndDispatch) \ - V(PushCallIRangeAndDispatchNative) \ - V(PushCallIThisRangeAndDispatch) \ + V(PushCallRangeAndDispatch) \ + V(PushCallRangeAndDispatchNative) \ + V(PushCallThisRangeAndDispatch) \ V(PushCallNewAndDispatchNative) \ V(PushCallNewAndDispatch) \ V(CallGetter) \ @@ -351,12 +351,12 @@ private: V(FloatMod) \ V(FindElementWithCache) \ V(MarkingBarrier) \ - V(CallArg0Dyn) \ - V(CallArg1Dyn) \ - V(CallArgs2Dyn) \ - V(CallArgs3Dyn) \ - V(CallIThisRangeDyn) \ - V(CallIRangeDyn) \ + V(CallArg0) \ + V(CallArg1) \ + V(CallArgs2) \ + V(CallArgs3) \ + V(CallThisRange) \ + V(CallRange) \ V(JSCall) \ V(ConstructorJSCall) \ V(JSFunctionEntry) \ diff --git a/ecmascript/compiler/circuit_builder-inl.h b/ecmascript/compiler/circuit_builder-inl.h index 8149b429c0..8af5e58139 100644 --- a/ecmascript/compiler/circuit_builder-inl.h +++ b/ecmascript/compiler/circuit_builder-inl.h @@ -407,9 +407,9 @@ GateRef CircuitBuilder::IsCallableFromBitField(GateRef bitfield) GateRef CircuitBuilder::IsCallable(GateRef obj) { - GateRef hclass = LoadHClass(obj); + GateRef hClass = LoadHClass(obj); GateRef bitfieldOffset = IntPtr(JSHClass::BIT_FIELD_OFFSET); - GateRef bitfield = Load(VariableType::INT32(), hclass, bitfieldOffset); + GateRef bitfield = Load(VariableType::INT32(), hClass, bitfieldOffset); return IsCallableFromBitField(bitfield); } diff --git a/ecmascript/compiler/interpreter_stub-inl.h b/ecmascript/compiler/interpreter_stub-inl.h index c1e168e513..c510422989 100644 --- a/ecmascript/compiler/interpreter_stub-inl.h +++ b/ecmascript/compiler/interpreter_stub-inl.h @@ -168,6 +168,15 @@ GateRef InterpreterStubBuilder::ReadInst16_3(GateRef pc) return Int16Add(currentInst2, ZExtInt8ToInt16(ReadInst8_3(pc))); } +GateRef InterpreterStubBuilder::ReadInst16_4(GateRef pc) +{ + /* 7 : skip 8 bits of opcode, 8 bits of prefix, first 2 parameters of 16 bits and 8 bits of low bits */ + GateRef currentInst1 = ZExtInt8ToInt16(ReadInst8_5(pc)); + GateRef currentInst2 = Int16LSL(currentInst1, Int16(8)); // 8 : set as high 8 bits + /* 6 : skip 8 bits of opcode, 8 bits of prefix and first 2 parameters of 16 bits */ + return Int16Add(currentInst2, ZExtInt8ToInt16(ReadInst8_4(pc))); +} + GateRef InterpreterStubBuilder::ReadInst16_5(GateRef pc) { /* 7 : skip 8 bits of opcode, 8 bits of prefix, first 2 parameters of 16 bits and 8 bits of low bits */ @@ -177,6 +186,15 @@ GateRef InterpreterStubBuilder::ReadInst16_5(GateRef pc) return Int16Add(currentInst2, ZExtInt8ToInt16(ReadInst8_5(pc))); } +GateRef InterpreterStubBuilder::ReadInst16_6(GateRef pc) +{ + /* 7 : skip 8 bits of opcode, 8 bits of prefix, first 2 parameters of 16 bits and 8 bits of low bits */ + GateRef currentInst1 = ZExtInt8ToInt16(ReadInst8_7(pc)); + GateRef currentInst2 = Int16LSL(currentInst1, Int16(8)); // 8 : set as high 8 bits + /* 6 : skip 8 bits of opcode, 8 bits of prefix and first 2 parameters of 16 bits */ + return Int16Add(currentInst2, ZExtInt8ToInt16(ReadInst8_6(pc))); +} + GateRef InterpreterStubBuilder::GetFrame(GateRef CurrentSp) { return PtrSub(CurrentSp, IntPtr(AsmInterpretedFrame::GetSize(GetEnvironment()->IsArch32Bit()))); diff --git a/ecmascript/compiler/interpreter_stub.cpp b/ecmascript/compiler/interpreter_stub.cpp index e8b8c5f612..4ca03d49e3 100644 --- a/ecmascript/compiler/interpreter_stub.cpp +++ b/ecmascript/compiler/interpreter_stub.cpp @@ -30,8 +30,6 @@ #include "ecmascript/message_string.h" #include "ecmascript/tagged_hash_table.h" -#include "libpandafile/bytecode_instruction-inl.h" - namespace panda::ecmascript::kungfu { #if ECMASCRIPT_ENABLE_ASM_INTERPRETER_LOG #define DECLARE_ASM_HANDLER(name) \ @@ -96,12 +94,12 @@ void name##StubBuilder::GenerateCircuitImpl(GateRef glue, GateRef sp, GateRef pc #define DISPATCH_BASE(...) \ Dispatch(glue, sp, pc, constpool, __VA_ARGS__) -#define INT_PTR(format) \ - IntPtr(BytecodeInstruction::Size(BytecodeInstruction::Format::format)) +#define INT_PTR(opcode) \ + IntPtr(BytecodeInstruction::Size(BytecodeInstruction::Opcode::opcode)) -#define DISPATCH_WITH_ACC(format) DISPATCH_BAK(VARACC, INT_PTR(format)) +#define DISPATCH_WITH_ACC(opcode) DISPATCH_BAK(VARACC, INT_PTR(opcode)) -#define DISPATCH(format) DISPATCH_BAK(OFFSET, INT_PTR(format)) +#define DISPATCH(opcode) DISPATCH_BAK(OFFSET, INT_PTR(opcode)) #define DISPATCH_LAST() \ DispatchLast(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter) \ @@ -145,100 +143,101 @@ void name##StubBuilder::GenerateCircuitImpl(GateRef glue, GateRef sp, GateRef pc CheckPendingException(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter, \ res, offset) -DECLARE_ASM_HANDLER(HandleLdNanPref) +/* +DECLARE_ASM_HANDLER(HandleLdNan) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); varAcc = DoubleBuildTaggedWithNoGC(Double(base::NAN_VALUE)); - DISPATCH_WITH_ACC(PREF_NONE); + DISPATCH_WITH_ACC(LDNAN); } -DECLARE_ASM_HANDLER(HandleLdInfinityPref) +DECLARE_ASM_HANDLER(HandleLdInfinity) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); varAcc = DoubleBuildTaggedWithNoGC(Double(base::POSITIVE_INFINITY)); - DISPATCH_WITH_ACC(PREF_NONE); + DISPATCH_WITH_ACC(LDINFINITY); } -DECLARE_ASM_HANDLER(HandleLdGlobalThisPref) +DECLARE_ASM_HANDLER(HandleLdGlobalThis) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); varAcc = GetGlobalObject(glue); - DISPATCH_WITH_ACC(PREF_NONE); + DISPATCH_WITH_ACC(LDGLOBALTHIS); } -DECLARE_ASM_HANDLER(HandleLdUndefinedPref) +DECLARE_ASM_HANDLER(HandleLdUndefined) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); varAcc = Undefined(); - DISPATCH_WITH_ACC(PREF_NONE); + DISPATCH_WITH_ACC(LDUNDEFINED); } -DECLARE_ASM_HANDLER(HandleLdNullPref) +DECLARE_ASM_HANDLER(HandleLdNull) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); varAcc = Null(); - DISPATCH_WITH_ACC(PREF_NONE); + DISPATCH_WITH_ACC(LDNULL); } -DECLARE_ASM_HANDLER(HandleLdSymbolPref) +DECLARE_ASM_HANDLER(HandleLdSymbol) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); varAcc = CallRuntime(glue, RTSTUB_ID(GetSymbolFunction), {}); - DISPATCH_WITH_ACC(PREF_NONE); + DISPATCH_WITH_ACC(LDSYMBOL); } -DECLARE_ASM_HANDLER(HandleLdGlobalPref) +DECLARE_ASM_HANDLER(HandleLdGlobal) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); varAcc = GetGlobalObject(glue); - DISPATCH_WITH_ACC(PREF_NONE); + DISPATCH_WITH_ACC(LDGLOBAL); } -DECLARE_ASM_HANDLER(HandleLdTruePref) +DECLARE_ASM_HANDLER(HandleLdTrue) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); varAcc = ChangeInt64ToTagged(Int64(JSTaggedValue::VALUE_TRUE)); - DISPATCH_WITH_ACC(PREF_NONE); + DISPATCH_WITH_ACC(LDTRUE); } -DECLARE_ASM_HANDLER(HandleLdFalsePref) +DECLARE_ASM_HANDLER(HandleLdFalse) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); varAcc = ChangeInt64ToTagged(Int64(JSTaggedValue::VALUE_FALSE)); - DISPATCH_WITH_ACC(PREF_NONE); + DISPATCH_WITH_ACC(LDFALSE); } -DECLARE_ASM_HANDLER(HandleThrowDynPref) +DECLARE_ASM_HANDLER(HandleThrow) { - CallRuntime(glue, RTSTUB_ID(ThrowDyn), { acc }); + CallRuntime(glue, RTSTUB_ID(Throw), { acc }); DISPATCH_LAST(); } -DECLARE_ASM_HANDLER(HandleTypeOfDynPref) +DECLARE_ASM_HANDLER(HandleTypeofImm8) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); varAcc = FastTypeOf(glue, acc); - DISPATCH_WITH_ACC(PREF_NONE); + DISPATCH_WITH_ACC(TYPEOF_IMM8); } -DECLARE_ASM_HANDLER(HandleLdLexEnvDynPref) +DECLARE_ASM_HANDLER(HandleLdLexEnv) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); GateRef state = GetFrame(sp); varAcc = GetEnvFromFrame(state); - DISPATCH_WITH_ACC(PREF_NONE); + DISPATCH_WITH_ACC(LDLEXENV); } -DECLARE_ASM_HANDLER(HandlePopLexEnvDynPref) +DECLARE_ASM_HANDLER(HandlePopLexEnv) { GateRef state = GetFrame(sp); GateRef currentLexEnv = GetEnvFromFrame(state); GateRef parentLexEnv = GetParentEnv(currentLexEnv); SetEnvToFrame(glue, state, parentLexEnv); - DISPATCH(PREF_NONE); + DISPATCH(POPLEXENV); } -DECLARE_ASM_HANDLER(HandleGetUnmappedArgsPref) +DECLARE_ASM_HANDLER(HandleGetUnmappedArgs) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); DEFVARIABLE(argumentsList, VariableType::JS_ANY(), Hole()); @@ -269,71 +268,71 @@ DECLARE_ASM_HANDLER(HandleGetUnmappedArgsPref) Bind(&dispatch); { varAcc = *argumentsObj; - DISPATCH_WITH_ACC(PREF_NONE); + DISPATCH_WITH_ACC(GETUNMAPPEDARGS); } Bind(&slowPath); { GateRef res = CallRuntime(glue, RTSTUB_ID(GetUnmapedArgs), {}); - CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(PREF_NONE)); + CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(GETUNMAPPEDARGS)); } } -DECLARE_ASM_HANDLER(HandleCopyRestArgsPrefImm16) +DECLARE_ASM_HANDLER(HandleCopyRestArgsImm16) { - GateRef restIdx = ZExtInt16ToInt32(ReadInst16_1(pc)); + GateRef restIdx = ZExtInt16ToInt32(ReadInst16_0(pc)); GateRef res = CallRuntime(glue, RTSTUB_ID(CopyRestArgs), { IntToTaggedTypeNGC(restIdx) }); - CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(PREF_IMM16)); + CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(COPYRESTARGS_IMM16)); } -DECLARE_ASM_HANDLER(HandleCreateArrayWithBufferPrefImm16) +DECLARE_ASM_HANDLER(HandleCreateArrayWithBufferImm8Imm16) { GateRef imm = ZExtInt16ToInt32(ReadInst16_1(pc)); GateRef result = GetObjectFromConstPool(constpool, imm); GateRef res = CallRuntime(glue, RTSTUB_ID(CreateArrayWithBuffer), { result }); - CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(PREF_IMM16)); + CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CREATEARRAYWITHBUFFER_IMM8_IMM16)); } -DECLARE_ASM_HANDLER(HandleCreateObjectWithBufferPrefImm16) +DECLARE_ASM_HANDLER(HandleCreateObjectWithBufferImm8Imm16) { GateRef imm = ZExtInt16ToInt32(ReadInst16_1(pc)); GateRef result = GetObjectFromConstPool(constpool, imm); GateRef res = CallRuntime(glue, RTSTUB_ID(CreateObjectWithBuffer), { result }); - CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(PREF_IMM16)); + CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CREATEOBJECTWITHBUFFER_IMM8_IMM16)); } -DECLARE_ASM_HANDLER(HandleCreateObjectWithExcludedKeysPrefImm16V8V8) +DECLARE_ASM_HANDLER(HandleCreateObjectWithExcludedKeysImm8V8V8) { - GateRef numKeys = ReadInst16_1(pc); - GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); - GateRef firstArgRegIdx = ZExtInt8ToInt16(ReadInst8_4(pc)); + GateRef numKeys = ReadInst8_0(pc); + GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); + GateRef firstArgRegIdx = ZExtInt8ToInt16(ReadInst8_2(pc)); GateRef res = CallRuntime(glue, RTSTUB_ID(CreateObjectWithExcludedKeys), { Int16ToTaggedTypeNGC(numKeys), obj, Int16ToTaggedTypeNGC(firstArgRegIdx) }); - CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(PREF_IMM16_V8_V8)); + CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CREATEOBJECTWITHEXCLUDEDKEYS_IMM8_V8_V8)); } -DECLARE_ASM_HANDLER(HandleCreateObjectHavingMethodPrefImm16) +DECLARE_ASM_HANDLER(HandleCreateObjectHavingMethodImm8Imm16) { GateRef imm = ZExtInt16ToInt32(ReadInst16_1(pc)); GateRef result = GetObjectFromConstPool(constpool, imm); GateRef res = CallRuntime(glue, RTSTUB_ID(CreateObjectHavingMethod), { result, acc, constpool }); - CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(PREF_IMM16)); + CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CREATEOBJECTHAVINGMETHOD_IMM8_IMM16)); } -DECLARE_ASM_HANDLER(HandleThrowIfSuperNotCorrectCallPrefImm16) +DECLARE_ASM_HANDLER(HandleThrowIfSuperNotCorrectCallImm16) { - GateRef imm = ReadInst16_1(pc); + GateRef imm = ReadInst16_0(pc); GateRef res = CallRuntime(glue, RTSTUB_ID(ThrowIfSuperNotCorrectCall), { Int16ToTaggedTypeNGC(imm), acc }); // acc is thisValue - CHECK_EXCEPTION(res, INT_PTR(PREF_IMM16)); + CHECK_EXCEPTION(res, INT_PTR(THROWIFSUPERNOTCORRECTCALL_IMM16)); } -DECLARE_ASM_HANDLER(HandleNewLexEnvDynPrefImm16) +DECLARE_ASM_HANDLER(HandleNewLexEnvImm8) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); DEFVARIABLE(result, VariableType::JS_ANY(), Hole()); auto env = GetEnvironment(); - GateRef numVars = ReadInst16_1(pc); + GateRef numVars = ReadInst8_0(pc); GateRef state = GetFrame(sp); auto parent = GetEnvFromFrame(state); NewObjectStubBuilder newBuilder(this); @@ -346,10 +345,10 @@ DECLARE_ASM_HANDLER(HandleNewLexEnvDynPrefImm16) Bind(¬Exception); varAcc = *result; SetEnvToFrame(glue, GetFrame(sp), *result); - DISPATCH_WITH_ACC(PREF_IMM16); + DISPATCH_WITH_ACC(NEWLEXENV_IMM8); } -DECLARE_ASM_HANDLER(HandleNewObjDynRangePrefImm16V8) +DECLARE_ASM_HANDLER(HandleNewObjRangeImm8Imm16V8) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); DEFVARIABLE(res, VariableType::JS_ANY(), Undefined()); @@ -425,7 +424,7 @@ DECLARE_ASM_HANDLER(HandleNewObjDynRangePrefImm16V8) Bind(&slowPath); GateRef firstArgIdx = Int16Add(firstArgRegIdx, firstArgOffset); GateRef length = Int16Sub(numArgs, firstArgOffset); - res = CallRuntime(glue, RTSTUB_ID(NewObjDynRange), + res = CallRuntime(glue, RTSTUB_ID(NewObjRange), { ctor, ctor, Int16ToTaggedTypeNGC(firstArgIdx), Int16ToTaggedTypeNGC(length) }); Jump(&checkResult); Bind(&checkResult); @@ -442,10 +441,10 @@ DECLARE_ASM_HANDLER(HandleNewObjDynRangePrefImm16V8) } Bind(&dispatch); varAcc = *res; - DISPATCH_WITH_ACC(PREF_IMM16_V8); + DISPATCH_WITH_ACC(NEWOBJRANGE_IMM8_IMM16_V8); } -DECLARE_ASM_HANDLER(HandleDefineFuncDynPrefId16Imm16V8) +DECLARE_ASM_HANDLER(HandleDefineFuncImm8Id16Imm16V8) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); auto env = GetEnvironment(); @@ -460,7 +459,7 @@ DECLARE_ASM_HANDLER(HandleDefineFuncDynPrefId16Imm16V8) Branch(FunctionIsResolved(*result), &isResolved, ¬Resolved); Bind(&isResolved); { - result = CallRuntime(glue, RTSTUB_ID(DefinefuncDyn), { *result }); + result = CallRuntime(glue, RTSTUB_ID(Definefunc), { *result }); Label notException(env); CHECK_EXCEPTION_WITH_JUMP(*result, ¬Exception); Bind(¬Exception); @@ -476,19 +475,19 @@ DECLARE_ASM_HANDLER(HandleDefineFuncDynPrefId16Imm16V8) } Bind(&defaultLabel); { - GateRef hClass = LoadHClass(*result); - SetPropertyInlinedProps(glue, *result, hClass, Int16ToTaggedNGC(length), + GateRef hclass = LoadHClass(*result); + SetPropertyInlinedProps(glue, *result, hclass, Int16ToTaggedNGC(length), Int32(JSFunction::LENGTH_INLINE_PROPERTY_INDEX), VariableType::INT64()); GateRef envHandle = GetVregValue(sp, ZExtInt8ToPtr(v0)); SetLexicalEnvToFunction(glue, *result, envHandle); GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); SetModuleToFunction(glue, *result, GetModuleFromFunction(currentFunc)); varAcc = *result; - DISPATCH_WITH_ACC(PREF_ID16_IMM16_V8); + DISPATCH_WITH_ACC(DEFINEFUNC_IMM8_ID16_IMM16_V8); } } -DECLARE_ASM_HANDLER(HandleDefineNCFuncDynPrefId16Imm16V8) +DECLARE_ASM_HANDLER(HandleDefineNCFuncImm8Id16Imm16V8) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); auto env = GetEnvironment(); @@ -503,7 +502,7 @@ DECLARE_ASM_HANDLER(HandleDefineNCFuncDynPrefId16Imm16V8) Branch(FunctionIsResolved(*result), &isResolved, ¬Resolved); Bind(&isResolved); { - result = CallRuntime(glue, RTSTUB_ID(DefineNCFuncDyn), { *result }); + result = CallRuntime(glue, RTSTUB_ID(DefineNCFunc), { *result }); Label notException(env); CHECK_EXCEPTION_WITH_JUMP(*result, ¬Exception); Bind(¬Exception); @@ -519,8 +518,8 @@ DECLARE_ASM_HANDLER(HandleDefineNCFuncDynPrefId16Imm16V8) } Bind(&defaultLabel); { - GateRef hClass = LoadHClass(*result); - SetPropertyInlinedProps(glue, *result, hClass, Int16ToTaggedNGC(length), + GateRef hclass = LoadHClass(*result); + SetPropertyInlinedProps(glue, *result, hclass, Int16ToTaggedNGC(length), Int32(JSFunction::LENGTH_INLINE_PROPERTY_INDEX), VariableType::INT64()); GateRef lexEnv = GetVregValue(sp, ZExtInt8ToPtr(v0)); SetLexicalEnvToFunction(glue, *result, lexEnv); @@ -528,11 +527,11 @@ DECLARE_ASM_HANDLER(HandleDefineNCFuncDynPrefId16Imm16V8) GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); SetModuleToFunction(glue, *result, GetModuleFromFunction(currentFunc)); varAcc = *result; - DISPATCH_WITH_ACC(PREF_ID16_IMM16_V8); + DISPATCH_WITH_ACC(DEFINENCFUNC_IMM8_ID16_IMM16_V8); } } -DECLARE_ASM_HANDLER(HandleDefineGeneratorFuncPrefId16Imm16V8) +DECLARE_ASM_HANDLER(HandleDefineGeneratorFuncImm8Id16Imm16V8) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); auto env = GetEnvironment(); @@ -563,19 +562,19 @@ DECLARE_ASM_HANDLER(HandleDefineGeneratorFuncPrefId16Imm16V8) } Bind(&defaultLabel); { - GateRef hClass = LoadHClass(*result); - SetPropertyInlinedProps(glue, *result, hClass, Int16ToTaggedNGC(length), + GateRef hclass = LoadHClass(*result); + SetPropertyInlinedProps(glue, *result, hclass, Int16ToTaggedNGC(length), Int32(JSFunction::LENGTH_INLINE_PROPERTY_INDEX), VariableType::INT64()); GateRef lexEnv = GetVregValue(sp, ZExtInt8ToPtr(v0)); SetLexicalEnvToFunction(glue, *result, lexEnv); GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); SetModuleToFunction(glue, *result, GetModuleFromFunction(currentFunc)); varAcc = *result; - DISPATCH_WITH_ACC(PREF_ID16_IMM16_V8); + DISPATCH_WITH_ACC(DEFINEGENERATORFUNC_IMM8_ID16_IMM16_V8); } } -DECLARE_ASM_HANDLER(HandleDefineAsyncFuncPrefId16Imm16V8) +DECLARE_ASM_HANDLER(HandleDefineAsyncFuncImm8Id16Imm16V8) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); auto env = GetEnvironment(); @@ -606,19 +605,19 @@ DECLARE_ASM_HANDLER(HandleDefineAsyncFuncPrefId16Imm16V8) } Bind(&defaultLabel); { - GateRef hClass = LoadHClass(*result); - SetPropertyInlinedProps(glue, *result, hClass, Int16ToTaggedNGC(length), + GateRef hclass = LoadHClass(*result); + SetPropertyInlinedProps(glue, *result, hclass, Int16ToTaggedNGC(length), Int32(JSFunction::LENGTH_INLINE_PROPERTY_INDEX), VariableType::INT64()); GateRef lexEnv = GetVregValue(sp, ZExtInt8ToPtr(v0)); SetLexicalEnvToFunction(glue, *result, lexEnv); GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); SetModuleToFunction(glue, *result, GetModuleFromFunction(currentFunc)); varAcc = *result; - DISPATCH_WITH_ACC(PREF_ID16_IMM16_V8); + DISPATCH_WITH_ACC(DEFINEASYNCFUNC_IMM8_ID16_IMM16_V8); } } -DECLARE_ASM_HANDLER(HandleDefineMethodPrefId16Imm16V8) +DECLARE_ASM_HANDLER(HandleDefineMethodImm8Id16Imm16V8) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); auto env = GetEnvironment(); @@ -650,142 +649,142 @@ DECLARE_ASM_HANDLER(HandleDefineMethodPrefId16Imm16V8) } Bind(&defaultLabel); { - GateRef hClass = LoadHClass(*result); - SetPropertyInlinedProps(glue, *result, hClass, Int16ToTaggedNGC(length), + GateRef hclass = LoadHClass(*result); + SetPropertyInlinedProps(glue, *result, hclass, Int16ToTaggedNGC(length), Int32(JSFunction::LENGTH_INLINE_PROPERTY_INDEX), VariableType::INT64()); GateRef lexEnv = GetVregValue(sp, ZExtInt8ToPtr(v0)); SetLexicalEnvToFunction(glue, *result, lexEnv); GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); SetModuleToFunction(glue, *result, GetModuleFromFunction(currentFunc)); varAcc = *result; - DISPATCH_WITH_ACC(PREF_ID16_IMM16_V8); + DISPATCH_WITH_ACC(DEFINEMETHOD_IMM8_ID16_IMM16_V8); } } -DECLARE_ASM_HANDLER(HandleCallSpreadDynPrefV8V8V8) +DECLARE_ASM_HANDLER(HandleCallSpreadImm8V8V8V8) { GateRef func = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); GateRef array = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); - GateRef res = CallRuntime(glue, RTSTUB_ID(CallSpreadDyn), { func, obj, array }); - CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(PREF_V8_V8_V8)); + GateRef res = CallRuntime(glue, RTSTUB_ID(CallSpread), { func, obj, array }); + CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CALLSPREAD_IMM8_V8_V8_V8)); } -DECLARE_ASM_HANDLER(HandleAsyncFunctionResolvePrefV8V8V8) +DECLARE_ASM_HANDLER(HandleAsyncFunctionResolveV8V8V8) { - GateRef asyncFuncObj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); - GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); + GateRef asyncFuncObj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_0(pc))); + GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); GateRef res = CallRuntime(glue, RTSTUB_ID(AsyncFunctionResolveOrReject), { asyncFuncObj, value, TaggedTrue() }); - CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(PREF_V8_V8_V8)); + CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(ASYNCFUNCTIONRESOLVE_V8_V8_V8)); } -DECLARE_ASM_HANDLER(HandleAsyncFunctionRejectPrefV8V8V8) +DECLARE_ASM_HANDLER(HandleAsyncFunctionRejectV8V8V8) { - GateRef asyncFuncObj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); - GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); + GateRef asyncFuncObj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_0(pc))); + GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); GateRef res = CallRuntime(glue, RTSTUB_ID(AsyncFunctionResolveOrReject), { asyncFuncObj, value, TaggedFalse() }); - CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(PREF_V8_V8_V8)); + CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(ASYNCFUNCTIONREJECT_V8_V8_V8)); } -DECLARE_ASM_HANDLER(HandleDefineGetterSetterByValuePrefV8V8V8V8) +DECLARE_ASM_HANDLER(HandleDefineGetterSetterByValueV8V8V8V8) { - GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); - GateRef prop = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); - GateRef getter = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); - GateRef setter = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_4(pc))); + GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_0(pc))); + GateRef prop = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); + GateRef getter = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); + GateRef setter = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); GateRef res = CallRuntime(glue, RTSTUB_ID(DefineGetterSetterByValue), { obj, prop, getter, setter, acc }); // acc is flag - CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(PREF_V8_V8_V8_V8)); + CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(DEFINEGETTERSETTERBYVALUE_V8_V8_V8_V8)); } -DECLARE_ASM_HANDLER(HandleSuperCallPrefImm16V8) +DECLARE_ASM_HANDLER(HandleSuperCallImm8Imm16V8) { GateRef range = ReadInst16_1(pc); GateRef v0 = ZExtInt8ToInt16(ReadInst8_3(pc)); // acc is thisFunc GateRef res = CallRuntime(glue, RTSTUB_ID(SuperCall), { acc, Int16ToTaggedTypeNGC(v0), Int16ToTaggedTypeNGC(range) }); - CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(PREF_IMM16_V8)); + CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(SUPERCALL_IMM8_IMM16_V8)); } -DECLARE_ASM_HANDLER(HandleGetPropIteratorPref) +DECLARE_ASM_HANDLER(HandleGetPropIterator) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); GateRef res = CallRuntime(glue, RTSTUB_ID(GetPropIterator), { *varAcc }); - CHECK_EXCEPTION_WITH_VARACC(res, INT_PTR(PREF_NONE)); + CHECK_EXCEPTION_WITH_VARACC(res, INT_PTR(GETPROPITERATOR)); } -DECLARE_ASM_HANDLER(HandleAsyncFunctionEnterPref) +DECLARE_ASM_HANDLER(HandleAsyncFunctionEnter) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); GateRef res = CallRuntime(glue, RTSTUB_ID(AsyncFunctionEnter), {}); - CHECK_EXCEPTION_WITH_VARACC(res, INT_PTR(PREF_NONE)); + CHECK_EXCEPTION_WITH_VARACC(res, INT_PTR(ASYNCFUNCTIONENTER)); } -DECLARE_ASM_HANDLER(HandleLdHolePref) +DECLARE_ASM_HANDLER(HandleLdHole) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); varAcc = Hole(); - DISPATCH_WITH_ACC(PREF_NONE); + DISPATCH_WITH_ACC(LDHOLE); } -DECLARE_ASM_HANDLER(HandleCreateEmptyObjectPref) +DECLARE_ASM_HANDLER(HandleCreateEmptyObject) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); GateRef res = CallRuntime(glue, RTSTUB_ID(CreateEmptyObject), {}); varAcc = res; - DISPATCH_WITH_ACC(PREF_NONE); + DISPATCH_WITH_ACC(CREATEEMPTYOBJECT); } -DECLARE_ASM_HANDLER(HandleCreateEmptyArrayPref) +DECLARE_ASM_HANDLER(HandleCreateEmptyArrayImm8) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); GateRef res = CallRuntime(glue, RTSTUB_ID(CreateEmptyArray), {}); varAcc = res; - DISPATCH_WITH_ACC(PREF_NONE); + DISPATCH_WITH_ACC(CREATEEMPTYARRAY_IMM8); } -DECLARE_ASM_HANDLER(HandleGetIteratorPref) +DECLARE_ASM_HANDLER(HandleGetIteratorImm8) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); GateRef res = CallRuntime(glue, RTSTUB_ID(GetIterator), { *varAcc }); - CHECK_EXCEPTION_WITH_VARACC(res, INT_PTR(PREF_NONE)); + CHECK_EXCEPTION_WITH_VARACC(res, INT_PTR(GETITERATOR_IMM8)); } -DECLARE_ASM_HANDLER(HandleThrowThrowNotExistsPref) +DECLARE_ASM_HANDLER(HandleThrowThrowNotExists) { CallRuntime(glue, RTSTUB_ID(ThrowThrowNotExists), {}); DISPATCH_LAST(); } -DECLARE_ASM_HANDLER(HandleThrowPatternNonCoerciblePref) +DECLARE_ASM_HANDLER(HandleThrowPatternNonCoercible) { CallRuntime(glue, RTSTUB_ID(ThrowPatternNonCoercible), {}); DISPATCH_LAST(); } -DECLARE_ASM_HANDLER(HandleLdHomeObjectPref) +DECLARE_ASM_HANDLER(HandleLdHomeObject) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); GateRef thisFunc = GetFunctionFromFrame(GetFrame(sp)); varAcc = GetHomeObjectFromJSFunction(thisFunc); - DISPATCH_WITH_ACC(PREF_NONE); + DISPATCH_WITH_ACC(LDHOMEOBJECT); } -DECLARE_ASM_HANDLER(HandleThrowDeleteSuperPropertyPref) +DECLARE_ASM_HANDLER(HandleThrowDeleteSuperProperty) { CallRuntime(glue, RTSTUB_ID(ThrowDeleteSuperProperty), {}); DISPATCH_LAST(); } -DECLARE_ASM_HANDLER(HandleDebuggerPref) +DECLARE_ASM_HANDLER(HandleDebugger) { - DISPATCH(PREF_NONE); + DISPATCH(DEBUGGER); } -DECLARE_ASM_HANDLER(HandleMul2DynPrefV8) +DECLARE_ASM_HANDLER(HandleMul2Imm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -800,8 +799,8 @@ DECLARE_ASM_HANDLER(HandleMul2DynPrefV8) Bind(&isHole); { // slow path - result = CallRuntime(glue, RTSTUB_ID(Mul2Dyn), { left, acc }); - CHECK_EXCEPTION_WITH_ACC(*result, INT_PTR(PREF_V8)); + result = CallRuntime(glue, RTSTUB_ID(Mul2), { left, acc }); + CHECK_EXCEPTION_WITH_ACC(*result, INT_PTR(MUL2_IMM8_V8)); } Bind(¬Hole); { @@ -809,10 +808,10 @@ DECLARE_ASM_HANDLER(HandleMul2DynPrefV8) Jump(&dispatch); } Bind(&dispatch); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(MUL2_IMM8_V8); } -DECLARE_ASM_HANDLER(HandleDiv2DynPrefV8) +DECLARE_ASM_HANDLER(HandleDiv2Imm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -827,8 +826,8 @@ DECLARE_ASM_HANDLER(HandleDiv2DynPrefV8) Bind(&isHole); { // slow path - result = CallRuntime(glue, RTSTUB_ID(Div2Dyn), { left, acc }); - CHECK_EXCEPTION_WITH_ACC(*result, INT_PTR(PREF_V8)); + result = CallRuntime(glue, RTSTUB_ID(Div2), { left, acc }); + CHECK_EXCEPTION_WITH_ACC(*result, INT_PTR(DIV2_IMM8_V8)); } Bind(¬Hole); { @@ -836,10 +835,10 @@ DECLARE_ASM_HANDLER(HandleDiv2DynPrefV8) Jump(&dispatch); } Bind(&dispatch); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(DIV2_IMM8_V8); } -DECLARE_ASM_HANDLER(HandleMod2DynPrefV8) +DECLARE_ASM_HANDLER(HandleMod2Imm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -854,8 +853,8 @@ DECLARE_ASM_HANDLER(HandleMod2DynPrefV8) Bind(&isHole); { // slow path - result = CallRuntime(glue, RTSTUB_ID(Mod2Dyn), { left, acc }); - CHECK_EXCEPTION_WITH_ACC(*result, INT_PTR(PREF_V8)); + result = CallRuntime(glue, RTSTUB_ID(Mod2), { left, acc }); + CHECK_EXCEPTION_WITH_ACC(*result, INT_PTR(MOD2_IMM8_V8)); } Bind(¬Hole); { @@ -863,10 +862,10 @@ DECLARE_ASM_HANDLER(HandleMod2DynPrefV8) Jump(&dispatch); } Bind(&dispatch); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(MOD2_IMM8_V8); } -DECLARE_ASM_HANDLER(HandleEqDynPrefV8) +DECLARE_ASM_HANDLER(HandleEqImm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -881,8 +880,8 @@ DECLARE_ASM_HANDLER(HandleEqDynPrefV8) Bind(&isHole); { // slow path - result = CallRuntime(glue, RTSTUB_ID(EqDyn), { left, acc }); - CHECK_EXCEPTION_WITH_ACC(*result, INT_PTR(PREF_V8)); + result = CallRuntime(glue, RTSTUB_ID(Eq), { left, acc }); + CHECK_EXCEPTION_WITH_ACC(*result, INT_PTR(EQ_IMM8_V8)); } Bind(¬Hole); { @@ -890,10 +889,10 @@ DECLARE_ASM_HANDLER(HandleEqDynPrefV8) Jump(&dispatch); } Bind(&dispatch); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(EQ_IMM8_V8); } -DECLARE_ASM_HANDLER(HandleNotEqDynPrefV8) +DECLARE_ASM_HANDLER(HandleNotEqImm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -908,8 +907,8 @@ DECLARE_ASM_HANDLER(HandleNotEqDynPrefV8) Bind(&isHole); { // slow path - result = CallRuntime(glue, RTSTUB_ID(NotEqDyn), { left, acc }); - CHECK_EXCEPTION_WITH_ACC(*result, INT_PTR(PREF_V8)); + result = CallRuntime(glue, RTSTUB_ID(NotEq), { left, acc }); + CHECK_EXCEPTION_WITH_ACC(*result, INT_PTR(NOTEQ_IMM8_V8)); } Bind(¬Hole); { @@ -928,10 +927,10 @@ DECLARE_ASM_HANDLER(HandleNotEqDynPrefV8) } } Bind(&dispatch); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(NOTEQ_IMM8_V8); } -DECLARE_ASM_HANDLER(HandleLessDynPrefV8) +DECLARE_ASM_HANDLER(HandleLessImm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -1019,14 +1018,14 @@ DECLARE_ASM_HANDLER(HandleLessDynPrefV8) Bind(&slowPath); { // slow path - GateRef result = CallRuntime(glue, RTSTUB_ID(LessDyn), { left, acc }); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8)); + GateRef result = CallRuntime(glue, RTSTUB_ID(Less), { left, acc }); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(LESS_IMM8_V8)); } Bind(&dispatch); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(LESS_IMM8_V8); } -DECLARE_ASM_HANDLER(HandleLessEqDynPrefV8) +DECLARE_ASM_HANDLER(HandleLessEqImm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -1114,14 +1113,14 @@ DECLARE_ASM_HANDLER(HandleLessEqDynPrefV8) Bind(&slowPath); { // slow path - GateRef result = CallRuntime(glue, RTSTUB_ID(LessEqDyn), { left, acc }); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8)); + GateRef result = CallRuntime(glue, RTSTUB_ID(LessEq), { left, acc }); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(LESSEQ_IMM8_V8)); } Bind(&dispatch); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(LESSEQ_IMM8_V8); } -DECLARE_ASM_HANDLER(HandleGreaterDynPrefV8) +DECLARE_ASM_HANDLER(HandleGreaterImm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -1209,14 +1208,14 @@ DECLARE_ASM_HANDLER(HandleGreaterDynPrefV8) Bind(&slowPath); { // slow path - GateRef result = CallRuntime(glue, RTSTUB_ID(GreaterDyn), { left, acc }); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8)); + GateRef result = CallRuntime(glue, RTSTUB_ID(Greater), { left, acc }); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(GREATER_IMM8_V8)); } Bind(&dispatch); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(GREATER_IMM8_V8); } -DECLARE_ASM_HANDLER(HandleGreaterEqDynPrefV8) +DECLARE_ASM_HANDLER(HandleGreaterEqImm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -1305,101 +1304,31 @@ DECLARE_ASM_HANDLER(HandleGreaterEqDynPrefV8) Bind(&slowPath); { // slow path - GateRef result = CallRuntime(glue, RTSTUB_ID(GreaterEqDyn), { left, acc }); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8)); + GateRef result = CallRuntime(glue, RTSTUB_ID(GreaterEq), { left, acc }); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(GREATEREQ_IMM8_V8)); } Bind(&dispatch); - DISPATCH_WITH_ACC(PREF_V8); -} - -DECLARE_ASM_HANDLER(SingleStepDebugging) -{ - auto env = GetEnvironment(); - DEFVARIABLE(varPc, VariableType::NATIVE_POINTER(), pc); - DEFVARIABLE(varSp, VariableType::NATIVE_POINTER(), sp); - DEFVARIABLE(varConstpool, VariableType::JS_POINTER(), constpool); - DEFVARIABLE(varProfileTypeInfo, VariableType::JS_POINTER(), profileTypeInfo); - DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); - DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); - - GateRef frame = GetFrame(*varSp); - SetPcToFrame(glue, frame, *varPc); - GateRef currentSp = *varSp; - varSp = TaggedCastToIntPtr(CallRuntime(glue, - RTSTUB_ID(JumpToCInterpreter), - { constpool, profileTypeInfo, acc, - IntToTaggedTypeNGC(hotnessCounter)})); - varPc = GetPcFromFrame(frame); - Label shouldReturn(env); - Label shouldContinue(env); - - Branch(IntPtrEqual(*varPc, IntPtr(0)), &shouldReturn, &shouldContinue); - Bind(&shouldReturn); - { - CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndReturn), { Undefined(), *varSp, currentSp }); - Return(); - } - Bind(&shouldContinue); - { - varAcc = GetAccFromFrame(frame); - GateRef function = GetFunctionFromFrame(frame); - varProfileTypeInfo = GetProfileTypeInfoFromFunction(function); - varConstpool = GetConstpoolFromFunction(function); - GateRef method = Load(VariableType::JS_ANY(), function, - IntPtr(JSFunctionBase::METHOD_OFFSET)); - varHotnessCounter = GetHotnessCounterFromMethod(method); - } - Label isException(env); - Label notException(env); - Branch(TaggedIsException(*varAcc), &isException, ¬Exception); - Bind(&isException); - DispatchLast(glue, *varSp, *varPc, *varConstpool, *varProfileTypeInfo, *varAcc, - *varHotnessCounter); - Bind(¬Exception); - DISPATCH_BAK(SSD, IntPtr(0)); -} - -DECLARE_ASM_HANDLER(BCDebuggerEntry) -{ - GateRef frame = GetFrame(sp); - SetPcToFrame(glue, frame, pc); - // NOTIFY_DEBUGGER_EVENT() - CallRuntime(glue, RTSTUB_ID(NotifyBytecodePcChanged), {}); - // goto normal handle stub - DispatchDebugger(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter); -} - -DECLARE_ASM_HANDLER(BCDebuggerExceptionEntry) -{ - DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); - varAcc = Hole(); - GateRef frame = GetFrame(sp); - SetPcToFrame(glue, frame, pc); - // NOTIFY_DEBUGGER_EVENT() - CallRuntime(glue, RTSTUB_ID(NotifyBytecodePcChanged), {}); - // goto last handle stub - DispatchDebuggerLast(glue, sp, pc, constpool, profileTypeInfo, *varAcc, hotnessCounter); + DISPATCH_WITH_ACC(GREATEREQ_IMM8_V8); } -DECLARE_ASM_HANDLER(HandleOverflow) +DECLARE_ASM_HANDLER(HandleNop) { - FatalPrint(glue, { Int32(GET_MESSAGE_STRING_ID(OPCODE_OVERFLOW)) }); - DISPATCH_BAK(OFFSET, IntPtr(0)); + DISPATCH(NOP); } -DECLARE_ASM_HANDLER(HandleLdaDynV8) +DECLARE_ASM_HANDLER(HandleLdaV8) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); GateRef vsrc = ReadInst8_0(pc); varAcc = GetVregValue(sp, ZExtInt8ToPtr(vsrc)); - DISPATCH_WITH_ACC(V8); + DISPATCH_WITH_ACC(LDA_V8); } -DECLARE_ASM_HANDLER(HandleStaDynV8) +DECLARE_ASM_HANDLER(HandleStaV8) { GateRef vdst = ReadInst8_0(pc); SetVregValue(glue, sp, ZExtInt8ToPtr(vdst), acc); - DISPATCH(V8); + DISPATCH(STA_V8); } DECLARE_ASM_HANDLER(HandleJmpImm8) @@ -1443,13 +1372,13 @@ DECLARE_ASM_HANDLER(HandleJmpImm32) DISPATCH_BAK(JUMP, SExtInt32ToPtr(offset)); } -DECLARE_ASM_HANDLER(HandleLdLexVarDynPrefImm4Imm4) +DECLARE_ASM_HANDLER(HandleLdLexVarImm4Imm4) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); - GateRef level = ZExtInt8ToInt32(ReadInst4_2(pc)); - GateRef slot = ZExtInt8ToInt32(ReadInst4_3(pc)); + GateRef level = ZExtInt8ToInt32(ReadInst4_0(pc)); + GateRef slot = ZExtInt8ToInt32(ReadInst4_1(pc)); GateRef state = GetFrame(sp); DEFVARIABLE(currentEnv, VariableType::JS_ANY(), GetEnvFromFrame(state)); DEFVARIABLE(i, VariableType::INT32(), Int32(0)); @@ -1468,16 +1397,16 @@ DECLARE_ASM_HANDLER(HandleLdLexVarDynPrefImm4Imm4) GateRef variable = GetPropertiesFromLexicalEnv(*currentEnv, slot); varAcc = variable; - DISPATCH_WITH_ACC(PREF_IMM4_IMM4); + DISPATCH_WITH_ACC(LDLEXVAR_IMM4_IMM4); } -DECLARE_ASM_HANDLER(HandleLdLexVarDynPrefImm8Imm8) +DECLARE_ASM_HANDLER(HandleLdLexVarImm8Imm8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); - GateRef level = ZExtInt8ToInt32(ReadInst8_1(pc)); - GateRef slot = ZExtInt8ToInt32(ReadInst8_2(pc)); + GateRef level = ZExtInt8ToInt32(ReadInst8_0(pc)); + GateRef slot = ZExtInt8ToInt32(ReadInst8_1(pc)); GateRef state = GetFrame(sp); DEFVARIABLE(currentEnv, VariableType::JS_ANY(), GetEnvFromFrame(state)); @@ -1496,16 +1425,16 @@ DECLARE_ASM_HANDLER(HandleLdLexVarDynPrefImm8Imm8) Bind(&afterLoop); GateRef variable = GetPropertiesFromLexicalEnv(*currentEnv, slot); varAcc = variable; - DISPATCH_WITH_ACC(PREF_IMM8_IMM8); + DISPATCH_WITH_ACC(LDLEXVAR_IMM8_IMM8); } -DECLARE_ASM_HANDLER(HandleLdLexVarDynPrefImm16Imm16) +DECLARE_ASM_HANDLER(HandleLdLexVarImm16Imm16) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); - GateRef level = ZExtInt16ToInt32(ReadInst16_1(pc)); - GateRef slot = ZExtInt16ToInt32(ReadInst16_3(pc)); + GateRef level = ZExtInt16ToInt32(ReadInst16_0(pc)); + GateRef slot = ZExtInt16ToInt32(ReadInst16_2(pc)); GateRef state = GetFrame(sp); DEFVARIABLE(currentEnv, VariableType::JS_ANY(), GetEnvFromFrame(state)); @@ -1524,15 +1453,15 @@ DECLARE_ASM_HANDLER(HandleLdLexVarDynPrefImm16Imm16) Bind(&afterLoop); GateRef variable = GetPropertiesFromLexicalEnv(*currentEnv, slot); varAcc = variable; - DISPATCH_WITH_ACC(PREF_IMM16_IMM16); + DISPATCH_WITH_ACC(LDLEXVAR_IMM16_IMM16); } -DECLARE_ASM_HANDLER(HandleStLexVarDynPrefImm4Imm4V8) +DECLARE_ASM_HANDLER(HandleStLexVarImm4Imm4V8) { auto env = GetEnvironment(); - GateRef level = ZExtInt8ToInt32(ReadInst4_2(pc)); - GateRef slot = ZExtInt8ToInt32(ReadInst4_3(pc)); - GateRef v0 = ReadInst8_2(pc); + GateRef level = ZExtInt8ToInt32(ReadInst4_0(pc)); + GateRef slot = ZExtInt8ToInt32(ReadInst4_1(pc)); + GateRef v0 = ReadInst8_1(pc); GateRef value = GetVregValue(sp, ZExtInt8ToPtr(v0)); GateRef state = GetFrame(sp); @@ -1551,15 +1480,15 @@ DECLARE_ASM_HANDLER(HandleStLexVarDynPrefImm4Imm4V8) LoopEnd(&loopHead); Bind(&afterLoop); SetPropertiesToLexicalEnv(glue, *currentEnv, slot, value); - DISPATCH(PREF_IMM4_IMM4_V8); + DISPATCH(STLEXVAR_IMM4_IMM4_V8); } -DECLARE_ASM_HANDLER(HandleStLexVarDynPrefImm8Imm8V8) +DECLARE_ASM_HANDLER(HandleStLexVarImm8Imm8V8) { auto env = GetEnvironment(); - GateRef level = ZExtInt8ToInt32(ReadInst8_1(pc)); - GateRef slot = ZExtInt8ToInt32(ReadInst8_2(pc)); - GateRef v0 = ReadInst8_3(pc); + GateRef level = ZExtInt8ToInt32(ReadInst8_0(pc)); + GateRef slot = ZExtInt8ToInt32(ReadInst8_1(pc)); + GateRef v0 = ReadInst8_2(pc); GateRef value = GetVregValue(sp, ZExtInt8ToPtr(v0)); GateRef state = GetFrame(sp); @@ -1578,15 +1507,15 @@ DECLARE_ASM_HANDLER(HandleStLexVarDynPrefImm8Imm8V8) LoopEnd(&loopHead); Bind(&afterLoop); SetPropertiesToLexicalEnv(glue, *currentEnv, slot, value); - DISPATCH(PREF_IMM8_IMM8_V8); + DISPATCH(STLEXVAR_IMM8_IMM8_V8); } -DECLARE_ASM_HANDLER(HandleStLexVarDynPrefImm16Imm16V8) +DECLARE_ASM_HANDLER(HandleStLexVarImm16Imm16V8) { auto env = GetEnvironment(); - GateRef level = ZExtInt16ToInt32(ReadInst16_1(pc)); - GateRef slot = ZExtInt16ToInt32(ReadInst16_3(pc)); - GateRef v0 = ReadInst8_5(pc); + GateRef level = ZExtInt16ToInt32(ReadInst16_0(pc)); + GateRef slot = ZExtInt16ToInt32(ReadInst16_2(pc)); + GateRef v0 = ReadInst8_4(pc); GateRef value = GetVregValue(sp, ZExtInt8ToPtr(v0)); GateRef state = GetFrame(sp); @@ -1605,10 +1534,10 @@ DECLARE_ASM_HANDLER(HandleStLexVarDynPrefImm16Imm16V8) LoopEnd(&loopHead); Bind(&afterLoop); SetPropertiesToLexicalEnv(glue, *currentEnv, slot, value); - DISPATCH(PREF_IMM16_IMM16_V8); + DISPATCH(STLEXVAR_IMM16_IMM16_V8); } -DECLARE_ASM_HANDLER(HandleIncDynPrefV8) +DECLARE_ASM_HANDLER(HandleIncImm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -1648,14 +1577,14 @@ DECLARE_ASM_HANDLER(HandleIncDynPrefV8) Bind(&slowPath); { // slow path - GateRef result = CallRuntime(glue, RTSTUB_ID(IncDyn), { value }); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8)); + GateRef result = CallRuntime(glue, RTSTUB_ID(Inc), { value }); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(INC_IMM8_V8)); } Bind(&accDispatch); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(INC_IMM8_V8); } -DECLARE_ASM_HANDLER(HandleDecDynPrefV8) +DECLARE_ASM_HANDLER(HandleDecImm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -1695,39 +1624,39 @@ DECLARE_ASM_HANDLER(HandleDecDynPrefV8) Bind(&slowPath); { // slow path - GateRef result = CallRuntime(glue, RTSTUB_ID(DecDyn), { value }); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8)); + GateRef result = CallRuntime(glue, RTSTUB_ID(Dec), { value }); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DEC_IMM8_V8)); } Bind(&accDispatch); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(DEC_IMM8_V8); } -DECLARE_ASM_HANDLER(HandleExpDynPrefV8) +DECLARE_ASM_HANDLER(HandleExpImm8V8) { GateRef v0 = ReadInst8_1(pc); GateRef base = GetVregValue(sp, ZExtInt8ToPtr(v0)); - GateRef result = CallRuntime(glue, RTSTUB_ID(ExpDyn), { base, acc }); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8)); + GateRef result = CallRuntime(glue, RTSTUB_ID(Exp), { base, acc }); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(EXP_IMM8_V8)); } -DECLARE_ASM_HANDLER(HandleIsInDynPrefV8) +DECLARE_ASM_HANDLER(HandleIsInImm8V8) { GateRef v0 = ReadInst8_1(pc); GateRef prop = GetVregValue(sp, ZExtInt8ToPtr(v0)); - GateRef result = CallRuntime(glue, RTSTUB_ID(IsInDyn), { prop, acc }); // acc is obj - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8)); + GateRef result = CallRuntime(glue, RTSTUB_ID(IsIn), { prop, acc }); // acc is obj + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(ISIN_IMM8_V8)); } -DECLARE_ASM_HANDLER(HandleInstanceOfDynPrefV8) +DECLARE_ASM_HANDLER(HandleInstanceOfImm8V8) { GateRef v0 = ReadInst8_1(pc); GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(v0)); - GateRef result = CallRuntime(glue, RTSTUB_ID(InstanceOfDyn), { obj, acc }); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8)); + GateRef result = CallRuntime(glue, RTSTUB_ID(InstanceOf), { obj, acc }); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(INSTANCEOF_IMM8_V8)); } -DECLARE_ASM_HANDLER(HandleStrictNotEqDynPrefV8) +DECLARE_ASM_HANDLER(HandleStrictNotEqImm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -1751,10 +1680,10 @@ DECLARE_ASM_HANDLER(HandleStrictNotEqDynPrefV8) Jump(&dispatch); } Bind(&dispatch); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(STRICTNOTEQ_IMM8_V8); } -DECLARE_ASM_HANDLER(HandleStrictEqDynPrefV8) +DECLARE_ASM_HANDLER(HandleStrictEqImm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -1778,15 +1707,15 @@ DECLARE_ASM_HANDLER(HandleStrictEqDynPrefV8) Jump(&dispatch); } Bind(&dispatch); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(STRICTEQ_IMM8_V8); } -DECLARE_ASM_HANDLER(HandleResumeGeneratorPrefV8) +DECLARE_ASM_HANDLER(HandleResumeGeneratorV8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); - GateRef vs = ReadInst8_1(pc); + GateRef vs = ReadInst8_0(pc); GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(vs)); Label isAsyncGeneratorObj(env); @@ -1806,15 +1735,15 @@ DECLARE_ASM_HANDLER(HandleResumeGeneratorPrefV8) Jump(&dispatch); } Bind(&dispatch); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(RESUMEGENERATOR_V8); } -DECLARE_ASM_HANDLER(HandleGetResumeModePrefV8) +DECLARE_ASM_HANDLER(HandleGetResumeModeV8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); - GateRef vs = ReadInst8_1(pc); + GateRef vs = ReadInst8_0(pc); GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(vs)); Label isAsyncGeneratorObj(env); @@ -1832,46 +1761,46 @@ DECLARE_ASM_HANDLER(HandleGetResumeModePrefV8) Jump(&dispatch); } Bind(&dispatch); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(GETRESUMEMODE_V8); } -DECLARE_ASM_HANDLER(HandleCreateGeneratorObjPrefV8) +DECLARE_ASM_HANDLER(HandleCreateGeneratorObjV8) { - GateRef v0 = ReadInst8_1(pc); + GateRef v0 = ReadInst8_0(pc); GateRef genFunc = GetVregValue(sp, ZExtInt8ToPtr(v0)); GateRef result = CallRuntime(glue, RTSTUB_ID(CreateGeneratorObj), { genFunc }); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8)); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(CREATEGENERATOROBJ_V8)); } -DECLARE_ASM_HANDLER(HandleThrowConstAssignmentPrefV8) +DECLARE_ASM_HANDLER(HandleThrowConstAssignmentV8) { - GateRef v0 = ReadInst8_1(pc); + GateRef v0 = ReadInst8_0(pc); GateRef value = GetVregValue(sp, ZExtInt8ToPtr(v0)); CallRuntime(glue, RTSTUB_ID(ThrowConstAssignment), { value }); DISPATCH_LAST(); } -DECLARE_ASM_HANDLER(HandleGetTemplateObjectPrefV8) +DECLARE_ASM_HANDLER(HandleGetTemplateObjectImm8V8) { GateRef v0 = ReadInst8_1(pc); GateRef literal = GetVregValue(sp, ZExtInt8ToPtr(v0)); GateRef result = CallRuntime(glue, RTSTUB_ID(GetTemplateObject), { literal }); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8)); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(GETTEMPLATEOBJECT_IMM8_V8)); } -DECLARE_ASM_HANDLER(HandleGetNextPropNamePrefV8) +DECLARE_ASM_HANDLER(HandleGetNextPropNameV8) { - GateRef v0 = ReadInst8_1(pc); + GateRef v0 = ReadInst8_0(pc); GateRef iter = GetVregValue(sp, ZExtInt8ToPtr(v0)); GateRef result = CallRuntime(glue, RTSTUB_ID(GetNextPropName), { iter }); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8)); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(GETNEXTPROPNAME_V8)); } -DECLARE_ASM_HANDLER(HandleThrowIfNotObjectPrefV8) +DECLARE_ASM_HANDLER(HandleThrowIfNotObjectV8) { auto env = GetEnvironment(); - GateRef v0 = ReadInst8_1(pc); + GateRef v0 = ReadInst8_0(pc); GateRef value = GetVregValue(sp, ZExtInt8ToPtr(v0)); Label isEcmaObject(env); Label notEcmaObject(env); @@ -1881,95 +1810,88 @@ DECLARE_ASM_HANDLER(HandleThrowIfNotObjectPrefV8) Branch(TaggedObjectIsEcmaObject(value), &isEcmaObject, ¬EcmaObject); Bind(&isEcmaObject); { - DISPATCH(PREF_V8); + DISPATCH(THROWIFNOTOBJECT_V8); } Bind(¬EcmaObject); CallRuntime(glue, RTSTUB_ID(ThrowIfNotObject), {}); DISPATCH_LAST(); } -DECLARE_ASM_HANDLER(HandleIterNextPrefV8) +DECLARE_ASM_HANDLER(HandleIterNextImm8V8) { GateRef v0 = ReadInst8_1(pc); GateRef iter = GetVregValue(sp, ZExtInt8ToPtr(v0)); GateRef result = CallRuntime(glue, RTSTUB_ID(IterNext), { iter }); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8)); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(ITERNEXT_IMM8_V8)); } -DECLARE_ASM_HANDLER(HandleCloseIteratorPrefV8) +DECLARE_ASM_HANDLER(HandleCloseIteratorImm8V8) { GateRef v0 = ReadInst8_1(pc); GateRef iter = GetVregValue(sp, ZExtInt8ToPtr(v0)); GateRef result = CallRuntime(glue, RTSTUB_ID(CloseIterator), { iter }); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8)); -} - -DECLARE_ASM_HANDLER(HandleCopyModulePrefV8) -{ - DISPATCH(PREF_V8); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(CLOSEITERATOR_IMM8_V8)); } -DECLARE_ASM_HANDLER(HandleSuperCallSpreadPrefV8) +DECLARE_ASM_HANDLER(HandleSuperCallSpreadImm8V8) { GateRef v0 = ReadInst8_1(pc); GateRef array = GetVregValue(sp, ZExtInt8ToPtr(v0)); GateRef result = CallRuntime(glue, RTSTUB_ID(SuperCallSpread), { acc, array }); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8)); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(SUPERCALLSPREAD_IMM8_V8)); } -DECLARE_ASM_HANDLER(HandleDelObjPropPrefV8V8) +DECLARE_ASM_HANDLER(HandleDelObjPropV8V8) { - GateRef v0 = ReadInst8_1(pc); - GateRef v1 = ReadInst8_2(pc); + GateRef v0 = ReadInst8_0(pc); + GateRef v1 = ReadInst8_1(pc); GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(v0)); GateRef prop = GetVregValue(sp, ZExtInt8ToPtr(v1)); GateRef result = CallRuntime(glue, RTSTUB_ID(DelObjProp), { obj, prop }); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8_V8)); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DELOBJPROP_V8_V8)); } -DECLARE_ASM_HANDLER(HandleNewObjSpreadDynPrefV8V8) +DECLARE_ASM_HANDLER(HandleNewObjApplyImm8V8) { GateRef v0 = ReadInst8_1(pc); - GateRef v1 = ReadInst8_2(pc); GateRef func = GetVregValue(sp, ZExtInt8ToPtr(v0)); - GateRef newTarget = GetVregValue(sp, ZExtInt8ToPtr(v1)); - GateRef result = CallRuntime(glue, RTSTUB_ID(NewObjSpreadDyn), { func, newTarget, acc }); // acc is array - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8_V8)); + GateRef result = CallRuntime(glue, RTSTUB_ID(NewObjApply), { func, acc }); // acc is array + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(NEWOBJSPREAD_IMM8_V8_V8)); } -DECLARE_ASM_HANDLER(HandleCreateIterResultObjPrefV8V8) +DECLARE_ASM_HANDLER(HandleCreateIterResultObjV8V8) { - GateRef v0 = ReadInst8_1(pc); - GateRef v1 = ReadInst8_2(pc); + GateRef v0 = ReadInst8_0(pc); + GateRef v1 = ReadInst8_1(pc); GateRef value = GetVregValue(sp, ZExtInt8ToPtr(v0)); GateRef flag = GetVregValue(sp, ZExtInt8ToPtr(v1)); GateRef result = CallRuntime(glue, RTSTUB_ID(CreateIterResultObj), { value, flag }); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8_V8)); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(CREATEITERRESULTOBJ_V8_V8)); } -DECLARE_ASM_HANDLER(HandleAsyncFunctionAwaitUncaughtPrefV8V8) +DECLARE_ASM_HANDLER(HandleAsyncFunctionAwaitUncaughtV8V8) { - GateRef v0 = ReadInst8_1(pc); - GateRef v1 = ReadInst8_2(pc); + GateRef v0 = ReadInst8_0(pc); + GateRef v1 = ReadInst8_1(pc); GateRef asyncFuncObj = GetVregValue(sp, ZExtInt8ToPtr(v0)); GateRef value = GetVregValue(sp, ZExtInt8ToPtr(v1)); GateRef result = CallRuntime(glue, RTSTUB_ID(AsyncFunctionAwaitUncaught), { asyncFuncObj, value }); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8_V8)); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(ASYNCFUNCTIONAWAITUNCAUGHT_V8_V8)); } -DECLARE_ASM_HANDLER(HandleThrowUndefinedIfHolePrefV8V8) +DECLARE_ASM_HANDLER(HandleThrowUndefinedIfHoleV8V8) { auto env = GetEnvironment(); - GateRef v0 = ReadInst8_1(pc); - GateRef v1 = ReadInst8_2(pc); + GateRef v0 = ReadInst8_0(pc); + GateRef v1 = ReadInst8_1(pc); GateRef hole = GetVregValue(sp, ZExtInt8ToPtr(v0)); Label isHole(env); Label notHole(env); Branch(TaggedIsHole(hole), &isHole, ¬Hole); Bind(¬Hole); { - DISPATCH(PREF_V8_V8); + DISPATCH(THROWUNDEFINEDIFHOLE_V8_V8); } Bind(&isHole); GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(v1)); @@ -1978,37 +1900,37 @@ DECLARE_ASM_HANDLER(HandleThrowUndefinedIfHolePrefV8V8) DISPATCH_LAST(); } -DECLARE_ASM_HANDLER(HandleCopyDataPropertiesPrefV8V8) +DECLARE_ASM_HANDLER(HandleCopyDataPropertiesV8V8) { - GateRef v0 = ReadInst8_1(pc); - GateRef v1 = ReadInst8_2(pc); + GateRef v0 = ReadInst8_0(pc); + GateRef v1 = ReadInst8_1(pc); GateRef dst = GetVregValue(sp, ZExtInt8ToPtr(v0)); GateRef src = GetVregValue(sp, ZExtInt8ToPtr(v1)); GateRef result = CallRuntime(glue, RTSTUB_ID(CopyDataProperties), { dst, src }); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8_V8)); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(COPYDATAPROPERTIES_V8_V8)); } -DECLARE_ASM_HANDLER(HandleStArraySpreadPrefV8V8) +DECLARE_ASM_HANDLER(HandleStArraySpreadV8V8) { - GateRef v0 = ReadInst8_1(pc); - GateRef v1 = ReadInst8_2(pc); + GateRef v0 = ReadInst8_0(pc); + GateRef v1 = ReadInst8_1(pc); GateRef dst = GetVregValue(sp, ZExtInt8ToPtr(v0)); GateRef index = GetVregValue(sp, ZExtInt8ToPtr(v1)); GateRef result = CallRuntime(glue, RTSTUB_ID(StArraySpread), { dst, index, acc }); // acc is res - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8_V8)); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(STARRAYSPREAD_V8_V8)); } -DECLARE_ASM_HANDLER(HandleGetIteratorNextPrefV8V8) +DECLARE_ASM_HANDLER(HandleGetIteratorNextV8V8) { - GateRef v0 = ReadInst8_1(pc); - GateRef v1 = ReadInst8_2(pc); + GateRef v0 = ReadInst8_0(pc); + GateRef v1 = ReadInst8_1(pc); GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(v0)); GateRef method = GetVregValue(sp, ZExtInt8ToPtr(v1)); GateRef result = CallRuntime(glue, RTSTUB_ID(GetIteratorNext), { obj, method }); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8_V8)); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(GETITERATORNEXT_V8_V8)); } -DECLARE_ASM_HANDLER(HandleSetObjectWithProtoPrefV8V8) +DECLARE_ASM_HANDLER(HandleSetObjectWithProtoImm8V8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -2021,10 +1943,10 @@ DECLARE_ASM_HANDLER(HandleSetObjectWithProtoPrefV8V8) Label notException(env); CHECK_EXCEPTION_WITH_JUMP(result, ¬Exception); Bind(¬Exception); - DISPATCH_WITH_ACC(PREF_V8_V8); + DISPATCH_WITH_ACC(SETOBJECTWITHPROTO_IMM8_V8_V8); } -DECLARE_ASM_HANDLER(HandleLdObjByValuePrefV8V8) +DECLARE_ASM_HANDLER(HandleLdObjByValueImm8V8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -2057,11 +1979,11 @@ DECLARE_ASM_HANDLER(HandleLdObjByValuePrefV8V8) } Bind(&checkException); { - CHECK_EXCEPTION_WITH_VARACC(*result, INT_PTR(PREF_V8_V8)); + CHECK_EXCEPTION_WITH_VARACC(*result, INT_PTR(LDOBJBYVALUE_IMM8_V8_V8)); } } -DECLARE_ASM_HANDLER(HandleStObjByValuePrefV8V8) +DECLARE_ASM_HANDLER(HandleStObjByValueImm8V8V8) { auto env = GetEnvironment(); DEFVARIABLE(result, VariableType::INT64(), Hole(VariableType::INT64())); @@ -2094,11 +2016,11 @@ DECLARE_ASM_HANDLER(HandleStObjByValuePrefV8V8) } Bind(&checkException); { - CHECK_EXCEPTION(*result, INT_PTR(PREF_V8_V8)); + CHECK_EXCEPTION(*result, INT_PTR(STOBJBYVALUE_IMM8_V8_V8)); } } -DECLARE_ASM_HANDLER(HandleStOwnByValuePrefV8V8) +DECLARE_ASM_HANDLER(HandleStOwnByValueImm8V8V8) { auto env = GetEnvironment(); @@ -2122,26 +2044,26 @@ DECLARE_ASM_HANDLER(HandleStOwnByValuePrefV8V8) Label notHole(env); Branch(TaggedIsHole(result), &slowPath, ¬Hole); Bind(¬Hole); - CHECK_EXCEPTION(result, INT_PTR(PREF_V8_V8)); + CHECK_EXCEPTION(result, INT_PTR(STOWNBYVALUE_IMM8_V8_V8)); } Bind(&slowPath); { GateRef result = CallRuntime(glue, RTSTUB_ID(StOwnByValue), { receiver, propKey, acc }); - CHECK_EXCEPTION(result, INT_PTR(PREF_V8_V8)); + CHECK_EXCEPTION(result, INT_PTR(STOWNBYVALUE_IMM8_V8_V8)); } } -DECLARE_ASM_HANDLER(HandleLdSuperByValuePrefV8V8) +DECLARE_ASM_HANDLER(HandleLdSuperByValueImm8V8V8) { GateRef v0 = ReadInst8_1(pc); GateRef v1 = ReadInst8_2(pc); GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); GateRef propKey = GetVregValue(sp, ZExtInt8ToPtr(v1)); GateRef result = CallRuntime(glue, RTSTUB_ID(LdSuperByValue), { receiver, propKey }); // sp for thisFunc - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8_V8)); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(LDSUPERBYVALUE_IMM8_V8_V8)); } -DECLARE_ASM_HANDLER(HandleStSuperByValuePrefV8V8) +DECLARE_ASM_HANDLER(HandleStSuperByValueImm8V8V8) { GateRef v0 = ReadInst8_1(pc); GateRef v1 = ReadInst8_2(pc); @@ -2149,32 +2071,32 @@ DECLARE_ASM_HANDLER(HandleStSuperByValuePrefV8V8) GateRef propKey = GetVregValue(sp, ZExtInt8ToPtr(v1)); // acc is value, sp for thisFunc GateRef result = CallRuntime(glue, RTSTUB_ID(StSuperByValue), { receiver, propKey, acc }); - CHECK_EXCEPTION(result, INT_PTR(PREF_V8_V8)); + CHECK_EXCEPTION(result, INT_PTR(STSUPERBYVALUE_IMM8_V8_V8)); } -DECLARE_ASM_HANDLER(HandleLdSuperByNamePrefId32V8) +DECLARE_ASM_HANDLER(HandleLdSuperByNameImm8Id16V8) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); - GateRef stringId = ReadInst32_1(pc); - GateRef v0 = ReadInst8_5(pc); + GateRef stringId = ReadInst16_1(pc); + GateRef v0 = ReadInst8_3(pc); GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); GateRef propKey = GetObjectFromConstPool(constpool, stringId); GateRef result = CallRuntime(glue, RTSTUB_ID(LdSuperByValue), { receiver, propKey }); - CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(PREF_ID32_V8)); + CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDSUPERBYNAME_IMM8_ID16_V8)); } -DECLARE_ASM_HANDLER(HandleStSuperByNamePrefId32V8) +DECLARE_ASM_HANDLER(HandleStSuperByNameImm8Id16V8) { - GateRef stringId = ReadInst32_1(pc); - GateRef v0 = ReadInst8_5(pc); + GateRef stringId = ReadInst16_1(pc); + GateRef v0 = ReadInst8_3(pc); GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); GateRef propKey = GetObjectFromConstPool(constpool, stringId); GateRef result = CallRuntime(glue, RTSTUB_ID(StSuperByValue), { receiver, propKey, acc }); - CHECK_EXCEPTION(result, INT_PTR(PREF_ID32_V8)); + CHECK_EXCEPTION(result, INT_PTR(STSUPERBYNAME_IMM8_ID16_V8)); } -DECLARE_ASM_HANDLER(HandleLdObjByIndexPrefV8Imm32) +DECLARE_ASM_HANDLER(HandleLdObjByIndexImm8V8Imm32) { auto env = GetEnvironment(); @@ -2190,17 +2112,17 @@ DECLARE_ASM_HANDLER(HandleLdObjByIndexPrefV8Imm32) Label notHole(env); Branch(TaggedIsHole(result), &slowPath, ¬Hole); Bind(¬Hole); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8_IMM32)); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(LDOBJBYINDEX_IMM8_V8_IMM32)); } Bind(&slowPath); { GateRef result = CallRuntime(glue, RTSTUB_ID(LdObjByIndex), { receiver, IntToTaggedTypeNGC(index), TaggedFalse(), Undefined() }); - CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(PREF_V8_IMM32)); + CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(LDOBJBYINDEX_IMM8_V8_IMM32)); } } -DECLARE_ASM_HANDLER(HandleStObjByIndexPrefV8Imm32) +DECLARE_ASM_HANDLER(HandleStObjByIndexImm8V8Imm32) { auto env = GetEnvironment(); @@ -2216,17 +2138,17 @@ DECLARE_ASM_HANDLER(HandleStObjByIndexPrefV8Imm32) Label notHole(env); Branch(TaggedIsHole(result), &slowPath, ¬Hole); Bind(¬Hole); - CHECK_EXCEPTION(result, INT_PTR(PREF_V8_IMM32)); + CHECK_EXCEPTION(result, INT_PTR(STOBJBYINDEX_IMM8_V8_IMM32)); } Bind(&slowPath); { GateRef result = CallRuntime(glue, RTSTUB_ID(StObjByIndex), { receiver, IntToTaggedTypeNGC(index), acc }); - CHECK_EXCEPTION(result, INT_PTR(PREF_V8_IMM32)); + CHECK_EXCEPTION(result, INT_PTR(STOBJBYINDEX_IMM8_V8_IMM32)); } } -DECLARE_ASM_HANDLER(HandleStOwnByIndexPrefV8Imm32) +DECLARE_ASM_HANDLER(HandleStOwnByIndexImm8V8Imm32) { auto env = GetEnvironment(); @@ -2249,49 +2171,49 @@ DECLARE_ASM_HANDLER(HandleStOwnByIndexPrefV8Imm32) Label notHole(env); Branch(TaggedIsHole(result), &slowPath, ¬Hole); Bind(¬Hole); - CHECK_EXCEPTION(result, INT_PTR(PREF_V8_IMM32)); + CHECK_EXCEPTION(result, INT_PTR(STOWNBYINDEX_IMM8_V8_IMM32)); } Bind(&slowPath); { GateRef result = CallRuntime(glue, RTSTUB_ID(StOwnByIndex), { receiver, IntToTaggedTypeNGC(index), acc }); - CHECK_EXCEPTION(result, INT_PTR(PREF_V8_IMM32)); + CHECK_EXCEPTION(result, INT_PTR(STOWNBYINDEX_IMM8_V8_IMM32)); } } -DECLARE_ASM_HANDLER(HandleStConstToGlobalRecordPrefId32) +DECLARE_ASM_HANDLER(HandleStConstToGlobalRecordId16) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); - GateRef stringId = ReadInst32_1(pc); + GateRef stringId = ReadInst16_0(pc); GateRef propKey = GetValueFromTaggedArray(VariableType::JS_ANY(), constpool, stringId); GateRef result = CallRuntime(glue, RTSTUB_ID(StGlobalRecord), { propKey, *varAcc, TaggedTrue() }); - CHECK_EXCEPTION_VARACC(result, INT_PTR(PREF_ID32)); + CHECK_EXCEPTION_VARACC(result, INT_PTR(STCONSTTOGLOBALRECORD_ID16)); } -DECLARE_ASM_HANDLER(HandleStLetToGlobalRecordPrefId32) +DECLARE_ASM_HANDLER(HandleStLetToGlobalRecordId16) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); - GateRef stringId = ReadInst32_1(pc); + GateRef stringId = ReadInst16_0(pc); GateRef propKey = GetValueFromTaggedArray(VariableType::JS_ANY(), constpool, stringId); GateRef result = CallRuntime(glue, RTSTUB_ID(StGlobalRecord), { propKey, *varAcc, TaggedFalse() }); - CHECK_EXCEPTION_VARACC(result, INT_PTR(PREF_ID32)); + CHECK_EXCEPTION_VARACC(result, INT_PTR(STLETTOGLOBALRECORD_ID16)); } -DECLARE_ASM_HANDLER(HandleStClassToGlobalRecordPrefId32) +DECLARE_ASM_HANDLER(HandleStClassToGlobalRecordId16) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); - GateRef stringId = ReadInst32_1(pc); + GateRef stringId = ReadInst16_0(pc); GateRef propKey = GetValueFromTaggedArray(VariableType::JS_ANY(), constpool, stringId); GateRef result = CallRuntime(glue, RTSTUB_ID(StGlobalRecord), { propKey, *varAcc, TaggedFalse() }); - CHECK_EXCEPTION_VARACC(result, INT_PTR(PREF_ID32)); + CHECK_EXCEPTION_VARACC(result, INT_PTR(STCLASSTOGLOBALRECORD_ID16)); } -DECLARE_ASM_HANDLER(HandleNegDynPrefV8) +DECLARE_ASM_HANDLER(HandleNegImm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -2311,7 +2233,7 @@ DECLARE_ASM_HANDLER(HandleNegDynPrefV8) Branch(Int32Equal(valueInt, Int32(0)), &valueIsZero, &valueNotZero); Bind(&valueIsZero); { - // Format::PREF_V8： size = 3 + // Format::IMM8_V8： size = 3 varAcc = DoubleBuildTaggedWithNoGC(Double(-0.0)); Jump(&accDispatch); } @@ -2335,16 +2257,16 @@ DECLARE_ASM_HANDLER(HandleNegDynPrefV8) Bind(&valueNotDouble); { // slow path - GateRef result = CallRuntime(glue, RTSTUB_ID(NegDyn), { value }); - CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(PREF_V8)); + GateRef result = CallRuntime(glue, RTSTUB_ID(Neg), { value }); + CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(NEG_IMM8_V8)); } } Bind(&accDispatch); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(NEG_IMM8_V8); } -DECLARE_ASM_HANDLER(HandleNotDynPrefV8) +DECLARE_ASM_HANDLER(HandleNotImm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -2377,15 +2299,15 @@ DECLARE_ASM_HANDLER(HandleNotDynPrefV8) Bind(&numberNotDouble); { // slow path - GateRef result = CallRuntime(glue, RTSTUB_ID(NotDyn), { value }); - CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(PREF_V8)); + GateRef result = CallRuntime(glue, RTSTUB_ID(Not), { value }); + CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(NOT_IMM8_V8)); } } Bind(&accDispatch); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(NOT_IMM8_V8); } -DECLARE_ASM_HANDLER(HandleAnd2DynPrefV8) +DECLARE_ASM_HANDLER(HandleAnd2Imm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -2454,18 +2376,18 @@ DECLARE_ASM_HANDLER(HandleAnd2DynPrefV8) // slow path Bind(&leftNotNumberOrRightNotNumber); { - GateRef taggedNumber = CallRuntime(glue, RTSTUB_ID(And2Dyn), { left, right }); - CHECK_EXCEPTION_WITH_VARACC(taggedNumber, INT_PTR(PREF_V8)); + GateRef taggedNumber = CallRuntime(glue, RTSTUB_ID(And2), { left, right }); + CHECK_EXCEPTION_WITH_VARACC(taggedNumber, INT_PTR(AND2_IMM8_V8)); } Bind(&accDispatch); { GateRef ret = Int32And(*opNumber0, *opNumber1); varAcc = IntToTaggedNGC(ret); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(AND2_IMM8_V8); } } -DECLARE_ASM_HANDLER(HandleOr2DynPrefV8) +DECLARE_ASM_HANDLER(HandleOr2Imm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -2534,18 +2456,18 @@ DECLARE_ASM_HANDLER(HandleOr2DynPrefV8) // slow path Bind(&leftNotNumberOrRightNotNumber); { - GateRef taggedNumber = CallRuntime(glue, RTSTUB_ID(Or2Dyn), { left, right }); - CHECK_EXCEPTION_WITH_VARACC(taggedNumber, INT_PTR(PREF_V8)); + GateRef taggedNumber = CallRuntime(glue, RTSTUB_ID(Or2), { left, right }); + CHECK_EXCEPTION_WITH_VARACC(taggedNumber, INT_PTR(OR2_IMM8_V8)); } Bind(&accDispatch); { GateRef ret = Int32Or(*opNumber0, *opNumber1); varAcc = IntToTaggedNGC(ret); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(OR2_IMM8_V8); } } -DECLARE_ASM_HANDLER(HandleXOr2DynPrefV8) +DECLARE_ASM_HANDLER(HandleXOr2Imm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -2614,18 +2536,18 @@ DECLARE_ASM_HANDLER(HandleXOr2DynPrefV8) // slow path Bind(&leftNotNumberOrRightNotNumber); { - GateRef taggedNumber = CallRuntime(glue, RTSTUB_ID(Xor2Dyn), { left, right }); - CHECK_EXCEPTION_WITH_VARACC(taggedNumber, INT_PTR(PREF_V8)); + GateRef taggedNumber = CallRuntime(glue, RTSTUB_ID(Xor2), { left, right }); + CHECK_EXCEPTION_WITH_VARACC(taggedNumber, INT_PTR(XOR2_IMM8_V8)); } Bind(&accDispatch); { GateRef ret = Int32Xor(*opNumber0, *opNumber1); varAcc = IntToTaggedNGC(ret); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(XOR2_IMM8_V8); } } -DECLARE_ASM_HANDLER(HandleAshr2DynPrefV8) +DECLARE_ASM_HANDLER(HandleAshr2Imm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -2694,19 +2616,19 @@ DECLARE_ASM_HANDLER(HandleAshr2DynPrefV8) // slow path Bind(&leftNotNumberOrRightNotNumber); { - GateRef taggedNumber = CallRuntime(glue, RTSTUB_ID(Ashr2Dyn), { left, right }); - CHECK_EXCEPTION_WITH_VARACC(taggedNumber, INT_PTR(PREF_V8)); + GateRef taggedNumber = CallRuntime(glue, RTSTUB_ID(Ashr2), { left, right }); + CHECK_EXCEPTION_WITH_VARACC(taggedNumber, INT_PTR(ASHR2_IMM8_V8)); } Bind(&accDispatch); { GateRef shift = Int32And(*opNumber1, Int32(0x1f)); GateRef ret = Int32ASR(*opNumber0, shift); varAcc = IntToTaggedNGC(ret); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(ASHR2_IMM8_V8); } } -DECLARE_ASM_HANDLER(HandleShr2DynPrefV8) +DECLARE_ASM_HANDLER(HandleShr2Imm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -2778,8 +2700,8 @@ DECLARE_ASM_HANDLER(HandleShr2DynPrefV8) // slow path Bind(&leftNotNumberOrRightNotNumber); { - GateRef taggedNumber = CallRuntime(glue, RTSTUB_ID(Shr2Dyn), { left, right }); - CHECK_EXCEPTION_WITH_VARACC(taggedNumber, INT_PTR(PREF_V8)); + GateRef taggedNumber = CallRuntime(glue, RTSTUB_ID(Shr2), { left, right }); + CHECK_EXCEPTION_WITH_VARACC(taggedNumber, INT_PTR(SHR2_IMM8_V8)); } Bind(&doShr); { @@ -2800,11 +2722,11 @@ DECLARE_ASM_HANDLER(HandleShr2DynPrefV8) } Bind(&accDispatch); { - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(SHR2_IMM8_V8); } } -DECLARE_ASM_HANDLER(HandleShl2DynPrefV8) +DECLARE_ASM_HANDLER(HandleShl2Imm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -2873,19 +2795,19 @@ DECLARE_ASM_HANDLER(HandleShl2DynPrefV8) // slow path Bind(&leftNotNumberOrRightNotNumber); { - GateRef taggedNumber = CallRuntime(glue, RTSTUB_ID(Shl2Dyn), { left, right }); - CHECK_EXCEPTION_WITH_VARACC(taggedNumber, INT_PTR(PREF_V8)); + GateRef taggedNumber = CallRuntime(glue, RTSTUB_ID(Shl2), { left, right }); + CHECK_EXCEPTION_WITH_VARACC(taggedNumber, INT_PTR(SHL2_IMM8_V8)); } Bind(&accDispatch); { GateRef shift = Int32And(*opNumber1, Int32(0x1f)); GateRef ret = Int32LSL(*opNumber0, shift); varAcc = IntToTaggedNGC(ret); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(SHL2_IMM8_V8); } } -DECLARE_ASM_HANDLER(HandleDefineClassWithBufferPrefId16Imm16Imm16V8V8) +DECLARE_ASM_HANDLER(HandleDefineClassWithBufferImm8Id16Imm16Imm16V8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -2915,10 +2837,10 @@ DECLARE_ASM_HANDLER(HandleDefineClassWithBufferPrefId16Imm16Imm16V8V8) SetModuleToFunction(glue, res, GetModuleFromFunction(currentFunc)); CallRuntime(glue, RTSTUB_ID(SetClassConstructorLength), { res, Int16ToTaggedTypeNGC(length) }); varAcc = res; - DISPATCH_WITH_ACC(PREF_ID16_IMM16_IMM16_V8_V8); + DISPATCH_WITH_ACC(DEFINECLASSWITHBUFFER_IMM8_ID16_IMM16_IMM16_V8_V8); } -DECLARE_ASM_HANDLER(HandleLdObjByNamePrefId32V8) +DECLARE_ASM_HANDLER(HandleLdObjByNameImm8Id16V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -2929,7 +2851,7 @@ DECLARE_ASM_HANDLER(HandleLdObjByNamePrefId32V8) Label slowPath(env); GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); - GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_5(pc))); + GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); GateRef value = 0; ICStubBuilder builder(this); builder.SetParameters(glue, receiver, profileTypeInfo, value, slotId); @@ -2941,7 +2863,7 @@ DECLARE_ASM_HANDLER(HandleLdObjByNamePrefId32V8) } Bind(&slowPath); { - GateRef stringId = ReadInst32_1(pc); + GateRef stringId = ReadInst16_1(pc); GateRef propKey = GetValueFromTaggedArray(VariableType::JS_ANY(), constpool, stringId); result = CallRuntime(glue, RTSTUB_ID(LoadICByName), { profileTypeInfo, receiver, propKey, IntToTaggedTypeNGC(slotId) }); @@ -2949,15 +2871,15 @@ DECLARE_ASM_HANDLER(HandleLdObjByNamePrefId32V8) } Bind(&checkException); { - CHECK_EXCEPTION_WITH_VARACC(*result, INT_PTR(PREF_ID32_V8)); + CHECK_EXCEPTION_WITH_VARACC(*result, INT_PTR(LDOBJBYNAME_IMM8_ID16_V8)); } } -DECLARE_ASM_HANDLER(HandleStObjByNamePrefId32V8) +DECLARE_ASM_HANDLER(HandleStObjByNameImm8Id16V8) { auto env = GetEnvironment(); - GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_5(pc))); + GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); DEFVARIABLE(result, VariableType::INT64(), Hole(VariableType::INT64())); @@ -2970,14 +2892,14 @@ DECLARE_ASM_HANDLER(HandleStObjByNamePrefId32V8) builder.StoreICByName(&result, &tryFastPath, &slowPath, &checkException); Bind(&tryFastPath); { - GateRef stringId = ReadInst32_1(pc); + GateRef stringId = ReadInst16_1(pc); GateRef propKey = GetValueFromTaggedArray(VariableType::JS_ANY(), constpool, stringId); result = SetPropertyByName(glue, receiver, propKey, acc, false); Branch(TaggedIsHole(*result), &slowPath, &checkException); } Bind(&slowPath); { - GateRef stringId = ReadInst32_1(pc); + GateRef stringId = ReadInst16_1(pc); GateRef propKey = GetValueFromTaggedArray(VariableType::JS_ANY(), constpool, stringId); GateRef ret = CallRuntime(glue, RTSTUB_ID(StoreICByName), { profileTypeInfo, receiver, propKey, acc, IntToTaggedTypeNGC(slotId) }); @@ -2986,11 +2908,11 @@ DECLARE_ASM_HANDLER(HandleStObjByNamePrefId32V8) } Bind(&checkException); { - CHECK_EXCEPTION(*result, INT_PTR(PREF_ID32_V8)); + CHECK_EXCEPTION(*result, INT_PTR(STOBJBYNAME_IMM8_ID16_V8)); } } -DECLARE_ASM_HANDLER(HandleStOwnByValueWithNameSetPrefV8V8) +DECLARE_ASM_HANDLER(HandleStOwnByValueWithNameSetImm8V8V8) { auto env = GetEnvironment(); GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); @@ -3019,7 +2941,7 @@ DECLARE_ASM_HANDLER(HandleStOwnByValueWithNameSetPrefV8V8) CHECK_EXCEPTION_WITH_JUMP(res, ¬Exception); Bind(¬Exception); CallRuntime(glue, RTSTUB_ID(SetFunctionNameNoPrefix), { acc, propKey }); - DISPATCH(PREF_V8_V8); + DISPATCH(STOWNBYVALUEWITHNAMESET_IMM8_V8_V8); } } } @@ -3029,16 +2951,16 @@ DECLARE_ASM_HANDLER(HandleStOwnByValueWithNameSetPrefV8V8) GateRef res = CallRuntime(glue, RTSTUB_ID(StOwnByValueWithNameSet), { receiver, propKey, acc }); CHECK_EXCEPTION_WITH_JUMP(res, ¬Exception1); Bind(¬Exception1); - DISPATCH(PREF_V8_V8); + DISPATCH(STOWNBYVALUEWITHNAMESET_IMM8_V8_V8); } } -DECLARE_ASM_HANDLER(HandleStOwnByNamePrefId32V8) +DECLARE_ASM_HANDLER(HandleStOwnByNameImm8Id16V8) { auto env = GetEnvironment(); - GateRef stringId = ReadInst32_1(pc); + GateRef stringId = ReadInst16_1(pc); GateRef propKey = GetValueFromTaggedArray(VariableType::JS_ANY(), constpool, stringId); - GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_5(pc))); + GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); DEFVARIABLE(result, VariableType::INT64(), Hole(VariableType::INT64())); Label checkResult(env); @@ -3067,15 +2989,15 @@ DECLARE_ASM_HANDLER(HandleStOwnByNamePrefId32V8) } Bind(&checkResult); { - CHECK_EXCEPTION(*result, INT_PTR(PREF_ID32_V8)); + CHECK_EXCEPTION(*result, INT_PTR(STOWNBYNAME_IMM8_ID16_V8)); } } -DECLARE_ASM_HANDLER(HandleStOwnByNameWithNameSetPrefId32V8) +DECLARE_ASM_HANDLER(HandleStOwnByNameWithNameSetImm8Id16V8) { auto env = GetEnvironment(); - GateRef stringId = ReadInst32_1(pc); - GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_5(pc))); + GateRef stringId = ReadInst16_1(pc); + GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); GateRef propKey = GetValueFromTaggedArray(VariableType::JS_ANY(), constpool, stringId); Label isJSObject(env); Label notJSObject(env); @@ -3100,7 +3022,7 @@ DECLARE_ASM_HANDLER(HandleStOwnByNameWithNameSetPrefId32V8) CHECK_EXCEPTION_WITH_JUMP(res, ¬Exception); Bind(¬Exception); CallRuntime(glue, RTSTUB_ID(SetFunctionNameNoPrefix), { acc, propKey }); - DISPATCH(PREF_ID32_V8); + DISPATCH(STOWNBYNAMEWITHNAMESET_IMM8_ID16_V8); } } } @@ -3110,16 +3032,16 @@ DECLARE_ASM_HANDLER(HandleStOwnByNameWithNameSetPrefId32V8) GateRef res = CallRuntime(glue, RTSTUB_ID(StOwnByNameWithNameSet), { receiver, propKey, acc }); CHECK_EXCEPTION_WITH_JUMP(res, ¬Exception1); Bind(¬Exception1); - DISPATCH(PREF_ID32_V8); + DISPATCH(STOWNBYNAMEWITHNAMESET_IMM8_ID16_V8); } } -DECLARE_ASM_HANDLER(HandleLdFunctionPref) +DECLARE_ASM_HANDLER(HandleLdThisFunction) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); varAcc = GetFunctionFromFrame(GetFrame(sp)); - DISPATCH_WITH_ACC(PREF_NONE); + DISPATCH_WITH_ACC(LDFUNCTION); } DECLARE_ASM_HANDLER(HandleMovV4V4) @@ -3128,52 +3050,52 @@ DECLARE_ASM_HANDLER(HandleMovV4V4) GateRef vsrc = ZExtInt8ToPtr(ReadInst4_1(pc)); GateRef value = GetVregValue(sp, vsrc); SetVregValue(glue, sp, vdst, value); - DISPATCH(V4_V4); + DISPATCH(MOV_V4_V4); } -DECLARE_ASM_HANDLER(HandleMovDynV8V8) +DECLARE_ASM_HANDLER(HandleMovV8V8) { GateRef vdst = ZExtInt8ToPtr(ReadInst8_0(pc)); GateRef vsrc = ZExtInt8ToPtr(ReadInst8_1(pc)); GateRef value = GetVregValue(sp, vsrc); SetVregValue(glue, sp, vdst, value); - DISPATCH(V8_V8); + DISPATCH(MOV_V8_V8); } -DECLARE_ASM_HANDLER(HandleMovDynV16V16) +DECLARE_ASM_HANDLER(HandleMovV16V16) { GateRef vdst = ZExtInt16ToPtr(ReadInst16_0(pc)); GateRef vsrc = ZExtInt16ToPtr(ReadInst16_2(pc)); GateRef value = GetVregValue(sp, vsrc); SetVregValue(glue, sp, vdst, value); - DISPATCH(V16_V16); + DISPATCH(MOV_V16_V16); } -DECLARE_ASM_HANDLER(HandleLdaStrId32) +DECLARE_ASM_HANDLER(HandleLdaStrId16) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); - GateRef stringId = ReadInst32_0(pc); + GateRef stringId = ReadInst16_0(pc); varAcc = GetValueFromTaggedArray(VariableType::JS_ANY(), constpool, stringId); - DISPATCH_WITH_ACC(ID32); + DISPATCH_WITH_ACC(LDA_STR_ID16); } -DECLARE_ASM_HANDLER(HandleLdaiDynImm32) +DECLARE_ASM_HANDLER(HandleLdaiImm32) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); GateRef imm = ReadInst32_0(pc); varAcc = IntToTaggedNGC(imm); - DISPATCH_WITH_ACC(IMM32); + DISPATCH_WITH_ACC(LDAI_IMM32); } -DECLARE_ASM_HANDLER(HandleFldaiDynImm64) +DECLARE_ASM_HANDLER(HandleFldaiImm64) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); GateRef imm = CastInt64ToFloat64(ReadInst64_0(pc)); varAcc = DoubleBuildTaggedWithNoGC(imm); - DISPATCH_WITH_ACC(IMM64); + DISPATCH_WITH_ACC(FLDAI_IMM64); } DECLARE_ASM_HANDLER(HandleJeqzImm8) @@ -3215,7 +3137,7 @@ DECLARE_ASM_HANDLER(HandleJeqzImm8) DISPATCH_BAK(JUMP, SExtInt32ToPtr(offset)); } Bind(&last); - DISPATCH_BAK(JUMP, INT_PTR(PREF_NONE)); + DISPATCH_BAK(JUMP, INT_PTR(JEQZ_IMM8)); } DECLARE_ASM_HANDLER(HandleJeqzImm16) @@ -3257,7 +3179,7 @@ DECLARE_ASM_HANDLER(HandleJeqzImm16) DISPATCH_BAK(JUMP, SExtInt32ToPtr(offset)); } Bind(&last); - DISPATCH_BAK(JUMP, INT_PTR(IMM16)); + DISPATCH_BAK(JUMP, INT_PTR(JEQZ_IMM16)); } DECLARE_ASM_HANDLER(HandleJnezImm8) @@ -3299,7 +3221,7 @@ DECLARE_ASM_HANDLER(HandleJnezImm8) DISPATCH_BAK(JUMP, SExtInt32ToPtr(offset)); } Bind(&last); - DISPATCH_BAK(JUMP, INT_PTR(PREF_NONE)); + DISPATCH_BAK(JUMP, INT_PTR(JNEZ_IMM8)); } DECLARE_ASM_HANDLER(HandleJnezImm16) @@ -3341,10 +3263,10 @@ DECLARE_ASM_HANDLER(HandleJnezImm16) DISPATCH_BAK(JUMP, SExtInt32ToPtr(offset)); } Bind(&last); - DISPATCH_BAK(JUMP, INT_PTR(IMM16)); + DISPATCH_BAK(JUMP, INT_PTR(JNEZ_IMM16)); } -DECLARE_ASM_HANDLER(HandleReturnDyn) +DECLARE_ASM_HANDLER(HandleReturn) { auto env = GetEnvironment(); DEFVARIABLE(varPc, VariableType::NATIVE_POINTER(), pc); @@ -3403,7 +3325,7 @@ DECLARE_ASM_HANDLER(HandleReturnDyn) } } -DECLARE_ASM_HANDLER(HandleReturnUndefinedPref) +DECLARE_ASM_HANDLER(HandleReturnUndefined) { auto env = GetEnvironment(); DEFVARIABLE(varPc, VariableType::NATIVE_POINTER(), pc); @@ -3464,7 +3386,7 @@ DECLARE_ASM_HANDLER(HandleReturnUndefinedPref) } } -DECLARE_ASM_HANDLER(HandleSuspendGeneratorPrefV8V8) +DECLARE_ASM_HANDLER(HandleSuspendGeneratorV8V8) { auto env = GetEnvironment(); DEFVARIABLE(varPc, VariableType::NATIVE_POINTER(), pc); @@ -3481,8 +3403,8 @@ DECLARE_ASM_HANDLER(HandleSuspendGeneratorPrefV8V8) Label dispatch(env); Label slowPath(env); - GateRef genObj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); - GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); + GateRef genObj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_0(pc))); + GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); GateRef frame = GetFrame(*varSp); GateRef res = CallRuntime(glue, RTSTUB_ID(SuspendGenerator), { genObj, value }); Label isException(env); @@ -3536,86 +3458,46 @@ DECLARE_ASM_HANDLER(HandleSuspendGeneratorPrefV8V8) } } -DECLARE_ASM_HANDLER(ExceptionHandler) +DECLARE_ASM_HANDLER(HandleGetModuleNamespaceId16) { - auto env = GetEnvironment(); - DEFVARIABLE(varPc, VariableType::NATIVE_POINTER(), pc); - DEFVARIABLE(varSp, VariableType::NATIVE_POINTER(), sp); - DEFVARIABLE(varConstpool, VariableType::JS_POINTER(), constpool); - DEFVARIABLE(varProfileTypeInfo, VariableType::JS_POINTER(), profileTypeInfo); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); - DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); - Label pcIsInvalid(env); - Label pcNotInvalid(env); - GateRef exceptionOffset = IntPtr(JSThread::GlueData::GetExceptionOffset(env->IsArch32Bit())); - GateRef exception = Load(VariableType::JS_ANY(), glue, exceptionOffset); - varPc = TaggedCastToIntPtr(CallRuntime(glue, RTSTUB_ID(UpFrame), {})); - varSp = GetCurrentFrame(glue); - Branch(IntPtrEqual(*varPc, IntPtr(0)), &pcIsInvalid, &pcNotInvalid); - Bind(&pcIsInvalid); - { - CallNGCRuntime(glue, RTSTUB_ID(ResumeUncaughtFrameAndReturn), { glue, *varSp, *varAcc }); - Return(); - } - Bind(&pcNotInvalid); - { - varAcc = exception; - // clear exception - Store(VariableType::INT64(), glue, glue, exceptionOffset, Hole()); - GateRef function = GetFunctionFromFrame(GetFrame(*varSp)); - varConstpool = GetConstpoolFromFunction(function); - varProfileTypeInfo = GetProfileTypeInfoFromFunction(function); - GateRef method = Load(VariableType::JS_ANY(), function, - IntPtr(JSFunctionBase::METHOD_OFFSET)); - varHotnessCounter = GetHotnessCounterFromMethod(method); - CallNGCRuntime(glue, RTSTUB_ID(ResumeCaughtFrameAndDispatch), { - glue, *varSp, *varPc, *varConstpool, - *varProfileTypeInfo, *varAcc, *varHotnessCounter}); - Return(); - } -} - -DECLARE_ASM_HANDLER(HandleGetModuleNamespacePrefId32) -{ - DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); - - GateRef stringId = ReadInst32_1(pc); + GateRef stringId = ReadInst16_0(pc); GateRef prop = GetObjectFromConstPool(constpool, stringId); GateRef moduleRef = CallRuntime(glue, RTSTUB_ID(GetModuleNamespace), { prop }); varAcc = moduleRef; - DISPATCH_WITH_ACC(PREF_ID32); + DISPATCH_WITH_ACC(GETMODULENAMESPACE_ID16); } -DECLARE_ASM_HANDLER(HandleStModuleVarPrefId32) +DECLARE_ASM_HANDLER(HandleStModuleVarId16) { - GateRef stringId = ReadInst32_1(pc); + GateRef stringId = ReadInst16_0(pc); GateRef prop = GetObjectFromConstPool(constpool, stringId); GateRef value = acc; CallRuntime(glue, RTSTUB_ID(StModuleVar), { prop, value }); - DISPATCH(PREF_ID32); + DISPATCH(STMODULEVAR_ID16); } -DECLARE_ASM_HANDLER(HandleLdModuleVarPrefId32Imm8) +DECLARE_ASM_HANDLER(HandleLdModuleVarId16Imm8) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); - GateRef stringId = ReadInst32_1(pc); - GateRef flag = ReadInst8_5(pc); + GateRef stringId = ReadInst16_0(pc); + GateRef flag = ReadInst8_2(pc); GateRef key = GetObjectFromConstPool(constpool, stringId); GateRef innerFlag = ZExtInt8ToInt32(flag); GateRef moduleVar = CallRuntime(glue, RTSTUB_ID(LdModuleVar), { key, IntToTaggedTypeNGC(innerFlag) }); varAcc = moduleVar; - DISPATCH_WITH_ACC(PREF_ID32_IMM8); + DISPATCH_WITH_ACC(LDMODULEVAR_ID16_IMM8); } -DECLARE_ASM_HANDLER(HandleTryLdGlobalByNamePrefId32) +DECLARE_ASM_HANDLER(HandleTryLdGlobalByNameImm8Id16) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); - GateRef stringId = ReadInst32_1(pc); + GateRef stringId = ReadInst16_1(pc); GateRef prop = GetObjectFromConstPool(constpool, stringId); Label dispatch(env); @@ -3651,7 +3533,7 @@ DECLARE_ASM_HANDLER(HandleTryLdGlobalByNamePrefId32) } Bind(&icResultCheck); { - CHECK_EXCEPTION_WITH_VARACC(*icResult, INT_PTR(PREF_ID32)); + CHECK_EXCEPTION_WITH_VARACC(*icResult, INT_PTR(TRYLDGLOBALBYNAME_IMM8_ID16)); } } Bind(&icNotAvailable); @@ -3671,7 +3553,7 @@ DECLARE_ASM_HANDLER(HandleTryLdGlobalByNamePrefId32) Bind(&slowPath); { GateRef slowResult = CallRuntime(glue, RTSTUB_ID(TryLdGlobalByName), { prop }); - CHECK_EXCEPTION_WITH_VARACC(slowResult, INT_PTR(PREF_ID32)); + CHECK_EXCEPTION_WITH_VARACC(slowResult, INT_PTR(TRYLDGLOBALBYNAME_IMM8_ID16)); } Bind(&isFoundInGlobal); { @@ -3686,13 +3568,13 @@ DECLARE_ASM_HANDLER(HandleTryLdGlobalByNamePrefId32) } } Bind(&dispatch); - DISPATCH_WITH_ACC(PREF_ID32); + DISPATCH_WITH_ACC(TRYLDGLOBALBYNAME_IMM8_ID16); } -DECLARE_ASM_HANDLER(HandleTryStGlobalByNamePrefId32) +DECLARE_ASM_HANDLER(HandleTryStGlobalByNameImm8Id16) { auto env = GetEnvironment(); - GateRef stringId = ReadInst32_1(pc); + GateRef stringId = ReadInst16_1(pc); GateRef propKey = GetObjectFromConstPool(constpool, stringId); DEFVARIABLE(result, VariableType::JS_ANY(), Undefined()); @@ -3753,16 +3635,16 @@ DECLARE_ASM_HANDLER(HandleTryStGlobalByNamePrefId32) } Bind(&checkResult); { - CHECK_EXCEPTION(*result, INT_PTR(PREF_ID32)); + CHECK_EXCEPTION(*result, INT_PTR(TRYSTGLOBALBYNAME_IMM8_ID16)); } } -DECLARE_ASM_HANDLER(HandleLdGlobalVarPrefId32) +DECLARE_ASM_HANDLER(HandleLdGlobalVarId16) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); - GateRef stringId = ReadInst32_1(pc); + GateRef stringId = ReadInst16_0(pc); GateRef propKey = GetObjectFromConstPool(constpool, stringId); DEFVARIABLE(result, VariableType::JS_ANY(), Undefined()); @@ -3770,117 +3652,51 @@ DECLARE_ASM_HANDLER(HandleLdGlobalVarPrefId32) Label dispatch(env); Label slowPath(env); GateRef globalObject = GetGlobalObject(glue); - Label icAvailable(env); - Label icNotAvailable(env); - Branch(TaggedIsUndefined(profileTypeInfo), &icNotAvailable, &icAvailable); - Bind(&icAvailable); - { - GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); - GateRef handler = GetValueFromTaggedArray(VariableType::JS_ANY(), profileTypeInfo, slotId); - Label isHeapObject(env); - Label notHeapObject(env); - Label ldMiss(env); - Branch(TaggedIsHeapObject(handler), &isHeapObject, ¬HeapObject); - Bind(&isHeapObject); - { - result = LoadGlobal(handler); - Branch(TaggedIsHole(*result), &ldMiss, &checkResult); - } - Bind(¬HeapObject); - { - Branch(TaggedIsHole(handler), &icNotAvailable, &ldMiss); - } - Bind(&ldMiss); - { - result = CallRuntime(glue, RTSTUB_ID(LoadMiss), - { profileTypeInfo, globalObject, propKey, IntToTaggedTypeNGC(slotId), - IntToTaggedTypeNGC(Int32(static_cast(ICKind::NamedGlobalLoadIC))) }); - Jump(&checkResult); - } - } - Bind(&icNotAvailable); + + result = CallRuntime(glue, RTSTUB_ID(GetGlobalOwnProperty), { propKey }); + Branch(TaggedIsHole(*result), &slowPath, &dispatch); + Bind(&slowPath); { - result = CallRuntime(glue, RTSTUB_ID(GetGlobalOwnProperty), { propKey }); - Branch(TaggedIsHole(*result), &slowPath, &dispatch); - Bind(&slowPath); - { - result = CallRuntime(glue, RTSTUB_ID(LdGlobalVar), { globalObject, propKey }); - Jump(&checkResult); - } + result = CallRuntime(glue, RTSTUB_ID(LdGlobalVar), { globalObject, propKey }); + Jump(&checkResult); } Bind(&checkResult); { - CHECK_EXCEPTION_WITH_VARACC(*result, INT_PTR(PREF_ID32)); + CHECK_EXCEPTION_WITH_VARACC(*result, INT_PTR(LDGLOBALVAR_ID16)); } Bind(&dispatch); varAcc = *result; - DISPATCH_WITH_ACC(PREF_ID32); + DISPATCH_WITH_ACC(LDGLOBALVAR_ID16); } -DECLARE_ASM_HANDLER(HandleStGlobalVarPrefId32) +DECLARE_ASM_HANDLER(HandleStGlobalVarId16) { - auto env = GetEnvironment(); - - GateRef stringId = ReadInst32_1(pc); + GateRef stringId = ReadInst16_0(pc); GateRef propKey = GetObjectFromConstPool(constpool, stringId); - DEFVARIABLE(result, VariableType::JS_ANY(), Undefined()); - Label checkResult(env); - - Label icAvailable(env); - Label icNotAvailable(env); - Branch(TaggedIsUndefined(profileTypeInfo), &icNotAvailable, &icAvailable); - Bind(&icAvailable); - { - GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); - GateRef handler = GetValueFromTaggedArray(VariableType::JS_ANY(), profileTypeInfo, slotId); - Label isHeapObject(env); - Label stMiss(env); - Branch(TaggedIsHeapObject(handler), &isHeapObject, &stMiss); - Bind(&isHeapObject); - { - result = StoreGlobal(glue, acc, handler); - Branch(TaggedIsHole(*result), &stMiss, &checkResult); - } - Bind(&stMiss); - { - GateRef globalObject = GetGlobalObject(glue); - result = CallRuntime(glue, RTSTUB_ID(StoreMiss), - { profileTypeInfo, globalObject, propKey, acc, IntToTaggedTypeNGC(slotId), - IntToTaggedTypeNGC(Int32(static_cast(ICKind::NamedGlobalStoreIC))) }); - Jump(&checkResult); - } - } - Bind(&icNotAvailable); - { - result = CallRuntime(glue, RTSTUB_ID(StGlobalVar), { propKey, acc }); - Jump(&checkResult); - } - Bind(&checkResult); - { - CHECK_EXCEPTION(*result, INT_PTR(PREF_ID32)); - } + GateRef result = CallRuntime(glue, RTSTUB_ID(StGlobalVar), { propKey, acc }); + CHECK_EXCEPTION(result, INT_PTR(STGLOBALVAR_ID16)); } -DECLARE_ASM_HANDLER(HandleCreateRegExpWithLiteralPrefId32Imm8) +DECLARE_ASM_HANDLER(HandleCreateRegExpWithLiteralImm8Id16Imm8) { - GateRef stringId = ReadInst32_1(pc); + GateRef stringId = ReadInst16_1(pc); GateRef pattern = GetObjectFromConstPool(constpool, stringId); - GateRef flags = ReadInst8_5(pc); + GateRef flags = ReadInst8_3(pc); GateRef res = CallRuntime(glue, RTSTUB_ID(CreateRegExpWithLiteral), { pattern, Int8ToTaggedTypeNGC(flags) }); - CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(PREF_ID32_IMM8)); + CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CREATEREGEXPWITHLITERAL_IMM8_ID16_IMM8)); } -DECLARE_ASM_HANDLER(HandleIsTruePref) +DECLARE_ASM_HANDLER(HandleIsTrue) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); varAcc = FastToBoolean(*varAcc); - DISPATCH_WITH_ACC(PREF_NONE); + DISPATCH_WITH_ACC(ISTRUE); } -DECLARE_ASM_HANDLER(HandleIsFalsePref) +DECLARE_ASM_HANDLER(HandleIsFalse) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -3901,10 +3717,10 @@ DECLARE_ASM_HANDLER(HandleIsFalsePref) Jump(&dispatch); } Bind(&dispatch); - DISPATCH_WITH_ACC(PREF_NONE); + DISPATCH_WITH_ACC(ISFALSE); } -DECLARE_ASM_HANDLER(HandleToNumberPrefV8) +DECLARE_ASM_HANDLER(HandleToNumberImm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -3916,16 +3732,16 @@ DECLARE_ASM_HANDLER(HandleToNumberPrefV8) Bind(&valueIsNumber); { varAcc = value; - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(TONUMBER_IMM8_V8); } Bind(&valueNotNumber); { GateRef res = CallRuntime(glue, RTSTUB_ID(ToNumber), { value }); - CHECK_EXCEPTION_WITH_VARACC(res, INT_PTR(PREF_V8)); + CHECK_EXCEPTION_WITH_VARACC(res, INT_PTR(TONUMBER_IMM8_V8)); } } -DECLARE_ASM_HANDLER(HandleAdd2DynPrefV8) +DECLARE_ASM_HANDLER(HandleAdd2Imm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -3946,15 +3762,15 @@ DECLARE_ASM_HANDLER(HandleAdd2DynPrefV8) // slow path Bind(&slowPath); { - GateRef taggedNumber = CallRuntime(glue, RTSTUB_ID(Add2Dyn), { left, right }); - CHECK_EXCEPTION_WITH_VARACC(taggedNumber, INT_PTR(PREF_V8)); + GateRef taggedNumber = CallRuntime(glue, RTSTUB_ID(Add2), { left, right }); + CHECK_EXCEPTION_WITH_VARACC(taggedNumber, INT_PTR(ADD2_IMM8_V8)); } Bind(&accDispatch); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(ADD2_IMM8_V8); } -DECLARE_ASM_HANDLER(HandleSub2DynPrefV8) +DECLARE_ASM_HANDLER(HandleSub2Imm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -3975,37 +3791,37 @@ DECLARE_ASM_HANDLER(HandleSub2DynPrefV8) // slow path Bind(&slowPath); { - GateRef taggedNumber = CallRuntime(glue, RTSTUB_ID(Sub2Dyn), { left, right }); - CHECK_EXCEPTION_WITH_VARACC(taggedNumber, INT_PTR(PREF_V8)); + GateRef taggedNumber = CallRuntime(glue, RTSTUB_ID(Sub2), { left, right }); + CHECK_EXCEPTION_WITH_VARACC(taggedNumber, INT_PTR(SUB2_IMM8_V8)); } Bind(&accDispatch); - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(SUB2_IMM8_V8); } -DECLARE_ASM_HANDLER(HandleCallArg0DynPrefV8) +DECLARE_ASM_HANDLER(HandleCallArg0Imm8V8) { GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARG0); GateRef funcReg = ReadInst8_1(pc); GateRef func = GetVregValue(sp, ZExtInt8ToPtr(funcReg)); - GateRef jumpSize = IntPtr(BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_V8)); + GateRef jumpSize = IntPtr(BytecodeInstruction::Size(BytecodeInstruction::Format::IMM8_V8)); GateRef res = JSCallDispatch(glue, func, actualNumArgs, JSCallMode::CALL_ARG0, {}); CHECK_PENDING_EXCEPTION(res, jumpSize); } -DECLARE_ASM_HANDLER(HandleCallArg1DynPrefV8V8) +DECLARE_ASM_HANDLER(HandleCallArg1Imm8V8V8) { GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARG1); GateRef funcReg = ReadInst8_1(pc); GateRef a0 = ReadInst8_2(pc); GateRef func = GetVregValue(sp, ZExtInt8ToPtr(funcReg)); GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0)); - GateRef jumpSize = IntPtr(BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_V8_V8)); + GateRef jumpSize = IntPtr(BytecodeInstruction::Size(BytecodeInstruction::Format::IMM8_V8_V8)); GateRef res = JSCallDispatch(glue, func, actualNumArgs, JSCallMode::CALL_ARG1, { a0Value }); CHECK_PENDING_EXCEPTION(res, jumpSize); } -DECLARE_ASM_HANDLER(HandleCallArgs2DynPrefV8V8V8) +DECLARE_ASM_HANDLER(HandleCallArgs2Imm8V8V8V8) { GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARGS2); GateRef funcReg = ReadInst8_1(pc); @@ -4014,13 +3830,13 @@ DECLARE_ASM_HANDLER(HandleCallArgs2DynPrefV8V8V8) GateRef func = GetVregValue(sp, ZExtInt8ToPtr(funcReg)); GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0)); GateRef a1Value = GetVregValue(sp, ZExtInt8ToPtr(a1)); - GateRef jumpSize = IntPtr(BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_V8_V8_V8)); + GateRef jumpSize = IntPtr(BytecodeInstruction::Size(BytecodeInstruction::Format::IMM8_V8_V8_V8)); GateRef res = JSCallDispatch(glue, func, actualNumArgs, JSCallMode::CALL_ARG2, { a0Value, a1Value }); CHECK_PENDING_EXCEPTION(res, jumpSize); } -DECLARE_ASM_HANDLER(HandleCallArgs3DynPrefV8V8V8V8) +DECLARE_ASM_HANDLER(HandleCallArgs3Imm8V8V8V8V8) { GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARGS3); GateRef funcReg = ReadInst8_1(pc); @@ -4031,27 +3847,27 @@ DECLARE_ASM_HANDLER(HandleCallArgs3DynPrefV8V8V8V8) GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0)); GateRef a1Value = GetVregValue(sp, ZExtInt8ToPtr(a1)); GateRef a2Value = GetVregValue(sp, ZExtInt8ToPtr(a2)); - GateRef jumpSize = IntPtr(BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_V8_V8_V8_V8)); + GateRef jumpSize = IntPtr(BytecodeInstruction::Size(BytecodeInstruction::Format::IMM8_V8_V8_V8_V8)); GateRef res = JSCallDispatch(glue, func, actualNumArgs, JSCallMode::CALL_ARG3, { a0Value, a1Value, a2Value }); CHECK_PENDING_EXCEPTION(res, jumpSize); } -DECLARE_ASM_HANDLER(HandleCallIRangeDynPrefImm16V8) +DECLARE_ASM_HANDLER(HandleCallRangeImm8Imm16V8) { GateRef actualNumArgs = ZExtInt16ToInt32(ReadInst16_1(pc)); GateRef funcReg = ReadInst8_3(pc); GateRef func = GetVregValue(sp, ZExtInt8ToPtr(funcReg)); GateRef argv = PtrAdd(sp, PtrMul( PtrAdd(ZExtInt8ToPtr(funcReg), IntPtr(1)), IntPtr(8))); // 1: skip function - GateRef jumpSize = IntPtr(BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_IMM16_V8)); + GateRef jumpSize = IntPtr(BytecodeInstruction::Size(BytecodeInstruction::Format::IMM8_IMM16_V8)); GateRef numArgs = ChangeInt32ToIntPtr(actualNumArgs); GateRef res = JSCallDispatch(glue, func, actualNumArgs, JSCallMode::CALL_WITH_ARGV, { numArgs, argv }); CHECK_PENDING_EXCEPTION(res, jumpSize); } -DECLARE_ASM_HANDLER(HandleCallIThisRangeDynPrefImm16V8) +DECLARE_ASM_HANDLER(HandleCallThisRangeImm8Imm16V8) { GateRef actualNumArgs = Int32Sub(ZExtInt16ToInt32(ReadInst16_1(pc)), Int32(1)); // 1: exclude this GateRef funcReg = ReadInst8_3(pc); @@ -4060,22 +3876,22 @@ DECLARE_ASM_HANDLER(HandleCallIThisRangeDynPrefImm16V8) GateRef thisValue = GetVregValue(sp, PtrAdd(funcReg, IntPtr(1))); GateRef argv = PtrAdd(sp, PtrMul( PtrAdd(funcReg, IntPtr(2)), IntPtr(8))); // 2: skip function&this - GateRef jumpSize = IntPtr(BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_IMM16_V8)); + GateRef jumpSize = IntPtr(BytecodeInstruction::Size(BytecodeInstruction::Format::IMM8_IMM16_V8)); GateRef numArgs = ChangeInt32ToIntPtr(actualNumArgs); GateRef res = JSCallDispatch(glue, func, actualNumArgs, JSCallMode::CALL_THIS_WITH_ARGV, { numArgs, argv, thisValue }); CHECK_PENDING_EXCEPTION(res, jumpSize); } -DECLARE_ASM_HANDLER(HandleLdBigIntPrefId32) +DECLARE_ASM_HANDLER(HandleLdBigIntId16) { - GateRef stringId = ReadInst32_1(pc); + GateRef stringId = ReadInst16_0(pc); GateRef numberBigInt = GetObjectFromConstPool(constpool, stringId); GateRef res = CallRuntime(glue, RTSTUB_ID(LdBigInt), { numberBigInt }); - CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(PREF_ID32)); + CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(LDBIGINT_ID16)); } -DECLARE_ASM_HANDLER(HandleToNumericPrefV8) +DECLARE_ASM_HANDLER(HandleToNumericImm8V8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); @@ -4087,16 +3903,16 @@ DECLARE_ASM_HANDLER(HandleToNumericPrefV8) Bind(&valueIsNumeric); { varAcc = value; - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(TONUMERIC_IMM8_V8); } Bind(&valueNotNumeric); { GateRef res = CallRuntime(glue, RTSTUB_ID(ToNumeric), { value }); - CHECK_EXCEPTION_WITH_VARACC(res, INT_PTR(PREF_V8)); + CHECK_EXCEPTION_WITH_VARACC(res, INT_PTR(TONUMERIC_IMM8_V8)); } } -DECLARE_ASM_HANDLER(HandleDefineAsyncGeneratorFuncPrefId16Imm16V8) +DECLARE_ASM_HANDLER(HandleDefineAsyncGeneratorFuncImm8Id16Imm16V8) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); auto env = GetEnvironment(); @@ -4132,24 +3948,24 @@ DECLARE_ASM_HANDLER(HandleDefineAsyncGeneratorFuncPrefId16Imm16V8) } Bind(&defaultLabel); { - GateRef hClass = LoadHClass(*result); - SetPropertyInlinedProps(glue, *result, hClass, Int16ToTaggedNGC(length), + GateRef hclass = LoadHClass(*result); + SetPropertyInlinedProps(glue, *result, hclass, Int16ToTaggedNGC(length), Int32(JSFunction::LENGTH_INLINE_PROPERTY_INDEX), VariableType::INT64()); GateRef lexEnv = GetVregValue(sp, ZExtInt8ToPtr(v0)); SetLexicalEnvToFunction(glue, *result, lexEnv); GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); SetModuleToFunction(glue, *result, GetModuleFromFunction(currentFunc)); varAcc = *result; - DISPATCH_WITH_ACC(PREF_ID16_IMM16_V8); + DISPATCH_WITH_ACC(DEFINEASYNCGENERATORFUNC_IMM8_ID16_IMM16_V8); } } -DECLARE_ASM_HANDLER(HandleCreateAsyncGeneratorObjPrefV8) +DECLARE_ASM_HANDLER(HandleCreateAsyncGeneratorObjV8) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); - GateRef v0 = ReadInst8_1(pc); + GateRef v0 = ReadInst8_0(pc); GateRef genFunc = GetVregValue(sp, ZExtInt8ToPtr(v0)); GateRef result = CallRuntime(glue, RTSTUB_ID(CreateAsyncGeneratorObj), { genFunc }); Label isException(env); @@ -4161,16 +3977,16 @@ DECLARE_ASM_HANDLER(HandleCreateAsyncGeneratorObjPrefV8) } Bind(¬Exception); varAcc = result; - DISPATCH_WITH_ACC(PREF_V8); + DISPATCH_WITH_ACC(CREATEASYNCGENERATOROBJ_V8); } -DECLARE_ASM_HANDLER(HandleAsyncGeneratorResolvePrefV8V8V8) +DECLARE_ASM_HANDLER(HandleAsyncGeneratorResolveV8V8V8) { DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); auto env = GetEnvironment(); - GateRef asyncGenerator = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); - GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); - GateRef flag = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); + GateRef asyncGenerator = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_0(pc))); + GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); + GateRef flag = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); GateRef res = CallRuntime(glue, RTSTUB_ID(AsyncGeneratorResolve), { asyncGenerator, value, flag }); Label isException(env); @@ -4183,17 +3999,17 @@ DECLARE_ASM_HANDLER(HandleAsyncGeneratorResolvePrefV8V8V8) Bind(¬Exception); { varAcc = res; - DISPATCH_WITH_ACC(PREF_V8_V8_V8); + DISPATCH_WITH_ACC(ASYNCGENERATORRESOLVE_V8_V8_V8); } } -DECLARE_ASM_HANDLER(HandleNewLexEnvWithNameDynPrefImm16Imm16) +DECLARE_ASM_HANDLER(HandleNewLexEnvWithNameImm16Imm16) { auto env = GetEnvironment(); DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); - GateRef numVars = ReadInst16_1(pc); - GateRef scopeId = ReadInst16_3(pc); - GateRef res = CallRuntime(glue, RTSTUB_ID(NewLexicalEnvWithNameDyn), + GateRef numVars = ReadInst16_0(pc); + GateRef scopeId = ReadInst16_2(pc); + GateRef res = CallRuntime(glue, RTSTUB_ID(NewLexicalEnvWithName), { Int16ToTaggedTypeNGC(numVars), Int16ToTaggedTypeNGC(scopeId) }); Label notException(env); CHECK_EXCEPTION_WITH_JUMP(res, ¬Exception); @@ -4201,7 +4017,183 @@ DECLARE_ASM_HANDLER(HandleNewLexEnvWithNameDynPrefImm16Imm16) varAcc = res; GateRef state = GetFrame(sp); SetEnvToFrame(glue, state, res); - DISPATCH_WITH_ACC(PREF_IMM16_IMM16); + DISPATCH_WITH_ACC(NEWLEXENVWITHNAME_IMM16_IMM16); +} + +// TODO: implement it +DECLARE_ASM_HANDLER(HandleTypeofImm16) +{ + DISPATCH(TYPEOF_IMM16); +} + +DECLARE_ASM_HANDLER(HandleCreateemptyarrayImm16) +{ + DISPATCH(CREATEEMPTYARRAY_IMM16); +} + +DECLARE_ASM_HANDLER(HandleGetiteratorImm16) +{ + DISPATCH(GETITERATOR_IMM16); +} + +DECLARE_ASM_HANDLER(HandleGettemplateobjectImm16V8) +{ + DISPATCH(GETTEMPLATEOBJECT_IMM16_V8); +} + +DECLARE_ASM_HANDLER(HandleCloseiteratorImm16V8) +{ + DISPATCH(CLOSEITERATOR_IMM16_V8); +} + +DECLARE_ASM_HANDLER(HandleNewobjspreadImm16V8V8) +{ + DISPATCH(NEWOBJSPREAD_IMM16_V8_V8); +} + +DECLARE_ASM_HANDLER(HandleSetobjectwithprotoImm16V8V8) +{ + DISPATCH(SETOBJECTWITHPROTO_IMM16_V8_V8); +} + +DECLARE_ASM_HANDLER(HandleLdobjbyvalueImm16V8V8) +{ + DISPATCH(LDOBJBYVALUE_IMM16_V8_V8); +} + +DECLARE_ASM_HANDLER(HandleStobjbyvalueImm16V8V8) +{ + DISPATCH(STOBJBYVALUE_IMM16_V8_V8); +} + +DECLARE_ASM_HANDLER(HandleStownbyvalueImm16V8V8) +{ + DISPATCH(STOWNBYVALUE_IMM16_V8_V8); +} + +DECLARE_ASM_HANDLER(HandleLdsuperbyvalueImm16V8V8) +{ + DISPATCH(LDSUPERBYVALUE_IMM16_V8_V8); +} + +DECLARE_ASM_HANDLER(HandleStsuperbyvalueImm16V8V8) +{ + DISPATCH(STSUPERBYVALUE_IMM16_V8_V8); +} + +DECLARE_ASM_HANDLER(HandleLdobjbyindexImm16V8Imm32) +{ + DISPATCH(LDOBJBYINDEX_IMM16_V8_IMM32); +} + +DECLARE_ASM_HANDLER(HandleStobjbyindexImm16V8Imm32) +{ + DISPATCH(STOBJBYINDEX_IMM16_V8_IMM32); +} + +DECLARE_ASM_HANDLER(HandleStownbyindexImm16V8Imm32) +{ + DISPATCH(STOWNBYINDEX_IMM16_V8_IMM32); +} + +DECLARE_ASM_HANDLER(HandleNewobjrangeImm16Imm16V8) +{ + DISPATCH(NEWOBJRANGE_IMM16_IMM16_V8); +} + +DECLARE_ASM_HANDLER(HandleDefinefuncImm16Id16Imm16V8) +{ + DISPATCH(DEFINEFUNC_IMM16_ID16_IMM16_V8); +} + +DECLARE_ASM_HANDLER(HandleDefinencfuncImm16Id16Imm16V8) +{ + DISPATCH(DEFINENCFUNC_IMM16_ID16_IMM16_V8); +} + +DECLARE_ASM_HANDLER(HandleDefinegeneratorfuncImm16Id16Imm16V8) +{ + DISPATCH(DEFINEGENERATORFUNC_IMM16_ID16_IMM16_V8); +} + +DECLARE_ASM_HANDLER(HandleDefineasyncfuncImm16Id16Imm16V8) +{ + DISPATCH(DEFINEASYNCFUNC_IMM16_ID16_IMM16_V8); +} + +DECLARE_ASM_HANDLER(HandleDefinemethodImm16Id16Imm16V8) +{ + DISPATCH(DEFINEMETHOD_IMM16_ID16_IMM16_V8); +} + +DECLARE_ASM_HANDLER(HandleCreatearraywithbufferImm16Imm16) +{ + DISPATCH(CREATEARRAYWITHBUFFER_IMM16_IMM16); +} + +DECLARE_ASM_HANDLER(HandleCreateobjecthavingmethodImm16Imm16) +{ + DISPATCH(CREATEOBJECTHAVINGMETHOD_IMM16_IMM16); +} + +DECLARE_ASM_HANDLER(HandleCreateobjectwithbufferImm16Imm16) +{ + DISPATCH(CREATEOBJECTWITHBUFFER_IMM16_IMM16); +} + +DECLARE_ASM_HANDLER(HandleDefineclasswithbufferImm16Id16Imm16Imm16V8V8) +{ + DISPATCH(DEFINECLASSWITHBUFFER_IMM16_ID16_IMM16_IMM16_V8_V8); +} + +DECLARE_ASM_HANDLER(HandleTryldglobalbynameImm16Id16) +{ + DISPATCH(TRYLDGLOBALBYNAME_IMM16_ID16); +} + +DECLARE_ASM_HANDLER(HandleTrystglobalbynameImm16Id16) +{ + DISPATCH(TRYSTGLOBALBYNAME_IMM16_ID16); +} + +DECLARE_ASM_HANDLER(HandleLdobjbynameImm16Id16V8) +{ + DISPATCH(LDOBJBYNAME_IMM16_ID16_V8); +} + +DECLARE_ASM_HANDLER(HandleStobjbynameImm16Id16V8) +{ + DISPATCH(STOBJBYNAME_IMM16_ID16_V8); +} + +DECLARE_ASM_HANDLER(HandleStownbynameImm16Id16V8) +{ + DISPATCH(STOWNBYNAME_IMM16_ID16_V8); +} + +DECLARE_ASM_HANDLER(HandleLdsuperbynameImm16Id16V8) +{ + DISPATCH(LDSUPERBYNAME_IMM16_ID16_V8); +} + +DECLARE_ASM_HANDLER(HandleStsuperbynameImm16Id16V8) +{ + DISPATCH(STSUPERBYNAME_IMM16_ID16_V8); +} + +DECLARE_ASM_HANDLER(HandleStownbyvaluewithnamesetImm16V8V8) +{ + DISPATCH(STOWNBYVALUEWITHNAMESET_IMM16_V8_V8); +} + +DECLARE_ASM_HANDLER(HandleStownbynamewithnamesetImm16Id16V8) +{ + DISPATCH(STOWNBYNAMEWITHNAMESET_IMM16_ID16_V8); +} + +DECLARE_ASM_HANDLER(HandleDefineasyncgeneratorfuncImm16Id16Imm16V8) +{ + DISPATCH(DEFINEASYNCGENERATORFUNC_IMM16_ID16_IMM16_V8); } DECLARE_ASM_HANDLER(InterpreterGetPropertyByName) @@ -4215,7 +4207,7 @@ DECLARE_ASM_HANDLER(InterpreterGetPropertyByName) Label isException(env); GateRef receiver = acc; - GateRef stringId = ReadInst32_1(pc); + GateRef stringId = ReadInst16_1(pc); GateRef propKey = GetValueFromTaggedArray(VariableType::JS_ANY(), constpool, stringId); result = GetPropertyByName(glue, receiver, propKey); @@ -4229,11 +4221,127 @@ DECLARE_ASM_HANDLER(InterpreterGetPropertyByName) } Bind(&checkResult); { - CHECK_EXCEPTION_WITH_VARACC(*result, INT_PTR(PREF_ID32_V8)); + CHECK_EXCEPTION_WITH_VARACC(*result, INT_PTR(LDOBJBYNAME_IMM8_ID16_V8)); } } +*/ + +DECLARE_ASM_HANDLER(ExceptionHandler) +{ + auto env = GetEnvironment(); + DEFVARIABLE(varPc, VariableType::NATIVE_POINTER(), pc); + DEFVARIABLE(varSp, VariableType::NATIVE_POINTER(), sp); + DEFVARIABLE(varConstpool, VariableType::JS_POINTER(), constpool); + DEFVARIABLE(varProfileTypeInfo, VariableType::JS_POINTER(), profileTypeInfo); + DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); + DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); + + Label pcIsInvalid(env); + Label pcNotInvalid(env); + GateRef exceptionOffset = IntPtr(JSThread::GlueData::GetExceptionOffset(env->IsArch32Bit())); + GateRef exception = Load(VariableType::JS_ANY(), glue, exceptionOffset); + varPc = TaggedCastToIntPtr(CallRuntime(glue, RTSTUB_ID(UpFrame), {})); + varSp = GetCurrentFrame(glue); + Branch(IntPtrEqual(*varPc, IntPtr(0)), &pcIsInvalid, &pcNotInvalid); + Bind(&pcIsInvalid); + { + CallNGCRuntime(glue, RTSTUB_ID(ResumeUncaughtFrameAndReturn), { glue, *varSp, *varAcc }); + Return(); + } + Bind(&pcNotInvalid); + { + varAcc = exception; + // clear exception + Store(VariableType::INT64(), glue, glue, exceptionOffset, Hole()); + GateRef function = GetFunctionFromFrame(GetFrame(*varSp)); + varConstpool = GetConstpoolFromFunction(function); + varProfileTypeInfo = GetProfileTypeInfoFromFunction(function); + GateRef method = Load(VariableType::JS_ANY(), function, + IntPtr(JSFunctionBase::METHOD_OFFSET)); + varHotnessCounter = GetHotnessCounterFromMethod(method); + CallNGCRuntime(glue, RTSTUB_ID(ResumeCaughtFrameAndDispatch), { + glue, *varSp, *varPc, *varConstpool, + *varProfileTypeInfo, *varAcc, *varHotnessCounter}); + Return(); + } +} + +DECLARE_ASM_HANDLER(SingleStepDebugging) +{ + auto env = GetEnvironment(); + DEFVARIABLE(varPc, VariableType::NATIVE_POINTER(), pc); + DEFVARIABLE(varSp, VariableType::NATIVE_POINTER(), sp); + DEFVARIABLE(varConstpool, VariableType::JS_POINTER(), constpool); + DEFVARIABLE(varProfileTypeInfo, VariableType::JS_POINTER(), profileTypeInfo); + DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); + DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); + + GateRef frame = GetFrame(*varSp); + SetPcToFrame(glue, frame, *varPc); + GateRef currentSp = *varSp; + varSp = TaggedCastToIntPtr(CallRuntime(glue, + RTSTUB_ID(JumpToCInterpreter), + { constpool, profileTypeInfo, acc, + IntToTaggedTypeNGC(hotnessCounter)})); + varPc = GetPcFromFrame(frame); + Label shouldReturn(env); + Label shouldContinue(env); + + Branch(IntPtrEqual(*varPc, IntPtr(0)), &shouldReturn, &shouldContinue); + Bind(&shouldReturn); + { + CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndReturn), { Undefined(), *varSp, currentSp }); + Return(); + } + Bind(&shouldContinue); + { + varAcc = GetAccFromFrame(frame); + GateRef function = GetFunctionFromFrame(frame); + varProfileTypeInfo = GetProfileTypeInfoFromFunction(function); + varConstpool = GetConstpoolFromFunction(function); + GateRef method = Load(VariableType::JS_ANY(), function, + IntPtr(JSFunctionBase::METHOD_OFFSET)); + varHotnessCounter = GetHotnessCounterFromMethod(method); + } + Label isException(env); + Label notException(env); + Branch(TaggedIsException(*varAcc), &isException, ¬Exception); + Bind(&isException); + DispatchLast(glue, *varSp, *varPc, *varConstpool, *varProfileTypeInfo, *varAcc, + *varHotnessCounter); + Bind(¬Exception); + DISPATCH_BAK(SSD, IntPtr(0)); +} + +DECLARE_ASM_HANDLER(BCDebuggerEntry) +{ + GateRef frame = GetFrame(sp); + SetPcToFrame(glue, frame, pc); + // NOTIFY_DEBUGGER_EVENT() + CallRuntime(glue, RTSTUB_ID(NotifyBytecodePcChanged), {}); + // goto normal handle stub + DispatchDebugger(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter); +} + +DECLARE_ASM_HANDLER(BCDebuggerExceptionEntry) +{ + DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); + varAcc = Hole(); + GateRef frame = GetFrame(sp); + SetPcToFrame(glue, frame, pc); + // NOTIFY_DEBUGGER_EVENT() + CallRuntime(glue, RTSTUB_ID(NotifyBytecodePcChanged), {}); + // goto last handle stub + DispatchDebuggerLast(glue, sp, pc, constpool, profileTypeInfo, *varAcc, hotnessCounter); +} + +DECLARE_ASM_HANDLER(HandleOverflow) +{ + FatalPrint(glue, { Int32(GET_MESSAGE_STRING_ID(OPCODE_OVERFLOW)) }); + DISPATCH_BAK(OFFSET, IntPtr(0)); +} -DECLARE_ASM_HANDLER(NewObjectDynRangeThrowException) +DECLARE_ASM_HANDLER(NewObjectRangeThrowException) { CallRuntime(glue, RTSTUB_ID(ThrowDerivedMustReturnException), {}); DISPATCH_LAST(); diff --git a/ecmascript/compiler/interpreter_stub.h b/ecmascript/compiler/interpreter_stub.h index 6bf7d22084..005ff1fa2e 100644 --- a/ecmascript/compiler/interpreter_stub.h +++ b/ecmascript/compiler/interpreter_stub.h @@ -50,7 +50,9 @@ public: inline GateRef ReadInst16_1(GateRef pc); inline GateRef ReadInst16_2(GateRef pc); inline GateRef ReadInst16_3(GateRef pc); + inline GateRef ReadInst16_4(GateRef pc); inline GateRef ReadInst16_5(GateRef pc); + inline GateRef ReadInst16_6(GateRef pc); inline GateRef ReadInstSigned8_0(GateRef pc); inline GateRef ReadInstSigned16_0(GateRef pc); inline GateRef ReadInstSigned32_0(GateRef pc); diff --git a/ecmascript/compiler/slowpath_lowering.cpp b/ecmascript/compiler/slowpath_lowering.cpp index 20023c60f6..424aa86119 100644 --- a/ecmascript/compiler/slowpath_lowering.cpp +++ b/ecmascript/compiler/slowpath_lowering.cpp @@ -56,7 +56,7 @@ void SlowPathLowering::CallRuntimeLowering() int32_t SlowPathLowering::ComputeCallArgc(GateRef gate, EcmaOpcode op) { - if (op == EcmaOpcode::CALLITHISRANGEDYN_PREF_IMM16_V8) { + if (op == EcmaOpcode::CALLTHISRANGE_IMM8_IMM16_V8) { return acc_.GetNumValueIn(gate) + NUM_MANDATORY_JSFUNC_ARGS - 3; // 3: calltarget, this and bcoffset } return acc_.GetNumValueIn(gate) + NUM_MANDATORY_JSFUNC_ARGS - 2; // 2: calltarget and bcoffset @@ -282,394 +282,394 @@ void SlowPathLowering::Lower(GateRef gate) // initialize label manager Environment env(gate, circuit_, &builder_); switch (op) { - case LDA_STR_ID32: + case EcmaOpcode::LDA_STR_ID16: LowerLoadStr(gate, glue); break; - case CALLARG0DYN_PREF_V8: - LowerCallArg0Dyn(gate, glue); + case EcmaOpcode::CALLARG0_IMM8_V8: + LowerCallArg0(gate, glue); break; - case CALLARG1DYN_PREF_V8_V8: - LowerCallArg1Dyn(gate, glue); + case EcmaOpcode::CALLARG1_IMM8_V8_V8: + LowerCallArg1(gate, glue); break; - case CALLARGS2DYN_PREF_V8_V8_V8: - LowerCallArgs2Dyn(gate, glue); + case EcmaOpcode::CALLARGS2_IMM8_V8_V8_V8: + LowerCallArgs2(gate, glue); break; - case CALLARGS3DYN_PREF_V8_V8_V8_V8: - LowerCallArgs3Dyn(gate, glue); + case EcmaOpcode::CALLARGS3_IMM8_V8_V8_V8_V8: + LowerCallArgs3(gate, glue); break; - case CALLITHISRANGEDYN_PREF_IMM16_V8: - LowerCallIThisRangeDyn(gate, glue); + case EcmaOpcode::CALLTHISRANGE_IMM8_IMM16_V8: + LowerCallThisRange(gate, glue); break; - case CALLSPREADDYN_PREF_V8_V8_V8: - LowerCallSpreadDyn(gate, glue); + case EcmaOpcode::CALLSPREAD_IMM8_V8_V8_V8: + LowerCallSpread(gate, glue); break; - case CALLIRANGEDYN_PREF_IMM16_V8: - LowerCallIRangeDyn(gate, glue); + case EcmaOpcode::CALLRANGE_IMM8_IMM16_V8: + LowerCallRange(gate, glue); break; - case LDLEXENVDYN_PREF: + case EcmaOpcode::LDLEXENV: LowerLexicalEnv(gate, glue); break; - case GETUNMAPPEDARGS_PREF: + case EcmaOpcode::GETUNMAPPEDARGS: LowerGetUnmappedArgs(gate, glue, actualArgc); break; - case ASYNCFUNCTIONENTER_PREF: + case EcmaOpcode::ASYNCFUNCTIONENTER: LowerAsyncFunctionEnter(gate, glue); break; - case INCDYN_PREF_V8: - LowerIncDyn(gate, glue); + case EcmaOpcode::INC_IMM8_V8: + LowerInc(gate, glue); break; - case DECDYN_PREF_V8: - LowerDecDyn(gate, glue); + case EcmaOpcode::DEC_IMM8_V8: + LowerDec(gate, glue); break; - case GETPROPITERATOR_PREF: + case EcmaOpcode::GETPROPITERATOR: LowerGetPropIterator(gate, glue); break; - case RESUMEGENERATOR_PREF_V8: + case EcmaOpcode::RESUMEGENERATOR_V8: LowerResumeGenerator(gate); break; - case GETRESUMEMODE_PREF_V8: + case EcmaOpcode::GETRESUMEMODE_V8: LowerGetResumeMode(gate); break; - case ITERNEXT_PREF_V8: + case EcmaOpcode::ITERNEXT_IMM8_V8: LowerIterNext(gate, glue); break; - case CLOSEITERATOR_PREF_V8: + case EcmaOpcode::CLOSEITERATOR_IMM8_V8: LowerCloseIterator(gate, glue); break; - case ADD2DYN_PREF_V8: - LowerAdd2Dyn(gate, glue); + case EcmaOpcode::ADD2_IMM8_V8: + LowerAdd2(gate, glue); break; - case SUB2DYN_PREF_V8: - LowerSub2Dyn(gate, glue); + case EcmaOpcode::SUB2_IMM8_V8: + LowerSub2(gate, glue); break; - case MUL2DYN_PREF_V8: - LowerMul2Dyn(gate, glue); + case EcmaOpcode::MUL2_IMM8_V8: + LowerMul2(gate, glue); break; - case DIV2DYN_PREF_V8: - LowerDiv2Dyn(gate, glue); + case EcmaOpcode::DIV2_IMM8_V8: + LowerDiv2(gate, glue); break; - case MOD2DYN_PREF_V8: - LowerMod2Dyn(gate, glue); + case EcmaOpcode::MOD2_IMM8_V8: + LowerMod2(gate, glue); break; - case EQDYN_PREF_V8: - LowerEqDyn(gate, glue); + case EcmaOpcode::EQ_IMM8_V8: + LowerEq(gate, glue); break; - case NOTEQDYN_PREF_V8: - LowerNotEqDyn(gate, glue); + case EcmaOpcode::NOTEQ_IMM8_V8: + LowerNotEq(gate, glue); break; - case LESSDYN_PREF_V8: - LowerLessDyn(gate, glue); + case EcmaOpcode::LESS_IMM8_V8: + LowerLess(gate, glue); break; - case LESSEQDYN_PREF_V8: - LowerLessEqDyn(gate, glue); + case EcmaOpcode::LESSEQ_IMM8_V8: + LowerLessEq(gate, glue); break; - case GREATERDYN_PREF_V8: - LowerGreaterDyn(gate, glue); + case EcmaOpcode::GREATER_IMM8_V8: + LowerGreater(gate, glue); break; - case GREATEREQDYN_PREF_V8: - LowerGreaterEqDyn(gate, glue); + case EcmaOpcode::GREATEREQ_IMM8_V8: + LowerGreaterEq(gate, glue); break; - case CREATEITERRESULTOBJ_PREF_V8_V8: + case EcmaOpcode::CREATEITERRESULTOBJ_V8_V8: LowerCreateIterResultObj(gate, glue); break; - case SUSPENDGENERATOR_PREF_V8_V8: + case EcmaOpcode::SUSPENDGENERATOR_V8_V8: LowerSuspendGenerator(gate, glue, jsFunc); break; - case ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8: + case EcmaOpcode::ASYNCFUNCTIONAWAITUNCAUGHT_V8_V8: LowerAsyncFunctionAwaitUncaught(gate, glue); break; - case ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8: + case EcmaOpcode::ASYNCFUNCTIONRESOLVE_V8_V8_V8: LowerAsyncFunctionResolve(gate, glue); break; - case ASYNCFUNCTIONREJECT_PREF_V8_V8_V8: + case EcmaOpcode::ASYNCFUNCTIONREJECT_V8_V8_V8: LowerAsyncFunctionReject(gate, glue); break; - case TRYLDGLOBALBYNAME_PREF_ID32: + case EcmaOpcode::TRYLDGLOBALBYNAME_IMM8_ID16: LowerTryLdGlobalByName(gate, glue); break; - case STGLOBALVAR_PREF_ID32: + case EcmaOpcode::STGLOBALVAR_ID16: LowerStGlobalVar(gate, glue); break; - case GETITERATOR_PREF: + case EcmaOpcode::GETITERATOR_IMM8: LowerGetIterator(gate, glue); break; - case NEWOBJSPREADDYN_PREF_V8_V8: - LowerNewObjSpreadDyn(gate, glue); + case EcmaOpcode::NEWOBJSPREAD_IMM8_V8_V8: + LowerNewObjApply(gate, glue); break; - case THROWDYN_PREF: - LowerThrowDyn(gate, glue); + case EcmaOpcode::THROW: + LowerThrow(gate, glue); break; - case TYPEOFDYN_PREF: - LowerTypeOfDyn(gate, glue); + case EcmaOpcode::TYPEOF_IMM8: + LowerTypeof(gate, glue); break; - case THROWCONSTASSIGNMENT_PREF_V8: + case EcmaOpcode::THROWCONSTASSIGNMENT_V8: LowerThrowConstAssignment(gate, glue); break; - case THROWTHROWNOTEXISTS_PREF: + case EcmaOpcode::THROWTHROWNOTEXISTS: LowerThrowThrowNotExists(gate, glue); break; - case THROWPATTERNNONCOERCIBLE_PREF: + case EcmaOpcode::THROWPATTERNNONCOERCIBLE: LowerThrowPatternNonCoercible(gate, glue); break; - case THROWIFNOTOBJECT_PREF_V8: + case EcmaOpcode::THROWIFNOTOBJECT_V8: LowerThrowIfNotObject(gate, glue); break; - case THROWUNDEFINEDIFHOLE_PREF_V8_V8: + case EcmaOpcode::THROWUNDEFINEDIFHOLE_V8_V8: LowerThrowUndefinedIfHole(gate, glue); break; - case THROWIFSUPERNOTCORRECTCALL_PREF_IMM16: + case EcmaOpcode::THROWIFSUPERNOTCORRECTCALL_IMM16: LowerThrowIfSuperNotCorrectCall(gate, glue); break; - case THROWDELETESUPERPROPERTY_PREF: + case EcmaOpcode::THROWDELETESUPERPROPERTY: LowerThrowDeleteSuperProperty(gate, glue); break; - case LDGLOBALTHIS_PREF: + case EcmaOpcode::LDGLOBALTHIS: LowerLdGlobal(gate, glue); break; - case LDSYMBOL_PREF: + case EcmaOpcode::LDSYMBOL: LowerLdSymbol(gate, glue); break; - case LDGLOBAL_PREF: + case EcmaOpcode::LDGLOBAL: LowerLdGlobal(gate, glue); break; - case TONUMBER_PREF_V8: + case EcmaOpcode::TONUMBER_IMM8_V8: LowerToNumber(gate, glue); break; - case NEGDYN_PREF_V8: - LowerNegDyn(gate, glue); + case EcmaOpcode::NEG_IMM8_V8: + LowerNeg(gate, glue); break; - case NOTDYN_PREF_V8: - LowerNotDyn(gate, glue); + case EcmaOpcode::NOT_IMM8_V8: + LowerNot(gate, glue); break; - case SHL2DYN_PREF_V8: - LowerShl2Dyn(gate, glue); + case EcmaOpcode::SHL2_IMM8_V8: + LowerShl2(gate, glue); break; - case SHR2DYN_PREF_V8: - LowerShr2Dyn(gate, glue); + case EcmaOpcode::SHR2_IMM8_V8: + LowerShr2(gate, glue); break; - case ASHR2DYN_PREF_V8: - LowerAshr2Dyn(gate, glue); + case EcmaOpcode::ASHR2_IMM8_V8: + LowerAshr2(gate, glue); break; - case AND2DYN_PREF_V8: - LowerAnd2Dyn(gate, glue); + case EcmaOpcode::AND2_IMM8_V8: + LowerAnd2(gate, glue); break; - case OR2DYN_PREF_V8: - LowerOr2Dyn(gate, glue); + case EcmaOpcode::OR2_IMM8_V8: + LowerOr2(gate, glue); break; - case XOR2DYN_PREF_V8: - LowerXor2Dyn(gate, glue); + case EcmaOpcode::XOR2_IMM8_V8: + LowerXor2(gate, glue); break; - case DELOBJPROP_PREF_V8_V8: + case EcmaOpcode::DELOBJPROP_V8_V8: LowerDelObjProp(gate, glue); break; - case DEFINENCFUNCDYN_PREF_ID16_IMM16_V8: - LowerDefineNCFuncDyn(gate, glue, jsFunc); + case EcmaOpcode::DEFINENCFUNC_IMM8_ID16_IMM16_V8: + LowerDefineNCFunc(gate, glue, jsFunc); break; - case DEFINEMETHOD_PREF_ID16_IMM16_V8: + case EcmaOpcode::DEFINEMETHOD_IMM8_ID16_IMM16_V8: LowerDefineMethod(gate, glue, jsFunc); break; - case EXPDYN_PREF_V8: - LowerExpDyn(gate, glue); + case EcmaOpcode::EXP_IMM8_V8: + LowerExp(gate, glue); break; - case ISINDYN_PREF_V8: - LowerIsInDyn(gate, glue); + case EcmaOpcode::ISIN_IMM8_V8: + LowerIsIn(gate, glue); break; - case INSTANCEOFDYN_PREF_V8: - LowerInstanceofDyn(gate, glue); + case EcmaOpcode::INSTANCEOF_IMM8_V8: + LowerInstanceof(gate, glue); break; - case STRICTNOTEQDYN_PREF_V8: + case EcmaOpcode::STRICTNOTEQ_IMM8_V8: LowerFastStrictNotEqual(gate, glue); break; - case STRICTEQDYN_PREF_V8: + case EcmaOpcode::STRICTEQ_IMM8_V8: LowerFastStrictEqual(gate, glue); break; - case CREATEEMPTYARRAY_PREF: + case EcmaOpcode::CREATEEMPTYARRAY_IMM8: LowerCreateEmptyArray(gate, glue); break; - case CREATEEMPTYOBJECT_PREF: + case EcmaOpcode::CREATEEMPTYOBJECT: LowerCreateEmptyObject(gate, glue); break; - case CREATEOBJECTWITHBUFFER_PREF_IMM16: + case EcmaOpcode::CREATEOBJECTWITHBUFFER_IMM8_IMM16: LowerCreateObjectWithBuffer(gate, glue, jsFunc); break; - case CREATEARRAYWITHBUFFER_PREF_IMM16: + case EcmaOpcode::CREATEARRAYWITHBUFFER_IMM8_IMM16: LowerCreateArrayWithBuffer(gate, glue, jsFunc); break; - case STMODULEVAR_PREF_ID32: + case EcmaOpcode::STMODULEVAR_ID16: LowerStModuleVar(gate, glue, jsFunc); break; - case GETTEMPLATEOBJECT_PREF_V8: + case EcmaOpcode::GETTEMPLATEOBJECT_IMM8_V8: LowerGetTemplateObject(gate, glue); break; - case SETOBJECTWITHPROTO_PREF_V8_V8: + case EcmaOpcode::SETOBJECTWITHPROTO_IMM8_V8_V8: LowerSetObjectWithProto(gate, glue); break; - case LDBIGINT_PREF_ID32: + case EcmaOpcode::LDBIGINT_ID16: LowerLdBigInt(gate, glue); break; - case TONUMERIC_PREF_V8: + case EcmaOpcode::TONUMERIC_IMM8_V8: LowerToNumeric(gate, glue); break; - case LDMODULEVAR_PREF_ID32_IMM8: + case EcmaOpcode::LDMODULEVAR_ID16_IMM8: LowerLdModuleVar(gate, glue, jsFunc); break; - case GETMODULENAMESPACE_PREF_ID32: + case EcmaOpcode::GETMODULENAMESPACE_ID16: LowerGetModuleNamespace(gate, glue, jsFunc); break; - case NEWOBJDYNRANGE_PREF_IMM16_V8: - LowerNewObjDynRange(gate, glue); + case EcmaOpcode::NEWOBJRANGE_IMM8_IMM16_V8: + LowerNewObjRange(gate, glue); break; - case JEQZ_IMM8: - case JEQZ_IMM16: + case EcmaOpcode::JEQZ_IMM8: + case EcmaOpcode::JEQZ_IMM16: LowerConditionJump(gate, true); break; - case JNEZ_IMM8: - case JNEZ_IMM16: + case EcmaOpcode::JNEZ_IMM8: + case EcmaOpcode::JNEZ_IMM16: LowerConditionJump(gate, false); break; - case GETITERATORNEXT_PREF_V8_V8: + case EcmaOpcode::GETITERATORNEXT_V8_V8: LowerGetIteratorNext(gate, glue); break; - case SUPERCALL_PREF_IMM16_V8: + case EcmaOpcode::SUPERCALL_IMM8_IMM16_V8: LowerSuperCall(gate, glue, newTarget); break; - case SUPERCALLSPREAD_PREF_V8: + case EcmaOpcode::SUPERCALLSPREAD_IMM8_V8: LowerSuperCallSpread(gate, glue, newTarget); break; - case ISTRUE_PREF: + case EcmaOpcode::ISTRUE: LowerIsTrueOrFalse(gate, glue, true); break; - case ISFALSE_PREF: + case EcmaOpcode::ISFALSE: LowerIsTrueOrFalse(gate, glue, false); break; - case GETNEXTPROPNAME_PREF_V8: + case EcmaOpcode::GETNEXTPROPNAME_V8: LowerGetNextPropName(gate, glue); break; - case COPYDATAPROPERTIES_PREF_V8_V8: + case EcmaOpcode::COPYDATAPROPERTIES_V8_V8: LowerCopyDataProperties(gate, glue); break; - case CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8: + case EcmaOpcode::CREATEOBJECTWITHEXCLUDEDKEYS_IMM8_V8_V8: LowerCreateObjectWithExcludedKeys(gate, glue); break; - case CREATEREGEXPWITHLITERAL_PREF_ID32_IMM8: + case EcmaOpcode::CREATEREGEXPWITHLITERAL_IMM8_ID16_IMM8: LowerCreateRegExpWithLiteral(gate, glue); break; - case STOWNBYVALUE_PREF_V8_V8: + case EcmaOpcode::STOWNBYVALUE_IMM8_V8_V8: LowerStOwnByValue(gate, glue); break; - case STOWNBYINDEX_PREF_V8_IMM32: + case EcmaOpcode::STOWNBYINDEX_IMM8_V8_IMM32: LowerStOwnByIndex(gate, glue); break; - case STOWNBYNAME_PREF_ID32_V8: + case EcmaOpcode::STOWNBYNAME_IMM8_ID16_V8: LowerStOwnByName(gate, glue); break; - case DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8: + case EcmaOpcode::DEFINEGENERATORFUNC_IMM8_ID16_IMM16_V8: LowerDefineGeneratorFunc(gate, glue, jsFunc); break; - case DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8: + case EcmaOpcode::DEFINEASYNCGENERATORFUNC_IMM8_ID16_IMM16_V8: LowerDefineAsyncGeneratorFunc(gate, glue, jsFunc); break; - case DEFINEASYNCFUNC_PREF_ID16_IMM16_V8: + case EcmaOpcode::DEFINEASYNCFUNC_IMM8_ID16_IMM16_V8: LowerDefineAsyncFunc(gate, glue, jsFunc); break; - case NEWLEXENVDYN_PREF_IMM16: - LowerNewLexicalEnvDyn(gate, glue); + case EcmaOpcode::NEWLEXENV_IMM8: + LowerNewLexicalEnv(gate, glue); break; - case NEWLEXENVWITHNAMEDYN_PREF_IMM16_IMM16: - LowerNewLexicalEnvWithNameDyn(gate, glue, jsFunc); + case EcmaOpcode::NEWLEXENVWITHNAME_IMM16_IMM16: + LowerNewLexicalEnvWithName(gate, glue, jsFunc); break; - case POPLEXENVDYN_PREF: + case EcmaOpcode::POPLEXENV: LowerPopLexicalEnv(gate, glue); break; - case LDSUPERBYVALUE_PREF_V8_V8: + case EcmaOpcode::LDSUPERBYVALUE_IMM8_V8_V8: LowerLdSuperByValue(gate, glue, jsFunc); break; - case STSUPERBYVALUE_PREF_V8_V8: + case EcmaOpcode::STSUPERBYVALUE_IMM8_V8_V8: LowerStSuperByValue(gate, glue, jsFunc); break; - case TRYSTGLOBALBYNAME_PREF_ID32: + case EcmaOpcode::TRYSTGLOBALBYNAME_IMM8_ID16: LowerTryStGlobalByName(gate, glue); break; - case STCONSTTOGLOBALRECORD_PREF_ID32: + case EcmaOpcode::STCONSTTOGLOBALRECORD_ID16: LowerStConstToGlobalRecord(gate, glue); break; - case STLETTOGLOBALRECORD_PREF_ID32: + case EcmaOpcode::STLETTOGLOBALRECORD_ID16: LowerStLetToGlobalRecord(gate, glue); break; - case STCLASSTOGLOBALRECORD_PREF_ID32: + case EcmaOpcode::STCLASSTOGLOBALRECORD_ID16: LowerStClassToGlobalRecord(gate, glue); break; - case STOWNBYVALUEWITHNAMESET_PREF_V8_V8: + case EcmaOpcode::STOWNBYVALUEWITHNAMESET_IMM8_V8_V8: LowerStOwnByValueWithNameSet(gate, glue); break; - case STOWNBYNAMEWITHNAMESET_PREF_ID32_V8: + case EcmaOpcode::STOWNBYNAMEWITHNAMESET_IMM8_ID16_V8: LowerStOwnByNameWithNameSet(gate, glue); break; - case LDGLOBALVAR_PREF_ID32: + case EcmaOpcode::LDGLOBALVAR_ID16: LowerLdGlobalVar(gate, glue); break; - case LDOBJBYNAME_PREF_ID32_V8: + case EcmaOpcode::LDOBJBYNAME_IMM8_ID16_V8: LowerLdObjByName(gate, glue); break; - case STOBJBYNAME_PREF_ID32_V8: + case EcmaOpcode::STOBJBYNAME_IMM8_ID16_V8: LowerStObjByName(gate, glue); break; - case DEFINEGETTERSETTERBYVALUE_PREF_V8_V8_V8_V8: + case EcmaOpcode::DEFINEGETTERSETTERBYVALUE_V8_V8_V8_V8: LowerDefineGetterSetterByValue(gate, glue); break; - case LDOBJBYINDEX_PREF_V8_IMM32: + case EcmaOpcode::LDOBJBYINDEX_IMM8_V8_IMM32: LowerLdObjByIndex(gate, glue); break; - case STOBJBYINDEX_PREF_V8_IMM32: + case EcmaOpcode::STOBJBYINDEX_IMM8_V8_IMM32: LowerStObjByIndex(gate, glue); break; - case LDOBJBYVALUE_PREF_V8_V8: + case EcmaOpcode::LDOBJBYVALUE_IMM8_V8_V8: LowerLdObjByValue(gate, glue); break; - case STOBJBYVALUE_PREF_V8_V8: + case EcmaOpcode::STOBJBYVALUE_IMM8_V8_V8: LowerStObjByValue(gate, glue); break; - case LDSUPERBYNAME_PREF_ID32_V8: + case EcmaOpcode::LDSUPERBYNAME_IMM8_ID16_V8: LowerLdSuperByName(gate, glue, jsFunc); break; - case STSUPERBYNAME_PREF_ID32_V8: + case EcmaOpcode::STSUPERBYNAME_IMM8_ID16_V8: LowerStSuperByName(gate, glue, jsFunc); break; - case CREATEGENERATOROBJ_PREF_V8: + case EcmaOpcode::CREATEGENERATOROBJ_V8: LowerCreateGeneratorObj(gate, glue); break; - case CREATEASYNCGENERATOROBJ_PREF_V8: + case EcmaOpcode::CREATEASYNCGENERATOROBJ_V8: LowerCreateAsyncGeneratorObj(gate, glue); break; - case ASYNCGENERATORRESOLVE_PREF_V8_V8_V8: + case EcmaOpcode::ASYNCGENERATORRESOLVE_V8_V8_V8: LowerAsyncGeneratorResolve(gate, glue); break; - case STARRAYSPREAD_PREF_V8_V8: + case EcmaOpcode::STARRAYSPREAD_V8_V8: LowerStArraySpread(gate, glue); break; - case LDLEXVARDYN_PREF_IMM4_IMM4: - case LDLEXVARDYN_PREF_IMM8_IMM8: - case LDLEXVARDYN_PREF_IMM16_IMM16: - LowerLdLexVarDyn(gate, glue); + case EcmaOpcode::LDLEXVAR_IMM4_IMM4: + case EcmaOpcode::LDLEXVAR_IMM8_IMM8: + case EcmaOpcode::LDLEXVAR_IMM16_IMM16: + LowerLdLexVar(gate, glue); break; - case STLEXVARDYN_PREF_IMM4_IMM4_V8: - case STLEXVARDYN_PREF_IMM8_IMM8_V8: - case STLEXVARDYN_PREF_IMM16_IMM16_V8: - LowerStLexVarDyn(gate, glue); + case EcmaOpcode::STLEXVAR_IMM4_IMM4_V8: + case EcmaOpcode::STLEXVAR_IMM8_IMM8_V8: + case EcmaOpcode::STLEXVAR_IMM16_IMM16_V8: + LowerStLexVar(gate, glue); break; - case CREATEOBJECTHAVINGMETHOD_PREF_IMM16: + case EcmaOpcode::CREATEOBJECTHAVINGMETHOD_IMM8_IMM16: LowerCreateObjectHavingMethod(gate, glue, jsFunc); break; - case LDHOMEOBJECT_PREF: + case EcmaOpcode::LDHOMEOBJECT: LowerLdHomeObject(gate, jsFunc); break; - case DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8: + case EcmaOpcode::DEFINECLASSWITHBUFFER_IMM8_ID16_IMM16_IMM16_V8_V8: LowerDefineClassWithBuffer(gate, glue, jsFunc); break; - case DEFINEFUNCDYN_PREF_ID16_IMM16_V8: - LowerDefineFuncDyn(gate, glue, jsFunc); + case EcmaOpcode::DEFINEFUNC_IMM8_ID16_IMM16_V8: + LowerDefineFunc(gate, glue, jsFunc); break; - case COPYRESTARGS_PREF_IMM16: + case EcmaOpcode::COPYRESTARGS_IMM16: LowerCopyRestArgs(gate, glue, actualArgc); break; default: @@ -690,10 +690,10 @@ GateRef SlowPathLowering::LowerCallRuntime(GateRef glue, int index, const std::v } } -void SlowPathLowering::LowerAdd2Dyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerAdd2(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleAdd2DynPrefV8))); - const int id = RTSTUB_ID(Add2Dyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleAdd2Imm8V8))); + const int id = RTSTUB_ID(Add2); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); auto args = {acc_.GetValueIn(gate, 0), acc_.GetValueIn(gate, 1)}; @@ -703,7 +703,7 @@ void SlowPathLowering::LowerAdd2Dyn(GateRef gate, GateRef glue) void SlowPathLowering::LowerCreateIterResultObj(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCreateIterResultObjPrefV8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCreateIterResultObjV8V8))); const int id = RTSTUB_ID(CreateIterResultObj); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); @@ -790,7 +790,7 @@ void SlowPathLowering::LowerSuspendGenerator(GateRef gate, GateRef glue, [[maybe ASSERT(acc_.GetNumValueIn(gate) == 4); SaveFrameToContext(gate, glue, jsFunc); acc_.SetDep(gate, builder_.GetDepend()); - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleSuspendGeneratorPrefV8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleSuspendGeneratorV8V8))); const int id = RTSTUB_ID(OptSuspendGenerator); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 1), acc_.GetValueIn(gate, 2)}); ReplaceHirToCall(gate, newGate); @@ -798,7 +798,7 @@ void SlowPathLowering::LowerSuspendGenerator(GateRef gate, GateRef glue, [[maybe void SlowPathLowering::LowerAsyncFunctionAwaitUncaught(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleAsyncFunctionAwaitUncaughtPrefV8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleAsyncFunctionAwaitUncaughtV8V8))); const int id = RTSTUB_ID(AsyncFunctionAwaitUncaught); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); @@ -808,7 +808,7 @@ void SlowPathLowering::LowerAsyncFunctionAwaitUncaught(GateRef gate, GateRef glu void SlowPathLowering::LowerAsyncFunctionResolve(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleAsyncFunctionResolvePrefV8V8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleAsyncFunctionResolveV8V8V8))); const int id = RTSTUB_ID(AsyncFunctionResolveOrReject); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); @@ -819,7 +819,7 @@ void SlowPathLowering::LowerAsyncFunctionResolve(GateRef gate, GateRef glue) void SlowPathLowering::LowerAsyncFunctionReject(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleAsyncFunctionRejectPrefV8V8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleAsyncFunctionRejectV8V8V8))); const int id = RTSTUB_ID(AsyncFunctionResolveOrReject); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); @@ -830,14 +830,14 @@ void SlowPathLowering::LowerAsyncFunctionReject(GateRef gate, GateRef glue) void SlowPathLowering::LowerLoadStr(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdaStrId32))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdaStrId16))); GateRef newGate = GetValueFromConstStringTable(glue, gate, 0); ReplaceHirToCall(gate, newGate); } void SlowPathLowering::LowerLexicalEnv(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdLexEnvDynPref))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdLexEnv))); const int id = RTSTUB_ID(OptGetLexicalEnv); GateRef newGate = LowerCallRuntime(glue, id, {}); ReplaceHirToCall(gate, newGate, true); @@ -845,7 +845,7 @@ void SlowPathLowering::LowerLexicalEnv(GateRef gate, GateRef glue) void SlowPathLowering::LowerTryLdGlobalByName(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleTryLdGlobalByNamePrefId32))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleTryLdGlobalByNameImm8Id16))); DEFVAlUE(result, (&builder_), VariableType::JS_ANY(), acc_.GetValueIn(gate, 0)); GateRef stringId = builder_.TaggedTypeNGC(builder_.ZExtInt32ToInt64(acc_.GetValueIn(gate, 0))); GateRef prop = LowerCallRuntime(glue, RTSTUB_ID(LoadValueFromConstantStringTable), { stringId }, true); @@ -884,7 +884,7 @@ void SlowPathLowering::LowerTryLdGlobalByName(GateRef gate, GateRef glue) void SlowPathLowering::LowerStGlobalVar(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStGlobalVarPrefId32))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStGlobalVarId16))); GateRef prop = GetValueFromConstStringTable(glue, gate, 0); acc_.SetDep(gate, prop); const int id = RTSTUB_ID(StGlobalVar); @@ -895,7 +895,7 @@ void SlowPathLowering::LowerStGlobalVar(GateRef gate, GateRef glue) void SlowPathLowering::LowerGetIterator(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleGetIteratorPref))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleGetIteratorImm8))); Label successExit(&builder_); Label exceptionExit(&builder_); auto result = LowerCallRuntime(glue, RTSTUB_ID(GetIterator), {acc_.GetValueIn(gate, 0)}, true); @@ -913,13 +913,13 @@ void SlowPathLowering::LowerToJSCall(GateRef gate, GateRef glue, const std::vect ReplaceHirToJSCall(gate, newGate, glue); } -void SlowPathLowering::LowerCallArg0Dyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerCallArg0(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCallArg0DynPrefV8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCallArg0Imm8V8))); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); - GateRef actualArgc = builder_.Int64(ComputeCallArgc(gate, EcmaOpcode::CALLARG0DYN_PREF_V8)); + GateRef actualArgc = builder_.Int64(ComputeCallArgc(gate, EcmaOpcode::CALLARG0_IMM8_V8)); GateRef newTarget = builder_.Undefined(); GateRef thisObj = builder_.Undefined(); GateRef func = acc_.GetValueIn(gate, 0); @@ -928,13 +928,13 @@ void SlowPathLowering::LowerCallArg0Dyn(GateRef gate, GateRef glue) LowerToJSCall(gate, glue, {glue, env, actualArgc, func, newTarget, thisObj, bcOffset}); } -void SlowPathLowering::LowerCallArg1Dyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerCallArg1(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCallArg1DynPrefV8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCallArg1Imm8V8V8))); // 3: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 3); // 2: func and bcoffset - GateRef actualArgc = builder_.Int64(ComputeCallArgc(gate, EcmaOpcode::CALLARG1DYN_PREF_V8_V8)); + GateRef actualArgc = builder_.Int64(ComputeCallArgc(gate, EcmaOpcode::CALLARG1_IMM8_V8_V8)); GateRef newTarget = builder_.Undefined(); GateRef thisObj = builder_.Undefined(); GateRef func = acc_.GetValueIn(gate, 0); @@ -943,13 +943,13 @@ void SlowPathLowering::LowerCallArg1Dyn(GateRef gate, GateRef glue) LowerToJSCall(gate, glue, {glue, env, actualArgc, func, newTarget, thisObj, acc_.GetValueIn(gate, 1), bcOffset}); } -void SlowPathLowering::LowerCallArgs2Dyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerCallArgs2(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCallArgs2DynPrefV8V8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCallArgs2Imm8V8V8V8))); // 4: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 4); // 2: func and bcoffset - GateRef actualArgc = builder_.Int64(ComputeCallArgc(gate, EcmaOpcode::CALLARGS2DYN_PREF_V8_V8_V8)); + GateRef actualArgc = builder_.Int64(ComputeCallArgc(gate, EcmaOpcode::CALLARGS2_IMM8_V8_V8_V8)); GateRef newTarget = builder_.Undefined(); GateRef thisObj = builder_.Undefined(); GateRef func = acc_.GetValueIn(gate, 0); @@ -959,12 +959,12 @@ void SlowPathLowering::LowerCallArgs2Dyn(GateRef gate, GateRef glue) acc_.GetValueIn(gate, 2), bcOffset}); } -void SlowPathLowering::LowerCallArgs3Dyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerCallArgs3(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCallArgs3DynPrefV8V8V8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCallArgs3Imm8V8V8V8V8))); // 5: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 5); - GateRef actualArgc = builder_.Int64(ComputeCallArgc(gate, EcmaOpcode::CALLARGS3DYN_PREF_V8_V8_V8_V8)); + GateRef actualArgc = builder_.Int64(ComputeCallArgc(gate, EcmaOpcode::CALLARGS3_IMM8_V8_V8_V8_V8)); GateRef newTarget = builder_.Undefined(); GateRef thisObj = builder_.Undefined(); GateRef func = acc_.GetValueIn(gate, 0); @@ -974,14 +974,14 @@ void SlowPathLowering::LowerCallArgs3Dyn(GateRef gate, GateRef glue) acc_.GetValueIn(gate, 2), acc_.GetValueIn(gate, 3), bcOffset}); } -void SlowPathLowering::LowerCallIThisRangeDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerCallThisRange(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCallIThisRangeDynPrefImm16V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCallThisRangeImm8Imm16V8))); std::vector vec; // The first register input is callTarget, second is thisObj and other inputs are common args. size_t fixedInputsNum = 2; ASSERT(acc_.GetNumValueIn(gate) - fixedInputsNum >= 0); - GateRef actualArgc = builder_.Int64(ComputeCallArgc(gate, EcmaOpcode::CALLITHISRANGEDYN_PREF_IMM16_V8)); + GateRef actualArgc = builder_.Int64(ComputeCallArgc(gate, EcmaOpcode::CALLTHISRANGE_IMM8_IMM16_V8)); GateRef callTarget = acc_.GetValueIn(gate, 0); GateRef thisObj = acc_.GetValueIn(gate, 1); GateRef newTarget = builder_.Undefined(); @@ -1000,10 +1000,10 @@ void SlowPathLowering::LowerCallIThisRangeDyn(GateRef gate, GateRef glue) LowerToJSCall(gate, glue, vec); } -void SlowPathLowering::LowerCallSpreadDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerCallSpread(GateRef gate, GateRef glue) { // need to fixed in later - const int id = RTSTUB_ID(CallSpreadDyn); + const int id = RTSTUB_ID(CallSpread); // 3: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 3); GateRef newGate = LowerCallRuntime(glue, id, @@ -1011,12 +1011,12 @@ void SlowPathLowering::LowerCallSpreadDyn(GateRef gate, GateRef glue) ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerCallIRangeDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerCallRange(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCallIRangeDynPrefImm16V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCallRangeImm8Imm16V8))); std::vector vec; size_t numArgs = acc_.GetNumValueIn(gate); - GateRef actualArgc = builder_.Int64(ComputeCallArgc(gate, EcmaOpcode::CALLIRANGEDYN_PREF_IMM16_V8)); + GateRef actualArgc = builder_.Int64(ComputeCallArgc(gate, EcmaOpcode::CALLRANGE_IMM8_IMM16_V8)); GateRef callTarget = acc_.GetValueIn(gate, 0); GateRef newTarget = builder_.Undefined(); GateRef thisObj = builder_.Undefined(); @@ -1034,10 +1034,10 @@ void SlowPathLowering::LowerCallIRangeDyn(GateRef gate, GateRef glue) LowerToJSCall(gate, glue, vec); } -void SlowPathLowering::LowerNewObjSpreadDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerNewObjApply(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleNewObjSpreadDynPrefV8V8))); - const int id = RTSTUB_ID(NewObjSpreadDyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleNewObjApplyImm8V8))); + const int id = RTSTUB_ID(NewObjApply); // 3: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 3); GateRef newGate = LowerCallRuntime(glue, id, @@ -1045,9 +1045,9 @@ void SlowPathLowering::LowerNewObjSpreadDyn(GateRef gate, GateRef glue) ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerThrowDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerThrow(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleThrowDynPref))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleThrow))); GateRef exception = acc_.GetValueIn(gate, 0); GateRef exceptionOffset = builder_.Int64(JSThread::GlueData::GetExceptionOffset(false)); GateRef val = builder_.Int64Add(glue, exceptionOffset); @@ -1058,7 +1058,7 @@ void SlowPathLowering::LowerThrowDyn(GateRef gate, GateRef glue) void SlowPathLowering::LowerThrowConstAssignment(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleThrowConstAssignmentPrefV8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleThrowConstAssignmentV8))); const int id = RTSTUB_ID(ThrowConstAssignment); // 1: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 1); @@ -1068,7 +1068,7 @@ void SlowPathLowering::LowerThrowConstAssignment(GateRef gate, GateRef glue) void SlowPathLowering::LowerThrowThrowNotExists(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleThrowThrowNotExistsPref))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleThrowThrowNotExists))); const int id = RTSTUB_ID(ThrowThrowNotExists); GateRef newGate = LowerCallRuntime(glue, id, {}); ReplaceHirToThrowCall(gate, newGate); @@ -1076,7 +1076,7 @@ void SlowPathLowering::LowerThrowThrowNotExists(GateRef gate, GateRef glue) void SlowPathLowering::LowerThrowPatternNonCoercible(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleThrowPatternNonCoerciblePref))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleThrowPatternNonCoercible))); const int id = RTSTUB_ID(ThrowPatternNonCoercible); GateRef newGate = LowerCallRuntime(glue, id, {}); ReplaceHirToThrowCall(gate, newGate); @@ -1084,7 +1084,7 @@ void SlowPathLowering::LowerThrowPatternNonCoercible(GateRef gate, GateRef glue) void SlowPathLowering::LowerThrowIfNotObject(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleThrowIfNotObjectPrefV8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleThrowIfNotObjectV8))); // 1: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 1); GateRef value = acc_.GetValueIn(gate, 0); @@ -1111,7 +1111,7 @@ void SlowPathLowering::LowerThrowIfNotObject(GateRef gate, GateRef glue) void SlowPathLowering::LowerThrowUndefinedIfHole(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleThrowIfNotObjectPrefV8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleThrowIfNotObjectV8))); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef hole = acc_.GetValueIn(gate, 0); @@ -1136,7 +1136,7 @@ void SlowPathLowering::LowerThrowUndefinedIfHole(GateRef gate, GateRef glue) void SlowPathLowering::LowerThrowIfSuperNotCorrectCall(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleThrowIfSuperNotCorrectCallPrefImm16))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleThrowIfSuperNotCorrectCallImm16))); Label successExit(&builder_); Label exceptionExit(&builder_); // 2: number of value inputs @@ -1151,7 +1151,7 @@ void SlowPathLowering::LowerThrowIfSuperNotCorrectCall(GateRef gate, GateRef glu void SlowPathLowering::LowerThrowDeleteSuperProperty(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleThrowDeleteSuperPropertyPref))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleThrowDeleteSuperProperty))); const int id = RTSTUB_ID(ThrowDeleteSuperProperty); GateRef newGate = LowerCallRuntime(glue, id, {}); ReplaceHirToThrowCall(gate, newGate); @@ -1183,7 +1183,7 @@ void SlowPathLowering::LowerExceptionHandler(GateRef hirGate) void SlowPathLowering::LowerLdSymbol(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdSymbolPref))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdSymbol))); const int id = RTSTUB_ID(GetSymbolFunction); GateRef newGate = LowerCallRuntime(glue, id, {}); ReplaceHirToCall(gate, newGate); @@ -1191,7 +1191,7 @@ void SlowPathLowering::LowerLdSymbol(GateRef gate, GateRef glue) void SlowPathLowering::LowerLdGlobal(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdGlobalPref))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdGlobal))); GateRef offset = builder_.Int64(JSThread::GlueData::GetGlobalObjOffset(false)); GateRef val = builder_.Int64Add(glue, offset); GateRef newGate = circuit_->NewGate(OpCode(OpCode::LOAD), VariableType::JS_ANY().GetMachineType(), @@ -1199,100 +1199,100 @@ void SlowPathLowering::LowerLdGlobal(GateRef gate, GateRef glue) ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerSub2Dyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerSub2(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleSub2DynPrefV8))); - const int id = RTSTUB_ID(Sub2Dyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleSub2Imm8V8))); + const int id = RTSTUB_ID(Sub2); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0), acc_.GetValueIn(gate, 1)}); ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerMul2Dyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerMul2(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleMul2DynPrefV8))); - const int id = RTSTUB_ID(Mul2Dyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleMul2Imm8V8))); + const int id = RTSTUB_ID(Mul2); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0), acc_.GetValueIn(gate, 1)}); ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerDiv2Dyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerDiv2(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleDiv2DynPrefV8))); - const int id = RTSTUB_ID(Div2Dyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleDiv2Imm8V8))); + const int id = RTSTUB_ID(Div2); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0), acc_.GetValueIn(gate, 1)}); ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerMod2Dyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerMod2(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleMod2DynPrefV8))); - const int id = RTSTUB_ID(Mod2Dyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleMod2Imm8V8))); + const int id = RTSTUB_ID(Mod2); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0), acc_.GetValueIn(gate, 1)}); ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerEqDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerEq(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleEqDynPrefV8))); - const int id = RTSTUB_ID(EqDyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleEqImm8V8))); + const int id = RTSTUB_ID(Eq); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0), acc_.GetValueIn(gate, 1)}); ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerNotEqDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerNotEq(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleNotEqDynPrefV8))); - const int id = RTSTUB_ID(NotEqDyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleNotEqImm8V8))); + const int id = RTSTUB_ID(NotEq); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0), acc_.GetValueIn(gate, 1)}); ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerLessDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerLess(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLessDynPrefV8))); - const int id = RTSTUB_ID(LessDyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLessImm8V8))); + const int id = RTSTUB_ID(Less); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0), acc_.GetValueIn(gate, 1)}); ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerLessEqDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerLessEq(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLessEqDynPrefV8))); - const int id = RTSTUB_ID(LessEqDyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLessEqImm8V8))); + const int id = RTSTUB_ID(LessEq); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0), acc_.GetValueIn(gate, 1)}); ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerGreaterDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerGreater(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleGreaterDynPrefV8))); - const int id = RTSTUB_ID(GreaterDyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleGreaterImm8V8))); + const int id = RTSTUB_ID(Greater); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0), acc_.GetValueIn(gate, 1)}); ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerGreaterEqDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerGreaterEq(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleGreaterEqDynPrefV8))); - const int id = RTSTUB_ID(GreaterEqDyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleGreaterEqImm8V8))); + const int id = RTSTUB_ID(GreaterEq); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0), acc_.GetValueIn(gate, 1)}); @@ -1301,7 +1301,7 @@ void SlowPathLowering::LowerGreaterEqDyn(GateRef gate, GateRef glue) void SlowPathLowering::LowerGetPropIterator(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleGetPropIteratorPref))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleGetPropIterator))); const int id = RTSTUB_ID(GetPropIterator); // 1: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 1); @@ -1311,7 +1311,7 @@ void SlowPathLowering::LowerGetPropIterator(GateRef gate, GateRef glue) void SlowPathLowering::LowerIterNext(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleIterNextPrefV8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleIterNextImm8V8))); const int id = RTSTUB_ID(IterNext); // 1: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 1); @@ -1321,7 +1321,7 @@ void SlowPathLowering::LowerIterNext(GateRef gate, GateRef glue) void SlowPathLowering::LowerCloseIterator(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCloseIteratorPrefV8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCloseIteratorImm8V8))); const int id = RTSTUB_ID(CloseIterator); // 1: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 1); @@ -1329,20 +1329,20 @@ void SlowPathLowering::LowerCloseIterator(GateRef gate, GateRef glue) ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerIncDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerInc(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleIncDynPrefV8))); - const int id = RTSTUB_ID(IncDyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleIncImm8V8))); + const int id = RTSTUB_ID(Inc); // 1: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 1); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0)}); ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerDecDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerDec(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleDecDynPrefV8))); - const int id = RTSTUB_ID(DecDyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleDecImm8V8))); + const int id = RTSTUB_ID(Dec); // 1: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 1); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0)}); @@ -1351,7 +1351,7 @@ void SlowPathLowering::LowerDecDyn(GateRef gate, GateRef glue) void SlowPathLowering::LowerToNumber(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleToNumberPrefV8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleToNumberImm8V8))); const int id = RTSTUB_ID(ToNumber); // 1: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 1); @@ -1359,80 +1359,80 @@ void SlowPathLowering::LowerToNumber(GateRef gate, GateRef glue) ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerNegDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerNeg(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleNegDynPrefV8))); - const int id = RTSTUB_ID(NegDyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleNegImm8V8))); + const int id = RTSTUB_ID(Neg); // 1: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 1); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0)}); ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerNotDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerNot(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleNotDynPrefV8))); - const int id = RTSTUB_ID(NotDyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleNotImm8V8))); + const int id = RTSTUB_ID(Not); // 1: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 1); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0)}); ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerShl2Dyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerShl2(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleShl2DynPrefV8))); - const int id = RTSTUB_ID(Shl2Dyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleShl2Imm8V8))); + const int id = RTSTUB_ID(Shl2); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0), acc_.GetValueIn(gate, 1)}); ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerShr2Dyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerShr2(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleShr2DynPrefV8))); - const int id = RTSTUB_ID(Shr2Dyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleShr2Imm8V8))); + const int id = RTSTUB_ID(Shr2); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0), acc_.GetValueIn(gate, 1)}); ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerAshr2Dyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerAshr2(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleAshr2DynPrefV8))); - const int id = RTSTUB_ID(Ashr2Dyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleAshr2Imm8V8))); + const int id = RTSTUB_ID(Ashr2); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0), acc_.GetValueIn(gate, 1)}); ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerAnd2Dyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerAnd2(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleAnd2DynPrefV8))); - const int id = RTSTUB_ID(And2Dyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleAnd2Imm8V8))); + const int id = RTSTUB_ID(And2); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0), acc_.GetValueIn(gate, 1)}); ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerOr2Dyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerOr2(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleOr2DynPrefV8))); - const int id = RTSTUB_ID(Or2Dyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleOr2Imm8V8))); + const int id = RTSTUB_ID(Or2); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0), acc_.GetValueIn(gate, 1)}); ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerXor2Dyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerXor2(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleXOr2DynPrefV8))); - const int id = RTSTUB_ID(Xor2Dyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleXOr2Imm8V8))); + const int id = RTSTUB_ID(Xor2); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0), acc_.GetValueIn(gate, 1)}); @@ -1441,7 +1441,7 @@ void SlowPathLowering::LowerXor2Dyn(GateRef gate, GateRef glue) void SlowPathLowering::LowerDelObjProp(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleDelObjPropPrefV8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleDelObjPropV8V8))); const int id = RTSTUB_ID(DelObjProp); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); @@ -1449,30 +1449,30 @@ void SlowPathLowering::LowerDelObjProp(GateRef gate, GateRef glue) ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerExpDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerExp(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleExpDynPrefV8))); - const int id = RTSTUB_ID(ExpDyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleExpImm8V8))); + const int id = RTSTUB_ID(Exp); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0), acc_.GetValueIn(gate, 1)}); ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerIsInDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerIsIn(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleIsInDynPrefV8))); - const int id = RTSTUB_ID(IsInDyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleIsInImm8V8))); + const int id = RTSTUB_ID(IsIn); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0), acc_.GetValueIn(gate, 1)}); ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerInstanceofDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerInstanceof(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleInstanceOfDynPrefV8))); - const int id = RTSTUB_ID(InstanceOfDyn); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleInstanceOfImm8V8))); + const int id = RTSTUB_ID(InstanceOf); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef newGate = LowerCallRuntime(glue, id, {acc_.GetValueIn(gate, 0), acc_.GetValueIn(gate, 1)}); @@ -1481,7 +1481,7 @@ void SlowPathLowering::LowerInstanceofDyn(GateRef gate, GateRef glue) void SlowPathLowering::LowerFastStrictNotEqual(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStrictNotEqDynPrefV8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStrictNotEqImm8V8))); const int id = RTSTUB_ID(FastStrictNotEqual); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); @@ -1491,7 +1491,7 @@ void SlowPathLowering::LowerFastStrictNotEqual(GateRef gate, GateRef glue) void SlowPathLowering::LowerFastStrictEqual(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStrictEqDynPrefV8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStrictEqImm8V8))); const int id = RTSTUB_ID(FastStrictEqual); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); @@ -1501,7 +1501,7 @@ void SlowPathLowering::LowerFastStrictEqual(GateRef gate, GateRef glue) void SlowPathLowering::LowerCreateEmptyArray(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCreateEmptyArrayPref))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCreateEmptyArrayImm8))); std::vector successControl; std::vector failControl; GateRef result = LowerCallRuntime(glue, RTSTUB_ID(CreateEmptyArray), {}, true); @@ -1514,7 +1514,7 @@ void SlowPathLowering::LowerCreateEmptyArray(GateRef gate, GateRef glue) void SlowPathLowering::LowerCreateEmptyObject(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCreateEmptyObjectPref))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCreateEmptyObject))); std::vector successControl; std::vector failControl; GateRef result = LowerCallRuntime(glue, RTSTUB_ID(CreateEmptyObject), {}, true); @@ -1527,7 +1527,7 @@ void SlowPathLowering::LowerCreateEmptyObject(GateRef gate, GateRef glue) void SlowPathLowering::LowerCreateArrayWithBuffer(GateRef gate, GateRef glue, GateRef jsFunc) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCreateArrayWithBufferPrefImm16))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCreateArrayWithBufferImm8Imm16))); Label successExit(&builder_); Label exceptionExit(&builder_); // 1: number of value inputs @@ -1543,7 +1543,7 @@ void SlowPathLowering::LowerCreateArrayWithBuffer(GateRef gate, GateRef glue, Ga void SlowPathLowering::LowerCreateObjectWithBuffer(GateRef gate, GateRef glue, GateRef jsFunc) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCreateObjectWithBufferPrefImm16))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCreateObjectWithBufferImm8Imm16))); Label successExit(&builder_); Label exceptionExit(&builder_); // 1: number of value inputs @@ -1559,7 +1559,7 @@ void SlowPathLowering::LowerCreateObjectWithBuffer(GateRef gate, GateRef glue, G void SlowPathLowering::LowerStModuleVar(GateRef gate, GateRef glue, GateRef jsFunc) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStModuleVarPrefId32))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStModuleVarId16))); std::vector successControl; std::vector failControl; // 2: number of value inputs @@ -1578,7 +1578,7 @@ void SlowPathLowering::LowerStModuleVar(GateRef gate, GateRef glue, GateRef jsFu void SlowPathLowering::LowerGetTemplateObject(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleGetTemplateObjectPrefV8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleGetTemplateObjectImm8V8))); const int id = RTSTUB_ID(GetTemplateObject); // 1: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 1); @@ -1589,7 +1589,7 @@ void SlowPathLowering::LowerGetTemplateObject(GateRef gate, GateRef glue) void SlowPathLowering::LowerSetObjectWithProto(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleSetObjectWithProtoPrefV8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleSetObjectWithProtoImm8V8V8))); const int id = RTSTUB_ID(SetObjectWithProto); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); @@ -1601,7 +1601,7 @@ void SlowPathLowering::LowerSetObjectWithProto(GateRef gate, GateRef glue) void SlowPathLowering::LowerLdBigInt(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdBigIntPrefId32))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdBigIntId16))); Label successExit(&builder_); Label exceptionExit(&builder_); // 1: number of value inputs @@ -1617,7 +1617,7 @@ void SlowPathLowering::LowerLdBigInt(GateRef gate, GateRef glue) void SlowPathLowering::LowerToNumeric(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleToNumericPrefV8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleToNumericImm8V8))); const int id = RTSTUB_ID(ToNumeric); // 1: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 1); @@ -1627,7 +1627,7 @@ void SlowPathLowering::LowerToNumeric(GateRef gate, GateRef glue) void SlowPathLowering::LowerLdModuleVar(GateRef gate, GateRef glue, GateRef jsFunc) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdModuleVarPrefId32Imm8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdModuleVarId16Imm8))); std::vector successControl; std::vector failControl; // 2: number of value inputs @@ -1645,7 +1645,7 @@ void SlowPathLowering::LowerLdModuleVar(GateRef gate, GateRef glue, GateRef jsFu void SlowPathLowering::LowerGetModuleNamespace(GateRef gate, GateRef glue, GateRef jsFunc) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleGetModuleNamespacePrefId32))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleGetModuleNamespaceId16))); std::vector successControl; std::vector failControl; // 1: number of value inputs @@ -1662,7 +1662,7 @@ void SlowPathLowering::LowerGetModuleNamespace(GateRef gate, GateRef glue, GateR void SlowPathLowering::LowerGetIteratorNext(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleGetIteratorNextPrefV8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleGetIteratorNextV8V8))); const int id = RTSTUB_ID(GetIteratorNext); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); @@ -1674,7 +1674,7 @@ void SlowPathLowering::LowerGetIteratorNext(GateRef gate, GateRef glue) void SlowPathLowering::LowerSuperCall(GateRef gate, GateRef glue, GateRef newTarget) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleSuperCallPrefImm16V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleSuperCallImm8Imm16V8))); const int id = RTSTUB_ID(OptSuperCall); std::vector vec; // 3: number of value inputs @@ -1693,7 +1693,7 @@ void SlowPathLowering::LowerSuperCall(GateRef gate, GateRef glue, GateRef newTar void SlowPathLowering::LowerSuperCallSpread(GateRef gate, GateRef glue, GateRef newTarget) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleSuperCallSpreadPrefV8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleSuperCallSpreadImm8V8))); const int id = RTSTUB_ID(OptSuperCallSpread); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); @@ -1706,9 +1706,9 @@ void SlowPathLowering::LowerSuperCallSpread(GateRef gate, GateRef glue, GateRef void SlowPathLowering::LowerIsTrueOrFalse(GateRef gate, GateRef glue, bool flag) { if (flag) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleIsTruePref))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleIsTrue))); } else { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleIsFalsePref))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleIsFalse))); } Label isTrue(&builder_); Label isFalse(&builder_); @@ -1741,10 +1741,10 @@ void SlowPathLowering::LowerIsTrueOrFalse(GateRef gate, GateRef glue, bool flag) ReplaceHirToSubCfg(gate, *result, successControl, exceptionControl, true); } -void SlowPathLowering::LowerNewObjDynRange(GateRef gate, GateRef glue) +void SlowPathLowering::LowerNewObjRange(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleNewObjDynRangePrefImm16V8))); - const int id = RTSTUB_ID(OptNewObjDynRange); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleNewObjRangeImm8Imm16V8))); + const int id = RTSTUB_ID(OptNewObjRange); size_t range = acc_.GetNumValueIn(gate); std::vector args(range); for (size_t i = 0; i < range; ++i) { @@ -1817,7 +1817,7 @@ void SlowPathLowering::LowerConditionJump(GateRef gate, bool isEqualJump) void SlowPathLowering::LowerGetNextPropName(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleGetNextPropNamePrefV8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleGetNextPropNameV8))); const int id = RTSTUB_ID(GetNextPropName); // 1: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 1); @@ -1828,7 +1828,7 @@ void SlowPathLowering::LowerGetNextPropName(GateRef gate, GateRef glue) void SlowPathLowering::LowerCopyDataProperties(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCopyDataPropertiesPrefV8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCopyDataPropertiesV8V8))); const int id = RTSTUB_ID(CopyDataProperties); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); @@ -1840,7 +1840,7 @@ void SlowPathLowering::LowerCopyDataProperties(GateRef gate, GateRef glue) void SlowPathLowering::LowerCreateObjectWithExcludedKeys(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCreateObjectWithExcludedKeysPrefImm16V8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCreateObjectWithExcludedKeysImm8V8V8))); const int id = RTSTUB_ID(CreateObjectWithExcludedKeys); // 3: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 3); @@ -1854,7 +1854,7 @@ void SlowPathLowering::LowerCreateObjectWithExcludedKeys(GateRef gate, GateRef g void SlowPathLowering::LowerCreateRegExpWithLiteral(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCreateRegExpWithLiteralPrefId32Imm8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCreateRegExpWithLiteralImm8Id16Imm8))); const int id = RTSTUB_ID(CreateRegExpWithLiteral); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); @@ -1866,7 +1866,7 @@ void SlowPathLowering::LowerCreateRegExpWithLiteral(GateRef gate, GateRef glue) void SlowPathLowering::LowerStOwnByValue(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStOwnByValuePrefV8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStOwnByValueImm8V8V8))); // 3: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 3); GateRef receiver = acc_.GetValueIn(gate, 0); @@ -1908,7 +1908,7 @@ void SlowPathLowering::LowerStOwnByValue(GateRef gate, GateRef glue) void SlowPathLowering::LowerStOwnByIndex(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStOwnByIndexPrefV8Imm32))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStOwnByIndexImm8V8Imm32))); // 3: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 3); GateRef receiver = acc_.GetValueIn(gate, 0); @@ -1951,7 +1951,7 @@ void SlowPathLowering::LowerStOwnByIndex(GateRef gate, GateRef glue) void SlowPathLowering::LowerStOwnByName(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStOwnByNamePrefId32V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStOwnByNameImm8Id16V8))); // 3: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 3); auto args = { builder_.TaggedTypeNGC(builder_.ZExtInt32ToInt64(acc_.GetValueIn(gate, 0))) }; @@ -1994,7 +1994,7 @@ void SlowPathLowering::LowerStOwnByName(GateRef gate, GateRef glue) void SlowPathLowering::LowerDefineGeneratorFunc(GateRef gate, GateRef glue, GateRef jsFunc) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleDefineGeneratorFuncPrefId16Imm16V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleDefineGeneratorFuncImm8Id16Imm16V8))); // 3: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 3); GateRef methodId = builder_.ZExtInt16ToInt32(acc_.GetValueIn(gate, 0)); @@ -2090,7 +2090,7 @@ void SlowPathLowering::LowerDefineAsyncGeneratorFunc(GateRef gate, GateRef glue, void SlowPathLowering::LowerDefineAsyncFunc(GateRef gate, GateRef glue, GateRef jsFunc) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleDefineAsyncFuncPrefId16Imm16V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleDefineAsyncFuncImm8Id16Imm16V8))); // 3: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 3); GateRef methodId = builder_.ZExtInt16ToInt32(acc_.GetValueIn(gate, 0)); @@ -2136,15 +2136,15 @@ void SlowPathLowering::LowerDefineAsyncFunc(GateRef gate, GateRef glue, GateRef ReplaceHirToSubCfg(gate, result, successControl, failControl); } -void SlowPathLowering::LowerNewLexicalEnvDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerNewLexicalEnv(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleNewLexEnvDynPrefImm16))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleNewLexEnvImm8))); Label successExit(&builder_); Label exceptionExit(&builder_); // 1: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 1); GateRef lexEnv = LowerCallRuntime(glue, RTSTUB_ID(OptGetLexicalEnv), {}, true); - GateRef result = LowerCallRuntime(glue, RTSTUB_ID(OptNewLexicalEnvDyn), + GateRef result = LowerCallRuntime(glue, RTSTUB_ID(OptNewLexicalEnv), {builder_.TaggedTypeNGC(acc_.GetValueIn(gate, 0)), lexEnv}, true); builder_.Branch(builder_.IsSpecial(result, JSTaggedValue::VALUE_EXCEPTION), &exceptionExit, &successExit); @@ -2152,9 +2152,9 @@ void SlowPathLowering::LowerNewLexicalEnvDyn(GateRef gate, GateRef glue) ReplaceHirToSubCfg(gate, result, successControl, failControl); } -void SlowPathLowering::LowerNewLexicalEnvWithNameDyn(GateRef gate, GateRef glue, GateRef jsFunc) +void SlowPathLowering::LowerNewLexicalEnvWithName(GateRef gate, GateRef glue, GateRef jsFunc) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleNewLexEnvWithNameDynPrefImm16Imm16))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleNewLexEnvWithNameImm16Imm16))); std::vector successControl; std::vector failControl; // 2: number of value inputs @@ -2163,7 +2163,7 @@ void SlowPathLowering::LowerNewLexicalEnvWithNameDyn(GateRef gate, GateRef glue, auto args = { builder_.TaggedTypeNGC(acc_.GetValueIn(gate, 0)), builder_.TaggedTypeNGC(acc_.GetValueIn(gate, 1)), lexEnv, jsFunc}; - GateRef result = LowerCallRuntime(glue, RTSTUB_ID(OptNewLexicalEnvWithNameDyn), args, true); + GateRef result = LowerCallRuntime(glue, RTSTUB_ID(OptNewLexicalEnvWithName), args, true); successControl.emplace_back(builder_.GetState()); successControl.emplace_back(builder_.GetDepend()); failControl.emplace_back(Circuit::NullGate()); @@ -2173,7 +2173,7 @@ void SlowPathLowering::LowerNewLexicalEnvWithNameDyn(GateRef gate, GateRef glue, void SlowPathLowering::LowerPopLexicalEnv(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandlePopLexEnvDynPref))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandlePopLexEnv))); std::vector successControl; std::vector failControl; LowerCallRuntime(glue, RTSTUB_ID(OptPopLexicalEnv), {}, true); @@ -2186,7 +2186,7 @@ void SlowPathLowering::LowerPopLexicalEnv(GateRef gate, GateRef glue) void SlowPathLowering::LowerLdSuperByValue(GateRef gate, GateRef glue, GateRef jsFunc) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdSuperByValuePrefV8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdSuperByValueImm8V8V8))); const int id = RTSTUB_ID(OptLdSuperByValue); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); @@ -2198,7 +2198,7 @@ void SlowPathLowering::LowerLdSuperByValue(GateRef gate, GateRef glue, GateRef j void SlowPathLowering::LowerStSuperByValue(GateRef gate, GateRef glue, GateRef jsFunc) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStSuperByValuePrefV8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStSuperByValueImm8V8V8))); const int id = RTSTUB_ID(OptStSuperByValue); // 3: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 3); @@ -2211,7 +2211,7 @@ void SlowPathLowering::LowerStSuperByValue(GateRef gate, GateRef glue, GateRef j void SlowPathLowering::LowerTryStGlobalByName(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleTryStGlobalByNamePrefId32))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleTryStGlobalByNameImm8Id16))); // order: 1. global record 2. global object DEFVAlUE(res, (&builder_), VariableType::JS_ANY(), builder_.Int64(JSTaggedValue::VALUE_HOLE)); // 2 : number of value inputs @@ -2259,7 +2259,7 @@ void SlowPathLowering::LowerTryStGlobalByName(GateRef gate, GateRef glue) void SlowPathLowering::LowerStConstToGlobalRecord(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStConstToGlobalRecordPrefId32))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStConstToGlobalRecordId16))); GateRef propKey = GetValueFromConstStringTable(glue, gate, 0); acc_.SetDep(gate, propKey); // 2 : number of value inputs @@ -2273,7 +2273,7 @@ void SlowPathLowering::LowerStConstToGlobalRecord(GateRef gate, GateRef glue) void SlowPathLowering::LowerStLetToGlobalRecord(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStLetToGlobalRecordPrefId32))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStLetToGlobalRecordId16))); Label successExit(&builder_); Label exceptionExit(&builder_); // 2: number of value inputs @@ -2291,7 +2291,7 @@ void SlowPathLowering::LowerStLetToGlobalRecord(GateRef gate, GateRef glue) void SlowPathLowering::LowerStClassToGlobalRecord(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStClassToGlobalRecordPrefId32))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStClassToGlobalRecordId16))); Label successExit(&builder_); Label exceptionExit(&builder_); // 2: number of value inputs @@ -2309,7 +2309,7 @@ void SlowPathLowering::LowerStClassToGlobalRecord(GateRef gate, GateRef glue) void SlowPathLowering::LowerStOwnByValueWithNameSet(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStOwnByValueWithNameSetPrefV8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStOwnByValueWithNameSetImm8V8V8))); // 3: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 3); GateRef receiver = acc_.GetValueIn(gate, 0); @@ -2360,7 +2360,7 @@ void SlowPathLowering::LowerStOwnByValueWithNameSet(GateRef gate, GateRef glue) void SlowPathLowering::LowerStOwnByNameWithNameSet(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStOwnByNameWithNameSetPrefId32V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStOwnByNameWithNameSetImm8Id16V8))); // 3: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 3); GateRef stringId = builder_.TaggedTypeNGC(builder_.ZExtInt32ToInt64(acc_.GetValueIn(gate, 0))); @@ -2412,7 +2412,7 @@ void SlowPathLowering::LowerStOwnByNameWithNameSet(GateRef gate, GateRef glue) void SlowPathLowering::LowerLdGlobalVar(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdGlobalVarPrefId32))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdGlobalVarId16))); std::vector successControl; std::vector failControl; Label successExit(&builder_); @@ -2449,7 +2449,7 @@ void SlowPathLowering::LowerLdGlobalVar(GateRef gate, GateRef glue) void SlowPathLowering::LowerLdObjByName(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdObjByNamePrefId32V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdObjByNameImm8Id16V8))); std::vector successControl; std::vector failControl; GateRef holeConst = builder_.HoleConstant(); @@ -2499,7 +2499,7 @@ void SlowPathLowering::LowerLdObjByName(GateRef gate, GateRef glue) void SlowPathLowering::LowerStObjByName(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStObjByNamePrefId32V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStObjByNameImm8Id16V8))); Label receiverIsHeapObject(&builder_); Label slowPath(&builder_); Label successExit(&builder_); @@ -2535,7 +2535,7 @@ void SlowPathLowering::LowerStObjByName(GateRef gate, GateRef glue) void SlowPathLowering::LowerDefineGetterSetterByValue(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleDefineGetterSetterByValuePrefV8V8V8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleDefineGetterSetterByValueV8V8V8V8))); const int id = RTSTUB_ID(DefineGetterSetterByValue); // 5: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 5); @@ -2551,7 +2551,7 @@ void SlowPathLowering::LowerDefineGetterSetterByValue(GateRef gate, GateRef glue void SlowPathLowering::LowerLdObjByIndex(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdObjByIndexPrefV8Imm32))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdObjByIndexImm8V8Imm32))); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); std::vector successControl; @@ -2601,7 +2601,7 @@ void SlowPathLowering::LowerLdObjByIndex(GateRef gate, GateRef glue) void SlowPathLowering::LowerStObjByIndex(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStObjByIndexPrefV8Imm32))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStObjByIndexImm8V8Imm32))); // 3: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 3); Label successExit(&builder_); @@ -2636,7 +2636,7 @@ void SlowPathLowering::LowerStObjByIndex(GateRef gate, GateRef glue) void SlowPathLowering::LowerLdObjByValue(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdObjByValuePrefV8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdObjByValueImm8V8V8))); std::vector successControl; std::vector failControl; // 2: number of value inputs @@ -2685,7 +2685,7 @@ void SlowPathLowering::LowerLdObjByValue(GateRef gate, GateRef glue) void SlowPathLowering::LowerStObjByValue(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStObjByValuePrefV8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStObjByValueImm8V8V8))); // 3: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 3); GateRef receiver = acc_.GetValueIn(gate, 0); @@ -2722,7 +2722,7 @@ void SlowPathLowering::LowerStObjByValue(GateRef gate, GateRef glue) void SlowPathLowering::LowerLdSuperByName(GateRef gate, GateRef glue, GateRef jsFunc) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdSuperByNamePrefId32V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdSuperByNameImm8Id16V8))); Label successExit(&builder_); Label exceptionExit(&builder_); // 2: number of value inputs @@ -2739,7 +2739,7 @@ void SlowPathLowering::LowerLdSuperByName(GateRef gate, GateRef glue, GateRef js void SlowPathLowering::LowerStSuperByName(GateRef gate, GateRef glue, GateRef jsFunc) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStSuperByNamePrefId32V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStSuperByNameImm8Id16V8))); Label successExit(&builder_); Label exceptionExit(&builder_); // 3: number of value inputs @@ -2756,7 +2756,7 @@ void SlowPathLowering::LowerStSuperByName(GateRef gate, GateRef glue, GateRef js void SlowPathLowering::LowerCreateGeneratorObj(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCreateGeneratorObjPrefV8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCreateGeneratorObjV8))); const int id = RTSTUB_ID(CreateGeneratorObj); // 1: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 1); @@ -2766,7 +2766,7 @@ void SlowPathLowering::LowerCreateGeneratorObj(GateRef gate, GateRef glue) void SlowPathLowering::LowerCreateAsyncGeneratorObj(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCreateAsyncGeneratorObjPrefV8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCreateAsyncGeneratorObjV8))); int id = RTSTUB_ID(CreateAsyncGeneratorObj); // 1: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 1); @@ -2776,7 +2776,7 @@ void SlowPathLowering::LowerCreateAsyncGeneratorObj(GateRef gate, GateRef glue) void SlowPathLowering::LowerAsyncGeneratorResolve(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleAsyncGeneratorResolvePrefV8V8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleAsyncGeneratorResolveV8V8V8))); int id = RTSTUB_ID(AsyncGeneratorResolve); // 3: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 3); @@ -2789,7 +2789,7 @@ void SlowPathLowering::LowerAsyncGeneratorResolve(GateRef gate, GateRef glue) void SlowPathLowering::LowerStArraySpread(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStArraySpreadPrefV8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStArraySpreadV8V8))); const int id = RTSTUB_ID(StArraySpread); // 3: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 3); @@ -2798,9 +2798,9 @@ void SlowPathLowering::LowerStArraySpread(GateRef gate, GateRef glue) ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerLdLexVarDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerLdLexVar(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdLexEnvDynPref))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleLdLexVarImm4Imm4))); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); GateRef level = builder_.TruncInt64ToInt32(acc_.GetValueIn(gate, 0)); @@ -2832,9 +2832,9 @@ void SlowPathLowering::LowerLdLexVarDyn(GateRef gate, GateRef glue) ReplaceHirToSubCfg(gate, result, successControl, exceptionControl, true); } -void SlowPathLowering::LowerStLexVarDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerStLexVar(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStLexVarDynPrefImm4Imm4V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleStLexVarImm4Imm4V8))); // 3: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 3); GateRef level = builder_.TruncInt64ToInt32(acc_.GetValueIn(gate, 0)); @@ -2863,13 +2863,13 @@ void SlowPathLowering::LowerStLexVarDyn(GateRef gate, GateRef glue) successControl.emplace_back(builder_.GetDepend()); exceptionControl.emplace_back(Circuit::NullGate()); exceptionControl.emplace_back(Circuit::NullGate()); - // StLexVarDyn will not be inValue to other hir gates, result gate will be ignored + // StLexVar will not be inValue to other hir gates, result gate will be ignored ReplaceHirToSubCfg(gate, Circuit::NullGate(), successControl, exceptionControl, true); } void SlowPathLowering::LowerCreateObjectHavingMethod(GateRef gate, GateRef glue, GateRef jsFunc) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCreateObjectHavingMethodPrefImm16))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCreateObjectHavingMethodImm8Imm16))); const int id = RTSTUB_ID(CreateObjectHavingMethod); // 2: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 2); @@ -2900,7 +2900,7 @@ void SlowPathLowering::LowerLdHomeObject(GateRef gate, GateRef jsFunc) void SlowPathLowering::LowerDefineClassWithBuffer(GateRef gate, GateRef glue, GateRef jsFunc) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleDefineClassWithBufferPrefId16Imm16Imm16V8V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleDefineClassWithBufferImm8Id16Imm16Imm16V8V8))); // 5: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 5); GateRef methodId = builder_.ZExtInt16ToInt32(acc_.GetValueIn(gate, 0)); @@ -2937,9 +2937,9 @@ void SlowPathLowering::LowerDefineClassWithBuffer(GateRef gate, GateRef glue, Ga ReplaceHirToSubCfg(gate, result, successControl, exceptionControl); } -void SlowPathLowering::LowerDefineFuncDyn(GateRef gate, GateRef glue, GateRef jsFunc) +void SlowPathLowering::LowerDefineFunc(GateRef gate, GateRef glue, GateRef jsFunc) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleDefineFuncDynPrefId16Imm16V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleDefineFuncImm8Id16Imm16V8))); GateRef methodId = acc_.GetValueIn(gate, 0); GateRef length = acc_.GetValueIn(gate, 1); GateRef v0 = acc_.GetValueIn(gate, 2); @@ -2956,7 +2956,7 @@ void SlowPathLowering::LowerDefineFuncDyn(GateRef gate, GateRef glue, GateRef js builder_.Branch(builder_.FunctionIsResolved(*result), &isResolved, ¬Resolved); builder_.Bind(&isResolved); { - result = LowerCallRuntime(glue, RTSTUB_ID(DefinefuncDyn), { *result }); + result = LowerCallRuntime(glue, RTSTUB_ID(Definefunc), { *result }); Label isException(&builder_); Label notException(&builder_); builder_.Branch(builder_.TaggedIsException(*result), &isException, ¬Exception); @@ -2977,8 +2977,8 @@ void SlowPathLowering::LowerDefineFuncDyn(GateRef gate, GateRef glue, GateRef js } builder_.Bind(&defaultLabel); { - GateRef hClass = builder_.LoadHClass(*result); - builder_.SetPropertyInlinedProps(glue, *result, hClass, builder_.TaggedNGC(length), + GateRef hclass = builder_.LoadHClass(*result); + builder_.SetPropertyInlinedProps(glue, *result, hclass, builder_.TaggedNGC(length), builder_.Int32(JSFunction::LENGTH_INLINE_PROPERTY_INDEX), VariableType::INT64()); builder_.SetLexicalEnvToFunction(glue, *result, v0); builder_.SetModuleToFunction(glue, *result, builder_.GetModuleFromFunction(jsFunc)); @@ -3000,7 +3000,7 @@ void SlowPathLowering::LowerDefineFuncDyn(GateRef gate, GateRef glue, GateRef js void SlowPathLowering::LowerAsyncFunctionEnter(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleAsyncFunctionEnterPref))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleAsyncFunctionEnter))); const int id = RTSTUB_ID(AsyncFunctionEnter); // 0: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 0); @@ -3008,9 +3008,9 @@ void SlowPathLowering::LowerAsyncFunctionEnter(GateRef gate, GateRef glue) ReplaceHirToCall(gate, newGate); } -void SlowPathLowering::LowerTypeOfDyn(GateRef gate, GateRef glue) +void SlowPathLowering::LowerTypeof(GateRef gate, GateRef glue) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleTypeOfDynPref))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleTypeofImm8))); // 1: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 1); std::vector successControl; @@ -3232,9 +3232,9 @@ void SlowPathLowering::LowerGetResumeMode(GateRef gate) ReplaceHirToSubCfg(gate, result, successControl, failControl, true); } -void SlowPathLowering::LowerDefineNCFuncDyn(GateRef gate, GateRef glue, GateRef jsFunc) +void SlowPathLowering::LowerDefineNCFunc(GateRef gate, GateRef glue, GateRef jsFunc) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleDefineNCFuncDynPrefId16Imm16V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleDefineNCFuncImm8Id16Imm16V8))); // 4: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 4); GateRef methodId = acc_.GetValueIn(gate, 0); @@ -3251,7 +3251,7 @@ void SlowPathLowering::LowerDefineNCFuncDyn(GateRef gate, GateRef glue, GateRef builder_.Branch(builder_.FunctionIsResolved(*method), &isResolved, ¬Resolved); builder_.Bind(&isResolved); { - method = LowerCallRuntime(glue, RTSTUB_ID(DefineNCFuncDyn), {*method}); + method = LowerCallRuntime(glue, RTSTUB_ID(DefineNCFunc), {*method}); Label notException(&builder_); builder_.Branch(builder_.IsSpecial(*method, JSTaggedValue::VALUE_EXCEPTION), &exceptionExit, ¬Exception); @@ -3284,7 +3284,7 @@ void SlowPathLowering::LowerDefineNCFuncDyn(GateRef gate, GateRef glue, GateRef void SlowPathLowering::LowerDefineMethod(GateRef gate, GateRef glue, GateRef jsFunc) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleDefineMethodPrefId16Imm16V8))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleDefineMethodImm8Id16Imm16V8))); // 4: number of value inputs ASSERT(acc_.GetNumValueIn(gate) == 4); GateRef methodId = acc_.GetValueIn(gate, 0); @@ -3334,7 +3334,7 @@ void SlowPathLowering::LowerDefineMethod(GateRef gate, GateRef glue, GateRef jsF void SlowPathLowering::LowerGetUnmappedArgs(GateRef gate, GateRef glue, GateRef actualArgc) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleGetUnmappedArgsPref))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleGetUnmappedArgs))); GateRef taggedArgc = builder_.TaggedTypeNGC(builder_.ZExtInt32ToInt64(actualArgc)); const int id = RTSTUB_ID(OptGetUnmapedArgs); GateRef newGate = LowerCallRuntime(glue, id, {taggedArgc}); @@ -3343,7 +3343,7 @@ void SlowPathLowering::LowerGetUnmappedArgs(GateRef gate, GateRef glue, GateRef void SlowPathLowering::LowerCopyRestArgs(GateRef gate, GateRef glue, GateRef actualArgc) { - DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCopyRestArgsPrefImm16))); + DebugPrintBC(gate, glue, builder_.Int32(GET_MESSAGE_STRING_ID(HandleCopyRestArgsImm16))); GateRef taggedArgc = builder_.TaggedTypeNGC(builder_.ZExtInt32ToInt64(actualArgc)); GateRef restIdx = acc_.GetValueIn(gate, 0); GateRef taggedRestIdx = builder_.TaggedTypeNGC(restIdx); diff --git a/ecmascript/compiler/slowpath_lowering.h b/ecmascript/compiler/slowpath_lowering.h index ee0a5cd3eb..1173fe8ce0 100644 --- a/ecmascript/compiler/slowpath_lowering.h +++ b/ecmascript/compiler/slowpath_lowering.h @@ -151,7 +151,7 @@ private: GateRef GetHomeObjectFromJSFunction(GateRef jsFunc); GateRef GetValueFromConstStringTable(GateRef glue, GateRef gate, uint32_t inIndex); void Lower(GateRef gate); - void LowerAdd2Dyn(GateRef gate, GateRef glue); + void LowerAdd2(GateRef gate, GateRef glue); void LowerCreateIterResultObj(GateRef gate, GateRef glue); void SaveFrameToContext(GateRef gate, GateRef glue, GateRef jsFunc); void LowerSuspendGenerator(GateRef gate, GateRef glue, [[maybe_unused]]GateRef jsFunc); @@ -164,15 +164,15 @@ private: void LowerTryLdGlobalByName(GateRef gate, GateRef glue); void LowerGetIterator(GateRef gate, GateRef glue); void LowerToJSCall(GateRef gate, GateRef glue, const std::vector &args); - void LowerCallArg0Dyn(GateRef gate, GateRef glue); - void LowerCallArg1Dyn(GateRef gate, GateRef glue); - void LowerCallArgs2Dyn(GateRef gate, GateRef glue); - void LowerCallArgs3Dyn(GateRef gate, GateRef glue); - void LowerCallIThisRangeDyn(GateRef gate, GateRef glue); - void LowerCallSpreadDyn(GateRef gate, GateRef glue); - void LowerCallIRangeDyn(GateRef gate, GateRef glue); - void LowerNewObjSpreadDyn(GateRef gate, GateRef glue); - void LowerThrowDyn(GateRef gate, GateRef glue); + void LowerCallArg0(GateRef gate, GateRef glue); + void LowerCallArg1(GateRef gate, GateRef glue); + void LowerCallArgs2(GateRef gate, GateRef glue); + void LowerCallArgs3(GateRef gate, GateRef glue); + void LowerCallThisRange(GateRef gate, GateRef glue); + void LowerCallSpread(GateRef gate, GateRef glue); + void LowerCallRange(GateRef gate, GateRef glue); + void LowerNewObjApply(GateRef gate, GateRef glue); + void LowerThrow(GateRef gate, GateRef glue); void LowerThrowConstAssignment(GateRef gate, GateRef glue); void LowerThrowThrowNotExists(GateRef gate, GateRef glue); void LowerThrowPatternNonCoercible(GateRef gate, GateRef glue); @@ -182,34 +182,34 @@ private: void LowerThrowDeleteSuperProperty(GateRef gate, GateRef glue); void LowerLdSymbol(GateRef gate, GateRef glue); void LowerLdGlobal(GateRef gate, GateRef glue); - void LowerSub2Dyn(GateRef gate, GateRef glue); - void LowerMul2Dyn(GateRef gate, GateRef glue); - void LowerDiv2Dyn(GateRef gate, GateRef glue); - void LowerMod2Dyn(GateRef gate, GateRef glue); - void LowerEqDyn(GateRef gate, GateRef glue); - void LowerNotEqDyn(GateRef gate, GateRef glue); - void LowerLessDyn(GateRef gate, GateRef glue); - void LowerLessEqDyn(GateRef gate, GateRef glue); - void LowerGreaterDyn(GateRef gate, GateRef glue); - void LowerGreaterEqDyn(GateRef gate, GateRef glue); + void LowerSub2(GateRef gate, GateRef glue); + void LowerMul2(GateRef gate, GateRef glue); + void LowerDiv2(GateRef gate, GateRef glue); + void LowerMod2(GateRef gate, GateRef glue); + void LowerEq(GateRef gate, GateRef glue); + void LowerNotEq(GateRef gate, GateRef glue); + void LowerLess(GateRef gate, GateRef glue); + void LowerLessEq(GateRef gate, GateRef glue); + void LowerGreater(GateRef gate, GateRef glue); + void LowerGreaterEq(GateRef gate, GateRef glue); void LowerGetPropIterator(GateRef gate, GateRef glue); void LowerIterNext(GateRef gate, GateRef glue); void LowerCloseIterator(GateRef gate, GateRef glue); - void LowerIncDyn(GateRef gate, GateRef glue); - void LowerDecDyn(GateRef gate, GateRef glue); + void LowerInc(GateRef gate, GateRef glue); + void LowerDec(GateRef gate, GateRef glue); void LowerToNumber(GateRef gate, GateRef glue); - void LowerNegDyn(GateRef gate, GateRef glue); - void LowerNotDyn(GateRef gate, GateRef glue); - void LowerShl2Dyn(GateRef gate, GateRef glue); - void LowerShr2Dyn(GateRef gate, GateRef glue); - void LowerAshr2Dyn(GateRef gate, GateRef glue); - void LowerAnd2Dyn(GateRef gate, GateRef glue); - void LowerOr2Dyn(GateRef gate, GateRef glue); - void LowerXor2Dyn(GateRef gate, GateRef glue); + void LowerNeg(GateRef gate, GateRef glue); + void LowerNot(GateRef gate, GateRef glue); + void LowerShl2(GateRef gate, GateRef glue); + void LowerShr2(GateRef gate, GateRef glue); + void LowerAshr2(GateRef gate, GateRef glue); + void LowerAnd2(GateRef gate, GateRef glue); + void LowerOr2(GateRef gate, GateRef glue); + void LowerXor2(GateRef gate, GateRef glue); void LowerDelObjProp(GateRef gate, GateRef glue); - void LowerExpDyn(GateRef gate, GateRef glue); - void LowerIsInDyn(GateRef gate, GateRef glue); - void LowerInstanceofDyn(GateRef gate, GateRef glue); + void LowerExp(GateRef gate, GateRef glue); + void LowerIsIn(GateRef gate, GateRef glue); + void LowerInstanceof(GateRef gate, GateRef glue); void LowerFastStrictNotEqual(GateRef gate, GateRef glue); void LowerFastStrictEqual(GateRef gate, GateRef glue); void LowerCreateEmptyArray(GateRef gate, GateRef glue); @@ -227,7 +227,7 @@ private: void LowerSuperCall(GateRef gate, GateRef glue, GateRef newTarget); void LowerSuperCallSpread(GateRef gate, GateRef glue, GateRef newTarget); void LowerIsTrueOrFalse(GateRef gate, GateRef glue, bool flag); - void LowerNewObjDynRange(GateRef gate, GateRef glue); + void LowerNewObjRange(GateRef gate, GateRef glue); void LowerConditionJump(GateRef gate, bool isEqualJump); void LowerGetNextPropName(GateRef gate, GateRef glue); void LowerCopyDataProperties(GateRef gate, GateRef glue); @@ -236,12 +236,12 @@ private: void LowerStOwnByValue(GateRef gate, GateRef glue); void LowerStOwnByIndex(GateRef gate, GateRef glue); void LowerStOwnByName(GateRef gate, GateRef glue); - void LowerDefineFuncDyn(GateRef gate, GateRef glue, GateRef jsFunc); + void LowerDefineFunc(GateRef gate, GateRef glue, GateRef jsFunc); void LowerDefineGeneratorFunc(GateRef gate, GateRef glue, GateRef jsFunc); void LowerDefineAsyncGeneratorFunc(GateRef gate, GateRef glue, GateRef jsFunc); void LowerDefineAsyncFunc(GateRef gate, GateRef glue, GateRef jsFunc); - void LowerNewLexicalEnvDyn(GateRef gate, GateRef glue); - void LowerNewLexicalEnvWithNameDyn(GateRef gate, GateRef glue, GateRef jsFunc); + void LowerNewLexicalEnv(GateRef gate, GateRef glue); + void LowerNewLexicalEnvWithName(GateRef gate, GateRef glue, GateRef jsFunc); void LowerPopLexicalEnv(GateRef gate, GateRef glue); void LowerLdSuperByValue(GateRef gate, GateRef glue, GateRef jsFunc); void LowerStSuperByValue(GateRef gate, GateRef glue, GateRef jsFunc); @@ -263,16 +263,16 @@ private: void LowerStObjByValue(GateRef gate, GateRef glue); void LowerCreateGeneratorObj(GateRef gate, GateRef glue); void LowerStArraySpread(GateRef gate, GateRef glue); - void LowerLdLexVarDyn(GateRef gate, GateRef glue); - void LowerStLexVarDyn(GateRef gate, GateRef glue); + void LowerLdLexVar(GateRef gate, GateRef glue); + void LowerStLexVar(GateRef gate, GateRef glue); void LowerCreateObjectHavingMethod(GateRef gate, GateRef glue, GateRef jsFunc); void LowerLdHomeObject(GateRef gate, GateRef jsFunc); void LowerDefineClassWithBuffer(GateRef gate, GateRef glue, GateRef jsFunc); void LowerAsyncFunctionEnter(GateRef gate, GateRef glue); - void LowerTypeOfDyn(GateRef gate, GateRef glue); + void LowerTypeof(GateRef gate, GateRef glue); void LowerResumeGenerator(GateRef gate); void LowerGetResumeMode(GateRef gate); - void LowerDefineNCFuncDyn(GateRef gate, GateRef glue, GateRef jsFunc); + void LowerDefineNCFunc(GateRef gate, GateRef glue, GateRef jsFunc); void LowerDefineMethod(GateRef gate, GateRef glue, GateRef jsFunc); void LowerGetUnmappedArgs(GateRef gate, GateRef glue, GateRef actualArgc); void LowerCopyRestArgs(GateRef gate, GateRef glue, GateRef actualArgc); diff --git a/ecmascript/compiler/stub_builder-inl.h b/ecmascript/compiler/stub_builder-inl.h index 0dce4120fd..898f9e65c5 100644 --- a/ecmascript/compiler/stub_builder-inl.h +++ b/ecmascript/compiler/stub_builder-inl.h @@ -927,9 +927,9 @@ inline GateRef StubBuilder::LoadHClass(GateRef object) return Load(VariableType::JS_POINTER(), object); } -inline void StubBuilder::StoreHClass(GateRef glue, GateRef object, GateRef hclass) +inline void StubBuilder::StoreHClass(GateRef glue, GateRef object, GateRef hClass) { - Store(VariableType::JS_POINTER(), glue, object, IntPtr(0), hclass); + Store(VariableType::JS_POINTER(), glue, object, IntPtr(0), hClass); } inline GateRef StubBuilder::GetObjectType(GateRef hClass) @@ -1112,21 +1112,21 @@ inline GateRef StubBuilder::GetHasChanged(GateRef object) return Int32NotEqual(Int32And(bitfield, mask), Int32(0)); } -inline GateRef StubBuilder::HclassIsPrototypeHandler(GateRef hclass) +inline GateRef StubBuilder::HclassIsPrototypeHandler(GateRef hClass) { - return Int32Equal(GetObjectType(hclass), + return Int32Equal(GetObjectType(hClass), Int32(static_cast(JSType::PROTOTYPE_HANDLER))); } -inline GateRef StubBuilder::HclassIsTransitionHandler(GateRef hclass) +inline GateRef StubBuilder::HclassIsTransitionHandler(GateRef hClass) { - return Int32Equal(GetObjectType(hclass), + return Int32Equal(GetObjectType(hClass), Int32(static_cast(JSType::TRANSITION_HANDLER))); } -inline GateRef StubBuilder::HclassIsPropertyBox(GateRef hclass) +inline GateRef StubBuilder::HclassIsPropertyBox(GateRef hClass) { - return Int32Equal(GetObjectType(hclass), + return Int32Equal(GetObjectType(hClass), Int32(static_cast(JSType::PROPERTY_BOX))); } diff --git a/ecmascript/compiler/stub_builder.cpp b/ecmascript/compiler/stub_builder.cpp index 10ed5c1471..c58c43a898 100644 --- a/ecmascript/compiler/stub_builder.cpp +++ b/ecmascript/compiler/stub_builder.cpp @@ -101,7 +101,7 @@ void StubBuilder::LoopEnd(Label *loopHead) } // FindElementWithCache in ecmascript/layout_info-inl.h -GateRef StubBuilder::FindElementWithCache(GateRef glue, GateRef layoutInfo, GateRef hClass, +GateRef StubBuilder::FindElementWithCache(GateRef glue, GateRef layoutInfo, GateRef hclass, GateRef key, GateRef propsNum) { auto env = GetEnvironment(); @@ -155,7 +155,7 @@ GateRef StubBuilder::FindElementWithCache(GateRef glue, GateRef layoutInfo, Gate Jump(&afterExceedCon); } Bind(&afterExceedCon); - result = UpdateLeaveFrameAndCallNGCRuntime(glue, RTSTUB_ID(FindElementWithCache), { glue, hClass, key, propsNum }); + result = UpdateLeaveFrameAndCallNGCRuntime(glue, RTSTUB_ID(FindElementWithCache), { glue, hclass, key, propsNum }); Jump(&exit); Bind(&exit); auto ret = *result; @@ -436,7 +436,7 @@ GateRef StubBuilder::FindEntryFromTransitionDictionary(GateRef glue, GateRef ele return ret; } -GateRef StubBuilder::JSObjectGetProperty(VariableType returnType, GateRef obj, GateRef hClass, GateRef attr) +GateRef StubBuilder::JSObjectGetProperty(VariableType returnType, GateRef obj, GateRef hclass, GateRef attr) { auto env = GetEnvironment(); Label entry(env); @@ -450,7 +450,7 @@ GateRef StubBuilder::JSObjectGetProperty(VariableType returnType, GateRef obj, G { Bind(&inlinedProp); { - result = GetPropertyInlinedProps(obj, hClass, attrOffset, returnType); + result = GetPropertyInlinedProps(obj, hclass, attrOffset, returnType); Jump(&exit); } Bind(¬InlinedProp); @@ -459,7 +459,7 @@ GateRef StubBuilder::JSObjectGetProperty(VariableType returnType, GateRef obj, G GateRef array = Load(VariableType::INT64(), obj, IntPtr(JSObject::PROPERTIES_OFFSET)); result = GetValueFromTaggedArray(returnType, array, Int32Sub(attrOffset, - GetInlinedPropertiesFromHClass(hClass))); + GetInlinedPropertiesFromHClass(hclass))); Jump(&exit); } } @@ -469,7 +469,7 @@ GateRef StubBuilder::JSObjectGetProperty(VariableType returnType, GateRef obj, G return ret; } -void StubBuilder::JSObjectSetProperty(GateRef glue, GateRef obj, GateRef hClass, GateRef attr, GateRef value) +void StubBuilder::JSObjectSetProperty(GateRef glue, GateRef obj, GateRef hclass, GateRef attr, GateRef value) { auto env = GetEnvironment(); Label subEntry(env); @@ -482,7 +482,7 @@ void StubBuilder::JSObjectSetProperty(GateRef glue, GateRef obj, GateRef hClass, { Bind(&inlinedProp); { - SetPropertyInlinedProps(glue, obj, hClass, value, attrOffset); + SetPropertyInlinedProps(glue, obj, hclass, value, attrOffset); Jump(&exit); } Bind(¬InlinedProp); @@ -491,7 +491,7 @@ void StubBuilder::JSObjectSetProperty(GateRef glue, GateRef obj, GateRef hClass, GateRef array = Load(VariableType::JS_POINTER(), obj, IntPtr(JSObject::PROPERTIES_OFFSET)); SetValueToTaggedArray(VariableType::JS_ANY(), glue, array, Int32Sub(attrOffset, - GetInlinedPropertiesFromHClass(hClass)), value); + GetInlinedPropertiesFromHClass(hclass)), value); Jump(&exit); } } @@ -679,10 +679,10 @@ void StubBuilder::JSHClassAddProperty(GateRef glue, GateRef receiver, GateRef ke Label exit(env); GateRef hclass = LoadHClass(receiver); GateRef metaData = GetPropertyMetaDataFromAttr(attr); - GateRef newDyn = FindTransitions(glue, receiver, hclass, key, metaData); + GateRef newClass = FindTransitions(glue, receiver, hclass, key, metaData); Label findHClass(env); Label notFindHClass(env); - Branch(Int64Equal(newDyn, Int64(JSTaggedValue::VALUE_UNDEFINED)), ¬FindHClass, &findHClass); + Branch(Int64Equal(newClass, Int64(JSTaggedValue::VALUE_UNDEFINED)), ¬FindHClass, &findHClass); Bind(&findHClass); { Jump(&exit); @@ -693,16 +693,16 @@ void StubBuilder::JSHClassAddProperty(GateRef glue, GateRef receiver, GateRef ke GateRef size = Int32Mul(GetInlinedPropsStartFromHClass(hclass), Int32(JSTaggedValue::TaggedTypeSize())); GateRef inlineProps = GetInlinedPropertiesFromHClass(hclass); - GateRef newJshclass = CallRuntime(glue, RTSTUB_ID(NewEcmaDynClass), + GateRef newJsHClass = CallRuntime(glue, RTSTUB_ID(NewEcmaHClass), { IntToTaggedTypeNGC(size), IntToTaggedTypeNGC(type), IntToTaggedTypeNGC(inlineProps) }); - CopyAllHClass(glue, newJshclass, hclass); + CopyAllHClass(glue, newJsHClass, hclass); CallRuntime(glue, RTSTUB_ID(UpdateLayOutAndAddTransition), - { hclass, newJshclass, key, IntToTaggedTypeNGC(attr) }); + { hclass, newJsHClass, key, IntToTaggedTypeNGC(attr) }); #if ECMASCRIPT_ENABLE_IC - NotifyHClassChanged(glue, hclass, newJshclass); + NotifyHClassChanged(glue, hclass, newJsHClass); #endif - StoreHClass(glue, receiver, newJshclass); + StoreHClass(glue, receiver, newJsHClass); Jump(&exit); } Bind(&exit); @@ -736,11 +736,11 @@ GateRef StubBuilder::AddPropertyByName(GateRef glue, GateRef receiver, GateRef k Label setHasCtor(env); Label notSetHasCtor(env); Label afterCtorCon(env); - GateRef hClass = LoadHClass(receiver); + GateRef hclass = LoadHClass(receiver); Branch(SetHasConstructorCondition(glue, receiver, key), &setHasCtor, ¬SetHasCtor); { Bind(&setHasCtor); - SetHasConstructorToHClass(glue, hClass, Int32(1)); + SetHasConstructorToHClass(glue, hclass, Int32(1)); Jump(&afterCtorCon); Bind(¬SetHasCtor); Jump(&afterCtorCon); @@ -748,8 +748,8 @@ GateRef StubBuilder::AddPropertyByName(GateRef glue, GateRef receiver, GateRef k Bind(&afterCtorCon); // 0x111 : default attribute for property: writable, enumerable, configurable DEFVARIABLE(attr, VariableType::INT32(), propertyAttributes); - GateRef numberOfProps = GetNumberOfPropsFromHClass(hClass); - GateRef inlinedProperties = GetInlinedPropertiesFromHClass(hClass); + GateRef numberOfProps = GetNumberOfPropsFromHClass(hclass); + GateRef inlinedProperties = GetInlinedPropertiesFromHClass(hclass); Label hasUnusedInProps(env); Label noUnusedInProps(env); Label afterInPropsCon(env); @@ -759,7 +759,7 @@ GateRef StubBuilder::AddPropertyByName(GateRef glue, GateRef receiver, GateRef k Jump(&afterInPropsCon); Bind(&hasUnusedInProps); { - SetPropertyInlinedProps(glue, receiver, hClass, value, numberOfProps); + SetPropertyInlinedProps(glue, receiver, hclass, value, numberOfProps); attr = SetOffsetFieldInPropAttr(*attr, numberOfProps); attr = SetIsInlinePropsFieldInPropAttr(*attr, Int32(1)); // 1: set inInlineProps true JSHClassAddProperty(glue, receiver, key, *attr); @@ -2020,8 +2020,8 @@ GateRef StubBuilder::GetPropertyByName(GateRef glue, GateRef receiver, GateRef k Jump(&loopHead); LoopBegin(&loopHead); { - GateRef hClass = LoadHClass(*holder); - GateRef jsType = GetObjectType(hClass); + GateRef hclass = LoadHClass(*holder); + GateRef jsType = GetObjectType(hclass); Label isSIndexObj(env); Label notSIndexObj(env); Branch(IsSpecialIndexedObj(jsType), &isSIndexObj, ¬SIndexObj); @@ -2055,13 +2055,13 @@ GateRef StubBuilder::GetPropertyByName(GateRef glue, GateRef receiver, GateRef k { Label isDicMode(env); Label notDicMode(env); - Branch(IsDictionaryModeByHClass(hClass), &isDicMode, ¬DicMode); + Branch(IsDictionaryModeByHClass(hclass), &isDicMode, ¬DicMode); Bind(¬DicMode); { - GateRef layOutInfo = GetLayoutFromHClass(hClass); - GateRef propsNum = GetNumberOfPropsFromHClass(hClass); + GateRef layOutInfo = GetLayoutFromHClass(hclass); + GateRef propsNum = GetNumberOfPropsFromHClass(hclass); // int entry = layoutInfo->FindElementWithCache(thread, hclass, key, propsNumber) - GateRef entryA = FindElementWithCache(glue, layOutInfo, hClass, key, propsNum); + GateRef entryA = FindElementWithCache(glue, layOutInfo, hclass, key, propsNum); Label hasEntry(env); Label noEntry(env); // if branch condition : entry != -1 @@ -2071,7 +2071,7 @@ GateRef StubBuilder::GetPropertyByName(GateRef glue, GateRef receiver, GateRef k // PropertyAttributes attr(layoutInfo->GetAttr(entry)) GateRef propAttr = GetPropAttrFromLayoutInfo(layOutInfo, entryA); GateRef attr = TaggedCastToInt32(propAttr); - GateRef value = JSObjectGetProperty(VariableType::JS_ANY(), *holder, hClass, attr); + GateRef value = JSObjectGetProperty(VariableType::JS_ANY(), *holder, hclass, attr); Label isAccessor(env); Label notAccessor(env); Branch(IsAccessor(attr), &isAccessor, ¬Accessor); @@ -2401,8 +2401,8 @@ GateRef StubBuilder::SetPropertyByName(GateRef glue, GateRef receiver, GateRef k } // auto *hclass = holder.GetTaggedObject()->GetClass() // JSType jsType = hclass->GetObjectType() - GateRef hClass = LoadHClass(*holder); - GateRef jsType = GetObjectType(hClass); + GateRef hclass = LoadHClass(*holder); + GateRef jsType = GetObjectType(hclass); Label isSIndexObj(env); Label notSIndexObj(env); // if branch condition : IsSpecialIndexedObj(jsType) @@ -2451,15 +2451,15 @@ GateRef StubBuilder::SetPropertyByName(GateRef glue, GateRef receiver, GateRef k Label isDicMode(env); Label notDicMode(env); // if branch condition : LIKELY(!hclass->IsDictionaryMode()) - Branch(IsDictionaryModeByHClass(hClass), &isDicMode, ¬DicMode); + Branch(IsDictionaryModeByHClass(hclass), &isDicMode, ¬DicMode); Bind(¬DicMode); { // LayoutInfo *layoutInfo = LayoutInfo::Cast(hclass->GetAttributes().GetTaggedObject()) - GateRef layOutInfo = GetLayoutFromHClass(hClass); + GateRef layOutInfo = GetLayoutFromHClass(hclass); // int propsNumber = hclass->NumberOfPropsFromHClass() - GateRef propsNum = GetNumberOfPropsFromHClass(hClass); + GateRef propsNum = GetNumberOfPropsFromHClass(hclass); // int entry = layoutInfo->FindElementWithCache(thread, hclass, key, propsNumber) - GateRef entry = FindElementWithCache(glue, layOutInfo, hClass, key, propsNum); + GateRef entry = FindElementWithCache(glue, layOutInfo, hclass, key, propsNum); Label hasEntry(env); // if branch condition : entry != -1 if (useOwn) { @@ -2478,7 +2478,7 @@ GateRef StubBuilder::SetPropertyByName(GateRef glue, GateRef receiver, GateRef k Bind(&isAccessor); { // auto accessor = JSObject::Cast(holder)->GetProperty(hclass, attr) - GateRef accessor = JSObjectGetProperty(VariableType::JS_ANY(), *holder, hClass, attr); + GateRef accessor = JSObjectGetProperty(VariableType::JS_ANY(), *holder, hclass, attr); Label shouldCall(env); // ShouldCallSetter(receiver, *holder, accessor, attr) Branch(ShouldCallSetter(receiver, *holder, accessor, attr), &shouldCall, ¬Accessor); @@ -2512,7 +2512,7 @@ GateRef StubBuilder::SetPropertyByName(GateRef glue, GateRef receiver, GateRef k { // JSObject::Cast(holder)->SetProperty(thread, hclass, attr, value) // return JSTaggedValue::Undefined() - JSObjectSetProperty(glue, *holder, hClass, attr, value); + JSObjectSetProperty(glue, *holder, hclass, attr, value); result = Undefined(VariableType::INT64()); Jump(&exit); } @@ -3824,12 +3824,12 @@ GateRef StubBuilder::JSCallDispatch(GateRef glue, GateRef func, GateRef actualNu Jump(&exit); } Bind(¬FastBuiltins); - result = CallNGCRuntime(glue, RTSTUB_ID(PushCallIRangeAndDispatchNative), + result = CallNGCRuntime(glue, RTSTUB_ID(PushCallRangeAndDispatchNative), { glue, nativeCode, func, thisValue, data[0], data[1] }); break; } case JSCallMode::CALL_WITH_ARGV: - result = CallNGCRuntime(glue, RTSTUB_ID(PushCallIRangeAndDispatchNative), + result = CallNGCRuntime(glue, RTSTUB_ID(PushCallRangeAndDispatchNative), { glue, nativeCode, func, thisValue, data[0], data[1] }); break; case JSCallMode::CALL_CONSTRUCTOR_WITH_ARGV: @@ -3950,12 +3950,12 @@ GateRef StubBuilder::JSCallDispatch(GateRef glue, GateRef func, GateRef actualNu Return(); break; case JSCallMode::CALL_WITH_ARGV: - result = CallNGCRuntime(glue, RTSTUB_ID(PushCallIRangeAndDispatch), + result = CallNGCRuntime(glue, RTSTUB_ID(PushCallRangeAndDispatch), { glue, sp, func, method, callField, data[0], data[1] }); Return(); break; case JSCallMode::CALL_THIS_WITH_ARGV: - result = CallNGCRuntime(glue, RTSTUB_ID(PushCallIThisRangeAndDispatch), + result = CallNGCRuntime(glue, RTSTUB_ID(PushCallThisRangeAndDispatch), { glue, sp, func, method, callField, data[0], data[1], data[2] }); Return(); break; diff --git a/ecmascript/compiler/stub_builder.h b/ecmascript/compiler/stub_builder.h index 02ea011e9f..0f7f02f02d 100644 --- a/ecmascript/compiler/stub_builder.h +++ b/ecmascript/compiler/stub_builder.h @@ -227,7 +227,7 @@ public: // object operation GateRef IsJSHClass(GateRef obj); GateRef LoadHClass(GateRef object); - void StoreHClass(GateRef glue, GateRef object, GateRef hclass); + void StoreHClass(GateRef glue, GateRef object, GateRef hClass); void CopyAllHClass(GateRef glue, GateRef dstHClass, GateRef scrHClass); GateRef GetObjectType(GateRef hClass); GateRef IsDictionaryMode(GateRef object); @@ -268,9 +268,9 @@ public: GateRef GetPrototypeHandlerHolder(GateRef object); GateRef GetPrototypeHandlerHandlerInfo(GateRef object); GateRef GetHasChanged(GateRef object); - GateRef HclassIsPrototypeHandler(GateRef hclass); - GateRef HclassIsTransitionHandler(GateRef hclass); - GateRef HclassIsPropertyBox(GateRef hclass); + GateRef HclassIsPrototypeHandler(GateRef hClass); + GateRef HclassIsTransitionHandler(GateRef hClass); + GateRef HclassIsPropertyBox(GateRef hClass); GateRef PropAttrGetOffset(GateRef attr); // SetDictionaryOrder func in property_attribute.h GateRef SetDictionaryOrderFieldInPropAttr(GateRef attr, GateRef value); @@ -335,13 +335,13 @@ public: GateRef StringToElementIndex(GateRef string); GateRef TryToElementsIndex(GateRef key); GateRef ComputePropertyCapacityInJSObj(GateRef oldLength); - GateRef FindTransitions(GateRef glue, GateRef receiver, GateRef hclass, GateRef key, GateRef attr); + GateRef FindTransitions(GateRef glue, GateRef receiver, GateRef hClass, GateRef key, GateRef attr); GateRef TaggedToRepresentation(GateRef value); GateRef LoadFromField(GateRef receiver, GateRef handlerInfo); GateRef LoadGlobal(GateRef cell); GateRef LoadElement(GateRef receiver, GateRef key); GateRef TryToElementsIndex(GateRef glue, GateRef key); - GateRef CheckPolyHClass(GateRef cachedValue, GateRef hclass); + GateRef CheckPolyHClass(GateRef cachedValue, GateRef hClass); GateRef LoadICWithHandler(GateRef glue, GateRef receiver, GateRef holder, GateRef handler); GateRef StoreICWithHandler(GateRef glue, GateRef receiver, GateRef holder, GateRef value, GateRef handler); diff --git a/ecmascript/compiler/test_stubs.cpp b/ecmascript/compiler/test_stubs.cpp index 90c4796b5c..9548310e21 100644 --- a/ecmascript/compiler/test_stubs.cpp +++ b/ecmascript/compiler/test_stubs.cpp @@ -53,7 +53,7 @@ void BarAOTStubBuilder::GenerateCircuit() [[maybe_unused]] GateRef thisObj = TaggedArgument(5); GateRef a = TaggedArgument(6); GateRef b = TaggedArgument(7); - GateRef result = CallRuntime(glue, RTSTUB_ID(Add2Dyn), {a, b}); + GateRef result = CallRuntime(glue, RTSTUB_ID(Add2), {a, b}); Return(result); } @@ -93,8 +93,8 @@ void Bar1AOTStubBuilder::GenerateCircuit() GateRef a = TaggedArgument(6); GateRef b = TaggedArgument(7); GateRef c = TaggedArgument(8); - GateRef result = CallRuntime(glue, RTSTUB_ID(Add2Dyn), {a, b}); - GateRef result2 = CallRuntime(glue, RTSTUB_ID(Add2Dyn), {result, c}); + GateRef result = CallRuntime(glue, RTSTUB_ID(Add2), {a, b}); + GateRef result2 = CallRuntime(glue, RTSTUB_ID(Add2), {result, c}); Return(result2); } diff --git a/ecmascript/compiler/tests/stub_tests.cpp b/ecmascript/compiler/tests/stub_tests.cpp index f75adfd1d2..a18197cf8d 100644 --- a/ecmascript/compiler/tests/stub_tests.cpp +++ b/ecmascript/compiler/tests/stub_tests.cpp @@ -143,7 +143,7 @@ HWTEST_F_L0(StubTest, FastAddTest) int x1 = 2147483647; int y1 = 15; auto resG = fn(thread->GetGlueAddr(), JSTaggedValue(x1).GetRawData(), JSTaggedValue(y1).GetRawData()); - auto expectedG = SlowRuntimeStub::Add2Dyn(thread, JSTaggedValue(x1), JSTaggedValue(y1)); + auto expectedG = SlowRuntimeStub::Add2(thread, JSTaggedValue(x1), JSTaggedValue(y1)); EXPECT_EQ(resG, expectedG); } diff --git a/ecmascript/compiler/trampoline/aarch64/asm_interpreter_call.cpp b/ecmascript/compiler/trampoline/aarch64/asm_interpreter_call.cpp index 9f397ae4e5..1c22f3e971 100644 --- a/ecmascript/compiler/trampoline/aarch64/asm_interpreter_call.cpp +++ b/ecmascript/compiler/trampoline/aarch64/asm_interpreter_call.cpp @@ -28,8 +28,6 @@ #include "ecmascript/message_string.h" #include "ecmascript/runtime_call_id.h" -#include "libpandafile/bytecode_instruction-inl.h" - namespace panda::ecmascript::aarch64 { using Label = panda::ecmascript::Label; #define __ assembler-> @@ -384,15 +382,15 @@ Register AsmInterpreterCall::GetNewTargetRegsiter(ExtendedAssembler *assembler, // X23 - arg0 // X23 - actualArgc // X24 - arg1 // X24 - argv // X25 - arg2 -void AsmInterpreterCall::PushCallIThisRangeAndDispatch(ExtendedAssembler *assembler) +void AsmInterpreterCall::PushCallThisRangeAndDispatch(ExtendedAssembler *assembler) { - __ BindAssemblerStub(RTSTUB_ID(PushCallIThisRangeAndDispatch)); + __ BindAssemblerStub(RTSTUB_ID(PushCallThisRangeAndDispatch)); JSCallCommonEntry(assembler, JSCallMode::CALL_THIS_WITH_ARGV); } -void AsmInterpreterCall::PushCallIRangeAndDispatch(ExtendedAssembler *assembler) +void AsmInterpreterCall::PushCallRangeAndDispatch(ExtendedAssembler *assembler) { - __ BindAssemblerStub(RTSTUB_ID(PushCallIRangeAndDispatch)); + __ BindAssemblerStub(RTSTUB_ID(PushCallRangeAndDispatch)); JSCallCommonEntry(assembler, JSCallMode::CALL_WITH_ARGV); } @@ -426,7 +424,7 @@ void AsmInterpreterCall::PushCallArgs0AndDispatch(ExtendedAssembler *assembler) JSCallCommonEntry(assembler, JSCallMode::CALL_ARG0); } -// uint64_t PushCallIRangeAndDispatchNative(uintptr_t glue, uint32_t argc, JSTaggedType calltarget, uintptr_t argv[]) +// uint64_t PushCallRangeAndDispatchNative(uintptr_t glue, uint32_t argc, JSTaggedType calltarget, uintptr_t argv[]) // c++ calling convention call js function // Input: X0 - glue // X1 - nativeCode @@ -434,9 +432,9 @@ void AsmInterpreterCall::PushCallArgs0AndDispatch(ExtendedAssembler *assembler) // X3 - thisValue // X4 - argc // X5 - argV (...) -void AsmInterpreterCall::PushCallIRangeAndDispatchNative(ExtendedAssembler *assembler) +void AsmInterpreterCall::PushCallRangeAndDispatchNative(ExtendedAssembler *assembler) { - __ BindAssemblerStub(RTSTUB_ID(PushCallIRangeAndDispatchNative)); + __ BindAssemblerStub(RTSTUB_ID(PushCallRangeAndDispatchNative)); CallNativeWithArgv(assembler, false); } @@ -641,11 +639,11 @@ void AsmInterpreterCall::ResumeRspAndDispatch(ExtendedAssembler *assembler) ASSERT(fpOffset < 0); ASSERT(spOffset < 0); - Label newObjectDynRangeReturn; + Label newObjectRangeReturn; Label dispatch; __ Ldur(fp, MemoryOperand(sp, fpOffset)); // store fp for temporary __ Cmp(jumpSizeRegister, Immediate(0)); - __ B(Condition::EQ, &newObjectDynRangeReturn); + __ B(Condition::EQ, &newObjectRangeReturn); __ Ldur(sp, MemoryOperand(sp, spOffset)); // update sp __ Add(pc, pc, Operand(jumpSizeRegister, LSL, 0)); @@ -661,7 +659,7 @@ void AsmInterpreterCall::ResumeRspAndDispatch(ExtendedAssembler *assembler) auto jumpSize = kungfu::AssemblerModule::GetJumpSizeFromJSCallMode(JSCallMode::CALL_CONSTRUCTOR_WITH_ARGV); Label getHiddenThis; Label notUndefined; - __ Bind(&newObjectDynRangeReturn); + __ Bind(&newObjectRangeReturn); { __ Cmp(ret, Immediate(JSTaggedValue::VALUE_UNDEFINED)); __ B(Condition::NE, ¬Undefined); @@ -713,7 +711,7 @@ void AsmInterpreterCall::ResumeRspAndDispatch(ExtendedAssembler *assembler) __ B(Condition::LS, &getHiddenThis); // constructor is base // exception branch { - __ Mov(opcode, kungfu::BytecodeStubCSigns::ID_NewObjectDynRangeThrowException); + __ Mov(opcode, kungfu::BytecodeStubCSigns::ID_NewObjectRangeThrowException); __ Ldur(sp, MemoryOperand(sp, spOffset)); // update sp __ B(&dispatch); } @@ -1111,7 +1109,7 @@ void AsmInterpreterCall::PushGeneratorFrameState(ExtendedAssembler *assembler, R // 32: get high 32bit __ Lsr(operatorRegister, operatorRegister, 32); __ Add(pcRegister, operatorRegister, pcRegister); - __ Add(pcRegister, pcRegister, Immediate(BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_V8_V8))); + __ Add(pcRegister, pcRegister, Immediate(BytecodeInstruction::Size(BytecodeInstruction::Format::V8_V8))); // 2 : pc and fp __ Stp(fpRegister, pcRegister, MemoryOperand(currentSlotRegister, -2 * FRAME_SLOT_SIZE, AddrMode::PREINDEX)); // jumpSizeAfterCall diff --git a/ecmascript/compiler/trampoline/aarch64/common_call.cpp b/ecmascript/compiler/trampoline/aarch64/common_call.cpp index 4ac1bfceff..453b58accc 100644 --- a/ecmascript/compiler/trampoline/aarch64/common_call.cpp +++ b/ecmascript/compiler/trampoline/aarch64/common_call.cpp @@ -28,8 +28,6 @@ #include "ecmascript/message_string.h" #include "ecmascript/runtime_call_id.h" -#include "libpandafile/bytecode_instruction-inl.h" - namespace panda::ecmascript::aarch64 { using Label = panda::ecmascript::Label; #define __ assembler-> diff --git a/ecmascript/compiler/trampoline/aarch64/common_call.h b/ecmascript/compiler/trampoline/aarch64/common_call.h index 18e47803d9..6d1174fb58 100644 --- a/ecmascript/compiler/trampoline/aarch64/common_call.h +++ b/ecmascript/compiler/trampoline/aarch64/common_call.h @@ -116,9 +116,9 @@ public: static void GeneratorReEnterAsmInterpDispatch(ExtendedAssembler *assembler); - static void PushCallIThisRangeAndDispatch(ExtendedAssembler *assembler); + static void PushCallThisRangeAndDispatch(ExtendedAssembler *assembler); - static void PushCallIRangeAndDispatch(ExtendedAssembler *assembler); + static void PushCallRangeAndDispatch(ExtendedAssembler *assembler); static void PushCallArgs3AndDispatch(ExtendedAssembler *assembler); @@ -128,9 +128,9 @@ public: static void PushCallArgs0AndDispatch(ExtendedAssembler *assembler); - static void PushCallIThisRangeAndDispatchNative(ExtendedAssembler *assembler); + static void PushCallThisRangeAndDispatchNative(ExtendedAssembler *assembler); - static void PushCallIRangeAndDispatchNative(ExtendedAssembler *assembler); + static void PushCallRangeAndDispatchNative(ExtendedAssembler *assembler); static void PushCallNewAndDispatchNative(ExtendedAssembler *assembler); diff --git a/ecmascript/compiler/trampoline/x64/asm_interpreter_call.cpp b/ecmascript/compiler/trampoline/x64/asm_interpreter_call.cpp index 588d629921..f4ae33199f 100644 --- a/ecmascript/compiler/trampoline/x64/asm_interpreter_call.cpp +++ b/ecmascript/compiler/trampoline/x64/asm_interpreter_call.cpp @@ -27,8 +27,6 @@ #include "ecmascript/message_string.h" #include "ecmascript/runtime_call_id.h" -#include "libpandafile/bytecode_instruction-inl.h" - namespace panda::ecmascript::x64 { #define __ assembler-> @@ -198,7 +196,7 @@ void AsmInterpreterCall::PushGeneratorFrameState(ExtendedAssembler *assembler, R __ Movq(Operand(methodRegister, JSMethod::NATIVE_POINTER_OR_BYTECODE_ARRAY_OFFSET), pcRegister); __ Movl(Operand(contextRegister, GeneratorContext::GENERATOR_BC_OFFSET_OFFSET), operatorRegister); __ Addq(operatorRegister, pcRegister); - __ Addq(BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_V8_V8), pcRegister); + __ Addq(BytecodeInstruction::Size(BytecodeInstruction::Format::V8_V8), pcRegister); __ Pushq(pcRegister); // pc __ Pushq(fpRegister); // fp __ Pushq(0); // jumpSizeAfterCall @@ -370,15 +368,15 @@ void AsmInterpreterCall::JSCallCommonEntry(ExtendedAssembler *assembler, JSCallM // %rsi - arg0 // %rsi - actualArgc // %rdi - arg1 // %rdi - argv // %r8 - arg2 -void AsmInterpreterCall::PushCallIThisRangeAndDispatch(ExtendedAssembler *assembler) +void AsmInterpreterCall::PushCallThisRangeAndDispatch(ExtendedAssembler *assembler) { - __ BindAssemblerStub(RTSTUB_ID(PushCallIThisRangeAndDispatch)); + __ BindAssemblerStub(RTSTUB_ID(PushCallThisRangeAndDispatch)); JSCallCommonEntry(assembler, JSCallMode::CALL_THIS_WITH_ARGV); } -void AsmInterpreterCall::PushCallIRangeAndDispatch(ExtendedAssembler *assembler) +void AsmInterpreterCall::PushCallRangeAndDispatch(ExtendedAssembler *assembler) { - __ BindAssemblerStub(RTSTUB_ID(PushCallIRangeAndDispatch)); + __ BindAssemblerStub(RTSTUB_ID(PushCallRangeAndDispatch)); JSCallCommonEntry(assembler, JSCallMode::CALL_WITH_ARGV); } @@ -705,7 +703,7 @@ void AsmInterpreterCall::DispatchCall(ExtendedAssembler *assembler, Register pcR __ Jmp(tempRegister); } -// uint64_t PushCallIRangeAndDispatchNative(uintptr_t glue, uint32_t argc, JSTaggedType calltarget, uintptr_t argv[]) +// uint64_t PushCallRangeAndDispatchNative(uintptr_t glue, uint32_t argc, JSTaggedType calltarget, uintptr_t argv[]) // c++ calling convention call js function // Input: %rdi - glue // %rsi - nativeCode @@ -713,9 +711,9 @@ void AsmInterpreterCall::DispatchCall(ExtendedAssembler *assembler, Register pcR // %rcx - thisValue // %r8 - argc // %r9 - argV (...) -void AsmInterpreterCall::PushCallIRangeAndDispatchNative(ExtendedAssembler *assembler) +void AsmInterpreterCall::PushCallRangeAndDispatchNative(ExtendedAssembler *assembler) { - __ BindAssemblerStub(RTSTUB_ID(PushCallIRangeAndDispatchNative)); + __ BindAssemblerStub(RTSTUB_ID(PushCallRangeAndDispatchNative)); CallNativeWithArgv(assembler, false); } @@ -915,9 +913,9 @@ void AsmInterpreterCall::ResumeRspAndDispatch(ExtendedAssembler *assembler) __ Subq(AsmInterpretedFrame::GetSize(false), frameStateBaseRegister); Label dispatch; - Label newObjectDynRangeReturn; + Label newObjectRangeReturn; __ Cmpq(0, jumpSizeRegister); - __ Je(&newObjectDynRangeReturn); + __ Je(&newObjectRangeReturn); __ Movq(Operand(frameStateBaseRegister, AsmInterpretedFrame::GetBaseOffset(false)), spRegister); // update sp __ Addq(jumpSizeRegister, pcRegister); // newPc @@ -938,7 +936,7 @@ void AsmInterpreterCall::ResumeRspAndDispatch(ExtendedAssembler *assembler) JSCallMode::CALL_CONSTRUCTOR_WITH_ARGV); Label getHiddenThis; Label notUndefined; - __ Bind(&newObjectDynRangeReturn); + __ Bind(&newObjectRangeReturn); __ Cmpq(JSTaggedValue::Undefined().GetRawData(), ret); __ Jne(¬Undefined); @@ -990,7 +988,7 @@ void AsmInterpreterCall::ResumeRspAndDispatch(ExtendedAssembler *assembler) // exception branch { __ Movq(Operand(frameStateBaseRegister, AsmInterpretedFrame::GetBaseOffset(false)), spRegister); - __ Movq(kungfu::BytecodeStubCSigns::ID_NewObjectDynRangeThrowException, opcodeRegister); + __ Movq(kungfu::BytecodeStubCSigns::ID_NewObjectRangeThrowException, opcodeRegister); __ Jmp(&dispatch); } } diff --git a/ecmascript/compiler/trampoline/x64/common_call.cpp b/ecmascript/compiler/trampoline/x64/common_call.cpp index 7a734d84da..40cb56bff7 100644 --- a/ecmascript/compiler/trampoline/x64/common_call.cpp +++ b/ecmascript/compiler/trampoline/x64/common_call.cpp @@ -27,8 +27,6 @@ #include "ecmascript/message_string.h" #include "ecmascript/runtime_call_id.h" -#include "libpandafile/bytecode_instruction-inl.h" - namespace panda::ecmascript::x64 { #define __ assembler-> diff --git a/ecmascript/compiler/trampoline/x64/common_call.h b/ecmascript/compiler/trampoline/x64/common_call.h index 2c919a242f..b1041ad448 100644 --- a/ecmascript/compiler/trampoline/x64/common_call.h +++ b/ecmascript/compiler/trampoline/x64/common_call.h @@ -87,9 +87,9 @@ public: static void AsmInterpreterEntry(ExtendedAssembler *assembler); - static void PushCallIThisRangeAndDispatch(ExtendedAssembler *assembler); + static void PushCallThisRangeAndDispatch(ExtendedAssembler *assembler); - static void PushCallIRangeAndDispatch(ExtendedAssembler *assembler); + static void PushCallRangeAndDispatch(ExtendedAssembler *assembler); static void PushCallArgs3AndDispatch(ExtendedAssembler *assembler); @@ -103,7 +103,7 @@ public: static void PushCallNewAndDispatchNative(ExtendedAssembler *assembler); - static void PushCallIRangeAndDispatchNative(ExtendedAssembler *assembler); + static void PushCallRangeAndDispatchNative(ExtendedAssembler *assembler); static void PushCallArgsAndDispatchNative(ExtendedAssembler *assembler); diff --git a/ecmascript/compiler/type_inference/type_infer.cpp b/ecmascript/compiler/type_inference/type_infer.cpp index 2500ddd522..c88a0a03f1 100644 --- a/ecmascript/compiler/type_inference/type_infer.cpp +++ b/ecmascript/compiler/type_inference/type_infer.cpp @@ -89,100 +89,105 @@ bool TypeInfer::ShouldInfer(const GateRef gate) const bool TypeInfer::Infer(GateRef gate) { + // TODO if (!ShouldInfer(gate)) { return false; } if (gateAccessor_.GetOpCode(gate) == OpCode::VALUE_SELECTOR) { return InferPhiGate(gate); } + /* // infer ecma.* bytecode gates EcmaOpcode op = builder_->GetByteCodeOpcode(gate); switch (op) { - case EcmaOpcode::LDNAN_PREF: - case EcmaOpcode::LDINFINITY_PREF: - case EcmaOpcode::SUB2DYN_PREF_V8: - case EcmaOpcode::MUL2DYN_PREF_V8: - case EcmaOpcode::DIV2DYN_PREF_V8: - case EcmaOpcode::MOD2DYN_PREF_V8: - case EcmaOpcode::SHL2DYN_PREF_V8: - case EcmaOpcode::ASHR2DYN_PREF_V8: - case EcmaOpcode::SHR2DYN_PREF_V8: - case EcmaOpcode::AND2DYN_PREF_V8: - case EcmaOpcode::OR2DYN_PREF_V8: - case EcmaOpcode::XOR2DYN_PREF_V8: - case EcmaOpcode::TONUMBER_PREF_V8: - case EcmaOpcode::TONUMERIC_PREF_V8: - case EcmaOpcode::NEGDYN_PREF_V8: - case EcmaOpcode::NOTDYN_PREF_V8: - case EcmaOpcode::INCDYN_PREF_V8: - case EcmaOpcode::DECDYN_PREF_V8: - case EcmaOpcode::EXPDYN_PREF_V8: - case EcmaOpcode::STARRAYSPREAD_PREF_V8_V8: + case EcmaOpcode::LDNAN: + case EcmaOpcode::LDINFINITY: + case EcmaOpcode::SUB2_IMM8_V8: + case EcmaOpcode::MUL2_IMM8_V8: + case EcmaOpcode::DIV2_IMM8_V8: + case EcmaOpcode::MOD2_IMM8_V8: + case EcmaOpcode::SHL2_IMM8_V8: + case EcmaOpcode::ASHR2_IMM8_V8: + case EcmaOpcode::SHR2_IMM8_V8: + case EcmaOpcode::AND2_IMM8_V8: + case EcmaOpcode::OR2_IMM8_V8: + case EcmaOpcode::XOR2_IMM8_V8: + case EcmaOpcode::TONUMBER_IMM8_V8: + case EcmaOpcode::TONUMERIC_IMM8_V8: + case EcmaOpcode::NEG_IMM8_V8: + case EcmaOpcode::NOT_IMM8_V8: + case EcmaOpcode::INC_IMM8_V8: + case EcmaOpcode::DEC_IMM8_V8: + case EcmaOpcode::EXP_IMM8_V8: + case EcmaOpcode::STARRAYSPREAD_V8_V8: return SetNumberType(gate); - case EcmaOpcode::LDTRUE_PREF: - case EcmaOpcode::LDFALSE_PREF: - case EcmaOpcode::EQDYN_PREF_V8: - case EcmaOpcode::NOTEQDYN_PREF_V8: - case EcmaOpcode::LESSDYN_PREF_V8: - case EcmaOpcode::LESSEQDYN_PREF_V8: - case EcmaOpcode::GREATERDYN_PREF_V8: - case EcmaOpcode::GREATEREQDYN_PREF_V8: - case EcmaOpcode::ISINDYN_PREF_V8: - case EcmaOpcode::INSTANCEOFDYN_PREF_V8: - case EcmaOpcode::STRICTNOTEQDYN_PREF_V8: - case EcmaOpcode::STRICTEQDYN_PREF_V8: - case EcmaOpcode::ISTRUE_PREF: - case EcmaOpcode::ISFALSE_PREF: - case EcmaOpcode::SETOBJECTWITHPROTO_PREF_V8_V8: - case EcmaOpcode::DELOBJPROP_PREF_V8_V8: + case EcmaOpcode::LDTRUE: + case EcmaOpcode::LDFALSE: + case EcmaOpcode::EQ_IMM8_V8: + case EcmaOpcode::NOTEQ_IMM8_V8: + case EcmaOpcode::LESS_IMM8_V8: + case EcmaOpcode::LESSEQ_IMM8_V8: + case EcmaOpcode::GREATER_IMM8_V8: + case EcmaOpcode::GREATEREQ_IMM8_V8: + case EcmaOpcode::ISIN_IMM8_V8: + case EcmaOpcode::INSTANCEOF_IMM8_V8: + case EcmaOpcode::STRICTNOTEQ_IMM8_V8: + case EcmaOpcode::STRICTEQ_IMM8_V8: + case EcmaOpcode::ISTRUE: + case EcmaOpcode::ISFALSE: + case EcmaOpcode::SETOBJECTWITHPROTO_IMM8_V8_V8: + case EcmaOpcode::DELOBJPROP_V8_V8: return SetBooleanType(gate); - case EcmaOpcode::LDUNDEFINED_PREF: + case EcmaOpcode::LDUNDEFINED: return InferLdUndefined(gate); - case EcmaOpcode::LDNULL_PREF: + case EcmaOpcode::LDNULL: return InferLdNull(gate); - case EcmaOpcode::LDAI_DYN_IMM32: - return InferLdaiDyn(gate); - case EcmaOpcode::FLDAI_DYN_IMM64: - return InferFLdaiDyn(gate); - case EcmaOpcode::LDSYMBOL_PREF: + case EcmaOpcode::LDAI_IMM32: + return InferLdai(gate); + case EcmaOpcode::FLDAI_IMM64: + return InferFLdai(gate); + case EcmaOpcode::LDSYMBOL: return InferLdSymbol(gate); - case EcmaOpcode::THROWDYN_PREF: - return InferThrowDyn(gate); - case EcmaOpcode::TYPEOFDYN_PREF: - return InferTypeOfDyn(gate); - case EcmaOpcode::ADD2DYN_PREF_V8: - return InferAdd2Dyn(gate); - case EcmaOpcode::LDOBJBYINDEX_PREF_V8_IMM32: + case EcmaOpcode::THROW: + return InferThrow(gate); + case EcmaOpcode::TYPEOF_IMM8: + return InferTypeOf(gate); + case EcmaOpcode::ADD2_IMM8_V8: + return InferAdd2(gate); + case EcmaOpcode::LDOBJBYINDEX_IMM8_IMM16: + case EcmaOpcode::LDOBJBYINDEX_IMM16_IMM16: + case EcmaOpcode::WIDE_LDOBJBYINDEX_PREF_IMM32: + case EcmaOpcode::DEPRECATED_LDOBJBYINDEX_PREF_V8_IMM32: return InferLdObjByIndex(gate); - case EcmaOpcode::STGLOBALVAR_PREF_ID32: - case EcmaOpcode::STCONSTTOGLOBALRECORD_PREF_ID32: - case EcmaOpcode::TRYSTGLOBALBYNAME_PREF_ID32: - case EcmaOpcode::STLETTOGLOBALRECORD_PREF_ID32: - case EcmaOpcode::STCLASSTOGLOBALRECORD_PREF_ID32: + case EcmaOpcode::STGLOBALVAR_ID16: + case EcmaOpcode::STCONSTTOGLOBALRECORD_ID16: + case EcmaOpcode::TRYSTGLOBALBYNAME_IMM8_ID16: + case EcmaOpcode::STLETTOGLOBALRECORD_ID16: + case EcmaOpcode::STCLASSTOGLOBALRECORD_ID16: return SetStGlobalBcType(gate); - case EcmaOpcode::LDGLOBALVAR_PREF_ID32: + case EcmaOpcode::LDGLOBALVAR_ID16: return InferLdGlobalVar(gate); - case EcmaOpcode::RETURNUNDEFINED_PREF: + case EcmaOpcode::RETURNUNDEFINED: return InferReturnUndefined(gate); - case EcmaOpcode::RETURN_DYN: - return InferReturnDyn(gate); - case EcmaOpcode::LDOBJBYNAME_PREF_ID32_V8: + case EcmaOpcode::RETURN: + return InferReturn(gate); + case EcmaOpcode::LDOBJBYNAME_IMM8_ID16_V8: return InferLdObjByName(gate); - case EcmaOpcode::LDA_STR_ID32: + case EcmaOpcode::LDA_STR_ID16: return InferLdStr(gate); - case EcmaOpcode::CALLARG0DYN_PREF_V8: - case EcmaOpcode::CALLARG1DYN_PREF_V8_V8: - case EcmaOpcode::CALLARGS2DYN_PREF_V8_V8_V8: - case EcmaOpcode::CALLARGS3DYN_PREF_V8_V8_V8_V8: - case EcmaOpcode::CALLSPREADDYN_PREF_V8_V8_V8: - case EcmaOpcode::CALLIRANGEDYN_PREF_IMM16_V8: - case EcmaOpcode::CALLITHISRANGEDYN_PREF_IMM16_V8: + case EcmaOpcode::CALLARG0_IMM8_V8: + case EcmaOpcode::CALLARG1_IMM8_V8_V8: + case EcmaOpcode::CALLARGS2_IMM8_V8_V8_V8: + case EcmaOpcode::CALLARGS3_IMM8_V8_V8_V8_V8: + case EcmaOpcode::CALLSPREAD_IMM8_V8_V8_V8: + case EcmaOpcode::CALLRANGE_IMM8_IMM16_V8: + case EcmaOpcode::CALLTHISRANGE_IMM8_IMM16_V8: return InferCallFunction(gate); - case EcmaOpcode::LDOBJBYVALUE_PREF_V8_V8: + case EcmaOpcode::LDOBJBYVALUE_IMM8_V8_V8: return InferLdObjByValue(gate); - case EcmaOpcode::GETNEXTPROPNAME_PREF_V8: + case EcmaOpcode::GETNEXTPROPNAME_V8: return InferGetNextPropName(gate); - case EcmaOpcode::DEFINEGETTERSETTERBYVALUE_PREF_V8_V8_V8_V8: + case EcmaOpcode::DEFINEGETTERSETTERBYVALUE_V8_V8_V8_V8: return InferDefineGetterSetterByValue(gate); case EcmaOpcode::NEWOBJDYNRANGE_PREF_IMM16_V8: case EcmaOpcode::NEWOBJSPREADDYN_PREF_V8_V8: @@ -190,11 +195,12 @@ bool TypeInfer::Infer(GateRef gate) case EcmaOpcode::SUPERCALL_PREF_IMM16_V8: case EcmaOpcode::SUPERCALLSPREAD_PREF_V8: return InferSuperCall(gate); - case EcmaOpcode::TRYLDGLOBALBYNAME_PREF_ID32: + case EcmaOpcode::TRYLDGLOBALBYNAME_IMM8_ID16: return InferTryLdGlobalByName(gate); default: break; } + */ return false; } @@ -250,13 +256,13 @@ bool TypeInfer::InferLdNull(GateRef gate) return UpdateType(gate, nullType); } -bool TypeInfer::InferLdaiDyn(GateRef gate) +bool TypeInfer::InferLdai(GateRef gate) { auto numberType = GateType::NumberType(); return UpdateType(gate, numberType); } -bool TypeInfer::InferFLdaiDyn(GateRef gate) +bool TypeInfer::InferFLdai(GateRef gate) { auto numberType = GateType::NumberType(); return UpdateType(gate, numberType); @@ -268,21 +274,21 @@ bool TypeInfer::InferLdSymbol(GateRef gate) return UpdateType(gate, symbolType); } -bool TypeInfer::InferThrowDyn(GateRef gate) +bool TypeInfer::InferThrow(GateRef gate) { ASSERT(gateAccessor_.GetNumValueIn(gate) == 1); auto gateType = gateAccessor_.GetGateType(gateAccessor_.GetValueIn(gate, 0)); return UpdateType(gate, gateType); } -bool TypeInfer::InferTypeOfDyn(GateRef gate) +bool TypeInfer::InferTypeOf(GateRef gate) { ASSERT(gateAccessor_.GetNumValueIn(gate) == 1); auto gateType = gateAccessor_.GetGateType(gateAccessor_.GetValueIn(gate, 0)); return UpdateType(gate, gateType); } -bool TypeInfer::InferAdd2Dyn(GateRef gate) +bool TypeInfer::InferAdd2(GateRef gate) { // 2: number of value inputs ASSERT(gateAccessor_.GetNumValueIn(gate) == 2); @@ -343,7 +349,7 @@ bool TypeInfer::InferReturnUndefined(GateRef gate) return UpdateType(gate, undefinedType); } -bool TypeInfer::InferReturnDyn(GateRef gate) +bool TypeInfer::InferReturn(GateRef gate) { ASSERT(gateAccessor_.GetNumValueIn(gate) == 1); auto gateType = gateAccessor_.GetGateType(gateAccessor_.GetValueIn(gate, 0)); @@ -357,7 +363,7 @@ bool TypeInfer::InferLdObjByName(GateRef gate) auto objType = gateAccessor_.GetGateType(gateAccessor_.GetValueIn(gate, 1)); if (objType.IsTSType()) { // If this object has no gt type, we cannot get its internal property type - if (IsObjectOrClass(objType)) { + if (IsObjectOrHClass(objType)) { auto index = gateAccessor_.GetBitField(gateAccessor_.GetValueIn(gate, 0)); auto name = tsManager_->GetStringById(index); auto type = GetPropType(objType, name); @@ -407,7 +413,7 @@ bool TypeInfer::InferLdObjByValue(GateRef gate) return UpdateType(gate, elementType); } // handle object - if (IsObjectOrClass(objType)) { + if (IsObjectOrHClass(objType)) { auto valueGate = gateAccessor_.GetValueIn(gate, 1); if (gateAccessor_.GetOpCode(valueGate) == OpCode::CONSTANT) { auto value = gateAccessor_.GetBitField(valueGate); @@ -481,12 +487,12 @@ void TypeInfer::Verify() const void TypeInfer::TypeCheck(GateRef gate) const { auto info = builder_->GetByteCodeInfo(gate); - if (!info.IsBc(EcmaOpcode::CALLARGS2DYN_PREF_V8_V8_V8)) { + if (!info.IsBc(EcmaOpcode::CALLARGS2_IMM8_V8_V8)) { return; } auto func = gateAccessor_.GetValueIn(gate, 0); auto funcInfo = builder_->GetByteCodeInfo(func); - if (!funcInfo.IsBc(EcmaOpcode::TRYLDGLOBALBYNAME_PREF_ID32)) { + if (!funcInfo.IsBc(EcmaOpcode::TRYLDGLOBALBYNAME_IMM8_ID16)) { return; } auto funcName = gateAccessor_.GetValueIn(func, 0); diff --git a/ecmascript/compiler/type_inference/type_infer.h b/ecmascript/compiler/type_inference/type_infer.h index f56cdb7c5f..b2f922a3b2 100644 --- a/ecmascript/compiler/type_inference/type_infer.h +++ b/ecmascript/compiler/type_inference/type_infer.h @@ -48,16 +48,16 @@ private: bool SetBooleanType(GateRef gate); bool InferLdUndefined(GateRef gate); bool InferLdNull(GateRef gate); - bool InferLdaiDyn(GateRef gate); - bool InferFLdaiDyn(GateRef gate); + bool InferLdai(GateRef gate); + bool InferFLdai(GateRef gate); bool InferLdSymbol(GateRef gate); - bool InferThrowDyn(GateRef gate); - bool InferTypeOfDyn(GateRef gate); - bool InferAdd2Dyn(GateRef gate); + bool InferThrow(GateRef gate); + bool InferTypeOf(GateRef gate); + bool InferAdd2(GateRef gate); bool InferLdObjByIndex(GateRef gate); bool InferLdGlobalVar(GateRef gate); bool InferReturnUndefined(GateRef gate); - bool InferReturnDyn(GateRef gate); + bool InferReturn(GateRef gate); bool InferLdObjByName(GateRef gate); bool InferNewObject(GateRef gate); bool SetStGlobalBcType(GateRef gate); @@ -79,7 +79,7 @@ private: return tsManager_->GetPropType(type, key); } - inline bool IsObjectOrClass(const GateType &type) const + inline bool IsObjectOrHClass(const GateType &type) const { auto flag = tsManager_->IsObjectTypeKind(type) || tsManager_->IsClassTypeKind(type) || diff --git a/ecmascript/compiler/type_lowering.cpp b/ecmascript/compiler/type_lowering.cpp index 8b931c7ea8..0cde733902 100644 --- a/ecmascript/compiler/type_lowering.cpp +++ b/ecmascript/compiler/type_lowering.cpp @@ -43,8 +43,8 @@ void TypeLowering::Lower(GateRef gate) // initialize label manager Environment env(gate, circuit_, &builder_); switch (op) { - case NEWOBJDYNRANGE_PREF_IMM16_V8: - LowerTypeNewObjDynRange(gate, glue); + case EcmaOpcode::NEWOBJRANGE_IMM8_IMM16_V8: + LowerTypeNewObjRange(gate, glue); break; default: break; @@ -101,7 +101,7 @@ GateRef TypeLowering::LowerCallRuntime(GateRef glue, int index, const std::vecto } } -void TypeLowering::LowerTypeNewObjDynRange(GateRef gate, GateRef glue) +void TypeLowering::LowerTypeNewObjRange(GateRef gate, GateRef glue) { GateRef ctor = acc_.GetValueIn(gate, 0); GateType ctorType = acc_.GetGateType(ctor); diff --git a/ecmascript/compiler/type_lowering.h b/ecmascript/compiler/type_lowering.h index 80fe61a21a..1f0ca14840 100644 --- a/ecmascript/compiler/type_lowering.h +++ b/ecmascript/compiler/type_lowering.h @@ -48,7 +48,7 @@ private: GateRef LowerCallRuntime(GateRef glue, int index, const std::vector &args, bool useLabel = false); - void LowerTypeNewObjDynRange(GateRef gate, GateRef glue); + void LowerTypeNewObjRange(GateRef gate, GateRef glue); BytecodeCircuitBuilder *bcBuilder_; Circuit *circuit_; diff --git a/ecmascript/containers/containers_private.cpp b/ecmascript/containers/containers_private.cpp index ad14ced151..9d595a1220 100644 --- a/ecmascript/containers/containers_private.cpp +++ b/ecmascript/containers/containers_private.cpp @@ -267,14 +267,14 @@ JSHandle ContainersPrivate::InitializeArrayList(JSThread *thread) // ArrayList.prototype JSHandle prototype = factory->NewEmptyJSObject(); JSHandle arrayListFuncPrototypeValue(prototype); - // ArrayList.prototype_or_dynclass - JSHandle arrayListInstanceDynclass = - factory->NewEcmaDynClass(JSAPIArrayList::SIZE, JSType::JS_API_ARRAY_LIST, arrayListFuncPrototypeValue); + // ArrayList.prototype_or_hclass + JSHandle arrayListInstanceClass = + factory->NewEcmaHClass(JSAPIArrayList::SIZE, JSType::JS_API_ARRAY_LIST, arrayListFuncPrototypeValue); // ArrayList() = new Function() JSHandle arrayListFunction(NewContainerConstructor( thread, prototype, ContainersArrayList::ArrayListConstructor, "ArrayList", FuncLength::ZERO)); JSHandle::Cast(arrayListFunction)->SetFunctionPrototype(thread, - arrayListInstanceDynclass.GetTaggedValue()); + arrayListInstanceClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); @@ -323,11 +323,11 @@ void ContainersPrivate::InitializeArrayListIterator(JSThread *thread, const JSHa GlobalEnvConstants *globalConst) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - // Iterator.dynclass - JSHandle iteratorFuncDynclass = - factory->NewEcmaDynClass(JSObject::SIZE, JSType::JS_ITERATOR, env->GetIteratorPrototype()); + // Iterator.hclass + JSHandle iteratorFuncHClass = + factory->NewEcmaHClass(JSObject::SIZE, JSType::JS_ITERATOR, env->GetIteratorPrototype()); // ArrayListIterator.prototype - JSHandle arrayListIteratorPrototype(factory->NewJSObject(iteratorFuncDynclass)); + JSHandle arrayListIteratorPrototype(factory->NewJSObject(iteratorFuncHClass)); // Iterator.prototype.next() SetFrozenFunction(thread, arrayListIteratorPrototype, "next", JSAPIArrayListIterator::Next, FuncLength::ONE); SetStringTagSymbol(thread, env, arrayListIteratorPrototype, "ArrayList Iterator"); @@ -341,13 +341,13 @@ JSHandle ContainersPrivate::InitializeLightWeightMap(JSThread *th ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); JSHandle funcPrototype = factory->NewEmptyJSObject(); JSHandle mapFuncPrototypeValue(funcPrototype); - JSHandle lightWeightMapInstanceDynclass = - factory->NewEcmaDynClass(JSAPILightWeightMap::SIZE, JSType::JS_API_LIGHT_WEIGHT_MAP, mapFuncPrototypeValue); + JSHandle lightWeightMapInstanceClass = + factory->NewEcmaHClass(JSAPILightWeightMap::SIZE, JSType::JS_API_LIGHT_WEIGHT_MAP, mapFuncPrototypeValue); JSHandle lightWeightMapFunction(NewContainerConstructor( thread, funcPrototype, ContainersLightWeightMap::LightWeightMapConstructor, "LightWeightMap", FuncLength::ZERO)); JSHandle::Cast(lightWeightMapFunction)-> - SetFunctionPrototype(thread, lightWeightMapInstanceDynclass.GetTaggedValue()); + SetFunctionPrototype(thread, lightWeightMapInstanceClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); @@ -395,9 +395,9 @@ void ContainersPrivate::InitializeLightWeightMapIterator(JSThread *thread) { JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHandle iteratorDynclass = factory->NewEcmaDynClass(JSObject::SIZE, JSType::JS_ITERATOR, + JSHandle iteratorClass = factory->NewEcmaHClass(JSObject::SIZE, JSType::JS_ITERATOR, env->GetIteratorPrototype()); - JSHandle lightWeightMapIteratorPrototype(factory->NewJSObject(iteratorDynclass)); + JSHandle lightWeightMapIteratorPrototype(factory->NewJSObject(iteratorClass)); SetFrozenFunction(thread, lightWeightMapIteratorPrototype, "next", JSAPILightWeightMapIterator::Next, FuncLength::ONE); SetStringTagSymbol(thread, env, lightWeightMapIteratorPrototype, "LightWeightMap Iterator"); @@ -413,13 +413,13 @@ JSHandle ContainersPrivate::InitializeLightWeightSet(JSThread *th // LightWeightSet.prototype JSHandle funcPrototype = factory->NewEmptyJSObject(); JSHandle funcPrototypeValue(funcPrototype); - // LightWeightSet.prototype_or_dynclass - JSHandle lightweightSetInstanceDynclass = - factory->NewEcmaDynClass(JSAPILightWeightSet::SIZE, JSType::JS_API_LIGHT_WEIGHT_SET, funcPrototypeValue); + // LightWeightSet.prototype_or_hclass + JSHandle lightweightSetInstanceClass = + factory->NewEcmaHClass(JSAPILightWeightSet::SIZE, JSType::JS_API_LIGHT_WEIGHT_SET, funcPrototypeValue); JSHandle lightweightSetFunction( NewContainerConstructor(thread, funcPrototype, ContainersLightWeightSet::LightWeightSetConstructor, "LightWeightSet", FuncLength::ZERO)); - JSHandle::Cast(lightweightSetFunction)->SetFunctionPrototype(thread, lightweightSetInstanceDynclass. + JSHandle::Cast(lightweightSetFunction)->SetFunctionPrototype(thread, lightweightSetInstanceClass. GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); @@ -460,9 +460,9 @@ void ContainersPrivate::InitializeLightWeightSetIterator(JSThread *thread) JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); auto globalConst = const_cast(thread->GlobalConstants()); - JSHandle iteratorDynclass = JSHandle(thread, globalConst->GetHandledJSAPIIteratorFuncDynClass(). + JSHandle iteratorClass = JSHandle(thread, globalConst->GetHandledJSAPIIteratorFuncHClass(). GetObject()); - JSHandle lightWeightSetIteratorPrototype(factory->NewJSObject(iteratorDynclass)); + JSHandle lightWeightSetIteratorPrototype(factory->NewJSObject(iteratorClass)); SetFrozenFunction( thread, lightWeightSetIteratorPrototype, "next", JSAPILightWeightSetIterator::Next, FuncLength::ONE); SetStringTagSymbol(thread, env, lightWeightSetIteratorPrototype, "LightWeightSet Iterator"); @@ -477,13 +477,13 @@ JSHandle ContainersPrivate::InitializeTreeMap(JSThread *thread) // TreeMap.prototype JSHandle mapFuncPrototype = factory->NewEmptyJSObject(); JSHandle mapFuncPrototypeValue(mapFuncPrototype); - // TreeMap.prototype_or_dynclass - JSHandle mapInstanceDynclass = - factory->NewEcmaDynClass(JSAPITreeMap::SIZE, JSType::JS_API_TREE_MAP, mapFuncPrototypeValue); + // TreeMap.prototype_or_hclass + JSHandle mapInstanceClass = + factory->NewEcmaHClass(JSAPITreeMap::SIZE, JSType::JS_API_TREE_MAP, mapFuncPrototypeValue); // TreeMap() = new Function() JSHandle mapFunction(NewContainerConstructor( thread, mapFuncPrototype, ContainersTreeMap::TreeMapConstructor, "TreeMap", FuncLength::ZERO)); - JSHandle::Cast(mapFunction)->SetFunctionPrototype(thread, mapInstanceDynclass.GetTaggedValue()); + JSHandle::Cast(mapFunction)->SetFunctionPrototype(thread, mapInstanceClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); @@ -532,12 +532,12 @@ void ContainersPrivate::InitializeTreeMapIterator(JSThread *thread) { JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - // Iterator.dynclass - JSHandle iteratorDynclass = - factory->NewEcmaDynClass(JSObject::SIZE, JSType::JS_ITERATOR, env->GetIteratorPrototype()); + // Iterator.hclass + JSHandle iteratorClass = + factory->NewEcmaHClass(JSObject::SIZE, JSType::JS_ITERATOR, env->GetIteratorPrototype()); // TreeMapIterator.prototype - JSHandle mapIteratorPrototype(factory->NewJSObject(iteratorDynclass)); + JSHandle mapIteratorPrototype(factory->NewJSObject(iteratorClass)); // TreeIterator.prototype.next() SetFrozenFunction(thread, mapIteratorPrototype, "next", JSAPITreeMapIterator::Next, FuncLength::ZERO); SetStringTagSymbol(thread, env, mapIteratorPrototype, "TreeMap Iterator"); @@ -552,13 +552,13 @@ JSHandle ContainersPrivate::InitializeTreeSet(JSThread *thread) // TreeSet.prototype JSHandle setFuncPrototype = factory->NewEmptyJSObject(); JSHandle setFuncPrototypeValue(setFuncPrototype); - // TreeSet.prototype_or_dynclass - JSHandle setInstanceDynclass = - factory->NewEcmaDynClass(JSAPITreeSet::SIZE, JSType::JS_API_TREE_SET, setFuncPrototypeValue); + // TreeSet.prototype_or_hclass + JSHandle setInstanceClass = + factory->NewEcmaHClass(JSAPITreeSet::SIZE, JSType::JS_API_TREE_SET, setFuncPrototypeValue); // TreeSet() = new Function() JSHandle setFunction(NewContainerConstructor( thread, setFuncPrototype, ContainersTreeSet::TreeSetConstructor, "TreeSet", FuncLength::ZERO)); - JSHandle::Cast(setFunction)->SetFunctionPrototype(thread, setInstanceDynclass.GetTaggedValue()); + JSHandle::Cast(setFunction)->SetFunctionPrototype(thread, setInstanceClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); @@ -604,12 +604,12 @@ void ContainersPrivate::InitializeTreeSetIterator(JSThread *thread) { JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - // Iterator.dynclass - JSHandle iteratorDynclass = - factory->NewEcmaDynClass(JSObject::SIZE, JSType::JS_ITERATOR, env->GetIteratorPrototype()); + // Iterator.hclass + JSHandle iteratorClass = + factory->NewEcmaHClass(JSObject::SIZE, JSType::JS_ITERATOR, env->GetIteratorPrototype()); // TreeSetIterator.prototype - JSHandle setIteratorPrototype(factory->NewJSObject(iteratorDynclass)); + JSHandle setIteratorPrototype(factory->NewJSObject(iteratorClass)); // TreeSetIterator.prototype.next() SetFrozenFunction(thread, setIteratorPrototype, "next", JSAPITreeSetIterator::Next, FuncLength::ZERO); SetStringTagSymbol(thread, env, setIteratorPrototype, "TreeSet Iterator"); @@ -624,14 +624,14 @@ JSHandle ContainersPrivate::InitializePlainArray(JSThread *thread // PlainArray.prototype JSHandle plainArrayFuncPrototype = factory->NewEmptyJSObject(); JSHandle plainArrayFuncPrototypeValue(plainArrayFuncPrototype); - // PlainArray.prototype_or_dynclass - JSHandle plainArrayInstanceDynclass = - factory->NewEcmaDynClass(JSAPIPlainArray::SIZE, JSType::JS_API_PLAIN_ARRAY, plainArrayFuncPrototypeValue); + // PlainArray.prototype_or_hclass + JSHandle plainArrayInstanceClass = + factory->NewEcmaHClass(JSAPIPlainArray::SIZE, JSType::JS_API_PLAIN_ARRAY, plainArrayFuncPrototypeValue); JSHandle plainArrayFunction( NewContainerConstructor(thread, plainArrayFuncPrototype, ContainersPlainArray::PlainArrayConstructor, "PlainArray", FuncLength::ZERO)); JSHandle::Cast(plainArrayFunction)->SetFunctionPrototype(thread, - plainArrayInstanceDynclass.GetTaggedValue()); + plainArrayInstanceClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); @@ -681,10 +681,10 @@ void ContainersPrivate::InitializePlainArrayIterator(JSThread *thread) JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); auto globalConst = const_cast(thread->GlobalConstants()); - JSHandle iteratorDynclass = JSHandle(thread, globalConst-> - GetHandledJSAPIIteratorFuncDynClass(). + JSHandle iteratorClass = JSHandle(thread, globalConst-> + GetHandledJSAPIIteratorFuncHClass(). GetObject()); - JSHandle plainarrayIteratorPrototype(factory->NewJSObject(iteratorDynclass)); + JSHandle plainarrayIteratorPrototype(factory->NewJSObject(iteratorClass)); SetFrozenFunction(thread, plainarrayIteratorPrototype, "next", JSAPIPlainArrayIterator::Next, FuncLength::ONE); SetStringTagSymbol(thread, env, plainarrayIteratorPrototype, "PlainArray Iterator"); globalConst->SetConstant(ConstantIndex::PLAIN_ARRAY_ITERATOR_PROTOTYPE_INDEX, @@ -698,13 +698,13 @@ JSHandle ContainersPrivate::InitializeStack(JSThread *thread) // Stack.prototype JSHandle stackFuncPrototype = factory->NewEmptyJSObject(); JSHandle stackFuncPrototypeValue(stackFuncPrototype); - // Stack.prototype_or_dynclass - JSHandle stackInstanceDynclass = - factory->NewEcmaDynClass(JSAPIStack::SIZE, JSType::JS_API_STACK, stackFuncPrototypeValue); + // Stack.prototype_or_hclass + JSHandle stackInstanceClass = + factory->NewEcmaHClass(JSAPIStack::SIZE, JSType::JS_API_STACK, stackFuncPrototypeValue); // Stack() = new Function() JSHandle stackFunction(NewContainerConstructor( thread, stackFuncPrototype, ContainersStack::StackConstructor, "Stack", FuncLength::ZERO)); - JSHandle::Cast(stackFunction)->SetFunctionPrototype(thread, stackInstanceDynclass.GetTaggedValue()); + JSHandle::Cast(stackFunction)->SetFunctionPrototype(thread, stackInstanceClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); @@ -740,10 +740,10 @@ JSHandle ContainersPrivate::InitializeStack(JSThread *thread) void ContainersPrivate::InitializeStackIterator(JSThread *thread, GlobalEnvConstants *globalConst) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHandle iteratorFuncDynclass = JSHandle(thread, globalConst-> - GetHandledJSAPIIteratorFuncDynClass().GetObject()); + JSHandle iteratorFuncHClass = JSHandle(thread, globalConst-> + GetHandledJSAPIIteratorFuncHClass().GetObject()); // StackIterator.prototype - JSHandle stackIteratorPrototype(factory->NewJSObject(iteratorFuncDynclass)); + JSHandle stackIteratorPrototype(factory->NewJSObject(iteratorFuncHClass)); // Iterator.prototype.next() SetFrozenFunction(thread, stackIteratorPrototype, "next", JSAPIStackIterator::Next, FuncLength::ONE); globalConst->SetConstant(ConstantIndex::STACK_ITERATOR_PROTOTYPE_INDEX, stackIteratorPrototype.GetTaggedValue()); @@ -756,13 +756,13 @@ JSHandle ContainersPrivate::InitializeVector(JSThread *thread) // Vector.prototype JSHandle prototype = factory->NewEmptyJSObject(); JSHandle vectorFuncPrototypeValue(prototype); - // Vector.prototype_or_dynclass - JSHandle vectorInstanceDynclass = - factory->NewEcmaDynClass(JSAPIVector::SIZE, JSType::JS_API_VECTOR, vectorFuncPrototypeValue); + // Vector.prototype_or_hclass + JSHandle vectorInstanceClass = + factory->NewEcmaHClass(JSAPIVector::SIZE, JSType::JS_API_VECTOR, vectorFuncPrototypeValue); // Vector() = new Function() JSHandle vectorFunction(NewContainerConstructor( thread, prototype, ContainersVector::VectorConstructor, "Vector", FuncLength::ZERO)); - JSHandle::Cast(vectorFunction)->SetFunctionPrototype(thread, vectorInstanceDynclass.GetTaggedValue()); + JSHandle::Cast(vectorFunction)->SetFunctionPrototype(thread, vectorInstanceClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); @@ -818,10 +818,10 @@ void ContainersPrivate::InitializeVectorIterator(JSThread *thread, const JSHandl GlobalEnvConstants *globalConst) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHandle iteratorFuncDynclass = JSHandle(thread, globalConst-> - GetHandledJSAPIIteratorFuncDynClass().GetObject()); + JSHandle iteratorFuncHClass = JSHandle(thread, globalConst-> + GetHandledJSAPIIteratorFuncHClass().GetObject()); // VectorIterator.prototype - JSHandle vectorIteratorPrototype(factory->NewJSObject(iteratorFuncDynclass)); + JSHandle vectorIteratorPrototype(factory->NewJSObject(iteratorFuncHClass)); // Iterator.prototype.next() SetFrozenFunction(thread, vectorIteratorPrototype, "next", JSAPIVectorIterator::Next, FuncLength::ONE); SetStringTagSymbol(thread, env, vectorIteratorPrototype, "Vector Iterator"); @@ -835,13 +835,13 @@ JSHandle ContainersPrivate::InitializeQueue(JSThread *thread) // Queue.prototype JSHandle queueFuncPrototype = factory->NewEmptyJSObject(); JSHandle queueFuncPrototypeValue(queueFuncPrototype); - // Queue.prototype_or_dynclass - JSHandle queueInstanceDynclass = - factory->NewEcmaDynClass(JSAPIQueue::SIZE, JSType::JS_API_QUEUE, queueFuncPrototypeValue); + // Queue.prototype_or_hclass + JSHandle queueInstanceClass = + factory->NewEcmaHClass(JSAPIQueue::SIZE, JSType::JS_API_QUEUE, queueFuncPrototypeValue); // Queue() = new Function() JSHandle queueFunction(NewContainerConstructor( thread, queueFuncPrototype, ContainersQueue::QueueConstructor, "Queue", FuncLength::ZERO)); - JSHandle::Cast(queueFunction)->SetFunctionPrototype(thread, queueInstanceDynclass.GetTaggedValue()); + JSHandle::Cast(queueFunction)->SetFunctionPrototype(thread, queueInstanceClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); @@ -871,10 +871,10 @@ void ContainersPrivate::InitializeQueueIterator(JSThread *thread, const JSHandle GlobalEnvConstants *globalConst) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHandle iteratorFuncDynclass = - factory->NewEcmaDynClass(JSObject::SIZE, JSType::JS_ITERATOR, env->GetIteratorPrototype()); + JSHandle iteratorFuncHClass = + factory->NewEcmaHClass(JSObject::SIZE, JSType::JS_ITERATOR, env->GetIteratorPrototype()); // QueueIterator.prototype - JSHandle queueIteratorPrototype(factory->NewJSObject(iteratorFuncDynclass)); + JSHandle queueIteratorPrototype(factory->NewJSObject(iteratorFuncHClass)); // Iterator.prototype.next() SetFrozenFunction(thread, queueIteratorPrototype, "next", JSAPIQueueIterator::Next, FuncLength::ONE); SetStringTagSymbol(thread, env, queueIteratorPrototype, "Queue Iterator"); @@ -888,13 +888,13 @@ JSHandle ContainersPrivate::InitializeDeque(JSThread *thread) // Deque.prototype JSHandle dequeFuncPrototype = factory->NewEmptyJSObject(); JSHandle dequeFuncPrototypeValue(dequeFuncPrototype); - // Deque.prototype_or_dynclass - JSHandle dequeInstanceDynclass = - factory->NewEcmaDynClass(JSAPIDeque::SIZE, JSType::JS_API_DEQUE, dequeFuncPrototypeValue); + // Deque.prototype_or_hclass + JSHandle dequeInstanceClass = + factory->NewEcmaHClass(JSAPIDeque::SIZE, JSType::JS_API_DEQUE, dequeFuncPrototypeValue); // Deque() = new Function() JSHandle dequeFunction(NewContainerConstructor( thread, dequeFuncPrototype, ContainersDeque::DequeConstructor, "Deque", FuncLength::ZERO)); - JSHandle::Cast(dequeFunction)->SetFunctionPrototype(thread, dequeInstanceDynclass.GetTaggedValue()); + JSHandle::Cast(dequeFunction)->SetFunctionPrototype(thread, dequeInstanceClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); @@ -928,9 +928,9 @@ void ContainersPrivate::InitializeDequeIterator(JSThread *thread, const JSHandle GlobalEnvConstants *globalConst) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHandle iteratorFuncDynclass = JSHandle(thread, globalConst-> - GetHandledJSAPIIteratorFuncDynClass().GetObject()); - JSHandle dequeIteratorPrototype(factory->NewJSObject(iteratorFuncDynclass)); + JSHandle iteratorFuncHClass = JSHandle(thread, globalConst-> + GetHandledJSAPIIteratorFuncHClass().GetObject()); + JSHandle dequeIteratorPrototype(factory->NewJSObject(iteratorFuncHClass)); SetFrozenFunction(thread, dequeIteratorPrototype, "next", JSAPIDequeIterator::Next, FuncLength::ONE); SetStringTagSymbol(thread, env, dequeIteratorPrototype, "Deque Iterator"); globalConst->SetConstant(ConstantIndex::DEQUE_ITERATOR_PROTOTYPE_INDEX, dequeIteratorPrototype.GetTaggedValue()); @@ -942,11 +942,11 @@ JSHandle ContainersPrivate::InitializeList(JSThread *thread) ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); JSHandle listFuncPrototype = factory->NewEmptyJSObject(); JSHandle listFuncPrototypeValue(listFuncPrototype); - JSHandle listInstanceDynclass = - factory->NewEcmaDynClass(JSAPIList::SIZE, JSType::JS_API_LIST, listFuncPrototypeValue); + JSHandle listInstanceClass = + factory->NewEcmaHClass(JSAPIList::SIZE, JSType::JS_API_LIST, listFuncPrototypeValue); JSHandle listFunction(NewContainerConstructor( thread, listFuncPrototype, ContainersList::ListConstructor, "List", FuncLength::ZERO)); - JSHandle::Cast(listFunction)->SetFunctionPrototype(thread, listInstanceDynclass.GetTaggedValue()); + JSHandle::Cast(listFunction)->SetFunctionPrototype(thread, listInstanceClass.GetTaggedValue()); JSHandle constructorKey = globalConst->GetHandledConstructorString(); JSObject::SetProperty(thread, JSHandle(listFuncPrototype), constructorKey, listFunction); @@ -991,12 +991,12 @@ JSHandle ContainersPrivate::InitializeLinkedList(JSThread *thread ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); JSHandle linkedListFuncPrototype = factory->NewEmptyJSObject(); JSHandle linkedListFuncPrototypeValue(linkedListFuncPrototype); - JSHandle linkedListInstanceDynclass = - factory->NewEcmaDynClass(JSAPILinkedList::SIZE, JSType::JS_API_LINKED_LIST, linkedListFuncPrototypeValue); + JSHandle linkedListInstanceClass = + factory->NewEcmaHClass(JSAPILinkedList::SIZE, JSType::JS_API_LINKED_LIST, linkedListFuncPrototypeValue); JSHandle linkedListFunction(NewContainerConstructor( thread, linkedListFuncPrototype, ContainersLinkedList::LinkedListConstructor, "LinkedList", FuncLength::ZERO)); JSHandle::Cast(linkedListFunction)->SetFunctionPrototype(thread, - linkedListInstanceDynclass.GetTaggedValue()); + linkedListInstanceClass.GetTaggedValue()); JSHandle constructorKey = globalConst->GetHandledConstructorString(); JSObject::SetProperty(thread, JSHandle(linkedListFuncPrototype), constructorKey, linkedListFunction); @@ -1046,9 +1046,9 @@ void ContainersPrivate::InitializeLinkedListIterator(JSThread *thread, const JSH { auto globalConst = const_cast(thread->GlobalConstants()); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHandle iteratorDynclass = - JSHandle(thread, globalConst->GetHandledJSAPIIteratorFuncDynClass().GetObject()); - JSHandle setIteratorPrototype(factory->NewJSObject(iteratorDynclass)); + JSHandle iteratorClass = + JSHandle(thread, globalConst->GetHandledJSAPIIteratorFuncHClass().GetObject()); + JSHandle setIteratorPrototype(factory->NewJSObject(iteratorClass)); SetFrozenFunction(thread, setIteratorPrototype, "next", JSAPILinkedListIterator::Next, FuncLength::ONE); SetStringTagSymbol(thread, env, setIteratorPrototype, "linkedlist Iterator"); globalConst->SetConstant(ConstantIndex::LINKED_LIST_ITERATOR_PROTOTYPE_INDEX, @@ -1059,9 +1059,9 @@ void ContainersPrivate::InitializeListIterator(JSThread *thread, const JSHandle< { auto globalConst = const_cast(thread->GlobalConstants()); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHandle iteratorDynclass = - JSHandle(thread, globalConst->GetHandledJSAPIIteratorFuncDynClass().GetObject()); - JSHandle setIteratorPrototype(factory->NewJSObject(iteratorDynclass)); + JSHandle iteratorClass = + JSHandle(thread, globalConst->GetHandledJSAPIIteratorFuncHClass().GetObject()); + JSHandle setIteratorPrototype(factory->NewJSObject(iteratorClass)); SetFrozenFunction(thread, setIteratorPrototype, "next", JSAPIListIterator::Next, FuncLength::ONE); SetStringTagSymbol(thread, env, setIteratorPrototype, "list Iterator"); globalConst->SetConstant(ConstantIndex::LIST_ITERATOR_PROTOTYPE_INDEX, setIteratorPrototype.GetTaggedValue()); @@ -1074,13 +1074,13 @@ JSHandle ContainersPrivate::InitializeHashMap(JSThread *thread) // HashMap.prototype JSHandle hashMapFuncPrototype = factory->NewEmptyJSObject(); JSHandle hashMapFuncPrototypeValue(hashMapFuncPrototype); - // HashMap.prototype_or_dynclass - JSHandle hashMapInstanceDynclass = - factory->NewEcmaDynClass(JSAPIHashMap::SIZE, JSType::JS_API_HASH_MAP, hashMapFuncPrototypeValue); + // HashMap.prototype_or_hclass + JSHandle hashMapInstanceClass = + factory->NewEcmaHClass(JSAPIHashMap::SIZE, JSType::JS_API_HASH_MAP, hashMapFuncPrototypeValue); JSHandle hashMapFunction(NewContainerConstructor( thread, hashMapFuncPrototype, ContainersHashMap::HashMapConstructor, "HashMap", FuncLength::ZERO)); - JSHandle::Cast(hashMapFunction)->SetFunctionPrototype(thread, hashMapInstanceDynclass.GetTaggedValue()); + JSHandle::Cast(hashMapFunction)->SetFunctionPrototype(thread, hashMapInstanceClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); @@ -1135,10 +1135,10 @@ void ContainersPrivate::InitializeHashMapIterator(JSThread *thread) JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); auto globalConst = const_cast(thread->GlobalConstants()); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHandle iteratorFuncDynclass = - JSHandle::Cast(globalConst->GetHandledJSAPIIteratorFuncDynClass()); + JSHandle iteratorFuncHClass = + JSHandle::Cast(globalConst->GetHandledJSAPIIteratorFuncHClass()); // HashMapIterator.prototype - JSHandle hashMapIteratorPrototype(factory->NewJSObject(iteratorFuncDynclass)); + JSHandle hashMapIteratorPrototype(factory->NewJSObject(iteratorFuncHClass)); // HashMapIterator.prototype.next() SetFrozenFunction(thread, hashMapIteratorPrototype, "next", JSAPIHashMapIterator::Next, FuncLength::ZERO); SetStringTagSymbol(thread, env, hashMapIteratorPrototype, "HashMap Iterator"); @@ -1154,13 +1154,13 @@ JSHandle ContainersPrivate::InitializeHashSet(JSThread *thread) // HashSet.prototype JSHandle hashSetFuncPrototype = factory->NewEmptyJSObject(); JSHandle hashSetFuncPrototypeValue(hashSetFuncPrototype); - // HashSet.prototype_or_dynclass - JSHandle hashSetInstanceDynclass = - factory->NewEcmaDynClass(JSAPIHashSet::SIZE, JSType::JS_API_HASH_SET, hashSetFuncPrototypeValue); + // HashSet.prototype_or_hclass + JSHandle hashSetInstanceClass = + factory->NewEcmaHClass(JSAPIHashSet::SIZE, JSType::JS_API_HASH_SET, hashSetFuncPrototypeValue); JSHandle hashSetFunction(NewContainerConstructor( thread, hashSetFuncPrototype, ContainersHashSet::HashSetConstructor, "HashSet", FuncLength::ZERO)); - JSHandle::Cast(hashSetFunction)->SetFunctionPrototype(thread, hashSetInstanceDynclass.GetTaggedValue()); + JSHandle::Cast(hashSetFunction)->SetFunctionPrototype(thread, hashSetInstanceClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); @@ -1200,11 +1200,11 @@ void ContainersPrivate::InitializeHashSetIterator(JSThread *thread) JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); auto globalConst = const_cast(thread->GlobalConstants()); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHandle iteratorFuncDynclass = - JSHandle::Cast(globalConst->GetHandledJSAPIIteratorFuncDynClass()); + JSHandle iteratorFuncHClass = + JSHandle::Cast(globalConst->GetHandledJSAPIIteratorFuncHClass()); // HashSetIterator.prototype - JSHandle hashSetIteratorPrototype(factory->NewJSObject(iteratorFuncDynclass)); + JSHandle hashSetIteratorPrototype(factory->NewJSObject(iteratorFuncHClass)); // HashSetIterator.prototype.next() SetFrozenFunction(thread, hashSetIteratorPrototype, "next", JSAPIHashSetIterator::Next, FuncLength::ZERO); SetStringTagSymbol(thread, env, hashSetIteratorPrototype, "HashSet Iterator"); diff --git a/ecmascript/dump.cpp b/ecmascript/dump.cpp index 3ed2452e1c..b2e4c35f66 100644 --- a/ecmascript/dump.cpp +++ b/ecmascript/dump.cpp @@ -491,7 +491,7 @@ static void DumpHClass(const JSHClass *jshclass, std::ostream &os, bool withDeta os << "\n"; } -static void DumpDynClass(TaggedObject *obj, std::ostream &os) +static void DumpClass(TaggedObject *obj, std::ostream &os) { JSHClass *hclass = obj->GetClass(); os << "JSHClass :" << std::setw(DUMP_TYPE_OFFSET) << " klass_(" << std::hex << hclass << ")\n"; @@ -537,7 +537,7 @@ static void DumpObject(TaggedObject *obj, std::ostream &os) switch (type) { case JSType::HCLASS: - return DumpDynClass(obj, os); + return DumpClass(obj, os); case JSType::TAGGED_ARRAY: case JSType::TAGGED_DICTIONARY: case JSType::TEMPLATE_MAP: @@ -1314,8 +1314,8 @@ void ConstantPool::Dump(std::ostream &os) const void JSFunction::Dump(std::ostream &os) const { - os << " - ProtoOrDynClass: "; - GetProtoOrDynClass().Dump(os); + os << " - ProtoOrHClass: "; + GetProtoOrHClass().Dump(os); os << "\n"; os << " - LexicalEnv: "; GetLexicalEnv().Dump(os); @@ -3357,7 +3357,7 @@ static void DumpStringClass(const EcmaString *str, vec.push_back(std::make_pair("string", JSTaggedValue(str))); } -static void DumpDynClass(TaggedObject *obj, +static void DumpClass(TaggedObject *obj, std::vector> &vec) { JSHClass *jshclass = obj->GetClass(); @@ -3373,7 +3373,7 @@ static void DumpObject(TaggedObject *obj, switch (type) { case JSType::HCLASS: - DumpDynClass(obj, vec); + DumpClass(obj, vec); return; case JSType::TAGGED_ARRAY: case JSType::TAGGED_DICTIONARY: @@ -4008,7 +4008,7 @@ void JSHClass::DumpForSnapshot([[maybe_unused]] std::vector> &vec) const { - vec.push_back(std::make_pair(CString("ProtoOrDynClass"), GetProtoOrDynClass())); + vec.push_back(std::make_pair(CString("ProtoOrHClass"), GetProtoOrHClass())); vec.push_back(std::make_pair(CString("LexicalEnv"), GetLexicalEnv())); vec.push_back(std::make_pair(CString("HomeObject"), GetHomeObject())); vec.push_back(std::make_pair(CString("FunctionKind"), JSTaggedValue(static_cast(GetFunctionKind())))); diff --git a/ecmascript/ecma_macros.h b/ecmascript/ecma_macros.h index 7b5a8cbd1b..4d04fc8f90 100644 --- a/ecmascript/ecma_macros.h +++ b/ecmascript/ecma_macros.h @@ -46,19 +46,19 @@ /* Note: We can't statically decide the element type is a primitive or heap object, especially for */ /* dynamically-typed languages like JavaScript. So we simply skip the read-barrier. */ // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) -#define GET_VALUE(addr, offset) Barriers::GetDynValue((addr), (offset)) +#define GET_VALUE(addr, offset) Barriers::GetValue((addr), (offset)) // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) #define SET_VALUE_WITH_BARRIER(thread, addr, offset, value) \ if ((value).IsHeapObject()) { \ - Barriers::SetDynObject(thread, addr, offset, (value).GetRawData()); \ + Barriers::SetObject(thread, addr, offset, (value).GetRawData()); \ } else { \ - Barriers::SetDynPrimitive(addr, offset, (value).GetRawData()); \ + Barriers::SetPrimitive(addr, offset, (value).GetRawData()); \ } // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) #define SET_VALUE_PRIMITIVE(addr, offset, value) \ - Barriers::SetDynPrimitive(this, offset, (value).GetRawData()) + Barriers::SetPrimitive(this, offset, (value).GetRawData()) // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) #define ACCESSORS(name, offset, endOffset) \ @@ -67,31 +67,31 @@ { \ /* Note: We can't statically decide the element type is a primitive or heap object, especially for */ \ /* dynamically-typed languages like JavaScript. So we simply skip the read-barrier. */ \ - return JSTaggedValue(Barriers::GetDynValue(this, offset)); \ + return JSTaggedValue(Barriers::GetValue(this, offset)); \ } \ template \ void Set##name(const JSThread *thread, JSHandle value, BarrierMode mode = WRITE_BARRIER) \ { \ if (mode == WRITE_BARRIER) { \ if (value.GetTaggedValue().IsHeapObject()) { \ - Barriers::SetDynObject(thread, this, offset, value.GetTaggedValue().GetRawData()); \ + Barriers::SetObject(thread, this, offset, value.GetTaggedValue().GetRawData()); \ } else { \ - Barriers::SetDynPrimitive(this, offset, value.GetTaggedValue().GetRawData()); \ + Barriers::SetPrimitive(this, offset, value.GetTaggedValue().GetRawData()); \ } \ } else { \ - Barriers::SetDynPrimitive(this, offset, value.GetTaggedValue().GetRawData()); \ + Barriers::SetPrimitive(this, offset, value.GetTaggedValue().GetRawData()); \ } \ } \ void Set##name(const JSThread *thread, JSTaggedValue value, BarrierMode mode = WRITE_BARRIER) \ { \ if (mode == WRITE_BARRIER) { \ if (value.IsHeapObject()) { \ - Barriers::SetDynObject(thread, this, offset, value.GetRawData()); \ + Barriers::SetObject(thread, this, offset, value.GetRawData()); \ } else { \ - Barriers::SetDynPrimitive(this, offset, value.GetRawData()); \ + Barriers::SetPrimitive(this, offset, value.GetRawData()); \ } \ } else { \ - Barriers::SetDynPrimitive(this, offset, value.GetRawData()); \ + Barriers::SetPrimitive(this, offset, value.GetRawData()); \ } \ } @@ -105,11 +105,11 @@ static constexpr size_t endOffset = (offset) + sizeof(sizeType); \ inline void Set##name(type value) \ { \ - Barriers::SetDynPrimitive(this, offset, value); \ + Barriers::SetPrimitive(this, offset, value); \ } \ inline type Get##name() const \ { \ - return Barriers::GetDynValue(this, offset); \ + return Barriers::GetValue(this, offset); \ } // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) diff --git a/ecmascript/ecma_vm.cpp b/ecmascript/ecma_vm.cpp index 44a8649303..6b85a7c82d 100644 --- a/ecmascript/ecma_vm.cpp +++ b/ecmascript/ecma_vm.cpp @@ -173,11 +173,11 @@ bool EcmaVM::Initialize() if (!options_.EnableSnapshotDeserialize()) { LOG_ECMA(DEBUG) << "EcmaVM::Initialize run builtins"; - JSHandle dynClassClassHandle = factory_->InitClassClass(); - JSHandle globalEnvClass = factory_->NewEcmaDynClass(*dynClassClassHandle, - GlobalEnv::SIZE, - JSType::GLOBAL_ENV); - globalConst->Init(thread_, *dynClassClassHandle); + JSHandle hClassHandle = factory_->InitClassClass(); + JSHandle globalEnvClass = factory_->NewEcmaHClass(*hClassHandle, + GlobalEnv::SIZE, + JSType::GLOBAL_ENV); + globalConst->Init(thread_, *hClassHandle); globalConstInitialized_ = true; JSHandle globalEnv = factory_->NewGlobalEnv(*globalEnvClass); globalEnv->Init(thread_); diff --git a/ecmascript/free_object.h b/ecmascript/free_object.h index 0aa1264360..ca57cefd92 100644 --- a/ecmascript/free_object.h +++ b/ecmascript/free_object.h @@ -49,7 +49,7 @@ public: inline void SetAvailable(uint32_t size) { if (size >= SIZE) { - Barriers::SetDynPrimitive(this, SIZE_OFFSET, JSTaggedValue(size).GetRawData()); + Barriers::SetPrimitive(this, SIZE_OFFSET, JSTaggedValue(size).GetRawData()); } } diff --git a/ecmascript/generator_helper.cpp b/ecmascript/generator_helper.cpp index 96926dc6c1..da181c8cdc 100644 --- a/ecmascript/generator_helper.cpp +++ b/ecmascript/generator_helper.cpp @@ -18,8 +18,6 @@ #include "ecmascript/interpreter/interpreter-inl.h" #include "ecmascript/js_iterator.h" -#include "libpandafile/bytecode_instruction-inl.h" - namespace panda::ecmascript { JSHandle GeneratorHelper::Next(JSThread *thread, const JSHandle &genContext, JSTaggedValue value) diff --git a/ecmascript/global_env.h b/ecmascript/global_env.h index 3c9fa81c00..dc88cb5cee 100644 --- a/ecmascript/global_env.h +++ b/ecmascript/global_env.h @@ -228,18 +228,18 @@ public: { \ uint32_t offset = HEADER_SIZE + index * JSTaggedValue::TaggedTypeSize(); \ if (mode == WRITE_BARRIER && value.GetTaggedValue().IsHeapObject()) { \ - Barriers::SetDynObject(thread, this, offset, value.GetTaggedValue().GetRawData()); \ + Barriers::SetObject(thread, this, offset, value.GetTaggedValue().GetRawData()); \ } else { \ - Barriers::SetDynPrimitive(this, offset, value.GetTaggedValue().GetRawData()); \ + Barriers::SetPrimitive(this, offset, value.GetTaggedValue().GetRawData()); \ } \ } \ inline void Set##name(const JSThread *thread, type value, BarrierMode mode = WRITE_BARRIER) \ { \ uint32_t offset = HEADER_SIZE + index * JSTaggedValue::TaggedTypeSize(); \ if (mode == WRITE_BARRIER && value.IsHeapObject()) { \ - Barriers::SetDynObject(thread, this, offset, value.GetRawData()); \ + Barriers::SetObject(thread, this, offset, value.GetRawData()); \ } else { \ - Barriers::SetDynPrimitive(this, offset, value.GetRawData()); \ + Barriers::SetPrimitive(this, offset, value.GetRawData()); \ } \ } GLOBAL_ENV_FIELDS(GLOBAL_ENV_FIELD_ACCESSORS) diff --git a/ecmascript/global_env_constants.cpp b/ecmascript/global_env_constants.cpp index c1e3a500bc..92cd3e9071 100644 --- a/ecmascript/global_env_constants.cpp +++ b/ecmascript/global_env_constants.cpp @@ -73,183 +73,183 @@ #include "ecmascript/ts_types/ts_type.h" namespace panda::ecmascript { -void GlobalEnvConstants::Init(JSThread *thread, JSHClass *dynClassClass) +void GlobalEnvConstants::Init(JSThread *thread, JSHClass *hClass) { - InitRootsClass(thread, dynClassClass); + InitRootsClass(thread, hClass); InitGlobalConstant(thread); } -void GlobalEnvConstants::InitRootsClass([[maybe_unused]] JSThread *thread, JSHClass *dynClassClass) +void GlobalEnvConstants::InitRootsClass([[maybe_unused]] JSThread *thread, JSHClass *hClass) { // Global constants are readonly. ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - SetConstant(ConstantIndex::HCLASS_CLASS_INDEX, JSTaggedValue(dynClassClass)); + SetConstant(ConstantIndex::HCLASS_CLASS_INDEX, JSTaggedValue(hClass)); SetConstant(ConstantIndex::FREE_OBJECT_WITH_NONE_FIELD_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, FreeObject::NEXT_OFFSET, JSType::FREE_OBJECT_WITH_NONE_FIELD)); + factory->NewEcmaReadOnlyHClass(hClass, FreeObject::NEXT_OFFSET, JSType::FREE_OBJECT_WITH_NONE_FIELD)); SetConstant(ConstantIndex::FREE_OBJECT_WITH_ONE_FIELD_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, FreeObject::SIZE_OFFSET, JSType::FREE_OBJECT_WITH_ONE_FIELD)); + factory->NewEcmaReadOnlyHClass(hClass, FreeObject::SIZE_OFFSET, JSType::FREE_OBJECT_WITH_ONE_FIELD)); SetConstant(ConstantIndex::FREE_OBJECT_WITH_TWO_FIELD_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, FreeObject::SIZE, JSType::FREE_OBJECT_WITH_TWO_FIELD)); - SetConstant(ConstantIndex::STRING_CLASS_INDEX, factory->NewEcmaReadOnlyDynClass(dynClassClass, 0, JSType::STRING)); + factory->NewEcmaReadOnlyHClass(hClass, FreeObject::SIZE, JSType::FREE_OBJECT_WITH_TWO_FIELD)); + SetConstant(ConstantIndex::STRING_CLASS_INDEX, factory->NewEcmaReadOnlyHClass(hClass, 0, JSType::STRING)); SetConstant(ConstantIndex::ARRAY_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, 0, JSType::TAGGED_ARRAY)); + factory->NewEcmaReadOnlyHClass(hClass, 0, JSType::TAGGED_ARRAY)); InitGlobalConstantSpecial(thread); SetConstant(ConstantIndex::DICTIONARY_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, 0, JSType::TAGGED_DICTIONARY)); + factory->NewEcmaReadOnlyHClass(hClass, 0, JSType::TAGGED_DICTIONARY)); SetConstant(ConstantIndex::BIGINT_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, BigInt::SIZE, JSType::BIGINT)); + factory->NewEcmaReadOnlyHClass(hClass, BigInt::SIZE, JSType::BIGINT)); SetConstant(ConstantIndex::JS_NATIVE_POINTER_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, JSNativePointer::SIZE, JSType::JS_NATIVE_POINTER)); + factory->NewEcmaReadOnlyHClass(hClass, JSNativePointer::SIZE, JSType::JS_NATIVE_POINTER)); SetConstant(ConstantIndex::ENV_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, 0, JSType::LEXICAL_ENV)); + factory->NewEcmaReadOnlyHClass(hClass, 0, JSType::LEXICAL_ENV)); SetConstant(ConstantIndex::SYMBOL_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, JSSymbol::SIZE, JSType::SYMBOL)); + factory->NewEcmaReadOnlyHClass(hClass, JSSymbol::SIZE, JSType::SYMBOL)); SetConstant(ConstantIndex::ACCESSOR_DATA_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, AccessorData::SIZE, JSType::ACCESSOR_DATA)); + factory->NewEcmaReadOnlyHClass(hClass, AccessorData::SIZE, JSType::ACCESSOR_DATA)); SetConstant(ConstantIndex::INTERNAL_ACCESSOR_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, AccessorData::SIZE, JSType::INTERNAL_ACCESSOR)); + factory->NewEcmaReadOnlyHClass(hClass, AccessorData::SIZE, JSType::INTERNAL_ACCESSOR)); SetConstant(ConstantIndex::JS_PROXY_ORDINARY_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSProxy::SIZE, JSType::JS_PROXY)); + factory->NewEcmaHClass(hClass, JSProxy::SIZE, JSType::JS_PROXY)); SetConstant(ConstantIndex::COMPLETION_RECORD_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, CompletionRecord::SIZE, JSType::COMPLETION_RECORD)); + factory->NewEcmaReadOnlyHClass(hClass, CompletionRecord::SIZE, JSType::COMPLETION_RECORD)); SetConstant(ConstantIndex::GENERATOR_CONTEST_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, GeneratorContext::SIZE, JSType::JS_GENERATOR_CONTEXT)); + factory->NewEcmaReadOnlyHClass(hClass, GeneratorContext::SIZE, JSType::JS_GENERATOR_CONTEXT)); SetConstant(ConstantIndex::ASYNC_GENERATOR_REQUEST_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, AsyncGeneratorRequest::SIZE, + factory->NewEcmaReadOnlyHClass(hClass, AsyncGeneratorRequest::SIZE, JSType::ASYNC_GENERATOR_REQUEST)); SetConstant(ConstantIndex::CAPABILITY_RECORD_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, PromiseCapability::SIZE, JSType::PROMISE_CAPABILITY)); + factory->NewEcmaReadOnlyHClass(hClass, PromiseCapability::SIZE, JSType::PROMISE_CAPABILITY)); SetConstant(ConstantIndex::REACTIONS_RECORD_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, PromiseReaction::SIZE, JSType::PROMISE_REACTIONS)); + factory->NewEcmaReadOnlyHClass(hClass, PromiseReaction::SIZE, JSType::PROMISE_REACTIONS)); SetConstant(ConstantIndex::PROMISE_ITERATOR_RECORD_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, PromiseIteratorRecord::SIZE, + factory->NewEcmaReadOnlyHClass(hClass, PromiseIteratorRecord::SIZE, JSType::PROMISE_ITERATOR_RECORD)); SetConstant(ConstantIndex::PROMISE_RECORD_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, PromiseRecord::SIZE, JSType::PROMISE_RECORD)); + factory->NewEcmaReadOnlyHClass(hClass, PromiseRecord::SIZE, JSType::PROMISE_RECORD)); SetConstant(ConstantIndex::PROMISE_RESOLVING_FUNCTIONS_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, ResolvingFunctionsRecord::SIZE, + factory->NewEcmaReadOnlyHClass(hClass, ResolvingFunctionsRecord::SIZE, JSType::RESOLVING_FUNCTIONS_RECORD)); SetConstant(ConstantIndex::MICRO_JOB_QUEUE_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, job::MicroJobQueue::SIZE, JSType::MICRO_JOB_QUEUE)); + factory->NewEcmaReadOnlyHClass(hClass, job::MicroJobQueue::SIZE, JSType::MICRO_JOB_QUEUE)); SetConstant(ConstantIndex::PENDING_JOB_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, job::PendingJob::SIZE, JSType::PENDING_JOB)); + factory->NewEcmaReadOnlyHClass(hClass, job::PendingJob::SIZE, JSType::PENDING_JOB)); SetConstant(ConstantIndex::PROTO_CHANGE_MARKER_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, ProtoChangeMarker::SIZE, JSType::PROTO_CHANGE_MARKER)); + factory->NewEcmaReadOnlyHClass(hClass, ProtoChangeMarker::SIZE, JSType::PROTO_CHANGE_MARKER)); SetConstant(ConstantIndex::PROTO_CHANGE_DETAILS_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, ProtoChangeDetails::SIZE, JSType::PROTOTYPE_INFO)); + factory->NewEcmaReadOnlyHClass(hClass, ProtoChangeDetails::SIZE, JSType::PROTOTYPE_INFO)); SetConstant(ConstantIndex::PROTOTYPE_HANDLER_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, PrototypeHandler::SIZE, JSType::PROTOTYPE_HANDLER)); + factory->NewEcmaReadOnlyHClass(hClass, PrototypeHandler::SIZE, JSType::PROTOTYPE_HANDLER)); SetConstant(ConstantIndex::TRANSITION_HANDLER_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, TransitionHandler::SIZE, JSType::TRANSITION_HANDLER)); + factory->NewEcmaReadOnlyHClass(hClass, TransitionHandler::SIZE, JSType::TRANSITION_HANDLER)); SetConstant(ConstantIndex::PROPERTY_BOX_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, PropertyBox::SIZE, JSType::PROPERTY_BOX)); + factory->NewEcmaReadOnlyHClass(hClass, PropertyBox::SIZE, JSType::PROPERTY_BOX)); SetConstant(ConstantIndex::PROGRAM_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, Program::SIZE, JSType::PROGRAM)); + factory->NewEcmaReadOnlyHClass(hClass, Program::SIZE, JSType::PROGRAM)); SetConstant( ConstantIndex::IMPORT_ENTRY_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, ImportEntry::SIZE, JSType::IMPORTENTRY_RECORD)); + factory->NewEcmaReadOnlyHClass(hClass, ImportEntry::SIZE, JSType::IMPORTENTRY_RECORD)); SetConstant( ConstantIndex::LOCAL_EXPORT_ENTRY_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, LocalExportEntry::SIZE, JSType::LOCAL_EXPORTENTRY_RECORD)); + factory->NewEcmaReadOnlyHClass(hClass, LocalExportEntry::SIZE, JSType::LOCAL_EXPORTENTRY_RECORD)); SetConstant( ConstantIndex::INDIRECT_EXPORT_ENTRY_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, IndirectExportEntry::SIZE, JSType::INDIRECT_EXPORTENTRY_RECORD)); + factory->NewEcmaReadOnlyHClass(hClass, IndirectExportEntry::SIZE, JSType::INDIRECT_EXPORTENTRY_RECORD)); SetConstant( ConstantIndex::STAR_EXPORT_ENTRY_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, StarExportEntry::SIZE, JSType::STAR_EXPORTENTRY_RECORD)); + factory->NewEcmaReadOnlyHClass(hClass, StarExportEntry::SIZE, JSType::STAR_EXPORTENTRY_RECORD)); SetConstant( ConstantIndex::SOURCE_TEXT_MODULE_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, SourceTextModule::SIZE, JSType::SOURCE_TEXT_MODULE_RECORD)); + factory->NewEcmaReadOnlyHClass(hClass, SourceTextModule::SIZE, JSType::SOURCE_TEXT_MODULE_RECORD)); SetConstant( ConstantIndex::RESOLVED_BINDING_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, ResolvedBinding::SIZE, JSType::RESOLVEDBINDING_RECORD)); + factory->NewEcmaReadOnlyHClass(hClass, ResolvedBinding::SIZE, JSType::RESOLVEDBINDING_RECORD)); - JSHClass *jsProxyCallableClass = *factory->NewEcmaDynClass(dynClassClass, JSProxy::SIZE, JSType::JS_PROXY); + JSHClass *jsProxyCallableClass = *factory->NewEcmaHClass(hClass, JSProxy::SIZE, JSType::JS_PROXY); jsProxyCallableClass->SetCallable(true); SetConstant(ConstantIndex::JS_PROXY_CALLABLE_CLASS_INDEX, JSTaggedValue(jsProxyCallableClass)); - JSHClass *jsProxyConstructClass = *factory->NewEcmaDynClass(dynClassClass, JSProxy::SIZE, JSType::JS_PROXY); + JSHClass *jsProxyConstructClass = *factory->NewEcmaHClass(hClass, JSProxy::SIZE, JSType::JS_PROXY); jsProxyConstructClass->SetCallable(true); jsProxyConstructClass->SetConstructor(true); SetConstant(ConstantIndex::JS_PROXY_CONSTRUCT_CLASS_INDEX, JSTaggedValue(jsProxyConstructClass)); SetConstant(ConstantIndex::JS_REALM_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSRealm::SIZE, JSType::JS_REALM)); + factory->NewEcmaHClass(hClass, JSRealm::SIZE, JSType::JS_REALM)); SetConstant(ConstantIndex::MACHINE_CODE_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, 0, JSType::MACHINE_CODE_OBJECT)); + factory->NewEcmaReadOnlyHClass(hClass, 0, JSType::MACHINE_CODE_OBJECT)); SetConstant(ConstantIndex::CLASS_INFO_EXTRACTOR_HCLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, ClassInfoExtractor::SIZE, + factory->NewEcmaReadOnlyHClass(hClass, ClassInfoExtractor::SIZE, JSType::CLASS_INFO_EXTRACTOR)); SetConstant(ConstantIndex::TS_OBJECT_TYPE_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, TSObjectType::SIZE, JSType::TS_OBJECT_TYPE)); + factory->NewEcmaReadOnlyHClass(hClass, TSObjectType::SIZE, JSType::TS_OBJECT_TYPE)); SetConstant(ConstantIndex::TS_CLASS_TYPE_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, TSClassType::SIZE, JSType::TS_CLASS_TYPE)); + factory->NewEcmaReadOnlyHClass(hClass, TSClassType::SIZE, JSType::TS_CLASS_TYPE)); SetConstant(ConstantIndex::TS_UNION_TYPE_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, TSUnionType::SIZE, JSType::TS_UNION_TYPE)); + factory->NewEcmaReadOnlyHClass(hClass, TSUnionType::SIZE, JSType::TS_UNION_TYPE)); SetConstant(ConstantIndex::TS_INTERFACE_TYPE_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, TSInterfaceType::SIZE, JSType::TS_INTERFACE_TYPE)); + factory->NewEcmaReadOnlyHClass(hClass, TSInterfaceType::SIZE, JSType::TS_INTERFACE_TYPE)); SetConstant(ConstantIndex::TS_CLASS_INSTANCE_TYPE_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, TSClassInstanceType::SIZE, + factory->NewEcmaReadOnlyHClass(hClass, TSClassInstanceType::SIZE, JSType::TS_CLASS_INSTANCE_TYPE)); SetConstant(ConstantIndex::TS_IMPORT_TYPE_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, TSImportType::SIZE, JSType::TS_IMPORT_TYPE)); + factory->NewEcmaReadOnlyHClass(hClass, TSImportType::SIZE, JSType::TS_IMPORT_TYPE)); SetConstant(ConstantIndex::TS_FUNCTION_TYPE_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, TSFunctionType::SIZE, JSType::TS_FUNCTION_TYPE)); + factory->NewEcmaReadOnlyHClass(hClass, TSFunctionType::SIZE, JSType::TS_FUNCTION_TYPE)); SetConstant(ConstantIndex::TS_ARRAY_TYPE_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, TSArrayType::SIZE, JSType::TS_ARRAY_TYPE)); + factory->NewEcmaReadOnlyHClass(hClass, TSArrayType::SIZE, JSType::TS_ARRAY_TYPE)); SetConstant(ConstantIndex::JS_REGEXP_ITERATOR_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSRegExpIterator::SIZE, JSType::JS_REG_EXP_ITERATOR)); + factory->NewEcmaHClass(hClass, JSRegExpIterator::SIZE, JSType::JS_REG_EXP_ITERATOR)); SetConstant(ConstantIndex::JS_SET_ITERATOR_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSSetIterator::SIZE, JSType::JS_SET_ITERATOR)); + factory->NewEcmaHClass(hClass, JSSetIterator::SIZE, JSType::JS_SET_ITERATOR)); SetConstant(ConstantIndex::JS_MAP_ITERATOR_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSMapIterator::SIZE, JSType::JS_MAP_ITERATOR)); + factory->NewEcmaHClass(hClass, JSMapIterator::SIZE, JSType::JS_MAP_ITERATOR)); SetConstant(ConstantIndex::JS_ARRAY_ITERATOR_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSArrayIterator::SIZE, JSType::JS_ARRAY_ITERATOR)); + factory->NewEcmaHClass(hClass, JSArrayIterator::SIZE, JSType::JS_ARRAY_ITERATOR)); SetConstant( ConstantIndex::JS_API_ARRAYLIST_ITERATOR_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSAPIArrayListIterator::SIZE, JSType::JS_API_ARRAYLIST_ITERATOR)); + factory->NewEcmaHClass(hClass, JSAPIArrayListIterator::SIZE, JSType::JS_API_ARRAYLIST_ITERATOR)); SetConstant(ConstantIndex::JS_API_DEQUE_ITERATOR_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSAPIDequeIterator::SIZE, JSType::JS_API_DEQUE_ITERATOR)); + factory->NewEcmaHClass(hClass, JSAPIDequeIterator::SIZE, JSType::JS_API_DEQUE_ITERATOR)); SetConstant(ConstantIndex::JS_API_LIGHTWEIGHTMAP_ITERATOR_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSAPILightWeightMapIterator::SIZE, + factory->NewEcmaHClass(hClass, JSAPILightWeightMapIterator::SIZE, JSType::JS_API_LIGHT_WEIGHT_MAP_ITERATOR)); SetConstant(ConstantIndex::JS_API_LIGHTWEIGHTSET_ITERATOR_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSAPILightWeightSetIterator::SIZE, + factory->NewEcmaHClass(hClass, JSAPILightWeightSetIterator::SIZE, JSType::JS_API_LIGHT_WEIGHT_SET_ITERATOR)); SetConstant( ConstantIndex::JS_API_LINKED_LIST_ITERATOR_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSAPILinkedListIterator::SIZE, JSType::JS_API_LINKED_LIST_ITERATOR)); + factory->NewEcmaHClass(hClass, JSAPILinkedListIterator::SIZE, JSType::JS_API_LINKED_LIST_ITERATOR)); SetConstant(ConstantIndex::JS_API_LIST_ITERATOR_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSAPIListIterator::SIZE, JSType::JS_API_LIST_ITERATOR)); + factory->NewEcmaHClass(hClass, JSAPIListIterator::SIZE, JSType::JS_API_LIST_ITERATOR)); SetConstant( ConstantIndex::JS_API_PLAIN_ARRAY_ITERATOR_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSAPIPlainArrayIterator::SIZE, JSType::JS_API_PLAIN_ARRAY_ITERATOR)); + factory->NewEcmaHClass(hClass, JSAPIPlainArrayIterator::SIZE, JSType::JS_API_PLAIN_ARRAY_ITERATOR)); SetConstant(ConstantIndex::JS_API_QUEUE_ITERATOR_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSAPIQueueIterator::SIZE, JSType::JS_API_QUEUE_ITERATOR)); + factory->NewEcmaHClass(hClass, JSAPIQueueIterator::SIZE, JSType::JS_API_QUEUE_ITERATOR)); SetConstant(ConstantIndex::JS_API_STACK_ITERATOR_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSAPIStackIterator::SIZE, JSType::JS_API_STACK_ITERATOR)); + factory->NewEcmaHClass(hClass, JSAPIStackIterator::SIZE, JSType::JS_API_STACK_ITERATOR)); SetConstant(ConstantIndex::JS_API_VECTOR_ITERATOR_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSAPIVectorIterator::SIZE, JSType::JS_API_VECTOR_ITERATOR)); + factory->NewEcmaHClass(hClass, JSAPIVectorIterator::SIZE, JSType::JS_API_VECTOR_ITERATOR)); SetConstant(ConstantIndex::JS_API_HASH_MAP_ITERATOR_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSAPIHashMapIterator::SIZE, JSType::JS_API_HASHMAP_ITERATOR)); + factory->NewEcmaHClass(hClass, JSAPIHashMapIterator::SIZE, JSType::JS_API_HASHMAP_ITERATOR)); SetConstant(ConstantIndex::JS_API_HASH_SET_ITERATOR_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSAPIHashSetIterator::SIZE, JSType::JS_API_HASHSET_ITERATOR)); + factory->NewEcmaHClass(hClass, JSAPIHashSetIterator::SIZE, JSType::JS_API_HASHSET_ITERATOR)); SetConstant(ConstantIndex::JS_API_TREE_MAP_ITERATOR_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSAPITreeMapIterator::SIZE, JSType::JS_API_TREEMAP_ITERATOR)); + factory->NewEcmaHClass(hClass, JSAPITreeMapIterator::SIZE, JSType::JS_API_TREEMAP_ITERATOR)); SetConstant(ConstantIndex::JS_API_TREE_SET_ITERATOR_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSAPITreeSetIterator::SIZE, JSType::JS_API_TREESET_ITERATOR)); + factory->NewEcmaHClass(hClass, JSAPITreeSetIterator::SIZE, JSType::JS_API_TREESET_ITERATOR)); SetConstant(ConstantIndex::LINKED_NODE_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, LinkedNode::SIZE, JSType::LINKED_NODE)); + factory->NewEcmaHClass(hClass, LinkedNode::SIZE, JSType::LINKED_NODE)); SetConstant(ConstantIndex::RB_TREENODE_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, RBTreeNode::SIZE, JSType::RB_TREENODE)); + factory->NewEcmaHClass(hClass, RBTreeNode::SIZE, JSType::RB_TREENODE)); SetConstant(ConstantIndex::CELL_RECORD_CLASS_INDEX, - factory->NewEcmaReadOnlyDynClass(dynClassClass, CellRecord::SIZE, JSType::CELL_RECORD)); - SetConstant(ConstantIndex::OBJECT_DYN_CLASS_INDEX, factory->NewEcmaDynClass(JSObject::SIZE, JSType::JS_OBJECT)); + factory->NewEcmaReadOnlyHClass(hClass, CellRecord::SIZE, JSType::CELL_RECORD)); + SetConstant(ConstantIndex::OBJECT_HCLASS_INDEX, factory->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT)); SetConstant(ConstantIndex::JS_METHOD_CLASS_INDEX, - factory->NewEcmaDynClass(dynClassClass, JSMethod::SIZE, JSType::JS_METHOD)); + factory->NewEcmaHClass(hClass, JSMethod::SIZE, JSType::JS_METHOD)); } void GlobalEnvConstants::InitGlobalConstantSpecial(JSThread *thread) diff --git a/ecmascript/global_env_constants.h b/ecmascript/global_env_constants.h index 7992d17001..aca7d278ed 100644 --- a/ecmascript/global_env_constants.h +++ b/ecmascript/global_env_constants.h @@ -101,9 +101,9 @@ class JSThread; V(JSTaggedValue, JSAPITreeSetIteratorClass, JS_API_TREE_SET_ITERATOR_CLASS_INDEX, ecma_roots_class) \ V(JSTaggedValue, LinkedNode, LINKED_NODE_CLASS_INDEX, ecma_roots_class) \ V(JSTaggedValue, RBTreeNode, RB_TREENODE_CLASS_INDEX, ecma_roots_class) \ - V(JSTaggedValue, JSAPIIteratorFuncDynClass, JS_API_ITERATOR_FUNC_DYN_CLASS_INDEX, ecma_roots_class) \ + V(JSTaggedValue, JSAPIIteratorFuncHClass, JS_API_ITERATOR_FUNC_DYN_CLASS_INDEX, ecma_roots_class) \ V(JSTaggedValue, CellRecordClass, CELL_RECORD_CLASS_INDEX, ecma_roots_class) \ - V(JSTaggedValue, ObjectDynClass, OBJECT_DYN_CLASS_INDEX, initial_object_dynclass) \ + V(JSTaggedValue, ObjectClass, OBJECT_HCLASS_INDEX, initial_object_hclass) \ V(JSTaggedValue, IteratorResultClass, ITERATOR_RESULT_CLASS, ecma_roots_class) \ V(JSTaggedValue, JSMethodClass, JS_METHOD_CLASS_INDEX, ecma_roots_class) @@ -442,9 +442,9 @@ public: const JSTaggedValue *EndSlot() const; - void Init(JSThread *thread, JSHClass *dynClassClass); + void Init(JSThread *thread, JSHClass *hClass); - void InitRootsClass(JSThread *thread, JSHClass *dynClassClass); + void InitRootsClass(JSThread *thread, JSHClass *hClass); void InitGlobalConstantSpecial(JSThread *thread); void InitGlobalConstant(JSThread *thread); diff --git a/ecmascript/ic/ic_binary_op.h b/ecmascript/ic/ic_binary_op.h index 108b6a66ea..40eb0e7120 100644 --- a/ecmascript/ic/ic_binary_op.h +++ b/ecmascript/ic/ic_binary_op.h @@ -88,7 +88,7 @@ public: } // Some special cases, such as: object + undefined, object + boolean, etc. case BinaryType::GENERIC: { - JSTaggedValue res = SlowRuntimeStub::Add2Dyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::Add2(thread, left, right); return res; } default: { @@ -185,7 +185,7 @@ public: } // Support special cases, such as: string like '2333', boolean, null case BinaryType::GENERIC: { - auto res = SlowRuntimeStub::Div2Dyn(thread, left, right); + auto res = SlowRuntimeStub::Div2(thread, left, right); return res; } case BinaryType::NUMBER_GEN: diff --git a/ecmascript/ic/ic_compare_op.cpp b/ecmascript/ic/ic_compare_op.cpp index 0aadb4694c..4d4389ea73 100644 --- a/ecmascript/ic/ic_compare_op.cpp +++ b/ecmascript/ic/ic_compare_op.cpp @@ -430,37 +430,37 @@ ComparisonResult CompareOp::Compare(JSThread *thread, JSTaggedValue left, return ret; } -JSTaggedValue CompareOp::LessDynWithIC(JSThread *thread, JSTaggedValue left, +JSTaggedValue CompareOp::LessWithIC(JSThread *thread, JSTaggedValue left, JSTaggedValue right, CompareOpType operationType) { - INTERPRETER_TRACE(thread, LessDynWithIC); + INTERPRETER_TRACE(thread, LessWithIC); bool ret = CompareOp::Compare(thread, left, right, operationType) == ComparisonResult::LESS; RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return (ret ? JSTaggedValue::True() : JSTaggedValue::False()); } -JSTaggedValue CompareOp::LessEqDynWithIC(JSThread *thread, JSTaggedValue left, +JSTaggedValue CompareOp::LessEqWithIC(JSThread *thread, JSTaggedValue left, JSTaggedValue right, CompareOpType operationType) { - INTERPRETER_TRACE(thread, LessEqDynWithIC); + INTERPRETER_TRACE(thread, LessEqWithIC); bool ret = CompareOp::Compare(thread, left, right, operationType) <= ComparisonResult::EQUAL; RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return (ret ? JSTaggedValue::True() : JSTaggedValue::False()); } -JSTaggedValue CompareOp::GreaterDynWithIC(JSThread *thread, JSTaggedValue left, +JSTaggedValue CompareOp::GreaterWithIC(JSThread *thread, JSTaggedValue left, JSTaggedValue right, CompareOpType operationType) { - INTERPRETER_TRACE(thread, GreaterDynWithIC); + INTERPRETER_TRACE(thread, GreaterWithIC); bool ret = CompareOp::Compare(thread, left, right, operationType) == ComparisonResult::GREAT; RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return (ret ? JSTaggedValue::True() : JSTaggedValue::False()); } -JSTaggedValue CompareOp::GreaterEqDynWithIC(JSThread *thread, JSTaggedValue left, +JSTaggedValue CompareOp::GreaterEqWithIC(JSThread *thread, JSTaggedValue left, JSTaggedValue right, CompareOpType operationType) { - INTERPRETER_TRACE(thread, GreaterEqDynWithIC); + INTERPRETER_TRACE(thread, GreaterEqWithIC); ComparisonResult comparison = CompareOp::Compare(thread, left, right, operationType); bool ret = (comparison == ComparisonResult::GREAT) || (comparison == ComparisonResult::EQUAL); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); diff --git a/ecmascript/ic/ic_compare_op.h b/ecmascript/ic/ic_compare_op.h index c985b42196..770f175da8 100644 --- a/ecmascript/ic/ic_compare_op.h +++ b/ecmascript/ic/ic_compare_op.h @@ -62,16 +62,16 @@ public: static ComparisonResult Compare(JSThread *thread, JSTaggedValue left, JSTaggedValue right, CompareOpType operationType); - static JSTaggedValue LessDynWithIC(JSThread *thread, JSTaggedValue left, + static JSTaggedValue LessWithIC(JSThread *thread, JSTaggedValue left, JSTaggedValue right, CompareOpType operationType); - static JSTaggedValue LessEqDynWithIC(JSThread *thread, JSTaggedValue left, + static JSTaggedValue LessEqWithIC(JSThread *thread, JSTaggedValue left, JSTaggedValue right, CompareOpType operationType); - static JSTaggedValue GreaterDynWithIC(JSThread *thread, JSTaggedValue left, + static JSTaggedValue GreaterWithIC(JSThread *thread, JSTaggedValue left, JSTaggedValue right, CompareOpType operationType); - static JSTaggedValue GreaterEqDynWithIC(JSThread *thread, JSTaggedValue left, + static JSTaggedValue GreaterEqWithIC(JSThread *thread, JSTaggedValue left, JSTaggedValue right, CompareOpType operationType); }; } // namespace panda::ecmascript diff --git a/ecmascript/ic/profile_type_info.cpp b/ecmascript/ic/profile_type_info.cpp index 72551a545a..57a36265a1 100644 --- a/ecmascript/ic/profile_type_info.cpp +++ b/ecmascript/ic/profile_type_info.cpp @@ -20,26 +20,26 @@ #include "ecmascript/tagged_array-inl.h" namespace panda::ecmascript { -void ProfileTypeAccessor::AddElementHandler(JSHandle dynclass, JSHandle handler) const +void ProfileTypeAccessor::AddElementHandler(JSHandle hclass, JSHandle handler) const { auto profileData = profileTypeInfo_->Get(slotId_); ASSERT(!profileData.IsHole()); auto index = slotId_; if (profileData.IsUndefined()) { - profileTypeInfo_->Set(thread_, index, GetWeakRef(dynclass.GetTaggedValue())); + profileTypeInfo_->Set(thread_, index, GetWeakRef(hclass.GetTaggedValue())); profileTypeInfo_->Set(thread_, index + 1, handler.GetTaggedValue()); return; } // clear key ic if (!profileData.IsWeak() && (profileData.IsString() || profileData.IsSymbol())) { - profileTypeInfo_->Set(thread_, index, GetWeakRef(dynclass.GetTaggedValue())); + profileTypeInfo_->Set(thread_, index, GetWeakRef(hclass.GetTaggedValue())); profileTypeInfo_->Set(thread_, index + 1, handler.GetTaggedValue()); return; } - AddHandlerWithoutKey(dynclass, handler); + AddHandlerWithoutKey(hclass, handler); } -void ProfileTypeAccessor::AddHandlerWithoutKey(JSHandle dynclass, JSHandle handler) const +void ProfileTypeAccessor::AddHandlerWithoutKey(JSHandle hclass, JSHandle handler) const { auto index = slotId_; if (IsNamedGlobalIC(GetKind())) { @@ -49,7 +49,7 @@ void ProfileTypeAccessor::AddHandlerWithoutKey(JSHandle dynclass, auto profileData = profileTypeInfo_->Get(slotId_); ASSERT(!profileData.IsHole()); if (profileData.IsUndefined()) { - profileTypeInfo_->Set(thread_, index, GetWeakRef(dynclass.GetTaggedValue())); + profileTypeInfo_->Set(thread_, index, GetWeakRef(hclass.GetTaggedValue())); profileTypeInfo_->Set(thread_, index + 1, handler.GetTaggedValue()); return; } @@ -70,7 +70,7 @@ void ProfileTypeAccessor::AddHandlerWithoutKey(JSHandle dynclass, newArr->Set(thread_, i, arr->Get(i)); newArr->Set(thread_, i + 1, arr->Get(i + 1)); } - newArr->Set(thread_, i, GetWeakRef(dynclass.GetTaggedValue())); + newArr->Set(thread_, i, GetWeakRef(hclass.GetTaggedValue())); newArr->Set(thread_, i + 1, handler.GetTaggedValue()); profileTypeInfo_->Set(thread_, index, newArr.GetTaggedValue()); profileTypeInfo_->Set(thread_, index + 1, JSTaggedValue::Hole()); @@ -82,14 +82,14 @@ void ProfileTypeAccessor::AddHandlerWithoutKey(JSHandle dynclass, uint32_t arrIndex = 0; newArr->Set(thread_, arrIndex++, profileTypeInfo_->Get(index)); newArr->Set(thread_, arrIndex++, profileTypeInfo_->Get(index + 1)); - newArr->Set(thread_, arrIndex++, GetWeakRef(dynclass.GetTaggedValue())); + newArr->Set(thread_, arrIndex++, GetWeakRef(hclass.GetTaggedValue())); newArr->Set(thread_, arrIndex, handler.GetTaggedValue()); profileTypeInfo_->Set(thread_, index, newArr.GetTaggedValue()); profileTypeInfo_->Set(thread_, index + 1, JSTaggedValue::Hole()); } -void ProfileTypeAccessor::AddHandlerWithKey(JSHandle key, JSHandle dynclass, +void ProfileTypeAccessor::AddHandlerWithKey(JSHandle key, JSHandle hclass, JSHandle handler) const { if (IsValueGlobalIC(GetKind())) { @@ -104,12 +104,12 @@ void ProfileTypeAccessor::AddHandlerWithKey(JSHandle key, JSHandl profileTypeInfo_->Set(thread_, index, key.GetTaggedValue()); const int arrayLength = 2; JSHandle newArr = thread_->GetEcmaVM()->GetFactory()->NewTaggedArray(arrayLength); - newArr->Set(thread_, 0, GetWeakRef(dynclass.GetTaggedValue())); + newArr->Set(thread_, 0, GetWeakRef(hclass.GetTaggedValue())); newArr->Set(thread_, 1, handler.GetTaggedValue()); profileTypeInfo_->Set(thread_, index + 1, newArr.GetTaggedValue()); return; } - // for element ic, profileData may dynclass or taggedarray + // for element ic, profileData may hclass or taggedarray if (key.GetTaggedValue() != profileData) { profileTypeInfo_->Set(thread_, index, JSTaggedValue::Hole()); profileTypeInfo_->Set(thread_, index + 1, JSTaggedValue::Hole()); @@ -128,7 +128,7 @@ void ProfileTypeAccessor::AddHandlerWithKey(JSHandle key, JSHandl } auto factory = thread_->GetEcmaVM()->GetFactory(); JSHandle newArr = factory->NewTaggedArray(newLen); - newArr->Set(thread_, 0, GetWeakRef(dynclass.GetTaggedValue())); + newArr->Set(thread_, 0, GetWeakRef(hclass.GetTaggedValue())); newArr->Set(thread_, 1, handler.GetTaggedValue()); for (uint32_t i = 0; i < arr->GetLength(); i += step) { newArr->Set(thread_, i + step, arr->Get(i)); @@ -143,7 +143,7 @@ void ProfileTypeAccessor::AddHandlerWithKey(JSHandle key, JSHandl uint32_t arrIndex = 0; newArr->Set(thread_, arrIndex++, arr->Get(0)); newArr->Set(thread_, arrIndex++, arr->Get(1)); - newArr->Set(thread_, arrIndex++, GetWeakRef(dynclass.GetTaggedValue())); + newArr->Set(thread_, arrIndex++, GetWeakRef(hclass.GetTaggedValue())); newArr->Set(thread_, arrIndex++, handler.GetTaggedValue()); profileTypeInfo_->Set(thread_, index + 1, newArr.GetTaggedValue()); diff --git a/ecmascript/ic/profile_type_info.h b/ecmascript/ic/profile_type_info.h index 17c9c0dd70..de8adbda0e 100644 --- a/ecmascript/ic/profile_type_info.h +++ b/ecmascript/ic/profile_type_info.h @@ -112,9 +112,9 @@ public: ICState GetICState() const; static std::string ICStateToString(ICState state); - void AddHandlerWithoutKey(JSHandle dynclass, JSHandle handler) const; - void AddElementHandler(JSHandle dynclass, JSHandle handler) const; - void AddHandlerWithKey(JSHandle key, JSHandle dynclass, + void AddHandlerWithoutKey(JSHandle hclass, JSHandle handler) const; + void AddElementHandler(JSHandle hclass, JSHandle handler) const; + void AddHandlerWithKey(JSHandle key, JSHandle hclass, JSHandle handler) const; void AddGlobalHandlerKey(JSHandle key, JSHandle handler) const; void AddGlobalRecordHandler(JSHandle handler) const; diff --git a/ecmascript/ic/tests/ic_binaryop_test.cpp b/ecmascript/ic/tests/ic_binaryop_test.cpp index f23962e2b8..0959297c46 100644 --- a/ecmascript/ic/tests/ic_binaryop_test.cpp +++ b/ecmascript/ic/tests/ic_binaryop_test.cpp @@ -67,21 +67,21 @@ HWTEST_F_L0(ICBinaryOPTest, AddWithTSType) JSHandle arg2(thread, arg2Value); JSHandle arg3(thread, arg3Value); - JSTaggedValue resInSlowPath1 = SlowRuntimeStub::Add2Dyn(thread, arg1.GetTaggedValue(), + JSTaggedValue resInSlowPath1 = SlowRuntimeStub::Add2(thread, arg1.GetTaggedValue(), arg2.GetTaggedValue()); JSHandle slowHandle1(thread, resInSlowPath1); JSTaggedValue resInICPath1 = ICBinaryOP::AddWithTSType(thread, arg1.GetTaggedValue(), arg2.GetTaggedValue(), JSTaggedValue(static_cast(BinaryType::NUMBER))); EXPECT_EQ(slowHandle1.GetTaggedValue(), resInICPath1); - JSTaggedValue resInSlowPath2 = SlowRuntimeStub::Add2Dyn(thread, arg1.GetTaggedValue(), + JSTaggedValue resInSlowPath2 = SlowRuntimeStub::Add2(thread, arg1.GetTaggedValue(), arg3.GetTaggedValue()); JSHandle slowHandle2(thread, resInSlowPath2); JSTaggedValue resInICPath2 = ICBinaryOP::AddWithTSType(thread, arg1.GetTaggedValue(), arg3.GetTaggedValue(), JSTaggedValue(static_cast(BinaryType::NUMBER))); EXPECT_EQ(slowHandle2.GetTaggedValue(), resInICPath2); - JSTaggedValue resInSlowPath3 = SlowRuntimeStub::Add2Dyn(thread, Str1.GetTaggedValue(), + JSTaggedValue resInSlowPath3 = SlowRuntimeStub::Add2(thread, Str1.GetTaggedValue(), Str2.GetTaggedValue()); JSHandle slowHandle3(thread, reinterpret_cast(resInSlowPath3.GetRawData())); JSTaggedValue resInICPath3 = ICBinaryOP::AddWithTSType(thread, Str1.GetTaggedValue(), Str2.GetTaggedValue(), @@ -89,7 +89,7 @@ HWTEST_F_L0(ICBinaryOPTest, AddWithTSType) ASSERT_TRUE(resInICPath3.IsString()); EXPECT_EQ(slowHandle3->Compare(reinterpret_cast(resInICPath3.GetRawData())), 0); - JSTaggedValue resInSlowPath4 = SlowRuntimeStub::Add2Dyn(thread, JSTaggedValue::Undefined(), + JSTaggedValue resInSlowPath4 = SlowRuntimeStub::Add2(thread, JSTaggedValue::Undefined(), arg2.GetTaggedValue()); JSHandle slowHandle4(thread, resInSlowPath4); JSTaggedValue resInICPath4 = ICBinaryOP::AddWithTSType(thread, JSTaggedValue::Undefined(), @@ -97,7 +97,7 @@ HWTEST_F_L0(ICBinaryOPTest, AddWithTSType) JSTaggedValue(static_cast(BinaryType::NUMBER_GEN))); EXPECT_EQ(slowHandle4.GetTaggedValue(), resInICPath4); - JSTaggedValue resInSlowPath5 = SlowRuntimeStub::Add2Dyn(thread, arg3.GetTaggedValue(), + JSTaggedValue resInSlowPath5 = SlowRuntimeStub::Add2(thread, arg3.GetTaggedValue(), Str1.GetTaggedValue()); JSHandle slowHandle5(thread, reinterpret_cast(resInSlowPath5.GetRawData())); JSTaggedValue resInICPath5 = ICBinaryOP::AddWithTSType(thread, arg3.GetTaggedValue(), @@ -106,7 +106,7 @@ HWTEST_F_L0(ICBinaryOPTest, AddWithTSType) ASSERT_TRUE(resInICPath5.IsString()); EXPECT_EQ(slowHandle5->Compare(reinterpret_cast(resInICPath5.GetRawData())), 0); - JSTaggedValue resInSlowPath6 = SlowRuntimeStub::Add2Dyn(thread, Str1.GetTaggedValue(), + JSTaggedValue resInSlowPath6 = SlowRuntimeStub::Add2(thread, Str1.GetTaggedValue(), JSTaggedValue::Null()); JSHandle slowHandle6(thread, reinterpret_cast(resInSlowPath6.GetRawData())); JSTaggedValue resInICPath6 = ICBinaryOP::AddWithTSType(thread, Str1.GetTaggedValue(), JSTaggedValue::Null(), @@ -114,14 +114,14 @@ HWTEST_F_L0(ICBinaryOPTest, AddWithTSType) ASSERT_TRUE(resInICPath6.IsString()); EXPECT_EQ(slowHandle6->Compare(reinterpret_cast(resInICPath6.GetRawData())), 0); - JSTaggedValue resInSlowPath7 = SlowRuntimeStub::Add2Dyn(thread, arg1.GetTaggedValue(), + JSTaggedValue resInSlowPath7 = SlowRuntimeStub::Add2(thread, arg1.GetTaggedValue(), JSTaggedValue::True()); JSHandle slowHandle7(thread, resInSlowPath7); JSTaggedValue resInICPath7 = ICBinaryOP::AddWithTSType(thread, arg1.GetTaggedValue(), JSTaggedValue::True(), JSTaggedValue(static_cast(BinaryType::NUMBER_GEN))); EXPECT_EQ(slowHandle7.GetTaggedValue(), resInICPath7); - JSTaggedValue resInSlowPath8 = SlowRuntimeStub::Add2Dyn(thread, arg4.GetTaggedValue(), + JSTaggedValue resInSlowPath8 = SlowRuntimeStub::Add2(thread, arg4.GetTaggedValue(), JSTaggedValue::Null()); JSHandle slowHandle8(thread, reinterpret_cast(resInSlowPath8.GetRawData())); JSTaggedValue resInICPath8 = ICBinaryOP::AddWithTSType(thread, arg4.GetTaggedValue(), JSTaggedValue::Null(), @@ -139,19 +139,19 @@ HWTEST_F_L0(ICBinaryOPTest, SubWithTSType) JSHandle arg2(thread, arg2Value); JSHandle arg3(thread, arg3Value); - JSTaggedValue resInSlowPath1 = SlowRuntimeStub::Sub2Dyn(thread, arg1.GetTaggedValue(), arg2.GetTaggedValue()); + JSTaggedValue resInSlowPath1 = SlowRuntimeStub::Sub2(thread, arg1.GetTaggedValue(), arg2.GetTaggedValue()); JSHandle slowHandle1(thread, resInSlowPath1); JSTaggedValue resInICPath1 = ICBinaryOP::SubWithTSType(thread, arg1.GetTaggedValue(), arg2.GetTaggedValue(), JSTaggedValue(static_cast(BinaryType::NUMBER))); EXPECT_EQ(slowHandle1.GetTaggedValue(), resInICPath1); - JSTaggedValue resInSlowPath2 = SlowRuntimeStub::Sub2Dyn(thread, arg2.GetTaggedValue(), arg3.GetTaggedValue()); + JSTaggedValue resInSlowPath2 = SlowRuntimeStub::Sub2(thread, arg2.GetTaggedValue(), arg3.GetTaggedValue()); JSHandle slowHandle2(thread, resInSlowPath2); JSTaggedValue resInICPath2 = ICBinaryOP::SubWithTSType(thread, arg2.GetTaggedValue(), arg3.GetTaggedValue(), JSTaggedValue(static_cast(BinaryType::NUMBER))); EXPECT_EQ(slowHandle2.GetTaggedValue(), resInICPath2); - JSTaggedValue resInSlowPath3 = SlowRuntimeStub::Sub2Dyn(thread, arg1.GetTaggedValue(), JSTaggedValue::True()); + JSTaggedValue resInSlowPath3 = SlowRuntimeStub::Sub2(thread, arg1.GetTaggedValue(), JSTaggedValue::True()); JSHandle slowHandle3(thread, resInSlowPath3); JSTaggedValue resInICPath3 = ICBinaryOP::SubWithTSType(thread, arg1.GetTaggedValue(), JSTaggedValue::True(), JSTaggedValue(static_cast(BinaryType::GENERIC))); @@ -167,19 +167,19 @@ HWTEST_F_L0(ICBinaryOPTest, MulWithTSType) JSHandle arg2(thread, arg2Value); JSHandle arg3(thread, arg3Value); - JSTaggedValue resInSlowPath1 = SlowRuntimeStub::Mul2Dyn(thread, arg1.GetTaggedValue(), arg2.GetTaggedValue()); + JSTaggedValue resInSlowPath1 = SlowRuntimeStub::Mul2(thread, arg1.GetTaggedValue(), arg2.GetTaggedValue()); JSHandle slowHandle1(thread, resInSlowPath1); JSTaggedValue resInICPath1 = ICBinaryOP::MulWithTSType(thread, arg1.GetTaggedValue(), arg2.GetTaggedValue(), JSTaggedValue(static_cast(BinaryType::NUMBER))); EXPECT_EQ(slowHandle1.GetTaggedValue(), resInICPath1); - JSTaggedValue resInSlowPath2 = SlowRuntimeStub::Mul2Dyn(thread, arg2.GetTaggedValue(), arg3.GetTaggedValue()); + JSTaggedValue resInSlowPath2 = SlowRuntimeStub::Mul2(thread, arg2.GetTaggedValue(), arg3.GetTaggedValue()); JSHandle slowHandle2(thread, resInSlowPath2); JSTaggedValue resInICPath2 = ICBinaryOP::MulWithTSType(thread, arg2.GetTaggedValue(), arg3.GetTaggedValue(), JSTaggedValue(static_cast(BinaryType::NUMBER))); EXPECT_EQ(slowHandle2.GetTaggedValue(), resInICPath2); - JSTaggedValue resInSlowPath3 = SlowRuntimeStub::Mul2Dyn(thread, arg1.GetTaggedValue(), JSTaggedValue::True()); + JSTaggedValue resInSlowPath3 = SlowRuntimeStub::Mul2(thread, arg1.GetTaggedValue(), JSTaggedValue::True()); JSHandle slowHandle3(thread, resInSlowPath3); JSTaggedValue resInICPath3 = ICBinaryOP::MulWithTSType(thread, arg1.GetTaggedValue(), JSTaggedValue::True(), JSTaggedValue(static_cast(BinaryType::GENERIC))); @@ -198,31 +198,31 @@ HWTEST_F_L0(ICBinaryOPTest, DivWithTSType) JSHandle arg3(thread, arg3Value); JSHandle arg4(thread, arg4Value); - JSTaggedValue resInSlowPath1 = SlowRuntimeStub::Div2Dyn(thread, arg3.GetTaggedValue(), arg2.GetTaggedValue()); + JSTaggedValue resInSlowPath1 = SlowRuntimeStub::Div2(thread, arg3.GetTaggedValue(), arg2.GetTaggedValue()); JSHandle slowHandle1(thread, resInSlowPath1); JSTaggedValue resInICPath1 = ICBinaryOP::DivWithTSType(thread, arg3.GetTaggedValue(), arg2.GetTaggedValue(), JSTaggedValue(static_cast(BinaryType::NUMBER))); EXPECT_EQ(slowHandle1.GetTaggedValue(), resInICPath1); - JSTaggedValue resInSlowPath2 = SlowRuntimeStub::Div2Dyn(thread, arg2.GetTaggedValue(), arg3.GetTaggedValue()); + JSTaggedValue resInSlowPath2 = SlowRuntimeStub::Div2(thread, arg2.GetTaggedValue(), arg3.GetTaggedValue()); JSHandle slowHandle2(thread, resInSlowPath2); JSTaggedValue resInICPath2 = ICBinaryOP::DivWithTSType(thread, arg2.GetTaggedValue(), arg3.GetTaggedValue(), JSTaggedValue(static_cast(BinaryType::NUMBER))); EXPECT_EQ(slowHandle2.GetTaggedValue(), resInICPath2); - JSTaggedValue resInSlowPath3 = SlowRuntimeStub::Div2Dyn(thread, arg1.GetTaggedValue(), arg2.GetTaggedValue()); + JSTaggedValue resInSlowPath3 = SlowRuntimeStub::Div2(thread, arg1.GetTaggedValue(), arg2.GetTaggedValue()); JSHandle slowHandle3(thread, resInSlowPath3); JSTaggedValue resInICPath3 = ICBinaryOP::DivWithTSType(thread, arg1.GetTaggedValue(), arg2.GetTaggedValue(), JSTaggedValue(static_cast(BinaryType::NUMBER))); EXPECT_EQ(slowHandle3.GetTaggedValue(), resInICPath3); - JSTaggedValue resInSlowPath4 = SlowRuntimeStub::Div2Dyn(thread, arg2.GetTaggedValue(), JSTaggedValue::True()); + JSTaggedValue resInSlowPath4 = SlowRuntimeStub::Div2(thread, arg2.GetTaggedValue(), JSTaggedValue::True()); JSHandle slowHandle4(thread, resInSlowPath4); JSTaggedValue resInICPath4 = ICBinaryOP::DivWithTSType(thread, arg2.GetTaggedValue(), JSTaggedValue::True(), JSTaggedValue(static_cast(BinaryType::GENERIC))); EXPECT_EQ(slowHandle4.GetTaggedValue(), resInICPath4); - JSTaggedValue resInSlowPath5 = SlowRuntimeStub::Div2Dyn(thread, arg4.GetTaggedValue(), JSTaggedValue::False()); + JSTaggedValue resInSlowPath5 = SlowRuntimeStub::Div2(thread, arg4.GetTaggedValue(), JSTaggedValue::False()); JSHandle slowHandle5(thread, resInSlowPath5); JSTaggedValue resInICPath5 = ICBinaryOP::DivWithTSType(thread, arg4.GetTaggedValue(), JSTaggedValue::False(), @@ -241,33 +241,33 @@ HWTEST_F_L0(ICBinaryOPTest, ModWithTSType) JSHandle arg3(thread, arg3Value); JSHandle arg4(thread, arg4Value); - JSTaggedValue resInSlowPath1 = SlowRuntimeStub::Mod2Dyn(thread, arg3.GetTaggedValue(), arg2.GetTaggedValue()); + JSTaggedValue resInSlowPath1 = SlowRuntimeStub::Mod2(thread, arg3.GetTaggedValue(), arg2.GetTaggedValue()); JSHandle slowHandle1(thread, resInSlowPath1); JSTaggedValue resInICPath1 = ICBinaryOP::ModWithTSType(thread, arg3.GetTaggedValue(), arg2.GetTaggedValue(), JSTaggedValue(static_cast(BinaryType::NUMBER))); EXPECT_EQ(slowHandle1.GetTaggedValue(), resInICPath1); - JSTaggedValue resInSlowPath2 = SlowRuntimeStub::Mod2Dyn(thread, arg2.GetTaggedValue(), arg3.GetTaggedValue()); + JSTaggedValue resInSlowPath2 = SlowRuntimeStub::Mod2(thread, arg2.GetTaggedValue(), arg3.GetTaggedValue()); JSHandle slowHandle2(thread, resInSlowPath2); JSTaggedValue resInICPath2 = ICBinaryOP::ModWithTSType(thread, arg2.GetTaggedValue(), arg3.GetTaggedValue(), JSTaggedValue(static_cast(BinaryType::NUMBER))); EXPECT_EQ(slowHandle2.GetTaggedValue(), resInICPath2); - JSTaggedValue resInSlowPath3 = SlowRuntimeStub::Mod2Dyn(thread, arg1.GetTaggedValue(), arg2.GetTaggedValue()); + JSTaggedValue resInSlowPath3 = SlowRuntimeStub::Mod2(thread, arg1.GetTaggedValue(), arg2.GetTaggedValue()); JSHandle slowHandle3(thread, resInSlowPath3); JSTaggedValue resInICPath3 = ICBinaryOP::ModWithTSType(thread, arg1.GetTaggedValue(), arg2.GetTaggedValue(), JSTaggedValue(static_cast(BinaryType::NUMBER))); EXPECT_EQ(slowHandle3.GetTaggedValue(), resInICPath3); - JSTaggedValue resInSlowPath4 = SlowRuntimeStub::Mod2Dyn(thread, arg2.GetTaggedValue(), JSTaggedValue::True()); + JSTaggedValue resInSlowPath4 = SlowRuntimeStub::Mod2(thread, arg2.GetTaggedValue(), JSTaggedValue::True()); JSHandle slowHandle4(thread, resInSlowPath4); JSTaggedValue resInICPath4 = ICBinaryOP::ModWithTSType(thread, arg2.GetTaggedValue(), JSTaggedValue::True(), JSTaggedValue(static_cast(BinaryType::GENERIC))); EXPECT_EQ(slowHandle4.GetTaggedValue(), resInICPath4); - JSTaggedValue resInSlowPath5 = SlowRuntimeStub::Mod2Dyn(thread, arg4.GetTaggedValue(), JSTaggedValue::False()); + JSTaggedValue resInSlowPath5 = SlowRuntimeStub::Mod2(thread, arg4.GetTaggedValue(), JSTaggedValue::False()); JSHandle slowHandle5(thread, resInSlowPath5); JSTaggedValue resInICPath5 = ICBinaryOP::ModWithTSType(thread, arg4.GetTaggedValue(), JSTaggedValue::False(), diff --git a/ecmascript/ic/tests/ic_compareop_test.cpp b/ecmascript/ic/tests/ic_compareop_test.cpp index b4fbe01fae..29c676800c 100644 --- a/ecmascript/ic/tests/ic_compareop_test.cpp +++ b/ecmascript/ic/tests/ic_compareop_test.cpp @@ -85,15 +85,15 @@ HWTEST_F_L0(IcCompareOPTest, EqualWithIC) JSTaggedValue booleanObj = builtins::BuiltinsBoolean::BooleanConstructor(ecmaRuntimeCallInfo); JSHandle booleanObjHandle(thread, booleanObj); - JSTaggedValue resInSlowPath1 = SlowRuntimeStub::EqDyn(thread, arg1Handle.GetTaggedValue(), + JSTaggedValue resInSlowPath1 = SlowRuntimeStub::Eq(thread, arg1Handle.GetTaggedValue(), arg2Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath2 = SlowRuntimeStub::EqDyn(thread, Str1.GetTaggedValue(), arg1Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath3 = SlowRuntimeStub::EqDyn(thread, Str1.GetTaggedValue(), arg3Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath4 = SlowRuntimeStub::EqDyn(thread, Str1.GetTaggedValue(), arg4Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath5 = SlowRuntimeStub::EqDyn(thread, booleanObjHandle.GetTaggedValue(), + JSTaggedValue resInSlowPath2 = SlowRuntimeStub::Eq(thread, Str1.GetTaggedValue(), arg1Handle.GetTaggedValue()); + JSTaggedValue resInSlowPath3 = SlowRuntimeStub::Eq(thread, Str1.GetTaggedValue(), arg3Handle.GetTaggedValue()); + JSTaggedValue resInSlowPath4 = SlowRuntimeStub::Eq(thread, Str1.GetTaggedValue(), arg4Handle.GetTaggedValue()); + JSTaggedValue resInSlowPath5 = SlowRuntimeStub::Eq(thread, booleanObjHandle.GetTaggedValue(), arg4Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath9 = SlowRuntimeStub::EqDyn(thread, JSTaggedValue::Undefined(), JSTaggedValue::Null()); - JSTaggedValue resInSlowPath10 = SlowRuntimeStub::EqDyn(thread, JSTaggedValue::Undefined(), JSTaggedValue::True()); + JSTaggedValue resInSlowPath9 = SlowRuntimeStub::Eq(thread, JSTaggedValue::Undefined(), JSTaggedValue::Null()); + JSTaggedValue resInSlowPath10 = SlowRuntimeStub::Eq(thread, JSTaggedValue::Undefined(), JSTaggedValue::True()); JSTaggedValue resInICPath1 = CompareOp::EqualWithIC(thread, arg1Handle.GetTaggedValue(), arg2Handle.GetTaggedValue(), CompareOpType::NUMBER_NUMBER); @@ -144,19 +144,19 @@ HWTEST_F_L0(IcCompareOPTest, NotEqualWithIC) JSTaggedValue booleanObj = builtins::BuiltinsBoolean::BooleanConstructor(ecmaRuntimeCallInfo); JSHandle booleanObjHandle(thread, booleanObj); - JSTaggedValue resInSlowPath1 = SlowRuntimeStub::NotEqDyn(thread, arg1Handle.GetTaggedValue(), + JSTaggedValue resInSlowPath1 = SlowRuntimeStub::NotEq(thread, arg1Handle.GetTaggedValue(), arg2Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath2 = SlowRuntimeStub::NotEqDyn(thread, Str1.GetTaggedValue(), + JSTaggedValue resInSlowPath2 = SlowRuntimeStub::NotEq(thread, Str1.GetTaggedValue(), arg1Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath3 = SlowRuntimeStub::NotEqDyn(thread, Str1.GetTaggedValue(), + JSTaggedValue resInSlowPath3 = SlowRuntimeStub::NotEq(thread, Str1.GetTaggedValue(), arg3Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath4 = SlowRuntimeStub::NotEqDyn(thread, Str1.GetTaggedValue(), + JSTaggedValue resInSlowPath4 = SlowRuntimeStub::NotEq(thread, Str1.GetTaggedValue(), arg4Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath5 = SlowRuntimeStub::NotEqDyn(thread, arg1Handle.GetTaggedValue(), + JSTaggedValue resInSlowPath5 = SlowRuntimeStub::NotEq(thread, arg1Handle.GetTaggedValue(), booleanObjHandle.GetTaggedValue()); - JSTaggedValue resInSlowPath9 = SlowRuntimeStub::NotEqDyn(thread, JSTaggedValue::Undefined(), + JSTaggedValue resInSlowPath9 = SlowRuntimeStub::NotEq(thread, JSTaggedValue::Undefined(), JSTaggedValue::Null()); - JSTaggedValue resInSlowPath10 = SlowRuntimeStub::NotEqDyn(thread, JSTaggedValue::Undefined(), + JSTaggedValue resInSlowPath10 = SlowRuntimeStub::NotEq(thread, JSTaggedValue::Undefined(), JSTaggedValue::True()); JSTaggedValue resInICPath1 = CompareOp::NotEqualWithIC(thread, arg1Handle.GetTaggedValue(), @@ -186,7 +186,7 @@ HWTEST_F_L0(IcCompareOPTest, NotEqualWithIC) }; -HWTEST_F_L0(IcCompareOPTest, LessDynWithIC) +HWTEST_F_L0(IcCompareOPTest, LessWithIC) { ObjectFactory *factory = ecmaVm->GetFactory(); @@ -212,35 +212,35 @@ HWTEST_F_L0(IcCompareOPTest, LessDynWithIC) JSTaggedValue booleanObj = builtins::BuiltinsBoolean::BooleanConstructor(ecmaRuntimeCallInfo); JSHandle booleanObjHandle(thread, booleanObj); - JSTaggedValue resInSlowPath1 = SlowRuntimeStub::LessDyn(thread, arg1Handle.GetTaggedValue(), + JSTaggedValue resInSlowPath1 = SlowRuntimeStub::Less(thread, arg1Handle.GetTaggedValue(), arg2Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath2 = SlowRuntimeStub::LessDyn(thread, Str1.GetTaggedValue(), + JSTaggedValue resInSlowPath2 = SlowRuntimeStub::Less(thread, Str1.GetTaggedValue(), arg1Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath3 = SlowRuntimeStub::LessDyn(thread, Str1.GetTaggedValue(), + JSTaggedValue resInSlowPath3 = SlowRuntimeStub::Less(thread, Str1.GetTaggedValue(), arg3Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath4 = SlowRuntimeStub::LessDyn(thread, Str1.GetTaggedValue(), + JSTaggedValue resInSlowPath4 = SlowRuntimeStub::Less(thread, Str1.GetTaggedValue(), arg4Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath5 = SlowRuntimeStub::LessDyn(thread, arg1Handle.GetTaggedValue(), + JSTaggedValue resInSlowPath5 = SlowRuntimeStub::Less(thread, arg1Handle.GetTaggedValue(), booleanObjHandle.GetTaggedValue()); - JSTaggedValue resInSlowPath9 = SlowRuntimeStub::LessDyn(thread, + JSTaggedValue resInSlowPath9 = SlowRuntimeStub::Less(thread, JSTaggedValue::Undefined(), JSTaggedValue::Null()); - JSTaggedValue resInSlowPath10 = SlowRuntimeStub::LessDyn(thread, + JSTaggedValue resInSlowPath10 = SlowRuntimeStub::Less(thread, JSTaggedValue::Undefined(), JSTaggedValue::True()); - JSTaggedValue resInICPath1 = CompareOp::LessDynWithIC(thread, arg1Handle.GetTaggedValue(), + JSTaggedValue resInICPath1 = CompareOp::LessWithIC(thread, arg1Handle.GetTaggedValue(), arg2Handle.GetTaggedValue(), CompareOpType::NUMBER_NUMBER); - JSTaggedValue resInICPath2 = CompareOp::LessDynWithIC(thread, Str1.GetTaggedValue(), + JSTaggedValue resInICPath2 = CompareOp::LessWithIC(thread, Str1.GetTaggedValue(), arg1Handle.GetTaggedValue(), CompareOpType::STRING_NUMBER); - JSTaggedValue resInICPath3 = CompareOp::LessDynWithIC(thread, Str1.GetTaggedValue(), + JSTaggedValue resInICPath3 = CompareOp::LessWithIC(thread, Str1.GetTaggedValue(), arg3Handle.GetTaggedValue(), CompareOpType::STRING_BOOLEAN); - JSTaggedValue resInICPath4 = CompareOp::LessDynWithIC(thread, Str1.GetTaggedValue(), + JSTaggedValue resInICPath4 = CompareOp::LessWithIC(thread, Str1.GetTaggedValue(), arg4Handle.GetTaggedValue(), CompareOpType::STRING_BOOLEAN); - JSTaggedValue resInICPath5 = CompareOp::LessDynWithIC(thread, arg1Handle.GetTaggedValue(), + JSTaggedValue resInICPath5 = CompareOp::LessWithIC(thread, arg1Handle.GetTaggedValue(), booleanObjHandle.GetTaggedValue(), CompareOpType::NUMBER_OBJ); - JSTaggedValue resInICPath9 = CompareOp::LessDynWithIC(thread, JSTaggedValue::Undefined(), + JSTaggedValue resInICPath9 = CompareOp::LessWithIC(thread, JSTaggedValue::Undefined(), JSTaggedValue::Null(), CompareOpType::UNDEFINED_NULL); - JSTaggedValue resInICPath10 = CompareOp::LessDynWithIC(thread, JSTaggedValue::Undefined(), + JSTaggedValue resInICPath10 = CompareOp::LessWithIC(thread, JSTaggedValue::Undefined(), JSTaggedValue::True(), CompareOpType::OTHER); EXPECT_EQ(resInSlowPath1, resInICPath1); @@ -253,7 +253,7 @@ HWTEST_F_L0(IcCompareOPTest, LessDynWithIC) }; -HWTEST_F_L0(IcCompareOPTest, LessEqDynWithIC) +HWTEST_F_L0(IcCompareOPTest, LessEqWithIC) { ObjectFactory *factory = ecmaVm->GetFactory(); @@ -277,39 +277,39 @@ HWTEST_F_L0(IcCompareOPTest, LessEqDynWithIC) JSTaggedValue booleanObj = builtins::BuiltinsBoolean::BooleanConstructor(ecmaRuntimeCallInfo); JSHandle booleanObjHandle(thread, booleanObj); - JSTaggedValue resInSlowPath1 = SlowRuntimeStub::LessEqDyn(thread, arg1Handle.GetTaggedValue(), + JSTaggedValue resInSlowPath1 = SlowRuntimeStub::LessEq(thread, arg1Handle.GetTaggedValue(), arg2Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath2 = SlowRuntimeStub::LessEqDyn(thread, Str1.GetTaggedValue(), + JSTaggedValue resInSlowPath2 = SlowRuntimeStub::LessEq(thread, Str1.GetTaggedValue(), arg1Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath3 = SlowRuntimeStub::LessEqDyn(thread, Str1.GetTaggedValue(), + JSTaggedValue resInSlowPath3 = SlowRuntimeStub::LessEq(thread, Str1.GetTaggedValue(), arg3Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath4 = SlowRuntimeStub::LessEqDyn(thread, Str1.GetTaggedValue(), + JSTaggedValue resInSlowPath4 = SlowRuntimeStub::LessEq(thread, Str1.GetTaggedValue(), arg4Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath5 = SlowRuntimeStub::LessEqDyn(thread, arg1Handle.GetTaggedValue(), + JSTaggedValue resInSlowPath5 = SlowRuntimeStub::LessEq(thread, arg1Handle.GetTaggedValue(), booleanObjHandle.GetTaggedValue()); - JSTaggedValue resInSlowPath9 = SlowRuntimeStub::LessEqDyn(thread, JSTaggedValue::Undefined(), + JSTaggedValue resInSlowPath9 = SlowRuntimeStub::LessEq(thread, JSTaggedValue::Undefined(), JSTaggedValue::Null()); - JSTaggedValue resInSlowPath10 = SlowRuntimeStub::LessEqDyn(thread, JSTaggedValue::Undefined(), + JSTaggedValue resInSlowPath10 = SlowRuntimeStub::LessEq(thread, JSTaggedValue::Undefined(), JSTaggedValue::True()); - JSTaggedValue resInICPath1 = CompareOp::LessEqDynWithIC(thread, arg1Handle.GetTaggedValue(), + JSTaggedValue resInICPath1 = CompareOp::LessEqWithIC(thread, arg1Handle.GetTaggedValue(), arg2Handle.GetTaggedValue(), CompareOpType::NUMBER_NUMBER); - JSTaggedValue resInICPath2 = CompareOp::LessEqDynWithIC(thread, Str1.GetTaggedValue(), + JSTaggedValue resInICPath2 = CompareOp::LessEqWithIC(thread, Str1.GetTaggedValue(), arg1Handle.GetTaggedValue(), CompareOpType::STRING_NUMBER); - JSTaggedValue resInICPath3 = CompareOp::LessEqDynWithIC(thread, Str1.GetTaggedValue(), + JSTaggedValue resInICPath3 = CompareOp::LessEqWithIC(thread, Str1.GetTaggedValue(), arg3Handle.GetTaggedValue(), CompareOpType::STRING_BOOLEAN); - JSTaggedValue resInICPath4 = CompareOp::LessEqDynWithIC(thread, Str1.GetTaggedValue(), + JSTaggedValue resInICPath4 = CompareOp::LessEqWithIC(thread, Str1.GetTaggedValue(), arg4Handle.GetTaggedValue(), CompareOpType::STRING_BOOLEAN); - JSTaggedValue resInICPath5 = CompareOp::LessEqDynWithIC(thread, + JSTaggedValue resInICPath5 = CompareOp::LessEqWithIC(thread, arg1Handle.GetTaggedValue(), booleanObjHandle.GetTaggedValue(), CompareOpType::NUMBER_OBJ); - JSTaggedValue resInICPath9 = CompareOp::LessEqDynWithIC(thread, JSTaggedValue::Undefined(), + JSTaggedValue resInICPath9 = CompareOp::LessEqWithIC(thread, JSTaggedValue::Undefined(), JSTaggedValue::Null(), CompareOpType::UNDEFINED_NULL); - JSTaggedValue resInICPath10 = CompareOp::LessEqDynWithIC(thread, JSTaggedValue::Undefined(), + JSTaggedValue resInICPath10 = CompareOp::LessEqWithIC(thread, JSTaggedValue::Undefined(), JSTaggedValue::True(), CompareOpType::OTHER); EXPECT_EQ(resInSlowPath1, resInICPath1); @@ -322,7 +322,7 @@ HWTEST_F_L0(IcCompareOPTest, LessEqDynWithIC) }; -HWTEST_F_L0(IcCompareOPTest, GreaterDynWithIC) +HWTEST_F_L0(IcCompareOPTest, GreaterWithIC) { ObjectFactory *factory = ecmaVm->GetFactory(); @@ -346,39 +346,39 @@ HWTEST_F_L0(IcCompareOPTest, GreaterDynWithIC) JSTaggedValue booleanObj = builtins::BuiltinsBoolean::BooleanConstructor(ecmaRuntimeCallInfo); JSHandle booleanObjHandle(thread, booleanObj); - JSTaggedValue resInSlowPath1 = SlowRuntimeStub::GreaterDyn(thread, arg1Handle.GetTaggedValue(), + JSTaggedValue resInSlowPath1 = SlowRuntimeStub::Greater(thread, arg1Handle.GetTaggedValue(), arg2Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath2 = SlowRuntimeStub::GreaterDyn(thread, Str1.GetTaggedValue(), + JSTaggedValue resInSlowPath2 = SlowRuntimeStub::Greater(thread, Str1.GetTaggedValue(), arg1Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath3 = SlowRuntimeStub::GreaterDyn(thread, Str1.GetTaggedValue(), + JSTaggedValue resInSlowPath3 = SlowRuntimeStub::Greater(thread, Str1.GetTaggedValue(), arg3Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath4 = SlowRuntimeStub::GreaterDyn(thread, Str1.GetTaggedValue(), + JSTaggedValue resInSlowPath4 = SlowRuntimeStub::Greater(thread, Str1.GetTaggedValue(), arg4Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath5 = SlowRuntimeStub::GreaterDyn(thread, arg1Handle.GetTaggedValue(), + JSTaggedValue resInSlowPath5 = SlowRuntimeStub::Greater(thread, arg1Handle.GetTaggedValue(), booleanObjHandle.GetTaggedValue()); - JSTaggedValue resInSlowPath9 = SlowRuntimeStub::GreaterDyn(thread, JSTaggedValue::Undefined(), + JSTaggedValue resInSlowPath9 = SlowRuntimeStub::Greater(thread, JSTaggedValue::Undefined(), JSTaggedValue::Null()); - JSTaggedValue resInSlowPath10 = SlowRuntimeStub::GreaterDyn(thread, JSTaggedValue::Undefined(), + JSTaggedValue resInSlowPath10 = SlowRuntimeStub::Greater(thread, JSTaggedValue::Undefined(), JSTaggedValue::True()); - JSTaggedValue resInICPath1 = CompareOp::GreaterDynWithIC(thread, arg1Handle.GetTaggedValue(), + JSTaggedValue resInICPath1 = CompareOp::GreaterWithIC(thread, arg1Handle.GetTaggedValue(), arg2Handle.GetTaggedValue(), CompareOpType::NUMBER_NUMBER); - JSTaggedValue resInICPath2 = CompareOp::GreaterDynWithIC(thread, Str1.GetTaggedValue(), + JSTaggedValue resInICPath2 = CompareOp::GreaterWithIC(thread, Str1.GetTaggedValue(), arg1Handle.GetTaggedValue(), CompareOpType::STRING_NUMBER); - JSTaggedValue resInICPath3 = CompareOp::GreaterDynWithIC(thread, Str1.GetTaggedValue(), + JSTaggedValue resInICPath3 = CompareOp::GreaterWithIC(thread, Str1.GetTaggedValue(), arg3Handle.GetTaggedValue(), CompareOpType::STRING_BOOLEAN); - JSTaggedValue resInICPath4 = CompareOp::GreaterDynWithIC(thread, Str1.GetTaggedValue(), + JSTaggedValue resInICPath4 = CompareOp::GreaterWithIC(thread, Str1.GetTaggedValue(), arg4Handle.GetTaggedValue(), CompareOpType::STRING_BOOLEAN); - JSTaggedValue resInICPath5 = CompareOp::GreaterDynWithIC(thread, arg1Handle.GetTaggedValue(), + JSTaggedValue resInICPath5 = CompareOp::GreaterWithIC(thread, arg1Handle.GetTaggedValue(), booleanObjHandle.GetTaggedValue(), CompareOpType::NUMBER_OBJ); - JSTaggedValue resInICPath9 = CompareOp::GreaterDynWithIC(thread, JSTaggedValue::Undefined(), + JSTaggedValue resInICPath9 = CompareOp::GreaterWithIC(thread, JSTaggedValue::Undefined(), JSTaggedValue::Null(), CompareOpType::UNDEFINED_NULL); - JSTaggedValue resInICPath10 = CompareOp::GreaterDynWithIC(thread, JSTaggedValue::Undefined(), + JSTaggedValue resInICPath10 = CompareOp::GreaterWithIC(thread, JSTaggedValue::Undefined(), JSTaggedValue::True(), CompareOpType::OTHER); EXPECT_EQ(resInSlowPath1, resInICPath1); @@ -391,7 +391,7 @@ HWTEST_F_L0(IcCompareOPTest, GreaterDynWithIC) }; -HWTEST_F_L0(IcCompareOPTest, GreaterEqDynWithIC) +HWTEST_F_L0(IcCompareOPTest, GreaterEqWithIC) { ObjectFactory *factory = ecmaVm->GetFactory(); @@ -416,39 +416,39 @@ HWTEST_F_L0(IcCompareOPTest, GreaterEqDynWithIC) JSTaggedValue booleanObj = builtins::BuiltinsBoolean::BooleanConstructor(ecmaRuntimeCallInfo); JSHandle booleanObjHandle(thread, booleanObj); - JSTaggedValue resInSlowPath1 = SlowRuntimeStub::GreaterEqDyn(thread, arg1Handle.GetTaggedValue(), + JSTaggedValue resInSlowPath1 = SlowRuntimeStub::GreaterEq(thread, arg1Handle.GetTaggedValue(), arg2Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath2 = SlowRuntimeStub::GreaterEqDyn(thread, Str1.GetTaggedValue(), + JSTaggedValue resInSlowPath2 = SlowRuntimeStub::GreaterEq(thread, Str1.GetTaggedValue(), arg1Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath3 = SlowRuntimeStub::GreaterEqDyn(thread, Str1.GetTaggedValue(), + JSTaggedValue resInSlowPath3 = SlowRuntimeStub::GreaterEq(thread, Str1.GetTaggedValue(), arg3Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath4 = SlowRuntimeStub::GreaterEqDyn(thread, Str1.GetTaggedValue(), + JSTaggedValue resInSlowPath4 = SlowRuntimeStub::GreaterEq(thread, Str1.GetTaggedValue(), arg4Handle.GetTaggedValue()); - JSTaggedValue resInSlowPath5 = SlowRuntimeStub::GreaterEqDyn(thread, arg1Handle.GetTaggedValue(), + JSTaggedValue resInSlowPath5 = SlowRuntimeStub::GreaterEq(thread, arg1Handle.GetTaggedValue(), booleanObjHandle.GetTaggedValue()); - JSTaggedValue resInSlowPath9 = SlowRuntimeStub::GreaterEqDyn(thread, JSTaggedValue::Undefined(), + JSTaggedValue resInSlowPath9 = SlowRuntimeStub::GreaterEq(thread, JSTaggedValue::Undefined(), JSTaggedValue::Null()); - JSTaggedValue resInSlowPath10 = SlowRuntimeStub::GreaterEqDyn(thread, JSTaggedValue::Undefined(), + JSTaggedValue resInSlowPath10 = SlowRuntimeStub::GreaterEq(thread, JSTaggedValue::Undefined(), JSTaggedValue::True()); - JSTaggedValue resInICPath1 = CompareOp::GreaterEqDynWithIC(thread, arg1Handle.GetTaggedValue(), + JSTaggedValue resInICPath1 = CompareOp::GreaterEqWithIC(thread, arg1Handle.GetTaggedValue(), arg2Handle.GetTaggedValue(), CompareOpType::NUMBER_NUMBER); - JSTaggedValue resInICPath2 = CompareOp::GreaterEqDynWithIC(thread, Str1.GetTaggedValue(), + JSTaggedValue resInICPath2 = CompareOp::GreaterEqWithIC(thread, Str1.GetTaggedValue(), arg1Handle.GetTaggedValue(), CompareOpType::STRING_NUMBER); - JSTaggedValue resInICPath3 = CompareOp::GreaterEqDynWithIC(thread, Str1.GetTaggedValue(), + JSTaggedValue resInICPath3 = CompareOp::GreaterEqWithIC(thread, Str1.GetTaggedValue(), arg3Handle.GetTaggedValue(), CompareOpType::STRING_BOOLEAN); - JSTaggedValue resInICPath4 = CompareOp::GreaterEqDynWithIC(thread, Str1.GetTaggedValue(), + JSTaggedValue resInICPath4 = CompareOp::GreaterEqWithIC(thread, Str1.GetTaggedValue(), arg4Handle.GetTaggedValue(), CompareOpType::STRING_BOOLEAN); - JSTaggedValue resInICPath5 = CompareOp::GreaterEqDynWithIC(thread, arg1Handle.GetTaggedValue(), + JSTaggedValue resInICPath5 = CompareOp::GreaterEqWithIC(thread, arg1Handle.GetTaggedValue(), booleanObjHandle.GetTaggedValue(), CompareOpType::NUMBER_OBJ); - JSTaggedValue resInICPath9 = CompareOp::GreaterEqDynWithIC(thread, JSTaggedValue::Undefined(), + JSTaggedValue resInICPath9 = CompareOp::GreaterEqWithIC(thread, JSTaggedValue::Undefined(), JSTaggedValue::Null(), CompareOpType::UNDEFINED_NULL); - JSTaggedValue resInICPath10 = CompareOp::GreaterEqDynWithIC(thread, JSTaggedValue::Undefined(), + JSTaggedValue resInICPath10 = CompareOp::GreaterEqWithIC(thread, JSTaggedValue::Undefined(), JSTaggedValue::True(), CompareOpType::OTHER); EXPECT_EQ(resInSlowPath1, resInICPath1); diff --git a/ecmascript/ic/tests/ic_handler_test.cpp b/ecmascript/ic/tests/ic_handler_test.cpp index 0fc501256a..a869ae88cb 100644 --- a/ecmascript/ic/tests/ic_handler_test.cpp +++ b/ecmascript/ic/tests/ic_handler_test.cpp @@ -218,8 +218,8 @@ HWTEST_F_L0(ICHandlerTest, LoadPrototype) JSHandle handleObj1 = JSObject::ObjectCreate(thread, nullHandle); JSHandle handleObj2 = JSObject::ObjectCreate(thread, handleObj1); - JSHandle obj1Dynclass(thread, handleObj1->GetJSHClass()); - JSHandle obj2Dynclass(thread, handleObj2->GetJSHClass()); + JSHandle obj1Class(thread, handleObj1->GetJSHClass()); + JSHandle obj2Class(thread, handleObj2->GetJSHClass()); ObjectOperator handleOp1(thread, handleKey, OperatorType::OWN); ObjectOperator handleOp2(thread, handleKey, OperatorType::OWN); @@ -230,7 +230,7 @@ HWTEST_F_L0(ICHandlerTest, LoadPrototype) JSHandle handlerValue1 = LoadHandler::LoadProperty(thread, handleOp1); EXPECT_TRUE(HandlerBase::IsNonExist(handlerValue1->GetInt())); // test op is Found and hclass has Prototype - JSHandle handlerValue2 = PrototypeHandler::LoadPrototype(thread, handleOp2, obj2Dynclass); + JSHandle handlerValue2 = PrototypeHandler::LoadPrototype(thread, handleOp2, obj2Class); JSHandle handler2 = JSHandle::Cast(handlerValue2); JSHandle handlerInfo2(thread, handler2->GetHandlerInfo()); EXPECT_EQ(HandlerBase::GetOffset(handlerInfo2->GetInt()), 2); @@ -258,13 +258,13 @@ HWTEST_F_L0(ICHandlerTest, StorePrototype) JSHandle nullObj = JSObject::ObjectCreate(thread, nullHandle); JSHandle handleObj = JSObject::ObjectCreate(thread, nullObj); - JSHandle objDynclass(thread, handleObj->GetJSHClass()); + JSHandle objClass(thread, handleObj->GetJSHClass()); ObjectOperator handleOp(thread, handleKey, OperatorType::OWN); handleOp.SetFastMode(true); handleOp.SetIndex(2); // test hclass has Prototype - JSHandle handlerValue = PrototypeHandler::StorePrototype(thread, handleOp, objDynclass); + JSHandle handlerValue = PrototypeHandler::StorePrototype(thread, handleOp, objClass); JSHandle handler = JSHandle::Cast(handlerValue); JSHandle handlerInfo(thread, handler->GetHandlerInfo()); EXPECT_EQ(HandlerBase::GetOffset(handlerInfo->GetInt()), 2); diff --git a/ecmascript/ic/tests/profile_type_info_test.cpp b/ecmascript/ic/tests/profile_type_info_test.cpp index cf1a38a919..47d015a803 100644 --- a/ecmascript/ic/tests/profile_type_info_test.cpp +++ b/ecmascript/ic/tests/profile_type_info_test.cpp @@ -126,7 +126,7 @@ HWTEST_F_L0(ProfileTypeInfoTest, AddHandlerWithoutKey) JSHandle objFun = env->GetObjectFunction(); JSHandle handleObj = factory->NewJSObjectByConstructor(JSHandle(objFun), objFun); - JSHandle objDynclassVal(thread, handleObj->GetJSHClass()); + JSHandle objClassVal(thread, handleObj->GetJSHClass()); JSHandle HandlerValue(thread, JSTaggedValue(2)); JSHandle handleTaggedArray = factory->NewTaggedArray(2); @@ -142,14 +142,14 @@ HWTEST_F_L0(ProfileTypeInfoTest, AddHandlerWithoutKey) uint32_t slotId = 0; // test profileData is Undefined ProfileTypeAccessor handleProfileTypeAccessor0(thread, handleProfileTypeInfo, slotId, ICKind::StoreIC); - handleProfileTypeAccessor0.AddHandlerWithoutKey(objDynclassVal, HandlerValue); + handleProfileTypeAccessor0.AddHandlerWithoutKey(objClassVal, HandlerValue); EXPECT_TRUE(handleProfileTypeInfo->Get(slotId).IsWeak()); EXPECT_EQ(handleProfileTypeInfo->Get(slotId + 1).GetInt(), 2); slotId = 1; // test POLY handleProfileTypeInfo->Set(thread, slotId, handleTaggedArray.GetTaggedValue()); // Reset Value ProfileTypeAccessor handleProfileTypeAccessor1(thread, handleProfileTypeInfo, slotId, ICKind::StoreIC); - handleProfileTypeAccessor1.AddHandlerWithoutKey(objDynclassVal, HandlerValue); + handleProfileTypeAccessor1.AddHandlerWithoutKey(objClassVal, HandlerValue); EXPECT_TRUE(handleProfileTypeInfo->Get(slotId).IsTaggedArray()); JSHandle resultArr1(thread, handleProfileTypeInfo->Get(slotId)); EXPECT_EQ(resultArr1->GetLength(), 4U); // 4 = 2 + 2 @@ -158,7 +158,7 @@ HWTEST_F_L0(ProfileTypeInfoTest, AddHandlerWithoutKey) slotId = 2; // test MONO to POLY handleProfileTypeInfo->Set(thread, slotId, HandlerValue.GetTaggedValue()); // Reset Value ProfileTypeAccessor handleProfileTypeAccessor2(thread, handleProfileTypeInfo, slotId, ICKind::StoreIC); - handleProfileTypeAccessor2.AddHandlerWithoutKey(objDynclassVal, HandlerValue); + handleProfileTypeAccessor2.AddHandlerWithoutKey(objClassVal, HandlerValue); JSHandle resultArr2(thread, handleProfileTypeInfo->Get(slotId)); EXPECT_EQ(resultArr2->GetLength(), 4U); // POLY_DEFAULT_LEN EXPECT_EQ(resultArr2->Get(0).GetInt(), 2); @@ -185,7 +185,7 @@ HWTEST_F_L0(ProfileTypeInfoTest, AddElementHandler) JSHandle objFun = env->GetObjectFunction(); JSHandle handleObj = factory->NewJSObjectByConstructor(JSHandle(objFun), objFun); - JSHandle objDynclassVal(thread, handleObj->GetJSHClass()); + JSHandle objClassVal(thread, handleObj->GetJSHClass()); JSHandle HandlerValue(thread, JSTaggedValue(3)); JSHandle handleDetailsArray = factory->NewTaggedArray(4); @@ -195,7 +195,7 @@ HWTEST_F_L0(ProfileTypeInfoTest, AddElementHandler) uint32_t slotId = 0; ProfileTypeAccessor handleProfileTypeAccessor0(thread, handleProfileTypeInfo, slotId, ICKind::StoreIC); - handleProfileTypeAccessor0.AddElementHandler(objDynclassVal, HandlerValue); + handleProfileTypeAccessor0.AddElementHandler(objClassVal, HandlerValue); EXPECT_TRUE(handleProfileTypeInfo->Get(0).IsWeak()); EXPECT_EQ(handleProfileTypeInfo->Get(1).GetInt(), 3); } @@ -218,7 +218,7 @@ HWTEST_F_L0(ProfileTypeInfoTest, AddHandlerWithKey) JSHandle objFun = env->GetObjectFunction(); JSHandle handleObj = factory->NewJSObjectByConstructor(JSHandle(objFun), objFun); - JSHandle objDynclassVal(thread, handleObj->GetJSHClass()); + JSHandle objClassVal(thread, handleObj->GetJSHClass()); JSHandle HandlerValue(thread, JSTaggedValue(2)); JSHandle HandleKey0(factory->NewFromASCII("key0")); JSHandle HandleKey1(factory->NewFromASCII("key1")); @@ -236,20 +236,20 @@ HWTEST_F_L0(ProfileTypeInfoTest, AddHandlerWithKey) uint32_t slotId = 0; // test profileData is Undefined ProfileTypeAccessor handleProfileTypeAccessor0(thread, handleProfileTypeInfo, slotId, ICKind::StoreIC); - handleProfileTypeAccessor0.AddHandlerWithKey(HandleKey1, objDynclassVal, HandlerValue); + handleProfileTypeAccessor0.AddHandlerWithKey(HandleKey1, objClassVal, HandlerValue); EXPECT_TRUE(handleProfileTypeInfo->Get(0).IsString()); EXPECT_TRUE(handleProfileTypeInfo->Get(1).IsTaggedArray()); slotId = 1; // test profileData is equal the key handleProfileTypeInfo->Set(thread, slotId, HandleKey1.GetTaggedValue()); // Reset Value ProfileTypeAccessor handleProfileTypeAccessor1(thread, handleProfileTypeInfo, slotId, ICKind::StoreIC); - handleProfileTypeAccessor1.AddHandlerWithKey(HandleKey1, objDynclassVal, HandlerValue); + handleProfileTypeAccessor1.AddHandlerWithKey(HandleKey1, objClassVal, HandlerValue); JSHandle resultArr1(thread, handleProfileTypeInfo->Get(slotId + 1)); EXPECT_EQ(resultArr1->GetLength(), 4U); // 4 = 2 + 2 slotId = 2; // test profileData is not equal the key ProfileTypeAccessor handleProfileTypeAccessor2(thread, handleProfileTypeInfo, slotId, ICKind::StoreIC); - handleProfileTypeAccessor2.AddHandlerWithKey(HandleKey0, objDynclassVal, HandlerValue); + handleProfileTypeAccessor2.AddHandlerWithKey(HandleKey0, objClassVal, HandlerValue); EXPECT_TRUE(handleProfileTypeInfo->Get(slotId).IsHole()); EXPECT_TRUE(handleProfileTypeInfo->Get(slotId + 1).IsHole()); } diff --git a/ecmascript/ic/tests/properties_cache_test.cpp b/ecmascript/ic/tests/properties_cache_test.cpp index 720f652118..e8f807a030 100644 --- a/ecmascript/ic/tests/properties_cache_test.cpp +++ b/ecmascript/ic/tests/properties_cache_test.cpp @@ -62,25 +62,25 @@ HWTEST_F_L0(PropertiesCacheTest, SetAndGet) JSHandle handleFunction(factory->NewJSFunction(env)); JSHandle handleSymbol(factory->NewJSSymbol()); JSHandle handleKey10(factory->NewFromASCII("10")); - JSHClass *FuncClass = JSObject::Cast(handleFunction->GetTaggedObject())->GetJSHClass(); + JSHClass *FuncHClass = JSObject::Cast(handleFunction->GetTaggedObject())->GetJSHClass(); PropertiesCache *handleProCache = thread->GetPropertiesCache(); // key is string for (int i = 0; i < 10; i++) { JSHandle handleNumKey(thread, JSTaggedValue(1)); JSHandle handleStrKey(JSTaggedValue::ToString(thread, handleNumKey)); - handleProCache->Set(FuncClass, handleStrKey.GetTaggedValue(), i); - EXPECT_EQ(handleProCache->Get(FuncClass, handleStrKey.GetTaggedValue()), i); + handleProCache->Set(FuncHClass, handleStrKey.GetTaggedValue(), i); + EXPECT_EQ(handleProCache->Get(FuncHClass, handleStrKey.GetTaggedValue()), i); } - EXPECT_EQ(handleProCache->Get(FuncClass, handleKey10.GetTaggedValue()), -1); // PropertiesCache::NOT_FOUND + EXPECT_EQ(handleProCache->Get(FuncHClass, handleKey10.GetTaggedValue()), -1); // PropertiesCache::NOT_FOUND // key is symbol for (int i = 0; i < 10; i++) { handleSymbol->SetHashField(static_cast(i)); - handleProCache->Set(FuncClass, handleSymbol.GetTaggedValue(), i); - EXPECT_EQ(handleProCache->Get(FuncClass, handleSymbol.GetTaggedValue()), i); + handleProCache->Set(FuncHClass, handleSymbol.GetTaggedValue(), i); + EXPECT_EQ(handleProCache->Get(FuncHClass, handleSymbol.GetTaggedValue()), i); } handleSymbol->SetHashField(static_cast(10)); - EXPECT_EQ(handleProCache->Get(FuncClass, handleSymbol.GetTaggedValue()), -1); // PropertiesCache::NOT_FOUND + EXPECT_EQ(handleProCache->Get(FuncHClass, handleSymbol.GetTaggedValue()), -1); // PropertiesCache::NOT_FOUND handleProCache->Clear(); } @@ -98,12 +98,12 @@ HWTEST_F_L0(PropertiesCacheTest, Clear) JSHandle handleKey(factory->NewFromASCII("10")); JSHandle handleFunction(factory->NewJSFunction(env)); - JSHClass *FuncClass = JSObject::Cast(handleFunction->GetTaggedObject())->GetJSHClass(); + JSHClass *FuncHClass = JSObject::Cast(handleFunction->GetTaggedObject())->GetJSHClass(); PropertiesCache *handleProCache = thread->GetPropertiesCache(); - handleProCache->Set(FuncClass, handleKey.GetTaggedValue(), 10); - EXPECT_EQ(handleProCache->Get(FuncClass, handleKey.GetTaggedValue()), 10); + handleProCache->Set(FuncHClass, handleKey.GetTaggedValue(), 10); + EXPECT_EQ(handleProCache->Get(FuncHClass, handleKey.GetTaggedValue()), 10); handleProCache->Clear(); - EXPECT_EQ(handleProCache->Get(FuncClass, handleKey.GetTaggedValue()), -1); // PropertiesCache::NOT_FOUND + EXPECT_EQ(handleProCache->Get(FuncHClass, handleKey.GetTaggedValue()), -1); // PropertiesCache::NOT_FOUND } } // namespace panda::test diff --git a/ecmascript/ic/tests/proto_change_details_test.cpp b/ecmascript/ic/tests/proto_change_details_test.cpp index cec855986c..b7615d18a7 100644 --- a/ecmascript/ic/tests/proto_change_details_test.cpp +++ b/ecmascript/ic/tests/proto_change_details_test.cpp @@ -137,7 +137,7 @@ HWTEST_F_L0(ProtoChangeDetailsTest, Add_001) JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); JSHandle objFun = env->GetObjectFunction(); JSHandle handleObj = factory->NewJSObjectByConstructor(JSHandle(objFun), objFun); - JSHandle objDynclassVal(thread, handleObj->GetJSHClass()); + JSHandle objClassVal(thread, handleObj->GetJSHClass()); uint32_t weakVectorCapacity = 10; uint32_t index = 2; JSHandle weakVector = WeakVector::Create(thread, weakVectorCapacity); @@ -146,9 +146,9 @@ HWTEST_F_L0(ProtoChangeDetailsTest, Add_001) } // weakVector is not full JSHandle handleChangeListenerArr = JSHandle::Cast(weakVector); JSHandle resultListenerArray = - ChangeListener::Add(thread, handleChangeListenerArr, JSHandle(objDynclassVal), &index); + ChangeListener::Add(thread, handleChangeListenerArr, JSHandle(objClassVal), &index); EXPECT_EQ(index, 9U); - JSTaggedValue weakRefValue(objDynclassVal.GetTaggedValue()); + JSTaggedValue weakRefValue(objClassVal.GetTaggedValue()); weakRefValue.CreateWeakRef(); EXPECT_EQ(resultListenerArray->Get(index).GetTaggedObject(), weakRefValue.GetTaggedWeakRef()); } @@ -168,7 +168,7 @@ HWTEST_F_L0(ProtoChangeDetailsTest, Add_002) JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); JSHandle objFun = env->GetObjectFunction(); JSHandle handleObj = factory->NewJSObjectByConstructor(JSHandle(objFun), objFun); - JSHandle objDynclassVal(thread, handleObj->GetJSHClass()); + JSHandle objClassVal(thread, handleObj->GetJSHClass()); uint32_t weakVectorCapacity = 10; uint32_t index = 2; JSHandle weakVector = WeakVector::Create(thread, weakVectorCapacity); @@ -179,9 +179,9 @@ HWTEST_F_L0(ProtoChangeDetailsTest, Add_002) // weakVector exist hole weakVector->Delete(thread, 1); // delete in one JSHandle resultListenerArray = - ChangeListener::Add(thread, handleChangeListenerArr, JSHandle(objDynclassVal), &index); + ChangeListener::Add(thread, handleChangeListenerArr, JSHandle(objClassVal), &index); EXPECT_EQ(index, 1U); - JSTaggedValue weakRefValue(objDynclassVal.GetTaggedValue()); + JSTaggedValue weakRefValue(objClassVal.GetTaggedValue()); weakRefValue.CreateWeakRef(); EXPECT_EQ(resultListenerArray->Get(index).GetTaggedObject(), weakRefValue.GetTaggedWeakRef()); } @@ -201,7 +201,7 @@ HWTEST_F_L0(ProtoChangeDetailsTest, Add_003) JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); JSHandle objFun = env->GetObjectFunction(); JSHandle handleObj = factory->NewJSObjectByConstructor(JSHandle(objFun), objFun); - JSHandle objDynclassVal(thread, handleObj->GetJSHClass()); + JSHandle objClassVal(thread, handleObj->GetJSHClass()); uint32_t weakVectorCapacity = 10; uint32_t index = 2; JSHandle weakVector = WeakVector::Create(thread, weakVectorCapacity); @@ -211,9 +211,9 @@ HWTEST_F_L0(ProtoChangeDetailsTest, Add_003) JSHandle handleChangeListenerArr = JSHandle::Cast(weakVector); // weakVector is full and no hole exists. JSHandle resultListenerArray = - ChangeListener::Add(thread, handleChangeListenerArr, JSHandle(objDynclassVal), &index); + ChangeListener::Add(thread, handleChangeListenerArr, JSHandle(objClassVal), &index); EXPECT_EQ(index, 10U); - JSTaggedValue weakRefValue(objDynclassVal.GetTaggedValue()); + JSTaggedValue weakRefValue(objClassVal.GetTaggedValue()); weakRefValue.CreateWeakRef(); EXPECT_EQ(resultListenerArray->Get(index).GetTaggedObject(), weakRefValue.GetTaggedWeakRef()); } diff --git a/ecmascript/interpreter/fast_runtime_stub-inl.h b/ecmascript/interpreter/fast_runtime_stub-inl.h index 109cadacd5..154fb91ed4 100644 --- a/ecmascript/interpreter/fast_runtime_stub-inl.h +++ b/ecmascript/interpreter/fast_runtime_stub-inl.h @@ -741,9 +741,9 @@ JSTaggedValue FastRuntimeStub::FastGetPropertyByIndex(JSThread *thread, JSTagged return result; } -JSTaggedValue FastRuntimeStub::NewLexicalEnvDyn(JSThread *thread, ObjectFactory *factory, uint16_t numVars) +JSTaggedValue FastRuntimeStub::NewLexicalEnv(JSThread *thread, ObjectFactory *factory, uint16_t numVars) { - INTERPRETER_TRACE(thread, NewLexicalEnvDyn); + INTERPRETER_TRACE(thread, NewLexicalEnv); [[maybe_unused]] EcmaHandleScope handleScope(thread); LexicalEnv *newEnv = factory->InlineNewLexicalEnv(numVars); if (UNLIKELY(newEnv == nullptr)) { diff --git a/ecmascript/interpreter/fast_runtime_stub.h b/ecmascript/interpreter/fast_runtime_stub.h index e1fc6cd03b..715745baa4 100644 --- a/ecmascript/interpreter/fast_runtime_stub.h +++ b/ecmascript/interpreter/fast_runtime_stub.h @@ -33,7 +33,7 @@ public: static inline JSTaggedValue FastEqual(JSTaggedValue left, JSTaggedValue right); static inline JSTaggedValue FastTypeOf(JSThread *thread, JSTaggedValue obj); static inline bool FastStrictEqual(JSTaggedValue left, JSTaggedValue right); - static inline JSTaggedValue NewLexicalEnvDyn(JSThread *thread, ObjectFactory *factory, uint16_t numVars); + static inline JSTaggedValue NewLexicalEnv(JSThread *thread, ObjectFactory *factory, uint16_t numVars); static inline JSTaggedValue GetGlobalOwnProperty(JSThread *thread, JSTaggedValue receiver, JSTaggedValue key); template static inline JSTaggedValue GetPropertyByName(JSThread *thread, JSTaggedValue receiver, JSTaggedValue key); diff --git a/ecmascript/interpreter/frame_handler.cpp b/ecmascript/interpreter/frame_handler.cpp index 59578df51d..64d28e54ed 100644 --- a/ecmascript/interpreter/frame_handler.cpp +++ b/ecmascript/interpreter/frame_handler.cpp @@ -21,7 +21,6 @@ #include "ecmascript/js_function.h" #include "ecmascript/js_thread.h" #include "ecmascript/mem/heap.h" -#include "libpandafile/bytecode_instruction-inl.h" namespace panda::ecmascript { FrameHandler::FrameHandler(const JSThread *thread) diff --git a/ecmascript/interpreter/interpreter-inl.h b/ecmascript/interpreter/interpreter-inl.h index 5a451c2b6a..ce7dd157a6 100644 --- a/ecmascript/interpreter/interpreter-inl.h +++ b/ecmascript/interpreter/interpreter-inl.h @@ -61,9 +61,11 @@ using CommonStubCSigns = kungfu::CommonStubCSigns; #define LOG_INST() false && LOG_INTERPRETER(DEBUG) #endif -// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) -#define HANDLE_OPCODE(handle_opcode) \ - handle_opcode: // NOLINT(clang-diagnostic-gnu-label-as-value, cppcoreguidelines-macro-usage) +#define HANDLE_OPCODE(opcode) \ + HANDLE_##opcode: + +#define DEBUG_HANDLE_OPCODE(opcode) \ + DEBUG_HANDLE_##opcode: // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) #define ADVANCE_PC(offset) \ @@ -72,10 +74,10 @@ using CommonStubCSigns = kungfu::CommonStubCSigns; #define GOTO_NEXT() // NOLINT(clang-diagnostic-gnu-label-as-value, cppcoreguidelines-macro-usage) // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) -#define DISPATCH(format) \ - do { \ - ADVANCE_PC(BytecodeInstruction::Size(format)) \ - opcode = READ_INST_OP(); goto *dispatchTable[opcode]; \ +#define DISPATCH(curOpcode) \ + do { \ + ADVANCE_PC(BytecodeInstruction::Size(EcmaOpcode::curOpcode)) \ + opcode = READ_INST_OP(); goto *dispatchTable[opcode]; \ } while (false) // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) @@ -85,6 +87,42 @@ using CommonStubCSigns = kungfu::CommonStubCSigns; opcode = READ_INST_OP(); goto *dispatchTable[opcode]; \ } while (false) +#define DISPATCH_THROW() \ + do { \ + opcode = *(pc + 1); \ + goto *throwDispatchTable[opcode]; \ + } while (false) + +#define DISPATCH_WIDE() \ + do { \ + opcode = *(pc + 1); \ + goto *wideDispatchTable[opcode]; \ + } while (false) + +#define DISPATCH_DEPRECATED() \ + do { \ + opcode = *(pc + 1); \ + goto *deprecatedDispatchTable[opcode]; \ + } while (false) + +#define DEBUG_DISPATCH_THROW() \ + do { \ + opcode = *(pc + 1); \ + goto *throwDebugDispatchTable[opcode]; \ + } while (false) + +#define DEBUG_DISPATCH_WIDE() \ + do { \ + opcode = *(pc + 1); \ + goto *wideDebugDispatchTable[opcode]; \ + } while (false) + +#define DEBUG_DISPATCH_DEPRECATED() \ + do { \ + opcode = *(pc + 1); \ + goto *deprecatedDebugDispatchTable[opcode]; \ + } while (false) + // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) #define GET_FRAME(CurrentSp) \ (reinterpret_cast(CurrentSp) - 1) // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic) @@ -106,7 +144,7 @@ using CommonStubCSigns = kungfu::CommonStubCSigns; // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) #define SET_VREG(idx, val) (sp[idx] = (val)); // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic) #define GET_ACC() (acc) // NOLINT(cppcoreguidelines-macro-usage) -#define SET_ACC(val) (acc = val); // NOLINT(cppcoreguidelines-macro-usage) +#define SET_ACC(val) (acc = val) // NOLINT(cppcoreguidelines-macro-usage) #define GET_OBJ_FROM_CACHE(index) \ (ConstantPool::Cast(GetConstantPool(sp).GetTaggedObject())->GetObjectFromCache(index)) @@ -115,7 +153,7 @@ using CommonStubCSigns = kungfu::CommonStubCSigns; #define INTERPRETER_GOTO_EXCEPTION_HANDLER() \ do { \ SAVE_PC(); \ - goto *dispatchTable[EcmaOpcode::LAST_OPCODE]; \ + goto *dispatchTable[EXCEPTION_OPCODE]; \ } while (false) // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) @@ -132,16 +170,24 @@ using CommonStubCSigns = kungfu::CommonStubCSigns; } // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) -#define REAL_GOTO_DISPATCH_OPCODE(opcode) \ - do { \ - goto *instDispatchTable[opcode]; \ +#define REAL_GOTO_DISPATCH_OPCODE(opcode) \ + do { \ + ASSERT(static_cast(opcode) <= 0xff); \ + goto *instDispatchTable[static_cast(opcode)]; \ + } while (false) + +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define REAL_GOTO_SECOND_DISPATCH_OPCODE(opcode) \ + do { \ + ASSERT(static_cast(opcode) > 0xff); \ + goto *instDispatchTable[static_cast(opcode) >> sizeof(uint8_t)]; \ } while (false) // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) #define REAL_GOTO_EXCEPTION_HANDLER() \ do { \ SAVE_PC(); \ - goto *instDispatchTable[EcmaOpcode::LAST_OPCODE]; \ + goto *instDispatchTable[EXCEPTION_OPCODE]; \ } while (false) // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) @@ -175,11 +221,11 @@ using CommonStubCSigns = kungfu::CommonStubCSigns; } while (false) // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) -#define CALL_INITIALIZE() \ +#define DEPRECATED_CALL_INITIALIZE() \ do { \ SAVE_PC(); \ thread->CheckSafepoint(); \ - funcTagged = sp[funcReg]; \ + funcTagged = sp[startReg]; \ JSTaggedValue funcValue(funcTagged); \ if (!funcValue.IsCallable()) { \ { \ @@ -195,6 +241,26 @@ using CommonStubCSigns = kungfu::CommonStubCSigns; newSp = sp - InterpretedFrame::NumOfMembers(); \ } while (false) +#define CALL_INITIALIZE() \ + do { \ + SAVE_PC(); \ + thread->CheckSafepoint(); \ + funcTagged = acc.GetRawData(); \ + JSTaggedValue funcValue = acc; \ + if (!funcValue.IsCallable()) { \ + { \ + [[maybe_unused]] EcmaHandleScope handleScope(thread); \ + JSHandle error = factory->GetJSError( \ + ErrorType::TYPE_ERROR, "is not callable"); \ + thread->SetException(error.GetTaggedValue()); \ + } \ + INTERPRETER_GOTO_EXCEPTION_HANDLER(); \ + } \ + funcObject = ECMAObject::Cast(funcValue.GetTaggedObject()); \ + methodHandle.Update(JSTaggedValue(funcObject->GetCallTarget())); \ + newSp = sp - InterpretedFrame::NumOfMembers(); \ + } while (false) + // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) #define CALL_PUSH_UNDEFINED(n) \ do { \ @@ -209,12 +275,18 @@ using CommonStubCSigns = kungfu::CommonStubCSigns; /* do nothing when 0 arg */ \ } while (false) +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define DEPRECATED_CALL_PUSH_ARGS_0() CALL_PUSH_ARGS_0() + // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) #define CALL_PUSH_ARGS_1() \ do { \ *(--newSp) = sp[a0]; \ } while (false) +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define DEPRECATED_CALL_PUSH_ARGS_1() CALL_PUSH_ARGS_1() + // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) #define CALL_PUSH_ARGS_2() \ do { \ @@ -222,6 +294,9 @@ using CommonStubCSigns = kungfu::CommonStubCSigns; CALL_PUSH_ARGS_1(); \ } while (false) +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define DEPRECATED_CALL_PUSH_ARGS_2() CALL_PUSH_ARGS_2() + // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) #define CALL_PUSH_ARGS_3() \ do { \ @@ -230,25 +305,51 @@ using CommonStubCSigns = kungfu::CommonStubCSigns; } while (false) // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) -#define CALL_PUSH_ARGS_I() \ +#define DEPRECATED_CALL_PUSH_ARGS_3() CALL_PUSH_ARGS_3() + +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define CALL_PUSH_ARGS_RANGE() \ + do { \ + if (UNLIKELY(thread->DoStackOverflowCheck(newSp - actualNumArgs))) { \ + INTERPRETER_GOTO_EXCEPTION_HANDLER(); \ + } \ + for (int i = actualNumArgs - 1; i >= 0; i--) { \ + *(--newSp) = sp[startReg + static_cast(i)]; \ + } \ + } while (false) + +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define DEPRECATED_CALL_PUSH_ARGS_RANGE() \ do { \ if (UNLIKELY(thread->DoStackOverflowCheck(newSp - actualNumArgs))) { \ INTERPRETER_GOTO_EXCEPTION_HANDLER(); \ } \ for (int i = actualNumArgs; i > 0; i--) { \ - *(--newSp) = sp[funcReg + static_cast(i)]; \ + *(--newSp) = sp[startReg + static_cast(i)]; \ + } \ + } while (false) + +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define CALL_PUSH_ARGS_THISRANGE() \ + do { \ + if (UNLIKELY(thread->DoStackOverflowCheck(newSp - actualNumArgs))) { \ + INTERPRETER_GOTO_EXCEPTION_HANDLER(); \ + } \ + /* 1: skip this */ \ + for (int i = actualNumArgs; i > 0; i--) { \ + *(--newSp) = sp[startReg + static_cast(i)]; \ } \ } while (false) // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) -#define CALL_PUSH_ARGS_I_THIS() \ +#define DEPRECATED_CALL_PUSH_ARGS_THISRANGE() \ do { \ if (UNLIKELY(thread->DoStackOverflowCheck(newSp - actualNumArgs))) { \ INTERPRETER_GOTO_EXCEPTION_HANDLER(); \ } \ /* 1: skip this */ \ for (int i = actualNumArgs + 1; i > 1; i--) { \ - *(--newSp) = sp[funcReg + static_cast(i)]; \ + *(--newSp) = sp[startReg + static_cast(i)]; \ } \ } while (false) @@ -258,6 +359,9 @@ using CommonStubCSigns = kungfu::CommonStubCSigns; /* do nothing when 0 arg */ \ } while (false) +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define DEPRECATED_CALL_PUSH_ARGS_0_NO_EXTRA() CALL_PUSH_ARGS_0_NO_EXTRA() + // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) #define CALL_PUSH_ARGS_1_NO_EXTRA() \ do { \ @@ -266,38 +370,72 @@ using CommonStubCSigns = kungfu::CommonStubCSigns; } \ } while (false) +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define DEPRECATED_CALL_PUSH_ARGS_1_NO_EXTRA() CALL_PUSH_ARGS_1_NO_EXTRA() + // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) #define CALL_PUSH_ARGS_2_NO_EXTRA() \ do { \ if (declaredNumArgs >= ActualNumArgsOfCall::CALLARGS2) { \ *(--newSp) = sp[a1]; \ } \ - CALL_PUSH_ARGS_1_NO_EXTRA(); \ + DEPRECATED_CALL_PUSH_ARGS_1_NO_EXTRA(); \ } while (false) +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define DEPRECATED_CALL_PUSH_ARGS_2_NO_EXTRA() CALL_PUSH_ARGS_2_NO_EXTRA() + // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) #define CALL_PUSH_ARGS_3_NO_EXTRA() \ do { \ if (declaredNumArgs >= ActualNumArgsOfCall::CALLARGS3) { \ *(--newSp) = sp[a2]; \ } \ - CALL_PUSH_ARGS_2_NO_EXTRA(); \ + DEPRECATED_CALL_PUSH_ARGS_2_NO_EXTRA(); \ + } while (false) + +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define DEPRECATED_CALL_PUSH_ARGS_3_NO_EXTRA() CALL_PUSH_ARGS_3_NO_EXTRA() + +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define CALL_PUSH_ARGS_RANGE_NO_EXTRA() \ + do { \ + int num = std::min(actualNumArgs, declaredNumArgs); \ + if (UNLIKELY(thread->DoStackOverflowCheck(newSp - num))) { \ + INTERPRETER_GOTO_EXCEPTION_HANDLER(); \ + } \ + for (int i = num - 1; i >= 0; i--) { \ + *(--newSp) = sp[startReg + static_cast(i)]; \ + } \ } while (false) // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) -#define CALL_PUSH_ARGS_I_NO_EXTRA() \ +#define DEPRECATED_CALL_PUSH_ARGS_RANGE_NO_EXTRA() \ do { \ int num = std::min(actualNumArgs, declaredNumArgs); \ if (UNLIKELY(thread->DoStackOverflowCheck(newSp - num))) { \ INTERPRETER_GOTO_EXCEPTION_HANDLER(); \ } \ for (int i = num; i > 0; i--) { \ - *(--newSp) = sp[funcReg + static_cast(i)]; \ + *(--newSp) = sp[startReg + static_cast(i)]; \ } \ } while (false) // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) -#define CALL_PUSH_ARGS_I_THIS_NO_EXTRA() \ +#define CALL_PUSH_ARGS_THISRANGE_NO_EXTRA() \ + do { \ + int num = std::min(actualNumArgs, declaredNumArgs); \ + if (UNLIKELY(thread->DoStackOverflowCheck(newSp - num))) { \ + INTERPRETER_GOTO_EXCEPTION_HANDLER(); \ + } \ + /* 1: skip this */ \ + for (int i = num; i > 0; i--) { \ + *(--newSp) = sp[startReg + static_cast(i)]; \ + } \ + } while (false) + +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define DEPRECATED_CALL_PUSH_ARGS_THISRANGE_NO_EXTRA() \ do { \ int num = std::min(actualNumArgs, declaredNumArgs); \ if (UNLIKELY(thread->DoStackOverflowCheck(newSp - num))) { \ @@ -305,7 +443,7 @@ using CommonStubCSigns = kungfu::CommonStubCSigns; } \ /* 1: skip this */ \ for (int i = num + 1; i > 1; i--) { \ - *(--newSp) = sp[funcReg + static_cast(i)]; \ + *(--newSp) = sp[startReg + static_cast(i)]; \ } \ } while (false) @@ -338,6 +476,35 @@ using CommonStubCSigns = kungfu::CommonStubCSigns; goto setVregsAndFrameNotNative; \ } while (false) +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define DEPRECATED_CALL_PUSH_ARGS(ARG_TYPE) \ + do { \ + if (methodHandle->IsNativeWithCallField()) { \ + /* native, just push all args directly */ \ + DEPRECATED_CALL_PUSH_ARGS_##ARG_TYPE(); \ + goto deprecatedSetVregsAndFrameNative; \ + } \ + int32_t declaredNumArgs = \ + static_cast(methodHandle->GetNumArgsWithCallField()); \ + if (actualNumArgs == declaredNumArgs) { \ + /* fast path, just push all args directly */ \ + DEPRECATED_CALL_PUSH_ARGS_##ARG_TYPE(); \ + goto deprecatedSetVregsAndFrameNotNative; \ + } \ + /* slow path */ \ + if (!methodHandle->HaveExtraWithCallField()) { \ + /* push length = declaredNumArgs, may push undefined */ \ + CALL_PUSH_UNDEFINED(declaredNumArgs - actualNumArgs); \ + DEPRECATED_CALL_PUSH_ARGS_##ARG_TYPE##_NO_EXTRA(); \ + } else { \ + /* push actualNumArgs in the end, then all args, may push undefined */ \ + *(--newSp) = JSTaggedValue(actualNumArgs).GetRawData(); \ + CALL_PUSH_UNDEFINED(declaredNumArgs - actualNumArgs); \ + DEPRECATED_CALL_PUSH_ARGS_##ARG_TYPE(); \ + } \ + goto deprecatedSetVregsAndFrameNotNative; \ + } while (false) + #if ECMASCRIPT_ENABLE_IC // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) #define UPDATE_HOTNESS_COUNTER_NON_ACC(offset) (UpdateHotnessCounter(thread, sp, acc, offset)) @@ -377,7 +544,9 @@ using CommonStubCSigns = kungfu::CommonStubCSigns; #define READ_INST_16_1() READ_INST_16(3) #define READ_INST_16_2() READ_INST_16(4) #define READ_INST_16_3() READ_INST_16(5) +#define READ_INST_16_4() READ_INST_16(6) #define READ_INST_16_5() READ_INST_16(7) +#define READ_INST_16_6() READ_INST_16(8) #define READ_INST_16(offset) \ ({ \ uint16_t currentInst = READ_INST_8(offset); \ @@ -613,8 +782,10 @@ JSTaggedValue EcmaInterpreter::GeneratorReEnterInterpreter(JSThread *thread, JSH } uint32_t pcOffset = context->GetBCOffset(); // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + // TODO: how to modify for first level inst??? + // check pandafile version ? const uint8_t *resumePc = method->GetBytecodeArray() + pcOffset + - BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_V8_V8); + BytecodeInstruction::Size(EcmaOpcode::DEPRECATED_SUSPENDGENERATOR_PREF_V8_V8); InterpretedFrame *state = GET_FRAME(newSp); state->pc = resumePc; @@ -708,69 +879,96 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t JSMutableHandle methodHandle(thread, JSTaggedValue::Undefined()); constexpr size_t numOps = 0x100; + constexpr size_t numThrowOps = 9; + constexpr size_t numWideOps = 18; + constexpr size_t numDeprecatedOps = 51; + static std::array instDispatchTable { #include "templates/instruction_dispatch.inl" }; + static std::array throwDispatchTable { +#include "templates/throw_instruction_dispatch.inl" + }; + + static std::array wideDispatchTable { +#include "templates/wide_instruction_dispatch.inl" + }; + + static std::array deprecatedDispatchTable { +#include "templates/deprecated_instruction_dispatch.inl" + }; + static std::array debugDispatchTable { #include "templates/debugger_instruction_dispatch.inl" }; + static std::array throwDebugDispatchTable { +#include "templates/debugger_throw_instruction_dispatch.inl" + }; + + static std::array wideDebugDispatchTable { +#include "templates/debugger_wide_instruction_dispatch.inl" + }; + + static std::array deprecatedDebugDispatchTable { +#include "templates/debugger_deprecated_instruction_dispatch.inl" + }; + auto *dispatchTable = instDispatchTable.data(); CHECK_SWITCH_TO_DEBUGGER_TABLE(); goto *dispatchTable[opcode]; - HANDLE_OPCODE(HANDLE_MOV_V4_V4) { + HANDLE_OPCODE(MOV_V4_V4) { uint16_t vdst = READ_INST_4_0(); uint16_t vsrc = READ_INST_4_1(); LOG_INST() << "mov v" << vdst << ", v" << vsrc; uint64_t value = GET_VREG(vsrc); SET_VREG(vdst, value) - DISPATCH(BytecodeInstruction::Format::V4_V4); + DISPATCH(MOV_V4_V4); } - - HANDLE_OPCODE(HANDLE_MOV_DYN_V8_V8) { + HANDLE_OPCODE(MOV_V8_V8) { uint16_t vdst = READ_INST_8_0(); uint16_t vsrc = READ_INST_8_1(); - LOG_INST() << "mov.dyn v" << vdst << ", v" << vsrc; + LOG_INST() << "mov v" << vdst << ", v" << vsrc; uint64_t value = GET_VREG(vsrc); SET_VREG(vdst, value) - DISPATCH(BytecodeInstruction::Format::V8_V8); + DISPATCH(MOV_V8_V8); } - HANDLE_OPCODE(HANDLE_MOV_DYN_V16_V16) { + HANDLE_OPCODE(MOV_V16_V16) { uint16_t vdst = READ_INST_16_0(); uint16_t vsrc = READ_INST_16_2(); - LOG_INST() << "mov.dyn v" << vdst << ", v" << vsrc; + LOG_INST() << "mov v" << vdst << ", v" << vsrc; uint64_t value = GET_VREG(vsrc); SET_VREG(vdst, value) - DISPATCH(BytecodeInstruction::Format::V16_V16); + DISPATCH(MOV_V16_V16); } - HANDLE_OPCODE(HANDLE_LDA_STR_ID32) { - uint32_t stringId = READ_INST_32_0(); + HANDLE_OPCODE(LDA_STR_ID16) { + uint16_t stringId = READ_INST_16_0(); LOG_INST() << "lda.str " << std::hex << stringId; SET_ACC(GET_OBJ_FROM_CACHE(stringId)); - DISPATCH(BytecodeInstruction::Format::ID32); + DISPATCH(LDA_STR_ID16); } - HANDLE_OPCODE(HANDLE_JMP_IMM8) { - int8_t offset = static_cast(READ_INST_8_0()); + HANDLE_OPCODE(JMP_IMM8) { + int8_t offset = READ_INST_8_0(); UPDATE_HOTNESS_COUNTER(offset); LOG_INST() << "jmp " << std::hex << static_cast(offset); DISPATCH_OFFSET(offset); } - HANDLE_OPCODE(HANDLE_JMP_IMM16) { - int16_t offset = static_cast(READ_INST_16_0()); + HANDLE_OPCODE(JMP_IMM16) { + int16_t offset = READ_INST_16_0(); UPDATE_HOTNESS_COUNTER(offset); LOG_INST() << "jmp " << std::hex << static_cast(offset); DISPATCH_OFFSET(offset); } - HANDLE_OPCODE(HANDLE_JMP_IMM32) { - int32_t offset = static_cast(READ_INST_32_0()); + HANDLE_OPCODE(JMP_IMM32) { + int32_t offset = READ_INST_32_0(); UPDATE_HOTNESS_COUNTER(offset); LOG_INST() << "jmp " << std::hex << offset; DISPATCH_OFFSET(offset); } - HANDLE_OPCODE(HANDLE_JEQZ_IMM8) { - int8_t offset = static_cast(READ_INST_8_0()); + HANDLE_OPCODE(JEQZ_IMM8) { + int8_t offset = READ_INST_8_0(); LOG_INST() << "jeqz ->\t" << "cond jmpz " << std::hex << static_cast(offset); if (GET_ACC() == JSTaggedValue::False() || (GET_ACC().IsInt() && GET_ACC().GetInt() == 0) || @@ -778,11 +976,11 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t UPDATE_HOTNESS_COUNTER(offset); DISPATCH_OFFSET(offset); } else { - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(JEQZ_IMM8); } } - HANDLE_OPCODE(HANDLE_JEQZ_IMM16) { - int16_t offset = static_cast(READ_INST_16_0()); + HANDLE_OPCODE(JEQZ_IMM16) { + int16_t offset = READ_INST_16_0(); LOG_INST() << "jeqz ->\t" << "cond jmpz " << std::hex << static_cast(offset); if (GET_ACC() == JSTaggedValue::False() || (GET_ACC().IsInt() && GET_ACC().GetInt() == 0) || @@ -790,11 +988,11 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t UPDATE_HOTNESS_COUNTER(offset); DISPATCH_OFFSET(offset); } else { - DISPATCH(BytecodeInstruction::Format::IMM16); + DISPATCH(JEQZ_IMM16); } } - HANDLE_OPCODE(HANDLE_JNEZ_IMM8) { - int8_t offset = static_cast(READ_INST_8_0()); + HANDLE_OPCODE(JNEZ_IMM8) { + int8_t offset = READ_INST_8_0(); LOG_INST() << "jnez ->\t" << "cond jmpz " << std::hex << static_cast(offset); if (GET_ACC() == JSTaggedValue::True() || (GET_ACC().IsInt() && GET_ACC().GetInt() != 0) || @@ -802,11 +1000,11 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t UPDATE_HOTNESS_COUNTER(offset); DISPATCH_OFFSET(offset); } else { - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(JNEZ_IMM8); } } - HANDLE_OPCODE(HANDLE_JNEZ_IMM16) { - int16_t offset = static_cast(READ_INST_16_0()); + HANDLE_OPCODE(JNEZ_IMM16) { + int16_t offset = READ_INST_16_0(); LOG_INST() << "jnez ->\t" << "cond jmpz " << std::hex << static_cast(offset); if (GET_ACC() == JSTaggedValue::True() || (GET_ACC().IsInt() && GET_ACC().GetInt() != 0) || @@ -814,121 +1012,213 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t UPDATE_HOTNESS_COUNTER(offset); DISPATCH_OFFSET(offset); } else { - DISPATCH(BytecodeInstruction::Format::IMM16); + DISPATCH(JNEZ_IMM16); } } - HANDLE_OPCODE(HANDLE_LDA_DYN_V8) { + HANDLE_OPCODE(LDA_V8) { uint16_t vsrc = READ_INST_8_0(); - LOG_INST() << "lda.dyn v" << vsrc; + LOG_INST() << "lda v" << vsrc; uint64_t value = GET_VREG(vsrc); - SET_ACC(JSTaggedValue(value)) - DISPATCH(BytecodeInstruction::Format::V8); + SET_ACC(JSTaggedValue(value)); + DISPATCH(LDA_V8); } - HANDLE_OPCODE(HANDLE_STA_DYN_V8) { + HANDLE_OPCODE(STA_V8) { uint16_t vdst = READ_INST_8_0(); - LOG_INST() << "sta.dyn v" << vdst; + LOG_INST() << "sta v" << vdst; SET_VREG(vdst, GET_ACC().GetRawData()) - DISPATCH(BytecodeInstruction::Format::V8); + DISPATCH(STA_V8); } - HANDLE_OPCODE(HANDLE_LDAI_DYN_IMM32) { - int32_t imm = static_cast(READ_INST_32_0()); - LOG_INST() << "ldai.dyn " << std::hex << imm; - SET_ACC(JSTaggedValue(imm)) - DISPATCH(BytecodeInstruction::Format::IMM32); + HANDLE_OPCODE(LDAI_IMM32) { + int32_t imm = READ_INST_32_0(); + LOG_INST() << "ldai " << std::hex << imm; + SET_ACC(JSTaggedValue(imm)); + DISPATCH(LDAI_IMM32); } - HANDLE_OPCODE(HANDLE_FLDAI_DYN_IMM64) { + HANDLE_OPCODE(FLDAI_IMM64) { auto imm = bit_cast(READ_INST_64_0()); - LOG_INST() << "fldai.dyn " << imm; - SET_ACC(JSTaggedValue(imm)) - DISPATCH(BytecodeInstruction::Format::IMM64); + LOG_INST() << "fldai " << imm; + SET_ACC(JSTaggedValue(imm)); + DISPATCH(FLDAI_IMM64); } { int32_t actualNumArgs; - uint32_t funcReg; + int32_t startReg; JSTaggedType funcTagged; ECMAObject *funcObject; JSTaggedType *newSp; bool callThis; - HANDLE_OPCODE(HANDLE_CALLARG0DYN_PREF_V8) { + HANDLE_OPCODE(CALLARG0_IMM8) { actualNumArgs = ActualNumArgsOfCall::CALLARG0; - funcReg = READ_INST_8_1(); - LOG_INST() << "callarg0.dyn " - << "v" << funcReg; + LOG_INST() << "callarg0"; CALL_INITIALIZE(); callThis = false; - CALL_PUSH_ARGS(0); + DEPRECATED_CALL_PUSH_ARGS(0); + } + HANDLE_OPCODE(DEPRECATED_CALLARG0_PREF_V8) { + actualNumArgs = ActualNumArgsOfCall::CALLARG0; + startReg = READ_INST_8_1(); + LOG_INST() << "callarg0 " + << "v" << startReg; + DEPRECATED_CALL_INITIALIZE(); + callThis = false; + DEPRECATED_CALL_PUSH_ARGS(0); } - HANDLE_OPCODE(HANDLE_CALLARG1DYN_PREF_V8_V8) { + HANDLE_OPCODE(CALLARG1_IMM8_V8) { actualNumArgs = ActualNumArgsOfCall::CALLARG1; - funcReg = READ_INST_8_1(); - uint8_t a0 = READ_INST_8_2(); - LOG_INST() << "callarg1.dyn " - << "v" << funcReg << ", v" << a0; + uint8_t a0 = READ_INST_8_1(); + LOG_INST() << "callarg1 " + << "v" << a0; CALL_INITIALIZE(); callThis = false; CALL_PUSH_ARGS(1); } - HANDLE_OPCODE(HANDLE_CALLARGS2DYN_PREF_V8_V8_V8) { + HANDLE_OPCODE(DEPRECATED_CALLARG1_PREF_V8_V8) { + actualNumArgs = ActualNumArgsOfCall::CALLARG1; + startReg = READ_INST_8_1(); + uint8_t a0 = READ_INST_8_2(); + LOG_INST() << "callarg1 " + << "v" << startReg << ", v" << a0; + DEPRECATED_CALL_INITIALIZE(); + callThis = false; + DEPRECATED_CALL_PUSH_ARGS(1); + } + HANDLE_OPCODE(CALLARGS2_IMM8_V8_V8) { + actualNumArgs = ActualNumArgsOfCall::CALLARGS2; + uint8_t a0 = READ_INST_8_1(); + uint8_t a1 = READ_INST_8_2(); + LOG_INST() << "callargs2 " + << "v" << a0 << ", v" << a1; + CALL_INITIALIZE(); + callThis = false; + CALL_PUSH_ARGS(2); + } + HANDLE_OPCODE(DEPRECATED_CALLARGS2_PREF_V8_V8_V8) { actualNumArgs = ActualNumArgsOfCall::CALLARGS2; - funcReg = READ_INST_8_1(); + startReg = READ_INST_8_1(); uint8_t a0 = READ_INST_8_2(); uint8_t a1 = READ_INST_8_3(); - LOG_INST() << "callargs2.dyn " - << "v" << funcReg << ", v" << a0 << ", v" << a1; + LOG_INST() << "callargs2 " + << "v" << startReg << ", v" << a0 << ", v" << a1; + DEPRECATED_CALL_INITIALIZE(); + callThis = false; + DEPRECATED_CALL_PUSH_ARGS(2); + } + HANDLE_OPCODE(CALLARGS3_IMM8_V8_V8_V8) { + actualNumArgs = ActualNumArgsOfCall::CALLARGS3; + uint8_t a0 = READ_INST_8_1(); + uint8_t a1 = READ_INST_8_2(); + uint8_t a2 = READ_INST_8_3(); + LOG_INST() << "callargs3 " + << "v" << a0 << ", v" << a1 << ", v" << a2; CALL_INITIALIZE(); callThis = false; + CALL_PUSH_ARGS(3); + } + HANDLE_OPCODE(DEPRECATED_CALLARGS3_PREF_V8_V8_V8_V8) { + actualNumArgs = ActualNumArgsOfCall::CALLARGS3; + startReg = READ_INST_8_1(); + uint8_t a0 = READ_INST_8_2(); + uint8_t a1 = READ_INST_8_3(); + uint8_t a2 = READ_INST_8_4(); + LOG_INST() << "callargs3 " + << "v" << startReg << ", v" << a0 << ", v" << a1 << ", v" << a2; + DEPRECATED_CALL_INITIALIZE(); + callThis = false; + DEPRECATED_CALL_PUSH_ARGS(3); + } + HANDLE_OPCODE(CALLTHIS0_IMM8_V8) { + actualNumArgs = ActualNumArgsOfCall::CALLARG0; + startReg = READ_INST_8_1(); + LOG_INST() << "call.this0, v" << startReg; + CALL_INITIALIZE(); + callThis = true; + CALL_PUSH_ARGS(0); + } + HANDLE_OPCODE(CALLTHIS1_IMM8_V8_V8) { + actualNumArgs = ActualNumArgsOfCall::CALLARG1; + startReg = READ_INST_8_1(); + uint8_t a0 = READ_INST_8_2(); + LOG_INST() << "call.this1, v" << startReg << " v" << a0; + CALL_INITIALIZE(); + callThis = true; + CALL_PUSH_ARGS(1); + } + HANDLE_OPCODE(CALLTHIS2_IMM8_V8_V8_V8) { + actualNumArgs = ActualNumArgsOfCall::CALLARGS2; + startReg = READ_INST_8_1(); + uint8_t a0 = READ_INST_8_2(); + uint8_t a1 = READ_INST_8_3(); + LOG_INST() << "call.this2, v" << startReg << " v" << a0 << " v" << a1; + CALL_INITIALIZE(); + callThis = true; CALL_PUSH_ARGS(2); } - HANDLE_OPCODE(HANDLE_CALLARGS3DYN_PREF_V8_V8_V8_V8) { + HANDLE_OPCODE(CALLTHIS3_IMM8_V8_V8_V8_V8) { actualNumArgs = ActualNumArgsOfCall::CALLARGS3; - funcReg = READ_INST_8_1(); + startReg = READ_INST_8_1(); uint8_t a0 = READ_INST_8_2(); uint8_t a1 = READ_INST_8_3(); uint8_t a2 = READ_INST_8_4(); - LOG_INST() << "callargs3.dyn " - << "v" << funcReg << ", v" << a0 << ", v" << a1 << ", v" << a2; + LOG_INST() << "call.this3, v" << startReg << " v" << a0 << " v" << a1 << " v" << a2; CALL_INITIALIZE(); - callThis = false; + callThis = true; CALL_PUSH_ARGS(3); } - HANDLE_OPCODE(HANDLE_CALLITHISRANGEDYN_PREF_IMM16_V8) { + HANDLE_OPCODE(CALLTHISRANGE_IMM8_IMM8_V8) { + actualNumArgs = static_cast(READ_INST_8_1() - 1); // 1: exclude this + startReg = READ_INST_8_2(); + LOG_INST() << "call.this.range " << actualNumArgs << ", v" << startReg; + CALL_INITIALIZE(); + callThis = true; + CALL_PUSH_ARGS(THISRANGE); + } + HANDLE_OPCODE(WIDE_CALLTHISRANGE_PREF_IMM16_V8) { actualNumArgs = static_cast(READ_INST_16_1() - 1); // 1: exclude this - funcReg = READ_INST_8_3(); - LOG_INST() << "calli.dyn.this.range " << actualNumArgs << ", v" << funcReg; + startReg = READ_INST_8_3(); + LOG_INST() << "call.this.range " << actualNumArgs << ", v" << startReg; CALL_INITIALIZE(); callThis = true; - CALL_PUSH_ARGS(I_THIS); - } - HANDLE_OPCODE(HANDLE_CALLSPREADDYN_PREF_V8_V8_V8) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - uint16_t v2 = READ_INST_8_3(); - LOG_INST() << "intrinsics::callspreaddyn" - << " v" << v0 << " v" << v1 << " v" << v2; - JSTaggedValue func = GET_VREG_VALUE(v0); - JSTaggedValue obj = GET_VREG_VALUE(v1); - JSTaggedValue array = GET_VREG_VALUE(v2); - - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::CallSpreadDyn(thread, func, obj, array); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8_V8); + CALL_PUSH_ARGS(THISRANGE); + } + HANDLE_OPCODE(DEPRECATED_CALLTHISRANGE_PREF_IMM16_V8) { + actualNumArgs = static_cast(READ_INST_16_1() - 1); // 1: exclude this + startReg = READ_INST_8_3(); + LOG_INST() << "call.this.range " << actualNumArgs << ", v" << startReg; + DEPRECATED_CALL_INITIALIZE(); + callThis = true; + DEPRECATED_CALL_PUSH_ARGS(THISRANGE); + } + HANDLE_OPCODE(CALLRANGE_IMM8_IMM8_V8) { + actualNumArgs = READ_INST_8_1(); + startReg = READ_INST_8_2(); + LOG_INST() << "calli.range " << actualNumArgs << ", v" << startReg; + CALL_INITIALIZE(); + callThis = false; + CALL_PUSH_ARGS(RANGE); } - HANDLE_OPCODE(HANDLE_CALLIRANGEDYN_PREF_IMM16_V8) { - actualNumArgs = static_cast(READ_INST_16_1()); - funcReg = READ_INST_8_3(); - LOG_INST() << "calli.rangedyn " << actualNumArgs << ", v" << funcReg; + HANDLE_OPCODE(WIDE_CALLRANGE_PREF_IMM16_V8) { + actualNumArgs = READ_INST_16_1(); + startReg = READ_INST_8_3(); + LOG_INST() << "calli.range " << actualNumArgs << ", v" << startReg; CALL_INITIALIZE(); callThis = false; - CALL_PUSH_ARGS(I); + CALL_PUSH_ARGS(RANGE); + } + HANDLE_OPCODE(DEPRECATED_CALLRANGE_PREF_IMM16_V8) { + actualNumArgs = READ_INST_16_1(); + startReg = READ_INST_8_3(); + LOG_INST() << "calli.range " << actualNumArgs << ", v" << startReg; + DEPRECATED_CALL_INITIALIZE(); + callThis = false; + DEPRECATED_CALL_PUSH_ARGS(RANGE); } - setVregsAndFrameNative: { + setVregsAndFrameNative: + startReg--; + deprecatedSetVregsAndFrameNative: { // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - *(--newSp) = (callThis ? sp[funcReg + callThis] : JSTaggedValue::VALUE_UNDEFINED); // push this + *(--newSp) = (callThis ? sp[startReg + 1] : JSTaggedValue::VALUE_UNDEFINED); // push this *(--newSp) = JSTaggedValue::VALUE_UNDEFINED; // push new target *(--newSp) = ToUintPtr(funcObject); // push func ASSERT(methodHandle->GetNumVregsWithCallField() == 0); // no need to push vregs @@ -954,7 +1244,9 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t SET_ACC(retValue); INTERPRETER_HANDLE_RETURN(); } - setVregsAndFrameNotNative: { + setVregsAndFrameNotNative: + startReg--; + deprecatedSetVregsAndFrameNotNative: { if (JSFunction::Cast(funcObject)->IsClassConstructor()) { { [[maybe_unused]] EcmaHandleScope handleScope(thread); @@ -969,7 +1261,7 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t // not normal call type, setting func/newTarget/this cannot be skipped if (methodHandle->HaveThisWithCallField()) { // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - *(--newSp) = (callThis ? sp[funcReg + callThis] : JSTaggedValue::VALUE_UNDEFINED); // push this + *(--newSp) = (callThis ? sp[startReg + 1] : JSTaggedValue::VALUE_UNDEFINED); // push this } if (methodHandle->HaveNewTargetWithCallField()) { // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) @@ -1005,8 +1297,41 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t DISPATCH_OFFSET(0); } } - HANDLE_OPCODE(HANDLE_RETURN_DYN) { - LOG_INST() << "return.dyn"; + HANDLE_OPCODE(APPLY_IMM8_V8_V8) { + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); + LOG_INST() << "intrinsics::callspread" + << " v" << v0 << " v" << v1; + JSTaggedValue func = GET_ACC(); + JSTaggedValue obj = GET_VREG_VALUE(v0); + JSTaggedValue array = GET_VREG_VALUE(v1); + + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::CallSpread(thread, func, obj, array); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + + DISPATCH(APPLY_IMM8_V8_V8); + } + HANDLE_OPCODE(DEPRECATED_CALLSPREAD_PREF_V8_V8_V8) { + uint16_t v0 = READ_INST_8_1(); + uint16_t v1 = READ_INST_8_2(); + uint16_t v2 = READ_INST_8_3(); + LOG_INST() << "intrinsics::callspread" + << " v" << v0 << " v" << v1 << " v" << v2; + JSTaggedValue func = GET_VREG_VALUE(v0); + JSTaggedValue obj = GET_VREG_VALUE(v1); + JSTaggedValue array = GET_VREG_VALUE(v2); + + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::CallSpread(thread, func, obj, array); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + + DISPATCH(DEPRECATED_CALLSPREAD_PREF_V8_V8_V8); + } + HANDLE_OPCODE(RETURN) { + LOG_INST() << "return"; InterpretedFrame *state = GET_FRAME(sp); LOG_INST() << "Exit: Runtime Call " << std::hex << reinterpret_cast(sp) << " " << std::hex << reinterpret_cast(state->pc); @@ -1052,7 +1377,7 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t } INTERPRETER_HANDLE_RETURN(); } - HANDLE_OPCODE(HANDLE_RETURNUNDEFINED_PREF) { + HANDLE_OPCODE(RETURNUNDEFINED) { LOG_INST() << "return.undefined"; InterpretedFrame *state = GET_FRAME(sp); LOG_INST() << "Exit: Runtime Call " << std::hex << reinterpret_cast(sp) << " " @@ -1097,59 +1422,52 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t } INTERPRETER_HANDLE_RETURN(); } - HANDLE_OPCODE(HANDLE_LDNAN_PREF) { + HANDLE_OPCODE(LDNAN) { LOG_INST() << "intrinsics::ldnan"; SET_ACC(JSTaggedValue(base::NAN_VALUE)); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(LDNAN); } - HANDLE_OPCODE(HANDLE_LDINFINITY_PREF) { + HANDLE_OPCODE(LDINFINITY) { LOG_INST() << "intrinsics::ldinfinity"; SET_ACC(JSTaggedValue(base::POSITIVE_INFINITY)); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(LDINFINITY); } - HANDLE_OPCODE(HANDLE_LDGLOBALTHIS_PREF) { + HANDLE_OPCODE(LDGLOBALTHIS) { LOG_INST() << "intrinsics::ldglobalthis"; - SET_ACC(globalObj) - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + SET_ACC(globalObj); + DISPATCH(LDGLOBALTHIS); } - HANDLE_OPCODE(HANDLE_LDUNDEFINED_PREF) { + HANDLE_OPCODE(LDUNDEFINED) { LOG_INST() << "intrinsics::ldundefined"; - SET_ACC(JSTaggedValue::Undefined()) - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + SET_ACC(JSTaggedValue::Undefined()); + DISPATCH(LDUNDEFINED); } - HANDLE_OPCODE(HANDLE_LDNULL_PREF) { + HANDLE_OPCODE(LDNULL) { LOG_INST() << "intrinsics::ldnull"; - SET_ACC(JSTaggedValue::Null()) - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + SET_ACC(JSTaggedValue::Null()); + DISPATCH(LDNULL); } - HANDLE_OPCODE(HANDLE_LDSYMBOL_PREF) { + HANDLE_OPCODE(LDSYMBOL) { LOG_INST() << "intrinsics::ldsymbol"; SET_ACC(globalEnv->GetSymbolFunction().GetTaggedValue()); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(LDSYMBOL); } - HANDLE_OPCODE(HANDLE_LDGLOBAL_PREF) { + HANDLE_OPCODE(LDGLOBAL) { LOG_INST() << "intrinsics::ldglobal"; - SET_ACC(globalObj) - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + SET_ACC(globalObj); + DISPATCH(LDGLOBAL); } - HANDLE_OPCODE(HANDLE_LDTRUE_PREF) { + HANDLE_OPCODE(LDTRUE) { LOG_INST() << "intrinsics::ldtrue"; - SET_ACC(JSTaggedValue::True()) - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + SET_ACC(JSTaggedValue::True()); + DISPATCH(LDTRUE); } - HANDLE_OPCODE(HANDLE_LDFALSE_PREF) { + HANDLE_OPCODE(LDFALSE) { LOG_INST() << "intrinsics::ldfalse"; - SET_ACC(JSTaggedValue::False()) - DISPATCH(BytecodeInstruction::Format::PREF_NONE); - } - HANDLE_OPCODE(HANDLE_LDLEXENVDYN_PREF) { - LOG_INST() << "intrinsics::ldlexenvDyn "; - InterpretedFrame *state = GET_FRAME(sp); - JSTaggedValue currentLexenv = state->env; - SET_ACC(currentLexenv); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + SET_ACC(JSTaggedValue::False()); + DISPATCH(LDFALSE); } - HANDLE_OPCODE(HANDLE_GETUNMAPPEDARGS_PREF) { + HANDLE_OPCODE(GETUNMAPPEDARGS) { LOG_INST() << "intrinsics::getunmappedargs"; uint32_t startIdx = 0; @@ -1159,252 +1477,66 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t JSTaggedValue res = SlowRuntimeStub::GetUnmapedArgs(thread, sp, actualNumArgs, startIdx); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(GETUNMAPPEDARGS); } - HANDLE_OPCODE(HANDLE_ASYNCFUNCTIONENTER_PREF) { + HANDLE_OPCODE(ASYNCFUNCTIONENTER) { LOG_INST() << "intrinsics::asyncfunctionenter"; SAVE_PC(); JSTaggedValue res = SlowRuntimeStub::AsyncFunctionEnter(thread); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(ASYNCFUNCTIONENTER); + } + HANDLE_OPCODE(TYPEOF_IMM8) { + LOG_INST() << "intrinsics::typeof"; + JSTaggedValue res = FastRuntimeStub::FastTypeOf(thread, GET_ACC()); + SET_ACC(res); + DISPATCH(TYPEOF_IMM8); + } + HANDLE_OPCODE(GETPROPITERATOR) { + LOG_INST() << "intrinsics::getpropiterator"; + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::GetPropIterator(thread, GET_ACC()); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(GETPROPITERATOR); } - HANDLE_OPCODE(HANDLE_TONUMBER_PREF_V8) { + HANDLE_OPCODE(GETITERATOR_IMM8) { + LOG_INST() << "intrinsics::getiterator"; + JSTaggedValue obj = GET_ACC(); + // slow path + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::GetIterator(thread, obj); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(GETITERATOR_IMM8); + } + // TODO + // HANDLE_OPCODE(ITERNEXT_IMM8_V8) { + // uint16_t v0 = READ_INST_8_1(); + // LOG_INST() << "intrinsics::iternext" + // << " v" << v0; + // SAVE_PC(); + // JSTaggedValue iter = GET_VREG_VALUE(v0); + // JSTaggedValue res = SlowRuntimeStub::IterNext(thread, iter); + // INTERPRETER_RETURN_IF_ABRUPT(res); + // SET_ACC(res); + // DISPATCH(ITERNEXT_IMM8_V8); + // } + HANDLE_OPCODE(CLOSEITERATOR_IMM8_V8) { uint16_t v0 = READ_INST_8_1(); - - LOG_INST() << "intrinsics::tonumber" + LOG_INST() << "intrinsics::closeiterator" << " v" << v0; - JSTaggedValue value = GET_VREG_VALUE(v0); - if (value.IsNumber()) { - // fast path - SET_ACC(value); - } else { - // slow path - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::ToNumber(thread, value); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + SAVE_PC(); + JSTaggedValue iter = GET_VREG_VALUE(v0); + JSTaggedValue res = SlowRuntimeStub::CloseIterator(thread, iter); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(CLOSEITERATOR_IMM8_V8); } - HANDLE_OPCODE(HANDLE_NEGDYN_PREF_V8) { + HANDLE_OPCODE(ADD2_IMM8_V8) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::negdyn" - << " v" << v0; - JSTaggedValue value = GET_VREG_VALUE(v0); - // fast path - if (value.IsInt()) { - if (value.GetInt() == 0) { - SET_ACC(JSTaggedValue(-0.0)); - } else { - SET_ACC(JSTaggedValue(-value.GetInt())); - } - } else if (value.IsDouble()) { - SET_ACC(JSTaggedValue(-value.GetDouble())); - } else { // slow path - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::NegDyn(thread, value); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - } - DISPATCH(BytecodeInstruction::Format::PREF_V8); - } - HANDLE_OPCODE(HANDLE_NOTDYN_PREF_V8) { - uint16_t v0 = READ_INST_8_1(); - - LOG_INST() << "intrinsics::notdyn" - << " v" << v0; - JSTaggedValue value = GET_VREG_VALUE(v0); - int32_t number; - // number, fast path - if (value.IsInt()) { - number = static_cast(value.GetInt()); - SET_ACC(JSTaggedValue(~number)); // NOLINT(hicpp-signed-bitwise) - } else if (value.IsDouble()) { - number = base::NumberHelper::DoubleToInt(value.GetDouble(), base::INT32_BITS); - SET_ACC(JSTaggedValue(~number)); // NOLINT(hicpp-signed-bitwise) - } else { - // slow path - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::NotDyn(thread, value); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - } - DISPATCH(BytecodeInstruction::Format::PREF_V8); - } - HANDLE_OPCODE(HANDLE_INCDYN_PREF_V8) { - uint16_t v0 = READ_INST_8_1(); - - LOG_INST() << "intrinsics::incdyn" - << " v" << v0; - - JSTaggedValue value = GET_VREG_VALUE(v0); - // number fast path - if (value.IsInt()) { - int32_t a0 = value.GetInt(); - if (UNLIKELY(a0 == INT32_MAX)) { - auto ret = static_cast(a0) + 1.0; - SET_ACC(JSTaggedValue(ret)) - } else { - SET_ACC(JSTaggedValue(a0 + 1)) - } - } else if (value.IsDouble()) { - SET_ACC(JSTaggedValue(value.GetDouble() + 1.0)) - } else { - // slow path - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::IncDyn(thread, value); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - } - DISPATCH(BytecodeInstruction::Format::PREF_V8); - } - HANDLE_OPCODE(HANDLE_DECDYN_PREF_V8) { - uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::decdyn" - << " v" << v0; - - JSTaggedValue value = GET_VREG_VALUE(v0); - // number, fast path - if (value.IsInt()) { - int32_t a0 = value.GetInt(); - if (UNLIKELY(a0 == INT32_MIN)) { - auto ret = static_cast(a0) - 1.0; - SET_ACC(JSTaggedValue(ret)) - } else { - SET_ACC(JSTaggedValue(a0 - 1)) - } - } else if (value.IsDouble()) { - SET_ACC(JSTaggedValue(value.GetDouble() - 1.0)) - } else { - // slow path - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::DecDyn(thread, value); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - } - DISPATCH(BytecodeInstruction::Format::PREF_V8); - } - HANDLE_OPCODE(HANDLE_THROWDYN_PREF) { - LOG_INST() << "intrinsics::throwdyn"; - SAVE_PC(); - SlowRuntimeStub::ThrowDyn(thread, GET_ACC()); - INTERPRETER_GOTO_EXCEPTION_HANDLER(); - } - HANDLE_OPCODE(HANDLE_TYPEOFDYN_PREF) { - LOG_INST() << "intrinsics::typeofdyn"; - JSTaggedValue res = FastRuntimeStub::FastTypeOf(thread, GET_ACC()); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); - } - HANDLE_OPCODE(HANDLE_GETPROPITERATOR_PREF) { - LOG_INST() << "intrinsics::getpropiterator"; - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::GetPropIterator(thread, GET_ACC()); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); - } - HANDLE_OPCODE(HANDLE_RESUMEGENERATOR_PREF_V8) { - LOG_INST() << "intrinsics::resumegenerator"; - uint16_t vs = READ_INST_8_1(); - JSTaggedValue objVal = GET_VREG_VALUE(vs); - - if (objVal.IsAsyncGeneratorObject()) { - JSAsyncGeneratorObject *obj = JSAsyncGeneratorObject::Cast(objVal.GetTaggedObject()); - SET_ACC(obj->GetResumeResult()); - } else { - JSGeneratorObject *obj = JSGeneratorObject::Cast(objVal.GetTaggedObject()); - SET_ACC(obj->GetResumeResult()); - } - DISPATCH(BytecodeInstruction::Format::PREF_V8); - } - HANDLE_OPCODE(HANDLE_GETRESUMEMODE_PREF_V8) { - LOG_INST() << "intrinsics::getresumemode"; - uint16_t vs = READ_INST_8_1(); - JSTaggedValue objVal = GET_VREG_VALUE(vs); - - if (objVal.IsAsyncGeneratorObject()) { - JSAsyncGeneratorObject *obj = JSAsyncGeneratorObject::Cast(objVal.GetTaggedObject()); - SET_ACC(JSTaggedValue(static_cast(obj->GetResumeMode()))); - } else { - JSGeneratorObject *obj = JSGeneratorObject::Cast(objVal.GetTaggedObject()); - SET_ACC(JSTaggedValue(static_cast(obj->GetResumeMode()))); - } - DISPATCH(BytecodeInstruction::Format::PREF_V8); - } - HANDLE_OPCODE(HANDLE_GETITERATOR_PREF) { - LOG_INST() << "intrinsics::getiterator"; - JSTaggedValue obj = GET_ACC(); - // slow path - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::GetIterator(thread, obj); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); - } - HANDLE_OPCODE(HANDLE_THROWCONSTASSIGNMENT_PREF_V8) { - uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "throwconstassignment" - << " v" << v0; - SAVE_PC(); - SlowRuntimeStub::ThrowConstAssignment(thread, GET_VREG_VALUE(v0)); - INTERPRETER_GOTO_EXCEPTION_HANDLER(); - } - HANDLE_OPCODE(HANDLE_THROWTHROWNOTEXISTS_PREF) { - LOG_INST() << "throwthrownotexists"; - - SAVE_PC(); - SlowRuntimeStub::ThrowThrowNotExists(thread); - INTERPRETER_GOTO_EXCEPTION_HANDLER(); - } - HANDLE_OPCODE(HANDLE_THROWPATTERNNONCOERCIBLE_PREF) { - LOG_INST() << "throwpatternnoncoercible"; - - SAVE_PC(); - SlowRuntimeStub::ThrowPatternNonCoercible(thread); - INTERPRETER_GOTO_EXCEPTION_HANDLER(); - } - HANDLE_OPCODE(HANDLE_THROWIFNOTOBJECT_PREF_V8) { - LOG_INST() << "throwifnotobject"; - uint16_t v0 = READ_INST_8_1(); - - JSTaggedValue value = GET_VREG_VALUE(v0); - // fast path - if (value.IsECMAObject()) { - DISPATCH(BytecodeInstruction::Format::PREF_V8); - } - - // slow path - SAVE_PC(); - SlowRuntimeStub::ThrowIfNotObject(thread); - INTERPRETER_GOTO_EXCEPTION_HANDLER(); - } - HANDLE_OPCODE(HANDLE_ITERNEXT_PREF_V8) { - uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::iternext" - << " v" << v0; - SAVE_PC(); - JSTaggedValue iter = GET_VREG_VALUE(v0); - JSTaggedValue res = SlowRuntimeStub::IterNext(thread, iter); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8); - } - HANDLE_OPCODE(HANDLE_CLOSEITERATOR_PREF_V8) { - uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::closeiterator" - << " v" << v0; - SAVE_PC(); - JSTaggedValue iter = GET_VREG_VALUE(v0); - JSTaggedValue res = SlowRuntimeStub::CloseIterator(thread, iter); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8); - } - HANDLE_OPCODE(HANDLE_ADD2DYN_PREF_V8) { - uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::add2dyn" + LOG_INST() << "intrinsics::add2" << " v" << v0; int32_t a0; int32_t a1; @@ -1416,27 +1548,27 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t a1 = right.GetInt(); if ((a0 > 0 && a1 > INT32_MAX - a0) || (a0 < 0 && a1 < INT32_MIN - a0)) { auto ret = static_cast(a0) + static_cast(a1); - SET_ACC(JSTaggedValue(ret)) + SET_ACC(JSTaggedValue(ret)); } else { - SET_ACC(JSTaggedValue(a0 + a1)) + SET_ACC(JSTaggedValue(a0 + a1)); } } else if (left.IsNumber() && right.IsNumber()) { double a0Double = left.IsInt() ? left.GetInt() : left.GetDouble(); double a1Double = right.IsInt() ? right.GetInt() : right.GetDouble(); double ret = a0Double + a1Double; - SET_ACC(JSTaggedValue(ret)) + SET_ACC(JSTaggedValue(ret)); } else { // one or both are not number, slow path SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::Add2Dyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::Add2(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(ADD2_IMM8_V8); } - HANDLE_OPCODE(HANDLE_SUB2DYN_PREF_V8) { + HANDLE_OPCODE(SUB2_IMM8_V8) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::sub2dyn" + LOG_INST() << "intrinsics::sub2" << " v" << v0; int32_t a0; int32_t a1; @@ -1447,27 +1579,27 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t a1 = -right.GetInt(); if ((a0 > 0 && a1 > INT32_MAX - a0) || (a0 < 0 && a1 < INT32_MIN - a0)) { auto ret = static_cast(a0) + static_cast(a1); - SET_ACC(JSTaggedValue(ret)) + SET_ACC(JSTaggedValue(ret)); } else { - SET_ACC(JSTaggedValue(a0 + a1)) + SET_ACC(JSTaggedValue(a0 + a1)); } } else if (left.IsNumber() && right.IsNumber()) { double a0Double = left.IsInt() ? left.GetInt() : left.GetDouble(); double a1Double = right.IsInt() ? right.GetInt() : right.GetDouble(); double ret = a0Double - a1Double; - SET_ACC(JSTaggedValue(ret)) + SET_ACC(JSTaggedValue(ret)); } else { // one or both are not number, slow path SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::Sub2Dyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::Sub2(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(SUB2_IMM8_V8); } - HANDLE_OPCODE(HANDLE_MUL2DYN_PREF_V8) { + HANDLE_OPCODE(MUL2_IMM8_V8) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::mul2dyn" + LOG_INST() << "intrinsics::mul2" << " v" << v0; JSTaggedValue left = GET_VREG_VALUE(v0); JSTaggedValue right = acc; @@ -1477,15 +1609,15 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t } else { // slow path SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::Mul2Dyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::Mul2(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(MUL2_IMM8_V8); } - HANDLE_OPCODE(HANDLE_DIV2DYN_PREF_V8) { + HANDLE_OPCODE(DIV2_IMM8_V8) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::div2dyn" + LOG_INST() << "intrinsics::div2" << " v" << v0; JSTaggedValue left = GET_VREG_VALUE(v0); JSTaggedValue right = acc; @@ -1496,15 +1628,15 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t } else { // slow path SAVE_PC(); - JSTaggedValue slowRes = SlowRuntimeStub::Div2Dyn(thread, left, right); + JSTaggedValue slowRes = SlowRuntimeStub::Div2(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(slowRes); SET_ACC(slowRes); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(DIV2_IMM8_V8); } - HANDLE_OPCODE(HANDLE_MOD2DYN_PREF_V8) { + HANDLE_OPCODE(MOD2_IMM8_V8) { uint16_t vs = READ_INST_8_1(); - LOG_INST() << "intrinsics::mod2dyn" + LOG_INST() << "intrinsics::mod2" << " v" << vs; JSTaggedValue left = GET_VREG_VALUE(vs); JSTaggedValue right = GET_ACC(); @@ -1514,16 +1646,16 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t } else { // slow path SAVE_PC(); - JSTaggedValue slowRes = SlowRuntimeStub::Mod2Dyn(thread, left, right); + JSTaggedValue slowRes = SlowRuntimeStub::Mod2(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(slowRes); SET_ACC(slowRes); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(MOD2_IMM8_V8); } - HANDLE_OPCODE(HANDLE_EQDYN_PREF_V8) { + HANDLE_OPCODE(EQ_IMM8_V8) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::eqdyn" + LOG_INST() << "intrinsics::eq" << " v" << v0; JSTaggedValue left = GET_VREG_VALUE(v0); JSTaggedValue right = acc; @@ -1533,17 +1665,17 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t } else { // slow path SAVE_PC(); - res = SlowRuntimeStub::EqDyn(thread, left, right); + res = SlowRuntimeStub::Eq(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(EQ_IMM8_V8); } - HANDLE_OPCODE(HANDLE_NOTEQDYN_PREF_V8) { + HANDLE_OPCODE(NOTEQ_IMM8_V8) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::noteqdyn" + LOG_INST() << "intrinsics::noteq" << " v" << v0; JSTaggedValue left = GET_VREG_VALUE(v0); JSTaggedValue right = acc; @@ -1555,16 +1687,16 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t } else { // slow path SAVE_PC(); - res = SlowRuntimeStub::NotEqDyn(thread, left, right); + res = SlowRuntimeStub::NotEq(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(NOTEQ_IMM8_V8); } - HANDLE_OPCODE(HANDLE_LESSDYN_PREF_V8) { + HANDLE_OPCODE(LESS_IMM8_V8) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::lessdyn" + LOG_INST() << "intrinsics::less" << " v" << v0; JSTaggedValue left = GET_VREG_VALUE(v0); JSTaggedValue right = GET_ACC(); @@ -1573,22 +1705,22 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t double valueA = left.IsInt() ? static_cast(left.GetInt()) : left.GetDouble(); double valueB = right.IsInt() ? static_cast(right.GetInt()) : right.GetDouble(); bool ret = JSTaggedValue::StrictNumberCompare(valueA, valueB) == ComparisonResult::LESS; - SET_ACC(ret ? JSTaggedValue::True() : JSTaggedValue::False()) + SET_ACC(ret ? JSTaggedValue::True() : JSTaggedValue::False()); } else if (left.IsBigInt() && right.IsBigInt()) { bool result = BigInt::LessThan(left, right); SET_ACC(JSTaggedValue(result)); } else { // slow path SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::LessDyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::Less(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(LESS_IMM8_V8); } - HANDLE_OPCODE(HANDLE_LESSEQDYN_PREF_V8) { + HANDLE_OPCODE(LESSEQ_IMM8_V8) { uint16_t vs = READ_INST_8_1(); - LOG_INST() << "intrinsics::lesseqdyn " + LOG_INST() << "intrinsics::lesseq " << " v" << vs; JSTaggedValue left = GET_VREG_VALUE(vs); JSTaggedValue right = GET_ACC(); @@ -1597,23 +1729,23 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t double valueA = left.IsInt() ? static_cast(left.GetInt()) : left.GetDouble(); double valueB = right.IsInt() ? static_cast(right.GetInt()) : right.GetDouble(); bool ret = JSTaggedValue::StrictNumberCompare(valueA, valueB) <= ComparisonResult::EQUAL; - SET_ACC(ret ? JSTaggedValue::True() : JSTaggedValue::False()) + SET_ACC(ret ? JSTaggedValue::True() : JSTaggedValue::False()); } else if (left.IsBigInt() && right.IsBigInt()) { bool result = BigInt::LessThan(left, right) || BigInt::Equal(left, right); SET_ACC(JSTaggedValue(result)); } else { // slow path SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::LessEqDyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::LessEq(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(LESSEQ_IMM8_V8); } - HANDLE_OPCODE(HANDLE_GREATERDYN_PREF_V8) { + HANDLE_OPCODE(GREATER_IMM8_V8) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::greaterdyn" + LOG_INST() << "intrinsics::greater" << " v" << v0; JSTaggedValue left = GET_VREG_VALUE(v0); JSTaggedValue right = acc; @@ -1622,22 +1754,22 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t double valueA = left.IsInt() ? static_cast(left.GetInt()) : left.GetDouble(); double valueB = right.IsInt() ? static_cast(right.GetInt()) : right.GetDouble(); bool ret = JSTaggedValue::StrictNumberCompare(valueA, valueB) == ComparisonResult::GREAT; - SET_ACC(ret ? JSTaggedValue::True() : JSTaggedValue::False()) + SET_ACC(ret ? JSTaggedValue::True() : JSTaggedValue::False()); } else if (left.IsBigInt() && right.IsBigInt()) { bool result = BigInt::LessThan(right, left); SET_ACC(JSTaggedValue(result)); } else { // slow path SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::GreaterDyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::Greater(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(GREATER_IMM8_V8); } - HANDLE_OPCODE(HANDLE_GREATEREQDYN_PREF_V8) { + HANDLE_OPCODE(GREATEREQ_IMM8_V8) { uint16_t vs = READ_INST_8_1(); - LOG_INST() << "intrinsics::greateqdyn " + LOG_INST() << "intrinsics::greateq " << " v" << vs; JSTaggedValue left = GET_VREG_VALUE(vs); JSTaggedValue right = GET_ACC(); @@ -1647,23 +1779,23 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t double valueB = right.IsInt() ? static_cast(right.GetInt()) : right.GetDouble(); ComparisonResult comparison = JSTaggedValue::StrictNumberCompare(valueA, valueB); bool ret = (comparison == ComparisonResult::GREAT) || (comparison == ComparisonResult::EQUAL); - SET_ACC(ret ? JSTaggedValue::True() : JSTaggedValue::False()) + SET_ACC(ret ? JSTaggedValue::True() : JSTaggedValue::False()); } else if (left.IsBigInt() && right.IsBigInt()) { bool result = BigInt::LessThan(right, left) || BigInt::Equal(right, left); - SET_ACC(JSTaggedValue(result)) + SET_ACC(JSTaggedValue(result)); } else { // slow path SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::GreaterEqDyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::GreaterEq(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(GREATEREQ_IMM8_V8); } - HANDLE_OPCODE(HANDLE_SHL2DYN_PREF_V8) { + HANDLE_OPCODE(SHL2_IMM8_V8) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::shl2dyn" + LOG_INST() << "intrinsics::shl2" << " v" << v0; JSTaggedValue left = GET_VREG_VALUE(v0); JSTaggedValue right = GET_ACC(); @@ -1676,7 +1808,7 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t using unsigned_type = std::make_unsigned_t; auto ret = static_cast(static_cast(opNumber0) << shift); // NOLINT(hicpp-signed-bitwise) - SET_ACC(JSTaggedValue(ret)) + SET_ACC(JSTaggedValue(ret)); } else if (left.IsNumber() && right.IsNumber()) { int32_t opNumber0 = left.IsInt() ? left.GetInt() : base::NumberHelper::DoubleToInt(left.GetDouble(), base::INT32_BITS); @@ -1687,20 +1819,20 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t using unsigned_type = std::make_unsigned_t; auto ret = static_cast(static_cast(opNumber0) << shift); // NOLINT(hicpp-signed-bitwise) - SET_ACC(JSTaggedValue(ret)) + SET_ACC(JSTaggedValue(ret)); } else { // slow path SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::Shl2Dyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::Shl2(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(SHL2_IMM8_V8); } - HANDLE_OPCODE(HANDLE_SHR2DYN_PREF_V8) { + HANDLE_OPCODE(SHR2_IMM8_V8) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::shr2dyn" + LOG_INST() << "intrinsics::shr2" << " v" << v0; JSTaggedValue left = GET_VREG_VALUE(v0); JSTaggedValue right = GET_ACC(); @@ -1713,7 +1845,7 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t using unsigned_type = std::make_unsigned_t; auto ret = static_cast(static_cast(opNumber0) >> shift); // NOLINT(hicpp-signed-bitwise) - SET_ACC(JSTaggedValue(ret)) + SET_ACC(JSTaggedValue(ret)); } else if (left.IsNumber() && right.IsNumber()) { int32_t opNumber0 = left.IsInt() ? left.GetInt() : base::NumberHelper::DoubleToInt(left.GetDouble(), base::INT32_BITS); @@ -1724,20 +1856,20 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t using unsigned_type = std::make_unsigned_t; auto ret = static_cast(static_cast(opNumber0) >> shift); // NOLINT(hicpp-signed-bitwise) - SET_ACC(JSTaggedValue(ret)) + SET_ACC(JSTaggedValue(ret)); } else { // slow path SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::Shr2Dyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::Shr2(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(SHR2_IMM8_V8); } - HANDLE_OPCODE(HANDLE_ASHR2DYN_PREF_V8) { + HANDLE_OPCODE(ASHR2_IMM8_V8) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::ashr2dyn" + LOG_INST() << "intrinsics::ashr2" << " v" << v0; JSTaggedValue left = GET_VREG_VALUE(v0); JSTaggedValue right = GET_ACC(); @@ -1748,7 +1880,7 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t uint32_t shift = static_cast(opNumber1) & 0x1f; // NOLINT(hicpp-signed-bitwise, readability-magic-numbers) auto ret = static_cast(opNumber0 >> shift); // NOLINT(hicpp-signed-bitwise) - SET_ACC(JSTaggedValue(ret)) + SET_ACC(JSTaggedValue(ret)); } else if (left.IsNumber() && right.IsNumber()) { int32_t opNumber0 = left.IsInt() ? left.GetInt() : base::NumberHelper::DoubleToInt(left.GetDouble(), base::INT32_BITS); @@ -1757,20 +1889,20 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t uint32_t shift = static_cast(opNumber1) & 0x1f; // NOLINT(hicpp-signed-bitwise, readability-magic-numbers) auto ret = static_cast(opNumber0 >> shift); // NOLINT(hicpp-signed-bitwise) - SET_ACC(JSTaggedValue(ret)) + SET_ACC(JSTaggedValue(ret)); } else { // slow path SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::Ashr2Dyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::Ashr2(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(ASHR2_IMM8_V8); } - HANDLE_OPCODE(HANDLE_AND2DYN_PREF_V8) { + HANDLE_OPCODE(AND2_IMM8_V8) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::and2dyn" + LOG_INST() << "intrinsics::and2" << " v" << v0; JSTaggedValue left = GET_VREG_VALUE(v0); JSTaggedValue right = GET_ACC(); @@ -1780,7 +1912,7 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t int32_t opNumber1 = right.GetInt(); // NOLINT(hicpp-signed-bitwise) auto ret = static_cast(opNumber0) & static_cast(opNumber1); - SET_ACC(JSTaggedValue(static_cast(ret))) + SET_ACC(JSTaggedValue(static_cast(ret))); } else if (left.IsNumber() && right.IsNumber()) { int32_t opNumber0 = left.IsInt() ? left.GetInt() : base::NumberHelper::DoubleToInt(left.GetDouble(), base::INT32_BITS); @@ -1788,20 +1920,20 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t right.IsInt() ? right.GetInt() : base::NumberHelper::DoubleToInt(right.GetDouble(), base::INT32_BITS); // NOLINT(hicpp-signed-bitwise) auto ret = static_cast(opNumber0) & static_cast(opNumber1); - SET_ACC(JSTaggedValue(static_cast(ret))) + SET_ACC(JSTaggedValue(static_cast(ret))); } else { // slow path SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::And2Dyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::And2(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(AND2_IMM8_V8); } - HANDLE_OPCODE(HANDLE_OR2DYN_PREF_V8) { + HANDLE_OPCODE(OR2_IMM8_V8) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::or2dyn" + LOG_INST() << "intrinsics::or2" << " v" << v0; JSTaggedValue left = GET_VREG_VALUE(v0); JSTaggedValue right = GET_ACC(); @@ -1811,7 +1943,7 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t int32_t opNumber1 = right.GetInt(); // NOLINT(hicpp-signed-bitwise) auto ret = static_cast(opNumber0) | static_cast(opNumber1); - SET_ACC(JSTaggedValue(static_cast(ret))) + SET_ACC(JSTaggedValue(static_cast(ret))); } else if (left.IsNumber() && right.IsNumber()) { int32_t opNumber0 = left.IsInt() ? left.GetInt() : base::NumberHelper::DoubleToInt(left.GetDouble(), base::INT32_BITS); @@ -1819,20 +1951,20 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t right.IsInt() ? right.GetInt() : base::NumberHelper::DoubleToInt(right.GetDouble(), base::INT32_BITS); // NOLINT(hicpp-signed-bitwise) auto ret = static_cast(opNumber0) | static_cast(opNumber1); - SET_ACC(JSTaggedValue(static_cast(ret))) + SET_ACC(JSTaggedValue(static_cast(ret))); } else { // slow path SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::Or2Dyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::Or2(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(OR2_IMM8_V8); } - HANDLE_OPCODE(HANDLE_XOR2DYN_PREF_V8) { + HANDLE_OPCODE(XOR2_IMM8_V8) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::xor2dyn" + LOG_INST() << "intrinsics::xor2" << " v" << v0; JSTaggedValue left = GET_VREG_VALUE(v0); JSTaggedValue right = GET_ACC(); @@ -1842,7 +1974,7 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t int32_t opNumber1 = right.GetInt(); // NOLINT(hicpp-signed-bitwise) auto ret = static_cast(opNumber0) ^ static_cast(opNumber1); - SET_ACC(JSTaggedValue(static_cast(ret))) + SET_ACC(JSTaggedValue(static_cast(ret))); } else if (left.IsNumber() && right.IsNumber()) { int32_t opNumber0 = left.IsInt() ? left.GetInt() : base::NumberHelper::DoubleToInt(left.GetDouble(), base::INT32_BITS); @@ -1850,325 +1982,78 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t right.IsInt() ? right.GetInt() : base::NumberHelper::DoubleToInt(right.GetDouble(), base::INT32_BITS); // NOLINT(hicpp-signed-bitwise) auto ret = static_cast(opNumber0) ^ static_cast(opNumber1); - SET_ACC(JSTaggedValue(static_cast(ret))) + SET_ACC(JSTaggedValue(static_cast(ret))); } else { // slow path SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::Xor2Dyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::Xor2(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(XOR2_IMM8_V8); } - HANDLE_OPCODE(HANDLE_DELOBJPROP_PREF_V8_V8) { + HANDLE_OPCODE(EXP_IMM8_V8) { uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - LOG_INST() << "intrinsics::delobjprop" - << " v0" << v0 << " v1" << v1; - - JSTaggedValue obj = GET_VREG_VALUE(v0); - JSTaggedValue prop = GET_VREG_VALUE(v1); - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::DelObjProp(thread, obj, prop); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); - } - HANDLE_OPCODE(HANDLE_DEFINEFUNCDYN_PREF_ID16_IMM16_V8) { - uint16_t methodId = READ_INST_16_1(); - uint16_t length = READ_INST_16_3(); - uint16_t v0 = READ_INST_8_5(); - LOG_INST() << "intrinsics::definefuncDyn length: " << length + LOG_INST() << "intrinsics::exp" << " v" << v0; - JSFunction *result = JSFunction::Cast(GET_OBJ_FROM_CACHE(methodId).GetTaggedObject()); - ASSERT(result != nullptr); - if (result->GetResolved()) { + JSTaggedValue base = GET_VREG_VALUE(v0); + JSTaggedValue exponent = GET_ACC(); + if (base.IsNumber() && exponent.IsNumber()) { + // fast path + double doubleBase = base.IsInt() ? base.GetInt() : base.GetDouble(); + double doubleExponent = exponent.IsInt() ? exponent.GetInt() : exponent.GetDouble(); + if (std::abs(doubleBase) == 1 && std::isinf(doubleExponent)) { + SET_ACC(JSTaggedValue(base::NAN_VALUE)); + } + bool baseZero = doubleBase == 0 && + (bit_cast(doubleBase) & base::DOUBLE_SIGN_MASK) == base::DOUBLE_SIGN_MASK; + bool isFinite = std::isfinite(doubleExponent); + bool truncEqual = base::NumberHelper::TruncateDouble(doubleExponent) == doubleExponent; + bool halfTruncEqual = (base::NumberHelper::TruncateDouble(doubleExponent / 2) + base::HALF) == + (doubleExponent / 2); + if (baseZero && isFinite && truncEqual && halfTruncEqual) { + if (doubleExponent > 0) { + SET_ACC(JSTaggedValue(-0.0)); + } + if (doubleExponent < 0) { + SET_ACC(JSTaggedValue(-base::POSITIVE_INFINITY)); + } + } + SET_ACC(JSTaggedValue(std::pow(doubleBase, doubleExponent))); + } else { + // slow path SAVE_PC(); - auto res = SlowRuntimeStub::DefinefuncDyn(thread, result); + JSTaggedValue res = SlowRuntimeStub::Exp(thread, base, exponent); INTERPRETER_RETURN_IF_ABRUPT(res); - result = JSFunction::Cast(res.GetTaggedObject()); - } else { - result->SetResolved(true); + SET_ACC(res); } - - result->SetPropertyInlinedProps(thread, JSFunction::LENGTH_INLINE_PROPERTY_INDEX, JSTaggedValue(length)); - JSTaggedValue envHandle = GET_VREG_VALUE(v0); - result->SetLexicalEnv(thread, envHandle); - - JSFunction *currentFunc = JSFunction::Cast((GET_FRAME(sp)->function).GetTaggedObject()); - result->SetModule(thread, currentFunc->GetModule()); - SET_ACC(JSTaggedValue(result)) - - DISPATCH(BytecodeInstruction::Format::PREF_ID16_IMM16_V8); + DISPATCH(EXP_IMM8_V8); } - HANDLE_OPCODE(HANDLE_DEFINENCFUNCDYN_PREF_ID16_IMM16_V8) { - uint16_t methodId = READ_INST_16_1(); - uint16_t length = READ_INST_16_3(); - uint16_t v0 = READ_INST_8_5(); - JSTaggedValue homeObject = GET_ACC(); - LOG_INST() << "intrinsics::definencfuncDyn length: " << length + HANDLE_OPCODE(ISIN_IMM8_V8) { + uint16_t v0 = READ_INST_8_1(); + LOG_INST() << "intrinsics::isin" << " v" << v0; - JSFunction *result = JSFunction::Cast(GET_OBJ_FROM_CACHE(methodId).GetTaggedObject()); - ASSERT(result != nullptr); - if (result->GetResolved()) { - SAVE_ACC(); - SAVE_PC(); - auto res = SlowRuntimeStub::DefineNCFuncDyn(thread, result); - INTERPRETER_RETURN_IF_ABRUPT(res); - result = JSFunction::Cast(res.GetTaggedObject()); - RESTORE_ACC(); - homeObject = GET_ACC(); - } else { - result->SetResolved(true); - } - - result->SetPropertyInlinedProps(thread, JSFunction::LENGTH_INLINE_PROPERTY_INDEX, JSTaggedValue(length)); - JSTaggedValue env = GET_VREG_VALUE(v0); - result->SetLexicalEnv(thread, env); - result->SetHomeObject(thread, homeObject); - - JSFunction *currentFunc = JSFunction::Cast((GET_FRAME(sp)->function).GetTaggedObject()); - result->SetModule(thread, currentFunc->GetModule()); - SET_ACC(JSTaggedValue(result)); - - DISPATCH(BytecodeInstruction::Format::PREF_ID16_IMM16_V8); + JSTaggedValue prop = GET_VREG_VALUE(v0); + JSTaggedValue obj = GET_ACC(); + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::IsIn(thread, prop, obj); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(ISIN_IMM8_V8); } - HANDLE_OPCODE(HANDLE_DEFINEMETHOD_PREF_ID16_IMM16_V8) { - uint16_t methodId = READ_INST_16_1(); - uint16_t length = READ_INST_16_3(); - uint16_t v0 = READ_INST_8_5(); - JSTaggedValue homeObject = GET_ACC(); - LOG_INST() << "intrinsics::definemethod length: " << length - << " v" << v0; - JSFunction *result = JSFunction::Cast(GET_OBJ_FROM_CACHE(methodId).GetTaggedObject()); - ASSERT(result != nullptr); - if (result->GetResolved()) { - SAVE_PC(); - auto res = SlowRuntimeStub::DefineMethod(thread, result, homeObject); - INTERPRETER_RETURN_IF_ABRUPT(res); - result = JSFunction::Cast(res.GetTaggedObject()); - } else { - result->SetHomeObject(thread, homeObject); - result->SetResolved(true); - } - - result->SetPropertyInlinedProps(thread, JSFunction::LENGTH_INLINE_PROPERTY_INDEX, JSTaggedValue(length)); - JSTaggedValue taggedCurEnv = GET_VREG_VALUE(v0); - result->SetLexicalEnv(thread, taggedCurEnv); - - JSFunction *currentFunc = JSFunction::Cast((GET_FRAME(sp)->function).GetTaggedObject()); - result->SetModule(thread, currentFunc->GetModule()); - SET_ACC(JSTaggedValue(result)); - - DISPATCH(BytecodeInstruction::Format::PREF_ID16_IMM16_V8); - } - HANDLE_OPCODE(HANDLE_NEWOBJDYNRANGE_PREF_IMM16_V8) { - uint16_t numArgs = READ_INST_16_1(); - uint16_t firstArgRegIdx = READ_INST_8_3(); - LOG_INST() << "intrinsics::newobjDynrange " << numArgs << " v" << firstArgRegIdx; - JSTaggedValue ctor = GET_VREG_VALUE(firstArgRegIdx); - - if (ctor.IsJSFunction() && ctor.IsConstructor()) { - JSFunction *ctorFunc = JSFunction::Cast(ctor.GetTaggedObject()); - methodHandle.Update(ctorFunc->GetMethod()); - - if (ctorFunc->IsBuiltinConstructor()) { - ASSERT(methodHandle->GetNumVregsWithCallField() == 0); - size_t frameSize = InterpretedFrame::NumOfMembers() + numArgs + 3; // 3: this & numArgs & thread - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - JSTaggedType *newSp = sp - frameSize; - if (UNLIKELY(thread->DoStackOverflowCheck(newSp))) { - INTERPRETER_GOTO_EXCEPTION_HANDLER(); - } - // copy args - uint32_t index = 0; - // numArgs - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - EcmaRuntimeCallInfo *ecmaRuntimeCallInfo = reinterpret_cast(newSp); - newSp[index++] = ToUintPtr(thread); - newSp[index++] = numArgs + 1; // +1 for this - // func - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - newSp[index++] = GET_VREG(firstArgRegIdx); - // newTarget - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - newSp[index++] = GET_VREG(firstArgRegIdx + 1); - // this - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; - for (size_t i = 2; i < numArgs; ++i) { // 2: func and newTarget - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - newSp[index++] = GET_VREG(firstArgRegIdx + i); - } - - InterpretedBuiltinFrame *state = GET_BUILTIN_FRAME(newSp); - state->base.prev = sp; - state->base.type = FrameType::INTERPRETER_BUILTIN_FRAME; - state->pc = nullptr; - state->function = ctor; - thread->SetCurrentSPFrame(newSp); - - LOG_INST() << "Entry: Runtime New."; - SAVE_PC(); - JSTaggedValue retValue = reinterpret_cast( - const_cast(methodHandle->GetNativePointer()))(ecmaRuntimeCallInfo); - thread->SetCurrentSPFrame(sp); - if (UNLIKELY(thread->HasPendingException())) { - INTERPRETER_GOTO_EXCEPTION_HANDLER(); - } - LOG_INST() << "Exit: Runtime New."; - SET_ACC(retValue); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16_V8); - } - - if (IsFastNewFrameEnter(ctorFunc, methodHandle)) { - SAVE_PC(); - uint32_t numVregs = methodHandle->GetNumVregsWithCallField(); - uint32_t numDeclaredArgs = ctorFunc->IsBase() ? - methodHandle->GetNumArgsWithCallField() + 1 : // +1 for this - methodHandle->GetNumArgsWithCallField() + 2; // +2 for newTarget and this - // +1 for hidden this, explicit this may be overwritten after bc optimizer - size_t frameSize = InterpretedFrame::NumOfMembers() + numVregs + numDeclaredArgs + 1; - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - JSTaggedType *newSp = sp - frameSize; - InterpretedFrame *state = GET_FRAME(newSp); - - if (UNLIKELY(thread->DoStackOverflowCheck(newSp))) { - INTERPRETER_GOTO_EXCEPTION_HANDLER(); - } - - uint32_t index = 0; - // initialize vregs value - for (size_t i = 0; i < numVregs; ++i) { - newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; - } - - // this - JSTaggedValue thisObj; - if (ctorFunc->IsBase()) { - JSTaggedValue newTarget = GET_VREG_VALUE(firstArgRegIdx + 1); - thisObj = FastRuntimeStub::NewThisObject(thread, ctor, newTarget, state); - INTERPRETER_RETURN_IF_ABRUPT(thisObj); - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - newSp[index++] = thisObj.GetRawData(); - } else { - ASSERT(ctorFunc->IsDerivedConstructor()); - JSTaggedValue newTarget = GET_VREG_VALUE(firstArgRegIdx + 1); - newSp[index++] = newTarget.GetRawData(); - thisObj = JSTaggedValue::Undefined(); - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - newSp[index++] = thisObj.GetRawData(); - - state->function = ctor; - state->constpool = methodHandle->GetConstantPool(); - state->profileTypeInfo = ctorFunc->GetProfileTypeInfo(); - state->env = ctorFunc->GetLexicalEnv(); - } - - // the second condition ensure not push extra args - for (size_t i = 2; i < numArgs && index < numVregs + numDeclaredArgs; ++i) { // 2: func and newTarget - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - newSp[index++] = GET_VREG(firstArgRegIdx + i); - } - - // set undefined to the extra prats of declare - for (size_t i = index; i < numVregs + numDeclaredArgs; ++i) { - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; - } - - // hidden this object - newSp[index] = thisObj.GetRawData(); - - state->base.prev = sp; - state->base.type = FrameType::INTERPRETER_FAST_NEW_FRAME; - state->pc = pc = methodHandle->GetBytecodeArray(); - sp = newSp; - state->acc = JSTaggedValue::Hole(); - - thread->SetCurrentSPFrame(newSp); - LOG_INST() << "Entry: Runtime New " << std::hex << reinterpret_cast(sp) << " " - << std::hex << reinterpret_cast(pc); - DISPATCH_OFFSET(0); - } - } - - // bound function, proxy, other call types, enter slow path - constexpr uint16_t firstArgOffset = 2; - JSTaggedValue newTarget = GET_VREG_VALUE(firstArgRegIdx + 1); - // Exclude func and newTarget - uint16_t firstArgIdx = firstArgRegIdx + firstArgOffset; - uint16_t length = numArgs - firstArgOffset; - - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::NewObjDynRange(thread, ctor, newTarget, firstArgIdx, length); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16_V8); - } - HANDLE_OPCODE(HANDLE_EXPDYN_PREF_V8) { - uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::expdyn" - << " v" << v0; - JSTaggedValue base = GET_VREG_VALUE(v0); - JSTaggedValue exponent = GET_ACC(); - if (base.IsNumber() && exponent.IsNumber()) { - // fast path - double doubleBase = base.IsInt() ? base.GetInt() : base.GetDouble(); - double doubleExponent = exponent.IsInt() ? exponent.GetInt() : exponent.GetDouble(); - if (std::abs(doubleBase) == 1 && std::isinf(doubleExponent)) { - SET_ACC(JSTaggedValue(base::NAN_VALUE)); - } - bool baseZero = doubleBase == 0 && - (bit_cast(doubleBase) & base::DOUBLE_SIGN_MASK) == base::DOUBLE_SIGN_MASK; - bool isFinite = std::isfinite(doubleExponent); - bool truncEqual = base::NumberHelper::TruncateDouble(doubleExponent) == doubleExponent; - bool halfTruncEqual = (base::NumberHelper::TruncateDouble(doubleExponent / 2) + base::HALF) == - (doubleExponent / 2); - if (baseZero && isFinite && truncEqual && halfTruncEqual) { - if (doubleExponent > 0) { - SET_ACC(JSTaggedValue(-0.0)); - } - if (doubleExponent < 0) { - SET_ACC(JSTaggedValue(-base::POSITIVE_INFINITY)); - } - } - SET_ACC(JSTaggedValue(std::pow(doubleBase, doubleExponent))); - } else { - // slow path - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::ExpDyn(thread, base, exponent); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - } - DISPATCH(BytecodeInstruction::Format::PREF_V8); - } - HANDLE_OPCODE(HANDLE_ISINDYN_PREF_V8) { - uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::isindyn" - << " v" << v0; - JSTaggedValue prop = GET_VREG_VALUE(v0); - JSTaggedValue obj = GET_ACC(); - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::IsInDyn(thread, prop, obj); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8); - } - HANDLE_OPCODE(HANDLE_INSTANCEOFDYN_PREF_V8) { - uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::instanceofdyn" + HANDLE_OPCODE(INSTANCEOF_IMM8_V8) { + uint16_t v0 = READ_INST_8_1(); + LOG_INST() << "intrinsics::instanceof" << " v" << v0; JSTaggedValue obj = GET_VREG_VALUE(v0); JSTaggedValue target = GET_ACC(); SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::InstanceofDyn(thread, obj, target); + JSTaggedValue res = SlowRuntimeStub::Instanceof(thread, obj, target); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(INSTANCEOF_IMM8_V8); } - HANDLE_OPCODE(HANDLE_STRICTNOTEQDYN_PREF_V8) { + HANDLE_OPCODE(STRICTNOTEQ_IMM8_V8) { uint16_t v0 = READ_INST_8_1(); LOG_INST() << "intrinsics::strictnoteq" << " v" << v0; @@ -2176,9 +2061,9 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t JSTaggedValue right = GET_ACC(); bool res = FastRuntimeStub::FastStrictEqual(left, right); SET_ACC(JSTaggedValue(!res)); - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(STRICTNOTEQ_IMM8_V8); } - HANDLE_OPCODE(HANDLE_STRICTEQDYN_PREF_V8) { + HANDLE_OPCODE(STRICTEQ_IMM8_V8) { uint16_t v0 = READ_INST_8_1(); LOG_INST() << "intrinsics::stricteq" << " v" << v0; @@ -2186,702 +2071,2937 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t JSTaggedValue right = GET_ACC(); bool res = FastRuntimeStub::FastStrictEqual(left, right); SET_ACC(JSTaggedValue(res)); - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(STRICTEQ_IMM8_V8); } - HANDLE_OPCODE(HANDLE_LDLEXVARDYN_PREF_IMM16_IMM16) { - uint16_t level = READ_INST_16_1(); - uint16_t slot = READ_INST_16_3(); - - LOG_INST() << "intrinsics::ldlexvardyn" - << " level:" << level << " slot:" << slot; - InterpretedFrame *state = GET_FRAME(sp); - JSTaggedValue currentLexenv = state->env; - JSTaggedValue env(currentLexenv); - for (uint32_t i = 0; i < level; i++) { - JSTaggedValue taggedParentEnv = LexicalEnv::Cast(env.GetTaggedObject())->GetParentEnv(); - ASSERT(!taggedParentEnv.IsUndefined()); - env = taggedParentEnv; - } - SET_ACC(LexicalEnv::Cast(env.GetTaggedObject())->GetProperties(slot)); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16_IMM16); + HANDLE_OPCODE(CREATEITERRESULTOBJ_V8_V8) { + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); + LOG_INST() << "intrinsics::createiterresultobj" + << " v" << v0 << " v" << v1; + JSTaggedValue value = GET_VREG_VALUE(v0); + JSTaggedValue flag = GET_VREG_VALUE(v1); + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::CreateIterResultObj(thread, value, flag); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(CREATEITERRESULTOBJ_V8_V8); } - HANDLE_OPCODE(HANDLE_LDLEXVARDYN_PREF_IMM8_IMM8) { - uint16_t level = READ_INST_8_1(); - uint16_t slot = READ_INST_8_2(); - - LOG_INST() << "intrinsics::ldlexvardyn" - << " level:" << level << " slot:" << slot; - InterpretedFrame *state = GET_FRAME(sp); - JSTaggedValue currentLexenv = state->env; - JSTaggedValue env(currentLexenv); - for (uint32_t i = 0; i < level; i++) { - JSTaggedValue taggedParentEnv = LexicalEnv::Cast(env.GetTaggedObject())->GetParentEnv(); - ASSERT(!taggedParentEnv.IsUndefined()); - env = taggedParentEnv; - } - SET_ACC(LexicalEnv::Cast(env.GetTaggedObject())->GetProperties(slot)); - DISPATCH(BytecodeInstruction::Format::PREF_IMM8_IMM8); + HANDLE_OPCODE(NEWOBJAPPLY_IMM8_V8) { + uint16_t v0 = READ_INST_8_1(); + LOG_INST() << "intrinsic::newobjspeard" + << " v" << v0; + JSTaggedValue func = GET_VREG_VALUE(v0); + JSTaggedValue array = GET_ACC(); + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::NewObjApply(thread, func, array); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(NEWOBJAPPLY_IMM8_V8); } - HANDLE_OPCODE(HANDLE_LDLEXVARDYN_PREF_IMM4_IMM4) { - uint16_t level = READ_INST_4_2(); - uint16_t slot = READ_INST_4_3(); + HANDLE_OPCODE(NEWOBJAPPLY_IMM16_V8) { + uint16_t v0 = READ_INST_8_2(); + LOG_INST() << "intrinsic::newobjspeard" + << " v" << v0; + JSTaggedValue func = GET_VREG_VALUE(v0); + JSTaggedValue array = GET_ACC(); + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::NewObjApply(thread, func, array); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(NEWOBJAPPLY_IMM16_V8); + } + HANDLE_OPCODE(STOWNBYNAME_IMM8_ID16_V8) { + uint16_t stringId = READ_INST_16_1(); + uint32_t v0 = READ_INST_8_3(); + LOG_INST() << "intrinsics::stownbyname " + << "v" << v0 << " stringId:" << stringId; - LOG_INST() << "intrinsics::ldlexvardyn" - << " level:" << level << " slot:" << slot; - InterpretedFrame *state = GET_FRAME(sp); - JSTaggedValue currentLexenv = state->env; - JSTaggedValue env(currentLexenv); - for (uint32_t i = 0; i < level; i++) { - JSTaggedValue taggedParentEnv = LexicalEnv::Cast(env.GetTaggedObject())->GetParentEnv(); - ASSERT(!taggedParentEnv.IsUndefined()); - env = taggedParentEnv; - } - SET_ACC(LexicalEnv::Cast(env.GetTaggedObject())->GetProperties(slot)); - DISPATCH(BytecodeInstruction::Format::PREF_IMM4_IMM4); - } - HANDLE_OPCODE(HANDLE_STLEXVARDYN_PREF_IMM16_IMM16_V8) { - uint16_t level = READ_INST_16_1(); - uint16_t slot = READ_INST_16_3(); - uint16_t v0 = READ_INST_8_5(); - LOG_INST() << "intrinsics::stlexvardyn" - << " level:" << level << " slot:" << slot << " v" << v0; - - JSTaggedValue value = GET_VREG_VALUE(v0); - InterpretedFrame *state = GET_FRAME(sp); - JSTaggedValue env = state->env; - for (uint32_t i = 0; i < level; i++) { - JSTaggedValue taggedParentEnv = LexicalEnv::Cast(env.GetTaggedObject())->GetParentEnv(); - ASSERT(!taggedParentEnv.IsUndefined()); - env = taggedParentEnv; + JSTaggedValue receiver = GET_VREG_VALUE(v0); + if (receiver.IsJSObject() && !receiver.IsClassConstructor() && !receiver.IsClassPrototype()) { + JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); + JSTaggedValue value = GET_ACC(); + // fast path + SAVE_ACC(); + JSTaggedValue res = FastRuntimeStub::SetPropertyByName(thread, receiver, propKey, value); + if (!res.IsHole()) { + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(STOWNBYNAME_IMM8_ID16_V8); + } + RESTORE_ACC(); } - LexicalEnv::Cast(env.GetTaggedObject())->SetProperties(thread, slot, value); - - DISPATCH(BytecodeInstruction::Format::PREF_IMM16_IMM16_V8); - } - HANDLE_OPCODE(HANDLE_NEWLEXENVWITHNAMEDYN_PREF_IMM16_IMM16) { - uint16_t numVars = READ_INST_16_1(); - uint16_t scopeId = READ_INST_16_3(); - LOG_INST() << "intrinsics::newlexenvwithnamedyn" - << " numVars " << numVars << " scopeId " << scopeId; + SAVE_ACC(); + receiver = GET_VREG_VALUE(v0); // Maybe moved by GC + auto propKey = GET_OBJ_FROM_CACHE(stringId); // Maybe moved by GC + auto value = GET_ACC(); // Maybe moved by GC SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::NewLexicalEnvWithNameDyn(thread, numVars, scopeId); + JSTaggedValue res = SlowRuntimeStub::StOwnByName(thread, receiver, propKey, value); + RESTORE_ACC(); INTERPRETER_RETURN_IF_ABRUPT(res); - - SET_ACC(res); - GET_FRAME(sp)->env = res; - DISPATCH(BytecodeInstruction::Format::PREF_IMM16_IMM16); - } - HANDLE_OPCODE(HANDLE_STLEXVARDYN_PREF_IMM8_IMM8_V8) { - uint16_t level = READ_INST_8_1(); - uint16_t slot = READ_INST_8_2(); - uint16_t v0 = READ_INST_8_3(); - LOG_INST() << "intrinsics::stlexvardyn" - << " level:" << level << " slot:" << slot << " v" << v0; - - JSTaggedValue value = GET_VREG_VALUE(v0); - InterpretedFrame *state = GET_FRAME(sp); - JSTaggedValue env = state->env; - for (uint32_t i = 0; i < level; i++) { - JSTaggedValue taggedParentEnv = LexicalEnv::Cast(env.GetTaggedObject())->GetParentEnv(); - ASSERT(!taggedParentEnv.IsUndefined()); - env = taggedParentEnv; - } - LexicalEnv::Cast(env.GetTaggedObject())->SetProperties(thread, slot, value); - - DISPATCH(BytecodeInstruction::Format::PREF_IMM8_IMM8_V8); - } - HANDLE_OPCODE(HANDLE_STLEXVARDYN_PREF_IMM4_IMM4_V8) { - uint16_t level = READ_INST_4_2(); - uint16_t slot = READ_INST_4_3(); - uint16_t v0 = READ_INST_8_2(); - LOG_INST() << "intrinsics::stlexvardyn" - << " level:" << level << " slot:" << slot << " v" << v0; - - JSTaggedValue value = GET_VREG_VALUE(v0); - InterpretedFrame *state = GET_FRAME(sp); - JSTaggedValue env = state->env; - for (uint32_t i = 0; i < level; i++) { - JSTaggedValue taggedParentEnv = LexicalEnv::Cast(env.GetTaggedObject())->GetParentEnv(); - ASSERT(!taggedParentEnv.IsUndefined()); - env = taggedParentEnv; - } - LexicalEnv::Cast(env.GetTaggedObject())->SetProperties(thread, slot, value); - - DISPATCH(BytecodeInstruction::Format::PREF_IMM4_IMM4_V8); + DISPATCH(STOWNBYNAME_IMM8_ID16_V8); } - HANDLE_OPCODE(HANDLE_NEWLEXENVDYN_PREF_IMM16) { - uint16_t numVars = READ_INST_16_1(); - LOG_INST() << "intrinsics::newlexenvdyn" - << " imm " << numVars; - - JSTaggedValue res = FastRuntimeStub::NewLexicalEnvDyn(thread, factory, numVars); - if (res.IsHole()) { - SAVE_PC(); - res = SlowRuntimeStub::NewLexicalEnvDyn(thread, numVars); - INTERPRETER_RETURN_IF_ABRUPT(res); - } + HANDLE_OPCODE(CREATEEMPTYARRAY_IMM8) { + LOG_INST() << "intrinsics::createemptyarray"; + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::CreateEmptyArray(thread, factory, globalEnv); SET_ACC(res); - GET_FRAME(sp)->env = res; - DISPATCH(BytecodeInstruction::Format::PREF_IMM16); - } - HANDLE_OPCODE(HANDLE_POPLEXENVDYN_PREF) { - InterpretedFrame *state = GET_FRAME(sp); - JSTaggedValue currentLexenv = state->env; - JSTaggedValue parentLexenv = LexicalEnv::Cast(currentLexenv.GetTaggedObject())->GetParentEnv(); - GET_FRAME(sp)->env = parentLexenv; - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(CREATEEMPTYARRAY_IMM8); } - HANDLE_OPCODE(HANDLE_CREATEITERRESULTOBJ_PREF_V8_V8) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - LOG_INST() << "intrinsics::createiterresultobj" - << " v" << v0 << " v" << v1; - JSTaggedValue value = GET_VREG_VALUE(v0); - JSTaggedValue flag = GET_VREG_VALUE(v1); + HANDLE_OPCODE(CREATEEMPTYOBJECT) { + LOG_INST() << "intrinsics::createemptyobject"; SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::CreateIterResultObj(thread, value, flag); - INTERPRETER_RETURN_IF_ABRUPT(res); + JSTaggedValue res = SlowRuntimeStub::CreateEmptyObject(thread, factory, globalEnv); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(CREATEEMPTYOBJECT); } - HANDLE_OPCODE(HANDLE_SUSPENDGENERATOR_PREF_V8_V8) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - LOG_INST() << "intrinsics::suspendgenerator" - << " v" << v0 << " v" << v1; - JSTaggedValue genObj = GET_VREG_VALUE(v0); - JSTaggedValue value = GET_VREG_VALUE(v1); - // suspend will record bytecode offset + HANDLE_OPCODE(CREATEREGEXPWITHLITERAL_IMM8_ID16_IMM8) { + uint16_t stringId = READ_INST_16_1(); + JSTaggedValue pattern = GET_OBJ_FROM_CACHE(stringId); + uint8_t flags = READ_INST_8_3(); + LOG_INST() << "intrinsics::createregexpwithliteral " + << "stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(pattern.GetTaggedObject())) + << ", flags:" << flags; SAVE_PC(); - SAVE_ACC(); - JSTaggedValue res = SlowRuntimeStub::SuspendGenerator(thread, genObj, value); + JSTaggedValue res = SlowRuntimeStub::CreateRegExpWithLiteral(thread, pattern, flags); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - - InterpretedFrame *state = GET_FRAME(sp); - methodHandle.Update(JSFunction::Cast(state->function.GetTaggedObject())->GetMethod()); - [[maybe_unused]] auto fistPC = methodHandle->GetBytecodeArray(); - UPDATE_HOTNESS_COUNTER(-(pc - fistPC)); - LOG_INST() << "Exit: SuspendGenerator " << std::hex << reinterpret_cast(sp) << " " - << std::hex << reinterpret_cast(state->pc); - sp = state->base.prev; - ASSERT(sp != nullptr); - InterpretedFrame *prevState = GET_FRAME(sp); - pc = prevState->pc; - // entry frame - if (FrameHandler::IsEntryFrame(pc)) { - state->acc = acc; - return; - } - - thread->SetCurrentSPFrame(sp); - - INTERPRETER_HANDLE_RETURN(); + DISPATCH(CREATEREGEXPWITHLITERAL_IMM8_ID16_IMM8); } - HANDLE_OPCODE(HANDLE_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - LOG_INST() << "intrinsics::asyncfunctionawaituncaught" - << " v" << v0 << " v" << v1; - JSTaggedValue asyncFuncObj = GET_VREG_VALUE(v0); - JSTaggedValue value = GET_VREG_VALUE(v1); + HANDLE_OPCODE(CREATEREGEXPWITHLITERAL_IMM16_ID16_IMM8) { + uint16_t stringId = READ_INST_16_2(); + JSTaggedValue pattern = GET_OBJ_FROM_CACHE(stringId); + uint8_t flags = READ_INST_8_4(); + LOG_INST() << "intrinsics::createregexpwithliteral " + << "stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(pattern.GetTaggedObject())) + << ", flags:" << flags; SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::AsyncFunctionAwaitUncaught(thread, asyncFuncObj, value); + JSTaggedValue res = SlowRuntimeStub::CreateRegExpWithLiteral(thread, pattern, flags); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(CREATEREGEXPWITHLITERAL_IMM16_ID16_IMM8); } - HANDLE_OPCODE(HANDLE_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8) { - uint16_t v0 = READ_INST_8_1(); - [[maybe_unused]] uint16_t v1 = READ_INST_8_2(); - uint16_t v2 = READ_INST_8_3(); - LOG_INST() << "intrinsics::asyncfunctionresolve" - << " v" << v0 << " v" << v1 << " v" << v2; - - JSTaggedValue asyncFuncObj = GET_VREG_VALUE(v0); - JSTaggedValue value = GET_VREG_VALUE(v2); + HANDLE_OPCODE(GETNEXTPROPNAME_V8) { + uint16_t v0 = READ_INST_8_0(); + LOG_INST() << "intrinsic::getnextpropname" + << " v" << v0; + JSTaggedValue iter = GET_VREG_VALUE(v0); SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::AsyncFunctionResolveOrReject(thread, asyncFuncObj, value, true); + JSTaggedValue res = SlowRuntimeStub::GetNextPropName(thread, iter); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8_V8); + DISPATCH(GETNEXTPROPNAME_V8); } - HANDLE_OPCODE(HANDLE_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8) { - uint16_t v0 = READ_INST_8_1(); - [[maybe_unused]] uint16_t v1 = READ_INST_8_2(); - uint16_t v2 = READ_INST_8_3(); - LOG_INST() << "intrinsics::asyncfunctionreject" - << " v" << v0 << " v" << v1 << " v" << v2; + HANDLE_OPCODE(STOWNBYVALUE_IMM8_V8_V8) { + uint32_t v0 = READ_INST_8_1(); + uint32_t v1 = READ_INST_8_2(); + LOG_INST() << "intrinsics::stownbyvalue" + << " v" << v0 << " v" << v1; - JSTaggedValue asyncFuncObj = GET_VREG_VALUE(v0); - JSTaggedValue value = GET_VREG_VALUE(v2); + JSTaggedValue receiver = GET_VREG_VALUE(v0); + if (receiver.IsHeapObject() && !receiver.IsClassConstructor() && !receiver.IsClassPrototype()) { + SAVE_ACC(); + JSTaggedValue propKey = GET_VREG_VALUE(v1); + JSTaggedValue value = GET_ACC(); + // fast path + JSTaggedValue res = FastRuntimeStub::SetPropertyByValue(thread, receiver, propKey, value); + + // SetPropertyByValue maybe gc need update the value + RESTORE_ACC(); + propKey = GET_VREG_VALUE(v1); + value = GET_ACC(); + if (!res.IsHole()) { + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(STOWNBYVALUE_IMM8_V8_V8); + } + } + + // slow path + SAVE_ACC(); + receiver = GET_VREG_VALUE(v0); // Maybe moved by GC + auto propKey = GET_VREG_VALUE(v1); // Maybe moved by GC + auto value = GET_ACC(); // Maybe moved by GC SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::AsyncFunctionResolveOrReject(thread, asyncFuncObj, value, false); + JSTaggedValue res = SlowRuntimeStub::StOwnByValue(thread, receiver, propKey, value); + RESTORE_ACC(); INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8_V8); + DISPATCH(STOWNBYVALUE_IMM8_V8_V8); } - HANDLE_OPCODE(HANDLE_NEWOBJSPREADDYN_PREF_V8_V8) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - LOG_INST() << "intrinsic::newobjspearddyn" - << " v" << v0 << " v" << v1; - JSTaggedValue func = GET_VREG_VALUE(v0); - JSTaggedValue newTarget = GET_VREG_VALUE(v1); - JSTaggedValue array = GET_ACC(); + HANDLE_OPCODE(DEPRECATED_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8) { + uint16_t methodId = READ_INST_16_1(); + uint16_t length = READ_INST_16_3(); + uint16_t v0 = READ_INST_8_5(); + LOG_INST() << "define async gengerator function length: " << length + << " v" << v0; + JSFunction *result = JSFunction::Cast(GET_OBJ_FROM_CACHE(methodId).GetTaggedObject()); + ASSERT(result != nullptr); + if (result->GetResolved()) { + SAVE_PC(); + auto res = SlowRuntimeStub::DefineAsyncGeneratorFunc(thread, result); + INTERPRETER_RETURN_IF_ABRUPT(res); + result = JSFunction::Cast(res.GetTaggedObject()); + } else { + result->SetResolved(true); + } + + result->SetPropertyInlinedProps(thread, JSFunction::LENGTH_INLINE_PROPERTY_INDEX, JSTaggedValue(length)); + JSTaggedValue env = GET_VREG_VALUE(v0); + result->SetLexicalEnv(thread, env); + + JSFunction *currentFunc = JSFunction::Cast((GET_FRAME(sp)->function).GetTaggedObject()); + result->SetModule(thread, currentFunc->GetModule()); + SET_ACC(JSTaggedValue(result)); + DISPATCH(DEPRECATED_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8); + } + HANDLE_OPCODE(LDHOLE) { + LOG_INST() << "intrinsic::ldhole"; + SET_ACC(JSTaggedValue::Hole()); + DISPATCH(LDHOLE); + } + HANDLE_OPCODE(DEFINEGETTERSETTERBYVALUE_V8_V8_V8_V8) { + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); + uint16_t v2 = READ_INST_8_2(); + uint16_t v3 = READ_INST_8_3(); + LOG_INST() << "intrinsics::definegettersetterbyvalue" + << " v" << v0 << " v" << v1 << " v" << v2 << " v" << v3; + + JSTaggedValue obj = GET_VREG_VALUE(v0); + JSTaggedValue prop = GET_VREG_VALUE(v1); + JSTaggedValue getter = GET_VREG_VALUE(v2); + JSTaggedValue setter = GET_VREG_VALUE(v3); + JSTaggedValue flag = GET_ACC(); SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::NewObjSpreadDyn(thread, func, newTarget, array); + JSTaggedValue res = + SlowRuntimeStub::DefineGetterSetterByValue(thread, obj, prop, getter, setter, flag.ToBoolean()); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(DEFINEGETTERSETTERBYVALUE_V8_V8_V8_V8); } - HANDLE_OPCODE(HANDLE_THROWUNDEFINEDIFHOLE_PREF_V8_V8) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - LOG_INST() << "intrinsic::throwundefinedifhole" + HANDLE_OPCODE(STOBJBYVALUE_IMM8_V8_V8) { + uint32_t v0 = READ_INST_8_1(); + uint32_t v1 = READ_INST_8_2(); + + LOG_INST() << "intrinsics::stobjbyvalue" << " v" << v0 << " v" << v1; - JSTaggedValue hole = GET_VREG_VALUE(v0); - if (!hole.IsHole()) { - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); - } - JSTaggedValue obj = GET_VREG_VALUE(v1); - ASSERT(obj.IsString()); - SAVE_PC(); - SlowRuntimeStub::ThrowUndefinedIfHole(thread, obj); - INTERPRETER_GOTO_EXCEPTION_HANDLER(); + + JSTaggedValue receiver = GET_VREG_VALUE(v0); +#if ECMASCRIPT_ENABLE_IC + auto profileTypeInfo = GetRuntimeProfileTypeInfo(sp); + if (!profileTypeInfo.IsUndefined()) { + uint16_t slotId = READ_INST_8_0(); + auto profileTypeArray = ProfileTypeInfo::Cast(profileTypeInfo.GetTaggedObject()); + JSTaggedValue firstValue = profileTypeArray->Get(slotId); + JSTaggedValue propKey = GET_VREG_VALUE(v1); + JSTaggedValue value = GET_ACC(); + JSTaggedValue res = JSTaggedValue::Hole(); + SAVE_ACC(); + + if (LIKELY(firstValue.IsHeapObject())) { + JSTaggedValue secondValue = profileTypeArray->Get(slotId + 1); + res = ICRuntimeStub::TryStoreICByValue(thread, receiver, propKey, firstValue, secondValue, value); + } + // IC miss and not enter the megamorphic state, store as polymorphic + if (res.IsHole() && !firstValue.IsHole()) { + res = ICRuntimeStub::StoreICByValue(thread, + profileTypeArray, + receiver, propKey, value, slotId); + } + + if (LIKELY(!res.IsHole())) { + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(STOBJBYVALUE_IMM8_V8_V8); + } + } +#endif + if (receiver.IsHeapObject()) { + SAVE_ACC(); + JSTaggedValue propKey = GET_VREG_VALUE(v1); + JSTaggedValue value = GET_ACC(); + // fast path + JSTaggedValue res = FastRuntimeStub::SetPropertyByValue(thread, receiver, propKey, value); + if (!res.IsHole()) { + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(STOBJBYVALUE_IMM8_V8_V8); + } + RESTORE_ACC(); + } + { + // slow path + SAVE_ACC(); + SAVE_PC(); + receiver = GET_VREG_VALUE(v0); // Maybe moved by GC + JSTaggedValue propKey = GET_VREG_VALUE(v1); // Maybe moved by GC + JSTaggedValue value = GET_ACC(); // Maybe moved by GC + JSTaggedValue res = SlowRuntimeStub::StObjByValue(thread, receiver, propKey, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + } + DISPATCH(STOBJBYVALUE_IMM8_V8_V8); } - HANDLE_OPCODE(HANDLE_STOWNBYNAME_PREF_ID32_V8) { - uint32_t stringId = READ_INST_32_1(); - uint32_t v0 = READ_INST_8_5(); - LOG_INST() << "intrinsics::stownbyname " + HANDLE_OPCODE(STSUPERBYVALUE_IMM8_V8_V8) { + uint32_t v0 = READ_INST_8_1(); + uint32_t v1 = READ_INST_8_2(); + + LOG_INST() << "intrinsics::stsuperbyvalue" + << " v" << v0 << " v" << v1; + JSTaggedValue receiver = GET_VREG_VALUE(v0); + JSTaggedValue propKey = GET_VREG_VALUE(v1); + JSTaggedValue value = GET_ACC(); + + // slow path + SAVE_ACC(); + SAVE_PC(); + JSTaggedValue thisFunc = GetThisFunction(sp); + JSTaggedValue res = SlowRuntimeStub::StSuperByValue(thread, receiver, propKey, value, thisFunc); + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(STSUPERBYVALUE_IMM8_V8_V8); + } + HANDLE_OPCODE(TRYLDGLOBALBYNAME_IMM8_ID16) { + uint16_t stringId = READ_INST_16_1(); + auto prop = GET_OBJ_FROM_CACHE(stringId); + + LOG_INST() << "intrinsics::tryldglobalbyname " + << "stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(prop.GetTaggedObject())); + +#if ECMASCRIPT_ENABLE_IC + auto profileTypeInfo = GetRuntimeProfileTypeInfo(sp); + if (!profileTypeInfo.IsUndefined()) { + uint16_t slotId = READ_INST_8_0(); + JSTaggedValue res = ICRuntimeStub::LoadGlobalICByName(thread, + ProfileTypeInfo::Cast( + profileTypeInfo.GetTaggedObject()), + globalObj, prop, slotId); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(TRYLDGLOBALBYNAME_IMM8_ID16); + } +#endif + + // order: 1. global record 2. global object + JSTaggedValue result = SlowRuntimeStub::LdGlobalRecord(thread, prop); + if (!result.IsUndefined()) { + SET_ACC(PropertyBox::Cast(result.GetTaggedObject())->GetValue()); + } else { + JSTaggedValue globalResult = FastRuntimeStub::GetGlobalOwnProperty(thread, globalObj, prop); + if (!globalResult.IsHole()) { + SET_ACC(globalResult); + } else { + // slow path + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::TryLdGlobalByNameFromGlobalProto(thread, globalObj, prop); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + } + } + + DISPATCH(TRYLDGLOBALBYNAME_IMM8_ID16); + } + HANDLE_OPCODE(TRYSTGLOBALBYNAME_IMM8_ID16) { + uint16_t stringId = READ_INST_16_1(); + JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); + LOG_INST() << "intrinsics::trystglobalbyname" + << " stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())); + +#if ECMASCRIPT_ENABLE_IC + auto profileTypeInfo = GetRuntimeProfileTypeInfo(sp); + if (!profileTypeInfo.IsUndefined()) { + uint16_t slotId = READ_INST_8_0(); + JSTaggedValue value = GET_ACC(); + SAVE_ACC(); + JSTaggedValue res = ICRuntimeStub::StoreGlobalICByName(thread, + ProfileTypeInfo::Cast( + profileTypeInfo.GetTaggedObject()), + globalObj, propKey, value, slotId); + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(TRYSTGLOBALBYNAME_IMM8_ID16); + } +#endif + + auto recordResult = SlowRuntimeStub::LdGlobalRecord(thread, propKey); + SAVE_PC(); + // 1. find from global record + if (!recordResult.IsUndefined()) { + JSTaggedValue value = GET_ACC(); + SAVE_ACC(); + JSTaggedValue res = SlowRuntimeStub::TryUpdateGlobalRecord(thread, propKey, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + } else { + // 2. find from global object + auto globalResult = FastRuntimeStub::GetGlobalOwnProperty(thread, globalObj, propKey); + if (globalResult.IsHole()) { + auto result = SlowRuntimeStub::ThrowReferenceError(thread, propKey, " is not defined"); + INTERPRETER_RETURN_IF_ABRUPT(result); + } + JSTaggedValue value = GET_ACC(); + SAVE_ACC(); + JSTaggedValue res = SlowRuntimeStub::StGlobalVar(thread, propKey, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + } + DISPATCH(TRYSTGLOBALBYNAME_IMM8_ID16); + } + HANDLE_OPCODE(STOWNBYVALUEWITHNAMESET_IMM8_V8_V8) { + uint32_t v0 = READ_INST_8_1(); + uint32_t v1 = READ_INST_8_2(); + LOG_INST() << "intrinsics::stownbyvaluewithnameset" + << " v" << v0 << " v" << v1; + JSTaggedValue receiver = GET_VREG_VALUE(v0); + if (receiver.IsHeapObject() && !receiver.IsClassConstructor() && !receiver.IsClassPrototype()) { + SAVE_ACC(); + JSTaggedValue propKey = GET_VREG_VALUE(v1); + JSTaggedValue value = GET_ACC(); + // fast path + JSTaggedValue res = FastRuntimeStub::SetPropertyByValue(thread, receiver, propKey, value); + + // SetPropertyByValue maybe gc need update the value + RESTORE_ACC(); + propKey = GET_VREG_VALUE(v1); + value = GET_ACC(); + if (!res.IsHole()) { + INTERPRETER_RETURN_IF_ABRUPT(res); + JSFunction::SetFunctionNameNoPrefix(thread, JSFunction::Cast(value.GetTaggedObject()), propKey); + RESTORE_ACC(); + DISPATCH(STOWNBYVALUEWITHNAMESET_IMM8_V8_V8); + } + } + + // slow path + SAVE_ACC(); + SAVE_PC(); + receiver = GET_VREG_VALUE(v0); // Maybe moved by GC + auto propKey = GET_VREG_VALUE(v1); // Maybe moved by GC + auto value = GET_ACC(); // Maybe moved by GC + JSTaggedValue res = SlowRuntimeStub::StOwnByValueWithNameSet(thread, receiver, propKey, value); + RESTORE_ACC(); + INTERPRETER_RETURN_IF_ABRUPT(res); + DISPATCH(STOWNBYVALUEWITHNAMESET_IMM8_V8_V8); + } + HANDLE_OPCODE(STOWNBYNAMEWITHNAMESET_IMM8_ID16_V8) { + uint16_t stringId = READ_INST_16_1(); + uint32_t v0 = READ_INST_8_3(); + LOG_INST() << "intrinsics::stownbynamewithnameset " << "v" << v0 << " stringId:" << stringId; - JSTaggedValue receiver = GET_VREG_VALUE(v0); - if (receiver.IsJSObject() && !receiver.IsClassConstructor() && !receiver.IsClassPrototype()) { - JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); - JSTaggedValue value = GET_ACC(); - // fast path - SAVE_ACC(); - JSTaggedValue res = FastRuntimeStub::SetPropertyByName(thread, receiver, propKey, value); - if (!res.IsHole()) { - INTERPRETER_RETURN_IF_ABRUPT(res); - RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); - } - RESTORE_ACC(); - } + JSTaggedValue receiver = GET_VREG_VALUE(v0); + if (receiver.IsJSObject() && !receiver.IsClassConstructor() && !receiver.IsClassPrototype()) { + JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); + JSTaggedValue value = GET_ACC(); + // fast path + SAVE_ACC(); + JSTaggedValue res = FastRuntimeStub::SetPropertyByName(thread, receiver, propKey, value); + if (!res.IsHole()) { + INTERPRETER_RETURN_IF_ABRUPT(res); + JSFunction::SetFunctionNameNoPrefix(thread, JSFunction::Cast(value.GetTaggedObject()), propKey); + RESTORE_ACC(); + DISPATCH(STOWNBYNAMEWITHNAMESET_IMM8_ID16_V8); + } + RESTORE_ACC(); + } + + SAVE_ACC(); + SAVE_PC(); + receiver = GET_VREG_VALUE(v0); // Maybe moved by GC + auto propKey = GET_OBJ_FROM_CACHE(stringId); // Maybe moved by GC + auto value = GET_ACC(); // Maybe moved by GC + JSTaggedValue res = SlowRuntimeStub::StOwnByNameWithNameSet(thread, receiver, propKey, value); + RESTORE_ACC(); + INTERPRETER_RETURN_IF_ABRUPT(res); + DISPATCH(STOWNBYNAMEWITHNAMESET_IMM8_ID16_V8); + } + HANDLE_OPCODE(LDGLOBALVAR_IMM16_ID16) { + uint16_t stringId = READ_INST_16_2(); + LOG_INST() << "intrinsics::ldglobalvar stringId:" << stringId; + JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); + +#if ECMASCRIPT_ENABLE_IC + auto profileTypeInfo = GetRuntimeProfileTypeInfo(sp); + if (!profileTypeInfo.IsUndefined()) { + uint16_t slotId = READ_INST_16_0(); + JSTaggedValue res = ICRuntimeStub::LoadGlobalICByName(thread, + ProfileTypeInfo::Cast( + profileTypeInfo.GetTaggedObject()), + globalObj, propKey, slotId); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(LDGLOBALVAR_IMM16_ID16); + } +#endif + + JSTaggedValue result = FastRuntimeStub::GetGlobalOwnProperty(thread, globalObj, propKey); + if (!result.IsHole()) { + SET_ACC(result); + } else { + // slow path + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::LdGlobalVarFromGlobalProto(thread, globalObj, propKey); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + } + DISPATCH(LDGLOBALVAR_IMM16_ID16); + } + HANDLE_OPCODE(STOBJBYNAME_IMM8_ID16_V8) { + uint32_t v0 = READ_INST_8_3(); + JSTaggedValue receiver = GET_VREG_VALUE(v0); + JSTaggedValue value = GET_ACC(); +#if ECMASCRIPT_ENABLE_IC + auto profileTypeInfo = GetRuntimeProfileTypeInfo(sp); + if (!profileTypeInfo.IsUndefined()) { + uint16_t slotId = READ_INST_8_0(); + auto profileTypeArray = ProfileTypeInfo::Cast(profileTypeInfo.GetTaggedObject()); + JSTaggedValue firstValue = profileTypeArray->Get(slotId); + JSTaggedValue res = JSTaggedValue::Hole(); + SAVE_ACC(); + + if (LIKELY(firstValue.IsHeapObject())) { + JSTaggedValue secondValue = profileTypeArray->Get(slotId + 1); + res = ICRuntimeStub::TryStoreICByName(thread, receiver, firstValue, secondValue, value); + } + if (LIKELY(!res.IsHole())) { + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(STOBJBYNAME_IMM8_ID16_V8); + } else if (!firstValue.IsHole()) { // IC miss and not enter the megamorphic state, store as polymorphic + uint16_t stringId = READ_INST_16_1(); + JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); + res = ICRuntimeStub::StoreICByName(thread, + profileTypeArray, + receiver, propKey, value, slotId); + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(STOBJBYNAME_IMM8_ID16_V8); + } + } +#endif + uint16_t stringId = READ_INST_16_1(); + LOG_INST() << "intrinsics::stobjbyname " + << "v" << v0 << " stringId:" << stringId; + if (receiver.IsHeapObject()) { + JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); + value = GET_ACC(); + // fast path + SAVE_ACC(); + JSTaggedValue res = FastRuntimeStub::SetPropertyByName(thread, receiver, propKey, value); + if (!res.IsHole()) { + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(STOBJBYNAME_IMM8_ID16_V8); + } + RESTORE_ACC(); + } + // slow path + SAVE_ACC(); + SAVE_PC(); + receiver = GET_VREG_VALUE(v0); // Maybe moved by GC + auto propKey = GET_OBJ_FROM_CACHE(stringId); // Maybe moved by GC + value = GET_ACC(); // Maybe moved by GC + JSTaggedValue res = SlowRuntimeStub::StObjByName(thread, receiver, propKey, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(STOBJBYNAME_IMM8_ID16_V8); + } + HANDLE_OPCODE(STSUPERBYNAME_IMM8_ID16_V8) { + uint16_t stringId = READ_INST_16_1(); + uint32_t v0 = READ_INST_8_3(); + + JSTaggedValue obj = GET_VREG_VALUE(v0); + JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); + JSTaggedValue value = GET_ACC(); + + LOG_INST() << "intrinsics::stsuperbyname" + << "v" << v0 << " stringId:" << stringId << ", " + << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())) << ", obj:" << obj.GetRawData() + << ", value:" << value.GetRawData(); + + // slow path + SAVE_ACC(); + SAVE_PC(); + JSTaggedValue thisFunc = GetThisFunction(sp); + JSTaggedValue res = SlowRuntimeStub::StSuperByValue(thread, obj, propKey, value, thisFunc); + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(STSUPERBYNAME_IMM8_ID16_V8); + } + HANDLE_OPCODE(STGLOBALVAR_IMM16_ID16) { + uint16_t stringId = READ_INST_16_2(); + JSTaggedValue prop = GET_OBJ_FROM_CACHE(stringId); + JSTaggedValue value = GET_ACC(); + + LOG_INST() << "intrinsics::stglobalvar " + << "stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(prop.GetTaggedObject())) + << ", value:" << value.GetRawData(); +#if ECMASCRIPT_ENABLE_IC + auto profileTypeInfo = GetRuntimeProfileTypeInfo(sp); + if (!profileTypeInfo.IsUndefined()) { + uint16_t slotId = READ_INST_16_0(); + SAVE_ACC(); + JSTaggedValue res = ICRuntimeStub::StoreGlobalICByName(thread, + ProfileTypeInfo::Cast( + profileTypeInfo.GetTaggedObject()), + globalObj, prop, value, slotId); + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(STGLOBALVAR_IMM16_ID16); + } +#endif + SAVE_ACC(); + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::StGlobalVar(thread, prop, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(STGLOBALVAR_IMM16_ID16); + } + HANDLE_OPCODE(CREATEGENERATOROBJ_V8) { + uint16_t v0 = READ_INST_8_0(); + LOG_INST() << "intrinsics::creategeneratorobj" + << " v" << v0; + SAVE_PC(); + JSTaggedValue genFunc = GET_VREG_VALUE(v0); + JSTaggedValue res = SlowRuntimeStub::CreateGeneratorObj(thread, genFunc); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(CREATEGENERATOROBJ_V8); + } + HANDLE_OPCODE(STARRAYSPREAD_V8_V8) { + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); + LOG_INST() << "ecmascript::intrinsics::starrayspread" + << " v" << v0 << " v" << v1 << "acc"; + JSTaggedValue dst = GET_VREG_VALUE(v0); + JSTaggedValue index = GET_VREG_VALUE(v1); + JSTaggedValue src = GET_ACC(); + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::StArraySpread(thread, dst, index, src); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(STARRAYSPREAD_V8_V8); + } + HANDLE_OPCODE(LDFUNCTION) { + LOG_INST() << "intrinsic::ldfunction"; + SET_ACC(GetThisFunction(sp)); + DISPATCH(LDFUNCTION); + } + HANDLE_OPCODE(LDBIGINT_ID16) { + uint16_t stringId = READ_INST_16_0(); + LOG_INST() << "intrinsic::ldbigint"; + JSTaggedValue numberBigInt = GET_OBJ_FROM_CACHE(stringId); + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::LdBigInt(thread, numberBigInt); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(LDBIGINT_ID16); + } + HANDLE_OPCODE(CREATEASYNCGENERATOROBJ_V8) { + uint16_t v0 = READ_INST_8_0(); + LOG_INST() << "intrinsics::createasyncgeneratorobj" + << " v" << v0; + SAVE_PC(); + JSTaggedValue genFunc = GET_VREG_VALUE(v0); + JSTaggedValue res = SlowRuntimeStub::CreateAsyncGeneratorObj(thread, genFunc); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(CREATEASYNCGENERATOROBJ_V8); + } + HANDLE_OPCODE(ASYNCGENERATORRESOLVE_V8_V8_V8) { + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); + uint16_t v2 = READ_INST_8_2(); + LOG_INST() << "intrinsics::asyncgeneratorresolve" + << " v" << v0 << " v" << v1 << " v" << v2; + JSTaggedValue asyncGenerator = GET_VREG_VALUE(v0); + JSTaggedValue value = GET_VREG_VALUE(v1); + JSTaggedValue flag = GET_VREG_VALUE(v2); + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::AsyncGeneratorResolve(thread, asyncGenerator, value, flag); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(ASYNCGENERATORRESOLVE_V8_V8_V8); + } + HANDLE_OPCODE(SUPERCALLTHISRANGE_IMM8_IMM8_V8) { + uint16_t range = READ_INST_8_1(); + uint16_t v0 = READ_INST_8_2(); + LOG_INST() << "intrinsics::supercall" + << " range: " << range << " v" << v0; + + JSTaggedValue thisFunc = GetThisFunction(sp); + JSTaggedValue newTarget = GetNewTarget(sp); + + SAVE_PC(); + JSTaggedValue superCtor = SlowRuntimeStub::GetSuperConstructor(thread, thisFunc); + INTERPRETER_RETURN_IF_ABRUPT(superCtor); + + if (superCtor.IsJSFunction() && superCtor.IsConstructor() && !newTarget.IsUndefined()) { + JSFunction *superCtorFunc = JSFunction::Cast(superCtor.GetTaggedObject()); + methodHandle.Update(superCtorFunc->GetMethod()); + if (superCtorFunc->IsBuiltinConstructor()) { + ASSERT(methodHandle->GetNumVregsWithCallField() == 0); + size_t frameSize = + InterpretedFrame::NumOfMembers() + range + NUM_MANDATORY_JSFUNC_ARGS + 2; // 2:thread & numArgs + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + JSTaggedType *newSp = sp - frameSize; + if (UNLIKELY(thread->DoStackOverflowCheck(newSp))) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + // copy args + uint32_t index = 0; + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + EcmaRuntimeCallInfo *ecmaRuntimeCallInfo = reinterpret_cast(newSp); + newSp[index++] = ToUintPtr(thread); + newSp[index++] = range + NUM_MANDATORY_JSFUNC_ARGS; + // func + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = superCtor.GetRawData(); + // newTarget + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = newTarget.GetRawData(); + // this + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + for (size_t i = 0; i < range; ++i) { + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = GET_VREG(v0 + i); + } + + InterpretedBuiltinFrame *state = GET_BUILTIN_FRAME(newSp); + state->base.prev = sp; + state->base.type = FrameType::INTERPRETER_BUILTIN_FRAME; + state->pc = nullptr; + state->function = superCtor; + thread->SetCurrentSPFrame(newSp); + LOG_INST() << "Entry: Runtime SuperCall "; + JSTaggedValue retValue = reinterpret_cast( + const_cast(methodHandle->GetNativePointer()))(ecmaRuntimeCallInfo); + thread->SetCurrentSPFrame(sp); + + if (UNLIKELY(thread->HasPendingException())) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + LOG_INST() << "Exit: Runtime SuperCall "; + SET_ACC(retValue); + DISPATCH(SUPERCALLTHISRANGE_IMM8_IMM8_V8); + } + + if (IsFastNewFrameEnter(superCtorFunc, methodHandle)) { + SAVE_PC(); + uint32_t numVregs = methodHandle->GetNumVregsWithCallField(); + uint32_t numDeclaredArgs = superCtorFunc->IsBase() ? + methodHandle->GetNumArgsWithCallField() + 1 : // +1 for this + methodHandle->GetNumArgsWithCallField() + 2; // +2 for newTarget and this + // +1 for hidden this, explicit this may be overwritten after bc optimizer + size_t frameSize = InterpretedFrame::NumOfMembers() + numVregs + numDeclaredArgs + 1; + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + JSTaggedType *newSp = sp - frameSize; + InterpretedFrame *state = GET_FRAME(newSp); + + if (UNLIKELY(thread->DoStackOverflowCheck(newSp))) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + + uint32_t index = 0; + // initialize vregs value + for (size_t i = 0; i < numVregs; ++i) { + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + } + + // this + JSTaggedValue thisObj; + if (superCtorFunc->IsBase()) { + thisObj = FastRuntimeStub::NewThisObject(thread, superCtor, newTarget, state); + INTERPRETER_RETURN_IF_ABRUPT(thisObj); + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = thisObj.GetRawData(); + } else { + ASSERT(superCtorFunc->IsDerivedConstructor()); + newSp[index++] = newTarget.GetRawData(); + thisObj = JSTaggedValue::Undefined(); + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = thisObj.GetRawData(); + + state->function = superCtor; + state->constpool = methodHandle->GetConstantPool(); + state->profileTypeInfo = superCtorFunc->GetProfileTypeInfo(); + state->env = superCtorFunc->GetLexicalEnv(); + } + + // the second condition ensure not push extra args + for (size_t i = 0; i < range && index < numVregs + numDeclaredArgs; ++i) { + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = GET_VREG(v0 + i); + } + + // set undefined to the extra prats of declare + for (size_t i = index; i < numVregs + numDeclaredArgs; ++i) { + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + } + + // hidden this object + newSp[index] = thisObj.GetRawData(); + + state->base.prev = sp; + state->base.type = FrameType::INTERPRETER_FAST_NEW_FRAME; + state->pc = pc = methodHandle->GetBytecodeArray(); + sp = newSp; + state->acc = JSTaggedValue::Hole(); + + thread->SetCurrentSPFrame(newSp); + LOG_INST() << "Entry: Runtime SuperCall " << std::hex << reinterpret_cast(sp) + << " " << std::hex << reinterpret_cast(pc); + DISPATCH_OFFSET(0); + } + } + + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::SuperCall(thread, thisFunc, newTarget, v0, range); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(SUPERCALLTHISRANGE_IMM8_IMM8_V8); + } + HANDLE_OPCODE(WIDE_SUPERCALLTHISRANGE_PREF_IMM16_V8) { + uint16_t range = READ_INST_16_1(); + uint16_t v0 = READ_INST_8_3(); + LOG_INST() << "intrinsics::supercall" + << " range: " << range << " v" << v0; + + JSTaggedValue thisFunc = GetThisFunction(sp); + JSTaggedValue newTarget = GetNewTarget(sp); + + SAVE_PC(); + JSTaggedValue superCtor = SlowRuntimeStub::GetSuperConstructor(thread, thisFunc); + INTERPRETER_RETURN_IF_ABRUPT(superCtor); + + if (superCtor.IsJSFunction() && superCtor.IsConstructor() && !newTarget.IsUndefined()) { + JSFunction *superCtorFunc = JSFunction::Cast(superCtor.GetTaggedObject()); + methodHandle.Update(superCtorFunc->GetMethod()); + if (superCtorFunc->IsBuiltinConstructor()) { + ASSERT(methodHandle->GetNumVregsWithCallField() == 0); + size_t frameSize = + InterpretedFrame::NumOfMembers() + range + NUM_MANDATORY_JSFUNC_ARGS + 2; // 2:thread & numArgs + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + JSTaggedType *newSp = sp - frameSize; + if (UNLIKELY(thread->DoStackOverflowCheck(newSp))) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + // copy args + uint32_t index = 0; + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + EcmaRuntimeCallInfo *ecmaRuntimeCallInfo = reinterpret_cast(newSp); + newSp[index++] = ToUintPtr(thread); + newSp[index++] = range + NUM_MANDATORY_JSFUNC_ARGS; + // func + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = superCtor.GetRawData(); + // newTarget + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = newTarget.GetRawData(); + // this + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + for (size_t i = 0; i < range; ++i) { + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = GET_VREG(v0 + i); + } + + InterpretedBuiltinFrame *state = GET_BUILTIN_FRAME(newSp); + state->base.prev = sp; + state->base.type = FrameType::INTERPRETER_BUILTIN_FRAME; + state->pc = nullptr; + state->function = superCtor; + thread->SetCurrentSPFrame(newSp); + LOG_INST() << "Entry: Runtime SuperCall "; + JSTaggedValue retValue = reinterpret_cast( + const_cast(methodHandle->GetNativePointer()))(ecmaRuntimeCallInfo); + thread->SetCurrentSPFrame(sp); + + if (UNLIKELY(thread->HasPendingException())) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + LOG_INST() << "Exit: Runtime SuperCall "; + SET_ACC(retValue); + DISPATCH(WIDE_SUPERCALLTHISRANGE_PREF_IMM16_V8); + } + + if (IsFastNewFrameEnter(superCtorFunc, methodHandle)) { + SAVE_PC(); + uint32_t numVregs = methodHandle->GetNumVregsWithCallField(); + uint32_t numDeclaredArgs = superCtorFunc->IsBase() ? + methodHandle->GetNumArgsWithCallField() + 1 : // +1 for this + methodHandle->GetNumArgsWithCallField() + 2; // +2 for newTarget and this + // +1 for hidden this, explicit this may be overwritten after bc optimizer + size_t frameSize = InterpretedFrame::NumOfMembers() + numVregs + numDeclaredArgs + 1; + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + JSTaggedType *newSp = sp - frameSize; + InterpretedFrame *state = GET_FRAME(newSp); + + if (UNLIKELY(thread->DoStackOverflowCheck(newSp))) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + + uint32_t index = 0; + // initialize vregs value + for (size_t i = 0; i < numVregs; ++i) { + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + } + + // this + JSTaggedValue thisObj; + if (superCtorFunc->IsBase()) { + thisObj = FastRuntimeStub::NewThisObject(thread, superCtor, newTarget, state); + INTERPRETER_RETURN_IF_ABRUPT(thisObj); + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = thisObj.GetRawData(); + } else { + ASSERT(superCtorFunc->IsDerivedConstructor()); + newSp[index++] = newTarget.GetRawData(); + thisObj = JSTaggedValue::Undefined(); + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = thisObj.GetRawData(); + + state->function = superCtor; + state->constpool = methodHandle->GetConstantPool(); + state->profileTypeInfo = superCtorFunc->GetProfileTypeInfo(); + state->env = superCtorFunc->GetLexicalEnv(); + } + + // the second condition ensure not push extra args + for (size_t i = 0; i < range && index < numVregs + numDeclaredArgs; ++i) { + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = GET_VREG(v0 + i); + } + + // set undefined to the extra prats of declare + for (size_t i = index; i < numVregs + numDeclaredArgs; ++i) { + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + } + + // hidden this object + newSp[index] = thisObj.GetRawData(); + + state->base.prev = sp; + state->base.type = FrameType::INTERPRETER_FAST_NEW_FRAME; + state->pc = pc = methodHandle->GetBytecodeArray(); + sp = newSp; + state->acc = JSTaggedValue::Hole(); + + thread->SetCurrentSPFrame(newSp); + LOG_INST() << "Entry: Runtime SuperCall " << std::hex << reinterpret_cast(sp) + << " " << std::hex << reinterpret_cast(pc); + DISPATCH_OFFSET(0); + } + } + + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::SuperCall(thread, thisFunc, newTarget, v0, range); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(WIDE_SUPERCALLTHISRANGE_PREF_IMM16_V8); + } + HANDLE_OPCODE(SUPERCALLARROWRANGE_IMM8_IMM8_V8) { + uint16_t range = READ_INST_8_1(); + uint16_t v0 = READ_INST_8_2(); + LOG_INST() << "intrinsics::supercall" + << " range: " << range << " v" << v0; + + JSTaggedValue thisFunc = GET_ACC(); + JSTaggedValue newTarget = GetNewTarget(sp); + + SAVE_PC(); + JSTaggedValue superCtor = SlowRuntimeStub::GetSuperConstructor(thread, thisFunc); + INTERPRETER_RETURN_IF_ABRUPT(superCtor); + + if (superCtor.IsJSFunction() && superCtor.IsConstructor() && !newTarget.IsUndefined()) { + JSFunction *superCtorFunc = JSFunction::Cast(superCtor.GetTaggedObject()); + methodHandle.Update(superCtorFunc->GetMethod()); + if (superCtorFunc->IsBuiltinConstructor()) { + ASSERT(methodHandle->GetNumVregsWithCallField() == 0); + size_t frameSize = + InterpretedFrame::NumOfMembers() + range + NUM_MANDATORY_JSFUNC_ARGS + 2; // 2:thread & numArgs + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + JSTaggedType *newSp = sp - frameSize; + if (UNLIKELY(thread->DoStackOverflowCheck(newSp))) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + // copy args + uint32_t index = 0; + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + EcmaRuntimeCallInfo *ecmaRuntimeCallInfo = reinterpret_cast(newSp); + newSp[index++] = ToUintPtr(thread); + newSp[index++] = range + NUM_MANDATORY_JSFUNC_ARGS; + // func + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = superCtor.GetRawData(); + // newTarget + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = newTarget.GetRawData(); + // this + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + for (size_t i = 0; i < range; ++i) { + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = GET_VREG(v0 + i); + } + + InterpretedBuiltinFrame *state = GET_BUILTIN_FRAME(newSp); + state->base.prev = sp; + state->base.type = FrameType::INTERPRETER_BUILTIN_FRAME; + state->pc = nullptr; + state->function = superCtor; + thread->SetCurrentSPFrame(newSp); + LOG_INST() << "Entry: Runtime SuperCall "; + JSTaggedValue retValue = reinterpret_cast( + const_cast(methodHandle->GetNativePointer()))(ecmaRuntimeCallInfo); + thread->SetCurrentSPFrame(sp); + + if (UNLIKELY(thread->HasPendingException())) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + LOG_INST() << "Exit: Runtime SuperCall "; + SET_ACC(retValue); + DISPATCH(SUPERCALLARROWRANGE_IMM8_IMM8_V8); + } + + if (IsFastNewFrameEnter(superCtorFunc, methodHandle)) { + SAVE_PC(); + uint32_t numVregs = methodHandle->GetNumVregsWithCallField(); + uint32_t numDeclaredArgs = superCtorFunc->IsBase() ? + methodHandle->GetNumArgsWithCallField() + 1 : // +1 for this + methodHandle->GetNumArgsWithCallField() + 2; // +2 for newTarget and this + // +1 for hidden this, explicit this may be overwritten after bc optimizer + size_t frameSize = InterpretedFrame::NumOfMembers() + numVregs + numDeclaredArgs + 1; + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + JSTaggedType *newSp = sp - frameSize; + InterpretedFrame *state = GET_FRAME(newSp); + + if (UNLIKELY(thread->DoStackOverflowCheck(newSp))) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + + uint32_t index = 0; + // initialize vregs value + for (size_t i = 0; i < numVregs; ++i) { + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + } + + // this + JSTaggedValue thisObj; + if (superCtorFunc->IsBase()) { + thisObj = FastRuntimeStub::NewThisObject(thread, superCtor, newTarget, state); + INTERPRETER_RETURN_IF_ABRUPT(thisObj); + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = thisObj.GetRawData(); + } else { + ASSERT(superCtorFunc->IsDerivedConstructor()); + newSp[index++] = newTarget.GetRawData(); + thisObj = JSTaggedValue::Undefined(); + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = thisObj.GetRawData(); + + state->function = superCtor; + state->constpool = methodHandle->GetConstantPool(); + state->profileTypeInfo = superCtorFunc->GetProfileTypeInfo(); + state->env = superCtorFunc->GetLexicalEnv(); + } + + // the second condition ensure not push extra args + for (size_t i = 0; i < range && index < numVregs + numDeclaredArgs; ++i) { + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = GET_VREG(v0 + i); + } + + // set undefined to the extra prats of declare + for (size_t i = index; i < numVregs + numDeclaredArgs; ++i) { + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + } + + // hidden this object + newSp[index] = thisObj.GetRawData(); + + state->base.prev = sp; + state->base.type = FrameType::INTERPRETER_FAST_NEW_FRAME; + state->pc = pc = methodHandle->GetBytecodeArray(); + sp = newSp; + state->acc = JSTaggedValue::Hole(); + + thread->SetCurrentSPFrame(newSp); + LOG_INST() << "Entry: Runtime SuperCall " << std::hex << reinterpret_cast(sp) + << " " << std::hex << reinterpret_cast(pc); + DISPATCH_OFFSET(0); + } + } + + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::SuperCall(thread, thisFunc, newTarget, v0, range); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(SUPERCALLARROWRANGE_IMM8_IMM8_V8); + } + HANDLE_OPCODE(WIDE_SUPERCALLARROWRANGE_PREF_IMM16_V8) { + uint16_t range = READ_INST_16_1(); + uint16_t v0 = READ_INST_8_3(); + LOG_INST() << "intrinsics::supercall" + << " range: " << range << " v" << v0; + + JSTaggedValue thisFunc = GET_ACC(); + JSTaggedValue newTarget = GetNewTarget(sp); + + SAVE_PC(); + JSTaggedValue superCtor = SlowRuntimeStub::GetSuperConstructor(thread, thisFunc); + INTERPRETER_RETURN_IF_ABRUPT(superCtor); + + if (superCtor.IsJSFunction() && superCtor.IsConstructor() && !newTarget.IsUndefined()) { + JSFunction *superCtorFunc = JSFunction::Cast(superCtor.GetTaggedObject()); + methodHandle.Update(superCtorFunc->GetMethod()); + if (superCtorFunc->IsBuiltinConstructor()) { + ASSERT(methodHandle->GetNumVregsWithCallField() == 0); + size_t frameSize = + InterpretedFrame::NumOfMembers() + range + NUM_MANDATORY_JSFUNC_ARGS + 2; // 2:thread & numArgs + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + JSTaggedType *newSp = sp - frameSize; + if (UNLIKELY(thread->DoStackOverflowCheck(newSp))) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + // copy args + uint32_t index = 0; + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + EcmaRuntimeCallInfo *ecmaRuntimeCallInfo = reinterpret_cast(newSp); + newSp[index++] = ToUintPtr(thread); + newSp[index++] = range + NUM_MANDATORY_JSFUNC_ARGS; + // func + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = superCtor.GetRawData(); + // newTarget + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = newTarget.GetRawData(); + // this + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + for (size_t i = 0; i < range; ++i) { + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = GET_VREG(v0 + i); + } + + InterpretedBuiltinFrame *state = GET_BUILTIN_FRAME(newSp); + state->base.prev = sp; + state->base.type = FrameType::INTERPRETER_BUILTIN_FRAME; + state->pc = nullptr; + state->function = superCtor; + thread->SetCurrentSPFrame(newSp); + LOG_INST() << "Entry: Runtime SuperCall "; + JSTaggedValue retValue = reinterpret_cast( + const_cast(methodHandle->GetNativePointer()))(ecmaRuntimeCallInfo); + thread->SetCurrentSPFrame(sp); + + if (UNLIKELY(thread->HasPendingException())) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + LOG_INST() << "Exit: Runtime SuperCall "; + SET_ACC(retValue); + DISPATCH(WIDE_SUPERCALLARROWRANGE_PREF_IMM16_V8); + } + + if (IsFastNewFrameEnter(superCtorFunc, methodHandle)) { + SAVE_PC(); + uint32_t numVregs = methodHandle->GetNumVregsWithCallField(); + uint32_t numDeclaredArgs = superCtorFunc->IsBase() ? + methodHandle->GetNumArgsWithCallField() + 1 : // +1 for this + methodHandle->GetNumArgsWithCallField() + 2; // +2 for newTarget and this + // +1 for hidden this, explicit this may be overwritten after bc optimizer + size_t frameSize = InterpretedFrame::NumOfMembers() + numVregs + numDeclaredArgs + 1; + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + JSTaggedType *newSp = sp - frameSize; + InterpretedFrame *state = GET_FRAME(newSp); + + if (UNLIKELY(thread->DoStackOverflowCheck(newSp))) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + + uint32_t index = 0; + // initialize vregs value + for (size_t i = 0; i < numVregs; ++i) { + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + } + + // this + JSTaggedValue thisObj; + if (superCtorFunc->IsBase()) { + thisObj = FastRuntimeStub::NewThisObject(thread, superCtor, newTarget, state); + INTERPRETER_RETURN_IF_ABRUPT(thisObj); + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = thisObj.GetRawData(); + } else { + ASSERT(superCtorFunc->IsDerivedConstructor()); + newSp[index++] = newTarget.GetRawData(); + thisObj = JSTaggedValue::Undefined(); + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = thisObj.GetRawData(); + + state->function = superCtor; + state->constpool = methodHandle->GetConstantPool(); + state->profileTypeInfo = superCtorFunc->GetProfileTypeInfo(); + state->env = superCtorFunc->GetLexicalEnv(); + } + + // the second condition ensure not push extra args + for (size_t i = 0; i < range && index < numVregs + numDeclaredArgs; ++i) { + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = GET_VREG(v0 + i); + } + + // set undefined to the extra prats of declare + for (size_t i = index; i < numVregs + numDeclaredArgs; ++i) { + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + } + + // hidden this object + newSp[index] = thisObj.GetRawData(); + + state->base.prev = sp; + state->base.type = FrameType::INTERPRETER_FAST_NEW_FRAME; + state->pc = pc = methodHandle->GetBytecodeArray(); + sp = newSp; + state->acc = JSTaggedValue::Hole(); + + thread->SetCurrentSPFrame(newSp); + LOG_INST() << "Entry: Runtime SuperCall " << std::hex << reinterpret_cast(sp) + << " " << std::hex << reinterpret_cast(pc); + DISPATCH_OFFSET(0); + } + } + + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::SuperCall(thread, thisFunc, newTarget, v0, range); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(WIDE_SUPERCALLARROWRANGE_PREF_IMM16_V8); + } + HANDLE_OPCODE(SUPERCALLSPREAD_IMM8_V8) { + uint16_t v0 = READ_INST_8_1(); + LOG_INST() << "intrinsic::supercallspread" + << " array: v" << v0; + + JSTaggedValue thisFunc = GET_ACC(); + JSTaggedValue newTarget = GetNewTarget(sp); + JSTaggedValue array = GET_VREG_VALUE(v0); + + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::SuperCallSpread(thread, thisFunc, newTarget, array); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(SUPERCALLSPREAD_IMM8_V8); + } + HANDLE_OPCODE(DEPRECATED_CREATEOBJECTHAVINGMETHOD_PREF_IMM16) { + uint16_t imm = READ_INST_16_1(); + LOG_INST() << "intrinsics::createobjecthavingmethod" + << " imm:" << imm; + JSObject *result = JSObject::Cast(GET_OBJ_FROM_CACHE(imm).GetTaggedObject()); + JSTaggedValue env = GET_ACC(); + + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::CreateObjectHavingMethod(thread, factory, result, env); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(DEPRECATED_CREATEOBJECTHAVINGMETHOD_PREF_IMM16); + } + HANDLE_OPCODE(DEPRECATED_LDHOMEOBJECT_PREF_NONE) { + LOG_INST() << "intrinsics::ldhomeobject"; + + JSTaggedValue thisFunc = GetThisFunction(sp); + JSTaggedValue homeObject = JSFunction::Cast(thisFunc.GetTaggedObject())->GetHomeObject(); + + SET_ACC(homeObject); + DISPATCH(DEPRECATED_LDHOMEOBJECT_PREF_NONE); + } + HANDLE_OPCODE(DEBUGGER) { + LOG_INST() << "intrinsics::debugger"; + DISPATCH(DEBUGGER); + } + HANDLE_OPCODE(ISTRUE) { + LOG_INST() << "intrinsics::istrue"; + if (GET_ACC().ToBoolean()) { + SET_ACC(JSTaggedValue::True()); + } else { + SET_ACC(JSTaggedValue::False()); + } + DISPATCH(ISTRUE); + } + HANDLE_OPCODE(ISFALSE) { + LOG_INST() << "intrinsics::isfalse"; + if (!GET_ACC().ToBoolean()) { + SET_ACC(JSTaggedValue::True()); + } else { + SET_ACC(JSTaggedValue::False()); + } + DISPATCH(ISFALSE); + } + HANDLE_OPCODE(EXCEPTION) { + FrameHandler frameHandler(thread); + uint32_t pcOffset = panda_file::INVALID_OFFSET; + for (; frameHandler.HasFrame(); frameHandler.PrevInterpretedFrame()) { + if (frameHandler.IsEntryFrame()) { + return; + } + auto method = frameHandler.GetMethod(); + pcOffset = FindCatchBlock(method, frameHandler.GetBytecodeOffset()); + if (pcOffset != panda_file::INVALID_OFFSET) { + sp = frameHandler.GetSp(); + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + pc = method->GetBytecodeArray() + pcOffset; + break; + } + } + if (pcOffset == panda_file::INVALID_OFFSET) { + return; + } + + auto exception = thread->GetException(); + SET_ACC(exception); + thread->ClearException(); + thread->SetCurrentSPFrame(sp); + DISPATCH_OFFSET(0); + } + // TODO: Implement code of 16bits ic slot bytecode + HANDLE_OPCODE(TYPEOF_IMM16) { + DISPATCH(TYPEOF_IMM16); + } + HANDLE_OPCODE(CREATEEMPTYARRAY_IMM16) { + DISPATCH(CREATEEMPTYARRAY_IMM16); + } + HANDLE_OPCODE(GETITERATOR_IMM16) { + DISPATCH(GETITERATOR_IMM16); + } + HANDLE_OPCODE(CLOSEITERATOR_IMM16_V8) { + DISPATCH(CLOSEITERATOR_IMM16_V8); + } + HANDLE_OPCODE(STOBJBYVALUE_IMM16_V8_V8) { + DISPATCH(STOBJBYVALUE_IMM16_V8_V8); + } + HANDLE_OPCODE(STOWNBYVALUE_IMM16_V8_V8) { + DISPATCH(STOWNBYVALUE_IMM16_V8_V8); + } + HANDLE_OPCODE(STSUPERBYVALUE_IMM16_V8_V8) { + DISPATCH(STSUPERBYVALUE_IMM16_V8_V8); + } + HANDLE_OPCODE(TRYLDGLOBALBYNAME_IMM16_ID16) { + DISPATCH(TRYLDGLOBALBYNAME_IMM16_ID16); + } + HANDLE_OPCODE(TRYSTGLOBALBYNAME_IMM16_ID16) { + DISPATCH(TRYSTGLOBALBYNAME_IMM16_ID16); + } + HANDLE_OPCODE(STOBJBYNAME_IMM16_ID16_V8) { + DISPATCH(STOBJBYNAME_IMM16_ID16_V8); + } + HANDLE_OPCODE(STOWNBYNAME_IMM16_ID16_V8) { + DISPATCH(STOWNBYNAME_IMM16_ID16_V8); + } + HANDLE_OPCODE(STSUPERBYNAME_IMM16_ID16_V8) { + DISPATCH(STSUPERBYNAME_IMM16_ID16_V8); + } + HANDLE_OPCODE(STOWNBYVALUEWITHNAMESET_IMM16_V8_V8) { + DISPATCH(STOWNBYVALUEWITHNAMESET_IMM16_V8_V8); + } + HANDLE_OPCODE(STOWNBYNAMEWITHNAMESET_IMM16_ID16_V8) { + DISPATCH(STOWNBYNAMEWITHNAMESET_IMM16_ID16_V8); + } + HANDLE_OPCODE(OVERFLOW) { + LOG_INTERPRETER(FATAL) << "opcode overflow"; + } + HANDLE_OPCODE(NOP) { + LOG_INST() << "intrinsics::nop"; + DISPATCH(NOP); + } + HANDLE_OPCODE(THROW) { + DISPATCH_THROW(); + } + HANDLE_OPCODE(WIDE) { + DISPATCH_WIDE(); + } + HANDLE_OPCODE(DEPRECATED) { + DISPATCH_DEPRECATED(); + } + HANDLE_OPCODE(THROW_PREF_NONE) { + LOG_INST() << "intrinsics::throw"; + SAVE_PC(); + SlowRuntimeStub::Throw(thread, GET_ACC()); + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + HANDLE_OPCODE(THROW_CONSTASSIGNMENT_PREF_V8) { + uint16_t v0 = READ_INST_8_1(); + LOG_INST() << "throwconstassignment" + << " v" << v0; + SAVE_PC(); + SlowRuntimeStub::ThrowConstAssignment(thread, GET_VREG_VALUE(v0)); + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + HANDLE_OPCODE(THROW_NOTEXISTS_PREF_NONE) { + LOG_INST() << "throwthrownotexists"; + + SAVE_PC(); + SlowRuntimeStub::ThrowThrowNotExists(thread); + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + HANDLE_OPCODE(THROW_PATTERNNONCOERCIBLE_PREF_NONE) { + LOG_INST() << "throwpatternnoncoercible"; + + SAVE_PC(); + SlowRuntimeStub::ThrowPatternNonCoercible(thread); + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + HANDLE_OPCODE(THROW_IFNOTOBJECT_PREF_V8) { + LOG_INST() << "throwifnotobject"; + uint16_t v0 = READ_INST_8_1(); + + JSTaggedValue value = GET_VREG_VALUE(v0); + // fast path + if (value.IsECMAObject()) { + DISPATCH(THROW_IFNOTOBJECT_PREF_V8); + } + + // slow path + SAVE_PC(); + SlowRuntimeStub::ThrowIfNotObject(thread); + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + HANDLE_OPCODE(THROW_UNDEFINEDIFHOLE_PREF_V8_V8) { + uint16_t v0 = READ_INST_8_1(); + uint16_t v1 = READ_INST_8_2(); + LOG_INST() << "intrinsic::throwundefinedifhole" + << " v" << v0 << " v" << v1; + JSTaggedValue hole = GET_VREG_VALUE(v0); + if (!hole.IsHole()) { + DISPATCH(THROW_UNDEFINEDIFHOLE_PREF_V8_V8); + } + JSTaggedValue obj = GET_VREG_VALUE(v1); + ASSERT(obj.IsString()); + SAVE_PC(); + SlowRuntimeStub::ThrowUndefinedIfHole(thread, obj); + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + HANDLE_OPCODE(THROW_DELETESUPERPROPERTY_PREF_NONE) { + LOG_INST() << "throwdeletesuperproperty"; + + SAVE_PC(); + SlowRuntimeStub::ThrowDeleteSuperProperty(thread); + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + HANDLE_OPCODE(THROW_IFSUPERNOTCORRECTCALL_PREF_IMM8) { + uint8_t imm = READ_INST_8_1(); + JSTaggedValue thisValue = GET_ACC(); + LOG_INST() << "intrinsic::throwifsupernotcorrectcall" + << " imm:" << imm; + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::ThrowIfSuperNotCorrectCall(thread, imm, thisValue); + INTERPRETER_RETURN_IF_ABRUPT(res); + DISPATCH(THROW_IFSUPERNOTCORRECTCALL_PREF_IMM8); + } + HANDLE_OPCODE(THROW_IFSUPERNOTCORRECTCALL_PREF_IMM16) { + uint16_t imm = READ_INST_16_1(); + JSTaggedValue thisValue = GET_ACC(); + LOG_INST() << "intrinsic::throwifsupernotcorrectcall" + << " imm:" << imm; + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::ThrowIfSuperNotCorrectCall(thread, imm, thisValue); + INTERPRETER_RETURN_IF_ABRUPT(res); + DISPATCH(THROW_IFSUPERNOTCORRECTCALL_PREF_IMM16); + } + HANDLE_OPCODE(CREATEOBJECTWITHEXCLUDEDKEYS_IMM8_V8_V8) { + uint8_t numKeys = READ_INST_8_0(); + uint16_t v0 = READ_INST_8_1(); + uint16_t firstArgRegIdx = READ_INST_8_2(); + LOG_INST() << "intrinsics::createobjectwithexcludedkeys " << numKeys << " v" << firstArgRegIdx; + + JSTaggedValue obj = GET_VREG_VALUE(v0); + + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::CreateObjectWithExcludedKeys(thread, numKeys, obj, firstArgRegIdx); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(CREATEOBJECTWITHEXCLUDEDKEYS_IMM8_V8_V8); + } + HANDLE_OPCODE(WIDE_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8) { + uint16_t numKeys = READ_INST_16_1(); + uint16_t v0 = READ_INST_8_3(); + uint16_t firstArgRegIdx = READ_INST_8_4(); + LOG_INST() << "intrinsics::createobjectwithexcludedkeys " << numKeys << " v" << firstArgRegIdx; + + JSTaggedValue obj = GET_VREG_VALUE(v0); + + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::CreateObjectWithExcludedKeys(thread, numKeys, obj, firstArgRegIdx); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(WIDE_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8); + } + HANDLE_OPCODE(NEWOBJRANGE_IMM8_IMM8_V8) { + uint16_t numArgs = READ_INST_8_1(); + uint16_t firstArgRegIdx = READ_INST_8_2(); + LOG_INST() << "intrinsics::newobjRange " << numArgs << " v" << firstArgRegIdx; + JSTaggedValue ctor = GET_VREG_VALUE(firstArgRegIdx); + + if (ctor.IsJSFunction() && ctor.IsConstructor()) { + JSFunction *ctorFunc = JSFunction::Cast(ctor.GetTaggedObject()); + methodHandle.Update(ctorFunc->GetMethod()); + if (ctorFunc->IsBuiltinConstructor()) { + ASSERT(methodHandle->GetNumVregsWithCallField() == 0); + size_t frameSize = InterpretedFrame::NumOfMembers() + numArgs + 3; // 3: this & numArgs & thread + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + JSTaggedType *newSp = sp - frameSize; + if (UNLIKELY(thread->DoStackOverflowCheck(newSp))) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + // copy args + uint32_t index = 0; + // numArgs + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + EcmaRuntimeCallInfo *ecmaRuntimeCallInfo = reinterpret_cast(newSp); + newSp[index++] = ToUintPtr(thread); + newSp[index++] = numArgs + 1; // +1 for this + // func + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = GET_VREG(firstArgRegIdx); + // newTarget + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = GET_VREG(firstArgRegIdx + 1); + // this + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + for (size_t i = 2; i < numArgs; ++i) { // 2: func and newTarget + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = GET_VREG(firstArgRegIdx + i); + } + + InterpretedBuiltinFrame *state = GET_BUILTIN_FRAME(newSp); + state->base.prev = sp; + state->base.type = FrameType::INTERPRETER_BUILTIN_FRAME; + state->pc = nullptr; + state->function = ctor; + thread->SetCurrentSPFrame(newSp); + + LOG_INST() << "Entry: Runtime New."; + SAVE_PC(); + JSTaggedValue retValue = reinterpret_cast( + const_cast(methodHandle->GetNativePointer()))(ecmaRuntimeCallInfo); + thread->SetCurrentSPFrame(sp); + if (UNLIKELY(thread->HasPendingException())) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + LOG_INST() << "Exit: Runtime New."; + SET_ACC(retValue); + DISPATCH(NEWOBJRANGE_IMM8_IMM8_V8); + } + + if (IsFastNewFrameEnter(ctorFunc, methodHandle)) { + SAVE_PC(); + uint32_t numVregs = methodHandle->GetNumVregsWithCallField(); + uint32_t numDeclaredArgs = ctorFunc->IsBase() ? + methodHandle->GetNumArgsWithCallField() + 1 : // +1 for this + methodHandle->GetNumArgsWithCallField() + 2; // +2 for newTarget and this + // +1 for hidden this, explicit this may be overwritten after bc optimizer + size_t frameSize = InterpretedFrame::NumOfMembers() + numVregs + numDeclaredArgs + 1; + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + JSTaggedType *newSp = sp - frameSize; + InterpretedFrame *state = GET_FRAME(newSp); + + if (UNLIKELY(thread->DoStackOverflowCheck(newSp))) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + + uint32_t index = 0; + // initialize vregs value + for (size_t i = 0; i < numVregs; ++i) { + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + } + + // this + JSTaggedValue thisObj; + if (ctorFunc->IsBase()) { + JSTaggedValue newTarget = GET_VREG_VALUE(firstArgRegIdx + 1); + thisObj = FastRuntimeStub::NewThisObject(thread, ctor, newTarget, state); + INTERPRETER_RETURN_IF_ABRUPT(thisObj); + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = thisObj.GetRawData(); + } else { + ASSERT(ctorFunc->IsDerivedConstructor()); + JSTaggedValue newTarget = GET_VREG_VALUE(firstArgRegIdx + 1); + newSp[index++] = newTarget.GetRawData(); + thisObj = JSTaggedValue::Undefined(); + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = thisObj.GetRawData(); + + state->function = ctor; + state->constpool = methodHandle->GetConstantPool(); + state->profileTypeInfo = ctorFunc->GetProfileTypeInfo(); + state->env = ctorFunc->GetLexicalEnv(); + } + + // the second condition ensure not push extra args + for (size_t i = 2; i < numArgs && index < numVregs + numDeclaredArgs; ++i) { // 2: func and newTarget + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = GET_VREG(firstArgRegIdx + i); + } + + // set undefined to the extra prats of declare + for (size_t i = index; i < numVregs + numDeclaredArgs; ++i) { + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + } + + // hidden this object + newSp[index] = thisObj.GetRawData(); + + state->base.prev = sp; + state->base.type = FrameType::INTERPRETER_FAST_NEW_FRAME; + state->pc = pc = methodHandle->GetBytecodeArray(); + sp = newSp; + state->acc = JSTaggedValue::Hole(); + + thread->SetCurrentSPFrame(newSp); + LOG_INST() << "Entry: Runtime New " << std::hex << reinterpret_cast(sp) << " " + << std::hex << reinterpret_cast(pc); + DISPATCH_OFFSET(0); + } + } + + // bound function, proxy, other call types, enter slow path + constexpr uint16_t firstArgOffset = 2; + JSTaggedValue newTarget = GET_VREG_VALUE(firstArgRegIdx + 1); + // Exclude func and newTarget + uint16_t firstArgIdx = firstArgRegIdx + firstArgOffset; + uint16_t length = numArgs - firstArgOffset; + + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::NewObjRange(thread, ctor, newTarget, firstArgIdx, length); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(NEWOBJRANGE_IMM8_IMM8_V8); + } + HANDLE_OPCODE(NEWOBJRANGE_IMM16_IMM8_V8) { + uint16_t numArgs = READ_INST_8_2(); + uint16_t firstArgRegIdx = READ_INST_8_3(); + LOG_INST() << "intrinsics::newobjRange " << numArgs << " v" << firstArgRegIdx; + JSTaggedValue ctor = GET_VREG_VALUE(firstArgRegIdx); + + if (ctor.IsJSFunction() && ctor.IsConstructor()) { + JSFunction *ctorFunc = JSFunction::Cast(ctor.GetTaggedObject()); + methodHandle.Update(ctorFunc->GetMethod()); + if (ctorFunc->IsBuiltinConstructor()) { + ASSERT(methodHandle->GetNumVregsWithCallField() == 0); + size_t frameSize = InterpretedFrame::NumOfMembers() + numArgs + 3; // 3: this & numArgs & thread + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + JSTaggedType *newSp = sp - frameSize; + if (UNLIKELY(thread->DoStackOverflowCheck(newSp))) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + // copy args + uint32_t index = 0; + // numArgs + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + EcmaRuntimeCallInfo *ecmaRuntimeCallInfo = reinterpret_cast(newSp); + newSp[index++] = ToUintPtr(thread); + newSp[index++] = numArgs + 1; // +1 for this + // func + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = GET_VREG(firstArgRegIdx); + // newTarget + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = GET_VREG(firstArgRegIdx + 1); + // this + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + for (size_t i = 2; i < numArgs; ++i) { // 2: func and newTarget + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = GET_VREG(firstArgRegIdx + i); + } + + InterpretedBuiltinFrame *state = GET_BUILTIN_FRAME(newSp); + state->base.prev = sp; + state->base.type = FrameType::INTERPRETER_BUILTIN_FRAME; + state->pc = nullptr; + state->function = ctor; + thread->SetCurrentSPFrame(newSp); + + LOG_INST() << "Entry: Runtime New."; + SAVE_PC(); + JSTaggedValue retValue = reinterpret_cast( + const_cast(methodHandle->GetNativePointer()))(ecmaRuntimeCallInfo); + thread->SetCurrentSPFrame(sp); + if (UNLIKELY(thread->HasPendingException())) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + LOG_INST() << "Exit: Runtime New."; + SET_ACC(retValue); + DISPATCH(NEWOBJRANGE_IMM16_IMM8_V8); + } + + if (IsFastNewFrameEnter(ctorFunc, methodHandle)) { + SAVE_PC(); + uint32_t numVregs = methodHandle->GetNumVregsWithCallField(); + uint32_t numDeclaredArgs = ctorFunc->IsBase() ? + methodHandle->GetNumArgsWithCallField() + 1 : // +1 for this + methodHandle->GetNumArgsWithCallField() + 2; // +2 for newTarget and this + // +1 for hidden this, explicit this may be overwritten after bc optimizer + size_t frameSize = InterpretedFrame::NumOfMembers() + numVregs + numDeclaredArgs + 1; + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + JSTaggedType *newSp = sp - frameSize; + InterpretedFrame *state = GET_FRAME(newSp); + + if (UNLIKELY(thread->DoStackOverflowCheck(newSp))) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + + uint32_t index = 0; + // initialize vregs value + for (size_t i = 0; i < numVregs; ++i) { + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + } + + // this + JSTaggedValue thisObj; + if (ctorFunc->IsBase()) { + JSTaggedValue newTarget = GET_VREG_VALUE(firstArgRegIdx + 1); + thisObj = FastRuntimeStub::NewThisObject(thread, ctor, newTarget, state); + INTERPRETER_RETURN_IF_ABRUPT(thisObj); + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = thisObj.GetRawData(); + } else { + ASSERT(ctorFunc->IsDerivedConstructor()); + JSTaggedValue newTarget = GET_VREG_VALUE(firstArgRegIdx + 1); + newSp[index++] = newTarget.GetRawData(); + thisObj = JSTaggedValue::Undefined(); + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = thisObj.GetRawData(); + + state->function = ctor; + state->constpool = methodHandle->GetConstantPool(); + state->profileTypeInfo = ctorFunc->GetProfileTypeInfo(); + state->env = ctorFunc->GetLexicalEnv(); + } + + // the second condition ensure not push extra args + for (size_t i = 2; i < numArgs && index < numVregs + numDeclaredArgs; ++i) { // 2: func and newTarget + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = GET_VREG(firstArgRegIdx + i); + } + + // set undefined to the extra prats of declare + for (size_t i = index; i < numVregs + numDeclaredArgs; ++i) { + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + } + + // hidden this object + newSp[index] = thisObj.GetRawData(); + + state->base.prev = sp; + state->base.type = FrameType::INTERPRETER_FAST_NEW_FRAME; + state->pc = pc = methodHandle->GetBytecodeArray(); + sp = newSp; + state->acc = JSTaggedValue::Hole(); + + thread->SetCurrentSPFrame(newSp); + LOG_INST() << "Entry: Runtime New " << std::hex << reinterpret_cast(sp) << " " + << std::hex << reinterpret_cast(pc); + DISPATCH_OFFSET(0); + } + } + + // bound function, proxy, other call types, enter slow path + constexpr uint16_t firstArgOffset = 2; + JSTaggedValue newTarget = GET_VREG_VALUE(firstArgRegIdx + 1); + // Exclude func and newTarget + uint16_t firstArgIdx = firstArgRegIdx + firstArgOffset; + uint16_t length = numArgs - firstArgOffset; + + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::NewObjRange(thread, ctor, newTarget, firstArgIdx, length); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(NEWOBJRANGE_IMM16_IMM8_V8); + } + HANDLE_OPCODE(WIDE_NEWOBJRANGE_PREF_IMM16_V8) { + uint16_t numArgs = READ_INST_16_1(); + uint16_t firstArgRegIdx = READ_INST_8_3(); + LOG_INST() << "intrinsics::newobjRange " << numArgs << " v" << firstArgRegIdx; + JSTaggedValue ctor = GET_VREG_VALUE(firstArgRegIdx); + + if (ctor.IsJSFunction() && ctor.IsConstructor()) { + JSFunction *ctorFunc = JSFunction::Cast(ctor.GetTaggedObject()); + methodHandle.Update(ctorFunc->GetMethod()); + if (ctorFunc->IsBuiltinConstructor()) { + ASSERT(methodHandle->GetNumVregsWithCallField() == 0); + size_t frameSize = InterpretedFrame::NumOfMembers() + numArgs + 3; // 3: this & numArgs & thread + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + JSTaggedType *newSp = sp - frameSize; + if (UNLIKELY(thread->DoStackOverflowCheck(newSp))) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + // copy args + uint32_t index = 0; + // numArgs + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + EcmaRuntimeCallInfo *ecmaRuntimeCallInfo = reinterpret_cast(newSp); + newSp[index++] = ToUintPtr(thread); + newSp[index++] = numArgs + 1; // +1 for this + // func + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = GET_VREG(firstArgRegIdx); + // newTarget + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = GET_VREG(firstArgRegIdx + 1); + // this + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + for (size_t i = 2; i < numArgs; ++i) { // 2: func and newTarget + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = GET_VREG(firstArgRegIdx + i); + } + + InterpretedBuiltinFrame *state = GET_BUILTIN_FRAME(newSp); + state->base.prev = sp; + state->base.type = FrameType::INTERPRETER_BUILTIN_FRAME; + state->pc = nullptr; + state->function = ctor; + thread->SetCurrentSPFrame(newSp); + + LOG_INST() << "Entry: Runtime New."; + SAVE_PC(); + JSTaggedValue retValue = reinterpret_cast( + const_cast(methodHandle->GetNativePointer()))(ecmaRuntimeCallInfo); + thread->SetCurrentSPFrame(sp); + if (UNLIKELY(thread->HasPendingException())) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + LOG_INST() << "Exit: Runtime New."; + SET_ACC(retValue); + DISPATCH(WIDE_NEWOBJRANGE_PREF_IMM16_V8); + } + + if (IsFastNewFrameEnter(ctorFunc, methodHandle)) { + SAVE_PC(); + uint32_t numVregs = methodHandle->GetNumVregsWithCallField(); + uint32_t numDeclaredArgs = ctorFunc->IsBase() ? + methodHandle->GetNumArgsWithCallField() + 1 : // +1 for this + methodHandle->GetNumArgsWithCallField() + 2; // +2 for newTarget and this + // +1 for hidden this, explicit this may be overwritten after bc optimizer + size_t frameSize = InterpretedFrame::NumOfMembers() + numVregs + numDeclaredArgs + 1; + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + JSTaggedType *newSp = sp - frameSize; + InterpretedFrame *state = GET_FRAME(newSp); + + if (UNLIKELY(thread->DoStackOverflowCheck(newSp))) { + INTERPRETER_GOTO_EXCEPTION_HANDLER(); + } + + uint32_t index = 0; + // initialize vregs value + for (size_t i = 0; i < numVregs; ++i) { + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + } + + // this + JSTaggedValue thisObj; + if (ctorFunc->IsBase()) { + JSTaggedValue newTarget = GET_VREG_VALUE(firstArgRegIdx + 1); + thisObj = FastRuntimeStub::NewThisObject(thread, ctor, newTarget, state); + INTERPRETER_RETURN_IF_ABRUPT(thisObj); + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = thisObj.GetRawData(); + } else { + ASSERT(ctorFunc->IsDerivedConstructor()); + JSTaggedValue newTarget = GET_VREG_VALUE(firstArgRegIdx + 1); + newSp[index++] = newTarget.GetRawData(); + thisObj = JSTaggedValue::Undefined(); + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = thisObj.GetRawData(); + + state->function = ctor; + state->constpool = methodHandle->GetConstantPool(); + state->profileTypeInfo = ctorFunc->GetProfileTypeInfo(); + state->env = ctorFunc->GetLexicalEnv(); + } + + // the second condition ensure not push extra args + for (size_t i = 2; i < numArgs && index < numVregs + numDeclaredArgs; ++i) { // 2: func and newTarget + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = GET_VREG(firstArgRegIdx + i); + } + + // set undefined to the extra prats of declare + for (size_t i = index; i < numVregs + numDeclaredArgs; ++i) { + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; + } + + // hidden this object + newSp[index] = thisObj.GetRawData(); + + state->base.prev = sp; + state->base.type = FrameType::INTERPRETER_FAST_NEW_FRAME; + state->pc = pc = methodHandle->GetBytecodeArray(); + sp = newSp; + state->acc = JSTaggedValue::Hole(); + + thread->SetCurrentSPFrame(newSp); + LOG_INST() << "Entry: Runtime New " << std::hex << reinterpret_cast(sp) << " " + << std::hex << reinterpret_cast(pc); + DISPATCH_OFFSET(0); + } + } + + // bound function, proxy, other call types, enter slow path + constexpr uint16_t firstArgOffset = 2; + JSTaggedValue newTarget = GET_VREG_VALUE(firstArgRegIdx + 1); + // Exclude func and newTarget + uint16_t firstArgIdx = firstArgRegIdx + firstArgOffset; + uint16_t length = numArgs - firstArgOffset; + + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::NewObjRange(thread, ctor, newTarget, firstArgIdx, length); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(WIDE_NEWOBJRANGE_PREF_IMM16_V8); + } + HANDLE_OPCODE(NEWLEXENV_IMM8) { + uint8_t numVars = READ_INST_8_0(); + LOG_INST() << "intrinsics::newlexenv" + << " imm " << numVars; + + JSTaggedValue res = FastRuntimeStub::NewLexicalEnv(thread, factory, numVars); + if (res.IsHole()) { + SAVE_PC(); + res = SlowRuntimeStub::NewLexicalEnv(thread, numVars); + INTERPRETER_RETURN_IF_ABRUPT(res); + } + SET_ACC(res); + GET_FRAME(sp)->env = res; + DISPATCH(NEWLEXENV_IMM8); + } + HANDLE_OPCODE(WIDE_NEWLEXENV_PREF_IMM16) { + uint16_t numVars = READ_INST_16_1(); + LOG_INST() << "intrinsics::newlexenv" + << " imm " << numVars; + + JSTaggedValue res = FastRuntimeStub::NewLexicalEnv(thread, factory, numVars); + if (res.IsHole()) { + SAVE_PC(); + res = SlowRuntimeStub::NewLexicalEnv(thread, numVars); + INTERPRETER_RETURN_IF_ABRUPT(res); + } + SET_ACC(res); + GET_FRAME(sp)->env = res; + DISPATCH(WIDE_NEWLEXENV_PREF_IMM16); + } + HANDLE_OPCODE(NEWLEXENVWITHNAME_IMM8_ID16) { + uint16_t numVars = READ_INST_8_0(); + uint16_t scopeId = READ_INST_16_1(); + LOG_INST() << "intrinsics::newlexenvwithname" + << " numVars " << numVars << " scopeId " << scopeId; + + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::NewLexicalEnvWithName(thread, numVars, scopeId); + INTERPRETER_RETURN_IF_ABRUPT(res); + + SET_ACC(res); + GET_FRAME(sp)->env = res; + DISPATCH(NEWLEXENVWITHNAME_IMM8_ID16); + } + HANDLE_OPCODE(WIDE_NEWLEXENVWITHNAME_PREF_IMM16_ID16) { + uint16_t numVars = READ_INST_16_1(); + uint16_t scopeId = READ_INST_16_3(); + LOG_INST() << "intrinsics::newlexenvwithname" + << " numVars " << numVars << " scopeId " << scopeId; + + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::NewLexicalEnvWithName(thread, numVars, scopeId); + INTERPRETER_RETURN_IF_ABRUPT(res); + + SET_ACC(res); + GET_FRAME(sp)->env = res; + DISPATCH(WIDE_NEWLEXENVWITHNAME_PREF_IMM16_ID16); + } + HANDLE_OPCODE(DEPRECATED_LDLEXENV_PREF_NONE) { + LOG_INST() << "intrinsics::ldlexenv "; + InterpretedFrame *state = GET_FRAME(sp); + JSTaggedValue currentLexenv = state->env; + SET_ACC(currentLexenv); + DISPATCH(DEPRECATED_LDLEXENV_PREF_NONE); + } + HANDLE_OPCODE(POPLEXENV) { + InterpretedFrame *state = GET_FRAME(sp); + JSTaggedValue currentLexenv = state->env; + JSTaggedValue parentLexenv = LexicalEnv::Cast(currentLexenv.GetTaggedObject())->GetParentEnv(); + GET_FRAME(sp)->env = parentLexenv; + DISPATCH(POPLEXENV); + } + HANDLE_OPCODE(DEPRECATED_POPLEXENV_PREF_NONE) { + InterpretedFrame *state = GET_FRAME(sp); + JSTaggedValue currentLexenv = state->env; + JSTaggedValue parentLexenv = LexicalEnv::Cast(currentLexenv.GetTaggedObject())->GetParentEnv(); + GET_FRAME(sp)->env = parentLexenv; + DISPATCH(DEPRECATED_POPLEXENV_PREF_NONE); + } + HANDLE_OPCODE(DEPRECATED_GETITERATORNEXT_PREF_V8_V8) { + uint16_t v0 = READ_INST_8_1(); + uint16_t v1 = READ_INST_8_2(); + LOG_INST() << "intrinsic::getiteratornext" + << " v" << v0 << " v" << v1; + JSTaggedValue obj = GET_VREG_VALUE(v0); + JSTaggedValue method = GET_VREG_VALUE(v1); + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::GetIteratorNext(thread, obj, method); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(DEPRECATED_GETITERATORNEXT_PREF_V8_V8); + } + HANDLE_OPCODE(CREATEARRAYWITHBUFFER_IMM8_ID16) { + uint16_t imm = READ_INST_16_1(); + LOG_INST() << "intrinsics::createarraywithbuffer" + << " imm:" << imm; + JSArray *result = JSArray::Cast(GET_OBJ_FROM_CACHE(imm).GetTaggedObject()); + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::CreateArrayWithBuffer(thread, factory, result); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(CREATEARRAYWITHBUFFER_IMM8_ID16); + } + HANDLE_OPCODE(CREATEARRAYWITHBUFFER_IMM16_ID16) { + uint16_t imm = READ_INST_16_2(); + LOG_INST() << "intrinsics::createarraywithbuffer" + << " imm:" << imm; + JSArray *result = JSArray::Cast(GET_OBJ_FROM_CACHE(imm).GetTaggedObject()); + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::CreateArrayWithBuffer(thread, factory, result); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(CREATEARRAYWITHBUFFER_IMM16_ID16); + } + HANDLE_OPCODE(DEPRECATED_CREATEARRAYWITHBUFFER_PREF_IMM16) { + uint16_t imm = READ_INST_16_1(); + LOG_INST() << "intrinsics::createarraywithbuffer" + << " imm:" << imm; + JSArray *result = JSArray::Cast(GET_OBJ_FROM_CACHE(imm).GetTaggedObject()); + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::CreateArrayWithBuffer(thread, factory, result); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(DEPRECATED_CREATEARRAYWITHBUFFER_PREF_IMM16); + } + HANDLE_OPCODE(CREATEOBJECTWITHBUFFER_IMM8_ID16) { + uint16_t imm = READ_INST_16_1(); + LOG_INST() << "intrinsics::createobjectwithbuffer" + << " imm:" << imm; + JSObject *result = JSObject::Cast(GET_OBJ_FROM_CACHE(imm).GetTaggedObject()); + + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::CreateObjectWithBuffer(thread, factory, result); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(CREATEOBJECTWITHBUFFER_IMM8_ID16); + } + HANDLE_OPCODE(CREATEOBJECTWITHBUFFER_IMM16_ID16) { + uint16_t imm = READ_INST_16_2(); + LOG_INST() << "intrinsics::createobjectwithbuffer" + << " imm:" << imm; + JSObject *result = JSObject::Cast(GET_OBJ_FROM_CACHE(imm).GetTaggedObject()); + + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::CreateObjectWithBuffer(thread, factory, result); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(CREATEOBJECTWITHBUFFER_IMM16_ID16); + } + HANDLE_OPCODE(DEPRECATED_CREATEOBJECTWITHBUFFER_PREF_IMM16) { + uint16_t imm = READ_INST_16_1(); + LOG_INST() << "intrinsics::createobjectwithbuffer" + << " imm:" << imm; + JSObject *result = JSObject::Cast(GET_OBJ_FROM_CACHE(imm).GetTaggedObject()); + + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::CreateObjectWithBuffer(thread, factory, result); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(DEPRECATED_CREATEOBJECTWITHBUFFER_PREF_IMM16); + } + HANDLE_OPCODE(TONUMBER_IMM8) { + LOG_INST() << "intrinsics::tonumber"; + JSTaggedValue value = GET_ACC(); + if (value.IsNumber()) { + // fast path + SET_ACC(value); + } else { + // slow path + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::ToNumber(thread, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + } + DISPATCH(TONUMBER_IMM8); + } + HANDLE_OPCODE(DEPRECATED_TONUMBER_PREF_V8) { + uint16_t v0 = READ_INST_8_1(); + + LOG_INST() << "intrinsics::tonumber" + << " v" << v0; + JSTaggedValue value = GET_VREG_VALUE(v0); + if (value.IsNumber()) { + // fast path + SET_ACC(value); + } else { + // slow path + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::ToNumber(thread, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + } + DISPATCH(DEPRECATED_TONUMBER_PREF_V8); + } + HANDLE_OPCODE(TONUMERIC_IMM8) { + LOG_INST() << "intrinsics::tonumeric"; + JSTaggedValue value = GET_ACC(); + if (value.IsNumber() || value.IsBigInt()) { + // fast path + SET_ACC(value); + } else { + // slow path + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::ToNumeric(thread, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + } + DISPATCH(TONUMERIC_IMM8); + } + HANDLE_OPCODE(DEPRECATED_TONUMERIC_PREF_V8) { + uint16_t v0 = READ_INST_8_1(); + LOG_INST() << "intrinsics::tonumeric" + << " v" << v0; + JSTaggedValue value = GET_VREG_VALUE(v0); + if (value.IsNumber() || value.IsBigInt()) { + // fast path + SET_ACC(value); + } else { + // slow path + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::ToNumeric(thread, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + } + DISPATCH(DEPRECATED_TONUMERIC_PREF_V8); + } + HANDLE_OPCODE(NEG_IMM8) { + LOG_INST() << "intrinsics::neg"; + JSTaggedValue value = GET_ACC(); + // fast path + if (value.IsInt()) { + if (value.GetInt() == 0) { + SET_ACC(JSTaggedValue(-0.0)); + } else { + SET_ACC(JSTaggedValue(-value.GetInt())); + } + } else if (value.IsDouble()) { + SET_ACC(JSTaggedValue(-value.GetDouble())); + } else { // slow path + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::Neg(thread, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + } + DISPATCH(NEG_IMM8); + } + HANDLE_OPCODE(DEPRECATED_NEG_PREF_V8) { + uint16_t v0 = READ_INST_8_1(); + LOG_INST() << "intrinsics::neg" + << " v" << v0; + JSTaggedValue value = GET_VREG_VALUE(v0); + // fast path + if (value.IsInt()) { + if (value.GetInt() == 0) { + SET_ACC(JSTaggedValue(-0.0)); + } else { + SET_ACC(JSTaggedValue(-value.GetInt())); + } + } else if (value.IsDouble()) { + SET_ACC(JSTaggedValue(-value.GetDouble())); + } else { // slow path + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::Neg(thread, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + } + DISPATCH(DEPRECATED_NEG_PREF_V8); + } + HANDLE_OPCODE(NOT_IMM8) { + LOG_INST() << "intrinsics::not"; + JSTaggedValue value = GET_ACC(); + int32_t number; + // number, fast path + if (value.IsInt()) { + number = static_cast(value.GetInt()); + SET_ACC(JSTaggedValue(~number)); // NOLINT(hicpp-signed-bitwise); + } else if (value.IsDouble()) { + number = base::NumberHelper::DoubleToInt(value.GetDouble(), base::INT32_BITS); + SET_ACC(JSTaggedValue(~number)); // NOLINT(hicpp-signed-bitwise); + } else { + // slow path + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::Not(thread, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + } + DISPATCH(NOT_IMM8); + } + HANDLE_OPCODE(DEPRECATED_NOT_PREF_V8) { + uint16_t v0 = READ_INST_8_1(); + + LOG_INST() << "intrinsics::not" + << " v" << v0; + JSTaggedValue value = GET_VREG_VALUE(v0); + int32_t number; + // number, fast path + if (value.IsInt()) { + number = static_cast(value.GetInt()); + SET_ACC(JSTaggedValue(~number)); // NOLINT(hicpp-signed-bitwise); + } else if (value.IsDouble()) { + number = base::NumberHelper::DoubleToInt(value.GetDouble(), base::INT32_BITS); + SET_ACC(JSTaggedValue(~number)); // NOLINT(hicpp-signed-bitwise); + } else { + // slow path + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::Not(thread, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + } + DISPATCH(DEPRECATED_NOT_PREF_V8); + } + HANDLE_OPCODE(INC_IMM8) { + LOG_INST() << "intrinsics::inc"; + + JSTaggedValue value = GET_ACC(); + // number fast path + if (value.IsInt()) { + int32_t a0 = value.GetInt(); + if (UNLIKELY(a0 == INT32_MAX)) { + auto ret = static_cast(a0) + 1.0; + SET_ACC(JSTaggedValue(ret)); + } else { + SET_ACC(JSTaggedValue(a0 + 1)); + } + } else if (value.IsDouble()) { + SET_ACC(JSTaggedValue(value.GetDouble() + 1.0)); + } else { + // slow path + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::Inc(thread, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + } + DISPATCH(INC_IMM8); + } + HANDLE_OPCODE(DEPRECATED_INC_PREF_V8) { + uint16_t v0 = READ_INST_8_1(); + + LOG_INST() << "intrinsics::inc" + << " v" << v0; + + JSTaggedValue value = GET_VREG_VALUE(v0); + // number fast path + if (value.IsInt()) { + int32_t a0 = value.GetInt(); + if (UNLIKELY(a0 == INT32_MAX)) { + auto ret = static_cast(a0) + 1.0; + SET_ACC(JSTaggedValue(ret)); + } else { + SET_ACC(JSTaggedValue(a0 + 1)); + } + } else if (value.IsDouble()) { + SET_ACC(JSTaggedValue(value.GetDouble() + 1.0)); + } else { + // slow path + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::Inc(thread, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + } + DISPATCH(DEPRECATED_INC_PREF_V8); + } + HANDLE_OPCODE(DEC_IMM8) { + LOG_INST() << "intrinsics::dec"; + + JSTaggedValue value = GET_ACC(); + // number, fast path + if (value.IsInt()) { + int32_t a0 = value.GetInt(); + if (UNLIKELY(a0 == INT32_MIN)) { + auto ret = static_cast(a0) - 1.0; + SET_ACC(JSTaggedValue(ret)); + } else { + SET_ACC(JSTaggedValue(a0 - 1)); + } + } else if (value.IsDouble()) { + SET_ACC(JSTaggedValue(value.GetDouble() - 1.0)); + } else { + // slow path + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::Dec(thread, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + } + DISPATCH(DEC_IMM8); + } + HANDLE_OPCODE(DEPRECATED_DEC_PREF_V8) { + uint16_t v0 = READ_INST_8_1(); + LOG_INST() << "intrinsics::dec" + << " v" << v0; + + JSTaggedValue value = GET_VREG_VALUE(v0); + // number, fast path + if (value.IsInt()) { + int32_t a0 = value.GetInt(); + if (UNLIKELY(a0 == INT32_MIN)) { + auto ret = static_cast(a0) - 1.0; + SET_ACC(JSTaggedValue(ret)); + } else { + SET_ACC(JSTaggedValue(a0 - 1)); + } + } else if (value.IsDouble()) { + SET_ACC(JSTaggedValue(value.GetDouble() - 1.0)); + } else { + // slow path + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::Dec(thread, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + } + DISPATCH(DEPRECATED_DEC_PREF_V8); + } + HANDLE_OPCODE(DEFINEFUNC_IMM8_ID16_IMM8) { + uint16_t methodId = READ_INST_16_1(); + uint16_t length = READ_INST_8_3(); + LOG_INST() << "intrinsics::definefunc length: " << length; + JSFunction *result = JSFunction::Cast(GET_OBJ_FROM_CACHE(methodId).GetTaggedObject()); + ASSERT(result != nullptr); + if (result->GetResolved()) { + SAVE_PC(); + auto res = SlowRuntimeStub::Definefunc(thread, result); + INTERPRETER_RETURN_IF_ABRUPT(res); + result = JSFunction::Cast(res.GetTaggedObject()); + } else { + result->SetResolved(true); + } + + result->SetPropertyInlinedProps(thread, JSFunction::LENGTH_INLINE_PROPERTY_INDEX, JSTaggedValue(length)); + InterpretedFrame *state = GET_FRAME(sp); + JSTaggedValue envHandle = state->env; + result->SetLexicalEnv(thread, envHandle); + + JSFunction *currentFunc = JSFunction::Cast((GET_FRAME(sp)->function).GetTaggedObject()); + result->SetModule(thread, currentFunc->GetModule()); + SET_ACC(JSTaggedValue(result)); + + DISPATCH(DEFINEFUNC_IMM8_ID16_IMM8); + } + HANDLE_OPCODE(DEFINEFUNC_IMM16_ID16_IMM8) { + uint16_t methodId = READ_INST_16_2(); + uint16_t length = READ_INST_8_4(); + LOG_INST() << "intrinsics::definefunc length: " << length; + JSFunction *result = JSFunction::Cast(GET_OBJ_FROM_CACHE(methodId).GetTaggedObject()); + ASSERT(result != nullptr); + if (result->GetResolved()) { + SAVE_PC(); + auto res = SlowRuntimeStub::Definefunc(thread, result); + INTERPRETER_RETURN_IF_ABRUPT(res); + result = JSFunction::Cast(res.GetTaggedObject()); + } else { + result->SetResolved(true); + } + + result->SetPropertyInlinedProps(thread, JSFunction::LENGTH_INLINE_PROPERTY_INDEX, JSTaggedValue(length)); + InterpretedFrame *state = GET_FRAME(sp); + JSTaggedValue envHandle = state->env; + result->SetLexicalEnv(thread, envHandle); + + JSFunction *currentFunc = JSFunction::Cast((GET_FRAME(sp)->function).GetTaggedObject()); + result->SetModule(thread, currentFunc->GetModule()); + SET_ACC(JSTaggedValue(result)); + + DISPATCH(DEFINEFUNC_IMM16_ID16_IMM8); + } + HANDLE_OPCODE(DEPRECATED_DEFINEFUNC_PREF_ID16_IMM16_V8) { + uint16_t methodId = READ_INST_16_1(); + uint16_t length = READ_INST_16_3(); + uint16_t v0 = READ_INST_8_5(); + LOG_INST() << "intrinsics::definefunc length: " << length + << " v" << v0; + JSFunction *result = JSFunction::Cast(GET_OBJ_FROM_CACHE(methodId).GetTaggedObject()); + ASSERT(result != nullptr); + if (result->GetResolved()) { + SAVE_PC(); + auto res = SlowRuntimeStub::Definefunc(thread, result); + INTERPRETER_RETURN_IF_ABRUPT(res); + result = JSFunction::Cast(res.GetTaggedObject()); + } else { + result->SetResolved(true); + } + + result->SetPropertyInlinedProps(thread, JSFunction::LENGTH_INLINE_PROPERTY_INDEX, JSTaggedValue(length)); + JSTaggedValue envHandle = GET_VREG_VALUE(v0); + result->SetLexicalEnv(thread, envHandle); + + JSFunction *currentFunc = JSFunction::Cast((GET_FRAME(sp)->function).GetTaggedObject()); + result->SetModule(thread, currentFunc->GetModule()); + SET_ACC(JSTaggedValue(result)); + + DISPATCH(DEPRECATED_DEFINEFUNC_PREF_ID16_IMM16_V8); + } + HANDLE_OPCODE(DEPRECATED_DEFINENCFUNC_PREF_ID16_IMM16_V8) { + uint16_t methodId = READ_INST_16_1(); + uint16_t length = READ_INST_16_3(); + uint16_t v0 = READ_INST_8_5(); + JSTaggedValue homeObject = GET_ACC(); + LOG_INST() << "intrinsics::definencfunc length: " << length + << " v" << v0; + JSFunction *result = JSFunction::Cast(GET_OBJ_FROM_CACHE(methodId).GetTaggedObject()); + ASSERT(result != nullptr); + if (result->GetResolved()) { + SAVE_ACC(); + SAVE_PC(); + auto res = SlowRuntimeStub::DefineNCFunc(thread, result); + INTERPRETER_RETURN_IF_ABRUPT(res); + result = JSFunction::Cast(res.GetTaggedObject()); + RESTORE_ACC(); + homeObject = GET_ACC(); + } else { + result->SetResolved(true); + } + + result->SetPropertyInlinedProps(thread, JSFunction::LENGTH_INLINE_PROPERTY_INDEX, JSTaggedValue(length)); + JSTaggedValue env = GET_VREG_VALUE(v0); + result->SetLexicalEnv(thread, env); + result->SetHomeObject(thread, homeObject); + + JSFunction *currentFunc = JSFunction::Cast((GET_FRAME(sp)->function).GetTaggedObject()); + result->SetModule(thread, currentFunc->GetModule()); + SET_ACC(JSTaggedValue(result)); + + DISPATCH(DEPRECATED_DEFINENCFUNC_PREF_ID16_IMM16_V8); + } + HANDLE_OPCODE(DEPRECATED_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8) { + uint16_t methodId = READ_INST_16_1(); + uint16_t length = READ_INST_16_3(); + uint16_t v0 = READ_INST_8_5(); + LOG_INST() << "define gengerator function length: " << length + << " v" << v0; + JSFunction *result = JSFunction::Cast(GET_OBJ_FROM_CACHE(methodId).GetTaggedObject()); + ASSERT(result != nullptr); + if (result->GetResolved()) { + SAVE_PC(); + auto res = SlowRuntimeStub::DefineGeneratorFunc(thread, result); + INTERPRETER_RETURN_IF_ABRUPT(res); + result = JSFunction::Cast(res.GetTaggedObject()); + } else { + result->SetResolved(true); + } + + result->SetPropertyInlinedProps(thread, JSFunction::LENGTH_INLINE_PROPERTY_INDEX, JSTaggedValue(length)); + JSTaggedValue env = GET_VREG_VALUE(v0); + result->SetLexicalEnv(thread, env); + + JSFunction *currentFunc = JSFunction::Cast((GET_FRAME(sp)->function).GetTaggedObject()); + result->SetModule(thread, currentFunc->GetModule()); + SET_ACC(JSTaggedValue(result)); + DISPATCH(DEPRECATED_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8); + } + HANDLE_OPCODE(DEPRECATED_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8) { + uint16_t methodId = READ_INST_16_1(); + uint16_t length = READ_INST_16_3(); + uint16_t v0 = READ_INST_8_5(); + LOG_INST() << "define async function length: " << length + << " v" << v0; + JSFunction *result = JSFunction::Cast(GET_OBJ_FROM_CACHE(methodId).GetTaggedObject()); + ASSERT(result != nullptr); + if (result->GetResolved()) { + SAVE_PC(); + auto res = SlowRuntimeStub::DefineAsyncFunc(thread, result); + INTERPRETER_RETURN_IF_ABRUPT(res); + result = JSFunction::Cast(res.GetTaggedObject()); + } else { + result->SetResolved(true); + } + + result->SetPropertyInlinedProps(thread, JSFunction::LENGTH_INLINE_PROPERTY_INDEX, JSTaggedValue(length)); + JSTaggedValue env = GET_VREG_VALUE(v0); + result->SetLexicalEnv(thread, env); + + JSFunction *currentFunc = JSFunction::Cast((GET_FRAME(sp)->function).GetTaggedObject()); + result->SetModule(thread, currentFunc->GetModule()); + SET_ACC(JSTaggedValue(result)); + DISPATCH(DEPRECATED_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8); + } + HANDLE_OPCODE(DEFINEMETHOD_IMM8_ID16_IMM8) { + uint16_t methodId = READ_INST_16_1(); + uint16_t length = READ_INST_16_3(); + JSTaggedValue homeObject = GET_ACC(); + LOG_INST() << "intrinsics::definemethod length: " << length; + JSFunction *result = JSFunction::Cast(GET_OBJ_FROM_CACHE(methodId).GetTaggedObject()); + ASSERT(result != nullptr); + if (result->GetResolved()) { + SAVE_PC(); + auto res = SlowRuntimeStub::DefineMethod(thread, result, homeObject); + INTERPRETER_RETURN_IF_ABRUPT(res); + result = JSFunction::Cast(res.GetTaggedObject()); + } else { + result->SetHomeObject(thread, homeObject); + result->SetResolved(true); + } + + result->SetPropertyInlinedProps(thread, JSFunction::LENGTH_INLINE_PROPERTY_INDEX, JSTaggedValue(length)); + InterpretedFrame *state = GET_FRAME(sp); + JSTaggedValue taggedCurEnv = state->env; + result->SetLexicalEnv(thread, taggedCurEnv); + + JSFunction *currentFunc = JSFunction::Cast((GET_FRAME(sp)->function).GetTaggedObject()); + result->SetModule(thread, currentFunc->GetModule()); + SET_ACC(JSTaggedValue(result)); + + DISPATCH(DEFINEMETHOD_IMM8_ID16_IMM8); + } + HANDLE_OPCODE(DEFINEMETHOD_IMM16_ID16_IMM8) { + uint16_t methodId = READ_INST_16_2(); + uint16_t length = READ_INST_16_4(); + JSTaggedValue homeObject = GET_ACC(); + LOG_INST() << "intrinsics::definemethod length: " << length; + JSFunction *result = JSFunction::Cast(GET_OBJ_FROM_CACHE(methodId).GetTaggedObject()); + ASSERT(result != nullptr); + if (result->GetResolved()) { + SAVE_PC(); + auto res = SlowRuntimeStub::DefineMethod(thread, result, homeObject); + INTERPRETER_RETURN_IF_ABRUPT(res); + result = JSFunction::Cast(res.GetTaggedObject()); + } else { + result->SetHomeObject(thread, homeObject); + result->SetResolved(true); + } + + result->SetPropertyInlinedProps(thread, JSFunction::LENGTH_INLINE_PROPERTY_INDEX, JSTaggedValue(length)); + InterpretedFrame *state = GET_FRAME(sp); + JSTaggedValue taggedCurEnv = state->env; + result->SetLexicalEnv(thread, taggedCurEnv); + + JSFunction *currentFunc = JSFunction::Cast((GET_FRAME(sp)->function).GetTaggedObject()); + result->SetModule(thread, currentFunc->GetModule()); + SET_ACC(JSTaggedValue(result)); + + DISPATCH(DEFINEMETHOD_IMM16_ID16_IMM8); + } + HANDLE_OPCODE(DEPRECATED_DEFINEMETHOD_PREF_ID16_IMM16_V8) { + uint16_t methodId = READ_INST_16_1(); + uint16_t length = READ_INST_16_3(); + uint16_t v0 = READ_INST_8_5(); + JSTaggedValue homeObject = GET_ACC(); + LOG_INST() << "intrinsics::definemethod length: " << length + << " v" << v0; + JSFunction *result = JSFunction::Cast(GET_OBJ_FROM_CACHE(methodId).GetTaggedObject()); + ASSERT(result != nullptr); + if (result->GetResolved()) { + SAVE_PC(); + auto res = SlowRuntimeStub::DefineMethod(thread, result, homeObject); + INTERPRETER_RETURN_IF_ABRUPT(res); + result = JSFunction::Cast(res.GetTaggedObject()); + } else { + result->SetHomeObject(thread, homeObject); + result->SetResolved(true); + } + + result->SetPropertyInlinedProps(thread, JSFunction::LENGTH_INLINE_PROPERTY_INDEX, JSTaggedValue(length)); + JSTaggedValue taggedCurEnv = GET_VREG_VALUE(v0); + result->SetLexicalEnv(thread, taggedCurEnv); + + JSFunction *currentFunc = JSFunction::Cast((GET_FRAME(sp)->function).GetTaggedObject()); + result->SetModule(thread, currentFunc->GetModule()); + SET_ACC(JSTaggedValue(result)); + + DISPATCH(DEPRECATED_DEFINEMETHOD_PREF_ID16_IMM16_V8); + } + HANDLE_OPCODE(DEFINECLASSWITHBUFFER_IMM8_ID16_ID16_IMM16_V8) { + uint16_t methodId = READ_INST_16_1(); + uint16_t length = READ_INST_16_5(); + uint16_t v0 = READ_INST_8_7(); + LOG_INST() << "intrinsics::defineclasswithbuffer" + << " method id:" << methodId << " lexenv: v" << v0; + JSFunction *classTemplate = JSFunction::Cast(GET_OBJ_FROM_CACHE(methodId).GetTaggedObject()); + ASSERT(classTemplate != nullptr); + + JSTaggedValue lexenv = GET_VREG_VALUE(v0); + JSTaggedValue proto = GET_ACC(); - SAVE_ACC(); - receiver = GET_VREG_VALUE(v0); // Maybe moved by GC - auto propKey = GET_OBJ_FROM_CACHE(stringId); // Maybe moved by GC - auto value = GET_ACC(); // Maybe moved by GC + JSTaggedValue res; SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::StOwnByName(thread, receiver, propKey, value); - RESTORE_ACC(); + res = SlowRuntimeStub::CloneClassFromTemplate(thread, JSTaggedValue(classTemplate), proto, lexenv); + INTERPRETER_RETURN_IF_ABRUPT(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); - } - HANDLE_OPCODE(HANDLE_CREATEEMPTYARRAY_PREF) { - LOG_INST() << "intrinsics::createemptyarray"; - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::CreateEmptyArray(thread, factory, globalEnv); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); - } - HANDLE_OPCODE(HANDLE_CREATEEMPTYOBJECT_PREF) { - LOG_INST() << "intrinsics::createemptyobject"; - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::CreateEmptyObject(thread, factory, globalEnv); + ASSERT(res.IsClassConstructor()); + JSFunction *cls = JSFunction::Cast(res.GetTaggedObject()); + + lexenv = GET_VREG_VALUE(v0); // slow runtime may gc + cls->SetLexicalEnv(thread, lexenv); + + JSFunction *currentFunc = JSFunction::Cast((GET_FRAME(sp)->function).GetTaggedObject()); + cls->SetModule(thread, currentFunc->GetModule()); + + SlowRuntimeStub::SetClassConstructorLength(thread, res, JSTaggedValue(length)); + SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(DEFINECLASSWITHBUFFER_IMM8_ID16_ID16_IMM16_V8); } - HANDLE_OPCODE(HANDLE_CREATEOBJECTWITHBUFFER_PREF_IMM16) { - uint16_t imm = READ_INST_16_1(); - LOG_INST() << "intrinsics::createobjectwithbuffer" - << " imm:" << imm; - JSObject *result = JSObject::Cast(GET_OBJ_FROM_CACHE(imm).GetTaggedObject()); + HANDLE_OPCODE(DEFINECLASSWITHBUFFER_IMM16_ID16_ID16_IMM16_V8) { + uint16_t methodId = READ_INST_16_2(); + uint16_t length = READ_INST_16_6(); + uint16_t v0 = READ_INST_8_8(); + LOG_INST() << "intrinsics::defineclasswithbuffer" + << " method id:" << methodId << " lexenv: v" << v0; + JSFunction *classTemplate = JSFunction::Cast(GET_OBJ_FROM_CACHE(methodId).GetTaggedObject()); + ASSERT(classTemplate != nullptr); + + JSTaggedValue lexenv = GET_VREG_VALUE(v0); + JSTaggedValue proto = GET_ACC(); + JSTaggedValue res; SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::CreateObjectWithBuffer(thread, factory, result); + res = SlowRuntimeStub::CloneClassFromTemplate(thread, JSTaggedValue(classTemplate), proto, lexenv); + INTERPRETER_RETURN_IF_ABRUPT(res); + ASSERT(res.IsClassConstructor()); + JSFunction *cls = JSFunction::Cast(res.GetTaggedObject()); + + lexenv = GET_VREG_VALUE(v0); // slow runtime may gc + cls->SetLexicalEnv(thread, lexenv); + + JSFunction *currentFunc = JSFunction::Cast((GET_FRAME(sp)->function).GetTaggedObject()); + cls->SetModule(thread, currentFunc->GetModule()); + + SlowRuntimeStub::SetClassConstructorLength(thread, res, JSTaggedValue(length)); + SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16); - } - HANDLE_OPCODE(HANDLE_SETOBJECTWITHPROTO_PREF_V8_V8) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - LOG_INST() << "intrinsics::setobjectwithproto" - << " v" << v0 << " v" << v1; - JSTaggedValue proto = GET_VREG_VALUE(v0); - JSTaggedValue obj = GET_VREG_VALUE(v1); - SAVE_ACC(); - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::SetObjectWithProto(thread, proto, obj); - INTERPRETER_RETURN_IF_ABRUPT(res); - RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(DEFINECLASSWITHBUFFER_IMM16_ID16_ID16_IMM16_V8); } - HANDLE_OPCODE(HANDLE_CREATEARRAYWITHBUFFER_PREF_IMM16) { - uint16_t imm = READ_INST_16_1(); - LOG_INST() << "intrinsics::createarraywithbuffer" - << " imm:" << imm; - JSArray *result = JSArray::Cast(GET_OBJ_FROM_CACHE(imm).GetTaggedObject()); + HANDLE_OPCODE(DEPRECATED_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8) { + uint16_t methodId = READ_INST_16_1(); + uint16_t length = READ_INST_16_5(); + uint16_t v0 = READ_INST_8_7(); + uint16_t v1 = READ_INST_8_8(); + LOG_INST() << "intrinsics::defineclasswithbuffer" + << " method id:" << methodId << " lexenv: v" << v0 << " parent: v" << v1; + JSFunction *classTemplate = JSFunction::Cast(GET_OBJ_FROM_CACHE(methodId).GetTaggedObject()); + ASSERT(classTemplate != nullptr); + + JSTaggedValue lexenv = GET_VREG_VALUE(v0); + JSTaggedValue proto = GET_VREG_VALUE(v1); + + JSTaggedValue res; SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::CreateArrayWithBuffer(thread, factory, result); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16); - } - HANDLE_OPCODE(HANDLE_GETMODULENAMESPACE_PREF_ID32) { - uint32_t stringId = READ_INST_32_1(); - auto localName = GET_OBJ_FROM_CACHE(stringId); + res = SlowRuntimeStub::CloneClassFromTemplate(thread, JSTaggedValue(classTemplate), proto, lexenv); - LOG_INST() << "intrinsics::getmodulenamespace " - << "stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(localName.GetTaggedObject())); + INTERPRETER_RETURN_IF_ABRUPT(res); + ASSERT(res.IsClassConstructor()); + JSFunction *cls = JSFunction::Cast(res.GetTaggedObject()); - JSTaggedValue moduleNamespace = SlowRuntimeStub::GetModuleNamespace(thread, localName); - INTERPRETER_RETURN_IF_ABRUPT(moduleNamespace); - SET_ACC(moduleNamespace); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); - } - HANDLE_OPCODE(HANDLE_STMODULEVAR_PREF_ID32) { - uint32_t stringId = READ_INST_32_1(); - auto key = GET_OBJ_FROM_CACHE(stringId); + lexenv = GET_VREG_VALUE(v0); // slow runtime may gc + cls->SetLexicalEnv(thread, lexenv); - LOG_INST() << "intrinsics::stmodulevar " - << "stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(key.GetTaggedObject())); + JSFunction *currentFunc = JSFunction::Cast((GET_FRAME(sp)->function).GetTaggedObject()); + cls->SetModule(thread, currentFunc->GetModule()); - JSTaggedValue value = GET_ACC(); + SlowRuntimeStub::SetClassConstructorLength(thread, res, JSTaggedValue(length)); - SAVE_ACC(); - SlowRuntimeStub::StModuleVar(thread, key, value); - RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + SET_ACC(res); + DISPATCH(DEPRECATED_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8); } - HANDLE_OPCODE(HANDLE_COPYMODULE_PREF_V8) { - DISPATCH(BytecodeInstruction::Format::PREF_V8); + HANDLE_OPCODE(RESUMEGENERATOR) { + LOG_INST() << "intrinsics::resumegenerator"; + JSTaggedValue objVal = GET_ACC(); + + if (objVal.IsAsyncGeneratorObject()) { + JSAsyncGeneratorObject *obj = JSAsyncGeneratorObject::Cast(objVal.GetTaggedObject()); + SET_ACC(obj->GetResumeResult()); + } else { + JSGeneratorObject *obj = JSGeneratorObject::Cast(objVal.GetTaggedObject()); + SET_ACC(obj->GetResumeResult()); + } + DISPATCH(RESUMEGENERATOR); } - HANDLE_OPCODE(HANDLE_LDMODULEVAR_PREF_ID32_IMM8) { - uint32_t stringId = READ_INST_32_1(); - uint8_t innerFlag = READ_INST_8_5(); + HANDLE_OPCODE(DEPRECATED_RESUMEGENERATOR_PREF_V8) { + LOG_INST() << "intrinsics::resumegenerator"; + uint16_t vs = READ_INST_8_1(); + JSTaggedValue objVal = GET_VREG_VALUE(vs); - JSTaggedValue key = GET_OBJ_FROM_CACHE(stringId); - LOG_INST() << "intrinsics::ldmodulevar " - << "string_id:" << stringId << ", " - << "key: " << ConvertToString(EcmaString::Cast(key.GetTaggedObject())); + if (objVal.IsAsyncGeneratorObject()) { + JSAsyncGeneratorObject *obj = JSAsyncGeneratorObject::Cast(objVal.GetTaggedObject()); + SET_ACC(obj->GetResumeResult()); + } else { + JSGeneratorObject *obj = JSGeneratorObject::Cast(objVal.GetTaggedObject()); + SET_ACC(obj->GetResumeResult()); + } + DISPATCH(DEPRECATED_RESUMEGENERATOR_PREF_V8); + } + HANDLE_OPCODE(GETRESUMEMODE) { + LOG_INST() << "intrinsics::getresumemode"; + JSTaggedValue objVal = GET_ACC(); - JSTaggedValue moduleVar = SlowRuntimeStub::LdModuleVar(thread, key, innerFlag != 0); - INTERPRETER_RETURN_IF_ABRUPT(moduleVar); - SET_ACC(moduleVar); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_IMM8); + if (objVal.IsAsyncGeneratorObject()) { + JSAsyncGeneratorObject *obj = JSAsyncGeneratorObject::Cast(objVal.GetTaggedObject()); + SET_ACC(JSTaggedValue(static_cast(obj->GetResumeMode()))); + } else { + JSGeneratorObject *obj = JSGeneratorObject::Cast(objVal.GetTaggedObject()); + SET_ACC(JSTaggedValue(static_cast(obj->GetResumeMode()))); + } + DISPATCH(GETRESUMEMODE); } - HANDLE_OPCODE(HANDLE_CREATEREGEXPWITHLITERAL_PREF_ID32_IMM8) { - uint32_t stringId = READ_INST_32_1(); - JSTaggedValue pattern = GET_OBJ_FROM_CACHE(stringId); - uint8_t flags = READ_INST_8_5(); - LOG_INST() << "intrinsics::createregexpwithliteral " - << "stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(pattern.GetTaggedObject())) - << ", flags:" << flags; - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::CreateRegExpWithLiteral(thread, pattern, flags); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_IMM8); + HANDLE_OPCODE(DEPRECATED_GETRESUMEMODE_PREF_V8) { + LOG_INST() << "intrinsics::getresumemode"; + uint16_t vs = READ_INST_8_1(); + JSTaggedValue objVal = GET_VREG_VALUE(vs); + + if (objVal.IsAsyncGeneratorObject()) { + JSAsyncGeneratorObject *obj = JSAsyncGeneratorObject::Cast(objVal.GetTaggedObject()); + SET_ACC(JSTaggedValue(static_cast(obj->GetResumeMode()))); + } else { + JSGeneratorObject *obj = JSGeneratorObject::Cast(objVal.GetTaggedObject()); + SET_ACC(JSTaggedValue(static_cast(obj->GetResumeMode()))); + } + DISPATCH(DEPRECATED_GETRESUMEMODE_PREF_V8); } - HANDLE_OPCODE(HANDLE_GETTEMPLATEOBJECT_PREF_V8) { - uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsic::gettemplateobject" - << " v" << v0; + HANDLE_OPCODE(GETTEMPLATEOBJECT_IMM8) { + LOG_INST() << "intrinsic::gettemplateobject"; - JSTaggedValue literal = GET_VREG_VALUE(v0); + JSTaggedValue literal = GET_ACC(); SAVE_PC(); JSTaggedValue res = SlowRuntimeStub::GetTemplateObject(thread, literal); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8); - } - HANDLE_OPCODE(HANDLE_GETNEXTPROPNAME_PREF_V8) { - uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsic::getnextpropname" - << " v" << v0; - JSTaggedValue iter = GET_VREG_VALUE(v0); - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::GetNextPropName(thread, iter); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8); - } - HANDLE_OPCODE(HANDLE_COPYDATAPROPERTIES_PREF_V8_V8) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - LOG_INST() << "intrinsic::copydataproperties" - << " v" << v0 << " v" << v1; - JSTaggedValue dst = GET_VREG_VALUE(v0); - JSTaggedValue src = GET_VREG_VALUE(v1); - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::CopyDataProperties(thread, dst, src); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); - } - HANDLE_OPCODE(HANDLE_STOWNBYINDEX_PREF_V8_IMM32) { - uint32_t v0 = READ_INST_8_1(); - uint32_t index = READ_INST_32_2(); - LOG_INST() << "intrinsics::stownbyindex" - << " v" << v0 << " imm" << index; - JSTaggedValue receiver = GET_VREG_VALUE(v0); - // fast path - if (receiver.IsHeapObject() && !receiver.IsClassConstructor() && !receiver.IsClassPrototype()) { - SAVE_ACC(); - JSTaggedValue value = GET_ACC(); - // fast path - JSTaggedValue res = - FastRuntimeStub::SetPropertyByIndex(thread, receiver, index, value); - if (!res.IsHole()) { - INTERPRETER_RETURN_IF_ABRUPT(res); - RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_V8_IMM32); - } - RESTORE_ACC(); - } - SAVE_ACC(); - receiver = GET_VREG_VALUE(v0); // Maybe moved by GC - auto value = GET_ACC(); // Maybe moved by GC - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::StOwnByIndex(thread, receiver, index, value); - INTERPRETER_RETURN_IF_ABRUPT(res); - RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_V8_IMM32); + DISPATCH(GETTEMPLATEOBJECT_IMM8); } - HANDLE_OPCODE(HANDLE_STOWNBYVALUE_PREF_V8_V8) { - uint32_t v0 = READ_INST_8_1(); - uint32_t v1 = READ_INST_8_2(); - LOG_INST() << "intrinsics::stownbyvalue" - << " v" << v0 << " v" << v1; - - JSTaggedValue receiver = GET_VREG_VALUE(v0); - if (receiver.IsHeapObject() && !receiver.IsClassConstructor() && !receiver.IsClassPrototype()) { - SAVE_ACC(); - JSTaggedValue propKey = GET_VREG_VALUE(v1); - JSTaggedValue value = GET_ACC(); - // fast path - JSTaggedValue res = FastRuntimeStub::SetPropertyByValue(thread, receiver, propKey, value); + HANDLE_OPCODE(GETTEMPLATEOBJECT_IMM16) { + LOG_INST() << "intrinsic::gettemplateobject"; - // SetPropertyByValue maybe gc need update the value - RESTORE_ACC(); - propKey = GET_VREG_VALUE(v1); - value = GET_ACC(); - if (!res.IsHole()) { - INTERPRETER_RETURN_IF_ABRUPT(res); - RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); - } - } + JSTaggedValue literal = GET_ACC(); + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::GetTemplateObject(thread, literal); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(GETTEMPLATEOBJECT_IMM16); + } + HANDLE_OPCODE(DEPRECATED_GETTEMPLATEOBJECT_PREF_V8) { + uint16_t v0 = READ_INST_8_1(); + LOG_INST() << "intrinsic::gettemplateobject" + << " v" << v0; - // slow path - SAVE_ACC(); - receiver = GET_VREG_VALUE(v0); // Maybe moved by GC - auto propKey = GET_VREG_VALUE(v1); // Maybe moved by GC - auto value = GET_ACC(); // Maybe moved by GC + JSTaggedValue literal = GET_VREG_VALUE(v0); SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::StOwnByValue(thread, receiver, propKey, value); - RESTORE_ACC(); + JSTaggedValue res = SlowRuntimeStub::GetTemplateObject(thread, literal); INTERPRETER_RETURN_IF_ABRUPT(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + SET_ACC(res); + DISPATCH(DEPRECATED_GETTEMPLATEOBJECT_PREF_V8); } - HANDLE_OPCODE(HANDLE_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8) { - uint16_t numKeys = READ_INST_16_1(); - uint16_t v0 = READ_INST_8_3(); - uint16_t firstArgRegIdx = READ_INST_8_4(); - LOG_INST() << "intrinsics::createobjectwithexcludedkeys " << numKeys << " v" << firstArgRegIdx; + HANDLE_OPCODE(DELOBJPROP_V8) { + uint16_t v0 = READ_INST_8_0(); + LOG_INST() << "intrinsics::delobjprop" + << " v0" << v0; JSTaggedValue obj = GET_VREG_VALUE(v0); - + JSTaggedValue prop = GET_ACC(); SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::CreateObjectWithExcludedKeys(thread, numKeys, obj, firstArgRegIdx); + JSTaggedValue res = SlowRuntimeStub::DelObjProp(thread, obj, prop); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16_V8_V8); + + DISPATCH(DELOBJPROP_V8); } - HANDLE_OPCODE(HANDLE_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8) { - uint16_t methodId = READ_INST_16_1(); - uint16_t length = READ_INST_16_3(); - uint16_t v0 = READ_INST_8_5(); - LOG_INST() << "define gengerator function length: " << length - << " v" << v0; - JSFunction *result = JSFunction::Cast(GET_OBJ_FROM_CACHE(methodId).GetTaggedObject()); - ASSERT(result != nullptr); - if (result->GetResolved()) { - SAVE_PC(); - auto res = SlowRuntimeStub::DefineGeneratorFunc(thread, result); - INTERPRETER_RETURN_IF_ABRUPT(res); - result = JSFunction::Cast(res.GetTaggedObject()); - } else { - result->SetResolved(true); - } + HANDLE_OPCODE(DEPRECATED_DELOBJPROP_PREF_V8_V8) { + uint16_t v0 = READ_INST_8_1(); + uint16_t v1 = READ_INST_8_2(); + LOG_INST() << "intrinsics::delobjprop" + << " v0" << v0 << " v1" << v1; - result->SetPropertyInlinedProps(thread, JSFunction::LENGTH_INLINE_PROPERTY_INDEX, JSTaggedValue(length)); - JSTaggedValue env = GET_VREG_VALUE(v0); - result->SetLexicalEnv(thread, env); + JSTaggedValue obj = GET_VREG_VALUE(v0); + JSTaggedValue prop = GET_VREG_VALUE(v1); + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::DelObjProp(thread, obj, prop); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); - JSFunction *currentFunc = JSFunction::Cast((GET_FRAME(sp)->function).GetTaggedObject()); - result->SetModule(thread, currentFunc->GetModule()); - SET_ACC(JSTaggedValue(result)) - DISPATCH(BytecodeInstruction::Format::PREF_ID16_IMM16_V8); + DISPATCH(DEPRECATED_DELOBJPROP_PREF_V8_V8); } - HANDLE_OPCODE(HANDLE_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8) { - uint16_t methodId = READ_INST_16_1(); - uint16_t length = READ_INST_16_3(); - uint16_t v0 = READ_INST_8_5(); - LOG_INST() << "define async gengerator function length: " << length + HANDLE_OPCODE(SUSPENDGENERATOR_V8) { + uint16_t v0 = READ_INST_8_0(); + LOG_INST() << "intrinsics::suspendgenerator" << " v" << v0; - JSFunction *result = JSFunction::Cast(GET_OBJ_FROM_CACHE(methodId).GetTaggedObject()); - ASSERT(result != nullptr); - if (result->GetResolved()) { - SAVE_PC(); - auto res = SlowRuntimeStub::DefineAsyncGeneratorFunc(thread, result); - INTERPRETER_RETURN_IF_ABRUPT(res); - result = JSFunction::Cast(res.GetTaggedObject()); - } else { - result->SetResolved(true); + JSTaggedValue genObj = GET_VREG_VALUE(v0); + JSTaggedValue value = GET_ACC(); + // suspend will record bytecode offset + SAVE_PC(); + SAVE_ACC(); + JSTaggedValue res = SlowRuntimeStub::SuspendGenerator(thread, genObj, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + + InterpretedFrame *state = GET_FRAME(sp); + methodHandle.Update(JSFunction::Cast(state->function.GetTaggedObject())->GetMethod()); + [[maybe_unused]] auto fistPC = methodHandle->GetBytecodeArray(); + UPDATE_HOTNESS_COUNTER(-(pc - fistPC)); + LOG_INST() << "Exit: SuspendGenerator " << std::hex << reinterpret_cast(sp) << " " + << std::hex << reinterpret_cast(state->pc); + sp = state->base.prev; + ASSERT(sp != nullptr); + InterpretedFrame *prevState = GET_FRAME(sp); + pc = prevState->pc; + // entry frame + if (FrameHandler::IsEntryFrame(pc)) { + state->acc = acc; + return; } - result->SetPropertyInlinedProps(thread, JSFunction::LENGTH_INLINE_PROPERTY_INDEX, JSTaggedValue(length)); - JSTaggedValue env = GET_VREG_VALUE(v0); - result->SetLexicalEnv(thread, env); + thread->SetCurrentSPFrame(sp); - JSFunction *currentFunc = JSFunction::Cast((GET_FRAME(sp)->function).GetTaggedObject()); - result->SetModule(thread, currentFunc->GetModule()); - SET_ACC(JSTaggedValue(result)) - DISPATCH(BytecodeInstruction::Format::PREF_ID16_IMM16_V8); + INTERPRETER_HANDLE_RETURN(); } - HANDLE_OPCODE(HANDLE_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8) { - uint16_t methodId = READ_INST_16_1(); - uint16_t length = READ_INST_16_3(); - uint16_t v0 = READ_INST_8_5(); - LOG_INST() << "define async function length: " << length - << " v" << v0; - JSFunction *result = JSFunction::Cast(GET_OBJ_FROM_CACHE(methodId).GetTaggedObject()); - ASSERT(result != nullptr); - if (result->GetResolved()) { - SAVE_PC(); - auto res = SlowRuntimeStub::DefineAsyncFunc(thread, result); - INTERPRETER_RETURN_IF_ABRUPT(res); - result = JSFunction::Cast(res.GetTaggedObject()); - } else { - result->SetResolved(true); + HANDLE_OPCODE(DEPRECATED_SUSPENDGENERATOR_PREF_V8_V8) { + uint16_t v0 = READ_INST_8_1(); + uint16_t v1 = READ_INST_8_2(); + LOG_INST() << "intrinsics::suspendgenerator" + << " v" << v0 << " v" << v1; + JSTaggedValue genObj = GET_VREG_VALUE(v0); + JSTaggedValue value = GET_VREG_VALUE(v1); + // suspend will record bytecode offset + SAVE_PC(); + SAVE_ACC(); + JSTaggedValue res = SlowRuntimeStub::SuspendGenerator(thread, genObj, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + + InterpretedFrame *state = GET_FRAME(sp); + JSMethod *method = JSFunction::Cast(state->function.GetTaggedObject())->GetCallTarget(); + [[maybe_unused]] auto fistPC = method->GetBytecodeArray(); + UPDATE_HOTNESS_COUNTER(-(pc - fistPC)); + LOG_INST() << "Exit: SuspendGenerator " << std::hex << reinterpret_cast(sp) << " " + << std::hex << reinterpret_cast(state->pc); + sp = state->base.prev; + ASSERT(sp != nullptr); + InterpretedFrame *prevState = GET_FRAME(sp); + pc = prevState->pc; + // entry frame + if (FrameHandler::IsEntryFrame(pc)) { + state->acc = acc; + return; } - result->SetPropertyInlinedProps(thread, JSFunction::LENGTH_INLINE_PROPERTY_INDEX, JSTaggedValue(length)); - JSTaggedValue env = GET_VREG_VALUE(v0); - result->SetLexicalEnv(thread, env); + thread->SetCurrentSPFrame(sp); - JSFunction *currentFunc = JSFunction::Cast((GET_FRAME(sp)->function).GetTaggedObject()); - result->SetModule(thread, currentFunc->GetModule()); - SET_ACC(JSTaggedValue(result)) - DISPATCH(BytecodeInstruction::Format::PREF_ID16_IMM16_V8); - } - HANDLE_OPCODE(HANDLE_LDHOLE_PREF) { - LOG_INST() << "intrinsic::ldhole"; - SET_ACC(JSTaggedValue::Hole()); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + INTERPRETER_HANDLE_RETURN(); } - HANDLE_OPCODE(HANDLE_COPYRESTARGS_PREF_IMM16) { - uint16_t restIdx = READ_INST_16_1(); - LOG_INST() << "intrinsics::copyrestargs" - << " index: " << restIdx; - - uint32_t startIdx = 0; - uint32_t restNumArgs = GetNumArgs(sp, restIdx, startIdx); - + HANDLE_OPCODE(ASYNCFUNCTIONAWAITUNCAUGHT_V8) { + uint16_t v0 = READ_INST_8_0(); + LOG_INST() << "intrinsics::asyncfunctionawaituncaught" + << " v" << v0; + JSTaggedValue asyncFuncObj = GET_VREG_VALUE(v0); + JSTaggedValue value = GET_ACC(); SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::CopyRestArgs(thread, sp, restNumArgs, startIdx); + JSTaggedValue res = SlowRuntimeStub::AsyncFunctionAwaitUncaught(thread, asyncFuncObj, value); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16); + DISPATCH(ASYNCFUNCTIONAWAITUNCAUGHT_V8); } - HANDLE_OPCODE(HANDLE_DEFINEGETTERSETTERBYVALUE_PREF_V8_V8_V8_V8) { + HANDLE_OPCODE(DEPRECATED_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8) { uint16_t v0 = READ_INST_8_1(); uint16_t v1 = READ_INST_8_2(); - uint16_t v2 = READ_INST_8_3(); - uint16_t v3 = READ_INST_8_4(); - LOG_INST() << "intrinsics::definegettersetterbyvalue" - << " v" << v0 << " v" << v1 << " v" << v2 << " v" << v3; - - JSTaggedValue obj = GET_VREG_VALUE(v0); - JSTaggedValue prop = GET_VREG_VALUE(v1); - JSTaggedValue getter = GET_VREG_VALUE(v2); - JSTaggedValue setter = GET_VREG_VALUE(v3); - JSTaggedValue flag = GET_ACC(); + LOG_INST() << "intrinsics::asyncfunctionawaituncaught" + << " v" << v0 << " v" << v1; + JSTaggedValue asyncFuncObj = GET_VREG_VALUE(v0); + JSTaggedValue value = GET_VREG_VALUE(v1); SAVE_PC(); - JSTaggedValue res = - SlowRuntimeStub::DefineGetterSetterByValue(thread, obj, prop, getter, setter, flag.ToBoolean()); + JSTaggedValue res = SlowRuntimeStub::AsyncFunctionAwaitUncaught(thread, asyncFuncObj, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(DEPRECATED_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8); + } + HANDLE_OPCODE(COPYDATAPROPERTIES_V8) { + uint16_t v0 = READ_INST_8_0(); + LOG_INST() << "intrinsic::copydataproperties" + << " v" << v0; + JSTaggedValue dst = GET_VREG_VALUE(v0); + JSTaggedValue src = GET_ACC(); + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::CopyDataProperties(thread, dst, src); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8_V8_V8); + DISPATCH(COPYDATAPROPERTIES_V8); } - HANDLE_OPCODE(HANDLE_LDOBJBYINDEX_PREF_V8_IMM32) { + HANDLE_OPCODE(DEPRECATED_COPYDATAPROPERTIES_PREF_V8_V8) { uint16_t v0 = READ_INST_8_1(); - uint32_t idx = READ_INST_32_2(); - LOG_INST() << "intrinsics::ldobjbyindex" - << " v" << v0 << " imm" << idx; - - JSTaggedValue receiver = GET_VREG_VALUE(v0); - // fast path - if (LIKELY(receiver.IsHeapObject())) { - JSTaggedValue res = FastRuntimeStub::GetPropertyByIndex(thread, receiver, idx); - if (!res.IsHole()) { - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_IMM32); - } - } - // not meet fast condition or fast path return hole, walk slow path - // slow stub not need receiver + uint16_t v1 = READ_INST_8_2(); + LOG_INST() << "intrinsic::copydataproperties" + << " v" << v0 << " v" << v1; + JSTaggedValue dst = GET_VREG_VALUE(v0); + JSTaggedValue src = GET_VREG_VALUE(v1); SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::LdObjByIndex(thread, receiver, idx, false, JSTaggedValue::Undefined()); + JSTaggedValue res = SlowRuntimeStub::CopyDataProperties(thread, dst, src); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_IMM32); + DISPATCH(DEPRECATED_COPYDATAPROPERTIES_PREF_V8_V8); } - HANDLE_OPCODE(HANDLE_STOBJBYINDEX_PREF_V8_IMM32) { + HANDLE_OPCODE(SETOBJECTWITHPROTO_IMM8_V8) { uint16_t v0 = READ_INST_8_1(); - uint32_t index = READ_INST_32_2(); - LOG_INST() << "intrinsics::stobjbyindex" - << " v" << v0 << " imm" << index; - - JSTaggedValue receiver = GET_VREG_VALUE(v0); - if (receiver.IsHeapObject()) { - SAVE_ACC(); - JSTaggedValue value = GET_ACC(); - // fast path - JSTaggedValue res = FastRuntimeStub::SetPropertyByIndex(thread, receiver, index, value); - if (!res.IsHole()) { - INTERPRETER_RETURN_IF_ABRUPT(res); - RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_V8_IMM32); - } - RESTORE_ACC(); - } - // slow path + LOG_INST() << "intrinsics::setobjectwithproto" + << " v" << v0; + JSTaggedValue proto = GET_VREG_VALUE(v0); + JSTaggedValue obj = GET_ACC(); SAVE_ACC(); SAVE_PC(); - receiver = GET_VREG_VALUE(v0); // Maybe moved by GC - JSTaggedValue value = GET_ACC(); // Maybe moved by GC - JSTaggedValue res = SlowRuntimeStub::StObjByIndex(thread, receiver, index, value); + JSTaggedValue res = SlowRuntimeStub::SetObjectWithProto(thread, proto, obj); + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(SETOBJECTWITHPROTO_IMM8_V8); + } + HANDLE_OPCODE(SETOBJECTWITHPROTO_IMM16_V8) { + uint16_t v0 = READ_INST_8_2(); + LOG_INST() << "intrinsics::setobjectwithproto" + << " v" << v0; + JSTaggedValue proto = GET_VREG_VALUE(v0); + JSTaggedValue obj = GET_ACC(); + SAVE_ACC(); + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::SetObjectWithProto(thread, proto, obj); + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(SETOBJECTWITHPROTO_IMM16_V8); + } + HANDLE_OPCODE(DEPRECATED_SETOBJECTWITHPROTO_PREF_V8_V8) { + uint16_t v0 = READ_INST_8_1(); + uint16_t v1 = READ_INST_8_2(); + LOG_INST() << "intrinsics::setobjectwithproto" + << " v" << v0 << " v" << v1; + JSTaggedValue proto = GET_VREG_VALUE(v0); + JSTaggedValue obj = GET_VREG_VALUE(v1); + SAVE_ACC(); + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::SetObjectWithProto(thread, proto, obj); INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_V8_IMM32); + DISPATCH(DEPRECATED_SETOBJECTWITHPROTO_PREF_V8_V8); } - HANDLE_OPCODE(HANDLE_LDOBJBYVALUE_PREF_V8_V8) { + HANDLE_OPCODE(LDOBJBYVALUE_IMM8_V8) { uint32_t v0 = READ_INST_8_1(); - uint32_t v1 = READ_INST_8_2(); LOG_INST() << "intrinsics::Ldobjbyvalue" - << " v" << v0 << " v" << v1; + << " v" << v0; JSTaggedValue receiver = GET_VREG_VALUE(v0); - JSTaggedValue propKey = GET_VREG_VALUE(v1); + JSTaggedValue propKey = GET_ACC(); #if ECMASCRIPT_ENABLE_IC auto profileTypeInfo = GetRuntimeProfileTypeInfo(sp); @@ -2905,7 +5025,7 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t if (LIKELY(!res.IsHole())) { INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(LDOBJBYVALUE_IMM8_V8); } } #endif @@ -2916,7 +5036,7 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t ASSERT(!res.IsAccessor()); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(LDOBJBYVALUE_IMM8_V8); } } // slow path @@ -2924,894 +5044,1166 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, const uint8_t JSTaggedValue res = SlowRuntimeStub::LdObjByValue(thread, receiver, propKey, false, JSTaggedValue::Undefined()); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(LDOBJBYVALUE_IMM8_V8); } - HANDLE_OPCODE(HANDLE_STOBJBYVALUE_PREF_V8_V8) { - uint32_t v0 = READ_INST_8_1(); - uint32_t v1 = READ_INST_8_2(); - - LOG_INST() << "intrinsics::stobjbyvalue" - << " v" << v0 << " v" << v1; + HANDLE_OPCODE(LDOBJBYVALUE_IMM16_V8) { + uint32_t v0 = READ_INST_8_2(); + LOG_INST() << "intrinsics::Ldobjbyvalue" + << " v" << v0; JSTaggedValue receiver = GET_VREG_VALUE(v0); + JSTaggedValue propKey = GET_ACC(); + #if ECMASCRIPT_ENABLE_IC auto profileTypeInfo = GetRuntimeProfileTypeInfo(sp); if (!profileTypeInfo.IsUndefined()) { - uint16_t slotId = READ_INST_8_0(); + uint16_t slotId = READ_INST_16_0(); auto profileTypeArray = ProfileTypeInfo::Cast(profileTypeInfo.GetTaggedObject()); JSTaggedValue firstValue = profileTypeArray->Get(slotId); - JSTaggedValue propKey = GET_VREG_VALUE(v1); - JSTaggedValue value = GET_ACC(); JSTaggedValue res = JSTaggedValue::Hole(); - SAVE_ACC(); if (LIKELY(firstValue.IsHeapObject())) { JSTaggedValue secondValue = profileTypeArray->Get(slotId + 1); - res = ICRuntimeStub::TryStoreICByValue(thread, receiver, propKey, firstValue, secondValue, value); + res = ICRuntimeStub::TryLoadICByValue(thread, receiver, propKey, firstValue, secondValue); } // IC miss and not enter the megamorphic state, store as polymorphic if (res.IsHole() && !firstValue.IsHole()) { - res = ICRuntimeStub::StoreICByValue(thread, - profileTypeArray, - receiver, propKey, value, slotId); + res = ICRuntimeStub::LoadICByValue(thread, + profileTypeArray, + receiver, propKey, slotId); } if (LIKELY(!res.IsHole())) { INTERPRETER_RETURN_IF_ABRUPT(res); - RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + SET_ACC(res); + DISPATCH(LDOBJBYVALUE_IMM16_V8); } } #endif - if (receiver.IsHeapObject()) { - SAVE_ACC(); - JSTaggedValue propKey = GET_VREG_VALUE(v1); - JSTaggedValue value = GET_ACC(); - // fast path - JSTaggedValue res = FastRuntimeStub::SetPropertyByValue(thread, receiver, propKey, value); + // fast path + if (LIKELY(receiver.IsHeapObject())) { + JSTaggedValue res = FastRuntimeStub::GetPropertyByValue(thread, receiver, propKey); if (!res.IsHole()) { + ASSERT(!res.IsAccessor()); INTERPRETER_RETURN_IF_ABRUPT(res); - RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + SET_ACC(res); + DISPATCH(LDOBJBYVALUE_IMM16_V8); } - RESTORE_ACC(); - } - { - // slow path - SAVE_ACC(); - SAVE_PC(); - receiver = GET_VREG_VALUE(v0); // Maybe moved by GC - JSTaggedValue propKey = GET_VREG_VALUE(v1); // Maybe moved by GC - JSTaggedValue value = GET_ACC(); // Maybe moved by GC - JSTaggedValue res = SlowRuntimeStub::StObjByValue(thread, receiver, propKey, value); - INTERPRETER_RETURN_IF_ABRUPT(res); - RESTORE_ACC(); } - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + // slow path + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::LdObjByValue(thread, receiver, propKey, false, JSTaggedValue::Undefined()); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(LDOBJBYVALUE_IMM16_V8); } - HANDLE_OPCODE(HANDLE_LDSUPERBYVALUE_PREF_V8_V8) { + HANDLE_OPCODE(DEPRECATED_LDOBJBYVALUE_PREF_V8_V8) { uint32_t v0 = READ_INST_8_1(); uint32_t v1 = READ_INST_8_2(); - LOG_INST() << "intrinsics::Ldsuperbyvalue" + LOG_INST() << "intrinsics::Ldobjbyvalue" << " v" << v0 << " v" << v1; JSTaggedValue receiver = GET_VREG_VALUE(v0); JSTaggedValue propKey = GET_VREG_VALUE(v1); + // fast path + if (LIKELY(receiver.IsHeapObject())) { + JSTaggedValue res = FastRuntimeStub::GetPropertyByValue(thread, receiver, propKey); + if (!res.IsHole()) { + ASSERT(!res.IsAccessor()); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(DEPRECATED_LDOBJBYVALUE_PREF_V8_V8); + } + } + // slow path + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::LdObjByValue(thread, receiver, propKey, false, JSTaggedValue::Undefined()); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(DEPRECATED_LDOBJBYVALUE_PREF_V8_V8); + } + HANDLE_OPCODE(LDSUPERBYVALUE_IMM8_V8) { + uint32_t v0 = READ_INST_8_1(); + LOG_INST() << "intrinsics::Ldsuperbyvalue" + << " v" << v0; + + JSTaggedValue receiver = GET_VREG_VALUE(v0); + JSTaggedValue propKey = GET_ACC(); + + // slow path + SAVE_PC(); + JSTaggedValue thisFunc = GetThisFunction(sp); + JSTaggedValue res = SlowRuntimeStub::LdSuperByValue(thread, receiver, propKey, thisFunc); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(LDSUPERBYVALUE_IMM8_V8); + } + HANDLE_OPCODE(LDSUPERBYVALUE_IMM16_V8) { + uint32_t v0 = READ_INST_8_2(); + LOG_INST() << "intrinsics::Ldsuperbyvalue" + << " v" << v0; + + JSTaggedValue receiver = GET_VREG_VALUE(v0); + JSTaggedValue propKey = GET_ACC(); + // slow path SAVE_PC(); JSTaggedValue thisFunc = GetThisFunction(sp); JSTaggedValue res = SlowRuntimeStub::LdSuperByValue(thread, receiver, propKey, thisFunc); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(LDSUPERBYVALUE_IMM8_V8); } - HANDLE_OPCODE(HANDLE_STSUPERBYVALUE_PREF_V8_V8) { + HANDLE_OPCODE(DEPRECATED_LDSUPERBYVALUE_PREF_V8_V8) { uint32_t v0 = READ_INST_8_1(); uint32_t v1 = READ_INST_8_2(); - - LOG_INST() << "intrinsics::stsuperbyvalue" + LOG_INST() << "intrinsics::Ldsuperbyvalue" << " v" << v0 << " v" << v1; + JSTaggedValue receiver = GET_VREG_VALUE(v0); JSTaggedValue propKey = GET_VREG_VALUE(v1); - JSTaggedValue value = GET_ACC(); // slow path - SAVE_ACC(); SAVE_PC(); JSTaggedValue thisFunc = GetThisFunction(sp); - JSTaggedValue res = SlowRuntimeStub::StSuperByValue(thread, receiver, propKey, value, thisFunc); + JSTaggedValue res = SlowRuntimeStub::LdSuperByValue(thread, receiver, propKey, thisFunc); INTERPRETER_RETURN_IF_ABRUPT(res); - RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + SET_ACC(res); + DISPATCH(DEPRECATED_LDSUPERBYVALUE_PREF_V8_V8); } - HANDLE_OPCODE(HANDLE_TRYLDGLOBALBYNAME_PREF_ID32) { - uint32_t stringId = READ_INST_32_1(); - auto prop = GET_OBJ_FROM_CACHE(stringId); - - LOG_INST() << "intrinsics::tryldglobalbyname " - << "stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(prop.GetTaggedObject())); + HANDLE_OPCODE(LDOBJBYINDEX_IMM8_IMM16) { + uint32_t idx = READ_INST_16_1(); + LOG_INST() << "intrinsics::ldobjbyindex" + << " imm" << idx; -#if ECMASCRIPT_ENABLE_IC - auto profileTypeInfo = GetRuntimeProfileTypeInfo(sp); - if (!profileTypeInfo.IsUndefined()) { - uint16_t slotId = READ_INST_8_0(); - JSTaggedValue res = ICRuntimeStub::LoadGlobalICByName(thread, - ProfileTypeInfo::Cast( - profileTypeInfo.GetTaggedObject()), - globalObj, prop, slotId); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + JSTaggedValue receiver = GET_ACC(); + // fast path + if (LIKELY(receiver.IsHeapObject())) { + JSTaggedValue res = FastRuntimeStub::GetPropertyByIndex(thread, receiver, idx); + if (!res.IsHole()) { + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(LDOBJBYINDEX_IMM8_IMM16); + } } -#endif + // not meet fast condition or fast path return hole, walk slow path + // slow stub not need receiver + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::LdObjByIndex(thread, receiver, idx, false, JSTaggedValue::Undefined()); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(LDOBJBYINDEX_IMM8_IMM16); + } + HANDLE_OPCODE(LDOBJBYINDEX_IMM16_IMM16) { + uint32_t idx = READ_INST_32_1(); + LOG_INST() << "intrinsics::ldobjbyindex" + << " imm" << idx; - // order: 1. global record 2. global object - JSTaggedValue result = SlowRuntimeStub::LdGlobalRecord(thread, prop); - if (!result.IsUndefined()) { - SET_ACC(PropertyBox::Cast(result.GetTaggedObject())->GetValue()); - } else { - JSTaggedValue globalResult = FastRuntimeStub::GetGlobalOwnProperty(thread, globalObj, prop); - if (!globalResult.IsHole()) { - SET_ACC(globalResult); - } else { - // slow path - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::TryLdGlobalByNameFromGlobalProto(thread, globalObj, prop); + JSTaggedValue receiver = GET_ACC(); + // fast path + if (LIKELY(receiver.IsHeapObject())) { + JSTaggedValue res = FastRuntimeStub::GetPropertyByIndex(thread, receiver, idx); + if (!res.IsHole()) { INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); + DISPATCH(LDOBJBYINDEX_IMM16_IMM16); } } - - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + // not meet fast condition or fast path return hole, walk slow path + // slow stub not need receiver + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::LdObjByIndex(thread, receiver, idx, false, JSTaggedValue::Undefined()); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(LDOBJBYINDEX_IMM16_IMM16); } - HANDLE_OPCODE(HANDLE_TRYSTGLOBALBYNAME_PREF_ID32) { - uint32_t stringId = READ_INST_32_1(); - JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); - LOG_INST() << "intrinsics::trystglobalbyname" - << " stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())); + HANDLE_OPCODE(WIDE_LDOBJBYINDEX_PREF_IMM32) { + uint32_t idx = READ_INST_32_1(); + LOG_INST() << "intrinsics::ldobjbyindex" + << " imm" << idx; -#if ECMASCRIPT_ENABLE_IC - auto profileTypeInfo = GetRuntimeProfileTypeInfo(sp); - if (!profileTypeInfo.IsUndefined()) { - uint16_t slotId = READ_INST_8_0(); - JSTaggedValue value = GET_ACC(); - SAVE_ACC(); - JSTaggedValue res = ICRuntimeStub::StoreGlobalICByName(thread, - ProfileTypeInfo::Cast( - profileTypeInfo.GetTaggedObject()), - globalObj, propKey, value, slotId); - INTERPRETER_RETURN_IF_ABRUPT(res); - RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + JSTaggedValue receiver = GET_ACC(); + // fast path + if (LIKELY(receiver.IsHeapObject())) { + JSTaggedValue res = FastRuntimeStub::GetPropertyByIndex(thread, receiver, idx); + if (!res.IsHole()) { + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(WIDE_LDOBJBYINDEX_PREF_IMM32); + } } -#endif + // not meet fast condition or fast path return hole, walk slow path + // slow stub not need receiver + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::LdObjByIndex(thread, receiver, idx, false, JSTaggedValue::Undefined()); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(WIDE_LDOBJBYINDEX_PREF_IMM32); + } + HANDLE_OPCODE(DEPRECATED_LDOBJBYINDEX_PREF_V8_IMM32) { + uint16_t v0 = READ_INST_8_1(); + uint32_t idx = READ_INST_32_2(); + LOG_INST() << "intrinsics::ldobjbyindex" + << " v" << v0 << " imm" << idx; - auto recordResult = SlowRuntimeStub::LdGlobalRecord(thread, propKey); + JSTaggedValue receiver = GET_VREG_VALUE(v0); + // fast path + if (LIKELY(receiver.IsHeapObject())) { + JSTaggedValue res = FastRuntimeStub::GetPropertyByIndex(thread, receiver, idx); + if (!res.IsHole()) { + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(DEPRECATED_LDOBJBYINDEX_PREF_V8_IMM32); + } + } + // not meet fast condition or fast path return hole, walk slow path + // slow stub not need receiver SAVE_PC(); - // 1. find from global record - if (!recordResult.IsUndefined()) { - JSTaggedValue value = GET_ACC(); + JSTaggedValue res = SlowRuntimeStub::LdObjByIndex(thread, receiver, idx, false, JSTaggedValue::Undefined()); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(DEPRECATED_LDOBJBYINDEX_PREF_V8_IMM32); + } + HANDLE_OPCODE(STOBJBYINDEX_IMM8_V8_IMM16) { + uint8_t v0 = READ_INST_8_1(); + uint16_t index = READ_INST_16_2(); + LOG_INST() << "intrinsics::stobjbyindex" + << " v" << v0 << " imm" << index; + + JSTaggedValue receiver = GET_VREG_VALUE(v0); + if (receiver.IsHeapObject()) { SAVE_ACC(); - JSTaggedValue res = SlowRuntimeStub::TryUpdateGlobalRecord(thread, propKey, value); - INTERPRETER_RETURN_IF_ABRUPT(res); - RESTORE_ACC(); - } else { - // 2. find from global object - auto globalResult = FastRuntimeStub::GetGlobalOwnProperty(thread, globalObj, propKey); - if (globalResult.IsHole()) { - auto result = SlowRuntimeStub::ThrowReferenceError(thread, propKey, " is not defined"); - INTERPRETER_RETURN_IF_ABRUPT(result); - } JSTaggedValue value = GET_ACC(); - SAVE_ACC(); - JSTaggedValue res = SlowRuntimeStub::StGlobalVar(thread, propKey, value); - INTERPRETER_RETURN_IF_ABRUPT(res); + // fast path + JSTaggedValue res = FastRuntimeStub::SetPropertyByIndex(thread, receiver, index, value); + if (!res.IsHole()) { + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(STOBJBYINDEX_IMM8_V8_IMM16); + } RESTORE_ACC(); } - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + // slow path + SAVE_ACC(); + SAVE_PC(); + receiver = GET_VREG_VALUE(v0); // Maybe moved by GC + JSTaggedValue value = GET_ACC(); // Maybe moved by GC + JSTaggedValue res = SlowRuntimeStub::StObjByIndex(thread, receiver, index, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(STOBJBYINDEX_IMM8_V8_IMM16); } + HANDLE_OPCODE(STOBJBYINDEX_IMM16_V8_IMM16) { + uint8_t v0 = READ_INST_8_2(); + uint16_t index = READ_INST_16_3(); + LOG_INST() << "intrinsics::stobjbyindex" + << " v" << v0 << " imm" << index; - HANDLE_OPCODE(HANDLE_STCONSTTOGLOBALRECORD_PREF_ID32) { - uint32_t stringId = READ_INST_32_1(); - JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); - LOG_INST() << "intrinsics::stconsttoglobalrecord" - << " stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())); - - JSTaggedValue value = GET_ACC(); + JSTaggedValue receiver = GET_VREG_VALUE(v0); + if (receiver.IsHeapObject()) { + SAVE_ACC(); + JSTaggedValue value = GET_ACC(); + // fast path + JSTaggedValue res = FastRuntimeStub::SetPropertyByIndex(thread, receiver, index, value); + if (!res.IsHole()) { + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(STOBJBYINDEX_IMM16_V8_IMM16); + } + RESTORE_ACC(); + } + // slow path SAVE_ACC(); SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::StGlobalRecord(thread, propKey, value, true); + receiver = GET_VREG_VALUE(v0); // Maybe moved by GC + JSTaggedValue value = GET_ACC(); // Maybe moved by GC + JSTaggedValue res = SlowRuntimeStub::StObjByIndex(thread, receiver, index, value); INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + DISPATCH(STOBJBYINDEX_IMM16_V8_IMM16); } + HANDLE_OPCODE(WIDE_STOBJBYINDEX_PREF_V8_IMM32) { + uint8_t v0 = READ_INST_8_1(); + uint32_t index = READ_INST_32_2(); + LOG_INST() << "intrinsics::stobjbyindex" + << " v" << v0 << " imm" << index; - HANDLE_OPCODE(HANDLE_STLETTOGLOBALRECORD_PREF_ID32) { - uint32_t stringId = READ_INST_32_1(); - JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); - LOG_INST() << "intrinsics::stlettoglobalrecord" - << " stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())); - - JSTaggedValue value = GET_ACC(); + JSTaggedValue receiver = GET_VREG_VALUE(v0); + if (receiver.IsHeapObject()) { + SAVE_ACC(); + JSTaggedValue value = GET_ACC(); + // fast path + JSTaggedValue res = FastRuntimeStub::SetPropertyByIndex(thread, receiver, index, value); + if (!res.IsHole()) { + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(WIDE_STOBJBYINDEX_PREF_V8_IMM32); + } + RESTORE_ACC(); + } + // slow path SAVE_ACC(); SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::StGlobalRecord(thread, propKey, value, false); + receiver = GET_VREG_VALUE(v0); // Maybe moved by GC + JSTaggedValue value = GET_ACC(); // Maybe moved by GC + JSTaggedValue res = SlowRuntimeStub::StObjByIndex(thread, receiver, index, value); INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + DISPATCH(WIDE_STOBJBYINDEX_PREF_V8_IMM32); } - - HANDLE_OPCODE(HANDLE_STCLASSTOGLOBALRECORD_PREF_ID32) { - uint32_t stringId = READ_INST_32_1(); - JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); - LOG_INST() << "intrinsics::stclasstoglobalrecord" - << " stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())); - - JSTaggedValue value = GET_ACC(); + HANDLE_OPCODE(STOWNBYINDEX_IMM8_V8_IMM16) { + uint8_t v0 = READ_INST_8_1(); + uint16_t index = READ_INST_16_2(); + LOG_INST() << "intrinsics::stownbyindex" + << " v" << v0 << " imm" << index; + JSTaggedValue receiver = GET_VREG_VALUE(v0); + // fast path + if (receiver.IsHeapObject() && !receiver.IsClassConstructor() && !receiver.IsClassPrototype()) { + SAVE_ACC(); + JSTaggedValue value = GET_ACC(); + // fast path + JSTaggedValue res = + FastRuntimeStub::SetPropertyByIndex(thread, receiver, index, value); + if (!res.IsHole()) { + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(STOWNBYINDEX_IMM8_V8_IMM16); + } + RESTORE_ACC(); + } SAVE_ACC(); + receiver = GET_VREG_VALUE(v0); // Maybe moved by GC + auto value = GET_ACC(); // Maybe moved by GC SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::StGlobalRecord(thread, propKey, value, false); + JSTaggedValue res = SlowRuntimeStub::StOwnByIndex(thread, receiver, index, value); INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + DISPATCH(STOWNBYINDEX_IMM8_V8_IMM16); } - - HANDLE_OPCODE(HANDLE_STOWNBYVALUEWITHNAMESET_PREF_V8_V8) { - uint32_t v0 = READ_INST_8_1(); - uint32_t v1 = READ_INST_8_2(); - LOG_INST() << "intrinsics::stownbyvaluewithnameset" - << " v" << v0 << " v" << v1; + HANDLE_OPCODE(STOWNBYINDEX_IMM16_V8_IMM16) { + uint8_t v0 = READ_INST_8_2(); + uint16_t index = READ_INST_16_3(); + LOG_INST() << "intrinsics::stownbyindex" + << " v" << v0 << " imm" << index; JSTaggedValue receiver = GET_VREG_VALUE(v0); + // fast path if (receiver.IsHeapObject() && !receiver.IsClassConstructor() && !receiver.IsClassPrototype()) { SAVE_ACC(); - JSTaggedValue propKey = GET_VREG_VALUE(v1); JSTaggedValue value = GET_ACC(); // fast path - JSTaggedValue res = FastRuntimeStub::SetPropertyByValue(thread, receiver, propKey, value); - - // SetPropertyByValue maybe gc need update the value - RESTORE_ACC(); - propKey = GET_VREG_VALUE(v1); - value = GET_ACC(); + JSTaggedValue res = + FastRuntimeStub::SetPropertyByIndex(thread, receiver, index, value); if (!res.IsHole()) { INTERPRETER_RETURN_IF_ABRUPT(res); - JSFunction::SetFunctionNameNoPrefix(thread, JSFunction::Cast(value.GetTaggedObject()), propKey); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(STOWNBYINDEX_IMM16_V8_IMM16); } + RESTORE_ACC(); } - - // slow path SAVE_ACC(); + receiver = GET_VREG_VALUE(v0); // Maybe moved by GC + auto value = GET_ACC(); // Maybe moved by GC SAVE_PC(); - receiver = GET_VREG_VALUE(v0); // Maybe moved by GC - auto propKey = GET_VREG_VALUE(v1); // Maybe moved by GC - auto value = GET_ACC(); // Maybe moved by GC - JSTaggedValue res = SlowRuntimeStub::StOwnByValueWithNameSet(thread, receiver, propKey, value); - RESTORE_ACC(); + JSTaggedValue res = SlowRuntimeStub::StOwnByIndex(thread, receiver, index, value); INTERPRETER_RETURN_IF_ABRUPT(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + RESTORE_ACC(); + DISPATCH(STOWNBYINDEX_IMM16_V8_IMM16); } - HANDLE_OPCODE(HANDLE_STOWNBYNAMEWITHNAMESET_PREF_ID32_V8) { - uint32_t stringId = READ_INST_32_1(); - uint32_t v0 = READ_INST_8_5(); - LOG_INST() << "intrinsics::stownbynamewithnameset " - << "v" << v0 << " stringId:" << stringId; - + HANDLE_OPCODE(WIDE_STOWNBYINDEX_PREF_V8_IMM32) { + uint8_t v0 = READ_INST_8_1(); + uint32_t index = READ_INST_32_2(); + LOG_INST() << "intrinsics::stownbyindex" + << " v" << v0 << " imm" << index; JSTaggedValue receiver = GET_VREG_VALUE(v0); - if (receiver.IsJSObject() && !receiver.IsClassConstructor() && !receiver.IsClassPrototype()) { - JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); + // fast path + if (receiver.IsHeapObject() && !receiver.IsClassConstructor() && !receiver.IsClassPrototype()) { + SAVE_ACC(); JSTaggedValue value = GET_ACC(); // fast path - SAVE_ACC(); - JSTaggedValue res = FastRuntimeStub::SetPropertyByName(thread, receiver, propKey, value); + JSTaggedValue res = + FastRuntimeStub::SetPropertyByIndex(thread, receiver, index, value); if (!res.IsHole()) { INTERPRETER_RETURN_IF_ABRUPT(res); - JSFunction::SetFunctionNameNoPrefix(thread, JSFunction::Cast(value.GetTaggedObject()), propKey); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); + DISPATCH(WIDE_STOWNBYINDEX_PREF_V8_IMM32); } RESTORE_ACC(); } + SAVE_ACC(); + receiver = GET_VREG_VALUE(v0); // Maybe moved by GC + auto value = GET_ACC(); // Maybe moved by GC + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::StOwnByIndex(thread, receiver, index, value); + INTERPRETER_RETURN_IF_ABRUPT(res); + RESTORE_ACC(); + DISPATCH(WIDE_STOWNBYINDEX_PREF_V8_IMM32); + } + HANDLE_OPCODE(COPYRESTARGS_IMM8) { + uint8_t restIdx = READ_INST_8_0(); + LOG_INST() << "intrinsics::copyrestargs" + << " index: " << restIdx; + + uint32_t startIdx = 0; + uint32_t restNumArgs = GetNumArgs(sp, restIdx, startIdx); + + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::CopyRestArgs(thread, sp, restNumArgs, startIdx); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(COPYRESTARGS_IMM8); + } + HANDLE_OPCODE(WIDE_COPYRESTARGS_PREF_IMM16) { + uint16_t restIdx = READ_INST_16_1(); + LOG_INST() << "intrinsics::copyrestargs" + << " index: " << restIdx; + + uint32_t startIdx = 0; + uint32_t restNumArgs = GetNumArgs(sp, restIdx, startIdx); + + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::CopyRestArgs(thread, sp, restNumArgs, startIdx); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(WIDE_COPYRESTARGS_PREF_IMM16); + } + HANDLE_OPCODE(LDLEXVAR_IMM4_IMM4) { + uint16_t level = READ_INST_4_0(); + uint16_t slot = READ_INST_4_1(); + + LOG_INST() << "intrinsics::ldlexvar" + << " level:" << level << " slot:" << slot; + InterpretedFrame *state = GET_FRAME(sp); + JSTaggedValue currentLexenv = state->env; + JSTaggedValue env(currentLexenv); + for (uint32_t i = 0; i < level; i++) { + JSTaggedValue taggedParentEnv = LexicalEnv::Cast(env.GetTaggedObject())->GetParentEnv(); + ASSERT(!taggedParentEnv.IsUndefined()); + env = taggedParentEnv; + } + SET_ACC(LexicalEnv::Cast(env.GetTaggedObject())->GetProperties(slot)); + DISPATCH(LDLEXVAR_IMM4_IMM4); + } + HANDLE_OPCODE(LDLEXVAR_IMM8_IMM8) { + uint16_t level = READ_INST_8_0(); + uint16_t slot = READ_INST_8_1(); + + LOG_INST() << "intrinsics::ldlexvar" + << " level:" << level << " slot:" << slot; + InterpretedFrame *state = GET_FRAME(sp); + JSTaggedValue currentLexenv = state->env; + JSTaggedValue env(currentLexenv); + for (uint32_t i = 0; i < level; i++) { + JSTaggedValue taggedParentEnv = LexicalEnv::Cast(env.GetTaggedObject())->GetParentEnv(); + ASSERT(!taggedParentEnv.IsUndefined()); + env = taggedParentEnv; + } + SET_ACC(LexicalEnv::Cast(env.GetTaggedObject())->GetProperties(slot)); + DISPATCH(LDLEXVAR_IMM8_IMM8); + } + HANDLE_OPCODE(WIDE_LDLEXVAR_PREF_IMM16_IMM16) { + uint16_t level = READ_INST_16_1(); + uint16_t slot = READ_INST_16_3(); + + LOG_INST() << "intrinsics::ldlexvar" + << " level:" << level << " slot:" << slot; + InterpretedFrame *state = GET_FRAME(sp); + JSTaggedValue currentLexenv = state->env; + JSTaggedValue env(currentLexenv); + for (uint32_t i = 0; i < level; i++) { + JSTaggedValue taggedParentEnv = LexicalEnv::Cast(env.GetTaggedObject())->GetParentEnv(); + ASSERT(!taggedParentEnv.IsUndefined()); + env = taggedParentEnv; + } + SET_ACC(LexicalEnv::Cast(env.GetTaggedObject())->GetProperties(slot)); + DISPATCH(WIDE_LDLEXVAR_PREF_IMM16_IMM16); + } + HANDLE_OPCODE(STLEXVAR_IMM4_IMM4) { + uint16_t level = READ_INST_4_0(); + uint16_t slot = READ_INST_4_1(); + LOG_INST() << "intrinsics::stlexvar" + << " level:" << level << " slot:" << slot; + + JSTaggedValue value = GET_ACC(); + InterpretedFrame *state = GET_FRAME(sp); + JSTaggedValue env = state->env; + for (uint32_t i = 0; i < level; i++) { + JSTaggedValue taggedParentEnv = LexicalEnv::Cast(env.GetTaggedObject())->GetParentEnv(); + ASSERT(!taggedParentEnv.IsUndefined()); + env = taggedParentEnv; + } + LexicalEnv::Cast(env.GetTaggedObject())->SetProperties(thread, slot, value); + + DISPATCH(STLEXVAR_IMM4_IMM4); + } + HANDLE_OPCODE(STLEXVAR_IMM8_IMM8) { + uint16_t level = READ_INST_8_0(); + uint16_t slot = READ_INST_8_1(); + LOG_INST() << "intrinsics::stlexvar" + << " level:" << level << " slot:" << slot; + + JSTaggedValue value = GET_ACC(); + InterpretedFrame *state = GET_FRAME(sp); + JSTaggedValue env = state->env; + for (uint32_t i = 0; i < level; i++) { + JSTaggedValue taggedParentEnv = LexicalEnv::Cast(env.GetTaggedObject())->GetParentEnv(); + ASSERT(!taggedParentEnv.IsUndefined()); + env = taggedParentEnv; + } + LexicalEnv::Cast(env.GetTaggedObject())->SetProperties(thread, slot, value); + + DISPATCH(STLEXVAR_IMM8_IMM8); + } + HANDLE_OPCODE(WIDE_STLEXVAR_PREF_IMM16_IMM16) { + uint16_t level = READ_INST_16_1(); + uint16_t slot = READ_INST_16_3(); + LOG_INST() << "intrinsics::stlexvar" + << " level:" << level << " slot:" << slot; + + JSTaggedValue value = GET_ACC(); + InterpretedFrame *state = GET_FRAME(sp); + JSTaggedValue env = state->env; + for (uint32_t i = 0; i < level; i++) { + JSTaggedValue taggedParentEnv = LexicalEnv::Cast(env.GetTaggedObject())->GetParentEnv(); + ASSERT(!taggedParentEnv.IsUndefined()); + env = taggedParentEnv; + } + LexicalEnv::Cast(env.GetTaggedObject())->SetProperties(thread, slot, value); + + DISPATCH(WIDE_STLEXVAR_PREF_IMM16_IMM16); + } + HANDLE_OPCODE(DEPRECATED_STLEXVAR_PREF_IMM4_IMM4_V8) { + uint16_t level = READ_INST_4_2(); + uint16_t slot = READ_INST_4_3(); + uint16_t v0 = READ_INST_8_2(); + LOG_INST() << "intrinsics::stlexvar" + << " level:" << level << " slot:" << slot << " v" << v0; + + JSTaggedValue value = GET_VREG_VALUE(v0); + InterpretedFrame *state = GET_FRAME(sp); + JSTaggedValue env = state->env; + for (uint32_t i = 0; i < level; i++) { + JSTaggedValue taggedParentEnv = LexicalEnv::Cast(env.GetTaggedObject())->GetParentEnv(); + ASSERT(!taggedParentEnv.IsUndefined()); + env = taggedParentEnv; + } + LexicalEnv::Cast(env.GetTaggedObject())->SetProperties(thread, slot, value); + + DISPATCH(DEPRECATED_STLEXVAR_PREF_IMM4_IMM4_V8); + } + HANDLE_OPCODE(DEPRECATED_STLEXVAR_PREF_IMM8_IMM8_V8) { + uint16_t level = READ_INST_8_1(); + uint16_t slot = READ_INST_8_2(); + uint16_t v0 = READ_INST_8_3(); + LOG_INST() << "intrinsics::stlexvar" + << " level:" << level << " slot:" << slot << " v" << v0; + + JSTaggedValue value = GET_VREG_VALUE(v0); + InterpretedFrame *state = GET_FRAME(sp); + JSTaggedValue env = state->env; + for (uint32_t i = 0; i < level; i++) { + JSTaggedValue taggedParentEnv = LexicalEnv::Cast(env.GetTaggedObject())->GetParentEnv(); + ASSERT(!taggedParentEnv.IsUndefined()); + env = taggedParentEnv; + } + LexicalEnv::Cast(env.GetTaggedObject())->SetProperties(thread, slot, value); + + DISPATCH(DEPRECATED_STLEXVAR_PREF_IMM8_IMM8_V8); + } + HANDLE_OPCODE(DEPRECATED_STLEXVAR_PREF_IMM16_IMM16_V8) { + uint16_t level = READ_INST_16_1(); + uint16_t slot = READ_INST_16_3(); + uint16_t v0 = READ_INST_8_5(); + LOG_INST() << "intrinsics::stlexvar" + << " level:" << level << " slot:" << slot << " v" << v0; + + JSTaggedValue value = GET_VREG_VALUE(v0); + InterpretedFrame *state = GET_FRAME(sp); + JSTaggedValue env = state->env; + for (uint32_t i = 0; i < level; i++) { + JSTaggedValue taggedParentEnv = LexicalEnv::Cast(env.GetTaggedObject())->GetParentEnv(); + ASSERT(!taggedParentEnv.IsUndefined()); + env = taggedParentEnv; + } + LexicalEnv::Cast(env.GetTaggedObject())->SetProperties(thread, slot, value); - SAVE_ACC(); - SAVE_PC(); - receiver = GET_VREG_VALUE(v0); // Maybe moved by GC - auto propKey = GET_OBJ_FROM_CACHE(stringId); // Maybe moved by GC - auto value = GET_ACC(); // Maybe moved by GC - JSTaggedValue res = SlowRuntimeStub::StOwnByNameWithNameSet(thread, receiver, propKey, value); - RESTORE_ACC(); - INTERPRETER_RETURN_IF_ABRUPT(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); + DISPATCH(DEPRECATED_STLEXVAR_PREF_IMM16_IMM16_V8); } + HANDLE_OPCODE(GETMODULENAMESPACE_IMM8) { + uint16_t stringId = READ_INST_8_0(); + auto localName = GET_OBJ_FROM_CACHE(stringId); - HANDLE_OPCODE(HANDLE_LDGLOBALVAR_PREF_ID32) { - uint32_t stringId = READ_INST_32_1(); - JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); + LOG_INST() << "intrinsics::getmodulenamespace " + << "stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(localName.GetTaggedObject())); -#if ECMASCRIPT_ENABLE_IC - auto profileTypeInfo = GetRuntimeProfileTypeInfo(sp); - if (!profileTypeInfo.IsUndefined()) { - uint16_t slotId = READ_INST_8_0(); - JSTaggedValue res = ICRuntimeStub::LoadGlobalICByName(thread, - ProfileTypeInfo::Cast( - profileTypeInfo.GetTaggedObject()), - globalObj, propKey, slotId); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); - } -#endif - JSTaggedValue result = FastRuntimeStub::GetGlobalOwnProperty(thread, globalObj, propKey); - if (!result.IsHole()) { - SET_ACC(result); - } else { - // slow path - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::LdGlobalVarFromGlobalProto(thread, globalObj, propKey); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - } - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + JSTaggedValue moduleNamespace = SlowRuntimeStub::GetModuleNamespace(thread, localName); + INTERPRETER_RETURN_IF_ABRUPT(moduleNamespace); + SET_ACC(moduleNamespace); + DISPATCH(GETMODULENAMESPACE_IMM8); } - HANDLE_OPCODE(HANDLE_LDOBJBYNAME_PREF_ID32_V8) { - uint32_t v0 = READ_INST_8_5(); - JSTaggedValue receiver = GET_VREG_VALUE(v0); + HANDLE_OPCODE(WIDE_GETMODULENAMESPACE_PREF_IMM16) { + uint16_t stringId = READ_INST_16_1(); + auto localName = GET_OBJ_FROM_CACHE(stringId); -#if ECMASCRIPT_ENABLE_IC - auto profileTypeInfo = GetRuntimeProfileTypeInfo(sp); - if (!profileTypeInfo.IsUndefined()) { - uint16_t slotId = READ_INST_8_0(); - auto profileTypeArray = ProfileTypeInfo::Cast(profileTypeInfo.GetTaggedObject()); - JSTaggedValue firstValue = profileTypeArray->Get(slotId); - JSTaggedValue res = JSTaggedValue::Hole(); + LOG_INST() << "intrinsics::getmodulenamespace " + << "stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(localName.GetTaggedObject())); - if (LIKELY(firstValue.IsHeapObject())) { - JSTaggedValue secondValue = profileTypeArray->Get(slotId + 1); - res = ICRuntimeStub::TryLoadICByName(thread, receiver, firstValue, secondValue); - } - if (LIKELY(!res.IsHole())) { - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); - } else if (!firstValue.IsHole()) { // IC miss and not enter the megamorphic state, store as polymorphic - uint32_t stringId = READ_INST_32_1(); - JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); - res = ICRuntimeStub::LoadICByName(thread, - profileTypeArray, - receiver, propKey, slotId); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); - } - } -#endif - uint32_t stringId = READ_INST_32_1(); - JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); - LOG_INST() << "intrinsics::ldobjbyname " - << "v" << v0 << " stringId:" << stringId << ", " - << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())) << ", obj:" << receiver.GetRawData(); + JSTaggedValue moduleNamespace = SlowRuntimeStub::GetModuleNamespace(thread, localName); + INTERPRETER_RETURN_IF_ABRUPT(moduleNamespace); + SET_ACC(moduleNamespace); + DISPATCH(WIDE_GETMODULENAMESPACE_PREF_IMM16); + } + HANDLE_OPCODE(DEPRECATED_GETMODULENAMESPACE_PREF_ID32) { + uint16_t stringId = READ_INST_32_1(); + auto localName = GET_OBJ_FROM_CACHE(stringId); - if (LIKELY(receiver.IsHeapObject())) { - // fast path - JSTaggedValue res = FastRuntimeStub::GetPropertyByName(thread, receiver, propKey); - if (!res.IsHole()) { - ASSERT(!res.IsAccessor()); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); - } - } - // not meet fast condition or fast path return hole, walk slow path - // slow stub not need receiver - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::LdObjByName(thread, receiver, propKey, false, JSTaggedValue::Undefined()); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); + LOG_INST() << "intrinsics::getmodulenamespace " + << "stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(localName.GetTaggedObject())); + + JSTaggedValue moduleNamespace = SlowRuntimeStub::GetModuleNamespace(thread, localName); + INTERPRETER_RETURN_IF_ABRUPT(moduleNamespace); + SET_ACC(moduleNamespace); + DISPATCH(DEPRECATED_GETMODULENAMESPACE_PREF_ID32); } - HANDLE_OPCODE(HANDLE_STOBJBYNAME_PREF_ID32_V8) { - uint32_t v0 = READ_INST_8_5(); - JSTaggedValue receiver = GET_VREG_VALUE(v0); + HANDLE_OPCODE(STMODULEVAR_IMM8) { + uint16_t stringId = READ_INST_8_0(); + auto key = GET_OBJ_FROM_CACHE(stringId); + + LOG_INST() << "intrinsics::stmodulevar " + << "stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(key.GetTaggedObject())); + JSTaggedValue value = GET_ACC(); -#if ECMASCRIPT_ENABLE_IC - auto profileTypeInfo = GetRuntimeProfileTypeInfo(sp); - if (!profileTypeInfo.IsUndefined()) { - uint16_t slotId = READ_INST_8_0(); - auto profileTypeArray = ProfileTypeInfo::Cast(profileTypeInfo.GetTaggedObject()); - JSTaggedValue firstValue = profileTypeArray->Get(slotId); - JSTaggedValue res = JSTaggedValue::Hole(); - SAVE_ACC(); - if (LIKELY(firstValue.IsHeapObject())) { - JSTaggedValue secondValue = profileTypeArray->Get(slotId + 1); - res = ICRuntimeStub::TryStoreICByName(thread, receiver, firstValue, secondValue, value); - } - if (LIKELY(!res.IsHole())) { - INTERPRETER_RETURN_IF_ABRUPT(res); - RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); - } else if (!firstValue.IsHole()) { // IC miss and not enter the megamorphic state, store as polymorphic - uint32_t stringId = READ_INST_32_1(); - JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); - res = ICRuntimeStub::StoreICByName(thread, - profileTypeArray, - receiver, propKey, value, slotId); - INTERPRETER_RETURN_IF_ABRUPT(res); - RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); - } - } -#endif - uint32_t stringId = READ_INST_32_1(); - LOG_INST() << "intrinsics::stobjbyname " - << "v" << v0 << " stringId:" << stringId; - if (receiver.IsHeapObject()) { - JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); - value = GET_ACC(); - // fast path - SAVE_ACC(); - JSTaggedValue res = FastRuntimeStub::SetPropertyByName(thread, receiver, propKey, value); - if (!res.IsHole()) { - INTERPRETER_RETURN_IF_ABRUPT(res); - RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); - } - RESTORE_ACC(); - } - // slow path SAVE_ACC(); - SAVE_PC(); - receiver = GET_VREG_VALUE(v0); // Maybe moved by GC - auto propKey = GET_OBJ_FROM_CACHE(stringId); // Maybe moved by GC - value = GET_ACC(); // Maybe moved by GC - JSTaggedValue res = SlowRuntimeStub::StObjByName(thread, receiver, propKey, value); - INTERPRETER_RETURN_IF_ABRUPT(res); + SlowRuntimeStub::StModuleVar(thread, key, value); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); + DISPATCH(STMODULEVAR_IMM8); } - HANDLE_OPCODE(HANDLE_LDSUPERBYNAME_PREF_ID32_V8) { - uint32_t stringId = READ_INST_32_1(); - uint32_t v0 = READ_INST_8_5(); - JSTaggedValue obj = GET_VREG_VALUE(v0); - JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); + HANDLE_OPCODE(WIDE_STMODULEVAR_PREF_IMM16) { + uint16_t stringId = READ_INST_16_1(); + auto key = GET_OBJ_FROM_CACHE(stringId); - LOG_INST() << "intrinsics::ldsuperbyname" - << "v" << v0 << " stringId:" << stringId << ", " - << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())) << ", obj:" << obj.GetRawData(); + LOG_INST() << "intrinsics::stmodulevar " + << "stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(key.GetTaggedObject())); - SAVE_PC(); - JSTaggedValue thisFunc = GetThisFunction(sp); - JSTaggedValue res = SlowRuntimeStub::LdSuperByValue(thread, obj, propKey, thisFunc); + JSTaggedValue value = GET_ACC(); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); + SAVE_ACC(); + SlowRuntimeStub::StModuleVar(thread, key, value); + RESTORE_ACC(); + DISPATCH(WIDE_STMODULEVAR_PREF_IMM16); } - HANDLE_OPCODE(HANDLE_STSUPERBYNAME_PREF_ID32_V8) { - uint32_t stringId = READ_INST_32_1(); - uint32_t v0 = READ_INST_8_5(); + HANDLE_OPCODE(DEPRECATED_STMODULEVAR_PREF_ID32) { + uint16_t stringId = READ_INST_32_1(); + auto key = GET_OBJ_FROM_CACHE(stringId); - JSTaggedValue obj = GET_VREG_VALUE(v0); - JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); - JSTaggedValue value = GET_ACC(); + LOG_INST() << "intrinsics::stmodulevar " + << "stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(key.GetTaggedObject())); - LOG_INST() << "intrinsics::stsuperbyname" - << "v" << v0 << " stringId:" << stringId << ", " - << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())) << ", obj:" << obj.GetRawData() - << ", value:" << value.GetRawData(); + JSTaggedValue value = GET_ACC(); - // slow path SAVE_ACC(); - SAVE_PC(); - JSTaggedValue thisFunc = GetThisFunction(sp); - JSTaggedValue res = SlowRuntimeStub::StSuperByValue(thread, obj, propKey, value, thisFunc); - INTERPRETER_RETURN_IF_ABRUPT(res); + SlowRuntimeStub::StModuleVar(thread, key, value); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); + DISPATCH(DEPRECATED_STMODULEVAR_PREF_ID32); } - HANDLE_OPCODE(HANDLE_STGLOBALVAR_PREF_ID32) { - uint32_t stringId = READ_INST_32_1(); - JSTaggedValue prop = GET_OBJ_FROM_CACHE(stringId); - JSTaggedValue value = GET_ACC(); + HANDLE_OPCODE(LDLOCALMODULEVAR_IMM8) { + uint16_t stringId = READ_INST_8_0(); - LOG_INST() << "intrinsics::stglobalvar " - << "stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(prop.GetTaggedObject())) - << ", value:" << value.GetRawData(); -#if ECMASCRIPT_ENABLE_IC - auto profileTypeInfo = GetRuntimeProfileTypeInfo(sp); - if (!profileTypeInfo.IsUndefined()) { - uint16_t slotId = READ_INST_8_0(); - SAVE_ACC(); - JSTaggedValue res = ICRuntimeStub::StoreGlobalICByName(thread, - ProfileTypeInfo::Cast( - profileTypeInfo.GetTaggedObject()), - globalObj, prop, value, slotId); - INTERPRETER_RETURN_IF_ABRUPT(res); - RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); - } -#endif + JSTaggedValue key = GET_OBJ_FROM_CACHE(stringId); + LOG_INST() << "intrinsics::ldmodulevar " + << "string_id:" << stringId << ", " + << "key: " << ConvertToString(EcmaString::Cast(key.GetTaggedObject())); + + JSTaggedValue moduleVar = SlowRuntimeStub::LdModuleVar(thread, key, true); + INTERPRETER_RETURN_IF_ABRUPT(moduleVar); + SET_ACC(moduleVar); + DISPATCH(LDLOCALMODULEVAR_IMM8); + } + HANDLE_OPCODE(WIDE_LDLOCALMODULEVAR_PREF_IMM16) { + uint16_t stringId = READ_INST_16_1(); + + JSTaggedValue key = GET_OBJ_FROM_CACHE(stringId); + LOG_INST() << "intrinsics::ldmodulevar " + << "string_id:" << stringId << ", " + << "key: " << ConvertToString(EcmaString::Cast(key.GetTaggedObject())); + + JSTaggedValue moduleVar = SlowRuntimeStub::LdModuleVar(thread, key, true); + INTERPRETER_RETURN_IF_ABRUPT(moduleVar); + SET_ACC(moduleVar); + DISPATCH(WIDE_LDLOCALMODULEVAR_PREF_IMM16); + } + HANDLE_OPCODE(LDEXTERNALMODULEVAR_IMM8) { + uint16_t stringId = READ_INST_8_0(); + + JSTaggedValue key = GET_OBJ_FROM_CACHE(stringId); + LOG_INST() << "intrinsics::ldmodulevar " + << "string_id:" << stringId << ", " + << "key: " << ConvertToString(EcmaString::Cast(key.GetTaggedObject())); + + JSTaggedValue moduleVar = SlowRuntimeStub::LdModuleVar(thread, key, false); + INTERPRETER_RETURN_IF_ABRUPT(moduleVar); + SET_ACC(moduleVar); + DISPATCH(LDEXTERNALMODULEVAR_IMM8); + } + HANDLE_OPCODE(WIDE_LDEXTERNALMODULEVAR_PREF_IMM16) { + uint16_t stringId = READ_INST_16_1(); + + JSTaggedValue key = GET_OBJ_FROM_CACHE(stringId); + LOG_INST() << "intrinsics::ldmodulevar " + << "string_id:" << stringId << ", " + << "key: " << ConvertToString(EcmaString::Cast(key.GetTaggedObject())); + + JSTaggedValue moduleVar = SlowRuntimeStub::LdModuleVar(thread, key, false); + INTERPRETER_RETURN_IF_ABRUPT(moduleVar); + SET_ACC(moduleVar); + DISPATCH(WIDE_LDEXTERNALMODULEVAR_PREF_IMM16); + } + HANDLE_OPCODE(STCONSTTOGLOBALRECORD_IMM16_ID16) { + uint16_t stringId = READ_INST_16_2(); + JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); + LOG_INST() << "intrinsics::stconsttoglobalrecord" + << " stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())); + + JSTaggedValue value = GET_ACC(); SAVE_ACC(); SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::StGlobalVar(thread, prop, value); + JSTaggedValue res = SlowRuntimeStub::StGlobalRecord(thread, propKey, value, true); INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + DISPATCH(STCONSTTOGLOBALRECORD_IMM16_ID16); } - HANDLE_OPCODE(HANDLE_CREATEGENERATOROBJ_PREF_V8) { - uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::creategeneratorobj" - << " v" << v0; + HANDLE_OPCODE(DEPRECATED_STCONSTTOGLOBALRECORD_PREF_ID32) { + uint16_t stringId = READ_INST_32_1(); + JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); + LOG_INST() << "intrinsics::stconsttoglobalrecord" + << " stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())); + + JSTaggedValue value = GET_ACC(); + SAVE_ACC(); SAVE_PC(); - JSTaggedValue genFunc = GET_VREG_VALUE(v0); - JSTaggedValue res = SlowRuntimeStub::CreateGeneratorObj(thread, genFunc); + JSTaggedValue res = SlowRuntimeStub::StGlobalRecord(thread, propKey, value, true); INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8); + RESTORE_ACC(); + DISPATCH(DEPRECATED_STCONSTTOGLOBALRECORD_PREF_ID32); } - HANDLE_OPCODE(HANDLE_STARRAYSPREAD_PREF_V8_V8) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - LOG_INST() << "ecmascript::intrinsics::starrayspread" - << " v" << v0 << " v" << v1 << "acc"; - JSTaggedValue dst = GET_VREG_VALUE(v0); - JSTaggedValue index = GET_VREG_VALUE(v1); - JSTaggedValue src = GET_ACC(); + HANDLE_OPCODE(STTOGLOBALRECORD_IMM16_ID16) { + uint16_t stringId = READ_INST_16_2(); + JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); + LOG_INST() << "intrinsics::stlettoglobalrecord" + << " stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())); + + JSTaggedValue value = GET_ACC(); + SAVE_ACC(); SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::StArraySpread(thread, dst, index, src); + JSTaggedValue res = SlowRuntimeStub::StGlobalRecord(thread, propKey, value, false); INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + RESTORE_ACC(); + DISPATCH(STTOGLOBALRECORD_IMM16_ID16); } - HANDLE_OPCODE(HANDLE_GETITERATORNEXT_PREF_V8_V8) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - LOG_INST() << "intrinsic::getiteratornext" - << " v" << v0 << " v" << v1; - JSTaggedValue obj = GET_VREG_VALUE(v0); - JSTaggedValue method = GET_VREG_VALUE(v1); + HANDLE_OPCODE(DEPRECATED_STLETTOGLOBALRECORD_PREF_ID32) { + uint16_t stringId = READ_INST_32_1(); + JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); + LOG_INST() << "intrinsics::stlettoglobalrecord" + << " stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())); + + JSTaggedValue value = GET_ACC(); + SAVE_ACC(); SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::GetIteratorNext(thread, obj, method); + JSTaggedValue res = SlowRuntimeStub::StGlobalRecord(thread, propKey, value, false); INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + RESTORE_ACC(); + DISPATCH(DEPRECATED_STLETTOGLOBALRECORD_PREF_ID32); } - HANDLE_OPCODE(HANDLE_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8) { - uint16_t methodId = READ_INST_16_1(); - uint16_t length = READ_INST_16_5(); - uint16_t v0 = READ_INST_8_7(); - uint16_t v1 = READ_INST_8_8(); - LOG_INST() << "intrinsics::defineclasswithbuffer" - << " method id:" << methodId << " lexenv: v" << v0 << " parent: v" << v1; - JSFunction *classTemplate = JSFunction::Cast(GET_OBJ_FROM_CACHE(methodId).GetTaggedObject()); - ASSERT(classTemplate != nullptr); - - JSTaggedValue lexenv = GET_VREG_VALUE(v0); - JSTaggedValue proto = GET_VREG_VALUE(v1); + HANDLE_OPCODE(DEPRECATED_STCLASSTOGLOBALRECORD_PREF_ID32) { + uint16_t stringId = READ_INST_32_1(); + JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); + LOG_INST() << "intrinsics::stclasstoglobalrecord" + << " stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())); - JSTaggedValue res; + JSTaggedValue value = GET_ACC(); + SAVE_ACC(); SAVE_PC(); - res = SlowRuntimeStub::CloneClassFromTemplate(thread, JSTaggedValue(classTemplate), proto, lexenv); - + JSTaggedValue res = SlowRuntimeStub::StGlobalRecord(thread, propKey, value, false); INTERPRETER_RETURN_IF_ABRUPT(res); - ASSERT(res.IsClassConstructor()); - JSFunction *cls = JSFunction::Cast(res.GetTaggedObject()); + RESTORE_ACC(); + DISPATCH(DEPRECATED_STCLASSTOGLOBALRECORD_PREF_ID32); + } + HANDLE_OPCODE(DEPRECATED_LDMODULEVAR_PREF_ID32_IMM8) { + uint16_t stringId = READ_INST_16_1(); + uint8_t innerFlag = READ_INST_8_5(); - lexenv = GET_VREG_VALUE(v0); // slow runtime may gc - cls->SetLexicalEnv(thread, lexenv); + JSTaggedValue key = GET_OBJ_FROM_CACHE(stringId); + LOG_INST() << "intrinsics::ldmodulevar " + << "string_id:" << stringId << ", " + << "key: " << ConvertToString(EcmaString::Cast(key.GetTaggedObject())); - JSFunction *currentFunc = JSFunction::Cast((GET_FRAME(sp)->function).GetTaggedObject()); - cls->SetModule(thread, currentFunc->GetModule()); + JSTaggedValue moduleVar = SlowRuntimeStub::LdModuleVar(thread, key, innerFlag != 0); + INTERPRETER_RETURN_IF_ABRUPT(moduleVar); + SET_ACC(moduleVar); + DISPATCH(DEPRECATED_LDMODULEVAR_PREF_ID32_IMM8); + } + HANDLE_OPCODE(LDOBJBYNAME_IMM8_ID16) { + JSTaggedValue receiver = GET_ACC(); - SlowRuntimeStub::SetClassConstructorLength(thread, res, JSTaggedValue(length)); +#if ECMASCRIPT_ENABLE_IC + auto profileTypeInfo = GetRuntimeProfileTypeInfo(sp); + if (!profileTypeInfo.IsUndefined()) { + uint16_t slotId = READ_INST_8_0(); + auto profileTypeArray = ProfileTypeInfo::Cast(profileTypeInfo.GetTaggedObject()); + JSTaggedValue firstValue = profileTypeArray->Get(slotId); + JSTaggedValue res = JSTaggedValue::Hole(); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID16_IMM16_IMM16_V8_V8); - } - HANDLE_OPCODE(HANDLE_LDFUNCTION_PREF) { - LOG_INST() << "intrinsic::ldfunction"; - SET_ACC(GetThisFunction(sp)); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); - } - HANDLE_OPCODE(HANDLE_LDBIGINT_PREF_ID32) { - uint32_t stringId = READ_INST_32_1(); - LOG_INST() << "intrinsic::ldbigint"; - JSTaggedValue numberBigInt = GET_OBJ_FROM_CACHE(stringId); - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::LdBigInt(thread, numberBigInt); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); - } - HANDLE_OPCODE(HANDLE_TONUMERIC_PREF_V8) { - uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::tonumeric" - << " v" << v0; - JSTaggedValue value = GET_VREG_VALUE(v0); - if (value.IsNumber() || value.IsBigInt()) { + if (LIKELY(firstValue.IsHeapObject())) { + JSTaggedValue secondValue = profileTypeArray->Get(slotId + 1); + res = ICRuntimeStub::TryLoadICByName(thread, receiver, firstValue, secondValue); + } + if (LIKELY(!res.IsHole())) { + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(LDOBJBYNAME_IMM8_ID16); + } else if (!firstValue.IsHole()) { // IC miss and not enter the megamorphic state, store as polymorphic + uint16_t stringId = READ_INST_16_1(); + JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); + res = ICRuntimeStub::LoadICByName(thread, + profileTypeArray, + receiver, propKey, slotId); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(LDOBJBYNAME_IMM8_ID16); + } + } +#endif + uint16_t stringId = READ_INST_16_1(); + JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); + LOG_INST() << "intrinsics::ldobjbyname stringId:" << stringId << ", " + << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())) << ", obj:" << receiver.GetRawData(); + + if (LIKELY(receiver.IsHeapObject())) { // fast path - SET_ACC(value); - } else { - // slow path - SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::ToNumeric(thread, value); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); + JSTaggedValue res = FastRuntimeStub::GetPropertyByName(thread, receiver, propKey); + if (!res.IsHole()) { + ASSERT(!res.IsAccessor()); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(LDOBJBYNAME_IMM8_ID16); + } } - DISPATCH(BytecodeInstruction::Format::PREF_V8); - } - HANDLE_OPCODE(HANDLE_CREATEASYNCGENERATOROBJ_PREF_V8) { - uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::createasyncgeneratorobj" - << " v" << v0; + // not meet fast condition or fast path return hole, walk slow path + // slow stub not need receiver SAVE_PC(); - JSTaggedValue genFunc = GET_VREG_VALUE(v0); - JSTaggedValue res = SlowRuntimeStub::CreateAsyncGeneratorObj(thread, genFunc); + JSTaggedValue res = SlowRuntimeStub::LdObjByName(thread, receiver, propKey, false, JSTaggedValue::Undefined()); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(LDOBJBYNAME_IMM8_ID16); } - HANDLE_OPCODE(HANDLE_ASYNCGENERATORRESOLVE_PREF_V8_V8_V8) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - uint16_t v2 = READ_INST_8_3(); - LOG_INST() << "intrinsics::asyncgeneratorresolve" - << " v" << v0 << " v" << v1 << " v" << v2; - JSTaggedValue asyncGenerator = GET_VREG_VALUE(v0); - JSTaggedValue value = GET_VREG_VALUE(v1); - JSTaggedValue flag = GET_VREG_VALUE(v2); + HANDLE_OPCODE(LDOBJBYNAME_IMM16_ID16) { + JSTaggedValue receiver = GET_ACC(); + +#if ECMASCRIPT_ENABLE_IC + auto profileTypeInfo = GetRuntimeProfileTypeInfo(sp); + if (!profileTypeInfo.IsUndefined()) { + uint16_t slotId = READ_INST_16_0(); + auto profileTypeArray = ProfileTypeInfo::Cast(profileTypeInfo.GetTaggedObject()); + JSTaggedValue firstValue = profileTypeArray->Get(slotId); + JSTaggedValue res = JSTaggedValue::Hole(); + + if (LIKELY(firstValue.IsHeapObject())) { + JSTaggedValue secondValue = profileTypeArray->Get(slotId + 1); + res = ICRuntimeStub::TryLoadICByName(thread, receiver, firstValue, secondValue); + } + if (LIKELY(!res.IsHole())) { + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(LDOBJBYNAME_IMM16_ID16); + } else if (!firstValue.IsHole()) { // IC miss and not enter the megamorphic state, store as polymorphic + uint16_t stringId = READ_INST_16_2(); + JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); + res = ICRuntimeStub::LoadICByName(thread, + profileTypeArray, + receiver, propKey, slotId); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(LDOBJBYNAME_IMM16_ID16); + } + } +#endif + uint16_t stringId = READ_INST_16_2(); + JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); + LOG_INST() << "intrinsics::ldobjbyname stringId:" << stringId << ", " + << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())) << ", obj:" << receiver.GetRawData(); + + if (LIKELY(receiver.IsHeapObject())) { + // fast path + JSTaggedValue res = FastRuntimeStub::GetPropertyByName(thread, receiver, propKey); + if (!res.IsHole()) { + ASSERT(!res.IsAccessor()); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(LDOBJBYNAME_IMM16_ID16); + } + } + // not meet fast condition or fast path return hole, walk slow path + // slow stub not need receiver SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::AsyncGeneratorResolve(thread, asyncGenerator, value, flag); + JSTaggedValue res = SlowRuntimeStub::LdObjByName(thread, receiver, propKey, false, JSTaggedValue::Undefined()); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8_V8); + DISPATCH(LDOBJBYNAME_IMM16_ID16); } - HANDLE_OPCODE(HANDLE_SUPERCALL_PREF_IMM16_V8) { - uint16_t range = READ_INST_16_1(); - uint16_t v0 = READ_INST_8_3(); - LOG_INST() << "intrinsics::supercall" - << " range: " << range << " v" << v0; - - JSTaggedValue thisFunc = GET_ACC(); - JSTaggedValue newTarget = GetNewTarget(sp); - - SAVE_PC(); - JSTaggedValue superCtor = SlowRuntimeStub::GetSuperConstructor(thread, thisFunc); - INTERPRETER_RETURN_IF_ABRUPT(superCtor); - - if (superCtor.IsJSFunction() && superCtor.IsConstructor() && !newTarget.IsUndefined()) { - JSFunction *superCtorFunc = JSFunction::Cast(superCtor.GetTaggedObject()); - methodHandle.Update(superCtorFunc->GetMethod()); - if (superCtorFunc->IsBuiltinConstructor()) { - ASSERT(methodHandle->GetNumVregsWithCallField() == 0); - size_t frameSize = - InterpretedFrame::NumOfMembers() + range + NUM_MANDATORY_JSFUNC_ARGS + 2; // 2:thread & numArgs - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - JSTaggedType *newSp = sp - frameSize; - if (UNLIKELY(thread->DoStackOverflowCheck(newSp))) { - INTERPRETER_GOTO_EXCEPTION_HANDLER(); - } - // copy args - uint32_t index = 0; - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - EcmaRuntimeCallInfo *ecmaRuntimeCallInfo = reinterpret_cast(newSp); - newSp[index++] = ToUintPtr(thread); - newSp[index++] = range + NUM_MANDATORY_JSFUNC_ARGS; - // func - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - newSp[index++] = superCtor.GetRawData(); - // newTarget - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - newSp[index++] = newTarget.GetRawData(); - // this - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; - for (size_t i = 0; i < range; ++i) { - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - newSp[index++] = GET_VREG(v0 + i); - } + HANDLE_OPCODE(DEPRECATED_LDOBJBYNAME_PREF_ID32_V8) { + uint32_t v0 = READ_INST_8_5(); + JSTaggedValue receiver = GET_VREG_VALUE(v0); - InterpretedBuiltinFrame *state = GET_BUILTIN_FRAME(newSp); - state->base.prev = sp; - state->base.type = FrameType::INTERPRETER_BUILTIN_FRAME; - state->pc = nullptr; - state->function = superCtor; - thread->SetCurrentSPFrame(newSp); - LOG_INST() << "Entry: Runtime SuperCall "; - JSTaggedValue retValue = reinterpret_cast( - const_cast(methodHandle->GetNativePointer()))(ecmaRuntimeCallInfo); - thread->SetCurrentSPFrame(sp); + uint16_t stringId = READ_INST_32_1(); + JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); + LOG_INST() << "intrinsics::ldobjbyname " + << "v" << v0 << " stringId:" << stringId << ", " + << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())) << ", obj:" << receiver.GetRawData(); - if (UNLIKELY(thread->HasPendingException())) { - INTERPRETER_GOTO_EXCEPTION_HANDLER(); - } - LOG_INST() << "Exit: Runtime SuperCall "; - SET_ACC(retValue); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16_V8); + if (LIKELY(receiver.IsHeapObject())) { + // fast path + JSTaggedValue res = FastRuntimeStub::GetPropertyByName(thread, receiver, propKey); + if (!res.IsHole()) { + ASSERT(!res.IsAccessor()); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(DEPRECATED_LDOBJBYNAME_PREF_ID32_V8); } + } + // not meet fast condition or fast path return hole, walk slow path + // slow stub not need receiver + SAVE_PC(); + JSTaggedValue res = SlowRuntimeStub::LdObjByName(thread, receiver, propKey, false, JSTaggedValue::Undefined()); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(DEPRECATED_LDOBJBYNAME_PREF_ID32_V8); + } + HANDLE_OPCODE(LDSUPERBYNAME_IMM8_ID16) { + uint16_t stringId = READ_INST_16_1(); + JSTaggedValue obj = GET_ACC(); + JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); - if (IsFastNewFrameEnter(superCtorFunc, methodHandle)) { - SAVE_PC(); - uint32_t numVregs = methodHandle->GetNumVregsWithCallField(); - uint32_t numDeclaredArgs = superCtorFunc->IsBase() ? - methodHandle->GetNumArgsWithCallField() + 1 : // +1 for this - methodHandle->GetNumArgsWithCallField() + 2; // +2 for newTarget and this - // +1 for hidden this, explicit this may be overwritten after bc optimizer - size_t frameSize = InterpretedFrame::NumOfMembers() + numVregs + numDeclaredArgs + 1; - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - JSTaggedType *newSp = sp - frameSize; - InterpretedFrame *state = GET_FRAME(newSp); - - if (UNLIKELY(thread->DoStackOverflowCheck(newSp))) { - INTERPRETER_GOTO_EXCEPTION_HANDLER(); - } + LOG_INST() << "intrinsics::ldsuperbyname stringId:" << stringId << ", " + << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())) << ", obj:" << obj.GetRawData(); - uint32_t index = 0; - // initialize vregs value - for (size_t i = 0; i < numVregs; ++i) { - newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; - } + SAVE_PC(); + JSTaggedValue thisFunc = GetThisFunction(sp); + JSTaggedValue res = SlowRuntimeStub::LdSuperByValue(thread, obj, propKey, thisFunc); - // this - JSTaggedValue thisObj; - if (superCtorFunc->IsBase()) { - thisObj = FastRuntimeStub::NewThisObject(thread, superCtor, newTarget, state); - INTERPRETER_RETURN_IF_ABRUPT(thisObj); - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - newSp[index++] = thisObj.GetRawData(); - } else { - ASSERT(superCtorFunc->IsDerivedConstructor()); - newSp[index++] = newTarget.GetRawData(); - thisObj = JSTaggedValue::Undefined(); - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - newSp[index++] = thisObj.GetRawData(); + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(LDSUPERBYNAME_IMM8_ID16); + } + HANDLE_OPCODE(LDSUPERBYNAME_IMM16_ID16) { + uint16_t stringId = READ_INST_16_2(); + JSTaggedValue obj = GET_ACC(); + JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); - state->function = superCtor; - state->constpool = methodHandle->GetConstantPool(); - state->profileTypeInfo = superCtorFunc->GetProfileTypeInfo(); - state->env = superCtorFunc->GetLexicalEnv(); - } + LOG_INST() << "intrinsics::ldsuperbyname stringId:" << stringId << ", " + << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())) << ", obj:" << obj.GetRawData(); - // the second condition ensure not push extra args - for (size_t i = 0; i < range && index < numVregs + numDeclaredArgs; ++i) { - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - newSp[index++] = GET_VREG(v0 + i); - } + SAVE_PC(); + JSTaggedValue thisFunc = GetThisFunction(sp); + JSTaggedValue res = SlowRuntimeStub::LdSuperByValue(thread, obj, propKey, thisFunc); - // set undefined to the extra prats of declare - for (size_t i = index; i < numVregs + numDeclaredArgs; ++i) { - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - newSp[index++] = JSTaggedValue::VALUE_UNDEFINED; - } + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(LDSUPERBYNAME_IMM16_ID16); + } + HANDLE_OPCODE(DEPRECATED_LDSUPERBYNAME_PREF_ID32_V8) { + uint32_t stringId = READ_INST_32_1(); + uint32_t v0 = READ_INST_8_5(); + JSTaggedValue obj = GET_VREG_VALUE(v0); + JSTaggedValue propKey = GET_OBJ_FROM_CACHE(stringId); - // hidden this object - newSp[index] = thisObj.GetRawData(); + LOG_INST() << "intrinsics::ldsuperbyname" + << "v" << v0 << " stringId:" << stringId << ", " + << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())) << ", obj:" << obj.GetRawData(); - state->base.prev = sp; - state->base.type = FrameType::INTERPRETER_FAST_NEW_FRAME; - state->pc = pc = methodHandle->GetBytecodeArray(); - sp = newSp; - state->acc = JSTaggedValue::Hole(); + SAVE_PC(); + JSTaggedValue thisFunc = GetThisFunction(sp); + JSTaggedValue res = SlowRuntimeStub::LdSuperByValue(thread, obj, propKey, thisFunc); - thread->SetCurrentSPFrame(newSp); - LOG_INST() << "Entry: Runtime SuperCall " << std::hex << reinterpret_cast(sp) - << " " << std::hex << reinterpret_cast(pc); - DISPATCH_OFFSET(0); - } - } + INTERPRETER_RETURN_IF_ABRUPT(res); + SET_ACC(res); + DISPATCH(DEPRECATED_LDSUPERBYNAME_PREF_ID32_V8); + } + HANDLE_OPCODE(ASYNCFUNCTIONRESOLVE_V8) { + uint16_t v0 = READ_INST_8_0(); + LOG_INST() << "intrinsics::asyncfunctionresolve" + << " v" << v0; + JSTaggedValue asyncFuncObj = GET_VREG_VALUE(v0); + JSTaggedValue value = GET_ACC(); SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::SuperCall(thread, thisFunc, newTarget, v0, range); + JSTaggedValue res = SlowRuntimeStub::AsyncFunctionResolveOrReject(thread, asyncFuncObj, value, true); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16_V8); + DISPATCH(ASYNCFUNCTIONRESOLVE_V8); } - HANDLE_OPCODE(HANDLE_SUPERCALLSPREAD_PREF_V8) { + HANDLE_OPCODE(DEPRECATED_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsic::supercallspread" - << " array: v" << v0; - - JSTaggedValue thisFunc = GET_ACC(); - JSTaggedValue newTarget = GetNewTarget(sp); - JSTaggedValue array = GET_VREG_VALUE(v0); + [[maybe_unused]] uint16_t v1 = READ_INST_8_2(); + uint16_t v2 = READ_INST_8_3(); + LOG_INST() << "intrinsics::asyncfunctionresolve" + << " v" << v0 << " v" << v1 << " v" << v2; + JSTaggedValue asyncFuncObj = GET_VREG_VALUE(v0); + JSTaggedValue value = GET_VREG_VALUE(v2); SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::SuperCallSpread(thread, thisFunc, newTarget, array); + JSTaggedValue res = SlowRuntimeStub::AsyncFunctionResolveOrReject(thread, asyncFuncObj, value, true); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(DEPRECATED_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8); } - HANDLE_OPCODE(HANDLE_CREATEOBJECTHAVINGMETHOD_PREF_IMM16) { - uint16_t imm = READ_INST_16_1(); - LOG_INST() << "intrinsics::createobjecthavingmethod" - << " imm:" << imm; - JSObject *result = JSObject::Cast(GET_OBJ_FROM_CACHE(imm).GetTaggedObject()); - JSTaggedValue env = GET_ACC(); + HANDLE_OPCODE(ASYNCFUNCTIONREJECT_V8) { + uint16_t v0 = READ_INST_8_0(); + LOG_INST() << "intrinsics::asyncfunctionreject" + << " v" << v0; + JSTaggedValue asyncFuncObj = GET_VREG_VALUE(v0); + JSTaggedValue value = GET_ACC(); SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::CreateObjectHavingMethod(thread, factory, result, env); + JSTaggedValue res = SlowRuntimeStub::AsyncFunctionResolveOrReject(thread, asyncFuncObj, value, false); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16); + DISPATCH(ASYNCFUNCTIONREJECT_V8); } - HANDLE_OPCODE(HANDLE_THROWIFSUPERNOTCORRECTCALL_PREF_IMM16) { - uint16_t imm = READ_INST_16_1(); - JSTaggedValue thisValue = GET_ACC(); - LOG_INST() << "intrinsic::throwifsupernotcorrectcall" - << " imm:" << imm; + HANDLE_OPCODE(DEPRECATED_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8) { + uint16_t v0 = READ_INST_8_1(); + [[maybe_unused]] uint16_t v1 = READ_INST_8_2(); + uint16_t v2 = READ_INST_8_3(); + LOG_INST() << "intrinsics::asyncfunctionreject" + << " v" << v0 << " v" << v1 << " v" << v2; + + JSTaggedValue asyncFuncObj = GET_VREG_VALUE(v0); + JSTaggedValue value = GET_VREG_VALUE(v2); SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::ThrowIfSuperNotCorrectCall(thread, imm, thisValue); + JSTaggedValue res = SlowRuntimeStub::AsyncFunctionResolveOrReject(thread, asyncFuncObj, value, false); INTERPRETER_RETURN_IF_ABRUPT(res); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16); + SET_ACC(res); + DISPATCH(DEPRECATED_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8); } - HANDLE_OPCODE(HANDLE_LDHOMEOBJECT_PREF) { - LOG_INST() << "intrinsics::ldhomeobject"; - - JSTaggedValue thisFunc = GetThisFunction(sp); - JSTaggedValue homeObject = JSFunction::Cast(thisFunc.GetTaggedObject())->GetHomeObject(); - - SET_ACC(homeObject); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + HANDLE_OPCODE(JSTRICTEQZ_IMM8) { + DISPATCH(JSTRICTEQZ_IMM8); } - HANDLE_OPCODE(HANDLE_THROWDELETESUPERPROPERTY_PREF) { - LOG_INST() << "throwdeletesuperproperty"; - - SAVE_PC(); - SlowRuntimeStub::ThrowDeleteSuperProperty(thread); - INTERPRETER_GOTO_EXCEPTION_HANDLER(); + HANDLE_OPCODE(JSTRICTEQZ_IMM16) { + DISPATCH(JSTRICTEQZ_IMM16); } - HANDLE_OPCODE(HANDLE_DEBUGGER_PREF) { - LOG_INST() << "intrinsics::debugger"; - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + HANDLE_OPCODE(JNSTRICTEQZ_IMM8) { + DISPATCH(JNSTRICTEQZ_IMM8); } - HANDLE_OPCODE(HANDLE_ISTRUE_PREF) { - LOG_INST() << "intrinsics::istrue"; - if (GET_ACC().ToBoolean()) { - SET_ACC(JSTaggedValue::True()); - } else { - SET_ACC(JSTaggedValue::False()); - } - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + HANDLE_OPCODE(JNSTRICTEQZ_IMM16) { + DISPATCH(JNSTRICTEQZ_IMM16); } - HANDLE_OPCODE(HANDLE_ISFALSE_PREF) { - LOG_INST() << "intrinsics::isfalse"; - if (!GET_ACC().ToBoolean()) { - SET_ACC(JSTaggedValue::True()); - } else { - SET_ACC(JSTaggedValue::False()); - } - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + HANDLE_OPCODE(JEQNULL_IMM8) { + DISPATCH(JEQNULL_IMM8); } - HANDLE_OPCODE(EXCEPTION_HANDLER) { - FrameHandler frameHandler(thread); - uint32_t pcOffset = panda_file::INVALID_OFFSET; - for (; frameHandler.HasFrame(); frameHandler.PrevInterpretedFrame()) { - if (frameHandler.IsEntryFrame()) { - return; - } - auto method = frameHandler.GetMethod(); - pcOffset = FindCatchBlock(method, frameHandler.GetBytecodeOffset()); - if (pcOffset != panda_file::INVALID_OFFSET) { - sp = frameHandler.GetSp(); - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - pc = method->GetBytecodeArray() + pcOffset; - break; - } - } - if (pcOffset == panda_file::INVALID_OFFSET) { - return; - } - - auto exception = thread->GetException(); - SET_ACC(exception); - thread->ClearException(); - thread->SetCurrentSPFrame(sp); - DISPATCH_OFFSET(0); + HANDLE_OPCODE(JEQNULL_IMM16) { + DISPATCH(JEQNULL_IMM16); } - HANDLE_OPCODE(HANDLE_OVERFLOW) { - LOG_INTERPRETER(FATAL) << "opcode overflow"; + HANDLE_OPCODE(JNENULL_IMM8) { + DISPATCH(JNENULL_IMM8); + } + HANDLE_OPCODE(JNENULL_IMM16) { + DISPATCH(JNENULL_IMM16); + } + HANDLE_OPCODE(JSTRICTEQNULL_IMM8) { + DISPATCH(JSTRICTEQNULL_IMM8); + } + HANDLE_OPCODE(JSTRICTEQNULL_IMM16) { + DISPATCH(JSTRICTEQNULL_IMM16); + } + HANDLE_OPCODE(JNSTRICTEQNULL_IMM8) { + DISPATCH(JNSTRICTEQNULL_IMM8); + } + HANDLE_OPCODE(JNSTRICTEQNULL_IMM16) { + DISPATCH(JNSTRICTEQNULL_IMM16); + } + HANDLE_OPCODE(JEQUNDEFINED_IMM8) { + DISPATCH(JEQUNDEFINED_IMM8); + } + HANDLE_OPCODE(JEQUNDEFINED_IMM16) { + DISPATCH(JEQUNDEFINED_IMM16); + } + HANDLE_OPCODE(JNEUNDEFINED_IMM8) { + DISPATCH(JNEUNDEFINED_IMM8); + } + HANDLE_OPCODE(JNEUNDEFINED_IMM16) { + DISPATCH(JNEUNDEFINED_IMM16); + } + HANDLE_OPCODE(JSTRICTEQUNDEFINED_IMM8) { + DISPATCH(JSTRICTEQUNDEFINED_IMM8); + } + HANDLE_OPCODE(JSTRICTEQUNDEFINED_IMM16) { + DISPATCH(JSTRICTEQUNDEFINED_IMM16); + } + HANDLE_OPCODE(JNSTRICTEQUNDEFINED_IMM8) { + DISPATCH(JNSTRICTEQUNDEFINED_IMM8); + } + HANDLE_OPCODE(JNSTRICTEQUNDEFINED_IMM16) { + DISPATCH(JNSTRICTEQUNDEFINED_IMM16); + } + HANDLE_OPCODE(JEQ_V8_IMM8) { + DISPATCH(JEQ_V8_IMM8); + } + HANDLE_OPCODE(JEQ_V8_IMM16) { + DISPATCH(JEQ_V8_IMM16); + } + HANDLE_OPCODE(JNE_V8_IMM8) { + DISPATCH(JNE_V8_IMM8); + } + HANDLE_OPCODE(JNE_V8_IMM16) { + DISPATCH(JNE_V8_IMM16); + } + HANDLE_OPCODE(JSTRICTEQ_V8_IMM8) { + DISPATCH(JSTRICTEQ_V8_IMM8); + } + HANDLE_OPCODE(JSTRICTEQ_V8_IMM16) { + DISPATCH(JSTRICTEQ_V8_IMM16); + } + HANDLE_OPCODE(JNSTRICTEQ_V8_IMM8) { + DISPATCH(JNSTRICTEQ_V8_IMM8); + } + HANDLE_OPCODE(JNSTRICTEQ_V8_IMM16) { + DISPATCH(JNSTRICTEQ_V8_IMM16); + } + HANDLE_OPCODE(LDNEWTARGET) { + DISPATCH(LDNEWTARGET); + } + HANDLE_OPCODE(LDTHIS) { + DISPATCH(LDTHIS); + } + HANDLE_OPCODE(LDTHISBYVALUE_IMM8) { + DISPATCH(LDTHISBYVALUE_IMM8); + } + HANDLE_OPCODE(LDTHISBYVALUE_IMM16) { + DISPATCH(LDTHISBYVALUE_IMM16); + } + HANDLE_OPCODE(STTHISBYVALUE_IMM8_V8) { + DISPATCH(STTHISBYVALUE_IMM8_V8); + } + HANDLE_OPCODE(STTHISBYVALUE_IMM16_V8) { + DISPATCH(STTHISBYVALUE_IMM16_V8); + } + HANDLE_OPCODE(LDTHISBYNAME_IMM8_ID16) { + DISPATCH(LDTHISBYNAME_IMM8_ID16); + } + HANDLE_OPCODE(LDTHISBYNAME_IMM16_ID16) { + DISPATCH(LDTHISBYNAME_IMM16_ID16); + } + HANDLE_OPCODE(STTHISBYNAME_IMM8_ID16) { + DISPATCH(STTHISBYNAME_IMM8_ID16); + } + HANDLE_OPCODE(STTHISBYNAME_IMM16_ID16) { + DISPATCH(STTHISBYNAME_IMM16_ID16); + } + HANDLE_OPCODE(LDPATCHVAR_IMM8) { + DISPATCH(LDPATCHVAR_IMM8); + } + HANDLE_OPCODE(STPATCHVAR_IMM8_V8) { + DISPATCH(STPATCHVAR_IMM8_V8); } #include "templates/debugger_instruction_handler.inl" } @@ -3903,33 +6295,8 @@ uint32_t EcmaInterpreter::GetNumArgs(JSTaggedType *sp, uint32_t restIdx, uint32_ size_t EcmaInterpreter::GetJumpSizeAfterCall(const uint8_t *prevPc) { - uint8_t op = *prevPc; - size_t jumpSize; - switch (op) { - case (EcmaOpcode::CALLARG0DYN_PREF_V8): - jumpSize = BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_V8); - break; - case (EcmaOpcode::CALLARG1DYN_PREF_V8_V8): - jumpSize = BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_V8_V8); - break; - case (EcmaOpcode::CALLARGS2DYN_PREF_V8_V8_V8): - jumpSize = BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_V8_V8_V8); - break; - case (EcmaOpcode::CALLARGS3DYN_PREF_V8_V8_V8_V8): - jumpSize = BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_V8_V8_V8_V8); - break; - case (EcmaOpcode::CALLIRANGEDYN_PREF_IMM16_V8): - jumpSize = BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_IMM16_V8); - break; - case (EcmaOpcode::CALLITHISRANGEDYN_PREF_IMM16_V8): - case (EcmaOpcode::NEWOBJDYNRANGE_PREF_IMM16_V8): - case (EcmaOpcode::SUPERCALL_PREF_IMM16_V8): - jumpSize = BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_IMM16_V8); - break; - default: - UNREACHABLE(); - } - + auto op = BytecodeInstruction(prevPc).GetOpcode(); + size_t jumpSize = BytecodeInstruction::Size(op); return jumpSize; } @@ -4028,168 +6395,298 @@ int16_t EcmaInterpreter::GetHotnessCounter(uint32_t codeSize) std::string GetEcmaOpcodeStr(EcmaOpcode opcode) { const std::map strMap = { - {LDNAN_PREF, "LDNAN"}, - {LDINFINITY_PREF, "LDINFINITY"}, - {LDGLOBALTHIS_PREF, "LDGLOBALTHIS"}, - {LDUNDEFINED_PREF, "LDUNDEFINED"}, - {LDNULL_PREF, "LDNULL"}, - {LDSYMBOL_PREF, "LDSYMBOL"}, - {LDGLOBAL_PREF, "LDGLOBAL"}, - {LDTRUE_PREF, "LDTRUE"}, - {LDFALSE_PREF, "LDFALSE"}, - {THROWDYN_PREF, "THROWDYN"}, - {TYPEOFDYN_PREF, "TYPEOFDYN"}, - {LDLEXENVDYN_PREF, "LDLEXENVDYN"}, - {POPLEXENVDYN_PREF, "POPLEXENVDYN"}, - {GETUNMAPPEDARGS_PREF, "GETUNMAPPEDARGS"}, - {GETPROPITERATOR_PREF, "GETPROPITERATOR"}, - {ASYNCFUNCTIONENTER_PREF, "ASYNCFUNCTIONENTER"}, - {LDHOLE_PREF, "LDHOLE"}, - {RETURNUNDEFINED_PREF, "RETURNUNDEFINED"}, - {CREATEEMPTYOBJECT_PREF, "CREATEEMPTYOBJECT"}, - {CREATEEMPTYARRAY_PREF, "CREATEEMPTYARRAY"}, - {GETITERATOR_PREF, "GETITERATOR"}, - {THROWTHROWNOTEXISTS_PREF, "THROWTHROWNOTEXISTS"}, - {THROWPATTERNNONCOERCIBLE_PREF, "THROWPATTERNNONCOERCIBLE"}, - {LDHOMEOBJECT_PREF, "LDHOMEOBJECT"}, - {THROWDELETESUPERPROPERTY_PREF, "THROWDELETESUPERPROPERTY"}, - {DEBUGGER_PREF, "DEBUGGER"}, - {ADD2DYN_PREF_V8, "ADD2DYN"}, - {SUB2DYN_PREF_V8, "SUB2DYN"}, - {MUL2DYN_PREF_V8, "MUL2DYN"}, - {DIV2DYN_PREF_V8, "DIV2DYN"}, - {MOD2DYN_PREF_V8, "MOD2DYN"}, - {EQDYN_PREF_V8, "EQDYN"}, - {NOTEQDYN_PREF_V8, "NOTEQDYN"}, - {LESSDYN_PREF_V8, "LESSDYN"}, - {LESSEQDYN_PREF_V8, "LESSEQDYN"}, - {GREATERDYN_PREF_V8, "GREATERDYN"}, - {GREATEREQDYN_PREF_V8, "GREATEREQDYN"}, - {SHL2DYN_PREF_V8, "SHL2DYN"}, - {ASHR2DYN_PREF_V8, "ASHR2DYN"}, - {SHR2DYN_PREF_V8, "SHR2DYN"}, - {AND2DYN_PREF_V8, "AND2DYN"}, - {OR2DYN_PREF_V8, "OR2DYN"}, - {XOR2DYN_PREF_V8, "XOR2DYN"}, - {TONUMBER_PREF_V8, "TONUMBER"}, - {NEGDYN_PREF_V8, "NEGDYN"}, - {NOTDYN_PREF_V8, "NOTDYN"}, - {INCDYN_PREF_V8, "INCDYN"}, - {DECDYN_PREF_V8, "DECDYN"}, - {EXPDYN_PREF_V8, "EXPDYN"}, - {ISINDYN_PREF_V8, "ISINDYN"}, - {INSTANCEOFDYN_PREF_V8, "INSTANCEOFDYN"}, - {STRICTNOTEQDYN_PREF_V8, "STRICTNOTEQDYN"}, - {STRICTEQDYN_PREF_V8, "STRICTEQDYN"}, - {RESUMEGENERATOR_PREF_V8, "RESUMEGENERATOR"}, - {GETRESUMEMODE_PREF_V8, "GETRESUMEMODE"}, - {CREATEGENERATOROBJ_PREF_V8, "CREATEGENERATOROBJ"}, - {THROWCONSTASSIGNMENT_PREF_V8, "THROWCONSTASSIGNMENT"}, - {GETTEMPLATEOBJECT_PREF_V8, "GETTEMPLATEOBJECT"}, - {GETNEXTPROPNAME_PREF_V8, "GETNEXTPROPNAME"}, - {CALLARG0DYN_PREF_V8, "CALLARG0DYN"}, - {THROWIFNOTOBJECT_PREF_V8, "THROWIFNOTOBJECT"}, - {ITERNEXT_PREF_V8, "ITERNEXT"}, - {CLOSEITERATOR_PREF_V8, "CLOSEITERATOR"}, - {COPYMODULE_PREF_V8, "COPYMODULE"}, - {SUPERCALLSPREAD_PREF_V8, "SUPERCALLSPREAD"}, - {DELOBJPROP_PREF_V8_V8, "DELOBJPROP"}, - {NEWOBJSPREADDYN_PREF_V8_V8, "NEWOBJSPREADDYN"}, - {CREATEITERRESULTOBJ_PREF_V8_V8, "CREATEITERRESULTOBJ"}, - {SUSPENDGENERATOR_PREF_V8_V8, "SUSPENDGENERATOR"}, - {ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8, "ASYNCFUNCTIONAWAITUNCAUGHT"}, - {THROWUNDEFINEDIFHOLE_PREF_V8_V8, "THROWUNDEFINEDIFHOLE"}, - {CALLARG1DYN_PREF_V8_V8, "CALLARG1DYN"}, - {COPYDATAPROPERTIES_PREF_V8_V8, "COPYDATAPROPERTIES"}, - {STARRAYSPREAD_PREF_V8_V8, "STARRAYSPREAD"}, - {GETITERATORNEXT_PREF_V8_V8, "GETITERATORNEXT"}, - {SETOBJECTWITHPROTO_PREF_V8_V8, "SETOBJECTWITHPROTO"}, - {LDOBJBYVALUE_PREF_V8_V8, "LDOBJBYVALUE"}, - {STOBJBYVALUE_PREF_V8_V8, "STOBJBYVALUE"}, - {STOWNBYVALUE_PREF_V8_V8, "STOWNBYVALUE"}, - {LDSUPERBYVALUE_PREF_V8_V8, "LDSUPERBYVALUE"}, - {STSUPERBYVALUE_PREF_V8_V8, "STSUPERBYVALUE"}, - {LDOBJBYINDEX_PREF_V8_IMM32, "LDOBJBYINDEX"}, - {STOBJBYINDEX_PREF_V8_IMM32, "STOBJBYINDEX"}, - {STOWNBYINDEX_PREF_V8_IMM32, "STOWNBYINDEX"}, - {CALLSPREADDYN_PREF_V8_V8_V8, "CALLSPREADDYN"}, - {ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8, "ASYNCFUNCTIONRESOLVE"}, - {ASYNCFUNCTIONREJECT_PREF_V8_V8_V8, "ASYNCFUNCTIONREJECT"}, - {CALLARGS2DYN_PREF_V8_V8_V8, "CALLARGS2DYN"}, - {CALLARGS3DYN_PREF_V8_V8_V8_V8, "CALLARGS3DYN"}, - {DEFINEGETTERSETTERBYVALUE_PREF_V8_V8_V8_V8, "DEFINEGETTERSETTERBYVALUE"}, - {NEWOBJDYNRANGE_PREF_IMM16_V8, "NEWOBJDYNRANGE"}, - {CALLIRANGEDYN_PREF_IMM16_V8, "CALLIRANGEDYN"}, - {CALLITHISRANGEDYN_PREF_IMM16_V8, "CALLITHISRANGEDYN"}, - {SUPERCALL_PREF_IMM16_V8, "SUPERCALL"}, - {CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8, "CREATEOBJECTWITHEXCLUDEDKEYS"}, - {DEFINEFUNCDYN_PREF_ID16_IMM16_V8, "DEFINEFUNCDYN"}, - {DEFINENCFUNCDYN_PREF_ID16_IMM16_V8, "DEFINENCFUNCDYN"}, - {DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8, "DEFINEGENERATORFUNC"}, - {DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8, "DEFINEASYNCGENERATORFUNC"}, - {DEFINEASYNCFUNC_PREF_ID16_IMM16_V8, "DEFINEASYNCFUNC"}, - {DEFINEMETHOD_PREF_ID16_IMM16_V8, "DEFINEMETHOD"}, - {NEWLEXENVDYN_PREF_IMM16, "NEWLEXENVDYN"}, - {COPYRESTARGS_PREF_IMM16, "COPYRESTARGS"}, - {CREATEARRAYWITHBUFFER_PREF_IMM16, "CREATEARRAYWITHBUFFER"}, - {CREATEOBJECTHAVINGMETHOD_PREF_IMM16, "CREATEOBJECTHAVINGMETHOD"}, - {THROWIFSUPERNOTCORRECTCALL_PREF_IMM16, "THROWIFSUPERNOTCORRECTCALL"}, - {CREATEOBJECTWITHBUFFER_PREF_IMM16, "CREATEOBJECTWITHBUFFER"}, - {LDLEXVARDYN_PREF_IMM4_IMM4, "LDLEXVARDYN"}, - {LDLEXVARDYN_PREF_IMM8_IMM8, "LDLEXVARDYN"}, - {LDLEXVARDYN_PREF_IMM16_IMM16, "LDLEXVARDYN"}, - {STLEXVARDYN_PREF_IMM4_IMM4_V8, "STLEXVARDYN"}, - {STLEXVARDYN_PREF_IMM8_IMM8_V8, "STLEXVARDYN"}, - {STLEXVARDYN_PREF_IMM16_IMM16_V8, "STLEXVARDYN"}, - {NEWLEXENVWITHNAMEDYN_PREF_IMM16_IMM16, "NEWLEXENVWITHNAMEDYN"}, - {DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8, "DEFINECLASSWITHBUFFER"}, - {GETMODULENAMESPACE_PREF_ID32, "GETMODULENAMESPACE"}, - {STMODULEVAR_PREF_ID32, "STMODULEVAR"}, - {TRYLDGLOBALBYNAME_PREF_ID32, "TRYLDGLOBALBYNAME"}, - {TRYSTGLOBALBYNAME_PREF_ID32, "TRYSTGLOBALBYNAME"}, - {LDGLOBALVAR_PREF_ID32, "LDGLOBALVAR"}, - {STGLOBALVAR_PREF_ID32, "STGLOBALVAR"}, - {LDOBJBYNAME_PREF_ID32_V8, "LDOBJBYNAME"}, - {STOBJBYNAME_PREF_ID32_V8, "STOBJBYNAME"}, - {STOWNBYNAME_PREF_ID32_V8, "STOWNBYNAME"}, - {LDSUPERBYNAME_PREF_ID32_V8, "LDSUPERBYNAME"}, - {STSUPERBYNAME_PREF_ID32_V8, "STSUPERBYNAME"}, - {LDMODULEVAR_PREF_ID32_IMM8, "LDMODULEVAR"}, - {CREATEREGEXPWITHLITERAL_PREF_ID32_IMM8, "CREATEREGEXPWITHLITERAL"}, - {ISTRUE_PREF, "ISTRUE"}, - {ISFALSE_PREF, "ISFALSE"}, - {STCONSTTOGLOBALRECORD_PREF_ID32, "STCONSTTOGLOBALRECORD"}, - {STLETTOGLOBALRECORD_PREF_ID32, "STLETTOGLOBALRECORD"}, - {STCLASSTOGLOBALRECORD_PREF_ID32, "STCLASSTOGLOBALRECORD"}, - {STOWNBYVALUEWITHNAMESET_PREF_V8_V8, "STOWNBYVALUEWITHNAMESET"}, - {STOWNBYNAMEWITHNAMESET_PREF_ID32_V8, "STOWNBYNAMEWITHNAMESET"}, - {LDFUNCTION_PREF, "LDFUNCTION"}, - {LDBIGINT_PREF_ID32, "LDBIGINT"}, - {TONUMERIC_PREF_V8, "TONUMERIC"}, - {CREATEASYNCGENERATOROBJ_PREF_V8, "CREATEASYNCGENERATOROBJ"}, - {ASYNCGENERATORRESOLVE_PREF_V8_V8_V8, "ASYNCGENERATORRESOLVE"}, - {MOV_DYN_V8_V8, "MOV_DYN"}, - {MOV_DYN_V16_V16, "MOV_DYN"}, - {LDA_STR_ID32, "LDA_STR"}, - {LDAI_DYN_IMM32, "LDAI_DYN"}, - {FLDAI_DYN_IMM64, "FLDAI_DYN"}, - {JMP_IMM8, "JMP"}, - {JMP_IMM16, "JMP"}, - {JMP_IMM32, "JMP"}, - {JEQZ_IMM8, "JEQZ"}, - {JEQZ_IMM16, "JEQZ"}, - {LDA_DYN_V8, "LDA_DYN"}, - {STA_DYN_V8, "STA_DYN"}, - {RETURN_DYN, "RETURN_DYN"}, - {MOV_V4_V4, "MOV"}, - {JNEZ_IMM8, "JNEZ"}, - {JNEZ_IMM16, "JNEZ"}, - {LAST_OPCODE, "LAST_OPCODE"}, + {EcmaOpcode::LDNAN, "LDNAN"}, + {EcmaOpcode::LDINFINITY, "LDINFINITY"}, + {EcmaOpcode::LDGLOBALTHIS, "LDGLOBALTHIS"}, + {EcmaOpcode::LDUNDEFINED, "LDUNDEFINED"}, + {EcmaOpcode::LDNULL, "LDNULL"}, + {EcmaOpcode::LDSYMBOL, "LDSYMBOL"}, + {EcmaOpcode::LDGLOBAL, "LDGLOBAL"}, + {EcmaOpcode::LDTRUE, "LDTRUE"}, + {EcmaOpcode::LDFALSE, "LDFALSE"}, + {EcmaOpcode::LDHOLE, "LDHOLE"}, + {EcmaOpcode::LDNEWTARGET, "LDNEWTARGET"}, + {EcmaOpcode::POPLEXENV, "POPLEXENV"}, + {EcmaOpcode::GETUNMAPPEDARGS, "GETUNMAPPEDARGS"}, + {EcmaOpcode::ASYNCFUNCTIONENTER, "ASYNCFUNCTIONENTER"}, + {EcmaOpcode::LDTHIS, "LDTHIS"}, + {EcmaOpcode::LDFUNCTION, "LDFUNCTION"}, + {EcmaOpcode::DEBUGGER, "DEBUGGER"}, + {EcmaOpcode::GETPROPITERATOR, "GETPROPITERATOR"}, + {EcmaOpcode::GETITERATOR_IMM8, "GETITERATOR_IMM8"}, + {EcmaOpcode::GETITERATOR_IMM16, "GETITERATOR_IMM16"}, + {EcmaOpcode::CLOSEITERATOR_IMM8_V8, "CLOSEITERATOR_IMM8_V8"}, + {EcmaOpcode::CLOSEITERATOR_IMM16_V8, "CLOSEITERATOR_IMM16_V8"}, + {EcmaOpcode::CREATEASYNCGENERATOROBJ_V8, "CREATEASYNCGENERATOROBJ_V8"}, + {EcmaOpcode::CREATEEMPTYOBJECT, "CREATEEMPTYOBJECT"}, + {EcmaOpcode::CREATEEMPTYARRAY_IMM8, "CREATEEMPTYARRAY_IMM8"}, + {EcmaOpcode::CREATEEMPTYARRAY_IMM16, "CREATEEMPTYARRAY_IMM16"}, + {EcmaOpcode::CREATEGENERATOROBJ_V8, "CREATEGENERATOROBJ_V8"}, + {EcmaOpcode::CREATEITERRESULTOBJ_V8_V8, "CREATEITERRESULTOBJ_V8_V8"}, + {EcmaOpcode::CREATEOBJECTWITHEXCLUDEDKEYS_IMM8_V8_V8, "CREATEOBJECTWITHEXCLUDEDKEYS_IMM8_V8_V8"}, + {EcmaOpcode::ASYNCGENERATORRESOLVE_V8_V8_V8, "ASYNCGENERATORRESOLVE_V8_V8_V8"}, + {EcmaOpcode::CREATEARRAYWITHBUFFER_IMM8_ID16, "CREATEARRAYWITHBUFFER_IMM8_ID16"}, + {EcmaOpcode::CREATEARRAYWITHBUFFER_IMM16_ID16, "CREATEARRAYWITHBUFFER_IMM16_ID16"}, + {EcmaOpcode::CALLTHIS0_IMM8_V8, "CALLTHIS0_IMM8_V8"}, + {EcmaOpcode::CALLTHIS1_IMM8_V8_V8, "CALLTHIS1_IMM8_V8_V8"}, + {EcmaOpcode::CREATEOBJECTWITHBUFFER_IMM8_ID16, "CREATEOBJECTWITHBUFFER_IMM8_ID16"}, + {EcmaOpcode::CREATEOBJECTWITHBUFFER_IMM16_ID16, "CREATEOBJECTWITHBUFFER_IMM16_ID16"}, + {EcmaOpcode::CREATEREGEXPWITHLITERAL_IMM8_ID16_IMM8, "CREATEREGEXPWITHLITERAL_IMM8_ID16_IMM8"}, + {EcmaOpcode::CREATEREGEXPWITHLITERAL_IMM16_ID16_IMM8, "CREATEREGEXPWITHLITERAL_IMM16_ID16_IMM8"}, + {EcmaOpcode::NEWOBJAPPLY_IMM8_V8, "NEWOBJAPPLY_IMM8_V8"}, + {EcmaOpcode::NEWOBJAPPLY_IMM16_V8, "NEWOBJAPPLY_IMM16_V8"}, + {EcmaOpcode::NEWOBJRANGE_IMM8_IMM8_V8, "NEWOBJRANGE_IMM8_IMM8_V8"}, + {EcmaOpcode::NEWOBJRANGE_IMM16_IMM8_V8, "NEWOBJRANGE_IMM16_IMM8_V8"}, + {EcmaOpcode::NEWLEXENV_IMM8, "NEWLEXENV_IMM8"}, + {EcmaOpcode::NEWLEXENVWITHNAME_IMM8_ID16, "NEWLEXENVWITHNAME_IMM8_ID16"}, + {EcmaOpcode::ADD2_IMM8_V8, "ADD2_IMM8_V8"}, + {EcmaOpcode::SUB2_IMM8_V8, "SUB2_IMM8_V8"}, + {EcmaOpcode::MUL2_IMM8_V8, "MUL2_IMM8_V8"}, + {EcmaOpcode::DIV2_IMM8_V8, "DIV2_IMM8_V8"}, + {EcmaOpcode::MOD2_IMM8_V8, "MOD2_IMM8_V8"}, + {EcmaOpcode::EQ_IMM8_V8, "EQ_IMM8_V8"}, + {EcmaOpcode::NOTEQ_IMM8_V8, "NOTEQ_IMM8_V8"}, + {EcmaOpcode::LESS_IMM8_V8, "LESS_IMM8_V8"}, + {EcmaOpcode::LESSEQ_IMM8_V8, "LESSEQ_IMM8_V8"}, + {EcmaOpcode::GREATER_IMM8_V8, "GREATER_IMM8_V8"}, + {EcmaOpcode::GREATEREQ_IMM8_V8, "GREATEREQ_IMM8_V8"}, + {EcmaOpcode::SHL2_IMM8_V8, "SHL2_IMM8_V8"}, + {EcmaOpcode::SHR2_IMM8_V8, "SHR2_IMM8_V8"}, + {EcmaOpcode::ASHR2_IMM8_V8, "ASHR2_IMM8_V8"}, + {EcmaOpcode::AND2_IMM8_V8, "AND2_IMM8_V8"}, + {EcmaOpcode::OR2_IMM8_V8, "OR2_IMM8_V8"}, + {EcmaOpcode::XOR2_IMM8_V8, "XOR2_IMM8_V8"}, + {EcmaOpcode::EXP_IMM8_V8, "EXP_IMM8_V8"}, + {EcmaOpcode::TYPEOF_IMM8, "TYPEOF_IMM8"}, + {EcmaOpcode::TYPEOF_IMM16, "TYPEOF_IMM16"}, + {EcmaOpcode::TONUMBER_IMM8, "TONUMBER_IMM8"}, + {EcmaOpcode::TONUMERIC_IMM8, "TONUMERIC_IMM8"}, + {EcmaOpcode::NEG_IMM8, "NEG_IMM8"}, + {EcmaOpcode::NOT_IMM8, "NOT_IMM8"}, + {EcmaOpcode::INC_IMM8, "INC_IMM8"}, + {EcmaOpcode::DEC_IMM8, "DEC_IMM8"}, + {EcmaOpcode::ISIN_IMM8_V8, "ISIN_IMM8_V8"}, + {EcmaOpcode::INSTANCEOF_IMM8_V8, "INSTANCEOF_IMM8_V8"}, + {EcmaOpcode::STRICTNOTEQ_IMM8_V8, "STRICTNOTEQ_IMM8_V8"}, + {EcmaOpcode::STRICTEQ_IMM8_V8, "STRICTEQ_IMM8_V8"}, + {EcmaOpcode::ISTRUE, "ISTRUE"}, + {EcmaOpcode::ISFALSE, "ISFALSE"}, + {EcmaOpcode::CALLTHIS2_IMM8_V8_V8_V8, "CALLTHIS2_IMM8_V8_V8_V8"}, + {EcmaOpcode::CALLTHIS3_IMM8_V8_V8_V8_V8, "CALLTHIS3_IMM8_V8_V8_V8_V8"}, + {EcmaOpcode::CALLTHISRANGE_IMM8_IMM8_V8, "CALLTHISRANGE_IMM8_IMM8_V8"}, + {EcmaOpcode::SUPERCALLTHISRANGE_IMM8_IMM8_V8, "SUPERCALLTHISRANGE_IMM8_IMM8_V8"}, + {EcmaOpcode::SUPERCALLARROWRANGE_IMM8_IMM8_V8, "SUPERCALLARROWRANGE_IMM8_IMM8_V8"}, + {EcmaOpcode::DEFINEFUNC_IMM8_ID16_IMM8, "DEFINEFUNC_IMM8_ID16_IMM8"}, + {EcmaOpcode::DEFINEFUNC_IMM16_ID16_IMM8, "DEFINEFUNC_IMM16_ID16_IMM8"}, + {EcmaOpcode::DEFINEMETHOD_IMM8_ID16_IMM8, "DEFINEMETHOD_IMM8_ID16_IMM8"}, + {EcmaOpcode::CALLARG0_IMM8, "CALLARG0_IMM8"}, + {EcmaOpcode::SUPERCALLSPREAD_IMM8_V8, "SUPERCALLSPREAD_IMM8_V8"}, + {EcmaOpcode::APPLY_IMM8_V8_V8, "APPLY_IMM8_V8_V8"}, + {EcmaOpcode::CALLARGS2_IMM8_V8_V8, "CALLARGS2_IMM8_V8_V8"}, + {EcmaOpcode::CALLARGS3_IMM8_V8_V8_V8, "CALLARGS3_IMM8_V8_V8_V8"}, + {EcmaOpcode::CALLRANGE_IMM8_IMM8_V8, "CALLRANGE_IMM8_IMM8_V8"}, + {EcmaOpcode::DEFINEMETHOD_IMM16_ID16_IMM8, "DEFINEMETHOD_IMM16_ID16_IMM8"}, + {EcmaOpcode::LDEXTERNALMODULEVAR_IMM8, "LDEXTERNALMODULEVAR_IMM8"}, + {EcmaOpcode::DEFINEGETTERSETTERBYVALUE_V8_V8_V8_V8, "DEFINEGETTERSETTERBYVALUE_V8_V8_V8_V8"}, + {EcmaOpcode::LDTHISBYNAME_IMM8_ID16, "LDTHISBYNAME_IMM8_ID16"}, + {EcmaOpcode::LDTHISBYNAME_IMM16_ID16, "LDTHISBYNAME_IMM16_ID16"}, + {EcmaOpcode::STTHISBYNAME_IMM8_ID16, "STTHISBYNAME_IMM8_ID16"}, + {EcmaOpcode::STTHISBYNAME_IMM16_ID16, "STTHISBYNAME_IMM16_ID16"}, + {EcmaOpcode::LDTHISBYVALUE_IMM8, "LDTHISBYVALUE_IMM8"}, + {EcmaOpcode::LDTHISBYVALUE_IMM16, "LDTHISBYVALUE_IMM16"}, + {EcmaOpcode::STTHISBYVALUE_IMM8_V8, "STTHISBYVALUE_IMM8_V8"}, + {EcmaOpcode::STTHISBYVALUE_IMM16_V8, "STTHISBYVALUE_IMM16_V8"}, + {EcmaOpcode::LDPATCHVAR_IMM8, "LDPATCHVAR_IMM8"}, + {EcmaOpcode::STPATCHVAR_IMM8_V8, "STPATCHVAR_IMM8_V8"}, + {EcmaOpcode::DEFINECLASSWITHBUFFER_IMM8_ID16_ID16_IMM16_V8, "DEFINECLASSWITHBUFFER_IMM8_ID16_ID16_IMM16_V8"}, + {EcmaOpcode::DEFINECLASSWITHBUFFER_IMM16_ID16_ID16_IMM16_V8, "DEFINECLASSWITHBUFFER_IMM16_ID16_ID16_IMM16_V8"}, + {EcmaOpcode::RESUMEGENERATOR, "RESUMEGENERATOR"}, + {EcmaOpcode::GETRESUMEMODE, "GETRESUMEMODE"}, + {EcmaOpcode::GETTEMPLATEOBJECT_IMM8, "GETTEMPLATEOBJECT_IMM8"}, + {EcmaOpcode::GETTEMPLATEOBJECT_IMM16, "GETTEMPLATEOBJECT_IMM16"}, + {EcmaOpcode::GETNEXTPROPNAME_V8, "GETNEXTPROPNAME_V8"}, + {EcmaOpcode::JSTRICTEQZ_IMM8, "JSTRICTEQZ_IMM8"}, + {EcmaOpcode::JSTRICTEQZ_IMM16, "JSTRICTEQZ_IMM16"}, + {EcmaOpcode::SETOBJECTWITHPROTO_IMM8_V8, "SETOBJECTWITHPROTO_IMM8_V8"}, + {EcmaOpcode::DELOBJPROP_V8, "DELOBJPROP_V8"}, + {EcmaOpcode::SUSPENDGENERATOR_V8, "SUSPENDGENERATOR_V8"}, + {EcmaOpcode::ASYNCFUNCTIONAWAITUNCAUGHT_V8, "ASYNCFUNCTIONAWAITUNCAUGHT_V8"}, + {EcmaOpcode::COPYDATAPROPERTIES_V8, "COPYDATAPROPERTIES_V8"}, + {EcmaOpcode::STARRAYSPREAD_V8_V8, "STARRAYSPREAD_V8_V8"}, + {EcmaOpcode::SETOBJECTWITHPROTO_IMM16_V8, "SETOBJECTWITHPROTO_IMM16_V8"}, + {EcmaOpcode::LDOBJBYVALUE_IMM8_V8, "LDOBJBYVALUE_IMM8_V8"}, + {EcmaOpcode::LDOBJBYVALUE_IMM16_V8, "LDOBJBYVALUE_IMM16_V8"}, + {EcmaOpcode::STOBJBYVALUE_IMM8_V8_V8, "STOBJBYVALUE_IMM8_V8_V8"}, + {EcmaOpcode::STOBJBYVALUE_IMM16_V8_V8, "STOBJBYVALUE_IMM16_V8_V8"}, + {EcmaOpcode::STOWNBYVALUE_IMM8_V8_V8, "STOWNBYVALUE_IMM8_V8_V8"}, + {EcmaOpcode::STOWNBYVALUE_IMM16_V8_V8, "STOWNBYVALUE_IMM16_V8_V8"}, + {EcmaOpcode::LDSUPERBYVALUE_IMM8_V8, "LDSUPERBYVALUE_IMM8_V8"}, + {EcmaOpcode::LDSUPERBYVALUE_IMM16_V8, "LDSUPERBYVALUE_IMM16_V8"}, + {EcmaOpcode::STSUPERBYVALUE_IMM8_V8_V8, "STSUPERBYVALUE_IMM8_V8_V8"}, + {EcmaOpcode::STSUPERBYVALUE_IMM16_V8_V8, "STSUPERBYVALUE_IMM16_V8_V8"}, + {EcmaOpcode::LDOBJBYINDEX_IMM8_IMM16, "LDOBJBYINDEX_IMM8_IMM16"}, + {EcmaOpcode::LDOBJBYINDEX_IMM16_IMM16, "LDOBJBYINDEX_IMM16_IMM16"}, + {EcmaOpcode::STOBJBYINDEX_IMM8_V8_IMM16, "STOBJBYINDEX_IMM8_V8_IMM16"}, + {EcmaOpcode::STOBJBYINDEX_IMM16_V8_IMM16, "STOBJBYINDEX_IMM16_V8_IMM16"}, + {EcmaOpcode::STOWNBYINDEX_IMM8_V8_IMM16, "STOWNBYINDEX_IMM8_V8_IMM16"}, + {EcmaOpcode::STOWNBYINDEX_IMM16_V8_IMM16, "STOWNBYINDEX_IMM16_V8_IMM16"}, + {EcmaOpcode::ASYNCFUNCTIONRESOLVE_V8, "ASYNCFUNCTIONRESOLVE_V8"}, + {EcmaOpcode::ASYNCFUNCTIONREJECT_V8, "ASYNCFUNCTIONREJECT_V8"}, + {EcmaOpcode::COPYRESTARGS_IMM8, "COPYRESTARGS_IMM8"}, + {EcmaOpcode::LDLEXVAR_IMM4_IMM4, "LDLEXVAR_IMM4_IMM4"}, + {EcmaOpcode::STLEXVAR_IMM4_IMM4, "STLEXVAR_IMM4_IMM4"}, + {EcmaOpcode::GETMODULENAMESPACE_IMM8, "GETMODULENAMESPACE_IMM8"}, + {EcmaOpcode::STMODULEVAR_IMM8, "STMODULEVAR_IMM8"}, + {EcmaOpcode::TRYLDGLOBALBYNAME_IMM8_ID16, "TRYLDGLOBALBYNAME_IMM8_ID16"}, + {EcmaOpcode::TRYLDGLOBALBYNAME_IMM16_ID16, "TRYLDGLOBALBYNAME_IMM16_ID16"}, + {EcmaOpcode::TRYSTGLOBALBYNAME_IMM8_ID16, "TRYSTGLOBALBYNAME_IMM8_ID16"}, + {EcmaOpcode::TRYSTGLOBALBYNAME_IMM16_ID16, "TRYSTGLOBALBYNAME_IMM16_ID16"}, + {EcmaOpcode::LDGLOBALVAR_IMM16_ID16, "LDGLOBALVAR_IMM16_ID16"}, + {EcmaOpcode::STGLOBALVAR_IMM16_ID16, "STGLOBALVAR_IMM16_ID16"}, + {EcmaOpcode::LDOBJBYNAME_IMM8_ID16, "LDOBJBYNAME_IMM8_ID16"}, + {EcmaOpcode::LDOBJBYNAME_IMM16_ID16, "LDOBJBYNAME_IMM16_ID16"}, + {EcmaOpcode::STOBJBYNAME_IMM8_ID16_V8, "STOBJBYNAME_IMM8_ID16_V8"}, + {EcmaOpcode::STOBJBYNAME_IMM16_ID16_V8, "STOBJBYNAME_IMM16_ID16_V8"}, + {EcmaOpcode::STOWNBYNAME_IMM8_ID16_V8, "STOWNBYNAME_IMM8_ID16_V8"}, + {EcmaOpcode::STOWNBYNAME_IMM16_ID16_V8, "STOWNBYNAME_IMM16_ID16_V8"}, + {EcmaOpcode::LDSUPERBYNAME_IMM8_ID16, "LDSUPERBYNAME_IMM8_ID16"}, + {EcmaOpcode::LDSUPERBYNAME_IMM16_ID16, "LDSUPERBYNAME_IMM16_ID16"}, + {EcmaOpcode::STSUPERBYNAME_IMM8_ID16_V8, "STSUPERBYNAME_IMM8_ID16_V8"}, + {EcmaOpcode::STSUPERBYNAME_IMM16_ID16_V8, "STSUPERBYNAME_IMM16_ID16_V8"}, + {EcmaOpcode::LDLOCALMODULEVAR_IMM8, "LDLOCALMODULEVAR_IMM8"}, + {EcmaOpcode::STCONSTTOGLOBALRECORD_IMM16_ID16, "STCONSTTOGLOBALRECORD_IMM16_ID16"}, + {EcmaOpcode::STTOGLOBALRECORD_IMM16_ID16, "STTOGLOBALRECORD_IMM16_ID16"}, + {EcmaOpcode::JNSTRICTEQZ_IMM8, "JNSTRICTEQZ_IMM8"}, + {EcmaOpcode::JNSTRICTEQZ_IMM16, "JNSTRICTEQZ_IMM16"}, + {EcmaOpcode::JEQNULL_IMM8, "JEQNULL_IMM8"}, + {EcmaOpcode::JEQNULL_IMM16, "JEQNULL_IMM16"}, + {EcmaOpcode::STOWNBYVALUEWITHNAMESET_IMM8_V8_V8, "STOWNBYVALUEWITHNAMESET_IMM8_V8_V8"}, + {EcmaOpcode::STOWNBYVALUEWITHNAMESET_IMM16_V8_V8, "STOWNBYVALUEWITHNAMESET_IMM16_V8_V8"}, + {EcmaOpcode::STOWNBYNAMEWITHNAMESET_IMM8_ID16_V8, "STOWNBYNAMEWITHNAMESET_IMM8_ID16_V8"}, + {EcmaOpcode::STOWNBYNAMEWITHNAMESET_IMM16_ID16_V8, "STOWNBYNAMEWITHNAMESET_IMM16_ID16_V8"}, + {EcmaOpcode::LDBIGINT_ID16, "LDBIGINT_ID16"}, + {EcmaOpcode::LDA_STR_ID16, "LDA_STR_ID16"}, + {EcmaOpcode::JMP_IMM8, "JMP_IMM8"}, + {EcmaOpcode::JMP_IMM16, "JMP_IMM16"}, + {EcmaOpcode::JMP_IMM32, "JMP_IMM32"}, + {EcmaOpcode::JEQZ_IMM8, "JEQZ_IMM8"}, + {EcmaOpcode::JEQZ_IMM16, "JEQZ_IMM16"}, + {EcmaOpcode::JNEZ_IMM8, "JNEZ_IMM8"}, + {EcmaOpcode::JNEZ_IMM16, "JNEZ_IMM16"}, + {EcmaOpcode::JNENULL_IMM8, "JNENULL_IMM8"}, + {EcmaOpcode::JNENULL_IMM16, "JNENULL_IMM16"}, + {EcmaOpcode::LDA_V8, "LDA_V8"}, + {EcmaOpcode::STA_V8, "STA_V8"}, + {EcmaOpcode::LDAI_IMM32, "LDAI_IMM32"}, + {EcmaOpcode::FLDAI_IMM64, "FLDAI_IMM64"}, + {EcmaOpcode::RETURN, "RETURN"}, + {EcmaOpcode::RETURNUNDEFINED, "RETURNUNDEFINED"}, + {EcmaOpcode::LDLEXVAR_IMM8_IMM8, "LDLEXVAR_IMM8_IMM8"}, + {EcmaOpcode::JSTRICTEQNULL_IMM8, "JSTRICTEQNULL_IMM8"}, + {EcmaOpcode::STLEXVAR_IMM8_IMM8, "STLEXVAR_IMM8_IMM8"}, + {EcmaOpcode::JSTRICTEQNULL_IMM16, "JSTRICTEQNULL_IMM16"}, + {EcmaOpcode::CALLARG1_IMM8_V8, "CALLARG1_IMM8_V8"}, + {EcmaOpcode::JNSTRICTEQNULL_IMM8, "JNSTRICTEQNULL_IMM8"}, + {EcmaOpcode::JNSTRICTEQNULL_IMM16, "JNSTRICTEQNULL_IMM16"}, + {EcmaOpcode::JEQUNDEFINED_IMM8, "JEQUNDEFINED_IMM8"}, + {EcmaOpcode::JEQUNDEFINED_IMM16, "JEQUNDEFINED_IMM16"}, + {EcmaOpcode::JNEUNDEFINED_IMM8, "JNEUNDEFINED_IMM8"}, + {EcmaOpcode::JNEUNDEFINED_IMM16, "JNEUNDEFINED_IMM16"}, + {EcmaOpcode::JSTRICTEQUNDEFINED_IMM8, "JSTRICTEQUNDEFINED_IMM8"}, + {EcmaOpcode::JSTRICTEQUNDEFINED_IMM16, "JSTRICTEQUNDEFINED_IMM16"}, + {EcmaOpcode::JNSTRICTEQUNDEFINED_IMM8, "JNSTRICTEQUNDEFINED_IMM8"}, + {EcmaOpcode::JNSTRICTEQUNDEFINED_IMM16, "JNSTRICTEQUNDEFINED_IMM16"}, + {EcmaOpcode::JEQ_V8_IMM8, "JEQ_V8_IMM8"}, + {EcmaOpcode::JEQ_V8_IMM16, "JEQ_V8_IMM16"}, + {EcmaOpcode::JNE_V8_IMM8, "JNE_V8_IMM8"}, + {EcmaOpcode::JNE_V8_IMM16, "JNE_V8_IMM16"}, + {EcmaOpcode::JSTRICTEQ_V8_IMM8, "JSTRICTEQ_V8_IMM8"}, + {EcmaOpcode::JSTRICTEQ_V8_IMM16, "JSTRICTEQ_V8_IMM16"}, + {EcmaOpcode::JNSTRICTEQ_V8_IMM8, "JNSTRICTEQ_V8_IMM8"}, + {EcmaOpcode::JNSTRICTEQ_V8_IMM16, "JNSTRICTEQ_V8_IMM16"}, + {EcmaOpcode::MOV_V4_V4, "MOV_V4_V4"}, + {EcmaOpcode::MOV_V8_V8, "MOV_V8_V8"}, + {EcmaOpcode::MOV_V16_V16, "MOV_V16_V16"}, + {EcmaOpcode::NOP, "NOP"}, + {static_cast(EXCEPTION_OPCODE), "EXCEPTION_OPCODE"}, + {EcmaOpcode::DEPRECATED_LDLEXENV_PREF_NONE, "DEPRECATED_LDLEXENV"}, + {EcmaOpcode::WIDE_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8, "WIDE_CREATEOBJECTWITHEXCLUDEDKEYS"}, + {EcmaOpcode::THROW_PREF_NONE, "THROW_PREF"}, + {EcmaOpcode::DEPRECATED_POPLEXENV_PREF_NONE, "DEPRECATED_POPLEXENV"}, + {EcmaOpcode::WIDE_NEWOBJRANGE_PREF_IMM16_V8, "WIDE_NEWOBJRANGE"}, + {EcmaOpcode::THROW_NOTEXISTS_PREF_NONE, "THROW_NOTEXISTS"}, + {EcmaOpcode::DEPRECATED_GETITERATORNEXT_PREF_V8_V8, "DEPRECATED_GETITERATORNEXT"}, + {EcmaOpcode::WIDE_NEWLEXENV_PREF_IMM16, "WIDE_NEWLEXENV"}, + {EcmaOpcode::THROW_PATTERNNONCOERCIBLE_PREF_NONE, "THROW_PATTERNNONCOERCIBLE"}, + {EcmaOpcode::DEPRECATED_CREATEARRAYWITHBUFFER_PREF_IMM16, "DEPRECATED_CREATEARRAYWITHBUFFER"}, + {EcmaOpcode::WIDE_NEWLEXENVWITHNAME_PREF_IMM16_ID16, "WIDE_NEWLEXENVWITHNAME"}, + {EcmaOpcode::THROW_DELETESUPERPROPERTY_PREF_NONE, "THROW_DELETESUPERPROPERTY"}, + {EcmaOpcode::DEPRECATED_CREATEOBJECTWITHBUFFER_PREF_IMM16, "DEPRECATED_CREATEOBJECTWITHBUFFER"}, + {EcmaOpcode::WIDE_CALLRANGE_PREF_IMM16_V8, "WIDE_CALLRANGE"}, + {EcmaOpcode::THROW_CONSTASSIGNMENT_PREF_V8, "THROW_CONSTASSIGNMENT"}, + {EcmaOpcode::DEPRECATED_TONUMBER_PREF_V8, "DEPRECATED_TONUMBER"}, + {EcmaOpcode::WIDE_CALLTHISRANGE_PREF_IMM16_V8, "WIDE_CALLTHISRANGE"}, + {EcmaOpcode::THROW_IFNOTOBJECT_PREF_V8, "THROW_IFNOTOBJECT"}, + {EcmaOpcode::DEPRECATED_TONUMERIC_PREF_V8, "DEPRECATED_TONUMERIC"}, + {EcmaOpcode::WIDE_SUPERCALLTHISRANGE_PREF_IMM16_V8, "WIDE_SUPERCALLTHISRANGE"}, + {EcmaOpcode::THROW_UNDEFINEDIFHOLE_PREF_V8_V8, "THROW_UNDEFINEDIFHOLE"}, + {EcmaOpcode::DEPRECATED_NEG_PREF_V8, "DEPRECATED_NEG"}, + {EcmaOpcode::WIDE_SUPERCALLARROWRANGE_PREF_IMM16_V8, "WIDE_SUPERCALLARROWRANGE"}, + {EcmaOpcode::THROW_IFSUPERNOTCORRECTCALL_PREF_IMM8, "THROW_IFSUPERNOTCORRECTCALL"}, + {EcmaOpcode::DEPRECATED_NOT_PREF_V8, "DEPRECATED_NOT"}, + {EcmaOpcode::WIDE_LDOBJBYINDEX_PREF_IMM32, "WIDE_LDOBJBYINDEX"}, + {EcmaOpcode::THROW_IFSUPERNOTCORRECTCALL_PREF_IMM16, "THROW_IFSUPERNOTCORRECTCALL"}, + {EcmaOpcode::DEPRECATED_INC_PREF_V8, "DEPRECATED_INC"}, + {EcmaOpcode::WIDE_STOBJBYINDEX_PREF_V8_IMM32, "WIDE_STOBJBYINDEX"}, + {EcmaOpcode::DEPRECATED_DEC_PREF_V8, "DEPRECATED_DEC"}, + {EcmaOpcode::WIDE_STOWNBYINDEX_PREF_V8_IMM32, "WIDE_STOWNBYINDEX"}, + {EcmaOpcode::DEPRECATED_CALLARG0_PREF_V8, "DEPRECATED_CALLARG0"}, + {EcmaOpcode::WIDE_COPYRESTARGS_PREF_IMM16, "WIDE_COPYRESTARGS"}, + {EcmaOpcode::DEPRECATED_CALLARG1_PREF_V8_V8, "DEPRECATED_CALLARG1"}, + {EcmaOpcode::WIDE_LDLEXVAR_PREF_IMM16_IMM16, "WIDE_LDLEXVAR"}, + {EcmaOpcode::DEPRECATED_CALLARGS2_PREF_V8_V8_V8, "DEPRECATED_CALLARGS2"}, + {EcmaOpcode::WIDE_STLEXVAR_PREF_IMM16_IMM16, "WIDE_STLEXVAR"}, + {EcmaOpcode::DEPRECATED_CALLARGS3_PREF_V8_V8_V8_V8, "DEPRECATED_CALLARGS3"}, + {EcmaOpcode::WIDE_GETMODULENAMESPACE_PREF_IMM16, "WIDE_GETMODULENAMESPACE"}, + {EcmaOpcode::DEPRECATED_CALLSPREAD_PREF_V8_V8_V8, "DEPRECATED_CALLSPREAD"}, + {EcmaOpcode::WIDE_STMODULEVAR_PREF_IMM16, "WIDE_STMODULEVAR"}, + {EcmaOpcode::DEPRECATED_DEFINEFUNC_PREF_ID16_IMM16_V8, "DEPRECATED_DEFINEFUNC"}, + {EcmaOpcode::WIDE_LDLOCALMODULEVAR_PREF_IMM16, "WIDE_LDLOCALMODULEVAR"}, + {EcmaOpcode::DEPRECATED_DEFINENCFUNC_PREF_ID16_IMM16_V8, "DEPRECATED_DEFINENCFUNC"}, + {EcmaOpcode::WIDE_LDEXTERNALMODULEVAR_PREF_IMM16, "WIDE_LDEXTERNALMODULEVAR"}, + {EcmaOpcode::DEPRECATED_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8, "DEPRECATED_DEFINEGENERATORFUNC"}, + {EcmaOpcode::DEPRECATED_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8, "DEPRECATED_DEFINEASYNCFUNC"}, + {EcmaOpcode::DEPRECATED_DEFINEMETHOD_PREF_ID16_IMM16_V8, "DEPRECATED_DEFINEMETHOD"}, + {EcmaOpcode::DEPRECATED_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8, "DEPRECATED_DEFINECLASSWITHBUFFER"}, + {EcmaOpcode::DEPRECATED_RESUMEGENERATOR_PREF_V8, "DEPRECATED_RESUMEGENERATOR"}, + {EcmaOpcode::DEPRECATED_GETRESUMEMODE_PREF_V8, "DEPRECATED_GETRESUMEMODE"}, + {EcmaOpcode::DEPRECATED_GETTEMPLATEOBJECT_PREF_V8, "DEPRECATED_GETTEMPLATEOBJECT"}, + {EcmaOpcode::DEPRECATED_DELOBJPROP_PREF_V8_V8, "DEPRECATED_DELOBJPROP"}, + {EcmaOpcode::DEPRECATED_SUSPENDGENERATOR_PREF_V8_V8, "DEPRECATED_SUSPENDGENERATOR"}, + {EcmaOpcode::DEPRECATED_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8, "DEPRECATED_ASYNCFUNCTIONAWAITUNCAUGHT"}, + {EcmaOpcode::DEPRECATED_COPYDATAPROPERTIES_PREF_V8_V8, "DEPRECATED_COPYDATAPROPERTIES"}, + {EcmaOpcode::DEPRECATED_SETOBJECTWITHPROTO_PREF_V8_V8, "DEPRECATED_SETOBJECTWITHPROTO"}, + {EcmaOpcode::DEPRECATED_LDOBJBYVALUE_PREF_V8_V8, "DEPRECATED_LDOBJBYVALUE"}, + {EcmaOpcode::DEPRECATED_LDSUPERBYVALUE_PREF_V8_V8, "DEPRECATED_LDSUPERBYVALUE"}, + {EcmaOpcode::DEPRECATED_LDOBJBYINDEX_PREF_V8_IMM32, "DEPRECATED_LDOBJBYINDEX"}, + {EcmaOpcode::DEPRECATED_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8, "DEPRECATED_ASYNCFUNCTIONRESOLVE"}, + {EcmaOpcode::DEPRECATED_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8, "DEPRECATED_ASYNCFUNCTIONREJECT"}, + {EcmaOpcode::DEPRECATED_STLEXVAR_PREF_IMM4_IMM4_V8, "DEPRECATED_STLEXVAR"}, + {EcmaOpcode::DEPRECATED_STLEXVAR_PREF_IMM8_IMM8_V8, "DEPRECATED_STLEXVAR"}, + {EcmaOpcode::DEPRECATED_STLEXVAR_PREF_IMM16_IMM16_V8, "DEPRECATED_STLEXVAR"}, + {EcmaOpcode::DEPRECATED_GETMODULENAMESPACE_PREF_ID32, "DEPRECATED_GETMODULENAMESPACE"}, + {EcmaOpcode::DEPRECATED_STMODULEVAR_PREF_ID32, "DEPRECATED_STMODULEVAR"}, + {EcmaOpcode::DEPRECATED_LDOBJBYNAME_PREF_ID32_V8, "DEPRECATED_LDOBJBYNAME"}, + {EcmaOpcode::DEPRECATED_LDSUPERBYNAME_PREF_ID32_V8, "DEPRECATED_LDSUPERBYNAME"}, + {EcmaOpcode::DEPRECATED_LDMODULEVAR_PREF_ID32_IMM8, "DEPRECATED_LDMODULEVAR"}, + {EcmaOpcode::DEPRECATED_STCONSTTOGLOBALRECORD_PREF_ID32, "DEPRECATED_STCONSTTOGLOBALRECORD"}, + {EcmaOpcode::DEPRECATED_STLETTOGLOBALRECORD_PREF_ID32, "DEPRECATED_STLETTOGLOBALRECORD"}, + {EcmaOpcode::DEPRECATED_STCLASSTOGLOBALRECORD_PREF_ID32, "DEPRECATED_STCLASSTOGLOBALRECORD"}, }; if (strMap.count(opcode) > 0) { return strMap.at(opcode); } - return "bytecode-" + std::to_string(opcode); + return "bytecode-" + std::to_string(static_cast(opcode)); } #undef LOG_INST #undef HANDLE_OPCODE @@ -4203,27 +6700,26 @@ std::string GetEcmaOpcodeStr(EcmaOpcode opcode) #undef SAVE_ACC #undef RESTORE_ACC #undef INTERPRETER_GOTO_EXCEPTION_HANDLER -#undef INTERPRETER_HANDLE_RETURN #undef CHECK_SWITCH_TO_DEBUGGER_TABLE #undef REAL_GOTO_DISPATCH_OPCODE #undef REAL_GOTO_EXCEPTION_HANDLER #undef INTERPRETER_RETURN_IF_ABRUPT #undef NOTIFY_DEBUGGER_EVENT -#undef CALL_INITIALIZE +#undef DEPRECATED_CALL_INITIALIZE #undef CALL_PUSH_UNDEFINED -#undef CALL_PUSH_ARGS_0 -#undef CALL_PUSH_ARGS_1 -#undef CALL_PUSH_ARGS_2 -#undef CALL_PUSH_ARGS_3 -#undef CALL_PUSH_ARGS_I -#undef CALL_PUSH_ARGS_I_THIS -#undef CALL_PUSH_ARGS_0_NO_EXTRA -#undef CALL_PUSH_ARGS_1_NO_EXTRA -#undef CALL_PUSH_ARGS_2_NO_EXTRA -#undef CALL_PUSH_ARGS_3_NO_EXTRA -#undef CALL_PUSH_ARGS_I_NO_EXTRA -#undef CALL_PUSH_ARGS_I_THIS_NO_EXTRA -#undef CALL_PUSH_ARGS +#undef DEPRECATED_CALL_PUSH_ARGS_0 +#undef DEPRECATED_CALL_PUSH_ARGS_1 +#undef DEPRECATED_CALL_PUSH_ARGS_2 +#undef DEPRECATED_CALL_PUSH_ARGS_3 +#undef DEPRECATED_CALL_PUSH_ARGS_RANGE +#undef DEPRECATED_CALL_PUSH_ARGS_THISRANGE +#undef DEPRECATED_CALL_PUSH_ARGS_0_NO_EXTRA +#undef DEPRECATED_CALL_PUSH_ARGS_1_NO_EXTRA +#undef DEPRECATED_CALL_PUSH_ARGS_2_NO_EXTRA +#undef DEPRECATED_CALL_PUSH_ARGS_3_NO_EXTRA +#undef DEPRECATED_CALL_PUSH_ARGS_RANGE_NO_EXTRA +#undef DEPRECATED_CALL_PUSH_ARGS_THISRANGE_NO_EXTRA +#undef DEPRECATED_CALL_PUSH_ARGS #undef UPDATE_HOTNESS_COUNTER_NON_ACC #undef UPDATE_HOTNESS_COUNTER #undef GET_VREG diff --git a/ecmascript/interpreter/interpreter.h b/ecmascript/interpreter/interpreter.h index a94b14eb88..4cdc1b2829 100644 --- a/ecmascript/interpreter/interpreter.h +++ b/ecmascript/interpreter/interpreter.h @@ -24,11 +24,16 @@ #include "ecmascript/frames.h" #include "ecmascript/require/js_cjs_module.h" +#include "libpandafile/bytecode_instruction-inl.h" + namespace panda::ecmascript { class ConstantPool; class ECMAObject; class GeneratorContext; +using EcmaOpcode = BytecodeInstruction::Opcode; +const uint8_t EXCEPTION_OPCODE = static_cast(EcmaOpcode::NOP) + 1; + class EcmaInterpreter { public: static const int16_t METHOD_HOTNESS_THRESHOLD = 0x700; @@ -61,166 +66,6 @@ public: static inline int16_t GetHotnessCounter(uint32_t codeSize); }; -enum EcmaOpcode { - LDNAN_PREF, - LDINFINITY_PREF, - LDGLOBALTHIS_PREF, - LDUNDEFINED_PREF, - LDNULL_PREF, - LDSYMBOL_PREF, - LDGLOBAL_PREF, - LDTRUE_PREF, - LDFALSE_PREF, - THROWDYN_PREF, - TYPEOFDYN_PREF, - LDLEXENVDYN_PREF, - POPLEXENVDYN_PREF, - GETUNMAPPEDARGS_PREF, - GETPROPITERATOR_PREF, - ASYNCFUNCTIONENTER_PREF, - LDHOLE_PREF, - RETURNUNDEFINED_PREF, - CREATEEMPTYOBJECT_PREF, - CREATEEMPTYARRAY_PREF, - GETITERATOR_PREF, - THROWTHROWNOTEXISTS_PREF, - THROWPATTERNNONCOERCIBLE_PREF, - LDHOMEOBJECT_PREF, - THROWDELETESUPERPROPERTY_PREF, - DEBUGGER_PREF, - ADD2DYN_PREF_V8, - SUB2DYN_PREF_V8, - MUL2DYN_PREF_V8, - DIV2DYN_PREF_V8, - MOD2DYN_PREF_V8, - EQDYN_PREF_V8, - NOTEQDYN_PREF_V8, - LESSDYN_PREF_V8, - LESSEQDYN_PREF_V8, - GREATERDYN_PREF_V8, - GREATEREQDYN_PREF_V8, - SHL2DYN_PREF_V8, - ASHR2DYN_PREF_V8, - SHR2DYN_PREF_V8, - AND2DYN_PREF_V8, - OR2DYN_PREF_V8, - XOR2DYN_PREF_V8, - TONUMBER_PREF_V8, - NEGDYN_PREF_V8, - NOTDYN_PREF_V8, - INCDYN_PREF_V8, - DECDYN_PREF_V8, - EXPDYN_PREF_V8, - ISINDYN_PREF_V8, - INSTANCEOFDYN_PREF_V8, - STRICTNOTEQDYN_PREF_V8, - STRICTEQDYN_PREF_V8, - RESUMEGENERATOR_PREF_V8, - GETRESUMEMODE_PREF_V8, - CREATEGENERATOROBJ_PREF_V8, - THROWCONSTASSIGNMENT_PREF_V8, - GETTEMPLATEOBJECT_PREF_V8, - GETNEXTPROPNAME_PREF_V8, - CALLARG0DYN_PREF_V8, - THROWIFNOTOBJECT_PREF_V8, - ITERNEXT_PREF_V8, - CLOSEITERATOR_PREF_V8, - COPYMODULE_PREF_V8, - SUPERCALLSPREAD_PREF_V8, - DELOBJPROP_PREF_V8_V8, - NEWOBJSPREADDYN_PREF_V8_V8, - CREATEITERRESULTOBJ_PREF_V8_V8, - SUSPENDGENERATOR_PREF_V8_V8, - ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8, - THROWUNDEFINEDIFHOLE_PREF_V8_V8, - CALLARG1DYN_PREF_V8_V8, - COPYDATAPROPERTIES_PREF_V8_V8, - STARRAYSPREAD_PREF_V8_V8, - GETITERATORNEXT_PREF_V8_V8, - SETOBJECTWITHPROTO_PREF_V8_V8, - LDOBJBYVALUE_PREF_V8_V8, - STOBJBYVALUE_PREF_V8_V8, - STOWNBYVALUE_PREF_V8_V8, - LDSUPERBYVALUE_PREF_V8_V8, - STSUPERBYVALUE_PREF_V8_V8, - LDOBJBYINDEX_PREF_V8_IMM32, - STOBJBYINDEX_PREF_V8_IMM32, - STOWNBYINDEX_PREF_V8_IMM32, - CALLSPREADDYN_PREF_V8_V8_V8, - ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8, - ASYNCFUNCTIONREJECT_PREF_V8_V8_V8, - CALLARGS2DYN_PREF_V8_V8_V8, - CALLARGS3DYN_PREF_V8_V8_V8_V8, - DEFINEGETTERSETTERBYVALUE_PREF_V8_V8_V8_V8, - NEWOBJDYNRANGE_PREF_IMM16_V8, - CALLIRANGEDYN_PREF_IMM16_V8, - CALLITHISRANGEDYN_PREF_IMM16_V8, - SUPERCALL_PREF_IMM16_V8, - CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8, - DEFINEFUNCDYN_PREF_ID16_IMM16_V8, - DEFINENCFUNCDYN_PREF_ID16_IMM16_V8, - DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8, - DEFINEASYNCFUNC_PREF_ID16_IMM16_V8, - DEFINEMETHOD_PREF_ID16_IMM16_V8, - NEWLEXENVDYN_PREF_IMM16, - COPYRESTARGS_PREF_IMM16, - CREATEARRAYWITHBUFFER_PREF_IMM16, - CREATEOBJECTHAVINGMETHOD_PREF_IMM16, - THROWIFSUPERNOTCORRECTCALL_PREF_IMM16, - CREATEOBJECTWITHBUFFER_PREF_IMM16, - LDLEXVARDYN_PREF_IMM4_IMM4, - LDLEXVARDYN_PREF_IMM8_IMM8, - LDLEXVARDYN_PREF_IMM16_IMM16, - STLEXVARDYN_PREF_IMM4_IMM4_V8, - STLEXVARDYN_PREF_IMM8_IMM8_V8, - STLEXVARDYN_PREF_IMM16_IMM16_V8, - DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8, - GETMODULENAMESPACE_PREF_ID32, - STMODULEVAR_PREF_ID32, - TRYLDGLOBALBYNAME_PREF_ID32, - TRYSTGLOBALBYNAME_PREF_ID32, - LDGLOBALVAR_PREF_ID32, - STGLOBALVAR_PREF_ID32, - LDOBJBYNAME_PREF_ID32_V8, - STOBJBYNAME_PREF_ID32_V8, - STOWNBYNAME_PREF_ID32_V8, - LDSUPERBYNAME_PREF_ID32_V8, - STSUPERBYNAME_PREF_ID32_V8, - LDMODULEVAR_PREF_ID32_IMM8, - CREATEREGEXPWITHLITERAL_PREF_ID32_IMM8, - ISTRUE_PREF, - ISFALSE_PREF, - STCONSTTOGLOBALRECORD_PREF_ID32, - STLETTOGLOBALRECORD_PREF_ID32, - STCLASSTOGLOBALRECORD_PREF_ID32, - STOWNBYVALUEWITHNAMESET_PREF_V8_V8, - STOWNBYNAMEWITHNAMESET_PREF_ID32_V8, - LDFUNCTION_PREF, - NEWLEXENVWITHNAMEDYN_PREF_IMM16_IMM16, - LDBIGINT_PREF_ID32, - TONUMERIC_PREF_V8, - CREATEASYNCGENERATOROBJ_PREF_V8, - ASYNCGENERATORRESOLVE_PREF_V8_V8_V8, - DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8, - MOV_DYN_V8_V8, - MOV_DYN_V16_V16, - LDA_STR_ID32, - LDAI_DYN_IMM32, - FLDAI_DYN_IMM64, - JMP_IMM8, - JMP_IMM16, - JMP_IMM32, - JEQZ_IMM8, - JEQZ_IMM16, - LDA_DYN_V8, - STA_DYN_V8, - RETURN_DYN, - MOV_V4_V4, - JNEZ_IMM8, - JNEZ_IMM16, - LAST_OPCODE, -}; - // if modify EcmaOpcode, please update GetEcmaOpcodeStr() inline std::string GetEcmaOpcodeStr(EcmaOpcode opcode); } // namespace panda::ecmascript diff --git a/ecmascript/interpreter/interpreter_assembly.cpp b/ecmascript/interpreter/interpreter_assembly.cpp index 547b0c5c4b..4197c2fbab 100644 --- a/ecmascript/interpreter/interpreter_assembly.cpp +++ b/ecmascript/interpreter/interpreter_assembly.cpp @@ -77,7 +77,7 @@ using panda::ecmascript::kungfu::CommonStubCSigns; return; \ } while (false) -#define DISPATCH(format) DISPATCH_OFFSET(BytecodeInstruction::Size(format)) +#define DISPATCH(opcode) DISPATCH_OFFSET(BytecodeInstruction::Size(BytecodeInstruction::Opcode::opcode)) // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) #define GET_ASM_FRAME(CurrentSp) \ @@ -196,7 +196,7 @@ using panda::ecmascript::kungfu::CommonStubCSigns; // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) #define SET_VREG(idx, val) (sp[idx] = (val)); // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic) #define GET_ACC() (acc) // NOLINT(cppcoreguidelines-macro-usage) -#define SET_ACC(val) (acc = val); // NOLINT(cppcoreguidelines-macro-usage) +#define SET_ACC(val) (acc = val) // NOLINT(cppcoreguidelines-macro-usage) using InterpreterEntry = JSTaggedType (*)(uintptr_t glue, ECMAObject *callTarget, JSMethod *method, uint64_t callField, size_t argc, uintptr_t argv); @@ -255,6 +255,7 @@ JSTaggedValue InterpreterAssembly::GeneratorReEnterInterpreter(JSThread *thread, return JSTaggedValue(acc); } +/* void InterpreterAssembly::HandleMovV4V4( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) @@ -264,41 +265,41 @@ void InterpreterAssembly::HandleMovV4V4( LOG_INST() << "mov v" << vdst << ", v" << vsrc; uint64_t value = GET_VREG(vsrc); SET_VREG(vdst, value) - DISPATCH(BytecodeInstruction::Format::V4_V4); + DISPATCH(MOV_V4_V4); } -void InterpreterAssembly::HandleMovDynV8V8( +void InterpreterAssembly::HandleMovV8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t vdst = READ_INST_8_0(); uint16_t vsrc = READ_INST_8_1(); - LOG_INST() << "mov.dyn v" << vdst << ", v" << vsrc; + LOG_INST() << "mov v" << vdst << ", v" << vsrc; uint64_t value = GET_VREG(vsrc); SET_VREG(vdst, value) - DISPATCH(BytecodeInstruction::Format::V8_V8); + DISPATCH(MOV_V8_V8); } -void InterpreterAssembly::HandleMovDynV16V16( +void InterpreterAssembly::HandleMovV16V16( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t vdst = READ_INST_16_0(); uint16_t vsrc = READ_INST_16_2(); - LOG_INST() << "mov.dyn v" << vdst << ", v" << vsrc; + LOG_INST() << "mov v" << vdst << ", v" << vsrc; uint64_t value = GET_VREG(vsrc); SET_VREG(vdst, value) - DISPATCH(BytecodeInstruction::Format::V16_V16); + DISPATCH(MOV_V16_V16); } -void InterpreterAssembly::HandleLdaStrId32( +void InterpreterAssembly::HandleLdaStrId16( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint32_t stringId = READ_INST_32_0(); + uint16_t stringId = READ_INST_16_0(); LOG_INST() << "lda.str " << std::hex << stringId; SET_ACC(ConstantPool::Cast(constpool.GetTaggedObject())->GetObjectFromCache(stringId)); - DISPATCH(BytecodeInstruction::Format::ID32); + DISPATCH(LDA_STR_ID16); } void InterpreterAssembly::HandleJmpImm8( @@ -343,7 +344,7 @@ void InterpreterAssembly::HandleJeqzImm8( UPDATE_HOTNESS_COUNTER(offset); DISPATCH_OFFSET(offset); } else { - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(JEQZ_IMM8); } } @@ -359,7 +360,7 @@ void InterpreterAssembly::HandleJeqzImm16( UPDATE_HOTNESS_COUNTER(offset); DISPATCH_OFFSET(offset); } else { - DISPATCH(BytecodeInstruction::Format::IMM16); + DISPATCH(JEQZ_IMM16); } } @@ -375,7 +376,7 @@ void InterpreterAssembly::HandleJnezImm8( UPDATE_HOTNESS_COUNTER(offset); DISPATCH_OFFSET(offset); } else { - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(JNEZ_IMM8); } } @@ -391,58 +392,58 @@ void InterpreterAssembly::HandleJnezImm16( UPDATE_HOTNESS_COUNTER(offset); DISPATCH_OFFSET(offset); } else { - DISPATCH(BytecodeInstruction::Format::IMM16); + DISPATCH(JNEZ_IMM16); } } -void InterpreterAssembly::HandleLdaDynV8( +void InterpreterAssembly::HandleLdaV8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t vsrc = READ_INST_8_0(); - LOG_INST() << "lda.dyn v" << vsrc; + LOG_INST() << "lda v" << vsrc; uint64_t value = GET_VREG(vsrc); - SET_ACC(JSTaggedValue(value)) - DISPATCH(BytecodeInstruction::Format::V8); + SET_ACC(JSTaggedValue(value)); + DISPATCH(LDA_V8); } -void InterpreterAssembly::HandleStaDynV8( +void InterpreterAssembly::HandleStaV8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t vdst = READ_INST_8_0(); - LOG_INST() << "sta.dyn v" << vdst; + LOG_INST() << "sta v" << vdst; SET_VREG(vdst, GET_ACC().GetRawData()) - DISPATCH(BytecodeInstruction::Format::V8); + DISPATCH(STA_V8); } -void InterpreterAssembly::HandleLdaiDynImm32( +void InterpreterAssembly::HandleLdaiImm32( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { int32_t imm = static_cast(READ_INST_32_0()); - LOG_INST() << "ldai.dyn " << std::hex << imm; - SET_ACC(JSTaggedValue(imm)) - DISPATCH(BytecodeInstruction::Format::IMM32); + LOG_INST() << "ldai " << std::hex << imm; + SET_ACC(JSTaggedValue(imm)); + DISPATCH(LDAI_IMM32); } -void InterpreterAssembly::HandleFldaiDynImm64( +void InterpreterAssembly::HandleFldaiImm64( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { auto imm = bit_cast(READ_INST_64_0()); - LOG_INST() << "fldai.dyn " << imm; - SET_ACC(JSTaggedValue(imm)) - DISPATCH(BytecodeInstruction::Format::IMM64); + LOG_INST() << "fldai " << imm; + SET_ACC(JSTaggedValue(imm)); + DISPATCH(FLDAI_IMM64); } -void InterpreterAssembly::HandleCallArg0DynPrefV8( +void InterpreterAssembly::HandleCallArg0Imm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint32_t actualNumArgs = ActualNumArgsOfCall::CALLARG0; uint32_t funcReg = READ_INST_8_1(); - LOG_INST() << "callarg0.dyn " + LOG_INST() << "callarg0 " << "v" << funcReg; // slow path JSHandle funcHandle(thread, GET_VREG_VALUE(funcReg)); @@ -450,17 +451,17 @@ void InterpreterAssembly::HandleCallArg0DynPrefV8( EcmaRuntimeCallInfo *info = EcmaInterpreter::NewRuntimeCallInfo(thread, funcHandle, undefined, undefined, actualNumArgs); JSFunction::Call(info); - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(CALLARG0_IMM8_V8); } -void InterpreterAssembly::HandleCallArg1DynPrefV8V8( +void InterpreterAssembly::HandleCallArg1Imm8V8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint32_t actualNumArgs = ActualNumArgsOfCall::CALLARG1; uint32_t funcReg = READ_INST_8_1(); uint8_t a0 = READ_INST_8_2(); - LOG_INST() << "callarg1.dyn " + LOG_INST() << "callarg1 " << "v" << funcReg << ", v" << a0; // slow path JSHandle funcHandle(thread, GET_VREG_VALUE(funcReg)); @@ -470,10 +471,10 @@ void InterpreterAssembly::HandleCallArg1DynPrefV8V8( RETURN_IF_ABRUPT_COMPLETION(thread); info->SetCallArg(GET_VREG_VALUE(a0)); JSFunction::Call(info); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(CALLARG1_IMM8_V8_V8); } -void InterpreterAssembly::HandleCallArgs2DynPrefV8V8V8( +void InterpreterAssembly::HandleCallArgs2Imm8V8V8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -481,7 +482,7 @@ void InterpreterAssembly::HandleCallArgs2DynPrefV8V8V8( uint32_t funcReg = READ_INST_8_1(); uint8_t a0 = READ_INST_8_2(); uint8_t a1 = READ_INST_8_3(); - LOG_INST() << "callargs2.dyn " + LOG_INST() << "callargs2 " << "v" << funcReg << ", v" << a0 << ", v" << a1; // slow path JSHandle funcHandle(thread, GET_VREG_VALUE(funcReg)); @@ -491,10 +492,10 @@ void InterpreterAssembly::HandleCallArgs2DynPrefV8V8V8( RETURN_IF_ABRUPT_COMPLETION(thread); info->SetCallArg(GET_VREG_VALUE(a0), GET_VREG_VALUE(a1)); JSFunction::Call(info); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8_V8); + DISPATCH(CALLARGS2_IMM8_V8_V8_V8); } -void InterpreterAssembly::HandleCallArgs3DynPrefV8V8V8V8( +void InterpreterAssembly::HandleCallArgs3Imm8V8V8V8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -503,7 +504,7 @@ void InterpreterAssembly::HandleCallArgs3DynPrefV8V8V8V8( uint8_t a0 = READ_INST_8_2(); uint8_t a1 = READ_INST_8_3(); uint8_t a2 = READ_INST_8_4(); - LOG_INST() << "callargs3.dyn " + LOG_INST() << "callargs3 " << "v" << funcReg << ", v" << a0 << ", v" << a1 << ", v" << a2; // slow path JSHandle funcHandle(thread, GET_VREG_VALUE(funcReg)); @@ -513,16 +514,16 @@ void InterpreterAssembly::HandleCallArgs3DynPrefV8V8V8V8( RETURN_IF_ABRUPT_COMPLETION(thread); info->SetCallArg(GET_VREG_VALUE(a0), GET_VREG_VALUE(a1), GET_VREG_VALUE(a2)); JSFunction::Call(info); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8_V8_V8); + DISPATCH(CALLARGS3_IMM8_V8_V8_V8_V8); } -void InterpreterAssembly::HandleCallIThisRangeDynPrefImm16V8( +void InterpreterAssembly::HandleCallThisRangeImm8Imm16V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint32_t actualNumArgs = READ_INST_16_1() - 1; // 1: exclude this uint32_t funcReg = READ_INST_8_3(); - LOG_INST() << "calli.dyn.this.range " << actualNumArgs << ", v" << funcReg; + LOG_INST() << "calli.this.range " << actualNumArgs << ", v" << funcReg; // slow path JSHandle funcHandle(thread, GET_VREG_VALUE(funcReg)); JSHandle thisHandle(thread, GET_VREG_VALUE(funcReg + 1)); @@ -534,36 +535,36 @@ void InterpreterAssembly::HandleCallIThisRangeDynPrefImm16V8( info->SetCallArg(i, GET_VREG_VALUE(funcReg + i + 2)); // 2: start index of the first arg } JSFunction::Call(info); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16_V8); + DISPATCH(CALLTHISRANGE_IMM8_IMM16_V8); } -void InterpreterAssembly::HandleCallSpreadDynPrefV8V8V8( +void InterpreterAssembly::HandleCallSpreadImm8V8V8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); uint16_t v1 = READ_INST_8_2(); uint16_t v2 = READ_INST_8_3(); - LOG_INST() << "intrinsics::callspreaddyn" + LOG_INST() << "intrinsics::callspread" << " v" << v0 << " v" << v1 << " v" << v2; JSTaggedValue func = GET_VREG_VALUE(v0); JSTaggedValue obj = GET_VREG_VALUE(v1); JSTaggedValue array = GET_VREG_VALUE(v2); - JSTaggedValue res = SlowRuntimeStub::CallSpreadDyn(thread, func, obj, array); + JSTaggedValue res = SlowRuntimeStub::CallSpread(thread, func, obj, array); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8_V8); + DISPATCH(CALLSPREAD_IMM8_V8_V8_V8); } -void InterpreterAssembly::HandleCallIRangeDynPrefImm16V8( +void InterpreterAssembly::HandleCallRangeImm8Imm16V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint32_t actualNumArgs = READ_INST_16_1(); uint32_t funcReg = READ_INST_8_3(); - LOG_INST() << "calli.rangedyn " << actualNumArgs << ", v" << funcReg; + LOG_INST() << "calli.range " << actualNumArgs << ", v" << funcReg; // slow path JSHandle funcHandle(thread, GET_VREG_VALUE(funcReg)); JSHandle undefined = thread->GlobalConstants()->GetHandledUndefined(); @@ -574,10 +575,10 @@ void InterpreterAssembly::HandleCallIRangeDynPrefImm16V8( info->SetCallArg(i, GET_VREG_VALUE(funcReg + i + 1)); // 1: start index of the first arg } JSFunction::Call(info); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16_V8); + DISPATCH(CALLRANGE_IMM8_IMM16_V8); } -void InterpreterAssembly::HandleReturnDyn( +void InterpreterAssembly::HandleReturn( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -605,7 +606,7 @@ void InterpreterAssembly::HandleReturnDyn( INTERPRETER_HANDLE_RETURN(); } -void InterpreterAssembly::HandleReturnUndefinedPref( +void InterpreterAssembly::HandleReturnUndefined( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -634,25 +635,25 @@ void InterpreterAssembly::HandleReturnUndefinedPref( INTERPRETER_HANDLE_RETURN(); } -void InterpreterAssembly::HandleLdNanPref( +void InterpreterAssembly::HandleLdNan( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { LOG_INST() << "intrinsics::ldnan"; SET_ACC(JSTaggedValue(base::NAN_VALUE)); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(LDNAN); } -void InterpreterAssembly::HandleLdInfinityPref( +void InterpreterAssembly::HandleLdInfinity( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { LOG_INST() << "intrinsics::ldinfinity"; SET_ACC(JSTaggedValue(base::POSITIVE_INFINITY)); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(LDINFINITY); } -void InterpreterAssembly::HandleLdGlobalThisPref( +void InterpreterAssembly::HandleLdGlobalThis( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -660,29 +661,29 @@ void InterpreterAssembly::HandleLdGlobalThisPref( EcmaVM *ecmaVm = thread->GetEcmaVM(); JSHandle globalEnv = ecmaVm->GetGlobalEnv(); JSTaggedValue globalObj = globalEnv->GetGlobalObject(); - SET_ACC(globalObj) - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + SET_ACC(globalObj); + DISPATCH(LDGLOBALTHIS); } -void InterpreterAssembly::HandleLdUndefinedPref( +void InterpreterAssembly::HandleLdUndefined( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { LOG_INST() << "intrinsics::ldundefined"; - SET_ACC(JSTaggedValue::Undefined()) - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + SET_ACC(JSTaggedValue::Undefined()); + DISPATCH(LDUNDEFINED); } -void InterpreterAssembly::HandleLdNullPref( +void InterpreterAssembly::HandleLdNull( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { LOG_INST() << "intrinsics::ldnull"; - SET_ACC(JSTaggedValue::Null()) - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + SET_ACC(JSTaggedValue::Null()); + DISPATCH(LDNULL); } -void InterpreterAssembly::HandleLdSymbolPref( +void InterpreterAssembly::HandleLdSymbol( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -690,10 +691,10 @@ void InterpreterAssembly::HandleLdSymbolPref( EcmaVM *ecmaVm = thread->GetEcmaVM(); JSHandle globalEnv = ecmaVm->GetGlobalEnv(); SET_ACC(globalEnv->GetSymbolFunction().GetTaggedValue()); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(LDSYMBOL); } -void InterpreterAssembly::HandleLdGlobalPref( +void InterpreterAssembly::HandleLdGlobal( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -701,40 +702,40 @@ void InterpreterAssembly::HandleLdGlobalPref( EcmaVM *ecmaVm = thread->GetEcmaVM(); JSHandle globalEnv = ecmaVm->GetGlobalEnv(); JSTaggedValue globalObj = globalEnv->GetGlobalObject(); - SET_ACC(globalObj) - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + SET_ACC(globalObj); + DISPATCH(LDGLOBAL); } -void InterpreterAssembly::HandleLdTruePref( +void InterpreterAssembly::HandleLdTrue( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { LOG_INST() << "intrinsics::ldtrue"; - SET_ACC(JSTaggedValue::True()) - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + SET_ACC(JSTaggedValue::True()); + DISPATCH(LDTRUE); } -void InterpreterAssembly::HandleLdFalsePref( +void InterpreterAssembly::HandleLdFalse( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { LOG_INST() << "intrinsics::ldfalse"; - SET_ACC(JSTaggedValue::False()) - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + SET_ACC(JSTaggedValue::False()); + DISPATCH(LDFALSE); } -void InterpreterAssembly::HandleLdLexEnvDynPref( +void InterpreterAssembly::HandleLdLexEnv( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - LOG_INST() << "intrinsics::ldlexenvDyn "; + LOG_INST() << "intrinsics::ldlexenv "; AsmInterpretedFrame *state = GET_ASM_FRAME(sp); JSTaggedValue currentLexenv = state->env; SET_ACC(currentLexenv); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(LDLEXENV); } -void InterpreterAssembly::HandleGetUnmappedArgsPref( +void InterpreterAssembly::HandleGetUnmappedArgs( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -746,10 +747,10 @@ void InterpreterAssembly::HandleGetUnmappedArgsPref( JSTaggedValue res = SlowRuntimeStub::GetUnmapedArgs(thread, sp, actualNumArgs, startIdx); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(GETUNMAPPEDARGS); } -void InterpreterAssembly::HandleAsyncFunctionEnterPref( +void InterpreterAssembly::HandleAsyncFunctionEnter( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -757,10 +758,10 @@ void InterpreterAssembly::HandleAsyncFunctionEnterPref( JSTaggedValue res = SlowRuntimeStub::AsyncFunctionEnter(thread); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(ASYNCFUNCTIONENTER); } -void InterpreterAssembly::HandleToNumberPrefV8( +void InterpreterAssembly::HandleToNumberImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -778,15 +779,15 @@ void InterpreterAssembly::HandleToNumberPrefV8( INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(TONUMBER_IMM8_V8); } -void InterpreterAssembly::HandleNegDynPrefV8( +void InterpreterAssembly::HandleNegImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::negdyn" + LOG_INST() << "intrinsics::neg" << " v" << v0; JSTaggedValue value = GET_VREG_VALUE(v0); // fast path @@ -799,46 +800,46 @@ void InterpreterAssembly::HandleNegDynPrefV8( } else if (value.IsDouble()) { SET_ACC(JSTaggedValue(-value.GetDouble())); } else { // slow path - JSTaggedValue res = SlowRuntimeStub::NegDyn(thread, value); + JSTaggedValue res = SlowRuntimeStub::Neg(thread, value); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(NEG_IMM8_V8); } -void InterpreterAssembly::HandleNotDynPrefV8( +void InterpreterAssembly::HandleNotImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::notdyn" + LOG_INST() << "intrinsics::not" << " v" << v0; JSTaggedValue value = GET_VREG_VALUE(v0); int32_t number; // number, fast path if (value.IsInt()) { number = static_cast(value.GetInt()); - SET_ACC(JSTaggedValue(~number)); // NOLINT(hicpp-signed-bitwise) + SET_ACC(JSTaggedValue(~number)); // NOLINT(hicpp-signed-bitwise); } else if (value.IsDouble()) { number = base::NumberHelper::DoubleToInt(value.GetDouble(), base::INT32_BITS); - SET_ACC(JSTaggedValue(~number)); // NOLINT(hicpp-signed-bitwise) + SET_ACC(JSTaggedValue(~number)); // NOLINT(hicpp-signed-bitwise); } else { // slow path - JSTaggedValue res = SlowRuntimeStub::NotDyn(thread, value); + JSTaggedValue res = SlowRuntimeStub::Not(thread, value); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(NOT_IMM8_V8); } -void InterpreterAssembly::HandleIncDynPrefV8( +void InterpreterAssembly::HandleIncImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::incdyn" + LOG_INST() << "intrinsics::inc" << " v" << v0; JSTaggedValue value = GET_VREG_VALUE(v0); @@ -847,27 +848,27 @@ void InterpreterAssembly::HandleIncDynPrefV8( int32_t a0 = value.GetInt(); if (UNLIKELY(a0 == INT32_MAX)) { auto ret = static_cast(a0) + 1.0; - SET_ACC(JSTaggedValue(ret)) + SET_ACC(JSTaggedValue(ret)); } else { - SET_ACC(JSTaggedValue(a0 + 1)) + SET_ACC(JSTaggedValue(a0 + 1)); } } else if (value.IsDouble()) { - SET_ACC(JSTaggedValue(value.GetDouble() + 1.0)) + SET_ACC(JSTaggedValue(value.GetDouble() + 1.0)); } else { // slow path - JSTaggedValue res = SlowRuntimeStub::IncDyn(thread, value); + JSTaggedValue res = SlowRuntimeStub::Inc(thread, value); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(INC_IMM8_V8); } -void InterpreterAssembly::HandleDecDynPrefV8( +void InterpreterAssembly::HandleDecImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::decdyn" + LOG_INST() << "intrinsics::dec" << " v" << v0; JSTaggedValue value = GET_VREG_VALUE(v0); @@ -876,41 +877,41 @@ void InterpreterAssembly::HandleDecDynPrefV8( int32_t a0 = value.GetInt(); if (UNLIKELY(a0 == INT32_MIN)) { auto ret = static_cast(a0) - 1.0; - SET_ACC(JSTaggedValue(ret)) + SET_ACC(JSTaggedValue(ret)); } else { - SET_ACC(JSTaggedValue(a0 - 1)) + SET_ACC(JSTaggedValue(a0 - 1)); } } else if (value.IsDouble()) { - SET_ACC(JSTaggedValue(value.GetDouble() - 1.0)) + SET_ACC(JSTaggedValue(value.GetDouble() - 1.0)); } else { // slow path - JSTaggedValue res = SlowRuntimeStub::DecDyn(thread, value); + JSTaggedValue res = SlowRuntimeStub::Dec(thread, value); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(DEC_IMM8_V8); } -void InterpreterAssembly::HandleThrowDynPref( +void InterpreterAssembly::HandleThrow( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - LOG_INST() << "intrinsics::throwdyn"; - SlowRuntimeStub::ThrowDyn(thread, GET_ACC()); + LOG_INST() << "intrinsics::throw"; + SlowRuntimeStub::Throw(thread, GET_ACC()); INTERPRETER_GOTO_EXCEPTION_HANDLER(); } -void InterpreterAssembly::HandleTypeOfDynPref( +void InterpreterAssembly::HandleTypeofImm8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - LOG_INST() << "intrinsics::typeofdyn"; + LOG_INST() << "intrinsics::typeof"; JSTaggedValue res = FastRuntimeStub::FastTypeOf(thread, GET_ACC()); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(TYPEOF_IMM8); } -void InterpreterAssembly::HandleGetPropIteratorPref( +void InterpreterAssembly::HandleGetPropIterator( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -918,15 +919,15 @@ void InterpreterAssembly::HandleGetPropIteratorPref( JSTaggedValue res = SlowRuntimeStub::GetPropIterator(thread, GET_ACC()); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(GETPROPITERATOR); } -void InterpreterAssembly::HandleResumeGeneratorPrefV8( +void InterpreterAssembly::HandleResumeGeneratorV8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { LOG_INST() << "intrinsics::resumegenerator"; - uint16_t vs = READ_INST_8_1(); + uint16_t vs = READ_INST_8_0(); JSTaggedValue objVal = GET_VREG_VALUE(vs); if (objVal.IsAsyncGeneratorObject()) { @@ -936,15 +937,15 @@ void InterpreterAssembly::HandleResumeGeneratorPrefV8( JSGeneratorObject *obj = JSGeneratorObject::Cast(objVal.GetTaggedObject()); SET_ACC(obj->GetResumeResult()); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(RESUMEGENERATOR_V8); } -void InterpreterAssembly::HandleGetResumeModePrefV8( +void InterpreterAssembly::HandleGetResumeModeV8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { LOG_INST() << "intrinsics::getresumemode"; - uint16_t vs = READ_INST_8_1(); + uint16_t vs = READ_INST_8_0(); JSTaggedValue objVal = GET_VREG_VALUE(vs); if (objVal.IsAsyncGeneratorObject()) { JSAsyncGeneratorObject *obj = JSAsyncGeneratorObject::Cast(objVal.GetTaggedObject()); @@ -953,10 +954,10 @@ void InterpreterAssembly::HandleGetResumeModePrefV8( JSGeneratorObject *obj = JSGeneratorObject::Cast(objVal.GetTaggedObject()); SET_ACC(JSTaggedValue(static_cast(obj->GetResumeMode()))); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(GETRESUMEMODE_V8); } -void InterpreterAssembly::HandleGetIteratorPref( +void InterpreterAssembly::HandleGetIteratorImm8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -966,21 +967,21 @@ void InterpreterAssembly::HandleGetIteratorPref( JSTaggedValue res = SlowRuntimeStub::GetIterator(thread, obj); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(GETITERATOR_IMM8); } -void InterpreterAssembly::HandleThrowConstAssignmentPrefV8( +void InterpreterAssembly::HandleThrowConstAssignmentV8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t v0 = READ_INST_8_1(); + uint16_t v0 = READ_INST_8_0(); LOG_INST() << "throwconstassignment" << " v" << v0; SlowRuntimeStub::ThrowConstAssignment(thread, GET_VREG_VALUE(v0)); INTERPRETER_GOTO_EXCEPTION_HANDLER(); } -void InterpreterAssembly::HandleThrowThrowNotExistsPref( +void InterpreterAssembly::HandleThrowThrowNotExists( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -990,7 +991,7 @@ void InterpreterAssembly::HandleThrowThrowNotExistsPref( INTERPRETER_GOTO_EXCEPTION_HANDLER(); } -void InterpreterAssembly::HandleThrowPatternNonCoerciblePref( +void InterpreterAssembly::HandleThrowPatternNonCoercible( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -1000,17 +1001,17 @@ void InterpreterAssembly::HandleThrowPatternNonCoerciblePref( INTERPRETER_GOTO_EXCEPTION_HANDLER(); } -void InterpreterAssembly::HandleThrowIfNotObjectPrefV8( +void InterpreterAssembly::HandleThrowIfNotObjectV8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { LOG_INST() << "throwifnotobject"; - uint16_t v0 = READ_INST_8_1(); + uint16_t v0 = READ_INST_8_0(); JSTaggedValue value = GET_VREG_VALUE(v0); // fast path if (value.IsECMAObject()) { - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(THROWIFNOTOBJECT_V8); } // slow path @@ -1018,7 +1019,7 @@ void InterpreterAssembly::HandleThrowIfNotObjectPrefV8( INTERPRETER_GOTO_EXCEPTION_HANDLER(); } -void InterpreterAssembly::HandleIterNextPrefV8( +void InterpreterAssembly::HandleIterNextImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -1029,10 +1030,10 @@ void InterpreterAssembly::HandleIterNextPrefV8( JSTaggedValue res = SlowRuntimeStub::IterNext(thread, iter); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(ITERNEXT_IMM8_V8); } -void InterpreterAssembly::HandleCloseIteratorPrefV8( +void InterpreterAssembly::HandleCloseIteratorImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -1043,15 +1044,15 @@ void InterpreterAssembly::HandleCloseIteratorPrefV8( JSTaggedValue res = SlowRuntimeStub::CloseIterator(thread, iter); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(CLOSEITERATOR_IMM8_V8); } -void InterpreterAssembly::HandleAdd2DynPrefV8( +void InterpreterAssembly::HandleAdd2Imm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::add2dyn" + LOG_INST() << "intrinsics::add2" << " v" << v0; int32_t a0; int32_t a1; @@ -1063,30 +1064,30 @@ void InterpreterAssembly::HandleAdd2DynPrefV8( a1 = right.GetInt(); if ((a0 > 0 && a1 > INT32_MAX - a0) || (a0 < 0 && a1 < INT32_MIN - a0)) { auto ret = static_cast(a0) + static_cast(a1); - SET_ACC(JSTaggedValue(ret)) + SET_ACC(JSTaggedValue(ret)); } else { - SET_ACC(JSTaggedValue(a0 + a1)) + SET_ACC(JSTaggedValue(a0 + a1)); } } else if (left.IsNumber() && right.IsNumber()) { double a0Double = left.IsInt() ? left.GetInt() : left.GetDouble(); double a1Double = right.IsInt() ? right.GetInt() : right.GetDouble(); double ret = a0Double + a1Double; - SET_ACC(JSTaggedValue(ret)) + SET_ACC(JSTaggedValue(ret)); } else { // one or both are not number, slow path - JSTaggedValue res = SlowRuntimeStub::Add2Dyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::Add2(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(ADD2_IMM8_V8); } -void InterpreterAssembly::HandleSub2DynPrefV8( +void InterpreterAssembly::HandleSub2Imm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::sub2dyn" + LOG_INST() << "intrinsics::sub2" << " v" << v0; int32_t a0; int32_t a1; @@ -1097,29 +1098,29 @@ void InterpreterAssembly::HandleSub2DynPrefV8( a1 = -right.GetInt(); if ((a0 > 0 && a1 > INT32_MAX - a0) || (a0 < 0 && a1 < INT32_MIN - a0)) { auto ret = static_cast(a0) + static_cast(a1); - SET_ACC(JSTaggedValue(ret)) + SET_ACC(JSTaggedValue(ret)); } else { - SET_ACC(JSTaggedValue(a0 + a1)) + SET_ACC(JSTaggedValue(a0 + a1)); } } else if (left.IsNumber() && right.IsNumber()) { double a0Double = left.IsInt() ? left.GetInt() : left.GetDouble(); double a1Double = right.IsInt() ? right.GetInt() : right.GetDouble(); double ret = a0Double - a1Double; - SET_ACC(JSTaggedValue(ret)) + SET_ACC(JSTaggedValue(ret)); } else { // one or both are not number, slow path - JSTaggedValue res = SlowRuntimeStub::Sub2Dyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::Sub2(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(SUB2_IMM8_V8); } -void InterpreterAssembly::HandleMul2DynPrefV8( +void InterpreterAssembly::HandleMul2Imm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::mul2dyn" + LOG_INST() << "intrinsics::mul2" << " v" << v0; JSTaggedValue left = GET_VREG_VALUE(v0); JSTaggedValue right = acc; @@ -1128,19 +1129,19 @@ void InterpreterAssembly::HandleMul2DynPrefV8( SET_ACC(value); } else { // slow path - JSTaggedValue res = SlowRuntimeStub::Mul2Dyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::Mul2(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(MUL2_IMM8_V8); } -void InterpreterAssembly::HandleDiv2DynPrefV8( +void InterpreterAssembly::HandleDiv2Imm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::div2dyn" + LOG_INST() << "intrinsics::div2" << " v" << v0; JSTaggedValue left = GET_VREG_VALUE(v0); JSTaggedValue right = acc; @@ -1150,19 +1151,19 @@ void InterpreterAssembly::HandleDiv2DynPrefV8( SET_ACC(res); } else { // slow path - JSTaggedValue slowRes = SlowRuntimeStub::Div2Dyn(thread, left, right); + JSTaggedValue slowRes = SlowRuntimeStub::Div2(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(slowRes); SET_ACC(slowRes); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(DIV2_IMM8_V8); } -void InterpreterAssembly::HandleMod2DynPrefV8( +void InterpreterAssembly::HandleMod2Imm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t vs = READ_INST_8_1(); - LOG_INST() << "intrinsics::mod2dyn" + LOG_INST() << "intrinsics::mod2" << " v" << vs; JSTaggedValue left = GET_VREG_VALUE(vs); JSTaggedValue right = GET_ACC(); @@ -1172,20 +1173,20 @@ void InterpreterAssembly::HandleMod2DynPrefV8( SET_ACC(res); } else { // slow path - JSTaggedValue slowRes = SlowRuntimeStub::Mod2Dyn(thread, left, right); + JSTaggedValue slowRes = SlowRuntimeStub::Mod2(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(slowRes); SET_ACC(slowRes); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(MOD2_IMM8_V8); } -void InterpreterAssembly::HandleEqDynPrefV8( +void InterpreterAssembly::HandleEqImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::eqdyn" + LOG_INST() << "intrinsics::eq" << " v" << v0; JSTaggedValue left = GET_VREG_VALUE(v0); JSTaggedValue right = acc; @@ -1194,21 +1195,21 @@ void InterpreterAssembly::HandleEqDynPrefV8( SET_ACC(res); } else { // slow path - res = SlowRuntimeStub::EqDyn(thread, left, right); + res = SlowRuntimeStub::Eq(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(EQ_IMM8_V8); } -void InterpreterAssembly::HandleNotEqDynPrefV8( +void InterpreterAssembly::HandleNotEqImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::noteqdyn" + LOG_INST() << "intrinsics::noteq" << " v" << v0; JSTaggedValue left = GET_VREG_VALUE(v0); JSTaggedValue right = acc; @@ -1219,20 +1220,20 @@ void InterpreterAssembly::HandleNotEqDynPrefV8( SET_ACC(res); } else { // slow path - res = SlowRuntimeStub::NotEqDyn(thread, left, right); + res = SlowRuntimeStub::NotEq(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(NOTEQ_IMM8_V8); } -void InterpreterAssembly::HandleLessDynPrefV8( +void InterpreterAssembly::HandleLessImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::lessdyn" + LOG_INST() << "intrinsics::less" << " v" << v0; JSTaggedValue left = GET_VREG_VALUE(v0); JSTaggedValue right = GET_ACC(); @@ -1245,25 +1246,25 @@ void InterpreterAssembly::HandleLessDynPrefV8( double valueA = left.IsInt() ? static_cast(left.GetInt()) : left.GetDouble(); double valueB = right.IsInt() ? static_cast(right.GetInt()) : right.GetDouble(); bool ret = JSTaggedValue::StrictNumberCompare(valueA, valueB) == ComparisonResult::LESS; - SET_ACC(ret ? JSTaggedValue::True() : JSTaggedValue::False()) + SET_ACC(ret ? JSTaggedValue::True() : JSTaggedValue::False()); } else if (left.IsBigInt() && right.IsBigInt()) { bool result = BigInt::LessThan(left, right); SET_ACC(JSTaggedValue(result)); } else { // slow path - JSTaggedValue res = SlowRuntimeStub::LessDyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::Less(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(LESS_IMM8_V8); } -void InterpreterAssembly::HandleLessEqDynPrefV8( +void InterpreterAssembly::HandleLessEqImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t vs = READ_INST_8_1(); - LOG_INST() << "intrinsics::lesseqdyn " + LOG_INST() << "intrinsics::lesseq " << " v" << vs; JSTaggedValue left = GET_VREG_VALUE(vs); JSTaggedValue right = GET_ACC(); @@ -1276,26 +1277,26 @@ void InterpreterAssembly::HandleLessEqDynPrefV8( double valueA = left.IsInt() ? static_cast(left.GetInt()) : left.GetDouble(); double valueB = right.IsInt() ? static_cast(right.GetInt()) : right.GetDouble(); bool ret = JSTaggedValue::StrictNumberCompare(valueA, valueB) <= ComparisonResult::EQUAL; - SET_ACC(ret ? JSTaggedValue::True() : JSTaggedValue::False()) + SET_ACC(ret ? JSTaggedValue::True() : JSTaggedValue::False()); } else if (left.IsBigInt() && right.IsBigInt()) { bool result = BigInt::LessThan(left, right) || BigInt::Equal(left, right); SET_ACC(JSTaggedValue(result)); } else { // slow path - JSTaggedValue res = SlowRuntimeStub::LessEqDyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::LessEq(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(LESSEQ_IMM8_V8); } -void InterpreterAssembly::HandleGreaterDynPrefV8( +void InterpreterAssembly::HandleGreaterImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::greaterdyn" + LOG_INST() << "intrinsics::greater" << " v" << v0; JSTaggedValue left = GET_VREG_VALUE(v0); JSTaggedValue right = acc; @@ -1308,25 +1309,25 @@ void InterpreterAssembly::HandleGreaterDynPrefV8( double valueA = left.IsInt() ? static_cast(left.GetInt()) : left.GetDouble(); double valueB = right.IsInt() ? static_cast(right.GetInt()) : right.GetDouble(); bool ret = JSTaggedValue::StrictNumberCompare(valueA, valueB) == ComparisonResult::GREAT; - SET_ACC(ret ? JSTaggedValue::True() : JSTaggedValue::False()) + SET_ACC(ret ? JSTaggedValue::True() : JSTaggedValue::False()); } else if (left.IsBigInt() && right.IsBigInt()) { bool result = BigInt::LessThan(right, left); SET_ACC(JSTaggedValue(result)); } else { // slow path - JSTaggedValue res = SlowRuntimeStub::GreaterDyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::Greater(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(GREATER_IMM8_V8); } -void InterpreterAssembly::HandleGreaterEqDynPrefV8( +void InterpreterAssembly::HandleGreaterEqImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t vs = READ_INST_8_1(); - LOG_INST() << "intrinsics::greateqdyn " + LOG_INST() << "intrinsics::greateq " << " v" << vs; JSTaggedValue left = GET_VREG_VALUE(vs); JSTaggedValue right = GET_ACC(); @@ -1340,26 +1341,26 @@ void InterpreterAssembly::HandleGreaterEqDynPrefV8( double valueB = right.IsInt() ? static_cast(right.GetInt()) : right.GetDouble(); ComparisonResult comparison = JSTaggedValue::StrictNumberCompare(valueA, valueB); bool ret = (comparison == ComparisonResult::GREAT) || (comparison == ComparisonResult::EQUAL); - SET_ACC(ret ? JSTaggedValue::True() : JSTaggedValue::False()) + SET_ACC(ret ? JSTaggedValue::True() : JSTaggedValue::False()); } else if (left.IsBigInt() && right.IsBigInt()) { bool result = BigInt::LessThan(right, left) || BigInt::Equal(right, left); - SET_ACC(JSTaggedValue(result)) + SET_ACC(JSTaggedValue(result)); } else { // slow path - JSTaggedValue res = SlowRuntimeStub::GreaterEqDyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::GreaterEq(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(GREATEREQ_IMM8_V8); } -void InterpreterAssembly::HandleShl2DynPrefV8( +void InterpreterAssembly::HandleShl2Imm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::shl2dyn" + LOG_INST() << "intrinsics::shl2" << " v" << v0; int32_t opNumber0; int32_t opNumber1; @@ -1392,16 +1393,16 @@ void InterpreterAssembly::HandleShl2DynPrefV8( using unsigned_type = std::make_unsigned_t; auto ret = static_cast(static_cast(opNumber0) << shift); // NOLINT(hicpp-signed-bitwise) - SET_ACC(JSTaggedValue(ret)) - DISPATCH(BytecodeInstruction::Format::PREF_V8); + SET_ACC(JSTaggedValue(ret)); + DISPATCH(SHL2_IMM8_V8); } -void InterpreterAssembly::HandleShr2DynPrefV8( +void InterpreterAssembly::HandleShr2Imm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::shr2dyn" + LOG_INST() << "intrinsics::shr2" << " v" << v0; JSTaggedValue left = GET_VREG_VALUE(v0); JSTaggedValue right = GET_ACC(); @@ -1414,7 +1415,7 @@ void InterpreterAssembly::HandleShr2DynPrefV8( using unsigned_type = std::make_unsigned_t; auto ret = static_cast(static_cast(opNumber0) >> shift); // NOLINT(hicpp-signed-bitwise) - SET_ACC(JSTaggedValue(ret)) + SET_ACC(JSTaggedValue(ret)); } else if (left.IsNumber() && right.IsNumber()) { int32_t opNumber0 = left.IsInt() ? left.GetInt() : base::NumberHelper::DoubleToInt(left.GetDouble(), base::INT32_BITS); @@ -1425,23 +1426,23 @@ void InterpreterAssembly::HandleShr2DynPrefV8( using unsigned_type = std::make_unsigned_t; auto ret = static_cast(static_cast(opNumber0) >> shift); // NOLINT(hicpp-signed-bitwise) - SET_ACC(JSTaggedValue(ret)) + SET_ACC(JSTaggedValue(ret)); } else { // slow path SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::Shr2Dyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::Shr2(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(SHR2_IMM8_V8); } -void InterpreterAssembly::HandleAshr2DynPrefV8( +void InterpreterAssembly::HandleAshr2Imm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::ashr2dyn" + LOG_INST() << "intrinsics::ashr2" << " v" << v0; JSTaggedValue left = GET_VREG_VALUE(v0); JSTaggedValue right = GET_ACC(); @@ -1452,7 +1453,7 @@ void InterpreterAssembly::HandleAshr2DynPrefV8( uint32_t shift = static_cast(opNumber1) & 0x1f; // NOLINT(hicpp-signed-bitwise, readability-magic-numbers) auto ret = static_cast(opNumber0 >> shift); // NOLINT(hicpp-signed-bitwise) - SET_ACC(JSTaggedValue(ret)) + SET_ACC(JSTaggedValue(ret)); } else if (left.IsNumber() && right.IsNumber()) { int32_t opNumber0 = left.IsInt() ? left.GetInt() : base::NumberHelper::DoubleToInt(left.GetDouble(), base::INT32_BITS); @@ -1461,24 +1462,24 @@ void InterpreterAssembly::HandleAshr2DynPrefV8( uint32_t shift = static_cast(opNumber1) & 0x1f; // NOLINT(hicpp-signed-bitwise, readability-magic-numbers) auto ret = static_cast(opNumber0 >> shift); // NOLINT(hicpp-signed-bitwise) - SET_ACC(JSTaggedValue(ret)) + SET_ACC(JSTaggedValue(ret)); } else { // slow path SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::Ashr2Dyn(thread, left, right); + JSTaggedValue res = SlowRuntimeStub::Ashr2(thread, left, right); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(ASHR2_IMM8_V8); } -void InterpreterAssembly::HandleAnd2DynPrefV8( +void InterpreterAssembly::HandleAnd2Imm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::and2dyn" + LOG_INST() << "intrinsics::and2" << " v" << v0; int32_t opNumber0; int32_t opNumber1; @@ -1507,17 +1508,17 @@ void InterpreterAssembly::HandleAnd2DynPrefV8( } // NOLINT(hicpp-signed-bitwise) auto ret = static_cast(opNumber0) & static_cast(opNumber1); - SET_ACC(JSTaggedValue(static_cast(ret))) - DISPATCH(BytecodeInstruction::Format::PREF_V8); + SET_ACC(JSTaggedValue(static_cast(ret))); + DISPATCH(AND2_IMM8_V8); } -void InterpreterAssembly::HandleOr2DynPrefV8( +void InterpreterAssembly::HandleOr2Imm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::or2dyn" + LOG_INST() << "intrinsics::or2" << " v" << v0; int32_t opNumber0; int32_t opNumber1; @@ -1546,17 +1547,17 @@ void InterpreterAssembly::HandleOr2DynPrefV8( } // NOLINT(hicpp-signed-bitwise) auto ret = static_cast(opNumber0) | static_cast(opNumber1); - SET_ACC(JSTaggedValue(static_cast(ret))) - DISPATCH(BytecodeInstruction::Format::PREF_V8); + SET_ACC(JSTaggedValue(static_cast(ret))); + DISPATCH(OR2_IMM8_V8); } -void InterpreterAssembly::HandleXOr2DynPrefV8( +void InterpreterAssembly::HandleXOr2Imm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::xor2dyn" + LOG_INST() << "intrinsics::xor2" << " v" << v0; int32_t opNumber0; int32_t opNumber1; @@ -1585,16 +1586,16 @@ void InterpreterAssembly::HandleXOr2DynPrefV8( } // NOLINT(hicpp-signed-bitwise) auto ret = static_cast(opNumber0) ^ static_cast(opNumber1); - SET_ACC(JSTaggedValue(static_cast(ret))) - DISPATCH(BytecodeInstruction::Format::PREF_V8); + SET_ACC(JSTaggedValue(static_cast(ret))); + DISPATCH(XOR2_IMM8_V8); } -void InterpreterAssembly::HandleDelObjPropPrefV8V8( +void InterpreterAssembly::HandleDelObjPropV8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); LOG_INST() << "intrinsics::delobjprop" << " v0" << v0 << " v1" << v1; @@ -1604,23 +1605,23 @@ void InterpreterAssembly::HandleDelObjPropPrefV8V8( INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(DELOBJPROP_V8_V8); } -void InterpreterAssembly::HandleDefineFuncDynPrefId16Imm16V8( +void InterpreterAssembly::HandleDefineFuncImm8Id16Imm16V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t methodId = READ_INST_16_1(); uint16_t length = READ_INST_16_3(); uint16_t v0 = READ_INST_8_5(); - LOG_INST() << "intrinsics::definefuncDyn length: " << length + LOG_INST() << "intrinsics::definefunc length: " << length << " v" << v0; JSFunction *result = JSFunction::Cast( ConstantPool::Cast(constpool.GetTaggedObject())->GetObjectFromCache(methodId).GetTaggedObject()); ASSERT(result != nullptr); if (result->GetResolved()) { - auto res = SlowRuntimeStub::DefinefuncDyn(thread, result); + auto res = SlowRuntimeStub::Definefunc(thread, result); INTERPRETER_RETURN_IF_ABRUPT(res); result = JSFunction::Cast(res.GetTaggedObject()); } else { @@ -1633,12 +1634,12 @@ void InterpreterAssembly::HandleDefineFuncDynPrefId16Imm16V8( JSFunction *currentFunc = JSFunction::Cast((GET_ASM_FRAME(sp)->function).GetTaggedObject()); result->SetModule(thread, currentFunc->GetModule()); - SET_ACC(JSTaggedValue(result)) + SET_ACC(JSTaggedValue(result)); - DISPATCH(BytecodeInstruction::Format::PREF_ID16_IMM16_V8); + DISPATCH(DEFINEFUNC_IMM8_ID16_IMM16_V8); } -void InterpreterAssembly::HandleDefineNCFuncDynPrefId16Imm16V8( +void InterpreterAssembly::HandleDefineNCFuncImm8Id16Imm16V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -1646,14 +1647,14 @@ void InterpreterAssembly::HandleDefineNCFuncDynPrefId16Imm16V8( uint16_t length = READ_INST_16_3(); uint16_t v0 = READ_INST_8_5(); JSTaggedValue homeObject = GET_ACC(); - LOG_INST() << "intrinsics::definencfuncDyn length: " << length + LOG_INST() << "intrinsics::definencfunc length: " << length << " v" << v0; JSFunction *result = JSFunction::Cast( ConstantPool::Cast(constpool.GetTaggedObject())->GetObjectFromCache(methodId).GetTaggedObject()); ASSERT(result != nullptr); if (result->GetResolved()) { SAVE_ACC(); - auto res = SlowRuntimeStub::DefineNCFuncDyn(thread, result); + auto res = SlowRuntimeStub::DefineNCFunc(thread, result); INTERPRETER_RETURN_IF_ABRUPT(res); result = JSFunction::Cast(res.GetTaggedObject()); RESTORE_ACC(); @@ -1671,10 +1672,10 @@ void InterpreterAssembly::HandleDefineNCFuncDynPrefId16Imm16V8( result->SetModule(thread, currentFunc->GetModule()); SET_ACC(JSTaggedValue(result)); - DISPATCH(BytecodeInstruction::Format::PREF_ID16_IMM16_V8); + DISPATCH(DEFINENCFUNC_IMM8_ID16_IMM16_V8); } -void InterpreterAssembly::HandleDefineMethodPrefId16Imm16V8( +void InterpreterAssembly::HandleDefineMethodImm8Id16Imm16V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -1704,16 +1705,16 @@ void InterpreterAssembly::HandleDefineMethodPrefId16Imm16V8( result->SetModule(thread, currentFunc->GetModule()); SET_ACC(JSTaggedValue(result)); - DISPATCH(BytecodeInstruction::Format::PREF_ID16_IMM16_V8); + DISPATCH(DEFINEMETHOD_IMM8_ID16_IMM16_V8); } -void InterpreterAssembly::HandleNewObjDynRangePrefImm16V8( +void InterpreterAssembly::HandleNewObjRangeImm8Imm16V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t numArgs = READ_INST_16_1(); uint16_t firstArgRegIdx = READ_INST_8_3(); - LOG_INST() << "intrinsics::newobjDynrange " << numArgs << " v" << firstArgRegIdx; + LOG_INST() << "intrinsics::newobjRange " << numArgs << " v" << firstArgRegIdx; JSTaggedValue ctor = GET_VREG_VALUE(firstArgRegIdx); // slow path @@ -1724,18 +1725,18 @@ void InterpreterAssembly::HandleNewObjDynRangePrefImm16V8( uint16_t length = numArgs - firstArgOffset; SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::NewObjDynRange(thread, ctor, newTarget, firstArgIdx, length); + JSTaggedValue res = SlowRuntimeStub::NewObjRange(thread, ctor, newTarget, firstArgIdx, length); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16_V8); + DISPATCH(NEWOBJRANGE_IMM8_IMM16_V8); } -void InterpreterAssembly::HandleExpDynPrefV8( +void InterpreterAssembly::HandleExpImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::expdyn" + LOG_INST() << "intrinsics::exp" << " v" << v0; JSTaggedValue base = GET_VREG_VALUE(v0); JSTaggedValue exponent = GET_ACC(); @@ -1761,44 +1762,44 @@ void InterpreterAssembly::HandleExpDynPrefV8( SET_ACC(JSTaggedValue(std::pow(doubleBase, doubleExponent))); } else { // slow path - JSTaggedValue res = SlowRuntimeStub::ExpDyn(thread, base, exponent); + JSTaggedValue res = SlowRuntimeStub::Exp(thread, base, exponent); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(EXP_IMM8_V8); } -void InterpreterAssembly::HandleIsInDynPrefV8( +void InterpreterAssembly::HandleIsInImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::isindyn" + LOG_INST() << "intrinsics::isin" << " v" << v0; JSTaggedValue prop = GET_VREG_VALUE(v0); JSTaggedValue obj = GET_ACC(); - JSTaggedValue res = SlowRuntimeStub::IsInDyn(thread, prop, obj); + JSTaggedValue res = SlowRuntimeStub::IsIn(thread, prop, obj); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(ISIN_IMM8_V8); } -void InterpreterAssembly::HandleInstanceOfDynPrefV8( +void InterpreterAssembly::HandleInstanceOfImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - LOG_INST() << "intrinsics::instanceofdyn" + LOG_INST() << "intrinsics::instanceof" << " v" << v0; JSTaggedValue obj = GET_VREG_VALUE(v0); JSTaggedValue target = GET_ACC(); - JSTaggedValue res = SlowRuntimeStub::InstanceofDyn(thread, obj, target); + JSTaggedValue res = SlowRuntimeStub::Instanceof(thread, obj, target); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(INSTANCEOF_IMM8_V8); } -void InterpreterAssembly::HandleStrictNotEqDynPrefV8( +void InterpreterAssembly::HandleStrictNotEqImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -1809,10 +1810,10 @@ void InterpreterAssembly::HandleStrictNotEqDynPrefV8( JSTaggedValue right = GET_ACC(); bool res = FastRuntimeStub::FastStrictEqual(left, right); SET_ACC(JSTaggedValue(!res)); - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(STRICTNOTEQ_IMM8_V8); } -void InterpreterAssembly::HandleStrictEqDynPrefV8( +void InterpreterAssembly::HandleStrictEqImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -1823,17 +1824,17 @@ void InterpreterAssembly::HandleStrictEqDynPrefV8( JSTaggedValue right = GET_ACC(); bool res = FastRuntimeStub::FastStrictEqual(left, right); SET_ACC(JSTaggedValue(res)); - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(STRICTEQ_IMM8_V8); } -void InterpreterAssembly::HandleLdLexVarDynPrefImm16Imm16( +void InterpreterAssembly::HandleLdLexVarImm16Imm16( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t level = READ_INST_16_1(); - uint16_t slot = READ_INST_16_3(); + uint16_t level = READ_INST_16_0(); + uint16_t slot = READ_INST_16_2(); - LOG_INST() << "intrinsics::ldlexvardyn" + LOG_INST() << "intrinsics::ldlexvar" << " level:" << level << " slot:" << slot; AsmInterpretedFrame *state = GET_ASM_FRAME(sp); JSTaggedValue currentLexenv = state->env; @@ -1844,17 +1845,17 @@ void InterpreterAssembly::HandleLdLexVarDynPrefImm16Imm16( env = taggedParentEnv; } SET_ACC(LexicalEnv::Cast(env.GetTaggedObject())->GetProperties(slot)); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16_IMM16); + DISPATCH(LDLEXVAR_IMM16_IMM16); } -void InterpreterAssembly::HandleLdLexVarDynPrefImm8Imm8( +void InterpreterAssembly::HandleLdLexVarImm8Imm8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t level = READ_INST_8_1(); - uint16_t slot = READ_INST_8_2(); + uint16_t level = READ_INST_8_0(); + uint16_t slot = READ_INST_8_1(); - LOG_INST() << "intrinsics::ldlexvardyn" + LOG_INST() << "intrinsics::ldlexvar" << " level:" << level << " slot:" << slot; AsmInterpretedFrame *state = GET_ASM_FRAME(sp); JSTaggedValue currentLexenv = state->env; @@ -1865,17 +1866,17 @@ void InterpreterAssembly::HandleLdLexVarDynPrefImm8Imm8( env = taggedParentEnv; } SET_ACC(LexicalEnv::Cast(env.GetTaggedObject())->GetProperties(slot)); - DISPATCH(BytecodeInstruction::Format::PREF_IMM8_IMM8); + DISPATCH(LDLEXVAR_IMM8_IMM8); } -void InterpreterAssembly::HandleLdLexVarDynPrefImm4Imm4( +void InterpreterAssembly::HandleLdLexVarImm4Imm4( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t level = READ_INST_4_2(); - uint16_t slot = READ_INST_4_3(); + uint16_t level = READ_INST_4_0(); + uint16_t slot = READ_INST_4_1(); - LOG_INST() << "intrinsics::ldlexvardyn" + LOG_INST() << "intrinsics::ldlexvar" << " level:" << level << " slot:" << slot; AsmInterpretedFrame *state = GET_ASM_FRAME(sp); JSTaggedValue currentLexenv = state->env; @@ -1886,17 +1887,17 @@ void InterpreterAssembly::HandleLdLexVarDynPrefImm4Imm4( env = taggedParentEnv; } SET_ACC(LexicalEnv::Cast(env.GetTaggedObject())->GetProperties(slot)); - DISPATCH(BytecodeInstruction::Format::PREF_IMM4_IMM4); + DISPATCH(LDLEXVAR_IMM4_IMM4); } -void InterpreterAssembly::HandleStLexVarDynPrefImm16Imm16V8( +void InterpreterAssembly::HandleStLexVarImm16Imm16V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t level = READ_INST_16_1(); - uint16_t slot = READ_INST_16_3(); - uint16_t v0 = READ_INST_8_5(); - LOG_INST() << "intrinsics::stlexvardyn" + uint16_t level = READ_INST_16_0(); + uint16_t slot = READ_INST_16_2(); + uint16_t v0 = READ_INST_8_4(); + LOG_INST() << "intrinsics::stlexvar" << " level:" << level << " slot:" << slot << " v" << v0; JSTaggedValue value = GET_VREG_VALUE(v0); @@ -1909,17 +1910,17 @@ void InterpreterAssembly::HandleStLexVarDynPrefImm16Imm16V8( } LexicalEnv::Cast(env.GetTaggedObject())->SetProperties(thread, slot, value); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16_IMM16_V8); + DISPATCH(STLEXVAR_IMM16_IMM16_V8); } -void InterpreterAssembly::HandleStLexVarDynPrefImm8Imm8V8( +void InterpreterAssembly::HandleStLexVarImm8Imm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t level = READ_INST_8_1(); - uint16_t slot = READ_INST_8_2(); - uint16_t v0 = READ_INST_8_3(); - LOG_INST() << "intrinsics::stlexvardyn" + uint16_t level = READ_INST_8_0(); + uint16_t slot = READ_INST_8_1(); + uint16_t v0 = READ_INST_8_2(); + LOG_INST() << "intrinsics::stlexvar" << " level:" << level << " slot:" << slot << " v" << v0; JSTaggedValue value = GET_VREG_VALUE(v0); @@ -1932,17 +1933,17 @@ void InterpreterAssembly::HandleStLexVarDynPrefImm8Imm8V8( } LexicalEnv::Cast(env.GetTaggedObject())->SetProperties(thread, slot, value); - DISPATCH(BytecodeInstruction::Format::PREF_IMM8_IMM8_V8); + DISPATCH(STLEXVAR_IMM8_IMM8_V8); } -void InterpreterAssembly::HandleStLexVarDynPrefImm4Imm4V8( +void InterpreterAssembly::HandleStLexVarImm4Imm4V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t level = READ_INST_4_2(); - uint16_t slot = READ_INST_4_3(); - uint16_t v0 = READ_INST_8_2(); - LOG_INST() << "intrinsics::stlexvardyn" + uint16_t level = READ_INST_4_0(); + uint16_t slot = READ_INST_4_1(); + uint16_t v0 = READ_INST_8_1(); + LOG_INST() << "intrinsics::stlexvar" << " level:" << level << " slot:" << slot << " v" << v0; JSTaggedValue value = GET_VREG_VALUE(v0); @@ -1955,29 +1956,29 @@ void InterpreterAssembly::HandleStLexVarDynPrefImm4Imm4V8( } LexicalEnv::Cast(env.GetTaggedObject())->SetProperties(thread, slot, value); - DISPATCH(BytecodeInstruction::Format::PREF_IMM4_IMM4_V8); + DISPATCH(STLEXVAR_IMM4_IMM4_V8); } -void InterpreterAssembly::HandleNewLexEnvDynPrefImm16( +void InterpreterAssembly::HandleNewLexEnvImm8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t numVars = READ_INST_16_1(); - LOG_INST() << "intrinsics::newlexenvdyn" + uint8_t numVars = READ_INST_8_0(); + LOG_INST() << "intrinsics::newlexenv" << " imm " << numVars; EcmaVM *ecmaVm = thread->GetEcmaVM(); ObjectFactory *factory = ecmaVm->GetFactory(); - JSTaggedValue res = FastRuntimeStub::NewLexicalEnvDyn(thread, factory, numVars); + JSTaggedValue res = FastRuntimeStub::NewLexicalEnv(thread, factory, numVars); if (res.IsHole()) { - res = SlowRuntimeStub::NewLexicalEnvDyn(thread, numVars); + res = SlowRuntimeStub::NewLexicalEnv(thread, numVars); INTERPRETER_RETURN_IF_ABRUPT(res); } SET_ACC(res); GET_ASM_FRAME(sp)->env = res; - DISPATCH(BytecodeInstruction::Format::PREF_IMM16); + DISPATCH(NEWLEXENV_IMM8); } -void InterpreterAssembly::HandlePopLexEnvDynPref( +void InterpreterAssembly::HandlePopLexEnv( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -1985,15 +1986,15 @@ void InterpreterAssembly::HandlePopLexEnvDynPref( JSTaggedValue currentLexenv = state->env; JSTaggedValue parentLexenv = LexicalEnv::Cast(currentLexenv.GetTaggedObject())->GetParentEnv(); GET_ASM_FRAME(sp)->env = parentLexenv; - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(POPLEXENV); } -void InterpreterAssembly::HandleCreateIterResultObjPrefV8V8( +void InterpreterAssembly::HandleCreateIterResultObjV8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); LOG_INST() << "intrinsics::createiterresultobj" << " v" << v0 << " v" << v1; JSTaggedValue value = GET_VREG_VALUE(v0); @@ -2001,15 +2002,15 @@ void InterpreterAssembly::HandleCreateIterResultObjPrefV8V8( JSTaggedValue res = SlowRuntimeStub::CreateIterResultObj(thread, value, flag); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(CREATEITERRESULTOBJ_V8_V8); } -void InterpreterAssembly::HandleSuspendGeneratorPrefV8V8( +void InterpreterAssembly::HandleSuspendGeneratorV8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); LOG_INST() << "intrinsics::suspendgenerator" << " v" << v0 << " v" << v1; JSTaggedValue genObj = GET_VREG_VALUE(v0); @@ -2043,12 +2044,12 @@ void InterpreterAssembly::HandleSuspendGeneratorPrefV8V8( DISPATCH_OFFSET(prevState->callSize); } -void InterpreterAssembly::HandleAsyncFunctionAwaitUncaughtPrefV8V8( +void InterpreterAssembly::HandleAsyncFunctionAwaitUncaughtV8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); LOG_INST() << "intrinsics::asyncfunctionawaituncaught" << " v" << v0 << " v" << v1; JSTaggedValue asyncFuncObj = GET_VREG_VALUE(v0); @@ -2056,16 +2057,16 @@ void InterpreterAssembly::HandleAsyncFunctionAwaitUncaughtPrefV8V8( JSTaggedValue res = SlowRuntimeStub::AsyncFunctionAwaitUncaught(thread, asyncFuncObj, value); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(ASYNCFUNCTIONAWAITUNCAUGHT_V8_V8); } -void InterpreterAssembly::HandleAsyncFunctionResolvePrefV8V8V8( +void InterpreterAssembly::HandleAsyncFunctionResolveV8V8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t v0 = READ_INST_8_1(); - [[maybe_unused]] uint16_t v1 = READ_INST_8_2(); - uint16_t v2 = READ_INST_8_3(); + uint16_t v0 = READ_INST_8_0(); + [[maybe_unused]] uint16_t v1 = READ_INST_8_1(); + uint16_t v2 = READ_INST_8_2(); LOG_INST() << "intrinsics::asyncfunctionresolve" << " v" << v0 << " v" << v1 << " v" << v2; @@ -2074,16 +2075,16 @@ void InterpreterAssembly::HandleAsyncFunctionResolvePrefV8V8V8( JSTaggedValue res = SlowRuntimeStub::AsyncFunctionResolveOrReject(thread, asyncFuncObj, value, true); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8_V8); + DISPATCH(ASYNCFUNCTIONRESOLVE_V8_V8_V8); } -void InterpreterAssembly::HandleAsyncFunctionRejectPrefV8V8V8( +void InterpreterAssembly::HandleAsyncFunctionRejectV8V8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t v0 = READ_INST_8_1(); - [[maybe_unused]] uint16_t v1 = READ_INST_8_2(); - uint16_t v2 = READ_INST_8_3(); + uint16_t v0 = READ_INST_8_0(); + [[maybe_unused]] uint16_t v1 = READ_INST_8_1(); + uint16_t v2 = READ_INST_8_2(); LOG_INST() << "intrinsics::asyncfunctionreject" << " v" << v0 << " v" << v1 << " v" << v2; @@ -2092,37 +2093,35 @@ void InterpreterAssembly::HandleAsyncFunctionRejectPrefV8V8V8( JSTaggedValue res = SlowRuntimeStub::AsyncFunctionResolveOrReject(thread, asyncFuncObj, value, false); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8_V8); + DISPATCH(ASYNCFUNCTIONREJECT_V8_V8_V8); } -void InterpreterAssembly::HandleNewObjSpreadDynPrefV8V8( +void InterpreterAssembly::HandleNewObjApplyImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - LOG_INST() << "intrinsic::newobjspearddyn" - << " v" << v0 << " v" << v1; + LOG_INST() << "intrinsic::newobjspeard" + << " v" << v0; JSTaggedValue func = GET_VREG_VALUE(v0); - JSTaggedValue newTarget = GET_VREG_VALUE(v1); JSTaggedValue array = GET_ACC(); - JSTaggedValue res = SlowRuntimeStub::NewObjSpreadDyn(thread, func, newTarget, array); + JSTaggedValue res = SlowRuntimeStub::NewObjApply(thread, func, array); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(NEWOBJSPREAD_IMM8_V8_V8); } -void InterpreterAssembly::HandleThrowUndefinedIfHolePrefV8V8( +void InterpreterAssembly::HandleThrowUndefinedIfHoleV8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); LOG_INST() << "intrinsic::throwundefinedifhole" << " v" << v0 << " v" << v1; JSTaggedValue hole = GET_VREG_VALUE(v0); if (!hole.IsHole()) { - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(THROWUNDEFINEDIFHOLE_V8_V8); } JSTaggedValue obj = GET_VREG_VALUE(v1); ASSERT(obj.IsString()); @@ -2130,12 +2129,12 @@ void InterpreterAssembly::HandleThrowUndefinedIfHolePrefV8V8( INTERPRETER_GOTO_EXCEPTION_HANDLER(); } -void InterpreterAssembly::HandleStOwnByNamePrefId32V8( +void InterpreterAssembly::HandleStOwnByNameImm8Id16V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint32_t stringId = READ_INST_32_1(); - uint32_t v0 = READ_INST_8_5(); + uint16_t stringId = READ_INST_16_1(); + uint32_t v0 = READ_INST_8_3(); LOG_INST() << "intrinsics::stownbyname " << "v" << v0 << " stringId:" << stringId; @@ -2149,7 +2148,7 @@ void InterpreterAssembly::HandleStOwnByNamePrefId32V8( if (!res.IsHole()) { INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); + DISPATCH(STOWNBYNAME_IMM8_ID16_V8); } RESTORE_ACC(); } @@ -2160,10 +2159,10 @@ void InterpreterAssembly::HandleStOwnByNamePrefId32V8( JSTaggedValue res = SlowRuntimeStub::StOwnByName(thread, receiver, propKey, value); RESTORE_ACC(); INTERPRETER_RETURN_IF_ABRUPT(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); + DISPATCH(STOWNBYNAME_IMM8_ID16_V8); } -void InterpreterAssembly::HandleCreateEmptyArrayPref( +void InterpreterAssembly::HandleCreateEmptyArrayImm8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -2173,10 +2172,10 @@ void InterpreterAssembly::HandleCreateEmptyArrayPref( ObjectFactory *factory = ecmaVm->GetFactory(); JSTaggedValue res = SlowRuntimeStub::CreateEmptyArray(thread, factory, globalEnv); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(CREATEEMPTYARRAY_IMM8); } -void InterpreterAssembly::HandleCreateEmptyObjectPref( +void InterpreterAssembly::HandleCreateEmptyObject( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -2186,10 +2185,10 @@ void InterpreterAssembly::HandleCreateEmptyObjectPref( ObjectFactory *factory = ecmaVm->GetFactory(); JSTaggedValue res = SlowRuntimeStub::CreateEmptyObject(thread, factory, globalEnv); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(CREATEEMPTYOBJECT); } -void InterpreterAssembly::HandleCreateObjectWithBufferPrefImm16( +void InterpreterAssembly::HandleCreateObjectWithBufferImm8Imm16( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -2203,10 +2202,10 @@ void InterpreterAssembly::HandleCreateObjectWithBufferPrefImm16( JSTaggedValue res = SlowRuntimeStub::CreateObjectWithBuffer(thread, factory, result); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16); + DISPATCH(CREATEOBJECTWITHBUFFER_IMM8_IMM16); } -void InterpreterAssembly::HandleSetObjectWithProtoPrefV8V8( +void InterpreterAssembly::HandleSetObjectWithProtoImm8V8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -2220,10 +2219,10 @@ void InterpreterAssembly::HandleSetObjectWithProtoPrefV8V8( JSTaggedValue res = SlowRuntimeStub::SetObjectWithProto(thread, proto, obj); INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(SETOBJECTWITHPROTO_IMM8_V8_V8); } -void InterpreterAssembly::HandleCreateArrayWithBufferPrefImm16( +void InterpreterAssembly::HandleCreateArrayWithBufferImm8Imm16( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -2237,14 +2236,14 @@ void InterpreterAssembly::HandleCreateArrayWithBufferPrefImm16( JSTaggedValue res = SlowRuntimeStub::CreateArrayWithBuffer(thread, factory, result); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16); + DISPATCH(CREATEARRAYWITHBUFFER_IMM8_IMM16); } -void InterpreterAssembly::HandleGetModuleNamespacePrefId32( +void InterpreterAssembly::HandleGetModuleNamespaceId16( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint32_t stringId = READ_INST_32_1(); + uint16_t stringId = READ_INST_16_0(); auto localName = ConstantPool::Cast(constpool.GetTaggedObject())->GetObjectFromCache(stringId); LOG_INST() << "intrinsics::getmodulenamespace " @@ -2253,14 +2252,14 @@ void InterpreterAssembly::HandleGetModuleNamespacePrefId32( JSTaggedValue moduleNamespace = SlowRuntimeStub::GetModuleNamespace(thread, localName); INTERPRETER_RETURN_IF_ABRUPT(moduleNamespace); SET_ACC(moduleNamespace); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + DISPATCH(GETMODULENAMESPACE_ID16); } -void InterpreterAssembly::HandleStModuleVarPrefId32( +void InterpreterAssembly::HandleStModuleVarId16( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint32_t stringId = READ_INST_32_1(); + uint16_t stringId = READ_INST_16_0(); auto key = ConstantPool::Cast(constpool.GetTaggedObject())->GetObjectFromCache(stringId); LOG_INST() << "intrinsics::stmodulevar " @@ -2271,22 +2270,15 @@ void InterpreterAssembly::HandleStModuleVarPrefId32( SAVE_ACC(); SlowRuntimeStub::StModuleVar(thread, key, value); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + DISPATCH(STMODULEVAR_ID16); } -void InterpreterAssembly::HandleCopyModulePrefV8( +void InterpreterAssembly::HandleLdModuleVarId16Imm8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - DISPATCH(BytecodeInstruction::Format::PREF_V8); -} - -void InterpreterAssembly::HandleLdModuleVarPrefId32Imm8( - JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, - JSTaggedValue acc, int16_t hotnessCounter) -{ - uint32_t stringId = READ_INST_32_1(); - uint8_t innerFlag = READ_INST_8_5(); + uint16_t stringId = READ_INST_16_0(); + uint8_t innerFlag = READ_INST_8_2(); JSTaggedValue key = ConstantPool::Cast(constpool.GetTaggedObject())->GetObjectFromCache(stringId); LOG_INST() << "intrinsics::ldmodulevar " @@ -2296,26 +2288,26 @@ void InterpreterAssembly::HandleLdModuleVarPrefId32Imm8( JSTaggedValue moduleVar = SlowRuntimeStub::LdModuleVar(thread, key, innerFlag != 0); INTERPRETER_RETURN_IF_ABRUPT(moduleVar); SET_ACC(moduleVar); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_IMM8); + DISPATCH(LDMODULEVAR_ID16_IMM8); } -void InterpreterAssembly::HandleCreateRegExpWithLiteralPrefId32Imm8( +void InterpreterAssembly::HandleCreateRegExpWithLiteralImm8Id16Imm8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint32_t stringId = READ_INST_32_1(); + uint16_t stringId = READ_INST_16_1(); JSTaggedValue pattern = ConstantPool::Cast(constpool.GetTaggedObject())->GetObjectFromCache(stringId); - uint8_t flags = READ_INST_8_5(); + uint8_t flags = READ_INST_8_3(); LOG_INST() << "intrinsics::createregexpwithliteral " << "stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(pattern.GetTaggedObject())) << ", flags:" << flags; JSTaggedValue res = SlowRuntimeStub::CreateRegExpWithLiteral(thread, pattern, flags); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_IMM8); + DISPATCH(CREATEREGEXPWITHLITERAL_IMM8_ID16_IMM8); } -void InterpreterAssembly::HandleGetTemplateObjectPrefV8( +void InterpreterAssembly::HandleGetTemplateObjectImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -2327,29 +2319,29 @@ void InterpreterAssembly::HandleGetTemplateObjectPrefV8( JSTaggedValue res = SlowRuntimeStub::GetTemplateObject(thread, literal); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(GETTEMPLATEOBJECT_IMM8_V8); } -void InterpreterAssembly::HandleGetNextPropNamePrefV8( +void InterpreterAssembly::HandleGetNextPropNameV8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t v0 = READ_INST_8_1(); + uint16_t v0 = READ_INST_8_0(); LOG_INST() << "intrinsic::getnextpropname" << " v" << v0; JSTaggedValue iter = GET_VREG_VALUE(v0); JSTaggedValue res = SlowRuntimeStub::GetNextPropName(thread, iter); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(GETNEXTPROPNAME_V8); } -void InterpreterAssembly::HandleCopyDataPropertiesPrefV8V8( +void InterpreterAssembly::HandleCopyDataPropertiesV8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); LOG_INST() << "intrinsic::copydataproperties" << " v" << v0 << " v" << v1; JSTaggedValue dst = GET_VREG_VALUE(v0); @@ -2357,10 +2349,10 @@ void InterpreterAssembly::HandleCopyDataPropertiesPrefV8V8( JSTaggedValue res = SlowRuntimeStub::CopyDataProperties(thread, dst, src); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(COPYDATAPROPERTIES_V8_V8); } -void InterpreterAssembly::HandleStOwnByIndexPrefV8Imm32( +void InterpreterAssembly::HandleStOwnByIndexImm8V8Imm32( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -2379,7 +2371,7 @@ void InterpreterAssembly::HandleStOwnByIndexPrefV8Imm32( if (!res.IsHole()) { INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_V8_IMM32); + DISPATCH(STOWNBYINDEX_IMM8_V8_IMM32); } RESTORE_ACC(); } @@ -2389,10 +2381,10 @@ void InterpreterAssembly::HandleStOwnByIndexPrefV8Imm32( JSTaggedValue res = SlowRuntimeStub::StOwnByIndex(thread, receiver, index, value); INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_V8_IMM32); + DISPATCH(STOWNBYINDEX_IMM8_V8_IMM32); } -void InterpreterAssembly::HandleStOwnByValuePrefV8V8( +void InterpreterAssembly::HandleStOwnByValueImm8V8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -2416,7 +2408,7 @@ void InterpreterAssembly::HandleStOwnByValuePrefV8V8( if (!res.IsHole()) { INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(STOWNBYVALUE_IMM8_V8_V8); } } @@ -2428,16 +2420,16 @@ void InterpreterAssembly::HandleStOwnByValuePrefV8V8( JSTaggedValue res = SlowRuntimeStub::StOwnByValue(thread, receiver, propKey, value); RESTORE_ACC(); INTERPRETER_RETURN_IF_ABRUPT(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(STOWNBYVALUE_IMM8_V8_V8); } -void InterpreterAssembly::HandleCreateObjectWithExcludedKeysPrefImm16V8V8( +void InterpreterAssembly::HandleCreateObjectWithExcludedKeysImm8V8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t numKeys = READ_INST_16_1(); - uint16_t v0 = READ_INST_8_3(); - uint16_t firstArgRegIdx = READ_INST_8_4(); + uint8_t numKeys = READ_INST_8_0(); + uint16_t v0 = READ_INST_8_1(); + uint16_t firstArgRegIdx = READ_INST_8_2(); LOG_INST() << "intrinsics::createobjectwithexcludedkeys " << numKeys << " v" << firstArgRegIdx; JSTaggedValue obj = GET_VREG_VALUE(v0); @@ -2445,10 +2437,10 @@ void InterpreterAssembly::HandleCreateObjectWithExcludedKeysPrefImm16V8V8( JSTaggedValue res = SlowRuntimeStub::CreateObjectWithExcludedKeys(thread, numKeys, obj, firstArgRegIdx); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16_V8_V8); + DISPATCH(CREATEOBJECTWITHEXCLUDEDKEYS_IMM8_V8_V8); } -void InterpreterAssembly::HandleDefineGeneratorFuncPrefId16Imm16V8( +void InterpreterAssembly::HandleDefineGeneratorFuncImm8Id16Imm16V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -2474,11 +2466,11 @@ void InterpreterAssembly::HandleDefineGeneratorFuncPrefId16Imm16V8( JSFunction *currentFunc = JSFunction::Cast((GET_ASM_FRAME(sp)->function).GetTaggedObject()); result->SetModule(thread, currentFunc->GetModule()); - SET_ACC(JSTaggedValue(result)) - DISPATCH(BytecodeInstruction::Format::PREF_ID16_IMM16_V8); + SET_ACC(JSTaggedValue(result)); + DISPATCH(DEFINEGENERATORFUNC_IMM8_ID16_IMM16_V8); } -void InterpreterAssembly::HandleDefineAsyncGeneratorFuncPrefId16Imm16V8( +void InterpreterAssembly::HandleDefineAsyncGeneratorFuncImm8Id16Imm16V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -2504,11 +2496,11 @@ void InterpreterAssembly::HandleDefineAsyncGeneratorFuncPrefId16Imm16V8( JSFunction *currentFunc = JSFunction::Cast((GET_ASM_FRAME(sp)->function).GetTaggedObject()); result->SetModule(thread, currentFunc->GetModule()); - SET_ACC(JSTaggedValue(result)) - DISPATCH(BytecodeInstruction::Format::PREF_ID16_IMM16_V8); + SET_ACC(JSTaggedValue(result)); + DISPATCH(DEFINEASYNCGENERATORFUNC_IMM8_ID16_IMM16_V8); } -void InterpreterAssembly::HandleDefineAsyncFuncPrefId16Imm16V8( +void InterpreterAssembly::HandleDefineAsyncFuncImm8Id16Imm16V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -2534,24 +2526,24 @@ void InterpreterAssembly::HandleDefineAsyncFuncPrefId16Imm16V8( JSFunction *currentFunc = JSFunction::Cast((GET_ASM_FRAME(sp)->function).GetTaggedObject()); result->SetModule(thread, currentFunc->GetModule()); - SET_ACC(JSTaggedValue(result)) - DISPATCH(BytecodeInstruction::Format::PREF_ID16_IMM16_V8); + SET_ACC(JSTaggedValue(result)); + DISPATCH(DEFINEASYNCFUNC_IMM8_ID16_IMM16_V8); } -void InterpreterAssembly::HandleLdHolePref( +void InterpreterAssembly::HandleLdHole( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { LOG_INST() << "intrinsic::ldhole"; SET_ACC(JSTaggedValue::Hole()); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(LDHOLE); } -void InterpreterAssembly::HandleCopyRestArgsPrefImm16( +void InterpreterAssembly::HandleCopyRestArgsImm16( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t restIdx = READ_INST_16_1(); + uint16_t restIdx = READ_INST_16_0(); LOG_INST() << "intrinsics::copyrestargs" << " index: " << restIdx; @@ -2561,17 +2553,17 @@ void InterpreterAssembly::HandleCopyRestArgsPrefImm16( JSTaggedValue res = SlowRuntimeStub::CopyRestArgs(thread, sp, restNumArgs, startIdx); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16); + DISPATCH(COPYRESTARGS_IMM16); } -void InterpreterAssembly::HandleDefineGetterSetterByValuePrefV8V8V8V8( +void InterpreterAssembly::HandleDefineGetterSetterByValueV8V8V8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - uint16_t v2 = READ_INST_8_3(); - uint16_t v3 = READ_INST_8_4(); + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); + uint16_t v2 = READ_INST_8_2(); + uint16_t v3 = READ_INST_8_3(); LOG_INST() << "intrinsics::definegettersetterbyvalue" << " v" << v0 << " v" << v1 << " v" << v2 << " v" << v3; @@ -2584,10 +2576,10 @@ void InterpreterAssembly::HandleDefineGetterSetterByValuePrefV8V8V8V8( SlowRuntimeStub::DefineGetterSetterByValue(thread, obj, prop, getter, setter, flag.ToBoolean()); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8_V8_V8); + DISPATCH(DEFINEGETTERSETTERBYVALUE_V8_V8_V8_V8); } -void InterpreterAssembly::HandleLdObjByIndexPrefV8Imm32( +void InterpreterAssembly::HandleLdObjByIndexImm8V8Imm32( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -2603,7 +2595,7 @@ void InterpreterAssembly::HandleLdObjByIndexPrefV8Imm32( if (!res.IsHole()) { INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_IMM32); + DISPATCH(LDOBJBYINDEX_IMM8_V8_IMM32); } } // not meet fast condition or fast path return hole, walk slow path @@ -2611,10 +2603,10 @@ void InterpreterAssembly::HandleLdObjByIndexPrefV8Imm32( JSTaggedValue res = SlowRuntimeStub::LdObjByIndex(thread, receiver, idx, false, JSTaggedValue::Undefined()); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_IMM32); + DISPATCH(LDOBJBYINDEX_IMM8_V8_IMM32); } -void InterpreterAssembly::HandleStObjByIndexPrefV8Imm32( +void InterpreterAssembly::HandleStObjByIndexImm8V8Imm32( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -2632,7 +2624,7 @@ void InterpreterAssembly::HandleStObjByIndexPrefV8Imm32( if (!res.IsHole()) { INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_V8_IMM32); + DISPATCH(STOBJBYINDEX_IMM8_V8_IMM32); } RESTORE_ACC(); } @@ -2643,10 +2635,10 @@ void InterpreterAssembly::HandleStObjByIndexPrefV8Imm32( JSTaggedValue res = SlowRuntimeStub::StObjByIndex(thread, receiver, index, value); INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_V8_IMM32); + DISPATCH(STOBJBYINDEX_IMM8_V8_IMM32); } -void InterpreterAssembly::HandleLdObjByValuePrefV8V8( +void InterpreterAssembly::HandleLdObjByValueImm8V8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -2677,7 +2669,7 @@ void InterpreterAssembly::HandleLdObjByValuePrefV8V8( if (LIKELY(!res.IsHole())) { INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(LDOBJBYVALUE_IMM8_V8_V8); } } #endif @@ -2688,17 +2680,17 @@ void InterpreterAssembly::HandleLdObjByValuePrefV8V8( ASSERT(!res.IsAccessor()); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(LDOBJBYVALUE_IMM8_V8_V8); } } // slow path JSTaggedValue res = SlowRuntimeStub::LdObjByValue(thread, receiver, propKey, false, JSTaggedValue::Undefined()); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(LDOBJBYVALUE_IMM8_V8_V8); } -void InterpreterAssembly::HandleStObjByValuePrefV8V8( +void InterpreterAssembly::HandleStObjByValueImm8V8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -2733,7 +2725,7 @@ void InterpreterAssembly::HandleStObjByValuePrefV8V8( if (LIKELY(!res.IsHole())) { INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(STOBJBYVALUE_IMM8_V8_V8); } } #endif @@ -2746,7 +2738,7 @@ void InterpreterAssembly::HandleStObjByValuePrefV8V8( if (!res.IsHole()) { INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(STOBJBYVALUE_IMM8_V8_V8); } RESTORE_ACC(); } @@ -2760,10 +2752,10 @@ void InterpreterAssembly::HandleStObjByValuePrefV8V8( INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); } - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(STOBJBYVALUE_IMM8_V8_V8); } -void InterpreterAssembly::HandleLdSuperByValuePrefV8V8( +void InterpreterAssembly::HandleLdSuperByValueImm8V8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -2780,10 +2772,10 @@ void InterpreterAssembly::HandleLdSuperByValuePrefV8V8( JSTaggedValue res = SlowRuntimeStub::LdSuperByValue(thread, receiver, propKey, thisFunc); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(LDSUPERBYVALUE_IMM8_V8_V8); } -void InterpreterAssembly::HandleStSuperByValuePrefV8V8( +void InterpreterAssembly::HandleStSuperByValueImm8V8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -2802,14 +2794,14 @@ void InterpreterAssembly::HandleStSuperByValuePrefV8V8( JSTaggedValue res = SlowRuntimeStub::StSuperByValue(thread, receiver, propKey, value, thisFunc); INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(STSUPERBYVALUE_IMM8_V8_V8); } -void InterpreterAssembly::HandleTryLdGlobalByNamePrefId32( +void InterpreterAssembly::HandleTryLdGlobalByNameImm8Id16( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint32_t stringId = READ_INST_32_1(); + uint16_t stringId = READ_INST_16_1(); auto prop = ConstantPool::Cast(constpool.GetTaggedObject())->GetObjectFromCache(stringId); LOG_INST() << "intrinsics::tryldglobalbyname " @@ -2827,7 +2819,7 @@ void InterpreterAssembly::HandleTryLdGlobalByNamePrefId32( globalObj, prop, slotId); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + DISPATCH(TRYLDGLOBALBYNAME_IMM8_ID16); } #endif @@ -2850,14 +2842,14 @@ void InterpreterAssembly::HandleTryLdGlobalByNamePrefId32( } } - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + DISPATCH(TRYLDGLOBALBYNAME_IMM8_ID16); } -void InterpreterAssembly::HandleTryStGlobalByNamePrefId32( +void InterpreterAssembly::HandleTryStGlobalByNameImm8Id16( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint32_t stringId = READ_INST_32_1(); + uint16_t stringId = READ_INST_16_1(); JSTaggedValue propKey = ConstantPool::Cast(constpool.GetTaggedObject())->GetObjectFromCache(stringId); LOG_INST() << "intrinsics::trystglobalbyname" << " stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())); @@ -2876,7 +2868,7 @@ void InterpreterAssembly::HandleTryStGlobalByNamePrefId32( globalObj, propKey, value, slotId); INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + DISPATCH(TRYSTGLOBALBYNAME_IMM8_ID16); } #endif @@ -2904,14 +2896,14 @@ void InterpreterAssembly::HandleTryStGlobalByNamePrefId32( INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); } - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + DISPATCH(TRYSTGLOBALBYNAME_IMM8_ID16); } -void InterpreterAssembly::HandleStConstToGlobalRecordPrefId32( +void InterpreterAssembly::HandleStConstToGlobalRecordId16( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint32_t stringId = READ_INST_32_1(); + uint16_t stringId = READ_INST_16_0(); JSTaggedValue propKey = ConstantPool::Cast(constpool.GetTaggedObject())->GetObjectFromCache(stringId); LOG_INST() << "intrinsics::stconsttoglobalrecord" << " stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())); @@ -2921,14 +2913,14 @@ void InterpreterAssembly::HandleStConstToGlobalRecordPrefId32( JSTaggedValue res = SlowRuntimeStub::StGlobalRecord(thread, propKey, value, true); INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + DISPATCH(STCONSTTOGLOBALRECORD_ID16); } -void InterpreterAssembly::HandleStLetToGlobalRecordPrefId32( +void InterpreterAssembly::HandleStLetToGlobalRecordId16( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint32_t stringId = READ_INST_32_1(); + uint16_t stringId = READ_INST_16_0(); JSTaggedValue propKey = ConstantPool::Cast(constpool.GetTaggedObject())->GetObjectFromCache(stringId); LOG_INST() << "intrinsics::stlettoglobalrecord" << " stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())); @@ -2938,14 +2930,14 @@ void InterpreterAssembly::HandleStLetToGlobalRecordPrefId32( JSTaggedValue res = SlowRuntimeStub::StGlobalRecord(thread, propKey, value, false); INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + DISPATCH(STLETTOGLOBALRECORD_ID16); } -void InterpreterAssembly::HandleStClassToGlobalRecordPrefId32( +void InterpreterAssembly::HandleStClassToGlobalRecordId16( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint32_t stringId = READ_INST_32_1(); + uint16_t stringId = READ_INST_16_0(); JSTaggedValue propKey = ConstantPool::Cast(constpool.GetTaggedObject())->GetObjectFromCache(stringId); LOG_INST() << "intrinsics::stclasstoglobalrecord" << " stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(propKey.GetTaggedObject())); @@ -2955,10 +2947,10 @@ void InterpreterAssembly::HandleStClassToGlobalRecordPrefId32( JSTaggedValue res = SlowRuntimeStub::StGlobalRecord(thread, propKey, value, false); INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + DISPATCH(STCLASSTOGLOBALRECORD_ID16); } -void InterpreterAssembly::HandleStOwnByValueWithNameSetPrefV8V8( +void InterpreterAssembly::HandleStOwnByValueWithNameSetImm8V8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -2982,7 +2974,7 @@ void InterpreterAssembly::HandleStOwnByValueWithNameSetPrefV8V8( INTERPRETER_RETURN_IF_ABRUPT(res); JSFunction::SetFunctionNameNoPrefix(thread, JSFunction::Cast(value.GetTaggedObject()), propKey); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(STOWNBYVALUEWITHNAMESET_IMM8_V8_V8); } } @@ -2994,15 +2986,15 @@ void InterpreterAssembly::HandleStOwnByValueWithNameSetPrefV8V8( JSTaggedValue res = SlowRuntimeStub::StOwnByValueWithNameSet(thread, receiver, propKey, value); RESTORE_ACC(); INTERPRETER_RETURN_IF_ABRUPT(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(STOWNBYVALUEWITHNAMESET_IMM8_V8_V8); } -void InterpreterAssembly::HandleStOwnByNameWithNameSetPrefId32V8( +void InterpreterAssembly::HandleStOwnByNameWithNameSetImm8Id16V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint32_t stringId = READ_INST_32_1(); - uint32_t v0 = READ_INST_8_5(); + uint16_t stringId = READ_INST_16_1(); + uint32_t v0 = READ_INST_8_3(); LOG_INST() << "intrinsics::stownbynamewithnameset " << "v" << v0 << " stringId:" << stringId; @@ -3017,7 +3009,7 @@ void InterpreterAssembly::HandleStOwnByNameWithNameSetPrefId32V8( INTERPRETER_RETURN_IF_ABRUPT(res); JSFunction::SetFunctionNameNoPrefix(thread, JSFunction::Cast(value.GetTaggedObject()), propKey); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); + DISPATCH(STOWNBYNAMEWITHNAMESET_IMM8_ID16_V8); } RESTORE_ACC(); } @@ -3029,30 +3021,19 @@ void InterpreterAssembly::HandleStOwnByNameWithNameSetPrefId32V8( JSTaggedValue res = SlowRuntimeStub::StOwnByNameWithNameSet(thread, receiver, propKey, value); RESTORE_ACC(); INTERPRETER_RETURN_IF_ABRUPT(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); + DISPATCH(STOWNBYNAMEWITHNAMESET_IMM8_ID16_V8); } -void InterpreterAssembly::HandleLdGlobalVarPrefId32( +void InterpreterAssembly::HandleLdGlobalVarId16( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint32_t stringId = READ_INST_32_1(); + uint32_t stringId = READ_INST_16_0(); JSTaggedValue propKey = ConstantPool::Cast(constpool.GetTaggedObject())->GetObjectFromCache(stringId); EcmaVM *ecmaVm = thread->GetEcmaVM(); JSHandle globalEnv = ecmaVm->GetGlobalEnv(); JSTaggedValue globalObj = globalEnv->GetGlobalObject(); -#if ECMASCRIPT_ENABLE_IC - if (!profileTypeInfo.IsUndefined()) { - uint16_t slotId = READ_INST_8_0(); - JSTaggedValue res = ICRuntimeStub::LoadGlobalICByName(thread, - ProfileTypeInfo::Cast( - profileTypeInfo.GetTaggedObject()), - globalObj, propKey, slotId); - INTERPRETER_RETURN_IF_ABRUPT(res); - SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); - } -#endif + JSTaggedValue result = FastRuntimeStub::GetGlobalOwnProperty(thread, globalObj, propKey); if (!result.IsHole()) { SET_ACC(result); @@ -3062,14 +3043,14 @@ void InterpreterAssembly::HandleLdGlobalVarPrefId32( INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + DISPATCH(LDGLOBALVAR_ID16); } -void InterpreterAssembly::HandleLdObjByNamePrefId32V8( +void InterpreterAssembly::HandleLdObjByNameImm8Id16V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint32_t v0 = READ_INST_8_5(); + uint32_t v0 = READ_INST_8_3(); JSTaggedValue receiver = GET_VREG_VALUE(v0); #if ECMASCRIPT_ENABLE_IC @@ -3085,7 +3066,7 @@ void InterpreterAssembly::HandleLdObjByNamePrefId32V8( } // IC miss and not enter the megamorphic state, store as polymorphic if (res.IsHole() && !firstValue.IsHole()) { - uint32_t stringId = READ_INST_32_1(); + uint16_t stringId = READ_INST_16_1(); JSTaggedValue propKey = ConstantPool::Cast(constpool.GetTaggedObject())->GetObjectFromCache(stringId); res = ICRuntimeStub::LoadICByName(thread, profileTypeArray, receiver, propKey, slotId); } @@ -3093,11 +3074,11 @@ void InterpreterAssembly::HandleLdObjByNamePrefId32V8( if (LIKELY(!res.IsHole())) { INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); + DISPATCH(LDOBJBYNAME_IMM8_ID16_V8); } } #endif - uint32_t stringId = READ_INST_32_1(); + uint16_t stringId = READ_INST_16_1(); JSTaggedValue propKey = ConstantPool::Cast(constpool.GetTaggedObject())->GetObjectFromCache(stringId); LOG_INST() << "intrinsics::ldobjbyname " << "v" << v0 << " stringId:" << stringId << ", " @@ -3110,7 +3091,7 @@ void InterpreterAssembly::HandleLdObjByNamePrefId32V8( ASSERT(!res.IsAccessor()); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); + DISPATCH(LDOBJBYNAME_IMM8_ID16_V8); } } // not meet fast condition or fast path return hole, walk slow path @@ -3118,14 +3099,14 @@ void InterpreterAssembly::HandleLdObjByNamePrefId32V8( JSTaggedValue res = SlowRuntimeStub::LdObjByName(thread, receiver, propKey, false, JSTaggedValue::Undefined()); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); + DISPATCH(LDOBJBYNAME_IMM8_ID16_V8); } -void InterpreterAssembly::HandleStObjByNamePrefId32V8( +void InterpreterAssembly::HandleStObjByNameImm8Id16V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint32_t v0 = READ_INST_8_5(); + uint32_t v0 = READ_INST_8_3(); JSTaggedValue receiver = GET_VREG_VALUE(v0); JSTaggedValue value = GET_ACC(); #if ECMASCRIPT_ENABLE_IC @@ -3142,7 +3123,7 @@ void InterpreterAssembly::HandleStObjByNamePrefId32V8( } // IC miss and not enter the megamorphic state, store as polymorphic if (res.IsHole() && !firstValue.IsHole()) { - uint32_t stringId = READ_INST_32_1(); + uint16_t stringId = READ_INST_16_1(); JSTaggedValue propKey = ConstantPool::Cast(constpool.GetTaggedObject())->GetObjectFromCache(stringId); res = ICRuntimeStub::StoreICByName(thread, profileTypeArray, receiver, propKey, value, slotId); } @@ -3150,11 +3131,11 @@ void InterpreterAssembly::HandleStObjByNamePrefId32V8( if (LIKELY(!res.IsHole())) { INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); + DISPATCH(STOBJBYNAME_IMM8_ID16_V8); } } #endif - uint32_t stringId = READ_INST_32_1(); + uint16_t stringId = READ_INST_16_1(); LOG_INST() << "intrinsics::stobjbyname " << "v" << v0 << " stringId:" << stringId; if (receiver.IsHeapObject()) { @@ -3166,7 +3147,7 @@ void InterpreterAssembly::HandleStObjByNamePrefId32V8( if (!res.IsHole()) { INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); + DISPATCH(STOBJBYNAME_IMM8_ID16_V8); } RESTORE_ACC(); } @@ -3178,15 +3159,15 @@ void InterpreterAssembly::HandleStObjByNamePrefId32V8( JSTaggedValue res = SlowRuntimeStub::StObjByName(thread, receiver, propKey, value); INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); + DISPATCH(STOBJBYNAME_IMM8_ID16_V8); } -void InterpreterAssembly::HandleLdSuperByNamePrefId32V8( +void InterpreterAssembly::HandleLdSuperByNameImm8Id16V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint32_t stringId = READ_INST_32_1(); - uint32_t v0 = READ_INST_8_5(); + uint16_t stringId = READ_INST_16_1(); + uint32_t v0 = READ_INST_8_3(); JSTaggedValue obj = GET_VREG_VALUE(v0); JSTaggedValue propKey = ConstantPool::Cast(constpool.GetTaggedObject())->GetObjectFromCache(stringId); @@ -3199,15 +3180,15 @@ void InterpreterAssembly::HandleLdSuperByNamePrefId32V8( INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); + DISPATCH(LDSUPERBYNAME_IMM8_ID16_V8); } -void InterpreterAssembly::HandleStSuperByNamePrefId32V8( +void InterpreterAssembly::HandleStSuperByNameImm8Id16V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint32_t stringId = READ_INST_32_1(); - uint32_t v0 = READ_INST_8_5(); + uint16_t stringId = READ_INST_16_1(); + uint32_t v0 = READ_INST_8_3(); JSTaggedValue obj = GET_VREG_VALUE(v0); JSTaggedValue propKey = ConstantPool::Cast(constpool.GetTaggedObject())->GetObjectFromCache(stringId); @@ -3224,78 +3205,63 @@ void InterpreterAssembly::HandleStSuperByNamePrefId32V8( JSTaggedValue res = SlowRuntimeStub::StSuperByValue(thread, obj, propKey, value, thisFunc); INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32_V8); + DISPATCH(STSUPERBYNAME_IMM8_ID16_V8); } -void InterpreterAssembly::HandleStGlobalVarPrefId32( +void InterpreterAssembly::HandleStGlobalVarId16( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint32_t stringId = READ_INST_32_1(); + uint16_t stringId = READ_INST_16_0(); JSTaggedValue prop = ConstantPool::Cast(constpool.GetTaggedObject())->GetObjectFromCache(stringId); JSTaggedValue value = GET_ACC(); LOG_INST() << "intrinsics::stglobalvar " << "stringId:" << stringId << ", " << ConvertToString(EcmaString::Cast(prop.GetTaggedObject())) << ", value:" << value.GetRawData(); -#if ECMASCRIPT_ENABLE_IC - if (!profileTypeInfo.IsUndefined()) { - uint16_t slotId = READ_INST_8_0(); - EcmaVM *ecmaVm = thread->GetEcmaVM(); - JSHandle globalEnv = ecmaVm->GetGlobalEnv(); - JSTaggedValue globalObj = globalEnv->GetGlobalObject(); - SAVE_ACC(); - JSTaggedValue res = ICRuntimeStub::StoreGlobalICByName(thread, - ProfileTypeInfo::Cast( - profileTypeInfo.GetTaggedObject()), - globalObj, prop, value, slotId); - INTERPRETER_RETURN_IF_ABRUPT(res); - RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); - } -#endif + SAVE_ACC(); JSTaggedValue res = SlowRuntimeStub::StGlobalVar(thread, prop, value); INTERPRETER_RETURN_IF_ABRUPT(res); RESTORE_ACC(); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + DISPATCH(STGLOBALVAR_ID16); } -void InterpreterAssembly::HandleCreateGeneratorObjPrefV8( +void InterpreterAssembly::HandleCreateGeneratorObjV8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t v0 = READ_INST_8_1(); + uint16_t v0 = READ_INST_8_0(); LOG_INST() << "intrinsics::creategeneratorobj" << " v" << v0; JSTaggedValue genFunc = GET_VREG_VALUE(v0); JSTaggedValue res = SlowRuntimeStub::CreateGeneratorObj(thread, genFunc); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(CREATEGENERATOROBJ_V8); } -void InterpreterAssembly::HandleCreateAsyncGeneratorObjPrefV8( +void InterpreterAssembly::HandleCreateAsyncGeneratorObjV8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t v0 = READ_INST_8_1(); + uint16_t v0 = READ_INST_8_0(); LOG_INST() << "intrinsics::" << " v" << v0; JSTaggedValue genFunc = GET_VREG_VALUE(v0); JSTaggedValue res = SlowRuntimeStub::CreateAsyncGeneratorObj(thread, genFunc); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(CREATEASYNCGENERATOROBJ_V8); } -void InterpreterAssembly::HandleAsyncGeneratorResolvePrefV8V8V8( +void InterpreterAssembly::HandleAsyncGeneratorResolveV8V8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); - uint16_t v2 = READ_INST_8_3(); + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); + uint16_t v2 = READ_INST_8_2(); LOG_INST() << "intrinsics::LowerAsyncGeneratorResolve" << " v" << v0; JSTaggedValue asyncGenerator = GET_VREG_VALUE(v0); @@ -3304,15 +3270,15 @@ void InterpreterAssembly::HandleAsyncGeneratorResolvePrefV8V8V8( JSTaggedValue res = SlowRuntimeStub::AsyncGeneratorResolve(thread, asyncGenerator, value, flag); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8_V8); + DISPATCH(ASYNCGENERATORRESOLVE_V8_V8_V8); } -void InterpreterAssembly::HandleStArraySpreadPrefV8V8( +void InterpreterAssembly::HandleStArraySpreadV8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); LOG_INST() << "ecmascript::intrinsics::starrayspread" << " v" << v0 << " v" << v1 << "acc"; JSTaggedValue dst = GET_VREG_VALUE(v0); @@ -3321,15 +3287,15 @@ void InterpreterAssembly::HandleStArraySpreadPrefV8V8( JSTaggedValue res = SlowRuntimeStub::StArraySpread(thread, dst, index, src); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(STARRAYSPREAD_V8_V8); } -void InterpreterAssembly::HandleGetIteratorNextPrefV8V8( +void InterpreterAssembly::HandleGetIteratorNextV8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t v0 = READ_INST_8_1(); - uint16_t v1 = READ_INST_8_2(); + uint16_t v0 = READ_INST_8_0(); + uint16_t v1 = READ_INST_8_1(); LOG_INST() << "intrinsic::getiteratornext" << " v" << v0 << " v" << v1; JSTaggedValue obj = GET_VREG_VALUE(v0); @@ -3337,10 +3303,10 @@ void InterpreterAssembly::HandleGetIteratorNextPrefV8V8( JSTaggedValue res = SlowRuntimeStub::GetIteratorNext(thread, obj, method); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8_V8); + DISPATCH(GETITERATORNEXT_V8_V8); } -void InterpreterAssembly::HandleDefineClassWithBufferPrefId16Imm16Imm16V8V8( +void InterpreterAssembly::HandleDefineClassWithBufferImm8Id16Imm16Imm16V8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -3373,51 +3339,51 @@ void InterpreterAssembly::HandleDefineClassWithBufferPrefId16Imm16Imm16V8V8( SlowRuntimeStub::SetClassConstructorLength(thread, res, JSTaggedValue(length)); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID16_IMM16_IMM16_V8_V8); + DISPATCH(DEFINECLASSWITHBUFFER_IMM8_ID16_IMM16_IMM16_V8_V8); } -void InterpreterAssembly::HandleLdFunctionPref( +void InterpreterAssembly::HandleLdThisFunction( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { LOG_INST() << "intrinsic::ldfunction"; SET_ACC(GetThisFunction(sp)); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(LDFUNCTION); } -void InterpreterAssembly::HandleNewLexEnvWithNameDynPrefImm16Imm16( +void InterpreterAssembly::HandleNewLexEnvWithNameImm16Imm16( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t numVars = READ_INST_16_1(); - uint16_t scopeId = READ_INST_16_3(); - LOG_INST() << "intrinsics::newlexenvwithnamedyn" + uint16_t numVars = READ_INST_16_0(); + uint16_t scopeId = READ_INST_16_2(); + LOG_INST() << "intrinsics::newlexenvwithname" << " numVars " << numVars << " scopeId " << scopeId; SAVE_PC(); - JSTaggedValue res = SlowRuntimeStub::NewLexicalEnvWithNameDyn(thread, numVars, scopeId); + JSTaggedValue res = SlowRuntimeStub::NewLexicalEnvWithName(thread, numVars, scopeId); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); GET_ASM_FRAME(sp)->env = res; - DISPATCH(BytecodeInstruction::Format::PREF_IMM16_IMM16); + DISPATCH(NEWLEXENVWITHNAME_IMM16_IMM16); } -void InterpreterAssembly::HandleLdBigIntPrefId32( +void InterpreterAssembly::HandleLdBigIntId16( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint32_t stringId = READ_INST_32_1(); + uint16_t stringId = READ_INST_16_0(); LOG_INST() << "intrinsic::ldbigint"; JSTaggedValue numberBigInt = ConstantPool::Cast(constpool.GetTaggedObject())->GetObjectFromCache(stringId); SAVE_PC(); JSTaggedValue res = SlowRuntimeStub::LdBigInt(thread, numberBigInt); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_ID32); + DISPATCH(LDBIGINT_ID16); } -void InterpreterAssembly::HandleToNumericPrefV8( +void InterpreterAssembly::HandleToNumericImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -3435,10 +3401,10 @@ void InterpreterAssembly::HandleToNumericPrefV8( INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); } - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(TONUMERIC_IMM8_V8); } -void InterpreterAssembly::HandleSuperCallPrefImm16V8( +void InterpreterAssembly::HandleSuperCallImm8Imm16V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -3453,10 +3419,10 @@ void InterpreterAssembly::HandleSuperCallPrefImm16V8( JSTaggedValue res = SlowRuntimeStub::SuperCall(thread, thisFunc, newTarget, v0, range); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16_V8); + DISPATCH(SUPERCALL_IMM8_IMM16_V8); } -void InterpreterAssembly::HandleSuperCallSpreadPrefV8( +void InterpreterAssembly::HandleSuperCallSpreadImm8V8( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -3471,10 +3437,10 @@ void InterpreterAssembly::HandleSuperCallSpreadPrefV8( JSTaggedValue res = SlowRuntimeStub::SuperCallSpread(thread, thisFunc, newTarget, array); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_V8); + DISPATCH(SUPERCALLSPREAD_IMM8_V8); } -void InterpreterAssembly::HandleCreateObjectHavingMethodPrefImm16( +void InterpreterAssembly::HandleCreateObjectHavingMethodImm8Imm16( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -3489,23 +3455,23 @@ void InterpreterAssembly::HandleCreateObjectHavingMethodPrefImm16( JSTaggedValue res = SlowRuntimeStub::CreateObjectHavingMethod(thread, factory, result, env); INTERPRETER_RETURN_IF_ABRUPT(res); SET_ACC(res); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16); + DISPATCH(CREATEOBJECTHAVINGMETHOD_IMM8_IMM16); } -void InterpreterAssembly::HandleThrowIfSuperNotCorrectCallPrefImm16( +void InterpreterAssembly::HandleThrowIfSuperNotCorrectCallImm16( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { - uint16_t imm = READ_INST_16_1(); + uint16_t imm = READ_INST_16_0(); JSTaggedValue thisValue = GET_ACC(); LOG_INST() << "intrinsic::throwifsupernotcorrectcall" << " imm:" << imm; JSTaggedValue res = SlowRuntimeStub::ThrowIfSuperNotCorrectCall(thread, imm, thisValue); INTERPRETER_RETURN_IF_ABRUPT(res); - DISPATCH(BytecodeInstruction::Format::PREF_IMM16); + DISPATCH(THROWIFSUPERNOTCORRECTCALL_IMM16); } -void InterpreterAssembly::HandleLdHomeObjectPref( +void InterpreterAssembly::HandleLdHomeObject( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -3515,10 +3481,10 @@ void InterpreterAssembly::HandleLdHomeObjectPref( JSTaggedValue homeObject = JSFunction::Cast(thisFunc.GetTaggedObject())->GetHomeObject(); SET_ACC(homeObject); - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(LDHOMEOBJECT); } -void InterpreterAssembly::HandleThrowDeleteSuperPropertyPref( +void InterpreterAssembly::HandleThrowDeleteSuperProperty( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -3528,15 +3494,15 @@ void InterpreterAssembly::HandleThrowDeleteSuperPropertyPref( INTERPRETER_GOTO_EXCEPTION_HANDLER(); } -void InterpreterAssembly::HandleDebuggerPref( +void InterpreterAssembly::HandleDebugger( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { LOG_INST() << "intrinsics::debugger"; - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(DEBUGGER); } -void InterpreterAssembly::HandleIsTruePref( +void InterpreterAssembly::HandleIsTrue( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -3546,10 +3512,10 @@ void InterpreterAssembly::HandleIsTruePref( } else { SET_ACC(JSTaggedValue::False()); } - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(ISTRUE); } -void InterpreterAssembly::HandleIsFalsePref( +void InterpreterAssembly::HandleIsFalse( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) { @@ -3559,9 +3525,263 @@ void InterpreterAssembly::HandleIsFalsePref( } else { SET_ACC(JSTaggedValue::False()); } - DISPATCH(BytecodeInstruction::Format::PREF_NONE); + DISPATCH(ISFALSE); +} + +void InterpreterAssembly::HandleTypeofImm16( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(TYPEOF_IMM16); +} + +void InterpreterAssembly::HandleCreateemptyarrayImm16( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(CREATEEMPTYARRAY_IMM16); +} + +void InterpreterAssembly::HandleGetiteratorImm16( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(GETITERATOR_IMM16); +} + +void InterpreterAssembly::HandleGettemplateobjectImm16V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(GETTEMPLATEOBJECT_IMM16_V8); +} + +void InterpreterAssembly::HandleCloseiteratorImm16V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(CLOSEITERATOR_IMM16_V8); +} + +void InterpreterAssembly::HandleNewobjspreadImm16V8V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(NEWOBJSPREAD_IMM16_V8_V8); +} + +void InterpreterAssembly::HandleSetobjectwithprotoImm16V8V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(SETOBJECTWITHPROTO_IMM16_V8_V8); +} + +void InterpreterAssembly::HandleLdobjbyvalueImm16V8V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(LDOBJBYVALUE_IMM16_V8_V8); +} + +void InterpreterAssembly::HandleStobjbyvalueImm16V8V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(STOBJBYVALUE_IMM16_V8_V8); +} + +void InterpreterAssembly::HandleStownbyvalueImm16V8V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(STOWNBYVALUE_IMM16_V8_V8); +} + +void InterpreterAssembly::HandleLdsuperbyvalueImm16V8V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(LDSUPERBYVALUE_IMM16_V8_V8); +} + +void InterpreterAssembly::HandleStsuperbyvalueImm16V8V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(STSUPERBYVALUE_IMM16_V8_V8); +} + +void InterpreterAssembly::HandleLdobjbyindexImm16V8Imm32( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(LDOBJBYINDEX_IMM16_V8_IMM32); +} + +void InterpreterAssembly::HandleStobjbyindexImm16V8Imm32( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(STOBJBYINDEX_IMM16_V8_IMM32); +} + +void InterpreterAssembly::HandleStownbyindexImm16V8Imm32( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(STOWNBYINDEX_IMM16_V8_IMM32); +} + +void InterpreterAssembly::HandleNewobjrangeImm16Imm16V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(NEWOBJRANGE_IMM16_IMM16_V8); +} + +void InterpreterAssembly::HandleDefinefuncImm16Id16Imm16V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(DEFINEFUNC_IMM16_ID16_IMM16_V8); +} + +void InterpreterAssembly::HandleDefinencfuncImm16Id16Imm16V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(DEFINENCFUNC_IMM16_ID16_IMM16_V8); +} + +void InterpreterAssembly::HandleDefinegeneratorfuncImm16Id16Imm16V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(DEFINEGENERATORFUNC_IMM16_ID16_IMM16_V8); } +void InterpreterAssembly::HandleDefineasyncfuncImm16Id16Imm16V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(DEFINEASYNCFUNC_IMM16_ID16_IMM16_V8); +} + +void InterpreterAssembly::HandleDefinemethodImm16Id16Imm16V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(DEFINEMETHOD_IMM16_ID16_IMM16_V8); +} + +void InterpreterAssembly::HandleCreatearraywithbufferImm16Imm16( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(CREATEARRAYWITHBUFFER_IMM16_IMM16); +} + +void InterpreterAssembly::HandleCreateobjecthavingmethodImm16Imm16( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(CREATEOBJECTHAVINGMETHOD_IMM16_IMM16); +} + +void InterpreterAssembly::HandleCreateobjectwithbufferImm16Imm16( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(CREATEOBJECTWITHBUFFER_IMM16_IMM16); +} + +void InterpreterAssembly::HandleDefineclasswithbufferImm16Id16Imm16Imm16V8V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(DEFINECLASSWITHBUFFER_IMM16_ID16_IMM16_IMM16_V8_V8); +} + +void InterpreterAssembly::HandleTryldglobalbynameImm16Id16( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(TRYLDGLOBALBYNAME_IMM16_ID16); +} + +void InterpreterAssembly::HandleTrystglobalbynameImm16Id16( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(TRYSTGLOBALBYNAME_IMM16_ID16); +} + +void InterpreterAssembly::HandleLdobjbynameImm16Id16V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(LDOBJBYNAME_IMM16_ID16_V8); +} + +void InterpreterAssembly::HandleStobjbynameImm16Id16V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(STOBJBYNAME_IMM16_ID16_V8); +} + +void InterpreterAssembly::HandleStownbynameImm16Id16V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(STOWNBYNAME_IMM16_ID16_V8); +} + +void InterpreterAssembly::HandleLdsuperbynameImm16Id16V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(LDSUPERBYNAME_IMM16_ID16_V8); +} + +void InterpreterAssembly::HandleStsuperbynameImm16Id16V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(STSUPERBYNAME_IMM16_ID16_V8); +} + +void InterpreterAssembly::HandleStownbyvaluewithnamesetImm16V8V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(STOWNBYVALUEWITHNAMESET_IMM16_V8_V8); +} + +void InterpreterAssembly::HandleStownbynamewithnamesetImm16Id16V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(STOWNBYNAMEWITHNAMESET_IMM16_ID16_V8); +} + +void InterpreterAssembly::HandleDefineasyncgeneratorfuncImm16Id16Imm16V8( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + DISPATCH(DEFINEASYNCGENERATORFUNC_IMM16_ID16_IMM16_V8); +} + +void InterpreterAssembly::HandleNop( + JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, + JSTaggedValue acc, int16_t hotnessCounter) +{ + LOG_INST() << "intrinsics::nop"; + DISPATCH(NOP); +} +*/ + void InterpreterAssembly::ExceptionHandler( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) @@ -3592,6 +3812,7 @@ void InterpreterAssembly::ExceptionHandler( thread->ClearException(); DISPATCH_OFFSET(0); } + void InterpreterAssembly::HandleOverflow( JSThread *thread, const uint8_t *pc, JSTaggedType *sp, JSTaggedValue constpool, JSTaggedValue profileTypeInfo, JSTaggedValue acc, int16_t hotnessCounter) @@ -3686,34 +3907,8 @@ uint32_t InterpreterAssembly::GetNumArgs(JSTaggedType *sp, uint32_t restIdx, uin inline size_t InterpreterAssembly::GetJumpSizeAfterCall(const uint8_t *prevPc) { - uint8_t op = *prevPc; - size_t jumpSize; - switch (op) { - case (EcmaOpcode::CALLARG0DYN_PREF_V8): - jumpSize = BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_V8); - break; - case (EcmaOpcode::CALLARG1DYN_PREF_V8_V8): - jumpSize = BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_V8_V8); - break; - case (EcmaOpcode::CALLARGS2DYN_PREF_V8_V8_V8): - jumpSize = BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_V8_V8_V8); - break; - case (EcmaOpcode::CALLARGS3DYN_PREF_V8_V8_V8_V8): - jumpSize = BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_V8_V8_V8_V8); - break; - case (EcmaOpcode::CALLIRANGEDYN_PREF_IMM16_V8): - jumpSize = BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_IMM16_V8); - break; - case (EcmaOpcode::CALLITHISRANGEDYN_PREF_IMM16_V8): - jumpSize = BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_IMM16_V8); - break; - case (EcmaOpcode::NEWOBJDYNRANGE_PREF_IMM16_V8): - jumpSize = BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_IMM16_V8); - break; - default: - UNREACHABLE(); - } - + auto op = BytecodeInstruction(prevPc).GetOpcode(); + size_t jumpSize = BytecodeInstruction::Size(op); return jumpSize; } diff --git a/ecmascript/interpreter/interpreter_assembly.h b/ecmascript/interpreter/interpreter_assembly.h index 8c45b9ace5..cc498c8630 100644 --- a/ecmascript/interpreter/interpreter_assembly.h +++ b/ecmascript/interpreter/interpreter_assembly.h @@ -129,42 +129,6 @@ static std::array asmDispat InterpreterAssembly::HandleOverflow, InterpreterAssembly::HandleOverflow, InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, - InterpreterAssembly::HandleOverflow, }; } // namespace panda::ecmascript #endif // ECMASCRIPT_INTERPRETER_INTERPRETER_ASSEMBLY_64BIT_H diff --git a/ecmascript/interpreter/slow_runtime_stub.cpp b/ecmascript/interpreter/slow_runtime_stub.cpp index 7bd5e5e018..17a57cf698 100644 --- a/ecmascript/interpreter/slow_runtime_stub.cpp +++ b/ecmascript/interpreter/slow_runtime_stub.cpp @@ -45,25 +45,25 @@ #include "ecmascript/stubs/runtime_stubs-inl.h" namespace panda::ecmascript { -JSTaggedValue SlowRuntimeStub::CallSpreadDyn(JSThread *thread, JSTaggedValue func, JSTaggedValue obj, +JSTaggedValue SlowRuntimeStub::CallSpread(JSThread *thread, JSTaggedValue func, JSTaggedValue obj, JSTaggedValue array) { - INTERPRETER_TRACE(thread, CallSpreadDyn); + INTERPRETER_TRACE(thread, CallSpread); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle jsFunc(thread, func); JSHandle jsArray(thread, array); JSHandle taggedObj(thread, obj); - return RuntimeStubs::RuntimeCallSpreadDyn(thread, jsFunc, taggedObj, jsArray); + return RuntimeStubs::RuntimeCallSpread(thread, jsFunc, taggedObj, jsArray); } -JSTaggedValue SlowRuntimeStub::NegDyn(JSThread *thread, JSTaggedValue value) +JSTaggedValue SlowRuntimeStub::Neg(JSThread *thread, JSTaggedValue value) { - INTERPRETER_TRACE(thread, NegDyn); + INTERPRETER_TRACE(thread, Neg); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle inputTag(thread, value); - return RuntimeStubs::RuntimeNegDyn(thread, inputTag); + return RuntimeStubs::RuntimeNeg(thread, inputTag); } JSTaggedValue SlowRuntimeStub::AsyncFunctionEnter(JSThread *thread) @@ -94,37 +94,37 @@ JSTaggedValue SlowRuntimeStub::ToNumeric(JSThread *thread, JSTaggedValue value) return RuntimeStubs::RuntimeToNumeric(thread, numeric); } -JSTaggedValue SlowRuntimeStub::NotDyn(JSThread *thread, JSTaggedValue value) +JSTaggedValue SlowRuntimeStub::Not(JSThread *thread, JSTaggedValue value) { - INTERPRETER_TRACE(thread, NotDyn); + INTERPRETER_TRACE(thread, Not); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle inputTag(thread, value); - return RuntimeStubs::RuntimeNotDyn(thread, inputTag); + return RuntimeStubs::RuntimeNot(thread, inputTag); } -JSTaggedValue SlowRuntimeStub::IncDyn(JSThread *thread, JSTaggedValue value) +JSTaggedValue SlowRuntimeStub::Inc(JSThread *thread, JSTaggedValue value) { - INTERPRETER_TRACE(thread, IncDyn); + INTERPRETER_TRACE(thread, Inc); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle inputTag(thread, value); - return RuntimeStubs::RuntimeIncDyn(thread, inputTag); + return RuntimeStubs::RuntimeInc(thread, inputTag); } -JSTaggedValue SlowRuntimeStub::DecDyn(JSThread *thread, JSTaggedValue value) +JSTaggedValue SlowRuntimeStub::Dec(JSThread *thread, JSTaggedValue value) { - INTERPRETER_TRACE(thread, DecDyn); + INTERPRETER_TRACE(thread, Dec); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle inputTag(thread, value); - return RuntimeStubs::RuntimeDecDyn(thread, inputTag); + return RuntimeStubs::RuntimeDec(thread, inputTag); } -void SlowRuntimeStub::ThrowDyn(JSThread *thread, JSTaggedValue value) +void SlowRuntimeStub::Throw(JSThread *thread, JSTaggedValue value) { - INTERPRETER_TRACE(thread, ThrowDyn); - RuntimeStubs::RuntimeThrowDyn(thread, value); + INTERPRETER_TRACE(thread, Throw); + RuntimeStubs::RuntimeThrow(thread, value); } JSTaggedValue SlowRuntimeStub::GetPropIterator(JSThread *thread, JSTaggedValue value) @@ -145,173 +145,173 @@ void SlowRuntimeStub::ThrowConstAssignment(JSThread *thread, JSTaggedValue value return RuntimeStubs::RuntimeThrowConstAssignment(thread, name); } -JSTaggedValue SlowRuntimeStub::Add2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right) +JSTaggedValue SlowRuntimeStub::Add2(JSThread *thread, JSTaggedValue left, JSTaggedValue right) { - INTERPRETER_TRACE(thread, Add2Dyn); + INTERPRETER_TRACE(thread, Add2); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle leftValue(thread, left); JSHandle rightValue(thread, right); - return RuntimeStubs::RuntimeAdd2Dyn(thread, leftValue, rightValue); + return RuntimeStubs::RuntimeAdd2(thread, leftValue, rightValue); } -JSTaggedValue SlowRuntimeStub::Sub2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right) +JSTaggedValue SlowRuntimeStub::Sub2(JSThread *thread, JSTaggedValue left, JSTaggedValue right) { - INTERPRETER_TRACE(thread, Sub2Dyn); + INTERPRETER_TRACE(thread, Sub2); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle leftTag(thread, left); JSHandle rightTag(thread, right); - return RuntimeStubs::RuntimeSub2Dyn(thread, leftTag, rightTag); + return RuntimeStubs::RuntimeSub2(thread, leftTag, rightTag); } -JSTaggedValue SlowRuntimeStub::Mul2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right) +JSTaggedValue SlowRuntimeStub::Mul2(JSThread *thread, JSTaggedValue left, JSTaggedValue right) { - INTERPRETER_TRACE(thread, Mul2Dyn); + INTERPRETER_TRACE(thread, Mul2); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle leftTag(thread, left); JSHandle rightTag(thread, right); - return RuntimeStubs::RuntimeMul2Dyn(thread, leftTag, rightTag); + return RuntimeStubs::RuntimeMul2(thread, leftTag, rightTag); } -JSTaggedValue SlowRuntimeStub::Div2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right) +JSTaggedValue SlowRuntimeStub::Div2(JSThread *thread, JSTaggedValue left, JSTaggedValue right) { - INTERPRETER_TRACE(thread, Div2Dyn); + INTERPRETER_TRACE(thread, Div2); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle leftTag(thread, left); JSHandle rightTag(thread, right); - return RuntimeStubs::RuntimeDiv2Dyn(thread, leftTag, rightTag); + return RuntimeStubs::RuntimeDiv2(thread, leftTag, rightTag); } -JSTaggedValue SlowRuntimeStub::Mod2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right) +JSTaggedValue SlowRuntimeStub::Mod2(JSThread *thread, JSTaggedValue left, JSTaggedValue right) { - INTERPRETER_TRACE(thread, Mod2Dyn); + INTERPRETER_TRACE(thread, Mod2); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle leftTag(thread, left); JSHandle rightTag(thread, right); - return RuntimeStubs::RuntimeMod2Dyn(thread, leftTag, rightTag); + return RuntimeStubs::RuntimeMod2(thread, leftTag, rightTag); } -JSTaggedValue SlowRuntimeStub::EqDyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right) +JSTaggedValue SlowRuntimeStub::Eq(JSThread *thread, JSTaggedValue left, JSTaggedValue right) { - INTERPRETER_TRACE(thread, EqDyn); + INTERPRETER_TRACE(thread, Eq); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle leftValue(thread, left); JSHandle rightValue(thread, right); - return RuntimeStubs::RuntimeEqDyn(thread, leftValue, rightValue); + return RuntimeStubs::RuntimeEq(thread, leftValue, rightValue); } -JSTaggedValue SlowRuntimeStub::NotEqDyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right) +JSTaggedValue SlowRuntimeStub::NotEq(JSThread *thread, JSTaggedValue left, JSTaggedValue right) { - INTERPRETER_TRACE(thread, NotEqDyn); + INTERPRETER_TRACE(thread, NotEq); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle leftValue(thread, left); JSHandle rightValue(thread, right); - return RuntimeStubs::RuntimeNotEqDyn(thread, leftValue, rightValue); + return RuntimeStubs::RuntimeNotEq(thread, leftValue, rightValue); } -JSTaggedValue SlowRuntimeStub::LessDyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right) +JSTaggedValue SlowRuntimeStub::Less(JSThread *thread, JSTaggedValue left, JSTaggedValue right) { - INTERPRETER_TRACE(thread, LessDyn); + INTERPRETER_TRACE(thread, Less); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle leftValue(thread, left); JSHandle rightValue(thread, right); - return RuntimeStubs::RuntimeLessDyn(thread, leftValue, rightValue); + return RuntimeStubs::RuntimeLess(thread, leftValue, rightValue); } -JSTaggedValue SlowRuntimeStub::LessEqDyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right) +JSTaggedValue SlowRuntimeStub::LessEq(JSThread *thread, JSTaggedValue left, JSTaggedValue right) { - INTERPRETER_TRACE(thread, LessEqDyn); + INTERPRETER_TRACE(thread, LessEq); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle leftValue(thread, left); JSHandle rightValue(thread, right); - return RuntimeStubs::RuntimeLessEqDyn(thread, leftValue, rightValue); + return RuntimeStubs::RuntimeLessEq(thread, leftValue, rightValue); } -JSTaggedValue SlowRuntimeStub::GreaterDyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right) +JSTaggedValue SlowRuntimeStub::Greater(JSThread *thread, JSTaggedValue left, JSTaggedValue right) { - INTERPRETER_TRACE(thread, GreaterDyn); + INTERPRETER_TRACE(thread, Greater); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle leftValue(thread, left); JSHandle rightValue(thread, right); - return RuntimeStubs::RuntimeGreaterDyn(thread, leftValue, rightValue); + return RuntimeStubs::RuntimeGreater(thread, leftValue, rightValue); } -JSTaggedValue SlowRuntimeStub::GreaterEqDyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right) +JSTaggedValue SlowRuntimeStub::GreaterEq(JSThread *thread, JSTaggedValue left, JSTaggedValue right) { - INTERPRETER_TRACE(thread, GreaterEqDyn); + INTERPRETER_TRACE(thread, GreaterEq); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle leftValue(thread, left); JSHandle rightValue(thread, right); - return RuntimeStubs::RuntimeGreaterEqDyn(thread, leftValue, rightValue); + return RuntimeStubs::RuntimeGreaterEq(thread, leftValue, rightValue); } -JSTaggedValue SlowRuntimeStub::Shl2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right) +JSTaggedValue SlowRuntimeStub::Shl2(JSThread *thread, JSTaggedValue left, JSTaggedValue right) { - INTERPRETER_TRACE(thread, Shl2Dyn); + INTERPRETER_TRACE(thread, Shl2); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle leftTag(thread, left); JSHandle rightTag(thread, right); - return RuntimeStubs::RuntimeShl2Dyn(thread, leftTag, rightTag); + return RuntimeStubs::RuntimeShl2(thread, leftTag, rightTag); } -JSTaggedValue SlowRuntimeStub::Shr2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right) +JSTaggedValue SlowRuntimeStub::Shr2(JSThread *thread, JSTaggedValue left, JSTaggedValue right) { - INTERPRETER_TRACE(thread, Shr2Dyn); + INTERPRETER_TRACE(thread, Shr2); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle leftTag(thread, left); JSHandle rightTag(thread, right); - return RuntimeStubs::RuntimeShr2Dyn(thread, leftTag, rightTag); + return RuntimeStubs::RuntimeShr2(thread, leftTag, rightTag); } -JSTaggedValue SlowRuntimeStub::Ashr2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right) +JSTaggedValue SlowRuntimeStub::Ashr2(JSThread *thread, JSTaggedValue left, JSTaggedValue right) { - INTERPRETER_TRACE(thread, Ashr2Dyn); + INTERPRETER_TRACE(thread, Ashr2); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle leftTag(thread, left); JSHandle rightTag(thread, right); - return RuntimeStubs::RuntimeAshr2Dyn(thread, leftTag, rightTag); + return RuntimeStubs::RuntimeAshr2(thread, leftTag, rightTag); } -JSTaggedValue SlowRuntimeStub::And2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right) +JSTaggedValue SlowRuntimeStub::And2(JSThread *thread, JSTaggedValue left, JSTaggedValue right) { - INTERPRETER_TRACE(thread, And2Dyn); + INTERPRETER_TRACE(thread, And2); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle leftTag(thread, left); JSHandle rightTag(thread, right); - return RuntimeStubs::RuntimeAnd2Dyn(thread, leftTag, rightTag); + return RuntimeStubs::RuntimeAnd2(thread, leftTag, rightTag); } -JSTaggedValue SlowRuntimeStub::Or2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right) +JSTaggedValue SlowRuntimeStub::Or2(JSThread *thread, JSTaggedValue left, JSTaggedValue right) { - INTERPRETER_TRACE(thread, Or2Dyn); + INTERPRETER_TRACE(thread, Or2); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle leftTag(thread, left); JSHandle rightTag(thread, right); - return RuntimeStubs::RuntimeOr2Dyn(thread, leftTag, rightTag); + return RuntimeStubs::RuntimeOr2(thread, leftTag, rightTag); } -JSTaggedValue SlowRuntimeStub::Xor2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right) +JSTaggedValue SlowRuntimeStub::Xor2(JSThread *thread, JSTaggedValue left, JSTaggedValue right) { - INTERPRETER_TRACE(thread, Xor2Dyn); + INTERPRETER_TRACE(thread, Xor2); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle leftTag(thread, left); JSHandle rightTag(thread, right); - return RuntimeStubs::RuntimeXor2Dyn(thread, leftTag, rightTag); + return RuntimeStubs::RuntimeXor2(thread, leftTag, rightTag); } JSTaggedValue SlowRuntimeStub::ToJSTaggedValueWithInt32(JSThread *thread, JSTaggedValue value) @@ -340,15 +340,15 @@ JSTaggedValue SlowRuntimeStub::DelObjProp(JSThread *thread, JSTaggedValue obj, J return RuntimeStubs::RuntimeDelObjProp(thread, objHandle, propHandle); } -JSTaggedValue SlowRuntimeStub::NewObjDynRange(JSThread *thread, JSTaggedValue func, JSTaggedValue newTarget, +JSTaggedValue SlowRuntimeStub::NewObjRange(JSThread *thread, JSTaggedValue func, JSTaggedValue newTarget, uint16_t firstArgIdx, uint16_t length) { - INTERPRETER_TRACE(thread, NewobjDynrange); + INTERPRETER_TRACE(thread, NewobjRange); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle funcHandle(thread, func); JSHandle newTargetHandle(thread, newTarget); - return RuntimeStubs::RuntimeNewObjDynRange(thread, funcHandle, newTargetHandle, firstArgIdx, length); + return RuntimeStubs::RuntimeNewObjRange(thread, funcHandle, newTargetHandle, firstArgIdx, length); } JSTaggedValue SlowRuntimeStub::CreateObjectWithExcludedKeys(JSThread *thread, uint16_t numKeys, JSTaggedValue objVal, @@ -361,48 +361,48 @@ JSTaggedValue SlowRuntimeStub::CreateObjectWithExcludedKeys(JSThread *thread, ui return RuntimeStubs::RuntimeCreateObjectWithExcludedKeys(thread, numKeys, obj, firstArgRegIdx); } -JSTaggedValue SlowRuntimeStub::ExpDyn(JSThread *thread, JSTaggedValue base, JSTaggedValue exponent) +JSTaggedValue SlowRuntimeStub::Exp(JSThread *thread, JSTaggedValue base, JSTaggedValue exponent) { - INTERPRETER_TRACE(thread, ExpDyn); + INTERPRETER_TRACE(thread, Exp); [[maybe_unused]] EcmaHandleScope handleScope(thread); - return RuntimeStubs::RuntimeExpDyn(thread, base, exponent); + return RuntimeStubs::RuntimeExp(thread, base, exponent); } -JSTaggedValue SlowRuntimeStub::IsInDyn(JSThread *thread, JSTaggedValue prop, JSTaggedValue obj) +JSTaggedValue SlowRuntimeStub::IsIn(JSThread *thread, JSTaggedValue prop, JSTaggedValue obj) { - INTERPRETER_TRACE(thread, IsInDyn); + INTERPRETER_TRACE(thread, IsIn); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle propHandle(thread, prop); JSHandle objHandle(thread, obj); - return RuntimeStubs::RuntimeIsInDyn(thread, propHandle, objHandle); + return RuntimeStubs::RuntimeIsIn(thread, propHandle, objHandle); } -JSTaggedValue SlowRuntimeStub::InstanceofDyn(JSThread *thread, JSTaggedValue obj, JSTaggedValue target) +JSTaggedValue SlowRuntimeStub::Instanceof(JSThread *thread, JSTaggedValue obj, JSTaggedValue target) { - INTERPRETER_TRACE(thread, InstanceofDyn); + INTERPRETER_TRACE(thread, Instanceof); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle objHandle(thread, obj); JSHandle targetHandle(thread, target); - return RuntimeStubs::RuntimeInstanceofDyn(thread, objHandle, targetHandle); + return RuntimeStubs::RuntimeInstanceof(thread, objHandle, targetHandle); } -JSTaggedValue SlowRuntimeStub::NewLexicalEnvDyn(JSThread *thread, uint16_t numVars) +JSTaggedValue SlowRuntimeStub::NewLexicalEnv(JSThread *thread, uint16_t numVars) { - INTERPRETER_TRACE(thread, NewlexenvDyn); + INTERPRETER_TRACE(thread, Newlexenv); [[maybe_unused]] EcmaHandleScope handleScope(thread); - return RuntimeStubs::RuntimeNewLexicalEnvDyn(thread, numVars); + return RuntimeStubs::RuntimeNewLexicalEnv(thread, numVars); } -JSTaggedValue SlowRuntimeStub::NewLexicalEnvWithNameDyn(JSThread *thread, uint16_t numVars, uint16_t scopeId) +JSTaggedValue SlowRuntimeStub::NewLexicalEnvWithName(JSThread *thread, uint16_t numVars, uint16_t scopeId) { - INTERPRETER_TRACE(thread, NewlexenvwithNameDyn); + INTERPRETER_TRACE(thread, NewlexenvwithName); [[maybe_unused]] EcmaHandleScope handleScope(thread); - return RuntimeStubs::RuntimeNewLexicalEnvWithNameDyn(thread, numVars, scopeId); + return RuntimeStubs::RuntimeNewLexicalEnvWithName(thread, numVars, scopeId); } JSTaggedValue SlowRuntimeStub::CreateIterResultObj(JSThread *thread, JSTaggedValue value, JSTaggedValue flag) @@ -534,16 +534,14 @@ JSTaggedValue SlowRuntimeStub::AsyncFunctionResolveOrReject(JSThread *thread, JS return RuntimeStubs::RuntimeAsyncFunctionResolveOrReject(thread, asyncFuncObjHandle, valueHandle, is_resolve); } -JSTaggedValue SlowRuntimeStub::NewObjSpreadDyn(JSThread *thread, JSTaggedValue func, JSTaggedValue newTarget, - JSTaggedValue array) +JSTaggedValue SlowRuntimeStub::NewObjApply(JSThread *thread, JSTaggedValue func, JSTaggedValue array) { - INTERPRETER_TRACE(thread, NewobjspreadDyn); + INTERPRETER_TRACE(thread, Newobjspread); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle funcHandle(thread, func); - JSHandle newTargetHandle(thread, newTarget); JSHandle jsArray(thread, array); - return RuntimeStubs::RuntimeNewObjSpreadDyn(thread, funcHandle, newTargetHandle, jsArray); + return RuntimeStubs::RuntimeNewObjApply(thread, funcHandle, jsArray); } void SlowRuntimeStub::ThrowUndefinedIfHole(JSThread *thread, JSTaggedValue obj) @@ -589,7 +587,7 @@ void SlowRuntimeStub::ThrowPatternNonCoercible(JSThread *thread) JSTaggedValue SlowRuntimeStub::StOwnByName(JSThread *thread, JSTaggedValue obj, JSTaggedValue prop, JSTaggedValue value) { - INTERPRETER_TRACE(thread, StOwnByNameDyn); + INTERPRETER_TRACE(thread, StOwnByName); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle objHandle(thread, obj); @@ -601,7 +599,7 @@ JSTaggedValue SlowRuntimeStub::StOwnByName(JSThread *thread, JSTaggedValue obj, JSTaggedValue SlowRuntimeStub::StOwnByNameWithNameSet(JSThread *thread, JSTaggedValue obj, JSTaggedValue prop, JSTaggedValue value) { - INTERPRETER_TRACE(thread, StOwnByNameDyn); + INTERPRETER_TRACE(thread, StOwnByName); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle objHandle(thread, obj); @@ -612,7 +610,7 @@ JSTaggedValue SlowRuntimeStub::StOwnByNameWithNameSet(JSThread *thread, JSTagged JSTaggedValue SlowRuntimeStub::StOwnByIndex(JSThread *thread, JSTaggedValue obj, uint32_t idx, JSTaggedValue value) { - INTERPRETER_TRACE(thread, StOwnByIdDyn); + INTERPRETER_TRACE(thread, StOwnById); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle objHandle(thread, obj); @@ -623,7 +621,7 @@ JSTaggedValue SlowRuntimeStub::StOwnByIndex(JSThread *thread, JSTaggedValue obj, JSTaggedValue SlowRuntimeStub::StOwnByValue(JSThread *thread, JSTaggedValue obj, JSTaggedValue key, JSTaggedValue value) { - INTERPRETER_TRACE(thread, StOwnByValueDyn); + INTERPRETER_TRACE(thread, StOwnByValue); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle objHandle(thread, obj); @@ -635,7 +633,7 @@ JSTaggedValue SlowRuntimeStub::StOwnByValue(JSThread *thread, JSTaggedValue obj, JSTaggedValue SlowRuntimeStub::StOwnByValueWithNameSet(JSThread *thread, JSTaggedValue obj, JSTaggedValue key, JSTaggedValue value) { - INTERPRETER_TRACE(thread, StOwnByValueDyn); + INTERPRETER_TRACE(thread, StOwnByValue); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle objHandle(thread, obj); @@ -821,7 +819,7 @@ JSTaggedValue SlowRuntimeStub::DefineGetterSetterByValue(JSThread *thread, JSTag JSTaggedValue SlowRuntimeStub::LdObjByIndex(JSThread *thread, JSTaggedValue obj, uint32_t idx, bool callGetter, JSTaggedValue receiver) { - INTERPRETER_TRACE(thread, LdObjByIndexDyn); + INTERPRETER_TRACE(thread, LdObjByIndex); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle objHandle(thread, obj); @@ -830,7 +828,7 @@ JSTaggedValue SlowRuntimeStub::LdObjByIndex(JSThread *thread, JSTaggedValue obj, JSTaggedValue SlowRuntimeStub::StObjByIndex(JSThread *thread, JSTaggedValue obj, uint32_t idx, JSTaggedValue value) { - INTERPRETER_TRACE(thread, StObjByIndexDyn); + INTERPRETER_TRACE(thread, StObjByIndex); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle objHandle(thread, obj); @@ -841,14 +839,14 @@ JSTaggedValue SlowRuntimeStub::StObjByIndex(JSThread *thread, JSTaggedValue obj, JSTaggedValue SlowRuntimeStub::LdObjByName(JSThread *thread, JSTaggedValue obj, JSTaggedValue prop, bool callGetter, JSTaggedValue receiver) { - INTERPRETER_TRACE(thread, LdObjByNameDyn); + INTERPRETER_TRACE(thread, LdObjByName); [[maybe_unused]] EcmaHandleScope handleScope(thread); return RuntimeStubs::RuntimeLdObjByName(thread, obj, prop, callGetter, receiver); } JSTaggedValue SlowRuntimeStub::StObjByName(JSThread *thread, JSTaggedValue obj, JSTaggedValue prop, JSTaggedValue value) { - INTERPRETER_TRACE(thread, StObjByNameDyn); + INTERPRETER_TRACE(thread, StObjByName); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle objHandle(thread, obj); @@ -860,7 +858,7 @@ JSTaggedValue SlowRuntimeStub::StObjByName(JSThread *thread, JSTaggedValue obj, JSTaggedValue SlowRuntimeStub::LdObjByValue(JSThread *thread, JSTaggedValue obj, JSTaggedValue prop, bool callGetter, JSTaggedValue receiver) { - INTERPRETER_TRACE(thread, LdObjByValueDyn); + INTERPRETER_TRACE(thread, LdObjByValue); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle objHandle(thread, obj); @@ -871,7 +869,7 @@ JSTaggedValue SlowRuntimeStub::LdObjByValue(JSThread *thread, JSTaggedValue obj, JSTaggedValue SlowRuntimeStub::StObjByValue(JSThread *thread, JSTaggedValue obj, JSTaggedValue prop, JSTaggedValue value) { - INTERPRETER_TRACE(thread, StObjByValueDyn); + INTERPRETER_TRACE(thread, StObjByValue); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle objHandle(thread, obj); @@ -998,20 +996,20 @@ JSTaggedValue SlowRuntimeStub::DefineAsyncFunc(JSThread *thread, JSFunction *fun return RuntimeStubs::RuntimeDefineAsyncFunc(thread, funcHandle); } -JSTaggedValue SlowRuntimeStub::DefineNCFuncDyn(JSThread *thread, JSFunction *func) +JSTaggedValue SlowRuntimeStub::DefineNCFunc(JSThread *thread, JSFunction *func) { - INTERPRETER_TRACE(thread, DefineNCFuncDyn); + INTERPRETER_TRACE(thread, DefineNCFunc); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle funcHandle(thread, func); - return RuntimeStubs::RuntimeDefineNCFuncDyn(thread, funcHandle); + return RuntimeStubs::RuntimeDefineNCFunc(thread, funcHandle); } -JSTaggedValue SlowRuntimeStub::DefinefuncDyn(JSThread *thread, JSFunction *func) +JSTaggedValue SlowRuntimeStub::Definefunc(JSThread *thread, JSFunction *func) { - INTERPRETER_TRACE(thread, DefinefuncDyn); + INTERPRETER_TRACE(thread, Definefunc); [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle funcHandle(thread, func); - return RuntimeStubs::RuntimeDefinefuncDyn(thread, funcHandle); + return RuntimeStubs::RuntimeDefinefunc(thread, funcHandle); } JSTaggedValue SlowRuntimeStub::GetSuperConstructor(JSThread *thread, JSTaggedValue ctor) @@ -1184,7 +1182,7 @@ JSTaggedValue SlowRuntimeStub::DefineAsyncGeneratorFunc(JSThread *thread, JSFunc JSHandle initialAsyncGeneratorFuncPrototype = factory->NewJSObjectByConstructor(objFun); JSObject::SetPrototype(thread, initialAsyncGeneratorFuncPrototype, env->GetAsyncGeneratorPrototype()); ASSERT_NO_ABRUPT_COMPLETION(thread); - jsFunc->SetProtoOrDynClass(thread, initialAsyncGeneratorFuncPrototype); + jsFunc->SetProtoOrHClass(thread, initialAsyncGeneratorFuncPrototype); return jsFunc.GetTaggedValue(); } diff --git a/ecmascript/interpreter/slow_runtime_stub.h b/ecmascript/interpreter/slow_runtime_stub.h index 7f8e2ada4d..c3d1f9193b 100644 --- a/ecmascript/interpreter/slow_runtime_stub.h +++ b/ecmascript/interpreter/slow_runtime_stub.h @@ -26,49 +26,49 @@ class JSArray; class SlowRuntimeStub { public: - static JSTaggedValue CallSpreadDyn(JSThread *thread, JSTaggedValue func, JSTaggedValue obj, JSTaggedValue array); - static JSTaggedValue NegDyn(JSThread *thread, JSTaggedValue value); + static JSTaggedValue CallSpread(JSThread *thread, JSTaggedValue func, JSTaggedValue obj, JSTaggedValue array); + static JSTaggedValue Neg(JSThread *thread, JSTaggedValue value); static JSTaggedValue AsyncFunctionEnter(JSThread *thread); static JSTaggedValue ToNumber(JSThread *thread, JSTaggedValue value); static JSTaggedValue ToNumeric(JSThread *thread, JSTaggedValue value); - static JSTaggedValue NotDyn(JSThread *thread, JSTaggedValue value); - static JSTaggedValue IncDyn(JSThread *thread, JSTaggedValue value); - static JSTaggedValue DecDyn(JSThread *thread, JSTaggedValue value); - static void ThrowDyn(JSThread *thread, JSTaggedValue value); + static JSTaggedValue Not(JSThread *thread, JSTaggedValue value); + static JSTaggedValue Inc(JSThread *thread, JSTaggedValue value); + static JSTaggedValue Dec(JSThread *thread, JSTaggedValue value); + static void Throw(JSThread *thread, JSTaggedValue value); static JSTaggedValue GetPropIterator(JSThread *thread, JSTaggedValue value); static void ThrowConstAssignment(JSThread *thread, JSTaggedValue value); - static JSTaggedValue Add2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right); - static JSTaggedValue Sub2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right); - static JSTaggedValue Mul2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right); - static JSTaggedValue Div2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right); - static JSTaggedValue Mod2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right); - static JSTaggedValue EqDyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right); - static JSTaggedValue NotEqDyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right); - static JSTaggedValue LessDyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right); - static JSTaggedValue LessEqDyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right); - static JSTaggedValue GreaterDyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right); - static JSTaggedValue GreaterEqDyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right); - static JSTaggedValue Shl2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right); - static JSTaggedValue Shr2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right); - static JSTaggedValue Ashr2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right); - static JSTaggedValue And2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right); - static JSTaggedValue Or2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right); - static JSTaggedValue Xor2Dyn(JSThread *thread, JSTaggedValue left, JSTaggedValue right); + static JSTaggedValue Add2(JSThread *thread, JSTaggedValue left, JSTaggedValue right); + static JSTaggedValue Sub2(JSThread *thread, JSTaggedValue left, JSTaggedValue right); + static JSTaggedValue Mul2(JSThread *thread, JSTaggedValue left, JSTaggedValue right); + static JSTaggedValue Div2(JSThread *thread, JSTaggedValue left, JSTaggedValue right); + static JSTaggedValue Mod2(JSThread *thread, JSTaggedValue left, JSTaggedValue right); + static JSTaggedValue Eq(JSThread *thread, JSTaggedValue left, JSTaggedValue right); + static JSTaggedValue NotEq(JSThread *thread, JSTaggedValue left, JSTaggedValue right); + static JSTaggedValue Less(JSThread *thread, JSTaggedValue left, JSTaggedValue right); + static JSTaggedValue LessEq(JSThread *thread, JSTaggedValue left, JSTaggedValue right); + static JSTaggedValue Greater(JSThread *thread, JSTaggedValue left, JSTaggedValue right); + static JSTaggedValue GreaterEq(JSThread *thread, JSTaggedValue left, JSTaggedValue right); + static JSTaggedValue Shl2(JSThread *thread, JSTaggedValue left, JSTaggedValue right); + static JSTaggedValue Shr2(JSThread *thread, JSTaggedValue left, JSTaggedValue right); + static JSTaggedValue Ashr2(JSThread *thread, JSTaggedValue left, JSTaggedValue right); + static JSTaggedValue And2(JSThread *thread, JSTaggedValue left, JSTaggedValue right); + static JSTaggedValue Or2(JSThread *thread, JSTaggedValue left, JSTaggedValue right); + static JSTaggedValue Xor2(JSThread *thread, JSTaggedValue left, JSTaggedValue right); static JSTaggedValue ToJSTaggedValueWithInt32(JSThread *thread, JSTaggedValue value); static JSTaggedValue ToJSTaggedValueWithUint32(JSThread *thread, JSTaggedValue value); static JSTaggedValue DelObjProp(JSThread *thread, JSTaggedValue obj, JSTaggedValue prop); - static JSTaggedValue NewObjDynRange(JSThread *thread, JSTaggedValue func, JSTaggedValue newTarget, + static JSTaggedValue NewObjRange(JSThread *thread, JSTaggedValue func, JSTaggedValue newTarget, uint16_t firstArgIdx, uint16_t length); static JSTaggedValue CreateObjectWithExcludedKeys(JSThread *thread, uint16_t numKeys, JSTaggedValue objVal, uint16_t firstArgRegIdx); - static JSTaggedValue ExpDyn(JSThread *thread, JSTaggedValue base, JSTaggedValue exponent); - static JSTaggedValue IsInDyn(JSThread *thread, JSTaggedValue prop, JSTaggedValue obj); - static JSTaggedValue InstanceofDyn(JSThread *thread, JSTaggedValue obj, JSTaggedValue target); + static JSTaggedValue Exp(JSThread *thread, JSTaggedValue base, JSTaggedValue exponent); + static JSTaggedValue IsIn(JSThread *thread, JSTaggedValue prop, JSTaggedValue obj); + static JSTaggedValue Instanceof(JSThread *thread, JSTaggedValue obj, JSTaggedValue target); - static JSTaggedValue NewLexicalEnvDyn(JSThread *thread, uint16_t numVars); - static JSTaggedValue NewLexicalEnvWithNameDyn(JSThread *thread, uint16_t numVars, uint16_t scopeId); + static JSTaggedValue NewLexicalEnv(JSThread *thread, uint16_t numVars); + static JSTaggedValue NewLexicalEnvWithName(JSThread *thread, uint16_t numVars, uint16_t scopeId); static JSTaggedValue CreateIterResultObj(JSThread *thread, JSTaggedValue value, JSTaggedValue flag); static JSTaggedValue CreateGeneratorObj(JSThread *thread, JSTaggedValue genFunc); @@ -83,8 +83,7 @@ public: static JSTaggedValue AsyncFunctionResolveOrReject(JSThread *thread, JSTaggedValue asyncFuncObj, JSTaggedValue value, bool is_resolve); - static JSTaggedValue NewObjSpreadDyn(JSThread *thread, JSTaggedValue func, JSTaggedValue newTarget, - JSTaggedValue array); + static JSTaggedValue NewObjApply(JSThread *thread, JSTaggedValue func, JSTaggedValue array); static void ThrowUndefinedIfHole(JSThread *thread, JSTaggedValue obj); static void ThrowIfNotObject(JSThread *thread); static void ThrowThrowNotExists(JSThread *thread); @@ -144,8 +143,8 @@ public: static JSTaggedValue DefineGeneratorFunc(JSThread *thread, JSFunction *func); static JSTaggedValue DefineAsyncFunc(JSThread *thread, JSFunction *func); - static JSTaggedValue DefineNCFuncDyn(JSThread *thread, JSFunction *func); - static JSTaggedValue DefinefuncDyn(JSThread *thread, JSFunction *func); + static JSTaggedValue DefineNCFunc(JSThread *thread, JSFunction *func); + static JSTaggedValue Definefunc(JSThread *thread, JSFunction *func); static JSTaggedValue GetSuperConstructor(JSThread *thread, JSTaggedValue ctor); static JSTaggedValue SuperCall(JSThread *thread, JSTaggedValue func, JSTaggedValue newTarget, uint16_t firstVRegIdx, diff --git a/ecmascript/interpreter/templates/debugger_deprecated_instruction_dispatch.inl b/ecmascript/interpreter/templates/debugger_deprecated_instruction_dispatch.inl new file mode 100644 index 0000000000..2eae976067 --- /dev/null +++ b/ecmascript/interpreter/templates/debugger_deprecated_instruction_dispatch.inl @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + &&DEBUG_HANDLE_DEPRECATED_LDLEXENV_PREF_NONE, + &&DEBUG_HANDLE_DEPRECATED_POPLEXENV_PREF_NONE, + &&DEBUG_HANDLE_DEPRECATED_GETITERATORNEXT_PREF_V8_V8, + &&DEBUG_HANDLE_DEPRECATED_CREATEARRAYWITHBUFFER_PREF_IMM16, + &&DEBUG_HANDLE_DEPRECATED_CREATEOBJECTWITHBUFFER_PREF_IMM16, + &&DEBUG_HANDLE_DEPRECATED_TONUMBER_PREF_V8, + &&DEBUG_HANDLE_DEPRECATED_TONUMERIC_PREF_V8, + &&DEBUG_HANDLE_DEPRECATED_NEG_PREF_V8, + &&DEBUG_HANDLE_DEPRECATED_NOT_PREF_V8, + &&DEBUG_HANDLE_DEPRECATED_INC_PREF_V8, + &&DEBUG_HANDLE_DEPRECATED_DEC_PREF_V8, + &&DEBUG_HANDLE_DEPRECATED_CALLARG0_PREF_V8, + &&DEBUG_HANDLE_DEPRECATED_CALLARG1_PREF_V8_V8, + &&DEBUG_HANDLE_DEPRECATED_CALLARGS2_PREF_V8_V8_V8, + &&DEBUG_HANDLE_DEPRECATED_CALLARGS3_PREF_V8_V8_V8_V8, + &&DEBUG_HANDLE_DEPRECATED_CALLRANGE_PREF_IMM16_V8, + &&DEBUG_HANDLE_DEPRECATED_CALLSPREAD_PREF_V8_V8_V8, + &&DEBUG_HANDLE_DEPRECATED_CALLTHISRANGE_PREF_IMM16_V8, + &&DEBUG_HANDLE_DEPRECATED_DEFINEFUNC_PREF_ID16_IMM16_V8, + &&DEBUG_HANDLE_DEPRECATED_DEFINENCFUNC_PREF_ID16_IMM16_V8, + &&DEBUG_HANDLE_DEPRECATED_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8, + &&DEBUG_HANDLE_DEPRECATED_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8, + &&DEBUG_HANDLE_DEPRECATED_DEFINEMETHOD_PREF_ID16_IMM16_V8, + &&DEBUG_HANDLE_DEPRECATED_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8, + &&DEBUG_HANDLE_DEPRECATED_RESUMEGENERATOR_PREF_V8, + &&DEBUG_HANDLE_DEPRECATED_GETRESUMEMODE_PREF_V8, + &&DEBUG_HANDLE_DEPRECATED_GETTEMPLATEOBJECT_PREF_V8, + &&DEBUG_HANDLE_DEPRECATED_DELOBJPROP_PREF_V8_V8, + &&DEBUG_HANDLE_DEPRECATED_SUSPENDGENERATOR_PREF_V8_V8, + &&DEBUG_HANDLE_DEPRECATED_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8, + &&DEBUG_HANDLE_DEPRECATED_COPYDATAPROPERTIES_PREF_V8_V8, + &&DEBUG_HANDLE_DEPRECATED_SETOBJECTWITHPROTO_PREF_V8_V8, + &&DEBUG_HANDLE_DEPRECATED_LDOBJBYVALUE_PREF_V8_V8, + &&DEBUG_HANDLE_DEPRECATED_LDSUPERBYVALUE_PREF_V8_V8, + &&DEBUG_HANDLE_DEPRECATED_LDOBJBYINDEX_PREF_V8_IMM32, + &&DEBUG_HANDLE_DEPRECATED_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8, + &&DEBUG_HANDLE_DEPRECATED_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8, + &&DEBUG_HANDLE_DEPRECATED_STLEXVAR_PREF_IMM4_IMM4_V8, + &&DEBUG_HANDLE_DEPRECATED_STLEXVAR_PREF_IMM8_IMM8_V8, + &&DEBUG_HANDLE_DEPRECATED_STLEXVAR_PREF_IMM16_IMM16_V8, + &&DEBUG_HANDLE_DEPRECATED_GETMODULENAMESPACE_PREF_ID32, + &&DEBUG_HANDLE_DEPRECATED_STMODULEVAR_PREF_ID32, + &&DEBUG_HANDLE_DEPRECATED_LDOBJBYNAME_PREF_ID32_V8, + &&DEBUG_HANDLE_DEPRECATED_LDSUPERBYNAME_PREF_ID32_V8, + &&DEBUG_HANDLE_DEPRECATED_LDMODULEVAR_PREF_ID32_IMM8, + &&DEBUG_HANDLE_DEPRECATED_STCONSTTOGLOBALRECORD_PREF_ID32, + &&DEBUG_HANDLE_DEPRECATED_STLETTOGLOBALRECORD_PREF_ID32, + &&DEBUG_HANDLE_DEPRECATED_STCLASSTOGLOBALRECORD_PREF_ID32, + &&DEBUG_HANDLE_DEPRECATED_LDHOMEOBJECT_PREF_NONE, + &&DEBUG_HANDLE_DEPRECATED_CREATEOBJECTHAVINGMETHOD_PREF_IMM16, + &&DEBUG_HANDLE_DEPRECATED_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8, \ No newline at end of file diff --git a/ecmascript/interpreter/templates/debugger_instruction_dispatch.inl b/ecmascript/interpreter/templates/debugger_instruction_dispatch.inl index 4a0ffe7241..f47c6d9748 100644 --- a/ecmascript/interpreter/templates/debugger_instruction_dispatch.inl +++ b/ecmascript/interpreter/templates/debugger_instruction_dispatch.inl @@ -13,223 +13,220 @@ * limitations under the License. */ - &&DEBUG_HANDLE_LDNAN_PREF, - &&DEBUG_HANDLE_LDINFINITY_PREF, - &&DEBUG_HANDLE_LDGLOBALTHIS_PREF, - &&DEBUG_HANDLE_LDUNDEFINED_PREF, - &&DEBUG_HANDLE_LDNULL_PREF, - &&DEBUG_HANDLE_LDSYMBOL_PREF, - &&DEBUG_HANDLE_LDGLOBAL_PREF, - &&DEBUG_HANDLE_LDTRUE_PREF, - &&DEBUG_HANDLE_LDFALSE_PREF, - &&DEBUG_HANDLE_THROWDYN_PREF, - &&DEBUG_HANDLE_TYPEOFDYN_PREF, - &&DEBUG_HANDLE_LDLEXENVDYN_PREF, - &&DEBUG_HANDLE_POPLEXENVDYN_PREF, - &&DEBUG_HANDLE_GETUNMAPPEDARGS_PREF, - &&DEBUG_HANDLE_GETPROPITERATOR_PREF, - &&DEBUG_HANDLE_ASYNCFUNCTIONENTER_PREF, - &&DEBUG_HANDLE_LDHOLE_PREF, - &&DEBUG_HANDLE_RETURNUNDEFINED_PREF, - &&DEBUG_HANDLE_CREATEEMPTYOBJECT_PREF, - &&DEBUG_HANDLE_CREATEEMPTYARRAY_PREF, - &&DEBUG_HANDLE_GETITERATOR_PREF, - &&DEBUG_HANDLE_THROWTHROWNOTEXISTS_PREF, - &&DEBUG_HANDLE_THROWPATTERNNONCOERCIBLE_PREF, - &&DEBUG_HANDLE_LDHOMEOBJECT_PREF, - &&DEBUG_HANDLE_THROWDELETESUPERPROPERTY_PREF, - &&DEBUG_HANDLE_DEBUGGER_PREF, - &&DEBUG_HANDLE_ADD2DYN_PREF_V8, - &&DEBUG_HANDLE_SUB2DYN_PREF_V8, - &&DEBUG_HANDLE_MUL2DYN_PREF_V8, - &&DEBUG_HANDLE_DIV2DYN_PREF_V8, - &&DEBUG_HANDLE_MOD2DYN_PREF_V8, - &&DEBUG_HANDLE_EQDYN_PREF_V8, - &&DEBUG_HANDLE_NOTEQDYN_PREF_V8, - &&DEBUG_HANDLE_LESSDYN_PREF_V8, - &&DEBUG_HANDLE_LESSEQDYN_PREF_V8, - &&DEBUG_HANDLE_GREATERDYN_PREF_V8, - &&DEBUG_HANDLE_GREATEREQDYN_PREF_V8, - &&DEBUG_HANDLE_SHL2DYN_PREF_V8, - &&DEBUG_HANDLE_ASHR2DYN_PREF_V8, - &&DEBUG_HANDLE_SHR2DYN_PREF_V8, - &&DEBUG_HANDLE_AND2DYN_PREF_V8, - &&DEBUG_HANDLE_OR2DYN_PREF_V8, - &&DEBUG_HANDLE_XOR2DYN_PREF_V8, - &&DEBUG_HANDLE_TONUMBER_PREF_V8, - &&DEBUG_HANDLE_NEGDYN_PREF_V8, - &&DEBUG_HANDLE_NOTDYN_PREF_V8, - &&DEBUG_HANDLE_INCDYN_PREF_V8, - &&DEBUG_HANDLE_DECDYN_PREF_V8, - &&DEBUG_HANDLE_EXPDYN_PREF_V8, - &&DEBUG_HANDLE_ISINDYN_PREF_V8, - &&DEBUG_HANDLE_INSTANCEOFDYN_PREF_V8, - &&DEBUG_HANDLE_STRICTNOTEQDYN_PREF_V8, - &&DEBUG_HANDLE_STRICTEQDYN_PREF_V8, - &&DEBUG_HANDLE_RESUMEGENERATOR_PREF_V8, - &&DEBUG_HANDLE_GETRESUMEMODE_PREF_V8, - &&DEBUG_HANDLE_CREATEGENERATOROBJ_PREF_V8, - &&DEBUG_HANDLE_THROWCONSTASSIGNMENT_PREF_V8, - &&DEBUG_HANDLE_GETTEMPLATEOBJECT_PREF_V8, - &&DEBUG_HANDLE_GETNEXTPROPNAME_PREF_V8, - &&DEBUG_HANDLE_CALLARG0DYN_PREF_V8, - &&DEBUG_HANDLE_THROWIFNOTOBJECT_PREF_V8, - &&DEBUG_HANDLE_ITERNEXT_PREF_V8, - &&DEBUG_HANDLE_CLOSEITERATOR_PREF_V8, - &&DEBUG_HANDLE_COPYMODULE_PREF_V8, - &&DEBUG_HANDLE_SUPERCALLSPREAD_PREF_V8, - &&DEBUG_HANDLE_DELOBJPROP_PREF_V8_V8, - &&DEBUG_HANDLE_NEWOBJSPREADDYN_PREF_V8_V8, - &&DEBUG_HANDLE_CREATEITERRESULTOBJ_PREF_V8_V8, - &&DEBUG_HANDLE_SUSPENDGENERATOR_PREF_V8_V8, - &&DEBUG_HANDLE_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8, - &&DEBUG_HANDLE_THROWUNDEFINEDIFHOLE_PREF_V8_V8, - &&DEBUG_HANDLE_CALLARG1DYN_PREF_V8_V8, - &&DEBUG_HANDLE_COPYDATAPROPERTIES_PREF_V8_V8, - &&DEBUG_HANDLE_STARRAYSPREAD_PREF_V8_V8, - &&DEBUG_HANDLE_GETITERATORNEXT_PREF_V8_V8, - &&DEBUG_HANDLE_SETOBJECTWITHPROTO_PREF_V8_V8, - &&DEBUG_HANDLE_LDOBJBYVALUE_PREF_V8_V8, - &&DEBUG_HANDLE_STOBJBYVALUE_PREF_V8_V8, - &&DEBUG_HANDLE_STOWNBYVALUE_PREF_V8_V8, - &&DEBUG_HANDLE_LDSUPERBYVALUE_PREF_V8_V8, - &&DEBUG_HANDLE_STSUPERBYVALUE_PREF_V8_V8, - &&DEBUG_HANDLE_LDOBJBYINDEX_PREF_V8_IMM32, - &&DEBUG_HANDLE_STOBJBYINDEX_PREF_V8_IMM32, - &&DEBUG_HANDLE_STOWNBYINDEX_PREF_V8_IMM32, - &&DEBUG_HANDLE_CALLSPREADDYN_PREF_V8_V8_V8, - &&DEBUG_HANDLE_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8, - &&DEBUG_HANDLE_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8, - &&DEBUG_HANDLE_CALLARGS2DYN_PREF_V8_V8_V8, - &&DEBUG_HANDLE_CALLARGS3DYN_PREF_V8_V8_V8_V8, - &&DEBUG_HANDLE_DEFINEGETTERSETTERBYVALUE_PREF_V8_V8_V8_V8, - &&DEBUG_HANDLE_NEWOBJDYNRANGE_PREF_IMM16_V8, - &&DEBUG_HANDLE_CALLIRANGEDYN_PREF_IMM16_V8, - &&DEBUG_HANDLE_CALLITHISRANGEDYN_PREF_IMM16_V8, - &&DEBUG_HANDLE_SUPERCALL_PREF_IMM16_V8, - &&DEBUG_HANDLE_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8, - &&DEBUG_HANDLE_DEFINEFUNCDYN_PREF_ID16_IMM16_V8, - &&DEBUG_HANDLE_DEFINENCFUNCDYN_PREF_ID16_IMM16_V8, - &&DEBUG_HANDLE_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8, - &&DEBUG_HANDLE_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8, - &&DEBUG_HANDLE_DEFINEMETHOD_PREF_ID16_IMM16_V8, - &&DEBUG_HANDLE_NEWLEXENVDYN_PREF_IMM16, - &&DEBUG_HANDLE_COPYRESTARGS_PREF_IMM16, - &&DEBUG_HANDLE_CREATEARRAYWITHBUFFER_PREF_IMM16, - &&DEBUG_HANDLE_CREATEOBJECTHAVINGMETHOD_PREF_IMM16, - &&DEBUG_HANDLE_THROWIFSUPERNOTCORRECTCALL_PREF_IMM16, - &&DEBUG_HANDLE_CREATEOBJECTWITHBUFFER_PREF_IMM16, - &&DEBUG_HANDLE_LDLEXVARDYN_PREF_IMM4_IMM4, - &&DEBUG_HANDLE_LDLEXVARDYN_PREF_IMM8_IMM8, - &&DEBUG_HANDLE_LDLEXVARDYN_PREF_IMM16_IMM16, - &&DEBUG_HANDLE_STLEXVARDYN_PREF_IMM4_IMM4_V8, - &&DEBUG_HANDLE_STLEXVARDYN_PREF_IMM8_IMM8_V8, - &&DEBUG_HANDLE_STLEXVARDYN_PREF_IMM16_IMM16_V8, - &&DEBUG_HANDLE_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8, - &&DEBUG_HANDLE_GETMODULENAMESPACE_PREF_ID32, - &&DEBUG_HANDLE_STMODULEVAR_PREF_ID32, - &&DEBUG_HANDLE_TRYLDGLOBALBYNAME_PREF_ID32, - &&DEBUG_HANDLE_TRYSTGLOBALBYNAME_PREF_ID32, - &&DEBUG_HANDLE_LDGLOBALVAR_PREF_ID32, - &&DEBUG_HANDLE_STGLOBALVAR_PREF_ID32, - &&DEBUG_HANDLE_LDOBJBYNAME_PREF_ID32_V8, - &&DEBUG_HANDLE_STOBJBYNAME_PREF_ID32_V8, - &&DEBUG_HANDLE_STOWNBYNAME_PREF_ID32_V8, - &&DEBUG_HANDLE_LDSUPERBYNAME_PREF_ID32_V8, - &&DEBUG_HANDLE_STSUPERBYNAME_PREF_ID32_V8, - &&DEBUG_HANDLE_LDMODULEVAR_PREF_ID32_IMM8, - &&DEBUG_HANDLE_CREATEREGEXPWITHLITERAL_PREF_ID32_IMM8, - &&DEBUG_HANDLE_ISTRUE_PREF, - &&DEBUG_HANDLE_ISFALSE_PREF, - &&DEBUG_HANDLE_STCONSTTOGLOBALRECORD_PREF_ID32, - &&DEBUG_HANDLE_STLETTOGLOBALRECORD_PREF_ID32, - &&DEBUG_HANDLE_STCLASSTOGLOBALRECORD_PREF_ID32, - &&DEBUG_HANDLE_STOWNBYVALUEWITHNAMESET_PREF_V8_V8, - &&DEBUG_HANDLE_STOWNBYNAMEWITHNAMESET_PREF_ID32_V8, - &&DEBUG_HANDLE_LDFUNCTION_PREF, - &&DEBUG_HANDLE_NEWLEXENVWITHNAMEDYN_PREF_IMM16_IMM16, - &&DEBUG_HANDLE_LDBIGINT_PREF_ID32, - &&DEBUG_HANDLE_TONUMERIC_PREF_V8, - &&DEBUG_HANDLE_CREATEASYNCGENERATOROBJ_PREF_V8, - &&DEBUG_HANDLE_ASYNCGENERATORRESOLVE_PREF_V8_V8_V8, - &&DEBUG_HANDLE_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8, - &&DEBUG_HANDLE_MOV_DYN_V8_V8, - &&DEBUG_HANDLE_MOV_DYN_V16_V16, - &&DEBUG_HANDLE_LDA_STR_ID32, - &&DEBUG_HANDLE_LDAI_DYN_IMM32, - &&DEBUG_HANDLE_FLDAI_DYN_IMM64, + &&DEBUG_HANDLE_LDNAN, + &&DEBUG_HANDLE_LDINFINITY, + &&DEBUG_HANDLE_LDGLOBALTHIS, + &&DEBUG_HANDLE_LDUNDEFINED, + &&DEBUG_HANDLE_LDNULL, + &&DEBUG_HANDLE_LDSYMBOL, + &&DEBUG_HANDLE_LDGLOBAL, + &&DEBUG_HANDLE_LDTRUE, + &&DEBUG_HANDLE_LDFALSE, + &&DEBUG_HANDLE_LDHOLE, + &&DEBUG_HANDLE_LDNEWTARGET, + &&DEBUG_HANDLE_POPLEXENV, + &&DEBUG_HANDLE_GETUNMAPPEDARGS, + &&DEBUG_HANDLE_ASYNCFUNCTIONENTER, + &&DEBUG_HANDLE_LDTHIS, + &&DEBUG_HANDLE_LDFUNCTION, + &&DEBUG_HANDLE_DEBUGGER, + &&DEBUG_HANDLE_GETPROPITERATOR, + &&DEBUG_HANDLE_GETITERATOR_IMM8, + &&DEBUG_HANDLE_GETITERATOR_IMM16, + &&DEBUG_HANDLE_CLOSEITERATOR_IMM8_V8, + &&DEBUG_HANDLE_CLOSEITERATOR_IMM16_V8, + &&DEBUG_HANDLE_CREATEASYNCGENERATOROBJ_V8, + &&DEBUG_HANDLE_CREATEEMPTYOBJECT, + &&DEBUG_HANDLE_CREATEEMPTYARRAY_IMM8, + &&DEBUG_HANDLE_CREATEEMPTYARRAY_IMM16, + &&DEBUG_HANDLE_CREATEGENERATOROBJ_V8, + &&DEBUG_HANDLE_CREATEITERRESULTOBJ_V8_V8, + &&DEBUG_HANDLE_CREATEOBJECTWITHEXCLUDEDKEYS_IMM8_V8_V8, + &&DEBUG_HANDLE_ASYNCGENERATORRESOLVE_V8_V8_V8, + &&DEBUG_HANDLE_CREATEARRAYWITHBUFFER_IMM8_ID16, + &&DEBUG_HANDLE_CREATEARRAYWITHBUFFER_IMM16_ID16, + &&DEBUG_HANDLE_CALLTHIS0_IMM8_V8, + &&DEBUG_HANDLE_CALLTHIS1_IMM8_V8_V8, + &&DEBUG_HANDLE_CREATEOBJECTWITHBUFFER_IMM8_ID16, + &&DEBUG_HANDLE_CREATEOBJECTWITHBUFFER_IMM16_ID16, + &&DEBUG_HANDLE_CREATEREGEXPWITHLITERAL_IMM8_ID16_IMM8, + &&DEBUG_HANDLE_CREATEREGEXPWITHLITERAL_IMM16_ID16_IMM8, + &&DEBUG_HANDLE_NEWOBJAPPLY_IMM8_V8, + &&DEBUG_HANDLE_NEWOBJAPPLY_IMM16_V8, + &&DEBUG_HANDLE_NEWOBJRANGE_IMM8_IMM8_V8, + &&DEBUG_HANDLE_NEWOBJRANGE_IMM16_IMM8_V8, + &&DEBUG_HANDLE_NEWLEXENV_IMM8, + &&DEBUG_HANDLE_NEWLEXENVWITHNAME_IMM8_ID16, + &&DEBUG_HANDLE_ADD2_IMM8_V8, + &&DEBUG_HANDLE_SUB2_IMM8_V8, + &&DEBUG_HANDLE_MUL2_IMM8_V8, + &&DEBUG_HANDLE_DIV2_IMM8_V8, + &&DEBUG_HANDLE_MOD2_IMM8_V8, + &&DEBUG_HANDLE_EQ_IMM8_V8, + &&DEBUG_HANDLE_NOTEQ_IMM8_V8, + &&DEBUG_HANDLE_LESS_IMM8_V8, + &&DEBUG_HANDLE_LESSEQ_IMM8_V8, + &&DEBUG_HANDLE_GREATER_IMM8_V8, + &&DEBUG_HANDLE_GREATEREQ_IMM8_V8, + &&DEBUG_HANDLE_SHL2_IMM8_V8, + &&DEBUG_HANDLE_SHR2_IMM8_V8, + &&DEBUG_HANDLE_ASHR2_IMM8_V8, + &&DEBUG_HANDLE_AND2_IMM8_V8, + &&DEBUG_HANDLE_OR2_IMM8_V8, + &&DEBUG_HANDLE_XOR2_IMM8_V8, + &&DEBUG_HANDLE_EXP_IMM8_V8, + &&DEBUG_HANDLE_TYPEOF_IMM8, + &&DEBUG_HANDLE_TYPEOF_IMM16, + &&DEBUG_HANDLE_TONUMBER_IMM8, + &&DEBUG_HANDLE_TONUMERIC_IMM8, + &&DEBUG_HANDLE_NEG_IMM8, + &&DEBUG_HANDLE_NOT_IMM8, + &&DEBUG_HANDLE_INC_IMM8, + &&DEBUG_HANDLE_DEC_IMM8, + &&DEBUG_HANDLE_ISIN_IMM8_V8, + &&DEBUG_HANDLE_INSTANCEOF_IMM8_V8, + &&DEBUG_HANDLE_STRICTNOTEQ_IMM8_V8, + &&DEBUG_HANDLE_STRICTEQ_IMM8_V8, + &&DEBUG_HANDLE_ISTRUE, + &&DEBUG_HANDLE_ISFALSE, + &&DEBUG_HANDLE_CALLTHIS2_IMM8_V8_V8_V8, + &&DEBUG_HANDLE_CALLTHIS3_IMM8_V8_V8_V8_V8, + &&DEBUG_HANDLE_CALLTHISRANGE_IMM8_IMM8_V8, + &&DEBUG_HANDLE_SUPERCALLTHISRANGE_IMM8_IMM8_V8, + &&DEBUG_HANDLE_SUPERCALLARROWRANGE_IMM8_IMM8_V8, + &&DEBUG_HANDLE_DEFINEFUNC_IMM8_ID16_IMM8, + &&DEBUG_HANDLE_DEFINEFUNC_IMM16_ID16_IMM8, + &&DEBUG_HANDLE_DEFINEMETHOD_IMM8_ID16_IMM8, + &&DEBUG_HANDLE_CALLARG0_IMM8, + &&DEBUG_HANDLE_SUPERCALLSPREAD_IMM8_V8, + &&DEBUG_HANDLE_APPLY_IMM8_V8_V8, + &&DEBUG_HANDLE_CALLARGS2_IMM8_V8_V8, + &&DEBUG_HANDLE_CALLARGS3_IMM8_V8_V8_V8, + &&DEBUG_HANDLE_CALLRANGE_IMM8_IMM8_V8, + &&DEBUG_HANDLE_DEFINEMETHOD_IMM16_ID16_IMM8, + &&DEBUG_HANDLE_LDEXTERNALMODULEVAR_IMM8, + &&DEBUG_HANDLE_DEFINEGETTERSETTERBYVALUE_V8_V8_V8_V8, + &&DEBUG_HANDLE_LDTHISBYNAME_IMM8_ID16, + &&DEBUG_HANDLE_LDTHISBYNAME_IMM16_ID16, + &&DEBUG_HANDLE_STTHISBYNAME_IMM8_ID16, + &&DEBUG_HANDLE_STTHISBYNAME_IMM16_ID16, + &&DEBUG_HANDLE_LDTHISBYVALUE_IMM8, + &&DEBUG_HANDLE_LDTHISBYVALUE_IMM16, + &&DEBUG_HANDLE_STTHISBYVALUE_IMM8_V8, + &&DEBUG_HANDLE_STTHISBYVALUE_IMM16_V8, + &&DEBUG_HANDLE_LDPATCHVAR_IMM8, + &&DEBUG_HANDLE_STPATCHVAR_IMM8_V8, + &&DEBUG_HANDLE_DEFINECLASSWITHBUFFER_IMM8_ID16_ID16_IMM16_V8, + &&DEBUG_HANDLE_DEFINECLASSWITHBUFFER_IMM16_ID16_ID16_IMM16_V8, + &&DEBUG_HANDLE_RESUMEGENERATOR, + &&DEBUG_HANDLE_GETRESUMEMODE, + &&DEBUG_HANDLE_GETTEMPLATEOBJECT_IMM8, + &&DEBUG_HANDLE_GETTEMPLATEOBJECT_IMM16, + &&DEBUG_HANDLE_GETNEXTPROPNAME_V8, + &&DEBUG_HANDLE_JSTRICTEQZ_IMM8, + &&DEBUG_HANDLE_JSTRICTEQZ_IMM16, + &&DEBUG_HANDLE_SETOBJECTWITHPROTO_IMM8_V8, + &&DEBUG_HANDLE_DELOBJPROP_V8, + &&DEBUG_HANDLE_SUSPENDGENERATOR_V8, + &&DEBUG_HANDLE_ASYNCFUNCTIONAWAITUNCAUGHT_V8, + &&DEBUG_HANDLE_COPYDATAPROPERTIES_V8, + &&DEBUG_HANDLE_STARRAYSPREAD_V8_V8, + &&DEBUG_HANDLE_SETOBJECTWITHPROTO_IMM16_V8, + &&DEBUG_HANDLE_LDOBJBYVALUE_IMM8_V8, + &&DEBUG_HANDLE_LDOBJBYVALUE_IMM16_V8, + &&DEBUG_HANDLE_STOBJBYVALUE_IMM8_V8_V8, + &&DEBUG_HANDLE_STOBJBYVALUE_IMM16_V8_V8, + &&DEBUG_HANDLE_STOWNBYVALUE_IMM8_V8_V8, + &&DEBUG_HANDLE_STOWNBYVALUE_IMM16_V8_V8, + &&DEBUG_HANDLE_LDSUPERBYVALUE_IMM8_V8, + &&DEBUG_HANDLE_LDSUPERBYVALUE_IMM16_V8, + &&DEBUG_HANDLE_STSUPERBYVALUE_IMM8_V8_V8, + &&DEBUG_HANDLE_STSUPERBYVALUE_IMM16_V8_V8, + &&DEBUG_HANDLE_LDOBJBYINDEX_IMM8_IMM16, + &&DEBUG_HANDLE_LDOBJBYINDEX_IMM16_IMM16, + &&DEBUG_HANDLE_STOBJBYINDEX_IMM8_V8_IMM16, + &&DEBUG_HANDLE_STOBJBYINDEX_IMM16_V8_IMM16, + &&DEBUG_HANDLE_STOWNBYINDEX_IMM8_V8_IMM16, + &&DEBUG_HANDLE_STOWNBYINDEX_IMM16_V8_IMM16, + &&DEBUG_HANDLE_ASYNCFUNCTIONRESOLVE_V8, + &&DEBUG_HANDLE_ASYNCFUNCTIONREJECT_V8, + &&DEBUG_HANDLE_COPYRESTARGS_IMM8, + &&DEBUG_HANDLE_LDLEXVAR_IMM4_IMM4, + &&DEBUG_HANDLE_STLEXVAR_IMM4_IMM4, + &&DEBUG_HANDLE_GETMODULENAMESPACE_IMM8, + &&DEBUG_HANDLE_STMODULEVAR_IMM8, + &&DEBUG_HANDLE_TRYLDGLOBALBYNAME_IMM8_ID16, + &&DEBUG_HANDLE_TRYLDGLOBALBYNAME_IMM16_ID16, + &&DEBUG_HANDLE_TRYSTGLOBALBYNAME_IMM8_ID16, + &&DEBUG_HANDLE_TRYSTGLOBALBYNAME_IMM16_ID16, + &&DEBUG_HANDLE_LDGLOBALVAR_IMM16_ID16, + &&DEBUG_HANDLE_STGLOBALVAR_IMM16_ID16, + &&DEBUG_HANDLE_LDOBJBYNAME_IMM8_ID16, + &&DEBUG_HANDLE_LDOBJBYNAME_IMM16_ID16, + &&DEBUG_HANDLE_STOBJBYNAME_IMM8_ID16_V8, + &&DEBUG_HANDLE_STOBJBYNAME_IMM16_ID16_V8, + &&DEBUG_HANDLE_STOWNBYNAME_IMM8_ID16_V8, + &&DEBUG_HANDLE_STOWNBYNAME_IMM16_ID16_V8, + &&DEBUG_HANDLE_LDSUPERBYNAME_IMM8_ID16, + &&DEBUG_HANDLE_LDSUPERBYNAME_IMM16_ID16, + &&DEBUG_HANDLE_STSUPERBYNAME_IMM8_ID16_V8, + &&DEBUG_HANDLE_STSUPERBYNAME_IMM16_ID16_V8, + &&DEBUG_HANDLE_LDLOCALMODULEVAR_IMM8, + &&DEBUG_HANDLE_STCONSTTOGLOBALRECORD_IMM16_ID16, + &&DEBUG_HANDLE_STTOGLOBALRECORD_IMM16_ID16, + &&DEBUG_HANDLE_JNSTRICTEQZ_IMM8, + &&DEBUG_HANDLE_JNSTRICTEQZ_IMM16, + &&DEBUG_HANDLE_JEQNULL_IMM8, + &&DEBUG_HANDLE_JEQNULL_IMM16, + &&DEBUG_HANDLE_STOWNBYVALUEWITHNAMESET_IMM8_V8_V8, + &&DEBUG_HANDLE_STOWNBYVALUEWITHNAMESET_IMM16_V8_V8, + &&DEBUG_HANDLE_STOWNBYNAMEWITHNAMESET_IMM8_ID16_V8, + &&DEBUG_HANDLE_STOWNBYNAMEWITHNAMESET_IMM16_ID16_V8, + &&DEBUG_HANDLE_LDBIGINT_ID16, + &&DEBUG_HANDLE_LDA_STR_ID16, &&DEBUG_HANDLE_JMP_IMM8, &&DEBUG_HANDLE_JMP_IMM16, &&DEBUG_HANDLE_JMP_IMM32, &&DEBUG_HANDLE_JEQZ_IMM8, &&DEBUG_HANDLE_JEQZ_IMM16, - &&DEBUG_HANDLE_LDA_DYN_V8, - &&DEBUG_HANDLE_STA_DYN_V8, - &&DEBUG_HANDLE_RETURN_DYN, - &&DEBUG_HANDLE_MOV_V4_V4, &&DEBUG_HANDLE_JNEZ_IMM8, &&DEBUG_HANDLE_JNEZ_IMM16, - &&DEBUG_EXCEPTION_HANDLER, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, - &&DEBUG_HANDLE_OVERFLOW, + &&DEBUG_HANDLE_JNENULL_IMM8, + &&DEBUG_HANDLE_JNENULL_IMM16, + &&DEBUG_HANDLE_LDA_V8, + &&DEBUG_HANDLE_STA_V8, + &&DEBUG_HANDLE_LDAI_IMM32, + &&DEBUG_HANDLE_FLDAI_IMM64, + &&DEBUG_HANDLE_RETURN, + &&DEBUG_HANDLE_RETURNUNDEFINED, + &&DEBUG_HANDLE_LDLEXVAR_IMM8_IMM8, + &&DEBUG_HANDLE_JSTRICTEQNULL_IMM8, + &&DEBUG_HANDLE_STLEXVAR_IMM8_IMM8, + &&DEBUG_HANDLE_JSTRICTEQNULL_IMM16, + &&DEBUG_HANDLE_CALLARG1_IMM8_V8, + &&DEBUG_HANDLE_JNSTRICTEQNULL_IMM8, + &&DEBUG_HANDLE_JNSTRICTEQNULL_IMM16, + &&DEBUG_HANDLE_JEQUNDEFINED_IMM8, + &&DEBUG_HANDLE_JEQUNDEFINED_IMM16, + &&DEBUG_HANDLE_JNEUNDEFINED_IMM8, + &&DEBUG_HANDLE_JNEUNDEFINED_IMM16, + &&DEBUG_HANDLE_JSTRICTEQUNDEFINED_IMM8, + &&DEBUG_HANDLE_JSTRICTEQUNDEFINED_IMM16, + &&DEBUG_HANDLE_JNSTRICTEQUNDEFINED_IMM8, + &&DEBUG_HANDLE_JNSTRICTEQUNDEFINED_IMM16, + &&DEBUG_HANDLE_JEQ_V8_IMM8, + &&DEBUG_HANDLE_JEQ_V8_IMM16, + &&DEBUG_HANDLE_JNE_V8_IMM8, + &&DEBUG_HANDLE_JNE_V8_IMM16, + &&DEBUG_HANDLE_JSTRICTEQ_V8_IMM8, + &&DEBUG_HANDLE_JSTRICTEQ_V8_IMM16, + &&DEBUG_HANDLE_JNSTRICTEQ_V8_IMM8, + &&DEBUG_HANDLE_JNSTRICTEQ_V8_IMM16, + &&DEBUG_HANDLE_MOV_V4_V4, + &&DEBUG_HANDLE_MOV_V8_V8, + &&DEBUG_HANDLE_MOV_V16_V16, + &&DEBUG_HANDLE_NOP, + &&DEBUG_HANDLE_EXCEPTION, &&DEBUG_HANDLE_OVERFLOW, &&DEBUG_HANDLE_OVERFLOW, &&DEBUG_HANDLE_OVERFLOW, @@ -268,4 +265,7 @@ &&DEBUG_HANDLE_OVERFLOW, &&DEBUG_HANDLE_OVERFLOW, &&DEBUG_HANDLE_OVERFLOW, + &&DEBUG_HANDLE_DEPRECATED, + &&DEBUG_HANDLE_WIDE, + &&DEBUG_HANDLE_THROW, &&DEBUG_HANDLE_OVERFLOW, \ No newline at end of file diff --git a/ecmascript/interpreter/templates/debugger_instruction_handler.inl b/ecmascript/interpreter/templates/debugger_instruction_handler.inl index 347b260ce6..9d1ee583ac 100644 --- a/ecmascript/interpreter/templates/debugger_instruction_handler.inl +++ b/ecmascript/interpreter/templates/debugger_instruction_handler.inl @@ -13,792 +13,1482 @@ * limitations under the License. */ - HANDLE_OPCODE(DEBUG_HANDLE_LDNAN_PREF) + DEBUG_HANDLE_OPCODE(LDNAN) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDNAN_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDNAN); } - HANDLE_OPCODE(DEBUG_HANDLE_LDINFINITY_PREF) + DEBUG_HANDLE_OPCODE(LDINFINITY) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDINFINITY_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDINFINITY); } - HANDLE_OPCODE(DEBUG_HANDLE_LDGLOBALTHIS_PREF) + DEBUG_HANDLE_OPCODE(LDGLOBALTHIS) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDGLOBALTHIS_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDGLOBALTHIS); } - HANDLE_OPCODE(DEBUG_HANDLE_LDUNDEFINED_PREF) + DEBUG_HANDLE_OPCODE(LDUNDEFINED) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDUNDEFINED_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDUNDEFINED); } - HANDLE_OPCODE(DEBUG_HANDLE_LDNULL_PREF) + DEBUG_HANDLE_OPCODE(LDNULL) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDNULL_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDNULL); } - HANDLE_OPCODE(DEBUG_HANDLE_LDSYMBOL_PREF) + DEBUG_HANDLE_OPCODE(LDSYMBOL) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDSYMBOL_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDSYMBOL); } - HANDLE_OPCODE(DEBUG_HANDLE_LDGLOBAL_PREF) + DEBUG_HANDLE_OPCODE(LDGLOBAL) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDGLOBAL_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDGLOBAL); } - HANDLE_OPCODE(DEBUG_HANDLE_LDTRUE_PREF) + DEBUG_HANDLE_OPCODE(LDTRUE) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDTRUE_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDTRUE); } - HANDLE_OPCODE(DEBUG_HANDLE_LDFALSE_PREF) + DEBUG_HANDLE_OPCODE(LDFALSE) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDFALSE_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDFALSE); } - HANDLE_OPCODE(DEBUG_HANDLE_THROWDYN_PREF) + DEBUG_HANDLE_OPCODE(LDHOLE) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::THROWDYN_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDHOLE); } - HANDLE_OPCODE(DEBUG_HANDLE_TYPEOFDYN_PREF) + DEBUG_HANDLE_OPCODE(LDNEWTARGET) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::TYPEOFDYN_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDNEWTARGET); } - HANDLE_OPCODE(DEBUG_HANDLE_LDLEXENVDYN_PREF) + DEBUG_HANDLE_OPCODE(POPLEXENV) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDLEXENVDYN_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::POPLEXENV); } - HANDLE_OPCODE(DEBUG_HANDLE_POPLEXENVDYN_PREF) + DEBUG_HANDLE_OPCODE(GETUNMAPPEDARGS) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::POPLEXENVDYN_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GETUNMAPPEDARGS); } - HANDLE_OPCODE(DEBUG_HANDLE_GETUNMAPPEDARGS_PREF) + DEBUG_HANDLE_OPCODE(ASYNCFUNCTIONENTER) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GETUNMAPPEDARGS_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ASYNCFUNCTIONENTER); } - HANDLE_OPCODE(DEBUG_HANDLE_GETPROPITERATOR_PREF) + DEBUG_HANDLE_OPCODE(LDTHIS) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GETPROPITERATOR_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDTHIS); } - HANDLE_OPCODE(DEBUG_HANDLE_ASYNCFUNCTIONENTER_PREF) + DEBUG_HANDLE_OPCODE(LDFUNCTION) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ASYNCFUNCTIONENTER_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDFUNCTION); } - HANDLE_OPCODE(DEBUG_HANDLE_LDHOLE_PREF) + DEBUG_HANDLE_OPCODE(DEBUGGER) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDHOLE_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DEBUGGER); } - HANDLE_OPCODE(DEBUG_HANDLE_RETURNUNDEFINED_PREF) + DEBUG_HANDLE_OPCODE(GETPROPITERATOR) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::RETURNUNDEFINED_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GETPROPITERATOR); } - HANDLE_OPCODE(DEBUG_HANDLE_CREATEEMPTYOBJECT_PREF) + DEBUG_HANDLE_OPCODE(GETITERATOR_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEEMPTYOBJECT_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GETITERATOR_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_CREATEEMPTYARRAY_PREF) + DEBUG_HANDLE_OPCODE(GETITERATOR_IMM16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEEMPTYARRAY_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GETITERATOR_IMM16); } - HANDLE_OPCODE(DEBUG_HANDLE_GETITERATOR_PREF) + DEBUG_HANDLE_OPCODE(CLOSEITERATOR_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GETITERATOR_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CLOSEITERATOR_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_THROWTHROWNOTEXISTS_PREF) + DEBUG_HANDLE_OPCODE(CLOSEITERATOR_IMM16_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::THROWTHROWNOTEXISTS_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CLOSEITERATOR_IMM16_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_THROWPATTERNNONCOERCIBLE_PREF) + DEBUG_HANDLE_OPCODE(CREATEASYNCGENERATOROBJ_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::THROWPATTERNNONCOERCIBLE_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEASYNCGENERATOROBJ_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_LDHOMEOBJECT_PREF) + DEBUG_HANDLE_OPCODE(CREATEEMPTYOBJECT) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDHOMEOBJECT_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEEMPTYOBJECT); } - HANDLE_OPCODE(DEBUG_HANDLE_THROWDELETESUPERPROPERTY_PREF) + DEBUG_HANDLE_OPCODE(CREATEEMPTYARRAY_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::THROWDELETESUPERPROPERTY_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEEMPTYARRAY_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_DEBUGGER_PREF) + DEBUG_HANDLE_OPCODE(CREATEEMPTYARRAY_IMM16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DEBUGGER_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEEMPTYARRAY_IMM16); } - HANDLE_OPCODE(DEBUG_HANDLE_ADD2DYN_PREF_V8) + DEBUG_HANDLE_OPCODE(CREATEGENERATOROBJ_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ADD2DYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEGENERATOROBJ_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_SUB2DYN_PREF_V8) + DEBUG_HANDLE_OPCODE(CREATEITERRESULTOBJ_V8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::SUB2DYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEITERRESULTOBJ_V8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_MUL2DYN_PREF_V8) + DEBUG_HANDLE_OPCODE(CREATEOBJECTWITHEXCLUDEDKEYS_IMM8_V8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::MUL2DYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEOBJECTWITHEXCLUDEDKEYS_IMM8_V8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_DIV2DYN_PREF_V8) + DEBUG_HANDLE_OPCODE(ASYNCGENERATORRESOLVE_V8_V8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DIV2DYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ASYNCGENERATORRESOLVE_V8_V8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_MOD2DYN_PREF_V8) + DEBUG_HANDLE_OPCODE(CREATEARRAYWITHBUFFER_IMM8_ID16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::MOD2DYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEARRAYWITHBUFFER_IMM8_ID16); } - HANDLE_OPCODE(DEBUG_HANDLE_EQDYN_PREF_V8) + DEBUG_HANDLE_OPCODE(CREATEARRAYWITHBUFFER_IMM16_ID16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::EQDYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEARRAYWITHBUFFER_IMM16_ID16); } - HANDLE_OPCODE(DEBUG_HANDLE_NOTEQDYN_PREF_V8) + DEBUG_HANDLE_OPCODE(CALLTHIS0_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::NOTEQDYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CALLTHIS0_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_LESSDYN_PREF_V8) + DEBUG_HANDLE_OPCODE(CALLTHIS1_IMM8_V8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LESSDYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CALLTHIS1_IMM8_V8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_LESSEQDYN_PREF_V8) + DEBUG_HANDLE_OPCODE(CREATEOBJECTWITHBUFFER_IMM8_ID16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LESSEQDYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEOBJECTWITHBUFFER_IMM8_ID16); } - HANDLE_OPCODE(DEBUG_HANDLE_GREATERDYN_PREF_V8) + DEBUG_HANDLE_OPCODE(CREATEOBJECTWITHBUFFER_IMM16_ID16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GREATERDYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEOBJECTWITHBUFFER_IMM16_ID16); } - HANDLE_OPCODE(DEBUG_HANDLE_GREATEREQDYN_PREF_V8) + DEBUG_HANDLE_OPCODE(CREATEREGEXPWITHLITERAL_IMM8_ID16_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GREATEREQDYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEREGEXPWITHLITERAL_IMM8_ID16_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_SHL2DYN_PREF_V8) + DEBUG_HANDLE_OPCODE(CREATEREGEXPWITHLITERAL_IMM16_ID16_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::SHL2DYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEREGEXPWITHLITERAL_IMM16_ID16_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_SHR2DYN_PREF_V8) + DEBUG_HANDLE_OPCODE(NEWOBJAPPLY_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::SHR2DYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::NEWOBJAPPLY_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_ASHR2DYN_PREF_V8) + DEBUG_HANDLE_OPCODE(NEWOBJAPPLY_IMM16_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ASHR2DYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::NEWOBJAPPLY_IMM16_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_AND2DYN_PREF_V8) + DEBUG_HANDLE_OPCODE(NEWOBJRANGE_IMM8_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::AND2DYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::NEWOBJRANGE_IMM8_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_OR2DYN_PREF_V8) + DEBUG_HANDLE_OPCODE(NEWOBJRANGE_IMM16_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::OR2DYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::NEWOBJRANGE_IMM16_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_XOR2DYN_PREF_V8) + DEBUG_HANDLE_OPCODE(NEWLEXENV_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::XOR2DYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::NEWLEXENV_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_TONUMBER_PREF_V8) + DEBUG_HANDLE_OPCODE(NEWLEXENVWITHNAME_IMM8_ID16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::TONUMBER_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::NEWLEXENVWITHNAME_IMM8_ID16); } - HANDLE_OPCODE(DEBUG_HANDLE_NEGDYN_PREF_V8) + DEBUG_HANDLE_OPCODE(ADD2_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::NEGDYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ADD2_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_NOTDYN_PREF_V8) + DEBUG_HANDLE_OPCODE(SUB2_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::NOTDYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::SUB2_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_INCDYN_PREF_V8) + DEBUG_HANDLE_OPCODE(MUL2_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::INCDYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::MUL2_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_DECDYN_PREF_V8) + DEBUG_HANDLE_OPCODE(DIV2_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DECDYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DIV2_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_EXPDYN_PREF_V8) + DEBUG_HANDLE_OPCODE(MOD2_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::EXPDYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::MOD2_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_ISINDYN_PREF_V8) + DEBUG_HANDLE_OPCODE(EQ_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ISINDYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::EQ_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_INSTANCEOFDYN_PREF_V8) + DEBUG_HANDLE_OPCODE(NOTEQ_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::INSTANCEOFDYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::NOTEQ_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_STRICTNOTEQDYN_PREF_V8) + DEBUG_HANDLE_OPCODE(LESS_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STRICTNOTEQDYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LESS_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_STRICTEQDYN_PREF_V8) + DEBUG_HANDLE_OPCODE(LESSEQ_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STRICTEQDYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LESSEQ_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_RESUMEGENERATOR_PREF_V8) + DEBUG_HANDLE_OPCODE(GREATER_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::RESUMEGENERATOR_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GREATER_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_GETRESUMEMODE_PREF_V8) + DEBUG_HANDLE_OPCODE(GREATEREQ_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GETRESUMEMODE_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GREATEREQ_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_CREATEGENERATOROBJ_PREF_V8) + DEBUG_HANDLE_OPCODE(SHL2_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEGENERATOROBJ_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::SHL2_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_THROWCONSTASSIGNMENT_PREF_V8) + DEBUG_HANDLE_OPCODE(SHR2_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::THROWCONSTASSIGNMENT_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::SHR2_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_GETTEMPLATEOBJECT_PREF_V8) + DEBUG_HANDLE_OPCODE(ASHR2_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GETTEMPLATEOBJECT_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ASHR2_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_GETNEXTPROPNAME_PREF_V8) + DEBUG_HANDLE_OPCODE(AND2_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GETNEXTPROPNAME_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::AND2_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_CALLARG0DYN_PREF_V8) + DEBUG_HANDLE_OPCODE(OR2_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CALLARG0DYN_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::OR2_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_THROWIFNOTOBJECT_PREF_V8) + DEBUG_HANDLE_OPCODE(XOR2_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::THROWIFNOTOBJECT_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::XOR2_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_ITERNEXT_PREF_V8) + DEBUG_HANDLE_OPCODE(EXP_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ITERNEXT_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::EXP_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_CLOSEITERATOR_PREF_V8) + DEBUG_HANDLE_OPCODE(TYPEOF_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CLOSEITERATOR_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::TYPEOF_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_COPYMODULE_PREF_V8) + DEBUG_HANDLE_OPCODE(TYPEOF_IMM16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::COPYMODULE_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::TYPEOF_IMM16); } - HANDLE_OPCODE(DEBUG_HANDLE_SUPERCALLSPREAD_PREF_V8) + DEBUG_HANDLE_OPCODE(TONUMBER_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::SUPERCALLSPREAD_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::TONUMBER_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_DELOBJPROP_PREF_V8_V8) + DEBUG_HANDLE_OPCODE(TONUMERIC_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DELOBJPROP_PREF_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::TONUMERIC_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_NEWOBJSPREADDYN_PREF_V8_V8) + DEBUG_HANDLE_OPCODE(NEG_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::NEWOBJSPREADDYN_PREF_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::NEG_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_CREATEITERRESULTOBJ_PREF_V8_V8) + DEBUG_HANDLE_OPCODE(NOT_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEITERRESULTOBJ_PREF_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::NOT_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_SUSPENDGENERATOR_PREF_V8_V8) + DEBUG_HANDLE_OPCODE(INC_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::SUSPENDGENERATOR_PREF_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::INC_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8) + DEBUG_HANDLE_OPCODE(DEC_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DEC_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_THROWUNDEFINEDIFHOLE_PREF_V8_V8) + DEBUG_HANDLE_OPCODE(ISIN_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::THROWUNDEFINEDIFHOLE_PREF_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ISIN_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_CALLARG1DYN_PREF_V8_V8) + DEBUG_HANDLE_OPCODE(INSTANCEOF_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CALLARG1DYN_PREF_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::INSTANCEOF_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_COPYDATAPROPERTIES_PREF_V8_V8) + DEBUG_HANDLE_OPCODE(STRICTNOTEQ_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::COPYDATAPROPERTIES_PREF_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STRICTNOTEQ_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_STARRAYSPREAD_PREF_V8_V8) + DEBUG_HANDLE_OPCODE(STRICTEQ_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STARRAYSPREAD_PREF_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STRICTEQ_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_GETITERATORNEXT_PREF_V8_V8) + DEBUG_HANDLE_OPCODE(ISTRUE) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GETITERATORNEXT_PREF_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ISTRUE); } - HANDLE_OPCODE(DEBUG_HANDLE_SETOBJECTWITHPROTO_PREF_V8_V8) + DEBUG_HANDLE_OPCODE(ISFALSE) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::SETOBJECTWITHPROTO_PREF_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ISFALSE); } - HANDLE_OPCODE(DEBUG_HANDLE_LDOBJBYVALUE_PREF_V8_V8) + DEBUG_HANDLE_OPCODE(CALLTHIS2_IMM8_V8_V8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDOBJBYVALUE_PREF_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CALLTHIS2_IMM8_V8_V8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_STOBJBYVALUE_PREF_V8_V8) + DEBUG_HANDLE_OPCODE(CALLTHIS3_IMM8_V8_V8_V8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOBJBYVALUE_PREF_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CALLTHIS3_IMM8_V8_V8_V8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_STOWNBYVALUE_PREF_V8_V8) + DEBUG_HANDLE_OPCODE(CALLTHISRANGE_IMM8_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOWNBYVALUE_PREF_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CALLTHISRANGE_IMM8_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_LDSUPERBYVALUE_PREF_V8_V8) + DEBUG_HANDLE_OPCODE(SUPERCALLTHISRANGE_IMM8_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDSUPERBYVALUE_PREF_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::SUPERCALLTHISRANGE_IMM8_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_STSUPERBYVALUE_PREF_V8_V8) + DEBUG_HANDLE_OPCODE(SUPERCALLARROWRANGE_IMM8_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STSUPERBYVALUE_PREF_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::SUPERCALLARROWRANGE_IMM8_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_LDOBJBYINDEX_PREF_V8_IMM32) + DEBUG_HANDLE_OPCODE(DEFINEFUNC_IMM8_ID16_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDOBJBYINDEX_PREF_V8_IMM32); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DEFINEFUNC_IMM8_ID16_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_STOBJBYINDEX_PREF_V8_IMM32) + DEBUG_HANDLE_OPCODE(DEFINEFUNC_IMM16_ID16_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOBJBYINDEX_PREF_V8_IMM32); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DEFINEFUNC_IMM16_ID16_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_STOWNBYINDEX_PREF_V8_IMM32) + DEBUG_HANDLE_OPCODE(DEFINEMETHOD_IMM8_ID16_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOWNBYINDEX_PREF_V8_IMM32); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DEFINEMETHOD_IMM8_ID16_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_CALLSPREADDYN_PREF_V8_V8_V8) + DEBUG_HANDLE_OPCODE(CALLARG0_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CALLSPREADDYN_PREF_V8_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CALLARG0_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8) + DEBUG_HANDLE_OPCODE(SUPERCALLSPREAD_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::SUPERCALLSPREAD_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8) + DEBUG_HANDLE_OPCODE(APPLY_IMM8_V8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ASYNCFUNCTIONREJECT_PREF_V8_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::APPLY_IMM8_V8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_CALLARGS2DYN_PREF_V8_V8_V8) + DEBUG_HANDLE_OPCODE(CALLARGS2_IMM8_V8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CALLARGS2DYN_PREF_V8_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CALLARGS2_IMM8_V8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_CALLARGS3DYN_PREF_V8_V8_V8_V8) + DEBUG_HANDLE_OPCODE(CALLARGS3_IMM8_V8_V8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CALLARGS3DYN_PREF_V8_V8_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CALLARGS3_IMM8_V8_V8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_DEFINEGETTERSETTERBYVALUE_PREF_V8_V8_V8_V8) + DEBUG_HANDLE_OPCODE(CALLRANGE_IMM8_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DEFINEGETTERSETTERBYVALUE_PREF_V8_V8_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CALLRANGE_IMM8_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_NEWOBJDYNRANGE_PREF_IMM16_V8) + DEBUG_HANDLE_OPCODE(DEPRECATED_CALLRANGE_PREF_IMM16_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::NEWOBJDYNRANGE_PREF_IMM16_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_CALLRANGE_PREF_IMM16_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_CALLIRANGEDYN_PREF_IMM16_V8) + DEBUG_HANDLE_OPCODE(DEFINEMETHOD_IMM16_ID16_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CALLIRANGEDYN_PREF_IMM16_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DEFINEMETHOD_IMM16_ID16_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_CALLITHISRANGEDYN_PREF_IMM16_V8) + DEBUG_HANDLE_OPCODE(LDEXTERNALMODULEVAR_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CALLITHISRANGEDYN_PREF_IMM16_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDEXTERNALMODULEVAR_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_SUPERCALL_PREF_IMM16_V8) + DEBUG_HANDLE_OPCODE(DEFINEGETTERSETTERBYVALUE_V8_V8_V8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::SUPERCALL_PREF_IMM16_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DEFINEGETTERSETTERBYVALUE_V8_V8_V8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8) + DEBUG_HANDLE_OPCODE(LDTHISBYNAME_IMM8_ID16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDTHISBYNAME_IMM8_ID16); } - HANDLE_OPCODE(DEBUG_HANDLE_DEFINEFUNCDYN_PREF_ID16_IMM16_V8) + DEBUG_HANDLE_OPCODE(LDTHISBYNAME_IMM16_ID16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DEFINEFUNCDYN_PREF_ID16_IMM16_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDTHISBYNAME_IMM16_ID16); } - HANDLE_OPCODE(DEBUG_HANDLE_DEFINENCFUNCDYN_PREF_ID16_IMM16_V8) + DEBUG_HANDLE_OPCODE(STTHISBYNAME_IMM8_ID16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DEFINENCFUNCDYN_PREF_ID16_IMM16_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STTHISBYNAME_IMM8_ID16); } - HANDLE_OPCODE(DEBUG_HANDLE_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8) + DEBUG_HANDLE_OPCODE(STTHISBYNAME_IMM16_ID16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STTHISBYNAME_IMM16_ID16); } - HANDLE_OPCODE(DEBUG_HANDLE_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8) + DEBUG_HANDLE_OPCODE(LDTHISBYVALUE_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDTHISBYVALUE_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8) + DEBUG_HANDLE_OPCODE(LDTHISBYVALUE_IMM16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DEFINEASYNCFUNC_PREF_ID16_IMM16_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDTHISBYVALUE_IMM16); } - HANDLE_OPCODE(DEBUG_HANDLE_DEFINEMETHOD_PREF_ID16_IMM16_V8) + DEBUG_HANDLE_OPCODE(STTHISBYVALUE_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DEFINEMETHOD_PREF_ID16_IMM16_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STTHISBYVALUE_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_NEWLEXENVDYN_PREF_IMM16) + DEBUG_HANDLE_OPCODE(STTHISBYVALUE_IMM16_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::NEWLEXENVDYN_PREF_IMM16); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STTHISBYVALUE_IMM16_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_COPYRESTARGS_PREF_IMM16) + DEBUG_HANDLE_OPCODE(LDPATCHVAR_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::COPYRESTARGS_PREF_IMM16); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDPATCHVAR_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_CREATEARRAYWITHBUFFER_PREF_IMM16) + DEBUG_HANDLE_OPCODE(STPATCHVAR_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEARRAYWITHBUFFER_PREF_IMM16); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STPATCHVAR_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_CREATEOBJECTHAVINGMETHOD_PREF_IMM16) + DEBUG_HANDLE_OPCODE(DEFINECLASSWITHBUFFER_IMM8_ID16_ID16_IMM16_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEOBJECTHAVINGMETHOD_PREF_IMM16); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DEFINECLASSWITHBUFFER_IMM8_ID16_ID16_IMM16_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_THROWIFSUPERNOTCORRECTCALL_PREF_IMM16) + DEBUG_HANDLE_OPCODE(DEFINECLASSWITHBUFFER_IMM16_ID16_ID16_IMM16_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::THROWIFSUPERNOTCORRECTCALL_PREF_IMM16); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DEFINECLASSWITHBUFFER_IMM16_ID16_ID16_IMM16_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_CREATEOBJECTWITHBUFFER_PREF_IMM16) + DEBUG_HANDLE_OPCODE(RESUMEGENERATOR) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEOBJECTWITHBUFFER_PREF_IMM16); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::RESUMEGENERATOR); } - HANDLE_OPCODE(DEBUG_HANDLE_LDLEXVARDYN_PREF_IMM4_IMM4) + DEBUG_HANDLE_OPCODE(GETRESUMEMODE) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDLEXVARDYN_PREF_IMM4_IMM4); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GETRESUMEMODE); } - HANDLE_OPCODE(DEBUG_HANDLE_LDLEXVARDYN_PREF_IMM8_IMM8) + DEBUG_HANDLE_OPCODE(GETTEMPLATEOBJECT_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDLEXVARDYN_PREF_IMM8_IMM8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GETTEMPLATEOBJECT_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_LDLEXVARDYN_PREF_IMM16_IMM16) + DEBUG_HANDLE_OPCODE(GETTEMPLATEOBJECT_IMM16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDLEXVARDYN_PREF_IMM16_IMM16); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GETTEMPLATEOBJECT_IMM16); } - HANDLE_OPCODE(DEBUG_HANDLE_STLEXVARDYN_PREF_IMM4_IMM4_V8) + DEBUG_HANDLE_OPCODE(GETNEXTPROPNAME_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STLEXVARDYN_PREF_IMM4_IMM4_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GETNEXTPROPNAME_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_STLEXVARDYN_PREF_IMM8_IMM8_V8) + DEBUG_HANDLE_OPCODE(JSTRICTEQZ_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STLEXVARDYN_PREF_IMM8_IMM8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JSTRICTEQZ_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_STLEXVARDYN_PREF_IMM16_IMM16_V8) + DEBUG_HANDLE_OPCODE(JSTRICTEQZ_IMM16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STLEXVARDYN_PREF_IMM16_IMM16_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JSTRICTEQZ_IMM16); } - HANDLE_OPCODE(DEBUG_HANDLE_NEWLEXENVWITHNAMEDYN_PREF_IMM16_IMM16) + DEBUG_HANDLE_OPCODE(SETOBJECTWITHPROTO_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::NEWLEXENVWITHNAMEDYN_PREF_IMM16_IMM16); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::SETOBJECTWITHPROTO_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8) + DEBUG_HANDLE_OPCODE(DELOBJPROP_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::DELOBJPROP_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_GETMODULENAMESPACE_PREF_ID32) + DEBUG_HANDLE_OPCODE(SUSPENDGENERATOR_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GETMODULENAMESPACE_PREF_ID32); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::SUSPENDGENERATOR_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_STMODULEVAR_PREF_ID32) + DEBUG_HANDLE_OPCODE(ASYNCFUNCTIONAWAITUNCAUGHT_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STMODULEVAR_PREF_ID32); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ASYNCFUNCTIONAWAITUNCAUGHT_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_TRYLDGLOBALBYNAME_PREF_ID32) + DEBUG_HANDLE_OPCODE(COPYDATAPROPERTIES_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::TRYLDGLOBALBYNAME_PREF_ID32); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::COPYDATAPROPERTIES_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_TRYSTGLOBALBYNAME_PREF_ID32) + DEBUG_HANDLE_OPCODE(STARRAYSPREAD_V8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::TRYSTGLOBALBYNAME_PREF_ID32); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STARRAYSPREAD_V8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_LDGLOBALVAR_PREF_ID32) + DEBUG_HANDLE_OPCODE(SETOBJECTWITHPROTO_IMM16_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDGLOBALVAR_PREF_ID32); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::SETOBJECTWITHPROTO_IMM16_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_STGLOBALVAR_PREF_ID32) + DEBUG_HANDLE_OPCODE(LDOBJBYVALUE_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STGLOBALVAR_PREF_ID32); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDOBJBYVALUE_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_LDOBJBYNAME_PREF_ID32_V8) + DEBUG_HANDLE_OPCODE(LDOBJBYVALUE_IMM16_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDOBJBYNAME_PREF_ID32_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDOBJBYVALUE_IMM16_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_STOBJBYNAME_PREF_ID32_V8) + DEBUG_HANDLE_OPCODE(STOBJBYVALUE_IMM8_V8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOBJBYNAME_PREF_ID32_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOBJBYVALUE_IMM8_V8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_STOWNBYNAME_PREF_ID32_V8) + DEBUG_HANDLE_OPCODE(STOBJBYVALUE_IMM16_V8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOWNBYNAME_PREF_ID32_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOBJBYVALUE_IMM16_V8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_LDSUPERBYNAME_PREF_ID32_V8) + DEBUG_HANDLE_OPCODE(STOWNBYVALUE_IMM8_V8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDSUPERBYNAME_PREF_ID32_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOWNBYVALUE_IMM8_V8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_STSUPERBYNAME_PREF_ID32_V8) + DEBUG_HANDLE_OPCODE(STOWNBYVALUE_IMM16_V8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STSUPERBYNAME_PREF_ID32_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOWNBYVALUE_IMM16_V8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_LDMODULEVAR_PREF_ID32_IMM8) + DEBUG_HANDLE_OPCODE(LDSUPERBYVALUE_IMM8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDMODULEVAR_PREF_ID32_IMM8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDSUPERBYVALUE_IMM8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_CREATEREGEXPWITHLITERAL_PREF_ID32_IMM8) + DEBUG_HANDLE_OPCODE(LDSUPERBYVALUE_IMM16_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEREGEXPWITHLITERAL_PREF_ID32_IMM8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDSUPERBYVALUE_IMM16_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_ISTRUE_PREF) + DEBUG_HANDLE_OPCODE(STSUPERBYVALUE_IMM8_V8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ISTRUE_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STSUPERBYVALUE_IMM8_V8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_ISFALSE_PREF) + DEBUG_HANDLE_OPCODE(STSUPERBYVALUE_IMM16_V8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ISFALSE_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STSUPERBYVALUE_IMM16_V8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_STCONSTTOGLOBALRECORD_PREF_ID32) + DEBUG_HANDLE_OPCODE(LDOBJBYINDEX_IMM8_IMM16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STCONSTTOGLOBALRECORD_PREF_ID32); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDOBJBYINDEX_IMM8_IMM16); } - HANDLE_OPCODE(DEBUG_HANDLE_STLETTOGLOBALRECORD_PREF_ID32) + DEBUG_HANDLE_OPCODE(LDOBJBYINDEX_IMM16_IMM16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STLETTOGLOBALRECORD_PREF_ID32); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDOBJBYINDEX_IMM16_IMM16); } - HANDLE_OPCODE(DEBUG_HANDLE_STCLASSTOGLOBALRECORD_PREF_ID32) + DEBUG_HANDLE_OPCODE(STOBJBYINDEX_IMM8_V8_IMM16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STCLASSTOGLOBALRECORD_PREF_ID32); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOBJBYINDEX_IMM8_V8_IMM16); } - HANDLE_OPCODE(DEBUG_HANDLE_STOWNBYVALUEWITHNAMESET_PREF_V8_V8) + DEBUG_HANDLE_OPCODE(STOBJBYINDEX_IMM16_V8_IMM16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOWNBYVALUEWITHNAMESET_PREF_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOBJBYINDEX_IMM16_V8_IMM16); } - HANDLE_OPCODE(DEBUG_HANDLE_STOWNBYNAMEWITHNAMESET_PREF_ID32_V8) + DEBUG_HANDLE_OPCODE(STOWNBYINDEX_IMM8_V8_IMM16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOWNBYNAMEWITHNAMESET_PREF_ID32_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOWNBYINDEX_IMM8_V8_IMM16); } - HANDLE_OPCODE(DEBUG_HANDLE_LDFUNCTION_PREF) + DEBUG_HANDLE_OPCODE(STOWNBYINDEX_IMM16_V8_IMM16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDFUNCTION_PREF); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOWNBYINDEX_IMM16_V8_IMM16); } - HANDLE_OPCODE(DEBUG_HANDLE_LDBIGINT_PREF_ID32) + DEBUG_HANDLE_OPCODE(ASYNCFUNCTIONRESOLVE_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDBIGINT_PREF_ID32); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ASYNCFUNCTIONRESOLVE_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_TONUMERIC_PREF_V8) + DEBUG_HANDLE_OPCODE(ASYNCFUNCTIONREJECT_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::TONUMERIC_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ASYNCFUNCTIONREJECT_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_CREATEASYNCGENERATOROBJ_PREF_V8) + DEBUG_HANDLE_OPCODE(COPYRESTARGS_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CREATEASYNCGENERATOROBJ_PREF_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::COPYRESTARGS_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_ASYNCGENERATORRESOLVE_PREF_V8_V8_V8) + DEBUG_HANDLE_OPCODE(LDLEXVAR_IMM4_IMM4) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::ASYNCGENERATORRESOLVE_PREF_V8_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDLEXVAR_IMM4_IMM4); } - HANDLE_OPCODE(DEBUG_HANDLE_MOV_DYN_V8_V8) + DEBUG_HANDLE_OPCODE(STLEXVAR_IMM4_IMM4) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::MOV_DYN_V8_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STLEXVAR_IMM4_IMM4); } - HANDLE_OPCODE(DEBUG_HANDLE_MOV_DYN_V16_V16) + DEBUG_HANDLE_OPCODE(GETMODULENAMESPACE_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::MOV_DYN_V16_V16); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::GETMODULENAMESPACE_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_LDA_STR_ID32) + DEBUG_HANDLE_OPCODE(STMODULEVAR_IMM8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDA_STR_ID32); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STMODULEVAR_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_LDAI_DYN_IMM32) + DEBUG_HANDLE_OPCODE(TRYLDGLOBALBYNAME_IMM8_ID16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDAI_DYN_IMM32); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::TRYLDGLOBALBYNAME_IMM8_ID16); } - HANDLE_OPCODE(DEBUG_HANDLE_FLDAI_DYN_IMM64) + DEBUG_HANDLE_OPCODE(TRYLDGLOBALBYNAME_IMM16_ID16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::FLDAI_DYN_IMM64); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::TRYLDGLOBALBYNAME_IMM16_ID16); } - HANDLE_OPCODE(DEBUG_HANDLE_JMP_IMM8) + DEBUG_HANDLE_OPCODE(TRYSTGLOBALBYNAME_IMM8_ID16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::TRYSTGLOBALBYNAME_IMM8_ID16); + } + DEBUG_HANDLE_OPCODE(TRYSTGLOBALBYNAME_IMM16_ID16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::TRYSTGLOBALBYNAME_IMM16_ID16); + } + DEBUG_HANDLE_OPCODE(LDGLOBALVAR_IMM16_ID16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDGLOBALVAR_IMM16_ID16); + } + DEBUG_HANDLE_OPCODE(STGLOBALVAR_IMM16_ID16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STGLOBALVAR_IMM16_ID16); + } + DEBUG_HANDLE_OPCODE(LDOBJBYNAME_IMM8_ID16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDOBJBYNAME_IMM8_ID16); + } + DEBUG_HANDLE_OPCODE(LDOBJBYNAME_IMM16_ID16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDOBJBYNAME_IMM16_ID16); + } + DEBUG_HANDLE_OPCODE(STOBJBYNAME_IMM8_ID16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOBJBYNAME_IMM8_ID16_V8); + } + DEBUG_HANDLE_OPCODE(STOBJBYNAME_IMM16_ID16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOBJBYNAME_IMM16_ID16_V8); + } + DEBUG_HANDLE_OPCODE(STOWNBYNAME_IMM8_ID16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOWNBYNAME_IMM8_ID16_V8); + } + DEBUG_HANDLE_OPCODE(STOWNBYNAME_IMM16_ID16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOWNBYNAME_IMM16_ID16_V8); + } + DEBUG_HANDLE_OPCODE(LDSUPERBYNAME_IMM8_ID16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDSUPERBYNAME_IMM8_ID16); + } + DEBUG_HANDLE_OPCODE(LDSUPERBYNAME_IMM16_ID16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDSUPERBYNAME_IMM16_ID16); + } + DEBUG_HANDLE_OPCODE(STSUPERBYNAME_IMM8_ID16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STSUPERBYNAME_IMM8_ID16_V8); + } + DEBUG_HANDLE_OPCODE(STSUPERBYNAME_IMM16_ID16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STSUPERBYNAME_IMM16_ID16_V8); + } + DEBUG_HANDLE_OPCODE(LDLOCALMODULEVAR_IMM8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDLOCALMODULEVAR_IMM8); + } + DEBUG_HANDLE_OPCODE(STCONSTTOGLOBALRECORD_IMM16_ID16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STCONSTTOGLOBALRECORD_IMM16_ID16); + } + DEBUG_HANDLE_OPCODE(STTOGLOBALRECORD_IMM16_ID16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STTOGLOBALRECORD_IMM16_ID16); + } + DEBUG_HANDLE_OPCODE(JNSTRICTEQZ_IMM8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JNSTRICTEQZ_IMM8); + } + DEBUG_HANDLE_OPCODE(JNSTRICTEQZ_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JNSTRICTEQZ_IMM16); + } + DEBUG_HANDLE_OPCODE(JEQNULL_IMM8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JEQNULL_IMM8); + } + DEBUG_HANDLE_OPCODE(JEQNULL_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JEQNULL_IMM16); + } + DEBUG_HANDLE_OPCODE(STOWNBYVALUEWITHNAMESET_IMM8_V8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOWNBYVALUEWITHNAMESET_IMM8_V8_V8); + } + DEBUG_HANDLE_OPCODE(STOWNBYVALUEWITHNAMESET_IMM16_V8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOWNBYVALUEWITHNAMESET_IMM16_V8_V8); + } + DEBUG_HANDLE_OPCODE(STOWNBYNAMEWITHNAMESET_IMM8_ID16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOWNBYNAMEWITHNAMESET_IMM8_ID16_V8); + } + DEBUG_HANDLE_OPCODE(STOWNBYNAMEWITHNAMESET_IMM16_ID16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STOWNBYNAMEWITHNAMESET_IMM16_ID16_V8); + } + DEBUG_HANDLE_OPCODE(LDBIGINT_ID16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDBIGINT_ID16); + } + DEBUG_HANDLE_OPCODE(LDA_STR_ID16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDA_STR_ID16); + } + DEBUG_HANDLE_OPCODE(JMP_IMM8) { NOTIFY_DEBUGGER_EVENT(); REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JMP_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_JMP_IMM16) + DEBUG_HANDLE_OPCODE(JMP_IMM16) { NOTIFY_DEBUGGER_EVENT(); REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JMP_IMM16); } - HANDLE_OPCODE(DEBUG_HANDLE_JMP_IMM32) + DEBUG_HANDLE_OPCODE(JMP_IMM32) { NOTIFY_DEBUGGER_EVENT(); REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JMP_IMM32); } - HANDLE_OPCODE(DEBUG_HANDLE_JEQZ_IMM8) + DEBUG_HANDLE_OPCODE(JEQZ_IMM8) { NOTIFY_DEBUGGER_EVENT(); REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JEQZ_IMM8); } - HANDLE_OPCODE(DEBUG_HANDLE_JEQZ_IMM16) + DEBUG_HANDLE_OPCODE(JEQZ_IMM16) { NOTIFY_DEBUGGER_EVENT(); REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JEQZ_IMM16); } - HANDLE_OPCODE(DEBUG_HANDLE_LDA_DYN_V8) + DEBUG_HANDLE_OPCODE(JNEZ_IMM8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JNEZ_IMM8); + } + DEBUG_HANDLE_OPCODE(JNEZ_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JNEZ_IMM16); + } + DEBUG_HANDLE_OPCODE(JNENULL_IMM8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JNENULL_IMM8); + } + DEBUG_HANDLE_OPCODE(JNENULL_IMM16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDA_DYN_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JNENULL_IMM16); } - HANDLE_OPCODE(DEBUG_HANDLE_STA_DYN_V8) + DEBUG_HANDLE_OPCODE(LDA_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STA_DYN_V8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDA_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_RETURN_DYN) + DEBUG_HANDLE_OPCODE(STA_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::RETURN_DYN); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STA_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_MOV_V4_V4) + DEBUG_HANDLE_OPCODE(LDAI_IMM32) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDAI_IMM32); + } + DEBUG_HANDLE_OPCODE(FLDAI_IMM64) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::FLDAI_IMM64); + } + DEBUG_HANDLE_OPCODE(RETURN) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::RETURN); + } + DEBUG_HANDLE_OPCODE(RETURNUNDEFINED) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::RETURNUNDEFINED); + } + DEBUG_HANDLE_OPCODE(LDLEXVAR_IMM8_IMM8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LDLEXVAR_IMM8_IMM8); + } + DEBUG_HANDLE_OPCODE(JSTRICTEQNULL_IMM8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JSTRICTEQNULL_IMM8); + } + DEBUG_HANDLE_OPCODE(STLEXVAR_IMM8_IMM8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::STLEXVAR_IMM8_IMM8); + } + DEBUG_HANDLE_OPCODE(JSTRICTEQNULL_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JSTRICTEQNULL_IMM16); + } + DEBUG_HANDLE_OPCODE(CALLARG1_IMM8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::CALLARG1_IMM8_V8); + } + DEBUG_HANDLE_OPCODE(JNSTRICTEQNULL_IMM8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JNSTRICTEQNULL_IMM8); + } + DEBUG_HANDLE_OPCODE(JNSTRICTEQNULL_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JNSTRICTEQNULL_IMM16); + } + DEBUG_HANDLE_OPCODE(JEQUNDEFINED_IMM8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JEQUNDEFINED_IMM8); + } + DEBUG_HANDLE_OPCODE(JEQUNDEFINED_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JEQUNDEFINED_IMM16); + } + DEBUG_HANDLE_OPCODE(JNEUNDEFINED_IMM8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JNEUNDEFINED_IMM8); + } + DEBUG_HANDLE_OPCODE(JNEUNDEFINED_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JNEUNDEFINED_IMM16); + } + DEBUG_HANDLE_OPCODE(JSTRICTEQUNDEFINED_IMM8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JSTRICTEQUNDEFINED_IMM8); + } + DEBUG_HANDLE_OPCODE(JSTRICTEQUNDEFINED_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JSTRICTEQUNDEFINED_IMM16); + } + DEBUG_HANDLE_OPCODE(JNSTRICTEQUNDEFINED_IMM8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JNSTRICTEQUNDEFINED_IMM8); + } + DEBUG_HANDLE_OPCODE(JNSTRICTEQUNDEFINED_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JNSTRICTEQUNDEFINED_IMM16); + } + DEBUG_HANDLE_OPCODE(JEQ_V8_IMM8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JEQ_V8_IMM8); + } + DEBUG_HANDLE_OPCODE(JEQ_V8_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JEQ_V8_IMM16); + } + DEBUG_HANDLE_OPCODE(JNE_V8_IMM8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JNE_V8_IMM8); + } + DEBUG_HANDLE_OPCODE(JNE_V8_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JNE_V8_IMM16); + } + DEBUG_HANDLE_OPCODE(JSTRICTEQ_V8_IMM8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JSTRICTEQ_V8_IMM8); + } + DEBUG_HANDLE_OPCODE(JSTRICTEQ_V8_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JSTRICTEQ_V8_IMM16); + } + DEBUG_HANDLE_OPCODE(JNSTRICTEQ_V8_IMM8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JNSTRICTEQ_V8_IMM8); + } + DEBUG_HANDLE_OPCODE(JNSTRICTEQ_V8_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JNSTRICTEQ_V8_IMM16); + } + DEBUG_HANDLE_OPCODE(MOV_V4_V4) { NOTIFY_DEBUGGER_EVENT(); REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::MOV_V4_V4); } - HANDLE_OPCODE(DEBUG_HANDLE_JNEZ_IMM8) + DEBUG_HANDLE_OPCODE(MOV_V8_V8) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JNEZ_IMM8); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::MOV_V8_V8); } - HANDLE_OPCODE(DEBUG_HANDLE_JNEZ_IMM16) + DEBUG_HANDLE_OPCODE(MOV_V16_V16) { NOTIFY_DEBUGGER_EVENT(); - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::JNEZ_IMM16); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::MOV_V16_V16); + } + DEBUG_HANDLE_OPCODE(NOP) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::NOP); + } + DEBUG_HANDLE_OPCODE(DEPRECATED) + { + NOTIFY_DEBUGGER_EVENT(); + DEBUG_DISPATCH_DEPRECATED(); + } + DEBUG_HANDLE_OPCODE(WIDE) + { + NOTIFY_DEBUGGER_EVENT(); + DEBUG_DISPATCH_WIDE(); + } + DEBUG_HANDLE_OPCODE(THROW) + { + NOTIFY_DEBUGGER_EVENT(); + DEBUG_DISPATCH_THROW(); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_LDLEXENV_PREF_NONE) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_LDLEXENV_PREF_NONE); + } + DEBUG_HANDLE_OPCODE(WIDE_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::WIDE_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8); + } + DEBUG_HANDLE_OPCODE(THROW_PREF_NONE) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::THROW_PREF_NONE); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_POPLEXENV_PREF_NONE) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_POPLEXENV_PREF_NONE); + } + DEBUG_HANDLE_OPCODE(WIDE_NEWOBJRANGE_PREF_IMM16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::WIDE_NEWOBJRANGE_PREF_IMM16_V8); + } + DEBUG_HANDLE_OPCODE(THROW_NOTEXISTS_PREF_NONE) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::THROW_NOTEXISTS_PREF_NONE); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_GETITERATORNEXT_PREF_V8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_GETITERATORNEXT_PREF_V8_V8); + } + DEBUG_HANDLE_OPCODE(WIDE_NEWLEXENV_PREF_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::WIDE_NEWLEXENV_PREF_IMM16); + } + DEBUG_HANDLE_OPCODE(THROW_PATTERNNONCOERCIBLE_PREF_NONE) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::THROW_PATTERNNONCOERCIBLE_PREF_NONE); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_CREATEARRAYWITHBUFFER_PREF_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_CREATEARRAYWITHBUFFER_PREF_IMM16); + } + DEBUG_HANDLE_OPCODE(WIDE_NEWLEXENVWITHNAME_PREF_IMM16_ID16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::WIDE_NEWLEXENVWITHNAME_PREF_IMM16_ID16); + } + DEBUG_HANDLE_OPCODE(THROW_DELETESUPERPROPERTY_PREF_NONE) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::THROW_DELETESUPERPROPERTY_PREF_NONE); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_CREATEOBJECTWITHBUFFER_PREF_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_CREATEOBJECTWITHBUFFER_PREF_IMM16); + } + DEBUG_HANDLE_OPCODE(WIDE_CALLRANGE_PREF_IMM16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::WIDE_CALLRANGE_PREF_IMM16_V8); + } + DEBUG_HANDLE_OPCODE(THROW_CONSTASSIGNMENT_PREF_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::THROW_CONSTASSIGNMENT_PREF_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_TONUMBER_PREF_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_TONUMBER_PREF_V8); + } + DEBUG_HANDLE_OPCODE(WIDE_CALLTHISRANGE_PREF_IMM16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::WIDE_CALLTHISRANGE_PREF_IMM16_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_CALLTHISRANGE_PREF_IMM16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_CALLTHISRANGE_PREF_IMM16_V8); + } + DEBUG_HANDLE_OPCODE(THROW_IFNOTOBJECT_PREF_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::THROW_IFNOTOBJECT_PREF_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_TONUMERIC_PREF_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_TONUMERIC_PREF_V8); + } + DEBUG_HANDLE_OPCODE(WIDE_SUPERCALLTHISRANGE_PREF_IMM16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::WIDE_SUPERCALLTHISRANGE_PREF_IMM16_V8); + } + DEBUG_HANDLE_OPCODE(THROW_UNDEFINEDIFHOLE_PREF_V8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::THROW_UNDEFINEDIFHOLE_PREF_V8_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_NEG_PREF_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_NEG_PREF_V8); + } + DEBUG_HANDLE_OPCODE(WIDE_SUPERCALLARROWRANGE_PREF_IMM16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::WIDE_SUPERCALLARROWRANGE_PREF_IMM16_V8); + } + DEBUG_HANDLE_OPCODE(THROW_IFSUPERNOTCORRECTCALL_PREF_IMM8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::THROW_IFSUPERNOTCORRECTCALL_PREF_IMM8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_NOT_PREF_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_NOT_PREF_V8); + } + DEBUG_HANDLE_OPCODE(WIDE_LDOBJBYINDEX_PREF_IMM32) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::WIDE_LDOBJBYINDEX_PREF_IMM32); + } + DEBUG_HANDLE_OPCODE(THROW_IFSUPERNOTCORRECTCALL_PREF_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::THROW_IFSUPERNOTCORRECTCALL_PREF_IMM16); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_INC_PREF_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_INC_PREF_V8); + } + DEBUG_HANDLE_OPCODE(WIDE_STOBJBYINDEX_PREF_V8_IMM32) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::WIDE_STOBJBYINDEX_PREF_V8_IMM32); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_DEC_PREF_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_DEC_PREF_V8); + } + DEBUG_HANDLE_OPCODE(WIDE_STOWNBYINDEX_PREF_V8_IMM32) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::WIDE_STOWNBYINDEX_PREF_V8_IMM32); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_CALLARG0_PREF_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_CALLARG0_PREF_V8); + } + DEBUG_HANDLE_OPCODE(WIDE_COPYRESTARGS_PREF_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::WIDE_COPYRESTARGS_PREF_IMM16); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_CALLARG1_PREF_V8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_CALLARG1_PREF_V8_V8); + } + DEBUG_HANDLE_OPCODE(WIDE_LDLEXVAR_PREF_IMM16_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::WIDE_LDLEXVAR_PREF_IMM16_IMM16); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_CALLARGS2_PREF_V8_V8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_CALLARGS2_PREF_V8_V8_V8); + } + DEBUG_HANDLE_OPCODE(WIDE_STLEXVAR_PREF_IMM16_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::WIDE_STLEXVAR_PREF_IMM16_IMM16); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_CALLARGS3_PREF_V8_V8_V8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_CALLARGS3_PREF_V8_V8_V8_V8); + } + DEBUG_HANDLE_OPCODE(WIDE_GETMODULENAMESPACE_PREF_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::WIDE_GETMODULENAMESPACE_PREF_IMM16); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_CALLSPREAD_PREF_V8_V8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_CALLSPREAD_PREF_V8_V8_V8); + } + DEBUG_HANDLE_OPCODE(WIDE_STMODULEVAR_PREF_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::WIDE_STMODULEVAR_PREF_IMM16); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_DEFINEFUNC_PREF_ID16_IMM16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_DEFINEFUNC_PREF_ID16_IMM16_V8); + } + DEBUG_HANDLE_OPCODE(WIDE_LDLOCALMODULEVAR_PREF_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::WIDE_LDLOCALMODULEVAR_PREF_IMM16); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_DEFINENCFUNC_PREF_ID16_IMM16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_DEFINENCFUNC_PREF_ID16_IMM16_V8); + } + DEBUG_HANDLE_OPCODE(WIDE_LDEXTERNALMODULEVAR_PREF_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::WIDE_LDEXTERNALMODULEVAR_PREF_IMM16); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_DEFINEMETHOD_PREF_ID16_IMM16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_DEFINEMETHOD_PREF_ID16_IMM16_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_RESUMEGENERATOR_PREF_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_RESUMEGENERATOR_PREF_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_GETRESUMEMODE_PREF_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_GETRESUMEMODE_PREF_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_GETTEMPLATEOBJECT_PREF_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_GETTEMPLATEOBJECT_PREF_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_DELOBJPROP_PREF_V8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_DELOBJPROP_PREF_V8_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_SUSPENDGENERATOR_PREF_V8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_SUSPENDGENERATOR_PREF_V8_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_COPYDATAPROPERTIES_PREF_V8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_COPYDATAPROPERTIES_PREF_V8_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_SETOBJECTWITHPROTO_PREF_V8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_SETOBJECTWITHPROTO_PREF_V8_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_LDOBJBYVALUE_PREF_V8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_LDOBJBYVALUE_PREF_V8_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_LDSUPERBYVALUE_PREF_V8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_LDSUPERBYVALUE_PREF_V8_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_LDOBJBYINDEX_PREF_V8_IMM32) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_LDOBJBYINDEX_PREF_V8_IMM32); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_STLEXVAR_PREF_IMM4_IMM4_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_STLEXVAR_PREF_IMM4_IMM4_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_STLEXVAR_PREF_IMM8_IMM8_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_STLEXVAR_PREF_IMM8_IMM8_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_STLEXVAR_PREF_IMM16_IMM16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_STLEXVAR_PREF_IMM16_IMM16_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_GETMODULENAMESPACE_PREF_ID32) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_GETMODULENAMESPACE_PREF_ID32); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_STMODULEVAR_PREF_ID32) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_STMODULEVAR_PREF_ID32); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_LDOBJBYNAME_PREF_ID32_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_LDOBJBYNAME_PREF_ID32_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_LDSUPERBYNAME_PREF_ID32_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_LDSUPERBYNAME_PREF_ID32_V8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_LDMODULEVAR_PREF_ID32_IMM8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_LDMODULEVAR_PREF_ID32_IMM8); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_STCONSTTOGLOBALRECORD_PREF_ID32) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_STCONSTTOGLOBALRECORD_PREF_ID32); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_STLETTOGLOBALRECORD_PREF_ID32) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_STLETTOGLOBALRECORD_PREF_ID32); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_STCLASSTOGLOBALRECORD_PREF_ID32) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_STCLASSTOGLOBALRECORD_PREF_ID32); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_LDHOMEOBJECT_PREF_NONE) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_LDHOMEOBJECT_PREF_NONE); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_CREATEOBJECTHAVINGMETHOD_PREF_IMM16) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_CREATEOBJECTHAVINGMETHOD_PREF_IMM16); + } + DEBUG_HANDLE_OPCODE(DEPRECATED_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8) + { + NOTIFY_DEBUGGER_EVENT(); + REAL_GOTO_SECOND_DISPATCH_OPCODE(EcmaOpcode::DEPRECATED_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8); } - HANDLE_OPCODE(DEBUG_EXCEPTION_HANDLER) + DEBUG_HANDLE_OPCODE(EXCEPTION) { NOTIFY_DEBUGGER_EXCEPTION_EVENT(); REAL_GOTO_EXCEPTION_HANDLER(); } - HANDLE_OPCODE(DEBUG_HANDLE_OVERFLOW) + DEBUG_HANDLE_OPCODE(OVERFLOW) { - REAL_GOTO_DISPATCH_OPCODE(EcmaOpcode::LAST_OPCODE + 1); + REAL_GOTO_DISPATCH_OPCODE(EXCEPTION_OPCODE + 1); } diff --git a/ecmascript/interpreter/templates/debugger_throw_instruction_dispatch.inl b/ecmascript/interpreter/templates/debugger_throw_instruction_dispatch.inl new file mode 100644 index 0000000000..beab15fb1a --- /dev/null +++ b/ecmascript/interpreter/templates/debugger_throw_instruction_dispatch.inl @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + &&DEBUG_HANDLE_THROW_PREF_NONE, + &&DEBUG_HANDLE_THROW_NOTEXISTS_PREF_NONE, + &&DEBUG_HANDLE_THROW_PATTERNNONCOERCIBLE_PREF_NONE, + &&DEBUG_HANDLE_THROW_DELETESUPERPROPERTY_PREF_NONE, + &&DEBUG_HANDLE_THROW_CONSTASSIGNMENT_PREF_V8, + &&DEBUG_HANDLE_THROW_IFNOTOBJECT_PREF_V8, + &&DEBUG_HANDLE_THROW_UNDEFINEDIFHOLE_PREF_V8_V8, + &&DEBUG_HANDLE_THROW_IFSUPERNOTCORRECTCALL_PREF_IMM8, + &&DEBUG_HANDLE_THROW_IFSUPERNOTCORRECTCALL_PREF_IMM16, diff --git a/ecmascript/interpreter/templates/debugger_wide_instruction_dispatch.inl b/ecmascript/interpreter/templates/debugger_wide_instruction_dispatch.inl new file mode 100644 index 0000000000..df7cc3f898 --- /dev/null +++ b/ecmascript/interpreter/templates/debugger_wide_instruction_dispatch.inl @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + &&DEBUG_HANDLE_WIDE_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8, + &&DEBUG_HANDLE_WIDE_NEWOBJRANGE_PREF_IMM16_V8, + &&DEBUG_HANDLE_WIDE_NEWLEXENV_PREF_IMM16, + &&DEBUG_HANDLE_WIDE_NEWLEXENVWITHNAME_PREF_IMM16_ID16, + &&DEBUG_HANDLE_WIDE_CALLRANGE_PREF_IMM16_V8, + &&DEBUG_HANDLE_WIDE_CALLTHISRANGE_PREF_IMM16_V8, + &&DEBUG_HANDLE_WIDE_SUPERCALLTHISRANGE_PREF_IMM16_V8, + &&DEBUG_HANDLE_WIDE_SUPERCALLARROWRANGE_PREF_IMM16_V8, + &&DEBUG_HANDLE_WIDE_LDOBJBYINDEX_PREF_IMM32, + &&DEBUG_HANDLE_WIDE_STOBJBYINDEX_PREF_V8_IMM32, + &&DEBUG_HANDLE_WIDE_STOWNBYINDEX_PREF_V8_IMM32, + &&DEBUG_HANDLE_WIDE_COPYRESTARGS_PREF_IMM16, + &&DEBUG_HANDLE_WIDE_LDLEXVAR_PREF_IMM16_IMM16, + &&DEBUG_HANDLE_WIDE_STLEXVAR_PREF_IMM16_IMM16, + &&DEBUG_HANDLE_WIDE_GETMODULENAMESPACE_PREF_IMM16, + &&DEBUG_HANDLE_WIDE_STMODULEVAR_PREF_IMM16, + &&DEBUG_HANDLE_WIDE_LDLOCALMODULEVAR_PREF_IMM16, + &&DEBUG_HANDLE_WIDE_LDEXTERNALMODULEVAR_PREF_IMM16, \ No newline at end of file diff --git a/ecmascript/interpreter/templates/deprecated_instruction_dispatch.inl b/ecmascript/interpreter/templates/deprecated_instruction_dispatch.inl new file mode 100644 index 0000000000..65e356a228 --- /dev/null +++ b/ecmascript/interpreter/templates/deprecated_instruction_dispatch.inl @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + &&HANDLE_DEPRECATED_LDLEXENV_PREF_NONE, + &&HANDLE_DEPRECATED_POPLEXENV_PREF_NONE, + &&HANDLE_DEPRECATED_GETITERATORNEXT_PREF_V8_V8, + &&HANDLE_DEPRECATED_CREATEARRAYWITHBUFFER_PREF_IMM16, + &&HANDLE_DEPRECATED_CREATEOBJECTWITHBUFFER_PREF_IMM16, + &&HANDLE_DEPRECATED_TONUMBER_PREF_V8, + &&HANDLE_DEPRECATED_TONUMERIC_PREF_V8, + &&HANDLE_DEPRECATED_NEG_PREF_V8, + &&HANDLE_DEPRECATED_NOT_PREF_V8, + &&HANDLE_DEPRECATED_INC_PREF_V8, + &&HANDLE_DEPRECATED_DEC_PREF_V8, + &&HANDLE_DEPRECATED_CALLARG0_PREF_V8, + &&HANDLE_DEPRECATED_CALLARG1_PREF_V8_V8, + &&HANDLE_DEPRECATED_CALLARGS2_PREF_V8_V8_V8, + &&HANDLE_DEPRECATED_CALLARGS3_PREF_V8_V8_V8_V8, + &&HANDLE_DEPRECATED_CALLRANGE_PREF_IMM16_V8, + &&HANDLE_DEPRECATED_CALLSPREAD_PREF_V8_V8_V8, + &&HANDLE_DEPRECATED_CALLTHISRANGE_PREF_IMM16_V8, + &&HANDLE_DEPRECATED_DEFINEFUNC_PREF_ID16_IMM16_V8, + &&HANDLE_DEPRECATED_DEFINENCFUNC_PREF_ID16_IMM16_V8, + &&HANDLE_DEPRECATED_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8, + &&HANDLE_DEPRECATED_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8, + &&HANDLE_DEPRECATED_DEFINEMETHOD_PREF_ID16_IMM16_V8, + &&HANDLE_DEPRECATED_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8, + &&HANDLE_DEPRECATED_RESUMEGENERATOR_PREF_V8, + &&HANDLE_DEPRECATED_GETRESUMEMODE_PREF_V8, + &&HANDLE_DEPRECATED_GETTEMPLATEOBJECT_PREF_V8, + &&HANDLE_DEPRECATED_DELOBJPROP_PREF_V8_V8, + &&HANDLE_DEPRECATED_SUSPENDGENERATOR_PREF_V8_V8, + &&HANDLE_DEPRECATED_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8, + &&HANDLE_DEPRECATED_COPYDATAPROPERTIES_PREF_V8_V8, + &&HANDLE_DEPRECATED_SETOBJECTWITHPROTO_PREF_V8_V8, + &&HANDLE_DEPRECATED_LDOBJBYVALUE_PREF_V8_V8, + &&HANDLE_DEPRECATED_LDSUPERBYVALUE_PREF_V8_V8, + &&HANDLE_DEPRECATED_LDOBJBYINDEX_PREF_V8_IMM32, + &&HANDLE_DEPRECATED_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8, + &&HANDLE_DEPRECATED_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8, + &&HANDLE_DEPRECATED_STLEXVAR_PREF_IMM4_IMM4_V8, + &&HANDLE_DEPRECATED_STLEXVAR_PREF_IMM8_IMM8_V8, + &&HANDLE_DEPRECATED_STLEXVAR_PREF_IMM16_IMM16_V8, + &&HANDLE_DEPRECATED_GETMODULENAMESPACE_PREF_ID32, + &&HANDLE_DEPRECATED_STMODULEVAR_PREF_ID32, + &&HANDLE_DEPRECATED_LDOBJBYNAME_PREF_ID32_V8, + &&HANDLE_DEPRECATED_LDSUPERBYNAME_PREF_ID32_V8, + &&HANDLE_DEPRECATED_LDMODULEVAR_PREF_ID32_IMM8, + &&HANDLE_DEPRECATED_STCONSTTOGLOBALRECORD_PREF_ID32, + &&HANDLE_DEPRECATED_STLETTOGLOBALRECORD_PREF_ID32, + &&HANDLE_DEPRECATED_STCLASSTOGLOBALRECORD_PREF_ID32, + &&HANDLE_DEPRECATED_LDHOMEOBJECT_PREF_NONE, + &&HANDLE_DEPRECATED_CREATEOBJECTHAVINGMETHOD_PREF_IMM16, + &&HANDLE_DEPRECATED_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8, \ No newline at end of file diff --git a/ecmascript/interpreter/templates/instruction_dispatch.inl b/ecmascript/interpreter/templates/instruction_dispatch.inl index 9a1dc0a7a7..c78e432af2 100644 --- a/ecmascript/interpreter/templates/instruction_dispatch.inl +++ b/ecmascript/interpreter/templates/instruction_dispatch.inl @@ -13,224 +13,220 @@ * limitations under the License. */ - &&HANDLE_LDNAN_PREF, - &&HANDLE_LDINFINITY_PREF, - &&HANDLE_LDGLOBALTHIS_PREF, - &&HANDLE_LDUNDEFINED_PREF, - &&HANDLE_LDNULL_PREF, - &&HANDLE_LDSYMBOL_PREF, - &&HANDLE_LDGLOBAL_PREF, - &&HANDLE_LDTRUE_PREF, - &&HANDLE_LDFALSE_PREF, - &&HANDLE_THROWDYN_PREF, - &&HANDLE_TYPEOFDYN_PREF, - &&HANDLE_LDLEXENVDYN_PREF, - &&HANDLE_POPLEXENVDYN_PREF, - &&HANDLE_GETUNMAPPEDARGS_PREF, - &&HANDLE_GETPROPITERATOR_PREF, - &&HANDLE_ASYNCFUNCTIONENTER_PREF, - &&HANDLE_LDHOLE_PREF, - &&HANDLE_RETURNUNDEFINED_PREF, - &&HANDLE_CREATEEMPTYOBJECT_PREF, - &&HANDLE_CREATEEMPTYARRAY_PREF, - &&HANDLE_GETITERATOR_PREF, - &&HANDLE_THROWTHROWNOTEXISTS_PREF, - &&HANDLE_THROWPATTERNNONCOERCIBLE_PREF, - &&HANDLE_LDHOMEOBJECT_PREF, - &&HANDLE_THROWDELETESUPERPROPERTY_PREF, - &&HANDLE_DEBUGGER_PREF, - &&HANDLE_ADD2DYN_PREF_V8, - &&HANDLE_SUB2DYN_PREF_V8, - &&HANDLE_MUL2DYN_PREF_V8, - &&HANDLE_DIV2DYN_PREF_V8, - &&HANDLE_MOD2DYN_PREF_V8, - &&HANDLE_EQDYN_PREF_V8, - &&HANDLE_NOTEQDYN_PREF_V8, - &&HANDLE_LESSDYN_PREF_V8, - &&HANDLE_LESSEQDYN_PREF_V8, - &&HANDLE_GREATERDYN_PREF_V8, - &&HANDLE_GREATEREQDYN_PREF_V8, - &&HANDLE_SHL2DYN_PREF_V8, - &&HANDLE_ASHR2DYN_PREF_V8, - &&HANDLE_SHR2DYN_PREF_V8, - &&HANDLE_AND2DYN_PREF_V8, - &&HANDLE_OR2DYN_PREF_V8, - &&HANDLE_XOR2DYN_PREF_V8, - &&HANDLE_TONUMBER_PREF_V8, - &&HANDLE_NEGDYN_PREF_V8, - &&HANDLE_NOTDYN_PREF_V8, - &&HANDLE_INCDYN_PREF_V8, - &&HANDLE_DECDYN_PREF_V8, - &&HANDLE_EXPDYN_PREF_V8, - &&HANDLE_ISINDYN_PREF_V8, - &&HANDLE_INSTANCEOFDYN_PREF_V8, - &&HANDLE_STRICTNOTEQDYN_PREF_V8, - &&HANDLE_STRICTEQDYN_PREF_V8, - &&HANDLE_RESUMEGENERATOR_PREF_V8, - &&HANDLE_GETRESUMEMODE_PREF_V8, - &&HANDLE_CREATEGENERATOROBJ_PREF_V8, - &&HANDLE_THROWCONSTASSIGNMENT_PREF_V8, - &&HANDLE_GETTEMPLATEOBJECT_PREF_V8, - &&HANDLE_GETNEXTPROPNAME_PREF_V8, - &&HANDLE_CALLARG0DYN_PREF_V8, - &&HANDLE_THROWIFNOTOBJECT_PREF_V8, - &&HANDLE_ITERNEXT_PREF_V8, - &&HANDLE_CLOSEITERATOR_PREF_V8, - &&HANDLE_COPYMODULE_PREF_V8, - &&HANDLE_SUPERCALLSPREAD_PREF_V8, - &&HANDLE_DELOBJPROP_PREF_V8_V8, - &&HANDLE_NEWOBJSPREADDYN_PREF_V8_V8, - &&HANDLE_CREATEITERRESULTOBJ_PREF_V8_V8, - &&HANDLE_SUSPENDGENERATOR_PREF_V8_V8, - &&HANDLE_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8, - &&HANDLE_THROWUNDEFINEDIFHOLE_PREF_V8_V8, - &&HANDLE_CALLARG1DYN_PREF_V8_V8, - &&HANDLE_COPYDATAPROPERTIES_PREF_V8_V8, - &&HANDLE_STARRAYSPREAD_PREF_V8_V8, - &&HANDLE_GETITERATORNEXT_PREF_V8_V8, - &&HANDLE_SETOBJECTWITHPROTO_PREF_V8_V8, - &&HANDLE_LDOBJBYVALUE_PREF_V8_V8, - &&HANDLE_STOBJBYVALUE_PREF_V8_V8, - &&HANDLE_STOWNBYVALUE_PREF_V8_V8, - &&HANDLE_LDSUPERBYVALUE_PREF_V8_V8, - &&HANDLE_STSUPERBYVALUE_PREF_V8_V8, - &&HANDLE_LDOBJBYINDEX_PREF_V8_IMM32, - &&HANDLE_STOBJBYINDEX_PREF_V8_IMM32, - &&HANDLE_STOWNBYINDEX_PREF_V8_IMM32, - &&HANDLE_CALLSPREADDYN_PREF_V8_V8_V8, - &&HANDLE_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8, - &&HANDLE_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8, - &&HANDLE_CALLARGS2DYN_PREF_V8_V8_V8, - &&HANDLE_CALLARGS3DYN_PREF_V8_V8_V8_V8, - &&HANDLE_DEFINEGETTERSETTERBYVALUE_PREF_V8_V8_V8_V8, - &&HANDLE_NEWOBJDYNRANGE_PREF_IMM16_V8, - &&HANDLE_CALLIRANGEDYN_PREF_IMM16_V8, - &&HANDLE_CALLITHISRANGEDYN_PREF_IMM16_V8, - &&HANDLE_SUPERCALL_PREF_IMM16_V8, - &&HANDLE_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8, - &&HANDLE_DEFINEFUNCDYN_PREF_ID16_IMM16_V8, - &&HANDLE_DEFINENCFUNCDYN_PREF_ID16_IMM16_V8, - &&HANDLE_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8, - &&HANDLE_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8, - &&HANDLE_DEFINEMETHOD_PREF_ID16_IMM16_V8, - &&HANDLE_NEWLEXENVDYN_PREF_IMM16, - &&HANDLE_COPYRESTARGS_PREF_IMM16, - &&HANDLE_CREATEARRAYWITHBUFFER_PREF_IMM16, - &&HANDLE_CREATEOBJECTHAVINGMETHOD_PREF_IMM16, - &&HANDLE_THROWIFSUPERNOTCORRECTCALL_PREF_IMM16, - &&HANDLE_CREATEOBJECTWITHBUFFER_PREF_IMM16, - &&HANDLE_LDLEXVARDYN_PREF_IMM4_IMM4, - &&HANDLE_LDLEXVARDYN_PREF_IMM8_IMM8, - &&HANDLE_LDLEXVARDYN_PREF_IMM16_IMM16, - &&HANDLE_STLEXVARDYN_PREF_IMM4_IMM4_V8, - &&HANDLE_STLEXVARDYN_PREF_IMM8_IMM8_V8, - &&HANDLE_STLEXVARDYN_PREF_IMM16_IMM16_V8, - &&HANDLE_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8, - &&HANDLE_GETMODULENAMESPACE_PREF_ID32, - &&HANDLE_STMODULEVAR_PREF_ID32, - &&HANDLE_TRYLDGLOBALBYNAME_PREF_ID32, - &&HANDLE_TRYSTGLOBALBYNAME_PREF_ID32, - &&HANDLE_LDGLOBALVAR_PREF_ID32, - &&HANDLE_STGLOBALVAR_PREF_ID32, - &&HANDLE_LDOBJBYNAME_PREF_ID32_V8, - &&HANDLE_STOBJBYNAME_PREF_ID32_V8, - &&HANDLE_STOWNBYNAME_PREF_ID32_V8, - &&HANDLE_LDSUPERBYNAME_PREF_ID32_V8, - &&HANDLE_STSUPERBYNAME_PREF_ID32_V8, - &&HANDLE_LDMODULEVAR_PREF_ID32_IMM8, - &&HANDLE_CREATEREGEXPWITHLITERAL_PREF_ID32_IMM8, - &&HANDLE_ISTRUE_PREF, - &&HANDLE_ISFALSE_PREF, - &&HANDLE_STCONSTTOGLOBALRECORD_PREF_ID32, - &&HANDLE_STLETTOGLOBALRECORD_PREF_ID32, - &&HANDLE_STCLASSTOGLOBALRECORD_PREF_ID32, - &&HANDLE_STOWNBYVALUEWITHNAMESET_PREF_V8_V8, - &&HANDLE_STOWNBYNAMEWITHNAMESET_PREF_ID32_V8, - &&HANDLE_LDFUNCTION_PREF, - &&HANDLE_NEWLEXENVWITHNAMEDYN_PREF_IMM16_IMM16, - &&HANDLE_LDBIGINT_PREF_ID32, - &&HANDLE_TONUMERIC_PREF_V8, - &&HANDLE_CREATEASYNCGENERATOROBJ_PREF_V8, - &&HANDLE_ASYNCGENERATORRESOLVE_PREF_V8_V8_V8, - &&HANDLE_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8, - &&HANDLE_MOV_DYN_V8_V8, - &&HANDLE_MOV_DYN_V16_V16, - &&HANDLE_LDA_STR_ID32, - &&HANDLE_LDAI_DYN_IMM32, - &&HANDLE_FLDAI_DYN_IMM64, + &&HANDLE_LDNAN, + &&HANDLE_LDINFINITY, + &&HANDLE_LDGLOBALTHIS, + &&HANDLE_LDUNDEFINED, + &&HANDLE_LDNULL, + &&HANDLE_LDSYMBOL, + &&HANDLE_LDGLOBAL, + &&HANDLE_LDTRUE, + &&HANDLE_LDFALSE, + &&HANDLE_LDHOLE, + &&HANDLE_LDNEWTARGET, + &&HANDLE_POPLEXENV, + &&HANDLE_GETUNMAPPEDARGS, + &&HANDLE_ASYNCFUNCTIONENTER, + &&HANDLE_LDTHIS, + &&HANDLE_LDFUNCTION, + &&HANDLE_DEBUGGER, + &&HANDLE_GETPROPITERATOR, + &&HANDLE_GETITERATOR_IMM8, + &&HANDLE_GETITERATOR_IMM16, + &&HANDLE_CLOSEITERATOR_IMM8_V8, + &&HANDLE_CLOSEITERATOR_IMM16_V8, + &&HANDLE_CREATEASYNCGENERATOROBJ_V8, + &&HANDLE_CREATEEMPTYOBJECT, + &&HANDLE_CREATEEMPTYARRAY_IMM8, + &&HANDLE_CREATEEMPTYARRAY_IMM16, + &&HANDLE_CREATEGENERATOROBJ_V8, + &&HANDLE_CREATEITERRESULTOBJ_V8_V8, + &&HANDLE_CREATEOBJECTWITHEXCLUDEDKEYS_IMM8_V8_V8, + &&HANDLE_ASYNCGENERATORRESOLVE_V8_V8_V8, + &&HANDLE_CREATEARRAYWITHBUFFER_IMM8_ID16, + &&HANDLE_CREATEARRAYWITHBUFFER_IMM16_ID16, + &&HANDLE_CALLTHIS0_IMM8_V8, + &&HANDLE_CALLTHIS1_IMM8_V8_V8, + &&HANDLE_CREATEOBJECTWITHBUFFER_IMM8_ID16, + &&HANDLE_CREATEOBJECTWITHBUFFER_IMM16_ID16, + &&HANDLE_CREATEREGEXPWITHLITERAL_IMM8_ID16_IMM8, + &&HANDLE_CREATEREGEXPWITHLITERAL_IMM16_ID16_IMM8, + &&HANDLE_NEWOBJAPPLY_IMM8_V8, + &&HANDLE_NEWOBJAPPLY_IMM16_V8, + &&HANDLE_NEWOBJRANGE_IMM8_IMM8_V8, + &&HANDLE_NEWOBJRANGE_IMM16_IMM8_V8, + &&HANDLE_NEWLEXENV_IMM8, + &&HANDLE_NEWLEXENVWITHNAME_IMM8_ID16, + &&HANDLE_ADD2_IMM8_V8, + &&HANDLE_SUB2_IMM8_V8, + &&HANDLE_MUL2_IMM8_V8, + &&HANDLE_DIV2_IMM8_V8, + &&HANDLE_MOD2_IMM8_V8, + &&HANDLE_EQ_IMM8_V8, + &&HANDLE_NOTEQ_IMM8_V8, + &&HANDLE_LESS_IMM8_V8, + &&HANDLE_LESSEQ_IMM8_V8, + &&HANDLE_GREATER_IMM8_V8, + &&HANDLE_GREATEREQ_IMM8_V8, + &&HANDLE_SHL2_IMM8_V8, + &&HANDLE_SHR2_IMM8_V8, + &&HANDLE_ASHR2_IMM8_V8, + &&HANDLE_AND2_IMM8_V8, + &&HANDLE_OR2_IMM8_V8, + &&HANDLE_XOR2_IMM8_V8, + &&HANDLE_EXP_IMM8_V8, + &&HANDLE_TYPEOF_IMM8, + &&HANDLE_TYPEOF_IMM16, + &&HANDLE_TONUMBER_IMM8, + &&HANDLE_TONUMERIC_IMM8, + &&HANDLE_NEG_IMM8, + &&HANDLE_NOT_IMM8, + &&HANDLE_INC_IMM8, + &&HANDLE_DEC_IMM8, + &&HANDLE_ISIN_IMM8_V8, + &&HANDLE_INSTANCEOF_IMM8_V8, + &&HANDLE_STRICTNOTEQ_IMM8_V8, + &&HANDLE_STRICTEQ_IMM8_V8, + &&HANDLE_ISTRUE, + &&HANDLE_ISFALSE, + &&HANDLE_CALLTHIS2_IMM8_V8_V8_V8, + &&HANDLE_CALLTHIS3_IMM8_V8_V8_V8_V8, + &&HANDLE_CALLTHISRANGE_IMM8_IMM8_V8, + &&HANDLE_SUPERCALLTHISRANGE_IMM8_IMM8_V8, + &&HANDLE_SUPERCALLARROWRANGE_IMM8_IMM8_V8, + &&HANDLE_DEFINEFUNC_IMM8_ID16_IMM8, + &&HANDLE_DEFINEFUNC_IMM16_ID16_IMM8, + &&HANDLE_DEFINEMETHOD_IMM8_ID16_IMM8, + &&HANDLE_CALLARG0_IMM8, + &&HANDLE_SUPERCALLSPREAD_IMM8_V8, + &&HANDLE_APPLY_IMM8_V8_V8, + &&HANDLE_CALLARGS2_IMM8_V8_V8, + &&HANDLE_CALLARGS3_IMM8_V8_V8_V8, + &&HANDLE_CALLRANGE_IMM8_IMM8_V8, + &&HANDLE_DEFINEMETHOD_IMM16_ID16_IMM8, + &&HANDLE_LDEXTERNALMODULEVAR_IMM8, + &&HANDLE_DEFINEGETTERSETTERBYVALUE_V8_V8_V8_V8, + &&HANDLE_LDTHISBYNAME_IMM8_ID16, + &&HANDLE_LDTHISBYNAME_IMM16_ID16, + &&HANDLE_STTHISBYNAME_IMM8_ID16, + &&HANDLE_STTHISBYNAME_IMM16_ID16, + &&HANDLE_LDTHISBYVALUE_IMM8, + &&HANDLE_LDTHISBYVALUE_IMM16, + &&HANDLE_STTHISBYVALUE_IMM8_V8, + &&HANDLE_STTHISBYVALUE_IMM16_V8, + &&HANDLE_LDPATCHVAR_IMM8, + &&HANDLE_STPATCHVAR_IMM8_V8, + &&HANDLE_DEFINECLASSWITHBUFFER_IMM8_ID16_ID16_IMM16_V8, + &&HANDLE_DEFINECLASSWITHBUFFER_IMM16_ID16_ID16_IMM16_V8, + &&HANDLE_RESUMEGENERATOR, + &&HANDLE_GETRESUMEMODE, + &&HANDLE_GETTEMPLATEOBJECT_IMM8, + &&HANDLE_GETTEMPLATEOBJECT_IMM16, + &&HANDLE_GETNEXTPROPNAME_V8, + &&HANDLE_JSTRICTEQZ_IMM8, + &&HANDLE_JSTRICTEQZ_IMM16, + &&HANDLE_SETOBJECTWITHPROTO_IMM8_V8, + &&HANDLE_DELOBJPROP_V8, + &&HANDLE_SUSPENDGENERATOR_V8, + &&HANDLE_ASYNCFUNCTIONAWAITUNCAUGHT_V8, + &&HANDLE_COPYDATAPROPERTIES_V8, + &&HANDLE_STARRAYSPREAD_V8_V8, + &&HANDLE_SETOBJECTWITHPROTO_IMM16_V8, + &&HANDLE_LDOBJBYVALUE_IMM8_V8, + &&HANDLE_LDOBJBYVALUE_IMM16_V8, + &&HANDLE_STOBJBYVALUE_IMM8_V8_V8, + &&HANDLE_STOBJBYVALUE_IMM16_V8_V8, + &&HANDLE_STOWNBYVALUE_IMM8_V8_V8, + &&HANDLE_STOWNBYVALUE_IMM16_V8_V8, + &&HANDLE_LDSUPERBYVALUE_IMM8_V8, + &&HANDLE_LDSUPERBYVALUE_IMM16_V8, + &&HANDLE_STSUPERBYVALUE_IMM8_V8_V8, + &&HANDLE_STSUPERBYVALUE_IMM16_V8_V8, + &&HANDLE_LDOBJBYINDEX_IMM8_IMM16, + &&HANDLE_LDOBJBYINDEX_IMM16_IMM16, + &&HANDLE_STOBJBYINDEX_IMM8_V8_IMM16, + &&HANDLE_STOBJBYINDEX_IMM16_V8_IMM16, + &&HANDLE_STOWNBYINDEX_IMM8_V8_IMM16, + &&HANDLE_STOWNBYINDEX_IMM16_V8_IMM16, + &&HANDLE_ASYNCFUNCTIONRESOLVE_V8, + &&HANDLE_ASYNCFUNCTIONREJECT_V8, + &&HANDLE_COPYRESTARGS_IMM8, + &&HANDLE_LDLEXVAR_IMM4_IMM4, + &&HANDLE_STLEXVAR_IMM4_IMM4, + &&HANDLE_GETMODULENAMESPACE_IMM8, + &&HANDLE_STMODULEVAR_IMM8, + &&HANDLE_TRYLDGLOBALBYNAME_IMM8_ID16, + &&HANDLE_TRYLDGLOBALBYNAME_IMM16_ID16, + &&HANDLE_TRYSTGLOBALBYNAME_IMM8_ID16, + &&HANDLE_TRYSTGLOBALBYNAME_IMM16_ID16, + &&HANDLE_LDGLOBALVAR_IMM16_ID16, + &&HANDLE_STGLOBALVAR_IMM16_ID16, + &&HANDLE_LDOBJBYNAME_IMM8_ID16, + &&HANDLE_LDOBJBYNAME_IMM16_ID16, + &&HANDLE_STOBJBYNAME_IMM8_ID16_V8, + &&HANDLE_STOBJBYNAME_IMM16_ID16_V8, + &&HANDLE_STOWNBYNAME_IMM8_ID16_V8, + &&HANDLE_STOWNBYNAME_IMM16_ID16_V8, + &&HANDLE_LDSUPERBYNAME_IMM8_ID16, + &&HANDLE_LDSUPERBYNAME_IMM16_ID16, + &&HANDLE_STSUPERBYNAME_IMM8_ID16_V8, + &&HANDLE_STSUPERBYNAME_IMM16_ID16_V8, + &&HANDLE_LDLOCALMODULEVAR_IMM8, + &&HANDLE_STCONSTTOGLOBALRECORD_IMM16_ID16, + &&HANDLE_STTOGLOBALRECORD_IMM16_ID16, + &&HANDLE_JNSTRICTEQZ_IMM8, + &&HANDLE_JNSTRICTEQZ_IMM16, + &&HANDLE_JEQNULL_IMM8, + &&HANDLE_JEQNULL_IMM16, + &&HANDLE_STOWNBYVALUEWITHNAMESET_IMM8_V8_V8, + &&HANDLE_STOWNBYVALUEWITHNAMESET_IMM16_V8_V8, + &&HANDLE_STOWNBYNAMEWITHNAMESET_IMM8_ID16_V8, + &&HANDLE_STOWNBYNAMEWITHNAMESET_IMM16_ID16_V8, + &&HANDLE_LDBIGINT_ID16, + &&HANDLE_LDA_STR_ID16, &&HANDLE_JMP_IMM8, &&HANDLE_JMP_IMM16, &&HANDLE_JMP_IMM32, &&HANDLE_JEQZ_IMM8, &&HANDLE_JEQZ_IMM16, - &&HANDLE_LDA_DYN_V8, - &&HANDLE_STA_DYN_V8, - &&HANDLE_RETURN_DYN, - &&HANDLE_MOV_V4_V4, &&HANDLE_JNEZ_IMM8, &&HANDLE_JNEZ_IMM16, - &&EXCEPTION_HANDLER, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, - &&HANDLE_OVERFLOW, + &&HANDLE_JNENULL_IMM8, + &&HANDLE_JNENULL_IMM16, + &&HANDLE_LDA_V8, + &&HANDLE_STA_V8, + &&HANDLE_LDAI_IMM32, + &&HANDLE_FLDAI_IMM64, + &&HANDLE_RETURN, + &&HANDLE_RETURNUNDEFINED, + &&HANDLE_LDLEXVAR_IMM8_IMM8, + &&HANDLE_JSTRICTEQNULL_IMM8, + &&HANDLE_STLEXVAR_IMM8_IMM8, + &&HANDLE_JSTRICTEQNULL_IMM16, + &&HANDLE_CALLARG1_IMM8_V8, + &&HANDLE_JNSTRICTEQNULL_IMM8, + &&HANDLE_JNSTRICTEQNULL_IMM16, + &&HANDLE_JEQUNDEFINED_IMM8, + &&HANDLE_JEQUNDEFINED_IMM16, + &&HANDLE_JNEUNDEFINED_IMM8, + &&HANDLE_JNEUNDEFINED_IMM16, + &&HANDLE_JSTRICTEQUNDEFINED_IMM8, + &&HANDLE_JSTRICTEQUNDEFINED_IMM16, + &&HANDLE_JNSTRICTEQUNDEFINED_IMM8, + &&HANDLE_JNSTRICTEQUNDEFINED_IMM16, + &&HANDLE_JEQ_V8_IMM8, + &&HANDLE_JEQ_V8_IMM16, + &&HANDLE_JNE_V8_IMM8, + &&HANDLE_JNE_V8_IMM16, + &&HANDLE_JSTRICTEQ_V8_IMM8, + &&HANDLE_JSTRICTEQ_V8_IMM16, + &&HANDLE_JNSTRICTEQ_V8_IMM8, + &&HANDLE_JNSTRICTEQ_V8_IMM16, + &&HANDLE_MOV_V4_V4, + &&HANDLE_MOV_V8_V8, + &&HANDLE_MOV_V16_V16, + &&HANDLE_NOP, + &&HANDLE_EXCEPTION, &&HANDLE_OVERFLOW, &&HANDLE_OVERFLOW, &&HANDLE_OVERFLOW, @@ -269,3 +265,7 @@ &&HANDLE_OVERFLOW, &&HANDLE_OVERFLOW, &&HANDLE_OVERFLOW, + &&HANDLE_DEPRECATED, + &&HANDLE_WIDE, + &&HANDLE_THROW, + &&HANDLE_OVERFLOW, \ No newline at end of file diff --git a/ecmascript/interpreter/templates/throw_instruction_dispatch.inl b/ecmascript/interpreter/templates/throw_instruction_dispatch.inl new file mode 100644 index 0000000000..da798142e3 --- /dev/null +++ b/ecmascript/interpreter/templates/throw_instruction_dispatch.inl @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + &&HANDLE_THROW_PREF_NONE, + &&HANDLE_THROW_NOTEXISTS_PREF_NONE, + &&HANDLE_THROW_PATTERNNONCOERCIBLE_PREF_NONE, + &&HANDLE_THROW_DELETESUPERPROPERTY_PREF_NONE, + &&HANDLE_THROW_CONSTASSIGNMENT_PREF_V8, + &&HANDLE_THROW_IFNOTOBJECT_PREF_V8, + &&HANDLE_THROW_UNDEFINEDIFHOLE_PREF_V8_V8, + &&HANDLE_THROW_IFSUPERNOTCORRECTCALL_PREF_IMM8, + &&HANDLE_THROW_IFSUPERNOTCORRECTCALL_PREF_IMM16, diff --git a/ecmascript/interpreter/templates/wide_instruction_dispatch.inl b/ecmascript/interpreter/templates/wide_instruction_dispatch.inl new file mode 100644 index 0000000000..445fd2896a --- /dev/null +++ b/ecmascript/interpreter/templates/wide_instruction_dispatch.inl @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + &&HANDLE_WIDE_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8, + &&HANDLE_WIDE_NEWOBJRANGE_PREF_IMM16_V8, + &&HANDLE_WIDE_NEWLEXENV_PREF_IMM16, + &&HANDLE_WIDE_NEWLEXENVWITHNAME_PREF_IMM16_ID16, + &&HANDLE_WIDE_CALLRANGE_PREF_IMM16_V8, + &&HANDLE_WIDE_CALLTHISRANGE_PREF_IMM16_V8, + &&HANDLE_WIDE_SUPERCALLTHISRANGE_PREF_IMM16_V8, + &&HANDLE_WIDE_SUPERCALLARROWRANGE_PREF_IMM16_V8, + &&HANDLE_WIDE_LDOBJBYINDEX_PREF_IMM32, + &&HANDLE_WIDE_STOBJBYINDEX_PREF_V8_IMM32, + &&HANDLE_WIDE_STOWNBYINDEX_PREF_V8_IMM32, + &&HANDLE_WIDE_COPYRESTARGS_PREF_IMM16, + &&HANDLE_WIDE_LDLEXVAR_PREF_IMM16_IMM16, + &&HANDLE_WIDE_STLEXVAR_PREF_IMM16_IMM16, + &&HANDLE_WIDE_GETMODULENAMESPACE_PREF_IMM16, + &&HANDLE_WIDE_STMODULEVAR_PREF_IMM16, + &&HANDLE_WIDE_LDLOCALMODULEVAR_PREF_IMM16, + &&HANDLE_WIDE_LDEXTERNALMODULEVAR_PREF_IMM16, \ No newline at end of file diff --git a/ecmascript/js_bigint.h b/ecmascript/js_bigint.h index d94416d475..67a5be20b8 100644 --- a/ecmascript/js_bigint.h +++ b/ecmascript/js_bigint.h @@ -120,13 +120,13 @@ public: inline uint32_t GetDigit(uint32_t index) const { ASSERT(index < GetLength()); - return Barriers::GetDynValue(GetData(), sizeof(uint32_t) * index); + return Barriers::GetValue(GetData(), sizeof(uint32_t) * index); } inline void SetDigit(uint32_t index, uint32_t digit) { ASSERT(index < GetLength()); - Barriers::SetDynPrimitive(GetData(), sizeof(uint32_t) * index, digit); + Barriers::SetPrimitive(GetData(), sizeof(uint32_t) * index, digit); } static constexpr size_t LENGTH_OFFSET = TaggedObjectSize(); diff --git a/ecmascript/js_function.cpp b/ecmascript/js_function.cpp index a95dd56cdc..b777e721d4 100644 --- a/ecmascript/js_function.cpp +++ b/ecmascript/js_function.cpp @@ -42,7 +42,7 @@ void JSFunction::InitializeJSFunction(JSThread *thread, const JSHandleSetProtoOrDynClass(thread, JSTaggedValue::Hole(), SKIP_BARRIER); + func->SetProtoOrHClass(thread, JSTaggedValue::Hole(), SKIP_BARRIER); func->SetHomeObject(thread, JSTaggedValue::Undefined(), SKIP_BARRIER); func->SetLexicalEnv(thread, JSTaggedValue::Undefined(), SKIP_BARRIER); func->SetModule(thread, JSTaggedValue::Undefined(), SKIP_BARRIER); @@ -70,7 +70,7 @@ void JSFunction::InitializeJSFunction(JSThread *thread, const JSHandle initialGeneratorFuncPrototype = factory->NewJSObjectByConstructor(objFun); JSObject::SetPrototype(thread, initialGeneratorFuncPrototype, env->GetAsyncGeneratorPrototype()); - func->SetProtoOrDynClass(thread, initialGeneratorFuncPrototype); + func->SetProtoOrHClass(thread, initialGeneratorFuncPrototype); } } else if (!JSFunction::IsClassConstructor(kind)) { // class ctor do nothing PropertyDescriptor desc(thread, accessor, kind != FunctionKind::BUILTIN_CONSTRUCTOR, false, false); @@ -103,9 +103,9 @@ JSHandle JSFunction::NewJSFunctionPrototype(JSThread *thread, ObjectFa JSHClass *JSFunction::GetOrCreateInitialJSHClass(JSThread *thread, const JSHandle &fun) { - JSTaggedValue protoOrDyn(fun->GetProtoOrDynClass()); - if (protoOrDyn.IsJSHClass()) { - return reinterpret_cast(protoOrDyn.GetTaggedObject()); + JSTaggedValue protoOrHClass(fun->GetProtoOrHClass()); + if (protoOrHClass.IsJSHClass()) { + return reinterpret_cast(protoOrHClass.GetTaggedObject()); } ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); @@ -113,12 +113,12 @@ JSHClass *JSFunction::GetOrCreateInitialJSHClass(JSThread *thread, const JSHandl if (!fun->HasFunctionPrototype()) { proto = JSHandle::Cast(NewJSFunctionPrototype(thread, factory, fun)); } else { - proto = JSHandle(thread, fun->GetProtoOrDynClass()); + proto = JSHandle(thread, fun->GetProtoOrHClass()); } - JSHandle dynclass = factory->NewEcmaDynClass(JSObject::SIZE, JSType::JS_OBJECT, proto); - fun->SetProtoOrDynClass(thread, dynclass); - return *dynclass; + JSHandle hclass = factory->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, proto); + fun->SetProtoOrHClass(thread, hclass); + return *hclass; } JSTaggedValue JSFunction::PrototypeGetter(JSThread *thread, const JSHandle &self) @@ -135,15 +135,15 @@ bool JSFunction::PrototypeSetter(JSThread *thread, const JSHandle &sel [[maybe_unused]] bool mayThrow) { JSHandle func(self); - JSTaggedValue protoOrDyn = func->GetProtoOrDynClass(); - if (protoOrDyn.IsJSHClass()) { + JSTaggedValue protoOrHClass = func->GetProtoOrHClass(); + if (protoOrHClass.IsJSHClass()) { // need transition - JSHandle dynclass(thread, protoOrDyn); - JSHandle newDynclass = JSHClass::TransitionProto(thread, dynclass, value); + JSHandle hclass(thread, protoOrHClass); + JSHandle newClass = JSHClass::TransitionProto(thread, hclass, value); if (value->IsECMAObject()) { JSObject::Cast(value->GetTaggedObject())->GetJSHClass()->SetIsPrototype(true); } - func->SetProtoOrDynClass(thread, newDynclass); + func->SetProtoOrHClass(thread, newClass); } else { func->SetFunctionPrototype(thread, value.GetTaggedValue()); } @@ -235,7 +235,7 @@ bool JSFunction::MakeConstructor(JSThread *thread, const JSHandle &f const GlobalEnvConstants *globalConst = thread->GlobalConstants(); JSHandle constructorKey = globalConst->GetHandledConstructorString(); - ASSERT_PRINT(func->GetProtoOrDynClass().IsHole() && func->IsExtensible(), + ASSERT_PRINT(func->GetProtoOrHClass().IsHole() && func->IsExtensible(), "function doesn't has proto_type property and is extensible object"); ASSERT_PRINT(JSObject::HasProperty(thread, JSHandle(func), constructorKey), "function must have constructor"); @@ -590,18 +590,18 @@ JSHandle JSFunction::GetInstanceJSHClass(JSThread *thread, JSHandle JSFunction::GetOrCreateDerivedJSHClass(JSThread *thread, JSHandle derived, JSHandle ctorInitialJSHClass) { - JSTaggedValue protoOrDyn(derived->GetProtoOrDynClass()); + JSTaggedValue protoOrHClass(derived->GetProtoOrHClass()); // has cached JSHClass, return directly - if (protoOrDyn.IsJSHClass()) { - return JSHandle(thread, protoOrDyn); + if (protoOrHClass.IsJSHClass()) { + return JSHandle(thread, protoOrHClass); } JSHandle newJSHClass = JSHClass::Clone(thread, ctorInitialJSHClass); // guarante derived has function prototype - JSHandle prototype(thread, derived->GetProtoOrDynClass()); + JSHandle prototype(thread, derived->GetProtoOrHClass()); ASSERT(!prototype->IsHole()); newJSHClass->SetPrototype(thread, prototype); - derived->SetProtoOrDynClass(thread, newJSHClass); + derived->SetProtoOrHClass(thread, newJSHClass); return newJSHClass; } diff --git a/ecmascript/js_function.h b/ecmascript/js_function.h index fd0d5cf427..8b764b107b 100644 --- a/ecmascript/js_function.h +++ b/ecmascript/js_function.h @@ -99,17 +99,17 @@ public: inline JSTaggedValue GetFunctionPrototype() const { ASSERT(HasFunctionPrototype()); - JSTaggedValue protoOrDyn = GetProtoOrDynClass(); - if (protoOrDyn.IsJSHClass()) { - return JSHClass::Cast(protoOrDyn.GetTaggedObject())->GetPrototype(); + JSTaggedValue protoOrHClass = GetProtoOrHClass(); + if (protoOrHClass.IsJSHClass()) { + return JSHClass::Cast(protoOrHClass.GetTaggedObject())->GetPrototype(); } - return protoOrDyn; + return protoOrHClass; } inline void SetFunctionPrototype(const JSThread *thread, JSTaggedValue proto) { - SetProtoOrDynClass(thread, proto); + SetProtoOrHClass(thread, proto); if (proto.IsJSHClass()) { proto = JSHClass::Cast(proto.GetTaggedObject())->GetPrototype(); } @@ -118,16 +118,16 @@ public: } } - inline bool HasInitialDynClass() const + inline bool HasInitialClass() const { - JSTaggedValue protoOrDyn = GetProtoOrDynClass(); - return protoOrDyn.IsJSHClass(); + JSTaggedValue protoOrHClass = GetProtoOrHClass(); + return protoOrHClass.IsJSHClass(); } inline bool HasFunctionPrototype() const { - JSTaggedValue protoOrDyn = GetProtoOrDynClass(); - return !protoOrDyn.IsHole(); + JSTaggedValue protoOrHClass = GetProtoOrHClass(); + return !protoOrHClass.IsHole(); } inline void SetFunctionLength(const JSThread *thread, JSTaggedValue length) @@ -206,7 +206,7 @@ public: JSHandle newTarget); static constexpr size_t PROTO_OR_DYNCLASS_OFFSET = JSFunctionBase::SIZE; - ACCESSORS(ProtoOrDynClass, PROTO_OR_DYNCLASS_OFFSET, LEXICAL_ENV_OFFSET) + ACCESSORS(ProtoOrHClass, PROTO_OR_DYNCLASS_OFFSET, LEXICAL_ENV_OFFSET) ACCESSORS(LexicalEnv, LEXICAL_ENV_OFFSET, HOME_OBJECT_OFFSET) ACCESSORS(HomeObject, HOME_OBJECT_OFFSET, FUNCTION_EXTRA_INFO_OFFSET) ACCESSORS(FunctionExtraInfo, FUNCTION_EXTRA_INFO_OFFSET, PROFILE_TYPE_INFO_OFFSET) @@ -232,7 +232,7 @@ public: private: static JSHandle GetOrCreateDerivedJSHClass(JSThread *thread, JSHandle derived, - JSHandle ctorInitialDynClass); + JSHandle ctorInitialClass); }; class JSGeneratorFunction : public JSFunction { diff --git a/ecmascript/js_hclass.cpp b/ecmascript/js_hclass.cpp index a0e293c769..237b013e4c 100644 --- a/ecmascript/js_hclass.cpp +++ b/ecmascript/js_hclass.cpp @@ -150,16 +150,16 @@ JSHandle JSHClass::Clone(const JSThread *thread, const JSHandleGetObjectType(); uint32_t size = jshclass->GetInlinedPropsStartSize(); uint32_t numInlinedProps = withoutInlinedProperties ? 0 : jshclass->GetInlinedProperties(); - JSHandle newJshclass = thread->GetEcmaVM()->GetFactory()->NewEcmaDynClass(size, type, numInlinedProps); + JSHandle newJsHClass = thread->GetEcmaVM()->GetFactory()->NewEcmaHClass(size, type, numInlinedProps); // Copy all - newJshclass->Copy(thread, *jshclass); - newJshclass->SetTransitions(thread, JSTaggedValue::Undefined()); - newJshclass->SetProtoChangeDetails(thread, JSTaggedValue::Null()); - newJshclass->SetEnumCache(thread, JSTaggedValue::Null()); + newJsHClass->Copy(thread, *jshclass); + newJsHClass->SetTransitions(thread, JSTaggedValue::Undefined()); + newJsHClass->SetProtoChangeDetails(thread, JSTaggedValue::Null()); + newJsHClass->SetEnumCache(thread, JSTaggedValue::Null()); // reuse Attributes first. - newJshclass->SetLayout(thread, jshclass->GetLayout()); + newJsHClass->SetLayout(thread, jshclass->GetLayout()); - return newJshclass; + return newJsHClass; } // use for transition to dictionary @@ -183,28 +183,28 @@ JSHandle JSHClass::SetPropertyOfObjHClass(const JSThread *thread, JSHa const PropertyAttributes &attr) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHClass *newDyn = jshclass->FindTransitions(key.GetTaggedValue(), JSTaggedValue(attr.GetPropertyMetaData())); - if (newDyn != nullptr) { - return JSHandle(thread, newDyn); + JSHClass *newClass = jshclass->FindTransitions(key.GetTaggedValue(), JSTaggedValue(attr.GetPropertyMetaData())); + if (newClass != nullptr) { + return JSHandle(thread, newClass); } - JSHandle newJshclass = JSHClass::Clone(thread, jshclass); - newJshclass->IncNumberOfProps(); + JSHandle newJsHClass = JSHClass::Clone(thread, jshclass); + newJsHClass->IncNumberOfProps(); uint32_t offset = attr.GetOffset(); { - JSMutableHandle layoutInfoHandle(thread, newJshclass->GetLayout()); + JSMutableHandle layoutInfoHandle(thread, newJsHClass->GetLayout()); if (layoutInfoHandle->NumberOfElements() != static_cast(offset)) { layoutInfoHandle.Update(factory->CopyAndReSort(layoutInfoHandle, offset, offset + 1)); } else if (layoutInfoHandle->GetPropertiesCapacity() <= static_cast(offset)) { // need to Grow layoutInfoHandle.Update( factory->ExtendLayoutInfo(layoutInfoHandle, LayoutInfo::ComputeGrowCapacity(offset))); } - newJshclass->SetLayout(thread, layoutInfoHandle); + newJsHClass->SetLayout(thread, layoutInfoHandle); layoutInfoHandle->AddKey(thread, offset, key.GetTaggedValue(), attr); } - AddTransitions(thread, jshclass, newJshclass, key, attr); - return newJshclass; + AddTransitions(thread, jshclass, newJsHClass, key, attr); + return newJsHClass; } void JSHClass::AddProperty(const JSThread *thread, const JSHandle &obj, const JSHandle &key, @@ -212,24 +212,24 @@ void JSHClass::AddProperty(const JSThread *thread, const JSHandle &obj { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); JSHandle jshclass(thread, obj->GetJSHClass()); - JSHClass *newDyn = jshclass->FindTransitions(key.GetTaggedValue(), JSTaggedValue(attr.GetPropertyMetaData())); - if (newDyn != nullptr) { - obj->SetClass(newDyn); + JSHClass *newClass = jshclass->FindTransitions(key.GetTaggedValue(), JSTaggedValue(attr.GetPropertyMetaData())); + if (newClass != nullptr) { + obj->SetClass(newClass); #if ECMASCRIPT_ENABLE_IC - JSHClass::NotifyHclassChanged(thread, jshclass, JSHandle(thread, newDyn)); + JSHClass::NotifyHclassChanged(thread, jshclass, JSHandle(thread, newClass)); #endif return; } // 2. Create hclass - JSHandle newJshclass = JSHClass::Clone(thread, jshclass); + JSHandle newJsHClass = JSHClass::Clone(thread, jshclass); // 3. Add Property and metaData uint32_t offset = attr.GetOffset(); - newJshclass->IncNumberOfProps(); + newJsHClass->IncNumberOfProps(); { - JSMutableHandle layoutInfoHandle(thread, newJshclass->GetLayout()); + JSMutableHandle layoutInfoHandle(thread, newJsHClass->GetLayout()); if (layoutInfoHandle->NumberOfElements() != static_cast(offset)) { layoutInfoHandle.Update(factory->CopyAndReSort(layoutInfoHandle, offset, offset + 1)); @@ -237,45 +237,45 @@ void JSHClass::AddProperty(const JSThread *thread, const JSHandle &obj layoutInfoHandle.Update( factory->ExtendLayoutInfo(layoutInfoHandle, LayoutInfo::ComputeGrowCapacity(offset))); } - newJshclass->SetLayout(thread, layoutInfoHandle); + newJsHClass->SetLayout(thread, layoutInfoHandle); layoutInfoHandle->AddKey(thread, offset, key.GetTaggedValue(), attr); } - // 4. Add newDynclass to old dynclass's transitions. - AddTransitions(thread, jshclass, newJshclass, key, attr); + // 4. Add newClass to old hclass's transitions. + AddTransitions(thread, jshclass, newJsHClass, key, attr); // 5. update hclass in object. #if ECMASCRIPT_ENABLE_IC - JSHClass::NotifyHclassChanged(thread, jshclass, newJshclass); + JSHClass::NotifyHclassChanged(thread, jshclass, newJsHClass); #endif - obj->SetClass(*newJshclass); + obj->SetClass(*newJsHClass); } JSHandle JSHClass::TransitionExtension(const JSThread *thread, const JSHandle &jshclass) { JSHandle key(thread->GlobalConstants()->GetHandledPreventExtensionsString()); { - auto *newDyn = jshclass->FindTransitions(key.GetTaggedValue(), JSTaggedValue(0)); - if (newDyn != nullptr) { - return JSHandle(thread, newDyn); + auto *newClass = jshclass->FindTransitions(key.GetTaggedValue(), JSTaggedValue(0)); + if (newClass != nullptr) { + return JSHandle(thread, newClass); } } ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); // 2. new a hclass - JSHandle newJshclass = JSHClass::Clone(thread, jshclass); - newJshclass->SetExtensible(false); + JSHandle newJsHClass = JSHClass::Clone(thread, jshclass); + newJsHClass->SetExtensible(false); - JSTaggedValue attrs = newJshclass->GetLayout(); + JSTaggedValue attrs = newJsHClass->GetLayout(); { JSMutableHandle layoutInfoHandle(thread, attrs); layoutInfoHandle.Update(factory->CopyLayoutInfo(layoutInfoHandle).GetTaggedValue()); - newJshclass->SetLayout(thread, layoutInfoHandle); + newJsHClass->SetLayout(thread, layoutInfoHandle); } - // 3. Add newDynclass to old dynclass's parent's transitions. - AddExtensionTransitions(thread, jshclass, newJshclass, key); + // 3. Add newClass to old hclass's parent's transitions. + AddExtensionTransitions(thread, jshclass, newJsHClass, key); // parent is the same as jshclass, already copy - return newJshclass; + return newJsHClass; } JSHandle JSHClass::TransitionProto(const JSThread *thread, const JSHandle &jshclass, @@ -284,29 +284,29 @@ JSHandle JSHClass::TransitionProto(const JSThread *thread, const JSHan JSHandle key(thread->GlobalConstants()->GetHandledPrototypeString()); { - auto *newDyn = jshclass->FindProtoTransitions(key.GetTaggedValue(), proto.GetTaggedValue()); - if (newDyn != nullptr) { - return JSHandle(thread, newDyn); + auto *newClass = jshclass->FindProtoTransitions(key.GetTaggedValue(), proto.GetTaggedValue()); + if (newClass != nullptr) { + return JSHandle(thread, newClass); } } ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); // 2. new a hclass - JSHandle newJshclass = JSHClass::Clone(thread, jshclass); - newJshclass->SetPrototype(thread, proto.GetTaggedValue()); + JSHandle newJsHClass = JSHClass::Clone(thread, jshclass); + newJsHClass->SetPrototype(thread, proto.GetTaggedValue()); - JSTaggedValue layout = newJshclass->GetLayout(); + JSTaggedValue layout = newJsHClass->GetLayout(); { JSMutableHandle layoutInfoHandle(thread, layout); layoutInfoHandle.Update(factory->CopyLayoutInfo(layoutInfoHandle).GetTaggedValue()); - newJshclass->SetLayout(thread, layoutInfoHandle); + newJsHClass->SetLayout(thread, layoutInfoHandle); } - // 3. Add newJshclass to old jshclass's parent's transitions. - AddProtoTransitions(thread, jshclass, newJshclass, key, proto); + // 3. Add newJsHClass to old jshclass's parent's transitions. + AddProtoTransitions(thread, jshclass, newJsHClass, key, proto); // parent is the same as jshclass, already copy - return newJshclass; + return newJsHClass; } JSHandle JSHClass::TransProtoWithoutLayout(const JSThread *thread, const JSHandle &jshclass, @@ -315,21 +315,21 @@ JSHandle JSHClass::TransProtoWithoutLayout(const JSThread *thread, con JSHandle key(thread->GlobalConstants()->GetHandledPrototypeString()); { - auto *newDyn = jshclass->FindProtoTransitions(key.GetTaggedValue(), proto.GetTaggedValue()); - if (newDyn != nullptr) { - return JSHandle(thread, newDyn); + auto *newClass = jshclass->FindProtoTransitions(key.GetTaggedValue(), proto.GetTaggedValue()); + if (newClass != nullptr) { + return JSHandle(thread, newClass); } } // 2. new a hclass - JSHandle newJshclass = JSHClass::Clone(thread, jshclass); - newJshclass->SetPrototype(thread, proto.GetTaggedValue()); + JSHandle newJsHClass = JSHClass::Clone(thread, jshclass); + newJsHClass->SetPrototype(thread, proto.GetTaggedValue()); - // 3. Add newJshclass to old jshclass's parent's transitions. - AddProtoTransitions(thread, jshclass, newJshclass, key, proto); + // 3. Add newJsHClass to old jshclass's parent's transitions. + AddProtoTransitions(thread, jshclass, newJsHClass, key, proto); // parent is the same as jshclass, already copy - return newJshclass; + return newJsHClass; } void JSHClass::SetPrototype(const JSThread *thread, JSTaggedValue proto) @@ -351,20 +351,20 @@ void JSHClass::TransitionToDictionary(const JSThread *thread, const JSHandle jshclass(thread, obj->GetJSHClass()); - JSHandle newJshclass = CloneWithoutInlinedProperties(thread, jshclass); + JSHandle newJsHClass = CloneWithoutInlinedProperties(thread, jshclass); { DISALLOW_GARBAGE_COLLECTION; // 2. Copy - newJshclass->SetNumberOfProps(0); - newJshclass->SetIsDictionaryMode(true); - ASSERT(newJshclass->GetInlinedProperties() == 0); + newJsHClass->SetNumberOfProps(0); + newJsHClass->SetIsDictionaryMode(true); + ASSERT(newJsHClass->GetInlinedProperties() == 0); - // 3. Add newJshclass to ? + // 3. Add newJsHClass to ? #if ECMASCRIPT_ENABLE_IC - JSHClass::NotifyHclassChanged(thread, JSHandle(thread, obj->GetJSHClass()), newJshclass); + JSHClass::NotifyHclassChanged(thread, JSHandle(thread, obj->GetJSHClass()), newJsHClass); #endif - obj->SetClass(newJshclass); + obj->SetClass(newJsHClass); } } @@ -376,9 +376,9 @@ JSHandle JSHClass::EnableProtoChangeMarker(const JSThread *thread UNREACHABLE(); } JSHandle protoHandle(thread, proto); - JSHandle protoDyncalss(thread, protoHandle->GetJSHClass()); - RegisterOnProtoChain(thread, protoDyncalss); - JSTaggedValue protoChangeMarker = protoDyncalss->GetProtoChangeMarker(); + JSHandle protoClass(thread, protoHandle->GetJSHClass()); + RegisterOnProtoChain(thread, protoClass); + JSTaggedValue protoChangeMarker = protoClass->GetProtoChangeMarker(); if (protoChangeMarker.IsProtoChangeMarker()) { JSHandle markerHandle(thread, ProtoChangeMarker::Cast(protoChangeMarker.GetTaggedObject())); if (!markerHandle->GetHasChanged()) { @@ -387,7 +387,7 @@ JSHandle JSHClass::EnableProtoChangeMarker(const JSThread *thread } JSHandle markerHandle = thread->GetEcmaVM()->GetFactory()->NewProtoChangeMarker(); markerHandle->SetHasChanged(false); - protoDyncalss->SetProtoChangeMarker(thread, markerHandle.GetTaggedValue()); + protoClass->SetProtoChangeMarker(thread, markerHandle.GetTaggedValue()); return JSHandle(markerHandle); } diff --git a/ecmascript/js_object.cpp b/ecmascript/js_object.cpp index 6f5d839f65..2b413f478f 100644 --- a/ecmascript/js_object.cpp +++ b/ecmascript/js_object.cpp @@ -1064,10 +1064,10 @@ bool JSObject::SetPrototype(JSThread *thread, const JSHandle &obj, con } } // map transition - JSHandle dynclass(thread, obj->GetJSHClass()); - JSHandle newDynclass = JSHClass::TransitionProto(thread, dynclass, proto); - JSHClass::NotifyHclassChanged(thread, dynclass, newDynclass); - obj->SetClass(newDynclass); + JSHandle hclass(thread, obj->GetJSHClass()); + JSHandle newClass = JSHClass::TransitionProto(thread, hclass, proto); + JSHClass::NotifyHclassChanged(thread, hclass, newClass); + obj->SetClass(newClass); thread->NotifyStableArrayElementsGuardians(obj); return true; } @@ -1961,7 +1961,7 @@ bool JSObject::UpdatePropertyInDictionary(const JSThread *thread, JSTaggedValue void ECMAObject::SetHash(int32_t hash) { - JSTaggedType hashField = Barriers::GetDynValue(this, HASH_OFFSET); + JSTaggedType hashField = Barriers::GetValue(this, HASH_OFFSET); JSTaggedValue value(hashField); if (value.IsHeapObject()) { JSThread *thread = this->GetJSThread(); @@ -1969,13 +1969,13 @@ void ECMAObject::SetHash(int32_t hash) TaggedArray *array = TaggedArray::Cast(value.GetTaggedObject()); array->Set(thread, 0, JSTaggedValue(hash)); } else { - Barriers::SetDynPrimitive(this, HASH_OFFSET, JSTaggedValue(hash).GetRawData()); + Barriers::SetPrimitive(this, HASH_OFFSET, JSTaggedValue(hash).GetRawData()); } } int32_t ECMAObject::GetHash() const { - JSTaggedType hashField = Barriers::GetDynValue(this, HASH_OFFSET); + JSTaggedType hashField = Barriers::GetValue(this, HASH_OFFSET); JSTaggedValue value(hashField); if (value.IsHeapObject()) { TaggedArray *array = TaggedArray::Cast(value.GetTaggedObject()); @@ -1988,7 +1988,7 @@ int32_t ECMAObject::GetHash() const void *ECMAObject::GetNativePointerField(int32_t index) const { - JSTaggedType hashField = Barriers::GetDynValue(this, HASH_OFFSET); + JSTaggedType hashField = Barriers::GetValue(this, HASH_OFFSET); JSTaggedValue value(hashField); if (value.IsHeapObject()) { JSThread *thread = this->GetJSThread(); @@ -2004,7 +2004,7 @@ void *ECMAObject::GetNativePointerField(int32_t index) const void ECMAObject::SetNativePointerField(int32_t index, void *nativePointer, const DeleteEntryPoint &callBack, void *data) { - JSTaggedType hashField = Barriers::GetDynValue(this, HASH_OFFSET); + JSTaggedType hashField = Barriers::GetValue(this, HASH_OFFSET); JSTaggedValue value(hashField); if (value.IsHeapObject()) { JSThread *thread = this->GetJSThread(); @@ -2028,7 +2028,7 @@ void ECMAObject::SetNativePointerField(int32_t index, void *nativePointer, int32_t ECMAObject::GetNativePointerFieldCount() const { int32_t len = 0; - JSTaggedType hashField = Barriers::GetDynValue(this, HASH_OFFSET); + JSTaggedType hashField = Barriers::GetValue(this, HASH_OFFSET); JSTaggedValue value(hashField); if (value.IsHeapObject()) { TaggedArray *array = TaggedArray::Cast(value.GetTaggedObject()); @@ -2039,14 +2039,14 @@ int32_t ECMAObject::GetNativePointerFieldCount() const void ECMAObject::SetNativePointerFieldCount(int32_t count) { - JSTaggedType hashField = Barriers::GetDynValue(this, HASH_OFFSET); + JSTaggedType hashField = Barriers::GetValue(this, HASH_OFFSET); JSTaggedValue value(hashField); if (!value.IsHeapObject()) { JSThread *thread = this->GetJSThread(); JSHandle obj(thread, this); JSHandle newArray = thread->GetEcmaVM()->GetFactory()->NewTaggedArray(count + 1); newArray->Set(thread, 0, value); - Barriers::SetDynObject(thread, *obj, HASH_OFFSET, newArray.GetTaggedValue().GetRawData()); + Barriers::SetObject(thread, *obj, HASH_OFFSET, newArray.GetTaggedValue().GetRawData()); } } } // namespace panda::ecmascript diff --git a/ecmascript/js_object.h b/ecmascript/js_object.h index c6e68111bf..6fa4776968 100644 --- a/ecmascript/js_object.h +++ b/ecmascript/js_object.h @@ -337,7 +337,7 @@ public: int32_t GetHash() const; void InitializeHash() { - Barriers::SetDynPrimitive(this, ECMAObject::HASH_OFFSET, JSTaggedValue(0).GetRawData()); + Barriers::SetPrimitive(this, ECMAObject::HASH_OFFSET, JSTaggedValue(0).GetRawData()); } void* GetNativePointerField(int32_t index) const; diff --git a/ecmascript/js_serializer.cpp b/ecmascript/js_serializer.cpp index 693ba8b105..0030433cc9 100644 --- a/ecmascript/js_serializer.cpp +++ b/ecmascript/js_serializer.cpp @@ -511,7 +511,7 @@ bool JSSerializer::WriteJSRegExp(const JSHandle &value) bufferSize_ = oldSize; return false; } - // Write Accessor(ByteCodeBuffer) which is a pointer to a Dynbuffer + // Write Accessor(ByteCodeBuffer) which is a pointer to a dynamic buffer JSHandle bufferValue(thread_, regExp->GetByteCodeBuffer()); JSHandle np = JSHandle::Cast(bufferValue); void *dynBuffer = np->GetExternalPointer(); @@ -641,7 +641,7 @@ bool JSSerializer::WriteJSArrayBuffer(const JSHandle &value) return false; } } else { - // Write Accessors(ArrayBufferData) which is a pointer to a DynBuffer + // Write Accessors(ArrayBufferData) which is a pointer to a Buffer JSHandle np(thread_, arrayBuffer->GetArrayBufferData()); void *buffer = np->GetExternalPointer(); if (!WriteRawData(buffer, arrayLength)) { diff --git a/ecmascript/jspandafile/bytecode_inst/instruction.h b/ecmascript/jspandafile/bytecode_inst/instruction.h new file mode 100644 index 0000000000..aee0aabf24 --- /dev/null +++ b/ecmascript/jspandafile/bytecode_inst/instruction.h @@ -0,0 +1,145 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ECMASCRIPT_JSPANDAFILE_BYTECODE_INST_INSTRUCTION_H +#define ECMASCRIPT_JSPANDAFILE_BYTECODE_INST_INSTRUCTION_H + +#include + +#include "libpandabase/utils/bit_helpers.h" + +#if !PANDA_TARGET_WINDOWS +#include "securec.h" +#endif + + +namespace panda::ecmascript { +class BytecodeInstBase { +public: + BytecodeInstBase() = default; + explicit BytecodeInstBase(const uint8_t *pc) : pc_ {pc} {} + ~BytecodeInstBase() = default; + +protected: + const uint8_t *GetPointer(int32_t offset) const + { + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + return pc_ + offset; + } + + const uint8_t *GetAddress() const + { + return pc_; + } + + const uint8_t *GetAddress() volatile const + { + return pc_; + } + + uint8_t GetPrimaryOpcode() const + { + return ReadByte(0); + } + + uint8_t GetSecondaryOpcode() const + { + return ReadByte(1); + } + + template + T Read(size_t offset) const + { + using unaligned_type __attribute__((aligned(1))) = const T; + return *reinterpret_cast(GetPointer(offset)); + } + + void Write(uint32_t value, uint32_t offset, uint32_t width) + { + auto *dst = const_cast(GetPointer(offset)); + if (memcpy_s(dst, width, &value, width) != 0) { + LOG(FATAL, PANDAFILE) << "Cannot write value : " << value << "at the dst offset : " << offset; + } + } + + uint8_t ReadByte(size_t offset) const + { + return Read(offset); + } + + template + inline auto ReadHelper(size_t byteoffset, size_t bytecount, size_t offset, size_t width) const + { + constexpr size_t BYTE_WIDTH = 8; + + size_t right_shift = offset % BYTE_WIDTH; + + S v = 0; + for (size_t i = 0; i < bytecount; i++) { + S mask = static_cast(ReadByte(byteoffset + i)) << (i * BYTE_WIDTH); + v |= mask; + } + + v >>= right_shift; + size_t left_shift = sizeof(R) * BYTE_WIDTH - width; + + // Do sign extension using arithmetic shift. It's implementation defined + // so we check such behavior using static assert + // NOLINTNEXTLINE(hicpp-signed-bitwise) + static_assert((-1 >> 1) == -1); + + // NOLINTNEXTLINE(hicpp-signed-bitwise) + return static_cast(v << left_shift) >> left_shift; + } + + template + inline auto Read() const + { + constexpr size_t BYTE_WIDTH = 8; + constexpr size_t BYTE_OFFSET = offset / BYTE_WIDTH; + constexpr size_t BYTE_OFFSET_END = (offset + width + BYTE_WIDTH - 1) / BYTE_WIDTH; + constexpr size_t BYTE_COUNT = BYTE_OFFSET_END - BYTE_OFFSET; + + using storage_type = helpers::TypeHelperT; + using return_type = helpers::TypeHelperT; + + return ReadHelper(BYTE_OFFSET, BYTE_COUNT, offset, width); + } + + template + inline auto Read64(size_t offset, size_t width) const + { + constexpr size_t BIT64 = 64; + constexpr size_t BYTE_WIDTH = 8; + + ASSERT((offset % BYTE_WIDTH) + width <= BIT64); + + size_t byteoffset = offset / BYTE_WIDTH; + size_t byteoffset_end = (offset + width + BYTE_WIDTH - 1) / BYTE_WIDTH; + size_t bytecount = byteoffset_end - byteoffset; + + using storage_type = helpers::TypeHelperT; + using return_type = helpers::TypeHelperT; + + return ReadHelper(byteoffset, bytecount, offset, width); + } + +private: + const uint8_t *pc_ {nullptr}; +}; + +} // panda::ecmascript + +#endif // ECMASCRIPT_JSPANDAFILE_BYTECODE_INST_OLD_INSTRUCTION_H \ No newline at end of file diff --git a/ecmascript/jspandafile/bytecode_inst/old_instruction.h b/ecmascript/jspandafile/bytecode_inst/old_instruction.h new file mode 100644 index 0000000000..98db94e9ef --- /dev/null +++ b/ecmascript/jspandafile/bytecode_inst/old_instruction.h @@ -0,0 +1,2033 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ECMASCRIPT_JSPANDAFILE_BYTECODE_INST_OLD_INSTRUCTION_H +#define ECMASCRIPT_JSPANDAFILE_BYTECODE_INST_OLD_INSTRUCTION_H + +#include "ecmascript/jspandafile/bytecode_inst/instruction.h" + +namespace panda::ecmascript { +class OldBytecodeInst : BytecodeInstBase { +public: +#include "ecmascript/jspandafile/bytecode_inst/old_instruction_enum.h" + + explicit OldBytecodeInst(const uint8_t *pc) : BytecodeInstBase {pc} + { + } + + inline typename OldBytecodeInst::Opcode GetOpcode() const + { + uint8_t primary = ReadByte(0); + if (primary >= 236) { // 236: second level bytecode index + uint8_t secondary = ReadByte(1); + return static_cast((secondary << 8U) | primary); + } + return static_cast(primary); + } + + OldBytecodeInst JumpTo(int32_t offset) const + { + return OldBytecodeInst(BytecodeInstBase::GetPointer(offset)); + } + + OldBytecodeInst GetNext() const + { + return JumpTo(GetSize()); + } + + const uint8_t *GetAddress() const + { + return BytecodeInstBase::GetAddress(); + } + + size_t GetSize() const + { + return Size(GetFormat(GetOpcode())); + } + + uint32_t GetId() const + { + Format format = GetFormat(GetOpcode()); + + if (format == Format::ID16) { + return static_cast(Read<8, 16>()); + } + if (format == Format::ID32) { + return static_cast(Read<8, 32>()); + } + if (format == Format::PREF_ID16_IMM16_IMM16_V8_V8) { + return static_cast(Read<16, 16>()); + } + if (format == Format::PREF_ID16_IMM16_V8) { + return static_cast(Read<16, 16>()); + } + if (format == Format::PREF_ID32) { + return static_cast(Read<16, 32>()); + } + if (format == Format::PREF_ID32_IMM8) { + return static_cast(Read<16, 32>()); + } + if (format == Format::PREF_ID32_V8) { + return static_cast(Read<16, 32>()); + } + if (format == Format::V4_IMM4_ID16) { + return static_cast(Read<16, 16>()); + } + if (format == Format::V4_V4_ID16) { + return static_cast(Read<16, 16>()); + } + if (format == Format::V4_V4_V4_IMM4_ID16) { + return static_cast(Read<24, 16>()); + } + if (format == Format::V4_V4_V4_V4_ID16) { + return static_cast(Read<24, 16>()); + } + if (format == Format::V8_ID16) { + return static_cast(Read<16, 16>()); + } + if (format == Format::V8_ID32) { + return static_cast(Read<16, 32>()); + } + + UNREACHABLE(); + } + + template + auto GetImm() const + { + if constexpr (format == Format::IMM16) { + constexpr std::array OFFSETS{8}; + constexpr std::array WIDTHS{16}; + return Read(); + } + if constexpr (format == Format::IMM16_V16) { + constexpr std::array OFFSETS{8}; + constexpr std::array WIDTHS{16}; + return Read(); + } + if constexpr (format == Format::IMM32) { + constexpr std::array OFFSETS{8}; + constexpr std::array WIDTHS{32}; + return Read(); + } + if constexpr (format == Format::IMM4_V4_V4_V4) { + constexpr std::array OFFSETS{8}; + constexpr std::array WIDTHS{4}; + return Read(); + } + if constexpr (format == Format::IMM4_V4_V4_V4_V4_V4) { + constexpr std::array OFFSETS{8}; + constexpr std::array WIDTHS{4}; + return Read(); + } + if constexpr (format == Format::IMM64) { + constexpr std::array OFFSETS{8}; + constexpr std::array WIDTHS{64}; + return Read(); + } + if constexpr (format == Format::IMM8) { + constexpr std::array OFFSETS{8}; + constexpr std::array WIDTHS{8}; + return Read(); + } + if constexpr (format == Format::PREF_ID16_IMM16_IMM16_V8_V8) { + constexpr std::array OFFSETS{32, 48}; + constexpr std::array WIDTHS{16, 16}; + return Read(); + } + if constexpr (format == Format::PREF_ID16_IMM16_V8) { + constexpr std::array OFFSETS{32}; + constexpr std::array WIDTHS{16}; + return Read(); + } + if constexpr (format == Format::PREF_ID32_IMM8) { + constexpr std::array OFFSETS{48}; + constexpr std::array WIDTHS{8}; + return Read(); + } + if constexpr (format == Format::PREF_IMM16) { + constexpr std::array OFFSETS{16}; + constexpr std::array WIDTHS{16}; + return Read(); + } + if constexpr (format == Format::PREF_IMM16_IMM16) { + constexpr std::array OFFSETS{16, 32}; + constexpr std::array WIDTHS{16, 16}; + return Read(); + } + if constexpr (format == Format::PREF_IMM16_IMM16_V8) { + constexpr std::array OFFSETS{16, 32}; + constexpr std::array WIDTHS{16, 16}; + return Read(); + } + if constexpr (format == Format::PREF_IMM16_V8) { + constexpr std::array OFFSETS{16}; + constexpr std::array WIDTHS{16}; + return Read(); + } + if constexpr (format == Format::PREF_IMM16_V8_V8) { + constexpr std::array OFFSETS{16}; + constexpr std::array WIDTHS{16}; + return Read(); + } + if constexpr (format == Format::PREF_IMM32) { + constexpr std::array OFFSETS{16}; + constexpr std::array WIDTHS{32}; + return Read(); + } + if constexpr (format == Format::PREF_IMM4_IMM4) { + constexpr std::array OFFSETS{16, 20}; + constexpr std::array WIDTHS{4, 4}; + return Read(); + } + if constexpr (format == Format::PREF_IMM4_IMM4_V8) { + constexpr std::array OFFSETS{16, 20}; + constexpr std::array WIDTHS{4, 4}; + return Read(); + } + if constexpr (format == Format::PREF_IMM8_IMM8) { + constexpr std::array OFFSETS{16, 24}; + constexpr std::array WIDTHS{8, 8}; + return Read(); + } + if constexpr (format == Format::PREF_IMM8_IMM8_V8) { + constexpr std::array OFFSETS{16, 24}; + constexpr std::array WIDTHS{8, 8}; + return Read(); + } + if constexpr (format == Format::PREF_V8_IMM32) { + constexpr std::array OFFSETS{24}; + constexpr std::array WIDTHS{32}; + return Read(); + } + if constexpr (format == Format::V4_IMM4) { + constexpr std::array OFFSETS{12}; + constexpr std::array WIDTHS{4}; + return Read(); + } + if constexpr (format == Format::V4_IMM4_ID16) { + constexpr std::array OFFSETS{12}; + constexpr std::array WIDTHS{4}; + return Read(); + } + if constexpr (format == Format::V4_V4_V4_IMM4_ID16) { + constexpr std::array OFFSETS{20}; + constexpr std::array WIDTHS{4}; + return Read(); + } + if constexpr (format == Format::V8_IMM16) { + constexpr std::array OFFSETS{16}; + constexpr std::array WIDTHS{16}; + return Read(); + } + if constexpr (format == Format::V8_IMM32) { + constexpr std::array OFFSETS{16}; + constexpr std::array WIDTHS{32}; + return Read(); + } + if constexpr (format == Format::V8_IMM64) { + constexpr std::array OFFSETS{16}; + constexpr std::array WIDTHS{64}; + return Read(); + } + if constexpr (format == Format::V8_IMM8) { + constexpr std::array OFFSETS{16}; + constexpr std::array WIDTHS{8}; + return Read(); + } + UNREACHABLE(); + } + + static constexpr size_t Size(Format format) + { + switch (format) { + case Format::ID16: { + constexpr size_t SIZE = 3; + return SIZE; + } + case Format::ID32: { + constexpr size_t SIZE = 5; + return SIZE; + } + case Format::IMM16: { + constexpr size_t SIZE = 3; + return SIZE; + } + case Format::IMM16_V16: { + constexpr size_t SIZE = 5; + return SIZE; + } + case Format::IMM32: { + constexpr size_t SIZE = 5; + return SIZE; + } + case Format::IMM4_V4_V4_V4: { + constexpr size_t SIZE = 3; + return SIZE; + } + case Format::IMM4_V4_V4_V4_V4_V4: { + constexpr size_t SIZE = 4; + return SIZE; + } + case Format::IMM64: { + constexpr size_t SIZE = 9; + return SIZE; + } + case Format::IMM8: { + constexpr size_t SIZE = 2; + return SIZE; + } + case Format::NONE: { + constexpr size_t SIZE = 1; + return SIZE; + } + case Format::PREF_ID16_IMM16_IMM16_V8_V8: { + constexpr size_t SIZE = 10; + return SIZE; + } + case Format::PREF_ID16_IMM16_V8: { + constexpr size_t SIZE = 7; + return SIZE; + } + case Format::PREF_ID32: { + constexpr size_t SIZE = 6; + return SIZE; + } + case Format::PREF_ID32_IMM8: { + constexpr size_t SIZE = 7; + return SIZE; + } + case Format::PREF_ID32_V8: { + constexpr size_t SIZE = 7; + return SIZE; + } + case Format::PREF_IMM16: { + constexpr size_t SIZE = 4; + return SIZE; + } + case Format::PREF_IMM16_IMM16: { + constexpr size_t SIZE = 6; + return SIZE; + } + case Format::PREF_IMM16_IMM16_V8: { + constexpr size_t SIZE = 7; + return SIZE; + } + case Format::PREF_IMM16_V8: { + constexpr size_t SIZE = 5; + return SIZE; + } + case Format::PREF_IMM16_V8_V8: { + constexpr size_t SIZE = 6; + return SIZE; + } + case Format::PREF_IMM32: { + constexpr size_t SIZE = 6; + return SIZE; + } + case Format::PREF_IMM4_IMM4: { + constexpr size_t SIZE = 3; + return SIZE; + } + case Format::PREF_IMM4_IMM4_V8: { + constexpr size_t SIZE = 4; + return SIZE; + } + case Format::PREF_IMM8_IMM8: { + constexpr size_t SIZE = 4; + return SIZE; + } + case Format::PREF_IMM8_IMM8_V8: { + constexpr size_t SIZE = 5; + return SIZE; + } + case Format::PREF_NONE: { + constexpr size_t SIZE = 2; + return SIZE; + } + case Format::PREF_V4_V4: { + constexpr size_t SIZE = 3; + return SIZE; + } + case Format::PREF_V8: { + constexpr size_t SIZE = 3; + return SIZE; + } + case Format::PREF_V8_IMM32: { + constexpr size_t SIZE = 7; + return SIZE; + } + case Format::PREF_V8_V8: { + constexpr size_t SIZE = 4; + return SIZE; + } + case Format::PREF_V8_V8_V8: { + constexpr size_t SIZE = 5; + return SIZE; + } + case Format::PREF_V8_V8_V8_V8: { + constexpr size_t SIZE = 6; + return SIZE; + } + case Format::V16_V16: { + constexpr size_t SIZE = 5; + return SIZE; + } + case Format::V4_IMM4: { + constexpr size_t SIZE = 2; + return SIZE; + } + case Format::V4_IMM4_ID16: { + constexpr size_t SIZE = 4; + return SIZE; + } + case Format::V4_V4: { + constexpr size_t SIZE = 2; + return SIZE; + } + case Format::V4_V4_ID16: { + constexpr size_t SIZE = 4; + return SIZE; + } + case Format::V4_V4_V4_IMM4_ID16: { + constexpr size_t SIZE = 5; + return SIZE; + } + case Format::V4_V4_V4_V4_ID16: { + constexpr size_t SIZE = 5; + return SIZE; + } + case Format::V8: { + constexpr size_t SIZE = 2; + return SIZE; + } + case Format::V8_ID16: { + constexpr size_t SIZE = 4; + return SIZE; + } + case Format::V8_ID32: { + constexpr size_t SIZE = 6; + return SIZE; + } + case Format::V8_IMM16: { + constexpr size_t SIZE = 4; + return SIZE; + } + case Format::V8_IMM32: { + constexpr size_t SIZE = 6; + return SIZE; + } + case Format::V8_IMM64: { + constexpr size_t SIZE = 10; + return SIZE; + } + case Format::V8_IMM8: { + constexpr size_t SIZE = 3; + return SIZE; + } + case Format::V8_V8: { + constexpr size_t SIZE = 3; + return SIZE; + } + default: + UNREACHABLE(); + } + } + + static constexpr Format GetFormat(Opcode opcode) + { + switch(opcode) { + case Opcode::NOP: + return Format::NONE; + case Opcode::MOV_V4_V4: + return Format::V4_V4; + case Opcode::MOV_V8_V8: + return Format::V8_V8; + case Opcode::MOV_V16_V16: + return Format::V16_V16; + case Opcode::MOV_64_V4_V4: + return Format::V4_V4; + case Opcode::MOV_64_V16_V16: + return Format::V16_V16; + case Opcode::MOV_OBJ_V4_V4: + return Format::V4_V4; + case Opcode::MOV_OBJ_V8_V8: + return Format::V8_V8; + case Opcode::MOV_OBJ_V16_V16: + return Format::V16_V16; + case Opcode::MOVI_V4_IMM4: + return Format::V4_IMM4; + case Opcode::MOVI_V8_IMM8: + return Format::V8_IMM8; + case Opcode::MOVI_V8_IMM16: + return Format::V8_IMM16; + case Opcode::MOVI_V8_IMM32: + return Format::V8_IMM32; + case Opcode::MOVI_64_V8_IMM64: + return Format::V8_IMM64; + case Opcode::FMOVI_64_V8_IMM64: + return Format::V8_IMM64; + case Opcode::MOV_NULL_V8: + return Format::V8; + case Opcode::LDA_V8: + return Format::V8; + case Opcode::LDA_64_V8: + return Format::V8; + case Opcode::LDA_OBJ_V8: + return Format::V8; + case Opcode::LDAI_IMM8: + return Format::IMM8; + case Opcode::LDAI_IMM16: + return Format::IMM16; + case Opcode::LDAI_IMM32: + return Format::IMM32; + case Opcode::LDAI_64_IMM64: + return Format::IMM64; + case Opcode::FLDAI_64_IMM64: + return Format::IMM64; + case Opcode::LDA_STR_ID32: + return Format::ID32; + case Opcode::LDA_CONST_V8_ID32: + return Format::V8_ID32; + case Opcode::LDA_TYPE_ID16: + return Format::ID16; + case Opcode::LDA_NULL: + return Format::NONE; + case Opcode::STA_V8: + return Format::V8; + case Opcode::STA_64_V8: + return Format::V8; + case Opcode::STA_OBJ_V8: + return Format::V8; + case Opcode::CMP_64_V8: + return Format::V8; + case Opcode::FCMPL_64_V8: + return Format::V8; + case Opcode::FCMPG_64_V8: + return Format::V8; + case Opcode::JMP_IMM8: + return Format::IMM8; + case Opcode::JMP_IMM16: + return Format::IMM16; + case Opcode::JMP_IMM32: + return Format::IMM32; + case Opcode::JEQ_OBJ_V8_IMM8: + return Format::V8_IMM8; + case Opcode::JEQ_OBJ_V8_IMM16: + return Format::V8_IMM16; + case Opcode::JNE_OBJ_V8_IMM8: + return Format::V8_IMM8; + case Opcode::JNE_OBJ_V8_IMM16: + return Format::V8_IMM16; + case Opcode::JEQZ_OBJ_IMM8: + return Format::IMM8; + case Opcode::JEQZ_OBJ_IMM16: + return Format::IMM16; + case Opcode::JNEZ_OBJ_IMM8: + return Format::IMM8; + case Opcode::JNEZ_OBJ_IMM16: + return Format::IMM16; + case Opcode::JEQZ_IMM8: + return Format::IMM8; + case Opcode::JEQZ_IMM16: + return Format::IMM16; + case Opcode::JNEZ_IMM8: + return Format::IMM8; + case Opcode::JNEZ_IMM16: + return Format::IMM16; + case Opcode::JLTZ_IMM8: + return Format::IMM8; + case Opcode::JLTZ_IMM16: + return Format::IMM16; + case Opcode::JGTZ_IMM8: + return Format::IMM8; + case Opcode::JGTZ_IMM16: + return Format::IMM16; + case Opcode::JLEZ_IMM8: + return Format::IMM8; + case Opcode::JLEZ_IMM16: + return Format::IMM16; + case Opcode::JGEZ_IMM8: + return Format::IMM8; + case Opcode::JGEZ_IMM16: + return Format::IMM16; + case Opcode::JEQ_V8_IMM8: + return Format::V8_IMM8; + case Opcode::JEQ_V8_IMM16: + return Format::V8_IMM16; + case Opcode::JNE_V8_IMM8: + return Format::V8_IMM8; + case Opcode::JNE_V8_IMM16: + return Format::V8_IMM16; + case Opcode::JLT_V8_IMM8: + return Format::V8_IMM8; + case Opcode::JLT_V8_IMM16: + return Format::V8_IMM16; + case Opcode::JGT_V8_IMM8: + return Format::V8_IMM8; + case Opcode::JGT_V8_IMM16: + return Format::V8_IMM16; + case Opcode::JLE_V8_IMM8: + return Format::V8_IMM8; + case Opcode::JLE_V8_IMM16: + return Format::V8_IMM16; + case Opcode::JGE_V8_IMM8: + return Format::V8_IMM8; + case Opcode::JGE_V8_IMM16: + return Format::V8_IMM16; + case Opcode::FNEG_64: + return Format::NONE; + case Opcode::NEG: + return Format::NONE; + case Opcode::NEG_64: + return Format::NONE; + case Opcode::ADD2_V8: + return Format::V8; + case Opcode::ADD2_64_V8: + return Format::V8; + case Opcode::SUB2_V8: + return Format::V8; + case Opcode::SUB2_64_V8: + return Format::V8; + case Opcode::MUL2_V8: + return Format::V8; + case Opcode::MUL2_64_V8: + return Format::V8; + case Opcode::FADD2_64_V8: + return Format::V8; + case Opcode::FSUB2_64_V8: + return Format::V8; + case Opcode::FMUL2_64_V8: + return Format::V8; + case Opcode::FDIV2_64_V8: + return Format::V8; + case Opcode::FMOD2_64_V8: + return Format::V8; + case Opcode::DIV2_V8: + return Format::V8; + case Opcode::DIV2_64_V8: + return Format::V8; + case Opcode::MOD2_V8: + return Format::V8; + case Opcode::MOD2_64_V8: + return Format::V8; + case Opcode::ADDI_IMM8: + return Format::IMM8; + case Opcode::SUBI_IMM8: + return Format::IMM8; + case Opcode::MULI_IMM8: + return Format::IMM8; + case Opcode::ANDI_IMM32: + return Format::IMM32; + case Opcode::ORI_IMM32: + return Format::IMM32; + case Opcode::SHLI_IMM8: + return Format::IMM8; + case Opcode::SHRI_IMM8: + return Format::IMM8; + case Opcode::ASHRI_IMM8: + return Format::IMM8; + case Opcode::DIVI_IMM8: + return Format::IMM8; + case Opcode::MODI_IMM8: + return Format::IMM8; + case Opcode::ADD_V4_V4: + return Format::V4_V4; + case Opcode::SUB_V4_V4: + return Format::V4_V4; + case Opcode::MUL_V4_V4: + return Format::V4_V4; + case Opcode::DIV_V4_V4: + return Format::V4_V4; + case Opcode::MOD_V4_V4: + return Format::V4_V4; + case Opcode::INCI_V4_IMM4: + return Format::V4_IMM4; + case Opcode::LDARR_8_V8: + return Format::V8; + case Opcode::LDARRU_8_V8: + return Format::V8; + case Opcode::LDARR_16_V8: + return Format::V8; + case Opcode::LDARRU_16_V8: + return Format::V8; + case Opcode::LDARR_V8: + return Format::V8; + case Opcode::LDARR_64_V8: + return Format::V8; + case Opcode::FLDARR_32_V8: + return Format::V8; + case Opcode::FLDARR_64_V8: + return Format::V8; + case Opcode::LDARR_OBJ_V8: + return Format::V8; + case Opcode::STARR_8_V4_V4: + return Format::V4_V4; + case Opcode::STARR_16_V4_V4: + return Format::V4_V4; + case Opcode::STARR_V4_V4: + return Format::V4_V4; + case Opcode::STARR_64_V4_V4: + return Format::V4_V4; + case Opcode::FSTARR_32_V4_V4: + return Format::V4_V4; + case Opcode::FSTARR_64_V4_V4: + return Format::V4_V4; + case Opcode::STARR_OBJ_V4_V4: + return Format::V4_V4; + case Opcode::LENARR_V8: + return Format::V8; + case Opcode::NEWARR_V4_V4_ID16: + return Format::V4_V4_ID16; + case Opcode::NEWOBJ_V8_ID16: + return Format::V8_ID16; + case Opcode::INITOBJ_SHORT_V4_V4_ID16: + return Format::V4_V4_ID16; + case Opcode::INITOBJ_V4_V4_V4_V4_ID16: + return Format::V4_V4_V4_V4_ID16; + case Opcode::INITOBJ_RANGE_V8_ID16: + return Format::V8_ID16; + case Opcode::LDOBJ_V8_ID16: + return Format::V8_ID16; + case Opcode::LDOBJ_64_V8_ID16: + return Format::V8_ID16; + case Opcode::LDOBJ_OBJ_V8_ID16: + return Format::V8_ID16; + case Opcode::STOBJ_V8_ID16: + return Format::V8_ID16; + case Opcode::STOBJ_64_V8_ID16: + return Format::V8_ID16; + case Opcode::STOBJ_OBJ_V8_ID16: + return Format::V8_ID16; + case Opcode::LDOBJ_V_V4_V4_ID16: + return Format::V4_V4_ID16; + case Opcode::LDOBJ_V_64_V4_V4_ID16: + return Format::V4_V4_ID16; + case Opcode::LDOBJ_V_OBJ_V4_V4_ID16: + return Format::V4_V4_ID16; + case Opcode::STOBJ_V_V4_V4_ID16: + return Format::V4_V4_ID16; + case Opcode::STOBJ_V_64_V4_V4_ID16: + return Format::V4_V4_ID16; + case Opcode::STOBJ_V_OBJ_V4_V4_ID16: + return Format::V4_V4_ID16; + case Opcode::LDSTATIC_ID16: + return Format::ID16; + case Opcode::LDSTATIC_64_ID16: + return Format::ID16; + case Opcode::LDSTATIC_OBJ_ID16: + return Format::ID16; + case Opcode::STSTATIC_ID16: + return Format::ID16; + case Opcode::STSTATIC_64_ID16: + return Format::ID16; + case Opcode::STSTATIC_OBJ_ID16: + return Format::ID16; + case Opcode::RETURN: + return Format::NONE; + case Opcode::RETURN_64: + return Format::NONE; + case Opcode::RETURN_OBJ: + return Format::NONE; + case Opcode::RETURN_VOID: + return Format::NONE; + case Opcode::THROW_V8: + return Format::V8; + case Opcode::CHECKCAST_ID16: + return Format::ID16; + case Opcode::ISINSTANCE_ID16: + return Format::ID16; + case Opcode::CALL_SHORT_V4_V4_ID16: + return Format::V4_V4_ID16; + case Opcode::CALL_V4_V4_V4_V4_ID16: + return Format::V4_V4_V4_V4_ID16; + case Opcode::CALL_RANGE_V8_ID16: + return Format::V8_ID16; + case Opcode::CALL_ACC_SHORT_V4_IMM4_ID16: + return Format::V4_IMM4_ID16; + case Opcode::CALL_ACC_V4_V4_V4_IMM4_ID16: + return Format::V4_V4_V4_IMM4_ID16; + case Opcode::CALL_VIRT_SHORT_V4_V4_ID16: + return Format::V4_V4_ID16; + case Opcode::CALL_VIRT_V4_V4_V4_V4_ID16: + return Format::V4_V4_V4_V4_ID16; + case Opcode::CALL_VIRT_RANGE_V8_ID16: + return Format::V8_ID16; + case Opcode::CALL_VIRT_ACC_SHORT_V4_IMM4_ID16: + return Format::V4_IMM4_ID16; + case Opcode::CALL_VIRT_ACC_V4_V4_V4_IMM4_ID16: + return Format::V4_V4_V4_IMM4_ID16; + case Opcode::MOV_DYN_V8_V8: + return Format::V8_V8; + case Opcode::MOV_DYN_V16_V16: + return Format::V16_V16; + case Opcode::LDA_DYN_V8: + return Format::V8; + case Opcode::STA_DYN_V8: + return Format::V8; + case Opcode::LDAI_DYN_IMM32: + return Format::IMM32; + case Opcode::FLDAI_DYN_IMM64: + return Format::IMM64; + case Opcode::RETURN_DYN: + return Format::NONE; + case Opcode::CALLI_DYN_SHORT_IMM4_V4_V4_V4: + return Format::IMM4_V4_V4_V4; + case Opcode::CALLI_DYN_IMM4_V4_V4_V4_V4_V4: + return Format::IMM4_V4_V4_V4_V4_V4; + case Opcode::CALLI_DYN_RANGE_IMM16_V16: + return Format::IMM16_V16; + case Opcode::FMOVI_PREF_V8_IMM32: + return Format::PREF_V8_IMM32; + case Opcode::I32TOF64_PREF_NONE: + return Format::PREF_NONE; + case Opcode::UCMP_PREF_V8: + return Format::PREF_V8; + case Opcode::NOT_PREF_NONE: + return Format::PREF_NONE; + case Opcode::ECMA_LDNAN_PREF_NONE: + return Format::PREF_NONE; + case Opcode::FLDAI_PREF_IMM32: + return Format::PREF_IMM32; + case Opcode::U32TOF64_PREF_NONE: + return Format::PREF_NONE; + case Opcode::UCMP_64_PREF_V8: + return Format::PREF_V8; + case Opcode::NOT_64_PREF_NONE: + return Format::PREF_NONE; + case Opcode::ECMA_LDINFINITY_PREF_NONE: + return Format::PREF_NONE; + case Opcode::FCMPL_PREF_V8: + return Format::PREF_V8; + case Opcode::I64TOF64_PREF_NONE: + return Format::PREF_NONE; + case Opcode::DIVU2_PREF_V8: + return Format::PREF_V8; + case Opcode::AND2_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_LDGLOBALTHIS_PREF_NONE: + return Format::PREF_NONE; + case Opcode::FCMPG_PREF_V8: + return Format::PREF_V8; + case Opcode::U64TOF64_PREF_NONE: + return Format::PREF_NONE; + case Opcode::DIVU2_64_PREF_V8: + return Format::PREF_V8; + case Opcode::AND2_64_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_LDUNDEFINED_PREF_NONE: + return Format::PREF_NONE; + case Opcode::FNEG_PREF_NONE: + return Format::PREF_NONE; + case Opcode::F64TOI32_PREF_NONE: + return Format::PREF_NONE; + case Opcode::MODU2_PREF_V8: + return Format::PREF_V8; + case Opcode::OR2_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_LDNULL_PREF_NONE: + return Format::PREF_NONE; + case Opcode::FADD2_PREF_V8: + return Format::PREF_V8; + case Opcode::F64TOI64_PREF_NONE: + return Format::PREF_NONE; + case Opcode::MODU2_64_PREF_V8: + return Format::PREF_V8; + case Opcode::OR2_64_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_LDSYMBOL_PREF_NONE: + return Format::PREF_NONE; + case Opcode::FSUB2_PREF_V8: + return Format::PREF_V8; + case Opcode::F64TOU32_PREF_NONE: + return Format::PREF_NONE; + case Opcode::XOR2_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_LDGLOBAL_PREF_NONE: + return Format::PREF_NONE; + case Opcode::FMUL2_PREF_V8: + return Format::PREF_V8; + case Opcode::F64TOU64_PREF_NONE: + return Format::PREF_NONE; + case Opcode::XOR2_64_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_LDTRUE_PREF_NONE: + return Format::PREF_NONE; + case Opcode::FDIV2_PREF_V8: + return Format::PREF_V8; + case Opcode::I32TOU1_PREF_NONE: + return Format::PREF_NONE; + case Opcode::SHL2_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_LDFALSE_PREF_NONE: + return Format::PREF_NONE; + case Opcode::FMOD2_PREF_V8: + return Format::PREF_V8; + case Opcode::I64TOU1_PREF_NONE: + return Format::PREF_NONE; + case Opcode::SHL2_64_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_THROWDYN_PREF_NONE: + return Format::PREF_NONE; + case Opcode::I32TOF32_PREF_NONE: + return Format::PREF_NONE; + case Opcode::U32TOU1_PREF_NONE: + return Format::PREF_NONE; + case Opcode::SHR2_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_TYPEOFDYN_PREF_NONE: + return Format::PREF_NONE; + case Opcode::U32TOF32_PREF_NONE: + return Format::PREF_NONE; + case Opcode::U64TOU1_PREF_NONE: + return Format::PREF_NONE; + case Opcode::SHR2_64_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_LDLEXENVDYN_PREF_NONE: + return Format::PREF_NONE; + case Opcode::I64TOF32_PREF_NONE: + return Format::PREF_NONE; + case Opcode::I32TOI64_PREF_NONE: + return Format::PREF_NONE; + case Opcode::ASHR2_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_POPLEXENVDYN_PREF_NONE: + return Format::PREF_NONE; + case Opcode::U64TOF32_PREF_NONE: + return Format::PREF_NONE; + case Opcode::I32TOI16_PREF_NONE: + return Format::PREF_NONE; + case Opcode::ASHR2_64_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_GETUNMAPPEDARGS_PREF_NONE: + return Format::PREF_NONE; + case Opcode::F32TOF64_PREF_NONE: + return Format::PREF_NONE; + case Opcode::I32TOU16_PREF_NONE: + return Format::PREF_NONE; + case Opcode::XORI_PREF_IMM32: + return Format::PREF_IMM32; + case Opcode::ECMA_GETPROPITERATOR_PREF_NONE: + return Format::PREF_NONE; + case Opcode::F32TOI32_PREF_NONE: + return Format::PREF_NONE; + case Opcode::I32TOI8_PREF_NONE: + return Format::PREF_NONE; + case Opcode::AND_PREF_V4_V4: + return Format::PREF_V4_V4; + case Opcode::ECMA_ASYNCFUNCTIONENTER_PREF_NONE: + return Format::PREF_NONE; + case Opcode::F32TOI64_PREF_NONE: + return Format::PREF_NONE; + case Opcode::I32TOU8_PREF_NONE: + return Format::PREF_NONE; + case Opcode::OR_PREF_V4_V4: + return Format::PREF_V4_V4; + case Opcode::ECMA_LDHOLE_PREF_NONE: + return Format::PREF_NONE; + case Opcode::F32TOU32_PREF_NONE: + return Format::PREF_NONE; + case Opcode::I64TOI32_PREF_NONE: + return Format::PREF_NONE; + case Opcode::XOR_PREF_V4_V4: + return Format::PREF_V4_V4; + case Opcode::ECMA_RETURNUNDEFINED_PREF_NONE: + return Format::PREF_NONE; + case Opcode::F32TOU64_PREF_NONE: + return Format::PREF_NONE; + case Opcode::U32TOI64_PREF_NONE: + return Format::PREF_NONE; + case Opcode::SHL_PREF_V4_V4: + return Format::PREF_V4_V4; + case Opcode::ECMA_CREATEEMPTYOBJECT_PREF_NONE: + return Format::PREF_NONE; + case Opcode::F64TOF32_PREF_NONE: + return Format::PREF_NONE; + case Opcode::U32TOI16_PREF_NONE: + return Format::PREF_NONE; + case Opcode::SHR_PREF_V4_V4: + return Format::PREF_V4_V4; + case Opcode::ECMA_CREATEEMPTYARRAY_PREF_NONE: + return Format::PREF_NONE; + case Opcode::U32TOU16_PREF_NONE: + return Format::PREF_NONE; + case Opcode::ASHR_PREF_V4_V4: + return Format::PREF_V4_V4; + case Opcode::ECMA_GETITERATOR_PREF_NONE: + return Format::PREF_NONE; + case Opcode::U32TOI8_PREF_NONE: + return Format::PREF_NONE; + case Opcode::ECMA_THROWTHROWNOTEXISTS_PREF_NONE: + return Format::PREF_NONE; + case Opcode::U32TOU8_PREF_NONE: + return Format::PREF_NONE; + case Opcode::ECMA_THROWPATTERNNONCOERCIBLE_PREF_NONE: + return Format::PREF_NONE; + case Opcode::U64TOI32_PREF_NONE: + return Format::PREF_NONE; + case Opcode::ECMA_LDHOMEOBJECT_PREF_NONE: + return Format::PREF_NONE; + case Opcode::U64TOU32_PREF_NONE: + return Format::PREF_NONE; + case Opcode::ECMA_THROWDELETESUPERPROPERTY_PREF_NONE: + return Format::PREF_NONE; + case Opcode::ECMA_DEBUGGER_PREF_NONE: + return Format::PREF_NONE; + case Opcode::ECMA_ADD2DYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_SUB2DYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_MUL2DYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_DIV2DYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_MOD2DYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_EQDYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_NOTEQDYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_LESSDYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_LESSEQDYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_GREATERDYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_GREATEREQDYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_SHL2DYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_SHR2DYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_ASHR2DYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_AND2DYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_OR2DYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_XOR2DYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_TONUMBER_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_NEGDYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_NOTDYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_INCDYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_DECDYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_EXPDYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_ISINDYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_INSTANCEOFDYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_STRICTNOTEQDYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_STRICTEQDYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_RESUMEGENERATOR_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_GETRESUMEMODE_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_CREATEGENERATOROBJ_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_THROWCONSTASSIGNMENT_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_GETTEMPLATEOBJECT_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_GETNEXTPROPNAME_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_CALLARG0DYN_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_THROWIFNOTOBJECT_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_ITERNEXT_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_CLOSEITERATOR_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_COPYMODULE_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_SUPERCALLSPREAD_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_DELOBJPROP_PREF_V8_V8: + return Format::PREF_V8_V8; + case Opcode::ECMA_NEWOBJSPREADDYN_PREF_V8_V8: + return Format::PREF_V8_V8; + case Opcode::ECMA_CREATEITERRESULTOBJ_PREF_V8_V8: + return Format::PREF_V8_V8; + case Opcode::ECMA_SUSPENDGENERATOR_PREF_V8_V8: + return Format::PREF_V8_V8; + case Opcode::ECMA_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8: + return Format::PREF_V8_V8; + case Opcode::ECMA_THROWUNDEFINEDIFHOLE_PREF_V8_V8: + return Format::PREF_V8_V8; + case Opcode::ECMA_CALLARG1DYN_PREF_V8_V8: + return Format::PREF_V8_V8; + case Opcode::ECMA_COPYDATAPROPERTIES_PREF_V8_V8: + return Format::PREF_V8_V8; + case Opcode::ECMA_STARRAYSPREAD_PREF_V8_V8: + return Format::PREF_V8_V8; + case Opcode::ECMA_GETITERATORNEXT_PREF_V8_V8: + return Format::PREF_V8_V8; + case Opcode::ECMA_SETOBJECTWITHPROTO_PREF_V8_V8: + return Format::PREF_V8_V8; + case Opcode::ECMA_LDOBJBYVALUE_PREF_V8_V8: + return Format::PREF_V8_V8; + case Opcode::ECMA_STOBJBYVALUE_PREF_V8_V8: + return Format::PREF_V8_V8; + case Opcode::ECMA_STOWNBYVALUE_PREF_V8_V8: + return Format::PREF_V8_V8; + case Opcode::ECMA_LDSUPERBYVALUE_PREF_V8_V8: + return Format::PREF_V8_V8; + case Opcode::ECMA_STSUPERBYVALUE_PREF_V8_V8: + return Format::PREF_V8_V8; + case Opcode::ECMA_LDOBJBYINDEX_PREF_V8_IMM32: + return Format::PREF_V8_IMM32; + case Opcode::ECMA_STOBJBYINDEX_PREF_V8_IMM32: + return Format::PREF_V8_IMM32; + case Opcode::ECMA_STOWNBYINDEX_PREF_V8_IMM32: + return Format::PREF_V8_IMM32; + case Opcode::ECMA_CALLSPREADDYN_PREF_V8_V8_V8: + return Format::PREF_V8_V8_V8; + case Opcode::ECMA_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8: + return Format::PREF_V8_V8_V8; + case Opcode::ECMA_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8: + return Format::PREF_V8_V8_V8; + case Opcode::ECMA_CALLARGS2DYN_PREF_V8_V8_V8: + return Format::PREF_V8_V8_V8; + case Opcode::ECMA_CALLARGS3DYN_PREF_V8_V8_V8_V8: + return Format::PREF_V8_V8_V8_V8; + case Opcode::ECMA_DEFINEGETTERSETTERBYVALUE_PREF_V8_V8_V8_V8: + return Format::PREF_V8_V8_V8_V8; + case Opcode::ECMA_NEWOBJDYNRANGE_PREF_IMM16_V8: + return Format::PREF_IMM16_V8; + case Opcode::ECMA_CALLRANGEDYN_PREF_IMM16_V8: + return Format::PREF_IMM16_V8; + case Opcode::ECMA_CALLTHISRANGEDYN_PREF_IMM16_V8: + return Format::PREF_IMM16_V8; + case Opcode::ECMA_SUPERCALL_PREF_IMM16_V8: + return Format::PREF_IMM16_V8; + case Opcode::ECMA_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8: + return Format::PREF_IMM16_V8_V8; + case Opcode::ECMA_DEFINEFUNCDYN_PREF_ID16_IMM16_V8: + return Format::PREF_ID16_IMM16_V8; + case Opcode::ECMA_DEFINENCFUNCDYN_PREF_ID16_IMM16_V8: + return Format::PREF_ID16_IMM16_V8; + case Opcode::ECMA_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8: + return Format::PREF_ID16_IMM16_V8; + case Opcode::ECMA_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8: + return Format::PREF_ID16_IMM16_V8; + case Opcode::ECMA_DEFINEMETHOD_PREF_ID16_IMM16_V8: + return Format::PREF_ID16_IMM16_V8; + case Opcode::ECMA_NEWLEXENVDYN_PREF_IMM16: + return Format::PREF_IMM16; + case Opcode::ECMA_COPYRESTARGS_PREF_IMM16: + return Format::PREF_IMM16; + case Opcode::ECMA_CREATEARRAYWITHBUFFER_PREF_IMM16: + return Format::PREF_IMM16; + case Opcode::ECMA_CREATEOBJECTHAVINGMETHOD_PREF_IMM16: + return Format::PREF_IMM16; + case Opcode::ECMA_THROWIFSUPERNOTCORRECTCALL_PREF_IMM16: + return Format::PREF_IMM16; + case Opcode::ECMA_CREATEOBJECTWITHBUFFER_PREF_IMM16: + return Format::PREF_IMM16; + case Opcode::ECMA_LDLEXVARDYN_PREF_IMM4_IMM4: + return Format::PREF_IMM4_IMM4; + case Opcode::ECMA_LDLEXVARDYN_PREF_IMM8_IMM8: + return Format::PREF_IMM8_IMM8; + case Opcode::ECMA_LDLEXVARDYN_PREF_IMM16_IMM16: + return Format::PREF_IMM16_IMM16; + case Opcode::ECMA_STLEXVARDYN_PREF_IMM4_IMM4_V8: + return Format::PREF_IMM4_IMM4_V8; + case Opcode::ECMA_STLEXVARDYN_PREF_IMM8_IMM8_V8: + return Format::PREF_IMM8_IMM8_V8; + case Opcode::ECMA_STLEXVARDYN_PREF_IMM16_IMM16_V8: + return Format::PREF_IMM16_IMM16_V8; + case Opcode::ECMA_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8: + return Format::PREF_ID16_IMM16_IMM16_V8_V8; + case Opcode::ECMA_GETMODULENAMESPACE_PREF_ID32: + return Format::PREF_ID32; + case Opcode::ECMA_STMODULEVAR_PREF_ID32: + return Format::PREF_ID32; + case Opcode::ECMA_TRYLDGLOBALBYNAME_PREF_ID32: + return Format::PREF_ID32; + case Opcode::ECMA_TRYSTGLOBALBYNAME_PREF_ID32: + return Format::PREF_ID32; + case Opcode::ECMA_LDGLOBALVAR_PREF_ID32: + return Format::PREF_ID32; + case Opcode::ECMA_STGLOBALVAR_PREF_ID32: + return Format::PREF_ID32; + case Opcode::ECMA_LDOBJBYNAME_PREF_ID32_V8: + return Format::PREF_ID32_V8; + case Opcode::ECMA_STOBJBYNAME_PREF_ID32_V8: + return Format::PREF_ID32_V8; + case Opcode::ECMA_STOWNBYNAME_PREF_ID32_V8: + return Format::PREF_ID32_V8; + case Opcode::ECMA_LDSUPERBYNAME_PREF_ID32_V8: + return Format::PREF_ID32_V8; + case Opcode::ECMA_STSUPERBYNAME_PREF_ID32_V8: + return Format::PREF_ID32_V8; + case Opcode::ECMA_LDMODULEVAR_PREF_ID32_IMM8: + return Format::PREF_ID32_IMM8; + case Opcode::ECMA_CREATEREGEXPWITHLITERAL_PREF_ID32_IMM8: + return Format::PREF_ID32_IMM8; + case Opcode::ECMA_ISTRUE_PREF_NONE: + return Format::PREF_NONE; + case Opcode::ECMA_ISFALSE_PREF_NONE: + return Format::PREF_NONE; + case Opcode::ECMA_STCONSTTOGLOBALRECORD_PREF_ID32: + return Format::PREF_ID32; + case Opcode::ECMA_STLETTOGLOBALRECORD_PREF_ID32: + return Format::PREF_ID32; + case Opcode::ECMA_STCLASSTOGLOBALRECORD_PREF_ID32: + return Format::PREF_ID32; + case Opcode::ECMA_STOWNBYVALUEWITHNAMESET_PREF_V8_V8: + return Format::PREF_V8_V8; + case Opcode::ECMA_STOWNBYNAMEWITHNAMESET_PREF_ID32_V8: + return Format::PREF_ID32_V8; + case Opcode::ECMA_LDFUNCTION_PREF_NONE: + return Format::PREF_NONE; + case Opcode::ECMA_NEWLEXENVWITHNAMEDYN_PREF_IMM16_IMM16: + return Format::PREF_IMM16_IMM16; + case Opcode::ECMA_LDBIGINT_PREF_ID32: + return Format::PREF_ID32; + case Opcode::ECMA_TONUMERIC_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_CREATEASYNCGENERATOROBJ_PREF_V8: + return Format::PREF_V8; + case Opcode::ECMA_ASYNCGENERATORRESOLVE_PREF_V8_V8_V8: + return Format::PREF_V8_V8_V8; + case Opcode::ECMA_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8: + return Format::PREF_ID16_IMM16_V8; + default: + break; + } + + UNREACHABLE(); + } + + static constexpr bool HasId(Format format, size_t idx) { + switch (format) { + case Format::ID16: + return idx < 1; + case Format::ID32: + return idx < 1; + case Format::PREF_ID16_IMM16_IMM16_V8_V8: + return idx < 1; + case Format::PREF_ID16_IMM16_V8: + return idx < 1; + case Format::PREF_ID32: + return idx < 1; + case Format::PREF_ID32_IMM8: + return idx < 1; + case Format::PREF_ID32_V8: + return idx < 1; + case Format::V4_IMM4_ID16: + return idx < 1; + case Format::V4_V4_ID16: + return idx < 1; + case Format::V4_V4_V4_IMM4_ID16: + return idx < 1; + case Format::V4_V4_V4_V4_ID16: + return idx < 1; + case Format::V8_ID16: + return idx < 1; + case Format::V8_ID32: + return idx < 1; + default: { + return false; + } + } + } + + inline bool HasFlag(Flags flag) const + { + switch(GetOpcode()) { + case Opcode::NOP: + return ((Flags::ACC_NONE) & flag) == flag; + case Opcode::MOV_V4_V4: + return ((Flags::ACC_NONE) & flag) == flag; + case Opcode::MOV_V8_V8: + return ((Flags::ACC_NONE) & flag) == flag; + case Opcode::MOV_V16_V16: + return ((Flags::ACC_NONE) & flag) == flag; + case Opcode::MOV_64_V4_V4: + return ((Flags::ACC_NONE) & flag) == flag; + case Opcode::MOV_64_V16_V16: + return ((Flags::ACC_NONE) & flag) == flag; + case Opcode::MOV_OBJ_V4_V4: + return ((Flags::ACC_NONE) & flag) == flag; + case Opcode::MOV_OBJ_V8_V8: + return ((Flags::ACC_NONE) & flag) == flag; + case Opcode::MOV_OBJ_V16_V16: + return ((Flags::ACC_NONE) & flag) == flag; + case Opcode::MOVI_V4_IMM4: + return ((Flags::ACC_NONE) & flag) == flag; + case Opcode::MOVI_V8_IMM8: + return ((Flags::ACC_NONE) & flag) == flag; + case Opcode::MOVI_V8_IMM16: + return ((Flags::ACC_NONE) & flag) == flag; + case Opcode::MOVI_V8_IMM32: + return ((Flags::ACC_NONE) & flag) == flag; + case Opcode::MOVI_64_V8_IMM64: + return ((Flags::ACC_NONE) & flag) == flag; + case Opcode::FMOVI_64_V8_IMM64: + return ((Flags::FLOAT | Flags::ACC_NONE) & flag) == flag; + case Opcode::MOV_NULL_V8: + return ((Flags::ACC_NONE) & flag) == flag; + case Opcode::LDA_V8: + return ((Flags::ACC_WRITE) & flag) == flag; + case Opcode::LDA_64_V8: + return ((Flags::ACC_WRITE) & flag) == flag; + case Opcode::LDA_OBJ_V8: + return ((Flags::ACC_WRITE) & flag) == flag; + case Opcode::LDAI_IMM8: + return ((Flags::ACC_WRITE) & flag) == flag; + case Opcode::LDAI_IMM16: + return ((Flags::ACC_WRITE) & flag) == flag; + case Opcode::LDAI_IMM32: + return ((Flags::ACC_WRITE) & flag) == flag; + case Opcode::LDAI_64_IMM64: + return ((Flags::ACC_WRITE) & flag) == flag; + case Opcode::FLDAI_64_IMM64: + return ((Flags::FLOAT | Flags::ACC_WRITE) & flag) == flag; + case Opcode::LDA_STR_ID32: + return ((Flags::STRING_ID | Flags::LANGUAGE_TYPE | Flags::MAYBE_DYNAMIC | Flags::ACC_WRITE) & flag) == flag; + case Opcode::LDA_CONST_V8_ID32: + return ((Flags::LITERALARRAY_ID | Flags::ACC_NONE) & flag) == flag; + case Opcode::LDA_TYPE_ID16: + return ((Flags::TYPE_ID | Flags::LANGUAGE_TYPE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::LDA_NULL: + return ((Flags::ACC_WRITE) & flag) == flag; + case Opcode::STA_V8: + return ((Flags::ACC_READ) & flag) == flag; + case Opcode::STA_64_V8: + return ((Flags::ACC_READ) & flag) == flag; + case Opcode::STA_OBJ_V8: + return ((Flags::ACC_READ) & flag) == flag; + case Opcode::CMP_64_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::FCMPL_64_V8: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::FCMPG_64_V8: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::JMP_IMM8: + return ((Flags::JUMP | Flags::ACC_NONE) & flag) == flag; + case Opcode::JMP_IMM16: + return ((Flags::JUMP | Flags::ACC_NONE) & flag) == flag; + case Opcode::JMP_IMM32: + return ((Flags::JUMP | Flags::ACC_NONE) & flag) == flag; + case Opcode::JEQ_OBJ_V8_IMM8: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JEQ_OBJ_V8_IMM16: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JNE_OBJ_V8_IMM8: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JNE_OBJ_V8_IMM16: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JEQZ_OBJ_IMM8: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JEQZ_OBJ_IMM16: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JNEZ_OBJ_IMM8: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JNEZ_OBJ_IMM16: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JEQZ_IMM8: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JEQZ_IMM16: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JNEZ_IMM8: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JNEZ_IMM16: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JLTZ_IMM8: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JLTZ_IMM16: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JGTZ_IMM8: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JGTZ_IMM16: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JLEZ_IMM8: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JLEZ_IMM16: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JGEZ_IMM8: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JGEZ_IMM16: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JEQ_V8_IMM8: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JEQ_V8_IMM16: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JNE_V8_IMM8: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JNE_V8_IMM16: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JLT_V8_IMM8: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JLT_V8_IMM16: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JGT_V8_IMM8: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JGT_V8_IMM16: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JLE_V8_IMM8: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JLE_V8_IMM16: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JGE_V8_IMM8: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::JGE_V8_IMM16: + return ((Flags::JUMP | Flags::CONDITIONAL | Flags::ACC_READ) & flag) == flag; + case Opcode::FNEG_64: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::NEG: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::NEG_64: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ADD2_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ADD2_64_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::SUB2_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::SUB2_64_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::MUL2_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::MUL2_64_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::FADD2_64_V8: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::FSUB2_64_V8: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::FMUL2_64_V8: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::FDIV2_64_V8: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::FMOD2_64_V8: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::DIV2_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::DIV2_64_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::MOD2_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::MOD2_64_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ADDI_IMM8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::SUBI_IMM8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::MULI_IMM8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ANDI_IMM32: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ORI_IMM32: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::SHLI_IMM8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::SHRI_IMM8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ASHRI_IMM8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::DIVI_IMM8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::MODI_IMM8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ADD_V4_V4: + return ((Flags::ACC_WRITE) & flag) == flag; + case Opcode::SUB_V4_V4: + return ((Flags::ACC_WRITE) & flag) == flag; + case Opcode::MUL_V4_V4: + return ((Flags::ACC_WRITE) & flag) == flag; + case Opcode::DIV_V4_V4: + return ((Flags::ACC_WRITE) & flag) == flag; + case Opcode::MOD_V4_V4: + return ((Flags::ACC_WRITE) & flag) == flag; + case Opcode::INCI_V4_IMM4: + return ((Flags::ACC_NONE) & flag) == flag; + case Opcode::LDARR_8_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::LDARRU_8_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::LDARR_16_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::LDARRU_16_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::LDARR_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::LDARR_64_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::FLDARR_32_V8: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::FLDARR_64_V8: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::LDARR_OBJ_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::STARR_8_V4_V4: + return ((Flags::ACC_READ) & flag) == flag; + case Opcode::STARR_16_V4_V4: + return ((Flags::ACC_READ) & flag) == flag; + case Opcode::STARR_V4_V4: + return ((Flags::ACC_READ) & flag) == flag; + case Opcode::STARR_64_V4_V4: + return ((Flags::ACC_READ) & flag) == flag; + case Opcode::FSTARR_32_V4_V4: + return ((Flags::FLOAT | Flags::ACC_READ) & flag) == flag; + case Opcode::FSTARR_64_V4_V4: + return ((Flags::FLOAT | Flags::ACC_READ) & flag) == flag; + case Opcode::STARR_OBJ_V4_V4: + return ((Flags::ACC_READ) & flag) == flag; + case Opcode::LENARR_V8: + return ((Flags::ACC_WRITE) & flag) == flag; + case Opcode::NEWARR_V4_V4_ID16: + return ((Flags::TYPE_ID | Flags::LANGUAGE_TYPE | Flags::INITIALIZE_TYPE | Flags::ACC_NONE) & flag) == flag; + case Opcode::NEWOBJ_V8_ID16: + return ((Flags::TYPE_ID | Flags::INITIALIZE_TYPE | Flags::ACC_NONE) & flag) == flag; + case Opcode::INITOBJ_SHORT_V4_V4_ID16: + return ((Flags::METHOD_ID | Flags::CALL | Flags::INITIALIZE_TYPE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::INITOBJ_V4_V4_V4_V4_ID16: + return ((Flags::METHOD_ID | Flags::CALL | Flags::INITIALIZE_TYPE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::INITOBJ_RANGE_V8_ID16: + return ((Flags::METHOD_ID | Flags::CALL | Flags::INITIALIZE_TYPE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::LDOBJ_V8_ID16: + return ((Flags::FIELD_ID | Flags::ACC_WRITE) & flag) == flag; + case Opcode::LDOBJ_64_V8_ID16: + return ((Flags::FIELD_ID | Flags::ACC_WRITE) & flag) == flag; + case Opcode::LDOBJ_OBJ_V8_ID16: + return ((Flags::FIELD_ID | Flags::ACC_WRITE) & flag) == flag; + case Opcode::STOBJ_V8_ID16: + return ((Flags::FIELD_ID | Flags::ACC_READ) & flag) == flag; + case Opcode::STOBJ_64_V8_ID16: + return ((Flags::FIELD_ID | Flags::ACC_READ) & flag) == flag; + case Opcode::STOBJ_OBJ_V8_ID16: + return ((Flags::FIELD_ID | Flags::ACC_READ) & flag) == flag; + case Opcode::LDOBJ_V_V4_V4_ID16: + return ((Flags::FIELD_ID | Flags::ACC_NONE) & flag) == flag; + case Opcode::LDOBJ_V_64_V4_V4_ID16: + return ((Flags::FIELD_ID | Flags::ACC_NONE) & flag) == flag; + case Opcode::LDOBJ_V_OBJ_V4_V4_ID16: + return ((Flags::FIELD_ID | Flags::ACC_NONE) & flag) == flag; + case Opcode::STOBJ_V_V4_V4_ID16: + return ((Flags::FIELD_ID | Flags::ACC_NONE) & flag) == flag; + case Opcode::STOBJ_V_64_V4_V4_ID16: + return ((Flags::FIELD_ID | Flags::ACC_NONE) & flag) == flag; + case Opcode::STOBJ_V_OBJ_V4_V4_ID16: + return ((Flags::FIELD_ID | Flags::ACC_NONE) & flag) == flag; + case Opcode::LDSTATIC_ID16: + return ((Flags::FIELD_ID | Flags::INITIALIZE_TYPE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::LDSTATIC_64_ID16: + return ((Flags::FIELD_ID | Flags::INITIALIZE_TYPE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::LDSTATIC_OBJ_ID16: + return ((Flags::FIELD_ID | Flags::INITIALIZE_TYPE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::STSTATIC_ID16: + return ((Flags::FIELD_ID | Flags::INITIALIZE_TYPE | Flags::ACC_READ) & flag) == flag; + case Opcode::STSTATIC_64_ID16: + return ((Flags::FIELD_ID | Flags::INITIALIZE_TYPE | Flags::ACC_READ) & flag) == flag; + case Opcode::STSTATIC_OBJ_ID16: + return ((Flags::FIELD_ID | Flags::INITIALIZE_TYPE | Flags::ACC_READ) & flag) == flag; + case Opcode::RETURN: + return ((Flags::RETURN | Flags::ACC_READ) & flag) == flag; + case Opcode::RETURN_64: + return ((Flags::RETURN | Flags::ACC_READ) & flag) == flag; + case Opcode::RETURN_OBJ: + return ((Flags::RETURN | Flags::ACC_READ) & flag) == flag; + case Opcode::RETURN_VOID: + return ((Flags::RETURN | Flags::ACC_NONE) & flag) == flag; + case Opcode::THROW_V8: + return ((Flags::ACC_NONE) & flag) == flag; + case Opcode::CHECKCAST_ID16: + return ((Flags::TYPE_ID | Flags::ACC_READ) & flag) == flag; + case Opcode::ISINSTANCE_ID16: + return ((Flags::TYPE_ID | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::CALL_SHORT_V4_V4_ID16: + return ((Flags::METHOD_ID | Flags::CALL | Flags::MAYBE_DYNAMIC | Flags::INITIALIZE_TYPE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::CALL_V4_V4_V4_V4_ID16: + return ((Flags::METHOD_ID | Flags::CALL | Flags::MAYBE_DYNAMIC | Flags::INITIALIZE_TYPE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::CALL_RANGE_V8_ID16: + return ((Flags::METHOD_ID | Flags::CALL | Flags::MAYBE_DYNAMIC | Flags::INITIALIZE_TYPE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::CALL_ACC_SHORT_V4_IMM4_ID16: + return ((Flags::METHOD_ID | Flags::CALL | Flags::MAYBE_DYNAMIC | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::CALL_ACC_V4_V4_V4_IMM4_ID16: + return ((Flags::METHOD_ID | Flags::CALL | Flags::MAYBE_DYNAMIC | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::CALL_VIRT_SHORT_V4_V4_ID16: + return ((Flags::METHOD_ID | Flags::CALL | Flags::CALL_VIRT | Flags::ACC_WRITE) & flag) == flag; + case Opcode::CALL_VIRT_V4_V4_V4_V4_ID16: + return ((Flags::METHOD_ID | Flags::CALL | Flags::CALL_VIRT | Flags::ACC_WRITE) & flag) == flag; + case Opcode::CALL_VIRT_RANGE_V8_ID16: + return ((Flags::METHOD_ID | Flags::CALL | Flags::CALL_VIRT | Flags::ACC_WRITE) & flag) == flag; + case Opcode::CALL_VIRT_ACC_SHORT_V4_IMM4_ID16: + return ((Flags::METHOD_ID | Flags::CALL | Flags::CALL_VIRT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::CALL_VIRT_ACC_V4_V4_V4_IMM4_ID16: + return ((Flags::METHOD_ID | Flags::CALL | Flags::CALL_VIRT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::MOV_DYN_V8_V8: + return ((Flags::DYNAMIC | Flags::ACC_NONE) & flag) == flag; + case Opcode::MOV_DYN_V16_V16: + return ((Flags::DYNAMIC | Flags::ACC_NONE) & flag) == flag; + case Opcode::LDA_DYN_V8: + return ((Flags::DYNAMIC | Flags::ACC_WRITE) & flag) == flag; + case Opcode::STA_DYN_V8: + return ((Flags::DYNAMIC | Flags::ACC_READ) & flag) == flag; + case Opcode::LDAI_DYN_IMM32: + return ((Flags::DYNAMIC | Flags::ACC_WRITE) & flag) == flag; + case Opcode::FLDAI_DYN_IMM64: + return ((Flags::DYNAMIC | Flags::FLOAT | Flags::ACC_WRITE) & flag) == flag; + case Opcode::RETURN_DYN: + return ((Flags::DYNAMIC | Flags::RETURN | Flags::ACC_READ) & flag) == flag; + case Opcode::CALLI_DYN_SHORT_IMM4_V4_V4_V4: + return ((Flags::DYNAMIC | Flags::CALL | Flags::ACC_WRITE) & flag) == flag; + case Opcode::CALLI_DYN_IMM4_V4_V4_V4_V4_V4: + return ((Flags::DYNAMIC | Flags::CALL | Flags::ACC_WRITE) & flag) == flag; + case Opcode::CALLI_DYN_RANGE_IMM16_V16: + return ((Flags::DYNAMIC | Flags::CALL | Flags::ACC_WRITE) & flag) == flag; + case Opcode::FMOVI_PREF_V8_IMM32: + return ((Flags::FLOAT | Flags::ACC_NONE) & flag) == flag; + case Opcode::I32TOF64_PREF_NONE: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::UCMP_PREF_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::NOT_PREF_NONE: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_LDNAN_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::FLDAI_PREF_IMM32: + return ((Flags::FLOAT | Flags::ACC_WRITE) & flag) == flag; + case Opcode::U32TOF64_PREF_NONE: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::UCMP_64_PREF_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::NOT_64_PREF_NONE: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_LDINFINITY_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::FCMPL_PREF_V8: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::I64TOF64_PREF_NONE: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::DIVU2_PREF_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::AND2_PREF_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_LDGLOBALTHIS_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::FCMPG_PREF_V8: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::U64TOF64_PREF_NONE: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::DIVU2_64_PREF_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::AND2_64_PREF_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_LDUNDEFINED_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::FNEG_PREF_NONE: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::F64TOI32_PREF_NONE: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::MODU2_PREF_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::OR2_PREF_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_LDNULL_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::FADD2_PREF_V8: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::F64TOI64_PREF_NONE: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::MODU2_64_PREF_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::OR2_64_PREF_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_LDSYMBOL_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::FSUB2_PREF_V8: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::F64TOU32_PREF_NONE: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::XOR2_PREF_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_LDGLOBAL_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::FMUL2_PREF_V8: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::F64TOU64_PREF_NONE: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::XOR2_64_PREF_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_LDTRUE_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::FDIV2_PREF_V8: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::I32TOU1_PREF_NONE: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::SHL2_PREF_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_LDFALSE_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::FMOD2_PREF_V8: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::I64TOU1_PREF_NONE: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::SHL2_64_PREF_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_THROWDYN_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::I32TOF32_PREF_NONE: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::U32TOU1_PREF_NONE: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::SHR2_PREF_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_TYPEOFDYN_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::U32TOF32_PREF_NONE: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::U64TOU1_PREF_NONE: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::SHR2_64_PREF_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_LDLEXENVDYN_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::I64TOF32_PREF_NONE: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::I32TOI64_PREF_NONE: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ASHR2_PREF_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_POPLEXENVDYN_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::U64TOF32_PREF_NONE: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::I32TOI16_PREF_NONE: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ASHR2_64_PREF_V8: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_GETUNMAPPEDARGS_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::F32TOF64_PREF_NONE: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::I32TOU16_PREF_NONE: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::XORI_PREF_IMM32: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_GETPROPITERATOR_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::F32TOI32_PREF_NONE: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::I32TOI8_PREF_NONE: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::AND_PREF_V4_V4: + return ((Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_ASYNCFUNCTIONENTER_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::F32TOI64_PREF_NONE: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::I32TOU8_PREF_NONE: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::OR_PREF_V4_V4: + return ((Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_LDHOLE_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::F32TOU32_PREF_NONE: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::I64TOI32_PREF_NONE: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::XOR_PREF_V4_V4: + return ((Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_RETURNUNDEFINED_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::RETURN | Flags::ACC_NONE) & flag) == flag; + case Opcode::F32TOU64_PREF_NONE: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::U32TOI64_PREF_NONE: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::SHL_PREF_V4_V4: + return ((Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_CREATEEMPTYOBJECT_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::F64TOF32_PREF_NONE: + return ((Flags::FLOAT | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::U32TOI16_PREF_NONE: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::SHR_PREF_V4_V4: + return ((Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_CREATEEMPTYARRAY_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::U32TOU16_PREF_NONE: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ASHR_PREF_V4_V4: + return ((Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_GETITERATOR_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::U32TOI8_PREF_NONE: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_THROWTHROWNOTEXISTS_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_NONE) & flag) == flag; + case Opcode::U32TOU8_PREF_NONE: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_THROWPATTERNNONCOERCIBLE_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_NONE) & flag) == flag; + case Opcode::U64TOI32_PREF_NONE: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_LDHOMEOBJECT_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::U64TOU32_PREF_NONE: + return ((Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_THROWDELETESUPERPROPERTY_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_NONE) & flag) == flag; + case Opcode::ECMA_DEBUGGER_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_NONE) & flag) == flag; + case Opcode::ECMA_ADD2DYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_SUB2DYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_MUL2DYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_DIV2DYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_MOD2DYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_EQDYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_NOTEQDYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_LESSDYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_LESSEQDYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_GREATERDYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_GREATEREQDYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_SHL2DYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_SHR2DYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_ASHR2DYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_AND2DYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_OR2DYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_XOR2DYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_TONUMBER_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_NEGDYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_NOTDYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_INCDYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_DECDYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_EXPDYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_ISINDYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_INSTANCEOFDYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_STRICTNOTEQDYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_STRICTEQDYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_RESUMEGENERATOR_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_GETRESUMEMODE_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_CREATEGENERATOROBJ_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_THROWCONSTASSIGNMENT_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_NONE) & flag) == flag; + case Opcode::ECMA_GETTEMPLATEOBJECT_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_GETNEXTPROPNAME_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_CALLARG0DYN_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_THROWIFNOTOBJECT_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_NONE) & flag) == flag; + case Opcode::ECMA_ITERNEXT_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_CLOSEITERATOR_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_COPYMODULE_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_SUPERCALLSPREAD_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_DELOBJPROP_PREF_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_NEWOBJSPREADDYN_PREF_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_CREATEITERRESULTOBJ_PREF_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_SUSPENDGENERATOR_PREF_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_THROWUNDEFINEDIFHOLE_PREF_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_NONE) & flag) == flag; + case Opcode::ECMA_CALLARG1DYN_PREF_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_COPYDATAPROPERTIES_PREF_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_STARRAYSPREAD_PREF_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_GETITERATORNEXT_PREF_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_SETOBJECTWITHPROTO_PREF_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_NONE) & flag) == flag; + case Opcode::ECMA_LDOBJBYVALUE_PREF_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_STOBJBYVALUE_PREF_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_STOWNBYVALUE_PREF_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_LDSUPERBYVALUE_PREF_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_STSUPERBYVALUE_PREF_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_LDOBJBYINDEX_PREF_V8_IMM32: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_STOBJBYINDEX_PREF_V8_IMM32: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_STOWNBYINDEX_PREF_V8_IMM32: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_CALLSPREADDYN_PREF_V8_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_CALLARGS2DYN_PREF_V8_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_CALLARGS3DYN_PREF_V8_V8_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_DEFINEGETTERSETTERBYVALUE_PREF_V8_V8_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_NEWOBJDYNRANGE_PREF_IMM16_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_CALLRANGEDYN_PREF_IMM16_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_CALLTHISRANGEDYN_PREF_IMM16_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_SUPERCALL_PREF_IMM16_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_DEFINEFUNCDYN_PREF_ID16_IMM16_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::METHOD_ID | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_DEFINENCFUNCDYN_PREF_ID16_IMM16_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::METHOD_ID | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::METHOD_ID | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::METHOD_ID | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_DEFINEMETHOD_PREF_ID16_IMM16_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::METHOD_ID | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_NEWLEXENVDYN_PREF_IMM16: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_COPYRESTARGS_PREF_IMM16: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_CREATEARRAYWITHBUFFER_PREF_IMM16: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_CREATEOBJECTHAVINGMETHOD_PREF_IMM16: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_THROWIFSUPERNOTCORRECTCALL_PREF_IMM16: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_CREATEOBJECTWITHBUFFER_PREF_IMM16: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_LDLEXVARDYN_PREF_IMM4_IMM4: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_LDLEXVARDYN_PREF_IMM8_IMM8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_LDLEXVARDYN_PREF_IMM16_IMM16: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_STLEXVARDYN_PREF_IMM4_IMM4_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_STLEXVARDYN_PREF_IMM8_IMM8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_STLEXVARDYN_PREF_IMM16_IMM16_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::METHOD_ID | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_GETMODULENAMESPACE_PREF_ID32: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::STRING_ID | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_STMODULEVAR_PREF_ID32: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::STRING_ID | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_TRYLDGLOBALBYNAME_PREF_ID32: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::STRING_ID | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_TRYSTGLOBALBYNAME_PREF_ID32: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::STRING_ID | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_LDGLOBALVAR_PREF_ID32: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::STRING_ID | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_STGLOBALVAR_PREF_ID32: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::STRING_ID | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_LDOBJBYNAME_PREF_ID32_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::STRING_ID | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_STOBJBYNAME_PREF_ID32_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::STRING_ID | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_STOWNBYNAME_PREF_ID32_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::STRING_ID | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_LDSUPERBYNAME_PREF_ID32_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::STRING_ID | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_STSUPERBYNAME_PREF_ID32_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::STRING_ID | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_LDMODULEVAR_PREF_ID32_IMM8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::STRING_ID | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_CREATEREGEXPWITHLITERAL_PREF_ID32_IMM8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::STRING_ID | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_ISTRUE_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_ISFALSE_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_STCONSTTOGLOBALRECORD_PREF_ID32: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::STRING_ID | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_STLETTOGLOBALRECORD_PREF_ID32: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::STRING_ID | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_STCLASSTOGLOBALRECORD_PREF_ID32: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::STRING_ID | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_STOWNBYVALUEWITHNAMESET_PREF_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_STOWNBYNAMEWITHNAMESET_PREF_ID32_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::STRING_ID | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_LDFUNCTION_PREF_NONE: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_NEWLEXENVWITHNAMEDYN_PREF_IMM16_IMM16: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_LDBIGINT_PREF_ID32: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::STRING_ID | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_TONUMERIC_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE | Flags::ACC_READ) & flag) == flag; + case Opcode::ECMA_CREATEASYNCGENERATOROBJ_PREF_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_ASYNCGENERATORRESOLVE_PREF_V8_V8_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::ACC_WRITE) & flag) == flag; + case Opcode::ECMA_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8: + return ((Flags::ACC_READ | Flags::ACC_WRITE | Flags::METHOD_ID | Flags::ACC_WRITE) & flag) == flag; + default: + return false; + } + + UNREACHABLE(); + } +}; +} // panda::ecmascript + +#endif // ECMASCRIPT_JSPANDAFILE_BYTECODE_INST_OLD_INSTRUCTION_H \ No newline at end of file diff --git a/ecmascript/jspandafile/bytecode_inst/old_instruction_enum.h b/ecmascript/jspandafile/bytecode_inst/old_instruction_enum.h new file mode 100644 index 0000000000..adcff51c01 --- /dev/null +++ b/ecmascript/jspandafile/bytecode_inst/old_instruction_enum.h @@ -0,0 +1,472 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +enum class Format : uint8_t { + ID16, + ID32, + IMM16, + IMM16_V16, + IMM32, + IMM4_V4_V4_V4, + IMM4_V4_V4_V4_V4_V4, + IMM64, + IMM8, + NONE, + PREF_ID16_IMM16_IMM16_V8_V8, + PREF_ID16_IMM16_V8, + PREF_ID32, + PREF_ID32_IMM8, + PREF_ID32_V8, + PREF_IMM16, + PREF_IMM16_IMM16, + PREF_IMM16_IMM16_V8, + PREF_IMM16_V8, + PREF_IMM16_V8_V8, + PREF_IMM32, + PREF_IMM4_IMM4, + PREF_IMM4_IMM4_V8, + PREF_IMM8_IMM8, + PREF_IMM8_IMM8_V8, + PREF_NONE, + PREF_V4_V4, + PREF_V8, + PREF_V8_IMM32, + PREF_V8_V8, + PREF_V8_V8_V8, + PREF_V8_V8_V8_V8, + V16_V16, + V4_IMM4, + V4_IMM4_ID16, + V4_V4, + V4_V4_ID16, + V4_V4_V4_IMM4_ID16, + V4_V4_V4_V4_ID16, + V8, + V8_ID16, + V8_ID32, + V8_IMM16, + V8_IMM32, + V8_IMM64, + V8_IMM8, + V8_V8, +}; + +enum class Opcode { + NOP = 0, + MOV_V4_V4 = 1, + MOV_V8_V8 = 2, + MOV_V16_V16 = 3, + MOV_64_V4_V4 = 4, + MOV_64_V16_V16 = 5, + MOV_OBJ_V4_V4 = 6, + MOV_OBJ_V8_V8 = 7, + MOV_OBJ_V16_V16 = 8, + MOVI_V4_IMM4 = 9, + MOVI_V8_IMM8 = 10, + MOVI_V8_IMM16 = 11, + MOVI_V8_IMM32 = 12, + MOVI_64_V8_IMM64 = 13, + FMOVI_64_V8_IMM64 = 14, + MOV_NULL_V8 = 15, + LDA_V8 = 16, + LDA_64_V8 = 17, + LDA_OBJ_V8 = 18, + LDAI_IMM8 = 19, + LDAI_IMM16 = 20, + LDAI_IMM32 = 21, + LDAI_64_IMM64 = 22, + FLDAI_64_IMM64 = 23, + LDA_STR_ID32 = 24, + LDA_CONST_V8_ID32 = 25, + LDA_TYPE_ID16 = 26, + LDA_NULL = 27, + STA_V8 = 28, + STA_64_V8 = 29, + STA_OBJ_V8 = 30, + CMP_64_V8 = 31, + FCMPL_64_V8 = 32, + FCMPG_64_V8 = 33, + JMP_IMM8 = 34, + JMP_IMM16 = 35, + JMP_IMM32 = 36, + JEQ_OBJ_V8_IMM8 = 37, + JEQ_OBJ_V8_IMM16 = 38, + JNE_OBJ_V8_IMM8 = 39, + JNE_OBJ_V8_IMM16 = 40, + JEQZ_OBJ_IMM8 = 41, + JEQZ_OBJ_IMM16 = 42, + JNEZ_OBJ_IMM8 = 43, + JNEZ_OBJ_IMM16 = 44, + JEQZ_IMM8 = 45, + JEQZ_IMM16 = 46, + JNEZ_IMM8 = 47, + JNEZ_IMM16 = 48, + JLTZ_IMM8 = 49, + JLTZ_IMM16 = 50, + JGTZ_IMM8 = 51, + JGTZ_IMM16 = 52, + JLEZ_IMM8 = 53, + JLEZ_IMM16 = 54, + JGEZ_IMM8 = 55, + JGEZ_IMM16 = 56, + JEQ_V8_IMM8 = 57, + JEQ_V8_IMM16 = 58, + JNE_V8_IMM8 = 59, + JNE_V8_IMM16 = 60, + JLT_V8_IMM8 = 61, + JLT_V8_IMM16 = 62, + JGT_V8_IMM8 = 63, + JGT_V8_IMM16 = 64, + JLE_V8_IMM8 = 65, + JLE_V8_IMM16 = 66, + JGE_V8_IMM8 = 67, + JGE_V8_IMM16 = 68, + FNEG_64 = 69, + NEG = 70, + NEG_64 = 71, + ADD2_V8 = 72, + ADD2_64_V8 = 73, + SUB2_V8 = 74, + SUB2_64_V8 = 75, + MUL2_V8 = 76, + MUL2_64_V8 = 77, + FADD2_64_V8 = 78, + FSUB2_64_V8 = 79, + FMUL2_64_V8 = 80, + FDIV2_64_V8 = 81, + FMOD2_64_V8 = 82, + DIV2_V8 = 83, + DIV2_64_V8 = 84, + MOD2_V8 = 85, + MOD2_64_V8 = 86, + ADDI_IMM8 = 87, + SUBI_IMM8 = 88, + MULI_IMM8 = 89, + ANDI_IMM32 = 90, + ORI_IMM32 = 91, + SHLI_IMM8 = 92, + SHRI_IMM8 = 93, + ASHRI_IMM8 = 94, + DIVI_IMM8 = 95, + MODI_IMM8 = 96, + ADD_V4_V4 = 97, + SUB_V4_V4 = 98, + MUL_V4_V4 = 99, + DIV_V4_V4 = 100, + MOD_V4_V4 = 101, + INCI_V4_IMM4 = 102, + LDARR_8_V8 = 103, + LDARRU_8_V8 = 104, + LDARR_16_V8 = 105, + LDARRU_16_V8 = 106, + LDARR_V8 = 107, + LDARR_64_V8 = 108, + FLDARR_32_V8 = 109, + FLDARR_64_V8 = 110, + LDARR_OBJ_V8 = 111, + STARR_8_V4_V4 = 112, + STARR_16_V4_V4 = 113, + STARR_V4_V4 = 114, + STARR_64_V4_V4 = 115, + FSTARR_32_V4_V4 = 116, + FSTARR_64_V4_V4 = 117, + STARR_OBJ_V4_V4 = 118, + LENARR_V8 = 119, + NEWARR_V4_V4_ID16 = 120, + NEWOBJ_V8_ID16 = 121, + INITOBJ_SHORT_V4_V4_ID16 = 122, + INITOBJ_V4_V4_V4_V4_ID16 = 123, + INITOBJ_RANGE_V8_ID16 = 124, + LDOBJ_V8_ID16 = 125, + LDOBJ_64_V8_ID16 = 126, + LDOBJ_OBJ_V8_ID16 = 127, + STOBJ_V8_ID16 = 128, + STOBJ_64_V8_ID16 = 129, + STOBJ_OBJ_V8_ID16 = 130, + LDOBJ_V_V4_V4_ID16 = 131, + LDOBJ_V_64_V4_V4_ID16 = 132, + LDOBJ_V_OBJ_V4_V4_ID16 = 133, + STOBJ_V_V4_V4_ID16 = 134, + STOBJ_V_64_V4_V4_ID16 = 135, + STOBJ_V_OBJ_V4_V4_ID16 = 136, + LDSTATIC_ID16 = 137, + LDSTATIC_64_ID16 = 138, + LDSTATIC_OBJ_ID16 = 139, + STSTATIC_ID16 = 140, + STSTATIC_64_ID16 = 141, + STSTATIC_OBJ_ID16 = 142, + RETURN = 143, + RETURN_64 = 144, + RETURN_OBJ = 145, + RETURN_VOID = 146, + THROW_V8 = 147, + CHECKCAST_ID16 = 148, + ISINSTANCE_ID16 = 149, + CALL_SHORT_V4_V4_ID16 = 150, + CALL_V4_V4_V4_V4_ID16 = 151, + CALL_RANGE_V8_ID16 = 152, + CALL_ACC_SHORT_V4_IMM4_ID16 = 153, + CALL_ACC_V4_V4_V4_IMM4_ID16 = 154, + CALL_VIRT_SHORT_V4_V4_ID16 = 155, + CALL_VIRT_V4_V4_V4_V4_ID16 = 156, + CALL_VIRT_RANGE_V8_ID16 = 157, + CALL_VIRT_ACC_SHORT_V4_IMM4_ID16 = 158, + CALL_VIRT_ACC_V4_V4_V4_IMM4_ID16 = 159, + MOV_DYN_V8_V8 = 160, + MOV_DYN_V16_V16 = 161, + LDA_DYN_V8 = 162, + STA_DYN_V8 = 163, + LDAI_DYN_IMM32 = 164, + FLDAI_DYN_IMM64 = 165, + RETURN_DYN = 166, + CALLI_DYN_SHORT_IMM4_V4_V4_V4 = 167, + CALLI_DYN_IMM4_V4_V4_V4_V4_V4 = 168, + CALLI_DYN_RANGE_IMM16_V16 = 169, + FMOVI_PREF_V8_IMM32 = 236, + I32TOF64_PREF_NONE = 237, + UCMP_PREF_V8 = 238, + NOT_PREF_NONE = 239, + ECMA_LDNAN_PREF_NONE = 255, + FLDAI_PREF_IMM32 = 492, + U32TOF64_PREF_NONE = 493, + UCMP_64_PREF_V8 = 494, + NOT_64_PREF_NONE = 495, + ECMA_LDINFINITY_PREF_NONE = 511, + FCMPL_PREF_V8 = 748, + I64TOF64_PREF_NONE = 749, + DIVU2_PREF_V8 = 750, + AND2_PREF_V8 = 751, + ECMA_LDGLOBALTHIS_PREF_NONE = 767, + FCMPG_PREF_V8 = 1004, + U64TOF64_PREF_NONE = 1005, + DIVU2_64_PREF_V8 = 1006, + AND2_64_PREF_V8 = 1007, + ECMA_LDUNDEFINED_PREF_NONE = 1023, + FNEG_PREF_NONE = 1260, + F64TOI32_PREF_NONE = 1261, + MODU2_PREF_V8 = 1262, + OR2_PREF_V8 = 1263, + ECMA_LDNULL_PREF_NONE = 1279, + FADD2_PREF_V8 = 1516, + F64TOI64_PREF_NONE = 1517, + MODU2_64_PREF_V8 = 1518, + OR2_64_PREF_V8 = 1519, + ECMA_LDSYMBOL_PREF_NONE = 1535, + FSUB2_PREF_V8 = 1772, + F64TOU32_PREF_NONE = 1773, + XOR2_PREF_V8 = 1775, + ECMA_LDGLOBAL_PREF_NONE = 1791, + FMUL2_PREF_V8 = 2028, + F64TOU64_PREF_NONE = 2029, + XOR2_64_PREF_V8 = 2031, + ECMA_LDTRUE_PREF_NONE = 2047, + FDIV2_PREF_V8 = 2284, + I32TOU1_PREF_NONE = 2285, + SHL2_PREF_V8 = 2287, + ECMA_LDFALSE_PREF_NONE = 2303, + FMOD2_PREF_V8 = 2540, + I64TOU1_PREF_NONE = 2541, + SHL2_64_PREF_V8 = 2543, + ECMA_THROWDYN_PREF_NONE = 2559, + I32TOF32_PREF_NONE = 2796, + U32TOU1_PREF_NONE = 2797, + SHR2_PREF_V8 = 2799, + ECMA_TYPEOFDYN_PREF_NONE = 2815, + U32TOF32_PREF_NONE = 3052, + U64TOU1_PREF_NONE = 3053, + SHR2_64_PREF_V8 = 3055, + ECMA_LDLEXENVDYN_PREF_NONE = 3071, + I64TOF32_PREF_NONE = 3308, + I32TOI64_PREF_NONE = 3309, + ASHR2_PREF_V8 = 3311, + ECMA_POPLEXENVDYN_PREF_NONE = 3327, + U64TOF32_PREF_NONE = 3564, + I32TOI16_PREF_NONE = 3565, + ASHR2_64_PREF_V8 = 3567, + ECMA_GETUNMAPPEDARGS_PREF_NONE = 3583, + F32TOF64_PREF_NONE = 3820, + I32TOU16_PREF_NONE = 3821, + XORI_PREF_IMM32 = 3823, + ECMA_GETPROPITERATOR_PREF_NONE = 3839, + F32TOI32_PREF_NONE = 4076, + I32TOI8_PREF_NONE = 4077, + AND_PREF_V4_V4 = 4079, + ECMA_ASYNCFUNCTIONENTER_PREF_NONE = 4095, + F32TOI64_PREF_NONE = 4332, + I32TOU8_PREF_NONE = 4333, + OR_PREF_V4_V4 = 4335, + ECMA_LDHOLE_PREF_NONE = 4351, + F32TOU32_PREF_NONE = 4588, + I64TOI32_PREF_NONE = 4589, + XOR_PREF_V4_V4 = 4591, + ECMA_RETURNUNDEFINED_PREF_NONE = 4607, + F32TOU64_PREF_NONE = 4844, + U32TOI64_PREF_NONE = 4845, + SHL_PREF_V4_V4 = 4847, + ECMA_CREATEEMPTYOBJECT_PREF_NONE = 4863, + F64TOF32_PREF_NONE = 5100, + U32TOI16_PREF_NONE = 5101, + SHR_PREF_V4_V4 = 5103, + ECMA_CREATEEMPTYARRAY_PREF_NONE = 5119, + U32TOU16_PREF_NONE = 5357, + ASHR_PREF_V4_V4 = 5359, + ECMA_GETITERATOR_PREF_NONE = 5375, + U32TOI8_PREF_NONE = 5613, + ECMA_THROWTHROWNOTEXISTS_PREF_NONE = 5631, + U32TOU8_PREF_NONE = 5869, + ECMA_THROWPATTERNNONCOERCIBLE_PREF_NONE = 5887, + U64TOI32_PREF_NONE = 6125, + ECMA_LDHOMEOBJECT_PREF_NONE = 6143, + U64TOU32_PREF_NONE = 6381, + ECMA_THROWDELETESUPERPROPERTY_PREF_NONE = 6399, + ECMA_DEBUGGER_PREF_NONE = 6655, + ECMA_ADD2DYN_PREF_V8 = 6911, + ECMA_SUB2DYN_PREF_V8 = 7167, + ECMA_MUL2DYN_PREF_V8 = 7423, + ECMA_DIV2DYN_PREF_V8 = 7679, + ECMA_MOD2DYN_PREF_V8 = 7935, + ECMA_EQDYN_PREF_V8 = 8191, + ECMA_NOTEQDYN_PREF_V8 = 8447, + ECMA_LESSDYN_PREF_V8 = 8703, + ECMA_LESSEQDYN_PREF_V8 = 8959, + ECMA_GREATERDYN_PREF_V8 = 9215, + ECMA_GREATEREQDYN_PREF_V8 = 9471, + ECMA_SHL2DYN_PREF_V8 = 9727, + ECMA_SHR2DYN_PREF_V8 = 9983, + ECMA_ASHR2DYN_PREF_V8 = 10239, + ECMA_AND2DYN_PREF_V8 = 10495, + ECMA_OR2DYN_PREF_V8 = 10751, + ECMA_XOR2DYN_PREF_V8 = 11007, + ECMA_TONUMBER_PREF_V8 = 11263, + ECMA_NEGDYN_PREF_V8 = 11519, + ECMA_NOTDYN_PREF_V8 = 11775, + ECMA_INCDYN_PREF_V8 = 12031, + ECMA_DECDYN_PREF_V8 = 12287, + ECMA_EXPDYN_PREF_V8 = 12543, + ECMA_ISINDYN_PREF_V8 = 12799, + ECMA_INSTANCEOFDYN_PREF_V8 = 13055, + ECMA_STRICTNOTEQDYN_PREF_V8 = 13311, + ECMA_STRICTEQDYN_PREF_V8 = 13567, + ECMA_RESUMEGENERATOR_PREF_V8 = 13823, + ECMA_GETRESUMEMODE_PREF_V8 = 14079, + ECMA_CREATEGENERATOROBJ_PREF_V8 = 14335, + ECMA_THROWCONSTASSIGNMENT_PREF_V8 = 14591, + ECMA_GETTEMPLATEOBJECT_PREF_V8 = 14847, + ECMA_GETNEXTPROPNAME_PREF_V8 = 15103, + ECMA_CALLARG0DYN_PREF_V8 = 15359, + ECMA_THROWIFNOTOBJECT_PREF_V8 = 15615, + ECMA_ITERNEXT_PREF_V8 = 15871, + ECMA_CLOSEITERATOR_PREF_V8 = 16127, + ECMA_COPYMODULE_PREF_V8 = 16383, + ECMA_SUPERCALLSPREAD_PREF_V8 = 16639, + ECMA_DELOBJPROP_PREF_V8_V8 = 16895, + ECMA_NEWOBJSPREADDYN_PREF_V8_V8 = 17151, + ECMA_CREATEITERRESULTOBJ_PREF_V8_V8 = 17407, + ECMA_SUSPENDGENERATOR_PREF_V8_V8 = 17663, + ECMA_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8 = 17919, + ECMA_THROWUNDEFINEDIFHOLE_PREF_V8_V8 = 18175, + ECMA_CALLARG1DYN_PREF_V8_V8 = 18431, + ECMA_COPYDATAPROPERTIES_PREF_V8_V8 = 18687, + ECMA_STARRAYSPREAD_PREF_V8_V8 = 18943, + ECMA_GETITERATORNEXT_PREF_V8_V8 = 19199, + ECMA_SETOBJECTWITHPROTO_PREF_V8_V8 = 19455, + ECMA_LDOBJBYVALUE_PREF_V8_V8 = 19711, + ECMA_STOBJBYVALUE_PREF_V8_V8 = 19967, + ECMA_STOWNBYVALUE_PREF_V8_V8 = 20223, + ECMA_LDSUPERBYVALUE_PREF_V8_V8 = 20479, + ECMA_STSUPERBYVALUE_PREF_V8_V8 = 20735, + ECMA_LDOBJBYINDEX_PREF_V8_IMM32 = 20991, + ECMA_STOBJBYINDEX_PREF_V8_IMM32 = 21247, + ECMA_STOWNBYINDEX_PREF_V8_IMM32 = 21503, + ECMA_CALLSPREADDYN_PREF_V8_V8_V8 = 21759, + ECMA_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8 = 22015, + ECMA_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8 = 22271, + ECMA_CALLARGS2DYN_PREF_V8_V8_V8 = 22527, + ECMA_CALLARGS3DYN_PREF_V8_V8_V8_V8 = 22783, + ECMA_DEFINEGETTERSETTERBYVALUE_PREF_V8_V8_V8_V8 = 23039, + ECMA_NEWOBJDYNRANGE_PREF_IMM16_V8 = 23295, + ECMA_CALLRANGEDYN_PREF_IMM16_V8 = 23551, + ECMA_CALLTHISRANGEDYN_PREF_IMM16_V8 = 23807, + ECMA_SUPERCALL_PREF_IMM16_V8 = 24063, + ECMA_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8 = 24319, + ECMA_DEFINEFUNCDYN_PREF_ID16_IMM16_V8 = 24575, + ECMA_DEFINENCFUNCDYN_PREF_ID16_IMM16_V8 = 24831, + ECMA_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8 = 25087, + ECMA_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8 = 25343, + ECMA_DEFINEMETHOD_PREF_ID16_IMM16_V8 = 25599, + ECMA_NEWLEXENVDYN_PREF_IMM16 = 25855, + ECMA_COPYRESTARGS_PREF_IMM16 = 26111, + ECMA_CREATEARRAYWITHBUFFER_PREF_IMM16 = 26367, + ECMA_CREATEOBJECTHAVINGMETHOD_PREF_IMM16 = 26623, + ECMA_THROWIFSUPERNOTCORRECTCALL_PREF_IMM16 = 26879, + ECMA_CREATEOBJECTWITHBUFFER_PREF_IMM16 = 27135, + ECMA_LDLEXVARDYN_PREF_IMM4_IMM4 = 27391, + ECMA_LDLEXVARDYN_PREF_IMM8_IMM8 = 27647, + ECMA_LDLEXVARDYN_PREF_IMM16_IMM16 = 27903, + ECMA_STLEXVARDYN_PREF_IMM4_IMM4_V8 = 28159, + ECMA_STLEXVARDYN_PREF_IMM8_IMM8_V8 = 28415, + ECMA_STLEXVARDYN_PREF_IMM16_IMM16_V8 = 28671, + ECMA_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8 = 28927, + ECMA_GETMODULENAMESPACE_PREF_ID32 = 29183, + ECMA_STMODULEVAR_PREF_ID32 = 29439, + ECMA_TRYLDGLOBALBYNAME_PREF_ID32 = 29695, + ECMA_TRYSTGLOBALBYNAME_PREF_ID32 = 29951, + ECMA_LDGLOBALVAR_PREF_ID32 = 30207, + ECMA_STGLOBALVAR_PREF_ID32 = 30463, + ECMA_LDOBJBYNAME_PREF_ID32_V8 = 30719, + ECMA_STOBJBYNAME_PREF_ID32_V8 = 30975, + ECMA_STOWNBYNAME_PREF_ID32_V8 = 31231, + ECMA_LDSUPERBYNAME_PREF_ID32_V8 = 31487, + ECMA_STSUPERBYNAME_PREF_ID32_V8 = 31743, + ECMA_LDMODULEVAR_PREF_ID32_IMM8 = 31999, + ECMA_CREATEREGEXPWITHLITERAL_PREF_ID32_IMM8 = 32255, + ECMA_ISTRUE_PREF_NONE = 32511, + ECMA_ISFALSE_PREF_NONE = 32767, + ECMA_STCONSTTOGLOBALRECORD_PREF_ID32 = 33023, + ECMA_STLETTOGLOBALRECORD_PREF_ID32 = 33279, + ECMA_STCLASSTOGLOBALRECORD_PREF_ID32 = 33535, + ECMA_STOWNBYVALUEWITHNAMESET_PREF_V8_V8 = 33791, + ECMA_STOWNBYNAMEWITHNAMESET_PREF_ID32_V8 = 34047, + ECMA_LDFUNCTION_PREF_NONE = 34303, + ECMA_NEWLEXENVWITHNAMEDYN_PREF_IMM16_IMM16 = 34559, + ECMA_LDBIGINT_PREF_ID32 = 34815, + ECMA_TONUMERIC_PREF_V8 = 35071, + ECMA_CREATEASYNCGENERATOROBJ_PREF_V8 = 35327, + ECMA_ASYNCGENERATORRESOLVE_PREF_V8_V8_V8 = 35583, + ECMA_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8 = 35839, + LAST = ECMA_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8 +}; + +enum Flags : uint32_t { + TYPE_ID = 0x1, + METHOD_ID = 0x2, + STRING_ID = 0x4, + LITERALARRAY_ID = 0x8, + FIELD_ID = 0x10, + CALL = 0x20, + CALL_VIRT = 0x40, + RETURN = 0x80, + SUSPEND = 0x100, + JUMP = 0x200, + CONDITIONAL = 0x400, + FLOAT = 0x800, + DYNAMIC = 0x1000, + MAYBE_DYNAMIC = 0x2000, + LANGUAGE_TYPE = 0x4000, + INITIALIZE_TYPE = 0x8000, + ACC_NONE = 0x10000, + ACC_READ = 0x20000, + ACC_WRITE = 0x40000, +}; diff --git a/ecmascript/jspandafile/class_info_extractor.cpp b/ecmascript/jspandafile/class_info_extractor.cpp index ef5ace4a55..9bdfb856e6 100644 --- a/ecmascript/jspandafile/class_info_extractor.cpp +++ b/ecmascript/jspandafile/class_info_extractor.cpp @@ -201,13 +201,13 @@ JSHandle ClassInfoExtractor::CreatePrototypeHClass(JSThread *thread, J layout->AddKey(thread, index, key.GetTaggedValue(), attributes); } - hclass = factory->NewEcmaDynClass(JSObject::SIZE, JSType::JS_OBJECT, length); + hclass = factory->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, length); // Not need set proto here hclass->SetLayout(thread, layout); hclass->SetNumberOfProps(length); } else { // dictionary mode - hclass = factory->NewEcmaDynClass(JSObject::SIZE, JSType::JS_OBJECT, 0); // without in-obj + hclass = factory->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, 0); // without in-obj hclass->SetIsDictionaryMode(true); hclass->SetNumberOfProps(0); } @@ -261,13 +261,13 @@ JSHandle ClassInfoExtractor::CreateConstructorHClass(JSThread *thread, layout->AddKey(thread, index, key.GetTaggedValue(), attributes); } - hclass = factory->NewEcmaDynClass(JSFunction::SIZE, JSType::JS_FUNCTION, length); + hclass = factory->NewEcmaHClass(JSFunction::SIZE, JSType::JS_FUNCTION, length); // Not need set proto here hclass->SetLayout(thread, layout); hclass->SetNumberOfProps(length); } else { // dictionary mode - hclass = factory->NewEcmaDynClass(JSFunction::SIZE, JSType::JS_FUNCTION, 0); // without in-obj + hclass = factory->NewEcmaHClass(JSFunction::SIZE, JSType::JS_FUNCTION, 0); // without in-obj hclass->SetIsDictionaryMode(true); hclass->SetNumberOfProps(0); } @@ -288,7 +288,7 @@ JSHandle ClassHelper::DefineClassTemplate(JSThread *thread, JSHandle JSHandle constructorHClass(thread, extractor->GetConstructorHClass()); JSHandle method = factory->NewJSMethod(extractor->GetConstructorMethod()); - JSHandle constructor = factory->NewJSFunctionByDynClass(method, + JSHandle constructor = factory->NewJSFunctionByHClass(method, constructorHClass, FunctionKind::CLASS_CONSTRUCTOR, MemSpaceType::OLD_SPACE); // non-static @@ -351,7 +351,7 @@ JSHandle ClassHelper::DefineClassTemplate(JSThread *thread, JSHandle ClassHelper::HandleElementsProperties(thread, JSHandle(constructor), staticElements, constantpool); } - constructor->SetProtoOrDynClass(thread, prototype); + constructor->SetProtoOrHClass(thread, prototype); return constructor; } diff --git a/ecmascript/jspandafile/literal_data_extractor.cpp b/ecmascript/jspandafile/literal_data_extractor.cpp index 131e4be7f9..8e69799aec 100644 --- a/ecmascript/jspandafile/literal_data_extractor.cpp +++ b/ecmascript/jspandafile/literal_data_extractor.cpp @@ -220,13 +220,13 @@ JSHandle LiteralDataExtractor::DefineMethodInLiteral(JSThread *threa functionClass = JSHandle::Cast(env->GetGeneratorFunctionClass()); } JSHandle jsFunc = - factory->NewJSFunctionByDynClass(method, functionClass, kind, MemSpaceType::OLD_SPACE); + factory->NewJSFunctionByHClass(method, functionClass, kind, MemSpaceType::OLD_SPACE); if (kind == FunctionKind::GENERATOR_FUNCTION) { JSHandle objFun(env->GetObjectFunction()); JSHandle initialGeneratorFuncPrototype = factory->NewJSObjectByConstructor(objFun); JSObject::SetPrototype(thread, initialGeneratorFuncPrototype, env->GetGeneratorPrototype()); - jsFunc->SetProtoOrDynClass(thread, initialGeneratorFuncPrototype); + jsFunc->SetProtoOrHClass(thread, initialGeneratorFuncPrototype); } jsFunc->SetPropertyInlinedProps(thread, JSFunction::LENGTH_INLINE_PROPERTY_INDEX, JSTaggedValue(length)); if (jsPandaFile->IsModule()) { diff --git a/ecmascript/jspandafile/panda_file_translator.cpp b/ecmascript/jspandafile/panda_file_translator.cpp index d2e3bd9360..9b3682df15 100644 --- a/ecmascript/jspandafile/panda_file_translator.cpp +++ b/ecmascript/jspandafile/panda_file_translator.cpp @@ -30,7 +30,6 @@ #include "ecmascript/ts_types/ts_manager.h" #include "ecmascript/ts_types/ts_type_table.h" #include "libpandabase/utils/utf.h" -#include "libpandafile/bytecode_instruction-inl.h" #include "libpandafile/class_data_accessor-inl.h" namespace panda::ecmascript { @@ -74,10 +73,12 @@ void PandaFileTranslator::TranslateClasses(JSPandaFile *jsPandaFile, const CStri method->SetHotnessCounter(EcmaInterpreter::GetHotnessCounter(codeSize)); method->InitializeCallField(jsPandaFile, codeDataAccessor.GetNumVregs(), codeDataAccessor.GetNumArgs()); const uint8_t *insns = codeDataAccessor.GetInstructions(); +#ifndef DISABLE_OLD_BYTECODE if (translatedCode.find(insns) == translatedCode.end()) { translatedCode.insert(insns); TranslateBytecode(jsPandaFile, codeSize, insns, method); } +#endif jsPandaFile->SetMethodToMap(method); }); } @@ -98,9 +99,9 @@ JSHandle PandaFileTranslator::GenerateProgram(EcmaVM *vm, const JSPanda auto method = jsPandaFile->FindMethods(mainMethodIndex); JSHandle jsMethod = factory->NewJSMethod(method); - JSHandle dynclass = JSHandle::Cast(env->GetFunctionClassWithProto()); + JSHandle hclass = JSHandle::Cast(env->GetFunctionClassWithProto()); JSHandle mainFunc = - factory->NewJSFunctionByDynClass(jsMethod, dynclass, FunctionKind::BASE_CONSTRUCTOR); + factory->NewJSFunctionByHClass(jsMethod, hclass, FunctionKind::BASE_CONSTRUCTOR); program->SetMainFunction(thread, mainFunc.GetTaggedValue()); @@ -132,11 +133,11 @@ JSTaggedValue PandaFileTranslator::ParseConstPool(EcmaVM *vm, const JSPandaFile const panda_file::File *pf = jsPandaFile->GetPandaFile(); - JSHandle dynclass = JSHandle::Cast(env->GetFunctionClassWithProto()); - JSHandle normalDynclass = JSHandle::Cast(env->GetFunctionClassWithoutProto()); - JSHandle asyncDynclass = JSHandle::Cast(env->GetAsyncFunctionClass()); - JSHandle generatorDynclass = JSHandle::Cast(env->GetGeneratorFunctionClass()); - JSHandle asyncGeneratorDynclass = JSHandle::Cast(env->GetAsyncGeneratorFunctionClass()); + JSHandle hclass = JSHandle::Cast(env->GetFunctionClassWithProto()); + JSHandle normalClass = JSHandle::Cast(env->GetFunctionClassWithoutProto()); + JSHandle asyncClass = JSHandle::Cast(env->GetAsyncFunctionClass()); + JSHandle generatorClass = JSHandle::Cast(env->GetGeneratorFunctionClass()); + JSHandle asyncGeneratorClass = JSHandle::Cast(env->GetAsyncGeneratorFunctionClass()); const CUnorderedMap &constpoolMap = jsPandaFile->GetConstpoolMap(); const bool isLoadedAOT = jsPandaFile->IsLoadedAOT(); @@ -155,8 +156,8 @@ JSTaggedValue PandaFileTranslator::ParseConstPool(EcmaVM *vm, const JSPandaFile ASSERT(method != nullptr); JSHandle jsMethod = factory->NewJSMethod(method); - JSHandle jsFunc = factory->NewJSFunctionByDynClass( - jsMethod, dynclass, FunctionKind::BASE_CONSTRUCTOR, MemSpaceType::OLD_SPACE); + JSHandle jsFunc = factory->NewJSFunctionByHClass( + jsMethod, hclass, FunctionKind::BASE_CONSTRUCTOR, MemSpaceType::OLD_SPACE); if (isLoadedAOT) { fileLoader->SetAOTFuncEntry(jsPandaFile, jsFunc); } @@ -168,8 +169,8 @@ JSTaggedValue PandaFileTranslator::ParseConstPool(EcmaVM *vm, const JSPandaFile ASSERT(method != nullptr); JSHandle jsMethod = factory->NewJSMethod(method); - JSHandle jsFunc = factory->NewJSFunctionByDynClass( - jsMethod, normalDynclass, FunctionKind::NORMAL_FUNCTION, MemSpaceType::OLD_SPACE); + JSHandle jsFunc = factory->NewJSFunctionByHClass( + jsMethod, normalClass, FunctionKind::NORMAL_FUNCTION, MemSpaceType::OLD_SPACE); if (isLoadedAOT) { fileLoader->SetAOTFuncEntry(jsPandaFile, jsFunc); } @@ -182,7 +183,7 @@ JSTaggedValue PandaFileTranslator::ParseConstPool(EcmaVM *vm, const JSPandaFile JSHandle jsMethod = factory->NewJSMethod(method); JSHandle jsFunc = - factory->NewJSFunctionByDynClass(jsMethod, generatorDynclass, FunctionKind::GENERATOR_FUNCTION); + factory->NewJSFunctionByHClass(jsMethod, generatorClass, FunctionKind::GENERATOR_FUNCTION); if (isLoadedAOT) { fileLoader->SetAOTFuncEntry(jsPandaFile, jsFunc); } @@ -192,7 +193,7 @@ JSTaggedValue PandaFileTranslator::ParseConstPool(EcmaVM *vm, const JSPandaFile JSHandle objFun(env->GetObjectFunction()); JSHandle initialGeneratorFuncPrototype = factory->NewJSObjectByConstructor(objFun); JSObject::SetPrototype(thread, initialGeneratorFuncPrototype, env->GetGeneratorPrototype()); - jsFunc->SetProtoOrDynClass(thread, initialGeneratorFuncPrototype); + jsFunc->SetProtoOrHClass(thread, initialGeneratorFuncPrototype); constpool->Set(thread, value.GetConstpoolIndex(), jsFunc.GetTaggedValue()); jsMethod->SetConstantPool(thread, constpool.GetTaggedValue()); @@ -203,8 +204,8 @@ JSTaggedValue PandaFileTranslator::ParseConstPool(EcmaVM *vm, const JSPandaFile JSHandle jsMethod = factory->NewJSMethod(method); JSHandle jsFunc = - factory->NewJSFunctionByDynClass(jsMethod, asyncGeneratorDynclass, - FunctionKind::ASYNC_GENERATOR_FUNCTION); + factory->NewJSFunctionByHClass(jsMethod, asyncGeneratorClass, + FunctionKind::ASYNC_GENERATOR_FUNCTION); constpool->Set(thread, value.GetConstpoolIndex(), jsFunc.GetTaggedValue()); jsMethod->SetConstantPool(thread, constpool.GetTaggedValue()); @@ -215,7 +216,7 @@ JSTaggedValue PandaFileTranslator::ParseConstPool(EcmaVM *vm, const JSPandaFile JSHandle jsMethod = factory->NewJSMethod(method); JSHandle jsFunc = - factory->NewJSFunctionByDynClass(jsMethod, asyncDynclass, FunctionKind::ASYNC_FUNCTION); + factory->NewJSFunctionByHClass(jsMethod, asyncClass, FunctionKind::ASYNC_FUNCTION); if (isLoadedAOT) { fileLoader->SetAOTFuncEntry(jsPandaFile, jsFunc); } @@ -234,8 +235,8 @@ JSTaggedValue PandaFileTranslator::ParseConstPool(EcmaVM *vm, const JSPandaFile ASSERT(method != nullptr); JSHandle jsMethod = factory->NewJSMethod(method); - JSHandle jsFunc = factory->NewJSFunctionByDynClass( - jsMethod, normalDynclass, FunctionKind::NORMAL_FUNCTION, MemSpaceType::OLD_SPACE); + JSHandle jsFunc = factory->NewJSFunctionByHClass( + jsMethod, normalClass, FunctionKind::NORMAL_FUNCTION, MemSpaceType::OLD_SPACE); if (isLoadedAOT) { fileLoader->SetAOTFuncEntry(jsPandaFile, jsFunc); } @@ -291,68 +292,1057 @@ JSTaggedValue PandaFileTranslator::ParseConstPool(EcmaVM *vm, const JSPandaFile return constpool.GetTaggedValue(); } -void PandaFileTranslator::FixOpcode(uint8_t *pc) +#ifndef DISABLE_OLD_BYTECODE +#define ADD_NOP_INST(pc, oldLen, newOpcode) \ +do { \ + int newLen = static_cast(BytecodeInstruction::Size(newOpcode)); \ + int paddingSize = static_cast(oldLen) - newLen; \ + for (int i = 0; i < paddingSize; i++) { \ + *(pc + newLen + i) = static_cast(EcmaOpcode::NOP); \ + } \ +} while (false) + +void PandaFileTranslator::FixOpcode(MethodLiteral *method, const OldBytecodeInst &inst) { - auto opcode = static_cast(*pc); + auto opcode = inst.GetOpcode(); + EcmaOpcode newOpcode; + auto oldLen = OldBytecodeInst::Size(OldBytecodeInst::GetFormat(opcode)); + auto pc = const_cast(inst.GetAddress()); + // First level opcode + if (static_cast(opcode) < 236) { // 236: second level bytecode index + switch (opcode) { + case OldBytecodeInst::Opcode::MOV_V4_V4: { + *pc = static_cast(EcmaOpcode::MOV_V4_V4); + break; + } + case OldBytecodeInst::Opcode::MOV_DYN_V8_V8: { + *pc = static_cast(EcmaOpcode::MOV_V8_V8); + break; + } + case OldBytecodeInst::Opcode::MOV_DYN_V16_V16: { + *pc = static_cast(EcmaOpcode::MOV_V16_V16); + break; + } + case OldBytecodeInst::Opcode::LDA_STR_ID32: { + newOpcode = EcmaOpcode::LDA_STR_ID16; + uint32_t id = inst.GetId(); + LOG_ECMA_IF(id > std::numeric_limits::max(), FATAL) << "Cannot translate to 16 bits: " << id; + *pc = static_cast(newOpcode); + uint16_t newId = static_cast(id); + if (memcpy_s(pc + 1, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { + LOG_FULL(FATAL) << "FixOpcode memcpy_s fail"; + UNREACHABLE(); + } + ADD_NOP_INST(pc, oldLen, newOpcode); + break; + } + case OldBytecodeInst::Opcode::JMP_IMM8: { + *pc = static_cast(EcmaOpcode::JMP_IMM8); + break; + } + case OldBytecodeInst::Opcode::JMP_IMM16: { + *pc = static_cast(EcmaOpcode::JMP_IMM16); + break; + } + case OldBytecodeInst::Opcode::JMP_IMM32: { + *pc = static_cast(EcmaOpcode::JMP_IMM32); + break; + } + case OldBytecodeInst::Opcode::JEQZ_IMM8: { + *pc = static_cast(EcmaOpcode::JEQZ_IMM8); + break; + } + case OldBytecodeInst::Opcode::JEQZ_IMM16: { + *pc = static_cast(EcmaOpcode::JEQZ_IMM16); + break; + } + case OldBytecodeInst::Opcode::JNEZ_IMM8: { + *pc = static_cast(EcmaOpcode::JNEZ_IMM8); + break; + } + case OldBytecodeInst::Opcode::JNEZ_IMM16: { + *pc = static_cast(EcmaOpcode::JNEZ_IMM16); + break; + } + case OldBytecodeInst::Opcode::LDA_DYN_V8: { + *pc = static_cast(EcmaOpcode::LDA_V8); + break; + } + case OldBytecodeInst::Opcode::STA_DYN_V8: { + *pc = static_cast(EcmaOpcode::STA_V8); + break; + } + case OldBytecodeInst::Opcode::LDAI_DYN_IMM32: { + *pc = static_cast(EcmaOpcode::LDAI_IMM32); + break; + } + case OldBytecodeInst::Opcode::FLDAI_DYN_IMM64: { + *pc = static_cast(EcmaOpcode::FLDAI_IMM64); + break; + } + case OldBytecodeInst::Opcode::RETURN_DYN: { + *pc = static_cast(EcmaOpcode::RETURN); + break; + } + default: + LOG_FULL(FATAL) << "FixOpcode fail: " << static_cast(opcode); + UNREACHABLE(); + } + return; + } + + // New second level bytecode translate + constexpr uint8_t opShifLen = 8; + constexpr EcmaOpcode throwPrefOp = EcmaOpcode::THROW_PREF_NONE; + constexpr EcmaOpcode widePrefOp = EcmaOpcode::WIDE_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8; + constexpr EcmaOpcode deprecatedPrefOp = EcmaOpcode::DEPRECATED_LDLEXENV_PREF_NONE; switch (opcode) { - case BytecodeInstruction::Opcode::MOV_V4_V4: - *pc = static_cast(EcmaOpcode::MOV_V4_V4); + // Translate to throw + case OldBytecodeInst::Opcode::ECMA_THROWIFSUPERNOTCORRECTCALL_PREF_IMM16: { + newOpcode = EcmaOpcode::THROW_IFSUPERNOTCORRECTCALL_PREF_IMM16; + *pc = static_cast(throwPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_THROWUNDEFINEDIFHOLE_PREF_V8_V8: { + newOpcode = EcmaOpcode::THROW_UNDEFINEDIFHOLE_PREF_V8_V8; + *pc = static_cast(throwPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_THROWIFNOTOBJECT_PREF_V8: { + newOpcode = EcmaOpcode::THROW_IFNOTOBJECT_PREF_V8; + *pc = static_cast(throwPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; break; - case BytecodeInstruction::Opcode::MOV_DYN_V8_V8: - *pc = static_cast(EcmaOpcode::MOV_DYN_V8_V8); + } + case OldBytecodeInst::Opcode::ECMA_THROWCONSTASSIGNMENT_PREF_V8: { + newOpcode = EcmaOpcode::THROW_CONSTASSIGNMENT_PREF_V8; + *pc = static_cast(throwPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; break; - case BytecodeInstruction::Opcode::MOV_DYN_V16_V16: - *pc = static_cast(EcmaOpcode::MOV_DYN_V16_V16); + } + case OldBytecodeInst::Opcode::ECMA_THROWDELETESUPERPROPERTY_PREF_NONE: { + newOpcode = EcmaOpcode::THROW_DELETESUPERPROPERTY_PREF_NONE; + *pc = static_cast(throwPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; break; - case BytecodeInstruction::Opcode::LDA_STR_ID32: - *pc = static_cast(EcmaOpcode::LDA_STR_ID32); + } + case OldBytecodeInst::Opcode::ECMA_THROWPATTERNNONCOERCIBLE_PREF_NONE: { + newOpcode = EcmaOpcode::THROW_PATTERNNONCOERCIBLE_PREF_NONE; + *pc = static_cast(throwPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; break; - case BytecodeInstruction::Opcode::JMP_IMM8: - *pc = static_cast(EcmaOpcode::JMP_IMM8); + } + case OldBytecodeInst::Opcode::ECMA_THROWTHROWNOTEXISTS_PREF_NONE: { + newOpcode = EcmaOpcode::THROW_NOTEXISTS_PREF_NONE; + *pc = static_cast(throwPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; break; - case BytecodeInstruction::Opcode::JMP_IMM16: - *pc = static_cast(EcmaOpcode::JMP_IMM16); + } + case OldBytecodeInst::Opcode::ECMA_THROWDYN_PREF_NONE: { + newOpcode = EcmaOpcode::THROW_PREF_NONE; + *pc = static_cast(throwPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; break; - case BytecodeInstruction::Opcode::JMP_IMM32: - *pc = static_cast(EcmaOpcode::JMP_IMM32); + } + // Translate to wide + case OldBytecodeInst::Opcode::ECMA_LDLEXVARDYN_PREF_IMM16_IMM16: { + newOpcode = EcmaOpcode::WIDE_LDLEXVAR_PREF_IMM16_IMM16; + *pc = static_cast(widePrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_COPYRESTARGS_PREF_IMM16: { + newOpcode = EcmaOpcode::WIDE_COPYRESTARGS_PREF_IMM16; + *pc = static_cast(widePrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_STOWNBYINDEX_PREF_V8_IMM32: { + newOpcode = EcmaOpcode::WIDE_STOWNBYINDEX_PREF_V8_IMM32; + *pc = static_cast(widePrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; break; - case BytecodeInstruction::Opcode::JEQZ_IMM8: - *pc = static_cast(EcmaOpcode::JEQZ_IMM8); + } + case OldBytecodeInst::Opcode::ECMA_STOBJBYINDEX_PREF_V8_IMM32: { + newOpcode = EcmaOpcode::WIDE_STOBJBYINDEX_PREF_V8_IMM32; + *pc = static_cast(widePrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; break; - case BytecodeInstruction::Opcode::JEQZ_IMM16: - *pc = static_cast(EcmaOpcode::JEQZ_IMM16); + } + case OldBytecodeInst::Opcode::ECMA_NEWLEXENVWITHNAMEDYN_PREF_IMM16_IMM16: { + newOpcode = EcmaOpcode::WIDE_NEWLEXENVWITHNAME_PREF_IMM16_ID16; + *pc = static_cast(widePrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; break; - case BytecodeInstruction::Opcode::JNEZ_IMM8: - *pc = static_cast(EcmaOpcode::JNEZ_IMM8); + } + case OldBytecodeInst::Opcode::ECMA_NEWLEXENVDYN_PREF_IMM16: { + newOpcode = EcmaOpcode::WIDE_NEWLEXENV_PREF_IMM16; + *pc = static_cast(widePrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; break; - case BytecodeInstruction::Opcode::JNEZ_IMM16: - *pc = static_cast(EcmaOpcode::JNEZ_IMM16); + } + case OldBytecodeInst::Opcode::ECMA_NEWOBJDYNRANGE_PREF_IMM16_V8: { + newOpcode = EcmaOpcode::WIDE_NEWOBJRANGE_PREF_IMM16_V8; + *pc = static_cast(widePrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; break; - case BytecodeInstruction::Opcode::LDA_DYN_V8: - *pc = static_cast(EcmaOpcode::LDA_DYN_V8); + } + case OldBytecodeInst::Opcode::ECMA_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8: { + newOpcode = EcmaOpcode::WIDE_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8; + *pc = static_cast(widePrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; break; - case BytecodeInstruction::Opcode::STA_DYN_V8: - *pc = static_cast(EcmaOpcode::STA_DYN_V8); + } + case OldBytecodeInst::Opcode::ECMA_SUPERCALL_PREF_IMM16_V8: { + newOpcode = EcmaOpcode::WIDE_SUPERCALLARROWRANGE_PREF_IMM16_V8; + *pc = static_cast(widePrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; break; - case BytecodeInstruction::Opcode::LDAI_DYN_IMM32: - *pc = static_cast(EcmaOpcode::LDAI_DYN_IMM32); + } + // Translate to deprecated + case OldBytecodeInst::Opcode::ECMA_STCLASSTOGLOBALRECORD_PREF_ID32: { + newOpcode = EcmaOpcode::DEPRECATED_STCLASSTOGLOBALRECORD_PREF_ID32; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; break; - case BytecodeInstruction::Opcode::FLDAI_DYN_IMM64: - *pc = static_cast(EcmaOpcode::FLDAI_DYN_IMM64); + } + case OldBytecodeInst::Opcode::ECMA_STLETTOGLOBALRECORD_PREF_ID32: { + newOpcode = EcmaOpcode::DEPRECATED_STLETTOGLOBALRECORD_PREF_ID32; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; break; - case BytecodeInstruction::Opcode::RETURN_DYN: - *pc = static_cast(EcmaOpcode::RETURN_DYN); + } + case OldBytecodeInst::Opcode::ECMA_STCONSTTOGLOBALRECORD_PREF_ID32: { + newOpcode = EcmaOpcode::DEPRECATED_STCONSTTOGLOBALRECORD_PREF_ID32; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; break; - default: - if (*pc != static_cast(BytecodeInstruction::Opcode::ECMA_LDNAN_PREF_NONE)) { - LOG_FULL(FATAL) << "Is not an Ecma Opcode opcode: " << static_cast(opcode); + } + case OldBytecodeInst::Opcode::ECMA_LDMODULEVAR_PREF_ID32_IMM8: { + newOpcode = EcmaOpcode::DEPRECATED_LDMODULEVAR_PREF_ID32_IMM8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_LDSUPERBYNAME_PREF_ID32_V8: { + newOpcode = EcmaOpcode::DEPRECATED_LDSUPERBYNAME_PREF_ID32_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_LDOBJBYNAME_PREF_ID32_V8: { + newOpcode = EcmaOpcode::DEPRECATED_LDOBJBYNAME_PREF_ID32_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_STMODULEVAR_PREF_ID32: { + newOpcode = EcmaOpcode::DEPRECATED_STMODULEVAR_PREF_ID32; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_GETMODULENAMESPACE_PREF_ID32: { + newOpcode = EcmaOpcode::DEPRECATED_GETMODULENAMESPACE_PREF_ID32; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_STLEXVARDYN_PREF_IMM16_IMM16_V8: { + newOpcode = EcmaOpcode::DEPRECATED_STLEXVAR_PREF_IMM16_IMM16_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_STLEXVARDYN_PREF_IMM8_IMM8_V8: { + newOpcode = EcmaOpcode::DEPRECATED_STLEXVAR_PREF_IMM8_IMM8_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_STLEXVARDYN_PREF_IMM4_IMM4_V8: { + newOpcode = EcmaOpcode::DEPRECATED_STLEXVAR_PREF_IMM4_IMM4_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8: { + newOpcode = EcmaOpcode::DEPRECATED_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8: { + newOpcode = EcmaOpcode::DEPRECATED_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_LDOBJBYINDEX_PREF_V8_IMM32: { + newOpcode = EcmaOpcode::DEPRECATED_LDOBJBYINDEX_PREF_V8_IMM32; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_LDSUPERBYVALUE_PREF_V8_V8: { + newOpcode = EcmaOpcode::DEPRECATED_LDSUPERBYVALUE_PREF_V8_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_LDOBJBYVALUE_PREF_V8_V8: { + newOpcode = EcmaOpcode::DEPRECATED_LDOBJBYVALUE_PREF_V8_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_SETOBJECTWITHPROTO_PREF_V8_V8: { + newOpcode = EcmaOpcode::DEPRECATED_SETOBJECTWITHPROTO_PREF_V8_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_COPYDATAPROPERTIES_PREF_V8_V8: { + newOpcode = EcmaOpcode::DEPRECATED_COPYDATAPROPERTIES_PREF_V8_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8: { + newOpcode = EcmaOpcode::DEPRECATED_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_SUSPENDGENERATOR_PREF_V8_V8: { + newOpcode = EcmaOpcode::DEPRECATED_SUSPENDGENERATOR_PREF_V8_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_DELOBJPROP_PREF_V8_V8: { + newOpcode = EcmaOpcode::DEPRECATED_DELOBJPROP_PREF_V8_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_GETTEMPLATEOBJECT_PREF_V8: { + newOpcode = EcmaOpcode::DEPRECATED_GETTEMPLATEOBJECT_PREF_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_GETRESUMEMODE_PREF_V8: { + newOpcode = EcmaOpcode::DEPRECATED_GETRESUMEMODE_PREF_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_RESUMEGENERATOR_PREF_V8: { + newOpcode = EcmaOpcode::DEPRECATED_RESUMEGENERATOR_PREF_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8: { + newOpcode = EcmaOpcode::DEPRECATED_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_DEFINEMETHOD_PREF_ID16_IMM16_V8: { + newOpcode = EcmaOpcode::DEPRECATED_DEFINEMETHOD_PREF_ID16_IMM16_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8: { + newOpcode = EcmaOpcode::DEPRECATED_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8: { + newOpcode = EcmaOpcode::DEPRECATED_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_DEFINENCFUNCDYN_PREF_ID16_IMM16_V8: { + newOpcode = EcmaOpcode::DEPRECATED_DEFINENCFUNC_PREF_ID16_IMM16_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_DEFINEFUNCDYN_PREF_ID16_IMM16_V8: { + newOpcode = EcmaOpcode::DEPRECATED_DEFINEFUNC_PREF_ID16_IMM16_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_CALLTHISRANGEDYN_PREF_IMM16_V8: { + newOpcode = EcmaOpcode::DEPRECATED_CALLTHISRANGE_PREF_IMM16_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_CALLSPREADDYN_PREF_V8_V8_V8: { + newOpcode = EcmaOpcode::DEPRECATED_CALLSPREAD_PREF_V8_V8_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_CALLRANGEDYN_PREF_IMM16_V8: { + newOpcode = EcmaOpcode::DEPRECATED_CALLRANGE_PREF_IMM16_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_CALLARGS3DYN_PREF_V8_V8_V8_V8: { + newOpcode = EcmaOpcode::DEPRECATED_CALLARGS3_PREF_V8_V8_V8_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_CALLARGS2DYN_PREF_V8_V8_V8: { + newOpcode = EcmaOpcode::DEPRECATED_CALLARGS2_PREF_V8_V8_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_CALLARG1DYN_PREF_V8_V8: { + newOpcode = EcmaOpcode::DEPRECATED_CALLARG1_PREF_V8_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_CALLARG0DYN_PREF_V8: { + newOpcode = EcmaOpcode::DEPRECATED_CALLARG0_PREF_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_DECDYN_PREF_V8: { + newOpcode = EcmaOpcode::DEPRECATED_DEC_PREF_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_INCDYN_PREF_V8: { + newOpcode = EcmaOpcode::DEPRECATED_INC_PREF_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_NOTDYN_PREF_V8: { + newOpcode = EcmaOpcode::DEPRECATED_NOT_PREF_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_NEGDYN_PREF_V8: { + newOpcode = EcmaOpcode::DEPRECATED_NEG_PREF_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_TONUMERIC_PREF_V8: { + newOpcode = EcmaOpcode::DEPRECATED_TONUMERIC_PREF_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_TONUMBER_PREF_V8: { + newOpcode = EcmaOpcode::DEPRECATED_TONUMBER_PREF_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_CREATEOBJECTWITHBUFFER_PREF_IMM16: { + newOpcode = EcmaOpcode::DEPRECATED_CREATEOBJECTWITHBUFFER_PREF_IMM16; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_CREATEARRAYWITHBUFFER_PREF_IMM16: { + newOpcode = EcmaOpcode::DEPRECATED_CREATEARRAYWITHBUFFER_PREF_IMM16; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_GETITERATORNEXT_PREF_V8_V8: { + newOpcode = EcmaOpcode::DEPRECATED_GETITERATORNEXT_PREF_V8_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_POPLEXENVDYN_PREF_NONE: { + newOpcode = EcmaOpcode::DEPRECATED_POPLEXENV_PREF_NONE; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_LDLEXENVDYN_PREF_NONE: { + newOpcode = EcmaOpcode::DEPRECATED_LDLEXENV_PREF_NONE; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_LDHOMEOBJECT_PREF_NONE: { + newOpcode = EcmaOpcode::DEPRECATED_LDHOMEOBJECT_PREF_NONE; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_CREATEOBJECTHAVINGMETHOD_PREF_IMM16: { + newOpcode = EcmaOpcode::DEPRECATED_CREATEOBJECTHAVINGMETHOD_PREF_IMM16; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + case OldBytecodeInst::Opcode::ECMA_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8: { + newOpcode = EcmaOpcode::DEPRECATED_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8; + *pc = static_cast(deprecatedPrefOp); + *(pc + 1) = static_cast(newOpcode) >> opShifLen; + break; + } + // The same format has IC + case OldBytecodeInst::Opcode::ECMA_TYPEOFDYN_PREF_NONE: { + newOpcode = EcmaOpcode::TYPEOF_IMM8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_INSTANCEOFDYN_PREF_V8: { + newOpcode = EcmaOpcode::INSTANCEOF_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_CREATEEMPTYARRAY_PREF_NONE: { + newOpcode = EcmaOpcode::CREATEEMPTYARRAY_IMM8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_GETITERATOR_PREF_NONE: { + newOpcode = EcmaOpcode::GETITERATOR_IMM8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_ADD2DYN_PREF_V8: { + newOpcode = EcmaOpcode::ADD2_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_SUB2DYN_PREF_V8: { + newOpcode = EcmaOpcode::SUB2_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_MUL2DYN_PREF_V8: { + newOpcode = EcmaOpcode::MUL2_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_DIV2DYN_PREF_V8: { + newOpcode = EcmaOpcode::DIV2_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_MOD2DYN_PREF_V8: { + newOpcode = EcmaOpcode::MOD2_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_EQDYN_PREF_V8: { + newOpcode = EcmaOpcode::EQ_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_NOTEQDYN_PREF_V8: { + newOpcode = EcmaOpcode::NOTEQ_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_LESSDYN_PREF_V8: { + newOpcode = EcmaOpcode::LESS_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_LESSEQDYN_PREF_V8: { + newOpcode = EcmaOpcode::LESSEQ_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_GREATERDYN_PREF_V8: { + newOpcode = EcmaOpcode::GREATER_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_GREATEREQDYN_PREF_V8: { + newOpcode = EcmaOpcode::GREATEREQ_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_SHL2DYN_PREF_V8: { + newOpcode = EcmaOpcode::SHL2_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_ASHR2DYN_PREF_V8: { + newOpcode = EcmaOpcode::SHR2_IMM8_V8; // TODO: old instruction was wrong + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_SHR2DYN_PREF_V8: { + newOpcode = EcmaOpcode::ASHR2_IMM8_V8; // TODO: old instruction was wrong + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_AND2DYN_PREF_V8: { + newOpcode = EcmaOpcode::AND2_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_OR2DYN_PREF_V8: { + newOpcode = EcmaOpcode::OR2_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_XOR2DYN_PREF_V8: { + newOpcode = EcmaOpcode::XOR2_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_EXPDYN_PREF_V8: { + newOpcode = EcmaOpcode::EXP_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_ISINDYN_PREF_V8: { + newOpcode = EcmaOpcode::ISIN_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_STRICTNOTEQDYN_PREF_V8: { + newOpcode = EcmaOpcode::STRICTNOTEQ_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_STRICTEQDYN_PREF_V8: { + newOpcode = EcmaOpcode::STRICTEQ_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_ITERNEXT_PREF_V8: { + // *pc = static_cast(EcmaOpcode::new_op_xxxxxxxx); + // *(pc + 1) = 0x00; + LOG_FULL(FATAL) << "Need Add ITERNEXT Deprecated"; + return; + } + case OldBytecodeInst::Opcode::ECMA_CLOSEITERATOR_PREF_V8: { + newOpcode = EcmaOpcode::CLOSEITERATOR_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_SUPERCALLSPREAD_PREF_V8: { + newOpcode = EcmaOpcode::SUPERCALLSPREAD_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_STOBJBYVALUE_PREF_V8_V8: { + newOpcode = EcmaOpcode::STOBJBYVALUE_IMM8_V8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_STOWNBYVALUE_PREF_V8_V8: { + newOpcode = EcmaOpcode::STOWNBYVALUE_IMM8_V8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_STSUPERBYVALUE_PREF_V8_V8: { + newOpcode = EcmaOpcode::STSUPERBYVALUE_IMM8_V8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + case OldBytecodeInst::Opcode::ECMA_STOWNBYVALUEWITHNAMESET_PREF_V8_V8: { + newOpcode = EcmaOpcode::STOWNBYVALUEWITHNAMESET_IMM8_V8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + break; + } + // The same format no IC + case OldBytecodeInst::Opcode::ECMA_ASYNCFUNCTIONENTER_PREF_NONE: { + newOpcode = EcmaOpcode::ASYNCFUNCTIONENTER; + *pc = static_cast(newOpcode); + break; + } + case OldBytecodeInst::Opcode::ECMA_ASYNCGENERATORRESOLVE_PREF_V8_V8_V8: { + newOpcode = EcmaOpcode::ASYNCGENERATORRESOLVE_V8_V8_V8; + *pc = static_cast(newOpcode); + auto newLen = BytecodeInstruction::Size(newOpcode); + if (memmove_s(pc + 1, newLen - 1, pc + 2, oldLen - 2) != EOK) { // 2: skip second level inst and pref + LOG_FULL(FATAL) << "FixOpcode memmove_s fail"; + UNREACHABLE(); + } + break; + } + case OldBytecodeInst::Opcode::ECMA_CREATEASYNCGENERATOROBJ_PREF_V8: { + newOpcode = EcmaOpcode::CREATEASYNCGENERATOROBJ_V8; + *pc = static_cast(newOpcode); + auto newLen = BytecodeInstruction::Size(newOpcode); + if (memmove_s(pc + 1, newLen - 1, pc + 2, oldLen - 2) != EOK) { // 2: skip second level inst and pref + LOG_FULL(FATAL) << "FixOpcode memmove_s fail"; + UNREACHABLE(); + } + break; + } + case OldBytecodeInst::Opcode::ECMA_CREATEEMPTYOBJECT_PREF_NONE: { + newOpcode = EcmaOpcode::CREATEEMPTYOBJECT; + *pc = static_cast(newOpcode); + break; + } + case OldBytecodeInst::Opcode::ECMA_CREATEGENERATOROBJ_PREF_V8: { + newOpcode = EcmaOpcode::CREATEGENERATOROBJ_V8; + *pc = static_cast(newOpcode); + auto newLen = BytecodeInstruction::Size(newOpcode); + if (memmove_s(pc + 1, newLen - 1, pc + 2, oldLen - 2) != EOK) { // 2: skip second level inst and pref + LOG_FULL(FATAL) << "FixOpcode memmove_s fail"; + UNREACHABLE(); + } + break; + } + case OldBytecodeInst::Opcode::ECMA_CREATEITERRESULTOBJ_PREF_V8_V8: { + newOpcode = EcmaOpcode::CREATEITERRESULTOBJ_V8_V8; + *pc = static_cast(newOpcode); + auto newLen = BytecodeInstruction::Size(newOpcode); + if (memmove_s(pc + 1, newLen - 1, pc + 2, oldLen - 2) != EOK) { // 2: skip second level inst and pref + LOG_FULL(FATAL) << "FixOpcode memmove_s fail"; + UNREACHABLE(); + } + break; + } + case OldBytecodeInst::Opcode::ECMA_DEBUGGER_PREF_NONE: { + newOpcode = EcmaOpcode::DEBUGGER; + *pc = static_cast(newOpcode); + break; + } + case OldBytecodeInst::Opcode::ECMA_DEFINEGETTERSETTERBYVALUE_PREF_V8_V8_V8_V8: { + newOpcode = EcmaOpcode::DEFINEGETTERSETTERBYVALUE_V8_V8_V8_V8; + *pc = static_cast(newOpcode); + auto newLen = BytecodeInstruction::Size(newOpcode); + if (memmove_s(pc + 1, newLen - 1, pc + 2, oldLen - 2) != EOK) { // 2: skip second level inst and pref + LOG_FULL(FATAL) << "FixOpcode memmove_s fail"; + UNREACHABLE(); + } + break; + } + case OldBytecodeInst::Opcode::ECMA_GETNEXTPROPNAME_PREF_V8: { + newOpcode = EcmaOpcode::GETNEXTPROPNAME_V8; + *pc = static_cast(newOpcode); + auto newLen = BytecodeInstruction::Size(newOpcode); + if (memmove_s(pc + 1, newLen - 1, pc + 2, oldLen - 2) != EOK) { // 2: skip second level inst and pref + LOG_FULL(FATAL) << "FixOpcode memmove_s fail"; + UNREACHABLE(); + } + break; + } + case OldBytecodeInst::Opcode::ECMA_GETPROPITERATOR_PREF_NONE: { + newOpcode = EcmaOpcode::GETPROPITERATOR; + *pc = static_cast(newOpcode); + break; + } + case OldBytecodeInst::Opcode::ECMA_GETUNMAPPEDARGS_PREF_NONE: { + newOpcode = EcmaOpcode::GETUNMAPPEDARGS; + *pc = static_cast(newOpcode); + break; + } + case OldBytecodeInst::Opcode::ECMA_ISFALSE_PREF_NONE: { + newOpcode = EcmaOpcode::ISFALSE; + *pc = static_cast(newOpcode); + break; + } + case OldBytecodeInst::Opcode::ECMA_ISTRUE_PREF_NONE: { + newOpcode = EcmaOpcode::ISTRUE; + *pc = static_cast(newOpcode); + break; + } + case OldBytecodeInst::Opcode::ECMA_LDFALSE_PREF_NONE: { + newOpcode = EcmaOpcode::LDFALSE; + *pc = static_cast(newOpcode); + break; + } + case OldBytecodeInst::Opcode::ECMA_LDTRUE_PREF_NONE: { + newOpcode = EcmaOpcode::LDTRUE; + *pc = static_cast(newOpcode); + break; + } + case OldBytecodeInst::Opcode::ECMA_LDFUNCTION_PREF_NONE: { + newOpcode = EcmaOpcode::LDFUNCTION; + *pc = static_cast(newOpcode); + break; + } + case OldBytecodeInst::Opcode::ECMA_LDGLOBALTHIS_PREF_NONE: { + newOpcode = EcmaOpcode::LDGLOBALTHIS; + *pc = static_cast(newOpcode); + break; + } + case OldBytecodeInst::Opcode::ECMA_LDGLOBAL_PREF_NONE: { + newOpcode = EcmaOpcode::LDGLOBAL; + *pc = static_cast(newOpcode); + break; + } + case OldBytecodeInst::Opcode::ECMA_LDHOLE_PREF_NONE: { + newOpcode = EcmaOpcode::LDHOLE; + *pc = static_cast(newOpcode); + break; + } + case OldBytecodeInst::Opcode::ECMA_LDNULL_PREF_NONE: { + newOpcode = EcmaOpcode::LDNULL; + *pc = static_cast(newOpcode); + break; + } + case OldBytecodeInst::Opcode::ECMA_LDSYMBOL_PREF_NONE: { + newOpcode = EcmaOpcode::LDSYMBOL; + *pc = static_cast(newOpcode); + break; + } + case OldBytecodeInst::Opcode::ECMA_LDUNDEFINED_PREF_NONE: { + newOpcode = EcmaOpcode::LDUNDEFINED; + *pc = static_cast(newOpcode); + break; + } + case OldBytecodeInst::Opcode::ECMA_LDNAN_PREF_NONE: { + newOpcode = EcmaOpcode::LDNAN; + *pc = static_cast(newOpcode); + break; + } + case OldBytecodeInst::Opcode::ECMA_LDINFINITY_PREF_NONE: { + newOpcode = EcmaOpcode::LDINFINITY; + *pc = static_cast(newOpcode); + break; + } + case OldBytecodeInst::Opcode::ECMA_RETURNUNDEFINED_PREF_NONE: { + newOpcode = EcmaOpcode::RETURNUNDEFINED; + *pc = static_cast(newOpcode); + break; + } + case OldBytecodeInst::Opcode::ECMA_LDLEXVARDYN_PREF_IMM4_IMM4: { + newOpcode = EcmaOpcode::LDLEXVAR_IMM4_IMM4; + *pc = static_cast(newOpcode); + auto newLen = BytecodeInstruction::Size(newOpcode); + if (memmove_s(pc + 1, newLen - 1, pc + 2, oldLen - 2) != EOK) { // 2: skip second level inst and pref + LOG_FULL(FATAL) << "FixOpcode memmove_s fail"; + UNREACHABLE(); + } + break; + } + case OldBytecodeInst::Opcode::ECMA_LDLEXVARDYN_PREF_IMM8_IMM8: { + newOpcode = EcmaOpcode::LDLEXVAR_IMM8_IMM8; + *pc = static_cast(newOpcode); + auto newLen = BytecodeInstruction::Size(newOpcode); + if (memmove_s(pc + 1, newLen - 1, pc + 2, oldLen - 2) != EOK) { // 2: skip second level inst and pref + LOG_FULL(FATAL) << "FixOpcode memmove_s fail"; + UNREACHABLE(); + } + break; + } + case OldBytecodeInst::Opcode::ECMA_STARRAYSPREAD_PREF_V8_V8: { + newOpcode = EcmaOpcode::STARRAYSPREAD_V8_V8; + *pc = static_cast(newOpcode); + auto newLen = BytecodeInstruction::Size(newOpcode); + // 2: skip opcode and second level pref + if (memmove_s(pc + 1, newLen - 1, pc + 2, oldLen - 2) != EOK) { + LOG_FULL(FATAL) << "FixOpcode memmove_s fail"; + UNREACHABLE(); + } + break; + } + // ID32 to ID16 has IC (PREF_ID32) + case OldBytecodeInst::Opcode::ECMA_TRYLDGLOBALBYNAME_PREF_ID32: { + newOpcode = EcmaOpcode::TRYLDGLOBALBYNAME_IMM8_ID16; + uint32_t id = inst.GetId(); + LOG_ECMA_IF(id > std::numeric_limits::max(), FATAL) << "Cannot translate to 16 bits: " << id; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + uint16_t newId = static_cast(id); + if (memcpy_s(pc + 2, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { // 2: skip opcode and ic slot + LOG_FULL(FATAL) << "FixOpcode memcpy_s fail"; UNREACHABLE(); } - *pc = *(pc + 1); - *(pc + 1) = 0xFF; + break; + } + case OldBytecodeInst::Opcode::ECMA_TRYSTGLOBALBYNAME_PREF_ID32: { + newOpcode = EcmaOpcode::TRYSTGLOBALBYNAME_IMM8_ID16; + uint32_t id = inst.GetId(); + LOG_ECMA_IF(id > std::numeric_limits::max(), FATAL) << "Cannot translate to 16 bits: " << id; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + uint16_t newId = static_cast(id); + if (memcpy_s(pc + 2, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { // 2: skip opcode and ic slot + LOG_FULL(FATAL) << "FixOpcode memcpy_s fail"; + UNREACHABLE(); + } + break; + } + // ID32 to ID16 has IC (ID32_V8 & ID32_IMM8) + case OldBytecodeInst::Opcode::ECMA_STOBJBYNAME_PREF_ID32_V8: { + newOpcode = EcmaOpcode::STOBJBYNAME_IMM8_ID16_V8; + uint32_t id = inst.GetId(); + LOG_ECMA_IF(id > std::numeric_limits::max(), FATAL) << "Cannot translate to 16 bits: " << id; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + uint16_t newId = static_cast(id); + if (memcpy_s(pc + 2, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { // 2: skip opcode and ic slot + LOG_FULL(FATAL) << "FixOpcode memcpy_s fail"; + UNREACHABLE(); + } + *(pc + 4) = *(pc + 6); // 4: index of new opcode; 6: index of old opcode + break; + } + case OldBytecodeInst::Opcode::ECMA_STOWNBYNAME_PREF_ID32_V8: { + newOpcode = EcmaOpcode::STOWNBYNAME_IMM8_ID16_V8; + uint32_t id = inst.GetId(); + LOG_ECMA_IF(id > std::numeric_limits::max(), FATAL) << "Cannot translate to 16 bits: " << id; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + uint16_t newId = static_cast(id); + if (memcpy_s(pc + 2, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { // 2: skip opcode and ic slot + LOG_FULL(FATAL) << "FixOpcode memcpy_s fail"; + UNREACHABLE(); + } + *(pc + 4) = *(pc + 6); // 4: index of new opcode; 6: index of old opcode + break; + } + case OldBytecodeInst::Opcode::ECMA_STSUPERBYNAME_PREF_ID32_V8: { + newOpcode = EcmaOpcode::STSUPERBYNAME_IMM8_ID16_V8; + uint32_t id = inst.GetId(); + LOG_ECMA_IF(id > std::numeric_limits::max(), FATAL) << "Cannot translate to 16 bits: " << id; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + uint16_t newId = static_cast(id); + if (memcpy_s(pc + 2, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { // 2: skip opcode and ic slot + LOG_FULL(FATAL) << "FixOpcode memcpy_s fail"; + UNREACHABLE(); + } + *(pc + 4) = *(pc + 6); // 4: index of new opcode; 6: index of old opcode + break; + } + case OldBytecodeInst::Opcode::ECMA_STOWNBYNAMEWITHNAMESET_PREF_ID32_V8: { + newOpcode = EcmaOpcode::STOWNBYNAMEWITHNAMESET_IMM8_ID16_V8; + uint32_t id = inst.GetId(); + LOG_ECMA_IF(id > std::numeric_limits::max(), FATAL) << "Cannot translate to 16 bits: " << id; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + uint16_t newId = static_cast(id); + if (memcpy_s(pc + 2, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { // 2: skip opcode and ic slot + LOG_FULL(FATAL) << "FixOpcode memcpy_s fail"; + UNREACHABLE(); + } + *(pc + 4) = *(pc + 6); // 4: index of new opcode; 6: index of old opcode + break; + } + case OldBytecodeInst::Opcode::ECMA_CREATEREGEXPWITHLITERAL_PREF_ID32_IMM8: { + newOpcode = EcmaOpcode::CREATEREGEXPWITHLITERAL_IMM8_ID16_IMM8; + uint32_t id = inst.GetId(); + LOG_ECMA_IF(id > std::numeric_limits::max(), FATAL) << "Cannot translate to 16 bits: " << id; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + uint16_t newId = static_cast(id); + if (memcpy_s(pc + 2, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { // 2: skip opcode and ic slot + LOG_FULL(FATAL) << "FixOpcode memcpy_s fail"; + UNREACHABLE(); + } + *(pc + 4) = *(pc + 6); // 4: index of new opcode; 6: index of old opcode + break; + } + // ID32 to ID16 no IC (PREF_ID32) + case OldBytecodeInst::Opcode::ECMA_LDBIGINT_PREF_ID32: { + newOpcode = EcmaOpcode::LDBIGINT_ID16; + uint32_t id = inst.GetId(); + LOG_ECMA_IF(id > std::numeric_limits::max(), FATAL) << "Cannot translate to 16 bits: " << id; + *pc = static_cast(newOpcode); + uint16_t newId = static_cast(id); + if (memcpy_s(pc + 1, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { + LOG_FULL(FATAL) << "FixOpcode memcpy_s fail"; + UNREACHABLE(); + } + break; + } + // Translate to other first level opcode + case OldBytecodeInst::Opcode::ECMA_NEWOBJSPREADDYN_PREF_V8_V8: { + newOpcode = EcmaOpcode::NEWOBJAPPLY_IMM8_V8; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + *(pc + 2) = *(pc + 3); // 2 & 3: skip newtarget, so move vreg1 to vreg0 + break; + } + case OldBytecodeInst::Opcode::ECMA_LDGLOBALVAR_PREF_ID32: { + newOpcode = EcmaOpcode::LDGLOBALVAR_IMM16_ID16; + uint32_t id = inst.GetId(); + LOG_ECMA_IF(id > std::numeric_limits::max(), FATAL) << "Cannot translate to 16 bits: " << id; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + *(pc + 2) = 0x00; + uint16_t newId = static_cast(id); + if (memcpy_s(pc + 3, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { // 3: offset of id + LOG_FULL(FATAL) << "FixOpcode memcpy_s fail"; + UNREACHABLE(); + } + break; + } + case OldBytecodeInst::Opcode::ECMA_STGLOBALVAR_PREF_ID32: { + newOpcode = EcmaOpcode::STGLOBALVAR_IMM16_ID16; + uint32_t id = inst.GetId(); + LOG_ECMA_IF(id > std::numeric_limits::max(), FATAL) << "Cannot translate to 16 bits: " << id; + *pc = static_cast(newOpcode); + *(pc + 1) = 0x00; + *(pc + 2) = 0x00; + uint16_t newId = static_cast(id); + if (memcpy_s(pc + 3, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { // 3: offset of id + LOG_FULL(FATAL) << "FixOpcode memcpy_s fail"; + UNREACHABLE(); + } + break; + } + default: + LOG_FULL(FATAL) << "Is not an Ecma Opcode opcode: " << static_cast(opcode); + UNREACHABLE(); break; } + ADD_NOP_INST(pc, oldLen, newOpcode); + UpdateICOffset(method, pc); } // reuse prefix 8bits to store slotid @@ -361,44 +1351,74 @@ void PandaFileTranslator::UpdateICOffset(MethodLiteral *method, uint8_t *pc) uint8_t offset = MethodLiteral::MAX_SLOT_SIZE; auto opcode = static_cast(*pc); switch (opcode) { - case EcmaOpcode::TRYLDGLOBALBYNAME_PREF_ID32: - case EcmaOpcode::TRYSTGLOBALBYNAME_PREF_ID32: - case EcmaOpcode::LDGLOBALVAR_PREF_ID32: - case EcmaOpcode::STGLOBALVAR_PREF_ID32: - case EcmaOpcode::ADD2DYN_PREF_V8: - case EcmaOpcode::SUB2DYN_PREF_V8: - case EcmaOpcode::MUL2DYN_PREF_V8: - case EcmaOpcode::DIV2DYN_PREF_V8: - case EcmaOpcode::MOD2DYN_PREF_V8: - case EcmaOpcode::SHL2DYN_PREF_V8: - case EcmaOpcode::SHR2DYN_PREF_V8: - case EcmaOpcode::ASHR2DYN_PREF_V8: - case EcmaOpcode::AND2DYN_PREF_V8: - case EcmaOpcode::OR2DYN_PREF_V8: - case EcmaOpcode::XOR2DYN_PREF_V8: - case EcmaOpcode::EQDYN_PREF_V8: - case EcmaOpcode::NOTEQDYN_PREF_V8: - case EcmaOpcode::LESSDYN_PREF_V8: - case EcmaOpcode::LESSEQDYN_PREF_V8: - case EcmaOpcode::GREATERDYN_PREF_V8: - case EcmaOpcode::GREATEREQDYN_PREF_V8: + case EcmaOpcode::TRYLDGLOBALBYNAME_IMM8_ID16: + U_FALLTHROUGH; + case EcmaOpcode::TRYSTGLOBALBYNAME_IMM8_ID16: + U_FALLTHROUGH; + case EcmaOpcode::LDGLOBALVAR_IMM16_ID16: + U_FALLTHROUGH; + case EcmaOpcode::STGLOBALVAR_IMM16_ID16: + U_FALLTHROUGH; + case EcmaOpcode::ADD2_IMM8_V8: + U_FALLTHROUGH; + case EcmaOpcode::SUB2_IMM8_V8: + U_FALLTHROUGH; + case EcmaOpcode::MUL2_IMM8_V8: + U_FALLTHROUGH; + case EcmaOpcode::DIV2_IMM8_V8: + U_FALLTHROUGH; + case EcmaOpcode::MOD2_IMM8_V8: + U_FALLTHROUGH; + case EcmaOpcode::SHL2_IMM8_V8: + U_FALLTHROUGH; + case EcmaOpcode::SHR2_IMM8_V8: + U_FALLTHROUGH; + case EcmaOpcode::ASHR2_IMM8_V8: + U_FALLTHROUGH; + case EcmaOpcode::AND2_IMM8_V8: + U_FALLTHROUGH; + case EcmaOpcode::OR2_IMM8_V8: + U_FALLTHROUGH; + case EcmaOpcode::XOR2_IMM8_V8: + U_FALLTHROUGH; + case EcmaOpcode::EQ_IMM8_V8: + U_FALLTHROUGH; + case EcmaOpcode::NOTEQ_IMM8_V8: + U_FALLTHROUGH; + case EcmaOpcode::LESS_IMM8_V8: + U_FALLTHROUGH; + case EcmaOpcode::LESSEQ_IMM8_V8: + U_FALLTHROUGH; + case EcmaOpcode::GREATER_IMM8_V8: + U_FALLTHROUGH; + case EcmaOpcode::GREATEREQ_IMM8_V8: offset = method->UpdateSlotSize(1); break; - case EcmaOpcode::LDOBJBYVALUE_PREF_V8_V8: - case EcmaOpcode::STOBJBYVALUE_PREF_V8_V8: - case EcmaOpcode::STOWNBYVALUE_PREF_V8_V8: - case EcmaOpcode::LDOBJBYNAME_PREF_ID32_V8: - case EcmaOpcode::STOBJBYNAME_PREF_ID32_V8: - case EcmaOpcode::STOWNBYNAME_PREF_ID32_V8: - case EcmaOpcode::LDOBJBYINDEX_PREF_V8_IMM32: - case EcmaOpcode::STOBJBYINDEX_PREF_V8_IMM32: - case EcmaOpcode::STOWNBYINDEX_PREF_V8_IMM32: - case EcmaOpcode::LDSUPERBYVALUE_PREF_V8_V8: - case EcmaOpcode::STSUPERBYVALUE_PREF_V8_V8: - case EcmaOpcode::LDSUPERBYNAME_PREF_ID32_V8: - case EcmaOpcode::STSUPERBYNAME_PREF_ID32_V8: - case EcmaOpcode::LDMODULEVAR_PREF_ID32_IMM8: - case EcmaOpcode::STMODULEVAR_PREF_ID32: + // case EcmaOpcode::LDOBJBYVALUE_IMM8_V8_V8: + // U_FALLTHROUGH; + case EcmaOpcode::STOBJBYVALUE_IMM8_V8_V8: + U_FALLTHROUGH; + case EcmaOpcode::STOWNBYVALUE_IMM8_V8_V8: + U_FALLTHROUGH; + // case EcmaOpcode::LDOBJBYNAME_IMM8_ID16_V8: + // U_FALLTHROUGH; + case EcmaOpcode::STOBJBYNAME_IMM8_ID16_V8: + U_FALLTHROUGH; + case EcmaOpcode::STOWNBYNAME_IMM8_ID16_V8: + U_FALLTHROUGH; + // case EcmaOpcode::LDOBJBYINDEX_IMM8_V8_IMM32: + // U_FALLTHROUGH; + // case EcmaOpcode::STOBJBYINDEX_IMM8_V8_IMM32: + // U_FALLTHROUGH; + // case EcmaOpcode::STOWNBYINDEX_IMM8_V8_IMM32: + // U_FALLTHROUGH; + // case EcmaOpcode::LDSUPERBYVALUE_IMM8_V8_V8: + // U_FALLTHROUGH; + case EcmaOpcode::STSUPERBYVALUE_IMM8_V8_V8: + U_FALLTHROUGH; + // case EcmaOpcode::LDSUPERBYNAME_IMM8_ID16_V8: + // U_FALLTHROUGH; + case EcmaOpcode::STSUPERBYNAME_IMM8_ID16_V8: offset = method->UpdateSlotSize(2); // 2: occupy two ic slot break; default: @@ -408,13 +1428,13 @@ void PandaFileTranslator::UpdateICOffset(MethodLiteral *method, uint8_t *pc) *(pc + 1) = offset; } -void PandaFileTranslator::FixInstructionId32(const BytecodeInstruction &inst, uint32_t index, +void PandaFileTranslator::FixInstructionId32(const OldBytecodeInst &inst, uint32_t index, uint32_t fixOrder) { // NOLINTNEXTLINE(hicpp-use-auto) auto pc = const_cast(inst.GetAddress()); - switch (inst.GetFormat()) { - case BytecodeInstruction::Format::ID32: { + switch (OldBytecodeInst::GetFormat(inst.GetOpcode())) { + case OldBytecodeInst::Format::ID32: { uint8_t size = sizeof(uint32_t); // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) if (memcpy_s(pc + FixInstructionIndex::FIX_ONE, size, &index, size) != EOK) { @@ -423,7 +1443,7 @@ void PandaFileTranslator::FixInstructionId32(const BytecodeInstruction &inst, ui } break; } - case BytecodeInstruction::Format::PREF_ID16_IMM16_V8: { + case OldBytecodeInst::Format::PREF_ID16_IMM16_V8: { uint16_t u16Index = index; uint8_t size = sizeof(uint16_t); // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) @@ -433,9 +1453,11 @@ void PandaFileTranslator::FixInstructionId32(const BytecodeInstruction &inst, ui } break; } - case BytecodeInstruction::Format::PREF_ID32: - case BytecodeInstruction::Format::PREF_ID32_V8: - case BytecodeInstruction::Format::PREF_ID32_IMM8: { + case OldBytecodeInst::Format::PREF_ID32: + U_FALLTHROUGH; + case OldBytecodeInst::Format::PREF_ID32_V8: + U_FALLTHROUGH; + case OldBytecodeInst::Format::PREF_ID32_IMM8: { uint8_t size = sizeof(uint32_t); // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) if (memcpy_s(pc + FixInstructionIndex::FIX_TWO, size, &index, size) != EOK) { @@ -444,7 +1466,7 @@ void PandaFileTranslator::FixInstructionId32(const BytecodeInstruction &inst, ui } break; } - case BytecodeInstruction::Format::PREF_IMM16: { + case OldBytecodeInst::Format::PREF_IMM16: { ASSERT(static_cast(index) == index); uint16_t u16Index = index; uint8_t size = sizeof(uint16_t); @@ -455,7 +1477,7 @@ void PandaFileTranslator::FixInstructionId32(const BytecodeInstruction &inst, ui } break; } - case BytecodeInstruction::Format::PREF_ID16_IMM16_IMM16_V8_V8: { + case OldBytecodeInst::Format::PREF_ID16_IMM16_IMM16_V8_V8: { // Usually, we fix one part of instruction one time. But as for instruction DefineClassWithBuffer, // which use both method id and literal buffer id.Using fixOrder indicates fix Location. if (fixOrder == 0) { @@ -490,69 +1512,70 @@ void PandaFileTranslator::TranslateBytecode(JSPandaFile *jsPandaFile, uint32_t i const MethodLiteral *method) { const panda_file::File *pf = jsPandaFile->GetPandaFile(); - auto bcIns = BytecodeInstruction(insArr); + auto bcIns = OldBytecodeInst(insArr); auto bcInsLast = bcIns.JumpTo(insSz); while (bcIns.GetAddress() != bcInsLast.GetAddress()) { - if (bcIns.HasFlag(BytecodeInstruction::Flags::STRING_ID) && - BytecodeInstruction::HasId(bcIns.GetFormat(), 0)) { + if (bcIns.HasFlag(OldBytecodeInst::Flags::STRING_ID) && + OldBytecodeInst::HasId(OldBytecodeInst::GetFormat(bcIns.GetOpcode()), 0)) { auto index = jsPandaFile->GetOrInsertConstantPool( - ConstPoolType::STRING, bcIns.GetId().AsFileId().GetOffset()); + ConstPoolType::STRING, bcIns.GetId()); FixInstructionId32(bcIns, index); } else { - BytecodeInstruction::Opcode opcode = static_cast(bcIns.GetOpcode()); + OldBytecodeInst::Opcode opcode = static_cast(bcIns.GetOpcode()); switch (opcode) { uint32_t index; uint32_t methodId; - case BytecodeInstruction::Opcode::ECMA_DEFINEFUNCDYN_PREF_ID16_IMM16_V8: - methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId().AsIndex()).GetOffset(); + case OldBytecodeInst::Opcode::ECMA_DEFINEFUNCDYN_PREF_ID16_IMM16_V8: + methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId()).GetOffset(); index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::BASE_FUNCTION, methodId); FixInstructionId32(bcIns, index); break; - case BytecodeInstruction::Opcode::ECMA_DEFINENCFUNCDYN_PREF_ID16_IMM16_V8: - methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId().AsIndex()).GetOffset(); + case OldBytecodeInst::Opcode::ECMA_DEFINENCFUNCDYN_PREF_ID16_IMM16_V8: + methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId()).GetOffset(); index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::NC_FUNCTION, methodId); FixInstructionId32(bcIns, index); break; - case BytecodeInstruction::Opcode::ECMA_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8: - methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId().AsIndex()).GetOffset(); + case OldBytecodeInst::Opcode::ECMA_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8: + methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId()).GetOffset(); index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::GENERATOR_FUNCTION, methodId); FixInstructionId32(bcIns, index); break; - case BytecodeInstruction::Opcode::ECMA_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8: - methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId().AsIndex()).GetOffset(); + case OldBytecodeInst::Opcode::ECMA_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8: + methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId()).GetOffset(); index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::ASYNC_GENERATOR_FUNCTION, methodId); FixInstructionId32(bcIns, index); break; - case BytecodeInstruction::Opcode::ECMA_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8: - methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId().AsIndex()).GetOffset(); + case OldBytecodeInst::Opcode::ECMA_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8: + methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId()).GetOffset(); index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::ASYNC_FUNCTION, methodId); FixInstructionId32(bcIns, index); break; - case BytecodeInstruction::Opcode::ECMA_DEFINEMETHOD_PREF_ID16_IMM16_V8: - methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId().AsIndex()).GetOffset(); + case OldBytecodeInst::Opcode::ECMA_DEFINEMETHOD_PREF_ID16_IMM16_V8: + methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId()).GetOffset(); index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::METHOD, methodId); FixInstructionId32(bcIns, index); break; - case BytecodeInstruction::Opcode::ECMA_CREATEOBJECTWITHBUFFER_PREF_IMM16: - case BytecodeInstruction::Opcode::ECMA_CREATEOBJECTHAVINGMETHOD_PREF_IMM16: { - auto imm = bcIns.GetImm(); + case OldBytecodeInst::Opcode::ECMA_CREATEOBJECTWITHBUFFER_PREF_IMM16: + U_FALLTHROUGH; + case OldBytecodeInst::Opcode::ECMA_CREATEOBJECTHAVINGMETHOD_PREF_IMM16: { + auto imm = bcIns.GetImm(); index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::OBJECT_LITERAL, static_cast(imm)); FixInstructionId32(bcIns, index); break; } - case BytecodeInstruction::Opcode::ECMA_CREATEARRAYWITHBUFFER_PREF_IMM16: { - auto imm = bcIns.GetImm(); + case OldBytecodeInst::Opcode::ECMA_CREATEARRAYWITHBUFFER_PREF_IMM16: { + auto imm = bcIns.GetImm(); index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::ARRAY_LITERAL, static_cast(imm)); FixInstructionId32(bcIns, index); break; } - case BytecodeInstruction::Opcode::ECMA_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8: { - methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId().AsIndex()).GetOffset(); + case OldBytecodeInst::Opcode::ECMA_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8: { + methodId = pf->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId()).GetOffset(); index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::CLASS_FUNCTION, methodId); FixInstructionId32(bcIns, index); - auto imm = bcIns.GetImm(); + auto imm = bcIns.GetImm(); index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::CLASS_LITERAL, static_cast(imm)); FixInstructionId32(bcIns, index, 1); @@ -563,12 +1586,12 @@ void PandaFileTranslator::TranslateBytecode(JSPandaFile *jsPandaFile, uint32_t i } } // NOLINTNEXTLINE(hicpp-use-auto) - auto pc = const_cast(bcIns.GetAddress()); - bcIns = bcIns.GetNext(); - FixOpcode(pc); - UpdateICOffset(const_cast(method), pc); + auto nextInst = bcIns.GetNext(); + FixOpcode(const_cast(method), bcIns); + bcIns = nextInst; } } +#endif void PandaFileTranslator::DefineClassesInConstPool(JSThread *thread, JSHandle constpool, const JSPandaFile *jsPandaFile) diff --git a/ecmascript/jspandafile/panda_file_translator.h b/ecmascript/jspandafile/panda_file_translator.h index b4de70e450..1691866607 100644 --- a/ecmascript/jspandafile/panda_file_translator.h +++ b/ecmascript/jspandafile/panda_file_translator.h @@ -21,10 +21,13 @@ #include "ecmascript/jspandafile/constpool_value.h" #include "libpandabase/utils/bit_field.h" -#include "libpandafile/bytecode_instruction-inl.h" #include "libpandafile/code_data_accessor-inl.h" #include "libpandafile/file-inl.h" +#ifndef DISABLE_OLD_BYTECODE +#include "ecmascript/jspandafile/bytecode_inst/old_instruction.h" +#endif + namespace panda::ecmascript { class JSThread; class Program; @@ -43,11 +46,13 @@ public: static void TranslateClasses(JSPandaFile *jsPandaFile, const CString &methodName); private: +#ifndef DISABLE_OLD_BYTECODE static void TranslateBytecode(JSPandaFile *jsPandaFile, uint32_t insSz, const uint8_t *insArr, const MethodLiteral *method); - static void FixInstructionId32(const BytecodeInstruction &inst, uint32_t index, uint32_t fixOrder = 0); - static void FixOpcode(uint8_t *pc); + static void FixInstructionId32(const OldBytecodeInst &inst, uint32_t index, uint32_t fixOrder = 0); + static void FixOpcode(MethodLiteral *method, const OldBytecodeInst &inst); static void UpdateICOffset(MethodLiteral *method, uint8_t *pc); +#endif static JSTaggedValue ParseConstPool(EcmaVM *vm, const JSPandaFile *jsPandaFile); static void DefineClassesInConstPool(JSThread *thread, JSHandle constpool, const JSPandaFile *jsPandaFile); diff --git a/ecmascript/log.h b/ecmascript/log.h index 689df96b97..8ebeddec22 100644 --- a/ecmascript/log.h +++ b/ecmascript/log.h @@ -98,7 +98,8 @@ public: private: std::ostringstream stream_; }; -#endif // ENABLE_HILOG +#define LOG_ECMA(level) HiLogIsLoggable(ARK_DOMAIN, TAG, LOG_##level) && panda::ecmascript::HiLog() +#else // ENABLE_HILOG template class StdLog { public: @@ -121,10 +122,6 @@ public: private: std::ostringstream stream_; }; - -#ifdef ENABLE_HILOG -#define LOG_ECMA(level) HiLogIsLoggable(ARK_DOMAIN, TAG, LOG_##level) && panda::ecmascript::HiLog() -#else // ENABLE_HILOG #define LOG_ECMA(level) ((level) >= panda::ecmascript::Log::GetLevel()) && panda::ecmascript::StdLog<(level)>() #endif // ENABLE_HILOG } // namespace panda::ecmascript diff --git a/ecmascript/mem/barriers-inl.h b/ecmascript/mem/barriers-inl.h index fdd559f69c..c63a2c7c8a 100644 --- a/ecmascript/mem/barriers-inl.h +++ b/ecmascript/mem/barriers-inl.h @@ -43,7 +43,7 @@ static ARK_INLINE void WriteBarrier(void *obj, size_t offset, JSTaggedType value // CODECHECK-NOLINTNEXTLINE(C_RULE_ID_COMMENT_LOCATION) // default value for need_write_barrier is true template -inline void Barriers::SetDynObject([[maybe_unused]] const JSThread *thread, void *obj, size_t offset, +inline void Barriers::SetObject([[maybe_unused]] const JSThread *thread, void *obj, size_t offset, JSTaggedType value) { // NOLINTNEXTLINE(clang-analyzer-core.NullDereference) diff --git a/ecmascript/mem/barriers.h b/ecmascript/mem/barriers.h index bbe629eabf..4af046d058 100644 --- a/ecmascript/mem/barriers.h +++ b/ecmascript/mem/barriers.h @@ -26,7 +26,7 @@ class Region; class Barriers { public: template - static inline void SetDynPrimitive(void *obj, size_t offset, T value) + static inline void SetPrimitive(void *obj, size_t offset, T value) { auto *addr = reinterpret_cast(ToUintPtr(obj) + offset); // NOLINTNEXTLINE(clang-analyzer-core.NullDereference) @@ -34,7 +34,7 @@ public: } template - static inline bool AtomicSetDynPrimitive(volatile void *obj, size_t offset, T oldValue, T value) + static inline bool AtomicSetPrimitive(volatile void *obj, size_t offset, T oldValue, T value) { volatile auto atomicField = reinterpret_cast *>(ToUintPtr(obj) + offset); return std::atomic_compare_exchange_strong_explicit(atomicField, &oldValue, value, std::memory_order_release, @@ -42,10 +42,10 @@ public: } template - static void SetDynObject(const JSThread *thread, void *obj, size_t offset, JSTaggedType value); + static void SetObject(const JSThread *thread, void *obj, size_t offset, JSTaggedType value); template - static inline T GetDynValue(const void *obj, size_t offset) + static inline T GetValue(const void *obj, size_t offset) { auto *addr = reinterpret_cast(ToUintPtr(obj) + offset); return *addr; diff --git a/ecmascript/mem/heap-inl.h b/ecmascript/mem/heap-inl.h index ffa37fc09d..6fcfd0e0b1 100644 --- a/ecmascript/mem/heap-inl.h +++ b/ecmascript/mem/heap-inl.h @@ -238,12 +238,12 @@ TaggedObject *Heap::AllocateNonMovableOrHugeObject(JSHClass *hclass, size_t size return object; } -TaggedObject *Heap::AllocateDynClassClass(JSHClass *hclass, size_t size) +TaggedObject *Heap::AllocateClassClass(JSHClass *hclass, size_t size) { size = AlignUp(size, static_cast(MemAlignment::MEM_ALIGN_OBJECT)); auto object = reinterpret_cast(nonMovableSpace_->Allocate(size)); if (UNLIKELY(object == nullptr)) { - LOG_ECMA_MEM(FATAL) << "Heap::AllocateDynClassClass can not allocate any space"; + LOG_ECMA_MEM(FATAL) << "Heap::AllocateClassClass can not allocate any space"; } *reinterpret_cast(ToUintPtr(object)) = reinterpret_cast(hclass); OnAllocateEvent(reinterpret_cast(object)); diff --git a/ecmascript/mem/heap.h b/ecmascript/mem/heap.h index 97ad832b37..eae252ee3f 100644 --- a/ecmascript/mem/heap.h +++ b/ecmascript/mem/heap.h @@ -216,7 +216,7 @@ public: // Non-movable inline TaggedObject *AllocateNonMovableOrHugeObject(JSHClass *hclass); inline TaggedObject *AllocateNonMovableOrHugeObject(JSHClass *hclass, size_t size); - inline TaggedObject *AllocateDynClassClass(JSHClass *hclass, size_t size); + inline TaggedObject *AllocateClassClass(JSHClass *hclass, size_t size); // Huge inline TaggedObject *AllocateHugeObject(JSHClass *hclass, size_t size); inline TaggedObject *AllocateHugeObject(size_t size); diff --git a/ecmascript/mem/object_xray.h b/ecmascript/mem/object_xray.h index 5f63ec39fd..25f820b202 100644 --- a/ecmascript/mem/object_xray.h +++ b/ecmascript/mem/object_xray.h @@ -312,7 +312,7 @@ public: break; } case JSType::HCLASS: - // semi gc is not needed to visit dyn class + // semi gc is not needed to visit hclass if (visitType != VisitType::SEMI_GC_VISIT) { JSHClass::Cast(object)->VisitRangeSlot(visitor); } diff --git a/ecmascript/mem/parallel_evacuator.cpp b/ecmascript/mem/parallel_evacuator.cpp index 9a82d43302..4c13974c1b 100644 --- a/ecmascript/mem/parallel_evacuator.cpp +++ b/ecmascript/mem/parallel_evacuator.cpp @@ -134,7 +134,7 @@ void ParallelEvacuator::EvacuateRegion(TlabAllocator *allocator, Region *region) LOG_FULL(FATAL) << "memcpy_s failed"; } - Barriers::SetDynPrimitive(header, 0, MarkWord::FromForwardingAddress(address)); + Barriers::SetPrimitive(header, 0, MarkWord::FromForwardingAddress(address)); #if ECMASCRIPT_ENABLE_HEAP_VERIFY VerifyHeapObject(reinterpret_cast(address)); #endif diff --git a/ecmascript/mem/parallel_marker-inl.h b/ecmascript/mem/parallel_marker-inl.h index 0991e9f095..450e3c562d 100644 --- a/ecmascript/mem/parallel_marker-inl.h +++ b/ecmascript/mem/parallel_marker-inl.h @@ -224,7 +224,7 @@ inline SlotStatus SemiGCMarker::EvacuateObject(uint32_t threadId, TaggedObject * bool isPromoted = ShouldBePromoted(object); uintptr_t forwardAddress = AllocateDstSpace(threadId, size, isPromoted); - bool result = Barriers::AtomicSetDynPrimitive(object, 0, markWord.GetValue(), + bool result = Barriers::AtomicSetPrimitive(object, 0, markWord.GetValue(), MarkWord::FromForwardingAddress(forwardAddress)); if (result) { UpdateForwardAddressIfSuccess(threadId, object, klass, forwardAddress, size, markWord, slot, isPromoted); @@ -299,8 +299,8 @@ inline SlotStatus CompressGCMarker::EvacuateObject(uint32_t threadId, TaggedObje JSHClass *klass = markWord.GetJSHClass(); size_t size = klass->SizeFromJSHClass(object); uintptr_t forwardAddress = AllocateForwardAddress(threadId, size, object); - bool result = Barriers::AtomicSetDynPrimitive(object, 0, markWord.GetValue(), - MarkWord::FromForwardingAddress(forwardAddress)); + bool result = Barriers::AtomicSetPrimitive(object, 0, markWord.GetValue(), + MarkWord::FromForwardingAddress(forwardAddress)); if (result) { UpdateForwardAddressIfSuccess(threadId, object, klass, forwardAddress, size, markWord, slot); return SlotStatus::CLEAR_SLOT; diff --git a/ecmascript/mem/tagged_object-inl.h b/ecmascript/mem/tagged_object-inl.h index 1e6aa9d2be..bd86e2a6c8 100644 --- a/ecmascript/mem/tagged_object-inl.h +++ b/ecmascript/mem/tagged_object-inl.h @@ -33,7 +33,7 @@ inline void TaggedObject::SetClassWithoutBarrier(JSHClass *hclass) inline void TaggedObject::SetClass(JSHClass *hclass) { - Barriers::SetDynObject(GetJSThread(), this, 0, JSTaggedValue(hclass).GetRawData()); + Barriers::SetObject(GetJSThread(), this, 0, JSTaggedValue(hclass).GetRawData()); } inline void TaggedObject::SetClass(JSHandle hclass) diff --git a/ecmascript/napi/jsnapi.cpp b/ecmascript/napi/jsnapi.cpp index 85a3ef82ec..f0128e127d 100644 --- a/ecmascript/napi/jsnapi.cpp +++ b/ecmascript/napi/jsnapi.cpp @@ -1070,10 +1070,10 @@ Local FunctionRef::NewClassFunction(EcmaVM *vm, FunctionCallback na JSThread *thread = vm->GetJSThread(); ObjectFactory *factory = vm->GetFactory(); JSHandle env = vm->GetGlobalEnv(); - JSHandle dynclass = JSHandle::Cast(env->GetFunctionClassWithoutName()); + JSHandle hclass = JSHandle::Cast(env->GetFunctionClassWithoutName()); JSHandle current = - factory->NewJSFunctionByDynClass(reinterpret_cast(Callback::RegisterCallback), - dynclass, ecmascript::FunctionKind::CLASS_CONSTRUCTOR); + factory->NewJSFunctionByHClass(reinterpret_cast(Callback::RegisterCallback), + hclass, ecmascript::FunctionKind::CLASS_CONSTRUCTOR); auto globalConst = thread->GlobalConstants(); JSHandle accessor = globalConst->GetHandledFunctionPrototypeAccessor(); diff --git a/ecmascript/napi/test/jsnapi_tests.cpp b/ecmascript/napi/test/jsnapi_tests.cpp index 49c7b35f7a..a4d3af8a9f 100644 --- a/ecmascript/napi/test/jsnapi_tests.cpp +++ b/ecmascript/napi/test/jsnapi_tests.cpp @@ -799,12 +799,12 @@ HWTEST_F_L0(JSNApiTests, InheritPrototype_003) JSHandle invokeSelf = factory->NewMethodForNativeFunction(reinterpret_cast(BuiltinsFunction::FunctionPrototypeInvokeSelf)); // father type - JSHandle protoDynclass = JSHandle::Cast(env->GetFunctionClassWithProto()); - JSHandle protoFunc = factory->NewJSFunctionByDynClass(invokeSelf, protoDynclass); + JSHandle protoClass = JSHandle::Cast(env->GetFunctionClassWithProto()); + JSHandle protoFunc = factory->NewJSFunctionByHClass(invokeSelf, protoClass); Local protoLocal = JSNApiHelper::ToLocal(JSHandle(protoFunc)); // son type - JSHandle noProtoDynclass = JSHandle::Cast(env->GetFunctionClassWithoutProto()); - JSHandle noProtoFunc = factory->NewJSFunctionByDynClass(invokeSelf, noProtoDynclass); + JSHandle noProtoClass = JSHandle::Cast(env->GetFunctionClassWithoutProto()); + JSHandle noProtoFunc = factory->NewJSFunctionByHClass(invokeSelf, noProtoClass); Local noProtoLocal = JSNApiHelper::ToLocal(JSHandle(noProtoFunc)); JSHandle sonHandle = JSHandle::Cast(JSNApiHelper::ToJSHandle(noProtoLocal)); @@ -847,18 +847,18 @@ HWTEST_F_L0(JSNApiTests, InheritPrototype_004) JSHandle ctor = factory->NewMethodForNativeFunction(reinterpret_cast(BuiltinsFunction::FunctionConstructor)); - JSHandle protoDynclass = JSHandle::Cast(env->GetFunctionClassWithProto()); - JSHandle funcFuncPrototype = factory->NewJSFunctionByDynClass(invokeSelf, protoDynclass); + JSHandle protoClass = JSHandle::Cast(env->GetFunctionClassWithProto()); + JSHandle funcFuncPrototype = factory->NewJSFunctionByHClass(invokeSelf, protoClass); // add method in funcPrototype PropertyDescriptor desc = PropertyDescriptor(thread_, deleteMethod); JSObject::DefineOwnProperty(thread_, JSHandle::Cast(funcFuncPrototype), deleteString, desc); JSHandle funcFuncPrototypeValue(funcFuncPrototype); - JSHandle funcFuncProtoIntanceDynclass = - factory->NewEcmaDynClass(JSFunction::SIZE, JSType::JS_FUNCTION, funcFuncPrototypeValue); - // new with NewJSFunctionByDynClass::function DynClass + JSHandle funcFuncProtoIntanceClass = + factory->NewEcmaHClass(JSFunction::SIZE, JSType::JS_FUNCTION, funcFuncPrototypeValue); + // new with NewJSFunctionByHClass::function Class JSHandle protoFunc = - factory->NewJSFunctionByDynClass(ctor, funcFuncProtoIntanceDynclass, FunctionKind::BUILTIN_CONSTRUCTOR); + factory->NewJSFunctionByHClass(ctor, funcFuncProtoIntanceClass, FunctionKind::BUILTIN_CONSTRUCTOR); EXPECT_TRUE(*protoFunc != nullptr); // add method in funcnction PropertyDescriptor desc1 = PropertyDescriptor(thread_, addMethod); @@ -867,15 +867,15 @@ HWTEST_F_L0(JSNApiTests, InheritPrototype_004) // father type Local protoLocal = JSNApiHelper::ToLocal(JSHandle(protoFunc)); - JSHandle noProtoDynclass = JSHandle::Cast(env->GetFunctionClassWithoutProto()); - JSHandle funcFuncNoProtoPrototype = factory->NewJSFunctionByDynClass(invokeSelf, noProtoDynclass); + JSHandle noProtoClass = JSHandle::Cast(env->GetFunctionClassWithoutProto()); + JSHandle funcFuncNoProtoPrototype = factory->NewJSFunctionByHClass(invokeSelf, noProtoClass); JSHandle funcFuncNoProtoPrototypeValue(funcFuncNoProtoPrototype); - JSHandle funcFuncNoProtoProtoIntanceDynclass = - factory->NewEcmaDynClass(JSFunction::SIZE, JSType::JS_FUNCTION, funcFuncNoProtoPrototypeValue); - // new with NewJSFunctionByDynClass::function DynClass - JSHandle noProtoFunc = factory->NewJSFunctionByDynClass(ctor, - funcFuncNoProtoProtoIntanceDynclass, FunctionKind::BUILTIN_CONSTRUCTOR); + JSHandle funcFuncNoProtoProtoIntanceClass = + factory->NewEcmaHClass(JSFunction::SIZE, JSType::JS_FUNCTION, funcFuncNoProtoPrototypeValue); + // new with NewJSFunctionByHClass::function Class + JSHandle noProtoFunc = factory->NewJSFunctionByHClass(ctor, + funcFuncNoProtoProtoIntanceClass, FunctionKind::BUILTIN_CONSTRUCTOR); EXPECT_TRUE(*noProtoFunc != nullptr); // set property that has same key with fater type PropertyDescriptor desc2 = PropertyDescriptor(thread_, defaultString); diff --git a/ecmascript/object_factory.cpp b/ecmascript/object_factory.cpp index 181b8a92a3..03aa3a4c90 100644 --- a/ecmascript/object_factory.cpp +++ b/ecmascript/object_factory.cpp @@ -152,11 +152,11 @@ JSHandle ObjectFactory::NewMethodForNativeFunction(const void *func, u return method; } -JSHandle ObjectFactory::NewEcmaDynClassClass(JSHClass *hclass, uint32_t size, JSType type) +JSHandle ObjectFactory::NewEcmaHClassClass(JSHClass *hclass, uint32_t size, JSType type) { NewObjectHook(); uint32_t classSize = JSHClass::SIZE; - auto *newClass = static_cast(heap_->AllocateDynClassClass(hclass, classSize)); + auto *newClass = static_cast(heap_->AllocateClassClass(hclass, classSize)); newClass->Initialize(thread_, size, type, 0); return JSHandle(thread_, newClass); @@ -164,13 +164,13 @@ JSHandle ObjectFactory::NewEcmaDynClassClass(JSHClass *hclass, uint32_ JSHandle ObjectFactory::InitClassClass() { - JSHandle dynClassClassHandle = NewEcmaDynClassClass(nullptr, JSHClass::SIZE, JSType::HCLASS); - JSHClass *dynclass = reinterpret_cast(dynClassClassHandle.GetTaggedValue().GetTaggedObject()); - dynclass->SetClass(dynclass); - return dynClassClassHandle; + JSHandle hClassHandle = NewEcmaHClassClass(nullptr, JSHClass::SIZE, JSType::HCLASS); + JSHClass *hclass = reinterpret_cast(hClassHandle.GetTaggedValue().GetTaggedObject()); + hclass->SetClass(hclass); + return hClassHandle; } -JSHandle ObjectFactory::NewEcmaDynClass(JSHClass *hclass, uint32_t size, JSType type, uint32_t inlinedProps) +JSHandle ObjectFactory::NewEcmaHClass(JSHClass *hclass, uint32_t size, JSType type, uint32_t inlinedProps) { NewObjectHook(); uint32_t classSize = JSHClass::SIZE; @@ -180,7 +180,7 @@ JSHandle ObjectFactory::NewEcmaDynClass(JSHClass *hclass, uint32_t siz return JSHandle(thread_, newClass); } -JSHandle ObjectFactory::NewEcmaReadOnlyDynClass(JSHClass *hclass, uint32_t size, JSType type, +JSHandle ObjectFactory::NewEcmaReadOnlyHClass(JSHClass *hclass, uint32_t size, JSType type, uint32_t inlinedProps) { NewObjectHook(); @@ -191,9 +191,9 @@ JSHandle ObjectFactory::NewEcmaReadOnlyDynClass(JSHClass *hclass, uint return JSHandle(thread_, newClass); } -JSHandle ObjectFactory::NewEcmaDynClass(uint32_t size, JSType type, uint32_t inlinedProps) +JSHandle ObjectFactory::NewEcmaHClass(uint32_t size, JSType type, uint32_t inlinedProps) { - return NewEcmaDynClass(JSHClass::Cast(thread_->GlobalConstants()->GetHClassClass().GetTaggedObject()), + return NewEcmaHClass(JSHClass::Cast(thread_->GlobalConstants()->GetHClassClass().GetTaggedObject()), size, type, inlinedProps); } @@ -364,16 +364,16 @@ void ObjectFactory::NewJSRegExpByteCodeData(const JSHandle ®exp, vo regexp->SetLength(static_cast(size)); } -JSHandle ObjectFactory::NewEcmaDynClass(uint32_t size, JSType type, const JSHandle &prototype) +JSHandle ObjectFactory::NewEcmaHClass(uint32_t size, JSType type, const JSHandle &prototype) { - JSHandle newClass = NewEcmaDynClass(size, type); + JSHandle newClass = NewEcmaHClass(size, type); newClass->SetPrototype(thread_, prototype.GetTaggedValue()); return newClass; } JSHandle ObjectFactory::NewJSObject(const JSHandle &jshclass) { - JSHandle obj(thread_, JSObject::Cast(NewDynObject(jshclass))); + JSHandle obj(thread_, JSObject::Cast(NewObject(jshclass))); JSHandle emptyArray = EmptyArray(); obj->InitializeHash(); obj->SetElements(thread_, emptyArray, SKIP_BARRIER); @@ -514,12 +514,12 @@ JSHandle ObjectFactory::CloneJSFuction(JSHandle obj, Fun JSHandle env = vm_->GetGlobalEnv(); JSHandle jshclass(thread_, obj->GetJSHClass()); JSHandle method(thread_, obj->GetMethod()); - JSHandle cloneFunc = NewJSFunctionByDynClass(method, jshclass, kind); + JSHandle cloneFunc = NewJSFunctionByHClass(method, jshclass, kind); if (kind == FunctionKind::GENERATOR_FUNCTION) { JSHandle objFun(env->GetObjectFunction()); JSHandle initialGeneratorFuncPrototype = NewJSObjectByConstructor(objFun); JSObject::SetPrototype(thread_, initialGeneratorFuncPrototype, env->GetGeneratorPrototype()); - cloneFunc->SetProtoOrDynClass(thread_, initialGeneratorFuncPrototype); + cloneFunc->SetProtoOrHClass(thread_, initialGeneratorFuncPrototype); } JSTaggedValue length = obj->GetPropertyInlinedProps(JSFunction::LENGTH_INLINE_PROPERTY_INDEX); @@ -544,7 +544,7 @@ JSHandle ObjectFactory::CloneClassCtor(JSHandle ctor, co "cloned function is not class"); JSHandle method(thread_, ctor->GetMethod()); - JSHandle cloneCtor = NewJSFunctionByDynClass(method, hclass, kind); + JSHandle cloneCtor = NewJSFunctionByHClass(method, hclass, kind); for (uint32_t i = 0; i < hclass->GetInlinedProperties(); i++) { JSTaggedValue value = ctor->GetPropertyInlinedProps(i); @@ -573,17 +573,17 @@ JSHandle ObjectFactory::CloneClassCtor(JSHandle ctor, co JSHandle ObjectFactory::NewNonMovableJSObject(const JSHandle &jshclass) { JSHandle obj(thread_, - JSObject::Cast(NewNonMovableDynObject(jshclass, jshclass->GetInlinedProperties()))); + JSObject::Cast(NewNonMovableObject(jshclass, jshclass->GetInlinedProperties()))); obj->InitializeHash(); obj->SetElements(thread_, EmptyArray(), SKIP_BARRIER); obj->SetProperties(thread_, EmptyArray(), SKIP_BARRIER); return obj; } -JSHandle ObjectFactory::NewJSPrimitiveRef(const JSHandle &dynKlass, +JSHandle ObjectFactory::NewJSPrimitiveRef(const JSHandle &hclass, const JSHandle &object) { - JSHandle obj = JSHandle::Cast(NewJSObject(dynKlass)); + JSHandle obj = JSHandle::Cast(NewJSObject(hclass)); obj->SetValue(thread_, object); return obj; } @@ -598,9 +598,9 @@ JSHandle ObjectFactory::NewJSArray() JSHandle ObjectFactory::NewJSForinIterator(const JSHandle &obj) { JSHandle env = vm_->GetGlobalEnv(); - JSHandle dynclass(env->GetForinIteratorClass()); + JSHandle hclass(env->GetForinIteratorClass()); - JSHandle it = JSHandle::Cast(NewJSObject(dynclass)); + JSHandle it = JSHandle::Cast(NewJSObject(hclass)); it->SetObject(thread_, obj); it->SetVisitedKeys(thread_, thread_->GlobalConstants()->GetEmptyTaggedQueue()); it->SetRemainingKeys(thread_, thread_->GlobalConstants()->GetEmptyTaggedQueue()); @@ -611,7 +611,7 @@ JSHandle ObjectFactory::NewJSForinIterator(const JSHandle ObjectFactory::CreateJSRegExpInstanceClass(JSHandle proto) { const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle regexpDynclass = NewEcmaDynClass(JSRegExp::SIZE, JSType::JS_REG_EXP, proto); + JSHandle regexpClass = NewEcmaHClass(JSRegExp::SIZE, JSType::JS_REG_EXP, proto); uint32_t fieldOrder = 0; JSHandle layoutInfoHandle = CreateLayoutInfo(1); @@ -624,17 +624,17 @@ JSHandle ObjectFactory::CreateJSRegExpInstanceClass(JSHandleSetLayout(thread_, layoutInfoHandle); - regexpDynclass->SetNumberOfProps(fieldOrder); + regexpClass->SetLayout(thread_, layoutInfoHandle); + regexpClass->SetNumberOfProps(fieldOrder); } - return regexpDynclass; + return regexpClass; } JSHandle ObjectFactory::CreateJSArrayInstanceClass(JSHandle proto) { const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle arrayDynclass = NewEcmaDynClass(JSArray::SIZE, JSType::JS_ARRAY, proto); + JSHandle arrayClass = NewEcmaHClass(JSArray::SIZE, JSType::JS_ARRAY, proto); uint32_t fieldOrder = 0; ASSERT(JSArray::LENGTH_INLINE_PROPERTY_INDEX == fieldOrder); @@ -648,13 +648,13 @@ JSHandle ObjectFactory::CreateJSArrayInstanceClass(JSHandleSetLayout(thread_, layoutInfoHandle); - arrayDynclass->SetNumberOfProps(fieldOrder); + arrayClass->SetLayout(thread_, layoutInfoHandle); + arrayClass->SetNumberOfProps(fieldOrder); } - arrayDynclass->SetIsStableElements(true); - arrayDynclass->SetHasConstructor(false); + arrayClass->SetIsStableElements(true); + arrayClass->SetHasConstructor(false); - return arrayDynclass; + return arrayClass; } JSHandle ObjectFactory::CreateJSArguments() @@ -663,7 +663,7 @@ JSHandle ObjectFactory::CreateJSArguments() const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); JSHandle proto = env->GetObjectFunctionPrototype(); - JSHandle argumentsDynclass = NewEcmaDynClass(JSArguments::SIZE, JSType::JS_ARGUMENTS, proto); + JSHandle argumentsClass = NewEcmaHClass(JSArguments::SIZE, JSType::JS_ARGUMENTS, proto); uint32_t fieldOrder = 0; ASSERT(JSArguments::LENGTH_INLINE_PROPERTY_INDEX == fieldOrder); @@ -710,18 +710,18 @@ JSHandle ObjectFactory::CreateJSArguments() } { - argumentsDynclass->SetLayout(thread_, layoutInfoHandle); - argumentsDynclass->SetNumberOfProps(fieldOrder); + argumentsClass->SetLayout(thread_, layoutInfoHandle); + argumentsClass->SetNumberOfProps(fieldOrder); } - argumentsDynclass->SetIsStableElements(true); - return argumentsDynclass; + argumentsClass->SetIsStableElements(true); + return argumentsClass; } JSHandle ObjectFactory::NewJSArguments() { JSHandle env = vm_->GetGlobalEnv(); - JSHandle dynclass = JSHandle::Cast(env->GetArgumentsClass()); - JSHandle obj = JSHandle::Cast(NewJSObject(dynclass)); + JSHandle hclass = JSHandle::Cast(env->GetArgumentsClass()); + JSHandle obj = JSHandle::Cast(NewJSObject(hclass)); return obj; } @@ -812,7 +812,7 @@ JSHandle ObjectFactory::NewJSAggregateError() JSHandle ObjectFactory::NewJSObjectByConstructor(const JSHandle &constructor) { if (!constructor->HasFunctionPrototype() || - (constructor->GetProtoOrDynClass().IsHeapObject() && constructor->GetFunctionPrototype().IsECMAObject())) { + (constructor->GetProtoOrHClass().IsHeapObject() && constructor->GetFunctionPrototype().IsECMAObject())) { JSHandle jshclass = JSFunction::GetInstanceJSHClass(thread_, constructor, JSHandle(constructor)); return NewJSObjectWithInit(jshclass); @@ -831,7 +831,7 @@ JSHandle ObjectFactory::NewJSObjectByConstructor(const JSHandle jshclass; if (!constructor->HasFunctionPrototype() || - (constructor->GetProtoOrDynClass().IsHeapObject() && constructor->GetFunctionPrototype().IsECMAObject())) { + (constructor->GetProtoOrHClass().IsHeapObject() && constructor->GetFunctionPrototype().IsECMAObject())) { jshclass = JSFunction::GetInstanceJSHClass(thread_, constructor, newTarget); } else { JSHandle env = vm_->GetGlobalEnv(); @@ -1281,32 +1281,32 @@ FreeObject *ObjectFactory::FillFreeObject(uintptr_t address, size_t size, Remove return object; } -TaggedObject *ObjectFactory::NewDynObject(const JSHandle &dynclass) +TaggedObject *ObjectFactory::NewObject(const JSHandle &hclass) { NewObjectHook(); - TaggedObject *header = heap_->AllocateYoungOrHugeObject(*dynclass); - uint32_t inobjPropCount = dynclass->GetInlinedProperties(); + TaggedObject *header = heap_->AllocateYoungOrHugeObject(*hclass); + uint32_t inobjPropCount = hclass->GetInlinedProperties(); if (inobjPropCount > 0) { - InitializeExtraProperties(dynclass, header, inobjPropCount); + InitializeExtraProperties(hclass, header, inobjPropCount); } return header; } -TaggedObject *ObjectFactory::NewNonMovableDynObject(const JSHandle &dynclass, int inobjPropCount) +TaggedObject *ObjectFactory::NewNonMovableObject(const JSHandle &hclass, int inobjPropCount) { NewObjectHook(); - TaggedObject *header = heap_->AllocateNonMovableOrHugeObject(*dynclass); + TaggedObject *header = heap_->AllocateNonMovableOrHugeObject(*hclass); if (inobjPropCount > 0) { - InitializeExtraProperties(dynclass, header, inobjPropCount); + InitializeExtraProperties(hclass, header, inobjPropCount); } return header; } -void ObjectFactory::InitializeExtraProperties(const JSHandle &dynclass, TaggedObject *obj, int inobjPropCount) +void ObjectFactory::InitializeExtraProperties(const JSHandle &hclass, TaggedObject *obj, int inobjPropCount) { - ASSERT(inobjPropCount * JSTaggedValue::TaggedTypeSize() < dynclass->GetObjectSize()); - auto paddr = reinterpret_cast(obj) + dynclass->GetObjectSize(); - JSTaggedType initVal = dynclass->IsAOT() ? JSTaggedValue::VALUE_HOLE : JSTaggedValue::VALUE_UNDEFINED; + ASSERT(inobjPropCount * JSTaggedValue::TaggedTypeSize() < hclass->GetObjectSize()); + auto paddr = reinterpret_cast(obj) + hclass->GetObjectSize(); + JSTaggedType initVal = hclass->IsAOT() ? JSTaggedValue::VALUE_HOLE : JSTaggedValue::VALUE_UNDEFINED; for (int i = 0; i < inobjPropCount; ++i) { paddr -= JSTaggedValue::TaggedTypeSize(); *reinterpret_cast(paddr) = initVal; @@ -1316,9 +1316,9 @@ void ObjectFactory::InitializeExtraProperties(const JSHandle &dynclass JSHandle ObjectFactory::OrdinaryNewJSObjectCreate(const JSHandle &proto) { JSHandle protoValue(proto); - JSHandle dynclass(thread_, thread_->GlobalConstants()->GetObjectDynClass().GetTaggedObject()); - JSHandle newDynclass = JSHClass::TransProtoWithoutLayout(thread_, dynclass, protoValue); - JSHandle newObj = NewJSObject(newDynclass); + JSHandle hclass(thread_, thread_->GlobalConstants()->GetObjectClass().GetTaggedObject()); + JSHandle newClass = JSHClass::TransProtoWithoutLayout(thread_, hclass, protoValue); + JSHandle newObj = NewJSObject(newClass); newObj->GetJSHClass()->SetExtensible(true); return newObj; } @@ -1333,23 +1333,23 @@ JSHandle ObjectFactory::NewJSFunction(const JSHandle &env JSHandle ObjectFactory::NewJSFunction(const JSHandle &env, const JSHandle &method, FunctionKind kind) { - JSHandle dynclass; + JSHandle hclass; if (kind == FunctionKind::BASE_CONSTRUCTOR) { - dynclass = JSHandle::Cast(env->GetFunctionClassWithProto()); + hclass = JSHandle::Cast(env->GetFunctionClassWithProto()); } else if (JSFunction::IsConstructorKind(kind)) { - dynclass = JSHandle::Cast(env->GetConstructorFunctionClass()); + hclass = JSHandle::Cast(env->GetConstructorFunctionClass()); } else { - dynclass = JSHandle::Cast(env->GetNormalFunctionClass()); + hclass = JSHandle::Cast(env->GetNormalFunctionClass()); } - return NewJSFunctionByDynClass(method, dynclass, kind); + return NewJSFunctionByHClass(method, hclass, kind); } JSHandle ObjectFactory::CreateFunctionClass(FunctionKind kind, uint32_t size, JSType type, const JSHandle &prototype) { const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle functionClass = NewEcmaDynClass(size, type, prototype); + JSHandle functionClass = NewEcmaHClass(size, type, prototype); { functionClass->SetCallable(true); // FunctionKind = BASE_CONSTRUCTOR @@ -1408,9 +1408,9 @@ JSHandle ObjectFactory::CreateFunctionClass(FunctionKind kind, uint32_ return functionClass; } -JSHandle ObjectFactory::NewJSFunctionByDynClass(const JSHandle &method, - const JSHandle &clazz, - FunctionKind kind, MemSpaceType type) +JSHandle ObjectFactory::NewJSFunctionByHClass(const JSHandle &method, + const JSHandle &clazz, + FunctionKind kind, MemSpaceType type) { JSHandle function; switch (type) { @@ -1433,7 +1433,7 @@ JSHandle ObjectFactory::NewJSFunctionByDynClass(const JSHandle ObjectFactory::NewJSFunctionByDynClass(const void *func, const JSHandle &clazz, +JSHandle ObjectFactory::NewJSFunctionByHClass(const void *func, const JSHandle &clazz, FunctionKind kind) { JSHandle jsMethod = NewMethodForNativeFunction(func); @@ -1463,16 +1463,16 @@ JSHandle ObjectFactory::NewJSMethod(const MethodLiteral *method) JSHandle ObjectFactory::NewJSNativeErrorFunction(const JSHandle &env, const void *nativeFunc) { JSHandle target = NewMethodForNativeFunction(nativeFunc); - JSHandle dynclass = JSHandle::Cast(env->GetNativeErrorFunctionClass()); - return NewJSFunctionByDynClass(target, dynclass, FunctionKind::BUILTIN_CONSTRUCTOR); + JSHandle hclass = JSHandle::Cast(env->GetNativeErrorFunctionClass()); + return NewJSFunctionByHClass(target, hclass, FunctionKind::BUILTIN_CONSTRUCTOR); } JSHandle ObjectFactory::NewSpecificTypedArrayFunction(const JSHandle &env, const void *nativeFunc) { JSHandle target = NewMethodForNativeFunction(nativeFunc); - JSHandle dynclass = JSHandle::Cast(env->GetSpecificTypedArrayFunctionClass()); - return NewJSFunctionByDynClass(target, dynclass, FunctionKind::BUILTIN_CONSTRUCTOR); + JSHandle hclass = JSHandle::Cast(env->GetSpecificTypedArrayFunctionClass()); + return NewJSFunctionByHClass(target, hclass, FunctionKind::BUILTIN_CONSTRUCTOR); } JSHandle ObjectFactory::NewAotFunction(uint32_t numArgs, uintptr_t codeEntry) @@ -1493,13 +1493,13 @@ JSHandle ObjectFactory::NewJSBoundFunction(const JSHandle env = vm_->GetGlobalEnv(); JSHandle proto = env->GetFunctionPrototype(); - JSHandle dynclass = NewEcmaDynClass(JSBoundFunction::SIZE, JSType::JS_BOUND_FUNCTION, proto); + JSHandle hclass = NewEcmaHClass(JSBoundFunction::SIZE, JSType::JS_BOUND_FUNCTION, proto); - JSHandle bundleFunction = JSHandle::Cast(NewJSObject(dynclass)); + JSHandle bundleFunction = JSHandle::Cast(NewJSObject(hclass)); bundleFunction->SetBoundTarget(thread_, target); bundleFunction->SetBoundThis(thread_, boundThis); bundleFunction->SetBoundArguments(thread_, args); - dynclass->SetCallable(true); + hclass->SetCallable(true); if (target.GetTaggedValue().IsConstructor()) { bundleFunction->SetConstructor(true); } @@ -1510,9 +1510,9 @@ JSHandle ObjectFactory::NewJSBoundFunction(const JSHandle ObjectFactory::NewJSIntlBoundFunction(MethodIndex idx, int functionLength) { JSHandle env = vm_->GetGlobalEnv(); - JSHandle dynclass = JSHandle::Cast(env->GetJSIntlBoundFunctionClass()); + JSHandle hclass = JSHandle::Cast(env->GetJSIntlBoundFunctionClass()); - JSHandle intlBoundFunc = JSHandle::Cast(NewJSObject(dynclass)); + JSHandle intlBoundFunc = JSHandle::Cast(NewJSObject(hclass)); intlBoundFunc->SetNumberFormat(thread_, JSTaggedValue::Undefined()); intlBoundFunc->SetDateTimeFormat(thread_, JSTaggedValue::Undefined()); intlBoundFunc->SetCollator(thread_, JSTaggedValue::Undefined()); @@ -1532,9 +1532,9 @@ JSHandle ObjectFactory::NewJSProxyRevocFunction(const JSHa { JSHandle env = vm_->GetGlobalEnv(); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle dynclass = JSHandle::Cast(env->GetProxyRevocFunctionClass()); + JSHandle hclass = JSHandle::Cast(env->GetProxyRevocFunctionClass()); - JSHandle revocFunction = JSHandle::Cast(NewJSObject(dynclass)); + JSHandle revocFunction = JSHandle::Cast(NewJSObject(hclass)); revocFunction->SetRevocableProxy(thread_, JSTaggedValue::Undefined()); revocFunction->SetRevocableProxy(thread_, proxy); JSHandle function = JSHandle::Cast(revocFunction); @@ -1551,10 +1551,10 @@ JSHandle ObjectFactory::NewJSProxyRevocFunction(const JSHa JSHandle ObjectFactory::NewJSAsyncAwaitStatusFunction(MethodIndex idx) { JSHandle env = vm_->GetGlobalEnv(); - JSHandle dynclass = JSHandle::Cast(env->GetAsyncAwaitStatusFunctionClass()); + JSHandle hclass = JSHandle::Cast(env->GetAsyncAwaitStatusFunctionClass()); JSHandle awaitFunction = - JSHandle::Cast(NewJSObject(dynclass)); + JSHandle::Cast(NewJSObject(hclass)); awaitFunction->SetAsyncContext(thread_, JSTaggedValue::Undefined()); JSFunction::InitializeJSFunction(thread_, JSHandle::Cast(awaitFunction)); awaitFunction->SetMethod(thread_, vm_->GetMethodByIndex(idx)); @@ -1565,8 +1565,8 @@ JSHandle ObjectFactory::NewJSGeneratorFunction(const JSHandle env = vm_->GetGlobalEnv(); - JSHandle dynclass = JSHandle::Cast(env->GetGeneratorFunctionClass()); - JSHandle generatorFunc = JSHandle::Cast(NewJSObject(dynclass)); + JSHandle hclass = JSHandle::Cast(env->GetGeneratorFunctionClass()); + JSHandle generatorFunc = JSHandle::Cast(NewJSObject(hclass)); JSFunction::InitializeJSFunction(thread_, generatorFunc, FunctionKind::GENERATOR_FUNCTION); generatorFunc->SetMethod(thread_, method); return generatorFunc; @@ -1574,13 +1574,13 @@ JSHandle ObjectFactory::NewJSGeneratorFunction(const JSHandle ObjectFactory::NewJSGeneratorObject(JSHandle generatorFunction) { - JSHandle proto(thread_, JSHandle::Cast(generatorFunction)->GetProtoOrDynClass()); + JSHandle proto(thread_, JSHandle::Cast(generatorFunction)->GetProtoOrHClass()); if (!proto->IsECMAObject()) { JSHandle realmHandle = JSObject::GetFunctionRealm(thread_, generatorFunction); proto = realmHandle->GetGeneratorPrototype(); } - JSHandle dynclass = NewEcmaDynClass(JSGeneratorObject::SIZE, JSType::JS_GENERATOR_OBJECT, proto); - JSHandle generatorObject = JSHandle::Cast(NewJSObject(dynclass)); + JSHandle hclass = NewEcmaHClass(JSGeneratorObject::SIZE, JSType::JS_GENERATOR_OBJECT, proto); + JSHandle generatorObject = JSHandle::Cast(NewJSObject(hclass)); generatorObject->SetGeneratorContext(thread_, JSTaggedValue::Undefined()); generatorObject->SetResumeResult(thread_, JSTaggedValue::Undefined()); return generatorObject; @@ -1588,23 +1588,23 @@ JSHandle ObjectFactory::NewJSGeneratorObject(JSHandle ObjectFactory::NewJSAsyncGeneratorObject(JSHandle generatorFunction) { - JSHandle proto(thread_, JSHandle::Cast(generatorFunction)->GetProtoOrDynClass()); + JSHandle proto(thread_, JSHandle::Cast(generatorFunction)->GetProtoOrHClass()); if (!proto->IsECMAObject()) { JSHandle realmHandle = JSObject::GetFunctionRealm(thread_, generatorFunction); proto = realmHandle->GetAsyncGeneratorPrototype(); } - JSHandle dynclass = NewEcmaDynClass(JSAsyncGeneratorObject::SIZE, + JSHandle hclass = NewEcmaHClass(JSAsyncGeneratorObject::SIZE, JSType::JS_ASYNC_GENERATOR_OBJECT, proto); JSHandle generatorObject = - JSHandle::Cast(NewJSObjectWithInit(dynclass)); + JSHandle::Cast(NewJSObjectWithInit(hclass)); return generatorObject; } JSHandle ObjectFactory::NewAsyncFunction(const JSHandle &method) { JSHandle env = vm_->GetGlobalEnv(); - JSHandle dynclass = JSHandle::Cast(env->GetAsyncFunctionClass()); - JSHandle asyncFunction = JSHandle::Cast(NewJSObject(dynclass)); + JSHandle hclass = JSHandle::Cast(env->GetAsyncFunctionClass()); + JSHandle asyncFunction = JSHandle::Cast(NewJSObject(hclass)); JSFunction::InitializeJSFunction(thread_, JSHandle::Cast(asyncFunction)); asyncFunction->SetMethod(thread_, method); return asyncFunction; @@ -1614,8 +1614,8 @@ JSHandle ObjectFactory::NewJSAsyncFuncObject() { JSHandle env = vm_->GetGlobalEnv(); JSHandle proto = env->GetInitialGenerator(); - JSHandle dynclass = NewEcmaDynClass(JSAsyncFuncObject::SIZE, JSType::JS_ASYNC_FUNC_OBJECT, proto); - JSHandle asyncFuncObject = JSHandle::Cast(NewJSObjectWithInit(dynclass)); + JSHandle hclass = NewEcmaHClass(JSAsyncFuncObject::SIZE, JSType::JS_ASYNC_FUNC_OBJECT, proto); + JSHandle asyncFuncObject = JSHandle::Cast(NewJSObjectWithInit(hclass)); return asyncFuncObject; } @@ -1943,10 +1943,10 @@ JSHandle ObjectFactory::NewJSProxy(const JSHandle &targe JSHandle ObjectFactory::NewJSRealm() { - JSHandle dynClassClassHandle = NewEcmaDynClassClass(nullptr, JSHClass::SIZE, JSType::HCLASS); - JSHClass *dynclass = reinterpret_cast(dynClassClassHandle.GetTaggedValue().GetTaggedObject()); - dynclass->SetClass(dynclass); - JSHandle realmEnvClass = NewEcmaDynClass(*dynClassClassHandle, GlobalEnv::SIZE, JSType::GLOBAL_ENV); + JSHandle hClassHandle = NewEcmaHClassClass(nullptr, JSHClass::SIZE, JSType::HCLASS); + JSHClass *hclass = reinterpret_cast(hClassHandle.GetTaggedValue().GetTaggedObject()); + hclass->SetClass(hclass); + JSHandle realmEnvClass = NewEcmaHClass(*hClassHandle, GlobalEnv::SIZE, JSType::GLOBAL_ENV); JSHandle realmEnvHandle = NewGlobalEnv(*realmEnvClass); auto result = TemplateMap::Create(thread_); @@ -1955,8 +1955,8 @@ JSHandle ObjectFactory::NewJSRealm() Builtins builtins; builtins.Initialize(realmEnvHandle, thread_); JSHandle protoValue = thread_->GlobalConstants()->GetHandledJSRealmClass(); - JSHandle dynHandle = NewEcmaDynClass(JSRealm::SIZE, JSType::JS_REALM, protoValue); - JSHandle realm(NewJSObject(dynHandle)); + JSHandle hclassHandle = NewEcmaHClass(JSRealm::SIZE, JSType::JS_REALM, protoValue); + JSHandle realm(NewJSObject(hclassHandle)); realm->SetGlobalEnv(thread_, realmEnvHandle.GetTaggedValue()); realm->SetValue(thread_, JSTaggedValue::Undefined()); @@ -2228,8 +2228,8 @@ JSHandle ObjectFactory::NewModuleNamespace() { NewObjectHook(); JSHandle env = vm_->GetGlobalEnv(); - JSHandle dynclass = JSHandle::Cast(env->GetModuleNamespaceClass()); - JSHandle obj = NewJSObject(dynclass); + JSHandle hclass = JSHandle::Cast(env->GetModuleNamespaceClass()); + JSHandle obj = NewJSObject(hclass); JSHandle moduleNamespace = JSHandle::Cast(obj); moduleNamespace->SetModule(thread_, JSTaggedValue::Undefined()); @@ -2431,9 +2431,9 @@ JSHandle ObjectFactory::NewJSSetIterator(const JSHandle &s JSHandle env = vm_->GetGlobalEnv(); JSHandle protoValue = env->GetSetIteratorPrototype(); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle dynHandle(globalConst->GetHandledJSSetIteratorClass()); - dynHandle->SetPrototype(thread_, protoValue); - JSHandle iter(NewJSObject(dynHandle)); + JSHandle hclassHandle(globalConst->GetHandledJSSetIteratorClass()); + hclassHandle->SetPrototype(thread_, protoValue); + JSHandle iter(NewJSObject(hclassHandle)); iter->GetJSHClass()->SetExtensible(true); iter->SetIteratedSet(thread_, set->GetLinkedSet()); iter->SetNextIndex(0); @@ -2448,9 +2448,9 @@ JSHandle ObjectFactory::NewJSRegExpIterator(const JSHandle env = vm_->GetGlobalEnv(); JSHandle protoValue = env->GetRegExpIteratorPrototype(); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle dynHandle(globalConst->GetHandledJSRegExpIteratorClass()); - dynHandle->SetPrototype(thread_, protoValue); - JSHandle iter(NewJSObject(dynHandle)); + JSHandle hclassHandle(globalConst->GetHandledJSRegExpIteratorClass()); + hclassHandle->SetPrototype(thread_, protoValue); + JSHandle iter(NewJSObject(hclassHandle)); iter->GetJSHClass()->SetExtensible(true); iter->SetIteratingRegExp(thread_, matcher.GetTaggedValue()); iter->SetIteratedString(thread_, inputStr.GetTaggedValue()); @@ -2465,9 +2465,9 @@ JSHandle ObjectFactory::NewJSMapIterator(const JSHandle &m JSHandle env = vm_->GetGlobalEnv(); JSHandle protoValue = env->GetMapIteratorPrototype(); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle dynHandle(globalConst->GetHandledJSMapIteratorClass()); - dynHandle->SetPrototype(thread_, protoValue); - JSHandle iter(NewJSObject(dynHandle)); + JSHandle hclassHandle(globalConst->GetHandledJSMapIteratorClass()); + hclassHandle->SetPrototype(thread_, protoValue); + JSHandle iter(NewJSObject(hclassHandle)); iter->GetJSHClass()->SetExtensible(true); iter->SetIteratedMap(thread_, map->GetLinkedMap()); iter->SetNextIndex(0); @@ -2481,9 +2481,9 @@ JSHandle ObjectFactory::NewJSAPIHashMapIterator(const JSHa NewObjectHook(); JSHandle proto(thread_, thread_->GlobalConstants()->GetHashMapIteratorPrototype()); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle dynHandle(globalConst->GetHandledJSAPIHashMapIteratorClass()); - dynHandle->SetPrototype(thread_, proto); - JSHandle iter(NewJSObject(dynHandle)); + JSHandle hclassHandle(globalConst->GetHandledJSAPIHashMapIteratorClass()); + hclassHandle->SetPrototype(thread_, proto); + JSHandle iter(NewJSObject(hclassHandle)); iter->GetJSHClass()->SetExtensible(true); iter->SetIteratedHashMap(thread_, hashMap); iter->SetNextIndex(0); @@ -2500,9 +2500,9 @@ JSHandle ObjectFactory::NewJSAPIHashSetIterator(const JSHa NewObjectHook(); JSHandle proto(thread_, thread_->GlobalConstants()->GetHashSetIteratorPrototype()); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle dynHandle(globalConst->GetHandledJSAPIHashSetIteratorClass()); - dynHandle->SetPrototype(thread_, proto); - JSHandle iter(NewJSObject(dynHandle)); + JSHandle hclassHandle(globalConst->GetHandledJSAPIHashSetIteratorClass()); + hclassHandle->SetPrototype(thread_, proto); + JSHandle iter(NewJSObject(hclassHandle)); iter->GetJSHClass()->SetExtensible(true); iter->SetIteratedHashSet(thread_, hashSet); iter->SetNextIndex(0); @@ -2519,9 +2519,9 @@ JSHandle ObjectFactory::NewJSArrayIterator(const JSHandle env = vm_->GetGlobalEnv(); JSHandle protoValue = env->GetArrayIteratorPrototype(); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle dynHandle(globalConst->GetHandledJSArrayIteratorClass()); - dynHandle->SetPrototype(thread_, protoValue); - JSHandle iter(NewJSObject(dynHandle)); + JSHandle hclassHandle(globalConst->GetHandledJSArrayIteratorClass()); + hclassHandle->SetPrototype(thread_, protoValue); + JSHandle iter(NewJSObject(hclassHandle)); iter->GetJSHClass()->SetExtensible(true); iter->SetIteratedArray(thread_, array); iter->SetNextIndex(0); @@ -2532,10 +2532,10 @@ JSHandle ObjectFactory::NewJSArrayIterator(const JSHandle ObjectFactory::CreateJSPromiseReactionsFunction(MethodIndex idx) { JSHandle env = vm_->GetGlobalEnv(); - JSHandle dynclass = JSHandle::Cast(env->GetPromiseReactionFunctionClass()); + JSHandle hclass = JSHandle::Cast(env->GetPromiseReactionFunctionClass()); JSHandle reactionsFunction = - JSHandle::Cast(NewJSObject(dynclass)); + JSHandle::Cast(NewJSObject(hclass)); reactionsFunction->SetPromise(thread_, JSTaggedValue::Hole()); reactionsFunction->SetAlreadyResolved(thread_, JSTaggedValue::Hole()); JSHandle function = JSHandle::Cast(reactionsFunction); @@ -2548,9 +2548,9 @@ JSHandle ObjectFactory::CreateJSPromiseReactionsFunc JSHandle ObjectFactory::CreateJSPromiseExecutorFunction() { JSHandle env = vm_->GetGlobalEnv(); - JSHandle dynclass = JSHandle::Cast(env->GetPromiseExecutorFunctionClass()); + JSHandle hclass = JSHandle::Cast(env->GetPromiseExecutorFunctionClass()); JSHandle executorFunction = - JSHandle::Cast(NewJSObject(dynclass)); + JSHandle::Cast(NewJSObject(hclass)); executorFunction->SetCapability(thread_, JSTaggedValue::Hole()); executorFunction->SetCapability(thread_, JSTaggedValue::Undefined()); JSHandle function = JSHandle::Cast(executorFunction); @@ -2564,9 +2564,9 @@ JSHandle ObjectFactory::CreateJSPromiseExecutorFuncti JSHandle ObjectFactory::NewJSPromiseAllResolveElementFunction() { JSHandle env = vm_->GetGlobalEnv(); - JSHandle dynclass = JSHandle::Cast(env->GetPromiseAllResolveElementFunctionClass()); + JSHandle hclass = JSHandle::Cast(env->GetPromiseAllResolveElementFunctionClass()); JSHandle function = - JSHandle::Cast(NewJSObject(dynclass)); + JSHandle::Cast(NewJSObject(hclass)); JSFunction::InitializeJSFunction(thread_, JSHandle::Cast(function)); function->SetMethod( thread_, vm_->GetMethodByIndex(MethodIndex::BUILTINS_PROMISE_HANDLER_RESOLVE_ELEMENT_FUNCTION)); @@ -2582,9 +2582,9 @@ JSHandle ObjectFactory::NewJSPromiseAllResol JSHandle ObjectFactory::NewJSPromiseAnyRejectElementFunction() { JSHandle env = vm_->GetGlobalEnv(); - JSHandle dynclass = JSHandle::Cast(env->GetPromiseAnyRejectElementFunctionClass()); + JSHandle hclass = JSHandle::Cast(env->GetPromiseAnyRejectElementFunctionClass()); JSHandle function = - JSHandle::Cast(NewJSObject(dynclass)); + JSHandle::Cast(NewJSObject(hclass)); JSFunction::InitializeJSFunction(thread_, JSHandle::Cast(function)); function->SetMethod( thread_, vm_->GetMethodByIndex(MethodIndex::BUILTINS_PROMISE_HANDLER_ANY_REJECT_ELEMENT_FUNCTION)); @@ -2600,9 +2600,9 @@ JSHandle ObjectFactory::NewJSPromiseAnyReject JSHandle ObjectFactory::NewJSPromiseAllSettledResolveElementFunction() { JSHandle env = vm_->GetGlobalEnv(); - JSHandle dynclass = JSHandle::Cast(env->GetPromiseAllSettledElementFunctionClass()); + JSHandle hclass = JSHandle::Cast(env->GetPromiseAllSettledElementFunctionClass()); JSHandle function = - JSHandle::Cast(NewJSObject(dynclass)); + JSHandle::Cast(NewJSObject(hclass)); JSFunction::InitializeJSFunction(thread_, JSHandle::Cast(function)); function->SetMethod(thread_, vm_->GetMethodByIndex(MethodIndex::BUILTINS_PROMISE_HANDLER_ALL_SETTLED_RESOLVE_ELEMENT_FUNCTION)); @@ -2618,9 +2618,9 @@ JSHandle ObjectFactory::NewJSPromiseAllSettl JSHandle ObjectFactory::NewJSPromiseAllSettledRejectElementFunction() { JSHandle env = vm_->GetGlobalEnv(); - JSHandle dynclass = JSHandle::Cast(env->GetPromiseAllSettledElementFunctionClass()); + JSHandle hclass = JSHandle::Cast(env->GetPromiseAllSettledElementFunctionClass()); JSHandle function = - JSHandle::Cast(NewJSObject(dynclass)); + JSHandle::Cast(NewJSObject(hclass)); JSFunction::InitializeJSFunction(thread_, JSHandle::Cast(function)); function->SetMethod(thread_, vm_->GetMethodByIndex(MethodIndex::BUILTINS_PROMISE_HANDLER_ALL_SETTLED_REJECT_ELEMENT_FUNCTION)); @@ -2636,9 +2636,9 @@ JSHandle ObjectFactory::NewJSPromiseAllSettl JSHandle ObjectFactory::NewJSPromiseThenFinallyFunction() { JSHandle env = vm_->GetGlobalEnv(); - JSHandle dynclass = JSHandle::Cast(env->GetPromiseFinallyFunctionClass()); + JSHandle hclass = JSHandle::Cast(env->GetPromiseFinallyFunctionClass()); JSHandle function = - JSHandle::Cast(NewJSObject(dynclass)); + JSHandle::Cast(NewJSObject(hclass)); JSFunction::InitializeJSFunction(thread_, JSHandle::Cast(function)); function->SetMethod(thread_, vm_->GetMethodByIndex(MethodIndex::BUILTINS_PROMISE_HANDLER_THEN_FINALLY_FUNCTION)); function->SetConstructor(thread_, JSTaggedValue::Undefined()); @@ -2650,9 +2650,9 @@ JSHandle ObjectFactory::NewJSPromiseThenFinallyFunctio JSHandle ObjectFactory::NewJSPromiseCatchFinallyFunction() { JSHandle env = vm_->GetGlobalEnv(); - JSHandle dynclass = JSHandle::Cast(env->GetPromiseFinallyFunctionClass()); + JSHandle hclass = JSHandle::Cast(env->GetPromiseFinallyFunctionClass()); JSHandle function = - JSHandle::Cast(NewJSObject(dynclass)); + JSHandle::Cast(NewJSObject(hclass)); JSFunction::InitializeJSFunction(thread_, JSHandle::Cast(function)); function->SetMethod(thread_, vm_->GetMethodByIndex(MethodIndex::BUILTINS_PROMISE_HANDLER_CATCH_FINALLY_FUNCTION)); function->SetConstructor(thread_, JSTaggedValue::Undefined()); @@ -2664,10 +2664,10 @@ JSHandle ObjectFactory::NewJSPromiseCatchFinallyFuncti JSHandle ObjectFactory::NewJSAsyGenResNextRetProRstFulfilledFtn() { JSHandle env = vm_->GetGlobalEnv(); - JSHandle dynclass = JSHandle::Cast( + JSHandle hclass = JSHandle::Cast( env->GetAsyncGeneratorResNextRetProRstFtnClass()); JSHandle function = - JSHandle::Cast(NewJSObject(dynclass)); + JSHandle::Cast(NewJSObject(hclass)); JSFunction::InitializeJSFunction(thread_, JSHandle::Cast(function)); function->SetMethod(thread_, vm_->GetMethodByIndex(MethodIndex::BUILTINS_ASYNC_GENERATOR_NEXT_FULFILLED_FUNCTION)); function->SetAsyncGeneratorObject(thread_, JSTaggedValue::Undefined()); @@ -2678,10 +2678,10 @@ JSHandle ObjectFactory::NewJSAsyGenResNextR JSHandle ObjectFactory::NewJSAsyGenResNextRetProRstRejectedFtn() { JSHandle env = vm_->GetGlobalEnv(); - JSHandle dynclass = JSHandle::Cast( + JSHandle hclass = JSHandle::Cast( env->GetAsyncGeneratorResNextRetProRstFtnClass()); JSHandle function = - JSHandle::Cast(NewJSObject(dynclass)); + JSHandle::Cast(NewJSObject(hclass)); JSFunction::InitializeJSFunction(thread_, JSHandle::Cast(function)); function->SetMethod(thread_, vm_->GetMethodByIndex(MethodIndex::BUILTINS_ASYNC_GENERATOR_NEXT_REJECTED_FUNCTION)); function->SetAsyncGeneratorObject(thread_, JSTaggedValue::Undefined()); @@ -2692,9 +2692,9 @@ JSHandle ObjectFactory::NewJSAsyGenResNextR JSHandle ObjectFactory::NewJSPromiseValueThunkFunction() { JSHandle env = vm_->GetGlobalEnv(); - JSHandle dynclass = JSHandle::Cast(env->GetPromiseValueThunkOrThrowerFunctionClass()); + JSHandle hclass = JSHandle::Cast(env->GetPromiseValueThunkOrThrowerFunctionClass()); JSHandle function = - JSHandle::Cast(NewJSObject(dynclass)); + JSHandle::Cast(NewJSObject(hclass)); JSFunction::InitializeJSFunction(thread_, JSHandle::Cast(function)); function->SetMethod(thread_, vm_->GetMethodByIndex(MethodIndex::BUILTINS_PROMISE_HANDLER_VALUE_THUNK_FUNCTION)); function->SetResult(thread_, JSTaggedValue::Undefined()); @@ -2705,9 +2705,9 @@ JSHandle ObjectFactory::NewJSPromiseValueT JSHandle ObjectFactory::NewJSPromiseThrowerFunction() { JSHandle env = vm_->GetGlobalEnv(); - JSHandle dynclass = JSHandle::Cast(env->GetPromiseValueThunkOrThrowerFunctionClass()); + JSHandle hclass = JSHandle::Cast(env->GetPromiseValueThunkOrThrowerFunctionClass()); JSHandle function = - JSHandle::Cast(NewJSObject(dynclass)); + JSHandle::Cast(NewJSObject(hclass)); JSFunction::InitializeJSFunction(thread_, JSHandle::Cast(function)); function->SetMethod(thread_, vm_->GetMethodByIndex(MethodIndex::BUILTINS_PROMISE_HANDLER_THROWER_FUNCTION)); function->SetResult(thread_, JSTaggedValue::Undefined()); @@ -2795,7 +2795,7 @@ JSHandle ObjectFactory::CreateObjectClass(const JSHandle fieldOrder++; } ASSERT(fieldOrder <= PropertyAttributes::MAX_CAPACITY_OF_PROPERTIES); - JSHandle objClass = NewEcmaDynClass(JSObject::SIZE, JSType::JS_OBJECT, fieldOrder); + JSHandle objClass = NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, fieldOrder); objClass->SetPrototype(thread_, proto.GetTaggedValue()); { objClass->SetExtensible(true); @@ -2846,7 +2846,7 @@ JSHandle ObjectFactory::GetObjectLiteralHClass(const JSHandle hclassCacheArr = JSHandle::Cast(hclassCache); JSTaggedValue maybeHClass = hclassCacheArr->Get(length); if (maybeHClass.IsHole()) { - JSHandle objHClass = NewEcmaDynClass(JSObject::SIZE, JSType::JS_OBJECT, length); + JSHandle objHClass = NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, length); objHClass->SetPrototype(thread_, proto.GetTaggedValue()); { objHClass->SetNumberOfProps(0); @@ -2861,9 +2861,9 @@ JSHandle ObjectFactory::GetObjectLiteralHClass(const JSHandle ObjectFactory::NewOldSpaceObjLiteralByHClass(const JSHandle &properties, size_t length) { - JSHandle dynclass = GetObjectLiteralHClass(properties, length); - JSHandle obj = NewOldSpaceJSObject(dynclass); - InitializeJSObject(obj, dynclass); + JSHandle hclass = GetObjectLiteralHClass(properties, length); + JSHandle obj = NewOldSpaceJSObject(hclass); + InitializeJSObject(obj, hclass); return obj; } @@ -3218,9 +3218,9 @@ JSHandle ObjectFactory::NewJSAPIArrayListIterator(const NewObjectHook(); JSHandle protoValue(thread_, thread_->GlobalConstants()->GetArrayListIteratorPrototype()); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle dynHandle(globalConst->GetHandledJSAPIArrayListIteratorClass()); - dynHandle->SetPrototype(thread_, protoValue); - JSHandle iter(NewJSObject(dynHandle)); + JSHandle hclassHandle(globalConst->GetHandledJSAPIArrayListIteratorClass()); + hclassHandle->SetPrototype(thread_, protoValue); + JSHandle iter(NewJSObject(hclassHandle)); iter->GetJSHClass()->SetExtensible(true); iter->SetIteratedArrayList(thread_, arrayList); iter->SetNextIndex(0); @@ -3233,9 +3233,9 @@ JSHandle ObjectFactory::NewJSAPILightWeightMapItera NewObjectHook(); JSHandle protoValue(thread_, thread_->GlobalConstants()->GetLightWeightMapIteratorPrototype()); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle dynHandle(globalConst->GetHandledJSAPILightWeightMapIteratorClass()); - dynHandle->SetPrototype(thread_, protoValue); - JSHandle iter(NewJSObject(dynHandle)); + JSHandle hclassHandle(globalConst->GetHandledJSAPILightWeightMapIteratorClass()); + hclassHandle->SetPrototype(thread_, protoValue); + JSHandle iter(NewJSObject(hclassHandle)); iter->GetJSHClass()->SetExtensible(true); iter->SetIteratedLightWeightMap(thread_, obj); iter->SetNextIndex(0); @@ -3249,9 +3249,9 @@ JSHandle ObjectFactory::NewJSAPILightWeightSetItera NewObjectHook(); JSHandle protoValue(thread_, thread_->GlobalConstants()->GetLightWeightSetIteratorPrototype()); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle dynHandle(globalConst->GetHandledJSAPILightWeightSetIteratorClass()); - dynHandle->SetPrototype(thread_, protoValue); - JSHandle iter(NewJSObject(dynHandle)); + JSHandle hclassHandle(globalConst->GetHandledJSAPILightWeightSetIteratorClass()); + hclassHandle->SetPrototype(thread_, protoValue); + JSHandle iter(NewJSObject(hclassHandle)); iter->GetJSHClass()->SetExtensible(true); iter->SetIteratedLightWeightSet(thread_, obj); iter->SetNextIndex(0); @@ -3279,9 +3279,9 @@ JSHandle ObjectFactory::NewJSAPIPlainArrayIterator(cons NewObjectHook(); JSHandle protoValue(thread_, thread_->GlobalConstants()->GetPlainArrayIteratorPrototype()); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle dynHandle(globalConst->GetHandledJSAPIPlainArrayIteratorClass()); - dynHandle->SetPrototype(thread_, protoValue); - JSHandle iter(NewJSObject(dynHandle)); + JSHandle hclassHandle(globalConst->GetHandledJSAPIPlainArrayIteratorClass()); + hclassHandle->SetPrototype(thread_, protoValue); + JSHandle iter(NewJSObject(hclassHandle)); iter->GetJSHClass()->SetExtensible(true); iter->SetIteratedPlainArray(thread_, plainarray); iter->SetNextIndex(0); @@ -3294,9 +3294,9 @@ JSHandle ObjectFactory::NewJSAPIStackIterator(const JSHandle NewObjectHook(); JSHandle protoValue(thread_, thread_->GlobalConstants()->GetStackIteratorPrototype()); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle dynHandle(globalConst->GetHandledJSAPIStackIteratorClass()); - dynHandle->SetPrototype(thread_, protoValue); - JSHandle iter(NewJSObject(dynHandle)); + JSHandle hclassHandle(globalConst->GetHandledJSAPIStackIteratorClass()); + hclassHandle->SetPrototype(thread_, protoValue); + JSHandle iter(NewJSObject(hclassHandle)); iter->GetJSHClass()->SetExtensible(true); iter->SetIteratedStack(thread_, stack); iter->SetNextIndex(0); @@ -3333,9 +3333,9 @@ JSHandle ObjectFactory::NewJSAPIDequeIterator(const JSHandle NewObjectHook(); JSHandle protoValue(thread_, thread_->GlobalConstants()->GetDequeIteratorPrototype()); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle dynHandle(globalConst->GetHandledJSAPIDequeIteratorClass()); - dynHandle->SetPrototype(thread_, protoValue); - JSHandle iter(NewJSObject(dynHandle)); + JSHandle hclassHandle(globalConst->GetHandledJSAPIDequeIteratorClass()); + hclassHandle->SetPrototype(thread_, protoValue); + JSHandle iter(NewJSObject(hclassHandle)); iter->GetJSHClass()->SetExtensible(true); iter->SetIteratedDeque(thread_, deque); iter->SetNextIndex(deque->GetFirst()); @@ -3372,9 +3372,9 @@ JSHandle ObjectFactory::NewJSAPIQueueIterator(const JSHandle NewObjectHook(); JSHandle protoValue(thread_, thread_->GlobalConstants()->GetQueueIteratorPrototype()); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle dynHandle(globalConst->GetHandledJSAPIQueueIteratorClass()); - dynHandle->SetPrototype(thread_, protoValue); - JSHandle iter(NewJSObject(dynHandle)); + JSHandle hclassHandle(globalConst->GetHandledJSAPIQueueIteratorClass()); + hclassHandle->SetPrototype(thread_, protoValue); + JSHandle iter(NewJSObject(hclassHandle)); iter->GetJSHClass()->SetExtensible(true); iter->SetIteratedQueue(thread_, queue); // IteratedQueue iter->SetNextIndex(0); @@ -3387,9 +3387,9 @@ JSHandle ObjectFactory::NewJSAPITreeMapIterator(const JSHa NewObjectHook(); JSHandle proto(thread_, thread_->GlobalConstants()->GetTreeMapIteratorPrototype()); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle dynHandle(globalConst->GetHandledJSAPITreeMapIteratorClass()); - dynHandle->SetPrototype(thread_, proto); - JSHandle iter(NewJSObject(dynHandle)); + JSHandle hclassHandle(globalConst->GetHandledJSAPITreeMapIteratorClass()); + hclassHandle->SetPrototype(thread_, proto); + JSHandle iter(NewJSObject(hclassHandle)); iter->GetJSHClass()->SetExtensible(true); iter->SetIteratedMap(thread_, map); iter->SetNextIndex(0); @@ -3407,9 +3407,9 @@ JSHandle ObjectFactory::NewJSAPITreeSetIterator(const JSHa NewObjectHook(); JSHandle proto(thread_, thread_->GlobalConstants()->GetTreeSetIteratorPrototype()); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle dynHandle(globalConst->GetHandledJSAPITreeSetIteratorClass()); - dynHandle->SetPrototype(thread_, proto); - JSHandle iter(NewJSObject(dynHandle)); + JSHandle hclassHandle(globalConst->GetHandledJSAPITreeSetIteratorClass()); + hclassHandle->SetPrototype(thread_, proto); + JSHandle iter(NewJSObject(hclassHandle)); iter->GetJSHClass()->SetExtensible(true); iter->SetIteratedSet(thread_, set); iter->SetNextIndex(0); @@ -3437,9 +3437,9 @@ JSHandle ObjectFactory::NewJSAPIVectorIterator(const JSHand NewObjectHook(); JSHandle proto(thread_, thread_->GlobalConstants()->GetVectorIteratorPrototype()); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle dynHandle(globalConst->GetHandledJSAPIVectorIteratorClass()); - dynHandle->SetPrototype(thread_, proto); - JSHandle iter(NewJSObject(dynHandle)); + JSHandle hclassHandle(globalConst->GetHandledJSAPIVectorIteratorClass()); + hclassHandle->SetPrototype(thread_, proto); + JSHandle iter(NewJSObject(hclassHandle)); iter->GetJSHClass()->SetExtensible(true); iter->SetIteratedVector(thread_, vector); iter->SetNextIndex(0); @@ -3451,9 +3451,9 @@ JSHandle ObjectFactory::NewJSAPILinkedListIterator(cons NewObjectHook(); JSHandle proto(thread_, thread_->GlobalConstants()->GetLinkedListIteratorPrototype()); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle dynHandle(globalConst->GetHandledJSAPILinkedListIteratorClass()); - dynHandle->SetPrototype(thread_, proto); - JSHandle iter(NewJSObject(dynHandle)); + JSHandle hclassHandle(globalConst->GetHandledJSAPILinkedListIteratorClass()); + hclassHandle->SetPrototype(thread_, proto); + JSHandle iter(NewJSObject(hclassHandle)); iter->GetJSHClass()->SetExtensible(true); iter->SetIteratedLinkedList(thread_, linkedList->GetDoubleList()); iter->SetNextIndex(0); @@ -3465,9 +3465,9 @@ JSHandle ObjectFactory::NewJSAPIListIterator(const JSHandle proto(thread_, thread_->GlobalConstants()->GetListIteratorPrototype()); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); - JSHandle dynHandle(globalConst->GetHandledJSAPIListIteratorClass()); - dynHandle->SetPrototype(thread_, proto); - JSHandle iter(NewJSObject(dynHandle)); + JSHandle hclassHandle(globalConst->GetHandledJSAPIListIteratorClass()); + hclassHandle->SetPrototype(thread_, proto); + JSHandle iter(NewJSObject(hclassHandle)); iter->GetJSHClass()->SetExtensible(true); iter->SetIteratedList(thread_, List->GetSingleList()); iter->SetNextIndex(0); @@ -3622,7 +3622,7 @@ JSHandle ObjectFactory::CreateIteratorResultInstanceClass() { auto globalConst = thread_->GlobalConstants(); JSHandle proto = vm_->GetGlobalEnv()->GetObjectFunctionPrototype(); - JSHandle iterResultClass = NewEcmaDynClass(JSObject::SIZE, JSType::JS_OBJECT, proto); + JSHandle iterResultClass = NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, proto); uint32_t fieldOrder = 0; JSHandle layoutInfoHandle = CreateLayoutInfo(2); // 2 means two field @@ -3650,20 +3650,20 @@ JSHandle ObjectFactory::CreateIteratorResultInstanceClass() return iterResultClass; } -TaggedObject *ObjectFactory::NewOldSpaceDynObject(const JSHandle &dynclass) +TaggedObject *ObjectFactory::NewOldSpaceObject(const JSHandle &hclass) { NewObjectHook(); - TaggedObject *header = heap_->AllocateOldOrHugeObject(*dynclass); - uint32_t inobjPropCount = dynclass->GetInlinedProperties(); + TaggedObject *header = heap_->AllocateOldOrHugeObject(*hclass); + uint32_t inobjPropCount = hclass->GetInlinedProperties(); if (inobjPropCount > 0) { - InitializeExtraProperties(dynclass, header, inobjPropCount); + InitializeExtraProperties(hclass, header, inobjPropCount); } return header; } JSHandle ObjectFactory::NewOldSpaceJSObject(const JSHandle &jshclass) { - JSHandle obj(thread_, JSObject::Cast(NewOldSpaceDynObject(jshclass))); + JSHandle obj(thread_, JSObject::Cast(NewOldSpaceObject(jshclass))); JSHandle emptyArray = EmptyArray(); obj->InitializeHash(); obj->SetElements(thread_, emptyArray); @@ -3679,7 +3679,7 @@ JSHandle ObjectFactory::NewOldSpaceTaggedArray(uint32_t length, JST JSHandle ObjectFactory::NewJSStableArrayWithElements(const JSHandle &elements) { JSHandle cls(thread_, - JSHandle::Cast(vm_->GetGlobalEnv()->GetArrayFunction())->GetProtoOrDynClass()); + JSHandle::Cast(vm_->GetGlobalEnv()->GetArrayFunction())->GetProtoOrHClass()); JSHandle array = JSHandle::Cast(NewJSObject(cls)); array->SetElements(thread_, elements); @@ -3694,8 +3694,8 @@ JSHandle ObjectFactory::NewJSAsyncGeneratorFunction(const JSHandle env = vm_->GetGlobalEnv(); - JSHandle dynclass = JSHandle::Cast(env->GetAsyncGeneratorFunctionClass()); - JSHandle asyncGeneratorFunc = JSHandle::Cast(NewJSObject(dynclass)); + JSHandle hclass = JSHandle::Cast(env->GetAsyncGeneratorFunctionClass()); + JSHandle asyncGeneratorFunc = JSHandle::Cast(NewJSObject(hclass)); JSFunction::InitializeJSFunction(thread_, asyncGeneratorFunc, FunctionKind::ASYNC_GENERATOR_FUNCTION); asyncGeneratorFunc->SetMethod(thread_, method); return asyncGeneratorFunc; diff --git a/ecmascript/object_factory.h b/ecmascript/object_factory.h index 0b64d3ec97..cc7cba6241 100644 --- a/ecmascript/object_factory.h +++ b/ecmascript/object_factory.h @@ -335,11 +335,11 @@ public: FreeObject *FillFreeObject(uintptr_t address, size_t size, RemoveSlots removeSlots = RemoveSlots::NO); - TaggedObject *NewDynObject(const JSHandle &dynclass); + TaggedObject *NewObject(const JSHandle &hclass); - TaggedObject *NewNonMovableDynObject(const JSHandle &dynclass, int inobjPropCount = 0); + TaggedObject *NewNonMovableObject(const JSHandle &hclass, int inobjPropCount = 0); - void InitializeExtraProperties(const JSHandle &dynclass, TaggedObject *obj, int inobjPropCount); + void InitializeExtraProperties(const JSHandle &hclass, TaggedObject *obj, int inobjPropCount); JSHandle NewTaggedQueue(uint32_t length); @@ -423,10 +423,10 @@ public: const JSHandle &objClass); JSHandle GetObjectLiteralHClass(const JSHandle &properties, size_t length); // only use for creating Function.prototype and Function - JSHandle NewJSFunctionByDynClass(const JSHandle &method, const JSHandle &clazz, + JSHandle NewJSFunctionByHClass(const JSHandle &method, const JSHandle &clazz, FunctionKind kind = FunctionKind::NORMAL_FUNCTION, MemSpaceType type = MemSpaceType::SEMI_SPACE); - JSHandle NewJSFunctionByDynClass(const void *func, const JSHandle &clazz, + JSHandle NewJSFunctionByHClass(const void *func, const JSHandle &clazz, FunctionKind kind = FunctionKind::NORMAL_FUNCTION); JSHandle NewJSMethod(const MethodLiteral *method); @@ -479,7 +479,7 @@ public: JSHandle NewJSObject(const JSHandle &jshclass); // used for creating jshclass in Builtins, Function, Class_Linker - JSHandle NewEcmaDynClass(uint32_t size, JSType type, const JSHandle &prototype); + JSHandle NewEcmaHClass(uint32_t size, JSType type, const JSHandle &prototype); // It is used to provide iterators for non ECMA standard jsapi containers. JSHandle NewJSAPIPlainArray(uint32_t capacity); @@ -545,7 +545,7 @@ public: // --------------------------------------old space object-------------------------------------------- JSHandle NewOldSpaceJSObject(const JSHandle &jshclass); - TaggedObject *NewOldSpaceDynObject(const JSHandle &dynclass); + TaggedObject *NewOldSpaceObject(const JSHandle &hclass); JSHandle NewOldSpaceTaggedArray(uint32_t length, JSTaggedValue initVal = JSTaggedValue::Hole()); // ---------------------------------New objects used internally-------------------------------------- @@ -571,13 +571,13 @@ private: void NewObjectHook() const; // used for creating jshclass in Builtins, Function, Class_Linker - JSHandle NewEcmaDynClass(uint32_t size, JSType type, + JSHandle NewEcmaHClass(uint32_t size, JSType type, uint32_t inlinedProps = JSHClass::DEFAULT_CAPACITY_OF_IN_OBJECTS); // used for creating jshclass in GlobalEnv, EcmaVM - JSHandle NewEcmaDynClassClass(JSHClass *hclass, uint32_t size, JSType type); - JSHandle NewEcmaDynClass(JSHClass *hclass, uint32_t size, JSType type, + JSHandle NewEcmaHClassClass(JSHClass *hclass, uint32_t size, JSType type); + JSHandle NewEcmaHClass(JSHClass *hclass, uint32_t size, JSType type, uint32_t inlinedProps = JSHClass::DEFAULT_CAPACITY_OF_IN_OBJECTS); - JSHandle NewEcmaReadOnlyDynClass(JSHClass *hclass, uint32_t size, JSType type, + JSHandle NewEcmaReadOnlyHClass(JSHClass *hclass, uint32_t size, JSType type, uint32_t inlinedProps = JSHClass::DEFAULT_CAPACITY_OF_IN_OBJECTS); JSHandle InitClassClass(); @@ -588,14 +588,14 @@ private: JSHandle NewFromASCIINonMovable(const CString &data); // used for creating Function - JSHandle NewJSFunction(const JSHandle &env, const JSHandle &dynKlass); + JSHandle NewJSFunction(const JSHandle &env, const JSHandle &hclass); JSHandle CreateObjectClass(const JSHandle &keys, const JSHandle &values); JSHandle CreateObjectClass(const JSHandle &properties, size_t length); JSHandle CreateFunctionClass(FunctionKind kind, uint32_t size, JSType type, const JSHandle &prototype); // used for creating ref.prototype in buildins, such as Number.prototype - JSHandle NewJSPrimitiveRef(const JSHandle &dynKlass, + JSHandle NewJSPrimitiveRef(const JSHandle &hclass, const JSHandle &object); JSHandle GetStringFromStringTable(const uint8_t *utf8Data, uint32_t utf8Len, bool canBeCompress) const; @@ -623,9 +623,9 @@ private: inline TaggedObject *AllocObjectWithSpaceType(size_t size, JSHClass *cls, MemSpaceType type); - friend class Builtins; // create builtins object need dynclass - friend class JSFunction; // create prototype_or_dynclass need dynclass - friend class JSHClass; // HC transition need dynclass + friend class Builtins; // create builtins object need hclass + friend class JSFunction; // create prototype_or_hclass need hclass + friend class JSHClass; // HC transition need hclass friend class EcmaVM; // hold the factory instance friend class JsVerificationTest; friend class PandaFileTranslator; @@ -639,8 +639,8 @@ private: class ClassLinkerFactory { private: - friend class GlobalEnv; // root class in class_linker need dynclass - friend class EcmaVM; // root class in class_linker need dynclass + friend class GlobalEnv; // root class in class_linker need hclass + friend class EcmaVM; // root class in class_linker need hclass }; } // namespace panda::ecmascript #endif // ECMASCRIPT_OBJECT_FACTORY_H diff --git a/ecmascript/runtime_call_id.h b/ecmascript/runtime_call_id.h index c5dd5a0d0e..cd8359c568 100644 --- a/ecmascript/runtime_call_id.h +++ b/ecmascript/runtime_call_id.h @@ -39,66 +39,66 @@ namespace panda::ecmascript { V(Ldfalse) \ V(Tonumber) \ V(Toboolean) \ - V(Add2Dyn) \ - V(Sub2Dyn) \ - V(Mul2Dyn) \ - V(Div2Dyn) \ - V(Mod2Dyn) \ - V(EqDyn) \ - V(NotEqDyn) \ - V(LessDyn) \ - V(LessEqDyn) \ - V(GreaterDyn) \ - V(GreaterEqDyn) \ - V(StrictNotEqDyn) \ - V(StrictEqDyn) \ - V(Shl2Dyn) \ - V(Shr2Dyn) \ - V(Ashr2Dyn) \ - V(And2Dyn) \ - V(Or2Dyn) \ - V(Xor2Dyn) \ - V(NegDyn) \ - V(NotDyn) \ - V(IncDyn) \ - V(DecDyn) \ - V(ExpDyn) \ - V(ThrowDyn) \ - V(LdObjByIndexDyn) \ - V(StObjByIndexDyn) \ - V(LdObjByNameDyn) \ - V(StObjByNameDyn) \ - V(LdObjByValueDyn) \ - V(StObjByValueDyn) \ - V(StOwnByNameDyn) \ - V(StOwnByIdDyn) \ - V(StOwnByValueDyn) \ + V(Add2) \ + V(Sub2) \ + V(Mul2) \ + V(Div2) \ + V(Mod2) \ + V(Eq) \ + V(NotEq) \ + V(Less) \ + V(LessEq) \ + V(Greater) \ + V(GreaterEq) \ + V(StrictNotEq) \ + V(StrictEq) \ + V(Shl2) \ + V(Shr2) \ + V(Ashr2) \ + V(And2) \ + V(Or2) \ + V(Xor2) \ + V(Neg) \ + V(Not) \ + V(Inc) \ + V(Dec) \ + V(Exp) \ + V(Throw) \ + V(LdObjByIndex) \ + V(StObjByIndex) \ + V(LdObjByName) \ + V(StObjByName) \ + V(LdObjByValue) \ + V(StObjByValue) \ + V(StOwnByName) \ + V(StOwnById) \ + V(StOwnByValue) \ V(Trygetobjprop) \ V(Delobjprop) \ V(Defineglobalvar) \ V(Definelocalvar) \ V(Definefuncexpr) \ - V(DefinefuncDyn) \ - V(DefineNCFuncDyn) \ - V(NewobjDynrange) \ - V(RefeqDyn) \ - V(TypeofDyn) \ - V(LdnewobjrangeDyn) \ - V(IsInDyn) \ - V(InstanceofDyn) \ - V(NewobjspreadDyn) \ - V(CallArg0Dyn) \ - V(CallArg1Dyn) \ - V(CallArg2Dyn) \ - V(CallArg3Dyn) \ - V(CallThisRangeDyn) \ - V(CallRangeDyn) \ - V(CallSpreadDyn) \ - V(NewlexenvDyn) \ - V(NewlexenvwithNameDyn) \ - V(StlexvarDyn) \ - V(LdlexvarDyn) \ - V(LdlexenvDyn) \ + V(Definefunc) \ + V(DefineNCFunc) \ + V(NewobjRange) \ + V(Refeq) \ + V(Typeof) \ + V(Ldnewobjrange) \ + V(IsIn) \ + V(Instanceof) \ + V(NewobjApply) \ + V(CallArg0) \ + V(CallArg1) \ + V(CallArg2) \ + V(CallArg3) \ + V(CallThisRange) \ + V(CallRange) \ + V(CallSpread) \ + V(Newlexenv) \ + V(NewlexenvwithName) \ + V(Stlexvar) \ + V(Ldlexvar) \ + V(Ldlexenv) \ V(GetPropIterator) \ V(CreateIterResultObj) \ V(DefineGeneratorFunc) \ @@ -160,7 +160,7 @@ namespace panda::ecmascript { V(FastGetPropertyByName) \ V(FastGetPropertyByValue) \ V(FastGetPropertyByIndex) \ - V(NewLexicalEnvDyn) \ + V(NewLexicalEnv) \ V(ExecuteNative) \ V(Execute) \ V(AsmExecute) \ @@ -175,7 +175,6 @@ namespace panda::ecmascript { V(getmodulenamespace) \ V(StModuleVar) \ V(LdModuleVar) \ - V(CopyModule) \ V(CreateRegExpWithLiteral) \ V(CreateArrayWithBuffer) \ V(GetNextPropName) \ @@ -198,7 +197,6 @@ namespace panda::ecmascript { V(LdSuperByValue) \ V(StSuperByValue) \ V(ThrowDeleteSuperProperty) \ - V(GetIteratorNext) \ V(ModWithTSType) \ V(MulWithTSType) \ V(SubWithTSType) \ @@ -214,11 +212,11 @@ namespace panda::ecmascript { V(EqualWithIC) \ V(NotEqualWithIC) \ V(Compare) \ - V(LessDynWithIC) \ - V(LessEqDynWithIC) \ - V(GreaterDynWithIC) \ + V(LessWithIC) \ + V(LessEqWithIC) \ + V(GreaterWithIC) \ V(SetPropertyByName) \ - V(GreaterEqDynWithIC) \ + V(GreaterEqWithIC) \ V(LdBigInt) \ V(Tonumeric) \ V(CreateAsyncGeneratorObj) \ @@ -307,7 +305,7 @@ namespace panda::ecmascript { V(Global, IsFinite) \ V(Global, IsNaN) \ V(Global, PrintEntryPoint) \ - V(Global, NewobjDynrange) \ + V(Global, NewobjRange) \ V(Global, CallJsBoundFunction) \ V(Global, CallJsProxy) \ V(Global, DecodeURI) \ diff --git a/ecmascript/stubs/runtime_stubs-inl.h b/ecmascript/stubs/runtime_stubs-inl.h index 12e8ea4a6a..aa32cc8dab 100644 --- a/ecmascript/stubs/runtime_stubs-inl.h +++ b/ecmascript/stubs/runtime_stubs-inl.h @@ -43,7 +43,7 @@ namespace panda::ecmascript { static constexpr size_t FIXED_NUM_ARGS = 3; -JSTaggedValue RuntimeStubs::RuntimeIncDyn(JSThread *thread, const JSHandle &value) +JSTaggedValue RuntimeStubs::RuntimeInc(JSThread *thread, const JSHandle &value) { JSHandle inputVal = JSTaggedValue::ToNumeric(thread, value); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); @@ -55,7 +55,7 @@ JSTaggedValue RuntimeStubs::RuntimeIncDyn(JSThread *thread, const JSHandle &value) +JSTaggedValue RuntimeStubs::RuntimeDec(JSThread *thread, const JSHandle &value) { JSHandle inputVal = JSTaggedValue::ToNumeric(thread, value); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); @@ -67,7 +67,7 @@ JSTaggedValue RuntimeStubs::RuntimeDecDyn(JSThread *thread, const JSHandle baseTag(thread, base); JSHandle exponentTag(thread, exponent); @@ -102,7 +102,7 @@ JSTaggedValue RuntimeStubs::RuntimeExpDyn(JSThread *thread, JSTaggedValue base, return JSTaggedValue(std::pow(doubleBase, doubleExponent)); } -JSTaggedValue RuntimeStubs::RuntimeIsInDyn(JSThread *thread, const JSHandle &prop, +JSTaggedValue RuntimeStubs::RuntimeIsIn(JSThread *thread, const JSHandle &prop, const JSHandle &obj) { if (!obj->IsECMAObject()) { @@ -115,7 +115,7 @@ JSTaggedValue RuntimeStubs::RuntimeIsInDyn(JSThread *thread, const JSHandle &obj, +JSTaggedValue RuntimeStubs::RuntimeInstanceof(JSThread *thread, const JSHandle &obj, const JSHandle &target) { bool ret = JSObject::InstanceOf(thread, obj, target); @@ -228,8 +228,7 @@ JSTaggedValue RuntimeStubs::RuntimeDelObjProp(JSThread *thread, const JSHandle &func, - const JSHandle &newTarget, +JSTaggedValue RuntimeStubs::RuntimeNewObjApply(JSThread *thread, const JSHandle &func, const JSHandle &array) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); @@ -245,7 +244,7 @@ JSTaggedValue RuntimeStubs::RuntimeNewObjSpreadDyn(JSThread *thread, const JSHan RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); } JSHandle undefined = thread->GlobalConstants()->GetHandledUndefined(); - EcmaRuntimeCallInfo *info = EcmaInterpreter::NewRuntimeCallInfo(thread, func, undefined, newTarget, length); + EcmaRuntimeCallInfo *info = EcmaInterpreter::NewRuntimeCallInfo(thread, func, undefined, func, length); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); info->SetCallArg(length, argsArray); return SlowRuntimeHelper::NewObject(info); @@ -602,7 +601,7 @@ JSTaggedValue RuntimeStubs::RuntimeStGlobalRecord(JSThread *thread, const JSHand return JSTaggedValue::True(); } -JSTaggedValue RuntimeStubs::RuntimeNegDyn(JSThread *thread, const JSHandle &value) +JSTaggedValue RuntimeStubs::RuntimeNeg(JSThread *thread, const JSHandle &value) { JSHandle inputVal = JSTaggedValue::ToNumeric(thread, value); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); @@ -624,7 +623,7 @@ JSTaggedValue RuntimeStubs::RuntimeNegDyn(JSThread *thread, const JSHandle &value) +JSTaggedValue RuntimeStubs::RuntimeNot(JSThread *thread, const JSHandle &value) { JSHandle inputVal = JSTaggedValue::ToNumeric(thread, value); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); @@ -986,7 +985,7 @@ JSTaggedValue RuntimeStubs::RuntimeGetIterator(JSThread *thread, const JSHandle< return EcmaInterpreter::Execute(info); } -void RuntimeStubs::RuntimeThrowDyn(JSThread *thread, JSTaggedValue value) +void RuntimeStubs::RuntimeThrow(JSThread *thread, JSTaggedValue value) { thread->SetException(value); } @@ -1120,7 +1119,7 @@ JSTaggedValue RuntimeStubs::RuntimeToNumeric(JSThread *thread, const JSHandle &left, +JSTaggedValue RuntimeStubs::RuntimeEq(JSThread *thread, const JSHandle &left, const JSHandle &right) { bool ret = JSTaggedValue::Equal(thread, left, right); @@ -1128,7 +1127,7 @@ JSTaggedValue RuntimeStubs::RuntimeEqDyn(JSThread *thread, const JSHandle &left, +JSTaggedValue RuntimeStubs::RuntimeNotEq(JSThread *thread, const JSHandle &left, const JSHandle &right) { bool ret = JSTaggedValue::Equal(thread, left, right); @@ -1136,7 +1135,7 @@ JSTaggedValue RuntimeStubs::RuntimeNotEqDyn(JSThread *thread, const JSHandle &left, +JSTaggedValue RuntimeStubs::RuntimeLess(JSThread *thread, const JSHandle &left, const JSHandle &right) { bool ret = JSTaggedValue::Compare(thread, left, right) == ComparisonResult::LESS; @@ -1144,7 +1143,7 @@ JSTaggedValue RuntimeStubs::RuntimeLessDyn(JSThread *thread, const JSHandle &left, +JSTaggedValue RuntimeStubs::RuntimeLessEq(JSThread *thread, const JSHandle &left, const JSHandle &right) { bool ret = JSTaggedValue::Compare(thread, left, right) <= ComparisonResult::EQUAL; @@ -1152,7 +1151,7 @@ JSTaggedValue RuntimeStubs::RuntimeLessEqDyn(JSThread *thread, const JSHandle &left, +JSTaggedValue RuntimeStubs::RuntimeGreater(JSThread *thread, const JSHandle &left, const JSHandle &right) { bool ret = JSTaggedValue::Compare(thread, left, right) == ComparisonResult::GREAT; @@ -1160,7 +1159,7 @@ JSTaggedValue RuntimeStubs::RuntimeGreaterDyn(JSThread *thread, const JSHandle &left, +JSTaggedValue RuntimeStubs::RuntimeGreaterEq(JSThread *thread, const JSHandle &left, const JSHandle &right) { ComparisonResult comparison = JSTaggedValue::Compare(thread, left, right); @@ -1169,7 +1168,7 @@ JSTaggedValue RuntimeStubs::RuntimeGreaterEqDyn(JSThread *thread, const JSHandle return (ret ? JSTaggedValue::True() : JSTaggedValue::False()); } -JSTaggedValue RuntimeStubs::RuntimeAdd2Dyn(JSThread *thread, const JSHandle &left, +JSTaggedValue RuntimeStubs::RuntimeAdd2(JSThread *thread, const JSHandle &left, const JSHandle &right) { if (left->IsString() && right->IsString()) { @@ -1209,7 +1208,7 @@ JSTaggedValue RuntimeStubs::RuntimeAdd2Dyn(JSThread *thread, const JSHandle &left, const JSHandle &right) { @@ -1239,7 +1238,7 @@ JSTaggedValue RuntimeStubs::RuntimeShl2Dyn(JSThread *thread, return JSTaggedValue(ret); } -JSTaggedValue RuntimeStubs::RuntimeShr2Dyn(JSThread *thread, const JSHandle &left, +JSTaggedValue RuntimeStubs::RuntimeShr2(JSThread *thread, const JSHandle &left, const JSHandle &right) { JSHandle valLeft = JSTaggedValue::ToNumeric(thread, left); @@ -1265,7 +1264,7 @@ JSTaggedValue RuntimeStubs::RuntimeShr2Dyn(JSThread *thread, const JSHandle &left, +JSTaggedValue RuntimeStubs::RuntimeSub2(JSThread *thread, const JSHandle &left, const JSHandle &right) { JSHandle valLeft = JSTaggedValue::ToNumeric(thread, left); @@ -1285,7 +1284,7 @@ JSTaggedValue RuntimeStubs::RuntimeSub2Dyn(JSThread *thread, const JSHandle &left, +JSTaggedValue RuntimeStubs::RuntimeMul2(JSThread *thread, const JSHandle &left, const JSHandle &right) { JSHandle valLeft = JSTaggedValue::ToNumeric(thread, left); @@ -1307,7 +1306,7 @@ JSTaggedValue RuntimeStubs::RuntimeMul2Dyn(JSThread *thread, const JSHandle &left, +JSTaggedValue RuntimeStubs::RuntimeDiv2(JSThread *thread, const JSHandle &left, const JSHandle &right) { JSHandle valLeft = JSTaggedValue::ToNumeric(thread, left); @@ -1335,7 +1334,7 @@ JSTaggedValue RuntimeStubs::RuntimeDiv2Dyn(JSThread *thread, const JSHandle &left, +JSTaggedValue RuntimeStubs::RuntimeMod2(JSThread *thread, const JSHandle &left, const JSHandle &right) { JSHandle valLeft = JSTaggedValue::ToNumeric(thread, left); @@ -1364,7 +1363,7 @@ JSTaggedValue RuntimeStubs::RuntimeMod2Dyn(JSThread *thread, const JSHandle &left, +JSTaggedValue RuntimeStubs::RuntimeAshr2(JSThread *thread, const JSHandle &left, const JSHandle &right) { JSHandle valLeft = JSTaggedValue::ToNumeric(thread, left); @@ -1390,7 +1389,7 @@ JSTaggedValue RuntimeStubs::RuntimeAshr2Dyn(JSThread *thread, const JSHandle &left, +JSTaggedValue RuntimeStubs::RuntimeAnd2(JSThread *thread, const JSHandle &left, const JSHandle &right) { JSHandle valLeft = JSTaggedValue::ToNumeric(thread, left); @@ -1416,7 +1415,7 @@ JSTaggedValue RuntimeStubs::RuntimeAnd2Dyn(JSThread *thread, const JSHandle(ret)); } -JSTaggedValue RuntimeStubs::RuntimeOr2Dyn(JSThread *thread, const JSHandle &left, +JSTaggedValue RuntimeStubs::RuntimeOr2(JSThread *thread, const JSHandle &left, const JSHandle &right) { JSHandle valLeft = JSTaggedValue::ToNumeric(thread, left); @@ -1442,7 +1441,7 @@ JSTaggedValue RuntimeStubs::RuntimeOr2Dyn(JSThread *thread, const JSHandle(ret)); } -JSTaggedValue RuntimeStubs::RuntimeXor2Dyn(JSThread *thread, const JSHandle &left, +JSTaggedValue RuntimeStubs::RuntimeXor2(JSThread *thread, const JSHandle &left, const JSHandle &right) { JSHandle valLeft = JSTaggedValue::ToNumeric(thread, left); @@ -1545,7 +1544,7 @@ JSTaggedValue RuntimeStubs::RuntimeCreateObjectWithBuffer(JSThread *thread, Obje return objLiteral.GetTaggedValue(); } -JSTaggedValue RuntimeStubs::RuntimeNewLexicalEnvDyn(JSThread *thread, uint16_t numVars) +JSTaggedValue RuntimeStubs::RuntimeNewLexicalEnv(JSThread *thread, uint16_t numVars) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); JSHandle newEnv = factory->NewLexicalEnv(numVars); @@ -1557,7 +1556,7 @@ JSTaggedValue RuntimeStubs::RuntimeNewLexicalEnvDyn(JSThread *thread, uint16_t n return newEnv.GetTaggedValue(); } -JSTaggedValue RuntimeStubs::RuntimeNewObjDynRange(JSThread *thread, const JSHandle &func, +JSTaggedValue RuntimeStubs::RuntimeNewObjRange(JSThread *thread, const JSHandle &func, const JSHandle &newTarget, uint16_t firstArgIdx, uint16_t length) { JSHandle preArgs(thread, JSTaggedValue::Undefined()); @@ -1573,15 +1572,16 @@ JSTaggedValue RuntimeStubs::RuntimeNewObjDynRange(JSThread *thread, const JSHand return tagged; } -JSTaggedValue RuntimeStubs::RuntimeDefinefuncDyn(JSThread *thread, const JSHandle &funcHandle) +JSTaggedValue RuntimeStubs::RuntimeDefinefunc(JSThread *thread, const JSHandle &funcHandle) { JSHandle method(thread, funcHandle->GetMethod()); + FunctionKind kind = funcHandle->GetFunctionKind(); JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHandle dynclass = JSHandle::Cast(env->GetFunctionClassWithProto()); - JSHandle jsFunc = factory->NewJSFunctionByDynClass(method, dynclass, FunctionKind::BASE_CONSTRUCTOR); + JSHandle hclass = JSHandle::Cast(env->GetFunctionClassWithProto()); + JSHandle jsFunc = factory->NewJSFunctionByHClass(method, hclass, kind); jsFunc->SetCodeEntry(funcHandle->GetCodeEntry()); ASSERT_NO_ABRUPT_COMPLETION(thread); return jsFunc.GetTaggedValue(); @@ -1669,14 +1669,14 @@ JSTaggedValue RuntimeStubs::RuntimeCreateObjectWithExcludedKeys(JSThread *thread return restObj.GetTaggedValue(); } -JSTaggedValue RuntimeStubs::RuntimeDefineNCFuncDyn(JSThread *thread, const JSHandle &funcHandle) +JSTaggedValue RuntimeStubs::RuntimeDefineNCFunc(JSThread *thread, const JSHandle &funcHandle) { JSHandle method(thread, funcHandle->GetMethod()); JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHandle dynclass = JSHandle::Cast(env->GetFunctionClassWithoutProto()); - JSHandle jsFunc = factory->NewJSFunctionByDynClass(method, dynclass, FunctionKind::ARROW_FUNCTION); + JSHandle hclass = JSHandle::Cast(env->GetFunctionClassWithoutProto()); + JSHandle jsFunc = factory->NewJSFunctionByHClass(method, hclass, FunctionKind::ARROW_FUNCTION); ASSERT_NO_ABRUPT_COMPLETION(thread); jsFunc->SetCodeEntry(funcHandle->GetCodeEntry()); return jsFunc.GetTaggedValue(); @@ -1698,7 +1698,7 @@ JSTaggedValue RuntimeStubs::RuntimeDefineGeneratorFunc(JSThread *thread, const J JSHandle initialGeneratorFuncPrototype = factory->NewJSObjectByConstructor(objFun); JSObject::SetPrototype(thread, initialGeneratorFuncPrototype, env->GetGeneratorPrototype()); ASSERT_NO_ABRUPT_COMPLETION(thread); - jsFunc->SetProtoOrDynClass(thread, initialGeneratorFuncPrototype); + jsFunc->SetProtoOrHClass(thread, initialGeneratorFuncPrototype); jsFunc->SetCodeEntry(funcHandle->GetCodeEntry()); return jsFunc.GetTaggedValue(); } @@ -1719,7 +1719,7 @@ JSTaggedValue RuntimeStubs::RuntimeDefineAsyncGeneratorFunc(JSThread *thread, co JSHandle initialGeneratorFuncPrototype = factory->NewJSObjectByConstructor(objFun); JSObject::SetPrototype(thread, initialGeneratorFuncPrototype, env->GetAsyncGeneratorPrototype()); ASSERT_NO_ABRUPT_COMPLETION(thread); - jsFunc->SetProtoOrDynClass(thread, initialGeneratorFuncPrototype); + jsFunc->SetProtoOrHClass(thread, initialGeneratorFuncPrototype); return jsFunc.GetTaggedValue(); } @@ -1730,8 +1730,8 @@ JSTaggedValue RuntimeStubs::RuntimeDefineAsyncFunc(JSThread *thread, const JSHan JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHandle dynclass = JSHandle::Cast(env->GetAsyncFunctionClass()); - JSHandle jsFunc = factory->NewJSFunctionByDynClass(method, dynclass, FunctionKind::ASYNC_FUNCTION); + JSHandle hclass = JSHandle::Cast(env->GetAsyncFunctionClass()); + JSHandle jsFunc = factory->NewJSFunctionByHClass(method, hclass, FunctionKind::ASYNC_FUNCTION); ASSERT_NO_ABRUPT_COMPLETION(thread); jsFunc->SetCodeEntry(funcHandle->GetCodeEntry()); return jsFunc.GetTaggedValue(); @@ -1745,15 +1745,15 @@ JSTaggedValue RuntimeStubs::RuntimeDefineMethod(JSThread *thread, const JSHandle JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHandle dynclass = JSHandle::Cast(env->GetFunctionClassWithoutProto()); - JSHandle jsFunc = factory->NewJSFunctionByDynClass(method, dynclass, FunctionKind::NORMAL_FUNCTION); + JSHandle hclass = JSHandle::Cast(env->GetFunctionClassWithoutProto()); + JSHandle jsFunc = factory->NewJSFunctionByHClass(method, hclass, FunctionKind::NORMAL_FUNCTION); jsFunc->SetHomeObject(thread, homeObject); ASSERT_NO_ABRUPT_COMPLETION(thread); jsFunc->SetCodeEntry(funcHandle->GetCodeEntry()); return jsFunc.GetTaggedValue(); } -JSTaggedValue RuntimeStubs::RuntimeCallSpreadDyn(JSThread *thread, +JSTaggedValue RuntimeStubs::RuntimeCallSpread(JSThread *thread, const JSHandle &func, const JSHandle &obj, const JSHandle &array) @@ -1914,7 +1914,7 @@ JSTaggedValue RuntimeStubs::RuntimeLdBigInt(JSThread *thread, const JSHandleGetEcmaVM()->GetFactory(); JSHandle newEnv = factory->NewLexicalEnv(numVars); @@ -1980,7 +1980,7 @@ JSTaggedValue RuntimeStubs::RuntimeGetUnmapedJSArgumentObj(JSThread *thread, con return obj.GetTaggedValue(); } -JSTaggedValue RuntimeStubs::RuntimeOptNewLexicalEnvDyn(JSThread *thread, uint16_t numVars, +JSTaggedValue RuntimeStubs::RuntimeOptNewLexicalEnv(JSThread *thread, uint16_t numVars, JSHandle ¤tLexEnv) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); @@ -1993,7 +1993,7 @@ JSTaggedValue RuntimeStubs::RuntimeOptNewLexicalEnvDyn(JSThread *thread, uint16_ return taggedEnv; } -JSTaggedValue RuntimeStubs::RuntimeOptNewLexicalEnvWithNameDyn(JSThread *thread, uint16_t numVars, uint16_t scopeId, +JSTaggedValue RuntimeStubs::RuntimeOptNewLexicalEnvWithName(JSThread *thread, uint16_t numVars, uint16_t scopeId, JSHandle ¤tLexEnv, JSHandle &func) { @@ -2210,7 +2210,7 @@ JSTaggedValue RuntimeStubs::RuntimeOptConstructGeneric(JSThread *thread, JSHandl return obj.GetTaggedValue(); } -JSTaggedValue RuntimeStubs::RuntimeOptNewObjDynRange(JSThread *thread, uintptr_t argv, uint32_t argc) +JSTaggedValue RuntimeStubs::RuntimeOptNewObjRange(JSThread *thread, uintptr_t argv, uint32_t argc) { JSHandle ctor = GetHArg(argv, argc, 0); JSHandle newTgt = GetHArg(argv, argc, 1); @@ -2248,7 +2248,7 @@ JSTaggedValue RuntimeStubs::RuntimeOptNewObjWithIHClass(JSThread *thread, uintpt thread->GlobalConstants()->GetHandledPrototypeString()).GetValue(); ihc->SetProto(thread, ctorPrototype); - ctor->SetProtoOrDynClass(thread, ihc); + ctor->SetProtoOrHClass(thread, ihc); const size_t numCtorAndNewTgt = 2; const size_t numCtorNewTgtAndIHCIndex = 3; diff --git a/ecmascript/stubs/runtime_stubs.cpp b/ecmascript/stubs/runtime_stubs.cpp index 6d037b8e13..c04a652939 100644 --- a/ecmascript/stubs/runtime_stubs.cpp +++ b/ecmascript/stubs/runtime_stubs.cpp @@ -290,13 +290,13 @@ DEF_RUNTIME_STUBS(TaggedArraySetValue) return JSTaggedValue::Undefined().GetRawData(); } -DEF_RUNTIME_STUBS(NewEcmaDynClass) +DEF_RUNTIME_STUBS(NewEcmaHClass) { - RUNTIME_STUBS_HEADER(NewEcmaDynClass); + RUNTIME_STUBS_HEADER(NewEcmaHClass); JSTaggedValue size = GetArg(argv, argc, 0); // 0: means the zeroth parameter JSTaggedValue type = GetArg(argv, argc, 1); // 1: means the first parameter JSTaggedValue inlinedProps = GetArg(argv, argc, 2); // 2: means the second parameter - return (thread->GetEcmaVM()->GetFactory()->NewEcmaDynClass( + return (thread->GetEcmaVM()->GetFactory()->NewEcmaHClass( size.GetInt(), JSType(type.GetInt()), inlinedProps.GetInt())).GetTaggedValue().GetRawData(); } @@ -327,7 +327,7 @@ DEF_RUNTIME_STUBS(UpdateLayOutAndAddTransition) layoutInfoHandle->AddKey(thread, offset, keyHandle.GetTaggedValue(), attrValue); } - // 5. Add newDynclass to old dynclass's transitions. + // 5. Add newClass to old hclass's transitions. JSHClass::AddTransitions(thread, oldHClassHandle, newHClassHandle, keyHandle, attrValue); return JSTaggedValue::Hole().GetRawData(); } @@ -364,23 +364,23 @@ DEF_RUNTIME_STUBS(NoticeThroughChainAndRefreshUser) return JSTaggedValue::Hole().GetRawData(); } -DEF_RUNTIME_STUBS(IncDyn) +DEF_RUNTIME_STUBS(Inc) { - RUNTIME_STUBS_HEADER(IncDyn); + RUNTIME_STUBS_HEADER(Inc); JSHandle value = GetHArg(argv, argc, 0); // 0: means the zeroth parameter - return RuntimeIncDyn(thread, value).GetRawData(); + return RuntimeInc(thread, value).GetRawData(); } -DEF_RUNTIME_STUBS(DecDyn) +DEF_RUNTIME_STUBS(Dec) { - RUNTIME_STUBS_HEADER(DecDyn); + RUNTIME_STUBS_HEADER(Dec); JSHandle value = GetHArg(argv, argc, 0); // 0: means the zeroth parameter - return RuntimeDecDyn(thread, value).GetRawData(); + return RuntimeDec(thread, value).GetRawData(); } -DEF_RUNTIME_STUBS(ExpDyn) +DEF_RUNTIME_STUBS(Exp) { - RUNTIME_STUBS_HEADER(ExpDyn); + RUNTIME_STUBS_HEADER(Exp); JSTaggedValue baseValue = GetArg(argv, argc, 0); // 0: means the zeroth parameter JSTaggedValue exponentValue = GetArg(argv, argc, 1); // 1: means the first parameter @@ -406,24 +406,24 @@ DEF_RUNTIME_STUBS(ExpDyn) return JSTaggedValue(std::pow(doubleBase, doubleExponent)).GetRawData(); } // Slow path - JSTaggedValue res = RuntimeExpDyn(thread, baseValue, exponentValue); + JSTaggedValue res = RuntimeExp(thread, baseValue, exponentValue); return res.GetRawData(); } -DEF_RUNTIME_STUBS(IsInDyn) +DEF_RUNTIME_STUBS(IsIn) { - RUNTIME_STUBS_HEADER(IsInDyn); + RUNTIME_STUBS_HEADER(IsIn); JSHandle prop = GetHArg(argv, argc, 0); // 0: means the zeroth parameter JSHandle obj = GetHArg(argv, argc, 1); // 1: means the first parameter - return RuntimeIsInDyn(thread, prop, obj).GetRawData(); + return RuntimeIsIn(thread, prop, obj).GetRawData(); } -DEF_RUNTIME_STUBS(InstanceOfDyn) +DEF_RUNTIME_STUBS(InstanceOf) { - RUNTIME_STUBS_HEADER(InstanceOfDyn); + RUNTIME_STUBS_HEADER(InstanceOf); JSHandle obj = GetHArg(argv, argc, 0); // 0: means the zeroth parameter JSHandle target = GetHArg(argv, argc, 1); // 1: means the first parameter - return RuntimeInstanceofDyn(thread, obj, target).GetRawData(); + return RuntimeInstanceof(thread, obj, target).GetRawData(); } DEF_RUNTIME_STUBS(FastStrictNotEqual) @@ -492,11 +492,6 @@ DEF_RUNTIME_STUBS(CloseIterator) return RuntimeCloseIterator(thread, iter).GetRawData(); } -DEF_RUNTIME_STUBS(CopyModule) -{ - return JSTaggedValue::Hole().GetRawData(); -} - DEF_RUNTIME_STUBS(SuperCallSpread) { RUNTIME_STUBS_HEADER(SuperCallSpread); @@ -524,13 +519,12 @@ DEF_RUNTIME_STUBS(DelObjProp) return RuntimeDelObjProp(thread, obj, prop).GetRawData(); } -DEF_RUNTIME_STUBS(NewObjSpreadDyn) +DEF_RUNTIME_STUBS(NewObjApply) { - RUNTIME_STUBS_HEADER(NewObjSpreadDyn); + RUNTIME_STUBS_HEADER(NewObjApply); JSHandle func = GetHArg(argv, argc, 0); // 0: means the zeroth parameter - JSHandle newTarget = GetHArg(argv, argc, 1); // 1: means the first parameter - JSHandle array = GetHArg(argv, argc, 2); // 2: means the second parameter - return RuntimeNewObjSpreadDyn(thread, func, newTarget, array).GetRawData(); + JSHandle array = GetHArg(argv, argc, 1); + return RuntimeNewObjApply(thread, func, array).GetRawData(); } DEF_RUNTIME_STUBS(CreateIterResultObj) @@ -719,77 +713,77 @@ DEF_RUNTIME_STUBS(StGlobalRecord) return RuntimeStGlobalRecord(thread, prop, value, isConst.IsTrue()).GetRawData(); } -DEF_RUNTIME_STUBS(NegDyn) +DEF_RUNTIME_STUBS(Neg) { - RUNTIME_STUBS_HEADER(NegDyn); + RUNTIME_STUBS_HEADER(Neg); JSHandle value = GetHArg(argv, argc, 0); // 0: means the zeroth parameter - return RuntimeNegDyn(thread, value).GetRawData(); + return RuntimeNeg(thread, value).GetRawData(); } -DEF_RUNTIME_STUBS(NotDyn) +DEF_RUNTIME_STUBS(Not) { - RUNTIME_STUBS_HEADER(NotDyn); + RUNTIME_STUBS_HEADER(Not); JSHandle value = GetHArg(argv, argc, 0); // 0: means the zeroth parameter - return RuntimeNotDyn(thread, value).GetRawData(); + return RuntimeNot(thread, value).GetRawData(); } -DEF_RUNTIME_STUBS(Shl2Dyn) +DEF_RUNTIME_STUBS(Shl2) { - RUNTIME_STUBS_HEADER(Shl2Dyn); + RUNTIME_STUBS_HEADER(Shl2); JSTaggedValue left = GetArg(argv, argc, 0); // 0: means the zeroth parameter JSTaggedValue right = GetArg(argv, argc, 1); // 1: means the first parameter - auto res = SlowRuntimeStub::Shl2Dyn(thread, left, right); + auto res = SlowRuntimeStub::Shl2(thread, left, right); return JSTaggedValue(res).GetRawData(); } -DEF_RUNTIME_STUBS(Shr2Dyn) +DEF_RUNTIME_STUBS(Shr2) { - RUNTIME_STUBS_HEADER(Shr2Dyn); + RUNTIME_STUBS_HEADER(Shr2); JSTaggedValue left = GetArg(argv, argc, 0); // 0: means the zeroth parameter JSTaggedValue right = GetArg(argv, argc, 1); // 1: means the first parameter - auto res = SlowRuntimeStub::Shr2Dyn(thread, left, right); + auto res = SlowRuntimeStub::Shr2(thread, left, right); return JSTaggedValue(res).GetRawData(); } -DEF_RUNTIME_STUBS(Ashr2Dyn) +DEF_RUNTIME_STUBS(Ashr2) { - RUNTIME_STUBS_HEADER(Ashr2Dyn); + RUNTIME_STUBS_HEADER(Ashr2); JSTaggedValue left = GetArg(argv, argc, 0); // 0: means the zeroth parameter JSTaggedValue right = GetArg(argv, argc, 1); // 1: means the first parameter - auto res = SlowRuntimeStub::Ashr2Dyn(thread, left, right); + auto res = SlowRuntimeStub::Ashr2(thread, left, right); return JSTaggedValue(res).GetRawData(); } -DEF_RUNTIME_STUBS(And2Dyn) +DEF_RUNTIME_STUBS(And2) { - RUNTIME_STUBS_HEADER(And2Dyn); + RUNTIME_STUBS_HEADER(And2); JSTaggedValue left = GetArg(argv, argc, 0); // 0: means the zeroth parameter JSTaggedValue right = GetArg(argv, argc, 1); // 1: means the first parameter - auto res = SlowRuntimeStub::And2Dyn(thread, left, right); + auto res = SlowRuntimeStub::And2(thread, left, right); return JSTaggedValue(res).GetRawData(); } -DEF_RUNTIME_STUBS(Xor2Dyn) +DEF_RUNTIME_STUBS(Xor2) { - RUNTIME_STUBS_HEADER(Xor2Dyn); + RUNTIME_STUBS_HEADER(Xor2); JSTaggedValue left = GetArg(argv, argc, 0); // 0: means the zeroth parameter JSTaggedValue right = GetArg(argv, argc, 1); // 1: means the first parameter - auto res = SlowRuntimeStub::Xor2Dyn(thread, left, right); + auto res = SlowRuntimeStub::Xor2(thread, left, right); return JSTaggedValue(res).GetRawData(); } -DEF_RUNTIME_STUBS(Or2Dyn) +DEF_RUNTIME_STUBS(Or2) { - RUNTIME_STUBS_HEADER(Or2Dyn); + RUNTIME_STUBS_HEADER(Or2); JSTaggedValue left = GetArg(argv, argc, 0); // 0: means the zeroth parameter JSTaggedValue right = GetArg(argv, argc, 1); // 1: means the first parameter - auto res = SlowRuntimeStub::Or2Dyn(thread, left, right); + auto res = SlowRuntimeStub::Or2(thread, left, right); return JSTaggedValue(res).GetRawData(); } @@ -1020,11 +1014,11 @@ DEF_RUNTIME_STUBS(GetIterator) return RuntimeGetIterator(thread, obj).GetRawData(); } -DEF_RUNTIME_STUBS(ThrowDyn) +DEF_RUNTIME_STUBS(Throw) { - RUNTIME_STUBS_HEADER(ThrowDyn); + RUNTIME_STUBS_HEADER(Throw); JSTaggedValue value = GetArg(argv, argc, 0); // 0: means the zeroth parameter - RuntimeThrowDyn(thread, value); + RuntimeThrow(thread, value); return JSTaggedValue::Hole().GetRawData(); } @@ -1180,93 +1174,93 @@ DEF_RUNTIME_STUBS(ToBoolean) return JSTaggedValue(result).GetRawData(); } -DEF_RUNTIME_STUBS(EqDyn) +DEF_RUNTIME_STUBS(Eq) { - RUNTIME_STUBS_HEADER(EqDyn); + RUNTIME_STUBS_HEADER(Eq); JSHandle left = GetHArg(argv, argc, 0); // 0: means the zeroth parameter JSHandle right = GetHArg(argv, argc, 1); // 1: means the first parameter - return RuntimeEqDyn(thread, left, right).GetRawData(); + return RuntimeEq(thread, left, right).GetRawData(); } -DEF_RUNTIME_STUBS(NotEqDyn) +DEF_RUNTIME_STUBS(NotEq) { - RUNTIME_STUBS_HEADER(NotEqDyn); + RUNTIME_STUBS_HEADER(NotEq); JSHandle left = GetHArg(argv, argc, 0); // 0: means the zeroth parameter JSHandle right = GetHArg(argv, argc, 1); // 1: means the first parameter - return RuntimeNotEqDyn(thread, left, right).GetRawData(); + return RuntimeNotEq(thread, left, right).GetRawData(); } -DEF_RUNTIME_STUBS(LessDyn) +DEF_RUNTIME_STUBS(Less) { - RUNTIME_STUBS_HEADER(LessDyn); + RUNTIME_STUBS_HEADER(Less); JSHandle left = GetHArg(argv, argc, 0); // 0: means the zeroth parameter JSHandle right = GetHArg(argv, argc, 1); // 1: means the first parameter - return RuntimeLessDyn(thread, left, right).GetRawData(); + return RuntimeLess(thread, left, right).GetRawData(); } -DEF_RUNTIME_STUBS(LessEqDyn) +DEF_RUNTIME_STUBS(LessEq) { - RUNTIME_STUBS_HEADER(LessEqDyn); + RUNTIME_STUBS_HEADER(LessEq); JSHandle left = GetHArg(argv, argc, 0); // 0: means the zeroth parameter JSHandle right = GetHArg(argv, argc, 1); // 1: means the first parameter - return RuntimeLessEqDyn(thread, left, right).GetRawData(); + return RuntimeLessEq(thread, left, right).GetRawData(); } -DEF_RUNTIME_STUBS(GreaterDyn) +DEF_RUNTIME_STUBS(Greater) { - RUNTIME_STUBS_HEADER(GreaterDyn); + RUNTIME_STUBS_HEADER(Greater); JSHandle left = GetHArg(argv, argc, 0); // 0: means the zeroth parameter JSHandle right = GetHArg(argv, argc, 1); // 1: means the first parameter - return RuntimeGreaterDyn(thread, left, right).GetRawData(); + return RuntimeGreater(thread, left, right).GetRawData(); } -DEF_RUNTIME_STUBS(GreaterEqDyn) +DEF_RUNTIME_STUBS(GreaterEq) { - RUNTIME_STUBS_HEADER(GreaterEqDyn); + RUNTIME_STUBS_HEADER(GreaterEq); JSHandle left = GetHArg(argv, argc, 0); // 0: means the zeroth parameter JSHandle right = GetHArg(argv, argc, 1); // 1: means the first parameter - return RuntimeGreaterEqDyn(thread, left, right).GetRawData(); + return RuntimeGreaterEq(thread, left, right).GetRawData(); } -DEF_RUNTIME_STUBS(Add2Dyn) +DEF_RUNTIME_STUBS(Add2) { - RUNTIME_STUBS_HEADER(Add2Dyn); + RUNTIME_STUBS_HEADER(Add2); JSHandle left = GetHArg(argv, argc, 0); // 0: means the zeroth parameter JSHandle right = GetHArg(argv, argc, 1); // 1: means the first parameter - JSTaggedValue res = RuntimeAdd2Dyn(thread, left, right); + JSTaggedValue res = RuntimeAdd2(thread, left, right); return res.GetRawData(); } -DEF_RUNTIME_STUBS(Sub2Dyn) +DEF_RUNTIME_STUBS(Sub2) { - RUNTIME_STUBS_HEADER(Sub2Dyn); + RUNTIME_STUBS_HEADER(Sub2); JSHandle left = GetHArg(argv, argc, 0); // 0: means the zeroth parameter JSHandle right = GetHArg(argv, argc, 1); // 1: means the first parameter - return RuntimeSub2Dyn(thread, left, right).GetRawData(); + return RuntimeSub2(thread, left, right).GetRawData(); } -DEF_RUNTIME_STUBS(Mul2Dyn) +DEF_RUNTIME_STUBS(Mul2) { - RUNTIME_STUBS_HEADER(Mul2Dyn); + RUNTIME_STUBS_HEADER(Mul2); JSHandle left = GetHArg(argv, argc, 0); // 0: means the zeroth parameter JSHandle right = GetHArg(argv, argc, 1); // 1: means the first parameter - return RuntimeMul2Dyn(thread, left, right).GetRawData(); + return RuntimeMul2(thread, left, right).GetRawData(); } -DEF_RUNTIME_STUBS(Div2Dyn) +DEF_RUNTIME_STUBS(Div2) { - RUNTIME_STUBS_HEADER(Div2Dyn); + RUNTIME_STUBS_HEADER(Div2); JSHandle left = GetHArg(argv, argc, 0); // 0: means the zeroth parameter JSHandle right = GetHArg(argv, argc, 1); // 1: means the first parameter - return RuntimeDiv2Dyn(thread, left, right).GetRawData(); + return RuntimeDiv2(thread, left, right).GetRawData(); } -DEF_RUNTIME_STUBS(Mod2Dyn) +DEF_RUNTIME_STUBS(Mod2) { - RUNTIME_STUBS_HEADER(Mod2Dyn); + RUNTIME_STUBS_HEADER(Mod2); JSHandle left = GetHArg(argv, argc, 0); // 0: means the zeroth parameter JSHandle right = GetHArg(argv, argc, 1); // 1: means the first parameter - return RuntimeMod2Dyn(thread, left, right).GetRawData(); + return RuntimeMod2(thread, left, right).GetRawData(); } DEF_RUNTIME_STUBS(LoadValueFromConstantStringTable) @@ -1379,11 +1373,11 @@ DEF_RUNTIME_STUBS(CreateObjectWithBuffer) return RuntimeCreateObjectWithBuffer(thread, factory, argObj).GetRawData(); } -DEF_RUNTIME_STUBS(NewLexicalEnvDyn) +DEF_RUNTIME_STUBS(NewLexicalEnv) { - RUNTIME_STUBS_HEADER(NewLexicalEnvDyn); + RUNTIME_STUBS_HEADER(NewLexicalEnv); JSTaggedValue numVars = GetArg(argv, argc, 0); // 0: means the zeroth parameter - return RuntimeNewLexicalEnvDyn(thread, static_cast(numVars.GetInt())).GetRawData(); + return RuntimeNewLexicalEnv(thread, static_cast(numVars.GetInt())).GetRawData(); } DEF_RUNTIME_STUBS(NewThisObject) @@ -1397,22 +1391,22 @@ DEF_RUNTIME_STUBS(NewThisObject) return obj.GetTaggedType(); // state is not set here } -DEF_RUNTIME_STUBS(NewObjDynRange) +DEF_RUNTIME_STUBS(NewObjRange) { - RUNTIME_STUBS_HEADER(NewObjDynRange); + RUNTIME_STUBS_HEADER(NewObjRange); JSHandle func = GetHArg(argv, argc, 0); // 0: means the zeroth parameter JSHandle newTarget = GetHArg(argv, argc, 1); // 1: means the first parameter JSTaggedValue firstArgIdx = GetArg(argv, argc, 2); // 2: means the second parameter JSTaggedValue length = GetArg(argv, argc, 3); // 3: means the third parameter - return RuntimeNewObjDynRange(thread, func, newTarget, static_cast(firstArgIdx.GetInt()), + return RuntimeNewObjRange(thread, func, newTarget, static_cast(firstArgIdx.GetInt()), static_cast(length.GetInt())).GetRawData(); } -DEF_RUNTIME_STUBS(DefinefuncDyn) +DEF_RUNTIME_STUBS(Definefunc) { - RUNTIME_STUBS_HEADER(DefinefuncDyn); + RUNTIME_STUBS_HEADER(Definefunc); JSHandle func = GetHArg(argv, argc, 0); // 0: means the zeroth parameter - return RuntimeDefinefuncDyn(thread, func).GetRawData(); + return RuntimeDefinefunc(thread, func).GetRawData(); } DEF_RUNTIME_STUBS(CreateRegExpWithLiteral) @@ -1451,11 +1445,11 @@ DEF_RUNTIME_STUBS(CreateObjectWithExcludedKeys) static_cast(firstArgRegIdx.GetInt())).GetRawData(); } -DEF_RUNTIME_STUBS(DefineNCFuncDyn) +DEF_RUNTIME_STUBS(DefineNCFunc) { - RUNTIME_STUBS_HEADER(DefineNCFuncDyn); + RUNTIME_STUBS_HEADER(DefineNCFunc); JSHandle func = GetHArg(argv, argc, 0); // 0: means the zeroth parameter - return RuntimeDefineNCFuncDyn(thread, func).GetRawData(); + return RuntimeDefineNCFunc(thread, func).GetRawData(); } DEF_RUNTIME_STUBS(DefineGeneratorFunc) @@ -1487,13 +1481,13 @@ DEF_RUNTIME_STUBS(DefineMethod) return RuntimeDefineMethod(thread, func, homeObject).GetRawData(); } -DEF_RUNTIME_STUBS(CallSpreadDyn) +DEF_RUNTIME_STUBS(CallSpread) { - RUNTIME_STUBS_HEADER(CallSpreadDyn); + RUNTIME_STUBS_HEADER(CallSpread); JSHandle func = GetHArg(argv, argc, 0); // 0: means the zeroth parameter JSHandle obj = GetHArg(argv, argc, 1); // 1: means the first parameter JSHandle array = GetHArg(argv, argc, 2); // 2: means the second parameter - return RuntimeCallSpreadDyn(thread, func, obj, array).GetRawData(); + return RuntimeCallSpread(thread, func, obj, array).GetRawData(); } DEF_RUNTIME_STUBS(DefineGetterSetterByValue) @@ -1627,12 +1621,12 @@ DEF_RUNTIME_STUBS(ToNumeric) return RuntimeToNumeric(thread, value).GetRawData(); } -DEF_RUNTIME_STUBS(NewLexicalEnvWithNameDyn) +DEF_RUNTIME_STUBS(NewLexicalEnvWithName) { - RUNTIME_STUBS_HEADER(NewLexicalEnvWithNameDyn); + RUNTIME_STUBS_HEADER(NewLexicalEnvWithName); JSTaggedValue numVars = GetArg(argv, argc, 0); // 0: means the zeroth parameter JSTaggedValue scopeId = GetArg(argv, argc, 1); // 1: means the first parameter - return RuntimeNewLexicalEnvWithNameDyn(thread, + return RuntimeNewLexicalEnvWithName(thread, static_cast(numVars.GetInt()), static_cast(scopeId.GetInt())).GetRawData(); } @@ -1650,24 +1644,24 @@ DEF_RUNTIME_STUBS(OptGetLexicalEnv) return RuntimeOptGetLexEnv(thread).GetRawData(); } -DEF_RUNTIME_STUBS(OptNewLexicalEnvDyn) +DEF_RUNTIME_STUBS(OptNewLexicalEnv) { - RUNTIME_STUBS_HEADER(OptNewLexicalEnvDyn); + RUNTIME_STUBS_HEADER(OptNewLexicalEnv); JSTaggedValue numVars = GetArg(argv, argc, 0); // 0: means the zeroth parameter JSHandle currentLexEnv = GetHArg(argv, argc, 1); // 1: means the first parameter - return RuntimeOptNewLexicalEnvDyn(thread, static_cast(numVars.GetInt()), currentLexEnv).GetRawData(); + return RuntimeOptNewLexicalEnv(thread, static_cast(numVars.GetInt()), currentLexEnv).GetRawData(); } -DEF_RUNTIME_STUBS(OptNewLexicalEnvWithNameDyn) +DEF_RUNTIME_STUBS(OptNewLexicalEnvWithName) { - RUNTIME_STUBS_HEADER(OptNewLexicalEnvWithNameDyn); + RUNTIME_STUBS_HEADER(OptNewLexicalEnvWithName); JSTaggedValue taggedNumVars = GetArg(argv, argc, 0); // 0: means the zeroth parameter JSTaggedValue taggedScopeId = GetArg(argv, argc, 1); // 1: means the first parameter JSHandle currentLexEnv = GetHArg(argv, argc, 2); // 2: means the second parameter JSHandle func = GetHArg(argv, argc, 3); // 3: means the third parameter uint16_t numVars = static_cast(taggedNumVars.GetInt()); uint16_t scopeId = static_cast(taggedScopeId.GetInt()); - return RuntimeOptNewLexicalEnvWithNameDyn(thread, numVars, scopeId, currentLexEnv, func).GetRawData(); + return RuntimeOptNewLexicalEnvWithName(thread, numVars, scopeId, currentLexEnv, func).GetRawData(); } DEF_RUNTIME_STUBS(OptPopLexicalEnv) @@ -1687,10 +1681,10 @@ DEF_RUNTIME_STUBS(OptCopyRestArgs) return RuntimeOptCopyRestArgs(thread, actualArgc.GetInt(), restIndex.GetInt()).GetRawData(); } -DEF_RUNTIME_STUBS(OptNewObjDynRange) +DEF_RUNTIME_STUBS(OptNewObjRange) { - RUNTIME_STUBS_HEADER(OptNewObjDynRange); - return RuntimeOptNewObjDynRange(thread, argv, argc).GetRawData(); + RUNTIME_STUBS_HEADER(OptNewObjRange); + return RuntimeOptNewObjRange(thread, argv, argc).GetRawData(); } DEF_RUNTIME_STUBS(GetTypeArrayPropertyByIndex) @@ -1727,9 +1721,9 @@ DEF_RUNTIME_STUBS(OptNewObjWithIHClass) return RuntimeOptNewObjWithIHClass(thread, argv, argc).GetRawData(); } -DEF_RUNTIME_STUBS(OptLdLexVarDyn) +DEF_RUNTIME_STUBS(OptLdLexVar) { - RUNTIME_STUBS_HEADER(OptLdLexVarDyn); + RUNTIME_STUBS_HEADER(OptLdLexVar); JSTaggedValue level = GetArg(argv, argc, 0); // 0: means the zeroth parameter JSTaggedValue slot = GetArg(argv, argc, 1); // 1: means the first parameter JSTaggedValue env = RuntimeOptGetLexEnv(thread); @@ -1741,9 +1735,9 @@ DEF_RUNTIME_STUBS(OptLdLexVarDyn) return LexicalEnv::Cast(env.GetTaggedObject())->GetProperties(slot.GetInt()).GetRawData(); } -DEF_RUNTIME_STUBS(OptStLexVarDyn) +DEF_RUNTIME_STUBS(OptStLexVar) { - RUNTIME_STUBS_HEADER(OptStLexVarDyn); + RUNTIME_STUBS_HEADER(OptStLexVar); JSTaggedValue level = GetArg(argv, argc, 0); // 0: means the zeroth parameter JSTaggedValue slot = GetArg(argv, argc, 1); // 1: means the first parameter JSTaggedValue value = GetArg(argv, argc, 2); // 2: means the second parameter @@ -1779,11 +1773,11 @@ JSTaggedType RuntimeStubs::CreateArrayFromList([[maybe_unused]]uintptr_t argGlue return arrHandle.GetTaggedValue().GetRawData(); } -int32_t RuntimeStubs::FindElementWithCache(uintptr_t argGlue, JSTaggedType hClass, +int32_t RuntimeStubs::FindElementWithCache(uintptr_t argGlue, JSTaggedType hclass, JSTaggedType key, int32_t num) { auto thread = JSThread::GlueToJSThread(argGlue); - auto cls = reinterpret_cast(hClass); + auto cls = reinterpret_cast(hclass); JSTaggedValue propKey = JSTaggedValue(key); auto layoutInfo = LayoutInfo::Cast(cls->GetLayout().GetTaggedObject()); PropertiesCache *cache = thread->GetPropertiesCache(); diff --git a/ecmascript/stubs/runtime_stubs.h b/ecmascript/stubs/runtime_stubs.h index 584b000d74..b76cd2f1ea 100644 --- a/ecmascript/stubs/runtime_stubs.h +++ b/ecmascript/stubs/runtime_stubs.h @@ -49,11 +49,11 @@ using JSFunctionEntryType = JSTaggedValue (*)(uintptr_t glue, uintptr_t prevFp, V(PushCallArgs1AndDispatch) \ V(PushCallArgs2AndDispatch) \ V(PushCallArgs3AndDispatch) \ - V(PushCallIRangeAndDispatch) \ + V(PushCallRangeAndDispatch) \ V(PushCallNewAndDispatch) \ V(PushCallNewAndDispatchNative) \ - V(PushCallIRangeAndDispatchNative) \ - V(PushCallIThisRangeAndDispatch) \ + V(PushCallRangeAndDispatchNative) \ + V(PushCallThisRangeAndDispatch) \ V(ResumeRspAndDispatch) \ V(ResumeRspAndReturn) \ V(ResumeCaughtFrameAndDispatch) \ @@ -101,7 +101,7 @@ using JSFunctionEntryType = JSTaggedValue (*)(uintptr_t glue, uintptr_t prevFp, V(NameDictPutIfAbsent) \ V(PropertiesSetValue) \ V(TaggedArraySetValue) \ - V(NewEcmaDynClass) \ + V(NewEcmaHClass) \ V(UpdateLayOutAndAddTransition) \ V(NoticeThroughChainAndRefreshUser) \ V(JumpToCInterpreter) \ @@ -112,19 +112,19 @@ using JSFunctionEntryType = JSTaggedValue (*)(uintptr_t glue, uintptr_t prevFp, V(StOwnByNameWithNameSet) \ V(SuspendGenerator) \ V(UpFrame) \ - V(NegDyn) \ - V(NotDyn) \ - V(IncDyn) \ - V(DecDyn) \ - V(Shl2Dyn) \ - V(Shr2Dyn) \ - V(Ashr2Dyn) \ - V(Or2Dyn) \ - V(Xor2Dyn) \ - V(And2Dyn) \ - V(ExpDyn) \ - V(IsInDyn) \ - V(InstanceOfDyn) \ + V(Neg) \ + V(Not) \ + V(Inc) \ + V(Dec) \ + V(Shl2) \ + V(Shr2) \ + V(Ashr2) \ + V(Or2) \ + V(Xor2) \ + V(And2) \ + V(Exp) \ + V(IsIn) \ + V(InstanceOf) \ V(FastStrictEqual) \ V(FastStrictNotEqual) \ V(CreateGeneratorObj) \ @@ -134,11 +134,10 @@ using JSFunctionEntryType = JSTaggedValue (*)(uintptr_t glue, uintptr_t prevFp, V(ThrowIfNotObject) \ V(IterNext) \ V(CloseIterator) \ - V(CopyModule) \ V(SuperCallSpread) \ V(OptSuperCallSpread) \ V(DelObjProp) \ - V(NewObjSpreadDyn) \ + V(NewObjApply) \ V(CreateIterResultObj) \ V(AsyncFunctionAwaitUncaught) \ V(AsyncFunctionResolveOrReject) \ @@ -167,14 +166,14 @@ using JSFunctionEntryType = JSTaggedValue (*)(uintptr_t glue, uintptr_t prevFp, V(StModuleVarOnJSFunc) \ V(LdModuleVar) \ V(LdModuleVarOnJSFunc) \ - V(ThrowDyn) \ + V(Throw) \ V(GetPropIterator) \ V(AsyncFunctionEnter) \ V(GetIterator) \ V(ThrowThrowNotExists) \ V(ThrowPatternNonCoercible) \ V(ThrowDeleteSuperProperty) \ - V(EqDyn) \ + V(Eq) \ V(LdGlobalRecord) \ V(GetGlobalOwnProperty) \ V(TryLdGlobalByName) \ @@ -186,16 +185,16 @@ using JSFunctionEntryType = JSTaggedValue (*)(uintptr_t glue, uintptr_t prevFp, V(LdGlobalVar) \ V(ToNumber) \ V(ToBoolean) \ - V(NotEqDyn) \ - V(LessDyn) \ - V(LessEqDyn) \ - V(GreaterDyn) \ - V(GreaterEqDyn) \ - V(Add2Dyn) \ - V(Sub2Dyn) \ - V(Mul2Dyn) \ - V(Div2Dyn) \ - V(Mod2Dyn) \ + V(NotEq) \ + V(Less) \ + V(LessEq) \ + V(Greater) \ + V(GreaterEq) \ + V(Add2) \ + V(Sub2) \ + V(Mul2) \ + V(Div2) \ + V(Mod2) \ V(LoadValueFromConstantStringTable) \ V(CreateEmptyObject) \ V(CreateEmptyArray) \ @@ -204,15 +203,15 @@ using JSFunctionEntryType = JSTaggedValue (*)(uintptr_t glue, uintptr_t prevFp, V(CopyRestArgs) \ V(CreateArrayWithBuffer) \ V(CreateObjectWithBuffer) \ - V(NewLexicalEnvDyn) \ + V(NewLexicalEnv) \ V(NewThisObject) \ - V(NewObjDynRange) \ - V(DefinefuncDyn) \ + V(NewObjRange) \ + V(Definefunc) \ V(CreateRegExpWithLiteral) \ V(ThrowIfSuperNotCorrectCall) \ V(CreateObjectHavingMethod) \ V(CreateObjectWithExcludedKeys) \ - V(DefineNCFuncDyn) \ + V(DefineNCFunc) \ V(DefineGeneratorFunc) \ V(DefineAsyncFunc) \ V(DefineMethod) \ @@ -223,7 +222,7 @@ using JSFunctionEntryType = JSTaggedValue (*)(uintptr_t glue, uintptr_t prevFp, V(ThrowStackOverflowException) \ V(ThrowDerivedMustReturnException) \ V(CallNative) \ - V(CallSpreadDyn) \ + V(CallSpread) \ V(DefineGetterSetterByValue) \ V(SuperCall) \ V(OptSuperCall) \ @@ -232,21 +231,21 @@ using JSFunctionEntryType = JSTaggedValue (*)(uintptr_t glue, uintptr_t prevFp, V(CreateAsyncGeneratorObj) \ V(AsyncGeneratorResolve) \ V(DefineAsyncGeneratorFunc) \ - V(NewLexicalEnvWithNameDyn) \ + V(NewLexicalEnvWithName) \ V(OptGetUnmapedArgs) \ V(OptCopyRestArgs) \ V(NotifyBytecodePcChanged) \ V(OptGetLexicalEnv) \ - V(OptNewLexicalEnvDyn) \ - V(OptNewLexicalEnvWithNameDyn) \ + V(OptNewLexicalEnv) \ + V(OptNewLexicalEnvWithName) \ V(OptSuspendGenerator) \ - V(OptNewObjDynRange) \ + V(OptNewObjRange) \ V(GetTypeArrayPropertyByIndex) \ V(SetTypeArrayPropertyByIndex) \ V(OptNewObjWithIHClass) \ V(OptPopLexicalEnv) \ - V(OptLdLexVarDyn) \ - V(OptStLexVarDyn) \ + V(OptLdLexVar) \ + V(OptStLexVar) \ V(JSObjectGetMethod) \ V(DebugAOTPrint) \ V(OptLdSuperByValue) \ @@ -302,19 +301,19 @@ public: static void InsertOldToNewRSet([[maybe_unused]]uintptr_t argGlue, Region* region, uintptr_t addr); static int32_t DoubleToInt(double x); static JSTaggedType FloatMod(double x, double y); - static int32_t FindElementWithCache(uintptr_t argGlue, JSTaggedType hClass, + static int32_t FindElementWithCache(uintptr_t argGlue, JSTaggedType hclass, JSTaggedType key, int32_t num); static bool StringsAreEquals(EcmaString *str1, EcmaString *str2); static bool BigIntEquals(JSTaggedType left, JSTaggedType right); private: static void PrintHeapReginInfo(uintptr_t argGlue); - static inline JSTaggedValue RuntimeIncDyn(JSThread *thread, const JSHandle &value); - static inline JSTaggedValue RuntimeDecDyn(JSThread *thread, const JSHandle &value); - static inline JSTaggedValue RuntimeExpDyn(JSThread *thread, JSTaggedValue base, JSTaggedValue exponent); - static inline JSTaggedValue RuntimeIsInDyn(JSThread *thread, const JSHandle &prop, + static inline JSTaggedValue RuntimeInc(JSThread *thread, const JSHandle &value); + static inline JSTaggedValue RuntimeDec(JSThread *thread, const JSHandle &value); + static inline JSTaggedValue RuntimeExp(JSThread *thread, JSTaggedValue base, JSTaggedValue exponent); + static inline JSTaggedValue RuntimeIsIn(JSThread *thread, const JSHandle &prop, const JSHandle &obj); - static inline JSTaggedValue RuntimeInstanceofDyn(JSThread *thread, const JSHandle &obj, + static inline JSTaggedValue RuntimeInstanceof(JSThread *thread, const JSHandle &obj, const JSHandle &target); static inline JSTaggedValue RuntimeCreateGeneratorObj(JSThread *thread, const JSHandle &genFunc); @@ -332,8 +331,7 @@ private: const JSHandle &array); static inline JSTaggedValue RuntimeDelObjProp(JSThread *thread, const JSHandle &obj, const JSHandle &prop); - static inline JSTaggedValue RuntimeNewObjSpreadDyn(JSThread *thread, const JSHandle &func, - const JSHandle &newTarget, + static inline JSTaggedValue RuntimeNewObjApply(JSThread *thread, const JSHandle &func, const JSHandle &array); static inline JSTaggedValue RuntimeCreateIterResultObj(JSThread *thread, const JSHandle &value, JSTaggedValue flag); @@ -348,10 +346,10 @@ private: const JSHandle &src); static inline JSTaggedValue RuntimeStArraySpread(JSThread *thread, const JSHandle &dst, JSTaggedValue index, const JSHandle &src); - static inline JSTaggedValue RuntimeGetIteratorNext(JSThread *thread, const JSHandle &obj, - const JSHandle &method); static inline JSTaggedValue RuntimeSetObjectWithProto(JSThread *thread, const JSHandle &proto, const JSHandle &obj); + static inline JSTaggedValue RuntimeGetIteratorNext(JSThread *thread, const JSHandle &obj, + const JSHandle &method); static inline JSTaggedValue RuntimeLdObjByValue(JSThread *thread, const JSHandle &obj, const JSHandle &prop, bool callGetter, JSTaggedValue receiver); @@ -375,8 +373,8 @@ private: const JSHandle &value); static inline JSTaggedValue RuntimeStGlobalRecord(JSThread *thread, const JSHandle &prop, const JSHandle &value, bool isConst); - static inline JSTaggedValue RuntimeNegDyn(JSThread *thread, const JSHandle &value); - static inline JSTaggedValue RuntimeNotDyn(JSThread *thread, const JSHandle &value); + static inline JSTaggedValue RuntimeNeg(JSThread *thread, const JSHandle &value); + static inline JSTaggedValue RuntimeNot(JSThread *thread, const JSHandle &value); static inline JSTaggedValue RuntimeResolveClass(JSThread *thread, const JSHandle &ctor, const JSHandle &literal, const JSHandle &base, @@ -411,7 +409,7 @@ private: static inline JSTaggedValue RuntimeGetPropIterator(JSThread *thread, const JSHandle &value); static inline JSTaggedValue RuntimeAsyncFunctionEnter(JSThread *thread); static inline JSTaggedValue RuntimeGetIterator(JSThread *thread, const JSHandle &obj); - static inline void RuntimeThrowDyn(JSThread *thread, JSTaggedValue value); + static inline void RuntimeThrow(JSThread *thread, JSTaggedValue value); static inline void RuntimeThrowThrowNotExists(JSThread *thread); static inline void RuntimeThrowPatternNonCoercible(JSThread *thread); static inline void RuntimeThrowDeleteSuperProperty(JSThread *thread); @@ -430,41 +428,41 @@ private: const JSHandle &value); static inline JSTaggedValue RuntimeToNumber(JSThread *thread, const JSHandle &value); static inline JSTaggedValue RuntimeToNumeric(JSThread *thread, const JSHandle &value); - static inline JSTaggedValue RuntimeEqDyn(JSThread *thread, const JSHandle &left, + static inline JSTaggedValue RuntimeEq(JSThread *thread, const JSHandle &left, const JSHandle &right); static inline JSTaggedValue RuntimeLdObjByName(JSThread *thread, JSTaggedValue obj, JSTaggedValue prop, bool callGetter, JSTaggedValue receiver); - static inline JSTaggedValue RuntimeNotEqDyn(JSThread *thread, const JSHandle &left, + static inline JSTaggedValue RuntimeNotEq(JSThread *thread, const JSHandle &left, const JSHandle &right); - static inline JSTaggedValue RuntimeLessDyn(JSThread *thread, const JSHandle &left, + static inline JSTaggedValue RuntimeLess(JSThread *thread, const JSHandle &left, const JSHandle &right); - static inline JSTaggedValue RuntimeLessEqDyn(JSThread *thread, const JSHandle &left, + static inline JSTaggedValue RuntimeLessEq(JSThread *thread, const JSHandle &left, const JSHandle &right); - static inline JSTaggedValue RuntimeGreaterDyn(JSThread *thread, const JSHandle &left, + static inline JSTaggedValue RuntimeGreater(JSThread *thread, const JSHandle &left, const JSHandle &right); - static inline JSTaggedValue RuntimeGreaterEqDyn(JSThread *thread, const JSHandle &left, + static inline JSTaggedValue RuntimeGreaterEq(JSThread *thread, const JSHandle &left, const JSHandle &right); - static inline JSTaggedValue RuntimeAdd2Dyn(JSThread *thread, const JSHandle &left, + static inline JSTaggedValue RuntimeAdd2(JSThread *thread, const JSHandle &left, const JSHandle &right); - static inline JSTaggedValue RuntimeShl2Dyn(JSThread *thread, const JSHandle &left, + static inline JSTaggedValue RuntimeShl2(JSThread *thread, const JSHandle &left, const JSHandle &right); - static inline JSTaggedValue RuntimeShr2Dyn(JSThread *thread, const JSHandle &left, + static inline JSTaggedValue RuntimeShr2(JSThread *thread, const JSHandle &left, const JSHandle &right); - static inline JSTaggedValue RuntimeSub2Dyn(JSThread *thread, const JSHandle &left, + static inline JSTaggedValue RuntimeSub2(JSThread *thread, const JSHandle &left, const JSHandle &right); - static inline JSTaggedValue RuntimeMul2Dyn(JSThread *thread, const JSHandle &left, + static inline JSTaggedValue RuntimeMul2(JSThread *thread, const JSHandle &left, const JSHandle &right); - static inline JSTaggedValue RuntimeDiv2Dyn(JSThread *thread, const JSHandle &left, + static inline JSTaggedValue RuntimeDiv2(JSThread *thread, const JSHandle &left, const JSHandle &right); - static inline JSTaggedValue RuntimeMod2Dyn(JSThread *thread, const JSHandle &left, + static inline JSTaggedValue RuntimeMod2(JSThread *thread, const JSHandle &left, const JSHandle &right); - static inline JSTaggedValue RuntimeAshr2Dyn(JSThread *thread, const JSHandle &left, + static inline JSTaggedValue RuntimeAshr2(JSThread *thread, const JSHandle &left, const JSHandle &right); - static inline JSTaggedValue RuntimeAnd2Dyn(JSThread *thread, const JSHandle &left, + static inline JSTaggedValue RuntimeAnd2(JSThread *thread, const JSHandle &left, const JSHandle &right); - static inline JSTaggedValue RuntimeOr2Dyn(JSThread *thread, const JSHandle &left, + static inline JSTaggedValue RuntimeOr2(JSThread *thread, const JSHandle &left, const JSHandle &right); - static inline JSTaggedValue RuntimeXor2Dyn(JSThread *thread, const JSHandle &left, + static inline JSTaggedValue RuntimeXor2(JSThread *thread, const JSHandle &left, const JSHandle &right); static inline JSTaggedValue RuntimeStOwnByNameWithNameSet(JSThread *thread, const JSHandle &obj, @@ -489,11 +487,11 @@ private: const JSHandle &literal); static inline JSTaggedValue RuntimeCreateObjectWithBuffer(JSThread *thread, ObjectFactory *factory, const JSHandle &literal); - static inline JSTaggedValue RuntimeNewLexicalEnvDyn(JSThread *thread, uint16_t numVars); - static inline JSTaggedValue RuntimeNewObjDynRange(JSThread *thread, const JSHandle &func, + static inline JSTaggedValue RuntimeNewLexicalEnv(JSThread *thread, uint16_t numVars); + static inline JSTaggedValue RuntimeNewObjRange(JSThread *thread, const JSHandle &func, const JSHandle &newTarget, uint16_t firstArgIdx, uint16_t length); - static inline JSTaggedValue RuntimeDefinefuncDyn(JSThread *thread, const JSHandle &funcHandle); + static inline JSTaggedValue RuntimeDefinefunc(JSThread *thread, const JSHandle &funcHandle); static inline JSTaggedValue RuntimeCreateRegExpWithLiteral(JSThread *thread, const JSHandle &pattern, uint8_t flags); static inline JSTaggedValue RuntimeThrowIfSuperNotCorrectCall(JSThread *thread, uint16_t index, @@ -505,12 +503,12 @@ private: const JSHandle &objVal, uint16_t firstArgRegIdx); static inline JSTaggedValue RuntimeDefineAsyncGeneratorFunc(JSThread *thread, const JSHandle &funcHandle); - static inline JSTaggedValue RuntimeDefineNCFuncDyn(JSThread *thread, const JSHandle &funcHandle); + static inline JSTaggedValue RuntimeDefineNCFunc(JSThread *thread, const JSHandle &funcHandle); static inline JSTaggedValue RuntimeDefineGeneratorFunc(JSThread *thread, const JSHandle &funcHandle); static inline JSTaggedValue RuntimeDefineAsyncFunc(JSThread *thread, const JSHandle &funcHandle); static inline JSTaggedValue RuntimeDefineMethod(JSThread *thread, const JSHandle &funcHandle, const JSHandle &homeObject); - static inline JSTaggedValue RuntimeCallSpreadDyn(JSThread *thread, const JSHandle &func, + static inline JSTaggedValue RuntimeCallSpread(JSThread *thread, const JSHandle &func, const JSHandle &obj, const JSHandle &array); static inline JSTaggedValue RuntimeDefineGetterSetterByValue(JSThread *thread, const JSHandle &obj, @@ -526,19 +524,19 @@ private: static inline JSTaggedValue RuntimeThrowReferenceError(JSThread *thread, JSTaggedValue prop, const char *desc); static inline JSTaggedValue RuntimeThrowSyntaxError(JSThread *thread, const char *message); static inline JSTaggedValue RuntimeLdBigInt(JSThread *thread, const JSHandle &numberBigInt); - static inline JSTaggedValue RuntimeNewLexicalEnvWithNameDyn(JSThread *thread, uint16_t numVars, uint16_t scopeId); + static inline JSTaggedValue RuntimeNewLexicalEnvWithName(JSThread *thread, uint16_t numVars, uint16_t scopeId); static inline JSTaggedValue RuntimeOptGetUnmapedArgs(JSThread *thread, uint32_t actualNumArgs); static inline JSTaggedValue RuntimeGetUnmapedJSArgumentObj(JSThread *thread, const JSHandle &argumentsList); - static inline JSTaggedValue RuntimeOptNewLexicalEnvDyn(JSThread *thread, uint16_t numVars, + static inline JSTaggedValue RuntimeOptNewLexicalEnv(JSThread *thread, uint16_t numVars, JSHandle ¤tLexEnv); - static inline JSTaggedValue RuntimeOptNewLexicalEnvWithNameDyn(JSThread *thread, uint16_t numVars, uint16_t scopeId, + static inline JSTaggedValue RuntimeOptNewLexicalEnvWithName(JSThread *thread, uint16_t numVars, uint16_t scopeId, JSHandle ¤tLexEnv, JSHandle &func); static inline JSTaggedValue RuntimeOptCopyRestArgs(JSThread *thread, uint32_t actualArgc, uint32_t restIndex); static inline JSTaggedValue RuntimeOptSuspendGenerator(JSThread *thread, const JSHandle &genObj, const JSHandle &value); - static inline JSTaggedValue RuntimeOptNewObjDynRange(JSThread *thread, uintptr_t argv, uint32_t argc); + static inline JSTaggedValue RuntimeOptNewObjRange(JSThread *thread, uintptr_t argv, uint32_t argc); static inline JSTaggedValue RuntimeOptConstruct(JSThread *thread, JSHandle ctor, JSHandle newTarget, JSHandle preArgs, JSHandle args); diff --git a/ecmascript/stubs/test_runtime_stubs.cpp b/ecmascript/stubs/test_runtime_stubs.cpp index d03d9928f0..2eecdc4b8e 100644 --- a/ecmascript/stubs/test_runtime_stubs.cpp +++ b/ecmascript/stubs/test_runtime_stubs.cpp @@ -106,10 +106,10 @@ DEF_RUNTIME_STUBS(DefineProxyFunc) CONVERT_ARG_HANDLE_CHECKED(JSTaggedValue, targetHandle, 0); // 1. handler has no "Call" JSFunction *function = env->GetObjectFunction().GetObject(); - JSHandle dynclass(thread, function); + JSHandle hclass(thread, function); ASSERT(targetHandle->IsECMAObject()); - JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); ASSERT(handlerHandle->IsECMAObject()); ASSERT(targetHandle->IsECMAObject()); @@ -128,9 +128,9 @@ DEF_RUNTIME_STUBS(DefineProxyHandler) ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); JSFunction* function = env->GetObjectFunction().GetObject(); - JSHandle dynclass(thread, function); + JSHandle hclass(thread, function); - JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); ASSERT(handlerHandle->IsECMAObject()); // 1. handler has "Call" JSHandle funcKey = thread->GlobalConstants()->GetHandledApplyString(); diff --git a/ecmascript/tagged_array-inl.h b/ecmascript/tagged_array-inl.h index 55125536b6..4676a54179 100644 --- a/ecmascript/tagged_array-inl.h +++ b/ecmascript/tagged_array-inl.h @@ -29,7 +29,7 @@ inline JSTaggedValue TaggedArray::Get(uint32_t idx) const // dynamically-typed languages like JavaScript. So we simply skip the read-barrier. size_t offset = JSTaggedValue::TaggedTypeSize() * idx; // NOLINTNEXTLINE(readability-braces-around-statements, bugprone-suspicious-semicolon) - return JSTaggedValue(Barriers::GetDynValue(GetData(), offset)); + return JSTaggedValue(Barriers::GetValue(GetData(), offset)); } inline JSTaggedValue TaggedArray::Get([[maybe_unused]] const JSThread *thread, uint32_t idx) const @@ -57,9 +57,9 @@ inline void TaggedArray::Set(const JSThread *thread, uint32_t idx, const JSHandl // NOLINTNEXTLINE(readability-braces-around-statements, bugprone-suspicious-semicolon) if (value.GetTaggedValue().IsHeapObject()) { - Barriers::SetDynObject(thread, GetData(), offset, value.GetTaggedValue().GetRawData()); + Barriers::SetObject(thread, GetData(), offset, value.GetTaggedValue().GetRawData()); } else { // NOLINTNEXTLINE(readability-misleading-indentation) - Barriers::SetDynPrimitive(GetData(), offset, value.GetTaggedValue().GetRawData()); + Barriers::SetPrimitive(GetData(), offset, value.GetTaggedValue().GetRawData()); } } @@ -70,9 +70,9 @@ inline void TaggedArray::Set(const JSThread *thread, uint32_t idx, const JSTagge // NOLINTNEXTLINE(readability-braces-around-statements, bugprone-suspicious-semicolon) if (value.IsHeapObject()) { - Barriers::SetDynObject(thread, GetData(), offset, value.GetRawData()); + Barriers::SetObject(thread, GetData(), offset, value.GetRawData()); } else { // NOLINTNEXTLINE(readability-misleading-indentation) - Barriers::SetDynPrimitive(GetData(), offset, value.GetRawData()); + Barriers::SetPrimitive(GetData(), offset, value.GetRawData()); } } @@ -142,7 +142,7 @@ void TaggedArray::InitializeWithSpecialValue(JSTaggedValue initValue, uint32_t l SetLength(length); for (uint32_t i = 0; i < length; i++) { size_t offset = JSTaggedValue::TaggedTypeSize() * i; - Barriers::SetDynPrimitive(GetData(), offset, initValue.GetRawData()); + Barriers::SetPrimitive(GetData(), offset, initValue.GetRawData()); } } diff --git a/ecmascript/tests/accessor_data_test.cpp b/ecmascript/tests/accessor_data_test.cpp index 555cff45e9..5c010464ed 100644 --- a/ecmascript/tests/accessor_data_test.cpp +++ b/ecmascript/tests/accessor_data_test.cpp @@ -60,18 +60,18 @@ HWTEST_F_L0(AccessorDataTest, AccessorData_Cast) ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); JSHandle nullHandle(thread, JSTaggedValue::Null()); - JSHandle accDynclassHandle = - factory->NewEcmaDynClass(JSObject::SIZE, JSType::ACCESSOR_DATA, nullHandle); - TaggedObject *accObject = factory->NewDynObject(accDynclassHandle); + JSHandle accClassHandle = + factory->NewEcmaHClass(JSObject::SIZE, JSType::ACCESSOR_DATA, nullHandle); + TaggedObject *accObject = factory->NewObject(accClassHandle); AccessorData::Cast(accObject)->SetGetter(thread, JSTaggedValue::Undefined()); AccessorData::Cast(accObject)->SetSetter(thread, JSTaggedValue::Undefined()); EXPECT_TRUE(JSTaggedValue(accObject).IsAccessorData()); AccessorData *acc = AccessorData::Cast(accObject); EXPECT_TRUE(JSTaggedValue(acc).IsAccessorData()); - JSHandle internalAccDynClassHandle = - factory->NewEcmaDynClass(JSObject::SIZE, JSType::INTERNAL_ACCESSOR, nullHandle); - TaggedObject *internalAccObject = factory->NewDynObject(internalAccDynClassHandle); + JSHandle internalAccClassHandle = + factory->NewEcmaHClass(JSObject::SIZE, JSType::INTERNAL_ACCESSOR, nullHandle); + TaggedObject *internalAccObject = factory->NewObject(internalAccClassHandle); EXPECT_TRUE(JSTaggedValue(internalAccObject).IsInternalAccessor()); AccessorData *internalAcc = AccessorData::Cast(internalAccObject); EXPECT_TRUE(JSTaggedValue(internalAcc).IsInternalAccessor()); @@ -95,16 +95,16 @@ HWTEST_F_L0(AccessorDataTest, IsInternal) EXPECT_EQ(internalAccHancle->IsInternal(), true); JSHandle nullHandle(thread, JSTaggedValue::Null()); - JSHandle accDynclass = factory->NewEcmaDynClass(JSObject::SIZE, JSType::ACCESSOR_DATA, nullHandle); - TaggedObject *accObject = factory->NewDynObject(accDynclass); + JSHandle accClass = factory->NewEcmaHClass(JSObject::SIZE, JSType::ACCESSOR_DATA, nullHandle); + TaggedObject *accObject = factory->NewObject(accClass); AccessorData *acc = AccessorData::Cast(accObject); acc->SetGetter(thread, JSTaggedValue::Undefined()); acc->SetSetter(thread, JSTaggedValue::Undefined()); EXPECT_EQ(acc->IsInternal(), false); - JSHandle internalAccDynClass = - factory->NewEcmaDynClass(JSObject::SIZE, JSType::INTERNAL_ACCESSOR, nullHandle); - TaggedObject *internalAccObject = factory->NewDynObject(internalAccDynClass); + JSHandle internalAccClass = + factory->NewEcmaHClass(JSObject::SIZE, JSType::INTERNAL_ACCESSOR, nullHandle); + TaggedObject *internalAccObject = factory->NewObject(internalAccClass); AccessorData *internalAcc = AccessorData::Cast(internalAccObject); EXPECT_EQ(internalAcc->IsInternal(), true); } @@ -141,8 +141,8 @@ HWTEST_F_L0(AccessorDataTest, HasSetter) // 3.Create normal AccessorData object from dynamic class. JSHandle nullHandle(thread, JSTaggedValue::Null()); - JSHandle accDynclass = factory->NewEcmaDynClass(JSObject::SIZE, JSType::ACCESSOR_DATA, nullHandle); - TaggedObject *accObject = factory->NewDynObject(accDynclass); + JSHandle accClass = factory->NewEcmaHClass(JSObject::SIZE, JSType::ACCESSOR_DATA, nullHandle); + TaggedObject *accObject = factory->NewObject(accClass); AccessorData *acc = AccessorData::Cast(accObject); acc->SetGetter(thread, JSTaggedValue::Undefined()); EXPECT_EQ(acc->HasSetter(), true); @@ -152,9 +152,9 @@ HWTEST_F_L0(AccessorDataTest, HasSetter) EXPECT_EQ(acc->HasSetter(), true); // 4.Create internal AccessorData object from dynamic class. - JSHandle internalAccDynClass = - factory->NewEcmaDynClass(JSObject::SIZE, JSType::INTERNAL_ACCESSOR, nullHandle); - TaggedObject *internalAccObject = factory->NewDynObject(internalAccDynClass); + JSHandle internalAccClass = + factory->NewEcmaHClass(JSObject::SIZE, JSType::INTERNAL_ACCESSOR, nullHandle); + TaggedObject *internalAccObject = factory->NewObject(internalAccClass); AccessorData *internalAcc = AccessorData::Cast(internalAccObject); EXPECT_EQ(internalAcc->HasSetter(), true); internalAcc->SetSetter(thread, JSTaggedValue::Undefined()); @@ -181,9 +181,9 @@ HWTEST_F_L0(AccessorDataTest, CallInternalSet) // Call the CallInternalGet method to inspect prototype. JSHandle nullPrototypeHandle(thread, JSTaggedValue::Null()); - JSHandle accDynclass1 = - factory->NewEcmaDynClass(JSObject::SIZE, JSType::INTERNAL_ACCESSOR, nullPrototypeHandle); - JSHandle accObject1(thread, factory->NewDynObject(accDynclass1)); + JSHandle accClass1 = + factory->NewEcmaHClass(JSObject::SIZE, JSType::INTERNAL_ACCESSOR, nullPrototypeHandle); + JSHandle accObject1(thread, factory->NewObject(accClass1)); accObject1->SetGetter(thread, JSTaggedValue::Undefined()); accObject1->SetSetter(thread, JSTaggedValue::Undefined()); JSHandle prototypeGetterFuncNativePtrHandle = @@ -217,9 +217,9 @@ HWTEST_F_L0(AccessorDataTest, CompletionRecord_Cast) ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); JSHandle nullHandle(thread, JSTaggedValue::Null()); - JSHandle comRecordDynclassHandle = - factory->NewEcmaDynClass(JSObject::SIZE, JSType::COMPLETION_RECORD, nullHandle); - TaggedObject *comRecordObject = factory->NewDynObject(comRecordDynclassHandle); + JSHandle comRecordClassHandle = + factory->NewEcmaHClass(JSObject::SIZE, JSType::COMPLETION_RECORD, nullHandle); + TaggedObject *comRecordObject = factory->NewObject(comRecordClassHandle); EXPECT_TRUE(JSTaggedValue(comRecordObject).IsCompletionRecord()); CompletionRecord *comRecord = CompletionRecord::Cast(comRecordObject); EXPECT_TRUE(JSTaggedValue(comRecord).IsCompletionRecord()); diff --git a/ecmascript/tests/dump_test.cpp b/ecmascript/tests/dump_test.cpp index 7bdf07d5a8..92a02f6521 100644 --- a/ecmascript/tests/dump_test.cpp +++ b/ecmascript/tests/dump_test.cpp @@ -178,7 +178,7 @@ HWTEST_F_L0(EcmaDumpTest, Dump) static JSHandle NewJSMap(JSThread *thread, ObjectFactory *factory, JSHandle proto) { - JSHandle mapClass = factory->NewEcmaDynClass(JSMap::SIZE, JSType::JS_MAP, proto); + JSHandle mapClass = factory->NewEcmaHClass(JSMap::SIZE, JSType::JS_MAP, proto); JSHandle jsMap = JSHandle::Cast(factory->NewJSObjectWithInit(mapClass)); JSHandle linkedMap(LinkedHashMap::Create(thread)); jsMap->SetLinkedMap(thread, linkedMap); @@ -187,7 +187,7 @@ static JSHandle NewJSMap(JSThread *thread, ObjectFactory *factory, JSHand static JSHandle NewJSSet(JSThread *thread, ObjectFactory *factory, JSHandle proto) { - JSHandle setClass = factory->NewEcmaDynClass(JSSet::SIZE, JSType::JS_SET, proto); + JSHandle setClass = factory->NewEcmaHClass(JSSet::SIZE, JSType::JS_SET, proto); JSHandle jsSet = JSHandle::Cast(factory->NewJSObjectWithInit(setClass)); JSHandle linkedSet(LinkedHashSet::Create(thread)); jsSet->SetLinkedSet(thread, linkedSet); @@ -198,7 +198,7 @@ static JSHandle NewJSAPIHashMap(JSThread *thread, ObjectFactory *f { auto globalEnv = thread->GetEcmaVM()->GetGlobalEnv(); JSHandle proto = globalEnv->GetObjectFunctionPrototype(); - JSHandle mapClass = factory->NewEcmaDynClass(JSAPIHashMap::SIZE, JSType::JS_API_HASH_MAP, proto); + JSHandle mapClass = factory->NewEcmaHClass(JSAPIHashMap::SIZE, JSType::JS_API_HASH_MAP, proto); JSHandle jsHashMap = JSHandle::Cast(factory->NewJSObjectWithInit(mapClass)); jsHashMap->SetTable(thread, TaggedHashArray::Create(thread)); jsHashMap->SetSize(0); @@ -209,7 +209,7 @@ static JSHandle NewJSAPIHashSet(JSThread *thread, ObjectFactory *f { auto globalEnv = thread->GetEcmaVM()->GetGlobalEnv(); JSHandle proto = globalEnv->GetObjectFunctionPrototype(); - JSHandle setClass = factory->NewEcmaDynClass(JSAPIHashSet::SIZE, JSType::JS_API_HASH_SET, proto); + JSHandle setClass = factory->NewEcmaHClass(JSAPIHashSet::SIZE, JSType::JS_API_HASH_SET, proto); JSHandle jsHashSet = JSHandle::Cast(factory->NewJSObjectWithInit(setClass)); jsHashSet->SetTable(thread, TaggedHashArray::Create(thread)); jsHashSet->SetSize(0); @@ -220,7 +220,7 @@ static JSHandle NewJSAPITreeMap(JSThread *thread, ObjectFactory *f { auto globalEnv = thread->GetEcmaVM()->GetGlobalEnv(); JSHandle proto = globalEnv->GetObjectFunctionPrototype(); - JSHandle mapClass = factory->NewEcmaDynClass(JSAPITreeMap::SIZE, JSType::JS_API_TREE_MAP, proto); + JSHandle mapClass = factory->NewEcmaHClass(JSAPITreeMap::SIZE, JSType::JS_API_TREE_MAP, proto); JSHandle jsTreeMap = JSHandle::Cast(factory->NewJSObjectWithInit(mapClass)); JSHandle treeMap(thread, TaggedTreeMap::Create(thread)); jsTreeMap->SetTreeMap(thread, treeMap); @@ -231,7 +231,7 @@ static JSHandle NewJSAPITreeSet(JSThread *thread, ObjectFactory *f { auto globalEnv = thread->GetEcmaVM()->GetGlobalEnv(); JSHandle proto = globalEnv->GetObjectFunctionPrototype(); - JSHandle setClass = factory->NewEcmaDynClass(JSAPITreeSet::SIZE, JSType::JS_API_TREE_SET, proto); + JSHandle setClass = factory->NewEcmaHClass(JSAPITreeSet::SIZE, JSType::JS_API_TREE_SET, proto); JSHandle jsTreeSet = JSHandle::Cast(factory->NewJSObjectWithInit(setClass)); JSHandle treeSet(thread, TaggedTreeSet::Create(thread)); jsTreeSet->SetTreeSet(thread, treeSet); @@ -242,7 +242,7 @@ static JSHandle NewJSAPIPlainArray(JSThread *thread, ObjectFact { auto globalEnv = thread->GetEcmaVM()->GetGlobalEnv(); JSHandle proto = globalEnv->GetObjectFunctionPrototype(); - JSHandle mapClass = factory->NewEcmaDynClass(JSAPIPlainArray::SIZE, JSType::JS_API_PLAIN_ARRAY, proto); + JSHandle mapClass = factory->NewEcmaHClass(JSAPIPlainArray::SIZE, JSType::JS_API_PLAIN_ARRAY, proto); JSHandle jSAPIPlainArray = JSHandle::Cast(factory->NewJSObjectWithInit(mapClass)); JSHandle keys = JSAPIPlainArray::CreateSlot(thread, JSAPIPlainArray::DEFAULT_CAPACITY_LENGTH); @@ -258,7 +258,7 @@ static JSHandle NewJSAPIList(JSThread *thread, ObjectFactory *factory { auto globalEnv = thread->GetEcmaVM()->GetGlobalEnv(); JSHandle proto = globalEnv->GetObjectFunctionPrototype(); - JSHandle listClass = factory->NewEcmaDynClass(JSAPIList::SIZE, JSType::JS_API_LIST, proto); + JSHandle listClass = factory->NewEcmaHClass(JSAPIList::SIZE, JSType::JS_API_LIST, proto); JSHandle jsAPIList = JSHandle::Cast(factory->NewJSObjectWithInit(listClass)); JSHandle taggedSingleList(thread, TaggedSingleList::Create(thread)); jsAPIList->SetSingleList(thread, taggedSingleList); @@ -269,7 +269,7 @@ static JSHandle NewJSAPILinkedList(JSThread *thread, ObjectFact { auto globalEnv = thread->GetEcmaVM()->GetGlobalEnv(); JSHandle proto = globalEnv->GetObjectFunctionPrototype(); - JSHandle mapClass = factory->NewEcmaDynClass(JSAPILinkedList::SIZE, JSType::JS_API_LINKED_LIST, proto); + JSHandle mapClass = factory->NewEcmaHClass(JSAPILinkedList::SIZE, JSType::JS_API_LINKED_LIST, proto); JSHandle jsAPILinkedList = JSHandle::Cast(factory->NewJSObjectWithInit(mapClass)); JSHandle linkedlist(thread, TaggedDoubleList::Create(thread)); jsAPILinkedList->SetDoubleList(thread, linkedlist); @@ -288,7 +288,7 @@ static JSHandle NewJSAPIArrayList(JSThread *thread, ObjectFactor JSHandle proto) { JSHandle arrayListClass = - factory->NewEcmaDynClass(JSAPIArrayList::SIZE, JSType::JS_API_ARRAY_LIST, proto); + factory->NewEcmaHClass(JSAPIArrayList::SIZE, JSType::JS_API_ARRAY_LIST, proto); JSHandle jsArrayList = JSHandle::Cast(factory->NewJSObjectWithInit(arrayListClass)); jsArrayList->SetLength(thread, JSTaggedValue(0)); return jsArrayList; @@ -296,7 +296,7 @@ static JSHandle NewJSAPIArrayList(JSThread *thread, ObjectFactor static JSHandle NewJSAPIStack(ObjectFactory *factory, JSHandle proto) { - JSHandle stackClass = factory->NewEcmaDynClass(JSAPIStack::SIZE, JSType::JS_API_STACK, proto); + JSHandle stackClass = factory->NewEcmaHClass(JSAPIStack::SIZE, JSType::JS_API_STACK, proto); JSHandle jsStack = JSHandle::Cast(factory->NewJSObjectWithInit(stackClass)); jsStack->SetTop(0); return jsStack; @@ -305,7 +305,7 @@ static JSHandle NewJSAPIStack(ObjectFactory *factory, JSHandle NewJSRegExp(JSThread *thread, ObjectFactory *factory, JSHandle proto) { JSHandle jSRegExpClass = - factory->NewEcmaDynClass(JSRegExp::SIZE, JSType::JS_REG_EXP, proto); + factory->NewEcmaHClass(JSRegExp::SIZE, JSType::JS_REG_EXP, proto); JSHandle jSRegExp = JSHandle::Cast(factory->NewJSObject(jSRegExpClass)); jSRegExp->SetByteCodeBuffer(thread, JSTaggedValue::Undefined()); jSRegExp->SetOriginalSource(thread, JSTaggedValue::Undefined()); @@ -320,7 +320,7 @@ static JSHandle NewJSAPILightWeightMap(JSThread *thread, Ob auto globalEnv = thread->GetEcmaVM()->GetGlobalEnv(); JSHandle proto = globalEnv->GetObjectFunctionPrototype(); JSHandle lwmapClass = - factory->NewEcmaDynClass(JSAPILightWeightMap::SIZE, JSType::JS_API_LIGHT_WEIGHT_MAP, proto); + factory->NewEcmaHClass(JSAPILightWeightMap::SIZE, JSType::JS_API_LIGHT_WEIGHT_MAP, proto); JSHandle jSAPILightWeightMap = JSHandle::Cast(factory->NewJSObjectWithInit(lwmapClass)); JSHandle hashArray = @@ -341,7 +341,7 @@ static JSHandle NewJSAPILightWeightSet(JSThread *thread, Ob auto globalEnv = thread->GetEcmaVM()->GetGlobalEnv(); JSHandle proto = globalEnv->GetObjectFunctionPrototype(); JSHandle setClass = - factory->NewEcmaDynClass(JSAPILightWeightSet::SIZE, JSType::JS_API_LIGHT_WEIGHT_SET, proto); + factory->NewEcmaHClass(JSAPILightWeightSet::SIZE, JSType::JS_API_LIGHT_WEIGHT_SET, proto); JSHandle jSAPILightWeightSet = JSHandle::Cast(factory->NewJSObjectWithInit(setClass)); JSHandle hashes = @@ -356,7 +356,7 @@ static JSHandle NewJSAPILightWeightSet(JSThread *thread, Ob static JSHandle NewJSAPIQueue(JSThread *thread, ObjectFactory *factory, JSHandle proto) { - JSHandle queueClass = factory->NewEcmaDynClass(JSAPIQueue::SIZE, JSType::JS_API_QUEUE, proto); + JSHandle queueClass = factory->NewEcmaHClass(JSAPIQueue::SIZE, JSType::JS_API_QUEUE, proto); JSHandle jsQueue = JSHandle::Cast(factory->NewJSObjectWithInit(queueClass)); JSHandle newElements = factory->NewTaggedArray(JSAPIQueue::DEFAULT_CAPACITY_LENGTH); jsQueue->SetLength(thread, JSTaggedValue(0)); @@ -368,7 +368,7 @@ static JSHandle NewJSAPIQueue(JSThread *thread, ObjectFactory *facto static JSHandle NewJSAPIDeque(JSThread *thread, ObjectFactory *factory, JSHandle proto) { - JSHandle dequeClass = factory->NewEcmaDynClass(JSAPIDeque::SIZE, JSType::JS_API_DEQUE, proto); + JSHandle dequeClass = factory->NewEcmaHClass(JSAPIDeque::SIZE, JSType::JS_API_DEQUE, proto); JSHandle jsDeque = JSHandle::Cast(factory->NewJSObjectWithInit(dequeClass)); JSHandle newElements = factory->NewTaggedArray(JSAPIDeque::DEFAULT_CAPACITY_LENGTH); jsDeque->SetFirst(0); @@ -379,7 +379,7 @@ static JSHandle NewJSAPIDeque(JSThread *thread, ObjectFactory *facto static JSHandle NewJSAPIVector(ObjectFactory *factory, JSHandle proto) { - JSHandle vectorClass = factory->NewEcmaDynClass(JSAPIVector::SIZE, JSType::JS_API_VECTOR, proto); + JSHandle vectorClass = factory->NewEcmaHClass(JSAPIVector::SIZE, JSType::JS_API_VECTOR, proto); JSHandle jsVector = JSHandle::Cast(factory->NewJSObjectWithInit(vectorClass)); jsVector->SetLength(0); return jsVector; @@ -401,7 +401,7 @@ HWTEST_F_L0(EcmaDumpTest, HeapProfileDump) #define NEW_OBJECT_AND_DUMP(ClassName, TypeName) \ JSHandle class##ClassName = \ - factory->NewEcmaDynClass(ClassName::SIZE, JSType::TypeName, proto); \ + factory->NewEcmaHClass(ClassName::SIZE, JSType::TypeName, proto); \ JSHandle object##ClassName = factory->NewJSObjectWithInit(class##ClassName); \ object##ClassName.GetTaggedValue().Dump(os); \ object##ClassName.GetTaggedValue().DumpForSnapshot(snapshotVector); @@ -557,7 +557,7 @@ HWTEST_F_L0(EcmaDumpTest, HeapProfileDump) } case JSType::JS_WEAK_MAP: { CHECK_DUMP_FIELDS(JSObject::SIZE, JSWeakMap::SIZE, 1U); - JSHandle weakMapClass = factory->NewEcmaDynClass(JSWeakMap::SIZE, JSType::JS_WEAK_MAP, proto); + JSHandle weakMapClass = factory->NewEcmaHClass(JSWeakMap::SIZE, JSType::JS_WEAK_MAP, proto); JSHandle jsWeakMap = JSHandle::Cast(factory->NewJSObjectWithInit(weakMapClass)); JSHandle weakLinkedMap(LinkedHashMap::Create(thread)); jsWeakMap->SetLinkedMap(thread, weakLinkedMap); @@ -566,7 +566,7 @@ HWTEST_F_L0(EcmaDumpTest, HeapProfileDump) } case JSType::JS_WEAK_SET: { CHECK_DUMP_FIELDS(JSObject::SIZE, JSWeakSet::SIZE, 1U); - JSHandle weakSetClass = factory->NewEcmaDynClass(JSWeakSet::SIZE, JSType::JS_WEAK_SET, proto); + JSHandle weakSetClass = factory->NewEcmaHClass(JSWeakSet::SIZE, JSType::JS_WEAK_SET, proto); JSHandle jsWeakSet = JSHandle::Cast(factory->NewJSObjectWithInit(weakSetClass)); JSHandle weakLinkedSet(LinkedHashSet::Create(thread)); jsWeakSet->SetLinkedSet(thread, weakLinkedSet); @@ -575,7 +575,7 @@ HWTEST_F_L0(EcmaDumpTest, HeapProfileDump) } case JSType::JS_WEAK_REF: { CHECK_DUMP_FIELDS(JSObject::SIZE, JSWeakRef::SIZE, 1U); - JSHandle weakRefClass = factory->NewEcmaDynClass(JSWeakRef::SIZE, JSType::JS_WEAK_REF, proto); + JSHandle weakRefClass = factory->NewEcmaHClass(JSWeakRef::SIZE, JSType::JS_WEAK_REF, proto); JSHandle jsWeakRef = JSHandle::Cast(factory->NewJSObjectWithInit(weakRefClass)); jsWeakRef->SetWeakObject(thread, JSTaggedValue::Undefined()); DUMP_FOR_HANDLE(jsWeakRef) @@ -584,7 +584,7 @@ HWTEST_F_L0(EcmaDumpTest, HeapProfileDump) case JSType::JS_FINALIZATION_REGISTRY: { CHECK_DUMP_FIELDS(JSObject::SIZE, JSFinalizationRegistry::SIZE, 5U); JSHandle finalizationRegistryClass = - factory->NewEcmaDynClass(JSFinalizationRegistry::SIZE, JSType::JS_FINALIZATION_REGISTRY, proto); + factory->NewEcmaHClass(JSFinalizationRegistry::SIZE, JSType::JS_FINALIZATION_REGISTRY, proto); JSHandle jsFinalizationRegistry = JSHandle::Cast(factory->NewJSObjectWithInit(finalizationRegistryClass)); JSHandle weakLinkedMap(LinkedHashMap::Create(thread)); @@ -600,7 +600,7 @@ HWTEST_F_L0(EcmaDumpTest, HeapProfileDump) } case JSType::JS_DATE: { CHECK_DUMP_FIELDS(JSObject::SIZE, JSDate::SIZE, 2U); - JSHandle dateClass = factory->NewEcmaDynClass(JSDate::SIZE, JSType::JS_DATE, proto); + JSHandle dateClass = factory->NewEcmaHClass(JSDate::SIZE, JSType::JS_DATE, proto); JSHandle date = JSHandle::Cast(factory->NewJSObjectWithInit(dateClass)); date->SetTimeValue(thread, JSTaggedValue(0.0)); date->SetLocalOffset(thread, JSTaggedValue(0.0)); @@ -769,7 +769,7 @@ HWTEST_F_L0(EcmaDumpTest, HeapProfileDump) } case JSType::HCLASS: { CHECK_DUMP_FIELDS(TaggedObject::TaggedObjectSize(), JSHClass::SIZE, 7U); - JSHandle hclass = factory->NewEcmaDynClass(JSHClass::SIZE, JSType::HCLASS, proto); + JSHandle hclass = factory->NewEcmaHClass(JSHClass::SIZE, JSType::HCLASS, proto); DUMP_FOR_HANDLE(hclass) break; } @@ -907,7 +907,7 @@ HWTEST_F_L0(EcmaDumpTest, HeapProfileDump) #endif JSHandle pendingClass(thread, JSHClass::Cast(globalConst->GetPendingJobClass().GetTaggedObject())); - JSHandle pendingJob(thread, factory->NewDynObject(pendingClass)); + JSHandle pendingJob(thread, factory->NewObject(pendingClass)); ecmascript::job::PendingJob::Cast(*pendingJob)->SetJob(thread, JSTaggedValue::Undefined()); ecmascript::job::PendingJob::Cast(*pendingJob)->SetArguments(thread, JSTaggedValue::Undefined()); DUMP_FOR_HANDLE(pendingJob) diff --git a/ecmascript/tests/js_api_deque_iterator_test.cpp b/ecmascript/tests/js_api_deque_iterator_test.cpp index 4b1c831405..c657379a40 100644 --- a/ecmascript/tests/js_api_deque_iterator_test.cpp +++ b/ecmascript/tests/js_api_deque_iterator_test.cpp @@ -55,7 +55,7 @@ protected: JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); JSHandle proto = env->GetFunctionPrototype(); - JSHandle dequeClass = factory->NewEcmaDynClass(JSAPIDeque::SIZE, JSType::JS_API_DEQUE, proto); + JSHandle dequeClass = factory->NewEcmaHClass(JSAPIDeque::SIZE, JSType::JS_API_DEQUE, proto); JSHandle jsDeque = JSHandle::Cast(factory->NewJSObject(dequeClass)); JSHandle newElements = factory->NewTaggedArray(JSAPIDeque::DEFAULT_CAPACITY_LENGTH); jsDeque->SetFirst(0); diff --git a/ecmascript/tests/js_function_test.cpp b/ecmascript/tests/js_function_test.cpp index d9d0bc72d7..32989609bc 100644 --- a/ecmascript/tests/js_function_test.cpp +++ b/ecmascript/tests/js_function_test.cpp @@ -71,7 +71,7 @@ HWTEST_F_L0(JSFunctionTest, Create) JSHandle env = ecmaVM->GetGlobalEnv(); JSHandle funHandle = thread->GetEcmaVM()->GetFactory()->NewJSFunction(env); EXPECT_TRUE(*funHandle != nullptr); - EXPECT_EQ(funHandle->GetProtoOrDynClass(), JSTaggedValue::Hole()); + EXPECT_EQ(funHandle->GetProtoOrHClass(), JSTaggedValue::Hole()); JSHandle lexicalEnv = thread->GetEcmaVM()->GetFactory()->NewLexicalEnv(0); funHandle->SetLexicalEnv(thread, lexicalEnv.GetTaggedValue()); @@ -134,9 +134,9 @@ HWTEST_F_L0(JSFunctionTest, Invoke) { EcmaVM *ecmaVM = thread->GetEcmaVM(); JSHandle env = ecmaVM->GetGlobalEnv(); - JSHandle dynclass(thread, JSObjectCreate(thread)); + JSHandle hclass(thread, JSObjectCreate(thread)); JSHandle callee( - thread->GetEcmaVM()->GetFactory()->NewJSObjectByConstructor(JSHandle::Cast(dynclass), dynclass)); + thread->GetEcmaVM()->GetFactory()->NewJSObjectByConstructor(JSHandle::Cast(hclass), hclass)); EXPECT_TRUE(*callee != nullptr); char keyArray[] = "invoked"; diff --git a/ecmascript/tests/js_generator_object_test.cpp b/ecmascript/tests/js_generator_object_test.cpp index bf71dac86f..c7c4c3c730 100644 --- a/ecmascript/tests/js_generator_object_test.cpp +++ b/ecmascript/tests/js_generator_object_test.cpp @@ -83,8 +83,8 @@ HWTEST_F_L0(JSGeneratorObjectTest, GeneratorValidate_003) auto factory = vm->GetFactory(); auto env = vm->GetGlobalEnv(); JSHandle genClass = - factory->NewEcmaDynClass(JSObject::SIZE, JSType::JS_GENERATOR_OBJECT, env->GetGeneratorFunctionPrototype()); - TaggedObject *genObjectHeader = factory->NewDynObject(genClass); + factory->NewEcmaHClass(JSObject::SIZE, JSType::JS_GENERATOR_OBJECT, env->GetGeneratorFunctionPrototype()); + TaggedObject *genObjectHeader = factory->NewObject(genClass); JSHandle genObj(thread, JSGeneratorObject::Cast(genObjectHeader)); JSGeneratorState state = JSGeneratorObject::GeneratorValidate(thread, JSHandle::Cast(genObj)); EXPECT_EQ(state, JSGeneratorState::SUSPENDED_YIELD); diff --git a/ecmascript/tests/js_hclass_test.cpp b/ecmascript/tests/js_hclass_test.cpp index c03ea57070..92d436479b 100644 --- a/ecmascript/tests/js_hclass_test.cpp +++ b/ecmascript/tests/js_hclass_test.cpp @@ -57,19 +57,19 @@ HWTEST_F_L0(JSHClassTest, InitializeClass) EcmaVM *vm = thread->GetEcmaVM(); ObjectFactory *factory = vm->GetFactory(); JSHandle nullHandle(thread, JSTaggedValue::Null()); - // Call NewEcmaDynClass function set object properties - JSHandle objectDynclass = - factory->NewEcmaDynClass(TaggedArray::SIZE, JSType::TAGGED_ARRAY, nullHandle); + // Call NewEcmaHClass function set object properties + JSHandle objectClass = + factory->NewEcmaHClass(TaggedArray::SIZE, JSType::TAGGED_ARRAY, nullHandle); // Get object properties - EXPECT_EQ(objectDynclass->GetLayout(), JSTaggedValue::Null()); - EXPECT_EQ(objectDynclass->GetPrototype(), JSTaggedValue::Null()); - EXPECT_EQ(objectDynclass->GetObjectType(), JSType::TAGGED_ARRAY); - EXPECT_TRUE(objectDynclass->IsExtensible()); - EXPECT_TRUE(!objectDynclass->IsPrototype()); - EXPECT_EQ(objectDynclass->GetTransitions(), JSTaggedValue::Undefined()); - EXPECT_EQ(objectDynclass->GetProtoChangeMarker(), JSTaggedValue::Null()); - EXPECT_EQ(objectDynclass->GetProtoChangeDetails(), JSTaggedValue::Null()); - EXPECT_EQ(objectDynclass->GetEnumCache(), JSTaggedValue::Null()); + EXPECT_EQ(objectClass->GetLayout(), JSTaggedValue::Null()); + EXPECT_EQ(objectClass->GetPrototype(), JSTaggedValue::Null()); + EXPECT_EQ(objectClass->GetObjectType(), JSType::TAGGED_ARRAY); + EXPECT_TRUE(objectClass->IsExtensible()); + EXPECT_TRUE(!objectClass->IsPrototype()); + EXPECT_EQ(objectClass->GetTransitions(), JSTaggedValue::Undefined()); + EXPECT_EQ(objectClass->GetProtoChangeMarker(), JSTaggedValue::Null()); + EXPECT_EQ(objectClass->GetProtoChangeDetails(), JSTaggedValue::Null()); + EXPECT_EQ(objectClass->GetEnumCache(), JSTaggedValue::Null()); } HWTEST_F_L0(JSHClassTest, SizeFromJSHClass) @@ -78,31 +78,31 @@ HWTEST_F_L0(JSHClassTest, SizeFromJSHClass) ObjectFactory *factory = vm->GetFactory(); JSHandle nullHandle(thread, JSTaggedValue::Null()); - JSHandle objectDynclass = factory->NewEcmaDynClass(TaggedArray::SIZE, JSType::TAGGED_ARRAY, nullHandle); - EXPECT_TRUE(*objectDynclass != nullptr); + JSHandle objectClass = factory->NewEcmaHClass(TaggedArray::SIZE, JSType::TAGGED_ARRAY, nullHandle); + EXPECT_TRUE(*objectClass != nullptr); size_t objectSize; #ifndef PANDA_TARGET_32 - objectSize = objectDynclass->SizeFromJSHClass(*objectDynclass); + objectSize = objectClass->SizeFromJSHClass(*objectClass); EXPECT_EQ(objectSize, 40U); #endif - objectDynclass = factory->NewEcmaDynClass(EcmaString::SIZE, JSType::STRING, nullHandle); - objectSize = objectDynclass->SizeFromJSHClass(*objectDynclass); + objectClass = factory->NewEcmaHClass(EcmaString::SIZE, JSType::STRING, nullHandle); + objectSize = objectClass->SizeFromJSHClass(*objectClass); EXPECT_EQ(objectSize, 16U); - objectDynclass = factory->NewEcmaDynClass(MachineCode::SIZE, JSType::MACHINE_CODE_OBJECT, nullHandle); - objectSize = objectDynclass->SizeFromJSHClass(*objectDynclass); + objectClass = factory->NewEcmaHClass(MachineCode::SIZE, JSType::MACHINE_CODE_OBJECT, nullHandle); + objectSize = objectClass->SizeFromJSHClass(*objectClass); EXPECT_EQ(objectSize, 24U); // size is an integral multiple of eight - objectDynclass = factory->NewEcmaDynClass(JSObject::SIZE - 1, JSType::JS_OBJECT, nullHandle); - objectSize = objectDynclass->SizeFromJSHClass(*objectDynclass); + objectClass = factory->NewEcmaHClass(JSObject::SIZE - 1, JSType::JS_OBJECT, nullHandle); + objectSize = objectClass->SizeFromJSHClass(*objectClass); EXPECT_EQ(objectSize, 56U); - objectDynclass = factory->NewEcmaDynClass(JSObject::SIZE + 1, JSType::JS_OBJECT, nullHandle); - objectSize = objectDynclass->SizeFromJSHClass(*objectDynclass); + objectClass = factory->NewEcmaHClass(JSObject::SIZE + 1, JSType::JS_OBJECT, nullHandle); + objectSize = objectClass->SizeFromJSHClass(*objectClass); EXPECT_EQ(objectSize, 64U); - objectDynclass = factory->NewEcmaDynClass(JSObject::SIZE, JSType::JS_OBJECT, nullHandle); - objectSize = objectDynclass->SizeFromJSHClass(*objectDynclass); + objectClass = factory->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, nullHandle); + objectSize = objectClass->SizeFromJSHClass(*objectClass); EXPECT_EQ(objectSize, 64U); } @@ -112,13 +112,13 @@ HWTEST_F_L0(JSHClassTest, HasReferenceField) ObjectFactory *factory = vm->GetFactory(); JSHandle nullHandle(thread, JSTaggedValue::Null()); - JSHandle obj1Dynclass = factory->NewEcmaDynClass(TaggedArray::SIZE, JSType::STRING, nullHandle); - JSHandle obj2Dynclass = - factory->NewEcmaDynClass(TaggedArray::SIZE, JSType::JS_NATIVE_POINTER, nullHandle); - JSHandle obj3Dynclass = factory->NewEcmaDynClass(TaggedArray::SIZE, JSType::JS_OBJECT, nullHandle); - EXPECT_FALSE(obj1Dynclass->HasReferenceField()); - EXPECT_FALSE(obj2Dynclass->HasReferenceField()); - EXPECT_TRUE(obj3Dynclass->HasReferenceField()); + JSHandle obj1Class = factory->NewEcmaHClass(TaggedArray::SIZE, JSType::STRING, nullHandle); + JSHandle obj2Class = + factory->NewEcmaHClass(TaggedArray::SIZE, JSType::JS_NATIVE_POINTER, nullHandle); + JSHandle obj3Class = factory->NewEcmaHClass(TaggedArray::SIZE, JSType::JS_OBJECT, nullHandle); + EXPECT_FALSE(obj1Class->HasReferenceField()); + EXPECT_FALSE(obj2Class->HasReferenceField()); + EXPECT_TRUE(obj3Class->HasReferenceField()); } HWTEST_F_L0(JSHClassTest, Clone) @@ -127,29 +127,29 @@ HWTEST_F_L0(JSHClassTest, Clone) ObjectFactory *factory = vm->GetFactory(); JSHandle nullHandle(thread, JSTaggedValue::Null()); - JSHandle objectDynclass = factory->NewEcmaDynClass(JSObject::SIZE, JSType::JS_OBJECT, nullHandle); + JSHandle objectClass = factory->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, nullHandle); // withoutInlinedProperties is false - JSHandle cloneDynclass = JSHClass::Clone(thread, objectDynclass, false); - EXPECT_TRUE(*cloneDynclass != nullptr); - EXPECT_TRUE(objectDynclass->GetObjectSize() == cloneDynclass->GetObjectSize()); - EXPECT_EQ(cloneDynclass->GetObjectSize(), 64U); // 64 : 64 not missing the size of inlinedproperties - EXPECT_TRUE(objectDynclass->GetLayout() == cloneDynclass->GetLayout()); - EXPECT_EQ(JSTaggedValue::SameValue(objectDynclass->GetPrototype(), cloneDynclass->GetPrototype()), true); - EXPECT_TRUE(objectDynclass->GetBitField() == cloneDynclass->GetBitField()); - EXPECT_TRUE(objectDynclass->GetBitField1() == cloneDynclass->GetBitField1()); - EXPECT_TRUE(objectDynclass->NumberOfProps() == cloneDynclass->NumberOfProps()); - EXPECT_EQ(cloneDynclass->GetNextInlinedPropsIndex(), 0); // 0 : 0 mean index + JSHandle cloneClass = JSHClass::Clone(thread, objectClass, false); + EXPECT_TRUE(*cloneClass != nullptr); + EXPECT_TRUE(objectClass->GetObjectSize() == cloneClass->GetObjectSize()); + EXPECT_EQ(cloneClass->GetObjectSize(), 64U); // 64 : 64 not missing the size of inlinedproperties + EXPECT_TRUE(objectClass->GetLayout() == cloneClass->GetLayout()); + EXPECT_EQ(JSTaggedValue::SameValue(objectClass->GetPrototype(), cloneClass->GetPrototype()), true); + EXPECT_TRUE(objectClass->GetBitField() == cloneClass->GetBitField()); + EXPECT_TRUE(objectClass->GetBitField1() == cloneClass->GetBitField1()); + EXPECT_TRUE(objectClass->NumberOfProps() == cloneClass->NumberOfProps()); + EXPECT_EQ(cloneClass->GetNextInlinedPropsIndex(), 0); // 0 : 0 mean index // withoutInlinedProperties is true - cloneDynclass = JSHClass::Clone(thread, objectDynclass, true); - EXPECT_TRUE(*cloneDynclass != nullptr); - EXPECT_TRUE(objectDynclass->GetObjectSize() > cloneDynclass->GetObjectSize()); - EXPECT_EQ(cloneDynclass->GetObjectSize(), 32U); // 32 : 32 missing the size of inlinedproperties - EXPECT_TRUE(objectDynclass->GetLayout() == cloneDynclass->GetLayout()); - EXPECT_EQ(JSTaggedValue::SameValue(objectDynclass->GetPrototype(), cloneDynclass->GetPrototype()), true); - EXPECT_TRUE(objectDynclass->GetBitField() == cloneDynclass->GetBitField()); - EXPECT_TRUE(objectDynclass->GetBitField1() > cloneDynclass->GetBitField1()); - EXPECT_TRUE(objectDynclass->NumberOfProps() == cloneDynclass->NumberOfProps()); - EXPECT_EQ(cloneDynclass->GetNextNonInlinedPropsIndex(), 0); // 0 : 0 mean index + cloneClass = JSHClass::Clone(thread, objectClass, true); + EXPECT_TRUE(*cloneClass != nullptr); + EXPECT_TRUE(objectClass->GetObjectSize() > cloneClass->GetObjectSize()); + EXPECT_EQ(cloneClass->GetObjectSize(), 32U); // 32 : 32 missing the size of inlinedproperties + EXPECT_TRUE(objectClass->GetLayout() == cloneClass->GetLayout()); + EXPECT_EQ(JSTaggedValue::SameValue(objectClass->GetPrototype(), cloneClass->GetPrototype()), true); + EXPECT_TRUE(objectClass->GetBitField() == cloneClass->GetBitField()); + EXPECT_TRUE(objectClass->GetBitField1() > cloneClass->GetBitField1()); + EXPECT_TRUE(objectClass->NumberOfProps() == cloneClass->NumberOfProps()); + EXPECT_EQ(cloneClass->GetNextNonInlinedPropsIndex(), 0); // 0 : 0 mean index } HWTEST_F_L0(JSHClassTest, TransitionElementsToDictionary) @@ -191,7 +191,7 @@ static JSHandle CreateJSHClass(JSThread *thread) JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); JSHandle objectFuncPrototype = env->GetObjectFunctionPrototype(); - JSHandle hclass = factory->NewEcmaDynClass(JSObject::SIZE, JSType::JS_OBJECT, objectFuncPrototype); + JSHandle hclass = factory->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, objectFuncPrototype); return hclass; } @@ -205,7 +205,7 @@ HWTEST_F_L0(JSHClassTest, SetPropertyOfObjHClass_001) JSHandle keyHandle2(factory->NewFromASCII("key2")); JSHandle keyHandle4(factory->NewFromASCII("key4")); // empty layoutInfo - JSHandle parentsDynclass = CreateJSHClass(thread); + JSHandle parentsClass = CreateJSHClass(thread); uint32_t length = 6; JSHandle properties = factory->NewTaggedArray(length); @@ -219,8 +219,8 @@ HWTEST_F_L0(JSHClassTest, SetPropertyOfObjHClass_001) } properties->Set(thread, i, accessorData.GetTaggedValue()); } - JSHandle childDynclass = factory->SetLayoutInObjHClass(properties, 3, parentsDynclass); - JSHandle childObj = factory->NewJSObject(childDynclass); + JSHandle childClass = factory->SetLayoutInObjHClass(properties, 3, parentsClass); + JSHandle childObj = factory->NewJSObject(childClass); std::vector keyVector; JSObject::GetAllKeys(childObj, keyVector); @@ -234,9 +234,9 @@ HWTEST_F_L0(JSHClassTest, SetPropertyOfObjHClass_002) { EcmaVM *vm = thread->GetEcmaVM(); ObjectFactory *factory = vm->GetFactory(); - JSHandle objDynclass = CreateJSHClass(thread); - JSHandle Obj1 = factory->NewJSObject(objDynclass); - JSHandle Obj2 = factory->NewJSObject(objDynclass); + JSHandle objClass = CreateJSHClass(thread); + JSHandle Obj1 = factory->NewJSObject(objClass); + JSHandle Obj2 = factory->NewJSObject(objClass); PropertyAttributes attr = PropertyAttributes::Default(); JSHandle keyE(factory->NewFromASCII("e")); @@ -245,11 +245,11 @@ HWTEST_F_L0(JSHClassTest, SetPropertyOfObjHClass_002) JSObject::SetProperty(thread, Obj1, keyE, JSHandle(thread, JSTaggedValue(7))); JSObject::SetProperty(thread, Obj2, keyF, JSHandle(thread, JSTaggedValue(8))); - JSHandle propertyHclass = JSHClass::SetPropertyOfObjHClass(thread, objDynclass, keyE, attr); + JSHandle propertyHclass = JSHClass::SetPropertyOfObjHClass(thread, objClass, keyE, attr); JSHandle obj1Class(thread, Obj1->GetClass()); EXPECT_TRUE(propertyHclass == obj1Class); - propertyHclass = JSHClass::SetPropertyOfObjHClass(thread, objDynclass, keyF, attr); + propertyHclass = JSHClass::SetPropertyOfObjHClass(thread, objClass, keyF, attr); JSHandle obj2Class(thread, Obj2->GetClass()); EXPECT_TRUE(propertyHclass == obj2Class); } @@ -265,10 +265,10 @@ HWTEST_F_L0(JSHClassTest, AddProperty) PropertyAttributes attr = PropertyAttributes::Default(); attr.SetIsInlinedProps(true); // empty layoutInfo - JSHandle objDynclass = CreateJSHClass(thread); - JSHandle Obj = factory->NewJSObject(objDynclass); + JSHandle objClass1 = CreateJSHClass(thread); + JSHandle Obj = factory->NewJSObject(objClass1); JSHandle objClass(thread, Obj->GetClass()); - EXPECT_FALSE(objDynclass != objClass); + EXPECT_FALSE(objClass1 != objClass); int keyLength = 3; for (int i = 0; i keyValue(thread, JSTaggedValue(i)); @@ -277,7 +277,7 @@ HWTEST_F_L0(JSHClassTest, AddProperty) attr.SetOffset(i); JSHClass::AddProperty(thread, Obj, keyHandleI, attr); } - EXPECT_TRUE(objDynclass == objClass); + EXPECT_TRUE(objClass1 == objClass); std::vector keyVector; JSObject::GetAllKeys(Obj, keyVector); EXPECT_EQ(keyVector.size(), 3U); @@ -296,23 +296,23 @@ HWTEST_F_L0(JSHClassTest, TransitionExtension) JSHandle keyHandle2(factory->NewFromASCII("key2")); PropertyAttributes attr = PropertyAttributes(0); attr.SetIsInlinedProps(true); - JSHandle obj1DynClass = CreateJSHClass(thread); - JSHandle obj2DynClass = CreateJSHClass(thread); - obj2DynClass->SetExtensible(true); - JSHandle Obj1 = factory->NewJSObject(obj1DynClass); - JSHandle Obj2 = factory->NewJSObject(obj2DynClass); + JSHandle obj1Class = CreateJSHClass(thread); + JSHandle obj2Class = CreateJSHClass(thread); + obj2Class->SetExtensible(true); + JSHandle Obj1 = factory->NewJSObject(obj1Class); + JSHandle Obj2 = factory->NewJSObject(obj2Class); JSObject::SetProperty(thread, Obj2, keyHandle0, JSHandle(thread, JSTaggedValue(7))); JSObject::SetProperty(thread, Obj2, keyHandle1, JSHandle(thread, JSTaggedValue(8))); JSObject::SetProperty(thread, Obj2, keyHandle2, JSHandle(thread, JSTaggedValue(9))); // obj has key "PreventExtensions" JSHClass::AddProperty(thread, Obj1, preExtensionsKey, attr); - JSHandle newDynClass1 = JSHClass::TransitionExtension(thread, obj1DynClass); + JSHandle newClass1 = JSHClass::TransitionExtension(thread, obj1Class); JSHandle objClass(thread, Obj1->GetClass()); - EXPECT_TRUE(newDynClass1 == objClass); + EXPECT_TRUE(newClass1 == objClass); // obj has no key "PreventExtensions" - JSHandle newDynClass2 = JSHClass::TransitionExtension(thread, obj2DynClass); - EXPECT_FALSE(newDynClass2->IsExtensible()); - JSHandle dictionary(thread, obj2DynClass->GetTransitions()); + JSHandle newClass2 = JSHClass::TransitionExtension(thread, obj2Class); + EXPECT_FALSE(newClass2->IsExtensible()); + JSHandle dictionary(thread, obj2Class->GetTransitions()); // find key std::vector keyVector; dictionary->GetAllKeysIntoVector(keyVector); @@ -332,15 +332,15 @@ HWTEST_F_L0(JSHClassTest, TransitionProto) JSHandle obj3Key(factory->NewFromASCII("key2")); PropertyAttributes attr = PropertyAttributes(0); attr.SetIsInlinedProps(true); - JSHandle objDynClass = CreateJSHClass(thread); - JSHandle Obj = factory->NewJSObject(objDynClass); + JSHandle objClass = CreateJSHClass(thread); + JSHandle Obj = factory->NewJSObject(objClass); // obj has no key "prototype" JSHClass::AddProperty(thread, Obj, obj1Key, attr); JSHClass::AddProperty(thread, Obj, obj2Key, attr); JSHClass::AddProperty(thread, Obj, obj3Key, attr); - JSHandle newDynClass = JSHClass::TransitionProto(thread, objDynClass, funcPrototype); - EXPECT_EQ(newDynClass->GetPrototype(), funcPrototype.GetTaggedValue()); - JSHandle transitionDictionary(thread, objDynClass->GetTransitions()); + JSHandle newClass = JSHClass::TransitionProto(thread, objClass, funcPrototype); + EXPECT_EQ(newClass->GetPrototype(), funcPrototype.GetTaggedValue()); + JSHandle transitionDictionary(thread, objClass->GetTransitions()); // find key std::vector keyVector; transitionDictionary->GetAllKeysIntoVector(keyVector); @@ -357,13 +357,13 @@ HWTEST_F_L0(JSHClassTest, TransitionToDictionary) JSHandle obj2Key(factory->NewFromASCII("key2")); JSHandle obj3Key(factory->NewFromASCII("key3")); JSHandle nullHandle(thread, JSTaggedValue::Null()); - JSHandle objDynclass = CreateJSHClass(thread); - objDynclass->SetIsPrototype(true); - JSHandle Obj0 = factory->NewJSObject(objDynclass); - JSHandle obj0Dynclass(thread, Obj0->GetJSHClass()); + JSHandle objClass = CreateJSHClass(thread); + objClass->SetIsPrototype(true); + JSHandle Obj0 = factory->NewJSObject(objClass); + JSHandle obj0Class1(thread, Obj0->GetJSHClass()); JSHandle Obj1 = JSObject::ObjectCreate(thread, nullHandle); JSHandle Obj2 = JSObject::ObjectCreate(thread, Obj1); - JSHandle obj2Dynclass(thread, Obj2->GetJSHClass()); + JSHandle obj2Class(thread, Obj2->GetJSHClass()); JSHandle Obj3 = JSObject::ObjectCreate(thread, Obj2); JSObject::SetProperty(thread, Obj1, obj1Key, JSHandle(thread, JSTaggedValue(100))); JSObject::SetProperty(thread, Obj2, obj2Key, JSHandle(thread, JSTaggedValue(101))); @@ -371,17 +371,17 @@ HWTEST_F_L0(JSHClassTest, TransitionToDictionary) // empty object JSHClass::TransitionToDictionary(thread, Obj0); JSHandle obj0Class(thread, Obj0->GetClass()); - EXPECT_TRUE(obj0Class->GetObjectSize() < obj0Dynclass->GetObjectSize()); + EXPECT_TRUE(obj0Class->GetObjectSize() < obj0Class1->GetObjectSize()); EXPECT_EQ(obj0Class->NumberOfProps(), 0U); EXPECT_TRUE(obj0Class->IsDictionaryMode()); EXPECT_TRUE(obj0Class->IsPrototype()); // not empty object - JSHandle obj3Dynclass(thread, Obj3->GetJSHClass()); - JSHClass::EnableProtoChangeMarker(thread, obj3Dynclass); + JSHandle obj3Class(thread, Obj3->GetJSHClass()); + JSHClass::EnableProtoChangeMarker(thread, obj3Class); JSHClass::TransitionToDictionary(thread, Obj2); // refresh users - JSHandle obj1Dynclass(thread, Obj1->GetJSHClass()); - JSTaggedValue protoDetails = obj1Dynclass->GetProtoChangeDetails(); + JSHandle obj1Class(thread, Obj1->GetJSHClass()); + JSTaggedValue protoDetails = obj1Class->GetProtoChangeDetails(); EXPECT_TRUE(protoDetails.IsProtoChangeDetails()); JSTaggedValue listenersValue = ProtoChangeDetails::Cast(protoDetails.GetTaggedObject())->GetChangeListener(); JSHandle listeners(thread, listenersValue.GetTaggedObject()); @@ -389,7 +389,7 @@ HWTEST_F_L0(JSHClassTest, TransitionToDictionary) EXPECT_TRUE(holeIndex == 0U); // new class JSHandle newClass(thread, Obj2->GetClass()); - EXPECT_TRUE(newClass->GetObjectSize() < obj2Dynclass->GetObjectSize()); + EXPECT_TRUE(newClass->GetObjectSize() < obj2Class->GetObjectSize()); EXPECT_EQ(newClass->NumberOfProps(), 0U); EXPECT_TRUE(newClass->IsDictionaryMode()); EXPECT_TRUE(newClass->IsPrototype()); @@ -403,13 +403,13 @@ HWTEST_F_L0(JSHClassTest, UpdatePropertyMetaData) PropertyAttributes oldAttr = PropertyAttributes(0); PropertyAttributes newAttr = PropertyAttributes(1); oldAttr.SetIsInlinedProps(true); - JSHandle objDynClass = CreateJSHClass(thread); - JSHandle Obj = factory->NewJSObject(objDynClass); + JSHandle objClass = CreateJSHClass(thread); + JSHandle Obj = factory->NewJSObject(objClass); // Set Transitions JSHClass::AddProperty(thread, Obj, objKey, oldAttr); // update metaData - objDynClass->UpdatePropertyMetaData(thread, objKey.GetTaggedValue(), newAttr); - LayoutInfo *layoutInfo = LayoutInfo::Cast(objDynClass->GetLayout().GetTaggedObject()); + objClass->UpdatePropertyMetaData(thread, objKey.GetTaggedValue(), newAttr); + LayoutInfo *layoutInfo = LayoutInfo::Cast(objClass->GetLayout().GetTaggedObject()); EXPECT_EQ(layoutInfo->GetAttr(oldAttr.GetOffset()).GetPropertyMetaData(), newAttr.GetPropertyMetaData()); } @@ -421,9 +421,9 @@ HWTEST_F_L0(JSHClassTest, SetPrototype) JSHandle nullHandle(thread, JSTaggedValue::Null()); JSHandle objectFuncPrototype = env->GetObjectFunctionPrototype(); - JSHandle objectDynclass = factory->NewEcmaDynClass(JSObject::SIZE, JSType::JS_OBJECT, nullHandle); - EXPECT_EQ(objectDynclass->GetPrototype(), nullHandle.GetTaggedValue()); - objectDynclass->SetPrototype(thread, objectFuncPrototype); - EXPECT_EQ(objectDynclass->GetPrototype(), objectFuncPrototype.GetTaggedValue()); + JSHandle objectClass = factory->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, nullHandle); + EXPECT_EQ(objectClass->GetPrototype(), nullHandle.GetTaggedValue()); + objectClass->SetPrototype(thread, objectFuncPrototype); + EXPECT_EQ(objectClass->GetPrototype(), objectFuncPrototype.GetTaggedValue()); } } // namespace panda::test \ No newline at end of file diff --git a/ecmascript/tests/js_object_test.cpp b/ecmascript/tests/js_object_test.cpp index 1d41718d6e..5b7067d277 100644 --- a/ecmascript/tests/js_object_test.cpp +++ b/ecmascript/tests/js_object_test.cpp @@ -508,9 +508,9 @@ HWTEST_F_L0(JSObjectTest, EnumerableOwnNames) HWTEST_F_L0(JSObjectTest, SetIntegrityLevelSealed) { - JSHandle dynclass1(thread, JSObjectTestCreate(thread)); + JSHandle hclass1(thread, JSObjectTestCreate(thread)); JSHandle obj1 = - thread->GetEcmaVM()->GetFactory()->NewJSObjectByConstructor(JSHandle(dynclass1), dynclass1); + thread->GetEcmaVM()->GetFactory()->NewJSObjectByConstructor(JSHandle(hclass1), hclass1); EXPECT_TRUE(*obj1 != nullptr); CString undefinedCStr = "x"; JSHandle key1(thread->GetEcmaVM()->GetFactory()->NewFromASCII(&undefinedCStr[0])); @@ -533,9 +533,9 @@ HWTEST_F_L0(JSObjectTest, SetIntegrityLevelSealed) HWTEST_F_L0(JSObjectTest, SetIntegrityLevelFrozen) { - JSHandle dynclass1(thread, JSObjectTestCreate(thread)); + JSHandle hclass1(thread, JSObjectTestCreate(thread)); JSHandle obj1 = - thread->GetEcmaVM()->GetFactory()->NewJSObjectByConstructor(JSHandle(dynclass1), dynclass1); + thread->GetEcmaVM()->GetFactory()->NewJSObjectByConstructor(JSHandle(hclass1), hclass1); EXPECT_TRUE(*obj1 != nullptr); CString undefinedCStr = "x"; @@ -558,9 +558,9 @@ HWTEST_F_L0(JSObjectTest, SetIntegrityLevelFrozen) HWTEST_F_L0(JSObjectTest, TestIntegrityLevelSealed) { - JSHandle dynclass1(thread, JSObjectTestCreate(thread)); + JSHandle hclass1(thread, JSObjectTestCreate(thread)); JSHandle obj1 = - thread->GetEcmaVM()->GetFactory()->NewJSObjectByConstructor(JSHandle(dynclass1), dynclass1); + thread->GetEcmaVM()->GetFactory()->NewJSObjectByConstructor(JSHandle(hclass1), hclass1); CString undefinedCStr = "level"; JSHandle key1(thread->GetEcmaVM()->GetFactory()->NewFromASCII(&undefinedCStr[0])); JSHandle value1(thread, JSTaggedValue(1)); @@ -582,9 +582,9 @@ HWTEST_F_L0(JSObjectTest, TestIntegrityLevelSealed) HWTEST_F_L0(JSObjectTest, TestIntegrityLevelFrozen) { - JSHandle dynclass1(thread, JSObjectTestCreate(thread)); + JSHandle hclass1(thread, JSObjectTestCreate(thread)); JSHandle obj1 = - thread->GetEcmaVM()->GetFactory()->NewJSObjectByConstructor(JSHandle(dynclass1), dynclass1); + thread->GetEcmaVM()->GetFactory()->NewJSObjectByConstructor(JSHandle(hclass1), hclass1); CString undefinedCStr = "level"; JSHandle key1(thread->GetEcmaVM()->GetFactory()->NewFromASCII(&undefinedCStr[0])); JSHandle value1(thread, JSTaggedValue(1)); @@ -606,9 +606,9 @@ HWTEST_F_L0(JSObjectTest, TestIntegrityLevelFrozen) HWTEST_F_L0(JSObjectTest, TestIntegrityLevelWithoutProperty) { - JSHandle dynclass1(thread, JSObjectTestCreate(thread)); + JSHandle hclass1(thread, JSObjectTestCreate(thread)); JSHandle obj1( - thread->GetEcmaVM()->GetFactory()->NewJSObjectByConstructor(JSHandle(dynclass1), dynclass1)); + thread->GetEcmaVM()->GetFactory()->NewJSObjectByConstructor(JSHandle(hclass1), hclass1)); JSHandle::Cast(obj1)->GetJSHClass()->SetExtensible(false); CString undefinedCStr = "level"; JSHandle key1(thread->GetEcmaVM()->GetFactory()->NewFromASCII(&undefinedCStr[0])); @@ -638,9 +638,9 @@ JSTaggedValue TestGetter(EcmaRuntimeCallInfo *argv) HWTEST_F_L0(JSObjectTest, Getter) { - JSHandle dynclass1(thread, JSObjectTestCreate(thread)); + JSHandle hclass1(thread, JSObjectTestCreate(thread)); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHandle obj = factory->NewJSObjectByConstructor(JSHandle(dynclass1), dynclass1); + JSHandle obj = factory->NewJSObjectByConstructor(JSHandle(hclass1), hclass1); JSHandle key1(factory->NewFromASCII("x")); JSHandle key2(factory->NewFromASCII("y")); JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); @@ -676,9 +676,9 @@ JSTaggedValue TestSetter(EcmaRuntimeCallInfo *argv) HWTEST_F_L0(JSObjectTest, Setter) { - JSHandle dynclass1(thread, JSObjectTestCreate(thread)); + JSHandle hclass1(thread, JSObjectTestCreate(thread)); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHandle obj = factory->NewJSObjectByConstructor(JSHandle(dynclass1), dynclass1); + JSHandle obj = factory->NewJSObjectByConstructor(JSHandle(hclass1), hclass1); JSHandle key1(factory->NewFromASCII("x")); JSHandle key2(factory->NewFromASCII("y")); JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); @@ -748,9 +748,9 @@ JSTaggedValue TestUndefinedSetter([[maybe_unused]] EcmaRuntimeCallInfo *argv) HWTEST_F_L0(JSObjectTest, GetterIsUndefined) { - JSHandle dynclass1(thread, JSObjectTestCreate(thread)); + JSHandle hclass1(thread, JSObjectTestCreate(thread)); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHandle obj = factory->NewJSObjectByConstructor(JSHandle(dynclass1), dynclass1); + JSHandle obj = factory->NewJSObjectByConstructor(JSHandle(hclass1), hclass1); JSHandle key(factory->NewFromASCII("property")); JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); JSHandle getter = @@ -781,9 +781,9 @@ HWTEST_F_L0(JSObjectTest, GetterIsUndefined) HWTEST_F_L0(JSObjectTest, SetterIsUndefined) { - JSHandle dynclass1(thread, JSObjectTestCreate(thread)); + JSHandle hclass1(thread, JSObjectTestCreate(thread)); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHandle obj = factory->NewJSObjectByConstructor(JSHandle(dynclass1), dynclass1); + JSHandle obj = factory->NewJSObjectByConstructor(JSHandle(hclass1), hclass1); JSHandle key(factory->NewFromASCII("property")); JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); JSHandle getter = @@ -934,10 +934,10 @@ HWTEST_F_L0(JSObjectTest, ElementFastToSlow) JSObject::SetProperty(thread, JSHandle(obj1), keyStr, key2); JSObject::SetProperty(thread, JSHandle(obj1), key0, key0); EXPECT_TRUE(!TaggedArray::Cast(obj1->GetElements().GetTaggedObject())->IsDictionaryMode()); - JSHandle dynClass(thread, obj1->GetJSHClass()); + JSHandle hclass(thread, obj1->GetJSHClass()); JSObject::SetProperty(thread, JSHandle(obj1), key1, key1); EXPECT_TRUE(!TaggedArray::Cast(obj1->GetElements().GetTaggedObject())->IsDictionaryMode()); - EXPECT_EQ(obj1->GetJSHClass(), *dynClass); + EXPECT_EQ(obj1->GetJSHClass(), *hclass); JSObject::SetProperty(thread, JSHandle(obj1), key2000, key2000); EXPECT_TRUE(TaggedArray::Cast(obj1->GetElements().GetTaggedObject())->IsDictionaryMode()); @@ -948,10 +948,10 @@ HWTEST_F_L0(JSObjectTest, ElementFastToSlow) JSHandle obj2 = factory->NewJSObjectByConstructor(JSHandle(objFunc), objFunc); JSObject::SetProperty(thread, JSHandle(obj2), key0, key0); EXPECT_TRUE(!TaggedArray::Cast(obj2->GetElements().GetTaggedObject())->IsDictionaryMode()); - JSHandle dynClass2(thread, obj2->GetJSHClass()); + JSHandle hclass2(thread, obj2->GetJSHClass()); JSObject::SetProperty(thread, JSHandle(obj2), key2, key2); EXPECT_TRUE(!TaggedArray::Cast(obj2->GetElements().GetTaggedObject())->IsDictionaryMode()); - EXPECT_EQ(obj2->GetJSHClass(), *dynClass2); + EXPECT_EQ(obj2->GetJSHClass(), *hclass2); // test change attr JSHandle obj3 = factory->NewJSObjectByConstructor(JSHandle(objFunc), objFunc); JSObject::SetProperty(thread, JSHandle(obj3), key0, key0); @@ -1003,25 +1003,25 @@ HWTEST_F_L0(JSObjectTest, EnableProtoChangeMarker) JSObject::SetProperty(thread, JSHandle(obj1), obj1Key, obj1Value); JSObject::SetProperty(thread, JSHandle(obj2), obj2Key, obj2Value); JSObject::SetProperty(thread, JSHandle(obj3), obj3Key, obj3Value); - JSHandle obj3Dynclass(thread, obj3->GetJSHClass()); - JSHandle resultMarker = JSHClass::EnableProtoChangeMarker(thread, obj3Dynclass); + JSHandle obj3Class(thread, obj3->GetJSHClass()); + JSHandle resultMarker = JSHClass::EnableProtoChangeMarker(thread, obj3Class); EXPECT_TRUE(resultMarker->IsProtoChangeMarker()); bool hasChanged = ProtoChangeMarker::Cast(resultMarker->GetTaggedObject())->GetHasChanged(); EXPECT_TRUE(!hasChanged); - JSHandle obj1Dynclass(thread, obj1->GetJSHClass()); - JSHandle obj2Dynclass(thread, obj2->GetJSHClass()); - JSTaggedValue obj2Marker = obj2Dynclass->GetProtoChangeMarker(); + JSHandle obj1Class(thread, obj1->GetJSHClass()); + JSHandle obj2Class(thread, obj2->GetJSHClass()); + JSTaggedValue obj2Marker = obj2Class->GetProtoChangeMarker(); EXPECT_TRUE(obj2Marker.IsProtoChangeMarker()); bool hasChanged2 = ProtoChangeMarker::Cast(obj2Marker.GetTaggedObject())->GetHasChanged(); EXPECT_TRUE(!hasChanged2); - JSTaggedValue obj1Marker = obj1Dynclass->GetProtoChangeMarker(); + JSTaggedValue obj1Marker = obj1Class->GetProtoChangeMarker(); EXPECT_TRUE(!obj1Marker.IsProtoChangeMarker()); - JSTaggedValue protoDetails2 = obj2Dynclass->GetProtoChangeDetails(); + JSTaggedValue protoDetails2 = obj2Class->GetProtoChangeDetails(); EXPECT_TRUE(protoDetails2.IsProtoChangeDetails()); - JSTaggedValue protoDetails1 = obj1Dynclass->GetProtoChangeDetails(); + JSTaggedValue protoDetails1 = obj1Class->GetProtoChangeDetails(); EXPECT_TRUE(protoDetails1.IsProtoChangeDetails()); JSTaggedValue listeners1 = ProtoChangeDetails::Cast(protoDetails1.GetTaggedObject())->GetChangeListener(); EXPECT_TRUE(listeners1 != JSTaggedValue::Undefined()); @@ -1029,7 +1029,7 @@ HWTEST_F_L0(JSObjectTest, EnableProtoChangeMarker) EXPECT_TRUE(listeners2 == JSTaggedValue::Undefined()); uint32_t index = ProtoChangeDetails::Cast(protoDetails2.GetTaggedObject())->GetRegisterIndex(); JSTaggedValue listenersResult = ChangeListener::Cast(listeners1.GetTaggedObject())->Get(index); - EXPECT_TRUE(listenersResult == obj2Dynclass.GetTaggedValue()); + EXPECT_TRUE(listenersResult == obj2Class.GetTaggedValue()); } HWTEST_F_L0(JSObjectTest, BuildRegisterTree) @@ -1067,49 +1067,49 @@ HWTEST_F_L0(JSObjectTest, BuildRegisterTree) JSObject::SetProperty(thread, JSHandle(obj6), obj6Key, obj6Value); JSObject::SetProperty(thread, JSHandle(obj7), obj7Key, obj7Value); - JSHandle obj1Dynclass(thread, obj1->GetJSHClass()); - JSHandle obj2Dynclass(thread, obj2->GetJSHClass()); - JSHandle obj3Dynclass(thread, obj3->GetJSHClass()); - JSHandle obj4Dynclass(thread, obj4->GetJSHClass()); - JSHandle obj5Dynclass(thread, obj5->GetJSHClass()); - JSHandle obj6Dynclass(thread, obj6->GetJSHClass()); - JSHandle obj7Dynclass(thread, obj7->GetJSHClass()); + JSHandle obj1Class(thread, obj1->GetJSHClass()); + JSHandle obj2Class(thread, obj2->GetJSHClass()); + JSHandle obj3Class(thread, obj3->GetJSHClass()); + JSHandle obj4Class(thread, obj4->GetJSHClass()); + JSHandle obj5Class(thread, obj5->GetJSHClass()); + JSHandle obj6Class(thread, obj6->GetJSHClass()); + JSHandle obj7Class(thread, obj7->GetJSHClass()); - JSHandle result3Marker = JSHClass::EnableProtoChangeMarker(thread, obj3Dynclass); - JSHandle result5Marker = JSHClass::EnableProtoChangeMarker(thread, obj5Dynclass); + JSHandle result3Marker = JSHClass::EnableProtoChangeMarker(thread, obj3Class); + JSHandle result5Marker = JSHClass::EnableProtoChangeMarker(thread, obj5Class); EXPECT_TRUE(result3Marker->IsProtoChangeMarker()); EXPECT_TRUE(!(ProtoChangeMarker::Cast(result3Marker->GetTaggedObject())->GetHasChanged())); EXPECT_TRUE(result5Marker->IsProtoChangeMarker()); EXPECT_TRUE(!(ProtoChangeMarker::Cast(result5Marker->GetTaggedObject())->GetHasChanged())); - EXPECT_TRUE(obj4Dynclass->GetProtoChangeMarker().IsProtoChangeMarker()); - EXPECT_TRUE(!obj6Dynclass->GetProtoChangeMarker().IsProtoChangeMarker()); + EXPECT_TRUE(obj4Class->GetProtoChangeMarker().IsProtoChangeMarker()); + EXPECT_TRUE(!obj6Class->GetProtoChangeMarker().IsProtoChangeMarker()); - JSHandle result7Marker = JSHClass::EnableProtoChangeMarker(thread, obj7Dynclass); + JSHandle result7Marker = JSHClass::EnableProtoChangeMarker(thread, obj7Class); EXPECT_TRUE(result7Marker->IsProtoChangeMarker()); EXPECT_TRUE(!(ProtoChangeMarker::Cast(result7Marker->GetTaggedObject())->GetHasChanged())); - JSTaggedValue protoDetails1 = obj1Dynclass->GetProtoChangeDetails(); + JSTaggedValue protoDetails1 = obj1Class->GetProtoChangeDetails(); EXPECT_TRUE(protoDetails1.IsProtoChangeDetails()); JSTaggedValue listeners1Value = ProtoChangeDetails::Cast(protoDetails1.GetTaggedObject())->GetChangeListener(); EXPECT_TRUE(listeners1Value != JSTaggedValue(0)); JSHandle listeners1(thread, listeners1Value.GetTaggedObject()); - JSTaggedValue protoDetails2 = obj2Dynclass->GetProtoChangeDetails(); + JSTaggedValue protoDetails2 = obj2Class->GetProtoChangeDetails(); EXPECT_TRUE(protoDetails2.IsProtoChangeDetails()); uint32_t index2 = ProtoChangeDetails::Cast(protoDetails2.GetTaggedObject())->GetRegisterIndex(); - EXPECT_TRUE(listeners1->Get(index2) == obj2Dynclass.GetTaggedValue()); + EXPECT_TRUE(listeners1->Get(index2) == obj2Class.GetTaggedValue()); JSTaggedValue listeners2Value = ProtoChangeDetails::Cast(protoDetails2.GetTaggedObject())->GetChangeListener(); EXPECT_TRUE(listeners2Value != JSTaggedValue(0)); JSHandle listeners2(thread, listeners2Value.GetTaggedObject()); - JSTaggedValue protoDetails4 = obj4Dynclass->GetProtoChangeDetails(); - JSTaggedValue protoDetails6 = obj6Dynclass->GetProtoChangeDetails(); + JSTaggedValue protoDetails4 = obj4Class->GetProtoChangeDetails(); + JSTaggedValue protoDetails6 = obj6Class->GetProtoChangeDetails(); EXPECT_TRUE(protoDetails4.IsProtoChangeDetails()); EXPECT_TRUE(protoDetails6.IsProtoChangeDetails()); uint32_t index4 = ProtoChangeDetails::Cast(protoDetails4.GetTaggedObject())->GetRegisterIndex(); - EXPECT_TRUE(listeners2->Get(index4) == obj4Dynclass.GetTaggedValue()); + EXPECT_TRUE(listeners2->Get(index4) == obj4Class.GetTaggedValue()); uint32_t index6 = ProtoChangeDetails::Cast(protoDetails6.GetTaggedObject())->GetRegisterIndex(); - EXPECT_TRUE(listeners2->Get(index6) == obj6Dynclass.GetTaggedValue()); + EXPECT_TRUE(listeners2->Get(index6) == obj6Class.GetTaggedValue()); EXPECT_TRUE(listeners1->GetEnd() == 1U); EXPECT_TRUE(listeners2->GetEnd() == 2U); @@ -1150,21 +1150,21 @@ HWTEST_F_L0(JSObjectTest, NoticeThroughChain) JSObject::SetProperty(thread, JSHandle(obj6), obj6Key, obj6Value); JSObject::SetProperty(thread, JSHandle(obj7), obj7Key, obj7Value); - JSHandle obj1Dynclass(thread, obj1->GetJSHClass()); - JSHandle obj2Dynclass(thread, obj2->GetJSHClass()); - JSHandle obj3Dynclass(thread, obj3->GetJSHClass()); - JSHandle obj4Dynclass(thread, obj4->GetJSHClass()); - JSHandle obj5Dynclass(thread, obj5->GetJSHClass()); - JSHandle obj6Dynclass(thread, obj6->GetJSHClass()); - JSHandle obj7Dynclass(thread, obj7->GetJSHClass()); - - JSHClass::EnableProtoChangeMarker(thread, obj3Dynclass); - JSHClass::EnableProtoChangeMarker(thread, obj7Dynclass); - JSHClass::EnableProtoChangeMarker(thread, obj5Dynclass); - - JSHClass::NoticeThroughChain(thread, obj2Dynclass); - JSHClass::UnregisterOnProtoChain(thread, obj2Dynclass); - JSTaggedValue protoDetails1 = obj1Dynclass->GetProtoChangeDetails(); + JSHandle obj1Class(thread, obj1->GetJSHClass()); + JSHandle obj2Class(thread, obj2->GetJSHClass()); + JSHandle obj3Class(thread, obj3->GetJSHClass()); + JSHandle obj4Class(thread, obj4->GetJSHClass()); + JSHandle obj5Class(thread, obj5->GetJSHClass()); + JSHandle obj6Class(thread, obj6->GetJSHClass()); + JSHandle obj7Class(thread, obj7->GetJSHClass()); + + JSHClass::EnableProtoChangeMarker(thread, obj3Class); + JSHClass::EnableProtoChangeMarker(thread, obj7Class); + JSHClass::EnableProtoChangeMarker(thread, obj5Class); + + JSHClass::NoticeThroughChain(thread, obj2Class); + JSHClass::UnregisterOnProtoChain(thread, obj2Class); + JSTaggedValue protoDetails1 = obj1Class->GetProtoChangeDetails(); EXPECT_TRUE(protoDetails1.IsProtoChangeDetails()); JSTaggedValue listeners1Value = ProtoChangeDetails::Cast(protoDetails1.GetTaggedObject())->GetChangeListener(); EXPECT_TRUE(listeners1Value != JSTaggedValue(0)); @@ -1172,19 +1172,19 @@ HWTEST_F_L0(JSObjectTest, NoticeThroughChain) uint32_t holeIndex = ChangeListener::CheckHole(listeners1); EXPECT_TRUE(holeIndex == 0U); - JSTaggedValue protoDetails2 = obj2Dynclass->GetProtoChangeDetails(); + JSTaggedValue protoDetails2 = obj2Class->GetProtoChangeDetails(); EXPECT_TRUE(protoDetails2.IsProtoChangeDetails()); JSTaggedValue listeners2Value = ProtoChangeDetails::Cast(protoDetails2.GetTaggedObject())->GetChangeListener(); EXPECT_TRUE(listeners2Value != JSTaggedValue(0)); uint32_t index2 = ProtoChangeDetails::Cast(protoDetails2.GetTaggedObject())->GetRegisterIndex(); EXPECT_TRUE(listeners1->Get(index2) == JSTaggedValue::Hole()); - JSTaggedValue obj6Marker = obj6Dynclass->GetProtoChangeMarker(); + JSTaggedValue obj6Marker = obj6Class->GetProtoChangeMarker(); EXPECT_TRUE(obj6Marker.IsProtoChangeMarker()); bool hasChanged6 = ProtoChangeMarker::Cast(obj6Marker.GetTaggedObject())->GetHasChanged(); EXPECT_TRUE(hasChanged6); - JSTaggedValue obj4Marker = obj4Dynclass->GetProtoChangeMarker(); + JSTaggedValue obj4Marker = obj4Class->GetProtoChangeMarker(); EXPECT_TRUE(obj4Marker.IsProtoChangeMarker()); bool hasChanged4 = ProtoChangeMarker::Cast(obj4Marker.GetTaggedObject())->GetHasChanged(); EXPECT_TRUE(hasChanged4); @@ -1225,39 +1225,39 @@ HWTEST_F_L0(JSObjectTest, ChangeProtoAndNoticeTheChain) JSObject::SetProperty(thread, JSHandle(obj6), obj6Key, obj6Value); JSObject::SetProperty(thread, JSHandle(obj7), obj7Key, obj7Value); - JSHandle obj5Dynclass(thread, obj5->GetJSHClass()); - JSHandle obj7Dynclass(thread, obj7->GetJSHClass()); + JSHandle obj5Class(thread, obj5->GetJSHClass()); + JSHandle obj7Class(thread, obj7->GetJSHClass()); - JSHClass::EnableProtoChangeMarker(thread, obj7Dynclass); - JSHClass::EnableProtoChangeMarker(thread, obj5Dynclass); + JSHClass::EnableProtoChangeMarker(thread, obj7Class); + JSHClass::EnableProtoChangeMarker(thread, obj5Class); JSObject::SetPrototype(thread, obj2, JSHandle(obj3)); - JSHandle obj1Dynclass(thread, obj1->GetJSHClass()); - JSHandle obj2Dynclass(thread, obj2->GetJSHClass()); - JSHandle obj3Dynclass(thread, obj3->GetJSHClass()); - JSHandle obj4Dynclass(thread, obj4->GetJSHClass()); - JSHandle obj6Dynclass(thread, obj6->GetJSHClass()); + JSHandle obj1Class(thread, obj1->GetJSHClass()); + JSHandle obj2Class(thread, obj2->GetJSHClass()); + JSHandle obj3Class(thread, obj3->GetJSHClass()); + JSHandle obj4Class(thread, obj4->GetJSHClass()); + JSHandle obj6Class(thread, obj6->GetJSHClass()); - JSTaggedValue obj6Marker = obj6Dynclass->GetProtoChangeMarker(); + JSTaggedValue obj6Marker = obj6Class->GetProtoChangeMarker(); EXPECT_TRUE(obj6Marker.IsProtoChangeMarker()); bool hasChanged6 = ProtoChangeMarker::Cast(obj6Marker.GetTaggedObject())->GetHasChanged(); EXPECT_TRUE(hasChanged6); - JSTaggedValue obj4Marker = obj4Dynclass->GetProtoChangeMarker(); + JSTaggedValue obj4Marker = obj4Class->GetProtoChangeMarker(); EXPECT_TRUE(obj4Marker.IsProtoChangeMarker()); bool hasChanged4 = ProtoChangeMarker::Cast(obj4Marker.GetTaggedObject())->GetHasChanged(); EXPECT_TRUE(hasChanged4); - JSTaggedValue protoDetails1 = obj1Dynclass->GetProtoChangeDetails(); + JSTaggedValue protoDetails1 = obj1Class->GetProtoChangeDetails(); EXPECT_TRUE(protoDetails1.IsProtoChangeDetails()); - JSTaggedValue protoDetails2 = obj2Dynclass->GetProtoChangeDetails(); + JSTaggedValue protoDetails2 = obj2Class->GetProtoChangeDetails(); EXPECT_TRUE(protoDetails2.IsProtoChangeDetails()); - JSTaggedValue protoDetails3 = obj3Dynclass->GetProtoChangeDetails(); + JSTaggedValue protoDetails3 = obj3Class->GetProtoChangeDetails(); EXPECT_TRUE(protoDetails3.IsProtoChangeDetails()); - JSTaggedValue protoDetails4 = obj4Dynclass->GetProtoChangeDetails(); + JSTaggedValue protoDetails4 = obj4Class->GetProtoChangeDetails(); EXPECT_TRUE(protoDetails4.IsProtoChangeDetails()); - JSTaggedValue protoDetails6 = obj6Dynclass->GetProtoChangeDetails(); + JSTaggedValue protoDetails6 = obj6Class->GetProtoChangeDetails(); EXPECT_TRUE(protoDetails6.IsProtoChangeDetails()); JSTaggedValue listeners1 = ProtoChangeDetails::Cast(protoDetails1.GetTaggedObject())->GetChangeListener(); @@ -1277,10 +1277,10 @@ HWTEST_F_L0(JSObjectTest, ChangeProtoAndNoticeTheChain) JSTaggedValue result4 = ChangeListener::Cast(listeners2.GetTaggedObject())->Get(index4); JSTaggedValue result6 = ChangeListener::Cast(listeners2.GetTaggedObject())->Get(index6); - EXPECT_TRUE(result2 == obj2Dynclass.GetTaggedValue()); - EXPECT_TRUE(result3 == obj3Dynclass.GetTaggedValue()); - EXPECT_TRUE(result4 == obj4Dynclass.GetTaggedValue()); - EXPECT_TRUE(result6 == obj6Dynclass.GetTaggedValue()); + EXPECT_TRUE(result2 == obj2Class.GetTaggedValue()); + EXPECT_TRUE(result3 == obj3Class.GetTaggedValue()); + EXPECT_TRUE(result4 == obj4Class.GetTaggedValue()); + EXPECT_TRUE(result6 == obj6Class.GetTaggedValue()); } HWTEST_F_L0(JSObjectTest, NativePointerField) @@ -1305,7 +1305,7 @@ static JSHandle CreateTestHClass(JSThread *thread) JSHandle globalEnv = thread->GetEcmaVM()->GetGlobalEnv(); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); JSHandle objectFuncPrototype = globalEnv->GetObjectFunctionPrototype(); - JSHandle hclass = factory->NewEcmaDynClass(JSObject::SIZE, JSType::JS_OBJECT, objectFuncPrototype); + JSHandle hclass = factory->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, objectFuncPrototype); return hclass; } diff --git a/ecmascript/tests/js_proxy_test.cpp b/ecmascript/tests/js_proxy_test.cpp index 2a188dd4c7..bf09b94b44 100644 --- a/ecmascript/tests/js_proxy_test.cpp +++ b/ecmascript/tests/js_proxy_test.cpp @@ -67,9 +67,9 @@ static JSFunction *JSObjectTestCreate(JSThread *thread) HWTEST_F_L0(JSProxyTest, ProxyCreate) { - JSHandle dynclass(thread, JSObjectTestCreate(thread)); + JSHandle hclass(thread, JSObjectTestCreate(thread)); JSHandle targetHandle( - thread->GetEcmaVM()->GetFactory()->NewJSObjectByConstructor(JSHandle::Cast(dynclass), dynclass)); + thread->GetEcmaVM()->GetFactory()->NewJSObjectByConstructor(JSHandle::Cast(hclass), hclass)); JSHandle key(thread->GetEcmaVM()->GetFactory()->NewFromASCII("x")); JSHandle value(thread, JSTaggedValue(1)); @@ -77,7 +77,7 @@ HWTEST_F_L0(JSProxyTest, ProxyCreate) EXPECT_EQ(JSObject::GetProperty(thread, targetHandle, key).GetValue()->GetInt(), 1); JSHandle handlerHandle( - thread->GetEcmaVM()->GetFactory()->NewJSObjectByConstructor(JSHandle::Cast(dynclass), dynclass)); + thread->GetEcmaVM()->GetFactory()->NewJSObjectByConstructor(JSHandle::Cast(hclass), hclass)); EXPECT_TRUE(handlerHandle->IsECMAObject()); JSHandle proxyHandle = JSProxy::ProxyCreate(thread, targetHandle, handlerHandle); @@ -100,8 +100,8 @@ HWTEST_F_L0(JSProxyTest, GetProperty) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); // 1. handler has no "get" - JSHandle dynclass(thread, JSObjectTestCreate(thread)); - JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle hclass(thread, JSObjectTestCreate(thread)); + JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(targetHandle->IsECMAObject()); JSHandle key(factory->NewFromASCII("x")); @@ -109,7 +109,7 @@ HWTEST_F_L0(JSProxyTest, GetProperty) JSObject::SetProperty(thread, targetHandle, key, value); EXPECT_EQ(JSObject::GetProperty(thread, targetHandle, key).GetValue()->GetInt(), 1); - JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(handlerHandle->IsECMAObject()); JSHandle proxyHandle = JSProxy::ProxyCreate(thread, targetHandle, handlerHandle); @@ -141,8 +141,8 @@ HWTEST_F_L0(JSProxyTest, GetOwnProperty) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); // 1. handler has no "get" - JSHandle dynclass(thread, JSObjectTestCreate(thread)); - JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle hclass(thread, JSObjectTestCreate(thread)); + JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(targetHandle->IsECMAObject()); JSHandle key(factory->NewFromASCII("x")); @@ -150,7 +150,7 @@ HWTEST_F_L0(JSProxyTest, GetOwnProperty) JSObject::SetProperty(thread, targetHandle, key, value); EXPECT_EQ(JSObject::GetProperty(thread, targetHandle, key).GetValue()->GetInt(), 1); - JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(handlerHandle->IsECMAObject()); JSHandle proxyHandle = JSProxy::ProxyCreate(thread, targetHandle, handlerHandle); @@ -185,14 +185,14 @@ HWTEST_F_L0(JSProxyTest, SetProperty) // 1. handler has no "get" ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); // 1. handler has no "get" - JSHandle dynclass(thread, JSObjectTestCreate(thread)); - JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle hclass(thread, JSObjectTestCreate(thread)); + JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(targetHandle->IsECMAObject()); JSHandle key(factory->NewFromASCII("x")); JSHandle value(thread, JSTaggedValue(1)); - JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(handlerHandle->IsECMAObject()); JSHandle proxyHandle = JSProxy::ProxyCreate(thread, targetHandle, handlerHandle); @@ -226,14 +226,14 @@ HWTEST_F_L0(JSProxyTest, DefineOwnProperty) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); // 1. handler has no "defineProperty" - JSHandle dynclass(thread, JSObjectTestCreate(thread)); - JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle hclass(thread, JSObjectTestCreate(thread)); + JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(targetHandle->IsECMAObject()); JSHandle key(factory->NewFromASCII("x")); JSHandle value(thread, JSTaggedValue(1)); - JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(handlerHandle->IsECMAObject()); JSHandle proxyHandle = JSProxy::ProxyCreate(thread, targetHandle, handlerHandle); @@ -268,14 +268,14 @@ HWTEST_F_L0(JSProxyTest, DeleteProperty) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); // 1. handler has no "deleteProperty" - JSHandle dynclass(thread, JSObjectTestCreate(thread)); - JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle hclass(thread, JSObjectTestCreate(thread)); + JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(targetHandle->IsECMAObject()); JSHandle key(factory->NewFromASCII("x")); JSHandle value(thread, JSTaggedValue(1)); - JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(handlerHandle->IsECMAObject()); JSHandle proxyHandle = JSProxy::ProxyCreate(thread, targetHandle, handlerHandle); @@ -315,15 +315,15 @@ HWTEST_F_L0(JSProxyTest, GetPrototypeOf) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); // 1. handler has no "GetPrototypeOf" - JSHandle dynclass(thread, JSObjectTestCreate(thread)); - JSHandle proto(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); - JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle hclass(thread, JSObjectTestCreate(thread)); + JSHandle proto(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); + JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(targetHandle->IsECMAObject()); JSObject::SetPrototype(thread, JSHandle(targetHandle), proto); EXPECT_TRUE( JSTaggedValue::SameValue(JSTaggedValue::GetPrototype(thread, targetHandle), proto.GetTaggedValue())); - JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(handlerHandle->IsECMAObject()); JSHandle proxyHandle = JSProxy::ProxyCreate(thread, targetHandle, handlerHandle); @@ -353,12 +353,12 @@ HWTEST_F_L0(JSProxyTest, SetPrototypeOf) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); // 1. handler has no "SetPrototypeOf" - JSHandle dynclass(thread, JSObjectTestCreate(thread)); - JSHandle proto(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); - JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle hclass(thread, JSObjectTestCreate(thread)); + JSHandle proto(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); + JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(targetHandle->IsECMAObject()); - JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(handlerHandle->IsECMAObject()); JSHandle proxyHandle = JSProxy::ProxyCreate(thread, targetHandle, handlerHandle); @@ -390,11 +390,11 @@ HWTEST_F_L0(JSProxyTest, IsExtensible) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); // 1. handler has no "IsExtensible" - JSHandle dynclass(thread, JSObjectTestCreate(thread)); - JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle hclass(thread, JSObjectTestCreate(thread)); + JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(targetHandle->IsECMAObject()); - JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(handlerHandle->IsECMAObject()); JSHandle proxyHandle = JSProxy::ProxyCreate(thread, targetHandle, handlerHandle); @@ -426,11 +426,11 @@ HWTEST_F_L0(JSProxyTest, PreventExtensions) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); // 1. handler has no "PreventExtensions" - JSHandle dynclass(thread, JSObjectTestCreate(thread)); - JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle hclass(thread, JSObjectTestCreate(thread)); + JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(targetHandle->IsECMAObject()); - JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(handlerHandle->IsECMAObject()); JSHandle proxyHandle = JSProxy::ProxyCreate(thread, targetHandle, handlerHandle); @@ -464,15 +464,15 @@ HWTEST_F_L0(JSProxyTest, HasProperty) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); // 1. handler has no "HasProperty" - JSHandle dynclass(thread, JSObjectTestCreate(thread)); - JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle hclass(thread, JSObjectTestCreate(thread)); + JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(targetHandle->IsECMAObject()); JSHandle key(factory->NewFromASCII("x")); PropertyDescriptor desc(thread, JSHandle(thread, JSTaggedValue(1))); JSObject::DefineOwnProperty(thread, JSHandle::Cast(targetHandle), key, desc); - JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(handlerHandle->IsECMAObject()); JSHandle proxyHandle = JSProxy::ProxyCreate(thread, targetHandle, handlerHandle); @@ -505,15 +505,15 @@ HWTEST_F_L0(JSProxyTest, OwnPropertyKeys) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); // 1. handler has no "OwnPropertyKeys" - JSHandle dynclass(thread, JSObjectTestCreate(thread)); - JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle hclass(thread, JSObjectTestCreate(thread)); + JSHandle targetHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(targetHandle->IsECMAObject()); JSHandle key(factory->NewFromASCII("x")); PropertyDescriptor desc(thread, JSHandle(thread, JSTaggedValue(1))); JSObject::DefineOwnProperty(thread, JSHandle::Cast(targetHandle), key, desc); - JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(handlerHandle->IsECMAObject()); JSHandle proxyHandle = JSProxy::ProxyCreate(thread, targetHandle, handlerHandle); @@ -550,11 +550,11 @@ HWTEST_F_L0(JSProxyTest, Call) ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); // 1. handler has no "Call" - JSHandle dynclass(thread, JSObjectTestCreate(thread)); + JSHandle hclass(thread, JSObjectTestCreate(thread)); JSHandle targetHandle(factory->NewJSFunction(env, reinterpret_cast(HandlerFunction))); EXPECT_TRUE(targetHandle->IsECMAObject()); - JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(handlerHandle->IsECMAObject()); JSHandle proxyHandle = JSProxy::ProxyCreate(thread, targetHandle, handlerHandle); @@ -586,8 +586,8 @@ JSTaggedValue HandlerConstruct([[maybe_unused]] EcmaRuntimeCallInfo *argv) { auto thread = argv->GetThread(); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHandle dynclass(thread, JSObjectTestCreate(thread)); - JSHandle obj(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle hclass(thread, JSObjectTestCreate(thread)); + JSHandle obj(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); JSHandle key(factory->NewFromASCII("x")); PropertyDescriptor desc(thread, JSHandle(thread, JSTaggedValue(2))); // 2 : test case @@ -598,8 +598,8 @@ JSTaggedValue HandlerConFunc([[maybe_unused]] EcmaRuntimeCallInfo *argv) { auto thread = argv->GetThread(); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); - JSHandle dynclass(thread, JSObjectTestCreate(thread)); - JSHandle obj(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle hclass(thread, JSObjectTestCreate(thread)); + JSHandle obj(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); JSHandle key(factory->NewFromASCII("x")); PropertyDescriptor desc(thread, JSHandle(thread, JSTaggedValue(1))); @@ -613,12 +613,12 @@ HWTEST_F_L0(JSProxyTest, Construct) ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); // 1. handler has no "Construct" - JSHandle dynclass(thread, JSObjectTestCreate(thread)); + JSHandle hclass(thread, JSObjectTestCreate(thread)); JSHandle targetHandle(factory->NewJSFunction(env, reinterpret_cast(HandlerConFunc))); JSHandle::Cast(targetHandle)->GetJSHClass()->SetConstructor(true); EXPECT_TRUE(targetHandle->IsECMAObject()); - JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(dynclass), dynclass)); + JSHandle handlerHandle(factory->NewJSObjectByConstructor(JSHandle(hclass), hclass)); EXPECT_TRUE(handlerHandle->IsECMAObject()); JSHandle proxyHandle = JSProxy::ProxyCreate(thread, targetHandle, handlerHandle); diff --git a/ecmascript/tests/object_factory_test.cpp b/ecmascript/tests/object_factory_test.cpp index 900d5212be..4d40861d3b 100644 --- a/ecmascript/tests/object_factory_test.cpp +++ b/ecmascript/tests/object_factory_test.cpp @@ -114,7 +114,7 @@ HWTEST_F_L0(ObjectFactoryTest, NewJSFunction) // check feild EXPECT_EQ(newFun->GetProperties(), thread->GlobalConstants()->GetEmptyArray()); EXPECT_EQ(newFun->GetElements(), thread->GlobalConstants()->GetEmptyArray()); - EXPECT_EQ(newFun->GetProtoOrDynClass(), JSTaggedValue::Hole()); + EXPECT_EQ(newFun->GetProtoOrHClass(), JSTaggedValue::Hole()); EXPECT_EQ(newFun->GetHomeObject(), JSTaggedValue::Undefined()); EXPECT_TRUE(JSTaggedValue(*newFun).IsJSFunction()); diff --git a/ecmascript/tests/weak_ref_old_gc_test.cpp b/ecmascript/tests/weak_ref_old_gc_test.cpp index a811859506..733f60dabb 100644 --- a/ecmascript/tests/weak_ref_old_gc_test.cpp +++ b/ecmascript/tests/weak_ref_old_gc_test.cpp @@ -129,7 +129,7 @@ HWTEST_F_L0(WeakRefOldGCTest, ArrayKeep) EXPECT_EQ(value, array->Get(1)); } -HWTEST_F_L0(WeakRefOldGCTest, DynObjectUndefined) +HWTEST_F_L0(WeakRefOldGCTest, ObjectUndefined) { JSHandle newObj1(thread, JSObjectTestCreate(thread)); JSTaggedValue array(ArrayTestCreate(thread)); @@ -140,7 +140,7 @@ HWTEST_F_L0(WeakRefOldGCTest, DynObjectUndefined) EXPECT_EQ(newObj1->GetElements(), JSTaggedValue::Undefined()); } -HWTEST_F_L0(WeakRefOldGCTest, DynObjectKeep) +HWTEST_F_L0(WeakRefOldGCTest, ObjectKeep) { JSHandle newObj1(thread, JSObjectTestCreate(thread)); JSHandle array(thread, ArrayTestCreate(thread)); diff --git a/ecmascript/tests/weak_ref_semi_gc_test.cpp b/ecmascript/tests/weak_ref_semi_gc_test.cpp index f817e7c786..8100ab807c 100644 --- a/ecmascript/tests/weak_ref_semi_gc_test.cpp +++ b/ecmascript/tests/weak_ref_semi_gc_test.cpp @@ -110,7 +110,7 @@ HWTEST_F_L0(WeakRefSemiGCTest, ArrayKeep) EXPECT_EQ(value, array->Get(1)); } -HWTEST_F_L0(WeakRefSemiGCTest, DynObjectUndefined) +HWTEST_F_L0(WeakRefSemiGCTest, ObjectUndefined) { JSHandle newObj1(thread, JSObjectTestCreate(thread)); JSTaggedValue array(ArrayTestCreate(thread)); @@ -121,7 +121,7 @@ HWTEST_F_L0(WeakRefSemiGCTest, DynObjectUndefined) EXPECT_EQ(newObj1->GetElements(), JSTaggedValue::Undefined()); } -HWTEST_F_L0(WeakRefSemiGCTest, DynObjectKeep) +HWTEST_F_L0(WeakRefSemiGCTest, ObjectKeep) { JSHandle newObj1(thread, JSObjectTestCreate(thread)); JSHandle array(thread, ArrayTestCreate(thread)); diff --git a/ecmascript/tests/weak_vector_test.cpp b/ecmascript/tests/weak_vector_test.cpp index 7c1db386b1..60ff071034 100644 --- a/ecmascript/tests/weak_vector_test.cpp +++ b/ecmascript/tests/weak_vector_test.cpp @@ -82,8 +82,8 @@ HWTEST_F_L0(WeakVectorTest, SetAndGet) JSHandle weakVector = WeakVector::Create(thread, weakVectorCapacity); JSHandle weakObj = factory->NewJSObjectByConstructor(JSHandle(objFun), objFun); - JSHandle weakObjDynclassVal(thread, weakObj->GetJSHClass()); - JSTaggedValue weakValue = JSTaggedValue(weakObjDynclassVal.GetTaggedValue().CreateAndGetWeakRef()); + JSHandle weakObjclassVal(thread, weakObj->GetJSHClass()); + JSTaggedValue weakValue = JSTaggedValue(weakObjclassVal.GetTaggedValue().CreateAndGetWeakRef()); // set weak value for (uint32_t i = 0; i < weakVectorCapacity; i++) { weakVector->Set(thread, i, weakValue); @@ -106,8 +106,8 @@ HWTEST_F_L0(WeakVectorTest, Grow) JSHandle objFun = env->GetStringFunction(); JSHandle weakObj = factory->NewJSObjectByConstructor(JSHandle(objFun), objFun); - JSHandle weakObjDynclassVal(thread, weakObj->GetJSHClass()); - JSTaggedValue weakValue = JSTaggedValue(weakObjDynclassVal.GetTaggedValue().CreateAndGetWeakRef()); + JSHandle weakObjclassVal(thread, weakObj->GetJSHClass()); + JSTaggedValue weakValue = JSTaggedValue(weakObjclassVal.GetTaggedValue().CreateAndGetWeakRef()); // test growing vector with null value uint32_t oldWeakVectorCapacity = 0; uint32_t newWeakVectorCapacity = 100; @@ -147,8 +147,8 @@ HWTEST_F_L0(WeakVectorTest, PushBack) JSHandle weakVector = WeakVector::Create(thread, weakVectorCapacity); JSHandle weakObj = factory->NewJSObjectByConstructor(JSHandle(objFun), objFun); - JSHandle weakObjDynclassVal(thread, weakObj->GetJSHClass()); - JSTaggedValue weakValue = JSTaggedValue(weakObjDynclassVal.GetTaggedValue().CreateAndGetWeakRef()); + JSHandle weakObjclassVal(thread, weakObj->GetJSHClass()); + JSTaggedValue weakValue = JSTaggedValue(weakObjclassVal.GetTaggedValue().CreateAndGetWeakRef()); // fill the value into the vector for (uint32_t i = 0; i < weakVectorCapacity; i++) { weakVector->Set(thread, i, weakValue); @@ -183,8 +183,8 @@ HWTEST_F_L0(WeakVectorTest, Delete) JSHandle weakVector = WeakVector::Create(thread, weakVectorCapacity); JSHandle weakObj = factory->NewJSObjectByConstructor(JSHandle(objFun), objFun); - JSHandle weakObjDynclassVal(thread, weakObj->GetJSHClass()); - JSTaggedValue weakValue = JSTaggedValue(weakObjDynclassVal.GetTaggedValue().CreateAndGetWeakRef()); + JSHandle weakObjclassVal(thread, weakObj->GetJSHClass()); + JSTaggedValue weakValue = JSTaggedValue(weakObjclassVal.GetTaggedValue().CreateAndGetWeakRef()); for (uint32_t i = 0; i < weakVectorCapacity; i++) { weakVector->PushBack(thread, weakValue); diff --git a/ecmascript/tooling/agent/runtime_impl.cpp b/ecmascript/tooling/agent/runtime_impl.cpp index bb8c886139..400f89c92a 100644 --- a/ecmascript/tooling/agent/runtime_impl.cpp +++ b/ecmascript/tooling/agent/runtime_impl.cpp @@ -318,7 +318,7 @@ void RuntimeImpl::GetProtoOrProtoType(Local value, bool isOwn, bool if (!isAccessorOnly && isOwn && !value->IsProxy()) { return; } - // Get Function ProtoOrDynClass + // Get Function ProtoOrHClass if (value->IsConstructor()) { Local prototype = Local(value)->GetFunctionPrototype(vm_); std::unique_ptr protoObj = RemoteObject::FromTagged(vm_, prototype); diff --git a/ecmascript/ts_types/ts_type.cpp b/ecmascript/ts_types/ts_type.cpp index ae3cbb6cc6..e20930b3cc 100644 --- a/ecmascript/ts_types/ts_type.cpp +++ b/ecmascript/ts_types/ts_type.cpp @@ -59,7 +59,7 @@ JSHClass *TSObjectType::CreateHClassByProps(JSThread *thread, JSHandleAddKey(thread, index, key.GetTaggedValue(), attributes); } - JSHandle hclass = factory->NewEcmaDynClass(JSObject::SIZE, JSType::JS_OBJECT, numOfProps); + JSHandle hclass = factory->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, numOfProps); hclass->SetLayout(thread, layout); hclass->SetNumberOfProps(numOfProps); hclass->SetAOT(true); -- Gitee