1/* 2 * Copyright (c) 2021-2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16#include <initializer_list> 17#include "ecmascript/base/number_helper.h" 18#include "ecmascript/compiler/access_object_stub_builder.h" 19#include "ecmascript/compiler/bc_call_signature.h" 20#include "ecmascript/compiler/call_stub_builder.h" 21#include "ecmascript/compiler/codegen/llvm/llvm_ir_builder.h" 22#include "ecmascript/compiler/ic_stub_builder.h" 23#include "ecmascript/compiler/interpreter_stub-inl.h" 24#include "ecmascript/compiler/new_object_stub_builder.h" 25#include "ecmascript/compiler/operations_stub_builder.h" 26#include "ecmascript/compiler/profiler_stub_builder.h" 27#include "ecmascript/compiler/stub_builder-inl.h" 28#include "ecmascript/compiler/variable_type.h" 29#include "ecmascript/dfx/vm_thread_control.h" 30#include "ecmascript/global_env_constants.h" 31#include "ecmascript/ic/profile_type_info.h" 32#include "ecmascript/interpreter/interpreter.h" 33#include "ecmascript/interpreter/interpreter_assembly.h" 34#include "ecmascript/js_array.h" 35#include "ecmascript/js_function.h" 36#include "ecmascript/js_generator_object.h" 37#include "ecmascript/message_string.h" 38#include "ecmascript/tagged_hash_table.h" 39#include "libpandafile/bytecode_instruction-inl.h" 40 41namespace panda::ecmascript::kungfu { 42#define DECLARE_ASM_HANDLER_BASE(name, needPrint, V, format) \ 43void name##StubBuilder::GenerateCircuit() \ 44{ \ 45 GateRef glue = PtrArgument(static_cast<size_t>(InterpreterHandlerInputs::GLUE)); \ 46 GateRef sp = PtrArgument(static_cast<size_t>(InterpreterHandlerInputs::SP)); \ 47 GateRef pc = PtrArgument(static_cast<size_t>(InterpreterHandlerInputs::PC)); \ 48 GateRef constpool = TaggedPointerArgument( \ 49 static_cast<size_t>(InterpreterHandlerInputs::CONSTPOOL)); \ 50 GateRef profileTypeInfo = TaggedPointerArgument( \ 51 static_cast<size_t>(InterpreterHandlerInputs::PROFILE_TYPE_INFO)); \ 52 GateRef acc = TaggedArgument(static_cast<size_t>(InterpreterHandlerInputs::ACC)); \ 53 GateRef hotnessCounter = Int32Argument( \ 54 static_cast<size_t>(InterpreterHandlerInputs::HOTNESS_COUNTER)); \ 55 DebugPrintInstruction<needPrint>(); \ 56 V(format) \ 57 GenerateCircuitImpl(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter, callback); \ 58} 59 60#define DECLARE_ASM_HANDLE_IMPLEMENT(name) \ 61void name##StubBuilder::GenerateCircuitImpl(GateRef glue, GateRef sp, GateRef pc, \ 62 GateRef constpool, GateRef profileTypeInfo, \ 63 GateRef acc, GateRef hotnessCounter, \ 64 [[maybe_unused]] ProfileOperation callback) 65 66#define REGISTER_PROFILE_CALL_BACK(format) \ 67 ProfileOperation callback( \ 68 [this, glue, sp, pc, profileTypeInfo](const std::initializer_list<GateRef> &values, OperationType type) { \ 69 ProfilerStubBuilder profiler(this); \ 70 profiler.PGOProfiler(glue, pc, GetFunctionFromFrame(GetFrame(sp)), profileTypeInfo, values, format, type); \ 71 }, nullptr); 72 73#define REGISTER_JIT_PROFILE_CALL_BACK(format) \ 74 ProfileOperation callback( \ 75 nullptr, \ 76 [this, glue, sp, pc, profileTypeInfo](const std::initializer_list<GateRef> &values, OperationType type) { \ 77 ProfilerStubBuilder profiler(this); \ 78 profiler.PGOProfiler(glue, pc, GetFunctionFromFrame(GetFrame(sp)), profileTypeInfo, values, format, type); \ 79 }); 80 81#define REGISTER_NULL_CALL_BACK(format) ProfileOperation callback; 82 83#define DECLARE_ASM_HANDLER(name) \ 84 DECLARE_ASM_HANDLER_BASE(name, true, REGISTER_NULL_CALL_BACK, SlotIDFormat::IMM8) \ 85 DECLARE_ASM_HANDLE_IMPLEMENT(name) 86 87#define DECLARE_ASM_HANDLER_NOPRINT(name) \ 88 DECLARE_ASM_HANDLER_BASE(name, false, REGISTER_NULL_CALL_BACK, SlotIDFormat::IMM8) \ 89 DECLARE_ASM_HANDLE_IMPLEMENT(name) 90 91#define DECLARE_ASM_HANDLER_PROFILE(name, base, format) \ 92 DECLARE_ASM_HANDLER_BASE(name, true, REGISTER_PROFILE_CALL_BACK, format) 93 94#define DECLARE_ASM_HANDLER_JIT_PROFILE(name, base, format) \ 95 DECLARE_ASM_HANDLER_BASE(name, true, REGISTER_JIT_PROFILE_CALL_BACK, format) 96 97// TYPE:{OFFSET, ACC_VARACC, JUMP, SSD} 98#define DISPATCH_BAK(TYPE, ...) DISPATCH_##TYPE(__VA_ARGS__) 99 100// Dispatch(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter, offset) 101#define DISPATCH_OFFSET(offset) \ 102 DISPATCH_BASE(profileTypeInfo, acc, hotnessCounter, offset) 103 104// Dispatch(glue, sp, pc, constpool, profileTypeInfo, *varAcc, hotnessCounter, offset) 105#define DISPATCH_VARACC(offset) \ 106 DISPATCH_BASE(profileTypeInfo, *varAcc, hotnessCounter, offset) 107 108// Dispatch(glue, sp, pc, constpool, *varProfileTypeInfo, acc, *varHotnessCounter, offset) 109#define DISPATCH_JUMP(offset) \ 110 DISPATCH_BASE(*varProfileTypeInfo, acc, *varHotnessCounter, offset) 111 112#define DISPATCH_SSD(offset) \ 113 Dispatch(glue, *varSp, *varPc, *varConstpool, *varProfileTypeInfo, *varAcc, \ 114 *varHotnessCounter, offset) 115 116#define DISPATCH_BASE(...) \ 117 Dispatch(glue, sp, pc, constpool, __VA_ARGS__) 118 119#define INT_PTR(opcode) \ 120 IntPtr(BytecodeInstruction::Size(BytecodeInstruction::Opcode::opcode)) 121 122#define DISPATCH_WITH_ACC(opcode) DISPATCH_BAK(VARACC, INT_PTR(opcode)) 123 124#define DISPATCH(opcode) DISPATCH_BAK(OFFSET, INT_PTR(opcode)) 125 126#define DISPATCH_LAST() \ 127 DispatchLast(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter) \ 128 129#define DISPATCH_LAST_WITH_ACC() \ 130 DispatchLast(glue, sp, pc, constpool, profileTypeInfo, *varAcc, hotnessCounter) \ 131 132#define UPDATE_HOTNESS(_sp, callback) \ 133 varHotnessCounter = Int32Add(offset, *varHotnessCounter); \ 134 BRANCH(Int32LessThan(*varHotnessCounter, Int32(0)), &slowPath, &dispatch); \ 135 Bind(&slowPath); \ 136 { \ 137 GateRef func = GetFunctionFromFrame(GetFrame(_sp)); \ 138 GateRef iVecOffset = IntPtr(JSThread::GlueData::GetInterruptVectorOffset(env->IsArch32Bit())); \ 139 GateRef interruptsFlag = Load(VariableType::INT8(), glue, iVecOffset); \ 140 varHotnessCounter = Int32(EcmaInterpreter::METHOD_HOTNESS_THRESHOLD); \ 141 Label initialized(env); \ 142 Label callRuntime(env); \ 143 BRANCH(BitOr(TaggedIsUndefined(*varProfileTypeInfo), \ 144 Int8Equal(interruptsFlag, Int8(VmThreadControl::VM_NEED_SUSPENSION))), \ 145 &callRuntime, &initialized); \ 146 Bind(&callRuntime); \ 147 if (!(callback).IsEmpty()) { \ 148 varProfileTypeInfo = CallRuntime(glue, RTSTUB_ID(UpdateHotnessCounterWithProf), { func }); \ 149 } else { \ 150 varProfileTypeInfo = CallRuntime(glue, RTSTUB_ID(UpdateHotnessCounter), { func }); \ 151 } \ 152 Label handleException(env); \ 153 Label noException(env); \ 154 BRANCH(HasPendingException(glue), &handleException, &noException); \ 155 Bind(&handleException); \ 156 { \ 157 DISPATCH_LAST(); \ 158 } \ 159 Bind(&noException); \ 160 { \ 161 Jump(&dispatch); \ 162 } \ 163 Bind(&initialized); \ 164 (callback).TryDump(); \ 165 (callback).TryJitCompile(); \ 166 Jump(&dispatch); \ 167 } \ 168 Bind(&dispatch); 169 170#define CHECK_EXCEPTION(res, offset) \ 171 CheckException(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter, \ 172 res, offset) 173 174#define CHECK_EXCEPTION_VARACC(res, offset) \ 175 CheckException(glue, sp, pc, constpool, profileTypeInfo, *varAcc, hotnessCounter, \ 176 res, offset) 177 178#define CHECK_EXCEPTION_WITH_JUMP(res, jump) \ 179 CheckExceptionWithJump(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter, \ 180 res, jump) 181 182#define CHECK_EXCEPTION_WITH_ACC(res, offset) \ 183 CheckExceptionWithVar(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter, \ 184 res, offset) 185 186#define CHECK_EXCEPTION_WITH_VARACC(res, offset) \ 187 CheckExceptionWithVar(glue, sp, pc, constpool, profileTypeInfo, *varAcc, hotnessCounter, \ 188 res, offset) 189 190#define CHECK_PENDING_EXCEPTION(res, offset) \ 191 CheckPendingException(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter, \ 192 res, offset) 193 194#define METHOD_ENTRY(func) \ 195 auto env = GetEnvironment(); \ 196 METHOD_ENTRY_ENV_DEFINED(func) 197 198#define METHOD_ENTRY_ENV_DEFINED(func) \ 199 GateRef isDebugModeOffset = IntPtr(JSThread::GlueData::GetIsDebugModeOffset(env->Is32Bit())); \ 200 GateRef isDebugMode = Load(VariableType::BOOL(), glue, isDebugModeOffset); \ 201 Label isDebugModeTrue(env); \ 202 Label isDebugModeFalse(env); \ 203 BRANCH(isDebugMode, &isDebugModeTrue, &isDebugModeFalse); \ 204 Bind(&isDebugModeTrue); \ 205 { \ 206 CallRuntime(glue, RTSTUB_ID(MethodEntry), { func }); \ 207 Jump(&isDebugModeFalse); \ 208 } \ 209 Bind(&isDebugModeFalse) 210 211#define METHOD_EXIT() \ 212 Label NeedCallRuntimeTrue(env); \ 213 Label NeedCallRuntimeFalse(env); \ 214 GateRef isDebugModeOrTracing = LogicOrBuilder(env) \ 215 .Or(Load(VariableType::BOOL(), glue, IntPtr(JSThread::GlueData::GetIsDebugModeOffset(env->Is32Bit())))) \ 216 .Or(Load(VariableType::BOOL(), glue, IntPtr(JSThread::GlueData::GetIsTracingOffset(env->Is32Bit())))) \ 217 .Done(); \ 218 BRANCH(isDebugModeOrTracing, &NeedCallRuntimeTrue, &NeedCallRuntimeFalse); \ 219 Bind(&NeedCallRuntimeTrue); \ 220 { \ 221 CallRuntime(glue, RTSTUB_ID(MethodExit), {}); \ 222 Jump(&NeedCallRuntimeFalse); \ 223 } \ 224 Bind(&NeedCallRuntimeFalse) 225 226#define TRY_OSR() \ 227 DEFVARIABLE(varOsrCache, VariableType::NATIVE_POINTER(), Undefined()); \ 228 DEFVARIABLE(varMachineCodeOffset, VariableType::JS_ANY(), Undefined()); \ 229 DEFVARIABLE(varMachineCode, VariableType::NATIVE_POINTER(), Undefined()); \ 230 Label getOsrCache(env); \ 231 Label getMachineCode(env); \ 232 Label checkDeOptFlag(env); \ 233 Label checkExecCount(env); \ 234 Label clearMachineCode(env); \ 235 Label executeBCByAOT(env); \ 236 Label executeBCByInterpreter(env); \ 237 GateRef curFrame = GetFrame(sp); \ 238 GateRef curFunction = GetFunctionFromFrame(curFrame); \ 239 GateRef curMethod = Load(VariableType::JS_ANY(), curFunction, IntPtr(JSFunctionBase::METHOD_OFFSET)); \ 240 Branch(TaggedIsUndefined(profileTypeInfo), &executeBCByInterpreter, &getOsrCache); \ 241 Bind(&getOsrCache); \ 242 { \ 243 GateRef profileTypeInfoLength = GetLengthOfTaggedArray(profileTypeInfo); \ 244 GateRef typeInfoNum = Int32Sub(profileTypeInfoLength, Int32(ProfileTypeInfo::JIT_OSR_INDEX)); \ 245 GateRef relativeOffset = PtrMul(ZExtInt32ToPtr(typeInfoNum), IntPtr(JSTaggedValue::TaggedTypeSize())); \ 246 GateRef osrCacheOffset = PtrAdd(relativeOffset, IntPtr(TaggedArray::DATA_OFFSET)); \ 247 varOsrCache = Load(VariableType::NATIVE_POINTER(), profileTypeInfo, osrCacheOffset); \ 248 Branch(TaggedIsUndefinedOrNull(*varOsrCache), &executeBCByInterpreter, &getMachineCode); \ 249 } \ 250 Bind(&getMachineCode); \ 251 { \ 252 DEFVARIABLE(varIndex, VariableType::INT32(), Int32(0)); \ 253 Label traverseOsrCache(env); \ 254 Label compareOffset(env); \ 255 Label addIndex(env); \ 256 Label traverseOsrCacheAgain(env); \ 257 GateRef fistPC = Load(VariableType::NATIVE_POINTER(), curMethod, \ 258 IntPtr(Method::NATIVE_POINTER_OR_BYTECODE_ARRAY_OFFSET)); \ 259 GateRef jmpOffsetInFunc = TruncPtrToInt32(PtrSub(pc, fistPC)); \ 260 GateRef length = GetLengthOfTaggedArray(*varOsrCache); \ 261 Branch(Int32LessThan(*varIndex, length), &traverseOsrCache, &executeBCByInterpreter); \ 262 LoopBegin(&traverseOsrCache); \ 263 { \ 264 GateRef relativeOffset = PtrMul(ZExtInt32ToPtr(*varIndex), IntPtr(JSTaggedValue::TaggedTypeSize())); \ 265 varMachineCodeOffset = PtrAdd(relativeOffset, IntPtr(TaggedArray::DATA_OFFSET)); \ 266 varMachineCode = Load(VariableType::NATIVE_POINTER(), *varOsrCache, *varMachineCodeOffset); \ 267 Branch(TaggedIsUndefinedOrNull(*varMachineCode), &addIndex, &compareOffset); \ 268 Bind(&compareOffset); \ 269 { \ 270 GateRef offsetField = Load(VariableType::INT32(), *varMachineCode, \ 271 IntPtr(MachineCode::INS_SIZE_OFFSET)); \ 272 Branch(Int32Equal(jmpOffsetInFunc, offsetField), &checkExecCount, &addIndex); \ 273 } \ 274 Bind(&addIndex); \ 275 { \ 276 varIndex = Int32Add(*varIndex, Int32(1)); \ 277 varMachineCode = NullPtr(); \ 278 Branch(Int32LessThan(*varIndex, length), &traverseOsrCacheAgain, &executeBCByInterpreter); \ 279 } \ 280 Bind(&traverseOsrCacheAgain); \ 281 } \ 282 LoopEnd(&traverseOsrCache); \ 283 } \ 284 Bind(&checkExecCount); \ 285 { \ 286 GateRef execCnt = Load(VariableType::INT16(), *varMachineCode, IntPtr(MachineCode::OSR_EXECUTE_CNT_OFFSET)); \ 287 Branch(Int32LessThan(ZExtInt16ToInt32(execCnt), Int32(5)), &checkDeOptFlag, &dispatch); \ 288 } \ 289 Bind(&checkDeOptFlag); \ 290 { \ 291 GateRef deOptField = Load(VariableType::INT16(), *varMachineCode, IntPtr(MachineCode::OSRMASK_OFFSET)); \ 292 Branch(Equal(deOptField, Int16(MachineCode::OSR_DEOPT_FLAG)), &clearMachineCode, &executeBCByAOT); \ 293 } \ 294 Bind(&clearMachineCode); \ 295 { \ 296 Store(VariableType::NATIVE_POINTER(), glue, *varOsrCache, *varMachineCodeOffset, Undefined()); \ 297 Jump(&executeBCByInterpreter); \ 298 } \ 299 Bind(&executeBCByAOT); \ 300 { \ 301 DEFVARIABLE(varRetVal, VariableType::JS_ANY(), Undefined()); \ 302 Label fastCallOptimized(env); \ 303 Label callOptimized(env); \ 304 Label handleReturn(env); \ 305 Label resumeRspAndReturn(env); \ 306 Label resumeRspAndDispatch(env); \ 307 Store(VariableType::NATIVE_POINTER(), glue, curFunction, IntPtr(JSFunction::MACHINECODE_OFFSET), \ 308 *varMachineCode); \ 309 GateRef execCnt = Load(VariableType::INT16(), *varMachineCode, IntPtr(MachineCode::OSR_EXECUTE_CNT_OFFSET)); \ 310 GateRef newExecCnt = Int16Add(execCnt, Int16(1)); \ 311 Store(VariableType::INT16(), glue, *varMachineCode, IntPtr(MachineCode::OSR_EXECUTE_CNT_OFFSET), \ 312 newExecCnt); \ 313 GateRef codeAddr = Load(VariableType::NATIVE_POINTER(), *varMachineCode, \ 314 IntPtr(MachineCode::FUNCADDR_OFFSET)); \ 315 varRetVal = FastCallOptimized(glue, codeAddr, { glue, sp }); \ 316 Jump(&handleReturn); \ 317 Bind(&handleReturn); \ 318 { \ 319 GateRef prevSp = Load(VariableType::NATIVE_POINTER(), curFrame, \ 320 IntPtr(AsmInterpretedFrame::GetBaseOffset(env->IsArch32Bit()))); \ 321 GateRef prevFrame = GetFrame(prevSp); \ 322 GateRef prevPc = GetPcFromFrame(prevFrame); \ 323 Branch(IntPtrEqual(prevPc, IntPtr(0)), &resumeRspAndReturn, &resumeRspAndDispatch); \ 324 Bind(&resumeRspAndReturn); \ 325 { \ 326 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndReturn), { *varRetVal, prevSp, sp}); \ 327 Return(); \ 328 } \ 329 Bind(&resumeRspAndDispatch); \ 330 { \ 331 GateRef prevFunction = GetFunctionFromFrame(prevFrame); \ 332 GateRef prevMethod = Load(VariableType::JS_ANY(), prevFunction, \ 333 IntPtr(JSFunctionBase::METHOD_OFFSET)); \ 334 GateRef prevConstpool = GetConstpoolFromMethod(prevMethod); \ 335 GateRef prevProfileTypeInfo = GetProfileTypeInfoFromFunction(prevFunction); \ 336 GateRef prevHotnessCounter = GetHotnessCounterFromMethod(prevMethod); \ 337 GateRef jumpSize = GetCallSizeFromFrame(prevFrame); \ 338 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndDispatch), \ 339 {glue, sp, prevPc, prevConstpool, prevProfileTypeInfo, *varRetVal, \ 340 prevHotnessCounter, jumpSize}); \ 341 Return(); \ 342 } \ 343 } \ 344 } \ 345 Bind(&executeBCByInterpreter) 346 347#define DEFINE_BY_NAME(newIc) \ 348 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); \ 349 GateRef stringId = ReadInst16_1(pc); \ 350 GateRef propKey = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId)); \ 351 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); \ 352 DEFVARIABLE(holder, VariableType::JS_ANY(), receiver); \ 353 Label icPath(env); \ 354 Label whichPath(env); \ 355 Label slowPath(env); \ 356 Label exit(env); \ 357 Label isEcmaObj(env); \ 358 /*hclass hit -> ic path*/ \ 359 Label tryGetHclass(env); \ 360 Label firstValueHeapObject(env); \ 361 Label hclassNotHit(env); \ 362 BRANCH(IsEcmaObject(receiver), &isEcmaObj, &slowPath); \ 363 Bind(&isEcmaObj); \ 364 BRANCH(TaggedIsUndefined(profileTypeInfo), &hclassNotHit, &tryGetHclass); \ 365 Bind(&tryGetHclass); \ 366 { \ 367 GateRef firstValue = GetValueFromTaggedArray(profileTypeInfo, slotId); \ 368 BRANCH(TaggedIsHeapObject(firstValue), &firstValueHeapObject, &hclassNotHit); \ 369 Bind(&firstValueHeapObject); \ 370 GateRef hclass = LoadHClass(*holder); \ 371 BRANCH(Equal(LoadObjectFromWeakRef(firstValue), hclass), &whichPath, &hclassNotHit); \ 372 } \ 373 Bind(&hclassNotHit); \ 374 /* found entry -> slow path*/ \ 375 Label loopHead(env); \ 376 Label loopEnd(env); \ 377 Label loopExit(env); \ 378 Jump(&loopHead); \ 379 LoopBegin(&loopHead); \ 380 { \ 381 GateRef hclass = LoadHClass(*holder); \ 382 GateRef jsType = GetObjectType(hclass); \ 383 Label findProperty(env); \ 384 BRANCH(IsSpecialIndexedObj(jsType), &slowPath, &findProperty); \ 385 Bind(&findProperty); \ 386 Label isDicMode(env); \ 387 Label notDicMode(env); \ 388 BRANCH(IsDictionaryModeByHClass(hclass), &isDicMode, ¬DicMode); \ 389 Bind(&isDicMode); \ 390 { \ 391 GateRef array = GetPropertiesArray(*holder); \ 392 GateRef entry = FindEntryFromNameDictionary(glue, array, propKey); \ 393 BRANCH(Int32NotEqual(entry, Int32(-1)), &slowPath, &loopExit); \ 394 } \ 395 Bind(¬DicMode); \ 396 { \ 397 GateRef layOutInfo = GetLayoutFromHClass(hclass); \ 398 GateRef propsNum = GetNumberOfPropsFromHClass(hclass); \ 399 GateRef entry = FindElementWithCache(glue, layOutInfo, hclass, propKey, propsNum); \ 400 BRANCH(Int32NotEqual(entry, Int32(-1)), &slowPath, &loopExit); \ 401 } \ 402 Bind(&loopExit); \ 403 { \ 404 holder = GetPrototypeFromHClass(LoadHClass(*holder)); \ 405 BRANCH(TaggedIsHeapObject(*holder), &loopEnd, &whichPath); \ 406 } \ 407 Bind(&loopEnd); \ 408 LoopEnd(&loopHead, env, glue); \ 409 } \ 410 Bind(&whichPath); \ 411 { \ 412 BRANCH(newIc, &icPath, &slowPath); \ 413 } \ 414 Bind(&icPath); \ 415 { \ 416 /* IC do the same thing as stobjbyname */ \ 417 AccessObjectStubBuilder builder(this); \ 418 StringIdInfo info(constpool, pc, StringIdInfo::Offset::BYTE_1, StringIdInfo::Length::BITS_16); \ 419 result = builder.StoreObjByName(glue, receiver, 0, info, acc, profileTypeInfo, slotId, callback); \ 420 Jump(&exit); \ 421 } \ 422 Bind(&slowPath); \ 423 { \ 424 result = DefineField(glue, receiver, propKey, acc); \ 425 Jump(&exit); \ 426 } \ 427 Bind(&exit) 428 429template <bool needPrint> 430void InterpreterStubBuilder::DebugPrintInstruction() 431{ 432#if ECMASCRIPT_ENABLE_INTERPRETER_LOG 433 if constexpr (!needPrint) { 434 return; 435 } 436 GateRef glue = PtrArgument(static_cast<size_t>(InterpreterHandlerInputs::GLUE)); 437 GateRef pc = PtrArgument(static_cast<size_t>(InterpreterHandlerInputs::PC)); 438 CallNGCRuntime(glue, RTSTUB_ID(DebugPrintInstruction), { glue, pc }); 439#endif 440} 441 442DECLARE_ASM_HANDLER(HandleLdnan) 443{ 444 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 445 varAcc = DoubleToTaggedDoublePtr(Double(base::NAN_VALUE)); 446 DISPATCH_WITH_ACC(LDNAN); 447} 448 449DECLARE_ASM_HANDLER(HandleLdinfinity) 450{ 451 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 452 varAcc = DoubleToTaggedDoublePtr(Double(base::POSITIVE_INFINITY)); 453 DISPATCH_WITH_ACC(LDINFINITY); 454} 455 456DECLARE_ASM_HANDLER(HandleLdundefined) 457{ 458 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 459 varAcc = Undefined(); 460 DISPATCH_WITH_ACC(LDUNDEFINED); 461} 462 463DECLARE_ASM_HANDLER(HandleLdnull) 464{ 465 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 466 varAcc = Null(); 467 DISPATCH_WITH_ACC(LDNULL); 468} 469 470DECLARE_ASM_HANDLER(HandleLdsymbol) 471{ 472 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 473 varAcc = CallRuntime(glue, RTSTUB_ID(GetSymbolFunction), {}); 474 DISPATCH_WITH_ACC(LDSYMBOL); 475} 476 477DECLARE_ASM_HANDLER(HandleLdglobal) 478{ 479 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 480 varAcc = GetGlobalObject(glue); 481 DISPATCH_WITH_ACC(LDGLOBAL); 482} 483 484DECLARE_ASM_HANDLER(HandleLdtrue) 485{ 486 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 487 varAcc = TaggedTrue(); 488 DISPATCH_WITH_ACC(LDTRUE); 489} 490 491DECLARE_ASM_HANDLER(HandleLdfalse) 492{ 493 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 494 varAcc = TaggedFalse(); 495 DISPATCH_WITH_ACC(LDFALSE); 496} 497 498DECLARE_ASM_HANDLER(HandleTypeofImm8) 499{ 500 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 501 varAcc = FastTypeOf(glue, acc); 502 DISPATCH_WITH_ACC(TYPEOF_IMM8); 503} 504 505DECLARE_ASM_HANDLER(HandleTypeofImm16) 506{ 507 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 508 varAcc = FastTypeOf(glue, acc); 509 DISPATCH_WITH_ACC(TYPEOF_IMM16); 510} 511 512DECLARE_ASM_HANDLER(HandlePoplexenv) 513{ 514 GateRef state = GetFrame(sp); 515 GateRef currentLexEnv = GetEnvFromFrame(state); 516 GateRef parentLexEnv = GetParentEnv(currentLexEnv); 517 SetEnvToFrame(glue, state, parentLexEnv); 518 DISPATCH(POPLEXENV); 519} 520 521DECLARE_ASM_HANDLER(HandleDeprecatedPoplexenvPrefNone) 522{ 523 GateRef state = GetFrame(sp); 524 GateRef currentLexEnv = GetEnvFromFrame(state); 525 GateRef parentLexEnv = GetParentEnv(currentLexEnv); 526 SetEnvToFrame(glue, state, parentLexEnv); 527 DISPATCH(DEPRECATED_POPLEXENV_PREF_NONE); 528} 529 530DECLARE_ASM_HANDLER(HandleGetunmappedargs) 531{ 532 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 533 DEFVARIABLE(argumentsList, VariableType::JS_ANY(), Hole()); 534 DEFVARIABLE(argumentsObj, VariableType::JS_ANY(), Hole()); 535 auto env = GetEnvironment(); 536 GateRef startIdxAndNumArgs = GetStartIdxAndNumArgs(sp, Int32(0)); 537 // 32: high 32 bits = startIdx, low 32 bits = numArgs 538 GateRef startIdx = TruncInt64ToInt32(Int64LSR(startIdxAndNumArgs, Int64(32))); 539 GateRef numArgs = TruncInt64ToInt32(startIdxAndNumArgs); 540 541 Label newArgumentsObj(env); 542 Label checkException(env); 543 Label dispatch(env); 544 Label slowPath(env); 545 NewObjectStubBuilder newBuilder(this); 546 newBuilder.SetParameters(glue, 0); 547 Label afterArgumentsList(env); 548 newBuilder.NewArgumentsList(&argumentsList, &afterArgumentsList, sp, startIdx, numArgs); 549 Bind(&afterArgumentsList); 550 BRANCH(TaggedIsException(*argumentsList), &slowPath, &newArgumentsObj); 551 Bind(&newArgumentsObj); 552 Label afterArgumentsObj(env); 553 newBuilder.NewArgumentsObj(&argumentsObj, &afterArgumentsObj, *argumentsList, numArgs); 554 Bind(&afterArgumentsObj); 555 BRANCH(TaggedIsException(*argumentsObj), &slowPath, &checkException); 556 Bind(&checkException); 557 BRANCH(HasPendingException(glue), &slowPath, &dispatch); 558 Bind(&dispatch); 559 { 560 varAcc = *argumentsObj; 561 DISPATCH_WITH_ACC(GETUNMAPPEDARGS); 562 } 563 564 Bind(&slowPath); 565 { 566 GateRef res = CallRuntime(glue, RTSTUB_ID(GetUnmapedArgs), {}); 567 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(GETUNMAPPEDARGS)); 568 } 569} 570 571DECLARE_ASM_HANDLER(HandleCopyrestargsImm8) 572{ 573 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 574 DEFVARIABLE(res, VariableType::JS_ANY(), Undefined()); 575 DEFVARIABLE(i, VariableType::INT32(), Int32(0)); 576 auto env = GetEnvironment(); 577 GateRef restIdx = ZExtInt8ToInt32(ReadInst8_0(pc)); 578 GateRef startIdxAndNumArgs = GetStartIdxAndNumArgs(sp, restIdx); 579 GateRef startIdx = TruncInt64ToInt32(Int64LSR(startIdxAndNumArgs, Int64(32))); 580 GateRef numArgs = TruncInt64ToInt32(startIdxAndNumArgs); 581 Label dispatch(env); 582 Label slowPath(env); 583 // For the args, we use ElementsKind::GENERIC as the kind 584 GateRef intialHClass = GetGlobalConstantValue(VariableType::JS_ANY(), glue, 585 ConstantIndex::ELEMENT_HOLE_TAGGED_HCLASS_INDEX); 586 NewObjectStubBuilder newBuilder(this); 587 newBuilder.SetParameters(glue, 0); 588 res = newBuilder.NewJSArrayWithSize(intialHClass, numArgs); 589 GateRef lengthOffset = IntPtr(JSArray::LENGTH_OFFSET); 590 Store(VariableType::INT32(), glue, *res, lengthOffset, TruncInt64ToInt32(numArgs)); 591 GateRef accessor = GetGlobalConstantValue(VariableType::JS_ANY(), glue, ConstantIndex::ARRAY_LENGTH_ACCESSOR); 592 SetPropertyInlinedProps(glue, *res, intialHClass, accessor, Int32(JSArray::LENGTH_INLINE_PROPERTY_INDEX)); 593 SetExtensibleToBitfield(glue, *res, true); 594 Label setArgumentsBegin(env); 595 Label setArgumentsAgain(env); 596 Label setArgumentsEnd(env); 597 GateRef elements = GetElementsArray(*res); 598 BRANCH(Int32UnsignedLessThan(*i, numArgs), &setArgumentsBegin, &setArgumentsEnd); 599 LoopBegin(&setArgumentsBegin); 600 { 601 GateRef idx = ZExtInt32ToPtr(Int32Add(startIdx, *i)); 602 GateRef receiver = Load(VariableType::JS_ANY(), sp, PtrMul(IntPtr(sizeof(JSTaggedType)), idx)); 603 SetValueToTaggedArray(VariableType::JS_ANY(), glue, elements, *i, receiver); 604 i = Int32Add(*i, Int32(1)); 605 BRANCH(Int32UnsignedLessThan(*i, numArgs), &setArgumentsAgain, &setArgumentsEnd); 606 Bind(&setArgumentsAgain); 607 } 608 LoopEnd(&setArgumentsBegin); 609 Bind(&setArgumentsEnd); 610 BRANCH(HasPendingException(glue), &slowPath, &dispatch); 611 Bind(&dispatch); 612 { 613 varAcc = *res; 614 DISPATCH_WITH_ACC(COPYRESTARGS_IMM8); 615 } 616 617 Bind(&slowPath); 618 { 619 GateRef result2 = CallRuntime(glue, RTSTUB_ID(CopyRestArgs), { IntToTaggedInt(restIdx) }); 620 CHECK_EXCEPTION_WITH_ACC(result2, INT_PTR(COPYRESTARGS_IMM8)); 621 } 622} 623 624DECLARE_ASM_HANDLER(HandleWideCopyrestargsPrefImm16) 625{ 626 GateRef restIdx = ZExtInt16ToInt32(ReadInst16_1(pc)); 627 GateRef res = CallRuntime(glue, RTSTUB_ID(CopyRestArgs), { IntToTaggedInt(restIdx) }); 628 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(WIDE_COPYRESTARGS_PREF_IMM16)); 629} 630 631DECLARE_ASM_HANDLER(HandleCreateobjectwithexcludedkeysImm8V8V8) 632{ 633 GateRef numKeys = ReadInst8_0(pc); 634 GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 635 GateRef firstArgRegIdx = ZExtInt8ToInt16(ReadInst8_2(pc)); 636 GateRef res = CallRuntime(glue, RTSTUB_ID(CreateObjectWithExcludedKeys), 637 { Int16ToTaggedInt(numKeys), obj, Int16ToTaggedInt(firstArgRegIdx) }); 638 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CREATEOBJECTWITHEXCLUDEDKEYS_IMM8_V8_V8)); 639} 640 641DECLARE_ASM_HANDLER(HandleWideCreateobjectwithexcludedkeysPrefImm16V8V8) 642{ 643 GateRef numKeys = ReadInst16_1(pc); 644 GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); 645 GateRef firstArgRegIdx = ZExtInt8ToInt16(ReadInst8_4(pc)); 646 GateRef res = CallRuntime(glue, RTSTUB_ID(CreateObjectWithExcludedKeys), 647 { Int16ToTaggedInt(numKeys), obj, Int16ToTaggedInt(firstArgRegIdx) }); 648 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(WIDE_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8)); 649} 650 651DECLARE_ASM_HANDLER(HandleThrowIfsupernotcorrectcallPrefImm16) 652{ 653 GateRef imm = ReadInst16_1(pc); 654 GateRef res = CallRuntime(glue, RTSTUB_ID(ThrowIfSuperNotCorrectCall), 655 { Int16ToTaggedInt(imm), acc }); // acc is thisValue 656 CHECK_EXCEPTION(res, INT_PTR(THROW_IFSUPERNOTCORRECTCALL_PREF_IMM16)); 657} 658 659DECLARE_ASM_HANDLER(HandleThrowIfsupernotcorrectcallPrefImm8) 660{ 661 GateRef imm = ReadInst8_1(pc); 662 GateRef res = CallRuntime(glue, RTSTUB_ID(ThrowIfSuperNotCorrectCall), 663 { Int8ToTaggedInt(imm), acc }); // acc is thisValue 664 CHECK_EXCEPTION(res, INT_PTR(THROW_IFSUPERNOTCORRECTCALL_PREF_IMM8)); 665} 666 667DECLARE_ASM_HANDLER(HandleAsyncfunctionresolveV8) 668{ 669 GateRef asyncFuncObj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_0(pc))); 670 GateRef value = acc; 671 GateRef res = CallRuntime(glue, RTSTUB_ID(AsyncFunctionResolveOrReject), 672 { asyncFuncObj, value, TaggedTrue() }); 673 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(ASYNCFUNCTIONRESOLVE_V8)); 674} 675 676DECLARE_ASM_HANDLER(HandleDeprecatedAsyncfunctionresolvePrefV8V8V8) 677{ 678 GateRef asyncFuncObj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 679 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); 680 GateRef res = CallRuntime(glue, RTSTUB_ID(AsyncFunctionResolveOrReject), 681 { asyncFuncObj, value, TaggedTrue() }); 682 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(DEPRECATED_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8)); 683} 684 685DECLARE_ASM_HANDLER(HandleAsyncfunctionrejectV8) 686{ 687 GateRef asyncFuncObj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_0(pc))); 688 GateRef value = acc; 689 GateRef res = CallRuntime(glue, RTSTUB_ID(AsyncFunctionResolveOrReject), 690 { asyncFuncObj, value, TaggedFalse() }); 691 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(ASYNCFUNCTIONREJECT_V8)); 692} 693 694DECLARE_ASM_HANDLER(HandleDeprecatedAsyncfunctionrejectPrefV8V8V8) 695{ 696 GateRef asyncFuncObj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 697 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); 698 GateRef res = CallRuntime(glue, RTSTUB_ID(AsyncFunctionResolveOrReject), 699 { asyncFuncObj, value, TaggedFalse() }); 700 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(DEPRECATED_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8)); 701} 702 703DECLARE_ASM_HANDLER(HandleDefinegettersetterbyvalueV8V8V8V8) 704{ 705 GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_0(pc))); 706 GateRef prop = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 707 GateRef getter = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); 708 GateRef setter = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); 709 GateRef frame = GetFrame(sp); 710 GateRef func = GetFunctionFromFrame(frame); 711 712 GateRef method = Load(VariableType::JS_ANY(), func, IntPtr(JSFunctionBase::METHOD_OFFSET)); 713 GateRef firstPC = 714 Load(VariableType::NATIVE_POINTER(), method, IntPtr(Method::NATIVE_POINTER_OR_BYTECODE_ARRAY_OFFSET)); 715 GateRef offset = TaggedPtrToTaggedIntPtr(PtrSub(pc, firstPC)); 716 GateRef res = CallRuntime(glue, RTSTUB_ID(DefineGetterSetterByValue), 717 { obj, prop, getter, setter, acc, func, offset }); // acc is flag 718 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(DEFINEGETTERSETTERBYVALUE_V8_V8_V8_V8)); 719} 720 721DECLARE_ASM_HANDLER(HandleGetpropiterator) 722{ 723 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 724 NewObjectStubBuilder newBuilder(this); 725 GateRef res = newBuilder.EnumerateObjectProperties(glue, *varAcc); 726 CHECK_EXCEPTION_WITH_VARACC(res, INT_PTR(GETPROPITERATOR)); 727} 728 729DECLARE_ASM_HANDLER(HandleAsyncfunctionenter) 730{ 731 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 732 GateRef res = CallRuntime(glue, RTSTUB_ID(AsyncFunctionEnter), {}); 733 CHECK_EXCEPTION_WITH_VARACC(res, INT_PTR(ASYNCFUNCTIONENTER)); 734} 735 736DECLARE_ASM_HANDLER(HandleLdhole) 737{ 738 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 739 varAcc = Hole(); 740 DISPATCH_WITH_ACC(LDHOLE); 741} 742 743DECLARE_ASM_HANDLER(HandleCreateemptyobject) 744{ 745 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 746 NewObjectStubBuilder newBuilder(this); 747 varAcc = newBuilder.CreateEmptyObject(glue); 748 DISPATCH_WITH_ACC(CREATEEMPTYOBJECT); 749} 750 751DECLARE_ASM_HANDLER(HandleCreateemptyarrayImm8) 752{ 753 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 754 DEFVARIABLE(varSp, VariableType::NATIVE_POINTER(), sp); 755 NewObjectStubBuilder newBuilder(this); 756 GateRef frame = GetFrame(*varSp); 757 GateRef func = GetFunctionFromFrame(frame); 758 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); 759 varAcc = newBuilder.CreateEmptyArray(glue, func, { pc, 0, true }, profileTypeInfo, slotId, callback); 760 DISPATCH_WITH_ACC(CREATEEMPTYARRAY_IMM8); 761} 762 763DECLARE_ASM_HANDLER(HandleCreateemptyarrayImm16) 764{ 765 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 766 DEFVARIABLE(varSp, VariableType::NATIVE_POINTER(), sp); 767 NewObjectStubBuilder newBuilder(this); 768 GateRef frame = GetFrame(*varSp); 769 GateRef func = GetFunctionFromFrame(frame); 770 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc)); 771 varAcc = newBuilder.CreateEmptyArray(glue, func, { pc, 0 , true }, profileTypeInfo, slotId, callback); 772 DISPATCH_WITH_ACC(CREATEEMPTYARRAY_IMM16); 773} 774 775DECLARE_ASM_HANDLER(HandleGetiteratorImm8) 776{ 777 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 778 GateRef res = GetIterator(glue, *varAcc, callback); 779 CHECK_PENDING_EXCEPTION(res, INT_PTR(GETITERATOR_IMM8)); 780} 781 782DECLARE_ASM_HANDLER(HandleGetiteratorImm16) 783{ 784 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 785 GateRef res = GetIterator(glue, *varAcc, callback); 786 CHECK_PENDING_EXCEPTION(res, INT_PTR(GETITERATOR_IMM16)); 787} 788 789DECLARE_ASM_HANDLER(HandleGetasynciteratorImm8) 790{ 791 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 792 GateRef res = CallRuntime(glue, RTSTUB_ID(GetAsyncIterator), { *varAcc }); 793 CHECK_PENDING_EXCEPTION(res, INT_PTR(GETASYNCITERATOR_IMM8)); 794} 795 796DECLARE_ASM_HANDLER(HandleLdPrivatePropertyImm8Imm16Imm16) 797{ 798 GateRef lexicalEnv = GetEnvFromFrame(GetFrame(sp)); 799 GateRef levelIndex = ReadInst16_1(pc); 800 GateRef slotIndex = ReadInst16_3(pc); 801 802 DEFVARIABLE(result, VariableType::JS_ANY(), Hole()); 803 result = CallRuntime(glue, 804 RTSTUB_ID(LdPrivateProperty), 805 {lexicalEnv, IntToTaggedInt(levelIndex), IntToTaggedInt(slotIndex), acc}); // acc as obj 806 CHECK_EXCEPTION_WITH_ACC(*result, INT_PTR(LDPRIVATEPROPERTY_IMM8_IMM16_IMM16)); 807} 808 809DECLARE_ASM_HANDLER(HandleStPrivatePropertyImm8Imm16Imm16V8) 810{ 811 GateRef lexicalEnv = GetEnvFromFrame(GetFrame(sp)); 812 GateRef levelIndex = ReadInst16_1(pc); 813 GateRef slotIndex = ReadInst16_3(pc); 814 GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_5(pc))); 815 DEFVARIABLE(result, VariableType::JS_ANY(), Hole()); 816 result = 817 CallRuntime(glue, 818 RTSTUB_ID(StPrivateProperty), 819 {lexicalEnv, IntToTaggedInt(levelIndex), IntToTaggedInt(slotIndex), obj, acc}); // acc as value 820 CHECK_EXCEPTION_WITH_ACC(*result, INT_PTR(STPRIVATEPROPERTY_IMM8_IMM16_IMM16_V8)); 821} 822 823DECLARE_ASM_HANDLER(HandleTestInImm8Imm16Imm16) 824{ 825 GateRef lexicalEnv = GetEnvFromFrame(GetFrame(sp)); 826 [[maybe_unused]] GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); 827 GateRef levelIndex = ReadInst16_1(pc); 828 GateRef slotIndex = ReadInst16_3(pc); 829 GateRef res = CallRuntime(glue, RTSTUB_ID(TestIn), {lexicalEnv, 830 IntToTaggedInt(levelIndex), IntToTaggedInt(slotIndex), acc}); // acc as obj 831 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(TESTIN_IMM8_IMM16_IMM16)); 832} 833 834DECLARE_ASM_HANDLER(HandleThrowPatternnoncoerciblePrefNone) 835{ 836 CallRuntime(glue, RTSTUB_ID(ThrowPatternNonCoercible), {}); 837 DISPATCH_LAST(); 838} 839 840DECLARE_ASM_HANDLER(HandleThrowDeletesuperpropertyPrefNone) 841{ 842 CallRuntime(glue, RTSTUB_ID(ThrowDeleteSuperProperty), {}); 843 DISPATCH_LAST(); 844} 845 846DECLARE_ASM_HANDLER(HandleDebugger) 847{ 848 CallRuntime(glue, RTSTUB_ID(NotifyDebuggerStatement), {}); 849 DISPATCH(DEBUGGER); 850} 851 852DECLARE_ASM_HANDLER(HandleMul2Imm8V8) 853{ 854 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 855 OperationsStubBuilder builder(this); 856 GateRef result = builder.Mul(glue, left, acc, callback); 857 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(MUL2_IMM8_V8)); 858} 859 860DECLARE_ASM_HANDLER(HandleDiv2Imm8V8) 861{ 862 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 863 OperationsStubBuilder builder(this); 864 GateRef result = builder.Div(glue, left, acc, callback); 865 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DIV2_IMM8_V8)); 866} 867 868DECLARE_ASM_HANDLER(HandleMod2Imm8V8) 869{ 870 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 871 OperationsStubBuilder builder(this); 872 GateRef result = builder.Mod(glue, left, acc, callback); 873 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(MOD2_IMM8_V8)); 874} 875 876DECLARE_ASM_HANDLER(HandleEqImm8V8) 877{ 878 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 879 OperationsStubBuilder builder(this); 880 GateRef result = builder.Equal(glue, left, acc, callback); 881 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(EQ_IMM8_V8)); 882} 883 884DECLARE_ASM_HANDLER(HandleJequndefinedImm16) 885{ 886 DISPATCH(NOP); 887} 888 889DECLARE_ASM_HANDLER(HandleJequndefinedImm8) 890{ 891 DISPATCH(NOP); 892} 893 894DECLARE_ASM_HANDLER(HandleNoteqImm8V8) 895{ 896 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 897 OperationsStubBuilder builder(this); 898 GateRef result = builder.NotEqual(glue, left, acc, callback); 899 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(NOTEQ_IMM8_V8)); 900} 901 902DECLARE_ASM_HANDLER(HandleLessImm8V8) 903{ 904 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 905 OperationsStubBuilder builder(this); 906 GateRef result = builder.Less(glue, left, acc, callback); 907 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(LESS_IMM8_V8)); 908} 909 910DECLARE_ASM_HANDLER(HandleLesseqImm8V8) 911{ 912 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 913 OperationsStubBuilder builder(this); 914 GateRef result = builder.LessEq(glue, left, acc, callback); 915 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(LESSEQ_IMM8_V8)); 916} 917 918DECLARE_ASM_HANDLER(HandleGreaterImm8V8) 919{ 920 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 921 OperationsStubBuilder builder(this); 922 GateRef result = builder.Greater(glue, left, acc, callback); 923 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(GREATER_IMM8_V8)); 924} 925 926DECLARE_ASM_HANDLER(HandleGreatereqImm8V8) 927{ 928 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 929 OperationsStubBuilder builder(this); 930 GateRef result = builder.GreaterEq(glue, left, acc, callback); 931 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(GREATEREQ_IMM8_V8)); 932} 933 934DECLARE_ASM_HANDLER(HandleNop) 935{ 936 DISPATCH(NOP); 937} 938 939DECLARE_ASM_HANDLER(HandleLdaV8) 940{ 941 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 942 GateRef vsrc = ReadInst8_0(pc); 943 varAcc = GetVregValue(sp, ZExtInt8ToPtr(vsrc)); 944 DISPATCH_WITH_ACC(LDA_V8); 945} 946 947DECLARE_ASM_HANDLER(HandleStaV8) 948{ 949 GateRef vdst = ReadInst8_0(pc); 950 SetVregValue(glue, sp, ZExtInt8ToPtr(vdst), acc); 951 DISPATCH(STA_V8); 952} 953 954DECLARE_ASM_HANDLER(HandleJmpImm8) 955{ 956 auto env = GetEnvironment(); 957 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_POINTER(), profileTypeInfo); 958 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); 959 960 GateRef offset = ReadInstSigned8_0(pc); 961 Label dispatch(env); 962 Label slowPath(env); 963 964 TRY_OSR(); 965 966 UPDATE_HOTNESS(sp, callback); 967 DISPATCH_BAK(JUMP, SExtInt32ToPtr(offset)); 968} 969 970DECLARE_ASM_HANDLER(HandleJmpImm16) 971{ 972 auto env = GetEnvironment(); 973 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_POINTER(), profileTypeInfo); 974 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); 975 976 GateRef offset = ReadInstSigned16_0(pc); 977 Label dispatch(env); 978 Label slowPath(env); 979 980 TRY_OSR(); 981 982 UPDATE_HOTNESS(sp, callback); 983 DISPATCH_BAK(JUMP, SExtInt32ToPtr(offset)); 984} 985 986DECLARE_ASM_HANDLER(HandleJmpImm32) 987{ 988 auto env = GetEnvironment(); 989 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_POINTER(), profileTypeInfo); 990 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); 991 992 GateRef offset = ReadInstSigned32_0(pc); 993 Label dispatch(env); 994 Label slowPath(env); 995 996 TRY_OSR(); 997 998 UPDATE_HOTNESS(sp, callback); 999 DISPATCH_BAK(JUMP, SExtInt32ToPtr(offset)); 1000} 1001 1002DECLARE_ASM_HANDLER(HandleLdlexvarImm4Imm4) 1003{ 1004 auto env = GetEnvironment(); 1005 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 1006 1007 GateRef level = ZExtInt8ToInt32(ReadInst4_0(pc)); 1008 GateRef slot = ZExtInt8ToInt32(ReadInst4_1(pc)); 1009 GateRef state = GetFrame(sp); 1010 DEFVARIABLE(currentEnv, VariableType::JS_ANY(), GetEnvFromFrame(state)); 1011 DEFVARIABLE(i, VariableType::INT32(), Int32(0)); 1012 1013 Label loopHead(env); 1014 Label loopEnd(env); 1015 Label afterLoop(env); 1016 BRANCH(Int32LessThan(*i, level), &loopHead, &afterLoop); 1017 LoopBegin(&loopHead); 1018 currentEnv = GetParentEnv(*currentEnv); 1019 i = Int32Add(*i, Int32(1)); 1020 BRANCH(Int32LessThan(*i, level), &loopEnd, &afterLoop); 1021 Bind(&loopEnd); 1022 LoopEnd(&loopHead, env, glue); 1023 Bind(&afterLoop); 1024 GateRef variable = GetPropertiesFromLexicalEnv(*currentEnv, slot); 1025 varAcc = variable; 1026 1027 DISPATCH_WITH_ACC(LDLEXVAR_IMM4_IMM4); 1028} 1029 1030DECLARE_ASM_HANDLER(HandleLdlexvarImm8Imm8) 1031{ 1032 auto env = GetEnvironment(); 1033 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 1034 1035 GateRef level = ZExtInt8ToInt32(ReadInst8_0(pc)); 1036 GateRef slot = ZExtInt8ToInt32(ReadInst8_1(pc)); 1037 1038 GateRef state = GetFrame(sp); 1039 DEFVARIABLE(currentEnv, VariableType::JS_ANY(), GetEnvFromFrame(state)); 1040 DEFVARIABLE(i, VariableType::INT32(), Int32(0)); 1041 1042 Label loopHead(env); 1043 Label loopEnd(env); 1044 Label afterLoop(env); 1045 BRANCH(Int32LessThan(*i, level), &loopHead, &afterLoop); 1046 LoopBegin(&loopHead); 1047 currentEnv = GetParentEnv(*currentEnv); 1048 i = Int32Add(*i, Int32(1)); 1049 BRANCH(Int32LessThan(*i, level), &loopEnd, &afterLoop); 1050 Bind(&loopEnd); 1051 LoopEnd(&loopHead, env, glue); 1052 Bind(&afterLoop); 1053 GateRef variable = GetPropertiesFromLexicalEnv(*currentEnv, slot); 1054 varAcc = variable; 1055 DISPATCH_WITH_ACC(LDLEXVAR_IMM8_IMM8); 1056} 1057 1058DECLARE_ASM_HANDLER(HandleWideLdlexvarPrefImm16Imm16) 1059{ 1060 auto env = GetEnvironment(); 1061 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 1062 1063 GateRef level = ZExtInt16ToInt32(ReadInst16_1(pc)); 1064 GateRef slot = ZExtInt16ToInt32(ReadInst16_3(pc)); 1065 1066 GateRef state = GetFrame(sp); 1067 DEFVARIABLE(currentEnv, VariableType::JS_ANY(), GetEnvFromFrame(state)); 1068 DEFVARIABLE(i, VariableType::INT32(), Int32(0)); 1069 1070 Label loopHead(env); 1071 Label loopEnd(env); 1072 Label afterLoop(env); 1073 BRANCH(Int32LessThan(*i, level), &loopHead, &afterLoop); 1074 LoopBegin(&loopHead); 1075 currentEnv = GetParentEnv(*currentEnv); 1076 i = Int32Add(*i, Int32(1)); 1077 BRANCH(Int32LessThan(*i, level), &loopEnd, &afterLoop); 1078 Bind(&loopEnd); 1079 LoopEnd(&loopHead, env, glue); 1080 Bind(&afterLoop); 1081 GateRef variable = GetPropertiesFromLexicalEnv(*currentEnv, slot); 1082 varAcc = variable; 1083 DISPATCH_WITH_ACC(WIDE_LDLEXVAR_PREF_IMM16_IMM16); 1084} 1085 1086DECLARE_ASM_HANDLER(HandleStlexvarImm4Imm4) 1087{ 1088 auto env = GetEnvironment(); 1089 GateRef level = ZExtInt8ToInt32(ReadInst4_0(pc)); 1090 GateRef slot = ZExtInt8ToInt32(ReadInst4_1(pc)); 1091 1092 GateRef value = acc; 1093 GateRef state = GetFrame(sp); 1094 DEFVARIABLE(currentEnv, VariableType::JS_ANY(), GetEnvFromFrame(state)); 1095 DEFVARIABLE(i, VariableType::INT32(), Int32(0)); 1096 1097 Label loopHead(env); 1098 Label loopEnd(env); 1099 Label afterLoop(env); 1100 BRANCH(Int32LessThan(*i, level), &loopHead, &afterLoop); 1101 LoopBegin(&loopHead); 1102 currentEnv = GetParentEnv(*currentEnv); 1103 i = Int32Add(*i, Int32(1)); 1104 BRANCH(Int32LessThan(*i, level), &loopEnd, &afterLoop); 1105 Bind(&loopEnd); 1106 LoopEnd(&loopHead, env, glue); 1107 Bind(&afterLoop); 1108 SetPropertiesToLexicalEnv(glue, *currentEnv, slot, value); 1109 DISPATCH(STLEXVAR_IMM4_IMM4); 1110} 1111 1112DECLARE_ASM_HANDLER(HandleStlexvarImm8Imm8) 1113{ 1114 auto env = GetEnvironment(); 1115 GateRef level = ZExtInt8ToInt32(ReadInst8_0(pc)); 1116 GateRef slot = ZExtInt8ToInt32(ReadInst8_1(pc)); 1117 1118 GateRef value = acc; 1119 GateRef state = GetFrame(sp); 1120 DEFVARIABLE(currentEnv, VariableType::JS_ANY(), GetEnvFromFrame(state)); 1121 DEFVARIABLE(i, VariableType::INT32(), Int32(0)); 1122 1123 Label loopHead(env); 1124 Label loopEnd(env); 1125 Label afterLoop(env); 1126 BRANCH(Int32LessThan(*i, level), &loopHead, &afterLoop); 1127 LoopBegin(&loopHead); 1128 currentEnv = GetParentEnv(*currentEnv); 1129 i = Int32Add(*i, Int32(1)); 1130 BRANCH(Int32LessThan(*i, level), &loopEnd, &afterLoop); 1131 Bind(&loopEnd); 1132 LoopEnd(&loopHead, env, glue); 1133 Bind(&afterLoop); 1134 SetPropertiesToLexicalEnv(glue, *currentEnv, slot, value); 1135 DISPATCH(STLEXVAR_IMM8_IMM8); 1136} 1137 1138DECLARE_ASM_HANDLER(HandleWideStlexvarPrefImm16Imm16) 1139{ 1140 auto env = GetEnvironment(); 1141 GateRef level = ZExtInt16ToInt32(ReadInst16_1(pc)); 1142 GateRef slot = ZExtInt16ToInt32(ReadInst16_3(pc)); 1143 1144 GateRef value = acc; 1145 GateRef state = GetFrame(sp); 1146 DEFVARIABLE(currentEnv, VariableType::JS_ANY(), GetEnvFromFrame(state)); 1147 DEFVARIABLE(i, VariableType::INT32(), Int32(0)); 1148 1149 Label loopHead(env); 1150 Label loopEnd(env); 1151 Label afterLoop(env); 1152 BRANCH(Int32LessThan(*i, level), &loopHead, &afterLoop); 1153 LoopBegin(&loopHead); 1154 currentEnv = GetParentEnv(*currentEnv); 1155 i = Int32Add(*i, Int32(1)); 1156 BRANCH(Int32LessThan(*i, level), &loopEnd, &afterLoop); 1157 Bind(&loopEnd); 1158 LoopEnd(&loopHead, env, glue); 1159 Bind(&afterLoop); 1160 SetPropertiesToLexicalEnv(glue, *currentEnv, slot, value); 1161 DISPATCH(WIDE_STLEXVAR_PREF_IMM16_IMM16); 1162} 1163 1164DECLARE_ASM_HANDLER(HandleDeprecatedStlexvarPrefImm16Imm16V8) 1165{ 1166 auto env = GetEnvironment(); 1167 GateRef level = ZExtInt16ToInt32(ReadInst16_1(pc)); 1168 GateRef slot = ZExtInt16ToInt32(ReadInst16_3(pc)); 1169 1170 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_5(pc))); 1171 GateRef state = GetFrame(sp); 1172 DEFVARIABLE(currentEnv, VariableType::JS_ANY(), GetEnvFromFrame(state)); 1173 DEFVARIABLE(i, VariableType::INT32(), Int32(0)); 1174 1175 Label loopHead(env); 1176 Label loopEnd(env); 1177 Label afterLoop(env); 1178 BRANCH(Int32LessThan(*i, level), &loopHead, &afterLoop); 1179 LoopBegin(&loopHead); 1180 currentEnv = GetParentEnv(*currentEnv); 1181 i = Int32Add(*i, Int32(1)); 1182 BRANCH(Int32LessThan(*i, level), &loopEnd, &afterLoop); 1183 Bind(&loopEnd); 1184 LoopEnd(&loopHead, env, glue); 1185 Bind(&afterLoop); 1186 SetPropertiesToLexicalEnv(glue, *currentEnv, slot, value); 1187 DISPATCH(DEPRECATED_STLEXVAR_PREF_IMM16_IMM16_V8); 1188} 1189 1190DECLARE_ASM_HANDLER(HandleDeprecatedStlexvarPrefImm8Imm8V8) 1191{ 1192 auto env = GetEnvironment(); 1193 GateRef level = ZExtInt8ToInt32(ReadInst8_1(pc)); 1194 GateRef slot = ZExtInt8ToInt32(ReadInst8_2(pc)); 1195 1196 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); 1197 GateRef state = GetFrame(sp); 1198 DEFVARIABLE(currentEnv, VariableType::JS_ANY(), GetEnvFromFrame(state)); 1199 DEFVARIABLE(i, VariableType::INT32(), Int32(0)); 1200 1201 Label loopHead(env); 1202 Label loopEnd(env); 1203 Label afterLoop(env); 1204 BRANCH(Int32LessThan(*i, level), &loopHead, &afterLoop); 1205 LoopBegin(&loopHead); 1206 currentEnv = GetParentEnv(*currentEnv); 1207 i = Int32Add(*i, Int32(1)); 1208 BRANCH(Int32LessThan(*i, level), &loopEnd, &afterLoop); 1209 Bind(&loopEnd); 1210 LoopEnd(&loopHead, env, glue); 1211 Bind(&afterLoop); 1212 SetPropertiesToLexicalEnv(glue, *currentEnv, slot, value); 1213 DISPATCH(DEPRECATED_STLEXVAR_PREF_IMM8_IMM8_V8); 1214} 1215 1216DECLARE_ASM_HANDLER(HandleDeprecatedStlexvarPrefImm4Imm4V8) 1217{ 1218 auto env = GetEnvironment(); 1219 GateRef level = ZExtInt8ToInt32(ReadInst4_2(pc)); 1220 GateRef slot = ZExtInt8ToInt32(ReadInst4_3(pc)); 1221 1222 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); 1223 GateRef state = GetFrame(sp); 1224 DEFVARIABLE(currentEnv, VariableType::JS_ANY(), GetEnvFromFrame(state)); 1225 DEFVARIABLE(i, VariableType::INT32(), Int32(0)); 1226 1227 Label loopHead(env); 1228 Label loopEnd(env); 1229 Label afterLoop(env); 1230 BRANCH(Int32LessThan(*i, level), &loopHead, &afterLoop); 1231 LoopBegin(&loopHead); 1232 currentEnv = GetParentEnv(*currentEnv); 1233 i = Int32Add(*i, Int32(1)); 1234 BRANCH(Int32LessThan(*i, level), &loopEnd, &afterLoop); 1235 Bind(&loopEnd); 1236 LoopEnd(&loopHead, env, glue); 1237 Bind(&afterLoop); 1238 SetPropertiesToLexicalEnv(glue, *currentEnv, slot, value); 1239 DISPATCH(DEPRECATED_STLEXVAR_PREF_IMM4_IMM4_V8); 1240} 1241 1242DECLARE_ASM_HANDLER(HandleIncImm8) 1243{ 1244 OperationsStubBuilder builder(this); 1245 GateRef result = builder.Inc(glue, acc, callback); 1246 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(INC_IMM8)); 1247} 1248 1249DECLARE_ASM_HANDLER(HandleDeprecatedIncPrefV8) 1250{ 1251 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 1252 OperationsStubBuilder builder(this); 1253 GateRef result = builder.Inc(glue, value); 1254 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DEPRECATED_INC_PREF_V8)); 1255} 1256 1257DECLARE_ASM_HANDLER(HandleDecImm8) 1258{ 1259 OperationsStubBuilder builder(this); 1260 GateRef result = builder.Dec(glue, acc, callback); 1261 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DEC_IMM8)); 1262} 1263 1264DECLARE_ASM_HANDLER(HandleDeprecatedDecPrefV8) 1265{ 1266 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 1267 OperationsStubBuilder builder(this); 1268 GateRef result = builder.Dec(glue, value); 1269 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DEPRECATED_DEC_PREF_V8)); 1270} 1271 1272DECLARE_ASM_HANDLER(HandleExpImm8V8) 1273{ 1274 GateRef v0 = ReadInst8_1(pc); 1275 GateRef base = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1276 GateRef result = CallRuntime(glue, RTSTUB_ID(Exp), { base, acc }); 1277 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(EXP_IMM8_V8)); 1278} 1279 1280DECLARE_ASM_HANDLER(HandleIsinImm8V8) 1281{ 1282 GateRef v0 = ReadInst8_1(pc); 1283 GateRef prop = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1284 GateRef result = CallRuntime(glue, RTSTUB_ID(IsIn), { prop, acc }); // acc is obj 1285 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(ISIN_IMM8_V8)); 1286} 1287 1288DECLARE_ASM_HANDLER(HandleInstanceofImm8V8) 1289{ 1290 GateRef v0 = ReadInst8_1(pc); 1291 GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1292 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); 1293 GateRef target = acc; 1294 AccessObjectStubBuilder builder(this); 1295 GateRef result = InstanceOf(glue, obj, target, profileTypeInfo, slotId, callback); 1296 CHECK_PENDING_EXCEPTION(result, INT_PTR(INSTANCEOF_IMM8_V8)); 1297} 1298 1299DECLARE_ASM_HANDLER(HandleStrictnoteqImm8V8) 1300{ 1301 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 1302 1303 GateRef v0 = ReadInst8_1(pc); 1304 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1305 1306 OperationsStubBuilder builder(this); 1307 varAcc = builder.StrictNotEqual(glue, left, acc, callback); 1308 DISPATCH_WITH_ACC(STRICTNOTEQ_IMM8_V8); 1309} 1310 1311DECLARE_ASM_HANDLER(HandleStricteqImm8V8) 1312{ 1313 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 1314 1315 GateRef v0 = ReadInst8_1(pc); 1316 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1317 1318 OperationsStubBuilder builder(this); 1319 varAcc = builder.StrictEqual(glue, left, acc, callback); 1320 DISPATCH_WITH_ACC(STRICTEQ_IMM8_V8); 1321} 1322 1323DECLARE_ASM_HANDLER(HandleResumegenerator) 1324{ 1325 auto env = GetEnvironment(); 1326 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 1327 GateRef obj = *varAcc; 1328 1329#if ECMASCRIPT_ENABLE_FUNCTION_CALL_TIMER 1330 GateRef frame = GetFrame(sp); 1331 GateRef curFunc = GetFunctionFromFrame(frame); 1332 CallNGCRuntime(glue, RTSTUB_ID(StartCallTimer), { glue, curFunc, False() }); 1333#endif 1334 Label isAsyncGeneratorObj(env); 1335 Label notAsyncGeneratorObj(env); 1336 Label dispatch(env); 1337 BRANCH(TaggedIsAsyncGeneratorObject(obj), &isAsyncGeneratorObj, ¬AsyncGeneratorObj); 1338 Bind(&isAsyncGeneratorObj); 1339 { 1340 GateRef resumeResultOffset = IntPtr(JSAsyncGeneratorObject::GENERATOR_RESUME_RESULT_OFFSET); 1341 varAcc = Load(VariableType::JS_ANY(), obj, resumeResultOffset); 1342 Jump(&dispatch); 1343 } 1344 Bind(¬AsyncGeneratorObj); 1345 { 1346 GateRef resumeResultOffset = IntPtr(JSGeneratorObject::GENERATOR_RESUME_RESULT_OFFSET); 1347 varAcc = Load(VariableType::JS_ANY(), obj, resumeResultOffset); 1348 GateRef taskInfoOffset = IntPtr(JSGeneratorObject::TASK_INFO_OFFSET); 1349 GateRef taskInfo = Load(VariableType::NATIVE_POINTER(), obj, taskInfoOffset); 1350 Store(VariableType::NATIVE_POINTER(), glue, glue, 1351 IntPtr(JSThread::GlueData::GetTaskInfoOffset(env->Is32Bit())), taskInfo); 1352 Store(VariableType::NATIVE_POINTER(), glue, obj, 1353 IntPtr(JSGeneratorObject::TASK_INFO_OFFSET), IntPtr(0)); 1354 Jump(&dispatch); 1355 } 1356 Bind(&dispatch); 1357 DISPATCH_WITH_ACC(RESUMEGENERATOR); 1358} 1359 1360DECLARE_ASM_HANDLER(HandleDeprecatedResumegeneratorPrefV8) 1361{ 1362 auto env = GetEnvironment(); 1363 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 1364 GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 1365#if ECMASCRIPT_ENABLE_FUNCTION_CALL_TIMER 1366 GateRef frame = GetFrame(sp); 1367 GateRef curFunc = GetFunctionFromFrame(frame); 1368 CallNGCRuntime(glue, RTSTUB_ID(StartCallTimer), { glue, curFunc, False() }); 1369#endif 1370 1371 Label isAsyncGeneratorObj(env); 1372 Label notAsyncGeneratorObj(env); 1373 Label dispatch(env); 1374 BRANCH(TaggedIsAsyncGeneratorObject(obj), &isAsyncGeneratorObj, ¬AsyncGeneratorObj); 1375 Bind(&isAsyncGeneratorObj); 1376 { 1377 GateRef resumeResultOffset = IntPtr(JSAsyncGeneratorObject::GENERATOR_RESUME_RESULT_OFFSET); 1378 varAcc = Load(VariableType::JS_ANY(), obj, resumeResultOffset); 1379 Jump(&dispatch); 1380 } 1381 Bind(¬AsyncGeneratorObj); 1382 { 1383 GateRef resumeResultOffset = IntPtr(JSGeneratorObject::GENERATOR_RESUME_RESULT_OFFSET); 1384 varAcc = Load(VariableType::JS_ANY(), obj, resumeResultOffset); 1385 Jump(&dispatch); 1386 } 1387 Bind(&dispatch); 1388 DISPATCH_WITH_ACC(DEPRECATED_RESUMEGENERATOR_PREF_V8); 1389} 1390 1391DECLARE_ASM_HANDLER(HandleGetresumemode) 1392{ 1393 auto env = GetEnvironment(); 1394 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 1395 GateRef obj = *varAcc; 1396 1397 Label isAsyncGeneratorObj(env); 1398 Label notAsyncGeneratorObj(env); 1399 Label dispatch(env); 1400 BRANCH(TaggedIsAsyncGeneratorObject(obj), &isAsyncGeneratorObj, ¬AsyncGeneratorObj); 1401 Bind(&isAsyncGeneratorObj); 1402 { 1403 varAcc = IntToTaggedPtr(GetResumeModeFromAsyncGeneratorObject(obj)); 1404 Jump(&dispatch); 1405 } 1406 Bind(¬AsyncGeneratorObj); 1407 { 1408 varAcc = IntToTaggedPtr(GetResumeModeFromGeneratorObject(obj)); 1409 Jump(&dispatch); 1410 } 1411 Bind(&dispatch); 1412 DISPATCH_WITH_ACC(GETRESUMEMODE); 1413} 1414 1415DECLARE_ASM_HANDLER(HandleDeprecatedGetresumemodePrefV8) 1416{ 1417 auto env = GetEnvironment(); 1418 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 1419 GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 1420 1421 Label isAsyncGeneratorObj(env); 1422 Label notAsyncGeneratorObj(env); 1423 Label dispatch(env); 1424 BRANCH(TaggedIsAsyncGeneratorObject(obj), &isAsyncGeneratorObj, ¬AsyncGeneratorObj); 1425 Bind(&isAsyncGeneratorObj); 1426 { 1427 varAcc = IntToTaggedPtr(GetResumeModeFromAsyncGeneratorObject(obj)); 1428 Jump(&dispatch); 1429 } 1430 Bind(¬AsyncGeneratorObj); 1431 { 1432 varAcc = IntToTaggedPtr(GetResumeModeFromGeneratorObject(obj)); 1433 Jump(&dispatch); 1434 } 1435 Bind(&dispatch); 1436 DISPATCH_WITH_ACC(DEPRECATED_GETRESUMEMODE_PREF_V8); 1437} 1438 1439DECLARE_ASM_HANDLER(HandleCreategeneratorobjV8) 1440{ 1441 GateRef v0 = ReadInst8_0(pc); 1442 GateRef genFunc = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1443 GateRef result = CallRuntime(glue, RTSTUB_ID(CreateGeneratorObj), { genFunc }); 1444 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(CREATEGENERATOROBJ_V8)); 1445} 1446 1447DECLARE_ASM_HANDLER(HandleThrowConstassignmentPrefV8) 1448{ 1449 GateRef v0 = ReadInst8_1(pc); 1450 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1451 CallRuntime(glue, RTSTUB_ID(ThrowConstAssignment), { value }); 1452 DISPATCH_LAST(); 1453} 1454 1455DECLARE_ASM_HANDLER(HandleGettemplateobjectImm8) 1456{ 1457 GateRef literal = acc; 1458 GateRef result = CallRuntime(glue, RTSTUB_ID(GetTemplateObject), { literal }); 1459 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(GETTEMPLATEOBJECT_IMM8)); 1460} 1461 1462DECLARE_ASM_HANDLER(HandleGettemplateobjectImm16) 1463{ 1464 GateRef literal = acc; 1465 GateRef result = CallRuntime(glue, RTSTUB_ID(GetTemplateObject), { literal }); 1466 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(GETTEMPLATEOBJECT_IMM16)); 1467} 1468 1469DECLARE_ASM_HANDLER(HandleDeprecatedGettemplateobjectPrefV8) 1470{ 1471 GateRef literal = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 1472 GateRef result = CallRuntime(glue, RTSTUB_ID(GetTemplateObject), { literal }); 1473 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DEPRECATED_GETTEMPLATEOBJECT_PREF_V8)); 1474} 1475 1476DECLARE_ASM_HANDLER(HandleGetnextpropnameV8) 1477{ 1478 GateRef v0 = ReadInst8_0(pc); 1479 GateRef iter = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1480 GateRef result = NextInternal(glue, iter); 1481 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(GETNEXTPROPNAME_V8)); 1482} 1483 1484DECLARE_ASM_HANDLER(HandleThrowIfnotobjectPrefV8) 1485{ 1486 auto env = GetEnvironment(); 1487 1488 GateRef v0 = ReadInst8_1(pc); 1489 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1490 Label isEcmaObject(env); 1491 Label notEcmaObject(env); 1492 Label isHeapObject(env); 1493 BRANCH(TaggedIsHeapObject(value), &isHeapObject, ¬EcmaObject); 1494 Bind(&isHeapObject); 1495 BRANCH(TaggedObjectIsEcmaObject(value), &isEcmaObject, ¬EcmaObject); 1496 Bind(&isEcmaObject); 1497 { 1498 DISPATCH(THROW_IFNOTOBJECT_PREF_V8); 1499 } 1500 Bind(¬EcmaObject); 1501 CallRuntime(glue, RTSTUB_ID(ThrowIfNotObject), {}); 1502 DISPATCH_LAST(); 1503} 1504 1505DECLARE_ASM_HANDLER(HandleCloseiteratorImm8V8) 1506{ 1507 GateRef v0 = ReadInst8_1(pc); 1508 GateRef iter = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1509 GateRef result = CallRuntime(glue, RTSTUB_ID(CloseIterator), { iter }); 1510 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(CLOSEITERATOR_IMM8_V8)); 1511} 1512 1513DECLARE_ASM_HANDLER(HandleCloseiteratorImm16V8) 1514{ 1515 GateRef v0 = ReadInst8_2(pc); 1516 GateRef iter = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1517 GateRef result = CallRuntime(glue, RTSTUB_ID(CloseIterator), { iter }); 1518 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(CLOSEITERATOR_IMM16_V8)); 1519} 1520 1521DECLARE_ASM_HANDLER(HandleSupercallspreadImm8V8) 1522{ 1523 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 1524 DEFVARIABLE(res, VariableType::JS_ANY(), Undefined()); 1525 DEFVARIABLE(thisObj, VariableType::JS_ANY(), Undefined()); 1526 auto env = GetEnvironment(); 1527 GateRef v0 = ReadInst8_1(pc); 1528 GateRef array = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1529 GateRef thisFunc = acc; 1530 GateRef newTarget = GetNewTarget(sp); 1531 GateRef superCtor = GetPrototype(glue, thisFunc); 1532 1533 Label dispatch(env); 1534 Label normalPath(env); 1535 Label slowPath(env); 1536 Label ctorIsJSFunction(env); 1537 Label ctorIsBase(env); 1538 Label ctorNotBase(env); 1539 Label ctorIsHeapObject(env); 1540 Label ctorIsConstructor(env); 1541 Label threadCheck(env); 1542 Label isException(env); 1543 Label noException(env); 1544 1545 BRANCH(TaggedIsHeapObject(superCtor), &ctorIsHeapObject, &slowPath); 1546 Bind(&ctorIsHeapObject); 1547 BRANCH(IsJSFunction(superCtor), &ctorIsJSFunction, &slowPath); 1548 Bind(&ctorIsJSFunction); 1549 BRANCH(IsConstructor(superCtor), &ctorIsConstructor, &slowPath); 1550 Bind(&ctorIsConstructor); 1551 BRANCH(TaggedIsUndefined(newTarget), &slowPath, &normalPath); 1552 Bind(&normalPath); 1553 { 1554 BRANCH(IsBase(superCtor), &ctorIsBase, &ctorNotBase); 1555 Bind(&ctorIsBase); 1556 NewObjectStubBuilder objBuilder(this); 1557 thisObj = objBuilder.FastSuperAllocateThis(glue, superCtor, newTarget); 1558 BRANCH(HasPendingException(glue), &isException, &ctorNotBase); 1559 Bind(&ctorNotBase); 1560 GateRef argvLen = Load(VariableType::INT32(), array, IntPtr(JSArray::LENGTH_OFFSET)); 1561 GateRef srcElements = GetCallSpreadArgs(glue, array, callback); 1562 BRANCH(TaggedIsException(srcElements), &isException, &noException); 1563 Bind(&noException); 1564 GateRef jumpSize = IntPtr(-BytecodeInstruction::Size(BytecodeInstruction::Format::IMM8_V8)); 1565 METHOD_ENTRY_ENV_DEFINED(superCtor); 1566 GateRef elementsPtr = PtrAdd(srcElements, IntPtr(TaggedArray::DATA_OFFSET)); 1567 JSCallArgs callArgs(JSCallMode::SUPER_CALL_SPREAD_WITH_ARGV); 1568 callArgs.superCallArgs = { thisFunc, array, ZExtInt32ToPtr(argvLen), elementsPtr, *thisObj, newTarget }; 1569 CallStubBuilder callBuilder(this, glue, superCtor, argvLen, jumpSize, nullptr, hotnessCounter, callArgs, 1570 callback); 1571 res = callBuilder.JSCallDispatch(); 1572 Jump(&threadCheck); 1573 } 1574 Bind(&slowPath); 1575 { 1576 res = CallRuntime(glue, RTSTUB_ID(SuperCallSpread), { thisFunc, array }); 1577 Jump(&threadCheck); 1578 } 1579 Bind(&threadCheck); 1580 { 1581 GateRef resVal = *res; 1582 GateRef isError = LogicAndBuilder(env).And(TaggedIsException(resVal)).And(HasPendingException(glue)).Done(); 1583 BRANCH(isError, &isException, &dispatch); 1584 } 1585 Bind(&isException); 1586 { 1587 DISPATCH_LAST(); 1588 } 1589 Bind(&dispatch); 1590 { 1591 varAcc = *res; 1592 DISPATCH_WITH_ACC(SUPERCALLSPREAD_IMM8_V8); 1593 } 1594} 1595 1596DECLARE_ASM_HANDLER(HandleDelobjpropV8) 1597{ 1598 GateRef v0 = ReadInst8_0(pc); 1599 GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1600 GateRef prop = acc; 1601 GateRef result = DeletePropertyOrThrow(glue, obj, prop); 1602 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DELOBJPROP_V8)); 1603} 1604 1605DECLARE_ASM_HANDLER(HandleDeprecatedDelobjpropPrefV8V8) 1606{ 1607 GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 1608 GateRef prop = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); 1609 GateRef result = CallRuntime(glue, RTSTUB_ID(DelObjProp), { obj, prop }); 1610 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DEPRECATED_DELOBJPROP_PREF_V8_V8)); 1611} 1612 1613DECLARE_ASM_HANDLER(HandleNewobjapplyImm8V8) 1614{ 1615 GateRef v0 = ReadInst8_1(pc); 1616 GateRef func = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1617 GateRef result = CallRuntime(glue, RTSTUB_ID(NewObjApply), { func, acc }); // acc is array 1618 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(NEWOBJAPPLY_IMM8_V8)); 1619} 1620 1621DECLARE_ASM_HANDLER(HandleNewobjapplyImm16V8) 1622{ 1623 GateRef v0 = ReadInst8_2(pc); 1624 GateRef func = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1625 GateRef result = CallRuntime(glue, RTSTUB_ID(NewObjApply), { func, acc }); // acc is array 1626 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(NEWOBJAPPLY_IMM16_V8)); 1627} 1628 1629DECLARE_ASM_HANDLER(HandleCreateiterresultobjV8V8) 1630{ 1631 GateRef v0 = ReadInst8_0(pc); 1632 GateRef v1 = ReadInst8_1(pc); 1633 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1634 GateRef flag = GetVregValue(sp, ZExtInt8ToPtr(v1)); 1635 GateRef result = CallRuntime(glue, RTSTUB_ID(CreateIterResultObj), { value, flag }); 1636 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(CREATEITERRESULTOBJ_V8_V8)); 1637} 1638 1639DECLARE_ASM_HANDLER(HandleAsyncfunctionawaituncaughtV8) 1640{ 1641 GateRef v0 = ReadInst8_0(pc); 1642 GateRef asyncFuncObj = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1643 GateRef value = acc; 1644 GateRef result = CallRuntime(glue, RTSTUB_ID(AsyncFunctionAwaitUncaught), { asyncFuncObj, value }); 1645 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(ASYNCFUNCTIONAWAITUNCAUGHT_V8)); 1646} 1647 1648DECLARE_ASM_HANDLER(HandleDeprecatedAsyncfunctionawaituncaughtPrefV8V8) 1649{ 1650 GateRef asyncFuncObj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 1651 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); 1652 GateRef result = CallRuntime(glue, RTSTUB_ID(AsyncFunctionAwaitUncaught), { asyncFuncObj, value }); 1653 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DEPRECATED_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8)); 1654} 1655 1656DECLARE_ASM_HANDLER(HandleThrowUndefinedifholePrefV8V8) 1657{ 1658 auto env = GetEnvironment(); 1659 1660 GateRef v0 = ReadInst8_1(pc); 1661 GateRef v1 = ReadInst8_2(pc); 1662 GateRef hole = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1663 Label isHole(env); 1664 Label notHole(env); 1665 BRANCH(TaggedIsHole(hole), &isHole, ¬Hole); 1666 Bind(¬Hole); 1667 { 1668 DISPATCH(THROW_UNDEFINEDIFHOLE_PREF_V8_V8); 1669 } 1670 Bind(&isHole); 1671 GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(v1)); 1672 // assert obj.IsString() 1673 CallRuntime(glue, RTSTUB_ID(ThrowUndefinedIfHole), { obj }); 1674 DISPATCH_LAST(); 1675} 1676 1677DECLARE_ASM_HANDLER(HandleThrowUndefinedifholewithnamePrefId16) 1678{ 1679 auto env = GetEnvironment(); 1680 1681 GateRef hole = acc; 1682 Label isHole(env); 1683 Label notHole(env); 1684 BRANCH(TaggedIsHole(hole), &isHole, ¬Hole); 1685 Bind(¬Hole); 1686 { 1687 DISPATCH(THROW_UNDEFINEDIFHOLEWITHNAME_PREF_ID16); 1688 } 1689 Bind(&isHole); 1690 GateRef stringId = ReadInst16_1(pc); 1691 GateRef str = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId)); 1692 // assert obj.IsString() 1693 CallRuntime(glue, RTSTUB_ID(ThrowUndefinedIfHole), { str }); 1694 DISPATCH_LAST(); 1695} 1696 1697DECLARE_ASM_HANDLER(HandleCopydatapropertiesV8) 1698{ 1699 GateRef v0 = ReadInst8_0(pc); 1700 GateRef dst = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1701 GateRef src = acc; 1702 GateRef result = CallRuntime(glue, RTSTUB_ID(CopyDataProperties), { dst, src }); 1703 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(COPYDATAPROPERTIES_V8)); 1704} 1705 1706DECLARE_ASM_HANDLER(HandleDeprecatedCopydatapropertiesPrefV8V8) 1707{ 1708 GateRef dst = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 1709 GateRef src = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); 1710 GateRef result = CallRuntime(glue, RTSTUB_ID(CopyDataProperties), { dst, src }); 1711 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DEPRECATED_COPYDATAPROPERTIES_PREF_V8_V8)); 1712} 1713 1714DECLARE_ASM_HANDLER(HandleStarrayspreadV8V8) 1715{ 1716 GateRef v0 = ReadInst8_0(pc); 1717 GateRef v1 = ReadInst8_1(pc); 1718 GateRef dst = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1719 GateRef index = GetVregValue(sp, ZExtInt8ToPtr(v1)); 1720 GateRef result = CallRuntime(glue, RTSTUB_ID(StArraySpread), { dst, index, acc }); // acc is res 1721 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(STARRAYSPREAD_V8_V8)); 1722} 1723 1724DECLARE_ASM_HANDLER(HandleSetobjectwithprotoImm8V8) 1725{ 1726 auto env = GetEnvironment(); 1727 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 1728 1729 GateRef v0 = ReadInst8_1(pc); 1730 GateRef proto = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1731 GateRef obj = *varAcc; 1732 GateRef result = CallRuntime(glue, RTSTUB_ID(SetObjectWithProto), { proto, obj }); 1733 Label notException(env); 1734 CHECK_EXCEPTION_WITH_JUMP(result, ¬Exception); 1735 Bind(¬Exception); 1736 DISPATCH_WITH_ACC(SETOBJECTWITHPROTO_IMM8_V8); 1737} 1738 1739DECLARE_ASM_HANDLER(HandleSetobjectwithprotoImm16V8) 1740{ 1741 auto env = GetEnvironment(); 1742 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 1743 1744 GateRef v0 = ReadInst8_2(pc); 1745 GateRef proto = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1746 GateRef obj = *varAcc; 1747 GateRef result = CallRuntime(glue, RTSTUB_ID(SetObjectWithProto), { proto, obj }); 1748 Label notException(env); 1749 CHECK_EXCEPTION_WITH_JUMP(result, ¬Exception); 1750 Bind(¬Exception); 1751 DISPATCH_WITH_ACC(SETOBJECTWITHPROTO_IMM16_V8); 1752} 1753 1754DECLARE_ASM_HANDLER(HandleDeprecatedSetobjectwithprotoPrefV8V8) 1755{ 1756 auto env = GetEnvironment(); 1757 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 1758 1759 GateRef proto = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 1760 GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); 1761 GateRef result = CallRuntime(glue, RTSTUB_ID(SetObjectWithProto), { proto, obj }); 1762 Label notException(env); 1763 CHECK_EXCEPTION_WITH_JUMP(result, ¬Exception); 1764 Bind(¬Exception); 1765 DISPATCH_WITH_ACC(DEPRECATED_SETOBJECTWITHPROTO_PREF_V8_V8); 1766} 1767 1768DECLARE_ASM_HANDLER(HandleStobjbyvalueImm8V8V8) 1769{ 1770 GateRef v0 = ReadInst8_1(pc); 1771 GateRef v1 = ReadInst8_2(pc); 1772 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1773 GateRef propKey = GetVregValue(sp, ZExtInt8ToPtr(v1)); 1774 GateRef value = acc; 1775 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); 1776 1777 AccessObjectStubBuilder builder(this); 1778 GateRef result = builder.StoreObjByValue(glue, receiver, propKey, value, profileTypeInfo, slotId, callback); 1779 CHECK_EXCEPTION(result, INT_PTR(STOBJBYVALUE_IMM8_V8_V8)); 1780} 1781 1782DECLARE_ASM_HANDLER(HandleStobjbyvalueImm16V8V8) 1783{ 1784 GateRef v0 = ReadInst8_2(pc); 1785 GateRef v1 = ReadInst8_3(pc); 1786 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1787 GateRef propKey = GetVregValue(sp, ZExtInt8ToPtr(v1)); 1788 GateRef value = acc; 1789 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc)); 1790 1791 AccessObjectStubBuilder builder(this); 1792 GateRef result = builder.StoreObjByValue(glue, receiver, propKey, value, profileTypeInfo, slotId, callback); 1793 CHECK_EXCEPTION(result, INT_PTR(STOBJBYVALUE_IMM16_V8_V8)); 1794} 1795 1796DECLARE_ASM_HANDLER(HandleStownbyvalueImm8V8V8) 1797{ 1798 auto env = GetEnvironment(); 1799 1800 GateRef v0 = ReadInst8_1(pc); 1801 GateRef v1 = ReadInst8_2(pc); 1802 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1803 GateRef propKey = GetVregValue(sp, ZExtInt8ToPtr(v1)); 1804 Label isHeapObject(env); 1805 Label slowPath(env); 1806 BRANCH(TaggedIsHeapObject(receiver), &isHeapObject, &slowPath); 1807 Bind(&isHeapObject); 1808 Label notClassConstructor(env); 1809 BRANCH(IsClassConstructor(receiver), &slowPath, ¬ClassConstructor); 1810 Bind(¬ClassConstructor); 1811 Label notClassPrototype(env); 1812 BRANCH(IsClassPrototype(receiver), &slowPath, ¬ClassPrototype); 1813 Bind(¬ClassPrototype); 1814 { 1815 // fast path 1816 GateRef result = SetPropertyByValue(glue, receiver, propKey, acc, true, callback); // acc is value 1817 Label notHole(env); 1818 BRANCH(TaggedIsHole(result), &slowPath, ¬Hole); 1819 Bind(¬Hole); 1820 CHECK_EXCEPTION(result, INT_PTR(STOWNBYVALUE_IMM8_V8_V8)); 1821 } 1822 Bind(&slowPath); 1823 { 1824 GateRef result = CallRuntime(glue, RTSTUB_ID(StOwnByValue), { receiver, propKey, acc }); 1825 CHECK_EXCEPTION(result, INT_PTR(STOWNBYVALUE_IMM8_V8_V8)); 1826 } 1827} 1828 1829DECLARE_ASM_HANDLER(HandleStownbyvalueImm16V8V8) 1830{ 1831 auto env = GetEnvironment(); 1832 1833 GateRef v0 = ReadInst8_2(pc); 1834 GateRef v1 = ReadInst8_3(pc); 1835 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1836 GateRef propKey = GetVregValue(sp, ZExtInt8ToPtr(v1)); 1837 Label isHeapObject(env); 1838 Label slowPath(env); 1839 BRANCH(TaggedIsHeapObject(receiver), &isHeapObject, &slowPath); 1840 Bind(&isHeapObject); 1841 Label notClassConstructor(env); 1842 BRANCH(IsClassConstructor(receiver), &slowPath, ¬ClassConstructor); 1843 Bind(¬ClassConstructor); 1844 Label notClassPrototype(env); 1845 BRANCH(IsClassPrototype(receiver), &slowPath, ¬ClassPrototype); 1846 Bind(¬ClassPrototype); 1847 { 1848 // fast path 1849 GateRef result = SetPropertyByValue(glue, receiver, propKey, acc, true, callback); // acc is value 1850 Label notHole(env); 1851 BRANCH(TaggedIsHole(result), &slowPath, ¬Hole); 1852 Bind(¬Hole); 1853 CHECK_EXCEPTION(result, INT_PTR(STOWNBYVALUE_IMM16_V8_V8)); 1854 } 1855 Bind(&slowPath); 1856 { 1857 GateRef result = CallRuntime(glue, RTSTUB_ID(StOwnByValue), { receiver, propKey, acc }); 1858 CHECK_EXCEPTION(result, INT_PTR(STOWNBYVALUE_IMM16_V8_V8)); 1859 } 1860} 1861 1862DECLARE_ASM_HANDLER(HandleStsuperbyvalueImm8V8V8) 1863{ 1864 GateRef v0 = ReadInst8_1(pc); 1865 GateRef v1 = ReadInst8_2(pc); 1866 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1867 GateRef propKey = GetVregValue(sp, ZExtInt8ToPtr(v1)); 1868 // acc is value, sp for thisFunc 1869 GateRef result = CallRuntime(glue, RTSTUB_ID(StSuperByValue), { receiver, propKey, acc }); 1870 CHECK_EXCEPTION(result, INT_PTR(STSUPERBYVALUE_IMM8_V8_V8)); 1871} 1872 1873DECLARE_ASM_HANDLER(HandleStsuperbyvalueImm16V8V8) 1874{ 1875 GateRef v0 = ReadInst8_2(pc); 1876 GateRef v1 = ReadInst8_3(pc); 1877 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1878 GateRef propKey = GetVregValue(sp, ZExtInt8ToPtr(v1)); 1879 // acc is value, sp for thisFunc 1880 GateRef result = CallRuntime(glue, RTSTUB_ID(StSuperByValue), { receiver, propKey, acc }); 1881 CHECK_EXCEPTION(result, INT_PTR(STSUPERBYVALUE_IMM16_V8_V8)); 1882} 1883 1884DECLARE_ASM_HANDLER(HandleStsuperbynameImm8Id16V8) 1885{ 1886 GateRef stringId = ReadInst16_1(pc); 1887 GateRef v0 = ReadInst8_3(pc); 1888 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1889 GateRef propKey = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId)); 1890 GateRef result = CallRuntime(glue, RTSTUB_ID(StSuperByValue), { receiver, propKey, acc }); 1891 CHECK_EXCEPTION(result, INT_PTR(STSUPERBYNAME_IMM8_ID16_V8)); 1892} 1893 1894DECLARE_ASM_HANDLER(HandleStsuperbynameImm16Id16V8) 1895{ 1896 GateRef stringId = ReadInst16_2(pc); 1897 GateRef v0 = ReadInst8_4(pc); 1898 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1899 GateRef propKey = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId)); 1900 GateRef result = CallRuntime(glue, RTSTUB_ID(StSuperByValue), { receiver, propKey, acc }); 1901 CHECK_EXCEPTION(result, INT_PTR(STSUPERBYNAME_IMM16_ID16_V8)); 1902} 1903 1904DECLARE_ASM_HANDLER(HandleStobjbyindexImm8V8Imm16) 1905{ 1906 auto env = GetEnvironment(); 1907 1908 GateRef v0 = ReadInst8_1(pc); 1909 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1910 GateRef index = ZExtInt16ToInt32(ReadInst16_2(pc)); 1911 Label fastPath(env); 1912 Label slowPath(env); 1913 BRANCH(TaggedIsHeapObject(receiver), &fastPath, &slowPath); 1914 Bind(&fastPath); 1915 { 1916 GateRef result = SetPropertyByIndex(glue, receiver, index, acc, false); 1917 Label notHole(env); 1918 BRANCH(TaggedIsHole(result), &slowPath, ¬Hole); 1919 Bind(¬Hole); 1920 CHECK_EXCEPTION(result, INT_PTR(STOBJBYINDEX_IMM8_V8_IMM16)); 1921 } 1922 Bind(&slowPath); 1923 { 1924 GateRef result = CallRuntime(glue, RTSTUB_ID(StObjByIndex), 1925 { receiver, IntToTaggedInt(index), acc }); 1926 CHECK_EXCEPTION(result, INT_PTR(STOBJBYINDEX_IMM8_V8_IMM16)); 1927 } 1928} 1929 1930DECLARE_ASM_HANDLER(HandleStobjbyindexImm16V8Imm16) 1931{ 1932 auto env = GetEnvironment(); 1933 1934 GateRef v0 = ReadInst8_2(pc); 1935 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1936 GateRef index = ZExtInt16ToInt32(ReadInst16_3(pc)); 1937 Label fastPath(env); 1938 Label slowPath(env); 1939 BRANCH(TaggedIsHeapObject(receiver), &fastPath, &slowPath); 1940 Bind(&fastPath); 1941 { 1942 GateRef result = SetPropertyByIndex(glue, receiver, index, acc, false); 1943 Label notHole(env); 1944 BRANCH(TaggedIsHole(result), &slowPath, ¬Hole); 1945 Bind(¬Hole); 1946 CHECK_EXCEPTION(result, INT_PTR(STOBJBYINDEX_IMM16_V8_IMM16)); 1947 } 1948 Bind(&slowPath); 1949 { 1950 GateRef result = CallRuntime(glue, RTSTUB_ID(StObjByIndex), 1951 { receiver, IntToTaggedInt(index), acc }); 1952 CHECK_EXCEPTION(result, INT_PTR(STOBJBYINDEX_IMM16_V8_IMM16)); 1953 } 1954} 1955 1956DECLARE_ASM_HANDLER(HandleWideStobjbyindexPrefV8Imm32) 1957{ 1958 auto env = GetEnvironment(); 1959 1960 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 1961 GateRef index = ReadInst32_2(pc); 1962 Label fastPath(env); 1963 Label slowPath(env); 1964 BRANCH(TaggedIsHeapObject(receiver), &fastPath, &slowPath); 1965 Bind(&fastPath); 1966 { 1967 GateRef result = SetPropertyByIndex(glue, receiver, index, acc, false); 1968 Label notHole(env); 1969 BRANCH(TaggedIsHole(result), &slowPath, ¬Hole); 1970 Bind(¬Hole); 1971 CHECK_EXCEPTION(result, INT_PTR(WIDE_STOBJBYINDEX_PREF_V8_IMM32)); 1972 } 1973 Bind(&slowPath); 1974 { 1975 GateRef result = CallRuntime(glue, RTSTUB_ID(StObjByIndex), 1976 { receiver, IntToTaggedInt(index), acc }); 1977 CHECK_EXCEPTION(result, INT_PTR(WIDE_STOBJBYINDEX_PREF_V8_IMM32)); 1978 } 1979} 1980 1981DECLARE_ASM_HANDLER(HandleStownbyindexImm8V8Imm16) 1982{ 1983 GateRef v0 = ReadInst8_1(pc); 1984 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1985 GateRef index = ZExtInt16ToInt32(ReadInst16_2(pc)); 1986 GateRef value = acc; 1987 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); 1988 1989 AccessObjectStubBuilder builder(this); 1990 GateRef result = builder.StoreOwnByIndex(glue, receiver, index, value, profileTypeInfo, slotId, callback); 1991 CHECK_EXCEPTION(result, INT_PTR(STOWNBYINDEX_IMM8_V8_IMM16)); 1992} 1993 1994DECLARE_ASM_HANDLER(HandleStownbyindexImm16V8Imm16) 1995{ 1996 GateRef v0 = ReadInst8_2(pc); 1997 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); 1998 GateRef index = ZExtInt16ToInt32(ReadInst16_3(pc)); 1999 GateRef value = acc; 2000 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc)); 2001 2002 AccessObjectStubBuilder builder(this); 2003 GateRef result = builder.StoreOwnByIndex(glue, receiver, index, value, profileTypeInfo, slotId, callback); 2004 CHECK_EXCEPTION(result, INT_PTR(STOWNBYINDEX_IMM16_V8_IMM16)); 2005} 2006 2007DECLARE_ASM_HANDLER(HandleWideStownbyindexPrefV8Imm32) 2008{ 2009 auto env = GetEnvironment(); 2010 2011 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 2012 GateRef index = ReadInst32_2(pc); 2013 Label isHeapObject(env); 2014 Label slowPath(env); 2015 BRANCH(TaggedIsHeapObject(receiver), &isHeapObject, &slowPath); 2016 Bind(&isHeapObject); 2017 Label notClassConstructor(env); 2018 BRANCH(IsClassConstructor(receiver), &slowPath, ¬ClassConstructor); 2019 Bind(¬ClassConstructor); 2020 Label notClassPrototype(env); 2021 BRANCH(IsClassPrototype(receiver), &slowPath, ¬ClassPrototype); 2022 Bind(¬ClassPrototype); 2023 { 2024 // fast path 2025 GateRef result = SetPropertyByIndex(glue, receiver, index, acc, true); // acc is value 2026 Label notHole(env); 2027 BRANCH(TaggedIsHole(result), &slowPath, ¬Hole); 2028 Bind(¬Hole); 2029 CHECK_EXCEPTION(result, INT_PTR(WIDE_STOWNBYINDEX_PREF_V8_IMM32)); 2030 } 2031 Bind(&slowPath); 2032 { 2033 GateRef result = CallRuntime(glue, RTSTUB_ID(StOwnByIndex), 2034 { receiver, IntToTaggedInt(index), acc }); 2035 CHECK_EXCEPTION(result, INT_PTR(WIDE_STOWNBYINDEX_PREF_V8_IMM32)); 2036 } 2037} 2038 2039DECLARE_ASM_HANDLER(HandleNegImm8) 2040{ 2041 OperationsStubBuilder builder(this); 2042 GateRef result = builder.Neg(glue, acc, callback); 2043 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(NEG_IMM8)); 2044} 2045 2046DECLARE_ASM_HANDLER(HandleDeprecatedNegPrefV8) 2047{ 2048 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 2049 OperationsStubBuilder builder(this); 2050 GateRef result = builder.Neg(glue, value); 2051 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DEPRECATED_NEG_PREF_V8)); 2052} 2053 2054DECLARE_ASM_HANDLER(HandleNotImm8) 2055{ 2056 OperationsStubBuilder builder(this); 2057 GateRef result = builder.Not(glue, acc, callback); 2058 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(NOT_IMM8)); 2059} 2060 2061DECLARE_ASM_HANDLER(HandleDeprecatedNotPrefV8) 2062{ 2063 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 2064 OperationsStubBuilder builder(this); 2065 GateRef result = builder.Not(glue, value); 2066 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DEPRECATED_NOT_PREF_V8)); 2067} 2068 2069DECLARE_ASM_HANDLER(HandleAnd2Imm8V8) 2070{ 2071 GateRef v0 = ReadInst8_1(pc); 2072 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(v0)); 2073 OperationsStubBuilder builder(this); 2074 GateRef result = builder.And(glue, left, acc, callback); 2075 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(AND2_IMM8_V8)); 2076} 2077 2078DECLARE_ASM_HANDLER(HandleOr2Imm8V8) 2079{ 2080 GateRef v0 = ReadInst8_1(pc); 2081 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(v0)); 2082 OperationsStubBuilder builder(this); 2083 GateRef result = builder.Or(glue, left, acc, callback); 2084 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(OR2_IMM8_V8)); 2085} 2086 2087DECLARE_ASM_HANDLER(HandleXor2Imm8V8) 2088{ 2089 GateRef v0 = ReadInst8_1(pc); 2090 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(v0)); 2091 OperationsStubBuilder builder(this); 2092 GateRef result = builder.Xor(glue, left, acc, callback); 2093 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(XOR2_IMM8_V8)); 2094} 2095 2096DECLARE_ASM_HANDLER(HandleAshr2Imm8V8) 2097{ 2098 GateRef v0 = ReadInst8_1(pc); 2099 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(v0)); 2100 OperationsStubBuilder builder(this); 2101 GateRef result = builder.Ashr(glue, left, acc, callback); 2102 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(ASHR2_IMM8_V8)); 2103} 2104 2105DECLARE_ASM_HANDLER(HandleShr2Imm8V8) 2106{ 2107 GateRef v0 = ReadInst8_1(pc); 2108 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(v0)); 2109 OperationsStubBuilder builder(this); 2110 GateRef result = builder.Shr(glue, left, acc, callback); 2111 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(SHR2_IMM8_V8)); 2112} 2113 2114DECLARE_ASM_HANDLER(HandleShl2Imm8V8) 2115{ 2116 GateRef v0 = ReadInst8_1(pc); 2117 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(v0)); 2118 OperationsStubBuilder builder(this); 2119 GateRef result = builder.Shl(glue, left, acc, callback); 2120 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(SHL2_IMM8_V8)); 2121} 2122 2123DECLARE_ASM_HANDLER(HandleStobjbynameImm8Id16V8) 2124{ 2125 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); 2126 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); 2127 2128 AccessObjectStubBuilder builder(this); 2129 StringIdInfo info(constpool, pc, StringIdInfo::Offset::BYTE_1, StringIdInfo::Length::BITS_16); 2130 GateRef result = builder.StoreObjByName(glue, receiver, 0, info, acc, profileTypeInfo, slotId, callback); 2131 CHECK_EXCEPTION(result, INT_PTR(STOBJBYNAME_IMM8_ID16_V8)); 2132} 2133 2134DECLARE_ASM_HANDLER(HandleStobjbynameImm16Id16V8) 2135{ 2136 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_4(pc))); 2137 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc)); 2138 2139 AccessObjectStubBuilder builder(this); 2140 StringIdInfo info(constpool, pc, StringIdInfo::Offset::BYTE_2, StringIdInfo::Length::BITS_16); 2141 GateRef result = builder.StoreObjByName(glue, receiver, 0, info, acc, profileTypeInfo, slotId, callback); 2142 CHECK_EXCEPTION(result, INT_PTR(STOBJBYNAME_IMM16_ID16_V8)); 2143} 2144 2145DECLARE_ASM_HANDLER(HandleStownbyvaluewithnamesetImm16V8V8) 2146{ 2147 auto env = GetEnvironment(); 2148 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); 2149 GateRef propKey = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); 2150 2151 Label isHeapObject(env); 2152 Label slowPath(env); 2153 Label notClassConstructor(env); 2154 Label notClassPrototype(env); 2155 Label notHole(env); 2156 Label notException(env); 2157 Label notException1(env); 2158 BRANCH(TaggedIsHeapObject(receiver), &isHeapObject, &slowPath); 2159 Bind(&isHeapObject); 2160 { 2161 BRANCH(IsClassConstructor(receiver), &slowPath, ¬ClassConstructor); 2162 Bind(¬ClassConstructor); 2163 { 2164 BRANCH(IsClassPrototype(receiver), &slowPath, ¬ClassPrototype); 2165 Bind(¬ClassPrototype); 2166 { 2167 GateRef res = SetPropertyByValue(glue, receiver, propKey, acc, true, callback, true); 2168 BRANCH(TaggedIsHole(res), &slowPath, ¬Hole); 2169 Bind(¬Hole); 2170 { 2171 CHECK_EXCEPTION_WITH_JUMP(res, ¬Exception); 2172 Bind(¬Exception); 2173 CallRuntime(glue, RTSTUB_ID(SetFunctionNameNoPrefix), { acc, propKey }); 2174 DISPATCH(STOWNBYVALUEWITHNAMESET_IMM16_V8_V8); 2175 } 2176 } 2177 } 2178 } 2179 Bind(&slowPath); 2180 { 2181 GateRef res = CallRuntime(glue, RTSTUB_ID(StOwnByValueWithNameSet), { receiver, propKey, acc }); 2182 CHECK_EXCEPTION_WITH_JUMP(res, ¬Exception1); 2183 Bind(¬Exception1); 2184 DISPATCH(STOWNBYVALUEWITHNAMESET_IMM16_V8_V8); 2185 } 2186} 2187 2188DECLARE_ASM_HANDLER(HandleStownbyvaluewithnamesetImm8V8V8) 2189{ 2190 auto env = GetEnvironment(); 2191 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 2192 GateRef propKey = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); 2193 2194 Label isHeapObject(env); 2195 Label slowPath(env); 2196 Label notClassConstructor(env); 2197 Label notClassPrototype(env); 2198 Label notHole(env); 2199 Label notException(env); 2200 Label notException1(env); 2201 BRANCH(TaggedIsHeapObject(receiver), &isHeapObject, &slowPath); 2202 Bind(&isHeapObject); 2203 { 2204 BRANCH(IsClassConstructor(receiver), &slowPath, ¬ClassConstructor); 2205 Bind(¬ClassConstructor); 2206 { 2207 BRANCH(IsClassPrototype(receiver), &slowPath, ¬ClassPrototype); 2208 Bind(¬ClassPrototype); 2209 { 2210 GateRef res = SetPropertyByValue(glue, receiver, propKey, acc, true, callback, true); 2211 BRANCH(TaggedIsHole(res), &slowPath, ¬Hole); 2212 Bind(¬Hole); 2213 { 2214 CHECK_EXCEPTION_WITH_JUMP(res, ¬Exception); 2215 Bind(¬Exception); 2216 CallRuntime(glue, RTSTUB_ID(SetFunctionNameNoPrefix), { acc, propKey }); 2217 DISPATCH(STOWNBYVALUEWITHNAMESET_IMM8_V8_V8); 2218 } 2219 } 2220 } 2221 } 2222 Bind(&slowPath); 2223 { 2224 GateRef res = CallRuntime(glue, RTSTUB_ID(StOwnByValueWithNameSet), { receiver, propKey, acc }); 2225 CHECK_EXCEPTION_WITH_JUMP(res, ¬Exception1); 2226 Bind(¬Exception1); 2227 DISPATCH(STOWNBYVALUEWITHNAMESET_IMM8_V8_V8); 2228 } 2229} 2230 2231DECLARE_ASM_HANDLER(HandleStownbynameImm8Id16V8) 2232{ 2233 auto env = GetEnvironment(); 2234 GateRef stringId = ReadInst16_1(pc); 2235 GateRef propKey = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId)); 2236 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); 2237 DEFVARIABLE(result, VariableType::JS_ANY(), Hole()); 2238 Label checkResult(env); 2239 2240 Label isJSObject(env); 2241 Label slowPath(env); 2242 BRANCH(IsJSObject(receiver), &isJSObject, &slowPath); 2243 Bind(&isJSObject); 2244 { 2245 Label notClassConstructor(env); 2246 BRANCH(IsClassConstructor(receiver), &slowPath, ¬ClassConstructor); 2247 Bind(¬ClassConstructor); 2248 { 2249 Label fastPath(env); 2250 BRANCH(IsClassPrototype(receiver), &slowPath, &fastPath); 2251 Bind(&fastPath); 2252 { 2253 result = SetPropertyByName(glue, receiver, propKey, acc, true, True(), callback); 2254 BRANCH(TaggedIsHole(*result), &slowPath, &checkResult); 2255 } 2256 } 2257 } 2258 Bind(&slowPath); 2259 { 2260 result = CallRuntime(glue, RTSTUB_ID(StOwnByName), { receiver, propKey, acc }); 2261 Jump(&checkResult); 2262 } 2263 Bind(&checkResult); 2264 { 2265 CHECK_EXCEPTION(*result, INT_PTR(STOWNBYNAME_IMM8_ID16_V8)); 2266 } 2267} 2268 2269DECLARE_ASM_HANDLER(HandleStownbynameImm16Id16V8) 2270{ 2271 auto env = GetEnvironment(); 2272 GateRef stringId = ReadInst16_2(pc); 2273 GateRef propKey = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId)); 2274 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_4(pc))); 2275 DEFVARIABLE(result, VariableType::JS_ANY(), Hole()); 2276 Label checkResult(env); 2277 2278 Label isJSObject(env); 2279 Label slowPath(env); 2280 BRANCH(IsJSObject(receiver), &isJSObject, &slowPath); 2281 Bind(&isJSObject); 2282 { 2283 Label notClassConstructor(env); 2284 BRANCH(IsClassConstructor(receiver), &slowPath, ¬ClassConstructor); 2285 Bind(¬ClassConstructor); 2286 { 2287 Label fastPath(env); 2288 BRANCH(IsClassPrototype(receiver), &slowPath, &fastPath); 2289 Bind(&fastPath); 2290 { 2291 result = SetPropertyByName(glue, receiver, propKey, acc, true, True(), callback); 2292 BRANCH(TaggedIsHole(*result), &slowPath, &checkResult); 2293 } 2294 } 2295 } 2296 Bind(&slowPath); 2297 { 2298 result = CallRuntime(glue, RTSTUB_ID(StOwnByName), { receiver, propKey, acc }); 2299 Jump(&checkResult); 2300 } 2301 Bind(&checkResult); 2302 { 2303 CHECK_EXCEPTION(*result, INT_PTR(STOWNBYNAME_IMM16_ID16_V8)); 2304 } 2305} 2306 2307DECLARE_ASM_HANDLER(HandleStownbynamewithnamesetImm8Id16V8) 2308{ 2309 auto env = GetEnvironment(); 2310 GateRef stringId = ReadInst16_1(pc); 2311 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); 2312 GateRef propKey = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId)); 2313 Label isJSObject(env); 2314 Label notJSObject(env); 2315 Label notClassConstructor(env); 2316 Label notClassPrototype(env); 2317 Label notHole(env); 2318 Label notException(env); 2319 Label notException1(env); 2320 BRANCH(IsJSObject(receiver), &isJSObject, ¬JSObject); 2321 Bind(&isJSObject); 2322 { 2323 BRANCH(IsClassConstructor(receiver), ¬JSObject, ¬ClassConstructor); 2324 Bind(¬ClassConstructor); 2325 { 2326 BRANCH(IsClassPrototype(receiver), ¬JSObject, ¬ClassPrototype); 2327 Bind(¬ClassPrototype); 2328 { 2329 GateRef res = SetPropertyByName(glue, receiver, propKey, acc, true, True(), callback, false, true); 2330 BRANCH(TaggedIsHole(res), ¬JSObject, ¬Hole); 2331 Bind(¬Hole); 2332 { 2333 CHECK_EXCEPTION_WITH_JUMP(res, ¬Exception); 2334 Bind(¬Exception); 2335 CallRuntime(glue, RTSTUB_ID(SetFunctionNameNoPrefix), { acc, propKey }); 2336 DISPATCH(STOWNBYNAMEWITHNAMESET_IMM8_ID16_V8); 2337 } 2338 } 2339 } 2340 } 2341 Bind(¬JSObject); 2342 { 2343 GateRef res = CallRuntime(glue, RTSTUB_ID(StOwnByNameWithNameSet), { receiver, propKey, acc }); 2344 CHECK_EXCEPTION_WITH_JUMP(res, ¬Exception1); 2345 Bind(¬Exception1); 2346 DISPATCH(STOWNBYNAMEWITHNAMESET_IMM8_ID16_V8); 2347 } 2348} 2349DECLARE_ASM_HANDLER(HandleStownbynamewithnamesetImm16Id16V8) 2350{ 2351 auto env = GetEnvironment(); 2352 GateRef stringId = ReadInst16_2(pc); 2353 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_4(pc))); 2354 GateRef propKey = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId)); 2355 Label isJSObject(env); 2356 Label notJSObject(env); 2357 Label notClassConstructor(env); 2358 Label notClassPrototype(env); 2359 Label notHole(env); 2360 Label notException(env); 2361 Label notException1(env); 2362 BRANCH(IsJSObject(receiver), &isJSObject, ¬JSObject); 2363 Bind(&isJSObject); 2364 { 2365 BRANCH(IsClassConstructor(receiver), ¬JSObject, ¬ClassConstructor); 2366 Bind(¬ClassConstructor); 2367 { 2368 BRANCH(IsClassPrototype(receiver), ¬JSObject, ¬ClassPrototype); 2369 Bind(¬ClassPrototype); 2370 { 2371 GateRef res = SetPropertyByName(glue, receiver, propKey, acc, true, True(), callback, false, true); 2372 BRANCH(TaggedIsHole(res), ¬JSObject, ¬Hole); 2373 Bind(¬Hole); 2374 { 2375 CHECK_EXCEPTION_WITH_JUMP(res, ¬Exception); 2376 Bind(¬Exception); 2377 CallRuntime(glue, RTSTUB_ID(SetFunctionNameNoPrefix), { acc, propKey }); 2378 DISPATCH(STOWNBYNAMEWITHNAMESET_IMM16_ID16_V8); 2379 } 2380 } 2381 } 2382 } 2383 Bind(¬JSObject); 2384 { 2385 GateRef res = CallRuntime(glue, RTSTUB_ID(StOwnByNameWithNameSet), { receiver, propKey, acc }); 2386 CHECK_EXCEPTION_WITH_JUMP(res, ¬Exception1); 2387 Bind(¬Exception1); 2388 DISPATCH(STOWNBYNAMEWITHNAMESET_IMM16_ID16_V8); 2389 } 2390} 2391 2392DECLARE_ASM_HANDLER(HandleLdfunction) 2393{ 2394 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 2395 2396 varAcc = GetFunctionFromFrame(GetFrame(sp)); 2397 DISPATCH_WITH_ACC(LDFUNCTION); 2398} 2399 2400DECLARE_ASM_HANDLER(HandleMovV4V4) 2401{ 2402 GateRef vdst = ZExtInt8ToPtr(ReadInst4_0(pc)); 2403 GateRef vsrc = ZExtInt8ToPtr(ReadInst4_1(pc)); 2404 GateRef value = GetVregValue(sp, vsrc); 2405 SetVregValue(glue, sp, vdst, value); 2406 DISPATCH(MOV_V4_V4); 2407} 2408 2409DECLARE_ASM_HANDLER(HandleMovV8V8) 2410{ 2411 GateRef vdst = ZExtInt8ToPtr(ReadInst8_0(pc)); 2412 GateRef vsrc = ZExtInt8ToPtr(ReadInst8_1(pc)); 2413 GateRef value = GetVregValue(sp, vsrc); 2414 SetVregValue(glue, sp, vdst, value); 2415 DISPATCH(MOV_V8_V8); 2416} 2417 2418DECLARE_ASM_HANDLER(HandleMovV16V16) 2419{ 2420 GateRef vdst = ZExtInt16ToPtr(ReadInst16_0(pc)); 2421 GateRef vsrc = ZExtInt16ToPtr(ReadInst16_2(pc)); 2422 GateRef value = GetVregValue(sp, vsrc); 2423 SetVregValue(glue, sp, vdst, value); 2424 DISPATCH(MOV_V16_V16); 2425} 2426 2427DECLARE_ASM_HANDLER(HandleLdaStrId16) 2428{ 2429 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 2430 2431 GateRef stringId = ReadInst16_0(pc); 2432 varAcc = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId)); 2433 DISPATCH_WITH_ACC(LDA_STR_ID16); 2434} 2435 2436DECLARE_ASM_HANDLER(HandleLdaiImm32) 2437{ 2438 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 2439 2440 GateRef imm = ReadInst32_0(pc); 2441 varAcc = IntToTaggedPtr(imm); 2442 DISPATCH_WITH_ACC(LDAI_IMM32); 2443} 2444 2445DECLARE_ASM_HANDLER(HandleFldaiImm64) 2446{ 2447 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 2448 2449 GateRef imm = CastInt64ToFloat64(ReadInst64_0(pc)); 2450 varAcc = DoubleToTaggedDoublePtr(imm); 2451 DISPATCH_WITH_ACC(FLDAI_IMM64); 2452} 2453 2454DECLARE_ASM_HANDLER(HandleJeqzImm8) 2455{ 2456 auto env = GetEnvironment(); 2457 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_ANY(), profileTypeInfo); 2458 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); 2459 2460 Label accEqualFalse(env); 2461 Label accNotEqualFalse(env); 2462 Label accIsInt(env); 2463 Label accNotInt(env); 2464 Label accIsDouble(env); 2465 Label last(env); 2466 BRANCH(TaggedIsFalse(acc), &accEqualFalse, &accNotEqualFalse); 2467 Bind(&accNotEqualFalse); 2468 { 2469 BRANCH(TaggedIsInt(acc), &accIsInt, &accNotInt); 2470 Bind(&accIsInt); 2471 { 2472 BRANCH(Int32Equal(TaggedGetInt(acc), Int32(0)), &accEqualFalse, &accNotInt); 2473 } 2474 Bind(&accNotInt); 2475 { 2476 BRANCH(TaggedIsDouble(acc), &accIsDouble, &last); 2477 Bind(&accIsDouble); 2478 { 2479 BRANCH(DoubleEqual(GetDoubleOfTDouble(acc), Double(0)), &accEqualFalse, &last); 2480 } 2481 } 2482 } 2483 Bind(&accEqualFalse); 2484 { 2485 Label dispatch(env); 2486 Label slowPath(env); 2487 GateRef offset = ReadInstSigned8_0(pc); 2488 UPDATE_HOTNESS(sp, callback); 2489 DISPATCH_BAK(JUMP, SExtInt32ToPtr(offset)); 2490 } 2491 Bind(&last); 2492 DISPATCH_BAK(JUMP, INT_PTR(JEQZ_IMM8)); 2493} 2494 2495DECLARE_ASM_HANDLER(HandleJeqzImm16) 2496{ 2497 auto env = GetEnvironment(); 2498 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_ANY(), profileTypeInfo); 2499 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); 2500 2501 Label accEqualFalse(env); 2502 Label accNotEqualFalse(env); 2503 Label accIsInt(env); 2504 Label accNotInt(env); 2505 Label accIsDouble(env); 2506 Label last(env); 2507 BRANCH(TaggedIsFalse(acc), &accEqualFalse, &accNotEqualFalse); 2508 Bind(&accNotEqualFalse); 2509 { 2510 BRANCH(TaggedIsInt(acc), &accIsInt, &accNotInt); 2511 Bind(&accIsInt); 2512 { 2513 BRANCH(Int32Equal(TaggedGetInt(acc), Int32(0)), &accEqualFalse, &accNotInt); 2514 } 2515 Bind(&accNotInt); 2516 { 2517 BRANCH(TaggedIsDouble(acc), &accIsDouble, &last); 2518 Bind(&accIsDouble); 2519 { 2520 BRANCH(DoubleEqual(GetDoubleOfTDouble(acc), Double(0)), &accEqualFalse, &last); 2521 } 2522 } 2523 } 2524 Bind(&accEqualFalse); 2525 { 2526 Label dispatch(env); 2527 Label slowPath(env); 2528 GateRef offset = ReadInstSigned16_0(pc); 2529 UPDATE_HOTNESS(sp, callback); 2530 DISPATCH_BAK(JUMP, SExtInt32ToPtr(offset)); 2531 } 2532 Bind(&last); 2533 DISPATCH_BAK(JUMP, INT_PTR(JEQZ_IMM16)); 2534} 2535 2536DECLARE_ASM_HANDLER(HandleJeqzImm32) 2537{ 2538 auto env = GetEnvironment(); 2539 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_ANY(), profileTypeInfo); 2540 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); 2541 2542 Label accEqualFalse(env); 2543 Label accNotEqualFalse(env); 2544 Label accIsInt(env); 2545 Label accNotInt(env); 2546 Label accIsDouble(env); 2547 Label last(env); 2548 BRANCH(TaggedIsFalse(acc), &accEqualFalse, &accNotEqualFalse); 2549 Bind(&accNotEqualFalse); 2550 { 2551 BRANCH(TaggedIsInt(acc), &accIsInt, &accNotInt); 2552 Bind(&accIsInt); 2553 { 2554 BRANCH(Int32Equal(TaggedGetInt(acc), Int32(0)), &accEqualFalse, &accNotInt); 2555 } 2556 Bind(&accNotInt); 2557 { 2558 BRANCH(TaggedIsDouble(acc), &accIsDouble, &last); 2559 Bind(&accIsDouble); 2560 { 2561 BRANCH(DoubleEqual(GetDoubleOfTDouble(acc), Double(0)), &accEqualFalse, &last); 2562 } 2563 } 2564 } 2565 Bind(&accEqualFalse); 2566 { 2567 Label dispatch(env); 2568 Label slowPath(env); 2569 GateRef offset = ReadInstSigned32_0(pc); 2570 UPDATE_HOTNESS(sp, callback); 2571 DISPATCH_BAK(JUMP, SExtInt32ToPtr(offset)); 2572 } 2573 Bind(&last); 2574 DISPATCH_BAK(JUMP, INT_PTR(JEQZ_IMM32)); 2575} 2576 2577DECLARE_ASM_HANDLER(HandleJnezImm8) 2578{ 2579 auto env = GetEnvironment(); 2580 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_ANY(), profileTypeInfo); 2581 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); 2582 2583 Label accEqualTrue(env); 2584 Label accNotEqualTrue(env); 2585 Label accIsInt(env); 2586 Label accNotInt(env); 2587 Label accIsDouble(env); 2588 Label last(env); 2589 BRANCH(TaggedIsTrue(acc), &accEqualTrue, &accNotEqualTrue); 2590 Bind(&accNotEqualTrue); 2591 { 2592 BRANCH(TaggedIsInt(acc), &accIsInt, &accNotInt); 2593 Bind(&accIsInt); 2594 { 2595 BRANCH(Int32Equal(TaggedGetInt(acc), Int32(0)), &accNotInt, &accEqualTrue); 2596 } 2597 Bind(&accNotInt); 2598 { 2599 BRANCH(TaggedIsDouble(acc), &accIsDouble, &last); 2600 Bind(&accIsDouble); 2601 { 2602 BRANCH(DoubleEqual(GetDoubleOfTDouble(acc), Double(0)), &last, &accEqualTrue); 2603 } 2604 } 2605 } 2606 Bind(&accEqualTrue); 2607 { 2608 Label dispatch(env); 2609 Label slowPath(env); 2610 GateRef offset = ReadInstSigned8_0(pc); 2611 UPDATE_HOTNESS(sp, callback); 2612 DISPATCH_BAK(JUMP, SExtInt32ToPtr(offset)); 2613 } 2614 Bind(&last); 2615 DISPATCH_BAK(JUMP, INT_PTR(JNEZ_IMM8)); 2616} 2617 2618DECLARE_ASM_HANDLER(HandleJnezImm16) 2619{ 2620 auto env = GetEnvironment(); 2621 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_ANY(), profileTypeInfo); 2622 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); 2623 2624 Label accEqualTrue(env); 2625 Label accNotEqualTrue(env); 2626 Label accIsInt(env); 2627 Label accNotInt(env); 2628 Label accIsDouble(env); 2629 Label last(env); 2630 BRANCH(TaggedIsTrue(acc), &accEqualTrue, &accNotEqualTrue); 2631 Bind(&accNotEqualTrue); 2632 { 2633 BRANCH(TaggedIsInt(acc), &accIsInt, &accNotInt); 2634 Bind(&accIsInt); 2635 { 2636 BRANCH(Int32Equal(TaggedGetInt(acc), Int32(0)), &accNotInt, &accEqualTrue); 2637 } 2638 Bind(&accNotInt); 2639 { 2640 BRANCH(TaggedIsDouble(acc), &accIsDouble, &last); 2641 Bind(&accIsDouble); 2642 { 2643 BRANCH(DoubleEqual(GetDoubleOfTDouble(acc), Double(0)), &last, &accEqualTrue); 2644 } 2645 } 2646 } 2647 Bind(&accEqualTrue); 2648 { 2649 Label dispatch(env); 2650 Label slowPath(env); 2651 GateRef offset = ReadInstSigned16_0(pc); 2652 UPDATE_HOTNESS(sp, callback); 2653 DISPATCH_BAK(JUMP, SExtInt32ToPtr(offset)); 2654 } 2655 Bind(&last); 2656 DISPATCH_BAK(JUMP, INT_PTR(JNEZ_IMM16)); 2657} 2658 2659DECLARE_ASM_HANDLER(HandleJnezImm32) 2660{ 2661 auto env = GetEnvironment(); 2662 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_ANY(), profileTypeInfo); 2663 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); 2664 2665 Label accEqualTrue(env); 2666 Label accNotEqualTrue(env); 2667 Label accIsInt(env); 2668 Label accNotInt(env); 2669 Label accIsDouble(env); 2670 Label last(env); 2671 BRANCH(TaggedIsTrue(acc), &accEqualTrue, &accNotEqualTrue); 2672 Bind(&accNotEqualTrue); 2673 { 2674 BRANCH(TaggedIsInt(acc), &accIsInt, &accNotInt); 2675 Bind(&accIsInt); 2676 { 2677 BRANCH(Int32Equal(TaggedGetInt(acc), Int32(0)), &accNotInt, &accEqualTrue); 2678 } 2679 Bind(&accNotInt); 2680 { 2681 BRANCH(TaggedIsDouble(acc), &accIsDouble, &last); 2682 Bind(&accIsDouble); 2683 { 2684 BRANCH(DoubleEqual(GetDoubleOfTDouble(acc), Double(0)), &last, &accEqualTrue); 2685 } 2686 } 2687 } 2688 Bind(&accEqualTrue); 2689 { 2690 Label dispatch(env); 2691 Label slowPath(env); 2692 GateRef offset = ReadInstSigned32_0(pc); 2693 UPDATE_HOTNESS(sp, callback); 2694 DISPATCH_BAK(JUMP, SExtInt32ToPtr(offset)); 2695 } 2696 Bind(&last); 2697 DISPATCH_BAK(JUMP, INT_PTR(JNEZ_IMM32)); 2698} 2699 2700DECLARE_ASM_HANDLER(HandleReturn) 2701{ 2702 auto env = GetEnvironment(); 2703 METHOD_EXIT(); 2704 DEFVARIABLE(varPc, VariableType::NATIVE_POINTER(), pc); 2705 DEFVARIABLE(varSp, VariableType::NATIVE_POINTER(), sp); 2706 DEFVARIABLE(prevState, VariableType::NATIVE_POINTER(), sp); 2707 DEFVARIABLE(varConstpool, VariableType::JS_POINTER(), constpool); 2708 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_POINTER(), profileTypeInfo); 2709 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 2710 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); 2711 2712 Label isBaselineBuiltinFrame(env); 2713 Label notBaselineBuiltinFrame(env); 2714 Label pcEqualNullptr(env); 2715 Label pcNotEqualNullptr(env); 2716 Label pcEqualBaseline(env); 2717 Label pcNotEqualBaseline(env); 2718 Label updateHotness(env); 2719 Label isStable(env); 2720 Label tryContinue(env); 2721 Label dispatch(env); 2722 Label slowPath(env); 2723 2724 GateRef frame = GetFrame(*varSp); 2725 BRANCH(TaggedIsUndefined(*varProfileTypeInfo), &updateHotness, &isStable); 2726 Bind(&isStable); 2727 { 2728 GateRef varProfileTypeInfoVal = *varProfileTypeInfo; 2729 GateRef isProfileDumpedAndJitCompiled = LogicAndBuilder(env) 2730 .And(ProfilerStubBuilder(env).IsProfileTypeInfoDumped(varProfileTypeInfoVal, callback)) 2731 .And(ProfilerStubBuilder(env).IsCompiledOrTryCompile(glue, GetFunctionFromFrame(frame), 2732 varProfileTypeInfoVal, callback)) 2733 .Done(); 2734 BRANCH(isProfileDumpedAndJitCompiled, &tryContinue, &updateHotness); 2735 } 2736 Bind(&updateHotness); 2737 { 2738 GateRef function = GetFunctionFromFrame(frame); 2739 GateRef method = Load(VariableType::JS_ANY(), function, 2740 IntPtr(JSFunctionBase::METHOD_OFFSET)); 2741 GateRef fistPC = Load(VariableType::NATIVE_POINTER(), method, 2742 IntPtr(Method::NATIVE_POINTER_OR_BYTECODE_ARRAY_OFFSET)); 2743 GateRef offset = Int32Not(TruncPtrToInt32(PtrSub(*varPc, fistPC))); 2744 UPDATE_HOTNESS(*varSp, callback); 2745 SetHotnessCounter(glue, method, *varHotnessCounter); 2746 Jump(&tryContinue); 2747 } 2748 2749 Bind(&tryContinue); 2750#if ECMASCRIPT_ENABLE_FUNCTION_CALL_TIMER 2751 GateRef curFunc = GetFunctionFromFrame(frame); 2752 CallNGCRuntime(glue, RTSTUB_ID(EndCallTimer), { glue, curFunc }); 2753#endif 2754 GateRef currentSp = *varSp; 2755 varSp = Load(VariableType::NATIVE_POINTER(), frame, 2756 IntPtr(AsmInterpretedFrame::GetBaseOffset(env->IsArch32Bit()))); 2757 2758 GateRef typePos = PtrSub(*varSp, IntPtr(JSTaggedValue::TaggedTypeSize())); 2759 GateRef maybeFrameType = Load(VariableType::INT64(), typePos); 2760 BRANCH(Int64Equal(maybeFrameType, Int64(static_cast<int64_t>(FrameType::BASELINE_BUILTIN_FRAME))), 2761 &isBaselineBuiltinFrame, ¬BaselineBuiltinFrame); 2762 Bind(&isBaselineBuiltinFrame); 2763 { 2764 varSp = Load(VariableType::NATIVE_POINTER(), *varSp); 2765 Jump(¬BaselineBuiltinFrame); 2766 } 2767 Bind(¬BaselineBuiltinFrame); 2768 prevState = GetFrame(*varSp); 2769 varPc = GetPcFromFrame(*prevState); 2770 BRANCH(IntPtrEqual(*varPc, IntPtr(0)), &pcEqualNullptr, &pcNotEqualNullptr); 2771 Bind(&pcEqualNullptr); 2772 { 2773 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndReturn), { *varAcc, *varSp, currentSp }); 2774 Return(); 2775 } 2776 Bind(&pcNotEqualNullptr); 2777 BRANCH(IntPtrEqual(*varPc, IntPtr(BASELINEJIT_PC_FLAG)), &pcEqualBaseline, &pcNotEqualBaseline); 2778 Bind(&pcEqualBaseline); 2779 { 2780 GateRef jumpSize = GetCallSizeFromFrame(*prevState); 2781 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndReturnBaseline), { *varAcc, *varSp, currentSp, jumpSize }); 2782 Return(); 2783 } 2784 Bind(&pcNotEqualBaseline); 2785 { 2786 GateRef function = GetFunctionFromFrame(*prevState); 2787 GateRef method = Load(VariableType::JS_ANY(), function, IntPtr(JSFunctionBase::METHOD_OFFSET)); 2788 varConstpool = GetConstpoolFromMethod(method); 2789 varProfileTypeInfo = GetProfileTypeInfoFromFunction(function); 2790 varHotnessCounter = GetHotnessCounterFromMethod(method); 2791 GateRef jumpSize = GetCallSizeFromFrame(*prevState); 2792 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndDispatch), 2793 { glue, currentSp, *varPc, *varConstpool, *varProfileTypeInfo, 2794 *varAcc, *varHotnessCounter, jumpSize }); 2795 Return(); 2796 } 2797} 2798 2799DECLARE_ASM_HANDLER(HandleReturnundefined) 2800{ 2801 auto env = GetEnvironment(); 2802 METHOD_EXIT(); 2803 DEFVARIABLE(varPc, VariableType::NATIVE_POINTER(), pc); 2804 DEFVARIABLE(varSp, VariableType::NATIVE_POINTER(), sp); 2805 DEFVARIABLE(prevState, VariableType::NATIVE_POINTER(), sp); 2806 DEFVARIABLE(varConstpool, VariableType::JS_POINTER(), constpool); 2807 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_POINTER(), profileTypeInfo); 2808 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 2809 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); 2810 2811 Label isBaselineBuiltinFrame(env); 2812 Label notBaselineBuiltinFrame(env); 2813 Label pcEqualNullptr(env); 2814 Label pcNotEqualNullptr(env); 2815 Label pcEqualBaseline(env); 2816 Label pcNotEqualBaseline(env); 2817 Label updateHotness(env); 2818 Label isStable(env); 2819 Label tryContinue(env); 2820 Label dispatch(env); 2821 Label slowPath(env); 2822 2823 GateRef frame = GetFrame(*varSp); 2824 BRANCH(TaggedIsUndefined(*varProfileTypeInfo), &updateHotness, &isStable); 2825 Bind(&isStable); 2826 { 2827 GateRef varProfileTypeInfoVal = *varProfileTypeInfo; 2828 GateRef isProfileDumpedAndJitCompiled = LogicAndBuilder(env) 2829 .And(ProfilerStubBuilder(env).IsProfileTypeInfoDumped(varProfileTypeInfoVal, callback)) 2830 .And(ProfilerStubBuilder(env).IsCompiledOrTryCompile(glue, GetFunctionFromFrame(frame), 2831 varProfileTypeInfoVal, callback)) 2832 .Done(); 2833 BRANCH(isProfileDumpedAndJitCompiled, &tryContinue, &updateHotness); 2834 } 2835 Bind(&updateHotness); 2836 { 2837 GateRef function = GetFunctionFromFrame(frame); 2838 GateRef method = Load(VariableType::JS_ANY(), function, 2839 IntPtr(JSFunctionBase::METHOD_OFFSET)); 2840 GateRef fistPC = Load(VariableType::NATIVE_POINTER(), method, 2841 IntPtr(Method::NATIVE_POINTER_OR_BYTECODE_ARRAY_OFFSET)); 2842 GateRef offset = Int32Not(TruncPtrToInt32(PtrSub(*varPc, fistPC))); 2843 UPDATE_HOTNESS(*varSp, callback); 2844 SetHotnessCounter(glue, method, *varHotnessCounter); 2845 Jump(&tryContinue); 2846 } 2847 2848 Bind(&tryContinue); 2849#if ECMASCRIPT_ENABLE_FUNCTION_CALL_TIMER 2850 GateRef curFunc = GetFunctionFromFrame(frame); 2851 CallNGCRuntime(glue, RTSTUB_ID(EndCallTimer), { glue, curFunc }); 2852#endif 2853 GateRef currentSp = *varSp; 2854 varSp = Load(VariableType::NATIVE_POINTER(), frame, 2855 IntPtr(AsmInterpretedFrame::GetBaseOffset(env->IsArch32Bit()))); 2856 2857 GateRef typePos = PtrSub(*varSp, IntPtr(JSTaggedValue::TaggedTypeSize())); 2858 GateRef maybeFrameType = Load(VariableType::INT64(), typePos); 2859 BRANCH(Int64Equal(maybeFrameType, Int64(static_cast<int64_t>(FrameType::BASELINE_BUILTIN_FRAME))), 2860 &isBaselineBuiltinFrame, ¬BaselineBuiltinFrame); 2861 Bind(&isBaselineBuiltinFrame); 2862 { 2863 varSp = Load(VariableType::NATIVE_POINTER(), *varSp); 2864 Jump(¬BaselineBuiltinFrame); 2865 } 2866 Bind(¬BaselineBuiltinFrame); 2867 prevState = GetFrame(*varSp); 2868 varPc = GetPcFromFrame(*prevState); 2869 varAcc = Undefined(); 2870 BRANCH(IntPtrEqual(*varPc, IntPtr(0)), &pcEqualNullptr, &pcNotEqualNullptr); 2871 Bind(&pcEqualNullptr); 2872 { 2873 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndReturn), { *varAcc, *varSp, currentSp }); 2874 Return(); 2875 } 2876 Bind(&pcNotEqualNullptr); 2877 BRANCH(IntPtrEqual(*varPc, IntPtr(BASELINEJIT_PC_FLAG)), &pcEqualBaseline, &pcNotEqualBaseline); 2878 Bind(&pcEqualBaseline); 2879 { 2880 GateRef jumpSize = GetCallSizeFromFrame(*prevState); 2881 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndReturnBaseline), { *varAcc, *varSp, currentSp, jumpSize }); 2882 Return(); 2883 } 2884 Bind(&pcNotEqualBaseline); 2885 { 2886 GateRef function = GetFunctionFromFrame(*prevState); 2887 GateRef method = Load(VariableType::JS_ANY(), function, IntPtr(JSFunctionBase::METHOD_OFFSET)); 2888 varConstpool = GetConstpoolFromMethod(method); 2889 varProfileTypeInfo = GetProfileTypeInfoFromFunction(function); 2890 varHotnessCounter = GetHotnessCounterFromMethod(method); 2891 GateRef jumpSize = GetCallSizeFromFrame(*prevState); 2892 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndDispatch), 2893 { glue, currentSp, *varPc, *varConstpool, *varProfileTypeInfo, 2894 *varAcc, *varHotnessCounter, jumpSize }); 2895 Return(); 2896 } 2897} 2898 2899DECLARE_ASM_HANDLER(HandleSuspendgeneratorV8) 2900{ 2901 auto env = GetEnvironment(); 2902 METHOD_EXIT(); 2903 DEFVARIABLE(varPc, VariableType::NATIVE_POINTER(), pc); 2904 DEFVARIABLE(varSp, VariableType::NATIVE_POINTER(), sp); 2905 DEFVARIABLE(prevState, VariableType::NATIVE_POINTER(), sp); 2906 DEFVARIABLE(varConstpool, VariableType::JS_POINTER(), constpool); 2907 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_POINTER(), profileTypeInfo); 2908 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 2909 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); 2910 2911 Label isBaselineBuiltinFrame(env); 2912 Label notBaselineBuiltinFrame(env); 2913 Label pcEqualNullptr(env); 2914 Label pcNotEqualNullptr(env); 2915 Label pcEqualBaseline(env); 2916 Label pcNotEqualBaseline(env); 2917 Label updateHotness(env); 2918 Label isStable(env); 2919 Label tryContinue(env); 2920 Label dispatch(env); 2921 Label slowPath(env); 2922 2923 GateRef genObj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_0(pc))); 2924 GateRef value = *varAcc; 2925 GateRef frame = GetFrame(*varSp); 2926 GateRef res = CallRuntime(glue, RTSTUB_ID(SuspendGenerator), { genObj, value }); 2927 Label isException(env); 2928 Label notException(env); 2929 BRANCH(TaggedIsException(res), &isException, ¬Exception); 2930 Bind(&isException); 2931 { 2932 DispatchLast(glue, *varSp, *varPc, *varConstpool, *varProfileTypeInfo, *varAcc, *varHotnessCounter); 2933 } 2934 Bind(¬Exception); 2935 varAcc = res; 2936 BRANCH(TaggedIsUndefined(*varProfileTypeInfo), &updateHotness, &isStable); 2937 Bind(&isStable); 2938 { 2939 BRANCH(ProfilerStubBuilder(env).IsProfileTypeInfoDumped(*varProfileTypeInfo, callback), &tryContinue, 2940 &updateHotness); 2941 } 2942 Bind(&updateHotness); 2943 { 2944 GateRef function = GetFunctionFromFrame(frame); 2945 GateRef method = Load(VariableType::JS_ANY(), function, 2946 IntPtr(JSFunctionBase::METHOD_OFFSET)); 2947 GateRef fistPC = Load(VariableType::NATIVE_POINTER(), method, 2948 IntPtr(Method::NATIVE_POINTER_OR_BYTECODE_ARRAY_OFFSET)); 2949 GateRef offset = Int32Not(TruncPtrToInt32(PtrSub(*varPc, fistPC))); 2950 UPDATE_HOTNESS(*varSp, callback); 2951 SetHotnessCounter(glue, method, *varHotnessCounter); 2952 Jump(&tryContinue); 2953 } 2954 2955 Bind(&tryContinue); 2956#if ECMASCRIPT_ENABLE_FUNCTION_CALL_TIMER 2957 GateRef curFunc = GetFunctionFromFrame(frame); 2958 CallNGCRuntime(glue, RTSTUB_ID(EndCallTimer), { glue, curFunc }); 2959#endif 2960 GateRef currentSp = *varSp; 2961 varSp = Load(VariableType::NATIVE_POINTER(), frame, 2962 IntPtr(AsmInterpretedFrame::GetBaseOffset(env->IsArch32Bit()))); 2963 2964 GateRef typePos = PtrSub(*varSp, IntPtr(JSTaggedValue::TaggedTypeSize())); 2965 GateRef maybeFrameType = Load(VariableType::INT64(), typePos); 2966 BRANCH(Int64Equal(maybeFrameType, Int64(static_cast<int64_t>(FrameType::BASELINE_BUILTIN_FRAME))), 2967 &isBaselineBuiltinFrame, ¬BaselineBuiltinFrame); 2968 Bind(&isBaselineBuiltinFrame); 2969 { 2970 varSp = Load(VariableType::NATIVE_POINTER(), *varSp); 2971 Jump(¬BaselineBuiltinFrame); 2972 } 2973 Bind(¬BaselineBuiltinFrame); 2974 prevState = GetFrame(*varSp); 2975 varPc = GetPcFromFrame(*prevState); 2976 BRANCH(IntPtrEqual(*varPc, IntPtr(0)), &pcEqualNullptr, &pcNotEqualNullptr); 2977 Bind(&pcEqualNullptr); 2978 { 2979 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndReturn), { *varAcc, *varSp, currentSp }); 2980 Return(); 2981 } 2982 Bind(&pcNotEqualNullptr); 2983 BRANCH(IntPtrEqual(*varPc, IntPtr(BASELINEJIT_PC_FLAG)), &pcEqualBaseline, &pcNotEqualBaseline); 2984 Bind(&pcEqualBaseline); 2985 { 2986 GateRef jumpSize = GetCallSizeFromFrame(*prevState); 2987 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndReturnBaseline), { *varAcc, *varSp, currentSp, jumpSize }); 2988 Return(); 2989 } 2990 Bind(&pcNotEqualBaseline); 2991 { 2992 GateRef function = GetFunctionFromFrame(*prevState); 2993 GateRef method = Load(VariableType::JS_ANY(), function, IntPtr(JSFunctionBase::METHOD_OFFSET)); 2994 varConstpool = GetConstpoolFromMethod(method); 2995 varProfileTypeInfo = GetProfileTypeInfoFromFunction(function); 2996 varHotnessCounter = GetHotnessCounterFromMethod(method); 2997 GateRef jumpSize = GetCallSizeFromFrame(*prevState); 2998 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndDispatch), 2999 { glue, currentSp, *varPc, *varConstpool, *varProfileTypeInfo, 3000 *varAcc, *varHotnessCounter, jumpSize }); 3001 Return(); 3002 } 3003} 3004 3005DECLARE_ASM_HANDLER(HandleDeprecatedSuspendgeneratorPrefV8V8) 3006{ 3007 auto env = GetEnvironment(); 3008 DEFVARIABLE(varPc, VariableType::NATIVE_POINTER(), pc); 3009 DEFVARIABLE(varSp, VariableType::NATIVE_POINTER(), sp); 3010 DEFVARIABLE(prevState, VariableType::NATIVE_POINTER(), sp); 3011 DEFVARIABLE(varConstpool, VariableType::JS_POINTER(), constpool); 3012 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_POINTER(), profileTypeInfo); 3013 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3014 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); 3015 3016 Label isBaselineBuiltinFrame(env); 3017 Label notBaselineBuiltinFrame(env); 3018 Label pcEqualNullptr(env); 3019 Label pcNotEqualNullptr(env); 3020 Label pcEqualBaseline(env); 3021 Label pcNotEqualBaseline(env); 3022 Label updateHotness(env); 3023 Label isStable(env); 3024 Label tryContinue(env); 3025 Label dispatch(env); 3026 Label slowPath(env); 3027 3028 GateRef genObj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 3029 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); 3030 GateRef frame = GetFrame(*varSp); 3031 GateRef res = CallRuntime(glue, RTSTUB_ID(SuspendGenerator), { genObj, value }); 3032 Label isException(env); 3033 Label notException(env); 3034 BRANCH(TaggedIsException(res), &isException, ¬Exception); 3035 Bind(&isException); 3036 { 3037 DispatchLast(glue, *varSp, *varPc, *varConstpool, *varProfileTypeInfo, *varAcc, *varHotnessCounter); 3038 } 3039 Bind(¬Exception); 3040 varAcc = res; 3041 BRANCH(TaggedIsUndefined(*varProfileTypeInfo), &updateHotness, &isStable); 3042 Bind(&isStable); 3043 { 3044 BRANCH(ProfilerStubBuilder(env).IsProfileTypeInfoDumped(*varProfileTypeInfo, callback), &tryContinue, 3045 &updateHotness); 3046 } 3047 Bind(&updateHotness); 3048 { 3049 GateRef function = GetFunctionFromFrame(frame); 3050 GateRef method = Load(VariableType::JS_ANY(), function, 3051 IntPtr(JSFunctionBase::METHOD_OFFSET)); 3052 GateRef fistPC = Load(VariableType::NATIVE_POINTER(), method, 3053 IntPtr(Method::NATIVE_POINTER_OR_BYTECODE_ARRAY_OFFSET)); 3054 GateRef offset = Int32Not(TruncPtrToInt32(PtrSub(*varPc, fistPC))); 3055 UPDATE_HOTNESS(*varSp, callback); 3056 SetHotnessCounter(glue, method, *varHotnessCounter); 3057 Jump(&tryContinue); 3058 } 3059 3060 Bind(&tryContinue); 3061#if ECMASCRIPT_ENABLE_FUNCTION_CALL_TIMER 3062 GateRef curFunc = GetFunctionFromFrame(frame); 3063 CallNGCRuntime(glue, RTSTUB_ID(EndCallTimer), { glue, curFunc }); 3064#endif 3065 GateRef currentSp = *varSp; 3066 varSp = Load(VariableType::NATIVE_POINTER(), frame, 3067 IntPtr(AsmInterpretedFrame::GetBaseOffset(env->IsArch32Bit()))); 3068 3069 GateRef typePos = PtrSub(*varSp, IntPtr(JSTaggedValue::TaggedTypeSize())); 3070 GateRef maybeFrameType = Load(VariableType::INT64(), typePos); 3071 BRANCH(Int64Equal(maybeFrameType, Int64(static_cast<int64_t>(FrameType::BASELINE_BUILTIN_FRAME))), 3072 &isBaselineBuiltinFrame, ¬BaselineBuiltinFrame); 3073 Bind(&isBaselineBuiltinFrame); 3074 { 3075 varSp = Load(VariableType::NATIVE_POINTER(), *varSp); 3076 Jump(¬BaselineBuiltinFrame); 3077 } 3078 Bind(¬BaselineBuiltinFrame); 3079 prevState = GetFrame(*varSp); 3080 varPc = GetPcFromFrame(*prevState); 3081 BRANCH(IntPtrEqual(*varPc, IntPtr(0)), &pcEqualNullptr, &pcNotEqualNullptr); 3082 Bind(&pcEqualNullptr); 3083 { 3084 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndReturn), { *varAcc, *varSp, currentSp }); 3085 Return(); 3086 } 3087 Bind(&pcNotEqualNullptr); 3088 BRANCH(IntPtrEqual(*varPc, IntPtr(BASELINEJIT_PC_FLAG)), &pcEqualBaseline, &pcNotEqualBaseline); 3089 Bind(&pcEqualBaseline); 3090 { 3091 GateRef jumpSize = GetCallSizeFromFrame(*prevState); 3092 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndReturnBaseline), { *varAcc, *varSp, currentSp, jumpSize }); 3093 Return(); 3094 } 3095 Bind(&pcNotEqualBaseline); 3096 { 3097 GateRef function = GetFunctionFromFrame(*prevState); 3098 GateRef method = Load(VariableType::JS_ANY(), function, IntPtr(JSFunctionBase::METHOD_OFFSET)); 3099 varConstpool = GetConstpoolFromMethod(method); 3100 varProfileTypeInfo = GetProfileTypeInfoFromFunction(function); 3101 varHotnessCounter = GetHotnessCounterFromMethod(method); 3102 GateRef jumpSize = GetCallSizeFromFrame(*prevState); 3103 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndDispatch), 3104 { glue, currentSp, *varPc, *varConstpool, *varProfileTypeInfo, 3105 *varAcc, *varHotnessCounter, jumpSize }); 3106 Return(); 3107 } 3108} 3109 3110DECLARE_ASM_HANDLER(HandleTryldglobalbynameImm8Id16) 3111{ 3112 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3113 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); 3114 AccessObjectStubBuilder builder(this); 3115 StringIdInfo info(constpool, pc, StringIdInfo::Offset::BYTE_1, StringIdInfo::Length::BITS_16); 3116 GateRef result = builder.TryLoadGlobalByName(glue, 0, info, profileTypeInfo, slotId, callback); 3117 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(TRYLDGLOBALBYNAME_IMM8_ID16)); 3118} 3119 3120DECLARE_ASM_HANDLER(HandleTryldglobalbynameImm16Id16) 3121{ 3122 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3123 3124 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc)); 3125 AccessObjectStubBuilder builder(this); 3126 StringIdInfo info(constpool, pc, StringIdInfo::Offset::BYTE_2, StringIdInfo::Length::BITS_16); 3127 GateRef result = builder.TryLoadGlobalByName(glue, 0, info, profileTypeInfo, slotId, callback); 3128 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(TRYLDGLOBALBYNAME_IMM16_ID16)); 3129} 3130 3131DECLARE_ASM_HANDLER(HandleTrystglobalbynameImm8Id16) 3132{ 3133 GateRef slotId = ZExtInt16ToInt32(ReadInst8_0(pc)); 3134 AccessObjectStubBuilder builder(this); 3135 StringIdInfo info(constpool, pc, StringIdInfo::Offset::BYTE_1, StringIdInfo::Length::BITS_16); 3136 GateRef result = builder.TryStoreGlobalByName(glue, 0, info, acc, profileTypeInfo, slotId, callback); 3137 CHECK_EXCEPTION(result, INT_PTR(TRYSTGLOBALBYNAME_IMM8_ID16)); 3138} 3139 3140DECLARE_ASM_HANDLER(HandleTrystglobalbynameImm16Id16) 3141{ 3142 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc)); 3143 AccessObjectStubBuilder builder(this); 3144 StringIdInfo info(constpool, pc, StringIdInfo::Offset::BYTE_2, StringIdInfo::Length::BITS_16); 3145 GateRef result = builder.TryStoreGlobalByName(glue, 0, info, acc, profileTypeInfo, slotId, callback); 3146 CHECK_EXCEPTION(result, INT_PTR(TRYSTGLOBALBYNAME_IMM16_ID16)); 3147} 3148 3149DECLARE_ASM_HANDLER(HandleLdglobalvarImm16Id16) 3150{ 3151 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3152 3153 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc)); 3154 AccessObjectStubBuilder builder(this); 3155 StringIdInfo info(constpool, pc, StringIdInfo::Offset::BYTE_2, StringIdInfo::Length::BITS_16); 3156 GateRef result = builder.LoadGlobalVar(glue, 0, info, profileTypeInfo, slotId, callback); 3157 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDGLOBALVAR_IMM16_ID16)); 3158} 3159 3160DECLARE_ASM_HANDLER(HandleStglobalvarImm16Id16) 3161{ 3162 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc)); 3163 AccessObjectStubBuilder builder(this); 3164 StringIdInfo info(constpool, pc, StringIdInfo::Offset::BYTE_2, StringIdInfo::Length::BITS_16); 3165 GateRef result = builder.StoreGlobalVar(glue, 0, info, acc, profileTypeInfo, slotId); 3166 CHECK_EXCEPTION(result, INT_PTR(STGLOBALVAR_IMM16_ID16)); 3167} 3168 3169DECLARE_ASM_HANDLER(HandleCreateregexpwithliteralImm8Id16Imm8) 3170{ 3171 GateRef stringId = ReadInst16_1(pc); 3172 GateRef pattern = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId)); 3173 GateRef flags = ReadInst8_3(pc); 3174 GateRef res = CallRuntime(glue, RTSTUB_ID(CreateRegExpWithLiteral), 3175 { pattern, Int8ToTaggedInt(flags) }); 3176 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CREATEREGEXPWITHLITERAL_IMM8_ID16_IMM8)); 3177} 3178 3179DECLARE_ASM_HANDLER(HandleCreateregexpwithliteralImm16Id16Imm8) 3180{ 3181 GateRef stringId = ReadInst16_2(pc); 3182 GateRef pattern = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId)); 3183 GateRef flags = ReadInst8_4(pc); 3184 GateRef res = CallRuntime(glue, RTSTUB_ID(CreateRegExpWithLiteral), 3185 { pattern, Int8ToTaggedInt(flags) }); 3186 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CREATEREGEXPWITHLITERAL_IMM16_ID16_IMM8)); 3187} 3188 3189DECLARE_ASM_HANDLER(HandleIstrue) 3190{ 3191 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3192 varAcc = FastToBoolean(*varAcc, true); 3193 DISPATCH_WITH_ACC(ISTRUE); 3194} 3195 3196DECLARE_ASM_HANDLER(HandleCallRuntimeIstruePrefImm8) 3197{ 3198 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3199 varAcc = FastToBooleanWithProfile(*varAcc, callback, true); 3200 DISPATCH_WITH_ACC(CALLRUNTIME_ISTRUE_PREF_IMM8); 3201} 3202 3203DECLARE_ASM_HANDLER(HandleIsfalse) 3204{ 3205 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3206 varAcc = FastToBoolean(*varAcc, false); 3207 DISPATCH_WITH_ACC(ISFALSE); 3208} 3209 3210DECLARE_ASM_HANDLER(HandleCallRuntimeIsfalsePrefImm8) 3211{ 3212 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3213 varAcc = FastToBooleanWithProfile(*varAcc, callback, false); 3214 DISPATCH_WITH_ACC(CALLRUNTIME_ISFALSE_PREF_IMM8); 3215} 3216 3217DECLARE_ASM_HANDLER(HandleTonumberImm8) 3218{ 3219 auto env = GetEnvironment(); 3220 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3221 GateRef value = *varAcc; 3222 Label valueIsNumber(env); 3223 Label valueNotNumber(env); 3224 BRANCH(TaggedIsNumber(value), &valueIsNumber, &valueNotNumber); 3225 Bind(&valueIsNumber); 3226 { 3227 varAcc = value; 3228 DISPATCH_WITH_ACC(TONUMBER_IMM8); 3229 } 3230 Bind(&valueNotNumber); 3231 { 3232 GateRef res = CallRuntime(glue, RTSTUB_ID(ToNumber), { value }); 3233 CHECK_EXCEPTION_WITH_VARACC(res, INT_PTR(TONUMBER_IMM8)); 3234 } 3235} 3236 3237DECLARE_ASM_HANDLER(HandleDeprecatedTonumberPrefV8) 3238{ 3239 auto env = GetEnvironment(); 3240 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3241 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 3242 Label valueIsNumber(env); 3243 Label valueNotNumber(env); 3244 BRANCH(TaggedIsNumber(value), &valueIsNumber, &valueNotNumber); 3245 Bind(&valueIsNumber); 3246 { 3247 varAcc = value; 3248 DISPATCH_WITH_ACC(DEPRECATED_TONUMBER_PREF_V8); 3249 } 3250 Bind(&valueNotNumber); 3251 { 3252 GateRef res = CallRuntime(glue, RTSTUB_ID(ToNumber), { value }); 3253 CHECK_EXCEPTION_WITH_VARACC(res, INT_PTR(DEPRECATED_TONUMBER_PREF_V8)); 3254 } 3255} 3256 3257DECLARE_ASM_HANDLER(HandleAdd2Imm8V8) 3258{ 3259 GateRef v0 = ReadInst8_1(pc); 3260 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(v0)); 3261 OperationsStubBuilder builder(this); 3262 GateRef result = builder.Add(glue, left, acc, callback); 3263 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(ADD2_IMM8_V8)); 3264} 3265 3266DECLARE_ASM_HANDLER(HandleSub2Imm8V8) 3267{ 3268 GateRef v0 = ReadInst8_1(pc); 3269 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(v0)); 3270 OperationsStubBuilder builder(this); 3271 GateRef result = builder.Sub(glue, left, acc, callback); 3272 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(SUB2_IMM8_V8)); 3273} 3274 3275DECLARE_ASM_HANDLER(HandleLdbigintId16) 3276{ 3277 GateRef stringId = ReadInst16_0(pc); 3278 GateRef numberBigInt = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId)); 3279 GateRef res = CallRuntime(glue, RTSTUB_ID(LdBigInt), { numberBigInt }); 3280 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(LDBIGINT_ID16)); 3281} 3282 3283DECLARE_ASM_HANDLER(HandleTonumericImm8) 3284{ 3285 auto env = GetEnvironment(); 3286 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3287 GateRef value = *varAcc; 3288 Label valueIsNumeric(env); 3289 Label valueNotNumeric(env); 3290 BRANCH(TaggedIsNumeric(value), &valueIsNumeric, &valueNotNumeric); 3291 Bind(&valueIsNumeric); 3292 { 3293 if (!callback.IsEmpty()) { 3294 Label valueIsNumber(env); 3295 Label profilerEnd(env); 3296 BRANCH(TaggedIsNumber(value), &valueIsNumber, &profilerEnd); 3297 Bind(&valueIsNumber); 3298 { 3299 Label valueIsInt(env); 3300 Label valueIsDouble(env); 3301 BRANCH(TaggedIsInt(value), &valueIsInt, &valueIsDouble); 3302 Bind(&valueIsInt); 3303 { 3304 callback.ProfileOpType(TaggedInt(PGOSampleType::IntType())); 3305 Jump(&profilerEnd); 3306 } 3307 Bind(&valueIsDouble); 3308 { 3309 callback.ProfileOpType(TaggedInt(PGOSampleType::DoubleType())); 3310 Jump(&profilerEnd); 3311 } 3312 } 3313 Bind(&profilerEnd); 3314 } 3315 varAcc = value; 3316 DISPATCH_WITH_ACC(TONUMERIC_IMM8); 3317 } 3318 Bind(&valueNotNumeric); 3319 { 3320 GateRef res = CallRuntime(glue, RTSTUB_ID(ToNumeric), { value }); 3321 CHECK_EXCEPTION_WITH_VARACC(res, INT_PTR(TONUMERIC_IMM8)); 3322 } 3323} 3324 3325DECLARE_ASM_HANDLER(HandleDeprecatedTonumericPrefV8) 3326{ 3327 auto env = GetEnvironment(); 3328 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3329 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 3330 Label valueIsNumeric(env); 3331 Label valueNotNumeric(env); 3332 BRANCH(TaggedIsNumeric(value), &valueIsNumeric, &valueNotNumeric); 3333 Bind(&valueIsNumeric); 3334 { 3335 varAcc = value; 3336 DISPATCH_WITH_ACC(DEPRECATED_TONUMERIC_PREF_V8); 3337 } 3338 Bind(&valueNotNumeric); 3339 { 3340 GateRef res = CallRuntime(glue, RTSTUB_ID(ToNumeric), { value }); 3341 CHECK_EXCEPTION_WITH_VARACC(res, INT_PTR(DEPRECATED_TONUMERIC_PREF_V8)); 3342 } 3343} 3344 3345DECLARE_ASM_HANDLER(HandleDynamicimport) 3346{ 3347 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3348 GateRef specifier = *varAcc; 3349 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 3350 GateRef res = CallRuntime(glue, RTSTUB_ID(DynamicImport), { specifier, currentFunc }); 3351 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(DYNAMICIMPORT)); 3352} 3353 3354DECLARE_ASM_HANDLER(HandleDeprecatedDynamicimportPrefV8) 3355{ 3356 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3357 GateRef specifier = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 3358 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 3359 GateRef res = CallRuntime(glue, RTSTUB_ID(DynamicImport), { specifier, currentFunc }); 3360 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(DEPRECATED_DYNAMICIMPORT_PREF_V8)); 3361} 3362 3363DECLARE_ASM_HANDLER(HandleCreateasyncgeneratorobjV8) 3364{ 3365 auto env = GetEnvironment(); 3366 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3367 3368 GateRef v0 = ReadInst8_0(pc); 3369 GateRef genFunc = GetVregValue(sp, ZExtInt8ToPtr(v0)); 3370 GateRef result = CallRuntime(glue, RTSTUB_ID(CreateAsyncGeneratorObj), { genFunc }); 3371 Label isException(env); 3372 Label notException(env); 3373 BRANCH(TaggedIsException(result), &isException, ¬Exception); 3374 Bind(&isException); 3375 { 3376 DISPATCH_LAST(); 3377 } 3378 Bind(¬Exception); 3379 varAcc = result; 3380 DISPATCH_WITH_ACC(CREATEASYNCGENERATOROBJ_V8); 3381} 3382 3383DECLARE_ASM_HANDLER(HandleAsyncgeneratorresolveV8V8V8) 3384{ 3385 auto env = GetEnvironment(); 3386 METHOD_EXIT(); 3387 DEFVARIABLE(varPc, VariableType::NATIVE_POINTER(), pc); 3388 DEFVARIABLE(varSp, VariableType::NATIVE_POINTER(), sp); 3389 DEFVARIABLE(prevState, VariableType::NATIVE_POINTER(), sp); 3390 DEFVARIABLE(varConstpool, VariableType::JS_POINTER(), constpool); 3391 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_POINTER(), profileTypeInfo); 3392 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); 3393 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3394 3395 Label isBaselineBuiltinFrame(env); 3396 Label notBaselineBuiltinFrame(env); 3397 Label pcEqualNullptr(env); 3398 Label pcNotEqualNullptr(env); 3399 Label pcEqualBaseline(env); 3400 Label pcNotEqualBaseline(env); 3401 Label updateHotness(env); 3402 Label isStable(env); 3403 Label tryContinue(env); 3404 Label dispatch(env); 3405 Label slowPath(env); 3406 3407 GateRef asyncGenerator = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_0(pc))); 3408 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 3409 GateRef flag = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); 3410 GateRef frame = GetFrame(*varSp); 3411 GateRef res = CallRuntime(glue, RTSTUB_ID(AsyncGeneratorResolve), 3412 { asyncGenerator, value, flag }); 3413 Label isException(env); 3414 Label notException(env); 3415 BRANCH(TaggedIsException(res), &isException, ¬Exception); 3416 Bind(&isException); 3417 { 3418 DISPATCH_LAST(); 3419 } 3420 Bind(¬Exception); 3421 varAcc = res; 3422 BRANCH(TaggedIsUndefined(*varProfileTypeInfo), &updateHotness, &isStable); 3423 Bind(&isStable); 3424 { 3425 BRANCH(ProfilerStubBuilder(env).IsProfileTypeInfoDumped(*varProfileTypeInfo, callback), &tryContinue, 3426 &updateHotness); 3427 } 3428 Bind(&updateHotness); 3429 { 3430 GateRef function = GetFunctionFromFrame(frame); 3431 GateRef method = Load(VariableType::JS_ANY(), function, 3432 IntPtr(JSFunctionBase::METHOD_OFFSET)); 3433 GateRef fistPC = Load(VariableType::NATIVE_POINTER(), method, 3434 IntPtr(Method::NATIVE_POINTER_OR_BYTECODE_ARRAY_OFFSET)); 3435 GateRef offset = Int32Not(TruncPtrToInt32(PtrSub(*varPc, fistPC))); 3436 UPDATE_HOTNESS(*varSp, callback); 3437 SetHotnessCounter(glue, method, *varHotnessCounter); 3438 Jump(&tryContinue); 3439 } 3440 3441 Bind(&tryContinue); 3442#if ECMASCRIPT_ENABLE_FUNCTION_CALL_TIMER 3443 GateRef curFunc = GetFunctionFromFrame(frame); 3444 CallNGCRuntime(glue, RTSTUB_ID(EndCallTimer), { glue, curFunc }); 3445#endif 3446 GateRef currentSp = *varSp; 3447 varSp = Load(VariableType::NATIVE_POINTER(), frame, 3448 IntPtr(AsmInterpretedFrame::GetBaseOffset(env->IsArch32Bit()))); 3449 3450 GateRef typePos = PtrSub(*varSp, IntPtr(JSTaggedValue::TaggedTypeSize())); 3451 GateRef maybeFrameType = Load(VariableType::INT64(), typePos); 3452 BRANCH(Int64Equal(maybeFrameType, Int64(static_cast<int64_t>(FrameType::BASELINE_BUILTIN_FRAME))), 3453 &isBaselineBuiltinFrame, ¬BaselineBuiltinFrame); 3454 Bind(&isBaselineBuiltinFrame); 3455 { 3456 varSp = Load(VariableType::NATIVE_POINTER(), *varSp); 3457 Jump(¬BaselineBuiltinFrame); 3458 } 3459 Bind(¬BaselineBuiltinFrame); 3460 prevState = GetFrame(*varSp); 3461 varPc = GetPcFromFrame(*prevState); 3462 BRANCH(IntPtrEqual(*varPc, IntPtr(0)), &pcEqualNullptr, &pcNotEqualNullptr); 3463 Bind(&pcEqualNullptr); 3464 { 3465 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndReturn), { *varAcc, *varSp, currentSp }); 3466 Return(); 3467 } 3468 Bind(&pcNotEqualNullptr); 3469 BRANCH(IntPtrEqual(*varPc, IntPtr(BASELINEJIT_PC_FLAG)), &pcEqualBaseline, &pcNotEqualBaseline); 3470 Bind(&pcEqualBaseline); 3471 { 3472 GateRef jumpSize = GetCallSizeFromFrame(*prevState); 3473 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndReturnBaseline), { *varAcc, *varSp, currentSp, jumpSize }); 3474 Return(); 3475 } 3476 Bind(&pcNotEqualBaseline); 3477 { 3478 GateRef function = GetFunctionFromFrame(*prevState); 3479 GateRef method = Load(VariableType::JS_ANY(), function, IntPtr(JSFunctionBase::METHOD_OFFSET)); 3480 varConstpool = GetConstpoolFromMethod(method); 3481 varProfileTypeInfo = GetProfileTypeInfoFromFunction(function); 3482 varHotnessCounter = GetHotnessCounterFromMethod(method); 3483 GateRef jumpSize = GetCallSizeFromFrame(*prevState); 3484 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndDispatch), 3485 { glue, currentSp, *varPc, *varConstpool, *varProfileTypeInfo, 3486 *varAcc, *varHotnessCounter, jumpSize }); 3487 Return(); 3488 } 3489} 3490 3491DECLARE_ASM_HANDLER(HandleAsyncgeneratorrejectV8) 3492{ 3493 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3494 GateRef asyncGenerator = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_0(pc))); 3495 GateRef res = CallRuntime(glue, RTSTUB_ID(AsyncGeneratorReject), 3496 { asyncGenerator, acc }); 3497 CHECK_EXCEPTION_VARACC(res, INT_PTR(ASYNCGENERATORREJECT_V8)); 3498} 3499 3500DECLARE_ASM_HANDLER(HandleSetgeneratorstateImm8) 3501{ 3502 GateRef index = ReadInst8_0(pc); 3503 GateRef value = acc; 3504 CallRuntime(glue, RTSTUB_ID(SetGeneratorState), { value, IntToTaggedInt(index) }); 3505 DISPATCH(SETGENERATORSTATE_IMM8); 3506} 3507 3508DECLARE_ASM_HANDLER(HandleDeprecatedAsyncgeneratorrejectPrefV8V8) 3509{ 3510 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3511 GateRef asyncGenerator = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 3512 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); 3513 GateRef res = CallRuntime(glue, RTSTUB_ID(AsyncGeneratorReject), 3514 { asyncGenerator, value }); 3515 CHECK_EXCEPTION_VARACC(res, INT_PTR(DEPRECATED_ASYNCGENERATORREJECT_PREF_V8_V8)); 3516} 3517 3518DECLARE_ASM_HANDLER(HandleSupercallthisrangeImm8Imm8V8) 3519{ 3520 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3521 DEFVARIABLE(res, VariableType::JS_ANY(), Undefined()); 3522 DEFVARIABLE(thisObj, VariableType::JS_ANY(), Undefined()); 3523 auto env = GetEnvironment(); 3524 GateRef range = ZExtInt8ToInt16(ReadInst8_1(pc)); 3525 GateRef v0 = ZExtInt8ToInt16(ReadInst8_2(pc)); 3526 GateRef actualNumArgs = ZExtInt16ToInt32(range); 3527 GateRef thisFunc = GetFunctionFromFrame(GetFrame(sp)); 3528 GateRef newTarget = GetNewTarget(sp); 3529 GateRef superCtor = GetPrototype(glue, thisFunc); 3530 3531 Label ctorIsHeapObject(env); 3532 Label ctorIsJSFunction(env); 3533 Label ctorIsConstructor(env); 3534 Label fastPath(env); 3535 Label slowPath(env); 3536 Label checkResult(env); 3537 Label threadCheck(env); 3538 Label dispatch(env); 3539 Label ctorIsBase(env); 3540 Label ctorNotBase(env); 3541 Label isException(env); 3542 3543 BRANCH(TaggedIsHeapObject(superCtor), &ctorIsHeapObject, &slowPath); 3544 Bind(&ctorIsHeapObject); 3545 BRANCH(IsJSFunction(superCtor), &ctorIsJSFunction, &slowPath); 3546 Bind(&ctorIsJSFunction); 3547 BRANCH(IsConstructor(superCtor), &ctorIsConstructor, &slowPath); 3548 Bind(&ctorIsConstructor); 3549 BRANCH(TaggedIsUndefined(newTarget), &slowPath, &fastPath); 3550 Bind(&fastPath); 3551 { 3552 BRANCH(IsBase(superCtor), &ctorIsBase, &ctorNotBase); 3553 Bind(&ctorIsBase); 3554 { 3555 NewObjectStubBuilder newBuilder(this); 3556 thisObj = newBuilder.FastSuperAllocateThis(glue, superCtor, newTarget); 3557 BRANCH(HasPendingException(glue), &isException, &ctorNotBase); 3558 } 3559 Bind(&ctorNotBase); 3560 GateRef argv = PtrAdd(sp, PtrMul(ZExtInt16ToPtr(v0), IntPtr(JSTaggedValue::TaggedTypeSize()))); // skip function 3561 GateRef jumpSize = IntPtr(-BytecodeInstruction::Size(BytecodeInstruction::Format::IMM8_IMM8_V8)); 3562 METHOD_ENTRY_ENV_DEFINED(superCtor); 3563 JSCallArgs callArgs(JSCallMode::SUPER_CALL_WITH_ARGV); 3564 callArgs.superCallArgs = { 3565 thisFunc, Int16ToTaggedInt(v0), ZExtInt32ToPtr(actualNumArgs), argv, *thisObj, newTarget 3566 }; 3567 CallStubBuilder callBuilder(this, glue, superCtor, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, 3568 callback); 3569 res = callBuilder.JSCallDispatch(); 3570 Jump(&threadCheck); 3571 } 3572 Bind(&slowPath); 3573 res = CallRuntime(glue, RTSTUB_ID(SuperCall), 3574 { thisFunc, Int16ToTaggedInt(v0), Int16ToTaggedInt(range) }); 3575 Jump(&checkResult); 3576 Bind(&checkResult); 3577 { 3578 BRANCH(TaggedIsException(*res), &isException, &dispatch); 3579 } 3580 Bind(&threadCheck); 3581 { 3582 BRANCH(HasPendingException(glue), &isException, &dispatch); 3583 } 3584 Bind(&isException); 3585 { 3586 DISPATCH_LAST(); 3587 } 3588 Bind(&dispatch); 3589 varAcc = *res; 3590 DISPATCH_WITH_ACC(SUPERCALLTHISRANGE_IMM8_IMM8_V8); 3591} 3592 3593DECLARE_ASM_HANDLER(HandleSupercallarrowrangeImm8Imm8V8) 3594{ 3595 GateRef range = ReadInst8_1(pc); 3596 GateRef v0 = ZExtInt8ToInt16(ReadInst8_2(pc)); 3597 GateRef res = CallRuntime(glue, RTSTUB_ID(SuperCall), 3598 { acc, Int16ToTaggedInt(v0), Int8ToTaggedInt(range) }); 3599 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(SUPERCALLARROWRANGE_IMM8_IMM8_V8)); 3600} 3601 3602DECLARE_ASM_HANDLER(HandleWideSupercallthisrangePrefImm16V8) 3603{ 3604 GateRef range = ReadInst16_1(pc); 3605 GateRef v0 = ZExtInt8ToInt16(ReadInst8_3(pc)); 3606 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 3607 GateRef res = CallRuntime(glue, RTSTUB_ID(SuperCall), 3608 { currentFunc, Int16ToTaggedInt(v0), Int16ToTaggedInt(range) }); 3609 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(WIDE_SUPERCALLTHISRANGE_PREF_IMM16_V8)); 3610} 3611 3612DECLARE_ASM_HANDLER(HandleWideSupercallarrowrangePrefImm16V8) 3613{ 3614 GateRef range = ReadInst16_1(pc); 3615 GateRef v0 = ZExtInt8ToInt16(ReadInst8_3(pc)); 3616 GateRef res = CallRuntime(glue, RTSTUB_ID(SuperCall), 3617 { acc, Int16ToTaggedInt(v0), Int16ToTaggedInt(range) }); 3618 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(WIDE_SUPERCALLARROWRANGE_PREF_IMM16_V8)); 3619} 3620 3621DECLARE_ASM_HANDLER(HandleLdsuperbyvalueImm8V8) 3622{ 3623 GateRef v0 = ReadInst8_1(pc); 3624 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); 3625 GateRef propKey = acc; 3626 GateRef result = CallRuntime(glue, RTSTUB_ID(LdSuperByValue), { receiver, propKey }); // sp for thisFunc 3627 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(LDSUPERBYVALUE_IMM8_V8)); 3628} 3629DECLARE_ASM_HANDLER(HandleLdsuperbyvalueImm16V8) 3630{ 3631 GateRef v0 = ReadInst8_2(pc); 3632 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); 3633 GateRef propKey = acc; 3634 GateRef result = CallRuntime(glue, RTSTUB_ID(LdSuperByValue), { receiver, propKey }); // sp for thisFunc 3635 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(LDSUPERBYVALUE_IMM16_V8)); 3636} 3637 3638DECLARE_ASM_HANDLER(HandleDeprecatedLdsuperbyvaluePrefV8V8) 3639{ 3640 GateRef v0 = ReadInst8_1(pc); 3641 GateRef v1 = ReadInst8_2(pc); 3642 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); 3643 GateRef propKey = GetVregValue(sp, ZExtInt8ToPtr(v1)); 3644 GateRef result = CallRuntime(glue, RTSTUB_ID(LdSuperByValue), { receiver, propKey }); // sp for thisFunc 3645 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DEPRECATED_LDSUPERBYVALUE_PREF_V8_V8)); 3646} 3647 3648DECLARE_ASM_HANDLER(HandleDeprecatedGetiteratornextPrefV8V8) 3649{ 3650 GateRef v0 = ReadInst8_1(pc); 3651 GateRef v1 = ReadInst8_2(pc); 3652 GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(v0)); 3653 GateRef method = GetVregValue(sp, ZExtInt8ToPtr(v1)); 3654 GateRef result = CallRuntime(glue, RTSTUB_ID(GetIteratorNext), { obj, method }); 3655 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DEPRECATED_GETITERATORNEXT_PREF_V8_V8)); 3656} 3657 3658DECLARE_ASM_HANDLER(HandleLdobjbyvalueImm8V8) 3659{ 3660 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3661 3662 GateRef v0 = ReadInst8_1(pc); 3663 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); 3664 GateRef propKey = acc; 3665 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); 3666 3667 AccessObjectStubBuilder builder(this); 3668 GateRef result = builder.LoadObjByValue(glue, receiver, propKey, profileTypeInfo, slotId, callback); 3669 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDOBJBYVALUE_IMM8_V8)); 3670} 3671 3672DECLARE_ASM_HANDLER(HandleLdobjbyvalueImm16V8) 3673{ 3674 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3675 3676 GateRef v0 = ReadInst8_2(pc); 3677 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); 3678 GateRef propKey = acc; 3679 GateRef slotId = ZExtInt8ToInt32(ReadInst16_0(pc)); 3680 3681 AccessObjectStubBuilder builder(this); 3682 GateRef result = builder.LoadObjByValue(glue, receiver, propKey, profileTypeInfo, slotId, callback); 3683 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDOBJBYVALUE_IMM16_V8)); 3684} 3685 3686DECLARE_ASM_HANDLER(HandleDeprecatedLdobjbyvaluePrefV8V8) 3687{ 3688 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3689 3690 GateRef v0 = ReadInst8_1(pc); 3691 GateRef v1 = ReadInst8_2(pc); 3692 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); 3693 GateRef propKey = GetVregValue(sp, ZExtInt8ToPtr(v1)); 3694 3695 AccessObjectStubBuilder builder(this); 3696 GateRef result = builder.DeprecatedLoadObjByValue(glue, receiver, propKey); 3697 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(DEPRECATED_LDOBJBYVALUE_PREF_V8_V8)); 3698} 3699 3700DECLARE_ASM_HANDLER(HandleLdsuperbynameImm8Id16) 3701{ 3702 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3703 3704 GateRef stringId = ReadInst16_1(pc); 3705 GateRef receiver = acc; 3706 GateRef propKey = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId)); 3707 GateRef result = CallRuntime(glue, RTSTUB_ID(LdSuperByValue), { receiver, propKey }); 3708 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDSUPERBYNAME_IMM8_ID16)); 3709} 3710 3711DECLARE_ASM_HANDLER(HandleLdsuperbynameImm16Id16) 3712{ 3713 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3714 3715 GateRef stringId = ReadInst16_2(pc); 3716 GateRef receiver = acc; 3717 GateRef propKey = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId)); 3718 GateRef result = CallRuntime(glue, RTSTUB_ID(LdSuperByValue), { receiver, propKey }); 3719 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDSUPERBYNAME_IMM16_ID16)); 3720} 3721 3722DECLARE_ASM_HANDLER(HandleDeprecatedLdsuperbynamePrefId32V8) 3723{ 3724 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3725 3726 GateRef stringId = ReadInst32_1(pc); 3727 GateRef v0 = ReadInst8_5(pc); 3728 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); 3729 GateRef propKey = GetStringFromConstPool(glue, constpool, stringId); 3730 GateRef result = CallRuntime(glue, RTSTUB_ID(LdSuperByValue), { receiver, propKey }); 3731 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(DEPRECATED_LDSUPERBYNAME_PREF_ID32_V8)); 3732} 3733 3734DECLARE_ASM_HANDLER(HandleLdobjbyindexImm8Imm16) 3735{ 3736 auto env = GetEnvironment(); 3737 3738 GateRef receiver = acc; 3739 GateRef index = ZExtInt16ToInt32(ReadInst16_1(pc)); 3740 Label fastPath(env); 3741 Label slowPath(env); 3742 BRANCH(TaggedIsHeapObject(receiver), &fastPath, &slowPath); 3743 Bind(&fastPath); 3744 { 3745 GateRef result = GetPropertyByIndex(glue, receiver, index, callback); 3746 Label notHole(env); 3747 BRANCH(TaggedIsHole(result), &slowPath, ¬Hole); 3748 Bind(¬Hole); 3749 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(LDOBJBYINDEX_IMM8_IMM16)); 3750 } 3751 Bind(&slowPath); 3752 { 3753 GateRef result = CallRuntime(glue, RTSTUB_ID(LdObjByIndex), 3754 { receiver, IntToTaggedInt(index), TaggedFalse(), Undefined() }); 3755 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(LDOBJBYINDEX_IMM8_IMM16)); 3756 } 3757} 3758 3759DECLARE_ASM_HANDLER(HandleLdobjbyindexImm16Imm16) 3760{ 3761 auto env = GetEnvironment(); 3762 3763 GateRef receiver = acc; 3764 GateRef index = ZExtInt16ToInt32(ReadInst16_2(pc)); 3765 Label fastPath(env); 3766 Label slowPath(env); 3767 BRANCH(TaggedIsHeapObject(receiver), &fastPath, &slowPath); 3768 Bind(&fastPath); 3769 { 3770 GateRef result = GetPropertyByIndex(glue, receiver, index, callback); 3771 Label notHole(env); 3772 BRANCH(TaggedIsHole(result), &slowPath, ¬Hole); 3773 Bind(¬Hole); 3774 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(LDOBJBYINDEX_IMM16_IMM16)); 3775 } 3776 Bind(&slowPath); 3777 { 3778 GateRef result = CallRuntime(glue, RTSTUB_ID(LdObjByIndex), 3779 { receiver, IntToTaggedInt(index), TaggedFalse(), Undefined() }); 3780 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(LDOBJBYINDEX_IMM16_IMM16)); 3781 } 3782} 3783 3784DECLARE_ASM_HANDLER(HandleWideLdobjbyindexPrefImm32) 3785{ 3786 auto env = GetEnvironment(); 3787 3788 GateRef receiver = acc; 3789 GateRef index = ReadInst32_1(pc); 3790 Label fastPath(env); 3791 Label slowPath(env); 3792 BRANCH(TaggedIsHeapObject(receiver), &fastPath, &slowPath); 3793 Bind(&fastPath); 3794 { 3795 GateRef result = GetPropertyByIndex(glue, receiver, index, callback); 3796 Label notHole(env); 3797 BRANCH(TaggedIsHole(result), &slowPath, ¬Hole); 3798 Bind(¬Hole); 3799 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(WIDE_LDOBJBYINDEX_PREF_IMM32)); 3800 } 3801 Bind(&slowPath); 3802 { 3803 GateRef result = CallRuntime(glue, RTSTUB_ID(LdObjByIndex), 3804 { receiver, IntToTaggedInt(index), TaggedFalse(), Undefined() }); 3805 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(WIDE_LDOBJBYINDEX_PREF_IMM32)); 3806 } 3807} 3808 3809DECLARE_ASM_HANDLER(HandleDeprecatedLdobjbyindexPrefV8Imm32) 3810{ 3811 auto env = GetEnvironment(); 3812 3813 GateRef v0 = ReadInst8_1(pc); 3814 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0)); 3815 GateRef index = ReadInst32_2(pc); 3816 Label fastPath(env); 3817 Label slowPath(env); 3818 BRANCH(TaggedIsHeapObject(receiver), &fastPath, &slowPath); 3819 Bind(&fastPath); 3820 { 3821 GateRef result = GetPropertyByIndex(glue, receiver, index, callback); 3822 Label notHole(env); 3823 BRANCH(TaggedIsHole(result), &slowPath, ¬Hole); 3824 Bind(¬Hole); 3825 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DEPRECATED_LDOBJBYINDEX_PREF_V8_IMM32)); 3826 } 3827 Bind(&slowPath); 3828 { 3829 GateRef result = CallRuntime(glue, RTSTUB_ID(LdObjByIndex), 3830 { receiver, IntToTaggedInt(index), TaggedFalse(), Undefined() }); 3831 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DEPRECATED_LDOBJBYINDEX_PREF_V8_IMM32)); 3832 } 3833} 3834 3835DECLARE_ASM_HANDLER(HandleStconsttoglobalrecordImm16Id16) 3836{ 3837 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3838 3839 GateRef stringId = ReadInst16_2(pc); 3840 GateRef propKey = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId)); 3841 GateRef result = CallRuntime(glue, RTSTUB_ID(StGlobalRecord), 3842 { propKey, *varAcc, TaggedTrue() }); 3843 CHECK_EXCEPTION_VARACC(result, INT_PTR(STCONSTTOGLOBALRECORD_IMM16_ID16)); 3844} 3845 3846DECLARE_ASM_HANDLER(HandleSttoglobalrecordImm16Id16) 3847{ 3848 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3849 3850 GateRef stringId = ReadInst16_2(pc); 3851 GateRef propKey = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId)); 3852 GateRef result = CallRuntime(glue, RTSTUB_ID(StGlobalRecord), 3853 { propKey, *varAcc, TaggedFalse() }); 3854 CHECK_EXCEPTION_VARACC(result, INT_PTR(STTOGLOBALRECORD_IMM16_ID16)); 3855} 3856 3857DECLARE_ASM_HANDLER(HandleDeprecatedStconsttoglobalrecordPrefId32) 3858{ 3859 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3860 3861 GateRef stringId = ReadInst32_1(pc); 3862 GateRef propKey = GetStringFromConstPool(glue, constpool, stringId); 3863 GateRef result = CallRuntime(glue, RTSTUB_ID(StGlobalRecord), 3864 { propKey, *varAcc, TaggedTrue() }); 3865 CHECK_EXCEPTION_VARACC(result, INT_PTR(DEPRECATED_STCONSTTOGLOBALRECORD_PREF_ID32)); 3866} 3867 3868DECLARE_ASM_HANDLER(HandleDeprecatedStlettoglobalrecordPrefId32) 3869{ 3870 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3871 3872 GateRef stringId = ReadInst32_1(pc); 3873 GateRef propKey = GetStringFromConstPool(glue, constpool, stringId); 3874 GateRef result = CallRuntime(glue, RTSTUB_ID(StGlobalRecord), 3875 { propKey, *varAcc, TaggedFalse() }); 3876 CHECK_EXCEPTION_VARACC(result, INT_PTR(DEPRECATED_STLETTOGLOBALRECORD_PREF_ID32)); 3877} 3878 3879DECLARE_ASM_HANDLER(HandleDeprecatedStclasstoglobalrecordPrefId32) 3880{ 3881 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3882 3883 GateRef stringId = ReadInst32_1(pc); 3884 GateRef propKey = GetStringFromConstPool(glue, constpool, stringId); 3885 GateRef result = CallRuntime(glue, RTSTUB_ID(StGlobalRecord), 3886 { propKey, *varAcc, TaggedFalse() }); 3887 CHECK_EXCEPTION_VARACC(result, INT_PTR(DEPRECATED_STCLASSTOGLOBALRECORD_PREF_ID32)); 3888} 3889 3890DECLARE_ASM_HANDLER(HandleGetmodulenamespaceImm8) 3891{ 3892 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3893 3894 GateRef index = ReadInst8_0(pc); 3895 GateRef moduleRef = CallRuntime(glue, RTSTUB_ID(GetModuleNamespaceByIndex), { IntToTaggedInt(index) }); 3896 varAcc = moduleRef; 3897 DISPATCH_WITH_ACC(GETMODULENAMESPACE_IMM8); 3898} 3899 3900DECLARE_ASM_HANDLER(HandleWideGetmodulenamespacePrefImm16) 3901{ 3902 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3903 3904 GateRef index = ReadInst16_1(pc); 3905 GateRef moduleRef = CallRuntime(glue, RTSTUB_ID(GetModuleNamespaceByIndex), { Int16ToTaggedInt(index) }); 3906 varAcc = moduleRef; 3907 DISPATCH_WITH_ACC(WIDE_GETMODULENAMESPACE_PREF_IMM16); 3908} 3909 3910DECLARE_ASM_HANDLER(HandleDeprecatedGetmodulenamespacePrefId32) 3911{ 3912 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3913 3914 GateRef stringId = ReadInst32_1(pc); 3915 GateRef prop = GetStringFromConstPool(glue, constpool, stringId); 3916 GateRef moduleRef = CallRuntime(glue, RTSTUB_ID(GetModuleNamespace), { prop }); 3917 varAcc = moduleRef; 3918 DISPATCH_WITH_ACC(DEPRECATED_GETMODULENAMESPACE_PREF_ID32); 3919} 3920 3921DECLARE_ASM_HANDLER(HandleLdlocalmodulevarImm8) 3922{ 3923 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3924 3925 GateRef index = ReadInst8_0(pc); 3926 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 3927 GateRef module = GetModuleFromFunction(currentFunc); 3928 varAcc = Loadlocalmodulevar(glue, index, module); 3929 DISPATCH_WITH_ACC(LDLOCALMODULEVAR_IMM8); 3930} 3931 3932DECLARE_ASM_HANDLER(HandleWideLdlocalmodulevarPrefImm16) 3933{ 3934 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3935 3936 GateRef index = ReadInst16_1(pc); 3937 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 3938 GateRef module = GetModuleFromFunction(currentFunc); 3939 varAcc = Loadlocalmodulevar(glue, index, module); 3940 DISPATCH_WITH_ACC(WIDE_LDLOCALMODULEVAR_PREF_IMM16); 3941} 3942 3943DECLARE_ASM_HANDLER(HandleLdexternalmodulevarImm8) 3944{ 3945 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3946 3947 GateRef index = ReadInst8_0(pc); 3948 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 3949 GateRef module = GetModuleFromFunction(currentFunc); 3950 GateRef moduleRef = CallRuntime(glue, RTSTUB_ID(LdExternalModuleVarByIndexWithModule), 3951 {Int8ToTaggedInt(index), module}); 3952 varAcc = moduleRef; 3953 DISPATCH_WITH_ACC(LDEXTERNALMODULEVAR_IMM8); 3954} 3955 3956DECLARE_ASM_HANDLER(HandleWideLdexternalmodulevarPrefImm16) 3957{ 3958 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3959 3960 GateRef index = ReadInst16_1(pc); 3961 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 3962 GateRef module = GetModuleFromFunction(currentFunc); 3963 GateRef moduleRef = CallRuntime(glue, RTSTUB_ID(LdExternalModuleVarByIndexWithModule), 3964 {Int16ToTaggedInt(index), module}); 3965 varAcc = moduleRef; 3966 DISPATCH_WITH_ACC(WIDE_LDEXTERNALMODULEVAR_PREF_IMM16); 3967} 3968 3969DECLARE_ASM_HANDLER(HandleDeprecatedLdmodulevarPrefId32Imm8) 3970{ 3971 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 3972 3973 GateRef stringId = ReadInst32_1(pc); 3974 GateRef flag = ZExtInt8ToInt32(ReadInst8_5(pc)); 3975 GateRef key = GetStringFromConstPool(glue, constpool, stringId); 3976 GateRef moduleRef = CallRuntime(glue, RTSTUB_ID(LdModuleVar), { key, IntToTaggedInt(flag) }); 3977 varAcc = moduleRef; 3978 DISPATCH_WITH_ACC(DEPRECATED_LDMODULEVAR_PREF_ID32_IMM8); 3979} 3980 3981DECLARE_ASM_HANDLER(HandleStmodulevarImm8) 3982{ 3983 GateRef index = ReadInst8_0(pc); 3984 GateRef value = acc; 3985 3986 CallRuntime(glue, RTSTUB_ID(StModuleVarByIndex), { IntToTaggedInt(index), value }); 3987 DISPATCH(STMODULEVAR_IMM8); 3988} 3989 3990DECLARE_ASM_HANDLER(HandleWideStmodulevarPrefImm16) 3991{ 3992 GateRef index = ReadInst16_1(pc); 3993 GateRef value = acc; 3994 3995 CallRuntime(glue, RTSTUB_ID(StModuleVarByIndex), { Int16ToTaggedInt(index), value }); 3996 DISPATCH(WIDE_STMODULEVAR_PREF_IMM16); 3997} 3998 3999DECLARE_ASM_HANDLER(HandleDeprecatedStmodulevarPrefId32) 4000{ 4001 GateRef stringId = ReadInst32_1(pc); 4002 GateRef prop = GetStringFromConstPool(glue, constpool, stringId); 4003 GateRef value = acc; 4004 4005 CallRuntime(glue, RTSTUB_ID(StModuleVar), { prop, value }); 4006 DISPATCH(DEPRECATED_STMODULEVAR_PREF_ID32); 4007} 4008 4009DECLARE_ASM_HANDLER(HandleNewlexenvImm8) 4010{ 4011 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 4012 DEFVARIABLE(result, VariableType::JS_ANY(), Hole()); 4013 auto env = GetEnvironment(); 4014 GateRef numVars = ReadInst8_0(pc); 4015 GateRef state = GetFrame(sp); 4016 auto parent = GetEnvFromFrame(state); 4017 NewObjectStubBuilder newBuilder(this); 4018 newBuilder.SetParameters(glue, 0); 4019 Label afterNew(env); 4020 newBuilder.NewLexicalEnv(&result, &afterNew, ZExtInt16ToInt32(numVars), parent); 4021 Bind(&afterNew); 4022 Label notException(env); 4023 CHECK_EXCEPTION_WITH_JUMP(*result, ¬Exception); 4024 Bind(¬Exception); 4025 varAcc = *result; 4026 SetEnvToFrame(glue, GetFrame(sp), *result); 4027 DISPATCH_WITH_ACC(NEWLEXENV_IMM8); 4028} 4029 4030DECLARE_ASM_HANDLER(HandleWideNewlexenvPrefImm16) 4031{ 4032 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 4033 DEFVARIABLE(result, VariableType::JS_ANY(), Hole()); 4034 auto env = GetEnvironment(); 4035 GateRef numVars = ReadInst16_1(pc); 4036 GateRef state = GetFrame(sp); 4037 auto parent = GetEnvFromFrame(state); 4038 NewObjectStubBuilder newBuilder(this); 4039 newBuilder.SetParameters(glue, 0); 4040 Label afterNew(env); 4041 newBuilder.NewLexicalEnv(&result, &afterNew, ZExtInt16ToInt32(numVars), parent); 4042 Bind(&afterNew); 4043 Label notException(env); 4044 CHECK_EXCEPTION_WITH_JUMP(*result, ¬Exception); 4045 Bind(¬Exception); 4046 varAcc = *result; 4047 SetEnvToFrame(glue, GetFrame(sp), *result); 4048 DISPATCH_WITH_ACC(WIDE_NEWLEXENV_PREF_IMM16); 4049} 4050 4051DECLARE_ASM_HANDLER(HandleNewlexenvwithnameImm8Id16) 4052{ 4053 auto env = GetEnvironment(); 4054 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 4055 GateRef numVars = ZExtInt8ToInt16(ReadInst8_0(pc)); 4056 GateRef scopeId = ReadInst16_1(pc); 4057 GateRef res = CallRuntime(glue, RTSTUB_ID(NewLexicalEnvWithName), 4058 { Int16ToTaggedInt(numVars), Int16ToTaggedInt(scopeId) }); 4059 Label notException(env); 4060 CHECK_EXCEPTION_WITH_JUMP(res, ¬Exception); 4061 Bind(¬Exception); 4062 varAcc = res; 4063 GateRef state = GetFrame(sp); 4064 SetEnvToFrame(glue, state, res); 4065 DISPATCH_WITH_ACC(NEWLEXENVWITHNAME_IMM8_ID16); 4066} 4067 4068DECLARE_ASM_HANDLER(HandleWideNewlexenvwithnamePrefImm16Id16) 4069{ 4070 auto env = GetEnvironment(); 4071 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 4072 GateRef numVars = ReadInst16_1(pc); 4073 GateRef scopeId = ReadInst16_3(pc); 4074 GateRef res = CallRuntime(glue, RTSTUB_ID(NewLexicalEnvWithName), 4075 { Int16ToTaggedInt(numVars), Int16ToTaggedInt(scopeId) }); 4076 Label notException(env); 4077 CHECK_EXCEPTION_WITH_JUMP(res, ¬Exception); 4078 Bind(¬Exception); 4079 varAcc = res; 4080 GateRef state = GetFrame(sp); 4081 SetEnvToFrame(glue, state, res); 4082 DISPATCH_WITH_ACC(WIDE_NEWLEXENVWITHNAME_PREF_IMM16_ID16); 4083} 4084 4085DECLARE_ASM_HANDLER(HandleDefineclasswithbufferImm8Id16Id16Imm16V8) 4086{ 4087 auto env = GetEnvironment(); 4088 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 4089 4090 GateRef methodId = ReadInst16_1(pc); 4091 GateRef literalId = ReadInst16_3(pc); 4092 GateRef length = ReadInst16_5(pc); 4093 GateRef v0 = ReadInst8_7(pc); 4094 4095 GateRef proto = GetVregValue(sp, ZExtInt8ToPtr(v0)); 4096 GateRef lexicalEnv = GetEnvFromFrame(GetFrame(sp)); 4097 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 4098 GateRef module = GetModuleFromFunction(currentFunc); 4099 GateRef res = CallRuntime(glue, RTSTUB_ID(CreateClassWithBuffer), 4100 { proto, lexicalEnv, constpool, 4101 Int16ToTaggedInt(methodId), 4102 Int16ToTaggedInt(literalId), module, 4103 Int16ToTaggedInt(length)}); 4104 4105 Label isException(env); 4106 Label isNotException(env); 4107 BRANCH(TaggedIsException(res), &isException, &isNotException); 4108 Bind(&isException); 4109 { 4110 DISPATCH_LAST_WITH_ACC(); 4111 } 4112 Bind(&isNotException); 4113#if ECMASCRIPT_ENABLE_IC 4114 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); 4115 UpdateProfileTypeInfoCellToFunction(glue, res, profileTypeInfo, slotId); 4116 callback.ProfileDefineClass(res); 4117#endif 4118 varAcc = res; 4119 DISPATCH_WITH_ACC(DEFINECLASSWITHBUFFER_IMM8_ID16_ID16_IMM16_V8); 4120} 4121 4122DECLARE_ASM_HANDLER(HandleDefineclasswithbufferImm16Id16Id16Imm16V8) 4123{ 4124 auto env = GetEnvironment(); 4125 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 4126 4127 GateRef methodId = ReadInst16_2(pc); 4128 GateRef literalId = ReadInst16_4(pc); 4129 GateRef length = ReadInst16_6(pc); 4130 GateRef v0 = ReadInst8_8(pc); 4131 4132 GateRef proto = GetVregValue(sp, ZExtInt8ToPtr(v0)); 4133 GateRef lexicalEnv = GetEnvFromFrame(GetFrame(sp)); 4134 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 4135 GateRef module = GetModuleFromFunction(currentFunc); 4136 GateRef res = CallRuntime(glue, RTSTUB_ID(CreateClassWithBuffer), 4137 { proto, lexicalEnv, constpool, 4138 Int16ToTaggedInt(methodId), 4139 Int16ToTaggedInt(literalId), module, 4140 Int16ToTaggedInt(length)}); 4141 4142 Label isException(env); 4143 Label isNotException(env); 4144 BRANCH(TaggedIsException(res), &isException, &isNotException); 4145 Bind(&isException); 4146 { 4147 DISPATCH_LAST_WITH_ACC(); 4148 } 4149 Bind(&isNotException); 4150#if ECMASCRIPT_ENABLE_IC 4151 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc)); 4152 UpdateProfileTypeInfoCellToFunction(glue, res, profileTypeInfo, slotId); 4153 callback.ProfileDefineClass(res); 4154#endif 4155 varAcc = res; 4156 DISPATCH_WITH_ACC(DEFINECLASSWITHBUFFER_IMM16_ID16_ID16_IMM16_V8); 4157} 4158 4159DECLARE_ASM_HANDLER(HandleDeprecatedDefineclasswithbufferPrefId16Imm16Imm16V8V8) 4160{ 4161 auto env = GetEnvironment(); 4162 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 4163 4164 GateRef methodId = ReadInst16_1(pc); 4165 GateRef literalId = ReadInst16_3(pc); 4166 GateRef length = ReadInst16_5(pc); 4167 GateRef v0 = ReadInst8_7(pc); 4168 GateRef v1 = ReadInst8_8(pc); 4169 4170 GateRef lexicalEnv = GetVregValue(sp, ZExtInt8ToPtr(v0)); 4171 GateRef proto = GetVregValue(sp, ZExtInt8ToPtr(v1)); 4172 4173 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 4174 GateRef module = GetModuleFromFunction(currentFunc); 4175 GateRef res = CallRuntime(glue, RTSTUB_ID(CreateClassWithBuffer), 4176 { proto, lexicalEnv, constpool, 4177 Int16ToTaggedInt(methodId), 4178 Int16ToTaggedInt(literalId), module, 4179 Int16ToTaggedInt(length)}); 4180 4181 Label isException(env); 4182 Label isNotException(env); 4183 BRANCH(TaggedIsException(res), &isException, &isNotException); 4184 Bind(&isException); 4185 { 4186 DISPATCH_LAST_WITH_ACC(); 4187 } 4188 Bind(&isNotException); 4189 varAcc = res; 4190 DISPATCH_WITH_ACC(DEPRECATED_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8); 4191} 4192 4193DECLARE_ASM_HANDLER(HandleLdobjbynameImm8Id16) 4194{ 4195 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 4196 4197 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); 4198 GateRef receiver = acc; 4199 AccessObjectStubBuilder builder(this); 4200 StringIdInfo info(constpool, pc, StringIdInfo::Offset::BYTE_1, StringIdInfo::Length::BITS_16); 4201 GateRef result = builder.LoadObjByName(glue, receiver, 0, info, profileTypeInfo, slotId, callback); 4202 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDOBJBYNAME_IMM8_ID16)); 4203} 4204 4205DECLARE_ASM_HANDLER(HandleLdobjbynameImm16Id16) 4206{ 4207 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 4208 4209 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc)); 4210 GateRef receiver = acc; 4211 AccessObjectStubBuilder builder(this); 4212 StringIdInfo info(constpool, pc, StringIdInfo::Offset::BYTE_2, StringIdInfo::Length::BITS_16); 4213 GateRef result = builder.LoadObjByName(glue, receiver, 0, info, profileTypeInfo, slotId, callback); 4214 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDOBJBYNAME_IMM16_ID16)); 4215} 4216 4217DECLARE_ASM_HANDLER(HandleDeprecatedLdobjbynamePrefId32V8) 4218{ 4219 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 4220 4221 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_5(pc))); 4222 GateRef stringId = ReadInst32_1(pc); 4223 GateRef propKey = GetStringFromConstPool(glue, constpool, stringId); 4224 AccessObjectStubBuilder builder(this); 4225 GateRef result = builder.DeprecatedLoadObjByName(glue, receiver, propKey); 4226 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(DEPRECATED_LDOBJBYNAME_PREF_ID32_V8)); 4227} 4228 4229DECLARE_ASM_HANDLER(HandleCallarg0Imm8) 4230{ 4231 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARG0); 4232 GateRef func = acc; 4233 METHOD_ENTRY(func); 4234 GateRef jumpSize = INT_PTR(CALLARG0_IMM8); 4235 JSCallArgs callArgs(JSCallMode::CALL_ARG0); 4236 callArgs.callArgs = { 0, 0, 0 }; 4237 CallStubBuilder callBuilder(this, glue, func, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, callback); 4238 GateRef res = callBuilder.JSCallDispatch(); 4239 CHECK_PENDING_EXCEPTION(res, jumpSize); 4240} 4241 4242DECLARE_ASM_HANDLER(HandleDeprecatedCallarg0PrefV8) 4243{ 4244 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARG0); 4245 GateRef funcReg = ReadInst8_1(pc); 4246 GateRef func = GetVregValue(sp, ZExtInt8ToPtr(funcReg)); 4247 GateRef jumpSize = INT_PTR(DEPRECATED_CALLARG0_PREF_V8); 4248 JSCallArgs callArgs(JSCallMode::DEPRECATED_CALL_ARG0); 4249 callArgs.callArgs = { 0, 0, 0 }; 4250 CallStubBuilder callBuilder(this, glue, func, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, callback); 4251 GateRef res = callBuilder.JSCallDispatch(); 4252 CHECK_PENDING_EXCEPTION(res, jumpSize); 4253} 4254 4255DECLARE_ASM_HANDLER(HandleCallarg1Imm8V8) 4256{ 4257 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARG1); 4258 GateRef a0 = ReadInst8_1(pc); 4259 GateRef func = acc; 4260 METHOD_ENTRY(func); 4261 GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0)); 4262 GateRef jumpSize = INT_PTR(CALLARG1_IMM8_V8); 4263 JSCallArgs callArgs(JSCallMode::CALL_ARG1); 4264 callArgs.callArgs = { a0Value, 0, 0 }; 4265 CallStubBuilder callBuilder(this, glue, func, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, callback); 4266 GateRef res = callBuilder.JSCallDispatch(); 4267 CHECK_PENDING_EXCEPTION(res, jumpSize); 4268} 4269 4270DECLARE_ASM_HANDLER(HandleDeprecatedCallarg1PrefV8V8) 4271{ 4272 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARG1); 4273 GateRef funcReg = ReadInst8_1(pc); 4274 GateRef a0 = ReadInst8_2(pc); 4275 GateRef func = GetVregValue(sp, ZExtInt8ToPtr(funcReg)); 4276 GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0)); 4277 GateRef jumpSize = INT_PTR(DEPRECATED_CALLARG1_PREF_V8_V8); 4278 JSCallArgs callArgs(JSCallMode::DEPRECATED_CALL_ARG1); 4279 callArgs.callArgs = { a0Value, 0, 0 }; 4280 CallStubBuilder callBuilder(this, glue, func, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, callback); 4281 GateRef res = callBuilder.JSCallDispatch(); 4282 CHECK_PENDING_EXCEPTION(res, jumpSize); 4283} 4284 4285DECLARE_ASM_HANDLER(HandleCallargs2Imm8V8V8) 4286{ 4287 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARGS2); 4288 GateRef a0 = ReadInst8_1(pc); 4289 GateRef a1 = ReadInst8_2(pc); 4290 GateRef func = acc; 4291 METHOD_ENTRY(func); 4292 GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0)); 4293 GateRef a1Value = GetVregValue(sp, ZExtInt8ToPtr(a1)); 4294 GateRef jumpSize = INT_PTR(CALLARGS2_IMM8_V8_V8); 4295 JSCallArgs callArgs(JSCallMode::CALL_ARG2); 4296 callArgs.callArgs = { a0Value, a1Value, 0 }; 4297 CallStubBuilder callBuilder(this, glue, func, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, callback); 4298 GateRef res = callBuilder.JSCallDispatch(); 4299 CHECK_PENDING_EXCEPTION(res, jumpSize); 4300} 4301 4302DECLARE_ASM_HANDLER(HandleDeprecatedCallargs2PrefV8V8V8) 4303{ 4304 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARGS2); 4305 GateRef funcReg = ReadInst8_1(pc); 4306 GateRef a0 = ReadInst8_2(pc); 4307 GateRef a1 = ReadInst8_3(pc); 4308 GateRef func = GetVregValue(sp, ZExtInt8ToPtr(funcReg)); 4309 GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0)); 4310 GateRef a1Value = GetVregValue(sp, ZExtInt8ToPtr(a1)); 4311 GateRef jumpSize = INT_PTR(DEPRECATED_CALLARGS2_PREF_V8_V8_V8); 4312 JSCallArgs callArgs(JSCallMode::DEPRECATED_CALL_ARG2); 4313 callArgs.callArgs = { a0Value, a1Value, 0 }; 4314 CallStubBuilder callBuilder(this, glue, func, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, callback); 4315 GateRef res = callBuilder.JSCallDispatch(); 4316 CHECK_PENDING_EXCEPTION(res, jumpSize); 4317} 4318 4319DECLARE_ASM_HANDLER(HandleCallargs3Imm8V8V8V8) 4320{ 4321 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARGS3); 4322 GateRef a0 = ReadInst8_1(pc); 4323 GateRef a1 = ReadInst8_2(pc); 4324 GateRef a2 = ReadInst8_3(pc); 4325 GateRef func = acc; 4326 METHOD_ENTRY(func); 4327 GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0)); 4328 GateRef a1Value = GetVregValue(sp, ZExtInt8ToPtr(a1)); 4329 GateRef a2Value = GetVregValue(sp, ZExtInt8ToPtr(a2)); 4330 GateRef jumpSize = INT_PTR(CALLARGS3_IMM8_V8_V8_V8); 4331 JSCallArgs callArgs(JSCallMode::CALL_ARG3); 4332 callArgs.callArgs = { a0Value, a1Value, a2Value }; 4333 CallStubBuilder callBuilder(this, glue, func, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, callback); 4334 GateRef res = callBuilder.JSCallDispatch(); 4335 CHECK_PENDING_EXCEPTION(res, jumpSize); 4336} 4337 4338DECLARE_ASM_HANDLER(HandleDeprecatedCallargs3PrefV8V8V8V8) 4339{ 4340 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARGS3); 4341 GateRef funcReg = ReadInst8_1(pc); 4342 GateRef a0 = ReadInst8_2(pc); 4343 GateRef a1 = ReadInst8_3(pc); 4344 GateRef a2 = ReadInst8_4(pc); 4345 GateRef func = GetVregValue(sp, ZExtInt8ToPtr(funcReg)); 4346 GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0)); 4347 GateRef a1Value = GetVregValue(sp, ZExtInt8ToPtr(a1)); 4348 GateRef a2Value = GetVregValue(sp, ZExtInt8ToPtr(a2)); 4349 GateRef jumpSize = INT_PTR(DEPRECATED_CALLARGS3_PREF_V8_V8_V8_V8); 4350 JSCallArgs callArgs(JSCallMode::DEPRECATED_CALL_ARG3); 4351 callArgs.callArgs = { a0Value, a1Value, a2Value }; 4352 CallStubBuilder callBuilder(this, glue, func, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, callback); 4353 GateRef res = callBuilder.JSCallDispatch(); 4354 CHECK_PENDING_EXCEPTION(res, jumpSize); 4355} 4356 4357DECLARE_ASM_HANDLER(HandleCallrangeImm8Imm8V8) 4358{ 4359 GateRef actualNumArgs = ZExtInt8ToInt32(ReadInst8_1(pc)); 4360 GateRef func = acc; 4361 METHOD_ENTRY(func); 4362 GateRef argv = PtrAdd(sp, PtrMul(ZExtInt8ToPtr(ReadInst8_2(pc)), IntPtr(8))); // 8: byteSize 4363 GateRef jumpSize = INT_PTR(CALLRANGE_IMM8_IMM8_V8); 4364 GateRef numArgs = ZExtInt32ToPtr(actualNumArgs); 4365 JSCallArgs callArgs(JSCallMode::CALL_WITH_ARGV); 4366 callArgs.callArgv = { numArgs, argv }; 4367 CallStubBuilder callBuilder(this, glue, func, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, callback); 4368 GateRef res = callBuilder.JSCallDispatch(); 4369 CHECK_PENDING_EXCEPTION(res, jumpSize); 4370} 4371 4372DECLARE_ASM_HANDLER(HandleWideCallrangePrefImm16V8) 4373{ 4374 GateRef actualNumArgs = ZExtInt16ToInt32(ReadInst16_1(pc)); 4375 GateRef func = acc; 4376 METHOD_ENTRY(func); 4377 GateRef argv = PtrAdd(sp, PtrMul(ZExtInt8ToPtr(ReadInst8_2(pc)), IntPtr(8))); // 8: byteSize 4378 GateRef jumpSize = INT_PTR(WIDE_CALLRANGE_PREF_IMM16_V8); 4379 GateRef numArgs = ZExtInt32ToPtr(actualNumArgs); 4380 JSCallArgs callArgs(JSCallMode::CALL_WITH_ARGV); 4381 callArgs.callArgv = { numArgs, argv }; 4382 CallStubBuilder callBuilder(this, glue, func, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, callback); 4383 GateRef res = callBuilder.JSCallDispatch(); 4384 CHECK_PENDING_EXCEPTION(res, jumpSize); 4385} 4386 4387DECLARE_ASM_HANDLER(HandleDeprecatedCallrangePrefImm16V8) 4388{ 4389 GateRef actualNumArgs = ZExtInt16ToInt32(ReadInst16_1(pc)); 4390 GateRef funcReg = ReadInst8_3(pc); 4391 GateRef func = GetVregValue(sp, ZExtInt8ToPtr(funcReg)); 4392 GateRef argv = PtrAdd(sp, PtrMul( 4393 PtrAdd(ZExtInt8ToPtr(funcReg), IntPtr(1)), IntPtr(8))); // 1: skip function 4394 GateRef jumpSize = INT_PTR(DEPRECATED_CALLRANGE_PREF_IMM16_V8); 4395 GateRef numArgs = ZExtInt32ToPtr(actualNumArgs); 4396 JSCallArgs callArgs(JSCallMode::DEPRECATED_CALL_WITH_ARGV); 4397 callArgs.callArgv = { numArgs, argv }; 4398 CallStubBuilder callBuilder(this, glue, func, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, callback); 4399 GateRef res = callBuilder.JSCallDispatch(); 4400 CHECK_PENDING_EXCEPTION(res, jumpSize); 4401} 4402 4403DECLARE_ASM_HANDLER(HandleCallthisrangeImm8Imm8V8) 4404{ 4405 GateRef actualNumArgs = ZExtInt8ToInt32(ReadInst8_1(pc)); 4406 GateRef thisReg = ZExtInt8ToPtr(ReadInst8_2(pc)); 4407 GateRef func = acc; 4408 METHOD_ENTRY(func); 4409 GateRef thisValue = GetVregValue(sp, thisReg); 4410 GateRef argv = PtrAdd(sp, PtrMul( 4411 PtrAdd(thisReg, IntPtr(1)), IntPtr(8))); // 1: skip this 4412 GateRef jumpSize = INT_PTR(CALLTHISRANGE_IMM8_IMM8_V8); 4413 GateRef numArgs = ZExtInt32ToPtr(actualNumArgs); 4414 JSCallArgs callArgs(JSCallMode::CALL_THIS_WITH_ARGV); 4415 callArgs.callArgvWithThis = { numArgs, argv, thisValue }; 4416 CallStubBuilder callBuilder(this, glue, func, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, callback); 4417 GateRef res = callBuilder.JSCallDispatch(); 4418 CHECK_PENDING_EXCEPTION(res, jumpSize); 4419} 4420 4421DECLARE_ASM_HANDLER(HandleWideCallthisrangePrefImm16V8) 4422{ 4423 GateRef actualNumArgs = ZExtInt16ToInt32(ReadInst16_1(pc)); 4424 GateRef thisReg = ZExtInt8ToPtr(ReadInst8_3(pc)); 4425 GateRef func = acc; 4426 METHOD_ENTRY(func); 4427 GateRef thisValue = GetVregValue(sp, thisReg); 4428 GateRef argv = PtrAdd(sp, PtrMul( 4429 PtrAdd(thisReg, IntPtr(1)), IntPtr(8))); // 1: skip this 4430 GateRef jumpSize = INT_PTR(WIDE_CALLTHISRANGE_PREF_IMM16_V8); 4431 GateRef numArgs = ZExtInt32ToPtr(actualNumArgs); 4432 JSCallArgs callArgs(JSCallMode::CALL_THIS_WITH_ARGV); 4433 callArgs.callArgvWithThis = { numArgs, argv, thisValue }; 4434 CallStubBuilder callBuilder(this, glue, func, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, callback); 4435 GateRef res = callBuilder.JSCallDispatch(); 4436 CHECK_PENDING_EXCEPTION(res, jumpSize); 4437} 4438 4439DECLARE_ASM_HANDLER(HandleDeprecatedCallthisrangePrefImm16V8) 4440{ 4441 GateRef actualNumArgs = Int32Sub(ZExtInt16ToInt32(ReadInst16_1(pc)), Int32(1)); // 1: exclude this 4442 GateRef funcReg = ReadInst8_3(pc); 4443 funcReg = ZExtInt8ToPtr(funcReg); 4444 GateRef func = GetVregValue(sp, funcReg); 4445 GateRef thisValue = GetVregValue(sp, PtrAdd(funcReg, IntPtr(1))); 4446 GateRef argv = PtrAdd(sp, PtrMul( 4447 PtrAdd(funcReg, IntPtr(2)), IntPtr(8))); // 2: skip function&this 4448 GateRef jumpSize = INT_PTR(DEPRECATED_CALLTHISRANGE_PREF_IMM16_V8); 4449 GateRef numArgs = ZExtInt32ToPtr(actualNumArgs); 4450 JSCallArgs callArgs(JSCallMode::DEPRECATED_CALL_THIS_WITH_ARGV); 4451 callArgs.callArgvWithThis = { numArgs, argv, thisValue }; 4452 CallStubBuilder callBuilder(this, glue, func, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, callback); 4453 GateRef res = callBuilder.JSCallDispatch(); 4454 CHECK_PENDING_EXCEPTION(res, jumpSize); 4455} 4456 4457DECLARE_ASM_HANDLER(HandleCallthis0Imm8V8) 4458{ 4459 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARG0); 4460 GateRef thisValue = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 4461 GateRef func = acc; 4462 METHOD_ENTRY(func); 4463 GateRef jumpSize = INT_PTR(CALLTHIS0_IMM8_V8); 4464 JSCallArgs callArgs(JSCallMode::CALL_THIS_ARG0); 4465 callArgs.callArgsWithThis = { 0, 0, 0, thisValue }; 4466 CallStubBuilder callBuilder(this, glue, func, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, callback); 4467 GateRef res = callBuilder.JSCallDispatch(); 4468 CHECK_PENDING_EXCEPTION(res, jumpSize); 4469} 4470 4471DECLARE_ASM_HANDLER(HandleCallthis1Imm8V8V8) 4472{ 4473 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARG1); 4474 GateRef thisValue = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 4475 GateRef a0 = ReadInst8_2(pc); 4476 GateRef func = acc; 4477 METHOD_ENTRY(func); 4478 GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0)); 4479 GateRef jumpSize = INT_PTR(CALLTHIS1_IMM8_V8_V8); 4480 JSCallArgs callArgs(JSCallMode::CALL_THIS_ARG1); 4481 callArgs.callArgsWithThis = { a0Value, 0, 0, thisValue }; 4482 CallStubBuilder callBuilder(this, glue, func, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, callback); 4483 GateRef res = callBuilder.JSCallDispatch(); 4484 CHECK_PENDING_EXCEPTION(res, jumpSize); 4485} 4486 4487DECLARE_ASM_HANDLER(HandleCallthis2Imm8V8V8V8) 4488{ 4489 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARGS2); 4490 GateRef thisValue = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 4491 GateRef a0 = ReadInst8_2(pc); 4492 GateRef a1 = ReadInst8_3(pc); 4493 GateRef func = acc; 4494 METHOD_ENTRY(func); 4495 GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0)); 4496 GateRef a1Value = GetVregValue(sp, ZExtInt8ToPtr(a1)); 4497 GateRef jumpSize = INT_PTR(CALLTHIS2_IMM8_V8_V8_V8); 4498 JSCallArgs callArgs(JSCallMode::CALL_THIS_ARG2); 4499 callArgs.callArgsWithThis = { a0Value, a1Value, 0, thisValue }; 4500 CallStubBuilder callBuilder(this, glue, func, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, callback); 4501 GateRef res = callBuilder.JSCallDispatch(); 4502 CHECK_PENDING_EXCEPTION(res, jumpSize); 4503} 4504 4505DECLARE_ASM_HANDLER(HandleCallthis3Imm8V8V8V8V8) 4506{ 4507 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARGS3); 4508 GateRef thisValue = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 4509 GateRef a0 = ReadInst8_2(pc); 4510 GateRef a1 = ReadInst8_3(pc); 4511 GateRef a2 = ReadInst8_4(pc); 4512 GateRef func = acc; 4513 METHOD_ENTRY(func); 4514 GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0)); 4515 GateRef a1Value = GetVregValue(sp, ZExtInt8ToPtr(a1)); 4516 GateRef a2Value = GetVregValue(sp, ZExtInt8ToPtr(a2)); 4517 GateRef jumpSize = INT_PTR(CALLTHIS3_IMM8_V8_V8_V8_V8); 4518 JSCallArgs callArgs(JSCallMode::CALL_THIS_ARG3); 4519 callArgs.callArgsWithThis = { a0Value, a1Value, a2Value, thisValue }; 4520 CallStubBuilder callBuilder(this, glue, func, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, callback); 4521 GateRef res = callBuilder.JSCallDispatch(); 4522 CHECK_PENDING_EXCEPTION(res, jumpSize); 4523} 4524 4525DECLARE_ASM_HANDLER(HandleCreatearraywithbufferImm8Id16) 4526{ 4527 GateRef imm = ZExtInt16ToInt32(ReadInst16_1(pc)); 4528 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 4529 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); 4530 4531 NewObjectStubBuilder newBuilder(this); 4532 GateRef res = newBuilder.CreateArrayWithBuffer( 4533 glue, imm, currentFunc, { pc, 0, true }, profileTypeInfo, slotId, callback); 4534 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CREATEARRAYWITHBUFFER_IMM8_ID16)); 4535} 4536 4537DECLARE_ASM_HANDLER(HandleCreatearraywithbufferImm16Id16) 4538{ 4539 GateRef imm = ZExtInt16ToInt32(ReadInst16_2(pc)); 4540 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 4541 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc)); 4542 4543 NewObjectStubBuilder newBuilder(this); 4544 GateRef res = newBuilder.CreateArrayWithBuffer( 4545 glue, imm, currentFunc, { pc, 0, true }, profileTypeInfo, slotId, callback); 4546 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CREATEARRAYWITHBUFFER_IMM16_ID16)); 4547} 4548 4549DECLARE_ASM_HANDLER(HandleDeprecatedCreatearraywithbufferPrefImm16) 4550{ 4551 GateRef imm = ZExtInt16ToInt32(ReadInst16_1(pc)); 4552 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 4553 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); 4554 4555 NewObjectStubBuilder newBuilder(this); 4556 GateRef res = newBuilder.CreateArrayWithBuffer( 4557 glue, imm, currentFunc, { pc, 0, true }, profileTypeInfo, slotId, callback); 4558 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(DEPRECATED_CREATEARRAYWITHBUFFER_PREF_IMM16)); 4559} 4560 4561DECLARE_ASM_HANDLER(HandleCreateobjectwithbufferImm8Id16) 4562{ 4563 GateRef imm = ZExtInt16ToInt32(ReadInst16_1(pc)); 4564 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 4565 GateRef module = GetModuleFromFunction(currentFunc); 4566 GateRef result = GetObjectLiteralFromConstPool(glue, constpool, imm, module); 4567 GateRef currentEnv = GetEnvFromFrame(GetFrame(sp)); 4568 NewObjectStubBuilder newBuilder(this); 4569 GateRef res = newBuilder.CreateObjectHavingMethod(glue, result, currentEnv); 4570 callback.ProfileCreateObject(res); 4571 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CREATEOBJECTWITHBUFFER_IMM8_ID16)); 4572} 4573 4574DECLARE_ASM_HANDLER(HandleCreateobjectwithbufferImm16Id16) 4575{ 4576 GateRef imm = ZExtInt16ToInt32(ReadInst16_2(pc)); 4577 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 4578 GateRef module = GetModuleFromFunction(currentFunc); 4579 GateRef result = GetObjectLiteralFromConstPool(glue, constpool, imm, module); 4580 GateRef currentEnv = GetEnvFromFrame(GetFrame(sp)); 4581 NewObjectStubBuilder newBuilder(this); 4582 GateRef res = newBuilder.CreateObjectHavingMethod(glue, result, currentEnv); 4583 callback.ProfileCreateObject(res); 4584 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CREATEOBJECTWITHBUFFER_IMM16_ID16)); 4585} 4586 4587DECLARE_ASM_HANDLER(HandleDeprecatedCreateobjectwithbufferPrefImm16) 4588{ 4589 GateRef imm = ZExtInt16ToInt32(ReadInst16_1(pc)); 4590 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 4591 GateRef module = GetModuleFromFunction(currentFunc); 4592 GateRef result = GetObjectLiteralFromConstPool(glue, constpool, imm, module); 4593 GateRef res = CallRuntime(glue, RTSTUB_ID(CreateObjectWithBuffer), { result }); 4594 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(DEPRECATED_CREATEOBJECTWITHBUFFER_PREF_IMM16)); 4595} 4596 4597DECLARE_ASM_HANDLER(HandleNewobjrangeImm8Imm8V8) 4598{ 4599 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 4600 DEFVARIABLE(res, VariableType::JS_ANY(), Undefined()); 4601 DEFVARIABLE(thisObj, VariableType::JS_ANY(), Undefined()); 4602 auto env = GetEnvironment(); 4603 GateRef numArgs = ZExtInt8ToInt16(ReadInst8_1(pc)); 4604 GateRef firstArgRegIdx = ZExtInt8ToInt16(ReadInst8_2(pc)); 4605 GateRef firstArgOffset = Int16(1); 4606 GateRef ctor = GetVregValue(sp, ZExtInt16ToPtr(firstArgRegIdx)); 4607 GateRef actualNumArgs = ZExtInt16ToInt32(Int16Sub(numArgs, firstArgOffset)); 4608 4609 Label ctorIsHeapObject(env); 4610 Label ctorIsJSFunction(env); 4611 Label fastPath(env); 4612 Label slowPath(env); 4613 Label checkResult(env); 4614 Label threadCheck(env); 4615 Label dispatch(env); 4616 Label ctorIsBase(env); 4617 Label ctorNotBase(env); 4618 Label isException(env); 4619 4620 BRANCH(TaggedIsHeapObject(ctor), &ctorIsHeapObject, &slowPath); 4621 Bind(&ctorIsHeapObject); 4622 BRANCH(IsJSFunction(ctor), &ctorIsJSFunction, &slowPath); 4623 Bind(&ctorIsJSFunction); 4624 BRANCH(IsConstructor(ctor), &fastPath, &slowPath); 4625 Bind(&fastPath); 4626 { 4627 BRANCH(IsBase(ctor), &ctorIsBase, &ctorNotBase); 4628 Bind(&ctorIsBase); 4629 { 4630 NewObjectStubBuilder newBuilder(this); 4631 thisObj = newBuilder.FastNewThisObject(glue, ctor); 4632 BRANCH(HasPendingException(glue), &isException, &ctorNotBase); 4633 } 4634 Bind(&ctorNotBase); 4635 GateRef argv = PtrAdd(sp, PtrMul( 4636 PtrAdd(firstArgRegIdx, firstArgOffset), IntPtr(8))); // 8: skip function 4637 GateRef jumpSize = IntPtr(-BytecodeInstruction::Size(BytecodeInstruction::Format::IMM8_IMM8_V8)); 4638 METHOD_ENTRY_ENV_DEFINED(ctor); 4639 JSCallArgs callArgs(JSCallMode::CALL_CONSTRUCTOR_WITH_ARGV); 4640 callArgs.callConstructorArgs = { ZExtInt32ToPtr(actualNumArgs), argv, *thisObj }; 4641 CallStubBuilder callBuilder(this, glue, ctor, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, 4642 callback); 4643 res = callBuilder.JSCallDispatch(); 4644 Jump(&threadCheck); 4645 } 4646 Bind(&slowPath); 4647 GateRef firstArgIdx = Int16Add(firstArgRegIdx, firstArgOffset); 4648 GateRef length = Int16Sub(numArgs, firstArgOffset); 4649 res = CallRuntime(glue, RTSTUB_ID(NewObjRange), 4650 { ctor, ctor, Int16ToTaggedInt(firstArgIdx), Int16ToTaggedInt(length) }); 4651 Jump(&checkResult); 4652 Bind(&checkResult); 4653 { 4654 BRANCH(TaggedIsException(*res), &isException, &dispatch); 4655 } 4656 Bind(&threadCheck); 4657 { 4658 BRANCH(HasPendingException(glue), &isException, &dispatch); 4659 } 4660 Bind(&isException); 4661 { 4662 DISPATCH_LAST(); 4663 } 4664 Bind(&dispatch); 4665 varAcc = *res; 4666 DISPATCH_WITH_ACC(NEWOBJRANGE_IMM8_IMM8_V8); 4667} 4668 4669DECLARE_ASM_HANDLER(HandleNewobjrangeImm16Imm8V8) 4670{ 4671 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 4672 DEFVARIABLE(res, VariableType::JS_ANY(), Undefined()); 4673 DEFVARIABLE(thisObj, VariableType::JS_ANY(), Undefined()); 4674 auto env = GetEnvironment(); 4675 GateRef numArgs = ZExtInt8ToInt16(ReadInst8_2(pc)); 4676 GateRef firstArgRegIdx = ZExtInt8ToInt16(ReadInst8_3(pc)); 4677 GateRef firstArgOffset = Int16(1); 4678 GateRef ctor = GetVregValue(sp, ZExtInt16ToPtr(firstArgRegIdx)); 4679 GateRef actualNumArgs = ZExtInt16ToInt32(Int16Sub(numArgs, firstArgOffset)); 4680 4681 Label ctorIsHeapObject(env); 4682 Label ctorIsJSFunction(env); 4683 Label fastPath(env); 4684 Label slowPath(env); 4685 Label checkResult(env); 4686 Label threadCheck(env); 4687 Label dispatch(env); 4688 Label ctorIsBase(env); 4689 Label ctorNotBase(env); 4690 Label isException(env); 4691 4692 BRANCH(TaggedIsHeapObject(ctor), &ctorIsHeapObject, &slowPath); 4693 Bind(&ctorIsHeapObject); 4694 BRANCH(IsJSFunction(ctor), &ctorIsJSFunction, &slowPath); 4695 Bind(&ctorIsJSFunction); 4696 BRANCH(IsConstructor(ctor), &fastPath, &slowPath); 4697 Bind(&fastPath); 4698 { 4699 BRANCH(IsBase(ctor), &ctorIsBase, &ctorNotBase); 4700 Bind(&ctorIsBase); 4701 { 4702 NewObjectStubBuilder newBuilder(this); 4703 thisObj = newBuilder.FastNewThisObject(glue, ctor); 4704 BRANCH(HasPendingException(glue), &isException, &ctorNotBase); 4705 } 4706 Bind(&ctorNotBase); 4707 GateRef argv = PtrAdd(sp, PtrMul( 4708 PtrAdd(firstArgRegIdx, firstArgOffset), IntPtr(8))); // 8: skip function 4709 GateRef jumpSize = 4710 IntPtr(-static_cast<int64_t>(BytecodeInstruction::Size(BytecodeInstruction::Format::IMM16_IMM8_V8))); 4711 METHOD_ENTRY_ENV_DEFINED(ctor); 4712 JSCallArgs callArgs(JSCallMode::CALL_CONSTRUCTOR_WITH_ARGV); 4713 callArgs.callConstructorArgs = { ZExtInt32ToPtr(actualNumArgs), argv, *thisObj }; 4714 CallStubBuilder callBuilder(this, glue, ctor, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, 4715 callback); 4716 res = callBuilder.JSCallDispatch(); 4717 Jump(&threadCheck); 4718 } 4719 Bind(&slowPath); 4720 GateRef firstArgIdx = Int16Add(firstArgRegIdx, firstArgOffset); 4721 GateRef length = Int16Sub(numArgs, firstArgOffset); 4722 res = CallRuntime(glue, RTSTUB_ID(NewObjRange), 4723 { ctor, ctor, Int16ToTaggedInt(firstArgIdx), Int16ToTaggedInt(length) }); 4724 Jump(&checkResult); 4725 Bind(&checkResult); 4726 { 4727 BRANCH(TaggedIsException(*res), &isException, &dispatch); 4728 } 4729 Bind(&threadCheck); 4730 { 4731 BRANCH(HasPendingException(glue), &isException, &dispatch); 4732 } 4733 Bind(&isException); 4734 { 4735 DISPATCH_LAST(); 4736 } 4737 Bind(&dispatch); 4738 varAcc = *res; 4739 DISPATCH_WITH_ACC(NEWOBJRANGE_IMM16_IMM8_V8); 4740} 4741 4742DECLARE_ASM_HANDLER(HandleWideNewobjrangePrefImm16V8) 4743{ 4744 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 4745 DEFVARIABLE(res, VariableType::JS_ANY(), Undefined()); 4746 DEFVARIABLE(thisObj, VariableType::JS_ANY(), Undefined()); 4747 auto env = GetEnvironment(); 4748 GateRef numArgs = ReadInst16_1(pc); 4749 GateRef firstArgRegIdx = ZExtInt8ToInt16(ReadInst8_3(pc)); 4750 GateRef firstArgOffset = Int16(1); 4751 GateRef ctor = GetVregValue(sp, ZExtInt16ToPtr(firstArgRegIdx)); 4752 GateRef actualNumArgs = ZExtInt16ToInt32(Int16Sub(numArgs, firstArgOffset)); 4753 4754 Label ctorIsHeapObject(env); 4755 Label ctorIsJSFunction(env); 4756 Label fastPath(env); 4757 Label slowPath(env); 4758 Label checkResult(env); 4759 Label threadCheck(env); 4760 Label dispatch(env); 4761 Label ctorIsBase(env); 4762 Label ctorNotBase(env); 4763 Label isException(env); 4764 4765 BRANCH(TaggedIsHeapObject(ctor), &ctorIsHeapObject, &slowPath); 4766 Bind(&ctorIsHeapObject); 4767 BRANCH(IsJSFunction(ctor), &ctorIsJSFunction, &slowPath); 4768 Bind(&ctorIsJSFunction); 4769 BRANCH(IsConstructor(ctor), &fastPath, &slowPath); 4770 Bind(&fastPath); 4771 { 4772 BRANCH(IsBase(ctor), &ctorIsBase, &ctorNotBase); 4773 Bind(&ctorIsBase); 4774 { 4775 NewObjectStubBuilder newBuilder(this); 4776 thisObj = newBuilder.FastNewThisObject(glue, ctor); 4777 BRANCH(HasPendingException(glue), &isException, &ctorNotBase); 4778 } 4779 Bind(&ctorNotBase); 4780 GateRef argv = PtrAdd(sp, PtrMul( 4781 PtrAdd(firstArgRegIdx, firstArgOffset), IntPtr(8))); // 8: skip function 4782 GateRef jumpSize = IntPtr(-BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_IMM16_V8)); 4783 JSCallArgs callArgs(JSCallMode::DEPRECATED_CALL_CONSTRUCTOR_WITH_ARGV); 4784 callArgs.callConstructorArgs = { ZExtInt32ToPtr(actualNumArgs), argv, *thisObj }; 4785 CallStubBuilder callBuilder(this, glue, ctor, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, 4786 callback); 4787 res = callBuilder.JSCallDispatch(); 4788 Jump(&threadCheck); 4789 } 4790 Bind(&slowPath); 4791 GateRef firstArgIdx = Int16Add(firstArgRegIdx, firstArgOffset); 4792 GateRef length = Int16Sub(numArgs, firstArgOffset); 4793 res = CallRuntime(glue, RTSTUB_ID(NewObjRange), 4794 { ctor, ctor, Int16ToTaggedInt(firstArgIdx), Int16ToTaggedInt(length) }); 4795 Jump(&checkResult); 4796 Bind(&checkResult); 4797 { 4798 BRANCH(TaggedIsException(*res), &isException, &dispatch); 4799 } 4800 Bind(&threadCheck); 4801 { 4802 BRANCH(HasPendingException(glue), &isException, &dispatch); 4803 } 4804 Bind(&isException); 4805 { 4806 DISPATCH_LAST(); 4807 } 4808 Bind(&dispatch); 4809 varAcc = *res; 4810 DISPATCH_WITH_ACC(WIDE_NEWOBJRANGE_PREF_IMM16_V8); 4811} 4812 4813DECLARE_ASM_HANDLER(HandleDefinefuncImm8Id16Imm8) 4814{ 4815 auto env = GetEnvironment(); 4816 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 4817 GateRef methodId = ReadInst16_1(pc); 4818 GateRef length = ReadInst8_3(pc); 4819 GateRef result = DefineFunc(glue, constpool, ZExtInt16ToInt32(methodId)); 4820 Label notException(env); 4821 CHECK_EXCEPTION_WITH_JUMP(result, ¬Exception); 4822 Bind(¬Exception); 4823 { 4824 SetLengthToFunction(glue, result, ZExtInt8ToInt32(length)); 4825 auto frame = GetFrame(sp); 4826 GateRef currentFunc = GetFunctionFromFrame(frame); 4827 GateRef module = GetModuleFromFunction(currentFunc); 4828 Label isSendableFunc(env); 4829 Label isNotSendableFunc(env); 4830 Label afterSendableFunc(env); 4831 BRANCH(IsSendableFunction(GetMethodFromFunction(result)), &isSendableFunc, &isNotSendableFunc); 4832 Bind(&isSendableFunc); 4833 { 4834 GateRef smodule = CallRuntime(glue, RTSTUB_ID(GetSharedModule), { module }); 4835 Label isSourceTextModule(env); 4836 Label isNotSourceTextModule(env); 4837 BRANCH(IsSourceTextModule(module), &isSourceTextModule, &isNotSourceTextModule); 4838 Bind(&isSourceTextModule); 4839 { 4840 SetSendableEnvToModule(glue, smodule, GetSendableEnvFromModule(module)); 4841 Jump(&isNotSourceTextModule); 4842 } 4843 Bind(&isNotSourceTextModule); 4844 SetModuleToFunction(glue, result, smodule, MemoryAttribute::DefaultWithShareBarrier()); 4845 Jump(&afterSendableFunc); 4846 } 4847 Bind(&isNotSendableFunc); 4848 { 4849 GateRef envHandle = GetEnvFromFrame(frame); 4850 SetLexicalEnvToFunction(glue, result, envHandle); 4851 SetModuleToFunction(glue, result, module); 4852 SetHomeObjectToFunction(glue, result, GetHomeObjectFromFunction(currentFunc)); 4853#if ECMASCRIPT_ENABLE_IC 4854 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); 4855 UpdateProfileTypeInfoCellToFunction(glue, result, profileTypeInfo, slotId); 4856 callback.ProfileDefineClass(result); 4857#endif 4858 Jump(&afterSendableFunc); 4859 } 4860 Bind(&afterSendableFunc); 4861 varAcc = result; 4862 DISPATCH_WITH_ACC(DEFINEFUNC_IMM8_ID16_IMM8); 4863 } 4864} 4865 4866DECLARE_ASM_HANDLER(HandleDefinefuncImm16Id16Imm8) 4867{ 4868 auto env = GetEnvironment(); 4869 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 4870 GateRef methodId = ReadInst16_2(pc); 4871 GateRef length = ReadInst8_4(pc); 4872 GateRef result = DefineFunc(glue, constpool, ZExtInt16ToInt32(methodId)); 4873 Label notException(env); 4874 CHECK_EXCEPTION_WITH_JUMP(result, ¬Exception); 4875 Bind(¬Exception); 4876 { 4877 SetLengthToFunction(glue, result, ZExtInt8ToInt32(length)); 4878 auto frame = GetFrame(sp); 4879 GateRef currentFunc = GetFunctionFromFrame(frame); 4880 GateRef module = GetModuleFromFunction(currentFunc); 4881 Label isSendableFunc(env); 4882 Label isNotSendableFunc(env); 4883 Label afterSendableFunc(env); 4884 BRANCH(IsSendableFunction(GetMethodFromFunction(result)), &isSendableFunc, &isNotSendableFunc); 4885 Bind(&isSendableFunc); 4886 { 4887 GateRef smodule = CallRuntime(glue, RTSTUB_ID(GetSharedModule), { module }); 4888 Label isSourceTextModule(env); 4889 Label isNotSourceTextModule(env); 4890 BRANCH(IsSourceTextModule(module), &isSourceTextModule, &isNotSourceTextModule); 4891 Bind(&isSourceTextModule); 4892 { 4893 SetSendableEnvToModule(glue, smodule, GetSendableEnvFromModule(module)); 4894 Jump(&isNotSourceTextModule); 4895 } 4896 Bind(&isNotSourceTextModule); 4897 SetModuleToFunction(glue, result, smodule, MemoryAttribute::DefaultWithShareBarrier()); 4898 Jump(&afterSendableFunc); 4899 } 4900 Bind(&isNotSendableFunc); 4901 { 4902 GateRef envHandle = GetEnvFromFrame(frame); 4903 SetLexicalEnvToFunction(glue, result, envHandle); 4904 SetModuleToFunction(glue, result, module); 4905 SetHomeObjectToFunction(glue, result, GetHomeObjectFromFunction(currentFunc)); 4906#if ECMASCRIPT_ENABLE_IC 4907 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc)); 4908 UpdateProfileTypeInfoCellToFunction(glue, result, profileTypeInfo, slotId); 4909 callback.ProfileDefineClass(result); 4910#endif 4911 Jump(&afterSendableFunc); 4912 } 4913 Bind(&afterSendableFunc); 4914 varAcc = result; 4915 DISPATCH_WITH_ACC(DEFINEFUNC_IMM16_ID16_IMM8); 4916 } 4917} 4918 4919DECLARE_ASM_HANDLER(HandleDefinemethodImm8Id16Imm8) 4920{ 4921 auto env = GetEnvironment(); 4922 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 4923 GateRef methodId = ReadInst16_1(pc); 4924 GateRef length = ReadInst8_3(pc); 4925 GateRef lexEnv = GetEnvFromFrame(GetFrame(sp)); 4926 DEFVARIABLE(result, VariableType::JS_POINTER(), 4927 GetMethodFromConstPool(glue, constpool, ZExtInt16ToInt32(methodId))); 4928 result = CallRuntime(glue, RTSTUB_ID(DefineMethod), { *result, acc, Int8ToTaggedInt(length), 4929 lexEnv, GetModule(sp) }); 4930 Label notException(env); 4931 CHECK_EXCEPTION_WITH_JUMP(*result, ¬Exception); 4932 Bind(¬Exception); 4933 { 4934 varAcc = *result; 4935 DISPATCH_WITH_ACC(DEFINEMETHOD_IMM8_ID16_IMM8); 4936 } 4937} 4938 4939DECLARE_ASM_HANDLER(HandleDefinemethodImm16Id16Imm8) 4940{ 4941 auto env = GetEnvironment(); 4942 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 4943 GateRef methodId = ReadInst16_2(pc); 4944 GateRef length = ReadInst8_4(pc); 4945 GateRef lexEnv = GetEnvFromFrame(GetFrame(sp)); 4946 DEFVARIABLE(result, VariableType::JS_POINTER(), 4947 GetMethodFromConstPool(glue, constpool, ZExtInt16ToInt32(methodId))); 4948 result = CallRuntime(glue, RTSTUB_ID(DefineMethod), { *result, acc, Int8ToTaggedInt(length), 4949 lexEnv, GetModule(sp) }); 4950 Label notException(env); 4951 CHECK_EXCEPTION_WITH_JUMP(*result, ¬Exception); 4952 Bind(¬Exception); 4953 { 4954 varAcc = *result; 4955 DISPATCH_WITH_ACC(DEFINEMETHOD_IMM16_ID16_IMM8); 4956 } 4957} 4958 4959DECLARE_ASM_HANDLER(HandleApplyImm8V8V8) 4960{ 4961 GateRef func = acc; 4962 GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 4963 GateRef array = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); 4964 GateRef res = CallRuntime(glue, RTSTUB_ID(CallSpread), { func, obj, array }); 4965 CHECK_PENDING_EXCEPTION(res, INT_PTR(APPLY_IMM8_V8_V8)); 4966} 4967 4968DECLARE_ASM_HANDLER(HandleDeprecatedCallspreadPrefV8V8V8) 4969{ 4970 GateRef func = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 4971 GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); 4972 GateRef array = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc))); 4973 GateRef res = CallRuntime(glue, RTSTUB_ID(CallSpread), { func, obj, array }); 4974 CHECK_PENDING_EXCEPTION(res, INT_PTR(DEPRECATED_CALLSPREAD_PREF_V8_V8_V8)); 4975} 4976 4977DECLARE_ASM_HANDLER(HandleThrowNotexistsPrefNone) 4978{ 4979 CallRuntime(glue, RTSTUB_ID(ThrowThrowNotExists), {}); 4980 DISPATCH_LAST(); 4981} 4982DECLARE_ASM_HANDLER(HandleThrowPrefNone) 4983{ 4984 CallRuntime(glue, RTSTUB_ID(Throw), { acc }); 4985 DISPATCH_LAST(); 4986} 4987 4988DECLARE_ASM_HANDLER(HandleJnstricteqV8Imm16) 4989{ 4990 DISPATCH(NOP); 4991} 4992DECLARE_ASM_HANDLER(HandleJnstricteqV8Imm8) 4993{ 4994 DISPATCH(NOP); 4995} 4996DECLARE_ASM_HANDLER(HandleJstricteqV8Imm16) 4997{ 4998 DISPATCH(NOP); 4999} 5000DECLARE_ASM_HANDLER(HandleJstricteqV8Imm8) 5001{ 5002 DISPATCH(NOP); 5003} 5004DECLARE_ASM_HANDLER(HandleJneV8Imm16) 5005{ 5006 DISPATCH(NOP); 5007} 5008DECLARE_ASM_HANDLER(HandleJneV8Imm8) 5009{ 5010 DISPATCH(NOP); 5011} 5012DECLARE_ASM_HANDLER(HandleJeqV8Imm16) 5013{ 5014 DISPATCH(NOP); 5015} 5016DECLARE_ASM_HANDLER(HandleJeqV8Imm8) 5017{ 5018 DISPATCH(NOP); 5019} 5020DECLARE_ASM_HANDLER(HandleJnstrictequndefinedImm16) 5021{ 5022 DISPATCH(NOP); 5023} 5024DECLARE_ASM_HANDLER(HandleJnstrictequndefinedImm8) 5025{ 5026 DISPATCH(NOP); 5027} 5028DECLARE_ASM_HANDLER(HandleJstrictequndefinedImm16) 5029{ 5030 DISPATCH(NOP); 5031} 5032DECLARE_ASM_HANDLER(HandleJstrictequndefinedImm8) 5033{ 5034 DISPATCH(NOP); 5035} 5036DECLARE_ASM_HANDLER(HandleJneundefinedImm16) 5037{ 5038 DISPATCH(NOP); 5039} 5040DECLARE_ASM_HANDLER(HandleJneundefinedImm8) 5041{ 5042 DISPATCH(NOP); 5043} 5044DECLARE_ASM_HANDLER(HandleJnstricteqnullImm16) 5045{ 5046 DISPATCH(NOP); 5047} 5048DECLARE_ASM_HANDLER(HandleJnstricteqnullImm8) 5049{ 5050 DISPATCH(NOP); 5051} 5052DECLARE_ASM_HANDLER(HandleJstricteqnullImm16) 5053{ 5054 DISPATCH(NOP); 5055} 5056DECLARE_ASM_HANDLER(HandleJstricteqnullImm8) 5057{ 5058 DISPATCH(NOP); 5059} 5060DECLARE_ASM_HANDLER(HandleJnenullImm16) 5061{ 5062 DISPATCH(NOP); 5063} 5064DECLARE_ASM_HANDLER(HandleJnenullImm8) 5065{ 5066 DISPATCH(NOP); 5067} 5068DECLARE_ASM_HANDLER(HandleJeqnullImm16) 5069{ 5070 DISPATCH(NOP); 5071} 5072DECLARE_ASM_HANDLER(HandleJeqnullImm8) 5073{ 5074 DISPATCH(NOP); 5075} 5076 5077DECLARE_ASM_HANDLER(HandleJnstricteqzImm16) 5078{ 5079 DISPATCH(NOP); 5080} 5081DECLARE_ASM_HANDLER(HandleJnstricteqzImm8) 5082{ 5083 DISPATCH(NOP); 5084} 5085DECLARE_ASM_HANDLER(HandleJstricteqzImm16) 5086{ 5087 DISPATCH(NOP); 5088} 5089DECLARE_ASM_HANDLER(HandleJstricteqzImm8) 5090{ 5091 DISPATCH(NOP); 5092} 5093DECLARE_ASM_HANDLER(HandleStthisbyvalueImm16V8) 5094{ 5095 GateRef v0 = ReadInst8_2(pc); 5096 GateRef receiver = GetThisFromFrame(GetFrame(sp)); 5097 GateRef propKey = GetVregValue(sp, ZExtInt8ToPtr(v0)); 5098 GateRef value = acc; 5099 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc)); 5100 5101 AccessObjectStubBuilder builder(this); 5102 GateRef result = builder.StoreObjByValue(glue, receiver, propKey, value, profileTypeInfo, slotId, callback); 5103 CHECK_EXCEPTION(result, INT_PTR(STTHISBYVALUE_IMM16_V8)); 5104} 5105DECLARE_ASM_HANDLER(HandleStthisbyvalueImm8V8) 5106{ 5107 GateRef v0 = ReadInst8_1(pc); 5108 GateRef receiver = GetThisFromFrame(GetFrame(sp)); 5109 GateRef propKey = GetVregValue(sp, ZExtInt8ToPtr(v0)); 5110 GateRef value = acc; 5111 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); 5112 5113 AccessObjectStubBuilder builder(this); 5114 GateRef result = builder.StoreObjByValue(glue, receiver, propKey, value, profileTypeInfo, slotId, callback); 5115 CHECK_EXCEPTION(result, INT_PTR(STTHISBYVALUE_IMM8_V8)); 5116} 5117DECLARE_ASM_HANDLER(HandleLdthisbyvalueImm16) 5118{ 5119 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5120 5121 GateRef receiver = GetThisFromFrame(GetFrame(sp)); 5122 GateRef propKey = acc; 5123 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc)); 5124 5125 AccessObjectStubBuilder builder(this); 5126 GateRef result = builder.LoadObjByValue(glue, receiver, propKey, profileTypeInfo, slotId, callback); 5127 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDTHISBYVALUE_IMM16)); 5128} 5129DECLARE_ASM_HANDLER(HandleLdthisbyvalueImm8) 5130{ 5131 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5132 5133 GateRef receiver = GetThisFromFrame(GetFrame(sp)); 5134 GateRef propKey = acc; 5135 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); 5136 5137 AccessObjectStubBuilder builder(this); 5138 GateRef result = builder.LoadObjByValue(glue, receiver, propKey, profileTypeInfo, slotId, callback); 5139 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDTHISBYVALUE_IMM8)); 5140} 5141DECLARE_ASM_HANDLER(HandleStthisbynameImm16Id16) 5142{ 5143 GateRef receiver = GetThisFromFrame(GetFrame(sp)); 5144 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc)); 5145 5146 AccessObjectStubBuilder builder(this); 5147 StringIdInfo info(constpool, pc, StringIdInfo::Offset::BYTE_2, StringIdInfo::Length::BITS_16); 5148 GateRef result = builder.StoreObjByName(glue, receiver, 0, info, acc, profileTypeInfo, slotId, callback); 5149 CHECK_EXCEPTION(result, INT_PTR(STTHISBYNAME_IMM16_ID16)); 5150} 5151DECLARE_ASM_HANDLER(HandleStthisbynameImm8Id16) 5152{ 5153 GateRef receiver = GetThisFromFrame(GetFrame(sp)); 5154 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); 5155 5156 AccessObjectStubBuilder builder(this); 5157 StringIdInfo info(constpool, pc, StringIdInfo::Offset::BYTE_1, StringIdInfo::Length::BITS_16); 5158 GateRef result = builder.StoreObjByName(glue, receiver, 0, info, acc, profileTypeInfo, slotId, callback); 5159 CHECK_EXCEPTION(result, INT_PTR(STTHISBYNAME_IMM8_ID16)); 5160} 5161DECLARE_ASM_HANDLER(HandleLdthisbynameImm16Id16) 5162{ 5163 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5164 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc)); 5165 GateRef receiver = GetThisFromFrame(GetFrame(sp)); 5166 5167 AccessObjectStubBuilder builder(this); 5168 StringIdInfo info(constpool, pc, StringIdInfo::Offset::BYTE_2, StringIdInfo::Length::BITS_16); 5169 GateRef result = builder.LoadObjByName(glue, receiver, 0, info, profileTypeInfo, slotId, callback); 5170 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDTHISBYNAME_IMM16_ID16)); 5171} 5172DECLARE_ASM_HANDLER(HandleLdthisbynameImm8Id16) 5173{ 5174 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5175 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); 5176 GateRef receiver = GetThisFromFrame(GetFrame(sp)); 5177 5178 AccessObjectStubBuilder builder(this); 5179 StringIdInfo info(constpool, pc, StringIdInfo::Offset::BYTE_1, StringIdInfo::Length::BITS_16); 5180 GateRef result = builder.LoadObjByName(glue, receiver, 0, info, profileTypeInfo, slotId, callback); 5181 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDTHISBYNAME_IMM8_ID16)); 5182} 5183DECLARE_ASM_HANDLER(HandleLdthis) 5184{ 5185 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5186 varAcc = GetThisFromFrame(GetFrame(sp)); 5187 DISPATCH_WITH_ACC(LDTHIS); 5188} 5189DECLARE_ASM_HANDLER(HandleLdnewtarget) 5190{ 5191 DISPATCH(NOP); 5192} 5193 5194DECLARE_ASM_HANDLER(HandleDeprecatedLdlexenvPrefNone) 5195{ 5196 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5197 GateRef state = GetFrame(sp); 5198 varAcc = GetEnvFromFrame(state); 5199 DISPATCH_WITH_ACC(DEPRECATED_LDLEXENV_PREF_NONE); 5200} 5201 5202DECLARE_ASM_HANDLER(HandleDeprecatedLdhomeobjectPrefNone) 5203{ 5204 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5205 GateRef state = GetFunctionFromFrame(GetFrame(sp)); 5206 varAcc = GetHomeObjectFromJSFunction(state); 5207 DISPATCH_WITH_ACC(DEPRECATED_LDHOMEOBJECT_PREF_NONE); 5208} 5209 5210DECLARE_ASM_HANDLER(HandleDeprecatedCreateobjecthavingmethodPrefImm16) 5211{ 5212 GateRef imm = ZExtInt16ToInt32(ReadInst16_1(pc)); 5213 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 5214 GateRef module = GetModuleFromFunction(currentFunc); 5215 GateRef result = GetObjectLiteralFromConstPool(glue, constpool, imm, module); 5216 NewObjectStubBuilder newBuilder(this); 5217 GateRef res = newBuilder.CreateObjectHavingMethod(glue, result, acc); 5218 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(DEPRECATED_CREATEOBJECTHAVINGMETHOD_PREF_IMM16)); 5219} 5220 5221#define DECLARE_UNUSED_ASM_HANDLE(name) \ 5222 DECLARE_ASM_HANDLER(name) \ 5223 { \ 5224 FatalPrint(glue, { Int32(GET_MESSAGE_STRING_ID(name)) }); \ 5225 DISPATCH_BAK(OFFSET, IntPtr(0)); \ 5226 } 5227ASM_UNUSED_BC_STUB_LIST(DECLARE_UNUSED_ASM_HANDLE) 5228#undef DECLARE_UNUSED_ASM_HANDLE 5229 5230DECLARE_ASM_HANDLER_NOPRINT(HandleThrow) 5231{ 5232 GateRef opcode = ZExtInt8ToPtr(ReadInst8_0(pc)); 5233 auto index = IntPtr(kungfu::BytecodeStubCSigns::ID_Throw_Start); 5234 auto jumpIndex = PtrAdd(opcode, index); 5235 DispatchWithId(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter, jumpIndex); 5236} 5237 5238DECLARE_ASM_HANDLER_NOPRINT(HandleWide) 5239{ 5240 GateRef opcode = ZExtInt8ToPtr(ReadInst8_0(pc)); 5241 auto index = IntPtr(kungfu::BytecodeStubCSigns::ID_Wide_Start); 5242 auto jumpIndex = PtrAdd(opcode, index); 5243 DispatchWithId(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter, jumpIndex); 5244} 5245 5246DECLARE_ASM_HANDLER_NOPRINT(HandleDeprecated) 5247{ 5248 GateRef opcode = ZExtInt8ToPtr(ReadInst8_0(pc)); 5249 auto index = IntPtr(kungfu::BytecodeStubCSigns::ID_Deprecated_Start); 5250 auto jumpIndex = PtrAdd(opcode, index); 5251 DispatchWithId(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter, jumpIndex); 5252} 5253 5254DECLARE_ASM_HANDLER_NOPRINT(HandleCallRuntime) 5255{ 5256 GateRef opcode = ZExtInt8ToPtr(ReadInst8_0(pc)); 5257 auto index = IntPtr(kungfu::BytecodeStubCSigns::ID_CallRuntime_Start); 5258 auto jumpIndex = PtrAdd(opcode, index); 5259 DispatchWithId(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter, jumpIndex); 5260} 5261 5262// interpreter helper handler 5263DECLARE_ASM_HANDLER_NOPRINT(ExceptionHandler) 5264{ 5265 auto env = GetEnvironment(); 5266 DEFVARIABLE(varPc, VariableType::NATIVE_POINTER(), pc); 5267 DEFVARIABLE(varSp, VariableType::NATIVE_POINTER(), sp); 5268 DEFVARIABLE(varConstpool, VariableType::JS_POINTER(), constpool); 5269 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_POINTER(), profileTypeInfo); 5270 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5271 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); 5272 5273 Label pcIsInvalid(env); 5274 Label pcNotInvalid(env); 5275 GateRef exceptionOffset = IntPtr(JSThread::GlueData::GetExceptionOffset(env->IsArch32Bit())); 5276 GateRef exception = Load(VariableType::JS_ANY(), glue, exceptionOffset); 5277 varPc = TaggedCastToIntPtr(CallRuntime(glue, RTSTUB_ID(UpFrame), {})); 5278 varSp = GetCurrentFrame(glue); 5279 BRANCH(IntPtrEqual(*varPc, IntPtr(0)), &pcIsInvalid, &pcNotInvalid); 5280 Bind(&pcIsInvalid); 5281 { 5282 CallNGCRuntime(glue, RTSTUB_ID(ResumeUncaughtFrameAndReturn), { glue, *varSp, *varAcc }); 5283 Return(); 5284 } 5285 Bind(&pcNotInvalid); 5286 { 5287 varAcc = exception; 5288 // clear exception 5289 Store(VariableType::INT64(), glue, glue, exceptionOffset, Hole()); 5290 GateRef function = GetFunctionFromFrame(GetFrame(*varSp)); 5291 GateRef method = Load(VariableType::JS_ANY(), function, IntPtr(JSFunctionBase::METHOD_OFFSET)); 5292 varConstpool = GetConstpoolFromMethod(method); 5293 varProfileTypeInfo = GetProfileTypeInfoFromFunction(function); 5294 varHotnessCounter = GetHotnessCounterFromMethod(method); 5295 CallNGCRuntime(glue, RTSTUB_ID(ResumeCaughtFrameAndDispatch), { 5296 glue, *varSp, *varPc, *varConstpool, 5297 *varProfileTypeInfo, *varAcc, *varHotnessCounter}); 5298 Return(); 5299 } 5300} 5301 5302DECLARE_ASM_HANDLER(SingleStepDebugging) 5303{ 5304 auto env = GetEnvironment(); 5305 DEFVARIABLE(varPc, VariableType::NATIVE_POINTER(), pc); 5306 DEFVARIABLE(varSp, VariableType::NATIVE_POINTER(), sp); 5307 DEFVARIABLE(varConstpool, VariableType::JS_POINTER(), constpool); 5308 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_POINTER(), profileTypeInfo); 5309 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5310 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); 5311 5312 GateRef frame = GetFrame(*varSp); 5313 SetPcToFrame(glue, frame, *varPc); 5314 GateRef currentSp = *varSp; 5315 varSp = TaggedCastToIntPtr(CallRuntime(glue, 5316 RTSTUB_ID(JumpToCInterpreter), 5317 { constpool, profileTypeInfo, acc, 5318 IntToTaggedInt(hotnessCounter)})); 5319 GateRef frameAfter = GetFrame(*varSp); 5320 varPc = GetPcFromFrame(frameAfter); 5321 Label shouldReturn(env); 5322 Label shouldContinue(env); 5323 5324 BRANCH(IntPtrEqual(*varPc, IntPtr(0)), &shouldReturn, &shouldContinue); 5325 Bind(&shouldReturn); 5326 { 5327 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndReturn), { Undefined(), *varSp, currentSp }); 5328 Return(); 5329 } 5330 Bind(&shouldContinue); 5331 { 5332 varAcc = GetAccFromFrame(frameAfter); 5333 GateRef function = GetFunctionFromFrame(frameAfter); 5334 GateRef method = Load(VariableType::JS_ANY(), function, IntPtr(JSFunctionBase::METHOD_OFFSET)); 5335 varProfileTypeInfo = GetProfileTypeInfoFromFunction(function); 5336 varConstpool = GetConstpoolFromMethod(method); 5337 varHotnessCounter = GetHotnessCounterFromMethod(method); 5338 } 5339 Label isException(env); 5340 Label notException(env); 5341 BRANCH(TaggedIsException(*varAcc), &isException, ¬Exception); 5342 Bind(&isException); 5343 DispatchLast(glue, *varSp, *varPc, *varConstpool, *varProfileTypeInfo, *varAcc, 5344 *varHotnessCounter); 5345 Bind(¬Exception); 5346 DISPATCH_BAK(SSD, IntPtr(0)); 5347} 5348 5349DECLARE_ASM_HANDLER(BCDebuggerEntry) 5350{ 5351 auto env = GetEnvironment(); 5352 Label callByteCodeChanged(env); 5353 Label isFrameDroppedTrue(env); 5354 Label isFrameDroppedFalse(env); 5355 Label isEntryFrameDroppedPending(env); 5356 Label isEntryFrameDroppedNotTrue(env); 5357 Label isBaselineBuiltinFrame(env); 5358 Label notBaselineBuiltinFrame(env); 5359 Label pcEqualNullptr(env); 5360 Label pcNotEqualNullptr(env); 5361 Label pcEqualBaseline(env); 5362 Label pcNotEqualBaseline(env); 5363 GateRef frame = GetFrame(sp); 5364 GateRef isEntryFrameDropped = Load(VariableType::INT8(), glue, 5365 IntPtr(JSThread::GlueData::GetEntryFrameDroppedStateOffset(env->Is32Bit()))); 5366 BRANCH(Int8Equal(isEntryFrameDropped, Int8(JSThread::FrameDroppedState::StatePending)), 5367 &isEntryFrameDroppedPending, &callByteCodeChanged); 5368 Bind(&isEntryFrameDroppedPending); 5369 { 5370 Store(VariableType::INT8(), glue, glue, 5371 IntPtr(JSThread::GlueData::GetEntryFrameDroppedStateOffset(env->Is32Bit())), 5372 Int8(JSThread::FrameDroppedState::StateFalse)); 5373 DEFVARIABLE(varPc, VariableType::NATIVE_POINTER(), pc); 5374 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5375 varPc = GetPcFromFrame(frame); 5376 varAcc = GetAccFromFrame(frame); 5377 Dispatch(glue, sp, *varPc, constpool, profileTypeInfo, *varAcc, hotnessCounter, IntPtr(0)); 5378 } 5379 Bind(&callByteCodeChanged); 5380 SetPcToFrame(glue, frame, pc); 5381 // NOTIFY_DEBUGGER_EVENT() 5382 CallRuntime(glue, RTSTUB_ID(NotifyBytecodePcChanged), {}); 5383 GateRef isFrameDropped = Load(VariableType::BOOL(), glue, 5384 IntPtr(JSThread::GlueData::GetIsFrameDroppedOffset(env->Is32Bit()))); 5385 BRANCH(isFrameDropped, &isFrameDroppedTrue, &isFrameDroppedFalse); 5386 Bind(&isFrameDroppedTrue); 5387 { 5388 DEFVARIABLE(varPc, VariableType::NATIVE_POINTER(), pc); 5389 DEFVARIABLE(varSp, VariableType::NATIVE_POINTER(), sp); 5390 DEFVARIABLE(prevState, VariableType::NATIVE_POINTER(), sp); 5391 DEFVARIABLE(varConstpool, VariableType::JS_POINTER(), constpool); 5392 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_POINTER(), profileTypeInfo); 5393 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5394 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter); 5395 GateRef state = GetFrame(*varSp); 5396 GateRef currentSp = *varSp; 5397 Store(VariableType::BOOL(), glue, glue, 5398 IntPtr(JSThread::GlueData::GetIsFrameDroppedOffset(env->Is32Bit())), False()); 5399 varSp = Load(VariableType::NATIVE_POINTER(), state, 5400 IntPtr(AsmInterpretedFrame::GetBaseOffset(env->IsArch32Bit()))); 5401 isEntryFrameDropped = Load(VariableType::INT8(), glue, 5402 IntPtr(JSThread::GlueData::GetEntryFrameDroppedStateOffset(env->Is32Bit()))); 5403 BRANCH(Int8Equal(isEntryFrameDropped, Int8(JSThread::FrameDroppedState::StateTrue)), 5404 &pcEqualNullptr, &isEntryFrameDroppedNotTrue); 5405 Bind(&isEntryFrameDroppedNotTrue); 5406 GateRef typePos = PtrSub(*varSp, IntPtr(JSTaggedValue::TaggedTypeSize())); 5407 GateRef maybeFrameType = Load(VariableType::INT64(), typePos); 5408 BRANCH(Int64Equal(maybeFrameType, Int64(static_cast<int64_t>(FrameType::BASELINE_BUILTIN_FRAME))), 5409 &isBaselineBuiltinFrame, ¬BaselineBuiltinFrame); 5410 Bind(&isBaselineBuiltinFrame); 5411 { 5412 varSp = Load(VariableType::NATIVE_POINTER(), *varSp); 5413 Jump(¬BaselineBuiltinFrame); 5414 } 5415 Bind(¬BaselineBuiltinFrame); 5416 prevState = GetFrame(*varSp); 5417 varPc = GetPcFromFrame(*prevState); 5418 BRANCH(IntPtrEqual(*varPc, IntPtr(0)), &pcEqualNullptr, &pcNotEqualNullptr); 5419 Bind(&pcEqualNullptr); 5420 { 5421 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndReturn), { *varAcc, *varSp, currentSp }); 5422 Return(); 5423 } 5424 Bind(&pcNotEqualNullptr); 5425 BRANCH(IntPtrEqual(*varPc, IntPtr(BASELINEJIT_PC_FLAG)), &pcEqualBaseline, &pcNotEqualBaseline); 5426 Bind(&pcEqualBaseline); 5427 { 5428 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndReturn), { *varAcc, *varSp, currentSp }); 5429 Return(); 5430 } 5431 Bind(&pcNotEqualBaseline); 5432 { 5433 GateRef function = GetFunctionFromFrame(*prevState); 5434 GateRef method = Load(VariableType::JS_ANY(), function, IntPtr(JSFunctionBase::METHOD_OFFSET)); 5435 varConstpool = GetConstpoolFromMethod(method); 5436 varProfileTypeInfo = GetProfileTypeInfoFromFunction(function); 5437 varHotnessCounter = GetHotnessCounterFromMethod(method); 5438 GateRef jumpSize = IntPtr(0); 5439 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndRollback), 5440 { glue, currentSp, *varPc, *varConstpool, *varProfileTypeInfo, 5441 *varAcc, *varHotnessCounter, jumpSize }); 5442 Return(); 5443 } 5444 } 5445 Bind(&isFrameDroppedFalse); 5446 SetAccToFrame(glue, frame, acc); 5447 // goto normal handle stub 5448 DispatchDebugger(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter); 5449} 5450 5451DECLARE_ASM_HANDLER(BCDebuggerExceptionEntry) 5452{ 5453 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5454 varAcc = Hole(); 5455 GateRef frame = GetFrame(sp); 5456 SetPcToFrame(glue, frame, pc); 5457 // NOTIFY_DEBUGGER_EVENT() 5458 CallRuntime(glue, RTSTUB_ID(NotifyBytecodePcChanged), {}); 5459 // goto last handle stub 5460 DispatchDebuggerLast(glue, sp, pc, constpool, profileTypeInfo, *varAcc, hotnessCounter); 5461} 5462 5463DECLARE_ASM_HANDLER(NewObjectRangeThrowException) 5464{ 5465 CallRuntime(glue, RTSTUB_ID(ThrowDerivedMustReturnException), {}); 5466 DISPATCH_LAST(); 5467} 5468 5469DECLARE_ASM_HANDLER(ThrowStackOverflowException) 5470{ 5471 CallRuntime(glue, RTSTUB_ID(ThrowStackOverflowException), {}); 5472 DISPATCH_LAST(); 5473} 5474 5475DECLARE_ASM_HANDLER(HandleDefinefuncImm8Id16Imm8ColdReload) 5476{ 5477 auto env = GetEnvironment(); 5478 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5479 GateRef methodId = ReadInst16_1(pc); 5480 GateRef length = ReadInst8_3(pc); 5481 GateRef result = DefineFunc(glue, constpool, ZExtInt16ToInt32(methodId)); 5482 Label notException(env); 5483 CHECK_EXCEPTION_WITH_JUMP(result, ¬Exception); 5484 Bind(¬Exception); 5485 { 5486 SetLengthToFunction(glue, result, ZExtInt8ToInt32(length)); 5487 auto frame = GetFrame(sp); 5488 GateRef envHandle = GetEnvFromFrame(frame); 5489 SetLexicalEnvToFunction(glue, result, envHandle); 5490 GateRef currentFunc = GetFunctionFromFrame(frame); 5491 SetModuleToFunction(glue, result, GetModuleFromFunction(currentFunc)); 5492 CallRuntime(glue, RTSTUB_ID(SetPatchModule), { result }); 5493 SetHomeObjectToFunction(glue, result, GetHomeObjectFromFunction(currentFunc)); 5494#if ECMASCRIPT_ENABLE_IC 5495 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc)); 5496 UpdateProfileTypeInfoCellToFunction(glue, result, profileTypeInfo, slotId); 5497 callback.ProfileDefineClass(result); 5498#endif 5499 varAcc = result; 5500 DISPATCH_WITH_ACC(DEFINEFUNC_IMM8_ID16_IMM8); 5501 } 5502} 5503 5504DECLARE_ASM_HANDLER(HandleDefinefuncImm16Id16Imm8ColdReload) 5505{ 5506 auto env = GetEnvironment(); 5507 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5508 GateRef methodId = ReadInst16_2(pc); 5509 GateRef length = ReadInst8_4(pc); 5510 GateRef result = DefineFunc(glue, constpool, ZExtInt16ToInt32(methodId)); 5511 Label notException(env); 5512 CHECK_EXCEPTION_WITH_JUMP(result, ¬Exception); 5513 Bind(¬Exception); 5514 { 5515 SetLengthToFunction(glue, result, ZExtInt8ToInt32(length)); 5516 auto frame = GetFrame(sp); 5517 GateRef envHandle = GetEnvFromFrame(frame); 5518 SetLexicalEnvToFunction(glue, result, envHandle); 5519 GateRef currentFunc = GetFunctionFromFrame(frame); 5520 SetHomeObjectToFunction(glue, result, GetHomeObjectFromFunction(currentFunc)); 5521 SetModuleToFunction(glue, result, GetModuleFromFunction(currentFunc)); 5522 CallRuntime(glue, RTSTUB_ID(SetPatchModule), { result }); 5523#if ECMASCRIPT_ENABLE_IC 5524 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc)); 5525 UpdateProfileTypeInfoCellToFunction(glue, result, profileTypeInfo, slotId); 5526 callback.ProfileDefineClass(result); 5527#endif 5528 varAcc = result; 5529 DISPATCH_WITH_ACC(DEFINEFUNC_IMM16_ID16_IMM8); 5530 } 5531} 5532 5533DECLARE_ASM_HANDLER(HandleWideLdpatchvarPrefImm16) 5534{ 5535 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5536 5537 GateRef index = ReadInst16_1(pc); 5538 GateRef result = CallRuntime(glue, RTSTUB_ID(LdPatchVar), { Int16ToTaggedInt(index) }); 5539 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(WIDE_LDPATCHVAR_PREF_IMM16)); 5540} 5541 5542DECLARE_ASM_HANDLER(HandleWideStpatchvarPrefImm16) 5543{ 5544 GateRef index = ReadInst16_1(pc); 5545 GateRef result = CallRuntime(glue, RTSTUB_ID(StPatchVar), { Int16ToTaggedInt(index), acc }); 5546 CHECK_EXCEPTION(result, INT_PTR(WIDE_STPATCHVAR_PREF_IMM16)); 5547} 5548 5549DECLARE_ASM_HANDLER(HandleCallRuntimeNotifyConcurrentResultPrefNone) 5550{ 5551 GateRef funcObj = GetFunctionFromFrame(GetFrame(sp)); 5552 CallRuntime(glue, RTSTUB_ID(NotifyConcurrentResult), {acc, funcObj}); 5553 DISPATCH(CALLRUNTIME_NOTIFYCONCURRENTRESULT_PREF_NONE); 5554} 5555 5556DECLARE_ASM_HANDLER(HandleDefineFieldByNameImm8Id16V8) 5557{ 5558 auto env = GetEnvironment(); 5559 DEFVARIABLE(result, VariableType::JS_ANY(), Hole()); 5560 DEFINE_BY_NAME(Boolean(false)); 5561 CHECK_EXCEPTION_WITH_ACC(*result, INT_PTR(DEFINEFIELDBYNAME_IMM8_ID16_V8)); 5562} 5563DECLARE_ASM_HANDLER(HandleDefinePropertyByNameImm8Id16V8) 5564{ 5565 auto env = GetEnvironment(); 5566 DEFVARIABLE(result, VariableType::JS_ANY(), Hole()); 5567 DEFINE_BY_NAME(Boolean(true)); 5568 CHECK_EXCEPTION_WITH_ACC(*result, INT_PTR(DEFINEPROPERTYBYNAME_IMM8_ID16_V8)); 5569} 5570 5571 5572DECLARE_ASM_HANDLER(HandleCallRuntimeDefineFieldByValuePrefImm8V8V8) 5573{ 5574 GateRef v0 = ReadInst8_2(pc); 5575 GateRef v1 = ReadInst8_3(pc); 5576 GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(v1)); 5577 GateRef propKey = GetVregValue(sp, ZExtInt8ToPtr(v0)); 5578 GateRef res = DefineField(glue, obj, propKey, acc); // acc as value 5579 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CALLRUNTIME_DEFINEFIELDBYVALUE_PREF_IMM8_V8_V8)); 5580} 5581 5582DECLARE_ASM_HANDLER(HandleCallRuntimeDefineFieldByIndexPrefImm8Imm32V8) 5583{ 5584 GateRef index = ReadInst32_2(pc); 5585 GateRef v0 = ReadInst8_6(pc); 5586 GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(v0)); 5587 GateRef propKey = IntToTaggedInt(index); 5588 GateRef res = DefineField(glue, obj, propKey, acc); // acc as value 5589 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CALLRUNTIME_DEFINEFIELDBYINDEX_PREF_IMM8_IMM32_V8)); 5590} 5591 5592DECLARE_ASM_HANDLER(HandleCallRuntimeToPropertyKeyPrefNone) 5593{ 5594 GateRef res = CallRuntime(glue, RTSTUB_ID(ToPropertyKey), {acc}); 5595 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CALLRUNTIME_TOPROPERTYKEY_PREF_NONE)); 5596} 5597 5598DECLARE_ASM_HANDLER(HandleCallRuntimeCreatePrivatePropertyPrefImm16Id16) 5599{ 5600 GateRef lexicalEnv = GetEnvFromFrame(GetFrame(sp)); 5601 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 5602 GateRef module = GetModuleFromFunction(currentFunc); 5603 GateRef count = ZExtInt16ToInt32(ReadInst16_1(pc)); 5604 GateRef literalId = ZExtInt16ToInt32(ReadInst16_3(pc)); 5605 GateRef res = CallRuntime(glue, RTSTUB_ID(CreatePrivateProperty), {lexicalEnv, 5606 IntToTaggedInt(count), constpool, IntToTaggedInt(literalId), module}); 5607 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CALLRUNTIME_CREATEPRIVATEPROPERTY_PREF_IMM16_ID16)); 5608} 5609 5610DECLARE_ASM_HANDLER(HandleCallRuntimeDefinePrivatePropertyPrefImm8Imm16Imm16V8) 5611{ 5612 GateRef lexicalEnv = GetEnvFromFrame(GetFrame(sp)); 5613 GateRef levelIndex = ReadInst16_2(pc); 5614 GateRef slotIndex = ReadInst16_4(pc); 5615 GateRef v0 = ReadInst8_6(pc); 5616 GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(v0)); 5617 GateRef res = CallRuntime(glue, RTSTUB_ID(DefinePrivateProperty), {lexicalEnv, 5618 IntToTaggedInt(levelIndex), IntToTaggedInt(slotIndex), obj, acc}); // acc as value 5619 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CALLRUNTIME_DEFINEPRIVATEPROPERTY_PREF_IMM8_IMM16_IMM16_V8)); 5620} 5621 5622DECLARE_ASM_HANDLER(HandleCallRuntimeCallInitPrefImm8V8) 5623{ 5624 // same as callthis0 5625 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARG0); 5626 GateRef thisValue = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc))); 5627 GateRef func = acc; 5628 METHOD_ENTRY(func); 5629 GateRef jumpSize = INT_PTR(CALLRUNTIME_CALLINIT_PREF_IMM8_V8); 5630 JSCallArgs callArgs(JSCallMode::CALL_THIS_ARG0); 5631 callArgs.callArgsWithThis = { 0, 0, 0, thisValue }; 5632 CallStubBuilder callBuilder(this, glue, func, actualNumArgs, jumpSize, nullptr, hotnessCounter, callArgs, callback); 5633 GateRef res = callBuilder.JSCallDispatch(); 5634 CHECK_PENDING_EXCEPTION(res, jumpSize); 5635} 5636 5637DECLARE_ASM_HANDLER(HandleCallRuntimeDefineSendableClassPrefImm16Id16Id16Imm16V8) 5638{ 5639 auto env = GetEnvironment(); 5640 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5641 5642 GateRef methodId = ReadInst16_3(pc); 5643 GateRef literalId = ReadInst16_5(pc); 5644 GateRef length = ReadInst16_7(pc); 5645 GateRef v0 = ReadInst8_9(pc); 5646 5647 GateRef proto = GetVregValue(sp, ZExtInt8ToPtr(v0)); 5648 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 5649 GateRef module = GetModuleFromFunction(currentFunc); 5650 GateRef res = CallRuntime(glue, RTSTUB_ID(CreateSharedClass), 5651 { proto, constpool, 5652 Int16ToTaggedInt(methodId), 5653 Int16ToTaggedInt(literalId), 5654 Int16ToTaggedInt(length), module }); 5655 5656 Label isException(env); 5657 Label isNotException(env); 5658 BRANCH(TaggedIsException(res), &isException, &isNotException); 5659 Bind(&isException); 5660 { 5661 DISPATCH_LAST_WITH_ACC(); 5662 } 5663 Bind(&isNotException); 5664 varAcc = res; 5665 DISPATCH_WITH_ACC(CALLRUNTIME_DEFINESENDABLECLASS_PREF_IMM16_ID16_ID16_IMM16_V8); 5666} 5667 5668DECLARE_ASM_HANDLER(HandleCallRuntimeLdSendableClassPrefImm16) 5669{ 5670 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5671 GateRef level = ReadInst16_1(pc); 5672 GateRef lexEnv = GetEnvFromFrame(GetFrame(sp)); 5673 varAcc = CallRuntime(glue, RTSTUB_ID(LdSendableClass), { lexEnv, Int16ToTaggedInt(level) }); 5674 DISPATCH_WITH_ACC(CALLRUNTIME_LDSENDABLECLASS_PREF_IMM16); 5675} 5676 5677DECLARE_ASM_HANDLER(HandleCallRuntimeLdsendableexternalmodulevarImm8) 5678{ 5679 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5680 DEFVARIABLE(moduleRef, VariableType::JS_ANY(), Undefined()); 5681 GateRef index = ReadInst8_1(pc); 5682 5683 // LdSendableExternalModuleVarByIndex may load uninitialized module lazy. Exception could happened. 5684 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 5685 moduleRef = CallRuntime(glue, RTSTUB_ID(LdSendableExternalModuleVarByIndex), {Int8ToTaggedInt(index), currentFunc}); 5686 5687 auto env = GetEnvironment(); 5688 Label notException(env); 5689 CHECK_EXCEPTION_WITH_JUMP(*moduleRef, ¬Exception); 5690 Bind(¬Exception); 5691 { 5692 varAcc = *moduleRef; 5693 DISPATCH_WITH_ACC(CALLRUNTIME_LDSENDABLEEXTERNALMODULEVAR_PREF_IMM8); 5694 } 5695} 5696 5697DECLARE_ASM_HANDLER(HandleCallRuntimeWideLdsendableexternalmodulevarPrefImm16) 5698{ 5699 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5700 DEFVARIABLE(moduleRef, VariableType::JS_ANY(), Undefined()); 5701 5702 GateRef index = ReadInst16_1(pc); 5703 5704 // LdSendableExternalModuleVarByIndex may load uninitialized module lazy. Exception could happened. 5705 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 5706 moduleRef = 5707 CallRuntime(glue, RTSTUB_ID(LdSendableExternalModuleVarByIndex), {Int16ToTaggedInt(index), currentFunc}); 5708 5709 auto env = GetEnvironment(); 5710 Label notException(env); 5711 CHECK_EXCEPTION_WITH_JUMP(*moduleRef, ¬Exception); 5712 Bind(¬Exception); 5713 { 5714 varAcc = *moduleRef; 5715 DISPATCH_WITH_ACC(CALLRUNTIME_WIDELDSENDABLEEXTERNALMODULEVAR_PREF_IMM16); 5716 } 5717} 5718 5719DECLARE_ASM_HANDLER(HandleCallRuntimeNewSendableEnvImm8) 5720{ 5721 auto env = GetEnvironment(); 5722 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5723 GateRef numVars = ZExtInt8ToInt16(ReadInst8_1(pc)); 5724 GateRef res = CallRuntime(glue, RTSTUB_ID(NewSendableEnv), 5725 { Int16ToTaggedInt(numVars) }); 5726 Label notException(env); 5727 CHECK_EXCEPTION_WITH_JUMP(res, ¬Exception); 5728 Bind(¬Exception); 5729 varAcc = res; 5730 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 5731 GateRef module = GetModuleFromFunction(currentFunc); 5732 SetSendableEnvToModule(glue, module, res); 5733 DISPATCH_WITH_ACC(CALLRUNTIME_NEWSENDABLEENV_PREF_IMM8); 5734} 5735 5736DECLARE_ASM_HANDLER(HandleCallRuntimeNewSendableEnvImm16) 5737{ 5738 auto env = GetEnvironment(); 5739 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5740 GateRef numVars = ReadInst16_1(pc); 5741 GateRef res = CallRuntime(glue, RTSTUB_ID(NewSendableEnv), 5742 { Int16ToTaggedInt(numVars) }); 5743 Label notException(env); 5744 CHECK_EXCEPTION_WITH_JUMP(res, ¬Exception); 5745 Bind(¬Exception); 5746 varAcc = res; 5747 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 5748 GateRef module = GetModuleFromFunction(currentFunc); 5749 SetSendableEnvToModule(glue, module, res); 5750 DISPATCH_WITH_ACC(CALLRUNTIME_WIDENEWSENDABLEENV_PREF_IMM16); 5751} 5752 5753DECLARE_ASM_HANDLER(HandleCallRuntimeStSendableVarImm4Imm4) 5754{ 5755 auto env = GetEnvironment(); 5756 GateRef level = ZExtInt8ToInt32(ReadInst4_2(pc)); 5757 GateRef slot = ZExtInt8ToInt32(ReadInst4_3(pc)); 5758 5759 GateRef value = acc; 5760 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 5761 GateRef module = GetModuleFromFunction(currentFunc); 5762 DEFVARIABLE(currentEnv, VariableType::JS_ANY(), GetSendableEnvFromModule(module)); 5763 DEFVARIABLE(i, VariableType::INT32(), Int32(0)); 5764 5765 Label loopHead(env); 5766 Label loopEnd(env); 5767 Label afterLoop(env); 5768 BRANCH(Int32LessThan(*i, level), &loopHead, &afterLoop); 5769 LoopBegin(&loopHead); 5770 currentEnv = GetSendableParentEnv(*currentEnv); 5771 i = Int32Add(*i, Int32(1)); 5772 BRANCH(Int32LessThan(*i, level), &loopEnd, &afterLoop); 5773 Bind(&loopEnd); 5774 LoopEnd(&loopHead, env, glue); 5775 Bind(&afterLoop); 5776 SetPropertiesToSendableEnv(glue, *currentEnv, slot, value); 5777 DISPATCH(CALLRUNTIME_STSENDABLEVAR_PREF_IMM4_IMM4); 5778} 5779 5780DECLARE_ASM_HANDLER(HandleCallRuntimeStSendableVarImm8Imm8) 5781{ 5782 auto env = GetEnvironment(); 5783 GateRef level = ZExtInt8ToInt32(ReadInst8_1(pc)); 5784 GateRef slot = ZExtInt8ToInt32(ReadInst8_2(pc)); 5785 5786 GateRef value = acc; 5787 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 5788 GateRef module = GetModuleFromFunction(currentFunc); 5789 DEFVARIABLE(currentEnv, VariableType::JS_ANY(), GetSendableEnvFromModule(module)); 5790 DEFVARIABLE(i, VariableType::INT32(), Int32(0)); 5791 5792 Label loopHead(env); 5793 Label loopEnd(env); 5794 Label afterLoop(env); 5795 BRANCH(Int32LessThan(*i, level), &loopHead, &afterLoop); 5796 LoopBegin(&loopHead); 5797 currentEnv = GetSendableParentEnv(*currentEnv); 5798 i = Int32Add(*i, Int32(1)); 5799 BRANCH(Int32LessThan(*i, level), &loopEnd, &afterLoop); 5800 Bind(&loopEnd); 5801 LoopEnd(&loopHead, env, glue); 5802 Bind(&afterLoop); 5803 SetPropertiesToSendableEnv(glue, *currentEnv, slot, value); 5804 DISPATCH(CALLRUNTIME_STSENDABLEVAR_PREF_IMM8_IMM8); 5805} 5806 5807DECLARE_ASM_HANDLER(HandleCallRuntimeStSendableVarImm16Imm16) 5808{ 5809 auto env = GetEnvironment(); 5810 GateRef level = ZExtInt16ToInt32(ReadInst16_1(pc)); 5811 GateRef slot = ZExtInt16ToInt32(ReadInst16_3(pc)); 5812 5813 GateRef value = acc; 5814 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 5815 GateRef module = GetModuleFromFunction(currentFunc); 5816 DEFVARIABLE(currentEnv, VariableType::JS_ANY(), GetSendableEnvFromModule(module)); 5817 DEFVARIABLE(i, VariableType::INT32(), Int32(0)); 5818 5819 Label loopHead(env); 5820 Label loopEnd(env); 5821 Label afterLoop(env); 5822 BRANCH(Int32LessThan(*i, level), &loopHead, &afterLoop); 5823 LoopBegin(&loopHead); 5824 currentEnv = GetSendableParentEnv(*currentEnv); 5825 i = Int32Add(*i, Int32(1)); 5826 BRANCH(Int32LessThan(*i, level), &loopEnd, &afterLoop); 5827 Bind(&loopEnd); 5828 LoopEnd(&loopHead, env, glue); 5829 Bind(&afterLoop); 5830 SetPropertiesToSendableEnv(glue, *currentEnv, slot, value); 5831 DISPATCH(CALLRUNTIME_WIDESTSENDABLEVAR_PREF_IMM16_IMM16); 5832} 5833 5834DECLARE_ASM_HANDLER(HandleCallRuntimeLdSendableVarImm4Imm4) 5835{ 5836 auto env = GetEnvironment(); 5837 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5838 5839 GateRef level = ZExtInt8ToInt32(ReadInst4_2(pc)); 5840 GateRef slot = ZExtInt8ToInt32(ReadInst4_3(pc)); 5841 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 5842 GateRef module = GetModuleFromFunction(currentFunc); 5843 DEFVARIABLE(currentEnv, VariableType::JS_ANY(), GetSendableEnvFromModule(module)); 5844 DEFVARIABLE(i, VariableType::INT32(), Int32(0)); 5845 5846 Label loopHead(env); 5847 Label loopEnd(env); 5848 Label afterLoop(env); 5849 BRANCH(Int32LessThan(*i, level), &loopHead, &afterLoop); 5850 LoopBegin(&loopHead); 5851 currentEnv = GetSendableParentEnv(*currentEnv); 5852 i = Int32Add(*i, Int32(1)); 5853 BRANCH(Int32LessThan(*i, level), &loopEnd, &afterLoop); 5854 Bind(&loopEnd); 5855 LoopEnd(&loopHead, env, glue); 5856 Bind(&afterLoop); 5857 GateRef variable = GetPropertiesFromSendableEnv(*currentEnv, slot); 5858 varAcc = variable; 5859 5860 DISPATCH_WITH_ACC(CALLRUNTIME_LDSENDABLEVAR_PREF_IMM4_IMM4); 5861} 5862 5863DECLARE_ASM_HANDLER(HandleCallRuntimeLdSendableVarImm8Imm8) 5864{ 5865 auto env = GetEnvironment(); 5866 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5867 5868 GateRef level = ZExtInt8ToInt32(ReadInst8_1(pc)); 5869 GateRef slot = ZExtInt8ToInt32(ReadInst8_2(pc)); 5870 5871 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 5872 GateRef module = GetModuleFromFunction(currentFunc); 5873 DEFVARIABLE(currentEnv, VariableType::JS_ANY(), GetSendableEnvFromModule(module)); 5874 DEFVARIABLE(i, VariableType::INT32(), Int32(0)); 5875 5876 Label loopHead(env); 5877 Label loopEnd(env); 5878 Label afterLoop(env); 5879 BRANCH(Int32LessThan(*i, level), &loopHead, &afterLoop); 5880 LoopBegin(&loopHead); 5881 currentEnv = GetSendableParentEnv(*currentEnv); 5882 i = Int32Add(*i, Int32(1)); 5883 BRANCH(Int32LessThan(*i, level), &loopEnd, &afterLoop); 5884 Bind(&loopEnd); 5885 LoopEnd(&loopHead, env, glue); 5886 Bind(&afterLoop); 5887 GateRef variable = GetPropertiesFromSendableEnv(*currentEnv, slot); 5888 varAcc = variable; 5889 5890 DISPATCH_WITH_ACC(CALLRUNTIME_LDSENDABLEVAR_PREF_IMM8_IMM8); 5891} 5892 5893DECLARE_ASM_HANDLER(HandleCallRuntimeLdSendableVarImm16Imm16) 5894{ 5895 auto env = GetEnvironment(); 5896 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5897 5898 GateRef level = ZExtInt16ToInt32(ReadInst16_1(pc)); 5899 GateRef slot = ZExtInt16ToInt32(ReadInst16_3(pc)); 5900 5901 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 5902 GateRef module = GetModuleFromFunction(currentFunc); 5903 DEFVARIABLE(currentEnv, VariableType::JS_ANY(), GetSendableEnvFromModule(module)); 5904 DEFVARIABLE(i, VariableType::INT32(), Int32(0)); 5905 5906 Label loopHead(env); 5907 Label loopEnd(env); 5908 Label afterLoop(env); 5909 BRANCH(Int32LessThan(*i, level), &loopHead, &afterLoop); 5910 LoopBegin(&loopHead); 5911 currentEnv = GetSendableParentEnv(*currentEnv); 5912 i = Int32Add(*i, Int32(1)); 5913 BRANCH(Int32LessThan(*i, level), &loopEnd, &afterLoop); 5914 Bind(&loopEnd); 5915 LoopEnd(&loopHead, env, glue); 5916 Bind(&afterLoop); 5917 GateRef variable = GetPropertiesFromSendableEnv(*currentEnv, slot); 5918 varAcc = variable; 5919 5920 DISPATCH_WITH_ACC(CALLRUNTIME_WIDELDSENDABLEVAR_PREF_IMM16_IMM16); 5921} 5922DECLARE_ASM_HANDLER(HandleCallRuntimeLdLazyModuleVarPrefImm8) 5923{ 5924 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5925 DEFVARIABLE(moduleRef, VariableType::JS_ANY(), Undefined()); 5926 GateRef index = ReadInst8_1(pc); 5927 5928 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 5929 moduleRef = CallRuntime(glue, RTSTUB_ID(LdLazyExternalModuleVarByIndex), { Int8ToTaggedInt(index), currentFunc }); 5930 5931 auto env = GetEnvironment(); 5932 Label notException(env); 5933 CHECK_EXCEPTION_WITH_JUMP(*moduleRef, ¬Exception); 5934 Bind(¬Exception); 5935 { 5936 varAcc = *moduleRef; 5937 DISPATCH_WITH_ACC(CALLRUNTIME_LDLAZYMODULEVAR_PREF_IMM8); 5938 } 5939} 5940 5941DECLARE_ASM_HANDLER(HandleCallRuntimeWideLdLazyModuleVarPrefImm16) 5942{ 5943 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5944 DEFVARIABLE(moduleRef, VariableType::JS_ANY(), Undefined()); 5945 5946 GateRef index = ReadInst16_1(pc); 5947 5948 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 5949 moduleRef = CallRuntime(glue, RTSTUB_ID(LdLazyExternalModuleVarByIndex), { Int16ToTaggedInt(index), currentFunc }); 5950 5951 auto env = GetEnvironment(); 5952 Label notException(env); 5953 CHECK_EXCEPTION_WITH_JUMP(*moduleRef, ¬Exception); 5954 Bind(¬Exception); 5955 { 5956 varAcc = *moduleRef; 5957 DISPATCH_WITH_ACC(CALLRUNTIME_WIDELDLAZYMODULEVAR_PREF_IMM16); 5958 } 5959} 5960 5961DECLARE_ASM_HANDLER(HandleCallRuntimeLdLazySendableModuleVarPrefImm8) 5962{ 5963 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5964 DEFVARIABLE(moduleRef, VariableType::JS_ANY(), Undefined()); 5965 GateRef index = ReadInst8_1(pc); 5966 5967 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 5968 moduleRef = CallRuntime(glue, RTSTUB_ID(LdLazySendableExternalModuleVarByIndex), 5969 { Int8ToTaggedInt(index), currentFunc }); 5970 5971 auto env = GetEnvironment(); 5972 Label notException(env); 5973 CHECK_EXCEPTION_WITH_JUMP(*moduleRef, ¬Exception); 5974 Bind(¬Exception); 5975 { 5976 varAcc = *moduleRef; 5977 DISPATCH_WITH_ACC(CALLRUNTIME_LDLAZYSENDABLEMODULEVAR_PREF_IMM8); 5978 } 5979} 5980 5981DECLARE_ASM_HANDLER(HandleCallRuntimeWideLdLazySendableModuleVarPrefImm16) 5982{ 5983 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc); 5984 DEFVARIABLE(moduleRef, VariableType::JS_ANY(), Undefined()); 5985 5986 GateRef index = ReadInst16_1(pc); 5987 5988 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp)); 5989 moduleRef = CallRuntime(glue, RTSTUB_ID(LdLazySendableExternalModuleVarByIndex), 5990 { Int16ToTaggedInt(index), currentFunc }); 5991 5992 auto env = GetEnvironment(); 5993 Label notException(env); 5994 CHECK_EXCEPTION_WITH_JUMP(*moduleRef, ¬Exception); 5995 Bind(¬Exception); 5996 { 5997 varAcc = *moduleRef; 5998 DISPATCH_WITH_ACC(CALLRUNTIME_WIDELDLAZYSENDABLEMODULEVAR_PREF_IMM16); 5999 } 6000} 6001 6002DECLARE_ASM_HANDLER(HandleCallRuntimeSuperCallForwardAllArgsV8) 6003{ 6004 DEFVARIABLE(varAcc, VariableType::JS_ANY(), Undefined()); 6005 DEFVARIABLE(res, VariableType::JS_ANY(), Undefined()); 6006 6007 auto env = GetEnvironment(); 6008 Label resIsException(env); 6009 Label isException(env); 6010 Label dispatch(env); 6011 6012 GateRef thisFunc = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc))); 6013 res = CallRuntime(glue, RTSTUB_ID(SuperCallForwardAllArgs), { thisFunc }); 6014 6015 BRANCH(TaggedIsException(*res), &resIsException, &dispatch); 6016 Bind(&resIsException); 6017 BRANCH(HasPendingException(glue), &isException, &dispatch); 6018 Bind(&isException); 6019 { 6020 DISPATCH_LAST(); 6021 } 6022 Bind(&dispatch); 6023 { 6024 varAcc = *res; 6025 DISPATCH_WITH_ACC(CALLRUNTIME_SUPERCALLFORWARDALLARGS_PREF_V8); 6026 } 6027} 6028 6029ASM_INTERPRETER_BC_TYPE_PROFILER_STUB_LIST(DECLARE_ASM_HANDLER_PROFILE) 6030ASM_INTERPRETER_BC_LAYOUT_PROFILER_STUB_LIST(DECLARE_ASM_HANDLER_PROFILE) 6031ASM_INTERPRETER_BC_FUNC_HOT_PROFILER_STUB_LIST(DECLARE_ASM_HANDLER_PROFILE) 6032ASM_INTERPRETER_BC_FUNC_COUNT_PROFILER_STUB_LIST(DECLARE_ASM_HANDLER_PROFILE) 6033ASM_INTERPRETER_BC_FUNC_HOT_JIT_PROFILER_STUB_LIST(DECLARE_ASM_HANDLER_JIT_PROFILE) 6034 6035#undef DECLARE_ASM_HANDLER 6036#undef DISPATCH 6037#undef DISPATCH_WITH_ACC 6038#undef DISPATCH_LAST 6039#undef DISPATCH_LAST_WITH_ACC 6040#undef USE_PARAMS 6041} // namespace panda::ecmascript::kungfu 6042