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),
2494 { glue, currentSp, *varPc, *varConstpool, *varProfileTypeInfo,
2495 *varAcc, *varHotnessCounter, jumpSize });
2496 Return();
2497 }
2498 }
2499
DECLARE_ASM_HANDLER(HandleDeprecatedSuspendgeneratorPrefV8V8)2500 DECLARE_ASM_HANDLER(HandleDeprecatedSuspendgeneratorPrefV8V8)
2501 {
2502 auto env = GetEnvironment();
2503 DEFVARIABLE(varPc, VariableType::NATIVE_POINTER(), pc);
2504 DEFVARIABLE(varSp, VariableType::NATIVE_POINTER(), sp);
2505 DEFVARIABLE(varConstpool, VariableType::JS_POINTER(), constpool);
2506 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_POINTER(), profileTypeInfo);
2507 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
2508 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter);
2509
2510 Label pcEqualNullptr(env);
2511 Label pcNotEqualNullptr(env);
2512 Label updateHotness(env);
2513 Label tryContinue(env);
2514 Label dispatch(env);
2515 Label slowPath(env);
2516
2517 GateRef genObj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc)));
2518 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc)));
2519 GateRef frame = GetFrame(*varSp);
2520 GateRef res = CallRuntime(glue, RTSTUB_ID(SuspendGenerator), { genObj, value });
2521 Label isException(env);
2522 Label notException(env);
2523 Branch(TaggedIsException(res), &isException, ¬Exception);
2524 Bind(&isException);
2525 {
2526 DispatchLast(glue, *varSp, *varPc, *varConstpool, *varProfileTypeInfo, *varAcc, *varHotnessCounter);
2527 }
2528 Bind(¬Exception);
2529 varAcc = res;
2530 Branch(TaggedIsUndefined(*varProfileTypeInfo), &updateHotness, &tryContinue);
2531 Bind(&updateHotness);
2532 {
2533 GateRef function = GetFunctionFromFrame(frame);
2534 GateRef method = Load(VariableType::JS_ANY(), function,
2535 IntPtr(JSFunctionBase::METHOD_OFFSET));
2536 GateRef fistPC = Load(VariableType::NATIVE_POINTER(), method,
2537 IntPtr(Method::NATIVE_POINTER_OR_BYTECODE_ARRAY_OFFSET));
2538 GateRef offset = Int32Not(TruncPtrToInt32(PtrSub(*varPc, fistPC)));
2539 UPDATE_HOTNESS(*varSp, callback);
2540 SetHotnessCounter(glue, method, *varHotnessCounter);
2541 Jump(&tryContinue);
2542 }
2543
2544 Bind(&tryContinue);
2545 #if ECMASCRIPT_ENABLE_FUNCTION_CALL_TIMER
2546 GateRef curFunc = GetFunctionFromFrame(frame);
2547 CallNGCRuntime(glue, RTSTUB_ID(EndCallTimer), { glue, curFunc });
2548 #endif
2549 GateRef currentSp = *varSp;
2550 varSp = Load(VariableType::NATIVE_POINTER(), frame,
2551 IntPtr(AsmInterpretedFrame::GetBaseOffset(env->IsArch32Bit())));
2552 GateRef prevState = GetFrame(*varSp);
2553 varPc = GetPcFromFrame(prevState);
2554 Branch(IntPtrEqual(*varPc, IntPtr(0)), &pcEqualNullptr, &pcNotEqualNullptr);
2555 Bind(&pcEqualNullptr);
2556 {
2557 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndReturn), { *varAcc, *varSp, currentSp });
2558 Return();
2559 }
2560 Bind(&pcNotEqualNullptr);
2561 {
2562 GateRef function = GetFunctionFromFrame(prevState);
2563 GateRef method = Load(VariableType::JS_ANY(), function, IntPtr(JSFunctionBase::METHOD_OFFSET));
2564 varConstpool = GetConstpoolFromMethod(method);
2565 varProfileTypeInfo = GetProfileTypeInfoFromMethod(method);
2566 varHotnessCounter = GetHotnessCounterFromMethod(method);
2567 GateRef jumpSize = GetCallSizeFromFrame(prevState);
2568 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndDispatch),
2569 { glue, currentSp, *varPc, *varConstpool, *varProfileTypeInfo,
2570 *varAcc, *varHotnessCounter, jumpSize });
2571 Return();
2572 }
2573 }
2574
DECLARE_ASM_HANDLER(HandleTryldglobalbynameImm8Id16)2575 DECLARE_ASM_HANDLER(HandleTryldglobalbynameImm8Id16)
2576 {
2577 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
2578
2579 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc));
2580 AccessObjectStubBuilder builder(this);
2581 StringIdInfo info = { constpool, pc, StringIdInfo::Offset::BYTE_1, StringIdInfo::Length::BITS_16 };
2582 GateRef result = builder.TryLoadGlobalByName(glue, 0, info, profileTypeInfo, slotId, callback);
2583 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(TRYLDGLOBALBYNAME_IMM8_ID16));
2584 }
2585
DECLARE_ASM_HANDLER(HandleTryldglobalbynameImm16Id16)2586 DECLARE_ASM_HANDLER(HandleTryldglobalbynameImm16Id16)
2587 {
2588 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
2589
2590 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc));
2591 AccessObjectStubBuilder builder(this);
2592 StringIdInfo info = { constpool, pc, StringIdInfo::Offset::BYTE_2, StringIdInfo::Length::BITS_16 };
2593 GateRef result = builder.TryLoadGlobalByName(glue, 0, info, profileTypeInfo, slotId, callback);
2594 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(TRYLDGLOBALBYNAME_IMM16_ID16));
2595 }
2596
DECLARE_ASM_HANDLER(HandleTrystglobalbynameImm8Id16)2597 DECLARE_ASM_HANDLER(HandleTrystglobalbynameImm8Id16)
2598 {
2599 GateRef slotId = ZExtInt16ToInt32(ReadInst8_0(pc));
2600 AccessObjectStubBuilder builder(this);
2601 StringIdInfo info = { constpool, pc, StringIdInfo::Offset::BYTE_1, StringIdInfo::Length::BITS_16 };
2602 GateRef result = builder.TryStoreGlobalByName(glue, 0, info, acc, profileTypeInfo, slotId, callback);
2603 CHECK_EXCEPTION(result, INT_PTR(TRYSTGLOBALBYNAME_IMM8_ID16));
2604 }
2605
DECLARE_ASM_HANDLER(HandleTrystglobalbynameImm16Id16)2606 DECLARE_ASM_HANDLER(HandleTrystglobalbynameImm16Id16)
2607 {
2608 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc));
2609 AccessObjectStubBuilder builder(this);
2610 StringIdInfo info = { constpool, pc, StringIdInfo::Offset::BYTE_2, StringIdInfo::Length::BITS_16 };
2611 GateRef result = builder.TryStoreGlobalByName(glue, 0, info, acc, profileTypeInfo, slotId, callback);
2612 CHECK_EXCEPTION(result, INT_PTR(TRYSTGLOBALBYNAME_IMM16_ID16));
2613 }
2614
DECLARE_ASM_HANDLER(HandleLdglobalvarImm16Id16)2615 DECLARE_ASM_HANDLER(HandleLdglobalvarImm16Id16)
2616 {
2617 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
2618
2619 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc));
2620 AccessObjectStubBuilder builder(this);
2621 StringIdInfo info = { constpool, pc, StringIdInfo::Offset::BYTE_2, StringIdInfo::Length::BITS_16 };
2622 GateRef result = builder.LoadGlobalVar(glue, 0, info, profileTypeInfo, slotId, callback);
2623 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDGLOBALVAR_IMM16_ID16));
2624 }
2625
DECLARE_ASM_HANDLER(HandleStglobalvarImm16Id16)2626 DECLARE_ASM_HANDLER(HandleStglobalvarImm16Id16)
2627 {
2628 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc));
2629 AccessObjectStubBuilder builder(this);
2630 StringIdInfo info = { constpool, pc, StringIdInfo::Offset::BYTE_2, StringIdInfo::Length::BITS_16 };
2631 GateRef result = builder.StoreGlobalVar(glue, 0, info, acc, profileTypeInfo, slotId);
2632 CHECK_EXCEPTION(result, INT_PTR(STGLOBALVAR_IMM16_ID16));
2633 }
2634
DECLARE_ASM_HANDLER(HandleCreateregexpwithliteralImm8Id16Imm8)2635 DECLARE_ASM_HANDLER(HandleCreateregexpwithliteralImm8Id16Imm8)
2636 {
2637 GateRef stringId = ReadInst16_1(pc);
2638 GateRef pattern = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId));
2639 GateRef flags = ReadInst8_3(pc);
2640 GateRef res = CallRuntime(glue, RTSTUB_ID(CreateRegExpWithLiteral),
2641 { pattern, Int8ToTaggedInt(flags) });
2642 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CREATEREGEXPWITHLITERAL_IMM8_ID16_IMM8));
2643 }
2644
DECLARE_ASM_HANDLER(HandleCreateregexpwithliteralImm16Id16Imm8)2645 DECLARE_ASM_HANDLER(HandleCreateregexpwithliteralImm16Id16Imm8)
2646 {
2647 GateRef stringId = ReadInst16_2(pc);
2648 GateRef pattern = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId));
2649 GateRef flags = ReadInst8_4(pc);
2650 GateRef res = CallRuntime(glue, RTSTUB_ID(CreateRegExpWithLiteral),
2651 { pattern, Int8ToTaggedInt(flags) });
2652 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CREATEREGEXPWITHLITERAL_IMM16_ID16_IMM8));
2653 }
2654
DECLARE_ASM_HANDLER(HandleIstrue)2655 DECLARE_ASM_HANDLER(HandleIstrue)
2656 {
2657 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
2658
2659 varAcc = FastToBoolean(*varAcc);
2660 DISPATCH_WITH_ACC(ISTRUE);
2661 }
2662
DECLARE_ASM_HANDLER(HandleIsfalse)2663 DECLARE_ASM_HANDLER(HandleIsfalse)
2664 {
2665 auto env = GetEnvironment();
2666 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
2667
2668 Label isTrue(env);
2669 Label isFalse(env);
2670 Label dispatch(env);
2671 auto result = FastToBoolean(*varAcc);
2672 Branch(TaggedIsTrue(result), &isTrue, &isFalse);
2673 Bind(&isTrue);
2674 {
2675 varAcc = TaggedFalse();
2676 Jump(&dispatch);
2677 }
2678 Bind(&isFalse);
2679 {
2680 varAcc = TaggedTrue();
2681 Jump(&dispatch);
2682 }
2683 Bind(&dispatch);
2684 DISPATCH_WITH_ACC(ISFALSE);
2685 }
2686
DECLARE_ASM_HANDLER(HandleTonumberImm8)2687 DECLARE_ASM_HANDLER(HandleTonumberImm8)
2688 {
2689 auto env = GetEnvironment();
2690 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
2691 GateRef value = *varAcc;
2692 Label valueIsNumber(env);
2693 Label valueNotNumber(env);
2694 Branch(TaggedIsNumber(value), &valueIsNumber, &valueNotNumber);
2695 Bind(&valueIsNumber);
2696 {
2697 varAcc = value;
2698 DISPATCH_WITH_ACC(TONUMBER_IMM8);
2699 }
2700 Bind(&valueNotNumber);
2701 {
2702 GateRef res = CallRuntime(glue, RTSTUB_ID(ToNumber), { value });
2703 CHECK_EXCEPTION_WITH_VARACC(res, INT_PTR(TONUMBER_IMM8));
2704 }
2705 }
2706
DECLARE_ASM_HANDLER(HandleDeprecatedTonumberPrefV8)2707 DECLARE_ASM_HANDLER(HandleDeprecatedTonumberPrefV8)
2708 {
2709 auto env = GetEnvironment();
2710 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
2711 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc)));
2712 Label valueIsNumber(env);
2713 Label valueNotNumber(env);
2714 Branch(TaggedIsNumber(value), &valueIsNumber, &valueNotNumber);
2715 Bind(&valueIsNumber);
2716 {
2717 varAcc = value;
2718 DISPATCH_WITH_ACC(DEPRECATED_TONUMBER_PREF_V8);
2719 }
2720 Bind(&valueNotNumber);
2721 {
2722 GateRef res = CallRuntime(glue, RTSTUB_ID(ToNumber), { value });
2723 CHECK_EXCEPTION_WITH_VARACC(res, INT_PTR(DEPRECATED_TONUMBER_PREF_V8));
2724 }
2725 }
2726
DECLARE_ASM_HANDLER(HandleAdd2Imm8V8)2727 DECLARE_ASM_HANDLER(HandleAdd2Imm8V8)
2728 {
2729 GateRef v0 = ReadInst8_1(pc);
2730 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(v0));
2731 OperationsStubBuilder builder(this);
2732 GateRef result = builder.Add(glue, left, acc, callback);
2733 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(ADD2_IMM8_V8));
2734 }
2735
DECLARE_ASM_HANDLER(HandleSub2Imm8V8)2736 DECLARE_ASM_HANDLER(HandleSub2Imm8V8)
2737 {
2738 GateRef v0 = ReadInst8_1(pc);
2739 GateRef left = GetVregValue(sp, ZExtInt8ToPtr(v0));
2740 OperationsStubBuilder builder(this);
2741 GateRef result = builder.Sub(glue, left, acc, callback);
2742 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(SUB2_IMM8_V8));
2743 }
2744
DECLARE_ASM_HANDLER(HandleLdbigintId16)2745 DECLARE_ASM_HANDLER(HandleLdbigintId16)
2746 {
2747 GateRef stringId = ReadInst16_0(pc);
2748 GateRef numberBigInt = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId));
2749 GateRef res = CallRuntime(glue, RTSTUB_ID(LdBigInt), { numberBigInt });
2750 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(LDBIGINT_ID16));
2751 }
2752
DECLARE_ASM_HANDLER(HandleTonumericImm8)2753 DECLARE_ASM_HANDLER(HandleTonumericImm8)
2754 {
2755 auto env = GetEnvironment();
2756 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
2757 GateRef value = *varAcc;
2758 Label valueIsNumeric(env);
2759 Label valueNotNumeric(env);
2760 Branch(TaggedIsNumeric(value), &valueIsNumeric, &valueNotNumeric);
2761 Bind(&valueIsNumeric);
2762 {
2763 varAcc = value;
2764 DISPATCH_WITH_ACC(TONUMERIC_IMM8);
2765 }
2766 Bind(&valueNotNumeric);
2767 {
2768 GateRef res = CallRuntime(glue, RTSTUB_ID(ToNumeric), { value });
2769 CHECK_EXCEPTION_WITH_VARACC(res, INT_PTR(TONUMERIC_IMM8));
2770 }
2771 }
2772
DECLARE_ASM_HANDLER(HandleDeprecatedTonumericPrefV8)2773 DECLARE_ASM_HANDLER(HandleDeprecatedTonumericPrefV8)
2774 {
2775 auto env = GetEnvironment();
2776 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
2777 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc)));
2778 Label valueIsNumeric(env);
2779 Label valueNotNumeric(env);
2780 Branch(TaggedIsNumeric(value), &valueIsNumeric, &valueNotNumeric);
2781 Bind(&valueIsNumeric);
2782 {
2783 varAcc = value;
2784 DISPATCH_WITH_ACC(DEPRECATED_TONUMERIC_PREF_V8);
2785 }
2786 Bind(&valueNotNumeric);
2787 {
2788 GateRef res = CallRuntime(glue, RTSTUB_ID(ToNumeric), { value });
2789 CHECK_EXCEPTION_WITH_VARACC(res, INT_PTR(DEPRECATED_TONUMERIC_PREF_V8));
2790 }
2791 }
2792
DECLARE_ASM_HANDLER(HandleDynamicimport)2793 DECLARE_ASM_HANDLER(HandleDynamicimport)
2794 {
2795 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
2796 GateRef specifier = *varAcc;
2797 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp));
2798 GateRef res = CallRuntime(glue, RTSTUB_ID(DynamicImport), { specifier, currentFunc });
2799 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(DYNAMICIMPORT));
2800 }
2801
DECLARE_ASM_HANDLER(HandleDeprecatedDynamicimportPrefV8)2802 DECLARE_ASM_HANDLER(HandleDeprecatedDynamicimportPrefV8)
2803 {
2804 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
2805 GateRef specifier = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc)));
2806 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp));
2807 GateRef res = CallRuntime(glue, RTSTUB_ID(DynamicImport), { specifier, currentFunc });
2808 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(DEPRECATED_DYNAMICIMPORT_PREF_V8));
2809 }
2810
DECLARE_ASM_HANDLER(HandleCreateasyncgeneratorobjV8)2811 DECLARE_ASM_HANDLER(HandleCreateasyncgeneratorobjV8)
2812 {
2813 auto env = GetEnvironment();
2814 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
2815
2816 GateRef v0 = ReadInst8_0(pc);
2817 GateRef genFunc = GetVregValue(sp, ZExtInt8ToPtr(v0));
2818 GateRef result = CallRuntime(glue, RTSTUB_ID(CreateAsyncGeneratorObj), { genFunc });
2819 Label isException(env);
2820 Label notException(env);
2821 Branch(TaggedIsException(result), &isException, ¬Exception);
2822 Bind(&isException);
2823 {
2824 DISPATCH_LAST();
2825 }
2826 Bind(¬Exception);
2827 varAcc = result;
2828 DISPATCH_WITH_ACC(CREATEASYNCGENERATOROBJ_V8);
2829 }
2830
DECLARE_ASM_HANDLER(HandleAsyncgeneratorresolveV8V8V8)2831 DECLARE_ASM_HANDLER(HandleAsyncgeneratorresolveV8V8V8)
2832 {
2833 auto env = GetEnvironment();
2834 DEFVARIABLE(varPc, VariableType::NATIVE_POINTER(), pc);
2835 DEFVARIABLE(varSp, VariableType::NATIVE_POINTER(), sp);
2836 DEFVARIABLE(varConstpool, VariableType::JS_POINTER(), constpool);
2837 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_POINTER(), profileTypeInfo);
2838 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter);
2839 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
2840
2841 Label pcEqualNullptr(env);
2842 Label pcNotEqualNullptr(env);
2843 Label updateHotness(env);
2844 Label tryContinue(env);
2845 Label dispatch(env);
2846 Label slowPath(env);
2847
2848 GateRef asyncGenerator = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_0(pc)));
2849 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc)));
2850 GateRef flag = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc)));
2851 GateRef frame = GetFrame(*varSp);
2852 GateRef res = CallRuntime(glue, RTSTUB_ID(AsyncGeneratorResolve),
2853 { asyncGenerator, value, flag });
2854 Label isException(env);
2855 Label notException(env);
2856 Branch(TaggedIsException(res), &isException, ¬Exception);
2857 Bind(&isException);
2858 {
2859 DISPATCH_LAST();
2860 }
2861 Bind(¬Exception);
2862 varAcc = res;
2863 Branch(TaggedIsUndefined(*varProfileTypeInfo), &updateHotness, &tryContinue);
2864 Bind(&updateHotness);
2865 {
2866 GateRef function = GetFunctionFromFrame(frame);
2867 GateRef method = Load(VariableType::JS_ANY(), function,
2868 IntPtr(JSFunctionBase::METHOD_OFFSET));
2869 GateRef fistPC = Load(VariableType::NATIVE_POINTER(), method,
2870 IntPtr(Method::NATIVE_POINTER_OR_BYTECODE_ARRAY_OFFSET));
2871 GateRef offset = Int32Not(TruncPtrToInt32(PtrSub(*varPc, fistPC)));
2872 UPDATE_HOTNESS(*varSp, callback);
2873 SetHotnessCounter(glue, method, *varHotnessCounter);
2874 Jump(&tryContinue);
2875 }
2876
2877 Bind(&tryContinue);
2878 #if ECMASCRIPT_ENABLE_FUNCTION_CALL_TIMER
2879 GateRef curFunc = GetFunctionFromFrame(frame);
2880 CallNGCRuntime(glue, RTSTUB_ID(EndCallTimer), { glue, curFunc });
2881 #endif
2882 GateRef currentSp = *varSp;
2883 varSp = Load(VariableType::NATIVE_POINTER(), frame,
2884 IntPtr(AsmInterpretedFrame::GetBaseOffset(env->IsArch32Bit())));
2885 GateRef prevState = GetFrame(*varSp);
2886 varPc = GetPcFromFrame(prevState);
2887 Branch(IntPtrEqual(*varPc, IntPtr(0)), &pcEqualNullptr, &pcNotEqualNullptr);
2888 Bind(&pcEqualNullptr);
2889 {
2890 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndReturn), { *varAcc, *varSp, currentSp });
2891 Return();
2892 }
2893 Bind(&pcNotEqualNullptr);
2894 {
2895 GateRef function = GetFunctionFromFrame(prevState);
2896 GateRef method = Load(VariableType::JS_ANY(), function, IntPtr(JSFunctionBase::METHOD_OFFSET));
2897 varConstpool = GetConstpoolFromMethod(method);
2898 varProfileTypeInfo = GetProfileTypeInfoFromMethod(method);
2899 varHotnessCounter = GetHotnessCounterFromMethod(method);
2900 GateRef jumpSize = GetCallSizeFromFrame(prevState);
2901 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndDispatch),
2902 { glue, currentSp, *varPc, *varConstpool, *varProfileTypeInfo,
2903 *varAcc, *varHotnessCounter, jumpSize });
2904 Return();
2905 }
2906 }
2907
DECLARE_ASM_HANDLER(HandleAsyncgeneratorrejectV8)2908 DECLARE_ASM_HANDLER(HandleAsyncgeneratorrejectV8)
2909 {
2910 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
2911 GateRef asyncGenerator = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_0(pc)));
2912 GateRef res = CallRuntime(glue, RTSTUB_ID(AsyncGeneratorReject),
2913 { asyncGenerator, acc });
2914 CHECK_EXCEPTION_VARACC(res, INT_PTR(ASYNCGENERATORREJECT_V8));
2915 }
2916
DECLARE_ASM_HANDLER(HandleSetgeneratorstateImm8)2917 DECLARE_ASM_HANDLER(HandleSetgeneratorstateImm8)
2918 {
2919 GateRef index = ReadInst8_0(pc);
2920 GateRef value = acc;
2921 CallRuntime(glue, RTSTUB_ID(SetGeneratorState), { value, IntToTaggedInt(index) });
2922 DISPATCH(SETGENERATORSTATE_IMM8);
2923 }
2924
DECLARE_ASM_HANDLER(HandleDeprecatedAsyncgeneratorrejectPrefV8V8)2925 DECLARE_ASM_HANDLER(HandleDeprecatedAsyncgeneratorrejectPrefV8V8)
2926 {
2927 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
2928 GateRef asyncGenerator = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc)));
2929 GateRef value = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc)));
2930 GateRef res = CallRuntime(glue, RTSTUB_ID(AsyncGeneratorReject),
2931 { asyncGenerator, value });
2932 CHECK_EXCEPTION_VARACC(res, INT_PTR(DEPRECATED_ASYNCGENERATORREJECT_PREF_V8_V8));
2933 }
2934
DECLARE_ASM_HANDLER(HandleSupercallthisrangeImm8Imm8V8)2935 DECLARE_ASM_HANDLER(HandleSupercallthisrangeImm8Imm8V8)
2936 {
2937 GateRef range = ReadInst8_1(pc);
2938 GateRef v0 = ZExtInt8ToInt16(ReadInst8_2(pc));
2939 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp));
2940 GateRef res = CallRuntime(glue, RTSTUB_ID(SuperCall),
2941 { currentFunc, Int16ToTaggedInt(v0), Int8ToTaggedInt(range) });
2942 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(SUPERCALLTHISRANGE_IMM8_IMM8_V8));
2943 }
2944
DECLARE_ASM_HANDLER(HandleSupercallarrowrangeImm8Imm8V8)2945 DECLARE_ASM_HANDLER(HandleSupercallarrowrangeImm8Imm8V8)
2946 {
2947 GateRef range = ReadInst8_1(pc);
2948 GateRef v0 = ZExtInt8ToInt16(ReadInst8_2(pc));
2949 GateRef res = CallRuntime(glue, RTSTUB_ID(SuperCall),
2950 { acc, Int16ToTaggedInt(v0), Int8ToTaggedInt(range) });
2951 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(SUPERCALLARROWRANGE_IMM8_IMM8_V8));
2952 }
2953
DECLARE_ASM_HANDLER(HandleWideSupercallthisrangePrefImm16V8)2954 DECLARE_ASM_HANDLER(HandleWideSupercallthisrangePrefImm16V8)
2955 {
2956 GateRef range = ReadInst16_1(pc);
2957 GateRef v0 = ZExtInt8ToInt16(ReadInst8_3(pc));
2958 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp));
2959 GateRef res = CallRuntime(glue, RTSTUB_ID(SuperCall),
2960 { currentFunc, Int16ToTaggedInt(v0), Int16ToTaggedInt(range) });
2961 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(WIDE_SUPERCALLTHISRANGE_PREF_IMM16_V8));
2962 }
2963
DECLARE_ASM_HANDLER(HandleWideSupercallarrowrangePrefImm16V8)2964 DECLARE_ASM_HANDLER(HandleWideSupercallarrowrangePrefImm16V8)
2965 {
2966 GateRef range = ReadInst16_1(pc);
2967 GateRef v0 = ZExtInt8ToInt16(ReadInst8_3(pc));
2968 GateRef res = CallRuntime(glue, RTSTUB_ID(SuperCall),
2969 { acc, Int16ToTaggedInt(v0), Int16ToTaggedInt(range) });
2970 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(WIDE_SUPERCALLARROWRANGE_PREF_IMM16_V8));
2971 }
2972
DECLARE_ASM_HANDLER(HandleLdsuperbyvalueImm8V8)2973 DECLARE_ASM_HANDLER(HandleLdsuperbyvalueImm8V8)
2974 {
2975 GateRef v0 = ReadInst8_1(pc);
2976 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0));
2977 GateRef propKey = acc;
2978 GateRef result = CallRuntime(glue, RTSTUB_ID(LdSuperByValue), { receiver, propKey }); // sp for thisFunc
2979 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(LDSUPERBYVALUE_IMM8_V8));
2980 }
DECLARE_ASM_HANDLER(HandleLdsuperbyvalueImm16V8)2981 DECLARE_ASM_HANDLER(HandleLdsuperbyvalueImm16V8)
2982 {
2983 GateRef v0 = ReadInst8_2(pc);
2984 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0));
2985 GateRef propKey = acc;
2986 GateRef result = CallRuntime(glue, RTSTUB_ID(LdSuperByValue), { receiver, propKey }); // sp for thisFunc
2987 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(LDSUPERBYVALUE_IMM16_V8));
2988 }
2989
DECLARE_ASM_HANDLER(HandleDeprecatedLdsuperbyvaluePrefV8V8)2990 DECLARE_ASM_HANDLER(HandleDeprecatedLdsuperbyvaluePrefV8V8)
2991 {
2992 GateRef v0 = ReadInst8_1(pc);
2993 GateRef v1 = ReadInst8_2(pc);
2994 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0));
2995 GateRef propKey = GetVregValue(sp, ZExtInt8ToPtr(v1));
2996 GateRef result = CallRuntime(glue, RTSTUB_ID(LdSuperByValue), { receiver, propKey }); // sp for thisFunc
2997 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DEPRECATED_LDSUPERBYVALUE_PREF_V8_V8));
2998 }
2999
DECLARE_ASM_HANDLER(HandleDeprecatedGetiteratornextPrefV8V8)3000 DECLARE_ASM_HANDLER(HandleDeprecatedGetiteratornextPrefV8V8)
3001 {
3002 GateRef v0 = ReadInst8_1(pc);
3003 GateRef v1 = ReadInst8_2(pc);
3004 GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(v0));
3005 GateRef method = GetVregValue(sp, ZExtInt8ToPtr(v1));
3006 GateRef result = CallRuntime(glue, RTSTUB_ID(GetIteratorNext), { obj, method });
3007 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DEPRECATED_GETITERATORNEXT_PREF_V8_V8));
3008 }
3009
DECLARE_ASM_HANDLER(HandleLdobjbyvalueImm8V8)3010 DECLARE_ASM_HANDLER(HandleLdobjbyvalueImm8V8)
3011 {
3012 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3013
3014 GateRef v0 = ReadInst8_1(pc);
3015 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0));
3016 GateRef propKey = acc;
3017 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc));
3018
3019 AccessObjectStubBuilder builder(this);
3020 GateRef result = builder.LoadObjByValue(glue, receiver, propKey, profileTypeInfo, slotId, callback);
3021 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDOBJBYVALUE_IMM8_V8));
3022 }
3023
DECLARE_ASM_HANDLER(HandleLdobjbyvalueImm16V8)3024 DECLARE_ASM_HANDLER(HandleLdobjbyvalueImm16V8)
3025 {
3026 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3027
3028 GateRef v0 = ReadInst8_2(pc);
3029 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0));
3030 GateRef propKey = acc;
3031 GateRef slotId = ZExtInt8ToInt32(ReadInst16_0(pc));
3032
3033 AccessObjectStubBuilder builder(this);
3034 GateRef result = builder.LoadObjByValue(glue, receiver, propKey, profileTypeInfo, slotId, callback);
3035 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDOBJBYVALUE_IMM16_V8));
3036 }
3037
DECLARE_ASM_HANDLER(HandleDeprecatedLdobjbyvaluePrefV8V8)3038 DECLARE_ASM_HANDLER(HandleDeprecatedLdobjbyvaluePrefV8V8)
3039 {
3040 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3041
3042 GateRef v0 = ReadInst8_1(pc);
3043 GateRef v1 = ReadInst8_2(pc);
3044 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0));
3045 GateRef propKey = GetVregValue(sp, ZExtInt8ToPtr(v1));
3046
3047 AccessObjectStubBuilder builder(this);
3048 GateRef result = builder.DeprecatedLoadObjByValue(glue, receiver, propKey);
3049 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(DEPRECATED_LDOBJBYVALUE_PREF_V8_V8));
3050 }
3051
DECLARE_ASM_HANDLER(HandleLdsuperbynameImm8Id16)3052 DECLARE_ASM_HANDLER(HandleLdsuperbynameImm8Id16)
3053 {
3054 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3055
3056 GateRef stringId = ReadInst16_1(pc);
3057 GateRef receiver = acc;
3058 GateRef propKey = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId));
3059 GateRef result = CallRuntime(glue, RTSTUB_ID(LdSuperByValue), { receiver, propKey });
3060 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDSUPERBYNAME_IMM8_ID16));
3061 }
3062
DECLARE_ASM_HANDLER(HandleLdsuperbynameImm16Id16)3063 DECLARE_ASM_HANDLER(HandleLdsuperbynameImm16Id16)
3064 {
3065 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3066
3067 GateRef stringId = ReadInst16_2(pc);
3068 GateRef receiver = acc;
3069 GateRef propKey = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId));
3070 GateRef result = CallRuntime(glue, RTSTUB_ID(LdSuperByValue), { receiver, propKey });
3071 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDSUPERBYNAME_IMM16_ID16));
3072 }
3073
DECLARE_ASM_HANDLER(HandleDeprecatedLdsuperbynamePrefId32V8)3074 DECLARE_ASM_HANDLER(HandleDeprecatedLdsuperbynamePrefId32V8)
3075 {
3076 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3077
3078 GateRef stringId = ReadInst32_1(pc);
3079 GateRef v0 = ReadInst8_5(pc);
3080 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0));
3081 GateRef propKey = GetStringFromConstPool(glue, constpool, stringId);
3082 GateRef result = CallRuntime(glue, RTSTUB_ID(LdSuperByValue), { receiver, propKey });
3083 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(DEPRECATED_LDSUPERBYNAME_PREF_ID32_V8));
3084 }
3085
DECLARE_ASM_HANDLER(HandleLdobjbyindexImm8Imm16)3086 DECLARE_ASM_HANDLER(HandleLdobjbyindexImm8Imm16)
3087 {
3088 auto env = GetEnvironment();
3089
3090 GateRef receiver = acc;
3091 GateRef index = ZExtInt16ToInt32(ReadInst16_1(pc));
3092 Label fastPath(env);
3093 Label slowPath(env);
3094 Branch(TaggedIsHeapObject(receiver), &fastPath, &slowPath);
3095 Bind(&fastPath);
3096 {
3097 GateRef result = GetPropertyByIndex(glue, receiver, index, callback);
3098 Label notHole(env);
3099 Branch(TaggedIsHole(result), &slowPath, ¬Hole);
3100 Bind(¬Hole);
3101 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(LDOBJBYINDEX_IMM8_IMM16));
3102 }
3103 Bind(&slowPath);
3104 {
3105 GateRef result = CallRuntime(glue, RTSTUB_ID(LdObjByIndex),
3106 { receiver, IntToTaggedInt(index), TaggedFalse(), Undefined() });
3107 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(LDOBJBYINDEX_IMM8_IMM16));
3108 }
3109 }
3110
DECLARE_ASM_HANDLER(HandleLdobjbyindexImm16Imm16)3111 DECLARE_ASM_HANDLER(HandleLdobjbyindexImm16Imm16)
3112 {
3113 auto env = GetEnvironment();
3114
3115 GateRef receiver = acc;
3116 GateRef index = ZExtInt16ToInt32(ReadInst16_2(pc));
3117 Label fastPath(env);
3118 Label slowPath(env);
3119 Branch(TaggedIsHeapObject(receiver), &fastPath, &slowPath);
3120 Bind(&fastPath);
3121 {
3122 GateRef result = GetPropertyByIndex(glue, receiver, index, callback);
3123 Label notHole(env);
3124 Branch(TaggedIsHole(result), &slowPath, ¬Hole);
3125 Bind(¬Hole);
3126 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(LDOBJBYINDEX_IMM16_IMM16));
3127 }
3128 Bind(&slowPath);
3129 {
3130 GateRef result = CallRuntime(glue, RTSTUB_ID(LdObjByIndex),
3131 { receiver, IntToTaggedInt(index), TaggedFalse(), Undefined() });
3132 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(LDOBJBYINDEX_IMM16_IMM16));
3133 }
3134 }
3135
DECLARE_ASM_HANDLER(HandleWideLdobjbyindexPrefImm32)3136 DECLARE_ASM_HANDLER(HandleWideLdobjbyindexPrefImm32)
3137 {
3138 auto env = GetEnvironment();
3139
3140 GateRef receiver = acc;
3141 GateRef index = ReadInst32_1(pc);
3142 Label fastPath(env);
3143 Label slowPath(env);
3144 Branch(TaggedIsHeapObject(receiver), &fastPath, &slowPath);
3145 Bind(&fastPath);
3146 {
3147 GateRef result = GetPropertyByIndex(glue, receiver, index, callback);
3148 Label notHole(env);
3149 Branch(TaggedIsHole(result), &slowPath, ¬Hole);
3150 Bind(¬Hole);
3151 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(WIDE_LDOBJBYINDEX_PREF_IMM32));
3152 }
3153 Bind(&slowPath);
3154 {
3155 GateRef result = CallRuntime(glue, RTSTUB_ID(LdObjByIndex),
3156 { receiver, IntToTaggedInt(index), TaggedFalse(), Undefined() });
3157 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(WIDE_LDOBJBYINDEX_PREF_IMM32));
3158 }
3159 }
3160
DECLARE_ASM_HANDLER(HandleDeprecatedLdobjbyindexPrefV8Imm32)3161 DECLARE_ASM_HANDLER(HandleDeprecatedLdobjbyindexPrefV8Imm32)
3162 {
3163 auto env = GetEnvironment();
3164
3165 GateRef v0 = ReadInst8_1(pc);
3166 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(v0));
3167 GateRef index = ReadInst32_2(pc);
3168 Label fastPath(env);
3169 Label slowPath(env);
3170 Branch(TaggedIsHeapObject(receiver), &fastPath, &slowPath);
3171 Bind(&fastPath);
3172 {
3173 GateRef result = GetPropertyByIndex(glue, receiver, index, callback);
3174 Label notHole(env);
3175 Branch(TaggedIsHole(result), &slowPath, ¬Hole);
3176 Bind(¬Hole);
3177 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DEPRECATED_LDOBJBYINDEX_PREF_V8_IMM32));
3178 }
3179 Bind(&slowPath);
3180 {
3181 GateRef result = CallRuntime(glue, RTSTUB_ID(LdObjByIndex),
3182 { receiver, IntToTaggedInt(index), TaggedFalse(), Undefined() });
3183 CHECK_EXCEPTION_WITH_ACC(result, INT_PTR(DEPRECATED_LDOBJBYINDEX_PREF_V8_IMM32));
3184 }
3185 }
3186
DECLARE_ASM_HANDLER(HandleStconsttoglobalrecordImm16Id16)3187 DECLARE_ASM_HANDLER(HandleStconsttoglobalrecordImm16Id16)
3188 {
3189 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3190
3191 GateRef stringId = ReadInst16_2(pc);
3192 GateRef propKey = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId));
3193 GateRef result = CallRuntime(glue, RTSTUB_ID(StGlobalRecord),
3194 { propKey, *varAcc, TaggedTrue() });
3195 CHECK_EXCEPTION_VARACC(result, INT_PTR(STCONSTTOGLOBALRECORD_IMM16_ID16));
3196 }
3197
DECLARE_ASM_HANDLER(HandleSttoglobalrecordImm16Id16)3198 DECLARE_ASM_HANDLER(HandleSttoglobalrecordImm16Id16)
3199 {
3200 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3201
3202 GateRef stringId = ReadInst16_2(pc);
3203 GateRef propKey = GetStringFromConstPool(glue, constpool, ZExtInt16ToInt32(stringId));
3204 GateRef result = CallRuntime(glue, RTSTUB_ID(StGlobalRecord),
3205 { propKey, *varAcc, TaggedFalse() });
3206 CHECK_EXCEPTION_VARACC(result, INT_PTR(STTOGLOBALRECORD_IMM16_ID16));
3207 }
3208
DECLARE_ASM_HANDLER(HandleDeprecatedStconsttoglobalrecordPrefId32)3209 DECLARE_ASM_HANDLER(HandleDeprecatedStconsttoglobalrecordPrefId32)
3210 {
3211 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3212
3213 GateRef stringId = ReadInst32_1(pc);
3214 GateRef propKey = GetStringFromConstPool(glue, constpool, stringId);
3215 GateRef result = CallRuntime(glue, RTSTUB_ID(StGlobalRecord),
3216 { propKey, *varAcc, TaggedTrue() });
3217 CHECK_EXCEPTION_VARACC(result, INT_PTR(DEPRECATED_STCONSTTOGLOBALRECORD_PREF_ID32));
3218 }
3219
DECLARE_ASM_HANDLER(HandleDeprecatedStlettoglobalrecordPrefId32)3220 DECLARE_ASM_HANDLER(HandleDeprecatedStlettoglobalrecordPrefId32)
3221 {
3222 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3223
3224 GateRef stringId = ReadInst32_1(pc);
3225 GateRef propKey = GetStringFromConstPool(glue, constpool, stringId);
3226 GateRef result = CallRuntime(glue, RTSTUB_ID(StGlobalRecord),
3227 { propKey, *varAcc, TaggedFalse() });
3228 CHECK_EXCEPTION_VARACC(result, INT_PTR(DEPRECATED_STLETTOGLOBALRECORD_PREF_ID32));
3229 }
3230
DECLARE_ASM_HANDLER(HandleDeprecatedStclasstoglobalrecordPrefId32)3231 DECLARE_ASM_HANDLER(HandleDeprecatedStclasstoglobalrecordPrefId32)
3232 {
3233 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3234
3235 GateRef stringId = ReadInst32_1(pc);
3236 GateRef propKey = GetStringFromConstPool(glue, constpool, stringId);
3237 GateRef result = CallRuntime(glue, RTSTUB_ID(StGlobalRecord),
3238 { propKey, *varAcc, TaggedFalse() });
3239 CHECK_EXCEPTION_VARACC(result, INT_PTR(DEPRECATED_STCLASSTOGLOBALRECORD_PREF_ID32));
3240 }
3241
DECLARE_ASM_HANDLER(HandleGetmodulenamespaceImm8)3242 DECLARE_ASM_HANDLER(HandleGetmodulenamespaceImm8)
3243 {
3244 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3245
3246 GateRef index = ReadInst8_0(pc);
3247 GateRef moduleRef = CallRuntime(glue, RTSTUB_ID(GetModuleNamespaceByIndex), { IntToTaggedInt(index) });
3248 varAcc = moduleRef;
3249 DISPATCH_WITH_ACC(GETMODULENAMESPACE_IMM8);
3250 }
3251
DECLARE_ASM_HANDLER(HandleWideGetmodulenamespacePrefImm16)3252 DECLARE_ASM_HANDLER(HandleWideGetmodulenamespacePrefImm16)
3253 {
3254 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3255
3256 GateRef index = ReadInst16_1(pc);
3257 GateRef moduleRef = CallRuntime(glue, RTSTUB_ID(GetModuleNamespaceByIndex), { Int16ToTaggedInt(index) });
3258 varAcc = moduleRef;
3259 DISPATCH_WITH_ACC(WIDE_GETMODULENAMESPACE_PREF_IMM16);
3260 }
3261
DECLARE_ASM_HANDLER(HandleDeprecatedGetmodulenamespacePrefId32)3262 DECLARE_ASM_HANDLER(HandleDeprecatedGetmodulenamespacePrefId32)
3263 {
3264 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3265
3266 GateRef stringId = ReadInst32_1(pc);
3267 GateRef prop = GetStringFromConstPool(glue, constpool, stringId);
3268 GateRef moduleRef = CallRuntime(glue, RTSTUB_ID(GetModuleNamespace), { prop });
3269 varAcc = moduleRef;
3270 DISPATCH_WITH_ACC(DEPRECATED_GETMODULENAMESPACE_PREF_ID32);
3271 }
3272
DECLARE_ASM_HANDLER(HandleLdlocalmodulevarImm8)3273 DECLARE_ASM_HANDLER(HandleLdlocalmodulevarImm8)
3274 {
3275 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3276
3277 GateRef index = ReadInst8_0(pc);
3278 GateRef moduleRef = CallRuntime(glue, RTSTUB_ID(LdLocalModuleVarByIndex), { Int8ToTaggedInt(index) });
3279 varAcc = moduleRef;
3280 DISPATCH_WITH_ACC(LDLOCALMODULEVAR_IMM8);
3281 }
3282
DECLARE_ASM_HANDLER(HandleWideLdlocalmodulevarPrefImm16)3283 DECLARE_ASM_HANDLER(HandleWideLdlocalmodulevarPrefImm16)
3284 {
3285 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3286
3287 GateRef index = ReadInst16_1(pc);
3288 GateRef moduleRef = CallRuntime(glue, RTSTUB_ID(LdLocalModuleVarByIndex), { Int16ToTaggedInt(index) });
3289 varAcc = moduleRef;
3290 DISPATCH_WITH_ACC(WIDE_LDLOCALMODULEVAR_PREF_IMM16);
3291 }
3292
DECLARE_ASM_HANDLER(HandleLdexternalmodulevarImm8)3293 DECLARE_ASM_HANDLER(HandleLdexternalmodulevarImm8)
3294 {
3295 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3296
3297 GateRef index = ReadInst8_0(pc);
3298 GateRef moduleRef = CallRuntime(glue, RTSTUB_ID(LdExternalModuleVarByIndex), { Int8ToTaggedInt(index) });
3299 varAcc = moduleRef;
3300 DISPATCH_WITH_ACC(LDEXTERNALMODULEVAR_IMM8);
3301 }
3302
DECLARE_ASM_HANDLER(HandleWideLdexternalmodulevarPrefImm16)3303 DECLARE_ASM_HANDLER(HandleWideLdexternalmodulevarPrefImm16)
3304 {
3305 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3306
3307 GateRef index = ReadInst16_1(pc);
3308 GateRef moduleRef = CallRuntime(glue, RTSTUB_ID(LdExternalModuleVarByIndex), { Int16ToTaggedInt(index) });
3309 varAcc = moduleRef;
3310 DISPATCH_WITH_ACC(WIDE_LDEXTERNALMODULEVAR_PREF_IMM16);
3311 }
3312
DECLARE_ASM_HANDLER(HandleDeprecatedLdmodulevarPrefId32Imm8)3313 DECLARE_ASM_HANDLER(HandleDeprecatedLdmodulevarPrefId32Imm8)
3314 {
3315 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3316
3317 GateRef stringId = ReadInst32_1(pc);
3318 GateRef flag = ZExtInt8ToInt32(ReadInst8_5(pc));
3319 GateRef key = GetStringFromConstPool(glue, constpool, stringId);
3320 GateRef moduleRef = CallRuntime(glue, RTSTUB_ID(LdModuleVar), { key, IntToTaggedInt(flag) });
3321 varAcc = moduleRef;
3322 DISPATCH_WITH_ACC(DEPRECATED_LDMODULEVAR_PREF_ID32_IMM8);
3323 }
3324
DECLARE_ASM_HANDLER(HandleStmodulevarImm8)3325 DECLARE_ASM_HANDLER(HandleStmodulevarImm8)
3326 {
3327 GateRef index = ReadInst8_0(pc);
3328 GateRef value = acc;
3329
3330 CallRuntime(glue, RTSTUB_ID(StModuleVarByIndex), { IntToTaggedInt(index), value });
3331 DISPATCH(STMODULEVAR_IMM8);
3332 }
3333
DECLARE_ASM_HANDLER(HandleWideStmodulevarPrefImm16)3334 DECLARE_ASM_HANDLER(HandleWideStmodulevarPrefImm16)
3335 {
3336 GateRef index = ReadInst16_1(pc);
3337 GateRef value = acc;
3338
3339 CallRuntime(glue, RTSTUB_ID(StModuleVarByIndex), { Int16ToTaggedInt(index), value });
3340 DISPATCH(WIDE_STMODULEVAR_PREF_IMM16);
3341 }
3342
DECLARE_ASM_HANDLER(HandleDeprecatedStmodulevarPrefId32)3343 DECLARE_ASM_HANDLER(HandleDeprecatedStmodulevarPrefId32)
3344 {
3345 GateRef stringId = ReadInst32_1(pc);
3346 GateRef prop = GetStringFromConstPool(glue, constpool, stringId);
3347 GateRef value = acc;
3348
3349 CallRuntime(glue, RTSTUB_ID(StModuleVar), { prop, value });
3350 DISPATCH(DEPRECATED_STMODULEVAR_PREF_ID32);
3351 }
3352
DECLARE_ASM_HANDLER(HandleNewlexenvImm8)3353 DECLARE_ASM_HANDLER(HandleNewlexenvImm8)
3354 {
3355 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3356 DEFVARIABLE(result, VariableType::JS_ANY(), Hole());
3357 auto env = GetEnvironment();
3358 GateRef numVars = ReadInst8_0(pc);
3359 GateRef state = GetFrame(sp);
3360 auto parent = GetEnvFromFrame(state);
3361 NewObjectStubBuilder newBuilder(this);
3362 newBuilder.SetParameters(glue, 0);
3363 Label afterNew(env);
3364 newBuilder.NewLexicalEnv(&result, &afterNew, ZExtInt16ToInt32(numVars), parent);
3365 Bind(&afterNew);
3366 Label notException(env);
3367 CHECK_EXCEPTION_WITH_JUMP(*result, ¬Exception);
3368 Bind(¬Exception);
3369 varAcc = *result;
3370 SetEnvToFrame(glue, GetFrame(sp), *result);
3371 DISPATCH_WITH_ACC(NEWLEXENV_IMM8);
3372 }
3373
DECLARE_ASM_HANDLER(HandleWideNewlexenvPrefImm16)3374 DECLARE_ASM_HANDLER(HandleWideNewlexenvPrefImm16)
3375 {
3376 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3377 DEFVARIABLE(result, VariableType::JS_ANY(), Hole());
3378 auto env = GetEnvironment();
3379 GateRef numVars = ReadInst16_1(pc);
3380 GateRef state = GetFrame(sp);
3381 auto parent = GetEnvFromFrame(state);
3382 NewObjectStubBuilder newBuilder(this);
3383 newBuilder.SetParameters(glue, 0);
3384 Label afterNew(env);
3385 newBuilder.NewLexicalEnv(&result, &afterNew, ZExtInt16ToInt32(numVars), parent);
3386 Bind(&afterNew);
3387 Label notException(env);
3388 CHECK_EXCEPTION_WITH_JUMP(*result, ¬Exception);
3389 Bind(¬Exception);
3390 varAcc = *result;
3391 SetEnvToFrame(glue, GetFrame(sp), *result);
3392 DISPATCH_WITH_ACC(WIDE_NEWLEXENV_PREF_IMM16);
3393 }
3394
DECLARE_ASM_HANDLER(HandleNewlexenvwithnameImm8Id16)3395 DECLARE_ASM_HANDLER(HandleNewlexenvwithnameImm8Id16)
3396 {
3397 auto env = GetEnvironment();
3398 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3399 GateRef numVars = ZExtInt8ToInt16(ReadInst8_0(pc));
3400 GateRef scopeId = ReadInst16_1(pc);
3401 GateRef res = CallRuntime(glue, RTSTUB_ID(NewLexicalEnvWithName),
3402 { Int16ToTaggedInt(numVars), Int16ToTaggedInt(scopeId) });
3403 Label notException(env);
3404 CHECK_EXCEPTION_WITH_JUMP(res, ¬Exception);
3405 Bind(¬Exception);
3406 varAcc = res;
3407 GateRef state = GetFrame(sp);
3408 SetEnvToFrame(glue, state, res);
3409 DISPATCH_WITH_ACC(NEWLEXENVWITHNAME_IMM8_ID16);
3410 }
3411
DECLARE_ASM_HANDLER(HandleWideNewlexenvwithnamePrefImm16Id16)3412 DECLARE_ASM_HANDLER(HandleWideNewlexenvwithnamePrefImm16Id16)
3413 {
3414 auto env = GetEnvironment();
3415 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3416 GateRef numVars = ReadInst16_1(pc);
3417 GateRef scopeId = ReadInst16_3(pc);
3418 GateRef res = CallRuntime(glue, RTSTUB_ID(NewLexicalEnvWithName),
3419 { Int16ToTaggedInt(numVars), Int16ToTaggedInt(scopeId) });
3420 Label notException(env);
3421 CHECK_EXCEPTION_WITH_JUMP(res, ¬Exception);
3422 Bind(¬Exception);
3423 varAcc = res;
3424 GateRef state = GetFrame(sp);
3425 SetEnvToFrame(glue, state, res);
3426 DISPATCH_WITH_ACC(WIDE_NEWLEXENVWITHNAME_PREF_IMM16_ID16);
3427 }
3428
DECLARE_ASM_HANDLER(HandleDefineclasswithbufferImm8Id16Id16Imm16V8)3429 DECLARE_ASM_HANDLER(HandleDefineclasswithbufferImm8Id16Id16Imm16V8)
3430 {
3431 auto env = GetEnvironment();
3432 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3433
3434 GateRef methodId = ReadInst16_1(pc);
3435 GateRef literalId = ReadInst16_3(pc);
3436 GateRef length = ReadInst16_5(pc);
3437 GateRef v0 = ReadInst8_7(pc);
3438
3439 GateRef proto = GetVregValue(sp, ZExtInt8ToPtr(v0));
3440 GateRef lexicalEnv = GetEnvFromFrame(GetFrame(sp));
3441 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp));
3442 GateRef module = GetModuleFromFunction(currentFunc);
3443 GateRef res = CallRuntime(glue, RTSTUB_ID(CreateClassWithBuffer),
3444 { proto, lexicalEnv, constpool,
3445 Int16ToTaggedInt(methodId),
3446 Int16ToTaggedInt(literalId), module });
3447
3448 Label isException(env);
3449 Label isNotException(env);
3450 Branch(TaggedIsException(res), &isException, &isNotException);
3451 Bind(&isException);
3452 {
3453 DISPATCH_LAST_WITH_ACC();
3454 }
3455 Bind(&isNotException);
3456 SetLexicalEnvToFunction(glue, res, lexicalEnv);
3457 SetModuleToFunction(glue, res, module);
3458 CallRuntime(glue, RTSTUB_ID(SetClassConstructorLength), { res, Int16ToTaggedInt(length) });
3459 callback.ProfileDefineClass(res);
3460 varAcc = res;
3461 DISPATCH_WITH_ACC(DEFINECLASSWITHBUFFER_IMM8_ID16_ID16_IMM16_V8);
3462 }
3463
DECLARE_ASM_HANDLER(HandleDefineclasswithbufferImm16Id16Id16Imm16V8)3464 DECLARE_ASM_HANDLER(HandleDefineclasswithbufferImm16Id16Id16Imm16V8)
3465 {
3466 auto env = GetEnvironment();
3467 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3468
3469 GateRef methodId = ReadInst16_2(pc);
3470 GateRef literalId = ReadInst16_4(pc);
3471 GateRef length = ReadInst16_6(pc);
3472 GateRef v0 = ReadInst8_8(pc);
3473
3474 GateRef proto = GetVregValue(sp, ZExtInt8ToPtr(v0));
3475 GateRef lexicalEnv = GetEnvFromFrame(GetFrame(sp));
3476 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp));
3477 GateRef module = GetModuleFromFunction(currentFunc);
3478 GateRef res = CallRuntime(glue, RTSTUB_ID(CreateClassWithBuffer),
3479 { proto, lexicalEnv, constpool,
3480 Int16ToTaggedInt(methodId),
3481 Int16ToTaggedInt(literalId), module });
3482
3483 Label isException(env);
3484 Label isNotException(env);
3485 Branch(TaggedIsException(res), &isException, &isNotException);
3486 Bind(&isException);
3487 {
3488 DISPATCH_LAST_WITH_ACC();
3489 }
3490 Bind(&isNotException);
3491 SetLexicalEnvToFunction(glue, res, lexicalEnv);
3492 SetModuleToFunction(glue, res, module);
3493 CallRuntime(glue, RTSTUB_ID(SetClassConstructorLength), { res, Int16ToTaggedInt(length) });
3494 callback.ProfileDefineClass(res);
3495 varAcc = res;
3496 DISPATCH_WITH_ACC(DEFINECLASSWITHBUFFER_IMM16_ID16_ID16_IMM16_V8);
3497 }
3498
DECLARE_ASM_HANDLER(HandleDeprecatedDefineclasswithbufferPrefId16Imm16Imm16V8V8)3499 DECLARE_ASM_HANDLER(HandleDeprecatedDefineclasswithbufferPrefId16Imm16Imm16V8V8)
3500 {
3501 auto env = GetEnvironment();
3502 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3503
3504 GateRef methodId = ReadInst16_1(pc);
3505 GateRef literalId = ReadInst16_3(pc);
3506 GateRef length = ReadInst16_5(pc);
3507 GateRef v0 = ReadInst8_7(pc);
3508 GateRef v1 = ReadInst8_8(pc);
3509
3510 GateRef lexicalEnv = GetVregValue(sp, ZExtInt8ToPtr(v0));
3511 GateRef proto = GetVregValue(sp, ZExtInt8ToPtr(v1));
3512
3513 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp));
3514 GateRef module = GetModuleFromFunction(currentFunc);
3515 GateRef res = CallRuntime(glue, RTSTUB_ID(CreateClassWithBuffer),
3516 { proto, lexicalEnv, constpool,
3517 Int16ToTaggedInt(methodId),
3518 Int16ToTaggedInt(literalId), module });
3519
3520 Label isException(env);
3521 Label isNotException(env);
3522 Branch(TaggedIsException(res), &isException, &isNotException);
3523 Bind(&isException);
3524 {
3525 DISPATCH_LAST_WITH_ACC();
3526 }
3527 Bind(&isNotException);
3528 SetLexicalEnvToFunction(glue, res, lexicalEnv);
3529 SetModuleToFunction(glue, res, module);
3530 CallRuntime(glue, RTSTUB_ID(SetClassConstructorLength), { res, Int16ToTaggedInt(length) });
3531 varAcc = res;
3532 DISPATCH_WITH_ACC(DEPRECATED_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8);
3533 }
3534
DECLARE_ASM_HANDLER(HandleLdobjbynameImm8Id16)3535 DECLARE_ASM_HANDLER(HandleLdobjbynameImm8Id16)
3536 {
3537 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3538
3539 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc));
3540 GateRef receiver = acc;
3541 AccessObjectStubBuilder builder(this);
3542 StringIdInfo info = { constpool, pc, StringIdInfo::Offset::BYTE_1, StringIdInfo::Length::BITS_16 };
3543 GateRef result = builder.LoadObjByName(glue, receiver, 0, info, profileTypeInfo, slotId, callback);
3544 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDOBJBYNAME_IMM8_ID16));
3545 }
3546
DECLARE_ASM_HANDLER(HandleLdobjbynameImm16Id16)3547 DECLARE_ASM_HANDLER(HandleLdobjbynameImm16Id16)
3548 {
3549 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3550
3551 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc));
3552 GateRef receiver = acc;
3553 AccessObjectStubBuilder builder(this);
3554 StringIdInfo info = { constpool, pc, StringIdInfo::Offset::BYTE_2, StringIdInfo::Length::BITS_16 };
3555 GateRef result = builder.LoadObjByName(glue, receiver, 0, info, profileTypeInfo, slotId, callback);
3556 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDOBJBYNAME_IMM16_ID16));
3557 }
3558
DECLARE_ASM_HANDLER(HandleDeprecatedLdobjbynamePrefId32V8)3559 DECLARE_ASM_HANDLER(HandleDeprecatedLdobjbynamePrefId32V8)
3560 {
3561 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3562
3563 GateRef receiver = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_5(pc)));
3564 GateRef stringId = ReadInst32_1(pc);
3565 GateRef propKey = GetStringFromConstPool(glue, constpool, stringId);
3566 AccessObjectStubBuilder builder(this);
3567 GateRef result = builder.DeprecatedLoadObjByName(glue, receiver, propKey);
3568 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(DEPRECATED_LDOBJBYNAME_PREF_ID32_V8));
3569 }
3570
DECLARE_ASM_HANDLER(HandleCallarg0Imm8)3571 DECLARE_ASM_HANDLER(HandleCallarg0Imm8)
3572 {
3573 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARG0);
3574 GateRef func = acc;
3575 GateRef jumpSize = INT_PTR(CALLARG0_IMM8);
3576 GateRef res = JSCallDispatch(glue, func, actualNumArgs, jumpSize, hotnessCounter,
3577 JSCallMode::CALL_ARG0, {}, callback);
3578 CHECK_PENDING_EXCEPTION(res, jumpSize);
3579 }
3580
DECLARE_ASM_HANDLER(HandleDeprecatedCallarg0PrefV8)3581 DECLARE_ASM_HANDLER(HandleDeprecatedCallarg0PrefV8)
3582 {
3583 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARG0);
3584 GateRef funcReg = ReadInst8_1(pc);
3585 GateRef func = GetVregValue(sp, ZExtInt8ToPtr(funcReg));
3586 GateRef jumpSize = INT_PTR(DEPRECATED_CALLARG0_PREF_V8);
3587 GateRef res = JSCallDispatch(glue, func, actualNumArgs, jumpSize, hotnessCounter,
3588 JSCallMode::DEPRECATED_CALL_ARG0, {}, callback);
3589 CHECK_PENDING_EXCEPTION(res, jumpSize);
3590 }
3591
DECLARE_ASM_HANDLER(HandleCallarg1Imm8V8)3592 DECLARE_ASM_HANDLER(HandleCallarg1Imm8V8)
3593 {
3594 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARG1);
3595 GateRef a0 = ReadInst8_1(pc);
3596 GateRef func = acc;
3597 GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0));
3598 GateRef jumpSize = INT_PTR(CALLARG1_IMM8_V8);
3599 GateRef res = JSCallDispatch(glue, func, actualNumArgs, jumpSize, hotnessCounter,
3600 JSCallMode::CALL_ARG1, { a0Value }, callback);
3601 CHECK_PENDING_EXCEPTION(res, jumpSize);
3602 }
3603
DECLARE_ASM_HANDLER(HandleDeprecatedCallarg1PrefV8V8)3604 DECLARE_ASM_HANDLER(HandleDeprecatedCallarg1PrefV8V8)
3605 {
3606 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARG1);
3607 GateRef funcReg = ReadInst8_1(pc);
3608 GateRef a0 = ReadInst8_2(pc);
3609 GateRef func = GetVregValue(sp, ZExtInt8ToPtr(funcReg));
3610 GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0));
3611 GateRef jumpSize = INT_PTR(DEPRECATED_CALLARG1_PREF_V8_V8);
3612 GateRef res = JSCallDispatch(glue, func, actualNumArgs, jumpSize, hotnessCounter,
3613 JSCallMode::DEPRECATED_CALL_ARG1, { a0Value }, callback);
3614 CHECK_PENDING_EXCEPTION(res, jumpSize);
3615 }
3616
DECLARE_ASM_HANDLER(HandleCallargs2Imm8V8V8)3617 DECLARE_ASM_HANDLER(HandleCallargs2Imm8V8V8)
3618 {
3619 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARGS2);
3620 GateRef a0 = ReadInst8_1(pc);
3621 GateRef a1 = ReadInst8_2(pc);
3622 GateRef func = acc;
3623 GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0));
3624 GateRef a1Value = GetVregValue(sp, ZExtInt8ToPtr(a1));
3625 GateRef jumpSize = INT_PTR(CALLARGS2_IMM8_V8_V8);
3626 GateRef res = JSCallDispatch(glue, func, actualNumArgs, jumpSize, hotnessCounter,
3627 JSCallMode::CALL_ARG2, { a0Value, a1Value }, callback);
3628 CHECK_PENDING_EXCEPTION(res, jumpSize);
3629 }
3630
DECLARE_ASM_HANDLER(HandleDeprecatedCallargs2PrefV8V8V8)3631 DECLARE_ASM_HANDLER(HandleDeprecatedCallargs2PrefV8V8V8)
3632 {
3633 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARGS2);
3634 GateRef funcReg = ReadInst8_1(pc);
3635 GateRef a0 = ReadInst8_2(pc);
3636 GateRef a1 = ReadInst8_3(pc);
3637 GateRef func = GetVregValue(sp, ZExtInt8ToPtr(funcReg));
3638 GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0));
3639 GateRef a1Value = GetVregValue(sp, ZExtInt8ToPtr(a1));
3640 GateRef jumpSize = INT_PTR(DEPRECATED_CALLARGS2_PREF_V8_V8_V8);
3641 GateRef res = JSCallDispatch(glue, func, actualNumArgs, jumpSize, hotnessCounter,
3642 JSCallMode::DEPRECATED_CALL_ARG2, { a0Value, a1Value }, callback);
3643 CHECK_PENDING_EXCEPTION(res, jumpSize);
3644 }
3645
DECLARE_ASM_HANDLER(HandleCallargs3Imm8V8V8V8)3646 DECLARE_ASM_HANDLER(HandleCallargs3Imm8V8V8V8)
3647 {
3648 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARGS3);
3649 GateRef a0 = ReadInst8_1(pc);
3650 GateRef a1 = ReadInst8_2(pc);
3651 GateRef a2 = ReadInst8_3(pc);
3652 GateRef func = acc;
3653 GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0));
3654 GateRef a1Value = GetVregValue(sp, ZExtInt8ToPtr(a1));
3655 GateRef a2Value = GetVregValue(sp, ZExtInt8ToPtr(a2));
3656 GateRef jumpSize = INT_PTR(CALLARGS3_IMM8_V8_V8_V8);
3657 GateRef res = JSCallDispatch(glue, func, actualNumArgs, jumpSize, hotnessCounter,
3658 JSCallMode::CALL_ARG3, { a0Value, a1Value, a2Value }, callback);
3659 CHECK_PENDING_EXCEPTION(res, jumpSize);
3660 }
3661
DECLARE_ASM_HANDLER(HandleDeprecatedCallargs3PrefV8V8V8V8)3662 DECLARE_ASM_HANDLER(HandleDeprecatedCallargs3PrefV8V8V8V8)
3663 {
3664 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARGS3);
3665 GateRef funcReg = ReadInst8_1(pc);
3666 GateRef a0 = ReadInst8_2(pc);
3667 GateRef a1 = ReadInst8_3(pc);
3668 GateRef a2 = ReadInst8_4(pc);
3669 GateRef func = GetVregValue(sp, ZExtInt8ToPtr(funcReg));
3670 GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0));
3671 GateRef a1Value = GetVregValue(sp, ZExtInt8ToPtr(a1));
3672 GateRef a2Value = GetVregValue(sp, ZExtInt8ToPtr(a2));
3673 GateRef jumpSize = INT_PTR(DEPRECATED_CALLARGS3_PREF_V8_V8_V8_V8);
3674 GateRef res = JSCallDispatch(glue, func, actualNumArgs, jumpSize, hotnessCounter,
3675 JSCallMode::DEPRECATED_CALL_ARG3, { a0Value, a1Value, a2Value }, callback);
3676 CHECK_PENDING_EXCEPTION(res, jumpSize);
3677 }
3678
DECLARE_ASM_HANDLER(HandleCallrangeImm8Imm8V8)3679 DECLARE_ASM_HANDLER(HandleCallrangeImm8Imm8V8)
3680 {
3681 GateRef actualNumArgs = ZExtInt8ToInt32(ReadInst8_1(pc));
3682 GateRef func = acc;
3683 GateRef argv = PtrAdd(sp, PtrMul(ZExtInt8ToPtr(ReadInst8_2(pc)), IntPtr(8))); // 8: byteSize
3684 GateRef jumpSize = INT_PTR(CALLRANGE_IMM8_IMM8_V8);
3685 GateRef numArgs = ZExtInt32ToPtr(actualNumArgs);
3686 GateRef res = JSCallDispatch(glue, func, actualNumArgs, jumpSize, hotnessCounter,
3687 JSCallMode::CALL_WITH_ARGV, { numArgs, argv }, callback);
3688 CHECK_PENDING_EXCEPTION(res, jumpSize);
3689 }
3690
DECLARE_ASM_HANDLER(HandleWideCallrangePrefImm16V8)3691 DECLARE_ASM_HANDLER(HandleWideCallrangePrefImm16V8)
3692 {
3693 GateRef actualNumArgs = ZExtInt16ToInt32(ReadInst16_1(pc));
3694 GateRef func = acc;
3695 GateRef argv = PtrAdd(sp, PtrMul(ZExtInt8ToPtr(ReadInst8_2(pc)), IntPtr(8))); // 8: byteSize
3696 GateRef jumpSize = INT_PTR(WIDE_CALLRANGE_PREF_IMM16_V8);
3697 GateRef numArgs = ZExtInt32ToPtr(actualNumArgs);
3698 GateRef res = JSCallDispatch(glue, func, actualNumArgs, jumpSize, hotnessCounter,
3699 JSCallMode::CALL_WITH_ARGV, { numArgs, argv }, callback);
3700 CHECK_PENDING_EXCEPTION(res, jumpSize);
3701 }
3702
DECLARE_ASM_HANDLER(HandleDeprecatedCallrangePrefImm16V8)3703 DECLARE_ASM_HANDLER(HandleDeprecatedCallrangePrefImm16V8)
3704 {
3705 GateRef actualNumArgs = ZExtInt16ToInt32(ReadInst16_1(pc));
3706 GateRef funcReg = ReadInst8_3(pc);
3707 GateRef func = GetVregValue(sp, ZExtInt8ToPtr(funcReg));
3708 GateRef argv = PtrAdd(sp, PtrMul(
3709 PtrAdd(ZExtInt8ToPtr(funcReg), IntPtr(1)), IntPtr(8))); // 1: skip function
3710 GateRef jumpSize = INT_PTR(DEPRECATED_CALLRANGE_PREF_IMM16_V8);
3711 GateRef numArgs = ZExtInt32ToPtr(actualNumArgs);
3712 GateRef res = JSCallDispatch(glue, func, actualNumArgs, jumpSize, hotnessCounter,
3713 JSCallMode::DEPRECATED_CALL_WITH_ARGV, { numArgs, argv }, callback);
3714 CHECK_PENDING_EXCEPTION(res, jumpSize);
3715 }
3716
DECLARE_ASM_HANDLER(HandleCallthisrangeImm8Imm8V8)3717 DECLARE_ASM_HANDLER(HandleCallthisrangeImm8Imm8V8)
3718 {
3719 GateRef actualNumArgs = ZExtInt8ToInt32(ReadInst8_1(pc));
3720 GateRef thisReg = ZExtInt8ToPtr(ReadInst8_2(pc));
3721 GateRef func = acc;
3722 GateRef thisValue = GetVregValue(sp, thisReg);
3723 GateRef argv = PtrAdd(sp, PtrMul(
3724 PtrAdd(thisReg, IntPtr(1)), IntPtr(8))); // 1: skip this
3725 GateRef jumpSize = INT_PTR(CALLTHISRANGE_IMM8_IMM8_V8);
3726 GateRef numArgs = ZExtInt32ToPtr(actualNumArgs);
3727 GateRef res = JSCallDispatch(glue, func, actualNumArgs, jumpSize, hotnessCounter,
3728 JSCallMode::CALL_THIS_WITH_ARGV, { numArgs, argv, thisValue }, callback);
3729 CHECK_PENDING_EXCEPTION(res, jumpSize);
3730 }
3731
DECLARE_ASM_HANDLER(HandleWideCallthisrangePrefImm16V8)3732 DECLARE_ASM_HANDLER(HandleWideCallthisrangePrefImm16V8)
3733 {
3734 GateRef actualNumArgs = ZExtInt16ToInt32(ReadInst16_1(pc));
3735 GateRef thisReg = ZExtInt8ToPtr(ReadInst8_3(pc));
3736 GateRef func = acc;
3737 GateRef thisValue = GetVregValue(sp, thisReg);
3738 GateRef argv = PtrAdd(sp, PtrMul(
3739 PtrAdd(thisReg, IntPtr(1)), IntPtr(8))); // 1: skip this
3740 GateRef jumpSize = INT_PTR(WIDE_CALLTHISRANGE_PREF_IMM16_V8);
3741 GateRef numArgs = ZExtInt32ToPtr(actualNumArgs);
3742 GateRef res = JSCallDispatch(glue, func, actualNumArgs, jumpSize, hotnessCounter,
3743 JSCallMode::CALL_THIS_WITH_ARGV, { numArgs, argv, thisValue }, callback);
3744 CHECK_PENDING_EXCEPTION(res, jumpSize);
3745 }
3746
DECLARE_ASM_HANDLER(HandleDeprecatedCallthisrangePrefImm16V8)3747 DECLARE_ASM_HANDLER(HandleDeprecatedCallthisrangePrefImm16V8)
3748 {
3749 GateRef actualNumArgs = Int32Sub(ZExtInt16ToInt32(ReadInst16_1(pc)), Int32(1)); // 1: exclude this
3750 GateRef funcReg = ReadInst8_3(pc);
3751 funcReg = ZExtInt8ToPtr(funcReg);
3752 GateRef func = GetVregValue(sp, funcReg);
3753 GateRef thisValue = GetVregValue(sp, PtrAdd(funcReg, IntPtr(1)));
3754 GateRef argv = PtrAdd(sp, PtrMul(
3755 PtrAdd(funcReg, IntPtr(2)), IntPtr(8))); // 2: skip function&this
3756 GateRef jumpSize = INT_PTR(DEPRECATED_CALLTHISRANGE_PREF_IMM16_V8);
3757 GateRef numArgs = ZExtInt32ToPtr(actualNumArgs);
3758 GateRef res = JSCallDispatch(glue, func, actualNumArgs, jumpSize, hotnessCounter,
3759 JSCallMode::DEPRECATED_CALL_THIS_WITH_ARGV, { numArgs, argv, thisValue }, callback);
3760 CHECK_PENDING_EXCEPTION(res, jumpSize);
3761 }
3762
DECLARE_ASM_HANDLER(HandleCallthis0Imm8V8)3763 DECLARE_ASM_HANDLER(HandleCallthis0Imm8V8)
3764 {
3765 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARG0);
3766 GateRef thisValue = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc)));
3767 GateRef func = acc;
3768 GateRef jumpSize = INT_PTR(CALLTHIS0_IMM8_V8);
3769 GateRef res = JSCallDispatch(glue, func, actualNumArgs, jumpSize, hotnessCounter,
3770 JSCallMode::CALL_THIS_ARG0, { thisValue }, callback);
3771 CHECK_PENDING_EXCEPTION(res, jumpSize);
3772 }
3773
DECLARE_ASM_HANDLER(HandleCallthis1Imm8V8V8)3774 DECLARE_ASM_HANDLER(HandleCallthis1Imm8V8V8)
3775 {
3776 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARG1);
3777 GateRef thisValue = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc)));
3778 GateRef a0 = ReadInst8_2(pc);
3779 GateRef func = acc;
3780 GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0));
3781 GateRef jumpSize = INT_PTR(CALLTHIS1_IMM8_V8_V8);
3782 GateRef res = JSCallDispatch(glue, func, actualNumArgs, jumpSize, hotnessCounter,
3783 JSCallMode::CALL_THIS_ARG1, { a0Value, thisValue }, callback);
3784 CHECK_PENDING_EXCEPTION(res, jumpSize);
3785 }
3786
DECLARE_ASM_HANDLER(HandleCallthis2Imm8V8V8V8)3787 DECLARE_ASM_HANDLER(HandleCallthis2Imm8V8V8V8)
3788 {
3789 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARGS2);
3790 GateRef thisValue = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc)));
3791 GateRef a0 = ReadInst8_2(pc);
3792 GateRef a1 = ReadInst8_3(pc);
3793 GateRef func = acc;
3794 GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0));
3795 GateRef a1Value = GetVregValue(sp, ZExtInt8ToPtr(a1));
3796 GateRef jumpSize = INT_PTR(CALLTHIS2_IMM8_V8_V8_V8);
3797 GateRef res = JSCallDispatch(glue, func, actualNumArgs, jumpSize, hotnessCounter,
3798 JSCallMode::CALL_THIS_ARG2, { a0Value, a1Value, thisValue }, callback);
3799 CHECK_PENDING_EXCEPTION(res, jumpSize);
3800 }
3801
DECLARE_ASM_HANDLER(HandleCallthis3Imm8V8V8V8V8)3802 DECLARE_ASM_HANDLER(HandleCallthis3Imm8V8V8V8V8)
3803 {
3804 GateRef actualNumArgs = Int32(InterpreterAssembly::ActualNumArgsOfCall::CALLARGS3);
3805 GateRef thisValue = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc)));
3806 GateRef a0 = ReadInst8_2(pc);
3807 GateRef a1 = ReadInst8_3(pc);
3808 GateRef a2 = ReadInst8_4(pc);
3809 GateRef func = acc;
3810 GateRef a0Value = GetVregValue(sp, ZExtInt8ToPtr(a0));
3811 GateRef a1Value = GetVregValue(sp, ZExtInt8ToPtr(a1));
3812 GateRef a2Value = GetVregValue(sp, ZExtInt8ToPtr(a2));
3813 GateRef jumpSize = INT_PTR(CALLTHIS3_IMM8_V8_V8_V8_V8);
3814 GateRef res = JSCallDispatch(glue, func, actualNumArgs, jumpSize, hotnessCounter,
3815 JSCallMode::CALL_THIS_ARG3, { a0Value, a1Value, a2Value, thisValue }, callback);
3816 CHECK_PENDING_EXCEPTION(res, jumpSize);
3817 }
3818
DECLARE_ASM_HANDLER(HandleCreatearraywithbufferImm8Id16)3819 DECLARE_ASM_HANDLER(HandleCreatearraywithbufferImm8Id16)
3820 {
3821 GateRef imm = ZExtInt16ToInt32(ReadInst16_1(pc));
3822 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp));
3823
3824 NewObjectStubBuilder newBuilder(this);
3825 GateRef res = newBuilder.CreateArrayWithBuffer(glue, imm, currentFunc, callback);
3826 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CREATEARRAYWITHBUFFER_IMM8_ID16));
3827 }
3828
DECLARE_ASM_HANDLER(HandleCreatearraywithbufferImm16Id16)3829 DECLARE_ASM_HANDLER(HandleCreatearraywithbufferImm16Id16)
3830 {
3831 GateRef imm = ZExtInt16ToInt32(ReadInst16_2(pc));
3832 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp));
3833
3834 NewObjectStubBuilder newBuilder(this);
3835 GateRef res = newBuilder.CreateArrayWithBuffer(glue, imm, currentFunc, callback);
3836 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CREATEARRAYWITHBUFFER_IMM16_ID16));
3837 }
3838
DECLARE_ASM_HANDLER(HandleDeprecatedCreatearraywithbufferPrefImm16)3839 DECLARE_ASM_HANDLER(HandleDeprecatedCreatearraywithbufferPrefImm16)
3840 {
3841 GateRef imm = ZExtInt16ToInt32(ReadInst16_1(pc));
3842 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp));
3843
3844 NewObjectStubBuilder newBuilder(this);
3845 GateRef res = newBuilder.CreateArrayWithBuffer(glue, imm, currentFunc, callback);
3846 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(DEPRECATED_CREATEARRAYWITHBUFFER_PREF_IMM16));
3847 }
3848
DECLARE_ASM_HANDLER(HandleCreateobjectwithbufferImm8Id16)3849 DECLARE_ASM_HANDLER(HandleCreateobjectwithbufferImm8Id16)
3850 {
3851 GateRef imm = ZExtInt16ToInt32(ReadInst16_1(pc));
3852 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp));
3853 GateRef module = GetModuleFromFunction(currentFunc);
3854 GateRef result = GetObjectLiteralFromConstPool(glue, constpool, imm, module);
3855 GateRef currentEnv = GetEnvFromFrame(GetFrame(sp));
3856 GateRef res = CallRuntime(glue, RTSTUB_ID(CreateObjectHavingMethod), { result, currentEnv });
3857 callback.ProfileCreateObject(res);
3858 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CREATEOBJECTWITHBUFFER_IMM8_ID16));
3859 }
3860
DECLARE_ASM_HANDLER(HandleCreateobjectwithbufferImm16Id16)3861 DECLARE_ASM_HANDLER(HandleCreateobjectwithbufferImm16Id16)
3862 {
3863 GateRef imm = ZExtInt16ToInt32(ReadInst16_2(pc));
3864 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp));
3865 GateRef module = GetModuleFromFunction(currentFunc);
3866 GateRef result = GetObjectLiteralFromConstPool(glue, constpool, imm, module);
3867 GateRef currentEnv = GetEnvFromFrame(GetFrame(sp));
3868 GateRef res = CallRuntime(glue, RTSTUB_ID(CreateObjectHavingMethod), { result, currentEnv });
3869 callback.ProfileCreateObject(res);
3870 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(CREATEOBJECTWITHBUFFER_IMM16_ID16));
3871 }
3872
DECLARE_ASM_HANDLER(HandleDeprecatedCreateobjectwithbufferPrefImm16)3873 DECLARE_ASM_HANDLER(HandleDeprecatedCreateobjectwithbufferPrefImm16)
3874 {
3875 GateRef imm = ZExtInt16ToInt32(ReadInst16_1(pc));
3876 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp));
3877 GateRef module = GetModuleFromFunction(currentFunc);
3878 GateRef result = GetObjectLiteralFromConstPool(glue, constpool, imm, module);
3879 GateRef res = CallRuntime(glue, RTSTUB_ID(CreateObjectWithBuffer), { result });
3880 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(DEPRECATED_CREATEOBJECTWITHBUFFER_PREF_IMM16));
3881 }
3882
DECLARE_ASM_HANDLER(HandleNewobjrangeImm8Imm8V8)3883 DECLARE_ASM_HANDLER(HandleNewobjrangeImm8Imm8V8)
3884 {
3885 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3886 DEFVARIABLE(res, VariableType::JS_ANY(), Undefined());
3887 DEFVARIABLE(thisObj, VariableType::JS_ANY(), Undefined());
3888 auto env = GetEnvironment();
3889 GateRef numArgs = ZExtInt8ToInt16(ReadInst8_1(pc));
3890 GateRef firstArgRegIdx = ZExtInt8ToInt16(ReadInst8_2(pc));
3891 GateRef firstArgOffset = Int16(1);
3892 GateRef ctor = GetVregValue(sp, ZExtInt16ToPtr(firstArgRegIdx));
3893 GateRef actualNumArgs = ZExtInt16ToInt32(Int16Sub(numArgs, firstArgOffset));
3894
3895 Label ctorIsHeapObject(env);
3896 Label ctorIsJSFunction(env);
3897 Label fastPath(env);
3898 Label slowPath(env);
3899 Label checkResult(env);
3900 Label threadCheck(env);
3901 Label dispatch(env);
3902 Label ctorIsBase(env);
3903 Label ctorNotBase(env);
3904 Label isException(env);
3905
3906 Branch(TaggedIsHeapObject(ctor), &ctorIsHeapObject, &slowPath);
3907 Bind(&ctorIsHeapObject);
3908 Branch(IsJSFunction(ctor), &ctorIsJSFunction, &slowPath);
3909 Bind(&ctorIsJSFunction);
3910 Branch(IsConstructor(ctor), &fastPath, &slowPath);
3911 Bind(&fastPath);
3912 {
3913 Branch(IsBase(ctor), &ctorIsBase, &ctorNotBase);
3914 Bind(&ctorIsBase);
3915 {
3916 NewObjectStubBuilder newBuilder(this);
3917 thisObj = newBuilder.FastNewThisObject(glue, ctor);
3918 Branch(HasPendingException(glue), &isException, &ctorNotBase);
3919 }
3920 Bind(&ctorNotBase);
3921 GateRef argv = PtrAdd(sp, PtrMul(
3922 PtrAdd(firstArgRegIdx, firstArgOffset), IntPtr(8))); // 8: skip function
3923 GateRef jumpSize = IntPtr(-BytecodeInstruction::Size(BytecodeInstruction::Format::IMM8_IMM8_V8));
3924 res = JSCallDispatch(glue, ctor, actualNumArgs, jumpSize, hotnessCounter,
3925 JSCallMode::CALL_CONSTRUCTOR_WITH_ARGV,
3926 { ZExtInt32ToPtr(actualNumArgs), argv, *thisObj }, callback);
3927 Jump(&threadCheck);
3928 }
3929 Bind(&slowPath);
3930 GateRef firstArgIdx = Int16Add(firstArgRegIdx, firstArgOffset);
3931 GateRef length = Int16Sub(numArgs, firstArgOffset);
3932 res = CallRuntime(glue, RTSTUB_ID(NewObjRange),
3933 { ctor, ctor, Int16ToTaggedInt(firstArgIdx), Int16ToTaggedInt(length) });
3934 Jump(&checkResult);
3935 Bind(&checkResult);
3936 {
3937 Branch(TaggedIsException(*res), &isException, &dispatch);
3938 }
3939 Bind(&threadCheck);
3940 {
3941 Branch(HasPendingException(glue), &isException, &dispatch);
3942 }
3943 Bind(&isException);
3944 {
3945 DISPATCH_LAST();
3946 }
3947 Bind(&dispatch);
3948 varAcc = *res;
3949 DISPATCH_WITH_ACC(NEWOBJRANGE_IMM8_IMM8_V8);
3950 }
3951
DECLARE_ASM_HANDLER(HandleNewobjrangeImm16Imm8V8)3952 DECLARE_ASM_HANDLER(HandleNewobjrangeImm16Imm8V8)
3953 {
3954 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
3955 DEFVARIABLE(res, VariableType::JS_ANY(), Undefined());
3956 DEFVARIABLE(thisObj, VariableType::JS_ANY(), Undefined());
3957 auto env = GetEnvironment();
3958 GateRef numArgs = ZExtInt8ToInt16(ReadInst8_2(pc));
3959 GateRef firstArgRegIdx = ZExtInt8ToInt16(ReadInst8_3(pc));
3960 GateRef firstArgOffset = Int16(1);
3961 GateRef ctor = GetVregValue(sp, ZExtInt16ToPtr(firstArgRegIdx));
3962 GateRef actualNumArgs = ZExtInt16ToInt32(Int16Sub(numArgs, firstArgOffset));
3963
3964 Label ctorIsHeapObject(env);
3965 Label ctorIsJSFunction(env);
3966 Label fastPath(env);
3967 Label slowPath(env);
3968 Label checkResult(env);
3969 Label threadCheck(env);
3970 Label dispatch(env);
3971 Label ctorIsBase(env);
3972 Label ctorNotBase(env);
3973 Label isException(env);
3974
3975 Branch(TaggedIsHeapObject(ctor), &ctorIsHeapObject, &slowPath);
3976 Bind(&ctorIsHeapObject);
3977 Branch(IsJSFunction(ctor), &ctorIsJSFunction, &slowPath);
3978 Bind(&ctorIsJSFunction);
3979 Branch(IsConstructor(ctor), &fastPath, &slowPath);
3980 Bind(&fastPath);
3981 {
3982 Branch(IsBase(ctor), &ctorIsBase, &ctorNotBase);
3983 Bind(&ctorIsBase);
3984 {
3985 NewObjectStubBuilder newBuilder(this);
3986 thisObj = newBuilder.FastNewThisObject(glue, ctor);
3987 Branch(HasPendingException(glue), &isException, &ctorNotBase);
3988 }
3989 Bind(&ctorNotBase);
3990 GateRef argv = PtrAdd(sp, PtrMul(
3991 PtrAdd(firstArgRegIdx, firstArgOffset), IntPtr(8))); // 8: skip function
3992 GateRef jumpSize =
3993 IntPtr(-static_cast<int64_t>(BytecodeInstruction::Size(BytecodeInstruction::Format::IMM16_IMM8_V8)));
3994 res = JSCallDispatch(glue, ctor, actualNumArgs, jumpSize, hotnessCounter,
3995 JSCallMode::CALL_CONSTRUCTOR_WITH_ARGV,
3996 { ZExtInt32ToPtr(actualNumArgs), argv, *thisObj }, callback);
3997 Jump(&threadCheck);
3998 }
3999 Bind(&slowPath);
4000 GateRef firstArgIdx = Int16Add(firstArgRegIdx, firstArgOffset);
4001 GateRef length = Int16Sub(numArgs, firstArgOffset);
4002 res = CallRuntime(glue, RTSTUB_ID(NewObjRange),
4003 { ctor, ctor, Int16ToTaggedInt(firstArgIdx), Int16ToTaggedInt(length) });
4004 Jump(&checkResult);
4005 Bind(&checkResult);
4006 {
4007 Branch(TaggedIsException(*res), &isException, &dispatch);
4008 }
4009 Bind(&threadCheck);
4010 {
4011 Branch(HasPendingException(glue), &isException, &dispatch);
4012 }
4013 Bind(&isException);
4014 {
4015 DISPATCH_LAST();
4016 }
4017 Bind(&dispatch);
4018 varAcc = *res;
4019 DISPATCH_WITH_ACC(NEWOBJRANGE_IMM16_IMM8_V8);
4020 }
4021
DECLARE_ASM_HANDLER(HandleWideNewobjrangePrefImm16V8)4022 DECLARE_ASM_HANDLER(HandleWideNewobjrangePrefImm16V8)
4023 {
4024 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
4025 DEFVARIABLE(res, VariableType::JS_ANY(), Undefined());
4026 DEFVARIABLE(thisObj, VariableType::JS_ANY(), Undefined());
4027 auto env = GetEnvironment();
4028 GateRef numArgs = ReadInst16_1(pc);
4029 GateRef firstArgRegIdx = ZExtInt8ToInt16(ReadInst8_3(pc));
4030 GateRef firstArgOffset = Int16(1);
4031 GateRef ctor = GetVregValue(sp, ZExtInt16ToPtr(firstArgRegIdx));
4032 GateRef actualNumArgs = ZExtInt16ToInt32(Int16Sub(numArgs, firstArgOffset));
4033
4034 Label ctorIsHeapObject(env);
4035 Label ctorIsJSFunction(env);
4036 Label fastPath(env);
4037 Label slowPath(env);
4038 Label checkResult(env);
4039 Label threadCheck(env);
4040 Label dispatch(env);
4041 Label ctorIsBase(env);
4042 Label ctorNotBase(env);
4043 Label isException(env);
4044
4045 Branch(TaggedIsHeapObject(ctor), &ctorIsHeapObject, &slowPath);
4046 Bind(&ctorIsHeapObject);
4047 Branch(IsJSFunction(ctor), &ctorIsJSFunction, &slowPath);
4048 Bind(&ctorIsJSFunction);
4049 Branch(IsConstructor(ctor), &fastPath, &slowPath);
4050 Bind(&fastPath);
4051 {
4052 Branch(IsBase(ctor), &ctorIsBase, &ctorNotBase);
4053 Bind(&ctorIsBase);
4054 {
4055 NewObjectStubBuilder newBuilder(this);
4056 thisObj = newBuilder.FastNewThisObject(glue, ctor);
4057 Branch(HasPendingException(glue), &isException, &ctorNotBase);
4058 }
4059 Bind(&ctorNotBase);
4060 GateRef argv = PtrAdd(sp, PtrMul(
4061 PtrAdd(firstArgRegIdx, firstArgOffset), IntPtr(8))); // 8: skip function
4062 GateRef jumpSize = IntPtr(-BytecodeInstruction::Size(BytecodeInstruction::Format::PREF_IMM16_V8));
4063 res = JSCallDispatch(glue, ctor, actualNumArgs, jumpSize, hotnessCounter,
4064 JSCallMode::DEPRECATED_CALL_CONSTRUCTOR_WITH_ARGV,
4065 { ZExtInt32ToPtr(actualNumArgs), argv, *thisObj }, callback);
4066 Jump(&threadCheck);
4067 }
4068 Bind(&slowPath);
4069 GateRef firstArgIdx = Int16Add(firstArgRegIdx, firstArgOffset);
4070 GateRef length = Int16Sub(numArgs, firstArgOffset);
4071 res = CallRuntime(glue, RTSTUB_ID(NewObjRange),
4072 { ctor, ctor, Int16ToTaggedInt(firstArgIdx), Int16ToTaggedInt(length) });
4073 Jump(&checkResult);
4074 Bind(&checkResult);
4075 {
4076 Branch(TaggedIsException(*res), &isException, &dispatch);
4077 }
4078 Bind(&threadCheck);
4079 {
4080 Branch(HasPendingException(glue), &isException, &dispatch);
4081 }
4082 Bind(&isException);
4083 {
4084 DISPATCH_LAST();
4085 }
4086 Bind(&dispatch);
4087 varAcc = *res;
4088 DISPATCH_WITH_ACC(WIDE_NEWOBJRANGE_PREF_IMM16_V8);
4089 }
4090
DECLARE_ASM_HANDLER(HandleDefinefuncImm8Id16Imm8)4091 DECLARE_ASM_HANDLER(HandleDefinefuncImm8Id16Imm8)
4092 {
4093 auto env = GetEnvironment();
4094 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
4095 GateRef methodId = ReadInst16_1(pc);
4096 GateRef length = ReadInst8_3(pc);
4097 DEFVARIABLE(result, VariableType::JS_POINTER(),
4098 GetMethodFromConstPool(glue, constpool, ZExtInt16ToInt32(methodId)));
4099 result = CallRuntime(glue, RTSTUB_ID(DefineFunc), { *result });
4100 Label notException(env);
4101 CHECK_EXCEPTION_WITH_JUMP(*result, ¬Exception);
4102 Bind(¬Exception);
4103 {
4104 GateRef hclass = LoadHClass(*result);
4105 SetPropertyInlinedProps(glue, *result, hclass, Int16ToTaggedInt(length),
4106 Int32(JSFunction::LENGTH_INLINE_PROPERTY_INDEX), VariableType::INT64());
4107 auto frame = GetFrame(sp);
4108 GateRef envHandle = GetEnvFromFrame(frame);
4109 SetLexicalEnvToFunction(glue, *result, envHandle);
4110 GateRef currentFunc = GetFunctionFromFrame(frame);
4111 SetModuleToFunction(glue, *result, GetModuleFromFunction(currentFunc));
4112 SetHomeObjectToFunction(glue, *result, GetHomeObjectFromFunction(currentFunc));
4113 varAcc = *result;
4114 DISPATCH_WITH_ACC(DEFINEFUNC_IMM8_ID16_IMM8);
4115 }
4116 }
4117
DECLARE_ASM_HANDLER(HandleDefinefuncImm16Id16Imm8)4118 DECLARE_ASM_HANDLER(HandleDefinefuncImm16Id16Imm8)
4119 {
4120 auto env = GetEnvironment();
4121 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
4122 GateRef methodId = ReadInst16_2(pc);
4123 GateRef length = ReadInst8_4(pc);
4124 DEFVARIABLE(result, VariableType::JS_POINTER(),
4125 GetMethodFromConstPool(glue, constpool, ZExtInt16ToInt32(methodId)));
4126 result = CallRuntime(glue, RTSTUB_ID(DefineFunc), { *result });
4127 Label notException(env);
4128 CHECK_EXCEPTION_WITH_JUMP(*result, ¬Exception);
4129 Bind(¬Exception);
4130 {
4131 GateRef hclass = LoadHClass(*result);
4132 SetPropertyInlinedProps(glue, *result, hclass, Int8ToTaggedInt(length),
4133 Int32(JSFunction::LENGTH_INLINE_PROPERTY_INDEX), VariableType::INT64());
4134 auto frame = GetFrame(sp);
4135 GateRef envHandle = GetEnvFromFrame(frame);
4136 SetLexicalEnvToFunction(glue, *result, envHandle);
4137 GateRef currentFunc = GetFunctionFromFrame(frame);
4138 SetModuleToFunction(glue, *result, GetModuleFromFunction(currentFunc));
4139 SetHomeObjectToFunction(glue, *result, GetHomeObjectFromFunction(currentFunc));
4140 varAcc = *result;
4141 DISPATCH_WITH_ACC(DEFINEFUNC_IMM16_ID16_IMM8);
4142 }
4143 }
4144
DECLARE_ASM_HANDLER(HandleDefinemethodImm8Id16Imm8)4145 DECLARE_ASM_HANDLER(HandleDefinemethodImm8Id16Imm8)
4146 {
4147 auto env = GetEnvironment();
4148 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
4149 GateRef methodId = ReadInst16_1(pc);
4150 GateRef length = ReadInst8_3(pc);
4151 DEFVARIABLE(result, VariableType::JS_POINTER(),
4152 GetMethodFromConstPool(glue, constpool, ZExtInt16ToInt32(methodId)));
4153 result = CallRuntime(glue, RTSTUB_ID(DefineMethod), { *result, acc });
4154 Label notException(env);
4155 CHECK_EXCEPTION_WITH_JUMP(*result, ¬Exception);
4156 Bind(¬Exception);
4157 {
4158 GateRef hclass = LoadHClass(*result);
4159 SetPropertyInlinedProps(glue, *result, hclass, Int8ToTaggedInt(length),
4160 Int32(JSFunction::LENGTH_INLINE_PROPERTY_INDEX), VariableType::INT64());
4161 GateRef lexEnv = GetEnvFromFrame(GetFrame(sp));
4162 SetLexicalEnvToFunction(glue, *result, lexEnv);
4163 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp));
4164 SetModuleToFunction(glue, *result, GetModuleFromFunction(currentFunc));
4165 varAcc = *result;
4166 DISPATCH_WITH_ACC(DEFINEMETHOD_IMM8_ID16_IMM8);
4167 }
4168 }
4169
DECLARE_ASM_HANDLER(HandleDefinemethodImm16Id16Imm8)4170 DECLARE_ASM_HANDLER(HandleDefinemethodImm16Id16Imm8)
4171 {
4172 auto env = GetEnvironment();
4173 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
4174 GateRef methodId = ReadInst16_2(pc);
4175 GateRef length = ReadInst8_4(pc);
4176 DEFVARIABLE(result, VariableType::JS_POINTER(),
4177 GetMethodFromConstPool(glue, constpool, ZExtInt16ToInt32(methodId)));
4178 result = CallRuntime(glue, RTSTUB_ID(DefineMethod), { *result, acc });
4179 Label notException(env);
4180 CHECK_EXCEPTION_WITH_JUMP(*result, ¬Exception);
4181 Bind(¬Exception);
4182 {
4183 GateRef hclass = LoadHClass(*result);
4184 SetPropertyInlinedProps(glue, *result, hclass, Int8ToTaggedInt(length),
4185 Int32(JSFunction::LENGTH_INLINE_PROPERTY_INDEX), VariableType::INT64());
4186 GateRef lexEnv = GetEnvFromFrame(GetFrame(sp));
4187 SetLexicalEnvToFunction(glue, *result, lexEnv);
4188 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp));
4189 SetModuleToFunction(glue, *result, GetModuleFromFunction(currentFunc));
4190 varAcc = *result;
4191 DISPATCH_WITH_ACC(DEFINEMETHOD_IMM16_ID16_IMM8);
4192 }
4193 }
4194
DECLARE_ASM_HANDLER(HandleApplyImm8V8V8)4195 DECLARE_ASM_HANDLER(HandleApplyImm8V8V8)
4196 {
4197 GateRef func = acc;
4198 GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc)));
4199 GateRef array = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc)));
4200 GateRef res = CallRuntime(glue, RTSTUB_ID(CallSpread), { func, obj, array });
4201 CHECK_PENDING_EXCEPTION(res, INT_PTR(APPLY_IMM8_V8_V8));
4202 }
4203
DECLARE_ASM_HANDLER(HandleDeprecatedCallspreadPrefV8V8V8)4204 DECLARE_ASM_HANDLER(HandleDeprecatedCallspreadPrefV8V8V8)
4205 {
4206 GateRef func = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_1(pc)));
4207 GateRef obj = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_2(pc)));
4208 GateRef array = GetVregValue(sp, ZExtInt8ToPtr(ReadInst8_3(pc)));
4209 GateRef res = CallRuntime(glue, RTSTUB_ID(CallSpread), { func, obj, array });
4210 CHECK_PENDING_EXCEPTION(res, INT_PTR(DEPRECATED_CALLSPREAD_PREF_V8_V8_V8));
4211 }
4212
DECLARE_ASM_HANDLER(HandleThrowNotexistsPrefNone)4213 DECLARE_ASM_HANDLER(HandleThrowNotexistsPrefNone)
4214 {
4215 CallRuntime(glue, RTSTUB_ID(ThrowThrowNotExists), {});
4216 DISPATCH_LAST();
4217 }
DECLARE_ASM_HANDLER(HandleThrowPrefNone)4218 DECLARE_ASM_HANDLER(HandleThrowPrefNone)
4219 {
4220 CallRuntime(glue, RTSTUB_ID(Throw), { acc });
4221 DISPATCH_LAST();
4222 }
4223
DECLARE_ASM_HANDLER(HandleJnstricteqV8Imm16)4224 DECLARE_ASM_HANDLER(HandleJnstricteqV8Imm16)
4225 {
4226 DISPATCH(NOP);
4227 }
DECLARE_ASM_HANDLER(HandleJnstricteqV8Imm8)4228 DECLARE_ASM_HANDLER(HandleJnstricteqV8Imm8)
4229 {
4230 DISPATCH(NOP);
4231 }
DECLARE_ASM_HANDLER(HandleJstricteqV8Imm16)4232 DECLARE_ASM_HANDLER(HandleJstricteqV8Imm16)
4233 {
4234 DISPATCH(NOP);
4235 }
DECLARE_ASM_HANDLER(HandleJstricteqV8Imm8)4236 DECLARE_ASM_HANDLER(HandleJstricteqV8Imm8)
4237 {
4238 DISPATCH(NOP);
4239 }
DECLARE_ASM_HANDLER(HandleJneV8Imm16)4240 DECLARE_ASM_HANDLER(HandleJneV8Imm16)
4241 {
4242 DISPATCH(NOP);
4243 }
DECLARE_ASM_HANDLER(HandleJneV8Imm8)4244 DECLARE_ASM_HANDLER(HandleJneV8Imm8)
4245 {
4246 DISPATCH(NOP);
4247 }
DECLARE_ASM_HANDLER(HandleJeqV8Imm16)4248 DECLARE_ASM_HANDLER(HandleJeqV8Imm16)
4249 {
4250 DISPATCH(NOP);
4251 }
DECLARE_ASM_HANDLER(HandleJeqV8Imm8)4252 DECLARE_ASM_HANDLER(HandleJeqV8Imm8)
4253 {
4254 DISPATCH(NOP);
4255 }
DECLARE_ASM_HANDLER(HandleJnstrictequndefinedImm16)4256 DECLARE_ASM_HANDLER(HandleJnstrictequndefinedImm16)
4257 {
4258 DISPATCH(NOP);
4259 }
DECLARE_ASM_HANDLER(HandleJnstrictequndefinedImm8)4260 DECLARE_ASM_HANDLER(HandleJnstrictequndefinedImm8)
4261 {
4262 DISPATCH(NOP);
4263 }
DECLARE_ASM_HANDLER(HandleJstrictequndefinedImm16)4264 DECLARE_ASM_HANDLER(HandleJstrictequndefinedImm16)
4265 {
4266 DISPATCH(NOP);
4267 }
DECLARE_ASM_HANDLER(HandleJstrictequndefinedImm8)4268 DECLARE_ASM_HANDLER(HandleJstrictequndefinedImm8)
4269 {
4270 DISPATCH(NOP);
4271 }
DECLARE_ASM_HANDLER(HandleJneundefinedImm16)4272 DECLARE_ASM_HANDLER(HandleJneundefinedImm16)
4273 {
4274 DISPATCH(NOP);
4275 }
DECLARE_ASM_HANDLER(HandleJneundefinedImm8)4276 DECLARE_ASM_HANDLER(HandleJneundefinedImm8)
4277 {
4278 DISPATCH(NOP);
4279 }
DECLARE_ASM_HANDLER(HandleJnstricteqnullImm16)4280 DECLARE_ASM_HANDLER(HandleJnstricteqnullImm16)
4281 {
4282 DISPATCH(NOP);
4283 }
DECLARE_ASM_HANDLER(HandleJnstricteqnullImm8)4284 DECLARE_ASM_HANDLER(HandleJnstricteqnullImm8)
4285 {
4286 DISPATCH(NOP);
4287 }
DECLARE_ASM_HANDLER(HandleJstricteqnullImm16)4288 DECLARE_ASM_HANDLER(HandleJstricteqnullImm16)
4289 {
4290 DISPATCH(NOP);
4291 }
DECLARE_ASM_HANDLER(HandleJstricteqnullImm8)4292 DECLARE_ASM_HANDLER(HandleJstricteqnullImm8)
4293 {
4294 DISPATCH(NOP);
4295 }
DECLARE_ASM_HANDLER(HandleJnenullImm16)4296 DECLARE_ASM_HANDLER(HandleJnenullImm16)
4297 {
4298 DISPATCH(NOP);
4299 }
DECLARE_ASM_HANDLER(HandleJnenullImm8)4300 DECLARE_ASM_HANDLER(HandleJnenullImm8)
4301 {
4302 DISPATCH(NOP);
4303 }
DECLARE_ASM_HANDLER(HandleJeqnullImm16)4304 DECLARE_ASM_HANDLER(HandleJeqnullImm16)
4305 {
4306 DISPATCH(NOP);
4307 }
DECLARE_ASM_HANDLER(HandleJeqnullImm8)4308 DECLARE_ASM_HANDLER(HandleJeqnullImm8)
4309 {
4310 DISPATCH(NOP);
4311 }
4312
DECLARE_ASM_HANDLER(HandleJnstricteqzImm16)4313 DECLARE_ASM_HANDLER(HandleJnstricteqzImm16)
4314 {
4315 DISPATCH(NOP);
4316 }
DECLARE_ASM_HANDLER(HandleJnstricteqzImm8)4317 DECLARE_ASM_HANDLER(HandleJnstricteqzImm8)
4318 {
4319 DISPATCH(NOP);
4320 }
DECLARE_ASM_HANDLER(HandleJstricteqzImm16)4321 DECLARE_ASM_HANDLER(HandleJstricteqzImm16)
4322 {
4323 DISPATCH(NOP);
4324 }
DECLARE_ASM_HANDLER(HandleJstricteqzImm8)4325 DECLARE_ASM_HANDLER(HandleJstricteqzImm8)
4326 {
4327 DISPATCH(NOP);
4328 }
DECLARE_ASM_HANDLER(HandleStthisbyvalueImm16V8)4329 DECLARE_ASM_HANDLER(HandleStthisbyvalueImm16V8)
4330 {
4331 GateRef v0 = ReadInst8_2(pc);
4332 GateRef receiver = GetThisFromFrame(GetFrame(sp));
4333 GateRef propKey = GetVregValue(sp, ZExtInt8ToPtr(v0));
4334 GateRef value = acc;
4335 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc));
4336
4337 AccessObjectStubBuilder builder(this);
4338 GateRef result = builder.StoreObjByValue(glue, receiver, propKey, value, profileTypeInfo, slotId, callback);
4339 CHECK_EXCEPTION(result, INT_PTR(STTHISBYVALUE_IMM16_V8));
4340 }
DECLARE_ASM_HANDLER(HandleStthisbyvalueImm8V8)4341 DECLARE_ASM_HANDLER(HandleStthisbyvalueImm8V8)
4342 {
4343 GateRef v0 = ReadInst8_1(pc);
4344 GateRef receiver = GetThisFromFrame(GetFrame(sp));
4345 GateRef propKey = GetVregValue(sp, ZExtInt8ToPtr(v0));
4346 GateRef value = acc;
4347 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc));
4348
4349 AccessObjectStubBuilder builder(this);
4350 GateRef result = builder.StoreObjByValue(glue, receiver, propKey, value, profileTypeInfo, slotId, callback);
4351 CHECK_EXCEPTION(result, INT_PTR(STTHISBYVALUE_IMM8_V8));
4352 }
DECLARE_ASM_HANDLER(HandleLdthisbyvalueImm16)4353 DECLARE_ASM_HANDLER(HandleLdthisbyvalueImm16)
4354 {
4355 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
4356
4357 GateRef receiver = GetThisFromFrame(GetFrame(sp));
4358 GateRef propKey = acc;
4359 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc));
4360
4361 AccessObjectStubBuilder builder(this);
4362 GateRef result = builder.LoadObjByValue(glue, receiver, propKey, profileTypeInfo, slotId, callback);
4363 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDTHISBYVALUE_IMM16));
4364 }
DECLARE_ASM_HANDLER(HandleLdthisbyvalueImm8)4365 DECLARE_ASM_HANDLER(HandleLdthisbyvalueImm8)
4366 {
4367 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
4368
4369 GateRef receiver = GetThisFromFrame(GetFrame(sp));
4370 GateRef propKey = acc;
4371 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc));
4372
4373 AccessObjectStubBuilder builder(this);
4374 GateRef result = builder.LoadObjByValue(glue, receiver, propKey, profileTypeInfo, slotId, callback);
4375 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDTHISBYVALUE_IMM8));
4376 }
DECLARE_ASM_HANDLER(HandleStthisbynameImm16Id16)4377 DECLARE_ASM_HANDLER(HandleStthisbynameImm16Id16)
4378 {
4379 GateRef receiver = GetThisFromFrame(GetFrame(sp));
4380 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc));
4381
4382 AccessObjectStubBuilder builder(this);
4383 StringIdInfo info = { constpool, pc, StringIdInfo::Offset::BYTE_2, StringIdInfo::Length::BITS_16 };
4384 GateRef result = builder.StoreObjByName(glue, receiver, 0, info, acc, profileTypeInfo, slotId, callback);
4385 CHECK_EXCEPTION(result, INT_PTR(STTHISBYNAME_IMM16_ID16));
4386 }
DECLARE_ASM_HANDLER(HandleStthisbynameImm8Id16)4387 DECLARE_ASM_HANDLER(HandleStthisbynameImm8Id16)
4388 {
4389 GateRef receiver = GetThisFromFrame(GetFrame(sp));
4390 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc));
4391
4392 AccessObjectStubBuilder builder(this);
4393 StringIdInfo info = { constpool, pc, StringIdInfo::Offset::BYTE_1, StringIdInfo::Length::BITS_16 };
4394 GateRef result = builder.StoreObjByName(glue, receiver, 0, info, acc, profileTypeInfo, slotId, callback);
4395 CHECK_EXCEPTION(result, INT_PTR(STTHISBYNAME_IMM8_ID16));
4396 }
DECLARE_ASM_HANDLER(HandleLdthisbynameImm16Id16)4397 DECLARE_ASM_HANDLER(HandleLdthisbynameImm16Id16)
4398 {
4399 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
4400 GateRef slotId = ZExtInt16ToInt32(ReadInst16_0(pc));
4401 GateRef receiver = GetThisFromFrame(GetFrame(sp));
4402
4403 AccessObjectStubBuilder builder(this);
4404 StringIdInfo info = { constpool, pc, StringIdInfo::Offset::BYTE_2, StringIdInfo::Length::BITS_16 };
4405 GateRef result = builder.LoadObjByName(glue, receiver, 0, info, profileTypeInfo, slotId, callback);
4406 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDTHISBYNAME_IMM16_ID16));
4407 }
DECLARE_ASM_HANDLER(HandleLdthisbynameImm8Id16)4408 DECLARE_ASM_HANDLER(HandleLdthisbynameImm8Id16)
4409 {
4410 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
4411 GateRef slotId = ZExtInt8ToInt32(ReadInst8_0(pc));
4412 GateRef receiver = GetThisFromFrame(GetFrame(sp));
4413
4414 AccessObjectStubBuilder builder(this);
4415 StringIdInfo info = { constpool, pc, StringIdInfo::Offset::BYTE_1, StringIdInfo::Length::BITS_16 };
4416 GateRef result = builder.LoadObjByName(glue, receiver, 0, info, profileTypeInfo, slotId, callback);
4417 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(LDTHISBYNAME_IMM8_ID16));
4418 }
DECLARE_ASM_HANDLER(HandleLdthis)4419 DECLARE_ASM_HANDLER(HandleLdthis)
4420 {
4421 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
4422 varAcc = GetThisFromFrame(GetFrame(sp));
4423 DISPATCH_WITH_ACC(LDTHIS);
4424 }
DECLARE_ASM_HANDLER(HandleLdnewtarget)4425 DECLARE_ASM_HANDLER(HandleLdnewtarget)
4426 {
4427 DISPATCH(NOP);
4428 }
4429
DECLARE_ASM_HANDLER(HandleDeprecatedLdlexenvPrefNone)4430 DECLARE_ASM_HANDLER(HandleDeprecatedLdlexenvPrefNone)
4431 {
4432 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
4433 GateRef state = GetFrame(sp);
4434 varAcc = GetEnvFromFrame(state);
4435 DISPATCH_WITH_ACC(DEPRECATED_LDLEXENV_PREF_NONE);
4436 }
4437
DECLARE_ASM_HANDLER(HandleDeprecatedLdhomeobjectPrefNone)4438 DECLARE_ASM_HANDLER(HandleDeprecatedLdhomeobjectPrefNone)
4439 {
4440 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
4441 GateRef state = GetFunctionFromFrame(GetFrame(sp));
4442 varAcc = GetHomeObjectFromJSFunction(state);
4443 DISPATCH_WITH_ACC(DEPRECATED_LDHOMEOBJECT_PREF_NONE);
4444 }
4445
DECLARE_ASM_HANDLER(HandleDeprecatedCreateobjecthavingmethodPrefImm16)4446 DECLARE_ASM_HANDLER(HandleDeprecatedCreateobjecthavingmethodPrefImm16)
4447 {
4448 GateRef imm = ZExtInt16ToInt32(ReadInst16_1(pc));
4449 GateRef currentFunc = GetFunctionFromFrame(GetFrame(sp));
4450 GateRef module = GetModuleFromFunction(currentFunc);
4451 GateRef result = GetObjectLiteralFromConstPool(glue, constpool, imm, module);
4452 GateRef res = CallRuntime(glue, RTSTUB_ID(CreateObjectHavingMethod), { result, acc });
4453 CHECK_EXCEPTION_WITH_ACC(res, INT_PTR(DEPRECATED_CREATEOBJECTHAVINGMETHOD_PREF_IMM16));
4454 }
4455
4456 #define DECLARE_UNUSED_ASM_HANDLE(name) \
4457 DECLARE_ASM_HANDLER(name) \
4458 { \
4459 FatalPrint(glue, { Int32(GET_MESSAGE_STRING_ID(name)) }); \
4460 DISPATCH_BAK(OFFSET, IntPtr(0)); \
4461 }
4462 ASM_UNUSED_BC_STUB_LIST(DECLARE_UNUSED_ASM_HANDLE)
4463 #undef DECLARE_UNUSED_ASM_HANDLE
4464
DECLARE_ASM_HANDLER_NOPRINT(HandleThrow)4465 DECLARE_ASM_HANDLER_NOPRINT(HandleThrow)
4466 {
4467 GateRef opcode = ZExtInt8ToPtr(ReadInst8_0(pc));
4468 auto index = IntPtr(kungfu::BytecodeStubCSigns::ID_Throw_Start);
4469 auto jumpIndex = PtrAdd(opcode, index);
4470 DispatchWithId(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter, jumpIndex);
4471 }
4472
DECLARE_ASM_HANDLER_NOPRINT(HandleWide)4473 DECLARE_ASM_HANDLER_NOPRINT(HandleWide)
4474 {
4475 GateRef opcode = ZExtInt8ToPtr(ReadInst8_0(pc));
4476 auto index = IntPtr(kungfu::BytecodeStubCSigns::ID_Wide_Start);
4477 auto jumpIndex = PtrAdd(opcode, index);
4478 DispatchWithId(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter, jumpIndex);
4479 }
4480
DECLARE_ASM_HANDLER_NOPRINT(HandleDeprecated)4481 DECLARE_ASM_HANDLER_NOPRINT(HandleDeprecated)
4482 {
4483 GateRef opcode = ZExtInt8ToPtr(ReadInst8_0(pc));
4484 auto index = IntPtr(kungfu::BytecodeStubCSigns::ID_Deprecated_Start);
4485 auto jumpIndex = PtrAdd(opcode, index);
4486 DispatchWithId(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter, jumpIndex);
4487 }
4488
DECLARE_ASM_HANDLER_NOPRINT(HandleCallRuntime)4489 DECLARE_ASM_HANDLER_NOPRINT(HandleCallRuntime)
4490 {
4491 GateRef opcode = ZExtInt8ToPtr(ReadInst8_0(pc));
4492 auto index = IntPtr(kungfu::BytecodeStubCSigns::ID_CallRuntime_Start);
4493 auto jumpIndex = PtrAdd(opcode, index);
4494 DispatchWithId(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter, jumpIndex);
4495 }
4496
4497 // interpreter helper handler
DECLARE_ASM_HANDLER_NOPRINT(ExceptionHandler)4498 DECLARE_ASM_HANDLER_NOPRINT(ExceptionHandler)
4499 {
4500 auto env = GetEnvironment();
4501 DEFVARIABLE(varPc, VariableType::NATIVE_POINTER(), pc);
4502 DEFVARIABLE(varSp, VariableType::NATIVE_POINTER(), sp);
4503 DEFVARIABLE(varConstpool, VariableType::JS_POINTER(), constpool);
4504 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_POINTER(), profileTypeInfo);
4505 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
4506 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter);
4507
4508 Label pcIsInvalid(env);
4509 Label pcNotInvalid(env);
4510 GateRef exceptionOffset = IntPtr(JSThread::GlueData::GetExceptionOffset(env->IsArch32Bit()));
4511 GateRef exception = Load(VariableType::JS_ANY(), glue, exceptionOffset);
4512 varPc = TaggedCastToIntPtr(CallRuntime(glue, RTSTUB_ID(UpFrame), {}));
4513 varSp = GetCurrentFrame(glue);
4514 Branch(IntPtrEqual(*varPc, IntPtr(0)), &pcIsInvalid, &pcNotInvalid);
4515 Bind(&pcIsInvalid);
4516 {
4517 CallNGCRuntime(glue, RTSTUB_ID(ResumeUncaughtFrameAndReturn), { glue, *varSp, *varAcc });
4518 Return();
4519 }
4520 Bind(&pcNotInvalid);
4521 {
4522 varAcc = exception;
4523 // clear exception
4524 Store(VariableType::INT64(), glue, glue, exceptionOffset, Hole());
4525 GateRef function = GetFunctionFromFrame(GetFrame(*varSp));
4526 GateRef method = Load(VariableType::JS_ANY(), function, IntPtr(JSFunctionBase::METHOD_OFFSET));
4527 varConstpool = GetConstpoolFromMethod(method);
4528 varProfileTypeInfo = GetProfileTypeInfoFromMethod(method);
4529 varHotnessCounter = GetHotnessCounterFromMethod(method);
4530 CallNGCRuntime(glue, RTSTUB_ID(ResumeCaughtFrameAndDispatch), {
4531 glue, *varSp, *varPc, *varConstpool,
4532 *varProfileTypeInfo, *varAcc, *varHotnessCounter});
4533 Return();
4534 }
4535 }
4536
DECLARE_ASM_HANDLER(SingleStepDebugging)4537 DECLARE_ASM_HANDLER(SingleStepDebugging)
4538 {
4539 auto env = GetEnvironment();
4540 DEFVARIABLE(varPc, VariableType::NATIVE_POINTER(), pc);
4541 DEFVARIABLE(varSp, VariableType::NATIVE_POINTER(), sp);
4542 DEFVARIABLE(varConstpool, VariableType::JS_POINTER(), constpool);
4543 DEFVARIABLE(varProfileTypeInfo, VariableType::JS_POINTER(), profileTypeInfo);
4544 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
4545 DEFVARIABLE(varHotnessCounter, VariableType::INT32(), hotnessCounter);
4546
4547 GateRef frame = GetFrame(*varSp);
4548 SetPcToFrame(glue, frame, *varPc);
4549 GateRef currentSp = *varSp;
4550 varSp = TaggedCastToIntPtr(CallRuntime(glue,
4551 RTSTUB_ID(JumpToCInterpreter),
4552 { constpool, profileTypeInfo, acc,
4553 IntToTaggedInt(hotnessCounter)}));
4554 GateRef frameAfter = GetFrame(*varSp);
4555 varPc = GetPcFromFrame(frameAfter);
4556 Label shouldReturn(env);
4557 Label shouldContinue(env);
4558
4559 Branch(IntPtrEqual(*varPc, IntPtr(0)), &shouldReturn, &shouldContinue);
4560 Bind(&shouldReturn);
4561 {
4562 CallNGCRuntime(glue, RTSTUB_ID(ResumeRspAndReturn), { Undefined(), *varSp, currentSp });
4563 Return();
4564 }
4565 Bind(&shouldContinue);
4566 {
4567 varAcc = GetAccFromFrame(frameAfter);
4568 GateRef function = GetFunctionFromFrame(frameAfter);
4569 GateRef method = Load(VariableType::JS_ANY(), function, IntPtr(JSFunctionBase::METHOD_OFFSET));
4570 varProfileTypeInfo = GetProfileTypeInfoFromMethod(method);
4571 varConstpool = GetConstpoolFromMethod(method);
4572 varHotnessCounter = GetHotnessCounterFromMethod(method);
4573 }
4574 Label isException(env);
4575 Label notException(env);
4576 Branch(TaggedIsException(*varAcc), &isException, ¬Exception);
4577 Bind(&isException);
4578 DispatchLast(glue, *varSp, *varPc, *varConstpool, *varProfileTypeInfo, *varAcc,
4579 *varHotnessCounter);
4580 Bind(¬Exception);
4581 DISPATCH_BAK(SSD, IntPtr(0));
4582 }
4583
DECLARE_ASM_HANDLER(BCDebuggerEntry)4584 DECLARE_ASM_HANDLER(BCDebuggerEntry)
4585 {
4586 GateRef frame = GetFrame(sp);
4587 SetPcToFrame(glue, frame, pc);
4588 // NOTIFY_DEBUGGER_EVENT()
4589 CallRuntime(glue, RTSTUB_ID(NotifyBytecodePcChanged), {});
4590 // goto normal handle stub
4591 DispatchDebugger(glue, sp, pc, constpool, profileTypeInfo, acc, hotnessCounter);
4592 }
4593
DECLARE_ASM_HANDLER(BCDebuggerExceptionEntry)4594 DECLARE_ASM_HANDLER(BCDebuggerExceptionEntry)
4595 {
4596 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
4597 varAcc = Hole();
4598 GateRef frame = GetFrame(sp);
4599 SetPcToFrame(glue, frame, pc);
4600 // NOTIFY_DEBUGGER_EVENT()
4601 CallRuntime(glue, RTSTUB_ID(NotifyBytecodePcChanged), {});
4602 // goto last handle stub
4603 DispatchDebuggerLast(glue, sp, pc, constpool, profileTypeInfo, *varAcc, hotnessCounter);
4604 }
4605
DECLARE_ASM_HANDLER(NewObjectRangeThrowException)4606 DECLARE_ASM_HANDLER(NewObjectRangeThrowException)
4607 {
4608 CallRuntime(glue, RTSTUB_ID(ThrowDerivedMustReturnException), {});
4609 DISPATCH_LAST();
4610 }
4611
DECLARE_ASM_HANDLER(ThrowStackOverflowException)4612 DECLARE_ASM_HANDLER(ThrowStackOverflowException)
4613 {
4614 CallRuntime(glue, RTSTUB_ID(ThrowStackOverflowException), {});
4615 DISPATCH_LAST();
4616 }
4617
DECLARE_ASM_HANDLER(HandleWideLdpatchvarPrefImm16)4618 DECLARE_ASM_HANDLER(HandleWideLdpatchvarPrefImm16)
4619 {
4620 DEFVARIABLE(varAcc, VariableType::JS_ANY(), acc);
4621
4622 GateRef index = ReadInst16_1(pc);
4623 GateRef result = CallRuntime(glue, RTSTUB_ID(LdPatchVar), { Int16ToTaggedInt(index) });
4624 CHECK_EXCEPTION_WITH_VARACC(result, INT_PTR(WIDE_LDPATCHVAR_PREF_IMM16));
4625 }
4626
DECLARE_ASM_HANDLER(HandleWideStpatchvarPrefImm16)4627 DECLARE_ASM_HANDLER(HandleWideStpatchvarPrefImm16)
4628 {
4629 GateRef index = ReadInst16_1(pc);
4630 GateRef result = CallRuntime(glue, RTSTUB_ID(StPatchVar), { Int16ToTaggedInt(index), acc });
4631 CHECK_EXCEPTION(result, INT_PTR(WIDE_STPATCHVAR_PREF_IMM16));
4632 }
4633
DECLARE_ASM_HANDLER(HandleCallRuntimeNotifyConcurrentResultPrefNone)4634 DECLARE_ASM_HANDLER(HandleCallRuntimeNotifyConcurrentResultPrefNone)
4635 {
4636 GateRef funcObj = GetFunctionFromFrame(GetFrame(sp));
4637 CallRuntime(glue, RTSTUB_ID(NotifyConcurrentResult), {acc, funcObj});
4638 DISPATCH(CALLRUNTIME_NOTIFYCONCURRENTRESULT_PREF_NONE);
4639 }
4640
4641 ASM_INTERPRETER_BC_TYPE_PROFILER_STUB_LIST(DECLARE_ASM_HANDLER_PROFILE)
4642 ASM_INTERPRETER_BC_LAYOUT_PROFILER_STUB_LIST(DECLARE_ASM_HANDLER_PROFILE)
4643 ASM_INTERPRETER_BC_FUNC_HOT_PROFILER_STUB_LIST(DECLARE_ASM_HANDLER_PROFILE)
4644 ASM_INTERPRETER_BC_FUNC_COUNT_PROFILER_STUB_LIST(DECLARE_ASM_HANDLER_PROFILE)
4645
4646 #undef DECLARE_ASM_HANDLER
4647 #undef DISPATCH
4648 #undef DISPATCH_WITH_ACC
4649 #undef DISPATCH_LAST
4650 #undef DISPATCH_LAST_WITH_ACC
4651 #undef USE_PARAMS
4652 } // namespace panda::ecmascript::kungfu
4653