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