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