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