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