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/compiler/stub_descriptor.h"
17
18 #include "llvm-c/Core.h"
19 #include "llvm/Support/Host.h"
20
21 namespace panda::ecmascript::kungfu {
22 // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
23 #define CALL_STUB_INIT_DESCRIPTOR(name) \
24 class Stub##name##InterfaceDescriptor final { \
25 public: \
26 static void Initialize(StubDescriptor *descriptor); \
27 }; \
28 void Stub##name##InterfaceDescriptor::Initialize(StubDescriptor *descriptor)
29
30
CALL_STUB_INIT_DESCRIPTOR(FastAdd)31 CALL_STUB_INIT_DESCRIPTOR(FastAdd)
32 {
33 // 2 : 2 input parameters
34 StubDescriptor fastAdd("FastAdd", 0, 2, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED); // number or hole
35 *descriptor = fastAdd;
36 // 2 : 2 input parameters
37 std::array<StubMachineType, 2> params = {
38 StubMachineType::TAGGED,
39 StubMachineType::TAGGED,
40 };
41 descriptor->SetParameters(params.data());
42 }
43
CALL_STUB_INIT_DESCRIPTOR(FastSub)44 CALL_STUB_INIT_DESCRIPTOR(FastSub)
45 {
46 // 2 : 2 input parameters
47 StubDescriptor fastSub("FastSub", 0, 2, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED); // number or hole
48 *descriptor = fastSub;
49 // 2 : 2 input parameters
50 std::array<StubMachineType, 2> params = {
51 StubMachineType::TAGGED,
52 StubMachineType::TAGGED,
53 };
54 descriptor->SetParameters(params.data());
55 }
56
CALL_STUB_INIT_DESCRIPTOR(FastMul)57 CALL_STUB_INIT_DESCRIPTOR(FastMul)
58 {
59 // 2 : 2 input parameters
60 StubDescriptor fastMul("FastMul", 0, 2, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED); // number or hole
61 *descriptor = fastMul;
62 // 2 : 2 input parameters
63 std::array<StubMachineType, 2> params = {
64 StubMachineType::TAGGED,
65 StubMachineType::TAGGED,
66 };
67 descriptor->SetParameters(params.data());
68 }
69
70 #ifndef NDEBUG
CALL_STUB_INIT_DESCRIPTOR(FastMulGCTest)71 CALL_STUB_INIT_DESCRIPTOR(FastMulGCTest)
72 {
73 // 3 : 3 input parameters
74 StubDescriptor fastMulGC("FastMulGCTest", 0, 3, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
75 *descriptor = fastMulGC;
76 // 3 : 3 input parameters
77 std::array<StubMachineType, 3> params = {
78 StubMachineType::NATIVE_POINTER,
79 StubMachineType::UINT64,
80 StubMachineType::UINT64,
81 };
82 descriptor->SetParameters(params.data());
83 }
84 #else
CALL_STUB_INIT_DESCRIPTOR(FastMulGCTest)85 CALL_STUB_INIT_DESCRIPTOR(FastMulGCTest) {}
86 #endif
87
CALL_STUB_INIT_DESCRIPTOR(FastDiv)88 CALL_STUB_INIT_DESCRIPTOR(FastDiv)
89 {
90 // 2 : 2 input parameters
91 StubDescriptor fastDiv("FastDiv", 0, 2, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED); // float or hole
92 *descriptor = fastDiv;
93 // 2 : 2 input parameters
94 std::array<StubMachineType, 2> params = {
95 StubMachineType::TAGGED,
96 StubMachineType::TAGGED,
97 };
98 descriptor->SetParameters(params.data());
99 }
100
CALL_STUB_INIT_DESCRIPTOR(FastMod)101 CALL_STUB_INIT_DESCRIPTOR(FastMod)
102 {
103 // 3 : 3 input parameters
104 StubDescriptor fastMod("FastMod", 0, 3,
105 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED); // int,float or hole
106 *descriptor = fastMod;
107 // 3 : 3 input parameters
108 std::array<StubMachineType, 3> params = {
109 StubMachineType::NATIVE_POINTER,
110 StubMachineType::TAGGED,
111 StubMachineType::TAGGED,
112 };
113 descriptor->SetParameters(params.data());
114 }
115
CALL_STUB_INIT_DESCRIPTOR(FastTypeOf)116 CALL_STUB_INIT_DESCRIPTOR(FastTypeOf)
117 {
118 // 2 input parameters
119 StubDescriptor fastTypeOf("FastTypeOf", 0, 2, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED_POINTER);
120 *descriptor = fastTypeOf;
121 // 2 input parameters
122 std::array<StubMachineType, 2> params = {
123 StubMachineType::NATIVE_POINTER, // glue
124 StubMachineType::TAGGED, // ACC
125 };
126 descriptor->SetParameters(params.data());
127 }
128
CALL_STUB_INIT_DESCRIPTOR(FastEqual)129 CALL_STUB_INIT_DESCRIPTOR(FastEqual)
130 {
131 // 2 input parameters, return may be true/false/hole
132 StubDescriptor fastEqual("FastEqual", 0, 2, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::UINT64);
133 *descriptor = fastEqual;
134 // 2 input parameters
135 std::array<StubMachineType, 2> params = {
136 StubMachineType::TAGGED,
137 StubMachineType::TAGGED,
138 };
139 descriptor->SetParameters(params.data());
140 }
141
CALL_STUB_INIT_DESCRIPTOR(SetPropertyByName)142 CALL_STUB_INIT_DESCRIPTOR(SetPropertyByName)
143 {
144 // 4 : 4 input parameters
145 StubDescriptor setPropertyByName("SetPropertyByName", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
146 StubMachineType::UINT64);
147 *descriptor = setPropertyByName;
148
149 std::array<StubMachineType, 4> params = { // 4 : 4 input parameters
150 StubMachineType::NATIVE_POINTER, StubMachineType::TAGGED_POINTER, StubMachineType::TAGGED_POINTER,
151 StubMachineType::TAGGED_POINTER
152 };
153 descriptor->SetParameters(params.data());
154 }
155
CALL_STUB_INIT_DESCRIPTOR(SetPropertyByNameWithOwn)156 CALL_STUB_INIT_DESCRIPTOR(SetPropertyByNameWithOwn)
157 {
158 // 4 : 4 input parameters
159 StubDescriptor setPropertyByNameWithOwn("SetPropertyByNameWithOwn", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
160 StubMachineType::UINT64);
161 *descriptor = setPropertyByNameWithOwn;
162
163 std::array<StubMachineType, 4> params = { // 4 : 4 input parameters
164 StubMachineType::NATIVE_POINTER, StubMachineType::TAGGED_POINTER, StubMachineType::TAGGED_POINTER,
165 StubMachineType::TAGGED_POINTER
166 };
167 descriptor->SetParameters(params.data());
168 }
169
CALL_STUB_INIT_DESCRIPTOR(GetPropertyByName)170 CALL_STUB_INIT_DESCRIPTOR(GetPropertyByName)
171 {
172 // 3 : 3 input parameters
173 StubDescriptor getPropertyByName("GetPropertyByName", 0, 3, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
174 *descriptor = getPropertyByName;
175 // 3 : 3 input parameters
176 std::array<StubMachineType, 3> params = {
177 StubMachineType::NATIVE_POINTER, // glue
178 StubMachineType::TAGGED, // receiver
179 StubMachineType::TAGGED_POINTER, // key
180 };
181 descriptor->SetParameters(params.data());
182 }
183
CALL_STUB_INIT_DESCRIPTOR(GetPropertyByIndex)184 CALL_STUB_INIT_DESCRIPTOR(GetPropertyByIndex)
185 {
186 // 3 : 3 input parameters
187 StubDescriptor getPropertyByIndex("GetPropertyByIndex", 0, 3, ArgumentsOrder::DEFAULT_ORDER,
188 StubMachineType::TAGGED);
189 *descriptor = getPropertyByIndex;
190 // 3 : 3 input parameters
191 std::array<StubMachineType, 3> params = {
192 StubMachineType::NATIVE_POINTER, // glue
193 StubMachineType::TAGGED, // receiver
194 StubMachineType::UINT32, // index
195 };
196 descriptor->SetParameters(params.data());
197 }
198
CALL_STUB_INIT_DESCRIPTOR(SetPropertyByIndex)199 CALL_STUB_INIT_DESCRIPTOR(SetPropertyByIndex)
200 {
201 // 4 : 4 input parameters
202 StubDescriptor setPropertyByIndex("SetPropertyByIndex", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
203 StubMachineType::UINT64); // hole or undefined
204 *descriptor = setPropertyByIndex;
205 // 4 : 4 input parameters
206 std::array<StubMachineType, 4> params = {
207 StubMachineType::NATIVE_POINTER,
208 StubMachineType::TAGGED_POINTER,
209 StubMachineType::UINT32,
210 StubMachineType::TAGGED,
211 };
212 descriptor->SetParameters(params.data());
213 }
214
CALL_STUB_INIT_DESCRIPTOR(GetPropertyByValue)215 CALL_STUB_INIT_DESCRIPTOR(GetPropertyByValue)
216 {
217 // 3 : 3 input parameters
218 StubDescriptor getPropertyByValue("GetPropertyByValue", 0, 3, ArgumentsOrder::DEFAULT_ORDER,
219 StubMachineType::TAGGED);
220 *descriptor = getPropertyByValue;
221 // 3 : 3 input parameters
222 std::array<StubMachineType, 3> params = {
223 StubMachineType::NATIVE_POINTER,
224 StubMachineType::TAGGED_POINTER,
225 StubMachineType::TAGGED,
226 };
227 descriptor->SetParameters(params.data());
228 }
229
CALL_STUB_INIT_DESCRIPTOR(JSHClassAddProperty)230 CALL_STUB_INIT_DESCRIPTOR(JSHClassAddProperty)
231 {
232 // 4 : 4 input parameters
233 StubDescriptor jsHClassAddProperty("JSHClassAddProperty", 0, 4,
234 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NONE);
235 *descriptor = jsHClassAddProperty;
236 // 4 : 4 input parameters
237 std::array<StubMachineType, 4> params = {
238 StubMachineType::NATIVE_POINTER,
239 StubMachineType::TAGGED_POINTER,
240 StubMachineType::TAGGED_POINTER,
241 StubMachineType::UINT32,
242 };
243 descriptor->SetParameters(params.data());
244 }
245
CALL_STUB_INIT_DESCRIPTOR(LoadICByName)246 CALL_STUB_INIT_DESCRIPTOR(LoadICByName)
247 {
248 // 5 : 5 input parameters
249 StubDescriptor loadICByName("LoadICByName", 0, 5,
250 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
251 *descriptor = loadICByName;
252 // 5 : 5 input parameters
253 std::array<StubMachineType, 5> params = {
254 StubMachineType::NATIVE_POINTER,
255 StubMachineType::TAGGED,
256 StubMachineType::TAGGED,
257 StubMachineType::TAGGED,
258 StubMachineType::INT32,
259 };
260 descriptor->SetParameters(params.data());
261 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
262 }
263
CALL_STUB_INIT_DESCRIPTOR(TryLoadICByName)264 CALL_STUB_INIT_DESCRIPTOR(TryLoadICByName)
265 {
266 // 4 : 4 input parameters
267 StubDescriptor tryLoadICByName("TryLoadICByName", 0, 4,
268 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
269 *descriptor = tryLoadICByName;
270 // 4 : 4 input parameters
271 std::array<StubMachineType, 4> params = {
272 StubMachineType::NATIVE_POINTER,
273 StubMachineType::TAGGED,
274 StubMachineType::TAGGED,
275 StubMachineType::TAGGED,
276 };
277 descriptor->SetParameters(params.data());
278 }
279
CALL_STUB_INIT_DESCRIPTOR(TryLoadICByValue)280 CALL_STUB_INIT_DESCRIPTOR(TryLoadICByValue)
281 {
282 // 5 : 5 input parameters
283 StubDescriptor tryLoadICByValue("TryLoadICByValue", 0, 5,
284 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
285 *descriptor = tryLoadICByValue;
286 // 5 : 5 input parameters
287 std::array<StubMachineType, 5> params = {
288 StubMachineType::NATIVE_POINTER,
289 StubMachineType::TAGGED,
290 StubMachineType::TAGGED,
291 StubMachineType::TAGGED,
292 StubMachineType::TAGGED,
293 };
294 descriptor->SetParameters(params.data());
295 }
296
CALL_STUB_INIT_DESCRIPTOR(StoreICByName)297 CALL_STUB_INIT_DESCRIPTOR(StoreICByName)
298 {
299 // 6 : 6 input parameters
300 StubDescriptor storeICByName("StoreICByName", 0, 6,
301 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::UINT64);
302 *descriptor = storeICByName;
303 // 6 : 6 input parameters
304 std::array<StubMachineType, 6> params = {
305 StubMachineType::NATIVE_POINTER,
306 StubMachineType::TAGGED,
307 StubMachineType::TAGGED,
308 StubMachineType::TAGGED,
309 StubMachineType::TAGGED,
310 StubMachineType::INT32,
311 };
312 descriptor->SetParameters(params.data());
313 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
314 }
315
CALL_STUB_INIT_DESCRIPTOR(TryStoreICByName)316 CALL_STUB_INIT_DESCRIPTOR(TryStoreICByName)
317 {
318 // 5 : 5 input parameters
319 StubDescriptor tryStoreICByName("TryStoreICByName", 0, 5,
320 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::UINT64); // undefined or hole
321 *descriptor = tryStoreICByName;
322 // 5 : 5 input parameters
323 std::array<StubMachineType, 5> params = {
324 StubMachineType::NATIVE_POINTER,
325 StubMachineType::TAGGED_POINTER,
326 StubMachineType::TAGGED,
327 StubMachineType::TAGGED,
328 StubMachineType::TAGGED_POINTER,
329 };
330 descriptor->SetParameters(params.data());
331 }
332
CALL_STUB_INIT_DESCRIPTOR(TryStoreICByValue)333 CALL_STUB_INIT_DESCRIPTOR(TryStoreICByValue)
334 {
335 // 6 : 6 input parameters
336 StubDescriptor tryStoreICByValue("TryStoreICByValue", 0, 6,
337 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::UINT64); // undefined or hole
338 *descriptor = tryStoreICByValue;
339 // 6 : 6 input parameters
340 std::array<StubMachineType, 6> params = {
341 StubMachineType::NATIVE_POINTER,
342 StubMachineType::TAGGED_POINTER,
343 StubMachineType::TAGGED,
344 StubMachineType::TAGGED,
345 StubMachineType::TAGGED,
346 StubMachineType::TAGGED_POINTER,
347 };
348 descriptor->SetParameters(params.data());
349 }
350
CALL_STUB_INIT_DESCRIPTOR(TestAbsoluteAddressRelocation)351 CALL_STUB_INIT_DESCRIPTOR(TestAbsoluteAddressRelocation)
352 {
353 // 2 : 2 input parameters
354 StubDescriptor TestAbsoluteAddressRelocation("TestAbsoluteAddressRelocation", 0, 2,
355 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::UINT64); // undefined or hole
356 *descriptor = TestAbsoluteAddressRelocation;
357 // 2 : 2 input parameters
358 std::array<StubMachineType, 2> params = {
359 StubMachineType::INT64,
360 StubMachineType::INT64,
361 };
362 descriptor->SetParameters(params.data());
363 }
364
CALL_STUB_INIT_DESCRIPTOR(FloatMod)365 CALL_STUB_INIT_DESCRIPTOR(FloatMod)
366 {
367 // 2 : 2 input parameters
368 StubDescriptor floatMod("FloatMod", 0, 2, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::FLOAT64);
369 *descriptor = floatMod;
370 // 2 : 2 input parameters
371 std::array<StubMachineType, 2> params = {
372 StubMachineType::FLOAT64,
373 StubMachineType::FLOAT64,
374 };
375 descriptor->SetParameters(params.data());
376 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB_NO_GC);
377 }
378
CALL_STUB_INIT_DESCRIPTOR(AddElementInternal)379 CALL_STUB_INIT_DESCRIPTOR(AddElementInternal)
380 {
381 // 5 : 5 input parameters
382 StubDescriptor addElementInternal("AddElementInternal", 0, 5, ArgumentsOrder::DEFAULT_ORDER,
383 StubMachineType::BOOL);
384 *descriptor = addElementInternal;
385 // 5 : 5 input parameters
386 std::array<StubMachineType, 5> params = {
387 StubMachineType::NATIVE_POINTER, StubMachineType::TAGGED_POINTER, StubMachineType::UINT32,
388 StubMachineType::TAGGED, StubMachineType::UINT32,
389 };
390 descriptor->SetParameters(params.data());
391 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
392 }
393
CALL_STUB_INIT_DESCRIPTOR(GetTaggedArrayPtrTest)394 CALL_STUB_INIT_DESCRIPTOR(GetTaggedArrayPtrTest)
395 {
396 StubDescriptor getTaggedArrayPtr("GetTaggedArrayPtrTest", 0, 1, ArgumentsOrder::DEFAULT_ORDER,
397 StubMachineType::TAGGED_POINTER);
398 *descriptor = getTaggedArrayPtr;
399 std::array<StubMachineType, 1> params = {
400 StubMachineType::NATIVE_POINTER,
401 };
402 descriptor->SetParameters(params.data());
403 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
404 }
405
CALL_STUB_INIT_DESCRIPTOR(CallSetter)406 CALL_STUB_INIT_DESCRIPTOR(CallSetter)
407 {
408 // 5 : 5 input parameters
409 StubDescriptor callSetter("CallSetter", 0, 5, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::BOOL);
410 *descriptor = callSetter;
411 // 5 : 5 input parameters
412 std::array<StubMachineType, 5> params = {
413 StubMachineType::NATIVE_POINTER, StubMachineType::TAGGED, StubMachineType::TAGGED_POINTER,
414 StubMachineType::TAGGED, StubMachineType::BOOL,
415 };
416 descriptor->SetParameters(params.data());
417 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
418 }
419
CALL_STUB_INIT_DESCRIPTOR(CallSetter2)420 CALL_STUB_INIT_DESCRIPTOR(CallSetter2)
421 {
422 // 4 : 4 input parameters, return Undefined or Exception
423 StubDescriptor callSetter("CallSetter2", 0, 4, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::UINT64);
424 *descriptor = callSetter;
425 // 4 : 4 input parameters
426 std::array<StubMachineType, 4> params = {
427 StubMachineType::NATIVE_POINTER, StubMachineType::TAGGED, StubMachineType::TAGGED_POINTER,
428 StubMachineType::TAGGED,
429 };
430 descriptor->SetParameters(params.data());
431 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
432 }
433
CALL_STUB_INIT_DESCRIPTOR(CallGetter)434 CALL_STUB_INIT_DESCRIPTOR(CallGetter)
435 {
436 // 3 : 3 input parameters
437 StubDescriptor callGetter("CallGetter", 0, 3, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
438 *descriptor = callGetter;
439 // 3 : 3 input parameters
440 std::array<StubMachineType, 3> params = {
441 StubMachineType::NATIVE_POINTER,
442 StubMachineType::TAGGED, // getter
443 StubMachineType::TAGGED_POINTER, // receiver
444 };
445 descriptor->SetParameters(params.data());
446 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
447 }
448
CALL_STUB_INIT_DESCRIPTOR(CallGetter2)449 CALL_STUB_INIT_DESCRIPTOR(CallGetter2)
450 {
451 // 4 : 4 input parameters
452 StubDescriptor callGetter("CallGetter2", 0, 4, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
453 *descriptor = callGetter;
454 // 4 : 4 input parameters
455 std::array<StubMachineType, 4> params = {
456 StubMachineType::NATIVE_POINTER,
457 StubMachineType::TAGGED_POINTER, // receiver
458 StubMachineType::TAGGED_POINTER, // holder
459 StubMachineType::TAGGED, // accessor
460 };
461 descriptor->SetParameters(params.data());
462 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
463 }
464
CALL_STUB_INIT_DESCRIPTOR(CallInternalGetter)465 CALL_STUB_INIT_DESCRIPTOR(CallInternalGetter)
466 {
467 // 3 : 3 input parameters
468 StubDescriptor accessorGetter("CallInternalGetter", 0, 3, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
469 *descriptor = accessorGetter;
470 // 3 : 3 input parameters
471 std::array<StubMachineType, 3> params = {
472 StubMachineType::NATIVE_POINTER,
473 StubMachineType::TAGGED, // accessor
474 StubMachineType::TAGGED_POINTER, // receiver
475 };
476 descriptor->SetParameters(params.data());
477 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
478 }
479
CALL_STUB_INIT_DESCRIPTOR(ThrowTypeError)480 CALL_STUB_INIT_DESCRIPTOR(ThrowTypeError)
481 {
482 // 2 : 2 input parameters
483 StubDescriptor throwTypeError("ThrowTypeError", 0, 2, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::BOOL);
484 *descriptor = throwTypeError;
485 // 2 : 2 input parameters
486 std::array<StubMachineType, 2> params = {
487 StubMachineType::NATIVE_POINTER,
488 StubMachineType::UINT32, // messageStringId
489 };
490 descriptor->SetParameters(params.data());
491 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
492 }
493
CALL_STUB_INIT_DESCRIPTOR(JSProxySetProperty)494 CALL_STUB_INIT_DESCRIPTOR(JSProxySetProperty)
495 {
496 // 6 : 6 input parameters
497 StubDescriptor jsproxySetproperty("JSProxySetProperty", 0, 6,
498 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::BOOL);
499 *descriptor = jsproxySetproperty;
500 // 6 : 6 input parameters
501 std::array<StubMachineType, 6> params = {
502 StubMachineType::NATIVE_POINTER, StubMachineType::TAGGED_POINTER, StubMachineType::UINT64,
503 StubMachineType::TAGGED, StubMachineType::TAGGED_POINTER, StubMachineType::BOOL,
504 };
505 descriptor->SetParameters(params.data());
506 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
507 }
508
CALL_STUB_INIT_DESCRIPTOR(GetHash32)509 CALL_STUB_INIT_DESCRIPTOR(GetHash32)
510 {
511 // 2 : 2 input parameters
512 StubDescriptor getHash32("GetHash32", 0, 2, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::UINT32);
513 *descriptor = getHash32;
514 // 2 : 2 input parameters
515 std::array<StubMachineType, 2> params = {
516 StubMachineType::NATIVE_POINTER,
517 StubMachineType::UINT32,
518 };
519 descriptor->SetParameters(params.data());
520 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
521 }
522
CALL_STUB_INIT_DESCRIPTOR(FindElementWithCache)523 CALL_STUB_INIT_DESCRIPTOR(FindElementWithCache)
524 {
525 // 4 : 4 input parameters
526 StubDescriptor findElementWithCache("FindElementWithCache", 0, 4,
527 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::INT32);
528 *descriptor = findElementWithCache;
529 std::array<StubMachineType, 4> params = { // 4 : 4 input parameters
530 StubMachineType::NATIVE_POINTER, // thread
531 StubMachineType::TAGGED_POINTER, // hclass
532 StubMachineType::TAGGED, // key
533 StubMachineType::UINT32,
534 };
535 descriptor->SetParameters(params.data());
536 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
537 }
538
CALL_STUB_INIT_DESCRIPTOR(Execute)539 CALL_STUB_INIT_DESCRIPTOR(Execute)
540 {
541 // 5 : 5 input parameters
542 StubDescriptor execute("Execute", 0, 5, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::UINT64);
543 *descriptor = execute;
544 std::array<StubMachineType, 5> params = { // 5 : 5 input parameters
545 StubMachineType::NATIVE_POINTER,
546 StubMachineType::TAGGED_POINTER,
547 StubMachineType::TAGGED,
548 StubMachineType::UINT32,
549 StubMachineType::NATIVE_POINTER,
550 };
551 descriptor->SetParameters(params.data());
552 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
553 }
554
CALL_STUB_INIT_DESCRIPTOR(StringGetHashCode)555 CALL_STUB_INIT_DESCRIPTOR(StringGetHashCode)
556 {
557 StubDescriptor stringGetHashCode("StringGetHashCode", 0, 1,
558 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::UINT32);
559 *descriptor = stringGetHashCode;
560 std::array<StubMachineType, 1> params = {
561 StubMachineType::TAGGED_POINTER,
562 };
563 descriptor->SetParameters(params.data());
564 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB_NO_GC);
565 }
566
CALL_STUB_INIT_DESCRIPTOR(NewInternalString)567 CALL_STUB_INIT_DESCRIPTOR(NewInternalString)
568 {
569 // 2 : 2 input parameters
570 StubDescriptor stringGetHashCode("NewInternalString", 0, 2,
571 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED_POINTER);
572 *descriptor = stringGetHashCode;
573 // 2 : 2 input parameters
574 std::array<StubMachineType, 2> params = {
575 StubMachineType::NATIVE_POINTER,
576 StubMachineType::TAGGED_POINTER,
577 };
578 descriptor->SetParameters(params.data());
579 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
580 }
581
CALL_STUB_INIT_DESCRIPTOR(NewEcmaDynClass)582 CALL_STUB_INIT_DESCRIPTOR(NewEcmaDynClass)
583 {
584 // 4 : 4 input parameters
585 StubDescriptor newEcmaDynClass("NewEcmaDynClass", 0, 4,
586 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED_POINTER);
587 *descriptor = newEcmaDynClass;
588 // 4 : 4 input parameters
589 std::array<StubMachineType, 4> params = {
590 StubMachineType::NATIVE_POINTER,
591 StubMachineType::UINT32,
592 StubMachineType::UINT32,
593 StubMachineType::UINT32,
594 };
595 descriptor->SetParameters(params.data());
596 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
597 }
598
CALL_STUB_INIT_DESCRIPTOR(UpdateLayOutAndAddTransition)599 CALL_STUB_INIT_DESCRIPTOR(UpdateLayOutAndAddTransition)
600 {
601 // 5 : 5 input parameters
602 StubDescriptor updateLayOutAndAddTransition("UpdateLayOutAndAddTransition", 0, 5,
603 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NONE);
604 *descriptor = updateLayOutAndAddTransition;
605 // 5 : 5 input parameters
606 std::array<StubMachineType, 5> params = {
607 StubMachineType::NATIVE_POINTER,
608 StubMachineType::TAGGED_POINTER,
609 StubMachineType::TAGGED_POINTER,
610 StubMachineType::TAGGED_POINTER,
611 StubMachineType::UINT32,
612 };
613 descriptor->SetParameters(params.data());
614 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
615 }
616
CALL_STUB_INIT_DESCRIPTOR(PropertiesSetValue)617 CALL_STUB_INIT_DESCRIPTOR(PropertiesSetValue)
618 {
619 // 6 : 6 input parameters
620 StubDescriptor propertiesSetValue("PropertiesSetValue", 0, 6,
621 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NONE);
622 *descriptor = propertiesSetValue;
623 // 6 : 6 input parameters
624 std::array<StubMachineType, 6> params = {
625 StubMachineType::NATIVE_POINTER,
626 StubMachineType::TAGGED_POINTER,
627 StubMachineType::TAGGED,
628 StubMachineType::TAGGED_POINTER,
629 StubMachineType::UINT32,
630 StubMachineType::UINT32,
631 };
632 descriptor->SetParameters(params.data());
633 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
634 }
635
CALL_STUB_INIT_DESCRIPTOR(TaggedArraySetValue)636 CALL_STUB_INIT_DESCRIPTOR(TaggedArraySetValue)
637 {
638 // 6 : 6 input parameters
639 StubDescriptor taggedArraySetValue("TaggedArraySetValue", 0, 6,
640 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::UINT64); // undefined or hole
641 *descriptor = taggedArraySetValue;
642 // 6 : 6 input parameters
643 std::array<StubMachineType, 6> params = {
644 StubMachineType::NATIVE_POINTER,
645 StubMachineType::TAGGED_POINTER,
646 StubMachineType::TAGGED,
647 StubMachineType::TAGGED_POINTER,
648 StubMachineType::UINT32,
649 StubMachineType::UINT32,
650 };
651 descriptor->SetParameters(params.data());
652 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
653 }
654
CALL_STUB_INIT_DESCRIPTOR(NewTaggedArray)655 CALL_STUB_INIT_DESCRIPTOR(NewTaggedArray)
656 {
657 // 2 : 2 input parameters
658 StubDescriptor newTaggedArray("NewTaggedArray", 0, 2, ArgumentsOrder::DEFAULT_ORDER,
659 StubMachineType::TAGGED_POINTER);
660 *descriptor = newTaggedArray;
661 std::array<StubMachineType, 2> params = { // 2 : 2 input parameters
662 StubMachineType::NATIVE_POINTER, StubMachineType::UINT32,
663 };
664 descriptor->SetParameters(params.data());
665 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
666 }
667
CALL_STUB_INIT_DESCRIPTOR(CopyArray)668 CALL_STUB_INIT_DESCRIPTOR(CopyArray)
669 {
670 // 4 : 4 input parameters
671 StubDescriptor copyArray("CopyArray", 0, 4, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED_POINTER);
672 *descriptor = copyArray;
673 std::array<StubMachineType, 4> params = { // 4 : 4 input parameters
674 StubMachineType::NATIVE_POINTER, StubMachineType::TAGGED_POINTER, StubMachineType::UINT32,
675 StubMachineType::UINT32,
676 };
677 descriptor->SetParameters(params.data());
678 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
679 }
680
CALL_STUB_INIT_DESCRIPTOR(NameDictPutIfAbsent)681 CALL_STUB_INIT_DESCRIPTOR(NameDictPutIfAbsent)
682 {
683 // 7 : 7 input parameters
684 StubDescriptor nameDictPutIfAbsent("NameDictPutIfAbsent", 0, 7, ArgumentsOrder::DEFAULT_ORDER,
685 StubMachineType::TAGGED_POINTER);
686 *descriptor = nameDictPutIfAbsent;
687 std::array<StubMachineType, 7> params = { // 7 : 7 input parameters
688 StubMachineType::NATIVE_POINTER, StubMachineType::TAGGED_POINTER, StubMachineType::TAGGED_POINTER,
689 StubMachineType::TAGGED, StubMachineType::TAGGED, StubMachineType::UINT32, StubMachineType::BOOL,
690 };
691 descriptor->SetParameters(params.data());
692 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
693 }
694
CALL_STUB_INIT_DESCRIPTOR(NoticeThroughChainAndRefreshUser)695 CALL_STUB_INIT_DESCRIPTOR(NoticeThroughChainAndRefreshUser)
696 {
697 // 3 : 3 input parameters
698 StubDescriptor noticeIC("NoticeThroughChainAndRefreshUser", 0, 3, ArgumentsOrder::DEFAULT_ORDER,
699 StubMachineType::NONE);
700 *descriptor = noticeIC;
701 // 3 : 3 input parameters
702 std::array<StubMachineType, 3> params = {
703 StubMachineType::NATIVE_POINTER,
704 StubMachineType::TAGGED_POINTER,
705 StubMachineType::TAGGED_POINTER,
706 };
707 descriptor->SetParameters(params.data());
708 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
709 }
710
CALL_STUB_INIT_DESCRIPTOR(BytecodeHandler)711 CALL_STUB_INIT_DESCRIPTOR(BytecodeHandler)
712 {
713 // 7 : 7 input parameters
714 StubDescriptor bytecodeHandler("bytecodeHandler", 0, 7,
715 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NONE);
716 *descriptor = bytecodeHandler;
717 std::array<StubMachineType, 7> params = { // 7 : 7 input parameters
718 StubMachineType::NATIVE_POINTER,
719 StubMachineType::NATIVE_POINTER,
720 StubMachineType::NATIVE_POINTER,
721 StubMachineType::TAGGED_POINTER,
722 StubMachineType::TAGGED_POINTER,
723 StubMachineType::TAGGED,
724 StubMachineType::INT32,
725 };
726 descriptor->SetParameters(params.data());
727 descriptor->SetStubKind(StubDescriptor::CallStubKind::BYTECODE_HANDLER);
728 }
729
CALL_STUB_INIT_DESCRIPTOR(SingleStepDebugging)730 CALL_STUB_INIT_DESCRIPTOR(SingleStepDebugging)
731 {
732 // 7 : 7 input parameters
733 StubDescriptor singleStepDebugging("singleStepDebugging", 0, 7,
734 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NONE);
735 *descriptor = singleStepDebugging;
736 std::array<StubMachineType, 7> params = { // 7 : 7 input parameters
737 StubMachineType::NATIVE_POINTER,
738 StubMachineType::NATIVE_POINTER,
739 StubMachineType::NATIVE_POINTER,
740 StubMachineType::TAGGED_POINTER,
741 StubMachineType::TAGGED_POINTER,
742 StubMachineType::TAGGED,
743 StubMachineType::INT32,
744 };
745 descriptor->SetParameters(params.data());
746 descriptor->SetStubKind(StubDescriptor::CallStubKind::BYTECODE_HANDLER);
747 }
748
CALL_STUB_INIT_DESCRIPTOR(AsmInterpreterEntry)749 CALL_STUB_INIT_DESCRIPTOR(AsmInterpreterEntry)
750 {
751 // 7 : 7 input parameters
752 StubDescriptor asmInterpreterEntry("AsmInterpreterEntry", 0, 7,
753 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NONE);
754 *descriptor = asmInterpreterEntry;
755 std::array<StubMachineType, 7> params = { // 7 : 7 input parameters
756 StubMachineType::NATIVE_POINTER,
757 StubMachineType::NATIVE_POINTER,
758 StubMachineType::NATIVE_POINTER,
759 StubMachineType::TAGGED_POINTER,
760 StubMachineType::TAGGED_POINTER,
761 StubMachineType::TAGGED,
762 StubMachineType::INT32,
763 };
764 descriptor->SetParameters(params.data());
765 }
766
CALL_STUB_INIT_DESCRIPTOR(JumpToCInterpreter)767 CALL_STUB_INIT_DESCRIPTOR(JumpToCInterpreter)
768 {
769 // 7 : 7 input parameters
770 StubDescriptor jumpToCInterpreter("jumpToCInterpreter", 0, 7,
771 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NATIVE_POINTER);
772 *descriptor = jumpToCInterpreter;
773 std::array<StubMachineType, 7> params = { // 7 : 7 input parameters
774 StubMachineType::NATIVE_POINTER,
775 StubMachineType::NATIVE_POINTER,
776 StubMachineType::NATIVE_POINTER,
777 StubMachineType::TAGGED_POINTER,
778 StubMachineType::TAGGED_POINTER,
779 StubMachineType::TAGGED,
780 StubMachineType::INT32,
781 };
782 descriptor->SetParameters(params.data());
783 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
784 }
785
CALL_STUB_INIT_DESCRIPTOR(DebugPrint)786 CALL_STUB_INIT_DESCRIPTOR(DebugPrint)
787 {
788 // 1 : 1 input parameters
789 StubDescriptor debugPrint("DebugPrint", 0, 1,
790 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NONE);
791 *descriptor = debugPrint;
792 // 1 : 1 input parameters
793 std::array<StubMachineType, 1> params = {
794 StubMachineType::INT32,
795 };
796 descriptor->SetVariableArgs(true);
797 descriptor->SetParameters(params.data());
798 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
799 }
800
CALL_STUB_INIT_DESCRIPTOR(IncDyn)801 CALL_STUB_INIT_DESCRIPTOR(IncDyn)
802 {
803 // 2 : 2 input parameters
804 StubDescriptor incDyn("IncDyn", 0, 2,
805 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
806 *descriptor = incDyn;
807 // 2 : 2 input parameters
808 std::array<StubMachineType, 2> params = {
809 StubMachineType::NATIVE_POINTER,
810 StubMachineType::TAGGED,
811 };
812 descriptor->SetParameters(params.data());
813 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
814 }
815
CALL_STUB_INIT_DESCRIPTOR(DecDyn)816 CALL_STUB_INIT_DESCRIPTOR(DecDyn)
817 {
818 // 2 : 2 input parameters
819 StubDescriptor decDyn("DecDyn", 0, 2,
820 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
821 *descriptor = decDyn;
822 // 2 : 2 input parameters
823 std::array<StubMachineType, 2> params = {
824 StubMachineType::NATIVE_POINTER,
825 StubMachineType::TAGGED,
826 };
827 descriptor->SetParameters(params.data());
828 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
829 }
830
CALL_STUB_INIT_DESCRIPTOR(ExpDyn)831 CALL_STUB_INIT_DESCRIPTOR(ExpDyn)
832 {
833 // 3 : 3 input parameters
834 StubDescriptor expDyn("ExpDyn", 0, 3,
835 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
836 *descriptor = expDyn;
837 // 3 : 3 input parameters
838 std::array<StubMachineType, 3> params = {
839 StubMachineType::NATIVE_POINTER,
840 StubMachineType::TAGGED,
841 StubMachineType::TAGGED,
842 };
843 descriptor->SetParameters(params.data());
844 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
845 }
846
CALL_STUB_INIT_DESCRIPTOR(IsInDyn)847 CALL_STUB_INIT_DESCRIPTOR(IsInDyn)
848 {
849 // 3 : 3 input parameters
850 StubDescriptor isInDyn("IsInDyn", 0, 3,
851 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
852 *descriptor = isInDyn;
853 // 3 : 3 input parameters
854 std::array<StubMachineType, 3> params = {
855 StubMachineType::NATIVE_POINTER,
856 StubMachineType::TAGGED,
857 StubMachineType::TAGGED,
858 };
859 descriptor->SetParameters(params.data());
860 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
861 }
862
CALL_STUB_INIT_DESCRIPTOR(InstanceOfDyn)863 CALL_STUB_INIT_DESCRIPTOR(InstanceOfDyn)
864 {
865 // 3 : 3 input parameters
866 StubDescriptor instanceOfDyn("InstanceOfDyn", 0, 3,
867 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
868 *descriptor = instanceOfDyn;
869 // 3 : 3 input parameters
870 std::array<StubMachineType, 3> params = {
871 StubMachineType::NATIVE_POINTER,
872 StubMachineType::TAGGED,
873 StubMachineType::TAGGED,
874 };
875 descriptor->SetParameters(params.data());
876 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
877 }
878
CALL_STUB_INIT_DESCRIPTOR(FastStrictNotEqual)879 CALL_STUB_INIT_DESCRIPTOR(FastStrictNotEqual)
880 {
881 // 2 : 2 input parameters
882 StubDescriptor fastStrictNotEqual("FastStrictNotEqual", 0, 2,
883 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
884 *descriptor = fastStrictNotEqual;
885 // 2 : 2 input parameters
886 std::array<StubMachineType, 2> params = {
887 StubMachineType::TAGGED,
888 StubMachineType::TAGGED,
889 };
890 descriptor->SetParameters(params.data());
891 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
892 }
893
CALL_STUB_INIT_DESCRIPTOR(FastStrictEqual)894 CALL_STUB_INIT_DESCRIPTOR(FastStrictEqual)
895 {
896 // 2 : 2 input parameters
897 StubDescriptor fastStrictEqual("FastStrictEqual", 0, 2,
898 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
899 *descriptor = fastStrictEqual;
900 // 2 : 2 input parameters
901 std::array<StubMachineType, 2> params = {
902 StubMachineType::TAGGED,
903 StubMachineType::TAGGED,
904 };
905 descriptor->SetParameters(params.data());
906 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
907 }
908
CALL_STUB_INIT_DESCRIPTOR(CreateGeneratorObj)909 CALL_STUB_INIT_DESCRIPTOR(CreateGeneratorObj)
910 {
911 // 2 : 2 input parameters
912 StubDescriptor createGeneratorObj("CreateGeneratorObj", 0, 2,
913 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
914 *descriptor = createGeneratorObj;
915 // 2 : 2 input parameters
916 std::array<StubMachineType, 2> params = {
917 StubMachineType::NATIVE_POINTER,
918 StubMachineType::TAGGED,
919 };
920 descriptor->SetParameters(params.data());
921 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
922 }
923
CALL_STUB_INIT_DESCRIPTOR(ThrowConstAssignment)924 CALL_STUB_INIT_DESCRIPTOR(ThrowConstAssignment)
925 {
926 // 2 : 2 input parameters
927 StubDescriptor throwConstAssignment("ThrowConstAssignment", 0, 2,
928 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NONE);
929 *descriptor = throwConstAssignment;
930 // 2 : 2 input parameters
931 std::array<StubMachineType, 2> params = {
932 StubMachineType::NATIVE_POINTER,
933 StubMachineType::TAGGED,
934 };
935 descriptor->SetParameters(params.data());
936 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
937 }
938
CALL_STUB_INIT_DESCRIPTOR(GetTemplateObject)939 CALL_STUB_INIT_DESCRIPTOR(GetTemplateObject)
940 {
941 // 2 : 2 input parameters
942 StubDescriptor getTemplateObject("GetTemplateObject", 0, 2,
943 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
944 *descriptor = getTemplateObject;
945 // 2 : 2 input parameters
946 std::array<StubMachineType, 2> params = {
947 StubMachineType::NATIVE_POINTER,
948 StubMachineType::TAGGED,
949 };
950 descriptor->SetParameters(params.data());
951 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
952 }
953
CALL_STUB_INIT_DESCRIPTOR(GetNextPropName)954 CALL_STUB_INIT_DESCRIPTOR(GetNextPropName)
955 {
956 // 2 : 2 input parameters
957 StubDescriptor getNextPropName("GetNextPropName", 0, 2,
958 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
959 *descriptor = getNextPropName;
960 // 2 : 2 input parameters
961 std::array<StubMachineType, 2> params = {
962 StubMachineType::NATIVE_POINTER,
963 StubMachineType::TAGGED,
964 };
965 descriptor->SetParameters(params.data());
966 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
967 }
968
CALL_STUB_INIT_DESCRIPTOR(ThrowIfNotObject)969 CALL_STUB_INIT_DESCRIPTOR(ThrowIfNotObject)
970 {
971 // 1 : 1 input parameter
972 StubDescriptor throwIfNotObject("ThrowIfNotObject", 0, 1,
973 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NONE);
974 *descriptor = throwIfNotObject;
975 // 1 : 1 input parameter
976 std::array<StubMachineType, 1> params = {
977 StubMachineType::NATIVE_POINTER,
978 };
979 descriptor->SetParameters(params.data());
980 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
981 }
982
CALL_STUB_INIT_DESCRIPTOR(InsertOldToNewRememberedSet)983 CALL_STUB_INIT_DESCRIPTOR(InsertOldToNewRememberedSet)
984 {
985 // 3 : 3 input parameters
986 StubDescriptor index("InsertOldToNewRememberedSet", 0, 3, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NONE);
987 *descriptor = index;
988 // 3 : 3 input parameters
989 std::array<StubMachineType, 3> params = {
990 StubMachineType::NATIVE_POINTER,
991 StubMachineType::NATIVE_POINTER,
992 StubMachineType::NATIVE_POINTER,
993 };
994 descriptor->SetParameters(params.data());
995 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
996 }
997
CALL_STUB_INIT_DESCRIPTOR(MarkingBarrier)998 CALL_STUB_INIT_DESCRIPTOR(MarkingBarrier)
999 {
1000 // 5 : 5 input parameters
1001 StubDescriptor index("MarkingBarrier", 0, 5, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NONE);
1002 *descriptor = index;
1003 // 5 : 5 input parameters
1004 std::array<StubMachineType, 5> params = {
1005 StubMachineType::NATIVE_POINTER,
1006 StubMachineType::NATIVE_POINTER,
1007 StubMachineType::NATIVE_POINTER,
1008 StubMachineType::NATIVE_POINTER,
1009 StubMachineType::NATIVE_POINTER,
1010 };
1011 descriptor->SetParameters(params.data());
1012 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1013 }
1014
CALL_STUB_INIT_DESCRIPTOR(IterNext)1015 CALL_STUB_INIT_DESCRIPTOR(IterNext)
1016 {
1017 // 2 : 2 input parameters
1018 StubDescriptor iterNext("IterNext", 0, 2,
1019 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1020 *descriptor = iterNext;
1021 // 2 : 2 input parameters
1022 std::array<StubMachineType, 2> params = {
1023 StubMachineType::NATIVE_POINTER,
1024 StubMachineType::TAGGED,
1025 };
1026 descriptor->SetParameters(params.data());
1027 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1028 }
1029
CALL_STUB_INIT_DESCRIPTOR(CallRuntimeTrampoline)1030 CALL_STUB_INIT_DESCRIPTOR(CallRuntimeTrampoline)
1031 {
1032 /* 4 : 4 input parameters */
1033 StubDescriptor CallRuntimeTrampoline("CallRuntimeTrampoline", 0, 4,
1034 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1035 *descriptor = CallRuntimeTrampoline;
1036 std::array<StubMachineType, 4> params = { /* 4 : 4 input parameters */
1037 StubMachineType::NATIVE_POINTER,
1038 StubMachineType::UINT64,
1039 StubMachineType::UINT64,
1040 StubMachineType::UINT64,
1041 };
1042 descriptor->SetVariableArgs(true);
1043 descriptor->SetParameters(params.data());
1044 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1045 }
1046
CALL_STUB_INIT_DESCRIPTOR(CloseIterator)1047 CALL_STUB_INIT_DESCRIPTOR(CloseIterator)
1048 {
1049 // 2 : 2 input parameters
1050 StubDescriptor closeIterator("CloseIterator", 0, 2,
1051 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1052 *descriptor = closeIterator;
1053 // 2 : 2 input parameters
1054 std::array<StubMachineType, 2> params = {
1055 StubMachineType::NATIVE_POINTER,
1056 StubMachineType::TAGGED,
1057 };
1058 descriptor->SetParameters(params.data());
1059 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1060 }
1061
CALL_STUB_INIT_DESCRIPTOR(CopyModule)1062 CALL_STUB_INIT_DESCRIPTOR(CopyModule)
1063 {
1064 // 2 : 2 input parameters
1065 StubDescriptor copyModule("CopyModule", 0, 2,
1066 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NONE);
1067 *descriptor = copyModule;
1068 // 2 : 2 input parameters
1069 std::array<StubMachineType, 2> params = {
1070 StubMachineType::NATIVE_POINTER,
1071 StubMachineType::TAGGED,
1072 };
1073 descriptor->SetParameters(params.data());
1074 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1075 }
1076
CALL_STUB_INIT_DESCRIPTOR(SuperCallSpread)1077 CALL_STUB_INIT_DESCRIPTOR(SuperCallSpread)
1078 {
1079 // 4 : 4 input parameters
1080 StubDescriptor superCallSpread("SuperCallSpread", 0, 4,
1081 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1082 *descriptor = superCallSpread;
1083 // 4 : 4 input parameters
1084 std::array<StubMachineType, 4> params = {
1085 StubMachineType::NATIVE_POINTER,
1086 StubMachineType::TAGGED,
1087 StubMachineType::NATIVE_POINTER,
1088 StubMachineType::TAGGED,
1089 };
1090 descriptor->SetParameters(params.data());
1091 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1092 }
1093
CALL_STUB_INIT_DESCRIPTOR(DelObjProp)1094 CALL_STUB_INIT_DESCRIPTOR(DelObjProp)
1095 {
1096 // 3 : 3 input parameters
1097 StubDescriptor delObjProp("DelObjProp", 0, 3,
1098 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1099 *descriptor = delObjProp;
1100 // 3 : 3 input parameters
1101 std::array<StubMachineType, 3> params = {
1102 StubMachineType::NATIVE_POINTER,
1103 StubMachineType::TAGGED,
1104 StubMachineType::TAGGED,
1105 };
1106 descriptor->SetParameters(params.data());
1107 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1108 }
1109
CALL_STUB_INIT_DESCRIPTOR(NewObjSpreadDyn)1110 CALL_STUB_INIT_DESCRIPTOR(NewObjSpreadDyn)
1111 {
1112 // 4 : 4 input parameters
1113 StubDescriptor newObjSpreadDyn("NewObjSpreadDyn", 0, 4,
1114 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1115 *descriptor = newObjSpreadDyn;
1116 // 4 : 4 input parameters
1117 std::array<StubMachineType, 4> params = {
1118 StubMachineType::NATIVE_POINTER,
1119 StubMachineType::TAGGED,
1120 StubMachineType::TAGGED,
1121 StubMachineType::TAGGED,
1122 };
1123 descriptor->SetParameters(params.data());
1124 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1125 }
1126
CALL_STUB_INIT_DESCRIPTOR(CreateIterResultObj)1127 CALL_STUB_INIT_DESCRIPTOR(CreateIterResultObj)
1128 {
1129 // 3 : 3 input parameters
1130 StubDescriptor createIterResultObj("CreateIterResultObj", 0, 3,
1131 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1132 *descriptor = createIterResultObj;
1133 // 3 : 3 input parameters
1134 std::array<StubMachineType, 3> params = {
1135 StubMachineType::NATIVE_POINTER,
1136 StubMachineType::TAGGED,
1137 StubMachineType::TAGGED,
1138 };
1139 descriptor->SetParameters(params.data());
1140 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1141 }
1142
CALL_STUB_INIT_DESCRIPTOR(AsyncFunctionAwaitUncaught)1143 CALL_STUB_INIT_DESCRIPTOR(AsyncFunctionAwaitUncaught)
1144 {
1145 // 3 : 3 input parameters
1146 StubDescriptor asyncFunctionAwaitUncaught("AsyncFunctionAwaitUncaught", 0, 3,
1147 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1148 *descriptor = asyncFunctionAwaitUncaught;
1149 // 3 : 3 input parameters
1150 std::array<StubMachineType, 3> params = {
1151 StubMachineType::NATIVE_POINTER,
1152 StubMachineType::TAGGED,
1153 StubMachineType::TAGGED,
1154 };
1155 descriptor->SetParameters(params.data());
1156 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1157 }
1158
CALL_STUB_INIT_DESCRIPTOR(AsyncFunctionResolveOrReject)1159 CALL_STUB_INIT_DESCRIPTOR(AsyncFunctionResolveOrReject)
1160 {
1161 // 4: 4 input parameters
1162 StubDescriptor asyncFunctionResolveOrReject("AsyncFunctionResolveOrReject", 0, 4,
1163 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1164 *descriptor = asyncFunctionResolveOrReject;
1165 // 4: 4 input parameters
1166 std::array<StubMachineType, 4> params = {
1167 StubMachineType::NATIVE_POINTER,
1168 StubMachineType::TAGGED,
1169 StubMachineType::TAGGED,
1170 StubMachineType::BOOL,
1171 };
1172 descriptor->SetParameters(params.data());
1173 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1174 }
1175
1176
CALL_STUB_INIT_DESCRIPTOR(ThrowUndefinedIfHole)1177 CALL_STUB_INIT_DESCRIPTOR(ThrowUndefinedIfHole)
1178 {
1179 // 2 : 2 input parameters
1180 StubDescriptor throwUndefinedIfHole("ThrowUndefinedIfHole", 0, 2,
1181 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NONE);
1182 *descriptor = throwUndefinedIfHole;
1183 // 2 : 2 input parameters
1184 std::array<StubMachineType, 2> params = {
1185 StubMachineType::NATIVE_POINTER,
1186 StubMachineType::TAGGED,
1187 };
1188 descriptor->SetParameters(params.data());
1189 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1190 }
1191
CALL_STUB_INIT_DESCRIPTOR(CopyDataProperties)1192 CALL_STUB_INIT_DESCRIPTOR(CopyDataProperties)
1193 {
1194 // 3 : 3 input parameters
1195 StubDescriptor copyDataProperties("CopyDataProperties", 0, 3,
1196 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1197 *descriptor = copyDataProperties;
1198 // 3 : 3 input parameters
1199 std::array<StubMachineType, 3> params = {
1200 StubMachineType::NATIVE_POINTER,
1201 StubMachineType::TAGGED,
1202 StubMachineType::TAGGED,
1203 };
1204 descriptor->SetParameters(params.data());
1205 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1206 }
1207
CALL_STUB_INIT_DESCRIPTOR(StArraySpread)1208 CALL_STUB_INIT_DESCRIPTOR(StArraySpread)
1209 {
1210 // 4 : 4 input parameters
1211 StubDescriptor stArraySpread("StArraySpread", 0, 4,
1212 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1213 *descriptor = stArraySpread;
1214 // 4 : 4 input parameters
1215 std::array<StubMachineType, 4> params = {
1216 StubMachineType::NATIVE_POINTER,
1217 StubMachineType::TAGGED,
1218 StubMachineType::TAGGED,
1219 StubMachineType::TAGGED,
1220 };
1221 descriptor->SetParameters(params.data());
1222 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1223 }
1224
CALL_STUB_INIT_DESCRIPTOR(GetIteratorNext)1225 CALL_STUB_INIT_DESCRIPTOR(GetIteratorNext)
1226 {
1227 // 3 : 3 input parameters
1228 StubDescriptor getIteratorNext("GetIteratorNext", 0, 3,
1229 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1230 *descriptor = getIteratorNext;
1231 // 3 : 3 input parameters
1232 std::array<StubMachineType, 3> params = {
1233 StubMachineType::NATIVE_POINTER,
1234 StubMachineType::TAGGED,
1235 StubMachineType::TAGGED,
1236 };
1237 descriptor->SetParameters(params.data());
1238 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1239 }
1240
CALL_STUB_INIT_DESCRIPTOR(SetObjectWithProto)1241 CALL_STUB_INIT_DESCRIPTOR(SetObjectWithProto)
1242 {
1243 // 3 : 3 input parameters
1244 StubDescriptor setObjectWithProto("SetObjectWithProto", 0, 3,
1245 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1246 *descriptor = setObjectWithProto;
1247 // 3 : 3 input parameters
1248 std::array<StubMachineType, 3> params = {
1249 StubMachineType::NATIVE_POINTER,
1250 StubMachineType::TAGGED,
1251 StubMachineType::TAGGED,
1252 };
1253 descriptor->SetParameters(params.data());
1254 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1255 }
1256
CALL_STUB_INIT_DESCRIPTOR(LoadICByValue)1257 CALL_STUB_INIT_DESCRIPTOR(LoadICByValue)
1258 {
1259 // 5 : 5 input parameters
1260 StubDescriptor loadICByValue("LoadICByValue", 0, 5,
1261 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1262 *descriptor = loadICByValue;
1263 // 5 : 5 input parameters
1264 std::array<StubMachineType, 5> params = {
1265 StubMachineType::NATIVE_POINTER,
1266 StubMachineType::TAGGED,
1267 StubMachineType::TAGGED,
1268 StubMachineType::TAGGED,
1269 StubMachineType::INT32,
1270 };
1271 descriptor->SetParameters(params.data());
1272 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1273 }
1274
CALL_STUB_INIT_DESCRIPTOR(StoreICByValue)1275 CALL_STUB_INIT_DESCRIPTOR(StoreICByValue)
1276 {
1277 // 6 : 6 input parameters
1278 StubDescriptor storeICByValue("StoreICByValue", 0, 6,
1279 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1280 *descriptor = storeICByValue;
1281 // 6 : 6 input parameters
1282 std::array<StubMachineType, 6> params = {
1283 StubMachineType::NATIVE_POINTER,
1284 StubMachineType::TAGGED,
1285 StubMachineType::TAGGED,
1286 StubMachineType::TAGGED,
1287 StubMachineType::TAGGED,
1288 StubMachineType::INT32,
1289 };
1290 descriptor->SetParameters(params.data());
1291 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1292 }
1293
CALL_STUB_INIT_DESCRIPTOR(StOwnByValue)1294 CALL_STUB_INIT_DESCRIPTOR(StOwnByValue)
1295 {
1296 // 4 : 4 input parameters
1297 StubDescriptor stOwnByValue("StOwnByValue", 0, 4,
1298 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1299 *descriptor = stOwnByValue;
1300 // 4 : 4 input parameters
1301 std::array<StubMachineType, 4> params = {
1302 StubMachineType::NATIVE_POINTER,
1303 StubMachineType::TAGGED,
1304 StubMachineType::TAGGED,
1305 StubMachineType::TAGGED,
1306 };
1307 descriptor->SetParameters(params.data());
1308 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1309 }
1310
CALL_STUB_INIT_DESCRIPTOR(LdSuperByValue)1311 CALL_STUB_INIT_DESCRIPTOR(LdSuperByValue)
1312 {
1313 // 4 : 4 input parameters
1314 StubDescriptor ldSuperByValue("LdSuperByValue", 0, 4,
1315 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1316 *descriptor = ldSuperByValue;
1317 // 4 : 4 input parameters
1318 std::array<StubMachineType, 4> params = {
1319 StubMachineType::NATIVE_POINTER,
1320 StubMachineType::TAGGED,
1321 StubMachineType::TAGGED,
1322 StubMachineType::NATIVE_POINTER,
1323 };
1324 descriptor->SetParameters(params.data());
1325 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1326 }
1327
CALL_STUB_INIT_DESCRIPTOR(StSuperByValue)1328 CALL_STUB_INIT_DESCRIPTOR(StSuperByValue)
1329 {
1330 // 5 : 5 input parameters
1331 StubDescriptor stSuperByValue("StSuperByValue", 0, 5,
1332 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1333 *descriptor = stSuperByValue;
1334 // 5 : 5 input parameters
1335 std::array<StubMachineType, 5> params = {
1336 StubMachineType::NATIVE_POINTER,
1337 StubMachineType::TAGGED,
1338 StubMachineType::TAGGED,
1339 StubMachineType::TAGGED,
1340 StubMachineType::NATIVE_POINTER,
1341 };
1342 descriptor->SetParameters(params.data());
1343 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1344 }
1345
CALL_STUB_INIT_DESCRIPTOR(LdObjByIndex)1346 CALL_STUB_INIT_DESCRIPTOR(LdObjByIndex)
1347 {
1348 // 5 : 5 input parameters
1349 StubDescriptor ldObjByIndex("LdObjByIndex", 0, 5,
1350 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1351 *descriptor = ldObjByIndex;
1352 // 5 : 5 input parameters
1353 std::array<StubMachineType, 5> params = {
1354 StubMachineType::NATIVE_POINTER,
1355 StubMachineType::TAGGED,
1356 StubMachineType::UINT32,
1357 StubMachineType::BOOL,
1358 StubMachineType::TAGGED,
1359 };
1360 descriptor->SetParameters(params.data());
1361 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1362 }
1363
CALL_STUB_INIT_DESCRIPTOR(StObjByIndex)1364 CALL_STUB_INIT_DESCRIPTOR(StObjByIndex)
1365 {
1366 // 4 : 4 input parameters
1367 StubDescriptor stObjByIndex("StObjByIndex", 0, 4,
1368 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1369 *descriptor = stObjByIndex;
1370 // 4 : 4 input parameters
1371 std::array<StubMachineType, 4> params = {
1372 StubMachineType::NATIVE_POINTER,
1373 StubMachineType::TAGGED,
1374 StubMachineType::UINT32,
1375 StubMachineType::TAGGED,
1376 };
1377 descriptor->SetParameters(params.data());
1378 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1379 }
1380
CALL_STUB_INIT_DESCRIPTOR(StOwnByIndex)1381 CALL_STUB_INIT_DESCRIPTOR(StOwnByIndex)
1382 {
1383 // 4 : 4 input parameters
1384 StubDescriptor stOwnByIndex("StOwnByIndex", 0, 4,
1385 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1386 *descriptor = stOwnByIndex;
1387 // 4 : 4 input parameters
1388 std::array<StubMachineType, 4> params = {
1389 StubMachineType::NATIVE_POINTER,
1390 StubMachineType::TAGGED,
1391 StubMachineType::UINT32,
1392 StubMachineType::TAGGED,
1393 };
1394 descriptor->SetParameters(params.data());
1395 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1396 }
1397
CALL_STUB_INIT_DESCRIPTOR(StGlobalRecord)1398 CALL_STUB_INIT_DESCRIPTOR(StGlobalRecord)
1399 {
1400 // 4 : 4 input parameters
1401 StubDescriptor stGlobalRecord("StGlobalRecord", 0, 4,
1402 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1403 *descriptor = stGlobalRecord;
1404 std::array<StubMachineType, 4> params = { // 4 : 4 input parameters
1405 StubMachineType::NATIVE_POINTER,
1406 StubMachineType::TAGGED,
1407 StubMachineType::TAGGED,
1408 StubMachineType::BOOL,
1409 };
1410 descriptor->SetParameters(params.data());
1411 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1412 }
1413
CALL_STUB_INIT_DESCRIPTOR(NegDyn)1414 CALL_STUB_INIT_DESCRIPTOR(NegDyn)
1415 {
1416 // 2 : 2 input parameters
1417 StubDescriptor NegDyn("NegDyn", 0, 2,
1418 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1419 *descriptor = NegDyn;
1420 // 2 : 2 input parameters
1421 std::array<StubMachineType, 2> params = {
1422 StubMachineType::NATIVE_POINTER,
1423 StubMachineType::TAGGED,
1424 };
1425 descriptor->SetParameters(params.data());
1426 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1427 }
1428
CALL_STUB_INIT_DESCRIPTOR(NotDyn)1429 CALL_STUB_INIT_DESCRIPTOR(NotDyn)
1430 {
1431 // 2 : 2 input parameters
1432 StubDescriptor NotDyn("NotDyn", 0, 2,
1433 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1434 *descriptor = NotDyn;
1435 // 2 : 2 input parameters
1436 std::array<StubMachineType, 2> params = {
1437 StubMachineType::NATIVE_POINTER,
1438 StubMachineType::TAGGED,
1439 };
1440 descriptor->SetParameters(params.data());
1441 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1442 }
1443
CALL_STUB_INIT_DESCRIPTOR(ChangeTwoInt32AndToJSTaggedValue)1444 CALL_STUB_INIT_DESCRIPTOR(ChangeTwoInt32AndToJSTaggedValue)
1445 {
1446 // 3 : 3 input parameters
1447 StubDescriptor ChangeTwoInt32AndToJSTaggedValue("ChangeTwoInt32AndToJSTaggedValue", 0, 3,
1448 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1449 *descriptor = ChangeTwoInt32AndToJSTaggedValue;
1450 // 3 : 3 input parameters
1451 std::array<StubMachineType, 3> params = {
1452 StubMachineType::NATIVE_POINTER,
1453 StubMachineType::TAGGED,
1454 StubMachineType::TAGGED,
1455 };
1456 descriptor->SetParameters(params.data());
1457 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1458 }
1459
CALL_STUB_INIT_DESCRIPTOR(ChangeTwoInt32XorToJSTaggedValue)1460 CALL_STUB_INIT_DESCRIPTOR(ChangeTwoInt32XorToJSTaggedValue)
1461 {
1462 // 3 : 3 input parameters
1463 StubDescriptor ChangeTwoInt32XorToJSTaggedValue("ChangeTwoInt32XorToJSTaggedValue", 0, 3,
1464 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1465 *descriptor = ChangeTwoInt32XorToJSTaggedValue;
1466 // 3 : 3 input parameters
1467 std::array<StubMachineType, 3> params = {
1468 StubMachineType::NATIVE_POINTER,
1469 StubMachineType::TAGGED,
1470 StubMachineType::TAGGED,
1471 };
1472 descriptor->SetParameters(params.data());
1473 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1474 }
1475
CALL_STUB_INIT_DESCRIPTOR(ChangeTwoInt32OrToJSTaggedValue)1476 CALL_STUB_INIT_DESCRIPTOR(ChangeTwoInt32OrToJSTaggedValue)
1477 {
1478 // 3 : 3 input parameters
1479 StubDescriptor ChangeTwoInt32OrToJSTaggedValue("ChangeTwoInt32OrToJSTaggedValue", 0, 3,
1480 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1481 *descriptor = ChangeTwoInt32OrToJSTaggedValue;
1482 // 3 : 3 input parameters
1483 std::array<StubMachineType, 3> params = {
1484 StubMachineType::NATIVE_POINTER,
1485 StubMachineType::TAGGED,
1486 StubMachineType::TAGGED,
1487 };
1488 descriptor->SetParameters(params.data());
1489 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1490 }
1491
CALL_STUB_INIT_DESCRIPTOR(ChangeTwoUint32AndToJSTaggedValue)1492 CALL_STUB_INIT_DESCRIPTOR(ChangeTwoUint32AndToJSTaggedValue)
1493 {
1494 // 3 : 3 input parameters
1495 StubDescriptor ChangeTwoUint32AndToJSTaggedValue("ChangeTwoUint32AndToJSTaggedValue", 0, 3,
1496 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1497 *descriptor = ChangeTwoUint32AndToJSTaggedValue;
1498 // 3 : 3 input parameters
1499 std::array<StubMachineType, 3> params = {
1500 StubMachineType::NATIVE_POINTER,
1501 StubMachineType::TAGGED,
1502 StubMachineType::TAGGED,
1503 };
1504 descriptor->SetParameters(params.data());
1505 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1506 }
1507
CALL_STUB_INIT_DESCRIPTOR(ChangeUintAndIntShrToJSTaggedValue)1508 CALL_STUB_INIT_DESCRIPTOR(ChangeUintAndIntShrToJSTaggedValue)
1509 {
1510 // 3 : 3 input parameters
1511 StubDescriptor ChangeUintAndIntShrToJSTaggedValue("ChangeUintAndIntShrToJSTaggedValue", 0, 3,
1512 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1513 *descriptor = ChangeUintAndIntShrToJSTaggedValue;
1514 // 3 : 3 input parameters
1515 std::array<StubMachineType, 3> params = {
1516 StubMachineType::NATIVE_POINTER,
1517 StubMachineType::TAGGED,
1518 StubMachineType::TAGGED,
1519 };
1520 descriptor->SetParameters(params.data());
1521 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1522 }
1523
CALL_STUB_INIT_DESCRIPTOR(ChangeUintAndIntShlToJSTaggedValue)1524 CALL_STUB_INIT_DESCRIPTOR(ChangeUintAndIntShlToJSTaggedValue)
1525 {
1526 // 3 : 3 input parameters
1527 StubDescriptor ChangeUintAndIntShlToJSTaggedValue("ChangeUintAndIntShlToJSTaggedValue", 0, 3,
1528 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1529 *descriptor = ChangeUintAndIntShlToJSTaggedValue;
1530 // 3 : 3 input parameters
1531 std::array<StubMachineType, 3> params = {
1532 StubMachineType::NATIVE_POINTER,
1533 StubMachineType::TAGGED,
1534 StubMachineType::TAGGED,
1535 };
1536 descriptor->SetParameters(params.data());
1537 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1538 }
1539
CALL_STUB_INIT_DESCRIPTOR(ResolveClass)1540 CALL_STUB_INIT_DESCRIPTOR(ResolveClass)
1541 {
1542 // 6 : 6 input parameters
1543 StubDescriptor resolveClass("ResolveClass", 0, 6,
1544 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1545 *descriptor = resolveClass;
1546 std::array<StubMachineType, 6> params = { // 6 : 6 input parameters
1547 StubMachineType::NATIVE_POINTER,
1548 StubMachineType::TAGGED,
1549 StubMachineType::TAGGED_POINTER,
1550 StubMachineType::TAGGED,
1551 StubMachineType::TAGGED,
1552 StubMachineType::TAGGED_POINTER,
1553 };
1554 descriptor->SetParameters(params.data());
1555 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1556 }
1557
CALL_STUB_INIT_DESCRIPTOR(CloneClassFromTemplate)1558 CALL_STUB_INIT_DESCRIPTOR(CloneClassFromTemplate)
1559 {
1560 // 5 : 5 input parameters
1561 StubDescriptor cloneClassFromTemplate("CloneClassFromTemplate", 0, 5,
1562 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1563 *descriptor = cloneClassFromTemplate;
1564 std::array<StubMachineType, 5> params = { // 5 : 5 input parameters
1565 StubMachineType::NATIVE_POINTER,
1566 StubMachineType::TAGGED,
1567 StubMachineType::TAGGED,
1568 StubMachineType::TAGGED,
1569 StubMachineType::TAGGED_POINTER,
1570 };
1571 descriptor->SetParameters(params.data());
1572 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1573 }
1574
CALL_STUB_INIT_DESCRIPTOR(SetClassConstructorLength)1575 CALL_STUB_INIT_DESCRIPTOR(SetClassConstructorLength)
1576 {
1577 // 3 : 3 input parameters
1578 StubDescriptor setClassConstructorLength("SetClassConstructorLength", 0, 3,
1579 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NONE);
1580 *descriptor = setClassConstructorLength;
1581 std::array<StubMachineType, 3> params = { // 3 : 3 input parameters
1582 StubMachineType::NATIVE_POINTER,
1583 StubMachineType::TAGGED,
1584 StubMachineType::UINT16,
1585 };
1586 descriptor->SetParameters(params.data());
1587 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1588 }
1589
CALL_STUB_INIT_DESCRIPTOR(UpdateHotnessCounter)1590 CALL_STUB_INIT_DESCRIPTOR(UpdateHotnessCounter)
1591 {
1592 // 2 : 2 input parameters
1593 StubDescriptor updateHotnessCounter("UpdateHotnessCounter", 0, 2,
1594 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1595 *descriptor = updateHotnessCounter;
1596 std::array<StubMachineType, 2> params = { // 2 : 2 input parameters
1597 StubMachineType::NATIVE_POINTER,
1598 StubMachineType::NATIVE_POINTER,
1599 };
1600 descriptor->SetParameters(params.data());
1601 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1602 }
1603
CALL_STUB_INIT_DESCRIPTOR(ImportModule)1604 CALL_STUB_INIT_DESCRIPTOR(ImportModule)
1605 {
1606 // 2 : 2 input parameters
1607 StubDescriptor importModule("ImportModule", 0, 2,
1608 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1609 *descriptor = importModule;
1610 std::array<StubMachineType, 2> params = { // 2 : 2 input parameters
1611 StubMachineType::NATIVE_POINTER,
1612 StubMachineType::TAGGED,
1613 };
1614 descriptor->SetParameters(params.data());
1615 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1616 }
1617
CALL_STUB_INIT_DESCRIPTOR(StModuleVar)1618 CALL_STUB_INIT_DESCRIPTOR(StModuleVar)
1619 {
1620 // 3 : 3 input parameters
1621 StubDescriptor stModuleVar("StModuleVar", 0, 3,
1622 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NONE);
1623 *descriptor = stModuleVar;
1624 std::array<StubMachineType, 3> params = { // 3 : 3 input parameters
1625 StubMachineType::NATIVE_POINTER,
1626 StubMachineType::TAGGED,
1627 StubMachineType::TAGGED,
1628 };
1629 descriptor->SetParameters(params.data());
1630 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1631 }
1632
CALL_STUB_INIT_DESCRIPTOR(LdModvarByName)1633 CALL_STUB_INIT_DESCRIPTOR(LdModvarByName)
1634 {
1635 // 3 : 3 input parameters
1636 StubDescriptor ldModvarByName("LdModvarByName", 0, 3,
1637 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1638 *descriptor = ldModvarByName;
1639 std::array<StubMachineType, 3> params = { // 3 : 3 input parameters
1640 StubMachineType::NATIVE_POINTER,
1641 StubMachineType::TAGGED,
1642 StubMachineType::TAGGED,
1643 };
1644 descriptor->SetParameters(params.data());
1645 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1646 }
1647
CALL_STUB_INIT_DESCRIPTOR(ThrowDyn)1648 CALL_STUB_INIT_DESCRIPTOR(ThrowDyn)
1649 {
1650 // 2 : 2 input parameters
1651 StubDescriptor throwDyn("ThrowDyn", 0, 2,
1652 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NONE);
1653 *descriptor = throwDyn;
1654 std::array<StubMachineType, 2> params = { // 2 : 2 input parameters
1655 StubMachineType::NATIVE_POINTER,
1656 StubMachineType::TAGGED,
1657 };
1658 descriptor->SetParameters(params.data());
1659 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1660 }
1661
CALL_STUB_INIT_DESCRIPTOR(GetPropIterator)1662 CALL_STUB_INIT_DESCRIPTOR(GetPropIterator)
1663 {
1664 // 2 : 2 input parameters
1665 StubDescriptor getPropIterator("GetPropIterator", 0, 2,
1666 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1667 *descriptor = getPropIterator;
1668 std::array<StubMachineType, 2> params = { // 2 : 2 input parameters
1669 StubMachineType::NATIVE_POINTER,
1670 StubMachineType::TAGGED,
1671 };
1672 descriptor->SetParameters(params.data());
1673 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1674 }
1675
CALL_STUB_INIT_DESCRIPTOR(LdGlobalRecord)1676 CALL_STUB_INIT_DESCRIPTOR(LdGlobalRecord)
1677 {
1678 // 2 : 2 input parameters
1679 StubDescriptor ldGlobalRecord("LdGlobalRecord", 0, 2,
1680 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1681 *descriptor = ldGlobalRecord;
1682 std::array<StubMachineType, 2> params = { // 2 : 2 input parameters
1683 StubMachineType::NATIVE_POINTER,
1684 StubMachineType::TAGGED,
1685 };
1686 descriptor->SetParameters(params.data());
1687 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1688 }
1689
CALL_STUB_INIT_DESCRIPTOR(AsyncFunctionEnter)1690 CALL_STUB_INIT_DESCRIPTOR(AsyncFunctionEnter)
1691 {
1692 // 1 : 1 input parameters
1693 StubDescriptor asyncFunctionEnter("AsyncFunctionEnter", 0, 1,
1694 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1695 *descriptor = asyncFunctionEnter;
1696 std::array<StubMachineType, 1> params = { // 1 : 1 input parameters
1697 StubMachineType::NATIVE_POINTER,
1698 };
1699 descriptor->SetParameters(params.data());
1700 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1701 }
1702
CALL_STUB_INIT_DESCRIPTOR(GetGlobalOwnProperty)1703 CALL_STUB_INIT_DESCRIPTOR(GetGlobalOwnProperty)
1704 {
1705 // 2 : 2 input parameters
1706 StubDescriptor getGlobalOwnProperty("GetGlobalOwnProperty", 0, 2,
1707 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1708 *descriptor = getGlobalOwnProperty;
1709 std::array<StubMachineType, 2> params = { // 2 : 2 input parameters
1710 StubMachineType::NATIVE_POINTER,
1711 StubMachineType::TAGGED,
1712 };
1713 descriptor->SetParameters(params.data());
1714 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1715 }
1716
CALL_STUB_INIT_DESCRIPTOR(GetIterator)1717 CALL_STUB_INIT_DESCRIPTOR(GetIterator)
1718 {
1719 // 2 : 2 input parameters
1720 StubDescriptor getIterator("GetIterator", 0, 2,
1721 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1722 *descriptor = getIterator;
1723 std::array<StubMachineType, 2> params = { // 2 : 2 input parameters
1724 StubMachineType::NATIVE_POINTER,
1725 StubMachineType::TAGGED,
1726 };
1727 descriptor->SetParameters(params.data());
1728 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1729 }
1730
CALL_STUB_INIT_DESCRIPTOR(ThrowThrowNotExists)1731 CALL_STUB_INIT_DESCRIPTOR(ThrowThrowNotExists)
1732 {
1733 // 1 : 1 input parameters
1734 StubDescriptor throwThrowNotExists("ThrowThrowNotExists", 0, 1,
1735 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NONE);
1736 *descriptor = throwThrowNotExists;
1737 std::array<StubMachineType, 1> params = { // 1 : 1 input parameters
1738 StubMachineType::NATIVE_POINTER,
1739 };
1740 descriptor->SetParameters(params.data());
1741 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1742 }
1743
CALL_STUB_INIT_DESCRIPTOR(TryLdGlobalByName)1744 CALL_STUB_INIT_DESCRIPTOR(TryLdGlobalByName)
1745 {
1746 // 2 : 2 input parameters
1747 StubDescriptor tryLdGlobalByName("TryLdGlobalByName", 0, 2,
1748 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1749 *descriptor = tryLdGlobalByName;
1750 std::array<StubMachineType, 2> params = { // 2 : 2 input parameters
1751 StubMachineType::NATIVE_POINTER,
1752 StubMachineType::TAGGED,
1753 };
1754 descriptor->SetParameters(params.data());
1755 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1756 }
1757
CALL_STUB_INIT_DESCRIPTOR(LoadMiss)1758 CALL_STUB_INIT_DESCRIPTOR(LoadMiss)
1759 {
1760 // 6 : 6 input parameters
1761 StubDescriptor loadMiss("LoadMiss", 0, 6,
1762 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1763 *descriptor = loadMiss;
1764 std::array<StubMachineType, 6> params = { // 6 : 6 input parameters
1765 StubMachineType::NATIVE_POINTER,
1766 StubMachineType::TAGGED_POINTER,
1767 StubMachineType::TAGGED,
1768 StubMachineType::TAGGED,
1769 StubMachineType::UINT32,
1770 StubMachineType::UINT32,
1771 };
1772 descriptor->SetParameters(params.data());
1773 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1774 }
1775
CALL_STUB_INIT_DESCRIPTOR(StoreMiss)1776 CALL_STUB_INIT_DESCRIPTOR(StoreMiss)
1777 {
1778 // 7 : 7 input parameters
1779 StubDescriptor storeMiss("StoreMiss", 0, 7,
1780 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1781 *descriptor = storeMiss;
1782 std::array<StubMachineType, 7> params = { // 7 : 7 input parameters
1783 StubMachineType::NATIVE_POINTER,
1784 StubMachineType::TAGGED_POINTER,
1785 StubMachineType::TAGGED,
1786 StubMachineType::TAGGED,
1787 StubMachineType::TAGGED,
1788 StubMachineType::UINT32,
1789 StubMachineType::UINT32,
1790 };
1791 descriptor->SetParameters(params.data());
1792 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1793 }
1794
CALL_STUB_INIT_DESCRIPTOR(ThrowPatternNonCoercible)1795 CALL_STUB_INIT_DESCRIPTOR(ThrowPatternNonCoercible)
1796 {
1797 // 1 : 1 input parameters
1798 StubDescriptor throwPatternNonCoercible("ThrowPatternNonCoercible", 0, 1,
1799 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NONE);
1800 *descriptor = throwPatternNonCoercible;
1801 std::array<StubMachineType, 1> params = { // 1 : 1 input parameters
1802 StubMachineType::NATIVE_POINTER,
1803 };
1804 descriptor->SetParameters(params.data());
1805 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1806 }
1807
CALL_STUB_INIT_DESCRIPTOR(TryUpdateGlobalRecord)1808 CALL_STUB_INIT_DESCRIPTOR(TryUpdateGlobalRecord)
1809 {
1810 // 3 : 3 input parameters
1811 StubDescriptor tryUpdateGlobalRecord("TryUpdateGlobalRecord", 0, 3,
1812 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1813 *descriptor = tryUpdateGlobalRecord;
1814 std::array<StubMachineType, 3> params = { // 3 : 3 input parameters
1815 StubMachineType::NATIVE_POINTER,
1816 StubMachineType::TAGGED,
1817 StubMachineType::TAGGED,
1818 };
1819 descriptor->SetParameters(params.data());
1820 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1821 }
1822
CALL_STUB_INIT_DESCRIPTOR(ThrowDeleteSuperProperty)1823 CALL_STUB_INIT_DESCRIPTOR(ThrowDeleteSuperProperty)
1824 {
1825 // 1 : 1 input parameters
1826 StubDescriptor throwDeleteSuperProperty("ThrowDeleteSuperProperty", 0, 1,
1827 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NONE);
1828 *descriptor = throwDeleteSuperProperty;
1829 std::array<StubMachineType, 1> params = { // 1 : 1 input parameters
1830 StubMachineType::NATIVE_POINTER,
1831 };
1832 descriptor->SetParameters(params.data());
1833 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1834 }
1835
CALL_STUB_INIT_DESCRIPTOR(ThrowReferenceError)1836 CALL_STUB_INIT_DESCRIPTOR(ThrowReferenceError)
1837 {
1838 // 2 : 2 input parameters
1839 StubDescriptor throwReferenceError("ThrowReferenceError", 0, 2,
1840 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1841 *descriptor = throwReferenceError;
1842 std::array<StubMachineType, 2> params = { // 2 : 2 input parameters
1843 StubMachineType::NATIVE_POINTER,
1844 StubMachineType::TAGGED,
1845 };
1846 descriptor->SetParameters(params.data());
1847 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1848 }
1849
CALL_STUB_INIT_DESCRIPTOR(EqDyn)1850 CALL_STUB_INIT_DESCRIPTOR(EqDyn)
1851 {
1852 // 3 : 3 input parameters
1853 StubDescriptor eqDyn("EqDyn", 0, 3,
1854 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1855 *descriptor = eqDyn;
1856 std::array<StubMachineType, 3> params = { // 3 : 3 input parameters
1857 StubMachineType::NATIVE_POINTER,
1858 StubMachineType::TAGGED,
1859 StubMachineType::TAGGED,
1860 };
1861 descriptor->SetParameters(params.data());
1862 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1863 }
1864
CALL_STUB_INIT_DESCRIPTOR(LdGlobalVar)1865 CALL_STUB_INIT_DESCRIPTOR(LdGlobalVar)
1866 {
1867 // 3 : 3 input parameters
1868 StubDescriptor ldGlobalVar("LdGlobalVar", 0, 3,
1869 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1870 *descriptor = ldGlobalVar;
1871 std::array<StubMachineType, 3> params = { // 3 : 3 input parameters
1872 StubMachineType::NATIVE_POINTER,
1873 StubMachineType::TAGGED,
1874 StubMachineType::TAGGED,
1875 };
1876 descriptor->SetParameters(params.data());
1877 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1878 }
1879
CALL_STUB_INIT_DESCRIPTOR(StGlobalVar)1880 CALL_STUB_INIT_DESCRIPTOR(StGlobalVar)
1881 {
1882 // 3 : 3 input parameters
1883 StubDescriptor stGlobalVar("StGlobalVar", 0, 3,
1884 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1885 *descriptor = stGlobalVar;
1886 std::array<StubMachineType, 3> params = { // 3 : 3 input parameters
1887 StubMachineType::NATIVE_POINTER,
1888 StubMachineType::TAGGED,
1889 StubMachineType::TAGGED,
1890 };
1891 descriptor->SetParameters(params.data());
1892 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1893 }
1894
CALL_STUB_INIT_DESCRIPTOR(ToBoolean)1895 CALL_STUB_INIT_DESCRIPTOR(ToBoolean)
1896 {
1897 // 1 : 1 input parameters
1898 StubDescriptor toBoolean("ToBoolean", 0, 1,
1899 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::BOOL);
1900 *descriptor = toBoolean;
1901 std::array<StubMachineType, 1> params = { // 1 : 1 input parameters
1902 StubMachineType::TAGGED,
1903 };
1904 descriptor->SetParameters(params.data());
1905 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1906 }
1907
CALL_STUB_INIT_DESCRIPTOR(NotEqDyn)1908 CALL_STUB_INIT_DESCRIPTOR(NotEqDyn)
1909 {
1910 // 3 : 3 input parameters
1911 StubDescriptor notEqDyn("NotEqDyn", 0, 3,
1912 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1913 *descriptor = notEqDyn;
1914 std::array<StubMachineType, 3> params = { // 3 : 3 input parameters
1915 StubMachineType::NATIVE_POINTER,
1916 StubMachineType::TAGGED,
1917 StubMachineType::TAGGED,
1918 };
1919 descriptor->SetParameters(params.data());
1920 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1921 }
1922
CALL_STUB_INIT_DESCRIPTOR(LessDyn)1923 CALL_STUB_INIT_DESCRIPTOR(LessDyn)
1924 {
1925 // 3 : 3 input parameters
1926 StubDescriptor lessDyn("LessDyn", 0, 3,
1927 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1928 *descriptor = lessDyn;
1929 std::array<StubMachineType, 3> params = { // 3 : 3 input parameters
1930 StubMachineType::NATIVE_POINTER,
1931 StubMachineType::TAGGED,
1932 StubMachineType::TAGGED,
1933 };
1934 descriptor->SetParameters(params.data());
1935 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1936 }
1937
CALL_STUB_INIT_DESCRIPTOR(LessEqDyn)1938 CALL_STUB_INIT_DESCRIPTOR(LessEqDyn)
1939 {
1940 // 3 : 3 input parameters
1941 StubDescriptor lessEqDyn("LessEqDyn", 0, 3,
1942 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1943 *descriptor = lessEqDyn;
1944 std::array<StubMachineType, 3> params = { // 3 : 3 input parameters
1945 StubMachineType::NATIVE_POINTER,
1946 StubMachineType::TAGGED,
1947 StubMachineType::TAGGED,
1948 };
1949 descriptor->SetParameters(params.data());
1950 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1951 }
1952
CALL_STUB_INIT_DESCRIPTOR(GreaterDyn)1953 CALL_STUB_INIT_DESCRIPTOR(GreaterDyn)
1954 {
1955 // 3 : 3 input parameters
1956 StubDescriptor greaterDyn("GreaterDyn", 0, 3,
1957 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1958 *descriptor = greaterDyn;
1959 std::array<StubMachineType, 3> params = { // 3 : 3 input parameters
1960 StubMachineType::NATIVE_POINTER,
1961 StubMachineType::TAGGED,
1962 StubMachineType::TAGGED,
1963 };
1964 descriptor->SetParameters(params.data());
1965 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1966 }
1967
CALL_STUB_INIT_DESCRIPTOR(GreaterEqDyn)1968 CALL_STUB_INIT_DESCRIPTOR(GreaterEqDyn)
1969 {
1970 // 3 : 3 input parameters
1971 StubDescriptor greaterEqDyn("GreaterEqDyn", 0, 3,
1972 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
1973 *descriptor = greaterEqDyn;
1974 std::array<StubMachineType, 3> params = { // 3 : 3 input parameters
1975 StubMachineType::NATIVE_POINTER,
1976 StubMachineType::TAGGED,
1977 StubMachineType::TAGGED,
1978 };
1979 descriptor->SetParameters(params.data());
1980 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
1981 }
1982
CALL_STUB_INIT_DESCRIPTOR(PhiGateTest)1983 CALL_STUB_INIT_DESCRIPTOR(PhiGateTest)
1984 {
1985 StubDescriptor phiGateTest("PhiGateTest", 0, 1, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::UINT32);
1986 *descriptor = phiGateTest;
1987 std::array<StubMachineType, 1> params = {
1988 StubMachineType::UINT32,
1989 };
1990 descriptor->SetParameters(params.data());
1991 descriptor->SetStubKind(StubDescriptor::CallStubKind::TEST_FUNC);
1992 }
1993
CALL_STUB_INIT_DESCRIPTOR(LoopTest)1994 CALL_STUB_INIT_DESCRIPTOR(LoopTest)
1995 {
1996 StubDescriptor loopTest("LoopTest", 0, 1, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::UINT32);
1997 *descriptor = loopTest;
1998 std::array<StubMachineType, 1> params = {
1999 StubMachineType::UINT32,
2000 };
2001 descriptor->SetParameters(params.data());
2002 descriptor->SetStubKind(StubDescriptor::CallStubKind::TEST_FUNC);
2003 }
2004
CALL_STUB_INIT_DESCRIPTOR(LoopTest1)2005 CALL_STUB_INIT_DESCRIPTOR(LoopTest1)
2006 {
2007 StubDescriptor loopTest1("LoopTest1", 0, 1, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::UINT32);
2008 *descriptor = loopTest1;
2009 std::array<StubMachineType, 1> params = {
2010 StubMachineType::UINT32,
2011 };
2012 descriptor->SetParameters(params.data());
2013 descriptor->SetStubKind(StubDescriptor::CallStubKind::TEST_FUNC);
2014 }
2015
CALL_STUB_INIT_DESCRIPTOR(SetPropertyByValue)2016 CALL_STUB_INIT_DESCRIPTOR(SetPropertyByValue)
2017 {
2018 // 4 : 4 input parameters
2019 StubDescriptor setPropertyByValue("SetPropertyByValue", 0, 4,
2020 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::UINT64);
2021 *descriptor = setPropertyByValue;
2022 // 4 : 4 input parameters
2023 std::array<StubMachineType, 4> params = {
2024 StubMachineType::NATIVE_POINTER,
2025 StubMachineType::TAGGED,
2026 StubMachineType::TAGGED,
2027 StubMachineType::TAGGED,
2028 };
2029 descriptor->SetParameters(params.data());
2030 }
2031
CALL_STUB_INIT_DESCRIPTOR(SetFunctionNameNoPrefix)2032 CALL_STUB_INIT_DESCRIPTOR(SetFunctionNameNoPrefix)
2033 {
2034 // 3 : 3 input parameters
2035 StubDescriptor setFunctionNameNoPrefix("SetFunctionNameNoPrefix", 0, 3,
2036 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
2037 *descriptor = setFunctionNameNoPrefix;
2038 std::array<StubMachineType, 3> params = { // 3 : 3 input parameters
2039 StubMachineType::NATIVE_POINTER,
2040 StubMachineType::TAGGED,
2041 StubMachineType::TAGGED,
2042 };
2043 descriptor->SetParameters(params.data());
2044 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
2045 }
2046
CALL_STUB_INIT_DESCRIPTOR(StOwnByName)2047 CALL_STUB_INIT_DESCRIPTOR(StOwnByName)
2048 {
2049 // 4 : 4 input parameters
2050 StubDescriptor stOwnByName("StOwnByName", 0, 4, ArgumentsOrder::DEFAULT_ORDER, StubMachineType::UINT64);
2051 *descriptor = stOwnByName;
2052 std::array<StubMachineType, 4> params = { // 4 : 4 input parameters
2053 StubMachineType::NATIVE_POINTER,
2054 StubMachineType::TAGGED,
2055 StubMachineType::TAGGED,
2056 StubMachineType::TAGGED,
2057 };
2058 descriptor->SetParameters(params.data());
2059 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
2060 }
2061
CALL_STUB_INIT_DESCRIPTOR(StOwnByNameWithNameSet)2062 CALL_STUB_INIT_DESCRIPTOR(StOwnByNameWithNameSet)
2063 {
2064 // 4 : 4 input parameters
2065 StubDescriptor stOwnByNameWithNameSet("StOwnByNameWithNameSet", 0, 4,
2066 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
2067 *descriptor = stOwnByNameWithNameSet;
2068 std::array<StubMachineType, 4> params = { // 4 : 4 input parameters
2069 StubMachineType::NATIVE_POINTER,
2070 StubMachineType::TAGGED,
2071 StubMachineType::TAGGED,
2072 StubMachineType::TAGGED,
2073 };
2074 descriptor->SetParameters(params.data());
2075 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
2076 }
2077
CALL_STUB_INIT_DESCRIPTOR(StOwnByValueWithNameSet)2078 CALL_STUB_INIT_DESCRIPTOR(StOwnByValueWithNameSet)
2079 {
2080 // 4 : 4 input parameters
2081 StubDescriptor stOwnByValueWithNameSet("StOwnByValueWithNameSet", 0, 4,
2082 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
2083 *descriptor = stOwnByValueWithNameSet;
2084 std::array<StubMachineType, 4> params = { // 4 : 4 input parameters
2085 StubMachineType::NATIVE_POINTER,
2086 StubMachineType::TAGGED,
2087 StubMachineType::TAGGED,
2088 StubMachineType::TAGGED,
2089 };
2090 descriptor->SetParameters(params.data());
2091 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
2092 }
2093
CALL_STUB_INIT_DESCRIPTOR(SuspendGenerator)2094 CALL_STUB_INIT_DESCRIPTOR(SuspendGenerator)
2095 {
2096 // 3 : 3 input parameters
2097 StubDescriptor suspendGenerator("SuspendGenerator", 0, 3,
2098 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
2099 *descriptor = suspendGenerator;
2100 std::array<StubMachineType, 3> params = { // 3 : 3 input parameters
2101 StubMachineType::NATIVE_POINTER,
2102 StubMachineType::TAGGED,
2103 StubMachineType::TAGGED,
2104 };
2105 descriptor->SetParameters(params.data());
2106 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
2107 }
2108
CALL_STUB_INIT_DESCRIPTOR(UpFrame)2109 CALL_STUB_INIT_DESCRIPTOR(UpFrame)
2110 {
2111 // 2 : 2 input parameters
2112 StubDescriptor upFrame("UpFrame", 0, 2,
2113 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::NATIVE_POINTER);
2114 *descriptor = upFrame;
2115 std::array<StubMachineType, 2> params = { // 2 : 2 input parameters
2116 StubMachineType::NATIVE_POINTER,
2117 StubMachineType::NATIVE_POINTER,
2118 };
2119 descriptor->SetParameters(params.data());
2120 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
2121 }
2122
CALL_STUB_INIT_DESCRIPTOR(ToNumber)2123 CALL_STUB_INIT_DESCRIPTOR(ToNumber)
2124 {
2125 // 2 : 2 input parameters
2126 StubDescriptor toNumber("ToNumber", 0, 2,
2127 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
2128 *descriptor = toNumber;
2129 std::array<StubMachineType, 2> params = { // 2 : 2 input parameters
2130 StubMachineType::NATIVE_POINTER,
2131 StubMachineType::TAGGED,
2132 };
2133 descriptor->SetParameters(params.data());
2134 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
2135 }
2136
CALL_STUB_INIT_DESCRIPTOR(Add2Dyn)2137 CALL_STUB_INIT_DESCRIPTOR(Add2Dyn)
2138 {
2139 // 3 : 3 input parameters
2140 StubDescriptor add2Dyn("Add2Dyn", 0, 3,
2141 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
2142 *descriptor = add2Dyn;
2143 std::array<StubMachineType, 3> params = { // 3 : 3 input parameters
2144 StubMachineType::NATIVE_POINTER,
2145 StubMachineType::TAGGED,
2146 StubMachineType::TAGGED,
2147 };
2148 descriptor->SetParameters(params.data());
2149 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
2150 }
2151
CALL_STUB_INIT_DESCRIPTOR(Sub2Dyn)2152 CALL_STUB_INIT_DESCRIPTOR(Sub2Dyn)
2153 {
2154 // 3 : 3 input parameters
2155 StubDescriptor sub2Dyn("Sub2Dyn", 0, 3,
2156 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
2157 *descriptor = sub2Dyn;
2158 std::array<StubMachineType, 3> params = { // 3 : 3 input parameters
2159 StubMachineType::NATIVE_POINTER,
2160 StubMachineType::TAGGED,
2161 StubMachineType::TAGGED,
2162 };
2163 descriptor->SetParameters(params.data());
2164 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
2165 }
2166
CALL_STUB_INIT_DESCRIPTOR(Mul2Dyn)2167 CALL_STUB_INIT_DESCRIPTOR(Mul2Dyn)
2168 {
2169 // 3 : 3 input parameters
2170 StubDescriptor mul2Dyn("Mul2Dyn", 0, 3,
2171 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
2172 *descriptor = mul2Dyn;
2173 std::array<StubMachineType, 3> params = { // 3 : 3 input parameters
2174 StubMachineType::NATIVE_POINTER,
2175 StubMachineType::TAGGED,
2176 StubMachineType::TAGGED,
2177 };
2178 descriptor->SetParameters(params.data());
2179 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
2180 }
2181
CALL_STUB_INIT_DESCRIPTOR(Div2Dyn)2182 CALL_STUB_INIT_DESCRIPTOR(Div2Dyn)
2183 {
2184 // 3 : 3 input parameters
2185 StubDescriptor div2Dyn("Div2Dyn", 0, 3,
2186 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
2187 *descriptor = div2Dyn;
2188 std::array<StubMachineType, 3> params = { // 3 : 3 input parameters
2189 StubMachineType::NATIVE_POINTER,
2190 StubMachineType::TAGGED,
2191 StubMachineType::TAGGED,
2192 };
2193 descriptor->SetParameters(params.data());
2194 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
2195 }
2196
CALL_STUB_INIT_DESCRIPTOR(Mod2Dyn)2197 CALL_STUB_INIT_DESCRIPTOR(Mod2Dyn)
2198 {
2199 // 3 : 3 input parameters
2200 StubDescriptor mod2Dyn("Mod2Dyn", 0, 3,
2201 ArgumentsOrder::DEFAULT_ORDER, StubMachineType::TAGGED);
2202 *descriptor = mod2Dyn;
2203 std::array<StubMachineType, 3> params = { // 3 : 3 input parameters
2204 StubMachineType::NATIVE_POINTER,
2205 StubMachineType::TAGGED,
2206 StubMachineType::TAGGED,
2207 };
2208 descriptor->SetParameters(params.data());
2209 descriptor->SetStubKind(StubDescriptor::CallStubKind::RUNTIME_STUB);
2210 }
2211
InitializeStubDescriptors()2212 void FastStubDescriptors::InitializeStubDescriptors()
2213 {
2214 // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
2215 #define DEF_CALL_STUB(name) NAME_##name
2216 // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
2217 #define INITIALIZE_CALL_STUB_DESCRIPTOR(name, argcounts) \
2218 Stub##name##InterfaceDescriptor::Initialize(&callStubsDescriptor_[DEF_CALL_STUB(name)]);
2219 CALL_STUB_LIST(INITIALIZE_CALL_STUB_DESCRIPTOR)
2220 #ifndef NDEBUG
2221 TEST_FUNC_LIST(INITIALIZE_CALL_STUB_DESCRIPTOR)
2222 #endif
2223 #undef INITIALIZE_CALL_STUB_DESCRIPTOR
2224 #undef DEF_CALL_STUB
2225 }
2226 } // namespace panda::ecmascript::kungfu
2227