diff --git a/docs/development-example-zh.md b/docs/development-example-zh.md index ff42871fe20e2a4f84c7deb854059bcc4f38b66f..88d7f4d9d8e0bb65bef3a9ec3a76d1cf5aaaa64b 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 9ea827c8d49ceef699ea77da971803734b46a89f..c68fa6fa41883c225ceec353d994902abc0b9980 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 24dbd6b9137c1e9ad107588ce035fcd705db0278..9680de4ec9726611bea49865a63d6cf4129e4b94 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 79b8a535b99fa9deb47af1394d80c23b7ea6ad41..6ea90bf07af1820fa75921c91af81d3240154a02 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 5865b9877ba50f8f747d57970bb8916c6bb42e93..2890b07dbb92f7e134fa574c9b004fad524efc0e 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 37cac055b6dee59c53f7d4788e4f7db0fffc1eb2..f8a61226c3f78a3cfed38f9f76d2245a0ca8e7f9 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 22af3b6dac91005a89a691922c1ee07bafe17991..7d68dbf99d77ee2b6c2faf071dcae70e3843fa8e 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 ca3b983f90a5fdf5d4e887817688f8113401d055..7b574362813efa530e8ac55cb180f51e8ce1a8e1 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 93b4774a8da7972565ea1126d33da6757dbff06b..9a4abe77435d9ac4a0c74dc96c4cb161dc366747 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 d32c05ba73e88a02295f0a528963ff04390df0aa..f452084f0e0d7b8b047ab295df018efc80e870c8 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 58cc111c8f5eb44b540902929bcedaf5fa5a6db4..c43145fdf1afe94dd870fe39e78ad453a54cc237 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 13e63eded8121960b90ae4e0388bf7c43dedf0cf..d238e7835de726e53924a7d66dbc14a997abf190 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 e3a35d83334d23006f181e4d0c121a86baf394ff..143e0e5d789c855fbebb1e41853a1a080a63ad95 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 abd949420200898228469274d96100f2aa5483eb..58a21337f51629c8c37818befd9988fef42f9c96 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 d495898d12cdbdb8e1c4517610618a562e57364d..b0beb724f79b3b5748f39986a23cbc940ffff35a 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 4be933359b5296417b15fe087fdd1c897200eb8f..4de432b9ab242367a580c5ebad7b2b4a76e3c03b 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 fd12d3549b78424576350d76db54fcb76c059810..19995ce48700d9831cd43cda67a85b567b9e6ff8 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 54ed3b5d0b1571cf8bd130f9c1072cc62f1b4319..e773a01220ca0d956cfa034402f9bfbfb97d1fe9 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 f7d9337b1bf5323b37f1f8076f82d572902d1c2b..dbe99d674cb13e3da78616d69c18bd6f4b702822 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 0707ad4f94e3df16d5b822e9eeafbe4ba5501ebe..8ae0ef40bfaa3e4b3491550328fe5ce2dbacdf9e 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 a30d9ee187c8e06d41e588d0730b08d8947ddc20..9edcc2456de0bdafe530220831ffe58c8fc7a068 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 94b0ef63133734a2d97abb4b4dc054cbcd0901b9..d125ae5aa3614cf751cd79c33470193da784ea4c 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 8149b429c06d210ffd453be07b1d6ca4ce556697..8af5e58139e582bfc15c6a85ed41cd4364357dd5 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 c1e168e513ecccbd55247dcda5974f6eade1e575..c510422989d413dab343de450d0ffc5a6e8e62fc 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 e8b8c5f612557dd93c5fdc4620f6dd37755e1519..4ca03d49e35b1b4990b65199f9c456ad015a8cb3 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 6bf7d22084b732a708fd3da391f1eec0c60d6019..005ff1fa2e18a3032f77c2ca01570806fe43821b 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 20023c60f6631d9c0cc373db8a598d9aa687ca3d..424aa86119b1211ef0ee08d96713eef459a4d6f6 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 ee0a5cd3ebcfc8986e3e701d38bded984399d71f..1173fe8ce039b2bc8e44261a387a832cb7d57867 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 0dce4120fd2e888a89858e7389c1ccce3e4dbe48..898f9e65c546dda7429afdbdcaadddc6f527b27d 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 10ed5c1471bed6994334e21816044344290fa18e..c58c43a89826adc216305d9080a07848cf37eec4 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 02ea011e9fe634ae4d171d873072b0d27fa0e03a..0f7f02f02d7e54cde931aff6ff5a80c151f4ed18 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 90c4796b5cbb87f659290e79f80e669c20eee151..9548310e212601054e57870ca6a577ed54fcde17 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 f75adfd1d2a1de2d65565494eece44d00433631c..a18197cf8d6f7ca01a1504b05d2c2dccf433285b 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 9f397ae4e59030bac422e90ec53ff9ef62c60408..1c22f3e971e633ee11d1202c3fffffeec0a0dfae 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 4ac1bfceffd76a38e8ccf31d9a027c299e174458..453b58accc8aef2824ef5563365088017f47f7aa 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 18e47803d9ea7acfd7f377c95ffc7d1e2a618fb8..6d1174fb589267187f53baf2e6ca0acef178ba61 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 588d629921abe5ea8adb9f6baf4905b19f2dcfb8..f4ae33199fa5bac992536fc7ca299958e6b6ec82 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 7a734d84daf74969fb1794a82f9fd0957458f38a..40cb56bff71e19a4b53cad3ba514f9c2b776ea9d 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 2c919a242fec8766b51d2515584a9749e2e8faf8..b1041ad448117c0129e7c05d594cce8a7ce4766a 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 2500ddd52288f4afb3a079b51cd13eed05abe470..c88a0a03f1097b0bf93e1aa3f396c5292a52cb15 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 f56cdb7c5f0617408cd06bf73eecaaac007cd7c3..b2f922a3b2ce8f635184ea2f9347597dad9efc56 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 8b931c7ea8e567cce14979e5a55154999851ea2c..0cde733902cc565085d197398d670555e2b9e083 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 80fe61a21a6a5e65b1836eb0f0d9cd06fdb39fad..1f0ca14840d823272b836020f925b2cf58fb4f28 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 ad14ced151eb1ea350ebdbb2e4db5da0bc85a25e..9d595a1220722792ab88fee3d05b2de4df0b77ed 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 3ed2452e1ce4eafda535ba9fb1ce9a94d5b65d40..b2e4c35f66ab9bf2717c5f5a44b7762b74d9eddc 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 7b5a8cbd1b37f542396c2dd628e4d2e62bf98bc1..4d04fc8f90138c409dc45f5626a86fa6fa68df30 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 44a86493030df3a1a19ef0e4e6eb1e23d0f9da5b..6b85a7c82d88c40db29e7b82401f88553f05f6a9 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 0aa12643600f3284b2366e4b93a990f53fbcaa6b..ca57cefd9209a2a681e3b56ad7f7dd8b699d3b7b 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 96926dc6c166274d8e3f4725f25a3b242a9811f2..da181c8cdc4a1601ae05237b1c2c9472b9c62582 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 3c9fa81c007e7cdee6fbcd3894af94050589df0a..dc88cb5ceef4023338c20cd2c6534bc5adf341c0 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 c1e3a500bc0534758edae99a229d7b6abaf67cc1..92cd3e9071c47640865a49bce905ee1902728485 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 7992d170014b4dd329ec95b1c189821ef2a7aa7f..aca7d278ed93491b60ae20b360802b275bacbde3 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 108b6a66ea1dadb649f1af4a0fa64ec1ae2068f4..40eb0e7120ed9965f2f29d9c37070fb9fa415913 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 0aadb4694c2bed10dc491f271d9ef506662d39a9..4d4389ea732612d15f9934db46284619d4b8dcc7 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 c985b42196bd43265230dd6c33635c3d0a77fd51..770f175da8e40ec016db74278b4744b37083ec6e 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 72551a545ad2fd86653ea69d10c06743c34768e7..57a36265a112e898843ff4b1c7b1dc63ed968637 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 17c9c0dd7037d351a7a57a4e78691d09e9f3e282..de8adbda0e64b9f04b9c04d9ff58ebccb0f56ea6 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 f23962e2b8e4976c4526dc9a5ef581bac33d6c82..0959297c46ae267104d831e21905e814e00a615e 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 b4fbe01fae157b950922e41bb53027d462200ca8..29c676800ccdab0a4a2046401e4194183420b324 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 0fc501256ad1e7e6809869143d09da87e965fce7..a869ae88cbbbe70f9dd8c2578ed4efe5aed9792b 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 cf1a38a9196695b0dff360e909b44768c952b0e2..47d015a803bf07c25a7a1c05f926906a44feb0b9 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 720f652118a76f99c166e68ef05927a75b78fb4e..e8f807a0309c041409043277e571ae57962ccaaf 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 cec855986c312c716b507f725cd61e96fbb3f805..b7615d18a7e1869a03de61bacbc9311398e24741 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 109cadacd587d557fa1f60321584df2e15be1303..154fb91ed4d7c93779c8d3f36ac81ea0c0fd98dd 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 e1fc6cd03b6826223686d1614391aabee3327403..715745baa44016b7f0bd944d7a197b0be3250f2b 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 59578df51d2cd98bff5b6e3647e3645a7fe78ce5..64d28e54ed9f8631b3f84f995ab05ea985d1edf0 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 5a451c2b6af29aa95976a7b88b75c70958eb551f..ce7dd157a625c145ae69438484ab0eb5bc80a78e 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 a94b14eb887440cbfdb7fb6ecc2eee988b6245d9..4cdc1b2829765fb0ce72bcefaa2eebcf44becaf2 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 547b0c5c4b8ca065ab92645c849a485e09eeadab..4197c2fbab5504a922c7139bf5758d0477a8ba97 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 8c45b9ace589c344dbb9f0cd72bfae56843d14ff..cc498c86302129d4d4bd7388287638935ad05ed0 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 7bd5e5e0183afe042379a266fceb2290f3cfd6b6..17a57cf698fa6932aac6da94a18ae790a1399864 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 7f8e2ada4df015ec9f18967e39da6eb494196d3a..c3d1f9193b3f03fad383640773297ea8d7f4b0d8 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 0000000000000000000000000000000000000000..2eae976067c747f38be1437751d3f1b93b770d62 --- /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 4a0ffe72417c7d9f609810733b7b0211e8af895b..f47c6d974856531114c20f61f3d873da8c557614 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 347b260ce6ae741f93ab36c7c2911992cf9e961b..9d1ee583aca86eabeb6b6393745dc49be373b478 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 0000000000000000000000000000000000000000..beab15fb1a0439c6c7ecd98fb6538cb00783b169 --- /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 0000000000000000000000000000000000000000..df7cc3f8989479820f47ceb88e5cd948ca30945e --- /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 0000000000000000000000000000000000000000..65e356a2284cb47096aba19517d6f78f6f29365e --- /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 9a1dc0a7a7f676306771fe1dff3592e09aad1d30..c78e432af26b761431f801d82de9efbf2c64f2f0 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 0000000000000000000000000000000000000000..da798142e34abcb15e4ab3560227c0b224cf8596 --- /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 0000000000000000000000000000000000000000..445fd2896a6b4421e159e98af7f4ac35d42d7559 --- /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 d94416d475ada95c1e1dfcf6b0d1e64278f9cdb4..67a5be20b8736251c4f6c6910eeec39c1951e77c 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 a95dd56cdcdc6432209e30eb469e21d4c580925e..b777e721d48ab782f63eb67e9f06bb0a072aa3a8 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 fd0d5cf427fe00697efb533e34b6f2d50720a00c..8b764b107b79b0792372f1c56031826712bfef84 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 a0e293c76930e24ccd1a3b1e03dff299b6c8a2f2..237b013e4c5b6bc4b27babdc64336ab057ef5a4f 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 6f5d839f6569f04781aaaa35b4982514c1f7f9ad..2b413f478f18dcc21723e1c9f9529c75ea14a768 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 c6e68111bfe4cd92dc5a7f4415e85a67e48c5c02..6fa47769688975c13e0d8f0dd402c8bebcb5a1c8 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 693ba8b105c704fed66f8fe72a33f85608bd123c..0030433cc95ae8a3cac46f9790bea330f7a90f66 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 0000000000000000000000000000000000000000..aee0aabf24fa7a7487a1120eeeff759c17429e10 --- /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 0000000000000000000000000000000000000000..98db94e9ef166c2249656fd5a20b50634a97170c --- /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 0000000000000000000000000000000000000000..adcff51c0170ed322805a2b2672b6b2435456d99 --- /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 ef5ace4a55bff08bcaf373845d1e77491863b783..9bdfb856e6cc2fc1ff9a85cf2e1570237c5f226d 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 131e4be7f90de55113a39b9eca7f595afcc7b87f..8e69799aec0cfea47caa4f85ad0679306062ea35 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 d2e3bd9360990d880cde864d98de8c4017e1a65c..9b3682df153e08071e7bb1b6c256d154a3d21356 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 b4de70e4508ea47cfa174a4e6c4fa5fbe87386c0..1691866607328b1ac1495ab142e8c8e7a56438ad 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 689df96b9786bdb4c791c2468218e3a3ba1f08be..8ebeddec2241b3622c343fb2bfa305fb6040d595 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 fdd559f69c64690cdf57726447ccb44dad207117..c63a2c7c8a0249b940b4d5fe44161a007efd7d3d 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 bbe629eabf5a04f83dce3914418dc18a3d9e5028..4af046d058d606598181a4fbd207dee99c563104 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 ffa37fc09de7d21b0dc230572196edb9e7a70dfe..6fcfd0e0b113378e2de7fa31adc464785c27aea4 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 97ad832b3787326917f9fd80e25e4792c2ca26c3..eae252ee3fb39087f85efdc25ee9adef0241f18d 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 5f63ec39fd503aa7a1bc2875bf88ee2c531108b5..25f820b202e6b41d538a2b43a157596a794e6b28 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 9a82d43302a81993791a74ff750836f0ab6048d3..4c13974c1bab1c3f8b67603b4433c9129aef650b 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 0991e9f095fc141c3e5a6148620ec1bf8a0c3444..450e3c562d3c05ed81b1ecbb51880758bf0ba14e 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 1e6aa9d2be9f00fb3f3bbd66405ac3a1c7f62809..bd86e2a6c835f5965f088bb91dfa53633db85732 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 85a3ef82ec35c892599d7561c9465444cb0eb7f5..f0128e127d44a669ea77422eaccdc70d37d2df90 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 49c7b35f7aecf06e633b3855cacefdc174115ea1..a4d3af8a9f7c23134f390378d4041202561de60f 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 181b8a92a3b48b338d90a5f9f33c028a33ddd1fe..03aa3a4c90a971e94420f0d2042293eaf765aefa 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 0b64d3ec9757b02f7750c36c5aa109c1d4a366d2..cc7cba6241c9d087d71d0f15dbe0b303911000a6 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 c5dd5a0d0efe7ceb6d922309a29dd062880b604c..cd8359c568d5e0f276b09b33472f2028e7b543f4 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 12e8ea4a6adfb17e58576e72776a19029f04eeb3..aa32cc8dab319da4f8474c8931c4dac4614aad70 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 6d037b8e1314000de26fad39b81951cd4a2abba8..c04a65293960857e38e38c862185d4f6f06ba1eb 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 584b000d74280782e01b9126d524dfb963e47b6d..b76cd2f1ea1ead0d06449651cc5bda5bd3e60c96 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 d03d9928f0216f9f7a4a28457ea05f406cbb1e24..2eecdc4b8e16f2628bb28f2514365a8fb0e76093 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 55125536b683a956e2b570069a9a00d5bf56ddff..4676a541798eb941dd37f767f722d96a1fdd47d3 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 555cff45e9d92984f1736809e456742389a4a5b4..5c010464ed7e1258dcdd0404dea747929b001daf 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 7bdf07d5a816572d244c68a92819b99c24c985a9..92a02f6521a9c8948324cde971d0a43db8469db7 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 4b1c831405ad3004aa95e7094039c6d307dce55d..c657379a40177eb4f5b2db03e41a10f085a56907 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 d9d0bc72d78f5e7ac832d3363fab2231a48194ec..32989609bcfc1aad080ac9fbf8ab447adfdaa3f1 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 bf71dac86f3ed7ea13a57a4bcce6f181cd66f90b..c7c4c3c73068ce183a5fbb0a8f575591901735e1 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 c03ea57070317a95f29acf9927e2fce5b1cbd2c4..92d436479b62b775dd4ac9afb3114fa1554b02d4 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 1d41718d6e8f9359619a842577eac87497392c34..5b7067d277a8ddfe4c5f95724943b4bc225d675a 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 2a188dd4c7d56b3e9fc0627754509ac357389c5e..bf09b94b44c86e06376c39d2891f75891a9a7b59 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 900d5212be31bfe0b2b96981b1c4286e03f90c20..4d40861d3b75df6d0aab7795bed92cd2a77c323a 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 a8118595065a0cad4723fae691eb5db726f0e94f..733f60dabbfdcb973baeac60ce667d42edc2866b 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 f817e7c7868c813611efc6517e708df9de3f1366..8100ab807c820f084c39a0704d01079d3ff3dd0d 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 7c1db386b10615c007daac266bbcd37a3b77fb89..60ff07103479cf7fcbba97dc079c315e1780c763 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 bb8c8861391b844632434a90fc8d7a1fed761fda..400f89c92ac5335fde4e4bfd88c9029e011a68e5 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 ae3cbb6cc6852082153287ae50e3d0113f72f565..e20930b3ccb588ed5bcbaa65d627cce3d15e0957 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);