1/* 2 * Copyright (c) 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 "ecmascript/compiler/baseline/baseline_compiler.h" 17#include "ecmascript/compiler/bytecode_info_collector.h" 18#include "ecmascript/js_function.h" 19#include "ecmascript/compiler/jit_compiler.h" 20#ifdef JIT_ENABLE_CODE_SIGN 21#include "jit_buffer_integrity.h" 22#include "ecmascript/compiler/jit_signcode.h" 23#endif 24 25namespace panda::ecmascript::kungfu { 26using namespace panda::ecmascript; 27#ifdef JIT_ENABLE_CODE_SIGN 28using namespace kungfu; 29using namespace OHOS::Security::CodeSign; 30#endif 31 32#define LOG_INST() LOG_BASELINEJIT(DEBUG) 33 34#define ADVANCE_PC(opcode) bytecodeArray += BytecodeInstruction::Size(opcode) 35#define BYTECODE_BASELINE_HANDLER_IMPLEMENT(name) \ 36void BaselineCompiler::Handle##name(const uint8_t *bytecodeArray) 37 38#define READ_INST_OP() READ_INST_8(0) // NOLINT(hicpp-signed-bitwise, cppcoreguidelines-macro-usage) 39#define READ_INST_4_0() (READ_INST_8(1) & 0xf) // NOLINT(hicpp-signed-bitwise, cppcoreguidelines-macro-usage) 40#define READ_INST_4_1() (READ_INST_8(1) >> 4 & 0xf) // NOLINT(hicpp-signed-bitwise, cppcoreguidelines-macro-usage) 41#define READ_INST_4_2() (READ_INST_8(2) & 0xf) // NOLINT(hicpp-signed-bitwise, cppcoreguidelines-macro-usage) 42#define READ_INST_4_3() (READ_INST_8(2) >> 4 & 0xf) // NOLINT(hicpp-signed-bitwise, cppcoreguidelines-macro-usage) 43#define READ_INST_8_0() READ_INST_8(1) // NOLINT(hicpp-signed-bitwise, cppcoreguidelines-macro-usage) 44#define READ_INST_8_1() READ_INST_8(2) // NOLINT(hicpp-signed-bitwise, cppcoreguidelines-macro-usage) 45#define READ_INST_8_2() READ_INST_8(3) // NOLINT(hicpp-signed-bitwise, cppcoreguidelines-macro-usage) 46#define READ_INST_8_3() READ_INST_8(4) // NOLINT(hicpp-signed-bitwise, cppcoreguidelines-macro-usage) 47#define READ_INST_8_4() READ_INST_8(5) // NOLINT(hicpp-signed-bitwise, cppcoreguidelines-macro-usage) 48#define READ_INST_8_5() READ_INST_8(6) // NOLINT(hicpp-signed-bitwise, cppcoreguidelines-macro-usage) 49#define READ_INST_8_6() READ_INST_8(7) // NOLINT(hicpp-signed-bitwise, cppcoreguidelines-macro-usage) 50#define READ_INST_8_7() READ_INST_8(8) // NOLINT(hicpp-signed-bitwise, cppcoreguidelines-macro-usage) 51#define READ_INST_8_8() READ_INST_8(9) // NOLINT(hicpp-signed-bitwise, cppcoreguidelines-macro-usage) 52#define READ_INST_8_9() READ_INST_8(10) // NOLINT(hicpp-signed-bitwise, cppcoreguidelines-macro-usage) 53#define READ_INST_8(offset) (*(bytecodeArray + (offset))) 54#define MOVE_AND_READ_INST_8(currentInst, offset) \ 55 (currentInst) <<= 8; \ 56 (currentInst) += READ_INST_8(offset); \ 57 58#define READ_INST_16_0() READ_INST_16(2) 59#define READ_INST_16_1() READ_INST_16(3) 60#define READ_INST_16_2() READ_INST_16(4) 61#define READ_INST_16_3() READ_INST_16(5) 62#define READ_INST_16_4() READ_INST_16(6) 63#define READ_INST_16_5() READ_INST_16(7) 64#define READ_INST_16_6() READ_INST_16(8) 65#define READ_INST_16_7() READ_INST_16(9) 66#define READ_INST_16(offset) \ 67 ({ \ 68 uint16_t currentInst = READ_INST_8(offset); \ 69 MOVE_AND_READ_INST_8(currentInst, (offset) - 1) \ 70 }) 71 72#define READ_INST_32_0() READ_INST_32(4) 73#define READ_INST_32_1() READ_INST_32(5) 74#define READ_INST_32_2() READ_INST_32(6) 75#define READ_INST_32(offset) \ 76 ({ \ 77 uint32_t currentInst = READ_INST_8(offset); \ 78 MOVE_AND_READ_INST_8(currentInst, (offset) - 1) \ 79 MOVE_AND_READ_INST_8(currentInst, (offset) - 2) \ 80 MOVE_AND_READ_INST_8(currentInst, (offset) - 3) \ 81 }) 82 83#define READ_INST_64_0() \ 84 ({ \ 85 uint64_t currentInst = READ_INST_8(8); \ 86 MOVE_AND_READ_INST_8(currentInst, 7) \ 87 MOVE_AND_READ_INST_8(currentInst, 6) \ 88 MOVE_AND_READ_INST_8(currentInst, 5) \ 89 MOVE_AND_READ_INST_8(currentInst, 4) \ 90 MOVE_AND_READ_INST_8(currentInst, 3) \ 91 MOVE_AND_READ_INST_8(currentInst, 2) \ 92 MOVE_AND_READ_INST_8(currentInst, 1) \ 93 }) 94 95#define CALL_BASELINE_UPDATE_HOTNESS() \ 96 std::vector<BaselineParameter> parameters; \ 97 parameters.emplace_back(BaselineSpecialParameter::GLUE); \ 98 parameters.emplace_back(BaselineSpecialParameter::SP); \ 99 parameters.emplace_back(static_cast<int32_t>(offset)); \ 100 auto *thread = vm->GetAssociatedJSThread(); \ 101 Address builtinAddress = thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineUpdateHotness); \ 102 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); \ 103 104void BaselineCompiler::SetPfHeaderAddr(const JSPandaFile *jsPandaFile) 105{ 106 const panda_file::File *pandaFile = jsPandaFile->GetPandaFile(); 107 pfHeaderAddr = pandaFile->GetBase(); 108} 109 110static ARK_INLINE void SetupCodeSigner([[maybe_unused]] EcmaVM *vm) 111{ 112#ifdef JIT_ENABLE_CODE_SIGN 113 bool enableCodeSign = !vm->GetJSOptions().GetDisableCodeSign(); 114 if (enableCodeSign && JitFort::IsResourceAvailable()) { 115 JitSignCode *singleton = JitSignCode::GetInstance(); 116 singleton->Reset(); 117 JitCodeSignerBase *jitSigner = CreateJitCodeSigner(JitBufferIntegrityLevel::Level0); 118 singleton->SetCodeSigner(jitSigner); 119 LOG_INST() << " Created Code Signer for baseline compilation: " << std::hex << (uintptr_t)jitSigner << "\n"; 120 } 121#endif 122 return; 123} 124 125void BaselineCompiler::Compile(const JSPandaFile *jsPandaFile, const MethodLiteral *methodLiteral) 126{ 127 std::string tripleStr = vm->GetJSOptions().GetTargetTriple(); 128 const uint8_t *bytecodeArray = methodLiteral->GetBytecodeArray(); 129 auto codeSize = MethodLiteral::GetCodeSize(jsPandaFile, methodLiteral->GetMethodId()); 130 const uint8_t *methodBytecodeLast = bytecodeArray + codeSize; 131 StackOffsetDescriptor stackOffsetDescriptor(methodLiteral->GetCallField()); 132 GetBaselineAssembler().SetStackOffsetDescriptor(stackOffsetDescriptor); 133 SetPfHeaderAddr(jsPandaFile); 134 firstPC = bytecodeArray; 135 136 SetupCodeSigner(vm); 137 138 auto *thread = vm->GetAssociatedJSThread(); 139 Address bcAddr = thread->GetRTInterface(RuntimeStubCSigns::ID_CallArg1AndCheckToBaseline); 140 LOG_INST() << " ID_CallArg1AndCheckToBaseline Address: " << std::hex << bcAddr; 141 142 std::unordered_set<size_t> jumpToOffsets; 143 GetJumpToOffsets(bytecodeArray, methodBytecodeLast, jumpToOffsets); 144 145 while (bytecodeArray < methodBytecodeLast) { 146 auto opCode = Bytecodes::GetOpcode(bytecodeArray); 147 LOG_INST() << "processing opCode: " << GetEcmaOpcodeStr(Bytecodes::GetOpcode(bytecodeArray)); 148 LOG_INST() << "current bytecodePc offset: " << 149 static_cast<uint32_t>(bytecodeArray - methodLiteral->GetBytecodeArray()); 150 LOG_INST() << "current relative nativePc diff: " << 151 static_cast<uint64_t>(GetBaselineAssembler().GetBufferSize() - nativePcOffsetTable.GetPrevNativePc()); 152 153 if (jumpToOffsets.count(bytecodeOffset) != 0) { 154 if (jumpMap.count(bytecodeOffset) != 0) { 155 JumpLabel *label = jumpMap.at(bytecodeOffset); 156 GetBaselineAssembler().Bind(*label); 157 } else { 158 JumpLabel *label = new JumpLabel(); 159 GetBaselineAssembler().Bind(*label); 160 jumpMap.insert({bytecodeOffset, label}); 161 } 162 } 163 164 switch (opCode) { 165#define BYTECODE_SWITCH_CASE(name) \ 166 case EcmaOpcode::name: \ 167 Handle##name(bytecodeArray); \ 168 break; 169 ECMA_OPCODE_LIST(BYTECODE_SWITCH_CASE) 170#undef BYTECODE_SWITCH_CASE 171 default: 172 break; 173 } 174 ADVANCE_PC(opCode); 175 bytecodeOffset += BytecodeInstruction::Size(opCode); 176 nativePcOffsetTable.AddPosition(static_cast<uint64_t>(GetBaselineAssembler().GetBufferSize())); 177 } 178} 179 180bool BaselineCompiler::CollectMemoryCodeInfos(MachineCodeDesc &codeDesc) 181{ 182 codeDesc.codeAddr = reinterpret_cast<uint64_t>(GetBaselineAssembler().GetBuffer()); 183 codeDesc.codeSize = GetBaselineAssembler().GetBufferSize(); 184 codeDesc.codeType = MachineCodeType::BASELINE_CODE; 185 codeDesc.stackMapOrOffsetTableAddr = reinterpret_cast<uint64_t>(nativePcOffsetTable.GetData()); 186 codeDesc.stackMapOrOffsetTableSize = nativePcOffsetTable.GetSize(); 187#ifdef JIT_ENABLE_CODE_SIGN 188 codeDesc.codeSigner = 0; 189 JitSignCode *singleton = JitSignCode::GetInstance(); 190 if (singleton->GetCodeSigner() != nullptr) { 191 LOG_INST() << "In CollectMemoryCodeInfos, signer = " << singleton->GetCodeSigner(); 192 LOG_INST() << " Kind = " << singleton->GetKind(); 193 codeDesc.codeSigner = reinterpret_cast<uintptr_t>(singleton->GetCodeSigner()); 194 } 195#endif 196 if (Jit::GetInstance()->IsEnableJitFort() && Jit::GetInstance()->IsEnableAsyncCopyToFort() && 197 JitCompiler::AllocFromFortAndCopy(*compilationEnv, codeDesc) == false) { 198 return false; 199 } 200 return true; 201} 202 203void BaselineCompiler::GetJumpToOffsets(const uint8_t *start, const uint8_t *end, 204 std::unordered_set<size_t> &jumpToOffsets) const 205{ 206 size_t offset = 0; 207 while (start < end) { 208 auto opCode = Bytecodes::GetOpcode(start); 209 switch (opCode) { 210 case EcmaOpcode::JEQZ_IMM8: 211 case EcmaOpcode::JNEZ_IMM8: 212 case EcmaOpcode::JMP_IMM8: { 213 int8_t jumpOffset = *(start + 1); // 1: get one byte in bytecodes 214 size_t jumpTo = offset + jumpOffset; 215 jumpToOffsets.insert(jumpTo); 216 break; 217 } 218 case EcmaOpcode::JEQZ_IMM16: 219 case EcmaOpcode::JNEZ_IMM16: 220 case EcmaOpcode::JMP_IMM16: { 221 int16_t jumpOffset = *(start + 2); // 2: get two bytes in bytecodes 222 uint16_t tmpValue = static_cast<uint16_t>(jumpOffset) << 8; // 8: left shift 8 bits 223 tmpValue += static_cast<uint8_t>(*(start + 1)); // 1: get one byte in bytecodes 224 size_t jumpTo = offset + static_cast<int16_t>(tmpValue); 225 jumpToOffsets.insert(jumpTo); 226 break; 227 } 228 case EcmaOpcode::JEQZ_IMM32: 229 case EcmaOpcode::JNEZ_IMM32: 230 case EcmaOpcode::JMP_IMM32: { 231 int32_t jumpOffset = *(start + 4); // 4: get four bytes in bytecodes 232 uint32_t tmpValue = static_cast<uint32_t>(jumpOffset) << 8; // 8: left shift 8 bits 233 tmpValue += static_cast<uint8_t>(*(start + 3)); // 3: get three bytes in bytecodes 234 tmpValue <<= 8; // 8: left shift 8 bits 235 tmpValue += static_cast<uint8_t>(*(start + 2)); // 2: get two bytes in bytecodes 236 tmpValue <<= 8; // 8: left shift 8 bits 237 tmpValue += static_cast<uint8_t>(*(start + 1)); // 1: get one byte in bytecodes 238 size_t jumpTo = static_cast<size_t>(static_cast<int32_t>(offset) + static_cast<int32_t>(tmpValue)); 239 jumpToOffsets.insert(jumpTo); 240 break; 241 } 242 default: 243 break; 244 } 245 246 start += BytecodeInstruction::Size(opCode); 247 offset += BytecodeInstruction::Size(opCode); 248 } 249} 250 251// ------- parse bytecodes about reading special variables ------- 252BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDFUNCTION) 253{ 254 (void)bytecodeArray; 255 LOG_INST() << " ldfunction "; 256 257 GetBaselineAssembler().Move(SpecialRegister::ACC_REGISTER, SpecialRegister::FUNC); 258} 259 260BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDNEWTARGET) 261{ 262 (void)bytecodeArray; 263 LOG_INST() << " ldnewtarget "; 264 265 // check hasNewTarget? 266 GetBaselineAssembler().Move(SpecialRegister::ACC_REGISTER, SpecialRegister::NEW_TARGET); 267} 268 269BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDTHIS) 270{ 271 (void)bytecodeArray; 272 LOG_INST() << " ldthis "; 273 274 GetBaselineAssembler().Move(SpecialRegister::ACC_REGISTER, SpecialRegister::THIS_OBJECT); 275} 276 277BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDUNDEFINED) 278{ 279 (void)bytecodeArray; 280 LOG_INST() << " ldundefined " << std::hex << Immediate(JSTaggedValue::VALUE_UNDEFINED).GetValue(); 281 282 GetBaselineAssembler().Move(SpecialRegister::ACC_REGISTER, Immediate(JSTaggedValue::VALUE_UNDEFINED)); 283} 284 285BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDNAN) 286{ 287 (void)bytecodeArray; 288 LOG_INST() << " ldnan " << std::hex << base::NAN_VALUE; 289 290 GetBaselineAssembler().Move(SpecialRegister::ACC_REGISTER, Immediate(JSTaggedValue(base::NAN_VALUE).GetRawData())); 291} 292 293BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDINFINITY) 294{ 295 (void)bytecodeArray; 296 297 LOG_INST() << " ldinfinity " << std::hex << base::POSITIVE_INFINITY; 298 GetBaselineAssembler().Move(SpecialRegister::ACC_REGISTER, Immediate(JSTaggedValue(base::POSITIVE_INFINITY).GetRawData())); 299} 300 301BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDNULL) 302{ 303 (void)bytecodeArray; 304 305 LOG_INST() << " ldnull " << std::hex << Immediate(JSTaggedValue::VALUE_NULL).GetValue(); 306 GetBaselineAssembler().Move(SpecialRegister::ACC_REGISTER, Immediate(JSTaggedValue::VALUE_NULL)); 307} 308 309BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDTRUE) 310{ 311 (void)bytecodeArray; 312 313 LOG_INST() << " ldtrue " << std::hex << Immediate(JSTaggedValue::VALUE_TRUE).GetValue(); 314 GetBaselineAssembler().Move(SpecialRegister::ACC_REGISTER, Immediate(JSTaggedValue::VALUE_TRUE)); 315} 316 317BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDFALSE) 318{ 319 (void)bytecodeArray; 320 321 LOG_INST() << " ldfalse " << std::hex << Immediate(JSTaggedValue::VALUE_FALSE).GetValue(); 322 GetBaselineAssembler().Move(SpecialRegister::ACC_REGISTER, Immediate(JSTaggedValue::VALUE_FALSE)); 323} 324 325BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDHOLE) 326{ 327 (void)bytecodeArray; 328 329 LOG_INST() << " ldhole " << std::hex << Immediate(JSTaggedValue::VALUE_HOLE).GetValue(); 330 GetBaselineAssembler().Move(SpecialRegister::ACC_REGISTER, Immediate(JSTaggedValue::VALUE_HOLE)); 331} 332 333BYTECODE_BASELINE_HANDLER_IMPLEMENT(NEWLEXENV_IMM8) 334{ 335 uint8_t numVars = READ_INST_8_0(); 336 337 auto *thread = vm->GetAssociatedJSThread(); 338 Address builtinAddress = 339 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineNewlexenvImm8); 340 LOG_INST() << " BaselineNewlexenvImm8 Address: " << std::hex << builtinAddress; 341 LOG_INST() << " numVars: " << static_cast<int32_t>(numVars); 342 343 std::vector<BaselineParameter> parameters; 344 parameters.emplace_back(BaselineSpecialParameter::GLUE); 345 parameters.emplace_back(BaselineSpecialParameter::ACC); 346 parameters.emplace_back(static_cast<int32_t>(numVars)); 347 parameters.emplace_back(BaselineSpecialParameter::SP); 348 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 349 GetBaselineAssembler().SaveResultIntoAcc(); 350} 351 352BYTECODE_BASELINE_HANDLER_IMPLEMENT(NEWLEXENVWITHNAME_IMM8_ID16) 353{ 354 uint8_t numVars = READ_INST_8_0(); 355 int16_t literalId = READ_INST_16_1(); 356 357 auto *thread = vm->GetAssociatedJSThread(); 358 Address builtinAddress = 359 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineNewlexenvwithnameImm8Id16); 360 LOG_INST() << " BaselineNewlexenvwithnameImm8Id16 Address: " << std::hex << builtinAddress; 361 LOG_INST() << " numVars: " << static_cast<int16_t>(numVars); 362 LOG_INST() << " literalId: " << literalId; 363 364 std::vector<BaselineParameter> parameters; 365 parameters.emplace_back(BaselineSpecialParameter::GLUE); 366 parameters.emplace_back(BaselineSpecialParameter::SP); 367 parameters.emplace_back(BaselineSpecialParameter::ACC); 368 parameters.emplace_back(static_cast<int16_t>(numVars)); 369 parameters.emplace_back(literalId); 370 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 371 GetBaselineAssembler().SaveResultIntoAcc(); 372} 373 374BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDLEXVAR_IMM4_IMM4) 375{ 376 uint8_t level = static_cast<uint8_t>(READ_INST_4_0()); 377 uint8_t slot = static_cast<uint8_t>(READ_INST_4_1()); 378 379 auto *thread = vm->GetAssociatedJSThread(); 380 Address builtinAddress = 381 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdlexvarImm4Imm4); 382 LOG_INST() << " BaselineLdlexvarImm4Imm4 Address: " << std::hex << builtinAddress; 383 LOG_INST() << " level: " << static_cast<int32_t>(level); 384 LOG_INST() << " solt: " << static_cast<int32_t>(slot); 385 386 std::vector<BaselineParameter> parameters; 387 parameters.emplace_back(BaselineSpecialParameter::SP); 388 parameters.emplace_back(static_cast<int32_t>(level)); 389 parameters.emplace_back(static_cast<int32_t>(slot)); 390 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 391 GetBaselineAssembler().SaveResultIntoAcc(); 392} 393 394BYTECODE_BASELINE_HANDLER_IMPLEMENT(STLEXVAR_IMM4_IMM4) 395{ 396 uint8_t level = static_cast<uint8_t>(READ_INST_4_0()); 397 uint8_t slot = static_cast<uint8_t>(READ_INST_4_1()); 398 399 auto *thread = vm->GetAssociatedJSThread(); 400 Address builtinAddress = 401 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStlexvarImm4Imm4); 402 LOG_INST() << " BaselineStlexvarImm4Imm4 Address: " << std::hex << builtinAddress; 403 LOG_INST() << " level: " << static_cast<int32_t>(level); 404 LOG_INST() << " solt: " << static_cast<int32_t>(slot); 405 406 std::vector<BaselineParameter> parameters; 407 parameters.emplace_back(BaselineSpecialParameter::GLUE); 408 parameters.emplace_back(BaselineSpecialParameter::SP); 409 parameters.emplace_back(BaselineSpecialParameter::ACC); 410 parameters.emplace_back(static_cast<int32_t>(level)); 411 parameters.emplace_back(static_cast<int32_t>(slot)); 412 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 413} 414 415BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDLEXVAR_IMM8_IMM8) 416{ 417 uint8_t level = READ_INST_8_0(); 418 uint8_t slot = READ_INST_8_1(); 419 420 auto *thread = vm->GetAssociatedJSThread(); 421 Address builtinAddress = 422 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdlexvarImm8Imm8); 423 LOG_INST() << " BaselineLdlexvarImm8Imm8 Address: " << std::hex << builtinAddress; 424 LOG_INST() << " level: " << static_cast<int32_t>(level); 425 LOG_INST() << " solt: " << static_cast<int32_t>(slot); 426 427 std::vector<BaselineParameter> parameters; 428 parameters.emplace_back(static_cast<int32_t>(level)); 429 parameters.emplace_back(static_cast<int32_t>(slot)); 430 parameters.emplace_back(BaselineSpecialParameter::SP); 431 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 432 GetBaselineAssembler().SaveResultIntoAcc(); 433} 434 435BYTECODE_BASELINE_HANDLER_IMPLEMENT(STLEXVAR_IMM8_IMM8) 436{ 437 uint8_t level = READ_INST_8_0(); 438 uint8_t slot = READ_INST_8_1(); 439 440 auto *thread = vm->GetAssociatedJSThread(); 441 Address builtinAddress = 442 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStlexvarImm8Imm8); 443 LOG_INST() << " BaselineStlexvarImm8Imm8 Address: " << std::hex << builtinAddress; 444 LOG_INST() << " level: " << static_cast<int32_t>(level); 445 LOG_INST() << " solt: " << static_cast<int32_t>(slot); 446 447 std::vector<BaselineParameter> parameters; 448 parameters.emplace_back(BaselineSpecialParameter::GLUE); 449 parameters.emplace_back(BaselineSpecialParameter::ACC); 450 parameters.emplace_back(static_cast<int32_t>(level)); 451 parameters.emplace_back(static_cast<int32_t>(slot)); 452 parameters.emplace_back(BaselineSpecialParameter::SP); 453 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 454} 455 456BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDBIGINT_ID16) 457{ 458 uint16_t stringId = READ_INST_16_0(); 459 460 auto *thread = vm->GetAssociatedJSThread(); 461 Address builtinAddress = 462 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdbigintId16); 463 LOG_INST() << " BaselineLdbigintId16 Address: " << std::hex << builtinAddress; 464 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 465 466 std::vector<BaselineParameter> parameters; 467 parameters.emplace_back(BaselineSpecialParameter::GLUE); 468 parameters.emplace_back(BaselineSpecialParameter::SP); 469 parameters.emplace_back(static_cast<int32_t>(stringId)); 470 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 471 GetBaselineAssembler().SaveResultIntoAcc(); 472} 473// ------- End parse bytecodes about reading special variables ------- 474 475// ------- parse bytecodes about reading and storing general variables ------- 476BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDSYMBOL) 477{ 478 (void)bytecodeArray; 479 480 auto *thread = vm->GetAssociatedJSThread(); 481 Address builtinAddress = 482 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdsymbol); 483 LOG_INST() << " BaselineLdsymbol Address: " << std::hex << builtinAddress; 484 485 std::vector<BaselineParameter> parameters; 486 parameters.emplace_back(BaselineSpecialParameter::GLUE); 487 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 488 GetBaselineAssembler().SaveResultIntoAcc(); 489} 490 491BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDGLOBAL) 492{ 493 (void)bytecodeArray; 494 495 auto *thread = vm->GetAssociatedJSThread(); 496 Address builtinAddress = 497 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdglobal); 498 LOG_INST() << " BaselineLdglobal Address: " << std::hex << builtinAddress; 499 500 std::vector<BaselineParameter> parameters; 501 parameters.emplace_back(BaselineSpecialParameter::GLUE); 502 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 503 GetBaselineAssembler().SaveResultIntoAcc(); 504} 505 506BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDGLOBALVAR_IMM16_ID16) 507{ 508 uint16_t slotId = READ_INST_16_0(); 509 uint16_t stringId = READ_INST_16_2(); 510 511 auto *thread = vm->GetAssociatedJSThread(); 512 Address builtinAddress = 513 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdglobalvarImm16Id16); 514 LOG_INST() << " BaselineLdglobalvarImm16Id16 Address: " << std::hex << builtinAddress; 515 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 516 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 517 518 std::vector<BaselineParameter> parameters; 519 parameters.emplace_back(BaselineSpecialParameter::GLUE); 520 parameters.emplace_back(BaselineSpecialParameter::SP); 521 parameters.emplace_back(static_cast<int32_t>(slotId)); 522 parameters.emplace_back(static_cast<int32_t>(stringId)); 523 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 524 GetBaselineAssembler().SaveResultIntoAcc(); 525} 526 527BYTECODE_BASELINE_HANDLER_IMPLEMENT(STGLOBALVAR_IMM16_ID16) 528{ 529 uint16_t slotId = READ_INST_16_0(); 530 uint16_t stringId = READ_INST_16_2(); 531 532 auto *thread = vm->GetAssociatedJSThread(); 533 Address builtinAddress = 534 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStglobalvarImm16Id16); 535 LOG_INST() << " BaselineStglobalvarImm16Id16 Address: " << std::hex << builtinAddress; 536 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 537 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 538 539 std::vector<BaselineParameter> parameters; 540 parameters.emplace_back(BaselineSpecialParameter::GLUE); 541 parameters.emplace_back(BaselineSpecialParameter::SP); 542 parameters.emplace_back(BaselineSpecialParameter::ACC); 543 parameters.emplace_back(static_cast<int32_t>(slotId)); 544 parameters.emplace_back(static_cast<int32_t>(stringId)); 545 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 546} 547 548BYTECODE_BASELINE_HANDLER_IMPLEMENT(TRYLDGLOBALBYNAME_IMM8_ID16) 549{ 550 uint8_t slotId = READ_INST_8_0(); 551 uint16_t stringId = READ_INST_16_1(); 552 553 auto *thread = vm->GetAssociatedJSThread(); 554 Address builtinAddress = 555 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineTryLdGLobalByNameImm8ID16); 556 LOG_INST() << " BaselineTryLdGLobalByNameImm8ID16 Address: " << std::hex << builtinAddress; 557 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 558 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 559 560 std::vector<BaselineParameter> parameters; 561 parameters.emplace_back(BaselineSpecialParameter::GLUE); 562 parameters.emplace_back(BaselineSpecialParameter::SP); 563 parameters.emplace_back(static_cast<int32_t>(stringId)); 564 parameters.emplace_back(static_cast<int32_t>(slotId)); 565 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 566 GetBaselineAssembler().SaveResultIntoAcc(); 567} 568 569BYTECODE_BASELINE_HANDLER_IMPLEMENT(TRYSTGLOBALBYNAME_IMM8_ID16) 570{ 571 uint8_t slotId = READ_INST_8_0(); 572 uint16_t stringId = READ_INST_16_1(); 573 574 auto *thread = vm->GetAssociatedJSThread(); 575 Address builtinAddress = 576 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineTrystglobalbynameImm8Id16); 577 LOG_INST() << " BaselineTrystglobalbynameImm8Id16 Address: " << std::hex << builtinAddress; 578 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 579 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 580 581 std::vector<BaselineParameter> parameters; 582 parameters.emplace_back(BaselineSpecialParameter::GLUE); 583 parameters.emplace_back(BaselineSpecialParameter::SP); 584 parameters.emplace_back(static_cast<int32_t>(stringId)); 585 parameters.emplace_back(static_cast<int32_t>(slotId)); 586 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 587} 588 589BYTECODE_BASELINE_HANDLER_IMPLEMENT(TRYLDGLOBALBYNAME_IMM16_ID16) 590{ 591 uint16_t slotId = READ_INST_16_0(); 592 uint16_t stringId = READ_INST_16_2(); 593 594 auto *thread = vm->GetAssociatedJSThread(); 595 Address builtinAddress = 596 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineTryldglobalbynameImm16Id16); 597 LOG_INST() << " BaselineTryldglobalbynameImm16Id16 Address: " << std::hex << builtinAddress; 598 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 599 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 600 601 std::vector<BaselineParameter> parameters; 602 parameters.emplace_back(BaselineSpecialParameter::GLUE); 603 parameters.emplace_back(BaselineSpecialParameter::SP); 604 parameters.emplace_back(static_cast<int32_t>(slotId)); 605 parameters.emplace_back(static_cast<int32_t>(stringId)); 606 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 607 GetBaselineAssembler().SaveResultIntoAcc(); 608} 609 610BYTECODE_BASELINE_HANDLER_IMPLEMENT(TRYSTGLOBALBYNAME_IMM16_ID16) 611{ 612 uint16_t slotId = READ_INST_16_0(); 613 uint16_t stringId = READ_INST_16_2(); 614 615 auto *thread = vm->GetAssociatedJSThread(); 616 Address builtinAddress = 617 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineTrystglobalbynameImm16Id16); 618 LOG_INST() << " BaselineTrystglobalbynameImm16Id16 Address: " << std::hex << builtinAddress; 619 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 620 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 621 622 std::vector<BaselineParameter> parameters; 623 parameters.emplace_back(BaselineSpecialParameter::GLUE); 624 parameters.emplace_back(BaselineSpecialParameter::SP); 625 parameters.emplace_back(static_cast<int32_t>(slotId)); 626 parameters.emplace_back(static_cast<int32_t>(stringId)); 627 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 628} 629 630BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDOBJBYNAME_IMM8_ID16) 631{ 632 uint8_t slotId = READ_INST_8_0(); 633 uint16_t stringId = READ_INST_16_1(); 634 635 auto *thread = vm->GetAssociatedJSThread(); 636 Address builtinAddress = 637 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdobjbynameImm8Id16); 638 LOG_INST() << " BaselineLdobjbynameImm8Id16 Address: " << std::hex << builtinAddress; 639 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 640 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 641 642 std::vector<BaselineParameter> parameters; 643 parameters.emplace_back(BaselineSpecialParameter::GLUE); 644 parameters.emplace_back(BaselineSpecialParameter::SP); 645 parameters.emplace_back(static_cast<int32_t>(slotId)); 646 parameters.emplace_back(static_cast<int32_t>(stringId)); 647 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 648 GetBaselineAssembler().SaveResultIntoAcc(); 649} 650 651BYTECODE_BASELINE_HANDLER_IMPLEMENT(STOBJBYNAME_IMM8_ID16_V8) 652{ 653 uint8_t slotId = READ_INST_8_0(); 654 uint16_t stringId = READ_INST_16_1(); 655 int8_t vObjId = READ_INST_8_3(); 656 657 auto *thread = vm->GetAssociatedJSThread(); 658 Address builtinAddress = 659 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStobjbynameImm8Id16V8); 660 LOG_INST() << " BaselineStobjbynameImm8Id16V8 Address: " << std::hex << builtinAddress; 661 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 662 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 663 664 std::vector<BaselineParameter> parameters; 665 parameters.emplace_back(BaselineSpecialParameter::GLUE); 666 parameters.emplace_back(BaselineSpecialParameter::SP); 667 parameters.emplace_back(static_cast<int32_t>(slotId)); 668 parameters.emplace_back(static_cast<int32_t>(stringId)); 669 parameters.emplace_back(VirtualRegister(vObjId)); 670 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 671} 672 673BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDOBJBYNAME_IMM16_ID16) 674{ 675 uint16_t slotId = READ_INST_16_0(); 676 uint16_t stringId = READ_INST_16_2(); 677 678 auto *thread = vm->GetAssociatedJSThread(); 679 Address builtinAddress = 680 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdobjbynameImm16Id16); 681 LOG_INST() << " BaselineLdobjbynameImm16Id16 Address: " << std::hex << builtinAddress; 682 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 683 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 684 685 std::vector<BaselineParameter> parameters; 686 parameters.emplace_back(BaselineSpecialParameter::GLUE); 687 parameters.emplace_back(BaselineSpecialParameter::SP); 688 parameters.emplace_back(static_cast<int32_t>(slotId)); 689 parameters.emplace_back(static_cast<int32_t>(stringId)); 690 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 691 GetBaselineAssembler().SaveResultIntoAcc(); 692} 693 694BYTECODE_BASELINE_HANDLER_IMPLEMENT(STOBJBYNAME_IMM16_ID16_V8) 695{ 696 uint16_t slotId = READ_INST_16_0(); 697 uint16_t stringId = READ_INST_16_2(); 698 uint8_t vObjId = READ_INST_8_4(); 699 700 auto *thread = vm->GetAssociatedJSThread(); 701 Address builtinAddress = 702 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStobjbynameImm16Id16V8); 703 LOG_INST() << " BaselineStobjbynameImm16Id16V8 Address: " << std::hex << builtinAddress; 704 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 705 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 706 707 std::vector<BaselineParameter> parameters; 708 parameters.emplace_back(BaselineSpecialParameter::GLUE); 709 parameters.emplace_back(BaselineSpecialParameter::SP); 710 parameters.emplace_back(static_cast<int32_t>(slotId)); 711 parameters.emplace_back(static_cast<int32_t>(stringId)); 712 parameters.emplace_back(VirtualRegister(vObjId)); 713 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 714} 715 716BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDOBJBYVALUE_IMM8_V8) 717{ 718 uint8_t slotId = READ_INST_8_0(); 719 uint8_t vObjId = READ_INST_8_1(); 720 721 auto *thread = vm->GetAssociatedJSThread(); 722 Address builtinAddress = 723 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdobjbyvalueImm8V8); 724 LOG_INST() << " BaselineLdobjbyvalueImm8V8 Address: " << std::hex << builtinAddress; 725 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 726 727 std::vector<BaselineParameter> parameters; 728 parameters.emplace_back(BaselineSpecialParameter::GLUE); 729 parameters.emplace_back(BaselineSpecialParameter::SP); 730 parameters.emplace_back(VirtualRegister(vObjId)); 731 parameters.emplace_back(static_cast<int32_t>(slotId)); 732 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 733 GetBaselineAssembler().SaveResultIntoAcc(); 734} 735 736BYTECODE_BASELINE_HANDLER_IMPLEMENT(STOBJBYVALUE_IMM8_V8_V8) 737{ 738 uint8_t slotId = READ_INST_8_0(); 739 uint8_t vObjId = READ_INST_8_1(); 740 uint8_t vKeyId = READ_INST_8_2(); 741 742 auto *thread = vm->GetAssociatedJSThread(); 743 Address builtinAddress = 744 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStobjbyvalueImm8V8V8); 745 LOG_INST() << " BaselineStobjbyvalueImm8V8V8 Address: " << std::hex << builtinAddress; 746 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 747 748 std::vector<BaselineParameter> parameters; 749 parameters.emplace_back(BaselineSpecialParameter::GLUE); 750 parameters.emplace_back(BaselineSpecialParameter::SP); 751 parameters.emplace_back(VirtualRegister(vObjId)); 752 parameters.emplace_back(static_cast<int32_t>(slotId)); 753 parameters.emplace_back(VirtualRegister(vKeyId)); 754 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 755} 756 757BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDOBJBYVALUE_IMM16_V8) 758{ 759 uint16_t slotId = READ_INST_16_0(); 760 uint8_t vObjId = READ_INST_8_2(); 761 762 auto *thread = vm->GetAssociatedJSThread(); 763 Address builtinAddress = 764 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdobjbyvalueImm16V8); 765 LOG_INST() << " BaselineLdobjbyvalueImm16V8 Address: " << std::hex << builtinAddress; 766 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 767 768 std::vector<BaselineParameter> parameters; 769 parameters.emplace_back(BaselineSpecialParameter::GLUE); 770 parameters.emplace_back(BaselineSpecialParameter::SP); 771 parameters.emplace_back(VirtualRegister(vObjId)); 772 parameters.emplace_back(static_cast<int32_t>(slotId)); 773 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 774 GetBaselineAssembler().SaveResultIntoAcc(); 775} 776 777BYTECODE_BASELINE_HANDLER_IMPLEMENT(STOBJBYVALUE_IMM16_V8_V8) 778{ 779 uint16_t slotId = READ_INST_16_0(); 780 int8_t vObjId = READ_INST_8_2(); 781 int8_t vKeyId = READ_INST_8_3(); 782 783 auto *thread = vm->GetAssociatedJSThread(); 784 Address builtinAddress = 785 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStobjbyvalueImm16V8V8); 786 LOG_INST() << " BaselineStobjbyvalueImm16V8V8 Address: " << std::hex << builtinAddress; 787 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 788 789 std::vector<BaselineParameter> parameters; 790 parameters.emplace_back(BaselineSpecialParameter::GLUE); 791 parameters.emplace_back(BaselineSpecialParameter::SP); 792 parameters.emplace_back(VirtualRegister(vObjId)); 793 parameters.emplace_back(static_cast<int32_t>(slotId)); 794 parameters.emplace_back(VirtualRegister(vKeyId)); 795 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 796} 797 798BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDOBJBYINDEX_IMM8_IMM16) 799{ 800 uint8_t slotId = READ_INST_8_0(); 801 uint16_t index = READ_INST_16_1(); 802 803 auto *thread = vm->GetAssociatedJSThread(); 804 Address builtinAddress = 805 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdobjbyindexImm8Imm16); 806 LOG_INST() << " BaselineLdobjbyindexImm8Imm16 Address: " << std::hex << builtinAddress; 807 LOG_INST() << " index: " << static_cast<int32_t>(index); 808 809 std::vector<BaselineParameter> parameters; 810 parameters.emplace_back(BaselineSpecialParameter::GLUE); 811 parameters.emplace_back(BaselineSpecialParameter::SP); 812 parameters.emplace_back(static_cast<int32_t>(index)); 813 parameters.emplace_back(static_cast<int32_t>(slotId)); 814 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 815 GetBaselineAssembler().SaveResultIntoAcc(); 816} 817 818BYTECODE_BASELINE_HANDLER_IMPLEMENT(STOBJBYINDEX_IMM8_V8_IMM16) 819{ 820 int8_t vObjId = READ_INST_8_1(); 821 uint16_t index = READ_INST_16_2(); 822 823 auto *thread = vm->GetAssociatedJSThread(); 824 Address builtinAddress = 825 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStobjbyindexImm8V8Imm16); 826 LOG_INST() << " BaselineStobjbyindexImm8V8Imm16 Address: " << std::hex << builtinAddress; 827 LOG_INST() << " index: " << static_cast<int32_t>(index); 828 829 std::vector<BaselineParameter> parameters; 830 parameters.emplace_back(BaselineSpecialParameter::GLUE); 831 parameters.emplace_back(BaselineSpecialParameter::SP); 832 parameters.emplace_back(VirtualRegister(vObjId)); 833 parameters.emplace_back(static_cast<int32_t>(index)); 834 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 835} 836 837BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDOBJBYINDEX_IMM16_IMM16) 838{ 839 uint16_t slotId = READ_INST_16_0(); 840 uint16_t index = READ_INST_16_2(); 841 842 auto *thread = vm->GetAssociatedJSThread(); 843 Address builtinAddress = 844 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdobjbyindexImm16Imm16); 845 LOG_INST() << " BaselineLdobjbyindexImm16Imm16 Address: " << std::hex << builtinAddress; 846 LOG_INST() << " index: " << static_cast<int32_t>(index); 847 848 std::vector<BaselineParameter> parameters; 849 parameters.emplace_back(BaselineSpecialParameter::GLUE); 850 parameters.emplace_back(BaselineSpecialParameter::SP); 851 parameters.emplace_back(static_cast<int32_t>(index)); 852 parameters.emplace_back(static_cast<int32_t>(slotId)); 853 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 854 GetBaselineAssembler().SaveResultIntoAcc(); 855} 856 857BYTECODE_BASELINE_HANDLER_IMPLEMENT(STOBJBYINDEX_IMM16_V8_IMM16) 858{ 859 uint16_t slotId = READ_INST_16_0(); 860 uint8_t vObjId = READ_INST_8_2(); 861 uint16_t index = READ_INST_16_3(); 862 863 auto *thread = vm->GetAssociatedJSThread(); 864 Address builtinAddress = 865 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStobjbyindexImm16V8Imm16); 866 LOG_INST() << " BaselineStobjbyindexImm16V8Imm16 Address: " << std::hex << builtinAddress; 867 LOG_INST() << " index: " << static_cast<int32_t>(index); 868 869 std::vector<BaselineParameter> parameters; 870 parameters.emplace_back(BaselineSpecialParameter::GLUE); 871 parameters.emplace_back(BaselineSpecialParameter::SP); 872 parameters.emplace_back(VirtualRegister(vObjId)); 873 parameters.emplace_back(static_cast<int32_t>(index)); 874 parameters.emplace_back(static_cast<int32_t>(slotId)); 875 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 876} 877 878BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDTHISBYNAME_IMM8_ID16) 879{ 880 uint8_t slotId = READ_INST_8_0(); 881 uint16_t stringId = READ_INST_16_1(); 882 883 auto *thread = vm->GetAssociatedJSThread(); 884 Address builtinAddress = 885 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdthisbynameImm8Id16); 886 LOG_INST() << " BaselineLdthisbynameImm8Id16 Address: " << std::hex << builtinAddress; 887 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 888 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 889 890 std::vector<BaselineParameter> parameters; 891 parameters.emplace_back(BaselineSpecialParameter::GLUE); 892 parameters.emplace_back(BaselineSpecialParameter::SP); 893 parameters.emplace_back(static_cast<int32_t>(stringId)); 894 parameters.emplace_back(static_cast<int32_t>(slotId)); 895 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 896 GetBaselineAssembler().SaveResultIntoAcc(); 897} 898 899BYTECODE_BASELINE_HANDLER_IMPLEMENT(STTHISBYNAME_IMM8_ID16) 900{ 901 uint8_t slotId = READ_INST_8_0(); 902 uint16_t stringId = READ_INST_16_1(); 903 904 auto *thread = vm->GetAssociatedJSThread(); 905 Address builtinAddress = 906 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStthisbynameImm8Id16); 907 LOG_INST() << " BaselineStthisbynameImm8Id16 Address: " << std::hex << builtinAddress; 908 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 909 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 910 911 std::vector<BaselineParameter> parameters; 912 parameters.emplace_back(BaselineSpecialParameter::GLUE); 913 parameters.emplace_back(BaselineSpecialParameter::SP); 914 parameters.emplace_back(static_cast<int32_t>(stringId)); 915 parameters.emplace_back(static_cast<int32_t>(slotId)); 916 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 917} 918 919BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDTHISBYNAME_IMM16_ID16) 920{ 921 uint16_t slotId = READ_INST_16_0(); 922 uint16_t stringId = READ_INST_16_2(); 923 924 auto *thread = vm->GetAssociatedJSThread(); 925 Address builtinAddress = 926 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdthisbynameImm16Id16); 927 LOG_INST() << " BaselineLdthisbynameImm16Id16 Address: " << std::hex << builtinAddress; 928 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 929 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 930 931 std::vector<BaselineParameter> parameters; 932 parameters.emplace_back(BaselineSpecialParameter::GLUE); 933 parameters.emplace_back(BaselineSpecialParameter::SP); 934 parameters.emplace_back(static_cast<int32_t>(stringId)); 935 parameters.emplace_back(static_cast<int32_t>(slotId)); 936 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 937 GetBaselineAssembler().SaveResultIntoAcc(); 938} 939 940BYTECODE_BASELINE_HANDLER_IMPLEMENT(STTHISBYNAME_IMM16_ID16) 941{ 942 uint16_t slotId = READ_INST_16_0(); 943 uint16_t stringId = READ_INST_16_2(); 944 945 auto *thread = vm->GetAssociatedJSThread(); 946 Address builtinAddress = 947 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStthisbynameImm16Id16); 948 LOG_INST() << " BaselineStthisbynameImm16Id16 Address: " << std::hex << builtinAddress; 949 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 950 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 951 952 std::vector<BaselineParameter> parameters; 953 parameters.emplace_back(BaselineSpecialParameter::GLUE); 954 parameters.emplace_back(BaselineSpecialParameter::SP); 955 parameters.emplace_back(static_cast<int32_t>(stringId)); 956 parameters.emplace_back(static_cast<int32_t>(slotId)); 957 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 958} 959 960BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDTHISBYVALUE_IMM8) 961{ 962 uint8_t slotId = READ_INST_8_0(); 963 964 auto *thread = vm->GetAssociatedJSThread(); 965 Address builtinAddress = 966 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdthisbyvalueImm8); 967 LOG_INST() << " BaselineLdthisbyvalueImm8 Address: " << std::hex << builtinAddress; 968 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 969 970 std::vector<BaselineParameter> parameters; 971 parameters.emplace_back(BaselineSpecialParameter::GLUE); 972 parameters.emplace_back(BaselineSpecialParameter::SP); 973 parameters.emplace_back(static_cast<int32_t>(slotId)); 974 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 975 GetBaselineAssembler().SaveResultIntoAcc(); 976} 977 978BYTECODE_BASELINE_HANDLER_IMPLEMENT(STTHISBYVALUE_IMM8_V8) 979{ 980 uint8_t slotId = READ_INST_8_0(); 981 uint8_t propKey = READ_INST_8_1(); 982 983 auto *thread = vm->GetAssociatedJSThread(); 984 Address builtinAddress = 985 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStthisbyvalueImm8V8); 986 LOG_INST() << " BaselineStthisbyvalueImm8V8 Address: " << std::hex << builtinAddress; 987 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 988 989 std::vector<BaselineParameter> parameters; 990 parameters.emplace_back(BaselineSpecialParameter::GLUE); 991 parameters.emplace_back(BaselineSpecialParameter::SP); 992 parameters.emplace_back(static_cast<int32_t>(slotId)); 993 parameters.emplace_back(VirtualRegister(propKey)); 994 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 995} 996 997BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDTHISBYVALUE_IMM16) 998{ 999 uint16_t slotId = READ_INST_16_0(); 1000 1001 auto *thread = vm->GetAssociatedJSThread(); 1002 Address builtinAddress = 1003 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdthisbyvalueImm16); 1004 LOG_INST() << " BaselineLdthisbyvalueImm16 Address: " << std::hex << builtinAddress; 1005 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 1006 1007 std::vector<BaselineParameter> parameters; 1008 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1009 parameters.emplace_back(BaselineSpecialParameter::SP); 1010 parameters.emplace_back(static_cast<int32_t>(slotId)); 1011 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1012 GetBaselineAssembler().SaveResultIntoAcc(); 1013} 1014 1015BYTECODE_BASELINE_HANDLER_IMPLEMENT(STTHISBYVALUE_IMM16_V8) 1016{ 1017 uint16_t slotId = READ_INST_16_0(); 1018 uint8_t propKey = READ_INST_8_1(); 1019 1020 auto *thread = vm->GetAssociatedJSThread(); 1021 Address builtinAddress = 1022 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStthisbyvalueImm16V8); 1023 LOG_INST() << " BaselineStthisbyvalueImm16V8 Address: " << std::hex << builtinAddress; 1024 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 1025 1026 std::vector<BaselineParameter> parameters; 1027 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1028 parameters.emplace_back(BaselineSpecialParameter::SP); 1029 parameters.emplace_back(static_cast<int32_t>(slotId)); 1030 parameters.emplace_back(VirtualRegister(propKey)); 1031 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1032} 1033 1034BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDSUPERBYVALUE_IMM8_V8) 1035{ 1036 int8_t object = READ_INST_8_1(); 1037 1038 auto *thread = vm->GetAssociatedJSThread(); 1039 Address builtinAddress = 1040 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdsuperbyvalueImm8V8); 1041 LOG_INST() << " BaselineLdsuperbyvalueImm8V8 Address: " << std::hex << builtinAddress; 1042 1043 std::vector<BaselineParameter> parameters; 1044 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1045 parameters.emplace_back(BaselineSpecialParameter::SP); 1046 parameters.emplace_back(BaselineSpecialParameter::ACC); 1047 parameters.emplace_back(VirtualRegister(object)); 1048 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1049 GetBaselineAssembler().SaveResultIntoAcc(); 1050} 1051 1052BYTECODE_BASELINE_HANDLER_IMPLEMENT(STSUPERBYVALUE_IMM8_V8_V8) 1053{ 1054 int8_t object = READ_INST_8_1(); 1055 int8_t propKey = READ_INST_8_2(); 1056 1057 auto *thread = vm->GetAssociatedJSThread(); 1058 Address builtinAddress = 1059 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStsuperbyvalueImm8V8V8); 1060 LOG_INST() << " BaselineStsuperbyvalueImm8V8V8 Address: " << std::hex << builtinAddress; 1061 1062 std::vector<BaselineParameter> parameters; 1063 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1064 parameters.emplace_back(BaselineSpecialParameter::SP); 1065 parameters.emplace_back(VirtualRegister(object)); 1066 parameters.emplace_back(VirtualRegister(propKey)); 1067 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1068} 1069 1070BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDSUPERBYVALUE_IMM16_V8) 1071{ 1072 int8_t object = READ_INST_8_1(); 1073 1074 auto *thread = vm->GetAssociatedJSThread(); 1075 Address builtinAddress = 1076 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdsuperbyvalueImm16V8); 1077 LOG_INST() << " BaselineLdsuperbyvalueImm16V8 Address: " << std::hex << builtinAddress; 1078 1079 std::vector<BaselineParameter> parameters; 1080 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1081 parameters.emplace_back(BaselineSpecialParameter::SP); 1082 parameters.emplace_back(BaselineSpecialParameter::ACC); 1083 parameters.emplace_back(VirtualRegister(object)); 1084 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1085 GetBaselineAssembler().SaveResultIntoAcc(); 1086} 1087 1088BYTECODE_BASELINE_HANDLER_IMPLEMENT(STSUPERBYVALUE_IMM16_V8_V8) 1089{ 1090 int8_t object = READ_INST_8_2(); 1091 int8_t propKey = READ_INST_8_3(); 1092 1093 auto *thread = vm->GetAssociatedJSThread(); 1094 Address builtinAddress = 1095 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStsuperbyvalueImm16V8V8); 1096 LOG_INST() << " BaselineStsuperbyvalueImm16V8V8 Address: " << std::hex << builtinAddress; 1097 1098 std::vector<BaselineParameter> parameters; 1099 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1100 parameters.emplace_back(BaselineSpecialParameter::SP); 1101 parameters.emplace_back(VirtualRegister(object)); 1102 parameters.emplace_back(VirtualRegister(propKey)); 1103 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1104} 1105 1106BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDSUPERBYNAME_IMM8_ID16) 1107{ 1108 uint16_t stringId = READ_INST_16_1(); 1109 1110 auto *thread = vm->GetAssociatedJSThread(); 1111 Address builtinAddress = 1112 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdsuperbynameImm8Id16); 1113 LOG_INST() << " BaselineLdsuperbynameImm8Id16 Address: " << std::hex << builtinAddress; 1114 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 1115 1116 std::vector<BaselineParameter> parameters; 1117 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1118 parameters.emplace_back(BaselineSpecialParameter::SP); 1119 parameters.emplace_back(static_cast<int32_t>(stringId)); 1120 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1121 GetBaselineAssembler().SaveResultIntoAcc(); 1122} 1123 1124BYTECODE_BASELINE_HANDLER_IMPLEMENT(STSUPERBYNAME_IMM8_ID16_V8) 1125{ 1126 uint16_t stringId = READ_INST_16_1(); 1127 int8_t object = READ_INST_8_3(); 1128 1129 auto *thread = vm->GetAssociatedJSThread(); 1130 Address builtinAddress = 1131 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStsuperbynameImm8Id16V8); 1132 LOG_INST() << " BaselineStsuperbynameImm8Id16V8 Address: " << std::hex << builtinAddress; 1133 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 1134 1135 std::vector<BaselineParameter> parameters; 1136 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1137 parameters.emplace_back(BaselineSpecialParameter::SP); 1138 parameters.emplace_back(BaselineSpecialParameter::ACC); 1139 parameters.emplace_back(VirtualRegister(object)); 1140 parameters.emplace_back(static_cast<int32_t>(stringId)); 1141 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1142} 1143 1144BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDSUPERBYNAME_IMM16_ID16) 1145{ 1146 uint16_t stringId = READ_INST_16_2(); 1147 1148 auto *thread = vm->GetAssociatedJSThread(); 1149 Address builtinAddress = 1150 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdsuperbynameImm16Id16); 1151 LOG_INST() << " BaselineLdsuperbynameImm16Id16 Address: " << std::hex << builtinAddress; 1152 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 1153 1154 std::vector<BaselineParameter> parameters; 1155 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1156 parameters.emplace_back(BaselineSpecialParameter::SP); 1157 parameters.emplace_back(static_cast<int32_t>(stringId)); 1158 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1159 GetBaselineAssembler().SaveResultIntoAcc(); 1160} 1161 1162BYTECODE_BASELINE_HANDLER_IMPLEMENT(STSUPERBYNAME_IMM16_ID16_V8) 1163{ 1164 uint16_t stringId = READ_INST_16_2(); 1165 int8_t object = READ_INST_8_4(); 1166 auto *thread = vm->GetAssociatedJSThread(); 1167 Address builtinAddress = 1168 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStsuperbynameImm16Id16V8); 1169 LOG_INST() << " BaselineStsuperbynameImm16Id16V8 Address: " << std::hex << builtinAddress; 1170 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 1171 1172 std::vector<BaselineParameter> parameters; 1173 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1174 parameters.emplace_back(BaselineSpecialParameter::SP); 1175 parameters.emplace_back(BaselineSpecialParameter::ACC); 1176 parameters.emplace_back(VirtualRegister(object)); 1177 parameters.emplace_back(static_cast<int32_t>(stringId)); 1178 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1179} 1180 1181BYTECODE_BASELINE_HANDLER_IMPLEMENT(STA_V8) 1182{ 1183 uint8_t vdst = READ_INST_8_0(); 1184 LOG_INST() << " sta v" << static_cast<int16_t>(vdst); 1185 baselineAssembler.Move(VirtualRegister(vdst), SpecialRegister::ACC_REGISTER); 1186} 1187 1188BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDAI_IMM32) 1189{ 1190 int32_t imm = static_cast<int32_t>(READ_INST_32_0()); 1191 LOG_INST() << " ldai " << static_cast<int16_t>(imm); 1192 uint64_t value = JSTaggedValue(imm).GetRawData(); 1193 baselineAssembler.Move(SpecialRegister::ACC_REGISTER, Immediate(value)); 1194} 1195 1196BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDA_V8) 1197{ 1198 uint8_t vsrc = READ_INST_8_0(); 1199 LOG_INST() << " lda v" << static_cast<int16_t>(vsrc); 1200 baselineAssembler.Move(SpecialRegister::ACC_REGISTER, VirtualRegister(vsrc)); 1201} 1202 1203BYTECODE_BASELINE_HANDLER_IMPLEMENT(STTOGLOBALRECORD_IMM16_ID16) 1204{ 1205 uint16_t stringId = READ_INST_16_2(); 1206 1207 auto *thread = vm->GetAssociatedJSThread(); 1208 Address builtinAddress = 1209 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStToGlobalRecordImm16ID16); 1210 LOG_INST() << " BaselineStToGlobalRecordImm16ID16 Address: " << std::hex << builtinAddress; 1211 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 1212 1213 std::vector<BaselineParameter> parameters; 1214 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1215 parameters.emplace_back(BaselineSpecialParameter::SP); 1216 parameters.emplace_back(BaselineSpecialParameter::ACC); 1217 parameters.emplace_back(static_cast<int32_t>(stringId)); 1218 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1219 GetBaselineAssembler().SaveResultIntoAcc(); 1220} 1221 1222BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDA_STR_ID16) 1223{ 1224 uint16_t stringId = READ_INST_16_0(); 1225 1226 auto *thread = vm->GetAssociatedJSThread(); 1227 Address builtinAddress = 1228 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdaStrID16); 1229 LOG_INST() << " BaselineLdaStrID16 Address: " << std::hex << builtinAddress << std::endl; 1230 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 1231 1232 std::vector<BaselineParameter> parameters; 1233 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1234 parameters.emplace_back(BaselineSpecialParameter::SP); 1235 parameters.emplace_back(static_cast<int32_t>(stringId)); 1236 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1237 GetBaselineAssembler().SaveResultIntoAcc(); 1238} 1239 1240BYTECODE_BASELINE_HANDLER_IMPLEMENT(FLDAI_IMM64) 1241{ 1242 int64_t imm = static_cast<int64_t>(READ_INST_64_0()); 1243 1244 auto *thread = vm->GetAssociatedJSThread(); 1245 Address builtinAddress = 1246 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineFldaiImm64); 1247 LOG_INST() << " BaselineFldaiImm64 Address: " << std::hex << builtinAddress << std::endl; 1248 1249 std::vector<BaselineParameter> parameters; 1250 parameters.emplace_back(imm); 1251 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1252 GetBaselineAssembler().SaveResultIntoAcc(); 1253} 1254 1255BYTECODE_BASELINE_HANDLER_IMPLEMENT(GETUNMAPPEDARGS) 1256{ 1257 (void)bytecodeArray; 1258 1259 auto *thread = vm->GetAssociatedJSThread(); 1260 Address builtinAddress = 1261 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineGetunmappedargs); 1262 LOG_INST() << " BaselineGetunmappedargs Address: " << std::hex << builtinAddress; 1263 1264 std::vector<BaselineParameter> parameters; 1265 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1266 parameters.emplace_back(BaselineSpecialParameter::SP); 1267 parameters.emplace_back(BaselineSpecialParameter::ACC); 1268 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1269 GetBaselineAssembler().SaveResultIntoAcc(); 1270} 1271 1272BYTECODE_BASELINE_HANDLER_IMPLEMENT(GETPROPITERATOR) 1273{ 1274 (void)bytecodeArray; 1275 1276 auto *thread = vm->GetAssociatedJSThread(); 1277 Address builtinAddress = 1278 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineGetpropiterator); 1279 LOG_INST() << " BaselineGetpropiterator Address: " << std::hex << builtinAddress; 1280 1281 std::vector<BaselineParameter> parameters; 1282 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1283 parameters.emplace_back(BaselineSpecialParameter::SP); 1284 parameters.emplace_back(BaselineSpecialParameter::ACC); 1285 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1286 GetBaselineAssembler().SaveResultIntoAcc(); 1287} 1288 1289BYTECODE_BASELINE_HANDLER_IMPLEMENT(GETITERATOR_IMM8) 1290{ 1291 uint8_t slotId = READ_INST_8_0(); 1292 auto *thread = vm->GetAssociatedJSThread(); 1293 Address builtinAddress = 1294 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineGetiteratorImm8); 1295 LOG_INST() << " BaselineGetiteratorImm8 Address: " << std::hex << builtinAddress; 1296 1297 std::vector<BaselineParameter> parameters; 1298 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1299 parameters.emplace_back(BaselineSpecialParameter::SP); 1300 parameters.emplace_back(static_cast<int32_t>(slotId)); 1301 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1302 GetBaselineAssembler().SaveResultIntoAcc(); 1303} 1304 1305BYTECODE_BASELINE_HANDLER_IMPLEMENT(GETITERATOR_IMM16) 1306{ 1307 uint16_t slotId = READ_INST_16_0(); 1308 auto *thread = vm->GetAssociatedJSThread(); 1309 Address builtinAddress = 1310 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineGetiteratorImm16); 1311 LOG_INST() << " BaselineGetiteratorImm16 Address: " << std::hex << builtinAddress; 1312 1313 std::vector<BaselineParameter> parameters; 1314 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1315 parameters.emplace_back(BaselineSpecialParameter::SP); 1316 parameters.emplace_back(static_cast<int32_t>(slotId)); 1317 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1318 GetBaselineAssembler().SaveResultIntoAcc(); 1319} 1320 1321BYTECODE_BASELINE_HANDLER_IMPLEMENT(CLOSEITERATOR_IMM8_V8) 1322{ 1323 uint8_t iter = READ_INST_8_1(); 1324 1325 auto *thread = vm->GetAssociatedJSThread(); 1326 Address builtinAddress = 1327 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCloseiteratorImm8V8); 1328 LOG_INST() << " BaselineCloseiteratorImm8V8 Address: " << std::hex << builtinAddress; 1329 1330 std::vector<BaselineParameter> parameters; 1331 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1332 parameters.emplace_back(BaselineSpecialParameter::SP); 1333 parameters.emplace_back(VirtualRegister(iter)); 1334 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1335 GetBaselineAssembler().SaveResultIntoAcc(); 1336} 1337 1338BYTECODE_BASELINE_HANDLER_IMPLEMENT(CLOSEITERATOR_IMM16_V8) 1339{ 1340 uint8_t iter = READ_INST_8_2(); 1341 1342 auto *thread = vm->GetAssociatedJSThread(); 1343 Address builtinAddress = 1344 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCloseiteratorImm16V8); 1345 LOG_INST() << " BaselineCloseiteratorImm16V8 Address: " << std::hex << builtinAddress; 1346 1347 std::vector<BaselineParameter> parameters; 1348 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1349 parameters.emplace_back(BaselineSpecialParameter::SP); 1350 parameters.emplace_back(VirtualRegister(iter)); 1351 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1352 GetBaselineAssembler().SaveResultIntoAcc(); 1353} 1354 1355BYTECODE_BASELINE_HANDLER_IMPLEMENT(ASYNCGENERATORRESOLVE_V8_V8_V8) 1356{ 1357 uint8_t generator = READ_INST_8_0(); 1358 uint8_t object = READ_INST_8_1(); 1359 uint8_t flag = READ_INST_8_2(); 1360 auto offset = static_cast<int32_t>(bytecodeArray - firstPC); 1361 1362 auto *thread = vm->GetAssociatedJSThread(); 1363 Address builtinAddress = 1364 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineAsyncgeneratorresolveV8V8V8); 1365 LOG_INST() << " BaselineAsyncgeneratorresolveV8V8V8 Address: " << std::hex << builtinAddress; 1366 1367 std::vector<BaselineParameter> parameters; 1368 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1369 parameters.emplace_back(BaselineSpecialParameter::SP); 1370 parameters.emplace_back(offset); 1371 parameters.emplace_back(generator); 1372 parameters.emplace_back(object); 1373 parameters.emplace_back(flag); 1374 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1375 GetBaselineAssembler().SaveResultIntoAcc(); 1376} 1377 1378BYTECODE_BASELINE_HANDLER_IMPLEMENT(CREATEEMPTYOBJECT) 1379{ 1380 uint8_t slotId = READ_INST_8_0(); 1381 1382 auto *thread = vm->GetAssociatedJSThread(); 1383 Address builtinAddress = 1384 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCreateemptyobject); 1385 LOG_INST() << " BaselineCreateemptyobject Address: " << std::hex << builtinAddress; 1386 1387 std::vector<BaselineParameter> parameters; 1388 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1389 parameters.emplace_back(BaselineSpecialParameter::SP); 1390 parameters.emplace_back(static_cast<int32_t>(slotId)); 1391 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1392 GetBaselineAssembler().SaveResultIntoAcc(); 1393} 1394 1395BYTECODE_BASELINE_HANDLER_IMPLEMENT(CREATEEMPTYARRAY_IMM8) 1396{ 1397 uint8_t slotId = READ_INST_8_0(); 1398 auto traceId = static_cast<int32_t>(bytecodeArray - pfHeaderAddr); 1399 1400 auto *thread = vm->GetAssociatedJSThread(); 1401 Address builtinAddress = 1402 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCreateemptyarrayImm8); 1403 LOG_INST() << " BaselineCreateemptyarrayImm8 Address: " << std::hex << builtinAddress; 1404 LOG_INST() << " traceId: " << std::hex << traceId; 1405 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 1406 1407 std::vector<BaselineParameter> parameters; 1408 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1409 parameters.emplace_back(BaselineSpecialParameter::SP); 1410 parameters.emplace_back(traceId); 1411 parameters.emplace_back(static_cast<int32_t>(slotId)); 1412 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1413 GetBaselineAssembler().SaveResultIntoAcc(); 1414} 1415 1416BYTECODE_BASELINE_HANDLER_IMPLEMENT(CREATEEMPTYARRAY_IMM16) 1417{ 1418 uint16_t slotId = READ_INST_16_0(); 1419 auto traceId = static_cast<int32_t>(bytecodeArray - pfHeaderAddr); 1420 1421 auto *thread = vm->GetAssociatedJSThread(); 1422 Address builtinAddress = 1423 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCreateemptyarrayImm16); 1424 LOG_INST() << " BaselineCreateemptyarrayImm16 Address: " << std::hex << builtinAddress; 1425 LOG_INST() << " traceId: " << std::hex << traceId; 1426 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 1427 1428 std::vector<BaselineParameter> parameters; 1429 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1430 parameters.emplace_back(BaselineSpecialParameter::SP); 1431 parameters.emplace_back(traceId); 1432 parameters.emplace_back(static_cast<int32_t>(slotId)); 1433 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1434 GetBaselineAssembler().SaveResultIntoAcc(); 1435} 1436 1437BYTECODE_BASELINE_HANDLER_IMPLEMENT(CREATEGENERATOROBJ_V8) 1438{ 1439 int8_t funcObj = READ_INST_8_0(); 1440 1441 auto *thread = vm->GetAssociatedJSThread(); 1442 Address builtinAddress = 1443 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCreategeneratorobjV8); 1444 LOG_INST() << " BaselineCreategeneratorobjV8 Address: " << std::hex << builtinAddress; 1445 1446 std::vector<BaselineParameter> parameters; 1447 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1448 parameters.emplace_back(BaselineSpecialParameter::SP); 1449 parameters.emplace_back(VirtualRegister(funcObj)); 1450 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1451 GetBaselineAssembler().SaveResultIntoAcc(); 1452} 1453 1454BYTECODE_BASELINE_HANDLER_IMPLEMENT(CREATEITERRESULTOBJ_V8_V8) 1455{ 1456 int8_t object = READ_INST_8_0(); 1457 int8_t flag = READ_INST_8_1(); 1458 1459 auto *thread = vm->GetAssociatedJSThread(); 1460 Address builtinAddress = 1461 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCreateiterresultobjV8V8); 1462 LOG_INST() << " BaselineCreateiterresultobjV8V8 Address: " << std::hex << builtinAddress; 1463 1464 std::vector<BaselineParameter> parameters; 1465 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1466 parameters.emplace_back(BaselineSpecialParameter::SP); 1467 parameters.emplace_back(VirtualRegister(object)); 1468 parameters.emplace_back(VirtualRegister(flag)); 1469 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1470 GetBaselineAssembler().SaveResultIntoAcc(); 1471} 1472 1473BYTECODE_BASELINE_HANDLER_IMPLEMENT(CREATEOBJECTWITHEXCLUDEDKEYS_IMM8_V8_V8) 1474{ 1475 uint8_t numKeys = READ_INST_8_0(); 1476 int8_t object = READ_INST_8_1(); 1477 uint8_t firstKeyIdx = READ_INST_8_2(); 1478 1479 auto *thread = vm->GetAssociatedJSThread(); 1480 Address builtinAddress = 1481 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCreateobjectwithexcludedkeysImm8V8V8); 1482 LOG_INST() << " BaselineCreateobjectwithexcludedkeysImm8V8V8 Address: " << std::hex << builtinAddress; 1483 LOG_INST() << " numKeys: " << static_cast<int16_t>(numKeys); 1484 LOG_INST() << " firstKeyIdx: " << static_cast<int16_t>(firstKeyIdx); 1485 1486 std::vector<BaselineParameter> parameters; 1487 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1488 parameters.emplace_back(BaselineSpecialParameter::SP); 1489 parameters.emplace_back(static_cast<int16_t>(numKeys)); 1490 parameters.emplace_back(VirtualRegister(object)); 1491 parameters.emplace_back(static_cast<int16_t>(firstKeyIdx)); 1492 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1493 GetBaselineAssembler().SaveResultIntoAcc(); 1494} 1495 1496BYTECODE_BASELINE_HANDLER_IMPLEMENT(CREATEOBJECTWITHBUFFER_IMM8_ID16) 1497{ 1498 uint8_t slotId = READ_INST_8_0(); 1499 uint16_t buffer = READ_INST_16_1(); 1500 1501 auto *thread = vm->GetAssociatedJSThread(); 1502 Address builtinAddress = 1503 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCreateobjectwithbufferImm8Id16); 1504 LOG_INST() << " BaselineCreateobjectwithbufferImm8Id16 Address: " << std::hex << builtinAddress; 1505 LOG_INST() << " buffer: " << static_cast<int32_t>(buffer); 1506 1507 std::vector<BaselineParameter> parameters; 1508 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1509 parameters.emplace_back(BaselineSpecialParameter::SP); 1510 parameters.emplace_back(static_cast<int32_t>(buffer)); 1511 parameters.emplace_back(static_cast<int32_t>(slotId)); 1512 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1513 GetBaselineAssembler().SaveResultIntoAcc(); 1514} 1515 1516BYTECODE_BASELINE_HANDLER_IMPLEMENT(CREATEOBJECTWITHBUFFER_IMM16_ID16) 1517{ 1518 uint16_t slotId = READ_INST_16_0(); 1519 uint16_t buffer = READ_INST_16_2(); 1520 1521 auto *thread = vm->GetAssociatedJSThread(); 1522 Address builtinAddress = 1523 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCreateobjectwithbufferImm16Id16); 1524 LOG_INST() << " BaselineCreateobjectwithbufferImm16Id16 Address: " << std::hex << builtinAddress; 1525 LOG_INST() << " buffer: " << static_cast<int32_t>(buffer); 1526 1527 std::vector<BaselineParameter> parameters; 1528 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1529 parameters.emplace_back(BaselineSpecialParameter::SP); 1530 parameters.emplace_back(static_cast<int32_t>(buffer)); 1531 parameters.emplace_back(static_cast<int32_t>(slotId)); 1532 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1533 GetBaselineAssembler().SaveResultIntoAcc(); 1534} 1535 1536BYTECODE_BASELINE_HANDLER_IMPLEMENT(CREATEREGEXPWITHLITERAL_IMM8_ID16_IMM8) 1537{ 1538 uint16_t stringId = READ_INST_16_1(); 1539 int8_t flag = READ_INST_8_3(); 1540 1541 auto *thread = vm->GetAssociatedJSThread(); 1542 Address builtinAddress = 1543 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCreateregexpwithliteralImm8Id16Imm8); 1544 LOG_INST() << " BaselineCreateregexpwithliteralImm8Id16Imm8 Address: " << std::hex << builtinAddress; 1545 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 1546 1547 std::vector<BaselineParameter> parameters; 1548 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1549 parameters.emplace_back(BaselineSpecialParameter::SP); 1550 parameters.emplace_back(static_cast<int32_t>(stringId)); 1551 parameters.emplace_back(flag); 1552 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1553 GetBaselineAssembler().SaveResultIntoAcc(); 1554} 1555 1556BYTECODE_BASELINE_HANDLER_IMPLEMENT(CREATEREGEXPWITHLITERAL_IMM16_ID16_IMM8) 1557{ 1558 uint16_t stringId = READ_INST_16_1(); 1559 int8_t flag = READ_INST_8_4(); 1560 1561 auto *thread = vm->GetAssociatedJSThread(); 1562 Address builtinAddress = 1563 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCreateregexpwithliteralImm16Id16Imm8); 1564 LOG_INST() << " BaselineCreateregexpwithliteralImm16Id16Imm8 Address: " << std::hex << builtinAddress; 1565 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 1566 1567 std::vector<BaselineParameter> parameters; 1568 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1569 parameters.emplace_back(BaselineSpecialParameter::SP); 1570 parameters.emplace_back(static_cast<int32_t>(stringId)); 1571 parameters.emplace_back(flag); 1572 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1573 GetBaselineAssembler().SaveResultIntoAcc(); 1574} 1575 1576BYTECODE_BASELINE_HANDLER_IMPLEMENT(CREATEARRAYWITHBUFFER_IMM8_ID16) 1577{ 1578 uint8_t slotId = READ_INST_8_0(); 1579 uint16_t literalId = READ_INST_16_1(); 1580 auto traceId = static_cast<int32_t>(bytecodeArray - pfHeaderAddr); 1581 1582 auto *thread = vm->GetAssociatedJSThread(); 1583 Address builtinAddress = 1584 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCreatearraywithbufferImm8Id16); 1585 LOG_INST() << " BaselineCreatearraywithbufferImm8Id16 Address: " << std::hex << builtinAddress; 1586 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 1587 LOG_INST() << " literalId: " << static_cast<int32_t>(literalId); 1588 1589 std::vector<BaselineParameter> parameters; 1590 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1591 parameters.emplace_back(BaselineSpecialParameter::SP); 1592 parameters.emplace_back(traceId); 1593 parameters.emplace_back(static_cast<int32_t>(literalId)); 1594 parameters.emplace_back(static_cast<int32_t>(slotId)); 1595 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1596 GetBaselineAssembler().SaveResultIntoAcc(); 1597} 1598 1599BYTECODE_BASELINE_HANDLER_IMPLEMENT(CREATEARRAYWITHBUFFER_IMM16_ID16) 1600{ 1601 uint16_t slotId = READ_INST_16_0(); 1602 uint16_t literalId = READ_INST_16_2(); 1603 auto traceId = static_cast<int32_t>(bytecodeArray - pfHeaderAddr); 1604 1605 auto *thread = vm->GetAssociatedJSThread(); 1606 Address builtinAddress = 1607 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCreatearraywithbufferImm16Id16); 1608 LOG_INST() << " BaselineCreatearraywithbufferImm16Id16 Address: " << std::hex << builtinAddress; 1609 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 1610 LOG_INST() << " literalId: " << static_cast<int32_t>(literalId); 1611 1612 std::vector<BaselineParameter> parameters; 1613 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1614 parameters.emplace_back(BaselineSpecialParameter::SP); 1615 parameters.emplace_back(traceId); 1616 parameters.emplace_back(static_cast<int32_t>(literalId)); 1617 parameters.emplace_back(static_cast<int32_t>(slotId)); 1618 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1619 GetBaselineAssembler().SaveResultIntoAcc(); 1620} 1621 1622BYTECODE_BASELINE_HANDLER_IMPLEMENT(NEWOBJAPPLY_IMM8_V8) 1623{ 1624 int8_t classId = READ_INST_8_1(); 1625 1626 auto *thread = vm->GetAssociatedJSThread(); 1627 Address builtinAddress = 1628 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineNewobjapplyImm8V8); 1629 LOG_INST() << " BaselineNewobjapplyImm8V8 Address: " << std::hex << builtinAddress; 1630 1631 std::vector<BaselineParameter> parameters; 1632 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1633 parameters.emplace_back(BaselineSpecialParameter::SP); 1634 parameters.emplace_back(BaselineSpecialParameter::ACC); 1635 parameters.emplace_back(VirtualRegister(classId)); 1636 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1637 GetBaselineAssembler().SaveResultIntoAcc(); 1638} 1639 1640BYTECODE_BASELINE_HANDLER_IMPLEMENT(NEWOBJAPPLY_IMM16_V8) 1641{ 1642 int8_t classId = READ_INST_8_2(); 1643 1644 auto *thread = vm->GetAssociatedJSThread(); 1645 Address builtinAddress = 1646 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineNewobjapplyImm16V8); 1647 LOG_INST() << " BaselineNewobjapplyImm16V8 Address: " << std::hex << builtinAddress; 1648 1649 std::vector<BaselineParameter> parameters; 1650 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1651 parameters.emplace_back(BaselineSpecialParameter::SP); 1652 parameters.emplace_back(BaselineSpecialParameter::ACC); 1653 parameters.emplace_back(VirtualRegister(classId)); 1654 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1655 GetBaselineAssembler().SaveResultIntoAcc(); 1656} 1657 1658// GLUE, SP, NUM_ARGS, FIRST_ARG_REG_IDX, SLOT_ID 1659BYTECODE_BASELINE_HANDLER_IMPLEMENT(NEWOBJRANGE_IMM8_IMM8_V8) 1660{ 1661 uint8_t slotId = READ_INST_8_0(); 1662 uint8_t numArgs = READ_INST_8_1(); 1663 uint8_t firstArgRegIdx = READ_INST_8_2(); 1664 1665 auto *thread = vm->GetAssociatedJSThread(); 1666 Address builtinAddress = 1667 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineNewobjrangeImm8Imm8V8); 1668 LOG_INST() << " BaselineNewobjrangeImm8Imm8V8 Address: " << std::hex << builtinAddress; 1669 LOG_INST() << " numArgs: " << static_cast<int16_t>(numArgs); 1670 LOG_INST() << " firstArgRegIdx: " << static_cast<int16_t>(firstArgRegIdx); 1671 1672 std::vector<BaselineParameter> parameters; 1673 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1674 parameters.emplace_back(BaselineSpecialParameter::SP); 1675 parameters.emplace_back(static_cast<int32_t>(numArgs)); 1676 parameters.emplace_back(static_cast<int32_t>(firstArgRegIdx)); 1677 parameters.emplace_back(static_cast<int32_t>(slotId)); 1678 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1679 GetBaselineAssembler().SaveResultIntoAcc(); 1680} 1681 1682BYTECODE_BASELINE_HANDLER_IMPLEMENT(NEWOBJRANGE_IMM16_IMM8_V8) 1683{ 1684 uint16_t slotId = READ_INST_16_0(); 1685 uint8_t numArgs = READ_INST_8_2(); 1686 uint8_t firstArgRegIdx = READ_INST_8_3(); 1687 auto *thread = vm->GetAssociatedJSThread(); 1688 Address builtinAddress = 1689 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineNewobjrangeImm16Imm8V8); 1690 LOG_INST() << " BaselineNewobjrangeImm16Imm8V8 Address: " << std::hex << builtinAddress; 1691 LOG_INST() << " numArgs: " << static_cast<int16_t>(numArgs); 1692 LOG_INST() << " firstArgRegIdx: " << static_cast<int16_t>(firstArgRegIdx); 1693 1694 std::vector<BaselineParameter> parameters; 1695 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1696 parameters.emplace_back(BaselineSpecialParameter::SP); 1697 parameters.emplace_back(static_cast<int16_t>(numArgs)); 1698 parameters.emplace_back(static_cast<int16_t>(firstArgRegIdx)); 1699 parameters.emplace_back(static_cast<int32_t>(slotId)); 1700 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1701 GetBaselineAssembler().SaveResultIntoAcc(); 1702} 1703 1704BYTECODE_BASELINE_HANDLER_IMPLEMENT(TYPEOF_IMM8) 1705{ 1706 (void)bytecodeArray; 1707 1708 auto *thread = vm->GetAssociatedJSThread(); 1709 Address builtinAddress = 1710 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineTypeofImm8); 1711 LOG_INST() << " BaselineTypeofImm8 Address: " << std::hex << builtinAddress; 1712 1713 std::vector<BaselineParameter> parameters; 1714 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1715 parameters.emplace_back(BaselineSpecialParameter::ACC); 1716 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1717 GetBaselineAssembler().SaveResultIntoAcc(); 1718} 1719 1720BYTECODE_BASELINE_HANDLER_IMPLEMENT(TYPEOF_IMM16) 1721{ 1722 (void)bytecodeArray; 1723 1724 auto *thread = vm->GetAssociatedJSThread(); 1725 Address builtinAddress = 1726 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineTypeofImm16); 1727 LOG_INST() << " BaselineTypeofImm16 Address: " << std::hex << builtinAddress; 1728 1729 std::vector<BaselineParameter> parameters; 1730 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1731 parameters.emplace_back(BaselineSpecialParameter::ACC); 1732 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1733 GetBaselineAssembler().SaveResultIntoAcc(); 1734} 1735 1736BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDEXTERNALMODULEVAR_IMM8) 1737{ 1738 int8_t index = READ_INST_8_0(); 1739 1740 auto *thread = vm->GetAssociatedJSThread(); 1741 Address builtinAddress = 1742 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdexternalmodulevarImm8); 1743 LOG_INST() << " BaselineLdexternalmodulevarImm8 Address: " << std::hex << builtinAddress; 1744 1745 std::vector<BaselineParameter> parameters; 1746 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1747 parameters.emplace_back(index); 1748 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1749 GetBaselineAssembler().SaveResultIntoAcc(); 1750} 1751 1752BYTECODE_BASELINE_HANDLER_IMPLEMENT(SETOBJECTWITHPROTO_IMM8_V8) 1753{ 1754 int8_t proto = READ_INST_8_1(); 1755 1756 auto *thread = vm->GetAssociatedJSThread(); 1757 Address builtinAddress = 1758 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineSetobjectwithprotoImm8V8); 1759 LOG_INST() << " BaselineSetobjectwithprotoImm8V8 Address: " << std::hex << builtinAddress; 1760 1761 std::vector<BaselineParameter> parameters; 1762 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1763 parameters.emplace_back(BaselineSpecialParameter::SP); 1764 parameters.emplace_back(BaselineSpecialParameter::ACC); 1765 parameters.emplace_back(VirtualRegister(proto)); 1766 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1767} 1768 1769BYTECODE_BASELINE_HANDLER_IMPLEMENT(SETOBJECTWITHPROTO_IMM16_V8) 1770{ 1771 int8_t proto = READ_INST_8_2(); 1772 1773 auto *thread = vm->GetAssociatedJSThread(); 1774 Address builtinAddress = 1775 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineSetobjectwithprotoImm16V8); 1776 LOG_INST() << " BaselineSetobjectwithprotoImm16V8 Address: " << std::hex << builtinAddress; 1777 1778 std::vector<BaselineParameter> parameters; 1779 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1780 parameters.emplace_back(BaselineSpecialParameter::SP); 1781 parameters.emplace_back(BaselineSpecialParameter::ACC); 1782 parameters.emplace_back(VirtualRegister(proto)); 1783 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1784} 1785 1786BYTECODE_BASELINE_HANDLER_IMPLEMENT(STARRAYSPREAD_V8_V8) 1787{ 1788 int8_t array = READ_INST_8_0(); 1789 int8_t index = READ_INST_8_1(); 1790 1791 auto *thread = vm->GetAssociatedJSThread(); 1792 Address builtinAddress = 1793 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStarrayspreadV8V8); 1794 LOG_INST() << " BaselineStarrayspreadV8V8 Address: " << std::hex << builtinAddress; 1795 1796 std::vector<BaselineParameter> parameters; 1797 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1798 parameters.emplace_back(BaselineSpecialParameter::SP); 1799 parameters.emplace_back(BaselineSpecialParameter::ACC); 1800 parameters.emplace_back(VirtualRegister(array)); 1801 parameters.emplace_back(VirtualRegister(index)); 1802 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1803 GetBaselineAssembler().SaveResultIntoAcc(); 1804} 1805 1806BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDLOCALMODULEVAR_IMM8) 1807{ 1808 int8_t index = READ_INST_8_0(); 1809 1810 auto *thread = vm->GetAssociatedJSThread(); 1811 Address builtinAddress = 1812 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdlocalmodulevarImm8); 1813 LOG_INST() << " BaselineLdlocalmodulevarImm8 Address: " << std::hex << builtinAddress; 1814 1815 std::vector<BaselineParameter> parameters; 1816 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1817 parameters.emplace_back(index); 1818 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1819 GetBaselineAssembler().SaveResultIntoAcc(); 1820} 1821 1822BYTECODE_BASELINE_HANDLER_IMPLEMENT(STMODULEVAR_IMM8) 1823{ 1824 int8_t index = READ_INST_8_0(); 1825 1826 auto *thread = vm->GetAssociatedJSThread(); 1827 Address builtinAddress = 1828 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStmodulevarImm8); 1829 LOG_INST() << " BaselineStmodulevarImm8 Address: " << std::hex << builtinAddress; 1830 1831 std::vector<BaselineParameter> parameters; 1832 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1833 parameters.emplace_back(BaselineSpecialParameter::ACC); 1834 parameters.emplace_back(index); 1835 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1836} 1837 1838BYTECODE_BASELINE_HANDLER_IMPLEMENT(STOWNBYVALUE_IMM8_V8_V8) 1839{ 1840 uint8_t slotId = READ_INST_8_0(); 1841 uint8_t objectId = READ_INST_8_1(); 1842 uint8_t propKeyId = READ_INST_8_2(); 1843 1844 auto *thread = vm->GetAssociatedJSThread(); 1845 Address builtinAddress = 1846 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStownbyvalueImm8V8V8); 1847 LOG_INST() << " BaselineStownbyvalueImm8V8V8 Address: " << std::hex << builtinAddress; 1848 1849 std::vector<BaselineParameter> parameters; 1850 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1851 parameters.emplace_back(BaselineSpecialParameter::SP); 1852 parameters.emplace_back(static_cast<int32_t>(objectId)); 1853 parameters.emplace_back(static_cast<int32_t>(propKeyId)); 1854 parameters.emplace_back(static_cast<int32_t>(slotId)); 1855 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1856} 1857 1858BYTECODE_BASELINE_HANDLER_IMPLEMENT(STOWNBYVALUE_IMM16_V8_V8) 1859{ 1860 uint16_t slotId = READ_INST_16_0(); 1861 uint8_t object = READ_INST_8_2(); 1862 uint8_t propKey = READ_INST_8_3(); 1863 1864 auto *thread = vm->GetAssociatedJSThread(); 1865 Address builtinAddress = 1866 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStownbyvalueImm16V8V8); 1867 LOG_INST() << " BaselineStownbyvalueImm16V8V8 Address: " << std::hex << builtinAddress; 1868 1869 std::vector<BaselineParameter> parameters; 1870 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1871 parameters.emplace_back(BaselineSpecialParameter::SP); 1872 parameters.emplace_back(VirtualRegister(object)); 1873 parameters.emplace_back(VirtualRegister(propKey)); 1874 parameters.emplace_back(static_cast<int32_t>(slotId)); 1875 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1876} 1877 1878BYTECODE_BASELINE_HANDLER_IMPLEMENT(STOWNBYINDEX_IMM8_V8_IMM16) 1879{ 1880 uint8_t slotId = READ_INST_8_0(); 1881 uint8_t object = READ_INST_8_1(); 1882 uint16_t propKey = READ_INST_16_2(); 1883 1884 auto *thread = vm->GetAssociatedJSThread(); 1885 Address builtinAddress = 1886 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStownbyindexImm8V8Imm16); 1887 LOG_INST() << " BaselineStownbyindexImm8V8Imm16 Address: " << std::hex << builtinAddress; 1888 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 1889 LOG_INST() << " propKey: " << static_cast<int32_t>(propKey); 1890 1891 std::vector<BaselineParameter> parameters; 1892 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1893 parameters.emplace_back(BaselineSpecialParameter::SP); 1894 parameters.emplace_back(VirtualRegister(object)); 1895 parameters.emplace_back(static_cast<int32_t>(propKey)); 1896 parameters.emplace_back(static_cast<int32_t>(slotId)); 1897 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1898} 1899 1900BYTECODE_BASELINE_HANDLER_IMPLEMENT(STOWNBYINDEX_IMM16_V8_IMM16) 1901{ 1902 uint16_t slotId = READ_INST_16_0(); 1903 uint8_t object = READ_INST_8_2(); 1904 uint16_t propKey = READ_INST_16_3(); 1905 1906 auto *thread = vm->GetAssociatedJSThread(); 1907 Address builtinAddress = 1908 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStownbyindexImm16V8Imm16); 1909 LOG_INST() << " BaselineStownbyindexImm16V8Imm16 Address: " << std::hex << builtinAddress; 1910 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 1911 LOG_INST() << " propKey: " << static_cast<int32_t>(propKey); 1912 1913 std::vector<BaselineParameter> parameters; 1914 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1915 parameters.emplace_back(BaselineSpecialParameter::SP); 1916 parameters.emplace_back(VirtualRegister(object)); 1917 parameters.emplace_back(static_cast<int32_t>(propKey)); 1918 parameters.emplace_back(static_cast<int32_t>(slotId)); 1919 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1920} 1921 1922BYTECODE_BASELINE_HANDLER_IMPLEMENT(STOWNBYNAME_IMM8_ID16_V8) 1923{ 1924 uint8_t slotId = READ_INST_8_0(); 1925 uint16_t stringId = READ_INST_16_1(); 1926 uint8_t objectId = READ_INST_8_3(); 1927 1928 auto *thread = vm->GetAssociatedJSThread(); 1929 Address builtinAddress = 1930 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStownbynameImm8Id16V8); 1931 LOG_INST() << " BaselineStownbynameImm8Id16V8 Address: " << std::hex << builtinAddress; 1932 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 1933 1934 std::vector<BaselineParameter> parameters; 1935 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1936 parameters.emplace_back(BaselineSpecialParameter::SP); 1937 parameters.emplace_back(static_cast<int32_t>(objectId)); 1938 parameters.emplace_back(static_cast<int32_t>(stringId)); 1939 parameters.emplace_back(static_cast<int32_t>(slotId)); 1940 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1941} 1942 1943BYTECODE_BASELINE_HANDLER_IMPLEMENT(STOWNBYNAME_IMM16_ID16_V8) 1944{ 1945 uint16_t slotId = READ_INST_16_0(); 1946 uint16_t stringId = READ_INST_16_2(); 1947 uint8_t object = READ_INST_8_4(); 1948 1949 auto *thread = vm->GetAssociatedJSThread(); 1950 Address builtinAddress = 1951 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStownbynameImm16Id16V8); 1952 LOG_INST() << " BaselineStownbynameImm16Id16V8 Address: " << std::hex << builtinAddress; 1953 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 1954 1955 std::vector<BaselineParameter> parameters; 1956 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1957 parameters.emplace_back(BaselineSpecialParameter::SP); 1958 parameters.emplace_back(VirtualRegister(object)); 1959 parameters.emplace_back(static_cast<int32_t>(stringId)); 1960 parameters.emplace_back(static_cast<int32_t>(slotId)); 1961 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1962} 1963 1964BYTECODE_BASELINE_HANDLER_IMPLEMENT(STOWNBYVALUEWITHNAMESET_IMM8_V8_V8) 1965{ 1966 uint8_t slotId = READ_INST_8_0(); 1967 uint8_t objectId = READ_INST_8_1(); 1968 uint8_t propKeyId = READ_INST_8_2(); 1969 1970 auto *thread = vm->GetAssociatedJSThread(); 1971 Address builtinAddress = 1972 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStownbyvaluewithnamesetImm8V8V8); 1973 LOG_INST() << " BaselineStownbyvaluewithnamesetImm8V8V8 Address: " << std::hex << builtinAddress; 1974 1975 std::vector<BaselineParameter> parameters; 1976 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1977 parameters.emplace_back(BaselineSpecialParameter::SP); 1978 parameters.emplace_back(static_cast<int32_t>(objectId)); 1979 parameters.emplace_back(static_cast<int32_t>(propKeyId)); 1980 parameters.emplace_back(static_cast<int32_t>(slotId)); 1981 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 1982} 1983 1984BYTECODE_BASELINE_HANDLER_IMPLEMENT(STOWNBYVALUEWITHNAMESET_IMM16_V8_V8) 1985{ 1986 uint16_t slotId = READ_INST_16_0(); 1987 uint8_t object = READ_INST_8_2(); 1988 uint8_t propKey = READ_INST_8_3(); 1989 1990 auto *thread = vm->GetAssociatedJSThread(); 1991 Address builtinAddress = 1992 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStownbyvaluewithnamesetImm16V8V8); 1993 LOG_INST() << " BaselineStownbyvaluewithnamesetImm16V8V8 Address: " << std::hex << builtinAddress; 1994 1995 std::vector<BaselineParameter> parameters; 1996 parameters.emplace_back(BaselineSpecialParameter::GLUE); 1997 parameters.emplace_back(BaselineSpecialParameter::SP); 1998 parameters.emplace_back(VirtualRegister(object)); 1999 parameters.emplace_back(VirtualRegister(propKey)); 2000 parameters.emplace_back(static_cast<int32_t>(slotId)); 2001 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2002} 2003 2004BYTECODE_BASELINE_HANDLER_IMPLEMENT(STOWNBYNAMEWITHNAMESET_IMM8_ID16_V8) 2005{ 2006 uint8_t slotId = READ_INST_8_0(); 2007 uint16_t stringId = READ_INST_16_1(); 2008 uint8_t objectId = READ_INST_8_3(); 2009 2010 auto *thread = vm->GetAssociatedJSThread(); 2011 Address builtinAddress = 2012 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStownbynamewithnamesetImm8Id16V8); 2013 LOG_INST() << " BaselineStownbynamewithnamesetImm8Id16V8 Address: " << std::hex << builtinAddress; 2014 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 2015 2016 std::vector<BaselineParameter> parameters; 2017 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2018 parameters.emplace_back(BaselineSpecialParameter::SP); 2019 parameters.emplace_back(static_cast<int32_t>(objectId)); 2020 parameters.emplace_back(static_cast<int32_t>(stringId)); 2021 parameters.emplace_back(static_cast<int32_t>(slotId)); 2022 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2023} 2024 2025BYTECODE_BASELINE_HANDLER_IMPLEMENT(STOWNBYNAMEWITHNAMESET_IMM16_ID16_V8) 2026{ 2027 uint16_t slotId = READ_INST_16_0(); 2028 uint16_t stringId = READ_INST_16_2(); 2029 uint8_t object = READ_INST_8_4(); 2030 2031 auto *thread = vm->GetAssociatedJSThread(); 2032 Address builtinAddress = 2033 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStownbynamewithnamesetImm16Id16V8); 2034 LOG_INST() << " BaselineStownbynamewithnamesetImm16Id16V8 Address: " << std::hex << builtinAddress; 2035 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 2036 2037 std::vector<BaselineParameter> parameters; 2038 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2039 parameters.emplace_back(BaselineSpecialParameter::SP); 2040 parameters.emplace_back(static_cast<int32_t>(stringId)); 2041 parameters.emplace_back(VirtualRegister(object)); 2042 parameters.emplace_back(static_cast<int32_t>(slotId)); 2043 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2044} 2045 2046BYTECODE_BASELINE_HANDLER_IMPLEMENT(STCONSTTOGLOBALRECORD_IMM16_ID16) 2047{ 2048 uint16_t stringId = READ_INST_16_2(); 2049 2050 auto *thread = vm->GetAssociatedJSThread(); 2051 Address builtinAddress = 2052 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStconsttoglobalrecordImm16Id16); 2053 LOG_INST() << " BaselineStconsttoglobalrecordImm16Id16 Address: " << std::hex << builtinAddress; 2054 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 2055 2056 std::vector<BaselineParameter> parameters; 2057 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2058 parameters.emplace_back(BaselineSpecialParameter::SP); 2059 parameters.emplace_back(BaselineSpecialParameter::ACC); 2060 parameters.emplace_back(static_cast<int32_t>(stringId)); 2061 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2062} 2063// ------- End parse bytecodes about reading and storing general variables ------- 2064 2065// ------- parse bytecodes about functions ------- 2066BYTECODE_BASELINE_HANDLER_IMPLEMENT(ASYNCFUNCTIONENTER) 2067{ 2068 (void)bytecodeArray; 2069 2070 auto *thread = vm->GetAssociatedJSThread(); 2071 Address builtinAddress = 2072 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineAsyncfunctionenter); 2073 LOG_INST() << " BaselineAsyncfunctionenter Address: " << std::hex << builtinAddress; 2074 2075 std::vector<BaselineParameter> parameters; 2076 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2077 parameters.emplace_back(BaselineSpecialParameter::SP); 2078 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2079 GetBaselineAssembler().SaveResultIntoAcc(); 2080} 2081 2082BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEFINEFUNC_IMM8_ID16_IMM8) 2083{ 2084 uint8_t slotId = READ_INST_8_0(); 2085 uint16_t methodId = READ_INST_16_1(); 2086 uint8_t length = READ_INST_8_3(); 2087 2088 auto *thread = vm->GetAssociatedJSThread(); 2089 Address builtinAddress = 2090 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDefinefuncImm8Id16Imm8); 2091 LOG_INST() << " BaselineDefinefuncImm8Id16Imm8 Address: " << std::hex << builtinAddress; 2092 LOG_INST() << " methodId: " << static_cast<int32_t>(methodId); 2093 LOG_INST() << " length: " << static_cast<int32_t>(length); 2094 2095 std::vector<BaselineParameter> parameters; 2096 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2097 parameters.emplace_back(BaselineSpecialParameter::SP); 2098 parameters.emplace_back(static_cast<int32_t>(methodId)); 2099 parameters.emplace_back(static_cast<int32_t>(length)); 2100 parameters.emplace_back(static_cast<int32_t>(slotId)); 2101 2102 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2103 GetBaselineAssembler().SaveResultIntoAcc(); 2104} 2105 2106BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEFINEFUNC_IMM16_ID16_IMM8) 2107{ 2108 uint16_t slotId = READ_INST_16_0(); 2109 uint16_t methodId = READ_INST_16_2(); 2110 uint8_t length = READ_INST_8_4(); 2111 2112 auto *thread = vm->GetAssociatedJSThread(); 2113 Address builtinAddress = 2114 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDefinefuncImm16Id16Imm8); 2115 LOG_INST() << " BaselineDefinefuncImm16Id16Imm8 Address: " << std::hex << builtinAddress; 2116 LOG_INST() << " methodId: " << static_cast<int32_t>(methodId); 2117 LOG_INST() << " length: " << static_cast<int32_t>(length); 2118 2119 std::vector<BaselineParameter> parameters; 2120 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2121 parameters.emplace_back(BaselineSpecialParameter::SP); 2122 parameters.emplace_back(static_cast<int32_t>(methodId)); 2123 parameters.emplace_back(static_cast<int32_t>(length)); 2124 parameters.emplace_back(static_cast<int32_t>(slotId)); 2125 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2126 GetBaselineAssembler().SaveResultIntoAcc(); 2127} 2128 2129BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEFINEMETHOD_IMM8_ID16_IMM8) 2130{ 2131 uint16_t methodId = READ_INST_16_1(); 2132 int8_t length = READ_INST_8_3(); 2133 2134 auto *thread = vm->GetAssociatedJSThread(); 2135 Address builtinAddress = 2136 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDefinemethodImm8Id16Imm8); 2137 LOG_INST() << " BaselineDefinemethodImm8Id16Imm8 Address: " << std::hex << builtinAddress; 2138 LOG_INST() << " methodId: " << static_cast<int32_t>(methodId); 2139 2140 std::vector<BaselineParameter> parameters; 2141 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2142 parameters.emplace_back(BaselineSpecialParameter::ACC); 2143 parameters.emplace_back(static_cast<int32_t>(methodId)); 2144 parameters.emplace_back(length); 2145 parameters.emplace_back(BaselineSpecialParameter::SP); 2146 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2147 GetBaselineAssembler().SaveResultIntoAcc(); 2148} 2149 2150BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEFINEMETHOD_IMM16_ID16_IMM8) 2151{ 2152 uint16_t methodId = READ_INST_16_2(); 2153 int8_t length = READ_INST_8_4(); 2154 2155 auto *thread = vm->GetAssociatedJSThread(); 2156 Address builtinAddress = 2157 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDefinemethodImm16Id16Imm8); 2158 LOG_INST() << " BaselineDefinemethodImm16Id16Imm8 Address: " << std::hex << builtinAddress; 2159 LOG_INST() << " methodId: " << static_cast<int32_t>(methodId); 2160 2161 std::vector<BaselineParameter> parameters; 2162 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2163 parameters.emplace_back(BaselineSpecialParameter::ACC); 2164 parameters.emplace_back(static_cast<int32_t>(methodId)); 2165 parameters.emplace_back(length); 2166 parameters.emplace_back(BaselineSpecialParameter::SP); 2167 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2168 GetBaselineAssembler().SaveResultIntoAcc(); 2169} 2170 2171BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLARG0_IMM8) 2172{ 2173 uint8_t slotId = READ_INST_8_0(); 2174 2175 auto *thread = vm->GetAssociatedJSThread(); 2176 Address builtinAddress = 2177 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCallarg0Imm8); 2178 LOG_INST() << " BaselineCallarg0Imm8 Address: " << std::hex << builtinAddress; 2179 2180 std::vector<BaselineParameter> parameters; 2181 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2182 parameters.emplace_back(BaselineSpecialParameter::SP); 2183 parameters.emplace_back(static_cast<int32_t>(slotId)); 2184 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2185 GetBaselineAssembler().SaveResultIntoAcc(); 2186} 2187 2188BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLARG1_IMM8_V8) 2189{ 2190 uint8_t slotId = READ_INST_8_0(); 2191 uint8_t argNo = READ_INST_8_1(); 2192 2193 auto *thread = vm->GetAssociatedJSThread(); 2194 Address builtinAddress = 2195 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCallArg1Imm8V8); 2196 LOG_INST() << " BaselineCallArg1Imm8V8 Address: " << std::hex << builtinAddress; 2197 2198 std::vector<BaselineParameter> parameters; 2199 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2200 parameters.emplace_back(BaselineSpecialParameter::SP); 2201 parameters.emplace_back(static_cast<int32_t>(argNo)); 2202 parameters.emplace_back(static_cast<int32_t>(slotId)); 2203 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2204 GetBaselineAssembler().SaveResultIntoAcc(); 2205} 2206 2207BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLARGS2_IMM8_V8_V8) 2208{ 2209 uint8_t slotId = READ_INST_8_0(); 2210 uint8_t arg1No = READ_INST_8_1(); 2211 uint8_t arg2No = READ_INST_8_2(); 2212 2213 auto *thread = vm->GetAssociatedJSThread(); 2214 Address builtinAddress = 2215 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCallargs2Imm8V8V8); 2216 LOG_INST() << " BaselineCallargs2Imm8V8V8 Address: " << std::hex << builtinAddress; 2217 2218 std::vector<BaselineParameter> parameters; 2219 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2220 parameters.emplace_back(BaselineSpecialParameter::SP); 2221 parameters.emplace_back(static_cast<int32_t>(arg1No)); 2222 parameters.emplace_back(static_cast<int32_t>(arg2No)); 2223 parameters.emplace_back(static_cast<int32_t>(slotId)); 2224 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2225 GetBaselineAssembler().SaveResultIntoAcc(); 2226} 2227 2228BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLARGS3_IMM8_V8_V8_V8) 2229{ 2230 uint8_t slotId = READ_INST_8_0(); 2231 uint8_t arg1No = READ_INST_8_1(); 2232 uint8_t arg2No = READ_INST_8_2(); 2233 uint8_t arg3No = READ_INST_8_3(); 2234 2235 auto *thread = vm->GetAssociatedJSThread(); 2236 Address builtinAddress = 2237 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCallargs3Imm8V8V8V8); 2238 LOG_INST() << " BaselineCallargs3Imm8V8V8V8 Address: " << std::hex << builtinAddress; 2239 2240 std::vector<BaselineParameter> parameters; 2241 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2242 parameters.emplace_back(BaselineSpecialParameter::SP); 2243 parameters.emplace_back(static_cast<int32_t>(arg1No)); 2244 parameters.emplace_back(static_cast<int32_t>(arg2No)); 2245 parameters.emplace_back(static_cast<int32_t>(arg3No)); 2246 parameters.emplace_back(static_cast<int32_t>(slotId)); 2247 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2248 GetBaselineAssembler().SaveResultIntoAcc(); 2249} 2250 2251BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRANGE_IMM8_IMM8_V8) 2252{ 2253 uint8_t slotId = READ_INST_8_0(); 2254 uint8_t numArgs = READ_INST_8_1(); 2255 uint8_t arg = READ_INST_8_2(); 2256 2257 auto *thread = vm->GetAssociatedJSThread(); 2258 Address builtinAddress = 2259 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCallrangeImm8Imm8V8); 2260 LOG_INST() << " BaselineCallrangeImm8Imm8V8 Address: " << std::hex << builtinAddress; 2261 LOG_INST() << " numArgs: " << static_cast<int32_t>(numArgs); 2262 2263 std::vector<BaselineParameter> parameters; 2264 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2265 parameters.emplace_back(BaselineSpecialParameter::SP); 2266 parameters.emplace_back(static_cast<int32_t>(numArgs)); 2267 parameters.emplace_back(static_cast<int32_t>(arg)); 2268 parameters.emplace_back(static_cast<int32_t>(slotId)); 2269 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2270 GetBaselineAssembler().SaveResultIntoAcc(); 2271} 2272 2273BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLTHIS0_IMM8_V8) 2274{ 2275 uint8_t slotId = READ_INST_8_0(); 2276 uint8_t thisObjNo = READ_INST_8_1(); 2277 2278 auto *thread = vm->GetAssociatedJSThread(); 2279 Address builtinAddress = 2280 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCallthis0Imm8V8); 2281 LOG_INST() << " BaselineCallthis0Imm8V8 Address: " << std::hex << builtinAddress; 2282 2283 std::vector<BaselineParameter> parameters; 2284 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2285 parameters.emplace_back(BaselineSpecialParameter::SP); 2286 parameters.emplace_back(static_cast<int32_t>(thisObjNo)); 2287 parameters.emplace_back(static_cast<int32_t>(slotId)); 2288 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2289 GetBaselineAssembler().SaveResultIntoAcc(); 2290} 2291 2292BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLTHIS1_IMM8_V8_V8) 2293{ 2294 uint8_t slotId = READ_INST_8_0(); 2295 uint8_t thisObjId = READ_INST_8_1(); 2296 uint8_t argId = READ_INST_8_2(); 2297 2298 auto *thread = vm->GetAssociatedJSThread(); 2299 Address builtinAddress = 2300 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCallthis1Imm8V8V8); 2301 LOG_INST() << " BaselineCallthis1Imm8V8V8 Address: " << std::hex << builtinAddress; 2302 LOG_INST() << " thisObjId: " << static_cast<int16_t>(thisObjId); 2303 LOG_INST() << " argId: " << static_cast<int16_t>(argId); 2304 2305 std::vector<BaselineParameter> parameters; 2306 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2307 parameters.emplace_back(BaselineSpecialParameter::SP); 2308 parameters.emplace_back(static_cast<int32_t>(thisObjId)); 2309 parameters.emplace_back(static_cast<int32_t>(argId)); 2310 parameters.emplace_back(static_cast<int32_t>(slotId)); 2311 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2312 GetBaselineAssembler().SaveResultIntoAcc(); 2313} 2314 2315BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLTHIS2_IMM8_V8_V8_V8) 2316{ 2317 uint8_t slotId = READ_INST_8_0(); 2318 uint8_t thisObjId = READ_INST_8_1(); 2319 uint8_t arg1Id = READ_INST_8_2(); 2320 uint8_t arg2Id = READ_INST_8_3(); 2321 2322 auto *thread = vm->GetAssociatedJSThread(); 2323 Address builtinAddress = 2324 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCallthis2Imm8V8V8V8); 2325 LOG_INST() << " BaselineCallthis2Imm8V8V8V8 Address: " << std::hex << builtinAddress; 2326 2327 std::vector<BaselineParameter> parameters; 2328 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2329 parameters.emplace_back(BaselineSpecialParameter::SP); 2330 parameters.emplace_back(static_cast<int32_t>(thisObjId)); 2331 parameters.emplace_back(static_cast<int32_t>(arg1Id)); 2332 parameters.emplace_back(static_cast<int32_t>(arg2Id)); 2333 parameters.emplace_back(static_cast<int32_t>(slotId)); 2334 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2335 GetBaselineAssembler().SaveResultIntoAcc(); 2336} 2337 2338BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLTHIS3_IMM8_V8_V8_V8_V8) 2339{ 2340 uint8_t slotId = READ_INST_8_0(); 2341 uint8_t thisObjId = READ_INST_8_1(); 2342 uint8_t arg1Id = READ_INST_8_2(); 2343 uint8_t arg2Id = READ_INST_8_3(); 2344 uint8_t arg3Id = READ_INST_8_4(); 2345 2346 auto *thread = vm->GetAssociatedJSThread(); 2347 Address builtinAddress = 2348 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCallthis3Imm8V8V8V8V8); 2349 LOG_INST() << " BaselineCallthis3Imm8V8V8V8V8 Address: " << std::hex << builtinAddress; 2350 2351 std::vector<BaselineParameter> parameters; 2352 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2353 parameters.emplace_back(BaselineSpecialParameter::SP); 2354 parameters.emplace_back(static_cast<int32_t>(thisObjId)); 2355 uint32_t argIds = static_cast<uint32_t>(arg1Id) | 2356 (static_cast<uint32_t>(arg2Id) << ONE_BYTE_SIZE) | 2357 (static_cast<uint32_t>(arg3Id) << TWO_BYTE_SIZE); 2358 parameters.emplace_back(static_cast<int32_t>(argIds)); 2359 parameters.emplace_back(static_cast<int32_t>(slotId)); 2360 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2361 GetBaselineAssembler().SaveResultIntoAcc(); 2362} 2363 2364BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLTHISRANGE_IMM8_IMM8_V8) 2365{ 2366 uint8_t slotId = READ_INST_8_0(); 2367 uint8_t numArgs = READ_INST_8_1(); 2368 uint8_t thisObj = READ_INST_8_2(); 2369 2370 auto *thread = vm->GetAssociatedJSThread(); 2371 Address builtinAddress = 2372 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCallthisrangeImm8Imm8V8); 2373 LOG_INST() << " BaselineCallthisrangeImm8Imm8V8 Address: " << std::hex << builtinAddress; 2374 LOG_INST() << " numArgs: " << static_cast<int32_t>(numArgs); 2375 LOG_INST() << " thisObjId: " << static_cast<int16_t>(thisObj); 2376 2377 std::vector<BaselineParameter> parameters; 2378 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2379 parameters.emplace_back(BaselineSpecialParameter::SP); 2380 parameters.emplace_back(static_cast<int32_t>(numArgs)); 2381 parameters.emplace_back(static_cast<int32_t>(thisObj)); 2382 parameters.emplace_back(static_cast<int32_t>(slotId)); 2383 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2384 GetBaselineAssembler().SaveResultIntoAcc(); 2385} 2386 2387BYTECODE_BASELINE_HANDLER_IMPLEMENT(SUPERCALLTHISRANGE_IMM8_IMM8_V8) 2388{ 2389 uint8_t range = READ_INST_8_1(); 2390 uint8_t v0 = READ_INST_8_2(); 2391 2392 auto *thread = vm->GetAssociatedJSThread(); 2393 Address builtinAddress = 2394 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineSupercallthisrangeImm8Imm8V8); 2395 LOG_INST() << " BaselineSupercallthisrangeImm8Imm8V8 Address: " << std::hex << builtinAddress; 2396 LOG_INST() << " range: " << static_cast<int16_t>(range); 2397 LOG_INST() << " v0: " << static_cast<int16_t>(v0); 2398 2399 std::vector<BaselineParameter> parameters; 2400 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2401 parameters.emplace_back(BaselineSpecialParameter::SP); 2402 parameters.emplace_back(static_cast<int16_t>(range)); 2403 parameters.emplace_back(static_cast<int16_t>(v0)); 2404 parameters.emplace_back(BaselineSpecialParameter::HOTNESS_COUNTER); 2405 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2406 GetBaselineAssembler().SaveResultIntoAcc(); 2407} 2408 2409BYTECODE_BASELINE_HANDLER_IMPLEMENT(SUPERCALLARROWRANGE_IMM8_IMM8_V8) 2410{ 2411 int8_t range = READ_INST_8_1(); 2412 uint8_t v0 = READ_INST_8_2(); 2413 2414 auto *thread = vm->GetAssociatedJSThread(); 2415 Address builtinAddress = 2416 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineSupercallarrowrangeImm8Imm8V8); 2417 LOG_INST() << " BaselineSupercallarrowrangeImm8Imm8V8 Address: " << std::hex << builtinAddress; 2418 LOG_INST() << " v0: " << static_cast<int16_t>(v0); 2419 2420 std::vector<BaselineParameter> parameters; 2421 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2422 parameters.emplace_back(BaselineSpecialParameter::SP); 2423 parameters.emplace_back(BaselineSpecialParameter::ACC); 2424 parameters.emplace_back(range); 2425 parameters.emplace_back(static_cast<int16_t>(v0)); 2426 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2427 GetBaselineAssembler().SaveResultIntoAcc(); 2428} 2429 2430BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_SUPERCALLFORWARDALLARGS_PREF_V8) 2431{ 2432 uint8_t v0 = READ_INST_8_1(); 2433 auto *thread = vm->GetAssociatedJSThread(); 2434 2435 Address builtinAddress = 2436 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCallRuntimeSupercallforwardallargsPrefV8); 2437 LOG_INST() << " BaselineCallRuntimeSupercallforwardallargsPrefV8 Address: " << std::hex << builtinAddress; 2438 LOG_INST() << " v0: " << static_cast<int16_t>(v0); 2439 2440 std::vector<BaselineParameter> parameters; 2441 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2442 parameters.emplace_back(BaselineSpecialParameter::SP); 2443 parameters.emplace_back(v0); 2444 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2445 GetBaselineAssembler().SaveResultIntoAcc(); 2446} 2447 2448BYTECODE_BASELINE_HANDLER_IMPLEMENT(SUPERCALLSPREAD_IMM8_V8) 2449{ 2450 int8_t argList = READ_INST_8_1(); 2451 2452 auto *thread = vm->GetAssociatedJSThread(); 2453 Address builtinAddress = 2454 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineSupercallspreadImm8V8); 2455 LOG_INST() << " BaselineSupercallspreadImm8V8 Address: " << std::hex << builtinAddress; 2456 2457 std::vector<BaselineParameter> parameters; 2458 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2459 parameters.emplace_back(BaselineSpecialParameter::SP); 2460 parameters.emplace_back(BaselineSpecialParameter::ACC); 2461 parameters.emplace_back(VirtualRegister(argList)); 2462 parameters.emplace_back(BaselineSpecialParameter::HOTNESS_COUNTER); 2463 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2464 GetBaselineAssembler().SaveResultIntoAcc(); 2465} 2466 2467BYTECODE_BASELINE_HANDLER_IMPLEMENT(APPLY_IMM8_V8_V8) 2468{ 2469 int8_t object = READ_INST_8_1(); 2470 int8_t argList = READ_INST_8_2(); 2471 2472 auto *thread = vm->GetAssociatedJSThread(); 2473 Address builtinAddress = 2474 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineApplyImm8V8V8); 2475 LOG_INST() << " BaselineApplyImm8V8V8 Address: " << std::hex << builtinAddress; 2476 2477 std::vector<BaselineParameter> parameters; 2478 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2479 parameters.emplace_back(BaselineSpecialParameter::SP); 2480 parameters.emplace_back(BaselineSpecialParameter::ACC); 2481 parameters.emplace_back(VirtualRegister(object)); 2482 parameters.emplace_back(VirtualRegister(argList)); 2483 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2484 GetBaselineAssembler().SaveResultIntoAcc(); 2485} 2486 2487BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEFINEGETTERSETTERBYVALUE_V8_V8_V8_V8) 2488{ 2489 uint8_t objectVregId = READ_INST_8_0(); 2490 uint8_t propKeyVregId = READ_INST_8_1(); 2491 uint8_t getterVregId = READ_INST_8_2(); 2492 uint8_t setterVregId = READ_INST_8_3(); 2493 auto offset = static_cast<int32_t>(bytecodeArray - firstPC); 2494 2495 auto *thread = vm->GetAssociatedJSThread(); 2496 Address builtinAddress = 2497 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDefinegettersetterbyvalueV8V8V8V8); 2498 LOG_INST() << " BaselineDefinegettersetterbyvalueV8V8V8V8 Address: " << std::hex << builtinAddress; 2499 2500 std::vector<BaselineParameter> parameters; 2501 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2502 parameters.emplace_back(BaselineSpecialParameter::SP); 2503 uint32_t vRegIds = static_cast<uint32_t>(objectVregId) | 2504 (static_cast<uint32_t>(propKeyVregId) << ONE_BYTE_SIZE) | 2505 (static_cast<uint32_t>(getterVregId) << TWO_BYTE_SIZE) | 2506 (static_cast<uint32_t>(setterVregId) << THREE_BYTE_SIZE); 2507 parameters.emplace_back(offset); 2508 parameters.emplace_back(static_cast<int32_t>(vRegIds)); 2509 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2510 GetBaselineAssembler().SaveResultIntoAcc(); 2511} 2512 2513BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEFINECLASSWITHBUFFER_IMM8_ID16_ID16_IMM16_V8) 2514{ 2515 int16_t methodId = READ_INST_16_1(); 2516 int16_t literalId = READ_INST_16_3(); 2517 int16_t count = READ_INST_16_5(); 2518 int8_t v0 = READ_INST_8_7(); 2519 2520 auto *thread = vm->GetAssociatedJSThread(); 2521 Address builtinAddress = 2522 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDefineclasswithbufferImm8Id16Id16Imm16V8); 2523 LOG_INST() << " BaselineDefineclasswithbufferImm8Id16Id16Imm16V8 Address: " << std::hex << builtinAddress; 2524 2525 std::vector<BaselineParameter> parameters; 2526 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2527 parameters.emplace_back(BaselineSpecialParameter::SP); 2528 parameters.emplace_back(methodId); 2529 parameters.emplace_back(literalId); 2530 parameters.emplace_back(count); 2531 parameters.emplace_back(v0); 2532 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2533 GetBaselineAssembler().SaveResultIntoAcc(); 2534} 2535 2536BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEFINECLASSWITHBUFFER_IMM16_ID16_ID16_IMM16_V8) 2537{ 2538 uint16_t slotId = READ_INST_16_0(); 2539 uint16_t methodId = READ_INST_16_2(); 2540 uint16_t literalId = READ_INST_16_4(); 2541 uint16_t count = READ_INST_16_6(); 2542 uint8_t superClass = READ_INST_8_8(); 2543 2544 auto *thread = vm->GetAssociatedJSThread(); 2545 Address builtinAddress = 2546 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDefineclasswithbufferImm16Id16Id16Imm16V8); 2547 LOG_INST() << " BaselineDefineclasswithbufferImm16Id16Id16Imm16V8 Address: " << std::hex << builtinAddress; 2548 2549 std::vector<BaselineParameter> parameters; 2550 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2551 parameters.emplace_back(BaselineSpecialParameter::SP); 2552 uint32_t methodAndLiteralId = static_cast<uint32_t>(methodId) | (static_cast<uint32_t>(literalId) << TWO_BYTE_SIZE); 2553 uint32_t countAndSuperClassId = static_cast<uint32_t>(count) | (static_cast<uint32_t>(superClass) << TWO_BYTE_SIZE); 2554 parameters.emplace_back(static_cast<int32_t>(methodAndLiteralId)); 2555 parameters.emplace_back(static_cast<int32_t>(countAndSuperClassId)); 2556 parameters.emplace_back(static_cast<int32_t>(slotId)); 2557 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2558 GetBaselineAssembler().SaveResultIntoAcc(); 2559} 2560 2561BYTECODE_BASELINE_HANDLER_IMPLEMENT(GETRESUMEMODE) 2562{ 2563 (void)bytecodeArray; 2564 2565 auto *thread = vm->GetAssociatedJSThread(); 2566 Address builtinAddress = 2567 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineGetresumemod); 2568 LOG_INST() << " BaselineGetresumemod Address: " << std::hex << builtinAddress; 2569 2570 std::vector<BaselineParameter> parameters; 2571 parameters.emplace_back(BaselineSpecialParameter::ACC); 2572 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2573 GetBaselineAssembler().SaveResultIntoAcc(); 2574} 2575 2576BYTECODE_BASELINE_HANDLER_IMPLEMENT(GETTEMPLATEOBJECT_IMM8) 2577{ 2578 (void)bytecodeArray; 2579 2580 auto *thread = vm->GetAssociatedJSThread(); 2581 Address builtinAddress = 2582 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineGettemplateobjectImm8); 2583 LOG_INST() << " BaselineGettemplateobjectImm8 Address: " << std::hex << builtinAddress; 2584 2585 std::vector<BaselineParameter> parameters; 2586 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2587 parameters.emplace_back(BaselineSpecialParameter::SP); 2588 parameters.emplace_back(BaselineSpecialParameter::ACC); 2589 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2590 GetBaselineAssembler().SaveResultIntoAcc(); 2591} 2592 2593BYTECODE_BASELINE_HANDLER_IMPLEMENT(GETTEMPLATEOBJECT_IMM16) 2594{ 2595 (void)bytecodeArray; 2596 2597 auto *thread = vm->GetAssociatedJSThread(); 2598 Address builtinAddress = 2599 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineGettemplateobjectImm16); 2600 LOG_INST() << " BaselineGettemplateobjectImm16 Address: " << std::hex << builtinAddress; 2601 2602 std::vector<BaselineParameter> parameters; 2603 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2604 parameters.emplace_back(BaselineSpecialParameter::SP); 2605 parameters.emplace_back(BaselineSpecialParameter::ACC); 2606 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2607 GetBaselineAssembler().SaveResultIntoAcc(); 2608} 2609 2610BYTECODE_BASELINE_HANDLER_IMPLEMENT(GETNEXTPROPNAME_V8) 2611{ 2612 int8_t iter = READ_INST_8_0(); 2613 2614 auto *thread = vm->GetAssociatedJSThread(); 2615 Address builtinAddress = 2616 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineGetnextpropnameV8); 2617 LOG_INST() << " BaselineGetnextpropnameV8 Address: " << std::hex << builtinAddress; 2618 2619 std::vector<BaselineParameter> parameters; 2620 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2621 parameters.emplace_back(BaselineSpecialParameter::SP); 2622 parameters.emplace_back(VirtualRegister(iter)); 2623 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2624 GetBaselineAssembler().SaveResultIntoAcc(); 2625} 2626 2627BYTECODE_BASELINE_HANDLER_IMPLEMENT(GETMODULENAMESPACE_IMM8) 2628{ 2629 uint8_t index = READ_INST_8_0(); 2630 2631 auto *thread = vm->GetAssociatedJSThread(); 2632 Address builtinAddress = 2633 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineGetmodulenamespaceImm8); 2634 LOG_INST() << " BaselineGetmodulenamespaceImm8 Address: " << std::hex << builtinAddress; 2635 LOG_INST() << " index: " << static_cast<int32_t>(index); 2636 2637 std::vector<BaselineParameter> parameters; 2638 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2639 parameters.emplace_back(static_cast<int32_t>(index)); 2640 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2641 GetBaselineAssembler().SaveResultIntoAcc(); 2642} 2643 2644BYTECODE_BASELINE_HANDLER_IMPLEMENT(ASYNCFUNCTIONAWAITUNCAUGHT_V8) 2645{ 2646 int8_t object = READ_INST_8_0(); 2647 2648 auto *thread = vm->GetAssociatedJSThread(); 2649 Address builtinAddress = 2650 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineAsyncfunctionawaituncaughtV8); 2651 LOG_INST() << " BaselineAsyncfunctionawaituncaughtV8 Address: " << std::hex << builtinAddress; 2652 2653 std::vector<BaselineParameter> parameters; 2654 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2655 parameters.emplace_back(BaselineSpecialParameter::SP); 2656 parameters.emplace_back(BaselineSpecialParameter::ACC); 2657 parameters.emplace_back(VirtualRegister(object)); 2658 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2659 GetBaselineAssembler().SaveResultIntoAcc(); 2660} 2661 2662BYTECODE_BASELINE_HANDLER_IMPLEMENT(ASYNCFUNCTIONRESOLVE_V8) 2663{ 2664 int8_t object = READ_INST_8_0(); 2665 2666 auto *thread = vm->GetAssociatedJSThread(); 2667 Address builtinAddress = 2668 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineAsyncfunctionresolveV8); 2669 LOG_INST() << " BaselineAsyncfunctionresolveV8 Address: " << std::hex << builtinAddress; 2670 2671 std::vector<BaselineParameter> parameters; 2672 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2673 parameters.emplace_back(BaselineSpecialParameter::SP); 2674 parameters.emplace_back(BaselineSpecialParameter::ACC); 2675 parameters.emplace_back(VirtualRegister(object)); 2676 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2677 GetBaselineAssembler().SaveResultIntoAcc(); 2678} 2679 2680BYTECODE_BASELINE_HANDLER_IMPLEMENT(ASYNCFUNCTIONREJECT_V8) 2681{ 2682 int8_t object = READ_INST_8_0(); 2683 2684 auto *thread = vm->GetAssociatedJSThread(); 2685 Address builtinAddress = 2686 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineAsyncfunctionrejectV8); 2687 LOG_INST() << " BaselineAsyncfunctionrejectV8 Address: " << std::hex << builtinAddress; 2688 2689 std::vector<BaselineParameter> parameters; 2690 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2691 parameters.emplace_back(BaselineSpecialParameter::SP); 2692 parameters.emplace_back(BaselineSpecialParameter::ACC); 2693 parameters.emplace_back(VirtualRegister(object)); 2694 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2695 GetBaselineAssembler().SaveResultIntoAcc(); 2696} 2697 2698BYTECODE_BASELINE_HANDLER_IMPLEMENT(COPYDATAPROPERTIES_V8) 2699{ 2700 int8_t object = READ_INST_8_0(); 2701 2702 auto *thread = vm->GetAssociatedJSThread(); 2703 Address builtinAddress = 2704 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCopydatapropertiesV8); 2705 LOG_INST() << " BaselineCopydatapropertiesV8 Address: " << std::hex << builtinAddress; 2706 2707 std::vector<BaselineParameter> parameters; 2708 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2709 parameters.emplace_back(BaselineSpecialParameter::SP); 2710 parameters.emplace_back(BaselineSpecialParameter::ACC); 2711 parameters.emplace_back(VirtualRegister(object)); 2712 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2713 GetBaselineAssembler().SaveResultIntoAcc(); 2714} 2715 2716BYTECODE_BASELINE_HANDLER_IMPLEMENT(COPYRESTARGS_IMM8) 2717{ 2718 uint8_t restIdx = READ_INST_8_0(); 2719 2720 auto *thread = vm->GetAssociatedJSThread(); 2721 Address builtinAddress = 2722 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCopyrestargsImm8); 2723 LOG_INST() << " BaselineCopyrestargsImm8 Address: " << std::hex << builtinAddress; 2724 LOG_INST() << " restIdx: " << static_cast<int32_t>(restIdx); 2725 2726 std::vector<BaselineParameter> parameters; 2727 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2728 parameters.emplace_back(BaselineSpecialParameter::SP); 2729 parameters.emplace_back(BaselineSpecialParameter::ACC); 2730 parameters.emplace_back(static_cast<int32_t>(restIdx)); 2731 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2732 GetBaselineAssembler().SaveResultIntoAcc(); 2733} 2734 2735BYTECODE_BASELINE_HANDLER_IMPLEMENT(DYNAMICIMPORT) 2736{ 2737 (void)bytecodeArray; 2738 2739 auto *thread = vm->GetAssociatedJSThread(); 2740 Address builtinAddress = 2741 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDynamicimport); 2742 LOG_INST() << " BaselineDynamicimport Address: " << std::hex << builtinAddress; 2743 2744 std::vector<BaselineParameter> parameters; 2745 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2746 parameters.emplace_back(BaselineSpecialParameter::SP); 2747 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2748 GetBaselineAssembler().SaveResultIntoAcc(); 2749} 2750 2751BYTECODE_BASELINE_HANDLER_IMPLEMENT(RESUMEGENERATOR) 2752{ 2753 (void)bytecodeArray; 2754 2755 auto *thread = vm->GetAssociatedJSThread(); 2756 Address builtinAddress = 2757 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineResumegenerator); 2758 LOG_INST() << " BaselineResumegenerator Address: " << std::hex << builtinAddress; 2759 2760 std::vector<BaselineParameter> parameters; 2761 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2762 parameters.emplace_back(BaselineSpecialParameter::SP); 2763 parameters.emplace_back(BaselineSpecialParameter::ACC); 2764 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2765 GetBaselineAssembler().SaveResultIntoAcc(); 2766} 2767 2768BYTECODE_BASELINE_HANDLER_IMPLEMENT(RETURNUNDEFINED) 2769{ 2770 auto offset = static_cast<int32_t>(bytecodeArray - firstPC); 2771 auto *thread = vm->GetAssociatedJSThread(); 2772 Address builtinAddress = 2773 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineReturnundefined); 2774 LOG_INST() << " BaselineReturnundefined Address: " << std::hex << builtinAddress; 2775 2776 std::vector<BaselineParameter> parameters; 2777 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2778 parameters.emplace_back(BaselineSpecialParameter::SP); 2779 parameters.emplace_back(offset); 2780 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2781} 2782 2783BYTECODE_BASELINE_HANDLER_IMPLEMENT(RETURN) 2784{ 2785 auto offset = static_cast<int32_t>(bytecodeArray - firstPC); 2786 2787 auto *thread = vm->GetAssociatedJSThread(); 2788 Address builtinAddress = 2789 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineReturn); 2790 LOG_INST() << " BaselineReturn Address: " << std::hex << builtinAddress; 2791 2792 std::vector<BaselineParameter> parameters; 2793 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2794 parameters.emplace_back(BaselineSpecialParameter::SP); 2795 parameters.emplace_back(offset); 2796 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2797} 2798// ------- End parse bytecodes about functions ------- 2799 2800// ------- parse bytecodes about arithmetic ------- 2801BYTECODE_BASELINE_HANDLER_IMPLEMENT(ADD2_IMM8_V8) 2802{ 2803 uint8_t vLeftId = READ_INST_8_1(); 2804 uint8_t slotId = READ_INST_8_0(); 2805 2806 auto *thread = vm->GetAssociatedJSThread(); 2807 Address builtinAddress = 2808 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineAdd2Imm8V8); 2809 LOG_INST() << " BaselineAdd2Imm8V8 Address: " << std::hex << builtinAddress; 2810 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 2811 2812 std::vector<BaselineParameter> parameters; 2813 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2814 parameters.emplace_back(BaselineSpecialParameter::SP); 2815 parameters.emplace_back(VirtualRegister(vLeftId)); 2816 parameters.emplace_back(static_cast<int32_t>(slotId)); 2817 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2818 GetBaselineAssembler().SaveResultIntoAcc(); 2819} 2820 2821BYTECODE_BASELINE_HANDLER_IMPLEMENT(SUB2_IMM8_V8) 2822{ 2823 uint8_t vLeftId = READ_INST_8_1(); 2824 uint8_t slotId = READ_INST_8_0(); 2825 2826 auto *thread = vm->GetAssociatedJSThread(); 2827 Address builtinAddress = 2828 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineSub2Imm8V8); 2829 LOG_INST() << " BaselineSub2Imm8V8 Address: " << std::hex << builtinAddress; 2830 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 2831 2832 std::vector<BaselineParameter> parameters; 2833 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2834 parameters.emplace_back(BaselineSpecialParameter::SP); 2835 parameters.emplace_back(VirtualRegister(vLeftId)); 2836 parameters.emplace_back(static_cast<int32_t>(slotId)); 2837 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2838 GetBaselineAssembler().SaveResultIntoAcc(); 2839} 2840 2841BYTECODE_BASELINE_HANDLER_IMPLEMENT(MUL2_IMM8_V8) 2842{ 2843 uint8_t vLeftId = READ_INST_8_1(); 2844 uint8_t slotId = READ_INST_8_0(); 2845 2846 auto *thread = vm->GetAssociatedJSThread(); 2847 Address builtinAddress = 2848 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineMul2Imm8V8); 2849 LOG_INST() << " BaselineMul2Imm8V8 Address: " << std::hex << builtinAddress; 2850 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 2851 2852 std::vector<BaselineParameter> parameters; 2853 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2854 parameters.emplace_back(BaselineSpecialParameter::SP); 2855 parameters.emplace_back(VirtualRegister(vLeftId)); 2856 parameters.emplace_back(static_cast<int32_t>(slotId)); 2857 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2858 GetBaselineAssembler().SaveResultIntoAcc(); 2859} 2860 2861BYTECODE_BASELINE_HANDLER_IMPLEMENT(DIV2_IMM8_V8) 2862{ 2863 uint8_t vLeftId = READ_INST_8_1(); 2864 uint8_t slotId = READ_INST_8_0(); 2865 2866 auto *thread = vm->GetAssociatedJSThread(); 2867 Address builtinAddress = 2868 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDiv2Imm8V8); 2869 LOG_INST() << " BaselineDiv2Imm8V8 Address: " << std::hex << builtinAddress; 2870 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 2871 2872 std::vector<BaselineParameter> parameters; 2873 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2874 parameters.emplace_back(BaselineSpecialParameter::SP); 2875 parameters.emplace_back(VirtualRegister(vLeftId)); 2876 parameters.emplace_back(static_cast<int32_t>(slotId)); 2877 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2878 GetBaselineAssembler().SaveResultIntoAcc(); 2879} 2880 2881BYTECODE_BASELINE_HANDLER_IMPLEMENT(MOD2_IMM8_V8) 2882{ 2883 uint8_t vLeftId = READ_INST_8_1(); 2884 uint8_t slotId = READ_INST_8_0(); 2885 2886 auto *thread = vm->GetAssociatedJSThread(); 2887 Address builtinAddress = 2888 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineMod2Imm8V8); 2889 LOG_INST() << " BaselineMod2Imm8V8 Address: " << std::hex << builtinAddress; 2890 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 2891 2892 std::vector<BaselineParameter> parameters; 2893 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2894 parameters.emplace_back(BaselineSpecialParameter::SP); 2895 parameters.emplace_back(VirtualRegister(vLeftId)); 2896 parameters.emplace_back(static_cast<int32_t>(slotId)); 2897 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2898 GetBaselineAssembler().SaveResultIntoAcc(); 2899} 2900 2901BYTECODE_BASELINE_HANDLER_IMPLEMENT(SHL2_IMM8_V8) 2902{ 2903 uint8_t vLeftId = READ_INST_8_1(); 2904 uint8_t slotId = READ_INST_8_0(); 2905 2906 auto *thread = vm->GetAssociatedJSThread(); 2907 Address builtinAddress = 2908 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineShl2Imm8V8); 2909 LOG_INST() << " BaselineShl2Imm8V8 Address: " << std::hex << builtinAddress; 2910 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 2911 2912 std::vector<BaselineParameter> parameters; 2913 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2914 parameters.emplace_back(BaselineSpecialParameter::SP); 2915 parameters.emplace_back(VirtualRegister(vLeftId)); 2916 parameters.emplace_back(static_cast<int32_t>(slotId)); 2917 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2918 GetBaselineAssembler().SaveResultIntoAcc(); 2919} 2920 2921BYTECODE_BASELINE_HANDLER_IMPLEMENT(SHR2_IMM8_V8) 2922{ 2923 uint8_t vLeftId = READ_INST_8_1(); 2924 uint8_t slotId = READ_INST_8_0(); 2925 2926 auto *thread = vm->GetAssociatedJSThread(); 2927 Address builtinAddress = 2928 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineShr2Imm8V8); 2929 LOG_INST() << " BaselineShr2Imm8V8 Address: " << std::hex << builtinAddress; 2930 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 2931 2932 std::vector<BaselineParameter> parameters; 2933 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2934 parameters.emplace_back(BaselineSpecialParameter::SP); 2935 parameters.emplace_back(VirtualRegister(vLeftId)); 2936 parameters.emplace_back(static_cast<int32_t>(slotId)); 2937 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2938 GetBaselineAssembler().SaveResultIntoAcc(); 2939} 2940 2941BYTECODE_BASELINE_HANDLER_IMPLEMENT(ASHR2_IMM8_V8) 2942{ 2943 uint8_t vLeftId = READ_INST_8_1(); 2944 uint8_t slotId = READ_INST_8_0(); 2945 2946 auto *thread = vm->GetAssociatedJSThread(); 2947 Address builtinAddress = 2948 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineAshr2Imm8V8); 2949 LOG_INST() << " BaselineAshr2Imm8V8 Address: " << std::hex << builtinAddress; 2950 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 2951 2952 std::vector<BaselineParameter> parameters; 2953 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2954 parameters.emplace_back(BaselineSpecialParameter::SP); 2955 parameters.emplace_back(VirtualRegister(vLeftId)); 2956 parameters.emplace_back(static_cast<int32_t>(slotId)); 2957 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2958 GetBaselineAssembler().SaveResultIntoAcc(); 2959} 2960 2961BYTECODE_BASELINE_HANDLER_IMPLEMENT(AND2_IMM8_V8) 2962{ 2963 uint8_t vLeftId = READ_INST_8_1(); 2964 uint8_t slotId = READ_INST_8_0(); 2965 2966 auto *thread = vm->GetAssociatedJSThread(); 2967 Address builtinAddress = 2968 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineAnd2Imm8V8); 2969 LOG_INST() << " BaselineAnd2Imm8V8 Address: " << std::hex << builtinAddress; 2970 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 2971 2972 std::vector<BaselineParameter> parameters; 2973 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2974 parameters.emplace_back(BaselineSpecialParameter::SP); 2975 parameters.emplace_back(VirtualRegister(vLeftId)); 2976 parameters.emplace_back(static_cast<int32_t>(slotId)); 2977 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2978 GetBaselineAssembler().SaveResultIntoAcc(); 2979} 2980 2981BYTECODE_BASELINE_HANDLER_IMPLEMENT(OR2_IMM8_V8) 2982{ 2983 uint8_t vLeftId = READ_INST_8_1(); 2984 uint8_t slotId = READ_INST_8_0(); 2985 2986 auto *thread = vm->GetAssociatedJSThread(); 2987 Address builtinAddress = 2988 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineOr2Imm8V8); 2989 LOG_INST() << " BaselineOr2Imm8V8 Address: " << std::hex << builtinAddress; 2990 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 2991 2992 std::vector<BaselineParameter> parameters; 2993 parameters.emplace_back(BaselineSpecialParameter::GLUE); 2994 parameters.emplace_back(BaselineSpecialParameter::SP); 2995 parameters.emplace_back(VirtualRegister(vLeftId)); 2996 parameters.emplace_back(static_cast<int32_t>(slotId)); 2997 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 2998 GetBaselineAssembler().SaveResultIntoAcc(); 2999} 3000 3001BYTECODE_BASELINE_HANDLER_IMPLEMENT(XOR2_IMM8_V8) 3002{ 3003 uint8_t vLeftId = READ_INST_8_1(); 3004 uint8_t slotId = READ_INST_8_0(); 3005 3006 auto *thread = vm->GetAssociatedJSThread(); 3007 Address builtinAddress = 3008 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineXor2Imm8V8); 3009 LOG_INST() << " BaselineXor2Imm8V8 Address: " << std::hex << builtinAddress; 3010 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 3011 3012 std::vector<BaselineParameter> parameters; 3013 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3014 parameters.emplace_back(BaselineSpecialParameter::SP); 3015 parameters.emplace_back(VirtualRegister(vLeftId)); 3016 parameters.emplace_back(static_cast<int32_t>(slotId)); 3017 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3018 GetBaselineAssembler().SaveResultIntoAcc(); 3019} 3020 3021BYTECODE_BASELINE_HANDLER_IMPLEMENT(EXP_IMM8_V8) 3022{ 3023 uint8_t vBaseId = READ_INST_8_1(); 3024 3025 auto *thread = vm->GetAssociatedJSThread(); 3026 Address builtinAddress = 3027 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineExpImm8V8); 3028 LOG_INST() << " BaselineExpImm8V8 Address: " << std::hex << builtinAddress; 3029 3030 std::vector<BaselineParameter> parameters; 3031 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3032 parameters.emplace_back(BaselineSpecialParameter::SP); 3033 parameters.emplace_back(VirtualRegister(vBaseId)); 3034 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3035 GetBaselineAssembler().SaveResultIntoAcc(); 3036} 3037 3038BYTECODE_BASELINE_HANDLER_IMPLEMENT(NEG_IMM8) 3039{ 3040 uint8_t slotId = READ_INST_8_0(); 3041 auto *thread = vm->GetAssociatedJSThread(); 3042 Address builtinAddress = 3043 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineNegImm8); 3044 LOG_INST() << " BaselineNegImm8 Address: " << std::hex << builtinAddress; 3045 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 3046 3047 std::vector<BaselineParameter> parameters; 3048 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3049 parameters.emplace_back(BaselineSpecialParameter::SP); 3050 parameters.emplace_back(static_cast<int32_t>(slotId)); 3051 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3052 GetBaselineAssembler().SaveResultIntoAcc(); 3053} 3054 3055BYTECODE_BASELINE_HANDLER_IMPLEMENT(NOT_IMM8) 3056{ 3057 uint8_t slotId = READ_INST_8_0(); 3058 auto *thread = vm->GetAssociatedJSThread(); 3059 Address builtinAddress = 3060 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineNotImm8); 3061 LOG_INST() << " BaselineNotImm8 Address: " << std::hex << builtinAddress; 3062 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 3063 3064 std::vector<BaselineParameter> parameters; 3065 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3066 parameters.emplace_back(BaselineSpecialParameter::SP); 3067 parameters.emplace_back(static_cast<int32_t>(slotId)); 3068 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3069 GetBaselineAssembler().SaveResultIntoAcc(); 3070} 3071 3072BYTECODE_BASELINE_HANDLER_IMPLEMENT(INC_IMM8) 3073{ 3074 uint8_t slotId = READ_INST_8_0(); 3075 auto *thread = vm->GetAssociatedJSThread(); 3076 Address builtinAddress = 3077 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineIncImm8); 3078 LOG_INST() << " BaselineIncImm8 Address: " << std::hex << builtinAddress; 3079 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 3080 3081 std::vector<BaselineParameter> parameters; 3082 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3083 parameters.emplace_back(BaselineSpecialParameter::SP); 3084 parameters.emplace_back(static_cast<int32_t>(slotId)); 3085 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3086 GetBaselineAssembler().SaveResultIntoAcc(); 3087} 3088 3089BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEC_IMM8) 3090{ 3091 uint8_t slotId = READ_INST_8_0(); 3092 auto *thread = vm->GetAssociatedJSThread(); 3093 Address builtinAddress = 3094 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDecImm8); 3095 LOG_INST() << " BaselineDecImm8 Address: " << std::hex << builtinAddress; 3096 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 3097 3098 std::vector<BaselineParameter> parameters; 3099 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3100 parameters.emplace_back(BaselineSpecialParameter::SP); 3101 parameters.emplace_back(static_cast<int32_t>(slotId)); 3102 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3103 GetBaselineAssembler().SaveResultIntoAcc(); 3104} 3105 3106BYTECODE_BASELINE_HANDLER_IMPLEMENT(TONUMBER_IMM8) 3107{ 3108 (void)bytecodeArray; 3109 3110 auto *thread = vm->GetAssociatedJSThread(); 3111 Address builtinAddress = 3112 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineTonumberImm8); 3113 LOG_INST() << " BaselineTonumberImm8 Address: " << std::hex << builtinAddress; 3114 3115 std::vector<BaselineParameter> parameters; 3116 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3117 parameters.emplace_back(BaselineSpecialParameter::SP); 3118 parameters.emplace_back(BaselineSpecialParameter::ACC); 3119 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3120 GetBaselineAssembler().SaveResultIntoAcc(); 3121} 3122 3123BYTECODE_BASELINE_HANDLER_IMPLEMENT(TONUMERIC_IMM8) 3124{ 3125 (void)bytecodeArray; 3126 3127 auto *thread = vm->GetAssociatedJSThread(); 3128 Address builtinAddress = 3129 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineTonumericImm8); 3130 LOG_INST() << " BaselineTonumericImm8 Address: " << std::hex << builtinAddress; 3131 3132 std::vector<BaselineParameter> parameters; 3133 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3134 parameters.emplace_back(BaselineSpecialParameter::SP); 3135 parameters.emplace_back(BaselineSpecialParameter::ACC); 3136 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3137 GetBaselineAssembler().SaveResultIntoAcc(); 3138} 3139// ------- End parse bytecodes about arithmetic ------- 3140 3141// ------- parse bytecodes about comparison and check ------- 3142BYTECODE_BASELINE_HANDLER_IMPLEMENT(EQ_IMM8_V8) 3143{ 3144 uint8_t vLeftId = READ_INST_8_1(); 3145 uint8_t slotId = READ_INST_8_0(); 3146 3147 auto *thread = vm->GetAssociatedJSThread(); 3148 Address builtinAddress = 3149 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineEqImm8V8); 3150 LOG_INST() << " BaselineEqImm8V8 Address: " << std::hex << builtinAddress; 3151 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 3152 3153 std::vector<BaselineParameter> parameters; 3154 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3155 parameters.emplace_back(BaselineSpecialParameter::SP); 3156 parameters.emplace_back(VirtualRegister(vLeftId)); 3157 parameters.emplace_back(static_cast<int32_t>(slotId)); 3158 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3159 GetBaselineAssembler().SaveResultIntoAcc(); 3160} 3161 3162BYTECODE_BASELINE_HANDLER_IMPLEMENT(NOTEQ_IMM8_V8) 3163{ 3164 uint8_t vLeftId = READ_INST_8_1(); 3165 uint8_t slotId = READ_INST_8_0(); 3166 3167 auto *thread = vm->GetAssociatedJSThread(); 3168 Address builtinAddress = 3169 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineNoteqImm8V8); 3170 LOG_INST() << " BaselineNoteqImm8V8 Address: " << std::hex << builtinAddress; 3171 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 3172 3173 std::vector<BaselineParameter> parameters; 3174 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3175 parameters.emplace_back(BaselineSpecialParameter::SP); 3176 parameters.emplace_back(VirtualRegister(vLeftId)); 3177 parameters.emplace_back(static_cast<int32_t>(slotId)); 3178 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3179 GetBaselineAssembler().SaveResultIntoAcc(); 3180} 3181 3182BYTECODE_BASELINE_HANDLER_IMPLEMENT(LESS_IMM8_V8) 3183{ 3184 uint8_t vLeftId = READ_INST_8_1(); 3185 uint8_t slotId = READ_INST_8_0(); 3186 3187 auto *thread = vm->GetAssociatedJSThread(); 3188 Address builtinAddress = 3189 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLessImm8V8); 3190 LOG_INST() << " BaselineLessImm8V8 Address: " << std::hex << builtinAddress; 3191 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 3192 3193 std::vector<BaselineParameter> parameters; 3194 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3195 parameters.emplace_back(BaselineSpecialParameter::SP); 3196 parameters.emplace_back(VirtualRegister(vLeftId)); 3197 parameters.emplace_back(static_cast<int32_t>(slotId)); 3198 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3199 GetBaselineAssembler().SaveResultIntoAcc(); 3200} 3201 3202BYTECODE_BASELINE_HANDLER_IMPLEMENT(LESSEQ_IMM8_V8) 3203{ 3204 uint8_t vLeftId = READ_INST_8_1(); 3205 uint8_t slotId = READ_INST_8_0(); 3206 3207 auto *thread = vm->GetAssociatedJSThread(); 3208 Address builtinAddress = 3209 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLesseqImm8V8); 3210 LOG_INST() << " BaselineLesseqImm8V8 Address: " << std::hex << builtinAddress; 3211 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 3212 3213 std::vector<BaselineParameter> parameters; 3214 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3215 parameters.emplace_back(BaselineSpecialParameter::SP); 3216 parameters.emplace_back(VirtualRegister(vLeftId)); 3217 parameters.emplace_back(static_cast<int32_t>(slotId)); 3218 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3219 GetBaselineAssembler().SaveResultIntoAcc(); 3220} 3221 3222BYTECODE_BASELINE_HANDLER_IMPLEMENT(GREATER_IMM8_V8) 3223{ 3224 uint8_t vLeftId = READ_INST_8_1(); 3225 uint8_t slotId = READ_INST_8_0(); 3226 3227 auto *thread = vm->GetAssociatedJSThread(); 3228 Address builtinAddress = 3229 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineGreaterImm8V8); 3230 LOG_INST() << " BaselineGreaterImm8V8 Address: " << std::hex << builtinAddress; 3231 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 3232 3233 std::vector<BaselineParameter> parameters; 3234 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3235 parameters.emplace_back(BaselineSpecialParameter::SP); 3236 parameters.emplace_back(VirtualRegister(vLeftId)); 3237 parameters.emplace_back(static_cast<int32_t>(slotId)); 3238 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3239 GetBaselineAssembler().SaveResultIntoAcc(); 3240} 3241 3242BYTECODE_BASELINE_HANDLER_IMPLEMENT(GREATEREQ_IMM8_V8) 3243{ 3244 uint8_t vLeftId = READ_INST_8_1(); 3245 uint8_t slotId = READ_INST_8_0(); 3246 3247 auto *thread = vm->GetAssociatedJSThread(); 3248 Address builtinAddress = 3249 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineGreatereqImm8V8); 3250 LOG_INST() << " BaselineGreatereqImm8V8 Address: " << std::hex << builtinAddress; 3251 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 3252 3253 std::vector<BaselineParameter> parameters; 3254 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3255 parameters.emplace_back(BaselineSpecialParameter::SP); 3256 parameters.emplace_back(VirtualRegister(vLeftId)); 3257 parameters.emplace_back(static_cast<int32_t>(slotId)); 3258 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3259 GetBaselineAssembler().SaveResultIntoAcc(); 3260} 3261 3262BYTECODE_BASELINE_HANDLER_IMPLEMENT(ISIN_IMM8_V8) 3263{ 3264 uint8_t vSrcId = READ_INST_8_1(); 3265 3266 auto *thread = vm->GetAssociatedJSThread(); 3267 Address builtinAddress = 3268 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineIsinImm8V8); 3269 LOG_INST() << " BaselineIsinImm8V8 Address: " << std::hex << builtinAddress; 3270 3271 std::vector<BaselineParameter> parameters; 3272 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3273 parameters.emplace_back(BaselineSpecialParameter::SP); 3274 parameters.emplace_back(BaselineSpecialParameter::ACC); 3275 parameters.emplace_back(VirtualRegister(vSrcId)); 3276 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3277 GetBaselineAssembler().SaveResultIntoAcc(); 3278} 3279 3280BYTECODE_BASELINE_HANDLER_IMPLEMENT(INSTANCEOF_IMM8_V8) 3281{ 3282 uint8_t slotId = READ_INST_8_0(); 3283 uint8_t vObjId = READ_INST_8_1(); 3284 3285 auto *thread = vm->GetAssociatedJSThread(); 3286 Address builtinAddress = 3287 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineInstanceofImm8V8); 3288 LOG_INST() << " BaselineInstanceofImm8V8 Address: " << std::hex << builtinAddress; 3289 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 3290 3291 std::vector<BaselineParameter> parameters; 3292 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3293 parameters.emplace_back(BaselineSpecialParameter::SP); 3294 parameters.emplace_back(static_cast<int32_t>(vObjId)); 3295 parameters.emplace_back(static_cast<int32_t>(slotId)); 3296 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3297 GetBaselineAssembler().SaveResultIntoAcc(); 3298} 3299 3300BYTECODE_BASELINE_HANDLER_IMPLEMENT(STRICTNOTEQ_IMM8_V8) 3301{ 3302 uint8_t slotId = READ_INST_8_0(); 3303 uint8_t vLeftId = READ_INST_8_1(); 3304 3305 auto *thread = vm->GetAssociatedJSThread(); 3306 Address builtinAddress = 3307 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStrictnoteqImm8V8); 3308 LOG_INST() << " BaselineStrictnoteqImm8V8 Address: " << std::hex << builtinAddress; 3309 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 3310 3311 std::vector<BaselineParameter> parameters; 3312 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3313 parameters.emplace_back(BaselineSpecialParameter::SP); 3314 parameters.emplace_back(VirtualRegister(vLeftId)); 3315 parameters.emplace_back(static_cast<int32_t>(slotId)); 3316 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3317 GetBaselineAssembler().SaveResultIntoAcc(); 3318} 3319 3320BYTECODE_BASELINE_HANDLER_IMPLEMENT(STRICTEQ_IMM8_V8) 3321{ 3322 uint8_t slotId = READ_INST_8_0(); 3323 uint8_t vLeftId = READ_INST_8_1(); 3324 3325 auto *thread = vm->GetAssociatedJSThread(); 3326 Address builtinAddress = 3327 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStricteqImm8V8); 3328 LOG_INST() << " BaselineStricteqImm8V8 Address: " << std::hex << builtinAddress; 3329 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 3330 3331 std::vector<BaselineParameter> parameters; 3332 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3333 parameters.emplace_back(BaselineSpecialParameter::SP); 3334 parameters.emplace_back(VirtualRegister(vLeftId)); 3335 parameters.emplace_back(static_cast<int32_t>(slotId)); 3336 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3337 GetBaselineAssembler().SaveResultIntoAcc(); 3338} 3339 3340BYTECODE_BASELINE_HANDLER_IMPLEMENT(ISTRUE) 3341{ 3342 (void)bytecodeArray; 3343 3344 auto *thread = vm->GetAssociatedJSThread(); 3345 Address builtinAddress = 3346 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineIstrue); 3347 LOG_INST() << " BaselineIstrue Address: " << std::hex << builtinAddress; 3348 3349 std::vector<BaselineParameter> parameters; 3350 parameters.emplace_back(BaselineSpecialParameter::ACC); 3351 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3352 GetBaselineAssembler().SaveResultIntoAcc(); 3353} 3354 3355BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_ISTRUE_PREF_IMM8) 3356{ 3357 uint8_t slotId = READ_INST_8_1(); 3358 3359 auto *thread = vm->GetAssociatedJSThread(); 3360 Address builtinAddress = 3361 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCallRuntimeIstruePrefImm8); 3362 LOG_INST() << " BaselineCallRuntimeIstruePrefImm8 Address: " << std::hex << builtinAddress; 3363 3364 std::vector<BaselineParameter> parameters; 3365 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3366 parameters.emplace_back(BaselineSpecialParameter::SP); 3367 parameters.emplace_back(BaselineSpecialParameter::ACC); 3368 parameters.emplace_back(static_cast<int32_t>(slotId)); 3369 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3370 GetBaselineAssembler().SaveResultIntoAcc(); 3371} 3372 3373BYTECODE_BASELINE_HANDLER_IMPLEMENT(ISFALSE) 3374{ 3375 (void)bytecodeArray; 3376 3377 auto *thread = vm->GetAssociatedJSThread(); 3378 Address builtinAddress = 3379 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineIsfalse); 3380 LOG_INST() << " BaselineIsfalse Address: " << std::hex << builtinAddress; 3381 3382 std::vector<BaselineParameter> parameters; 3383 parameters.emplace_back(BaselineSpecialParameter::ACC); 3384 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3385 GetBaselineAssembler().SaveResultIntoAcc(); 3386} 3387 3388BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_ISFALSE_PREF_IMM8) 3389{ 3390 uint8_t slotId = READ_INST_8_1(); 3391 3392 auto *thread = vm->GetAssociatedJSThread(); 3393 Address builtinAddress = 3394 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCallRuntimeIsfalsePrefImm8); 3395 LOG_INST() << " BaselineCallRuntimeIsfalsePrefImm8 Address: " << std::hex << builtinAddress; 3396 3397 std::vector<BaselineParameter> parameters; 3398 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3399 parameters.emplace_back(BaselineSpecialParameter::SP); 3400 parameters.emplace_back(BaselineSpecialParameter::ACC); 3401 parameters.emplace_back(static_cast<int32_t>(slotId)); 3402 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3403 GetBaselineAssembler().SaveResultIntoAcc(); 3404} 3405 3406// ------- End parse bytecodes about comparison ------- 3407 3408// ------- parse bytecodes about control flow ------- 3409BYTECODE_BASELINE_HANDLER_IMPLEMENT(JEQZ_IMM8) 3410{ 3411 int8_t offset = static_cast<int8_t>(READ_INST_8_0()); 3412 size_t pos = offset + bytecodeOffset; 3413 3414 JumpLabel *jump = nullptr; 3415 if (jumpMap.count(pos) != 0) { 3416 jump = jumpMap.at(pos); 3417 } else { 3418 jump = new JumpLabel(); 3419 jumpMap.insert({pos, jump}); 3420 } 3421 3422 GetBaselineAssembler().Cmp(SpecialRegister::ACC_REGISTER, Immediate(JSTaggedValue::VALUE_FALSE)); 3423 JumpLabel exitLabel; 3424 GetBaselineAssembler().Jnz(exitLabel); 3425 CALL_BASELINE_UPDATE_HOTNESS(); 3426 GetBaselineAssembler().Jump(*jump); 3427 GetBaselineAssembler().Bind(exitLabel); 3428} 3429 3430BYTECODE_BASELINE_HANDLER_IMPLEMENT(JEQZ_IMM16) 3431{ 3432 int16_t offset = READ_INST_16_0(); 3433 size_t pos = offset + bytecodeOffset; 3434 3435 JumpLabel *jump = nullptr; 3436 if (jumpMap.count(pos) != 0) { 3437 jump = jumpMap.at(pos); 3438 } else { 3439 jump = new JumpLabel(); 3440 jumpMap.insert({pos, jump}); 3441 } 3442 3443 GetBaselineAssembler().Cmp(SpecialRegister::ACC_REGISTER, Immediate(JSTaggedValue::VALUE_FALSE)); 3444 JumpLabel exitLabel; 3445 GetBaselineAssembler().Jnz(exitLabel); 3446 CALL_BASELINE_UPDATE_HOTNESS(); 3447 GetBaselineAssembler().Jump(*jump); 3448 GetBaselineAssembler().Bind(exitLabel); 3449} 3450 3451BYTECODE_BASELINE_HANDLER_IMPLEMENT(JEQZ_IMM32) 3452{ 3453 int32_t offset = static_cast<int32_t>(READ_INST_32_0()); 3454 size_t pos = static_cast<size_t>(offset + static_cast<int32_t>(bytecodeOffset)); 3455 3456 JumpLabel *jump = nullptr; 3457 if (jumpMap.count(pos) != 0) { 3458 jump = jumpMap.at(pos); 3459 } else { 3460 jump = new JumpLabel(); 3461 jumpMap.insert({pos, jump}); 3462 } 3463 3464 JumpLabel exitLabel; 3465 GetBaselineAssembler().Cmp(SpecialRegister::ACC_REGISTER, Immediate(JSTaggedValue::VALUE_FALSE)); 3466 GetBaselineAssembler().Jnz(exitLabel); 3467 CALL_BASELINE_UPDATE_HOTNESS(); 3468 GetBaselineAssembler().Jump(*jump); 3469 GetBaselineAssembler().Bind(exitLabel); 3470} 3471 3472BYTECODE_BASELINE_HANDLER_IMPLEMENT(JNEZ_IMM8) 3473{ 3474 int8_t offset = READ_INST_8_0(); 3475 size_t pos = offset + bytecodeOffset; 3476 3477 JumpLabel *jump = nullptr; 3478 if (jumpMap.count(pos) != 0) { 3479 jump = jumpMap.at(pos); 3480 } else { 3481 jump = new JumpLabel(); 3482 jumpMap.insert({pos, jump}); 3483 } 3484 3485 GetBaselineAssembler().Cmp(SpecialRegister::ACC_REGISTER, Immediate(JSTaggedValue::VALUE_FALSE)); 3486 JumpLabel labelExit; 3487 GetBaselineAssembler().Jz(labelExit); 3488 3489 CALL_BASELINE_UPDATE_HOTNESS(); 3490 GetBaselineAssembler().Jump(*jump); 3491 3492 GetBaselineAssembler().Bind(labelExit); 3493} 3494 3495BYTECODE_BASELINE_HANDLER_IMPLEMENT(JNEZ_IMM16) 3496{ 3497 int16_t offset = READ_INST_16_0(); 3498 size_t pos = offset + bytecodeOffset; 3499 3500 JumpLabel *jump = nullptr; 3501 if (jumpMap.count(pos) != 0) { 3502 jump = jumpMap.at(pos); 3503 } else { 3504 jump = new JumpLabel(); 3505 jumpMap.insert({pos, jump}); 3506 } 3507 3508 GetBaselineAssembler().Cmp(SpecialRegister::ACC_REGISTER, Immediate(JSTaggedValue::VALUE_FALSE)); 3509 JumpLabel labelExit; 3510 GetBaselineAssembler().Jz(labelExit); 3511 3512 CALL_BASELINE_UPDATE_HOTNESS(); 3513 GetBaselineAssembler().Jump(*jump); 3514 3515 GetBaselineAssembler().Bind(labelExit); 3516} 3517 3518BYTECODE_BASELINE_HANDLER_IMPLEMENT(JNEZ_IMM32) 3519{ 3520 int32_t offset = static_cast<int32_t>(READ_INST_32_0()); 3521 size_t pos = static_cast<size_t>(offset + static_cast<int32_t>(bytecodeOffset)); 3522 3523 JumpLabel *jump = nullptr; 3524 if (jumpMap.count(pos) != 0) { 3525 jump = jumpMap.at(pos); 3526 } else { 3527 jump = new JumpLabel(); 3528 jumpMap.insert({pos, jump}); 3529 } 3530 3531 GetBaselineAssembler().Cmp(SpecialRegister::ACC_REGISTER, Immediate(JSTaggedValue::VALUE_FALSE)); 3532 JumpLabel labelExit; 3533 GetBaselineAssembler().Jz(labelExit); 3534 3535 CALL_BASELINE_UPDATE_HOTNESS(); 3536 GetBaselineAssembler().Jump(*jump); 3537 3538 GetBaselineAssembler().Bind(labelExit); 3539} 3540 3541BYTECODE_BASELINE_HANDLER_IMPLEMENT(JEQ_V8_IMM8) 3542{ 3543 (void)bytecodeArray; 3544} 3545 3546BYTECODE_BASELINE_HANDLER_IMPLEMENT(JEQ_V8_IMM16) 3547{ 3548 (void)bytecodeArray; 3549} 3550 3551BYTECODE_BASELINE_HANDLER_IMPLEMENT(JNE_V8_IMM8) 3552{ 3553 (void)bytecodeArray; 3554} 3555 3556BYTECODE_BASELINE_HANDLER_IMPLEMENT(JNE_V8_IMM16) 3557{ 3558 (void)bytecodeArray; 3559} 3560 3561BYTECODE_BASELINE_HANDLER_IMPLEMENT(JMP_IMM8) 3562{ 3563 int8_t offset = READ_INST_8_0(); 3564 size_t pos = offset + bytecodeOffset; 3565 3566 JumpLabel *jump = nullptr; 3567 if (jumpMap.count(pos) != 0) { 3568 jump = jumpMap.at(pos); 3569 } else { 3570 jump = new JumpLabel(); 3571 jumpMap.insert({pos, jump}); 3572 } 3573 3574 CALL_BASELINE_UPDATE_HOTNESS(); 3575 GetBaselineAssembler().Jump(*jump); 3576} 3577 3578BYTECODE_BASELINE_HANDLER_IMPLEMENT(JMP_IMM16) 3579{ 3580 int16_t offset = READ_INST_16_0(); 3581 size_t pos = offset + bytecodeOffset; 3582 3583 JumpLabel *jump = nullptr; 3584 if (jumpMap.count(pos) != 0) { 3585 jump = jumpMap.at(pos); 3586 } else { 3587 jump = new JumpLabel(); 3588 jumpMap.insert({pos, jump}); 3589 } 3590 3591 CALL_BASELINE_UPDATE_HOTNESS(); 3592 GetBaselineAssembler().Jump(*jump); 3593} 3594 3595BYTECODE_BASELINE_HANDLER_IMPLEMENT(JMP_IMM32) 3596{ 3597 int32_t offset = static_cast<int32_t>(READ_INST_32_0()); 3598 size_t pos = static_cast<size_t>(offset + static_cast<int32_t>(bytecodeOffset)); 3599 3600 JumpLabel *jump = nullptr; 3601 if (jumpMap.count(pos) != 0) { 3602 jump = jumpMap.at(pos); 3603 } else { 3604 jump = new JumpLabel(); 3605 jumpMap.insert({pos, jump}); 3606 } 3607 3608 CALL_BASELINE_UPDATE_HOTNESS(); 3609 GetBaselineAssembler().Jump(*jump); 3610} 3611 3612BYTECODE_BASELINE_HANDLER_IMPLEMENT(JEQNULL_IMM8) 3613{ 3614 (void)bytecodeArray; 3615} 3616 3617BYTECODE_BASELINE_HANDLER_IMPLEMENT(JEQNULL_IMM16) 3618{ 3619 (void)bytecodeArray; 3620} 3621 3622BYTECODE_BASELINE_HANDLER_IMPLEMENT(JNENULL_IMM8) 3623{ 3624 (void)bytecodeArray; 3625} 3626 3627BYTECODE_BASELINE_HANDLER_IMPLEMENT(JNENULL_IMM16) 3628{ 3629 (void)bytecodeArray; 3630} 3631 3632BYTECODE_BASELINE_HANDLER_IMPLEMENT(JSTRICTEQZ_IMM8) 3633{ 3634 (void)bytecodeArray; 3635} 3636 3637BYTECODE_BASELINE_HANDLER_IMPLEMENT(JSTRICTEQZ_IMM16) 3638{ 3639 (void)bytecodeArray; 3640} 3641 3642BYTECODE_BASELINE_HANDLER_IMPLEMENT(JNSTRICTEQZ_IMM8) 3643{ 3644 (void)bytecodeArray; 3645} 3646 3647BYTECODE_BASELINE_HANDLER_IMPLEMENT(JNSTRICTEQZ_IMM16) 3648{ 3649 (void)bytecodeArray; 3650} 3651 3652BYTECODE_BASELINE_HANDLER_IMPLEMENT(JSTRICTEQNULL_IMM8) 3653{ 3654 (void)bytecodeArray; 3655} 3656 3657BYTECODE_BASELINE_HANDLER_IMPLEMENT(JSTRICTEQNULL_IMM16) 3658{ 3659 (void)bytecodeArray; 3660} 3661 3662BYTECODE_BASELINE_HANDLER_IMPLEMENT(JNSTRICTEQNULL_IMM8) 3663{ 3664 (void)bytecodeArray; 3665} 3666// ------- End parse bytecodes about control flow ------- 3667 3668// ------- parse other bytecodes ------- 3669BYTECODE_BASELINE_HANDLER_IMPLEMENT(POPLEXENV) 3670{ 3671 (void)bytecodeArray; 3672 3673 auto *thread = vm->GetAssociatedJSThread(); 3674 Address builtinAddress = 3675 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselinePoplexenv); 3676 LOG_INST() << " BaselinePoplexenv Address: " << std::hex << builtinAddress; 3677 3678 std::vector<BaselineParameter> parameters; 3679 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3680 parameters.emplace_back(BaselineSpecialParameter::SP); // state 3681 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3682} 3683 3684BYTECODE_BASELINE_HANDLER_IMPLEMENT(CREATEASYNCGENERATOROBJ_V8) 3685{ 3686 uint8_t func = READ_INST_8_0(); 3687 LOG_INST() << " createasyncgeneratorobj v" << std::dec << func; 3688 3689 auto *thread = vm->GetAssociatedJSThread(); 3690 Address builtinAddress = 3691 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCreateasyncgeneratorobjV8); 3692 LOG_INST() << " BaselineCreateasyncgeneratorobjV8 Address: " << std::hex << builtinAddress; 3693 3694 std::vector<BaselineParameter> parameters; 3695 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3696 parameters.emplace_back(BaselineSpecialParameter::SP); 3697 parameters.emplace_back(VirtualRegister(func)); 3698 parameters.emplace_back(BaselineSpecialParameter::ACC); 3699 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3700 GetBaselineAssembler().SaveResultIntoAcc(); 3701} 3702 3703BYTECODE_BASELINE_HANDLER_IMPLEMENT(DELOBJPROP_V8) 3704{ 3705 int8_t object = READ_INST_8_0(); 3706 3707 auto *thread = vm->GetAssociatedJSThread(); 3708 Address builtinAddress = 3709 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDelobjpropV8); 3710 LOG_INST() << " BaselineDelobjpropV8 Address: " << std::hex << builtinAddress; 3711 3712 std::vector<BaselineParameter> parameters; 3713 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3714 parameters.emplace_back(BaselineSpecialParameter::SP); 3715 parameters.emplace_back(BaselineSpecialParameter::ACC); 3716 parameters.emplace_back(VirtualRegister(object)); 3717 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3718 GetBaselineAssembler().SaveResultIntoAcc(); 3719} 3720 3721BYTECODE_BASELINE_HANDLER_IMPLEMENT(SUSPENDGENERATOR_V8) 3722{ 3723 uint8_t v0 = READ_INST_8_0(); 3724 auto offset = static_cast<int32_t>(bytecodeArray - firstPC); 3725 auto *thread = vm->GetAssociatedJSThread(); 3726 Address builtinAddress = 3727 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineSuspendgeneratorV8); 3728 LOG_INST() << " BaselineSuspendgeneratorV8 Address: " << std::hex << builtinAddress; 3729 3730 std::vector<BaselineParameter> parameters; 3731 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3732 parameters.emplace_back(BaselineSpecialParameter::SP); 3733 parameters.emplace_back(offset); 3734 parameters.emplace_back(static_cast<int32_t>(v0)); 3735 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3736} 3737 3738BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEBUGGER) 3739{ 3740 (void)bytecodeArray; 3741 3742 auto *thread = vm->GetAssociatedJSThread(); 3743 Address builtinAddress = 3744 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDebugger); 3745 LOG_INST() << " BaselineDebugger Address: " << std::hex << builtinAddress; 3746 3747 std::vector<BaselineParameter> parameters; 3748 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3749 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3750} 3751 3752// ------- parse wide bytecodes ------- 3753// GLUE, SP, V0, INDEX, SLOT_ID 3754BYTECODE_BASELINE_HANDLER_IMPLEMENT(WIDE_STOBJBYINDEX_PREF_V8_IMM32) 3755{ 3756 uint8_t slotId = READ_INST_8_0(); 3757 uint8_t v0 = READ_INST_8_1(); 3758 int32_t index = static_cast<int32_t>(READ_INST_32_2()); 3759 auto *thread = vm->GetAssociatedJSThread(); 3760 Address builtinAddress = 3761 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineWideStobjbyindexPrefV8Imm32); 3762 LOG_INST() << " BaselineWideStobjbyindexPrefV8Imm32 Address: " << std::hex << builtinAddress; 3763 3764 std::vector<BaselineParameter> parameters; 3765 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3766 parameters.emplace_back(BaselineSpecialParameter::SP); 3767 parameters.emplace_back(static_cast<int32_t>(v0)); 3768 parameters.emplace_back(index); 3769 parameters.emplace_back(static_cast<int32_t>(slotId)); 3770 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3771} 3772 3773// GLUE, SP, ACC, V0, INDEX 3774BYTECODE_BASELINE_HANDLER_IMPLEMENT(WIDE_STOWNBYINDEX_PREF_V8_IMM32) 3775{ 3776 uint8_t slotId = READ_INST_8_0(); 3777 uint8_t v0 = READ_INST_8_1(); 3778 int32_t index = static_cast<int32_t>(READ_INST_32_2()); 3779 auto *thread = vm->GetAssociatedJSThread(); 3780 Address builtinAddress = 3781 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineWideStownbyindexPrefV8Imm32); 3782 LOG_INST() << " BaselineWideStownbyindexPrefV8Imm32 Address: " << std::hex << builtinAddress; 3783 3784 std::vector<BaselineParameter> parameters; 3785 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3786 parameters.emplace_back(BaselineSpecialParameter::SP); 3787 parameters.emplace_back(static_cast<int32_t>(v0)); 3788 parameters.emplace_back(index); 3789 parameters.emplace_back(static_cast<int32_t>(slotId)); 3790 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3791} 3792 3793// GLUE, SP, INDEX 3794BYTECODE_BASELINE_HANDLER_IMPLEMENT(WIDE_COPYRESTARGS_PREF_IMM16) 3795{ 3796 uint16_t index = READ_INST_16_1(); 3797 auto *thread = vm->GetAssociatedJSThread(); 3798 Address builtinAddress = 3799 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineWideCopyrestargsPrefImm16); 3800 LOG_INST() << " BaselineWideCopyrestargsPrefImm16 Address: " << std::hex << builtinAddress; 3801 LOG_INST() << " index: " << static_cast<int32_t>(index); 3802 3803 std::vector<BaselineParameter> parameters; 3804 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3805 parameters.emplace_back(BaselineSpecialParameter::SP); 3806 parameters.emplace_back(static_cast<int32_t>(index)); 3807 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3808 GetBaselineAssembler().SaveResultIntoAcc(); 3809} 3810 3811// SP, LEVEL, SLOT 3812BYTECODE_BASELINE_HANDLER_IMPLEMENT(WIDE_LDLEXVAR_PREF_IMM16_IMM16) 3813{ 3814 uint16_t level = READ_INST_16_1(); 3815 uint16_t slot = READ_INST_16_3(); 3816 auto *thread = vm->GetAssociatedJSThread(); 3817 Address builtinAddress = 3818 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineWideLdlexvarPrefImm16Imm16); 3819 LOG_INST() << " BaselineWideLdlexvarPrefImm16Imm16 Address: " << std::hex << builtinAddress; 3820 LOG_INST() << " level: " << static_cast<int32_t>(level); 3821 LOG_INST() << " slot: " << static_cast<int32_t>(slot); 3822 3823 std::vector<BaselineParameter> parameters; 3824 parameters.emplace_back(BaselineSpecialParameter::SP); 3825 parameters.emplace_back(static_cast<int32_t>(level)); 3826 parameters.emplace_back(static_cast<int32_t>(slot)); 3827 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3828 GetBaselineAssembler().SaveResultIntoAcc(); 3829} 3830 3831// GLUE, SP, ACC, LEVEL, SLOT 3832BYTECODE_BASELINE_HANDLER_IMPLEMENT(WIDE_STLEXVAR_PREF_IMM16_IMM16) 3833{ 3834 uint16_t level = READ_INST_16_1(); 3835 uint16_t slot = READ_INST_16_3(); 3836 auto *thread = vm->GetAssociatedJSThread(); 3837 Address builtinAddress = 3838 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineWideStlexvarPrefImm16Imm16); 3839 LOG_INST() << " BaselineWideStlexvarPrefImm16Imm16 Address: " << std::hex << builtinAddress; 3840 LOG_INST() << " level: " << static_cast<int32_t>(level); 3841 LOG_INST() << " slot: " << static_cast<int32_t>(slot); 3842 3843 std::vector<BaselineParameter> parameters; 3844 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3845 parameters.emplace_back(BaselineSpecialParameter::SP); 3846 parameters.emplace_back(BaselineSpecialParameter::ACC); 3847 parameters.emplace_back(static_cast<int32_t>(level)); 3848 parameters.emplace_back(static_cast<int32_t>(slot)); 3849 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3850} 3851 3852// GLUE, ACC, INDEX 3853BYTECODE_BASELINE_HANDLER_IMPLEMENT(WIDE_GETMODULENAMESPACE_PREF_IMM16) 3854{ 3855 int16_t index = READ_INST_16_1(); 3856 auto *thread = vm->GetAssociatedJSThread(); 3857 Address builtinAddress = 3858 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineWideGetmodulenamespacePrefImm16); 3859 LOG_INST() << " BaselineWideGetmodulenamespacePrefImm16 Address: " << std::hex << builtinAddress; 3860 3861 std::vector<BaselineParameter> parameters; 3862 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3863 parameters.emplace_back(index); 3864 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3865 GetBaselineAssembler().SaveResultIntoAcc(); 3866} 3867 3868// GLUE, ACC, INDEX 3869BYTECODE_BASELINE_HANDLER_IMPLEMENT(WIDE_STMODULEVAR_PREF_IMM16) 3870{ 3871 int16_t index = READ_INST_16_1(); 3872 auto *thread = vm->GetAssociatedJSThread(); 3873 Address builtinAddress = 3874 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineWideStmodulevarPrefImm16); 3875 LOG_INST() << " BaselineWideStmodulevarPrefImm16 Address: " << std::hex << builtinAddress; 3876 3877 std::vector<BaselineParameter> parameters; 3878 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3879 parameters.emplace_back(BaselineSpecialParameter::ACC); 3880 parameters.emplace_back(index); 3881 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3882} 3883 3884// GLUE, INDEX 3885BYTECODE_BASELINE_HANDLER_IMPLEMENT(WIDE_LDLOCALMODULEVAR_PREF_IMM16) 3886{ 3887 int16_t index = READ_INST_16_1(); 3888 auto *thread = vm->GetAssociatedJSThread(); 3889 Address builtinAddress = 3890 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineWideLdlocalmodulevarPrefImm16); 3891 LOG_INST() << " BaselineWideLdlocalmodulevarPrefImm16 Address: " << std::hex << builtinAddress; 3892 3893 std::vector<BaselineParameter> parameters; 3894 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3895 parameters.emplace_back(index); 3896 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3897 GetBaselineAssembler().SaveResultIntoAcc(); 3898} 3899 3900// GLUE, INDEX 3901BYTECODE_BASELINE_HANDLER_IMPLEMENT(WIDE_LDEXTERNALMODULEVAR_PREF_IMM16) 3902{ 3903 int16_t index = READ_INST_16_1(); 3904 auto *thread = vm->GetAssociatedJSThread(); 3905 Address builtinAddress = 3906 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineWideLdexternalmodulevarPrefImm16); 3907 LOG_INST() << " BaselineWideLdexternalmodulevarPrefImm16 Address: " << std::hex << builtinAddress; 3908 3909 std::vector<BaselineParameter> parameters; 3910 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3911 parameters.emplace_back(index); 3912 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3913 GetBaselineAssembler().SaveResultIntoAcc(); 3914} 3915 3916// GLUE, SP, INDEX 3917BYTECODE_BASELINE_HANDLER_IMPLEMENT(WIDE_LDPATCHVAR_PREF_IMM16) 3918{ 3919 int16_t index = READ_INST_16_1(); 3920 auto *thread = vm->GetAssociatedJSThread(); 3921 Address builtinAddress = 3922 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineWideLdpatchvarPrefImm16); 3923 LOG_INST() << " BaselineWideLdpatchvarPrefImm16 Address: " << std::hex << builtinAddress; 3924 3925 std::vector<BaselineParameter> parameters; 3926 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3927 parameters.emplace_back(BaselineSpecialParameter::SP); 3928 parameters.emplace_back(index); 3929 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3930 GetBaselineAssembler().SaveResultIntoAcc(); 3931} 3932 3933// GLUE, ACC, INDEX 3934BYTECODE_BASELINE_HANDLER_IMPLEMENT(WIDE_STPATCHVAR_PREF_IMM16) 3935{ 3936 int16_t index = READ_INST_16_1(); 3937 auto *thread = vm->GetAssociatedJSThread(); 3938 Address builtinAddress = 3939 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineWideStpatchvarPrefImm16); 3940 LOG_INST() << " BaselineWideStpatchvarPrefImm16 Address: " << std::hex << builtinAddress; 3941 3942 std::vector<BaselineParameter> parameters; 3943 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3944 parameters.emplace_back(BaselineSpecialParameter::SP); 3945 parameters.emplace_back(BaselineSpecialParameter::ACC); 3946 parameters.emplace_back(index); 3947 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3948} 3949 3950// GLUE, ACC, INDEX 3951BYTECODE_BASELINE_HANDLER_IMPLEMENT(WIDE_LDOBJBYINDEX_PREF_IMM32) 3952{ 3953 uint8_t slotId = READ_INST_8_0(); 3954 int32_t index = static_cast<int32_t>(READ_INST_32_1()); 3955 auto *thread = vm->GetAssociatedJSThread(); 3956 Address builtinAddress = 3957 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineWideLdobjbyindexPrefImm32); 3958 LOG_INST() << " BaselineWideLdobjbyindexPrefImm32 Address: " << std::hex << builtinAddress; 3959 3960 std::vector<BaselineParameter> parameters; 3961 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3962 parameters.emplace_back(BaselineSpecialParameter::SP); 3963 parameters.emplace_back(index); 3964 parameters.emplace_back(static_cast<int32_t>(slotId)); 3965 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3966 GetBaselineAssembler().SaveResultIntoAcc(); 3967} 3968 3969// GLUE, ACC, RANGE, V0_I8 3970BYTECODE_BASELINE_HANDLER_IMPLEMENT(WIDE_SUPERCALLARROWRANGE_PREF_IMM16_V8) 3971{ 3972 int16_t range = READ_INST_16_1(); 3973 uint8_t v0 = READ_INST_8_3(); 3974 auto *thread = vm->GetAssociatedJSThread(); 3975 Address builtinAddress = 3976 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineWideSupercallarrowrangePrefImm16V8); 3977 LOG_INST() << " BaselineWideSupercallarrowrangePrefImm16V8 Address: " << std::hex << builtinAddress; 3978 LOG_INST() << " range: " << range; 3979 LOG_INST() << " v0: " << static_cast<int16_t>(v0); 3980 3981 std::vector<BaselineParameter> parameters; 3982 parameters.emplace_back(BaselineSpecialParameter::GLUE); 3983 parameters.emplace_back(BaselineSpecialParameter::SP); 3984 parameters.emplace_back(BaselineSpecialParameter::ACC); 3985 parameters.emplace_back(range); 3986 parameters.emplace_back(static_cast<int16_t>(v0)); 3987 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 3988} 3989 3990// GLUE, SP, RANGE, V0_I8 3991BYTECODE_BASELINE_HANDLER_IMPLEMENT(WIDE_SUPERCALLTHISRANGE_PREF_IMM16_V8) 3992{ 3993 int16_t range = READ_INST_16_1(); 3994 uint8_t v0 = READ_INST_8_3(); 3995 auto *thread = vm->GetAssociatedJSThread(); 3996 Address builtinAddress = 3997 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineWideSupercallthisrangePrefImm16V8); 3998 LOG_INST() << " BaselineWideSupercallthisrangePrefImm16V8 Address: " << std::hex << builtinAddress; 3999 LOG_INST() << " range: " << range; 4000 LOG_INST() << " v0: " << static_cast<int16_t>(v0); 4001 4002 std::vector<BaselineParameter> parameters; 4003 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4004 parameters.emplace_back(BaselineSpecialParameter::SP); 4005 parameters.emplace_back(range); 4006 parameters.emplace_back(static_cast<int16_t>(v0)); 4007 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4008 GetBaselineAssembler().SaveResultIntoAcc(); 4009} 4010 4011// GLUE, SP, ACC, ACTUAL_NUM_ARGS, VREG_ID, HOTNESS_COUNTER 4012BYTECODE_BASELINE_HANDLER_IMPLEMENT(WIDE_CALLTHISRANGE_PREF_IMM16_V8) 4013{ 4014 uint16_t actualNumArgs = READ_INST_16_1(); 4015 int8_t vregId = READ_INST_8_3(); 4016 auto *thread = vm->GetAssociatedJSThread(); 4017 Address builtinAddress = 4018 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineWideCallthisrangePrefImm16V8); 4019 LOG_INST() << " BaselineWideCallthisrangePrefImm16V8 Address: " << std::hex << builtinAddress; 4020 LOG_INST() << " actualNumArgs: " << static_cast<int32_t>(actualNumArgs); 4021 4022 std::vector<BaselineParameter> parameters; 4023 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4024 parameters.emplace_back(BaselineSpecialParameter::SP); 4025 parameters.emplace_back(BaselineSpecialParameter::ACC); 4026 parameters.emplace_back(static_cast<int32_t>(actualNumArgs)); 4027 parameters.emplace_back(vregId); 4028 parameters.emplace_back(BaselineSpecialParameter::HOTNESS_COUNTER); 4029 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4030 GetBaselineAssembler().SaveResultIntoAcc(); 4031} 4032 4033// GLUE, SP, ACC, ACTUAL_NUM_ARGS, VREG_ID, HOTNESS_COUNTER 4034BYTECODE_BASELINE_HANDLER_IMPLEMENT(WIDE_CALLRANGE_PREF_IMM16_V8) 4035{ 4036 uint16_t actualNumArgs = READ_INST_16_1(); 4037 int8_t vregId = READ_INST_8_2(); 4038 auto *thread = vm->GetAssociatedJSThread(); 4039 Address builtinAddress = 4040 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineWideCallrangePrefImm16V8); 4041 LOG_INST() << " BaselineWideCallrangePrefImm16V8 Address: " << std::hex << builtinAddress; 4042 LOG_INST() << " actualNumArgs: " << static_cast<int32_t>(actualNumArgs); 4043 4044 std::vector<BaselineParameter> parameters; 4045 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4046 parameters.emplace_back(BaselineSpecialParameter::SP); 4047 parameters.emplace_back(BaselineSpecialParameter::ACC); 4048 parameters.emplace_back(static_cast<int32_t>(actualNumArgs)); 4049 parameters.emplace_back(vregId); 4050 parameters.emplace_back(BaselineSpecialParameter::HOTNESS_COUNTER); 4051 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4052 GetBaselineAssembler().SaveResultIntoAcc(); 4053} 4054 4055// GLUE, SP, ACC, NUM_VARS, SCOPE_ID 4056BYTECODE_BASELINE_HANDLER_IMPLEMENT(WIDE_NEWLEXENVWITHNAME_PREF_IMM16_ID16) 4057{ 4058 int16_t numVars = READ_INST_16_1(); 4059 int16_t scopeId = READ_INST_16_3(); 4060 auto *thread = vm->GetAssociatedJSThread(); 4061 Address builtinAddress = 4062 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineWideNewlexenvwithnamePrefImm16Id16); 4063 LOG_INST() << " BaselineWideNewlexenvwithnamePrefImm16Id16 Address: " << std::hex << builtinAddress; 4064 LOG_INST() << " numVars: " << numVars; 4065 LOG_INST() << " scopeId: " << scopeId; 4066 4067 std::vector<BaselineParameter> parameters; 4068 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4069 parameters.emplace_back(BaselineSpecialParameter::SP); 4070 parameters.emplace_back(BaselineSpecialParameter::ACC); 4071 parameters.emplace_back(numVars); 4072 parameters.emplace_back(scopeId); 4073 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4074 GetBaselineAssembler().SaveResultIntoAcc(); 4075} 4076 4077// GLUE, SP, ACC, NUM_VARS 4078BYTECODE_BASELINE_HANDLER_IMPLEMENT(WIDE_NEWLEXENV_PREF_IMM16) 4079{ 4080 uint16_t numVars = READ_INST_16_1(); 4081 auto *thread = vm->GetAssociatedJSThread(); 4082 Address builtinAddress = 4083 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineWideNewlexenvPrefImm16); 4084 LOG_INST() << " BaselineWideNewlexenvPrefImm16 Address: " << std::hex << builtinAddress; 4085 LOG_INST() << " numVars: " << static_cast<int32_t>(numVars); 4086 4087 std::vector<BaselineParameter> parameters; 4088 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4089 parameters.emplace_back(BaselineSpecialParameter::SP); 4090 parameters.emplace_back(BaselineSpecialParameter::ACC); 4091 parameters.emplace_back(static_cast<int32_t>(numVars)); 4092 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4093 GetBaselineAssembler().SaveResultIntoAcc(); 4094} 4095 4096// GLUE, SP, NUM_ARGS, IDX, HOTNESS_COUNTER, SLOT_ID 4097BYTECODE_BASELINE_HANDLER_IMPLEMENT(WIDE_NEWOBJRANGE_PREF_IMM16_V8) 4098{ 4099 uint16_t slotId = READ_INST_16_0(); 4100 int16_t numArgs = READ_INST_16_1(); 4101 uint8_t firstArgRegIdx = READ_INST_8_3(); 4102 auto *thread = vm->GetAssociatedJSThread(); 4103 Address builtinAddress = 4104 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineWideNewobjrangePrefImm16V8); 4105 LOG_INST() << " BaselineWideNewobjrangePrefImm16V8 Address: " << std::hex << builtinAddress; 4106 LOG_INST() << " numArgs: " << numArgs; 4107 LOG_INST() << " firstArgRegIdx: " << static_cast<int16_t>(firstArgRegIdx); 4108 4109 std::vector<BaselineParameter> parameters; 4110 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4111 parameters.emplace_back(BaselineSpecialParameter::SP); 4112 parameters.emplace_back(numArgs); 4113 parameters.emplace_back(static_cast<int16_t>(firstArgRegIdx)); 4114 parameters.emplace_back(BaselineSpecialParameter::HOTNESS_COUNTER); 4115 parameters.emplace_back(static_cast<int32_t>(slotId)); 4116 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4117 GetBaselineAssembler().SaveResultIntoAcc(); 4118} 4119 4120// GLUE, SP, V0, V1, V2 4121BYTECODE_BASELINE_HANDLER_IMPLEMENT(WIDE_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8) 4122{ 4123 int16_t numKeys = READ_INST_16_1(); 4124 int8_t objId = READ_INST_8_3(); 4125 uint8_t firstArgRegIdx = READ_INST_8_4(); 4126 auto *thread = vm->GetAssociatedJSThread(); 4127 Address builtinAddress = 4128 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineWideCreateobjectwithexcludedkeysPrefImm16V8V8); 4129 LOG_INST() << " BaselineWideCreateobjectwithexcludedkeysPrefImm16V8V8 Address: " << std::hex << builtinAddress; 4130 LOG_INST() << " numKeys: " << numKeys; 4131 LOG_INST() << " objId: " << static_cast<int16_t>(objId); 4132 LOG_INST() << " firstArgRegIdx: " << static_cast<int16_t>(firstArgRegIdx); 4133 4134 std::vector<BaselineParameter> parameters; 4135 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4136 parameters.emplace_back(BaselineSpecialParameter::SP); 4137 parameters.emplace_back(numKeys); 4138 parameters.emplace_back(objId); 4139 parameters.emplace_back(static_cast<int16_t>(firstArgRegIdx)); 4140 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4141 GetBaselineAssembler().SaveResultIntoAcc(); 4142} 4143 4144// ------- End parse wide bytecodes ------- 4145 4146// ------- parse throw bytecodes ------- 4147 4148// GLUE, SP 4149BYTECODE_BASELINE_HANDLER_IMPLEMENT(THROW_PATTERNNONCOERCIBLE_PREF_NONE) 4150{ 4151 (void)bytecodeArray; 4152 auto *thread = vm->GetAssociatedJSThread(); 4153 Address builtinAddress = 4154 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineThrowPatternnoncoerciblePrefNone); 4155 LOG_INST() << " BaselineThrowPatternnoncoerciblePrefNone Address: " << std::hex << builtinAddress; 4156 4157 std::vector<BaselineParameter> parameters; 4158 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4159 parameters.emplace_back(BaselineSpecialParameter::SP); 4160 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4161} 4162 4163BYTECODE_BASELINE_HANDLER_IMPLEMENT(THROW_NOTEXISTS_PREF_NONE) 4164{ 4165 (void)bytecodeArray; 4166 auto *thread = vm->GetAssociatedJSThread(); 4167 Address builtinAddress = 4168 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineThrowNotexistsPrefNone); 4169 LOG_INST() << " BaselineThrowNotexistsPrefNone Address: " << std::hex << builtinAddress; 4170 4171 std::vector<BaselineParameter> parameters; 4172 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4173 parameters.emplace_back(BaselineSpecialParameter::SP); 4174 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4175} 4176 4177// GLUE, SP 4178BYTECODE_BASELINE_HANDLER_IMPLEMENT(THROW_DELETESUPERPROPERTY_PREF_NONE) 4179{ 4180 (void)bytecodeArray; 4181 auto *thread = vm->GetAssociatedJSThread(); 4182 Address builtinAddress = 4183 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineThrowDeletesuperpropertyPrefNone); 4184 LOG_INST() << " BaselineThrowDeletesuperpropertyPrefNone Address: " << std::hex << builtinAddress; 4185 4186 std::vector<BaselineParameter> parameters; 4187 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4188 parameters.emplace_back(BaselineSpecialParameter::SP); 4189 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4190} 4191 4192// GLUE, ACC, IMM 4193BYTECODE_BASELINE_HANDLER_IMPLEMENT(THROW_IFSUPERNOTCORRECTCALL_PREF_IMM16) 4194{ 4195 int16_t imm = READ_INST_16_1(); 4196 auto *thread = vm->GetAssociatedJSThread(); 4197 Address builtinAddress = 4198 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineThrowIfsupernotcorrectcallPrefImm16); 4199 LOG_INST() << " BaselineThrowIfsupernotcorrectcallPrefImm16 Address: " << std::hex << builtinAddress; 4200 4201 std::vector<BaselineParameter> parameters; 4202 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4203 parameters.emplace_back(BaselineSpecialParameter::SP); 4204 parameters.emplace_back(BaselineSpecialParameter::ACC); 4205 parameters.emplace_back(imm); 4206 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4207} 4208 4209// GLUE, ACC, IMM 4210BYTECODE_BASELINE_HANDLER_IMPLEMENT(THROW_IFSUPERNOTCORRECTCALL_PREF_IMM8) 4211{ 4212 int8_t imm = READ_INST_8_1(); 4213 auto *thread = vm->GetAssociatedJSThread(); 4214 Address builtinAddress = 4215 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineThrowIfsupernotcorrectcallPrefImm8); 4216 LOG_INST() << " BaselineThrowIfsupernotcorrectcallPrefImm8 Address: " << std::hex << builtinAddress; 4217 4218 std::vector<BaselineParameter> parameters; 4219 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4220 parameters.emplace_back(BaselineSpecialParameter::SP); 4221 parameters.emplace_back(BaselineSpecialParameter::ACC); 4222 parameters.emplace_back(imm); 4223 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4224} 4225 4226// GLUE, ACC, SP, STRING_ID 4227BYTECODE_BASELINE_HANDLER_IMPLEMENT(THROW_UNDEFINEDIFHOLEWITHNAME_PREF_ID16) 4228{ 4229 uint16_t stringId = READ_INST_16_1(); 4230 auto *thread = vm->GetAssociatedJSThread(); 4231 Address builtinAddress = 4232 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineThrowUndefinedifholewithnamePrefId16); 4233 LOG_INST() << " BaselineThrowUndefinedifholewithnamePrefId16 Address: " << std::hex << builtinAddress; 4234 4235 std::vector<BaselineParameter> parameters; 4236 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4237 parameters.emplace_back(BaselineSpecialParameter::SP); 4238 parameters.emplace_back(static_cast<int32_t>(stringId)); 4239 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4240} 4241 4242// GLUE, SP, V0, V1 4243BYTECODE_BASELINE_HANDLER_IMPLEMENT(THROW_UNDEFINEDIFHOLE_PREF_V8_V8) 4244{ 4245 int8_t v0 = READ_INST_8_1(); 4246 int8_t v1 = READ_INST_8_2(); 4247 auto *thread = vm->GetAssociatedJSThread(); 4248 Address builtinAddress = 4249 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineThrowUndefinedifholePrefV8V8); 4250 LOG_INST() << " BaselineThrowUndefinedifholePrefV8V8 Address: " << std::hex << builtinAddress; 4251 4252 std::vector<BaselineParameter> parameters; 4253 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4254 parameters.emplace_back(BaselineSpecialParameter::SP); 4255 parameters.emplace_back(v0); 4256 parameters.emplace_back(v1); 4257 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4258} 4259 4260// GLUE, SP, V0 4261BYTECODE_BASELINE_HANDLER_IMPLEMENT(THROW_IFNOTOBJECT_PREF_V8) 4262{ 4263 int8_t v0 = READ_INST_8_1(); 4264 auto *thread = vm->GetAssociatedJSThread(); 4265 Address builtinAddress = 4266 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineThrowIfnotobjectPrefV8); 4267 LOG_INST() << " BaselineThrowIfnotobjectPrefV8 Address: " << std::hex << builtinAddress; 4268 4269 std::vector<BaselineParameter> parameters; 4270 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4271 parameters.emplace_back(BaselineSpecialParameter::SP); 4272 parameters.emplace_back(VirtualRegister(v0)); 4273 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4274} 4275 4276BYTECODE_BASELINE_HANDLER_IMPLEMENT(THROW_CONSTASSIGNMENT_PREF_V8) 4277{ 4278 int8_t v0 = READ_INST_8_1(); 4279 auto *thread = vm->GetAssociatedJSThread(); 4280 Address builtinAddress = 4281 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineThrowConstassignmentPrefV8); 4282 LOG_INST() << " BaselineThrowConstassignmentPrefV8 Address: " << std::hex << builtinAddress; 4283 4284 std::vector<BaselineParameter> parameters; 4285 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4286 parameters.emplace_back(BaselineSpecialParameter::SP); 4287 parameters.emplace_back(VirtualRegister(v0)); 4288 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4289} 4290 4291// GLUE, SP, ACC 4292BYTECODE_BASELINE_HANDLER_IMPLEMENT(THROW_PREF_NONE) 4293{ 4294 (void)bytecodeArray; 4295 auto *thread = vm->GetAssociatedJSThread(); 4296 Address builtinAddress = 4297 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineThrowPrefNone); 4298 LOG_INST() << " BaselineThrowPrefNone Address: " << std::hex << builtinAddress; 4299 4300 std::vector<BaselineParameter> parameters; 4301 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4302 parameters.emplace_back(BaselineSpecialParameter::SP); 4303 parameters.emplace_back(BaselineSpecialParameter::ACC); 4304 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4305} 4306 4307// ------- End parse throw bytecodes ------- 4308 4309// ------- parse SET/GET bytecodes ------- 4310 4311// GLUE, SP, ACC, INDEX0, INDEX1, ENV 4312BYTECODE_BASELINE_HANDLER_IMPLEMENT(TESTIN_IMM8_IMM16_IMM16) 4313{ 4314 uint16_t levelIndex = READ_INST_16_1(); 4315 uint16_t slotIndex = READ_INST_16_3(); 4316 auto *thread = vm->GetAssociatedJSThread(); 4317 Address builtinAddress = 4318 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineTestInImm8Imm16Imm16); 4319 LOG_INST() << " BaselineTestInImm8Imm16Imm16 Address: " << std::hex << builtinAddress; 4320 LOG_INST() << " levelIndex: " << static_cast<int32_t>(levelIndex); 4321 LOG_INST() << " slotIndex: " << static_cast<int32_t>(slotIndex); 4322 4323 std::vector<BaselineParameter> parameters; 4324 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4325 parameters.emplace_back(BaselineSpecialParameter::SP); 4326 parameters.emplace_back(BaselineSpecialParameter::ACC); 4327 parameters.emplace_back(static_cast<int32_t>(levelIndex)); 4328 parameters.emplace_back(static_cast<int32_t>(slotIndex)); 4329 parameters.emplace_back(BaselineSpecialParameter::ENV); 4330 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4331 GetBaselineAssembler().SaveResultIntoAcc(); 4332} 4333 4334// GLUE, SP, INDEX0, INDEX1, INDEX2 4335BYTECODE_BASELINE_HANDLER_IMPLEMENT(STPRIVATEPROPERTY_IMM8_IMM16_IMM16_V8) 4336{ 4337 uint16_t levelIndex = READ_INST_16_1(); 4338 uint16_t slotIndex = READ_INST_16_3(); 4339 int8_t objId = READ_INST_8_5(); 4340 auto *thread = vm->GetAssociatedJSThread(); 4341 Address builtinAddress = 4342 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineStPrivatePropertyImm8Imm16Imm16V8); 4343 LOG_INST() << " BaselineStPrivatePropertyImm8Imm16Imm16V8 Address: " << std::hex << builtinAddress; 4344 LOG_INST() << " levelIndex: " << static_cast<int32_t>(levelIndex); 4345 LOG_INST() << " slotIndex: " << static_cast<int32_t>(slotIndex); 4346 4347 std::vector<BaselineParameter> parameters; 4348 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4349 parameters.emplace_back(BaselineSpecialParameter::SP); 4350 parameters.emplace_back(static_cast<int32_t>(levelIndex)); 4351 parameters.emplace_back(static_cast<int32_t>(slotIndex)); 4352 parameters.emplace_back(objId); 4353 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4354 GetBaselineAssembler().SaveResultIntoAcc(); 4355} 4356 4357// GLUE, ACC, INDEX0, INDEX1, ENV 4358BYTECODE_BASELINE_HANDLER_IMPLEMENT(LDPRIVATEPROPERTY_IMM8_IMM16_IMM16) 4359{ 4360 uint16_t levelIndex = READ_INST_16_1(); 4361 uint16_t slotIndex = READ_INST_16_3(); 4362 auto *thread = vm->GetAssociatedJSThread(); 4363 Address builtinAddress = 4364 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineLdPrivatePropertyImm8Imm16Imm16); 4365 LOG_INST() << " BaselineLdPrivatePropertyImm8Imm16Imm16 Address: " << std::hex << builtinAddress; 4366 LOG_INST() << " levelIndex: " << static_cast<int32_t>(levelIndex); 4367 LOG_INST() << " slotIndex: " << static_cast<int32_t>(slotIndex); 4368 4369 std::vector<BaselineParameter> parameters; 4370 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4371 parameters.emplace_back(BaselineSpecialParameter::SP); 4372 parameters.emplace_back(BaselineSpecialParameter::ACC); 4373 parameters.emplace_back(static_cast<int32_t>(levelIndex)); 4374 parameters.emplace_back(static_cast<int32_t>(slotIndex)); 4375 parameters.emplace_back(BaselineSpecialParameter::ENV); 4376 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4377 GetBaselineAssembler().SaveResultIntoAcc(); 4378} 4379 4380// GLUE, SP, ACC 4381BYTECODE_BASELINE_HANDLER_IMPLEMENT(GETASYNCITERATOR_IMM8) 4382{ 4383 (void)bytecodeArray; 4384 auto *thread = vm->GetAssociatedJSThread(); 4385 Address builtinAddress = 4386 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineGetasynciteratorImm8); 4387 LOG_INST() << " BaselineGetasynciteratorImm8 Address: " << std::hex << builtinAddress; 4388 4389 std::vector<BaselineParameter> parameters; 4390 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4391 parameters.emplace_back(BaselineSpecialParameter::SP); 4392 parameters.emplace_back(BaselineSpecialParameter::ACC); 4393 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4394 GetBaselineAssembler().SaveResultIntoAcc(); 4395} 4396 4397// GLUE, ACC, INDEX 4398BYTECODE_BASELINE_HANDLER_IMPLEMENT(SETGENERATORSTATE_IMM8) 4399{ 4400 uint8_t v0 = READ_INST_8_0(); 4401 auto *thread = vm->GetAssociatedJSThread(); 4402 Address builtinAddress = 4403 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineSetgeneratorstateImm8); 4404 LOG_INST() << " BaselineSetgeneratorstateImm8 Address: " << std::hex << builtinAddress; 4405 LOG_INST() << " v0: " << static_cast<int32_t>(v0); 4406 4407 std::vector<BaselineParameter> parameters; 4408 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4409 parameters.emplace_back(BaselineSpecialParameter::ACC); 4410 parameters.emplace_back(static_cast<int32_t>(v0)); 4411 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4412} 4413 4414// ------- End parse SET/GET bytecodes ------- 4415 4416// ------- parse JUMP bytecodes ------- 4417 4418BYTECODE_BASELINE_HANDLER_IMPLEMENT(JNSTRICTEQNULL_IMM16) 4419{ 4420 (void)bytecodeArray; 4421} 4422 4423BYTECODE_BASELINE_HANDLER_IMPLEMENT(JEQUNDEFINED_IMM8) 4424{ 4425 (void)bytecodeArray; 4426} 4427 4428BYTECODE_BASELINE_HANDLER_IMPLEMENT(JEQUNDEFINED_IMM16) 4429{ 4430 (void)bytecodeArray; 4431} 4432 4433BYTECODE_BASELINE_HANDLER_IMPLEMENT(JNEUNDEFINED_IMM8) 4434{ 4435 (void)bytecodeArray; 4436} 4437 4438BYTECODE_BASELINE_HANDLER_IMPLEMENT(JNEUNDEFINED_IMM16) 4439{ 4440 (void)bytecodeArray; 4441} 4442 4443BYTECODE_BASELINE_HANDLER_IMPLEMENT(JSTRICTEQUNDEFINED_IMM8) 4444{ 4445 (void)bytecodeArray; 4446} 4447 4448BYTECODE_BASELINE_HANDLER_IMPLEMENT(JSTRICTEQUNDEFINED_IMM16) 4449{ 4450 (void)bytecodeArray; 4451} 4452 4453BYTECODE_BASELINE_HANDLER_IMPLEMENT(JNSTRICTEQUNDEFINED_IMM8) 4454{ 4455 (void)bytecodeArray; 4456} 4457 4458BYTECODE_BASELINE_HANDLER_IMPLEMENT(JNSTRICTEQUNDEFINED_IMM16) 4459{ 4460 (void)bytecodeArray; 4461} 4462 4463BYTECODE_BASELINE_HANDLER_IMPLEMENT(JSTRICTEQ_V8_IMM8) 4464{ 4465 (void)bytecodeArray; 4466} 4467 4468BYTECODE_BASELINE_HANDLER_IMPLEMENT(JSTRICTEQ_V8_IMM16) 4469{ 4470 (void)bytecodeArray; 4471} 4472 4473BYTECODE_BASELINE_HANDLER_IMPLEMENT(JNSTRICTEQ_V8_IMM8) 4474{ 4475 (void)bytecodeArray; 4476} 4477 4478BYTECODE_BASELINE_HANDLER_IMPLEMENT(JNSTRICTEQ_V8_IMM16) 4479{ 4480 (void)bytecodeArray; 4481} 4482 4483BYTECODE_BASELINE_HANDLER_IMPLEMENT(NOP) 4484{ 4485 (void)bytecodeArray; 4486} 4487 4488BYTECODE_BASELINE_HANDLER_IMPLEMENT(ASYNCGENERATORREJECT_V8) 4489{ 4490 int8_t v0 = READ_INST_8_0(); 4491 auto *thread = vm->GetAssociatedJSThread(); 4492 Address builtinAddress = 4493 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineAsyncgeneratorrejectV8); 4494 LOG_INST() << " BaselineAsyncgeneratorrejectV8 Address: " << std::hex << builtinAddress; 4495 4496 std::vector<BaselineParameter> parameters; 4497 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4498 parameters.emplace_back(BaselineSpecialParameter::SP); 4499 parameters.emplace_back(BaselineSpecialParameter::ACC); 4500 parameters.emplace_back(v0); 4501 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4502 GetBaselineAssembler().SaveResultIntoAcc(); 4503} 4504 4505BYTECODE_BASELINE_HANDLER_IMPLEMENT(MOV_V16_V16) 4506{ 4507 uint16_t vdst = READ_INST_16_0(); 4508 uint16_t vsrc = READ_INST_16_2(); 4509 LOG_INST() << "mov v" << static_cast<VRegIDType>(vdst) << ", v" << static_cast<VRegIDType>(vsrc); 4510 GetBaselineAssembler().Move(VirtualRegister(static_cast<VRegIDType>(vdst)), 4511 VirtualRegister(static_cast<VRegIDType>(vsrc))); 4512} 4513 4514BYTECODE_BASELINE_HANDLER_IMPLEMENT(MOV_V8_V8) 4515{ 4516 uint8_t vdst = READ_INST_8_0(); 4517 uint8_t vsrc = READ_INST_8_1(); 4518 LOG_INST() << "mov v" << static_cast<VRegIDType>(vdst) << ", v" << static_cast<VRegIDType>(vsrc); 4519 GetBaselineAssembler().Move(VirtualRegister(static_cast<VRegIDType>(vdst)), 4520 VirtualRegister(static_cast<VRegIDType>(vsrc))); 4521} 4522 4523// GLUE, SP, VDST, VSRC 4524BYTECODE_BASELINE_HANDLER_IMPLEMENT(MOV_V4_V4) 4525{ 4526 uint8_t vdst = READ_INST_4_0(); 4527 uint8_t vsrc = READ_INST_4_1(); 4528 LOG_INST() << "mov v" << static_cast<VRegIDType>(vdst) << ", v" << static_cast<VRegIDType>(vsrc); 4529 GetBaselineAssembler().Move(VirtualRegister(static_cast<VRegIDType>(vdst)), 4530 VirtualRegister(static_cast<VRegIDType>(vsrc))); 4531} 4532 4533// ------- End parse JUMP bytecodes ------- 4534 4535// ------- parse deprecated bytecodes ------- 4536 4537// GLUE, SP, ACC, PROFILE_TYPE_INFO, HOTNESS_COUNTER, V0, V1 4538BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_SUSPENDGENERATOR_PREF_V8_V8) 4539{ 4540 int8_t v0 = READ_INST_8_1(); 4541 int8_t v1 = READ_INST_8_2(); 4542 auto offset = static_cast<int32_t>(bytecodeArray - firstPC); 4543 auto *thread = vm->GetAssociatedJSThread(); 4544 Address builtinAddress = 4545 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedSuspendgeneratorPrefV8V8); 4546 LOG_INST() << " BaselineDeprecatedSuspendgeneratorPrefV8V8 Address: " << std::hex << builtinAddress; 4547 4548 std::vector<BaselineParameter> parameters; 4549 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4550 parameters.emplace_back(BaselineSpecialParameter::SP); 4551 parameters.emplace_back(offset); 4552 parameters.emplace_back(v0); 4553 parameters.emplace_back(v1); 4554 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4555} 4556 4557// ACC, SP 4558BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_LDLEXENV_PREF_NONE) 4559{ 4560 (void)bytecodeArray; 4561 auto *thread = vm->GetAssociatedJSThread(); 4562 Address builtinAddress = 4563 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedLdlexenvPrefNone); 4564 LOG_INST() << " BaselineDeprecatedLdlexenvPrefNone Address: " << std::hex << builtinAddress; 4565 4566 std::vector<BaselineParameter> parameters; 4567 parameters.emplace_back(BaselineSpecialParameter::SP); 4568 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4569 GetBaselineAssembler().SaveResultIntoAcc(); 4570} 4571 4572// GLUE, SP 4573BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_POPLEXENV_PREF_NONE) 4574{ 4575 (void)bytecodeArray; 4576 auto *thread = vm->GetAssociatedJSThread(); 4577 Address builtinAddress = 4578 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedPoplexenvPrefNone); 4579 LOG_INST() << " BaselineDeprecatedPoplexenvPrefNone Address: " << std::hex << builtinAddress; 4580 4581 std::vector<BaselineParameter> parameters; 4582 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4583 parameters.emplace_back(BaselineSpecialParameter::SP); 4584 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4585} 4586 4587// GLUE, SP, V0, V1 4588BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_GETITERATORNEXT_PREF_V8_V8) 4589{ 4590 int8_t v0 = READ_INST_8_1(); 4591 int8_t v1 = READ_INST_8_2(); 4592 auto *thread = vm->GetAssociatedJSThread(); 4593 Address builtinAddress = 4594 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedGetiteratornextPrefV8V8); 4595 LOG_INST() << " BaselineDeprecatedGetiteratornextPrefV8V8 Address: " << std::hex << builtinAddress; 4596 4597 std::vector<BaselineParameter> parameters; 4598 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4599 parameters.emplace_back(BaselineSpecialParameter::SP); 4600 parameters.emplace_back(v0); 4601 parameters.emplace_back(v1); 4602 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4603 GetBaselineAssembler().SaveResultIntoAcc(); 4604} 4605 4606// GLUE, IMM_I16, FUNC, SLOT_ID_I8, PROFILE_TYPE_INFO, PC 4607BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_CREATEARRAYWITHBUFFER_PREF_IMM16) 4608{ 4609 int16_t immI16 = READ_INST_16_1(); 4610 uint8_t slotId = READ_INST_8_0(); 4611 auto *thread = vm->GetAssociatedJSThread(); 4612 Address builtinAddress = 4613 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedCreatearraywithbufferPrefImm16); 4614 LOG_INST() << " BaselineDeprecatedCreatearraywithbufferPrefImm16 Address: " << std::hex << builtinAddress; 4615 LOG_INST() << " immI16: " << immI16; 4616 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 4617 4618 std::vector<BaselineParameter> parameters; 4619 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4620 parameters.emplace_back(BaselineSpecialParameter::SP); 4621 parameters.emplace_back(immI16); 4622 parameters.emplace_back(static_cast<int32_t>(slotId)); 4623 parameters.emplace_back(BaselineSpecialParameter::PROFILE_TYPE_INFO); 4624 parameters.emplace_back(BaselineSpecialParameter::PC); 4625 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4626 GetBaselineAssembler().SaveResultIntoAcc(); 4627} 4628 4629// GLUE, IMM_I16, SP, FUNC 4630BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_CREATEOBJECTWITHBUFFER_PREF_IMM16) 4631{ 4632 int16_t immI16 = READ_INST_16_1(); 4633 auto *thread = vm->GetAssociatedJSThread(); 4634 Address builtinAddress = 4635 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedCreateobjectwithbufferPrefImm16); 4636 LOG_INST() << " BaselineDeprecatedCreateobjectwithbufferPrefImm16 Address: " << std::hex << builtinAddress; 4637 4638 std::vector<BaselineParameter> parameters; 4639 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4640 parameters.emplace_back(immI16); 4641 parameters.emplace_back(BaselineSpecialParameter::SP); 4642 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4643 GetBaselineAssembler().SaveResultIntoAcc(); 4644} 4645 4646// GLUE, SP, V0 4647BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_TONUMBER_PREF_V8) 4648{ 4649 int8_t v0 = READ_INST_8_1(); 4650 auto *thread = vm->GetAssociatedJSThread(); 4651 Address builtinAddress = 4652 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedTonumberPrefV8); 4653 LOG_INST() << " BaselineDeprecatedTonumberPrefV8 Address: " << std::hex << builtinAddress; 4654 4655 std::vector<BaselineParameter> parameters; 4656 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4657 parameters.emplace_back(BaselineSpecialParameter::SP); 4658 parameters.emplace_back(v0); 4659 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4660 GetBaselineAssembler().SaveResultIntoAcc(); 4661} 4662 4663// GLUE, SP, V0 4664BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_TONUMERIC_PREF_V8) 4665{ 4666 int8_t v0 = READ_INST_8_1(); 4667 auto *thread = vm->GetAssociatedJSThread(); 4668 Address builtinAddress = 4669 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedTonumericPrefV8); 4670 LOG_INST() << " BaselineDeprecatedTonumericPrefV8 Address: " << std::hex << builtinAddress; 4671 4672 std::vector<BaselineParameter> parameters; 4673 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4674 parameters.emplace_back(BaselineSpecialParameter::SP); 4675 parameters.emplace_back(v0); 4676 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4677 GetBaselineAssembler().SaveResultIntoAcc(); 4678} 4679 4680// GLUE, SP, V0 4681BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_NEG_PREF_V8) 4682{ 4683 int8_t v0 = READ_INST_8_1(); 4684 auto *thread = vm->GetAssociatedJSThread(); 4685 Address builtinAddress = 4686 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedNegPrefV8); 4687 LOG_INST() << " BaselineDeprecatedNegPrefV8 Address: " << std::hex << builtinAddress; 4688 4689 std::vector<BaselineParameter> parameters; 4690 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4691 parameters.emplace_back(BaselineSpecialParameter::SP); 4692 parameters.emplace_back(v0); 4693 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4694 GetBaselineAssembler().SaveResultIntoAcc(); 4695} 4696 4697// GLUE, SP, V0 4698BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_INC_PREF_V8) 4699{ 4700 int8_t v0 = READ_INST_8_1(); 4701 auto *thread = vm->GetAssociatedJSThread(); 4702 Address builtinAddress = 4703 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedIncPrefV8); 4704 LOG_INST() << " BaselineDeprecatedIncPrefV8 Address: " << std::hex << builtinAddress; 4705 4706 std::vector<BaselineParameter> parameters; 4707 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4708 parameters.emplace_back(BaselineSpecialParameter::SP); 4709 parameters.emplace_back(v0); 4710 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4711 GetBaselineAssembler().SaveResultIntoAcc(); 4712} 4713 4714// GLUE, SP, INDEX 4715BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_NOT_PREF_V8) 4716{ 4717 int8_t index = READ_INST_8_1(); 4718 auto *thread = vm->GetAssociatedJSThread(); 4719 Address builtinAddress = 4720 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedNotPrefV8); 4721 LOG_INST() << " BaselineDeprecatedNotPrefV8 Address: " << std::hex << builtinAddress; 4722 4723 std::vector<BaselineParameter> parameters; 4724 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4725 parameters.emplace_back(BaselineSpecialParameter::SP); 4726 parameters.emplace_back(index); 4727 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4728 GetBaselineAssembler().SaveResultIntoAcc(); 4729} 4730 4731// GLUE, SP, INDEX 4732BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_DEC_PREF_V8) 4733{ 4734 int8_t index = READ_INST_8_1(); 4735 auto *thread = vm->GetAssociatedJSThread(); 4736 Address builtinAddress = 4737 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedDecPrefV8); 4738 LOG_INST() << " BaselineDeprecatedDecPrefV8 Address: " << std::hex << builtinAddress; 4739 4740 std::vector<BaselineParameter> parameters; 4741 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4742 parameters.emplace_back(BaselineSpecialParameter::SP); 4743 parameters.emplace_back(index); 4744 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4745 GetBaselineAssembler().SaveResultIntoAcc(); 4746} 4747 4748// GLUE, SP, FUNC_REG, HOTNESS_COUNTER 4749BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_CALLARG0_PREF_V8) 4750{ 4751 int8_t funcReg = READ_INST_8_1(); 4752 4753 auto *thread = vm->GetAssociatedJSThread(); 4754 Address builtinAddress = 4755 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedCallarg0PrefV8); 4756 LOG_INST() << " BaselineDeprecatedCallarg0PrefV8 Address: " << std::hex << builtinAddress; 4757 4758 std::vector<BaselineParameter> parameters; 4759 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4760 parameters.emplace_back(BaselineSpecialParameter::SP); 4761 parameters.emplace_back(funcReg); 4762 parameters.emplace_back(BaselineSpecialParameter::HOTNESS_COUNTER); 4763 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4764 GetBaselineAssembler().SaveResultIntoAcc(); 4765} 4766 4767// GLUE, SP, FUNC_REG, A0, HOTNESS_COUNTER 4768BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_CALLARG1_PREF_V8_V8) 4769{ 4770 int8_t funcReg = READ_INST_8_1(); 4771 int8_t v0 = READ_INST_8_2(); 4772 4773 auto *thread = vm->GetAssociatedJSThread(); 4774 Address builtinAddress = 4775 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedCallarg1PrefV8V8); 4776 LOG_INST() << " BaselineDeprecatedCallarg1PrefV8V8 Address: " << std::hex << builtinAddress; 4777 4778 std::vector<BaselineParameter> parameters; 4779 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4780 parameters.emplace_back(BaselineSpecialParameter::SP); 4781 parameters.emplace_back(funcReg); 4782 parameters.emplace_back(v0); 4783 parameters.emplace_back(BaselineSpecialParameter::HOTNESS_COUNTER); 4784 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4785 GetBaselineAssembler().SaveResultIntoAcc(); 4786} 4787 4788// GLUE, SP, FUNC_REG, A0, A1, HOTNESS_COUNTER 4789BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_CALLARGS2_PREF_V8_V8_V8) 4790{ 4791 int8_t funcReg = READ_INST_8_1(); 4792 int8_t v0 = READ_INST_8_2(); 4793 int8_t v1 = READ_INST_8_3(); 4794 4795 auto *thread = vm->GetAssociatedJSThread(); 4796 Address builtinAddress = 4797 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedCallargs2PrefV8V8V8); 4798 LOG_INST() << " BaselineDeprecatedCallargs2PrefV8V8V8 Address: " << std::hex << builtinAddress; 4799 4800 std::vector<BaselineParameter> parameters; 4801 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4802 parameters.emplace_back(BaselineSpecialParameter::SP); 4803 parameters.emplace_back(funcReg); 4804 parameters.emplace_back(v0); 4805 parameters.emplace_back(v1); 4806 parameters.emplace_back(BaselineSpecialParameter::HOTNESS_COUNTER); 4807 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4808 GetBaselineAssembler().SaveResultIntoAcc(); 4809} 4810 4811// GLUE, SP, FUNC_REG, A0, A1, A2, HOTNESS_COUNTER 4812BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_CALLARGS3_PREF_V8_V8_V8_V8) 4813{ 4814 int8_t funcReg = READ_INST_8_1(); 4815 int8_t v0 = READ_INST_8_2(); 4816 int8_t v1 = READ_INST_8_3(); 4817 int8_t v2 = READ_INST_8_4(); 4818 4819 auto *thread = vm->GetAssociatedJSThread(); 4820 Address builtinAddress = 4821 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedCallargs3PrefV8V8V8V8); 4822 LOG_INST() << " BaselineDeprecatedCallargs3PrefV8V8V8V8 Address: " << std::hex << builtinAddress; 4823 4824 std::vector<BaselineParameter> parameters; 4825 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4826 parameters.emplace_back(BaselineSpecialParameter::SP); 4827 parameters.emplace_back(funcReg); 4828 parameters.emplace_back(v0); 4829 parameters.emplace_back(v1); 4830 parameters.emplace_back(v2); 4831 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4832 GetBaselineAssembler().SaveResultIntoAcc(); 4833} 4834 4835// GLUE, SP, V0, V1, V2 4836BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_CALLSPREAD_PREF_V8_V8_V8) 4837{ 4838 int8_t v0 = READ_INST_8_1(); 4839 int8_t v1 = READ_INST_8_2(); 4840 int8_t v2 = READ_INST_8_3(); 4841 4842 auto *thread = vm->GetAssociatedJSThread(); 4843 Address builtinAddress = 4844 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedCallspreadPrefV8V8V8); 4845 LOG_INST() << " BaselineDeprecatedCallspreadPrefV8V8V8 Address: " << std::hex << builtinAddress; 4846 4847 std::vector<BaselineParameter> parameters; 4848 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4849 parameters.emplace_back(BaselineSpecialParameter::SP); 4850 parameters.emplace_back(v0); 4851 parameters.emplace_back(v1); 4852 parameters.emplace_back(v2); 4853 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4854 GetBaselineAssembler().SaveResultIntoAcc(); 4855} 4856 4857// GLUE, SP, INDEX, FUNC_REG, HOTNESS_COUNTER 4858BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_CALLRANGE_PREF_IMM16_V8) 4859{ 4860 uint16_t actualNumArgs = READ_INST_16_1(); 4861 int8_t funcReg = READ_INST_8_3(); 4862 4863 auto *thread = vm->GetAssociatedJSThread(); 4864 Address builtinAddress = 4865 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedCallrangePrefImm16V8); 4866 LOG_INST() << " BaselineDeprecatedCallrangePrefImm16V8 Address: " << std::hex << builtinAddress; 4867 LOG_INST() << " actualNumArgs: " << static_cast<int32_t>(actualNumArgs); 4868 4869 std::vector<BaselineParameter> parameters; 4870 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4871 parameters.emplace_back(BaselineSpecialParameter::SP); 4872 parameters.emplace_back(static_cast<int32_t>(actualNumArgs)); 4873 parameters.emplace_back(funcReg); 4874 parameters.emplace_back(BaselineSpecialParameter::HOTNESS_COUNTER); 4875 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4876 GetBaselineAssembler().SaveResultIntoAcc(); 4877} 4878 4879// GLUE, SP, INDEX, FUNC_REG, HOTNESS_COUNTER 4880BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_CALLTHISRANGE_PREF_IMM16_V8) 4881{ 4882 uint16_t index = READ_INST_16_1(); 4883 int8_t funcReg = READ_INST_8_3(); 4884 4885 auto *thread = vm->GetAssociatedJSThread(); 4886 Address builtinAddress = 4887 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedCallthisrangePrefImm16V8); 4888 LOG_INST() << " BaselineDeprecatedCallthisrangePrefImm16V8 Address: " << std::hex << builtinAddress; 4889 LOG_INST() << " index: " << static_cast<int32_t>(index); 4890 4891 std::vector<BaselineParameter> parameters; 4892 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4893 parameters.emplace_back(BaselineSpecialParameter::SP); 4894 parameters.emplace_back(static_cast<int32_t>(index)); 4895 parameters.emplace_back(funcReg); 4896 parameters.emplace_back(BaselineSpecialParameter::HOTNESS_COUNTER); 4897 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4898 GetBaselineAssembler().SaveResultIntoAcc(); 4899} 4900 4901// GLUE, SP, ACC, METHOD_ID, LITERAL_ID, LENGTH, V0, V1, FUNC 4902BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8) 4903{ 4904 uint16_t methodId = READ_INST_16_1(); 4905 uint16_t literalId = READ_INST_16_3(); 4906 uint16_t length = READ_INST_16_5(); 4907 uint8_t v0 = READ_INST_8_7(); 4908 uint8_t v1 = READ_INST_8_8(); 4909 auto *thread = vm->GetAssociatedJSThread(); 4910 Address builtinAddress = thread->GetBaselineStubEntry( 4911 BaselineStubCSigns::BaselineDeprecatedDefineclasswithbufferPrefId16Imm16Imm16V8V8); 4912 LOG_INST() << " BaselineDeprecatedDefineclasswithbufferPrefId16Imm16Imm16V8V8 Address: " 4913 << std::hex << builtinAddress; 4914 4915 std::vector<BaselineParameter> parameters; 4916 parameters.emplace_back(BaselineSpecialParameter::SP); 4917 parameters.emplace_back(static_cast<int32_t>(methodId)); 4918 parameters.emplace_back(static_cast<int32_t>(literalId)); 4919 parameters.emplace_back(static_cast<int32_t>(length)); 4920 uint32_t vregIds = static_cast<uint32_t>(v0) | (static_cast<uint32_t>(v1) << ONE_BYTE_SIZE); 4921 parameters.emplace_back(static_cast<int32_t>(vregIds)); 4922 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4923 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4924 GetBaselineAssembler().SaveResultIntoAcc(); 4925} 4926 4927// GLUE, SP, ACC, V0, FUNC 4928BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_RESUMEGENERATOR_PREF_V8) 4929{ 4930 int8_t v0 = READ_INST_8_1(); 4931 auto *thread = vm->GetAssociatedJSThread(); 4932 Address builtinAddress = 4933 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedResumegeneratorPrefV8); 4934 LOG_INST() << " BaselineDeprecatedResumegeneratorPrefV8 Address: " << std::hex << builtinAddress; 4935 4936 std::vector<BaselineParameter> parameters; 4937 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4938 parameters.emplace_back(BaselineSpecialParameter::SP); 4939 parameters.emplace_back(BaselineSpecialParameter::ACC); 4940 parameters.emplace_back(v0); 4941 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4942 GetBaselineAssembler().SaveResultIntoAcc(); 4943} 4944 4945// SP, ACC, V0 4946BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_GETRESUMEMODE_PREF_V8) 4947{ 4948 int8_t v0 = READ_INST_8_1(); 4949 auto *thread = vm->GetAssociatedJSThread(); 4950 Address builtinAddress = 4951 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedGetresumemodePrefV8); 4952 LOG_INST() << " BaselineDeprecatedGetresumemodePrefV8 Address: " << std::hex << builtinAddress; 4953 4954 std::vector<BaselineParameter> parameters; 4955 parameters.emplace_back(BaselineSpecialParameter::SP); 4956 parameters.emplace_back(BaselineSpecialParameter::ACC); 4957 parameters.emplace_back(v0); 4958 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4959 GetBaselineAssembler().SaveResultIntoAcc(); 4960} 4961 4962// GLUE, SP, V0 4963BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_GETTEMPLATEOBJECT_PREF_V8) 4964{ 4965 int8_t v0 = READ_INST_8_1(); 4966 auto *thread = vm->GetAssociatedJSThread(); 4967 Address builtinAddress = 4968 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedGettemplateobjectPrefV8); 4969 LOG_INST() << " BaselineDeprecatedGettemplateobjectPrefV8 Address: " << std::hex << builtinAddress; 4970 4971 std::vector<BaselineParameter> parameters; 4972 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4973 parameters.emplace_back(BaselineSpecialParameter::SP); 4974 parameters.emplace_back(v0); 4975 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4976 GetBaselineAssembler().SaveResultIntoAcc(); 4977} 4978 4979// GLUE, SP, V0, V1 4980BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_DELOBJPROP_PREF_V8_V8) 4981{ 4982 int8_t v0 = READ_INST_8_1(); 4983 int8_t v1 = READ_INST_8_2(); 4984 auto *thread = vm->GetAssociatedJSThread(); 4985 Address builtinAddress = 4986 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedDelobjpropPrefV8V8); 4987 LOG_INST() << " BaselineDeprecatedDelobjpropPrefV8V8 Address: " << std::hex << builtinAddress; 4988 4989 std::vector<BaselineParameter> parameters; 4990 parameters.emplace_back(BaselineSpecialParameter::GLUE); 4991 parameters.emplace_back(BaselineSpecialParameter::SP); 4992 parameters.emplace_back(v0); 4993 parameters.emplace_back(v1); 4994 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 4995 GetBaselineAssembler().SaveResultIntoAcc(); 4996} 4997 4998// GLUE, SP, V0, V1 4999BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8) 5000{ 5001 int8_t v0 = READ_INST_8_1(); 5002 int8_t v1 = READ_INST_8_2(); 5003 auto *thread = vm->GetAssociatedJSThread(); 5004 Address builtinAddress = 5005 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedAsyncfunctionawaituncaughtPrefV8V8); 5006 LOG_INST() << " BaselineDeprecatedAsyncfunctionawaituncaughtPrefV8V8 Address: " << std::hex << builtinAddress; 5007 5008 std::vector<BaselineParameter> parameters; 5009 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5010 parameters.emplace_back(BaselineSpecialParameter::SP); 5011 parameters.emplace_back(v0); 5012 parameters.emplace_back(v1); 5013 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5014 GetBaselineAssembler().SaveResultIntoAcc(); 5015} 5016 5017// GLUE, SP, V0, V1 5018BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_COPYDATAPROPERTIES_PREF_V8_V8) 5019{ 5020 int8_t v0 = READ_INST_8_1(); 5021 int8_t v1 = READ_INST_8_2(); 5022 auto *thread = vm->GetAssociatedJSThread(); 5023 Address builtinAddress = 5024 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedCopydatapropertiesPrefV8V8); 5025 LOG_INST() << " BaselineDeprecatedCopydatapropertiesPrefV8V8 Address: " << std::hex << builtinAddress; 5026 5027 std::vector<BaselineParameter> parameters; 5028 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5029 parameters.emplace_back(BaselineSpecialParameter::SP); 5030 parameters.emplace_back(v0); 5031 parameters.emplace_back(v1); 5032 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5033 GetBaselineAssembler().SaveResultIntoAcc(); 5034} 5035 5036// GLUE, SP, ACC, V0, V1 5037BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_SETOBJECTWITHPROTO_PREF_V8_V8) 5038{ 5039 int8_t v0 = READ_INST_8_1(); 5040 int8_t v1 = READ_INST_8_2(); 5041 auto *thread = vm->GetAssociatedJSThread(); 5042 Address builtinAddress = 5043 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedSetobjectwithprotoPrefV8V8); 5044 LOG_INST() << " BaselineDeprecatedSetobjectwithprotoPrefV8V8 Address: " << std::hex << builtinAddress; 5045 5046 std::vector<BaselineParameter> parameters; 5047 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5048 parameters.emplace_back(BaselineSpecialParameter::SP); 5049 parameters.emplace_back(BaselineSpecialParameter::ACC); 5050 parameters.emplace_back(v0); 5051 parameters.emplace_back(v1); 5052 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5053 GetBaselineAssembler().SaveResultIntoAcc(); 5054} 5055 5056BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_LDOBJBYVALUE_PREF_V8_V8) 5057{ 5058 int8_t v0 = READ_INST_8_1(); 5059 int8_t v1 = READ_INST_8_2(); 5060 auto *thread = vm->GetAssociatedJSThread(); 5061 Address builtinAddress = 5062 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedLdobjbyvaluePrefV8V8); 5063 LOG_INST() << " BaselineDeprecatedLdobjbyvaluePrefV8V8 Address: " << std::hex << builtinAddress; 5064 5065 std::vector<BaselineParameter> parameters; 5066 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5067 parameters.emplace_back(BaselineSpecialParameter::SP); 5068 parameters.emplace_back(v0); 5069 parameters.emplace_back(v1); 5070 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5071 GetBaselineAssembler().SaveResultIntoAcc(); 5072} 5073 5074// GLUE, SP, V0, V1 5075BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_LDSUPERBYVALUE_PREF_V8_V8) 5076{ 5077 int8_t v0 = READ_INST_8_1(); 5078 int8_t v1 = READ_INST_8_2(); 5079 auto *thread = vm->GetAssociatedJSThread(); 5080 Address builtinAddress = 5081 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedLdsuperbyvaluePrefV8V8); 5082 LOG_INST() << " BaselineDeprecatedLdsuperbyvaluePrefV8V8 Address: " << std::hex << builtinAddress; 5083 5084 std::vector<BaselineParameter> parameters; 5085 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5086 parameters.emplace_back(BaselineSpecialParameter::SP); 5087 parameters.emplace_back(v0); 5088 parameters.emplace_back(v1); 5089 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5090 GetBaselineAssembler().SaveResultIntoAcc(); 5091} 5092 5093// GLUE, SP, V0, INDEX 5094BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_LDOBJBYINDEX_PREF_V8_IMM32) 5095{ 5096 int8_t v0 = READ_INST_8_1(); 5097 int32_t index = static_cast<int32_t>(READ_INST_32_2()); 5098 auto *thread = vm->GetAssociatedJSThread(); 5099 Address builtinAddress = 5100 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedLdobjbyindexPrefV8Imm32); 5101 LOG_INST() << " BaselineDeprecatedLdobjbyindexPrefV8Imm32 Address: " << std::hex << builtinAddress; 5102 5103 std::vector<BaselineParameter> parameters; 5104 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5105 parameters.emplace_back(BaselineSpecialParameter::SP); 5106 parameters.emplace_back(v0); 5107 parameters.emplace_back(index); 5108 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5109 GetBaselineAssembler().SaveResultIntoAcc(); 5110} 5111 5112// GLUE, SP, V0, V1 5113BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8) 5114{ 5115 int8_t v0 = READ_INST_8_1(); 5116 int8_t v1 = READ_INST_8_3(); 5117 auto *thread = vm->GetAssociatedJSThread(); 5118 Address builtinAddress = 5119 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedAsyncfunctionresolvePrefV8V8V8); 5120 LOG_INST() << " BaselineDeprecatedAsyncfunctionresolvePrefV8V8V8 Address: " << std::hex << builtinAddress; 5121 5122 std::vector<BaselineParameter> parameters; 5123 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5124 parameters.emplace_back(BaselineSpecialParameter::SP); 5125 parameters.emplace_back(v0); 5126 parameters.emplace_back(v1); 5127 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5128 GetBaselineAssembler().SaveResultIntoAcc(); 5129} 5130 5131// GLUE, SP, V0, V1 5132BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8) 5133{ 5134 int8_t v0 = READ_INST_8_1(); 5135 int8_t v1 = READ_INST_8_3(); 5136 auto *thread = vm->GetAssociatedJSThread(); 5137 Address builtinAddress = 5138 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedAsyncfunctionrejectPrefV8V8V8); 5139 LOG_INST() << " BaselineDeprecatedAsyncfunctionrejectPrefV8V8V8 Address: " << std::hex << builtinAddress; 5140 5141 std::vector<BaselineParameter> parameters; 5142 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5143 parameters.emplace_back(BaselineSpecialParameter::SP); 5144 parameters.emplace_back(v0); 5145 parameters.emplace_back(v1); 5146 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5147 GetBaselineAssembler().SaveResultIntoAcc(); 5148} 5149 5150// GLUE, SP, LEVEL, SLOT, V0 5151BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_STLEXVAR_PREF_IMM4_IMM4_V8) 5152{ 5153 uint8_t level = READ_INST_4_2(); 5154 uint8_t slot = READ_INST_4_3(); 5155 int8_t v0 = READ_INST_8_2(); 5156 5157 auto *thread = vm->GetAssociatedJSThread(); 5158 Address builtinAddress = 5159 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedStlexvarPrefImm4Imm4V8); 5160 LOG_INST() << " BaselineDeprecatedStlexvarPrefImm4Imm4V8 Address: " << std::hex << builtinAddress; 5161 LOG_INST() << " level: " << static_cast<int32_t>(level); 5162 LOG_INST() << " slot: " << static_cast<int32_t>(slot); 5163 5164 std::vector<BaselineParameter> parameters; 5165 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5166 parameters.emplace_back(BaselineSpecialParameter::SP); 5167 parameters.emplace_back(static_cast<int32_t>(level)); 5168 parameters.emplace_back(static_cast<int32_t>(slot)); 5169 parameters.emplace_back(v0); 5170 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5171} 5172 5173// GLUE, SP, LEVEL, SLOT, V0 5174BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_STLEXVAR_PREF_IMM8_IMM8_V8) 5175{ 5176 uint8_t level = READ_INST_8_1(); 5177 uint8_t slot = READ_INST_8_2(); 5178 int8_t v0 = READ_INST_8_3(); 5179 5180 auto *thread = vm->GetAssociatedJSThread(); 5181 Address builtinAddress = 5182 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedStlexvarPrefImm8Imm8V8); 5183 LOG_INST() << " BaselineDeprecatedStlexvarPrefImm8Imm8V8 Address: " << std::hex << builtinAddress; 5184 LOG_INST() << " level: " << static_cast<int32_t>(level); 5185 LOG_INST() << " slot: " << static_cast<int32_t>(slot); 5186 5187 std::vector<BaselineParameter> parameters; 5188 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5189 parameters.emplace_back(BaselineSpecialParameter::SP); 5190 parameters.emplace_back(static_cast<int32_t>(level)); 5191 parameters.emplace_back(static_cast<int32_t>(slot)); 5192 parameters.emplace_back(v0); 5193 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5194} 5195 5196// GLUE, SP, LEVEL, SLOT, V0 5197BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_STLEXVAR_PREF_IMM16_IMM16_V8) 5198{ 5199 uint16_t level = READ_INST_16_1(); 5200 uint16_t slot = READ_INST_16_3(); 5201 int8_t v0 = READ_INST_8_5(); 5202 5203 auto *thread = vm->GetAssociatedJSThread(); 5204 Address builtinAddress = 5205 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedStlexvarPrefImm16Imm16V8); 5206 LOG_INST() << " BaselineDeprecatedStlexvarPrefImm16Imm16V8 Address: " << std::hex << builtinAddress; 5207 LOG_INST() << " level: " << static_cast<int32_t>(level); 5208 LOG_INST() << " slot: " << static_cast<int32_t>(slot); 5209 5210 std::vector<BaselineParameter> parameters; 5211 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5212 parameters.emplace_back(BaselineSpecialParameter::SP); 5213 parameters.emplace_back(static_cast<int32_t>(level)); 5214 parameters.emplace_back(static_cast<int32_t>(slot)); 5215 parameters.emplace_back(v0); 5216 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5217} 5218 5219// GLUE, STRING_ID, SP 5220BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_GETMODULENAMESPACE_PREF_ID32) 5221{ 5222 int32_t stringId = static_cast<int32_t>(READ_INST_32_1()); 5223 auto *thread = vm->GetAssociatedJSThread(); 5224 Address builtinAddress = 5225 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedGetmodulenamespacePrefId32); 5226 LOG_INST() << " BaselineDeprecatedGetmodulenamespacePrefId32 Address: " << std::hex << builtinAddress; 5227 5228 std::vector<BaselineParameter> parameters; 5229 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5230 parameters.emplace_back(stringId); 5231 parameters.emplace_back(BaselineSpecialParameter::SP); 5232 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5233} 5234 5235// GLUE, ACC, STRING_ID, SP 5236BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_STMODULEVAR_PREF_ID32) 5237{ 5238 int32_t stringId = static_cast<int32_t>(READ_INST_32_1()); 5239 auto *thread = vm->GetAssociatedJSThread(); 5240 Address builtinAddress = 5241 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedStmodulevarPrefId32); 5242 LOG_INST() << " BaselineDeprecatedStmodulevarPrefId32 Address: " << std::hex << builtinAddress; 5243 5244 std::vector<BaselineParameter> parameters; 5245 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5246 parameters.emplace_back(BaselineSpecialParameter::ACC); 5247 parameters.emplace_back(stringId); 5248 parameters.emplace_back(BaselineSpecialParameter::SP); 5249 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5250} 5251 5252BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_LDOBJBYNAME_PREF_ID32_V8) 5253{ 5254 int32_t stringId = static_cast<int32_t>(READ_INST_32_1()); 5255 int8_t v0 = READ_INST_8_5(); 5256 auto *thread = vm->GetAssociatedJSThread(); 5257 Address builtinAddress = 5258 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedLdobjbynamePrefId32V8); 5259 LOG_INST() << " BaselineDeprecatedLdobjbynamePrefId32V8 Address: " << std::hex << builtinAddress; 5260 5261 std::vector<BaselineParameter> parameters; 5262 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5263 parameters.emplace_back(BaselineSpecialParameter::SP); 5264 parameters.emplace_back(v0); 5265 parameters.emplace_back(stringId); 5266 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5267 GetBaselineAssembler().SaveResultIntoAcc(); 5268} 5269 5270BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_LDSUPERBYNAME_PREF_ID32_V8) 5271{ 5272 int32_t stringId = static_cast<int32_t>(READ_INST_32_1()); 5273 int8_t v0 = READ_INST_8_5(); 5274 auto *thread = vm->GetAssociatedJSThread(); 5275 Address builtinAddress = 5276 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedLdsuperbynamePrefId32V8); 5277 LOG_INST() << " BaselineDeprecatedLdsuperbynamePrefId32V8 Address: " << std::hex << builtinAddress; 5278 5279 std::vector<BaselineParameter> parameters; 5280 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5281 parameters.emplace_back(BaselineSpecialParameter::SP); 5282 parameters.emplace_back(stringId); 5283 parameters.emplace_back(v0); 5284 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5285 GetBaselineAssembler().SaveResultIntoAcc(); 5286} 5287 5288BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_LDMODULEVAR_PREF_ID32_IMM8) 5289{ 5290 int32_t stringId = static_cast<int32_t>(READ_INST_32_1()); 5291 int8_t flagI8 = READ_INST_8_5(); 5292 auto *thread = vm->GetAssociatedJSThread(); 5293 Address builtinAddress = 5294 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedLdmodulevarPrefId32Imm8); 5295 LOG_INST() << " BaselineDeprecatedLdmodulevarPrefId32Imm8 Address: " << std::hex << builtinAddress; 5296 5297 std::vector<BaselineParameter> parameters; 5298 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5299 parameters.emplace_back(stringId); 5300 parameters.emplace_back(flagI8); 5301 parameters.emplace_back(BaselineSpecialParameter::SP); 5302 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5303 GetBaselineAssembler().SaveResultIntoAcc(); 5304} 5305 5306BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_STCONSTTOGLOBALRECORD_PREF_ID32) 5307{ 5308 int32_t stringId = static_cast<int32_t>(READ_INST_32_1()); 5309 auto *thread = vm->GetAssociatedJSThread(); 5310 Address builtinAddress = 5311 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedStconsttoglobalrecordPrefId32); 5312 LOG_INST() << " BaselineDeprecatedStconsttoglobalrecordPrefId32 Address: " << std::hex << builtinAddress; 5313 5314 std::vector<BaselineParameter> parameters; 5315 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5316 parameters.emplace_back(BaselineSpecialParameter::ACC); 5317 parameters.emplace_back(stringId); 5318 parameters.emplace_back(BaselineSpecialParameter::SP); 5319 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5320 GetBaselineAssembler().SaveResultIntoAcc(); 5321} 5322 5323// GLUE, ACC, STRING_ID, SP 5324BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_STLETTOGLOBALRECORD_PREF_ID32) 5325{ 5326 int32_t stringId = static_cast<int32_t>(READ_INST_32_1()); 5327 auto *thread = vm->GetAssociatedJSThread(); 5328 Address builtinAddress = 5329 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedStlettoglobalrecordPrefId32); 5330 LOG_INST() << " BaselineDeprecatedStlettoglobalrecordPrefId32 Address: " << std::hex << builtinAddress; 5331 5332 std::vector<BaselineParameter> parameters; 5333 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5334 parameters.emplace_back(BaselineSpecialParameter::ACC); 5335 parameters.emplace_back(stringId); 5336 parameters.emplace_back(BaselineSpecialParameter::SP); 5337 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5338 GetBaselineAssembler().SaveResultIntoAcc(); 5339} 5340 5341// GLUE, ACC, STRING_ID, SP 5342BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_STCLASSTOGLOBALRECORD_PREF_ID32) 5343{ 5344 int32_t stringId = static_cast<int32_t>(READ_INST_32_1()); 5345 auto *thread = vm->GetAssociatedJSThread(); 5346 Address builtinAddress = 5347 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedStclasstoglobalrecordPrefId32); 5348 LOG_INST() << " BaselineDeprecatedStclasstoglobalrecordPrefId32 Address: " << std::hex << builtinAddress; 5349 5350 std::vector<BaselineParameter> parameters; 5351 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5352 parameters.emplace_back(BaselineSpecialParameter::ACC); 5353 parameters.emplace_back(stringId); 5354 parameters.emplace_back(BaselineSpecialParameter::SP); 5355 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5356 GetBaselineAssembler().SaveResultIntoAcc(); 5357} 5358 5359BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_LDHOMEOBJECT_PREF_NONE) 5360{ 5361 (void)bytecodeArray; 5362 auto *thread = vm->GetAssociatedJSThread(); 5363 Address builtinAddress = 5364 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedLdhomeobjectPrefNone); 5365 LOG_INST() << " BaselineDeprecatedLdhomeobjectPrefNone Address: " << std::hex << builtinAddress; 5366 5367 std::vector<BaselineParameter> parameters; 5368 parameters.emplace_back(BaselineSpecialParameter::SP); 5369 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5370 GetBaselineAssembler().SaveResultIntoAcc(); 5371} 5372 5373// GLUE, ACC, CONSTPOOL, IMM_I16, FUNC 5374BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_CREATEOBJECTHAVINGMETHOD_PREF_IMM16) 5375{ 5376 int16_t immI16 = READ_INST_16_1(); 5377 auto *thread = vm->GetAssociatedJSThread(); 5378 Address builtinAddress = 5379 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedCreateobjecthavingmethodPrefImm16); 5380 LOG_INST() << " BaselineDeprecatedCreateobjecthavingmethodPrefImm16 Address: " << std::hex << builtinAddress; 5381 5382 std::vector<BaselineParameter> parameters; 5383 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5384 parameters.emplace_back(BaselineSpecialParameter::ACC); 5385 parameters.emplace_back(BaselineSpecialParameter::SP); 5386 parameters.emplace_back(immI16); 5387 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5388 GetBaselineAssembler().SaveResultIntoAcc(); 5389} 5390 5391BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEPRECATED_DYNAMICIMPORT_PREF_V8) 5392{ 5393 int8_t vregId = READ_INST_8_1(); 5394 auto *thread = vm->GetAssociatedJSThread(); 5395 Address builtinAddress = 5396 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDeprecatedDynamicimportPrefV8); 5397 LOG_INST() << " BaselineDeprecatedDynamicimportPrefV8 Address: " << std::hex << builtinAddress; 5398 5399 std::vector<BaselineParameter> parameters; 5400 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5401 parameters.emplace_back(BaselineSpecialParameter::SP); 5402 parameters.emplace_back(BaselineSpecialParameter::ACC); 5403 parameters.emplace_back(VirtualRegister(vregId)); 5404 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5405 GetBaselineAssembler().SaveResultIntoAcc(); 5406} 5407 5408// ------- End deprecated ------- 5409 5410// GLUE, SP, SLOT_ID, STRING_ID, V0 5411BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEFINEFIELDBYNAME_IMM8_ID16_V8) 5412{ 5413 uint8_t slotId = READ_INST_8_0(); 5414 uint16_t stringId = READ_INST_16_1(); 5415 uint8_t v0 = READ_INST_8_3(); 5416 5417 auto *thread = vm->GetAssociatedJSThread(); 5418 Address builtinAddress = 5419 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDefineFieldByNameImm8Id16V8); 5420 LOG_INST() << " BaselineDefineFieldByNameImm8Id16V8 Address: " << std::hex << builtinAddress; 5421 LOG_INST() << " slotId: " << static_cast<int32_t>(slotId); 5422 LOG_INST() << " stringId: " << static_cast<int32_t>(stringId); 5423 5424 std::vector<BaselineParameter> parameters; 5425 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5426 parameters.emplace_back(BaselineSpecialParameter::SP); 5427 parameters.emplace_back(static_cast<int32_t>(slotId)); 5428 parameters.emplace_back(static_cast<int32_t>(stringId)); 5429 parameters.emplace_back(static_cast<int32_t>(v0)); 5430 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5431 GetBaselineAssembler().SaveResultIntoAcc(); 5432} 5433 5434// GLUE, SP, ACC, PROFILE_TYPE_INFO, SLOT_ID_I8, STRING_ID, V0 5435BYTECODE_BASELINE_HANDLER_IMPLEMENT(DEFINEPROPERTYBYNAME_IMM8_ID16_V8) 5436{ 5437 uint8_t slotId = READ_INST_8_0(); 5438 uint16_t stringId = READ_INST_16_1(); 5439 uint8_t v0 = READ_INST_8_3(); 5440 5441 auto *thread = vm->GetAssociatedJSThread(); 5442 Address builtinAddress = 5443 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineDefinePropertyByNameImm8Id16V8); 5444 LOG_INST() << " BaselineDefinePropertyByNameImm8Id16V8 Address: " << std::hex << builtinAddress; 5445 5446 std::vector<BaselineParameter> parameters; 5447 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5448 parameters.emplace_back(BaselineSpecialParameter::SP); 5449 parameters.emplace_back(static_cast<int32_t>(slotId)); 5450 parameters.emplace_back(static_cast<int32_t>(stringId)); 5451 parameters.emplace_back(static_cast<int32_t>(v0)); 5452 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5453 GetBaselineAssembler().SaveResultIntoAcc(); 5454} 5455 5456BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_NOTIFYCONCURRENTRESULT_PREF_NONE) 5457{ 5458 (void)bytecodeArray; 5459 auto *thread = vm->GetAssociatedJSThread(); 5460 Address builtinAddress = 5461 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCallRuntimeNotifyConcurrentResultPrefNone); 5462 LOG_INST() << " BaselineCallRuntimeNotifyConcurrentResultPrefNone Address: " << std::hex << builtinAddress; 5463 5464 std::vector<BaselineParameter> parameters; 5465 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5466 parameters.emplace_back(BaselineSpecialParameter::SP); 5467 parameters.emplace_back(BaselineSpecialParameter::ACC); 5468 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5469} 5470 5471BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_DEFINEFIELDBYVALUE_PREF_IMM8_V8_V8) 5472{ 5473 int8_t v0 = READ_INST_8_2(); 5474 int8_t v1 = READ_INST_8_3(); 5475 auto *thread = vm->GetAssociatedJSThread(); 5476 Address builtinAddress = 5477 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCallRuntimeDefineFieldByValuePrefImm8V8V8); 5478 LOG_INST() << " BaselineCallRuntimeDefineFieldByValuePrefImm8V8V8 Address: " << std::hex << builtinAddress; 5479 5480 std::vector<BaselineParameter> parameters; 5481 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5482 parameters.emplace_back(BaselineSpecialParameter::SP); 5483 parameters.emplace_back(BaselineSpecialParameter::ACC); 5484 parameters.emplace_back(v0); 5485 parameters.emplace_back(v1); 5486 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5487 GetBaselineAssembler().SaveResultIntoAcc(); 5488} 5489 5490// GLUE, SP, ACC, INDEX, V0 5491BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_DEFINEFIELDBYINDEX_PREF_IMM8_IMM32_V8) 5492{ 5493 int32_t index = static_cast<int32_t>(READ_INST_32_2()); 5494 int8_t v0 = READ_INST_8_6(); 5495 auto *thread = vm->GetAssociatedJSThread(); 5496 Address builtinAddress = 5497 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCallRuntimeDefineFieldByIndexPrefImm8Imm32V8); 5498 LOG_INST() << " BaselineCallRuntimeDefineFieldByIndexPrefImm8Imm32V8 Address: " << std::hex << builtinAddress; 5499 5500 std::vector<BaselineParameter> parameters; 5501 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5502 parameters.emplace_back(BaselineSpecialParameter::SP); 5503 parameters.emplace_back(BaselineSpecialParameter::ACC); 5504 parameters.emplace_back(index); 5505 parameters.emplace_back(v0); 5506 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5507 GetBaselineAssembler().SaveResultIntoAcc(); 5508} 5509 5510BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_TOPROPERTYKEY_PREF_NONE) 5511{ 5512 (void)bytecodeArray; 5513 auto *thread = vm->GetAssociatedJSThread(); 5514 Address builtinAddress = 5515 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCallRuntimeToPropertyKeyPrefNone); 5516 LOG_INST() << " BaselineCallRuntimeToPropertyKeyPrefNone Address: " << std::hex << builtinAddress; 5517 5518 std::vector<BaselineParameter> parameters; 5519 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5520 parameters.emplace_back(BaselineSpecialParameter::SP); 5521 parameters.emplace_back(BaselineSpecialParameter::ACC); 5522 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5523 GetBaselineAssembler().SaveResultIntoAcc(); 5524} 5525 5526// GLUE, SP, COUNT, LITERAL_ID 5527BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_CREATEPRIVATEPROPERTY_PREF_IMM16_ID16) 5528{ 5529 uint16_t count = READ_INST_16_1(); 5530 uint16_t literalId = READ_INST_16_3(); 5531 auto *thread = vm->GetAssociatedJSThread(); 5532 Address builtinAddress = 5533 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCallRuntimeCreatePrivatePropertyPrefImm16Id16); 5534 LOG_INST() << " BaselineCallRuntimeCreatePrivatePropertyPrefImm16Id16 Address: " << std::hex << builtinAddress; 5535 LOG_INST() << " count: " << static_cast<int32_t>(count); 5536 LOG_INST() << " literalId: " << static_cast<int32_t>(literalId); 5537 5538 std::vector<BaselineParameter> parameters; 5539 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5540 parameters.emplace_back(BaselineSpecialParameter::SP); 5541 parameters.emplace_back(static_cast<int32_t>(count)); 5542 parameters.emplace_back(static_cast<int32_t>(literalId)); 5543 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5544 GetBaselineAssembler().SaveResultIntoAcc(); 5545} 5546 5547BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_DEFINEPRIVATEPROPERTY_PREF_IMM8_IMM16_IMM16_V8) 5548{ 5549 uint16_t levelIndex = READ_INST_16_2(); 5550 uint16_t slotIndex = READ_INST_16_4(); 5551 int8_t v0 = READ_INST_8_6(); 5552 auto *thread = vm->GetAssociatedJSThread(); 5553 Address builtinAddress = thread->GetBaselineStubEntry( 5554 BaselineStubCSigns::BaselineCallRuntimeDefinePrivatePropertyPrefImm8Imm16Imm16V8); 5555 LOG_INST() << " BaselineCallRuntimeDefinePrivatePropertyPrefImm8Imm16Imm16V8 Address: " 5556 << std::hex << builtinAddress; 5557 LOG_INST() << " levelIndex: " << static_cast<int32_t>(levelIndex); 5558 LOG_INST() << " slotIndex: " << static_cast<int32_t>(slotIndex); 5559 5560 std::vector<BaselineParameter> parameters; 5561 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5562 parameters.emplace_back(BaselineSpecialParameter::SP); 5563 parameters.emplace_back(BaselineSpecialParameter::ACC); 5564 parameters.emplace_back(static_cast<int32_t>(levelIndex)); 5565 parameters.emplace_back(static_cast<int32_t>(slotIndex)); 5566 parameters.emplace_back(v0); 5567 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5568 GetBaselineAssembler().SaveResultIntoAcc(); 5569} 5570 5571BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_CALLINIT_PREF_IMM8_V8) 5572{ 5573 uint8_t slotId = READ_INST_8_1(); 5574 int8_t v0 = READ_INST_8_2(); 5575 auto *thread = vm->GetAssociatedJSThread(); 5576 Address builtinAddress = 5577 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCallRuntimeCallInitPrefImm8V8); 5578 LOG_INST() << " BaselineCallRuntimeCallInitPrefImm8V8 Address: " << std::hex << builtinAddress; 5579 5580 std::vector<BaselineParameter> parameters; 5581 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5582 parameters.emplace_back(BaselineSpecialParameter::SP); 5583 parameters.emplace_back(BaselineSpecialParameter::ACC); 5584 parameters.emplace_back(v0); 5585 parameters.emplace_back(BaselineSpecialParameter::HOTNESS_COUNTER); 5586 parameters.emplace_back(static_cast<int32_t>(slotId)); 5587 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5588 GetBaselineAssembler().SaveResultIntoAcc(); 5589} 5590 5591BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_DEFINESENDABLECLASS_PREF_IMM16_ID16_ID16_IMM16_V8) 5592{ 5593 int16_t methodId = READ_INST_16_3(); 5594 int16_t literalId = READ_INST_16_5(); 5595 int16_t length = READ_INST_16_7(); 5596 int8_t v0 = READ_INST_8_9(); 5597 5598 auto *thread = vm->GetAssociatedJSThread(); 5599 Address builtinAddress = thread->GetBaselineStubEntry( 5600 BaselineStubCSigns::BaselineCallRuntimeDefineSendableClassPrefImm16Id16Id16Imm16V8); 5601 LOG_INST() << " BaselineCallRuntimeDefineSendableClassPrefImm16Id16Id16Imm16V8 Address: " 5602 << std::hex << builtinAddress; 5603 5604 std::vector<BaselineParameter> parameters; 5605 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5606 parameters.emplace_back(BaselineSpecialParameter::SP); 5607 parameters.emplace_back(methodId); 5608 parameters.emplace_back(literalId); 5609 parameters.emplace_back(length); 5610 parameters.emplace_back(v0); 5611 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5612 GetBaselineAssembler().SaveResultIntoAcc(); 5613} 5614 5615BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_LDSENDABLECLASS_PREF_IMM16) 5616{ 5617 int16_t level = READ_INST_16_1(); 5618 auto *thread = vm->GetAssociatedJSThread(); 5619 Address builtinAddress = 5620 thread->GetBaselineStubEntry(BaselineStubCSigns::BaselineCallRuntimeLdSendableClassPrefImm16); 5621 LOG_INST() << " BaselineCallRuntimeLdSendableClassPrefImm16 Address: " << std::hex << builtinAddress; 5622 5623 std::vector<BaselineParameter> parameters; 5624 parameters.emplace_back(BaselineSpecialParameter::GLUE); 5625 parameters.emplace_back(BaselineSpecialParameter::SP); 5626 parameters.emplace_back(level); 5627 GetBaselineAssembler().CallBuiltin(builtinAddress, parameters); 5628 GetBaselineAssembler().SaveResultIntoAcc(); 5629} 5630 5631BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_LDSENDABLEEXTERNALMODULEVAR_PREF_IMM8) 5632{ 5633 (void)bytecodeArray; 5634} 5635 5636BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_WIDELDSENDABLEEXTERNALMODULEVAR_PREF_IMM16) 5637{ 5638 (void)bytecodeArray; 5639} 5640 5641BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_NEWSENDABLEENV_PREF_IMM8) 5642{ 5643 (void)bytecodeArray; 5644} 5645 5646BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_WIDENEWSENDABLEENV_PREF_IMM16) 5647{ 5648 (void)bytecodeArray; 5649} 5650 5651BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_STSENDABLEVAR_PREF_IMM4_IMM4) 5652{ 5653 (void)bytecodeArray; 5654} 5655 5656BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_STSENDABLEVAR_PREF_IMM8_IMM8) 5657{ 5658 (void)bytecodeArray; 5659} 5660 5661BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_WIDESTSENDABLEVAR_PREF_IMM16_IMM16) 5662{ 5663 (void)bytecodeArray; 5664} 5665 5666BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_LDSENDABLEVAR_PREF_IMM4_IMM4) 5667{ 5668 (void)bytecodeArray; 5669} 5670 5671BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_LDSENDABLEVAR_PREF_IMM8_IMM8) 5672{ 5673 (void)bytecodeArray; 5674} 5675 5676BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_WIDELDSENDABLEVAR_PREF_IMM16_IMM16) 5677{ 5678 (void)bytecodeArray; 5679} 5680 5681BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_LDLAZYMODULEVAR_PREF_IMM8) 5682{ 5683 (void)bytecodeArray; 5684} 5685 5686BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_WIDELDLAZYMODULEVAR_PREF_IMM16) 5687{ 5688 (void)bytecodeArray; 5689} 5690 5691BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_LDLAZYSENDABLEMODULEVAR_PREF_IMM8) 5692{ 5693 (void)bytecodeArray; 5694} 5695 5696BYTECODE_BASELINE_HANDLER_IMPLEMENT(CALLRUNTIME_WIDELDLAZYSENDABLEMODULEVAR_PREF_IMM16) 5697{ 5698 (void)bytecodeArray; 5699} 5700#undef LOG_INST 5701} // namespace panda::ecmascript::kungfu 5702