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