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