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