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