1/*
2 * Copyright (c) 2024 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/baseline/baseline_call_signature.h"
17
18namespace panda::ecmascript::kungfu {
19
20#define BINARY_OP_SIGNATURE_DESC(name)                                  \
21    CallSignature signature(name, 0, 4,                                 \
22        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());         \
23    *callSign = signature;                                              \
24    std::array<VariableType, 4> params = {                              \
25        VariableType::NATIVE_POINTER(),                                 \
26        VariableType::NATIVE_POINTER(),                                 \
27        VariableType::JS_ANY(),                                         \
28        VariableType::INT32(),                                          \
29    }
30
31#define SINGLE_OP_SIGNATURE_DESC(name)                                  \
32    CallSignature signature(name, 0, 3,                                 \
33        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());         \
34    *callSign = signature;                                              \
35    std::array<VariableType, 3> params = {                              \
36        VariableType::NATIVE_POINTER(),                                 \
37        VariableType::NATIVE_POINTER(),                                 \
38        VariableType::INT32(),                                          \
39    }
40
41DEF_CALL_SIGNATURE(BaselineTryLdGLobalByNameImm8ID16)
42{
43    // 4 : 4 input parameters
44    CallSignature signature("BaselineTryLdGLobalByNameImm8ID16", 0, 4,
45        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
46    *callSign = signature;
47    // 4 : 4 input parameters
48    std::array<VariableType, 4> params = {
49        VariableType::NATIVE_POINTER(),
50        VariableType::NATIVE_POINTER(),
51        VariableType::INT32(),
52        VariableType::INT32(),
53    };
54    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
55}
56
57DEF_CALL_SIGNATURE(BaselineStToGlobalRecordImm16ID16)
58{
59    // 4 : 4 input parameters
60    CallSignature signature("BaselineStToGlobalRecordImm16ID16", 0, 4,
61        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
62    *callSign = signature;
63    // 4 : 4 input parameters
64    std::array<VariableType, 4> params = {
65        VariableType::NATIVE_POINTER(),
66        VariableType::NATIVE_POINTER(),
67        VariableType::JS_ANY(),
68        VariableType::INT32(),
69    };
70    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
71}
72
73DEF_CALL_SIGNATURE(BaselineLdaStrID16)
74{
75    // 3 : 3 input parameters
76    CallSignature signature("BaselineLdaStrID16", 0, 3,
77        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
78    *callSign = signature;
79    // 3 : 3 input parameters
80    std::array<VariableType, 3> params = {
81        VariableType::NATIVE_POINTER(),
82        VariableType::NATIVE_POINTER(),
83        VariableType::INT32(),
84    };
85    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
86}
87
88DEF_CALL_SIGNATURE(BaselineCallArg1Imm8V8)
89{
90    // 4 : 4 input parameters
91    CallSignature signature("BaselineCallArg1Imm8V8", 0, 4,
92        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
93    *callSign = signature;
94    // 4 : 4 input parameters
95    std::array<VariableType, 4> params = {
96        VariableType::NATIVE_POINTER(),
97        VariableType::NATIVE_POINTER(),
98        VariableType::INT32(),
99        VariableType::INT32(),
100    };
101    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
102}
103
104DEF_CALL_SIGNATURE(BaselineLdsymbol)
105{
106    // 1 : 1 input parameters
107    CallSignature signature("BaselineLdsymbol", 0, 1,
108        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
109    *callSign = signature;
110    // 1 : 1 input parameters
111    std::array<VariableType, 1> params = {
112        VariableType::NATIVE_POINTER(),
113    };
114    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
115}
116
117DEF_CALL_SIGNATURE(BaselineLdglobal)
118{
119    // 1 : 1 input parameters
120    CallSignature signature("BaselineLdglobal", 0, 1,
121        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
122    *callSign = signature;
123    // 1 : 1 input parameters
124    std::array<VariableType, 1> params = {
125        VariableType::NATIVE_POINTER(),
126    };
127    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
128}
129
130DEF_CALL_SIGNATURE(BaselinePoplexenv)
131{
132    // 2 : 2 input parameters
133    CallSignature signature("BaselinePoplexenv", 0, 2,
134        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
135    *callSign = signature;
136    // 2 : 2 input parameters
137    std::array<VariableType, 2> params = {
138        VariableType::NATIVE_POINTER(),
139        VariableType::NATIVE_POINTER(),
140    };
141    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
142}
143
144DEF_CALL_SIGNATURE(BaselineGetunmappedargs)
145{
146    // 3 : 3 input parameters
147    CallSignature signature("BaselineGetunmappedargs", 0, 3,
148        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
149    *callSign = signature;
150    // 3 : 3 input parameters
151    std::array<VariableType, 3> params = {
152        VariableType::NATIVE_POINTER(),
153        VariableType::NATIVE_POINTER(),
154        VariableType::JS_ANY(),
155    };
156    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
157}
158
159DEF_CALL_SIGNATURE(BaselineAsyncfunctionenter)
160{
161    // 2 : 2 input parameters
162    CallSignature signature("BaselineAsyncfunctionenter", 0, 2,
163        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
164    *callSign = signature;
165    // 2 : 2 input parameters
166    std::array<VariableType, 2> params = {
167        VariableType::NATIVE_POINTER(),
168        VariableType::NATIVE_POINTER(),
169    };
170    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
171}
172
173DEF_CALL_SIGNATURE(BaselineCreateasyncgeneratorobjV8)
174{
175    // 4 : 4 input parameters
176    CallSignature signature("BaselineCreateasyncgeneratorobjV8", 0, 4,
177        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
178    *callSign = signature;
179    // 4 : 4 input parameters
180    std::array<VariableType, 4> params = {
181        VariableType::NATIVE_POINTER(),
182        VariableType::NATIVE_POINTER(),
183        VariableType::JS_ANY(),
184        VariableType::JS_ANY(),
185    };
186    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
187}
188
189DEF_CALL_SIGNATURE(BaselineDebugger)
190{
191    // 1 : 1 input parameters
192    CallSignature signature("BaselineDebugger", 0, 1,
193        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
194    *callSign = signature;
195    // 1 : 1 input parameters
196    std::array<VariableType, 1> params = {
197        VariableType::NATIVE_POINTER(),
198    };
199    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
200}
201
202DEF_CALL_SIGNATURE(BaselineGetpropiterator)
203{
204    // 3 : 3 input parameters
205    CallSignature signature("BaselineGetpropiterator", 0, 3,
206        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
207    *callSign = signature;
208    // 3 : 3 input parameters
209    std::array<VariableType, 3> params = {
210        VariableType::NATIVE_POINTER(),
211        VariableType::NATIVE_POINTER(),
212        VariableType::JS_ANY(),
213    };
214    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
215}
216
217DEF_CALL_SIGNATURE(BaselineGetiteratorImm8)
218{
219    // 3 : 3 input parameters
220    CallSignature signature("BaselineGetiteratorImm8", 0, 3,
221        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
222    *callSign = signature;
223    // 3 : 3 input parameters
224    std::array<VariableType, 3> params = {
225        VariableType::NATIVE_POINTER(),
226        VariableType::NATIVE_POINTER(),
227        VariableType::INT32(),
228    };
229    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
230}
231
232DEF_CALL_SIGNATURE(BaselineGetiteratorImm16)
233{
234    // 3 : 3 input parameters
235    CallSignature signature("BaselineGetiteratorImm16", 0, 3,
236        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
237    *callSign = signature;
238    // 3 : 3 input parameters
239    std::array<VariableType, 3> params = {
240        VariableType::NATIVE_POINTER(),
241        VariableType::NATIVE_POINTER(),
242        VariableType::INT32(),
243    };
244    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
245}
246
247DEF_CALL_SIGNATURE(BaselineCloseiteratorImm8V8)
248{
249    // 3 : 3 input parameters
250    CallSignature signature("BaselineCloseiteratorImm8V8", 0, 3,
251        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
252    *callSign = signature;
253    // 3 : 3 input parameters
254    std::array<VariableType, 3> params = {
255        VariableType::NATIVE_POINTER(),
256        VariableType::NATIVE_POINTER(),
257        VariableType::JS_ANY(),
258    };
259    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
260}
261
262DEF_CALL_SIGNATURE(BaselineCloseiteratorImm16V8)
263{
264    // 3 : 3 input parameters
265    CallSignature signature("BaselineCloseiteratorImm16V8", 0, 3,
266        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
267    *callSign = signature;
268    // 3 : 3 input parameters
269    std::array<VariableType, 3> params = {
270        VariableType::NATIVE_POINTER(),
271        VariableType::NATIVE_POINTER(),
272        VariableType::JS_ANY(),
273    };
274    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
275}
276
277// GLUE, SP, OFFSET, V0, V1, V2
278DEF_CALL_SIGNATURE(BaselineAsyncgeneratorresolveV8V8V8)
279{
280    // 6 : 6 input parameters
281    CallSignature signature("BaselineAsyncgeneratorresolveV8V8V8", 0, 6,
282        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
283    *callSign = signature;
284    // 6 : 6 input parameters
285    std::array<VariableType, 6> params = {
286        VariableType::NATIVE_POINTER(),
287        VariableType::NATIVE_POINTER(),
288        VariableType::INT32(),
289        VariableType::INT8(),
290        VariableType::INT8(),
291        VariableType::INT8(),
292    };
293    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
294}
295
296DEF_CALL_SIGNATURE(BaselineCreateemptyobject)
297{
298    // 3 : 3 input parameters
299    CallSignature signature("BaselineCreateemptyobject", 0, 3,
300        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
301    *callSign = signature;
302    // 3 : 3 input parameters
303    std::array<VariableType, 3> params = {
304        VariableType::NATIVE_POINTER(),
305        VariableType::NATIVE_POINTER(),
306        VariableType::INT32(),
307    };
308    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
309}
310
311DEF_CALL_SIGNATURE(BaselineCreateemptyarrayImm8)
312{
313    // 4 : 4 input parameters
314    CallSignature signature("BaselineCreateemptyarrayImm8", 0, 4,
315        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
316    *callSign = signature;
317    // 4 : 4 input parameters
318    std::array<VariableType, 4> params = {
319        VariableType::NATIVE_POINTER(),
320        VariableType::NATIVE_POINTER(),
321        VariableType::INT32(),
322        VariableType::INT32(),
323    };
324    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
325}
326
327DEF_CALL_SIGNATURE(BaselineCreateemptyarrayImm16)
328{
329    // 4 : 4 input parameters
330    CallSignature signature("BaselineCreateemptyarrayImm16", 0, 4,
331        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
332    *callSign = signature;
333    // 4 : 4 input parameters
334    std::array<VariableType, 4> params = {
335        VariableType::NATIVE_POINTER(),
336        VariableType::NATIVE_POINTER(),
337        VariableType::INT32(),
338        VariableType::INT32(),
339    };
340    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
341}
342
343DEF_CALL_SIGNATURE(BaselineCreategeneratorobjV8)
344{
345    // 3 : 3 input parameters
346    CallSignature signature("BaselineCreategeneratorobjV8", 0, 3,
347        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
348    *callSign = signature;
349    // 3 : 3 input parameters
350    std::array<VariableType, 3> params = {
351        VariableType::NATIVE_POINTER(),
352        VariableType::NATIVE_POINTER(),
353        VariableType::JS_ANY(),
354    };
355    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
356}
357
358
359DEF_CALL_SIGNATURE(BaselineCreateiterresultobjV8V8)
360{
361    // 4 : 4 input parameters
362    CallSignature signature("BaselineCreateiterresultobjV8V8", 0, 4,
363        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
364    *callSign = signature;
365    // 4 : 4 input parameters
366    std::array<VariableType, 4> params = {
367        VariableType::NATIVE_POINTER(),
368        VariableType::NATIVE_POINTER(),
369        VariableType::JS_ANY(),
370        VariableType::JS_ANY(),
371    };
372    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
373}
374
375DEF_CALL_SIGNATURE(BaselineCreateobjectwithexcludedkeysImm8V8V8)
376{
377    // 5 : 5 input parameters
378    CallSignature signature("BaselineCreateobjectwithexcludedkeysImm8V8V8", 0, 5,
379        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
380    *callSign = signature;
381    // 5 : 5 input parameters
382    std::array<VariableType, 5> params = {
383        VariableType::NATIVE_POINTER(),
384        VariableType::NATIVE_POINTER(),
385        VariableType::INT16(),
386        VariableType::JS_ANY(),
387        VariableType::INT16(),
388    };
389    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
390}
391
392DEF_CALL_SIGNATURE(BaselineCallthis0Imm8V8)
393{
394    // 4 : 4 input parameters
395    CallSignature signature("BaselineCallthis0Imm8V8", 0, 4,
396        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
397    *callSign = signature;
398    // 4 : 4 input parameters
399    std::array<VariableType, 4> params = {
400        VariableType::NATIVE_POINTER(),
401        VariableType::NATIVE_POINTER(),
402        VariableType::INT32(),
403        VariableType::INT32(),
404    };
405    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
406}
407
408DEF_CALL_SIGNATURE(BaselineCreatearraywithbufferImm8Id16)
409{
410    // 5 : 5 input parameters
411    CallSignature signature("BaselineCreatearraywithbufferImm8Id16", 0, 5,
412        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
413    *callSign = signature;
414    // 5 : 5 input parameters
415    std::array<VariableType, 5> params = {
416        VariableType::NATIVE_POINTER(),
417        VariableType::NATIVE_POINTER(),
418        VariableType::INT32(),
419        VariableType::INT32(),
420        VariableType::INT32(),
421    };
422    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
423}
424
425DEF_CALL_SIGNATURE(BaselineCreatearraywithbufferImm16Id16)
426{
427    // 5 : 5 input parameters
428    CallSignature signature("BaselineCreatearraywithbufferImm16Id16", 0, 5,
429        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
430    *callSign = signature;
431    // 5 : 5 input parameters
432    std::array<VariableType, 5> params = {
433        VariableType::NATIVE_POINTER(),
434        VariableType::NATIVE_POINTER(),
435        VariableType::INT32(),
436        VariableType::INT32(),
437        VariableType::INT32(),
438    };
439    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
440}
441
442DEF_CALL_SIGNATURE(BaselineCallthis1Imm8V8V8)
443{
444    // 5 : 5 input parameters
445    CallSignature signature("BaselineCallthis1Imm8V8V8", 0, 5,
446        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
447    *callSign = signature;
448    // 5 : 5 input parameters
449    std::array<VariableType, 5> params = {
450        VariableType::NATIVE_POINTER(),
451        VariableType::NATIVE_POINTER(),
452        VariableType::INT32(),
453        VariableType::INT32(),
454        VariableType::INT32(),
455    };
456    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
457}
458
459DEF_CALL_SIGNATURE(BaselineCallthis2Imm8V8V8V8)
460{
461    // 6 : 6 input parameters
462    CallSignature signature("BaselineCallthis2Imm8V8V8V8", 0, 6,
463        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
464    *callSign = signature;
465    // 6 : 6 input parameters
466    std::array<VariableType, 6> params = {
467        VariableType::NATIVE_POINTER(),
468        VariableType::NATIVE_POINTER(),
469        VariableType::INT32(),
470        VariableType::INT32(),
471        VariableType::INT32(),
472        VariableType::INT32(),
473    };
474    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
475}
476
477DEF_CALL_SIGNATURE(BaselineCreateobjectwithbufferImm8Id16)
478{
479    // 4 : 4 input parameters
480    CallSignature signature("BaselineCreateobjectwithbufferImm8Id16", 0, 4,
481        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
482    *callSign = signature;
483    // 4 : 4 input parameters
484    std::array<VariableType, 4> params = {
485        VariableType::NATIVE_POINTER(),
486        VariableType::NATIVE_POINTER(),
487        VariableType::INT32(),
488        VariableType::INT32(),
489    };
490    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
491}
492
493DEF_CALL_SIGNATURE(BaselineCreateobjectwithbufferImm16Id16)
494{
495    // 4 : 4 input parameters
496    CallSignature signature("BaselineCreateobjectwithbufferImm16Id16", 0, 4,
497        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
498    *callSign = signature;
499    // 4 : 4 input parameters
500    std::array<VariableType, 4> params = {
501        VariableType::NATIVE_POINTER(),
502        VariableType::NATIVE_POINTER(),
503        VariableType::INT32(),
504        VariableType::INT32(),
505    };
506    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
507}
508
509DEF_CALL_SIGNATURE(BaselineCreateregexpwithliteralImm8Id16Imm8)
510{
511    // 4 : 4 input parameters
512    CallSignature signature("BaselineCreateregexpwithliteralImm8Id16Imm8", 0, 4,
513        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
514    *callSign = signature;
515    // 4 : 4 input parameters
516    std::array<VariableType, 4> params = {
517        VariableType::NATIVE_POINTER(),
518        VariableType::NATIVE_POINTER(),
519        VariableType::INT32(),
520        VariableType::INT32(),
521    };
522    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
523}
524
525DEF_CALL_SIGNATURE(BaselineCreateregexpwithliteralImm16Id16Imm8)
526{
527    // 4 : 4 input parameters
528    CallSignature signature("BaselineCreateregexpwithliteralImm16Id16Imm8", 0, 4,
529        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
530    *callSign = signature;
531    // 4 : 4 input parameters
532    std::array<VariableType, 4> params = {
533        VariableType::NATIVE_POINTER(),
534        VariableType::NATIVE_POINTER(),
535        VariableType::INT32(),
536        VariableType::INT32(),
537    };
538    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
539}
540
541DEF_CALL_SIGNATURE(BaselineNewobjapplyImm8V8)
542{
543    // 4 : 4 input parameters
544    CallSignature signature("BaselineNewobjapplyImm8V8", 0, 4,
545        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
546    *callSign = signature;
547    // 4 : 4 input parameters
548    std::array<VariableType, 4> params = {
549        VariableType::NATIVE_POINTER(),
550        VariableType::NATIVE_POINTER(),
551        VariableType::JS_ANY(),
552        VariableType::JS_ANY(),
553    };
554    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
555}
556
557DEF_CALL_SIGNATURE(BaselineNewobjapplyImm16V8)
558{
559    // 4 : 4 input parameters
560    CallSignature signature("BaselineNewobjapplyImm16V8", 0, 4,
561        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
562    *callSign = signature;
563    // 4 : 4 input parameters
564    std::array<VariableType, 4> params = {
565        VariableType::NATIVE_POINTER(),
566        VariableType::NATIVE_POINTER(),
567        VariableType::JS_ANY(),
568        VariableType::JS_ANY(),
569    };
570    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
571}
572
573DEF_CALL_SIGNATURE(BaselineNewlexenvImm8)
574{
575    // 4 : 4 input parameters
576    CallSignature signature("BaselineNewlexenvImm8", 0, 4,
577        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
578    *callSign = signature;
579    // 4 : 4 input parameters
580    std::array<VariableType, 4> params = {
581        VariableType::NATIVE_POINTER(),
582        VariableType::JS_ANY(),
583        VariableType::INT32(),
584        VariableType::NATIVE_POINTER(),
585    };
586    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
587}
588
589DEF_CALL_SIGNATURE(BaselineNewlexenvwithnameImm8Id16)
590{
591    // 5 : 5 input parameters
592    CallSignature signature("BaselineNewlexenvwithnameImm8Id16", 0, 5,
593        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
594    *callSign = signature;
595    // 5 : 5 input parameters
596    std::array<VariableType, 5> params = {
597        VariableType::NATIVE_POINTER(),
598        VariableType::NATIVE_POINTER(),
599        VariableType::JS_ANY(),
600        VariableType::INT16(),
601        VariableType::INT16(),
602    };
603    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
604}
605
606DEF_CALL_SIGNATURE(BaselineAdd2Imm8V8)
607{
608    BINARY_OP_SIGNATURE_DESC("BaselineAdd2Imm8V8");
609    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
610}
611
612DEF_CALL_SIGNATURE(BaselineSub2Imm8V8)
613{
614    BINARY_OP_SIGNATURE_DESC("BaselineSub2Imm8V8");
615    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
616}
617
618DEF_CALL_SIGNATURE(BaselineMul2Imm8V8)
619{
620    BINARY_OP_SIGNATURE_DESC("BaselineMul2Imm8V8");
621    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
622}
623
624DEF_CALL_SIGNATURE(BaselineDiv2Imm8V8)
625{
626    BINARY_OP_SIGNATURE_DESC("BaselineDiv2Imm8V8");
627    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
628}
629
630DEF_CALL_SIGNATURE(BaselineMod2Imm8V8)
631{
632    BINARY_OP_SIGNATURE_DESC("BaselineMod2Imm8V8");
633    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
634}
635
636DEF_CALL_SIGNATURE(BaselineEqImm8V8)
637{
638    BINARY_OP_SIGNATURE_DESC("BaselineEqImm8V8");
639    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
640}
641
642DEF_CALL_SIGNATURE(BaselineNoteqImm8V8)
643{
644    BINARY_OP_SIGNATURE_DESC("BaselineNoteqImm8V8");
645    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
646}
647
648DEF_CALL_SIGNATURE(BaselineLessImm8V8)
649{
650    BINARY_OP_SIGNATURE_DESC("BaselineLessImm8V8");
651    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
652}
653
654DEF_CALL_SIGNATURE(BaselineLesseqImm8V8)
655{
656    BINARY_OP_SIGNATURE_DESC("BaselineLesseqImm8V8");
657    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
658}
659
660DEF_CALL_SIGNATURE(BaselineGreaterImm8V8)
661{
662    BINARY_OP_SIGNATURE_DESC("BaselineGreaterImm8V8");
663    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
664}
665
666DEF_CALL_SIGNATURE(BaselineGreatereqImm8V8)
667{
668    BINARY_OP_SIGNATURE_DESC("BaselineGreatereqImm8V8");
669    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
670}
671
672DEF_CALL_SIGNATURE(BaselineShl2Imm8V8)
673{
674    BINARY_OP_SIGNATURE_DESC("BaselineShl2Imm8V8");
675    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
676}
677
678DEF_CALL_SIGNATURE(BaselineShr2Imm8V8)
679{
680    BINARY_OP_SIGNATURE_DESC("BaselineShr2Imm8V8");
681    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
682}
683
684DEF_CALL_SIGNATURE(BaselineAshr2Imm8V8)
685{
686    BINARY_OP_SIGNATURE_DESC("BaselineAshr2Imm8V8");
687    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
688}
689
690DEF_CALL_SIGNATURE(BaselineAnd2Imm8V8)
691{
692    BINARY_OP_SIGNATURE_DESC("BaselineAnd2Imm8V8");
693    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
694}
695
696DEF_CALL_SIGNATURE(BaselineOr2Imm8V8)
697{
698    BINARY_OP_SIGNATURE_DESC("BaselineOr2Imm8V8");
699    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
700}
701
702DEF_CALL_SIGNATURE(BaselineXor2Imm8V8)
703{
704    BINARY_OP_SIGNATURE_DESC("BaselineXor2Imm8V8");
705    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
706}
707
708DEF_CALL_SIGNATURE(BaselineExpImm8V8)
709{
710    // 3 : 3 input parameters
711    CallSignature signature("BaselineExpImm8V8", 0, 3,
712        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
713    *callSign = signature;
714    // 3 : 3 input parameters
715    std::array<VariableType, 3> params = {
716        VariableType::NATIVE_POINTER(),
717        VariableType::NATIVE_POINTER(),
718        VariableType::JS_ANY(),
719    };
720    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
721}
722
723DEF_CALL_SIGNATURE(BaselineTypeofImm8)
724{
725    // 2 : 2 input parameters
726    CallSignature signature("BaselineTypeofImm8", 0, 2,
727        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
728    *callSign = signature;
729    // 2 : 2 input parameters
730    std::array<VariableType, 2> params = {
731        VariableType::NATIVE_POINTER(),
732        VariableType::JS_ANY(),
733    };
734    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
735}
736
737DEF_CALL_SIGNATURE(BaselineTypeofImm16)
738{
739    // 2 : 2 input parameters
740    CallSignature signature("BaselineTypeofImm16", 0, 2,
741        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
742    *callSign = signature;
743    // 2 : 2 input parameters
744    std::array<VariableType, 2> params = {
745        VariableType::NATIVE_POINTER(),
746        VariableType::JS_ANY(),
747    };
748    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
749}
750
751DEF_CALL_SIGNATURE(BaselineTonumberImm8)
752{
753    // 3 : 3 input parameters
754    CallSignature signature("BaselineTonumberImm8", 0, 3,
755        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
756    *callSign = signature;
757    // 3 : 3 input parameters
758    std::array<VariableType, 3> params = {
759        VariableType::NATIVE_POINTER(),
760        VariableType::NATIVE_POINTER(),
761        VariableType::JS_ANY(),
762    };
763    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
764}
765
766DEF_CALL_SIGNATURE(BaselineTonumericImm8)
767{
768    // 3 : 3 input parameters
769    CallSignature signature("BaselineTonumericImm8", 0, 3,
770        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
771    *callSign = signature;
772    // 3 : 3 input parameters
773    std::array<VariableType, 3> params = {
774        VariableType::NATIVE_POINTER(),
775        VariableType::NATIVE_POINTER(),
776        VariableType::JS_ANY(),
777    };
778    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
779}
780
781DEF_CALL_SIGNATURE(BaselineNegImm8)
782{
783    SINGLE_OP_SIGNATURE_DESC("BaselineNegImm8");
784    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
785}
786
787DEF_CALL_SIGNATURE(BaselineNotImm8)
788{
789    SINGLE_OP_SIGNATURE_DESC("BaselineNotImm8");
790    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
791}
792
793DEF_CALL_SIGNATURE(BaselineIncImm8)
794{
795    SINGLE_OP_SIGNATURE_DESC("BaselineIncImm8");
796    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
797}
798
799DEF_CALL_SIGNATURE(BaselineDecImm8)
800{
801    SINGLE_OP_SIGNATURE_DESC("BaselineDecImm8");
802    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
803}
804
805DEF_CALL_SIGNATURE(BaselineIsinImm8V8)
806{
807    // 4 : 4 input parameters
808    CallSignature signature("BaselineIsinImm8V8", 0, 4,
809        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
810    *callSign = signature;
811    // 4 : 4 input parameters
812    std::array<VariableType, 4> params = {
813        VariableType::NATIVE_POINTER(),
814        VariableType::NATIVE_POINTER(),
815        VariableType::JS_ANY(),
816        VariableType::JS_ANY(),
817    };
818    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
819}
820
821DEF_CALL_SIGNATURE(BaselineInstanceofImm8V8)
822{
823    // 4 : 4 input parameters
824    CallSignature signature("BaselineInstanceofImm8V8", 0, 4,
825        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
826    *callSign = signature;
827    // 4 : 4 input parameters
828    std::array<VariableType, 4> params = {
829        VariableType::NATIVE_POINTER(),
830        VariableType::NATIVE_POINTER(),
831        VariableType::INT32(),
832        VariableType::INT32(),
833    };
834    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
835}
836
837DEF_CALL_SIGNATURE(BaselineStrictnoteqImm8V8)
838{
839    BINARY_OP_SIGNATURE_DESC("BaselineStrictnoteqImm8V8");
840    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
841}
842
843DEF_CALL_SIGNATURE(BaselineStricteqImm8V8)
844{
845    BINARY_OP_SIGNATURE_DESC("BaselineStricteqImm8V8");
846    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
847}
848
849DEF_CALL_SIGNATURE(BaselineIstrue)
850{
851    // 1 : 1 input parameters
852    CallSignature signature("BaselineIstrue", 0, 1,
853        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
854    *callSign = signature;
855    // 1 : 1 input parameters
856    std::array<VariableType, 1> params = {
857        VariableType::JS_ANY(),
858    };
859    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
860}
861
862DEF_CALL_SIGNATURE(BaselineIsfalse)
863{
864    // 1 : 1 input parameters
865    CallSignature signature("BaselineIsfalse", 0, 1,
866        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
867    *callSign = signature;
868    // 1 : 1 input parameters
869    std::array<VariableType, 1> params = {
870        VariableType::JS_ANY(),
871    };
872    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
873}
874
875DEF_CALL_SIGNATURE(BaselineCallthis3Imm8V8V8V8V8)
876{
877    // 5 : 5 input parameters
878    CallSignature signature("BaselineCallthis3Imm8V8V8V8V8", 0, 5,
879        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
880    *callSign = signature;
881    // 5 : 5 input parameters
882    std::array<VariableType, 5> params = {
883        VariableType::NATIVE_POINTER(),
884        VariableType::NATIVE_POINTER(),
885        VariableType::INT32(),
886        VariableType::INT32(),
887        VariableType::INT32(),
888    };
889    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
890}
891
892DEF_CALL_SIGNATURE(BaselineCallthisrangeImm8Imm8V8)
893{
894    // 5 : 5 input parameters
895    CallSignature signature("BaselineCallthisrangeImm8Imm8V8", 0, 5,
896        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
897    *callSign = signature;
898    // 5 : 5 input parameters
899    std::array<VariableType, 5> params = {
900        VariableType::NATIVE_POINTER(),
901        VariableType::NATIVE_POINTER(),
902        VariableType::INT32(),
903        VariableType::INT8(),
904        VariableType::INT32(),
905    };
906    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
907}
908
909DEF_CALL_SIGNATURE(BaselineSupercallthisrangeImm8Imm8V8)
910{
911    // 5 : 5 input parameters
912    CallSignature signature("BaselineSupercallthisrangeImm8Imm8V8", 0, 5,
913        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
914    *callSign = signature;
915    // 5 : 5 input parameters
916    std::array<VariableType, 5> params = {
917        VariableType::NATIVE_POINTER(),
918        VariableType::NATIVE_POINTER(),
919        VariableType::INT16(),
920        VariableType::INT16(),
921        VariableType::INT32(),
922    };
923    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
924}
925
926DEF_CALL_SIGNATURE(BaselineSupercallarrowrangeImm8Imm8V8)
927{
928    // 5 : 5 input parameters
929    CallSignature signature("BaselineSupercallarrowrangeImm8Imm8V8", 0, 5,
930        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
931    *callSign = signature;
932    // 5 : 5 input parameters
933    std::array<VariableType, 5> params = {
934        VariableType::NATIVE_POINTER(),
935        VariableType::NATIVE_POINTER(),
936        VariableType::JS_ANY(),
937        VariableType::INT8(),
938        VariableType::INT16(),
939    };
940    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
941}
942
943DEF_CALL_SIGNATURE(BaselineDefinefuncImm8Id16Imm8)
944{
945    // 5 : 5 input parameters
946    CallSignature signature("BaselineDefinefuncImm8Id16Imm8", 0, 5,
947        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
948    *callSign = signature;
949    // 5 : 5 input parameters
950    std::array<VariableType, 5> params = {
951        VariableType::NATIVE_POINTER(),
952        VariableType::NATIVE_POINTER(),
953        VariableType::INT32(),
954        VariableType::INT32(),
955        VariableType::INT32(),
956    };
957    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
958}
959
960DEF_CALL_SIGNATURE(BaselineDefinefuncImm16Id16Imm8)
961{
962    // 5 : 5 input parameters
963    CallSignature signature("BaselineDefinefuncImm16Id16Imm8", 0, 5,
964        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
965    *callSign = signature;
966    // 5 : 5 input parameters
967    std::array<VariableType, 5> params = {
968        VariableType::NATIVE_POINTER(),
969        VariableType::NATIVE_POINTER(),
970        VariableType::INT32(),
971        VariableType::INT32(),
972        VariableType::INT32(),
973    };
974    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
975}
976
977DEF_CALL_SIGNATURE(BaselineDefinemethodImm8Id16Imm8)
978{
979    // 5 : 5 input parameters
980    CallSignature signature("BaselineDefinemethodImm8Id16Imm8", 0, 5,
981        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
982    *callSign = signature;
983    // 5 : 5 input parameters
984    std::array<VariableType, 5> params = {
985        VariableType::NATIVE_POINTER(),
986        VariableType::JS_ANY(),
987        VariableType::INT32(),
988        VariableType::INT8(),
989        VariableType::NATIVE_POINTER(),
990    };
991    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
992}
993
994DEF_CALL_SIGNATURE(BaselineDefinemethodImm16Id16Imm8)
995{
996    // 5 : 5 input parameters
997    CallSignature signature("BaselineDefinemethodImm16Id16Imm8", 0, 5,
998        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
999    *callSign = signature;
1000    // 5 : 5 input parameters
1001    std::array<VariableType, 5> params = {
1002        VariableType::NATIVE_POINTER(),
1003        VariableType::JS_ANY(),
1004        VariableType::INT32(),
1005        VariableType::INT8(),
1006        VariableType::NATIVE_POINTER(),
1007    };
1008    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1009}
1010
1011DEF_CALL_SIGNATURE(BaselineCallarg0Imm8)
1012{
1013    // 3 : 3 input parameters
1014    CallSignature signature("BaselineCallarg0Imm8", 0, 3,
1015        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1016    *callSign = signature;
1017    // 3 : 3 input parameters
1018    std::array<VariableType, 3> params = {
1019        VariableType::NATIVE_POINTER(),
1020        VariableType::NATIVE_POINTER(),
1021        VariableType::INT32(),
1022    };
1023    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1024}
1025
1026DEF_CALL_SIGNATURE(BaselineSupercallspreadImm8V8)
1027{
1028    // 5 : 5 input parameters
1029    CallSignature signature("BaselineSupercallspreadImm8V8", 0, 5,
1030        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1031    *callSign = signature;
1032    // 5 : 5 input parameters
1033    std::array<VariableType, 5> params = {
1034        VariableType::NATIVE_POINTER(),
1035        VariableType::NATIVE_POINTER(),
1036        VariableType::JS_ANY(),
1037        VariableType::JS_ANY(),
1038        VariableType::INT32(),
1039    };
1040    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1041}
1042
1043DEF_CALL_SIGNATURE(BaselineCallRuntimeSupercallforwardallargsPrefV8)
1044{
1045    // 3 : 3 input parameters
1046    CallSignature signature("BaselineCallRuntimeSupercallforwardallargsPrefV8", 0, 3,
1047        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1048    *callSign = signature;
1049    // 3 : 3 input parameters
1050    std::array<VariableType, 3> params = {
1051        VariableType::NATIVE_POINTER(),
1052        VariableType::NATIVE_POINTER(),
1053        VariableType::INT32(),
1054    };
1055    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1056}
1057
1058DEF_CALL_SIGNATURE(BaselineApplyImm8V8V8)
1059{
1060    // 5 : 5 input parameters
1061    CallSignature signature("BaselineApplyImm8V8V8", 0, 5,
1062        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1063    *callSign = signature;
1064    // 5 : 5 input parameters
1065    std::array<VariableType, 5> params = {
1066        VariableType::NATIVE_POINTER(),
1067        VariableType::NATIVE_POINTER(),
1068        VariableType::JS_ANY(),
1069        VariableType::JS_ANY(),
1070        VariableType::JS_ANY(),
1071    };
1072    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1073}
1074
1075DEF_CALL_SIGNATURE(BaselineCallargs2Imm8V8V8)
1076{
1077    // 5 : 5 input parameters
1078    CallSignature signature("BaselineCallargs2Imm8V8V8", 0, 5,
1079        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1080    *callSign = signature;
1081    // 5 : 5 input parameters
1082    std::array<VariableType, 5> params = {
1083        VariableType::NATIVE_POINTER(),
1084        VariableType::NATIVE_POINTER(),
1085        VariableType::INT32(),
1086        VariableType::INT32(),
1087        VariableType::INT32(),
1088    };
1089    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1090}
1091
1092DEF_CALL_SIGNATURE(BaselineCallargs3Imm8V8V8V8)
1093{
1094    // 6 : 6 input parameters
1095    CallSignature signature("BaselineCallargs3Imm8V8V8V8", 0, 6,
1096        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1097    *callSign = signature;
1098    // 6 : 6 input parameters
1099    std::array<VariableType, 6> params = {
1100        VariableType::NATIVE_POINTER(),
1101        VariableType::NATIVE_POINTER(),
1102        VariableType::INT32(),
1103        VariableType::INT32(),
1104        VariableType::INT32(),
1105        VariableType::INT32(),
1106    };
1107    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1108}
1109
1110DEF_CALL_SIGNATURE(BaselineCallrangeImm8Imm8V8)
1111{
1112    // 5 : 5 input parameters
1113    CallSignature signature("BaselineCallrangeImm8Imm8V8", 0, 5,
1114        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1115    *callSign = signature;
1116    // 5 : 5 input parameters
1117    std::array<VariableType, 5> params = {
1118        VariableType::NATIVE_POINTER(),
1119        VariableType::NATIVE_POINTER(),
1120        VariableType::INT32(),
1121        VariableType::INT32(),
1122        VariableType::INT32(),
1123    };
1124    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1125}
1126
1127DEF_CALL_SIGNATURE(BaselineLdexternalmodulevarImm8)
1128{
1129    // 2 : 2 input parameters
1130    CallSignature signature("BaselineLdexternalmodulevarImm8", 0, 2,
1131        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1132    *callSign = signature;
1133    // 2 : 2 input parameters
1134    std::array<VariableType, 2> params = {
1135        VariableType::NATIVE_POINTER(),
1136        VariableType::INT8(),
1137    };
1138    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1139}
1140
1141DEF_CALL_SIGNATURE(BaselineLdthisbynameImm8Id16)
1142{
1143    // 4 : 4 input parameters
1144    CallSignature signature("BaselineLdthisbynameImm8Id16", 0, 4,
1145        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1146    *callSign = signature;
1147    // 4 : 4 input parameters
1148    std::array<VariableType, 4> params = {
1149        VariableType::NATIVE_POINTER(),
1150        VariableType::NATIVE_POINTER(),
1151        VariableType::INT32(),
1152        VariableType::INT32(),
1153    };
1154    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1155}
1156
1157DEF_CALL_SIGNATURE(BaselineDefinegettersetterbyvalueV8V8V8V8)
1158{
1159    // 4 : 4 input parameters
1160    CallSignature signature("BaselineDefinegettersetterbyvalueV8V8V8V8", 0, 4,
1161        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1162    *callSign = signature;
1163    // 4 : 4 input parameters
1164    std::array<VariableType, 4> params = {
1165        VariableType::NATIVE_POINTER(),
1166        VariableType::NATIVE_POINTER(),
1167        VariableType::INT32(),
1168        VariableType::INT32(),
1169    };
1170    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1171}
1172
1173DEF_CALL_SIGNATURE(BaselineLdthisbynameImm16Id16)
1174{
1175    // 4 : 4 input parameters
1176    CallSignature signature("BaselineLdthisbynameImm16Id16", 0, 4,
1177        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1178    *callSign = signature;
1179    // 4 : 4 input parameters
1180    std::array<VariableType, 4> params = {
1181        VariableType::NATIVE_POINTER(),
1182        VariableType::NATIVE_POINTER(),
1183        VariableType::INT32(),
1184        VariableType::INT32(),
1185    };
1186    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1187}
1188
1189DEF_CALL_SIGNATURE(BaselineStthisbynameImm8Id16)
1190{
1191    // 4 : 4 input parameters
1192    CallSignature signature("BaselineStthisbynameImm8Id16", 0, 4,
1193        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1194    *callSign = signature;
1195    // 4 : 4 input parameters
1196    std::array<VariableType, 4> params = {
1197        VariableType::NATIVE_POINTER(),
1198        VariableType::NATIVE_POINTER(),
1199        VariableType::INT32(),
1200        VariableType::INT32(),
1201    };
1202    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1203}
1204
1205DEF_CALL_SIGNATURE(BaselineStthisbynameImm16Id16)
1206{
1207    // 4 : 4 input parameters
1208    CallSignature signature("BaselineStthisbynameImm16Id16", 0, 4,
1209        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1210    *callSign = signature;
1211    // 4 : 4 input parameters
1212    std::array<VariableType, 4> params = {
1213        VariableType::NATIVE_POINTER(),
1214        VariableType::NATIVE_POINTER(),
1215        VariableType::INT32(),
1216        VariableType::INT32(),
1217    };
1218    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1219}
1220
1221DEF_CALL_SIGNATURE(BaselineLdthisbyvalueImm8)
1222{
1223    // 3 : 3 input parameters
1224    CallSignature signature("BaselineLdthisbyvalueImm8", 0, 3,
1225        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1226    *callSign = signature;
1227    // 3 : 3 input parameters
1228    std::array<VariableType, 3> params = {
1229        VariableType::NATIVE_POINTER(),
1230        VariableType::NATIVE_POINTER(),
1231        VariableType::INT32(),
1232    };
1233    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1234}
1235
1236DEF_CALL_SIGNATURE(BaselineLdthisbyvalueImm16)
1237{
1238    // 3 : 3 input parameters
1239    CallSignature signature("BaselineLdthisbyvalueImm16", 0, 3,
1240        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1241    *callSign = signature;
1242    // 3 : 3 input parameters
1243    std::array<VariableType, 3> params = {
1244        VariableType::NATIVE_POINTER(),
1245        VariableType::NATIVE_POINTER(),
1246        VariableType::INT32(),
1247    };
1248    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1249}
1250
1251DEF_CALL_SIGNATURE(BaselineStthisbyvalueImm8V8)
1252{
1253    // 4 : 4 input parameters
1254    CallSignature signature("BaselineStthisbyvalueImm8V8", 0, 4,
1255        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1256    *callSign = signature;
1257    // 4 : 4 input parameters
1258    std::array<VariableType, 4> params = {
1259        VariableType::NATIVE_POINTER(),
1260        VariableType::NATIVE_POINTER(),
1261        VariableType::INT32(),
1262        VariableType::JS_ANY(),
1263    };
1264    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1265}
1266
1267DEF_CALL_SIGNATURE(BaselineStthisbyvalueImm16V8)
1268{
1269    // 4 : 4 input parameters
1270    CallSignature signature("BaselineStthisbyvalueImm16V8", 0, 4,
1271        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1272    *callSign = signature;
1273    // 4 : 4 input parameters
1274    std::array<VariableType, 4> params = {
1275        VariableType::NATIVE_POINTER(),
1276        VariableType::NATIVE_POINTER(),
1277        VariableType::INT32(),
1278        VariableType::JS_ANY(),
1279    };
1280    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1281}
1282
1283DEF_CALL_SIGNATURE(BaselineDynamicimport)
1284{
1285    // 2 : 2 input parameters
1286    CallSignature signature("BaselineDynamicimport", 0, 2,
1287        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1288    *callSign = signature;
1289    // 2 : 2 input parameters
1290    std::array<VariableType, 2> params = {
1291        VariableType::NATIVE_POINTER(),
1292        VariableType::NATIVE_POINTER(),
1293    };
1294    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1295}
1296
1297DEF_CALL_SIGNATURE(BaselineDefineclasswithbufferImm8Id16Id16Imm16V8)
1298{
1299    // 6 : 6 input parameters
1300    CallSignature signature("BaselineDefineclasswithbufferImm8Id16Id16Imm16V8", 0, 6,
1301        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1302    *callSign = signature;
1303    // 6 : 6 input parameters
1304    std::array<VariableType, 6> params = {
1305        VariableType::NATIVE_POINTER(),
1306        VariableType::NATIVE_POINTER(),
1307        VariableType::INT16(),
1308        VariableType::INT16(),
1309        VariableType::INT16(),
1310        VariableType::INT8(),
1311    };
1312    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1313}
1314
1315DEF_CALL_SIGNATURE(BaselineDefineclasswithbufferImm16Id16Id16Imm16V8)
1316{
1317    // 5 : 5 input parameters
1318    CallSignature signature("BaselineDefineclasswithbufferImm16Id16Id16Imm16V8", 0, 5,
1319        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1320    *callSign = signature;
1321    // 5 : 5 input parameters
1322    std::array<VariableType, 5> params = {
1323        VariableType::NATIVE_POINTER(),
1324        VariableType::NATIVE_POINTER(),
1325        VariableType::INT32(),
1326        VariableType::INT32(),
1327        VariableType::INT32(),
1328    };
1329    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1330}
1331
1332DEF_CALL_SIGNATURE(BaselineResumegenerator)
1333{
1334    // 3 : 3 input parameters
1335    CallSignature signature("BaselineResumegenerator", 0, 3,
1336        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1337    *callSign = signature;
1338    // 3 : 3 input parameters
1339    std::array<VariableType, 3> params = {
1340        VariableType::NATIVE_POINTER(),
1341        VariableType::NATIVE_POINTER(),
1342        VariableType::JS_ANY(),
1343    };
1344    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1345}
1346
1347DEF_CALL_SIGNATURE(BaselineGetresumemod)
1348{
1349    // 1 : 1 input parameters
1350    CallSignature signature("BaselineGetresumemod", 0, 1,
1351        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1352    *callSign = signature;
1353    // 1 : 1 input parameters
1354    std::array<VariableType, 1> params = {
1355        VariableType::JS_ANY(),
1356    };
1357    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1358}
1359
1360DEF_CALL_SIGNATURE(BaselineGettemplateobjectImm8)
1361{
1362    // 3 : 3 input parameters
1363    CallSignature signature("BaselineGettemplateobjectImm8", 0, 3,
1364        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1365    *callSign = signature;
1366    // 3 : 3 input parameters
1367    std::array<VariableType, 3> params = {
1368        VariableType::NATIVE_POINTER(),
1369        VariableType::NATIVE_POINTER(),
1370        VariableType::JS_ANY(),
1371    };
1372    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1373}
1374
1375DEF_CALL_SIGNATURE(BaselineGettemplateobjectImm16)
1376{
1377    // 3 : 3 input parameters
1378    CallSignature signature("BaselineGettemplateobjectImm16", 0, 3,
1379        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1380    *callSign = signature;
1381    // 3 : 3 input parameters
1382    std::array<VariableType, 3> params = {
1383        VariableType::NATIVE_POINTER(),
1384        VariableType::NATIVE_POINTER(),
1385        VariableType::JS_ANY(),
1386    };
1387    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1388}
1389
1390DEF_CALL_SIGNATURE(BaselineGetnextpropnameV8)
1391{
1392    // 3 : 3 input parameters
1393    CallSignature signature("BaselineGetnextpropnameV8", 0, 3,
1394        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1395    *callSign = signature;
1396    // 3 : 3 input parameters
1397    std::array<VariableType, 3> params = {
1398        VariableType::NATIVE_POINTER(),
1399        VariableType::NATIVE_POINTER(),
1400        VariableType::JS_ANY(),
1401    };
1402    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1403}
1404
1405DEF_CALL_SIGNATURE(BaselineSetobjectwithprotoImm8V8)
1406{
1407    // 4 : 4 input parameters
1408    CallSignature signature("BaselineSetobjectwithprotoImm8V8", 0, 4,
1409        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1410    *callSign = signature;
1411    // 4 : 4 input parameters
1412    std::array<VariableType, 4> params = {
1413        VariableType::NATIVE_POINTER(),
1414        VariableType::NATIVE_POINTER(),
1415        VariableType::JS_ANY(),
1416        VariableType::JS_ANY(),
1417    };
1418    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1419}
1420
1421DEF_CALL_SIGNATURE(BaselineDelobjpropV8)
1422{
1423    // 4 : 4 input parameters
1424    CallSignature signature("BaselineDelobjpropV8", 0, 4,
1425        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1426    *callSign = signature;
1427    // 4 : 4 input parameters
1428    std::array<VariableType, 4> params = {
1429        VariableType::NATIVE_POINTER(),
1430        VariableType::NATIVE_POINTER(),
1431        VariableType::JS_ANY(),
1432        VariableType::JS_ANY(),
1433    };
1434    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1435}
1436
1437DEF_CALL_SIGNATURE(BaselineAsyncfunctionawaituncaughtV8)
1438{
1439    // 4 : 4 input parameters
1440    CallSignature signature("BaselineAsyncfunctionawaituncaughtV8", 0, 4,
1441        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1442    *callSign = signature;
1443    // 4 : 4 input parameters
1444    std::array<VariableType, 4> params = {
1445        VariableType::NATIVE_POINTER(),
1446        VariableType::NATIVE_POINTER(),
1447        VariableType::JS_ANY(),
1448        VariableType::JS_ANY(),
1449    };
1450    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1451}
1452
1453DEF_CALL_SIGNATURE(BaselineCopydatapropertiesV8)
1454{
1455    // 4 : 4 input parameters
1456    CallSignature signature("BaselineCopydatapropertiesV8", 0, 4,
1457        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1458    *callSign = signature;
1459    // 4 : 4 input parameters
1460    std::array<VariableType, 4> params = {
1461        VariableType::NATIVE_POINTER(),
1462        VariableType::NATIVE_POINTER(),
1463        VariableType::JS_ANY(),
1464        VariableType::JS_ANY(),
1465    };
1466    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1467}
1468
1469DEF_CALL_SIGNATURE(BaselineStarrayspreadV8V8)
1470{
1471    // 5 : 5 input parameters
1472    CallSignature signature("BaselineStarrayspreadV8V8", 0, 5,
1473        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1474    *callSign = signature;
1475    // 5 : 5 input parameters
1476    std::array<VariableType, 5> params = {
1477        VariableType::NATIVE_POINTER(),
1478        VariableType::NATIVE_POINTER(),
1479        VariableType::JS_ANY(),
1480        VariableType::JS_ANY(),
1481        VariableType::JS_ANY(),
1482    };
1483    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1484}
1485
1486DEF_CALL_SIGNATURE(BaselineSetobjectwithprotoImm16V8)
1487{
1488    // 4 : 4 input parameters
1489    CallSignature signature("BaselineSetobjectwithprotoImm16V8", 0, 4,
1490        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1491    *callSign = signature;
1492    // 4 : 4 input parameters
1493    std::array<VariableType, 4> params = {
1494        VariableType::NATIVE_POINTER(),
1495        VariableType::NATIVE_POINTER(),
1496        VariableType::JS_ANY(),
1497        VariableType::JS_ANY(),
1498    };
1499    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1500}
1501
1502DEF_CALL_SIGNATURE(BaselineLdobjbyvalueImm8V8)
1503{
1504    // 4 : 4 input parameters
1505    CallSignature signature("BaselineLdobjbyvalueImm8V8", 0, 4,
1506        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1507    *callSign = signature;
1508    // 4 : 4 input parameters
1509    std::array<VariableType, 4> params = {
1510        VariableType::NATIVE_POINTER(),
1511        VariableType::NATIVE_POINTER(),
1512        VariableType::JS_ANY(),
1513        VariableType::INT32(),
1514    };
1515    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1516}
1517
1518DEF_CALL_SIGNATURE(BaselineLdobjbyvalueImm16V8)
1519{
1520    // 4 : 4 input parameters
1521    CallSignature signature("BaselineLdobjbyvalueImm16V8", 0, 4,
1522        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1523    *callSign = signature;
1524    // 4 : 4 input parameters
1525    std::array<VariableType, 4> params = {
1526        VariableType::NATIVE_POINTER(),
1527        VariableType::NATIVE_POINTER(),
1528        VariableType::JS_ANY(),
1529        VariableType::INT32(),
1530    };
1531    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1532}
1533
1534DEF_CALL_SIGNATURE(BaselineStobjbyvalueImm8V8V8)
1535{
1536    // 5 : 5 input parameters
1537    CallSignature signature("BaselineStobjbyvalueImm8V8V8", 0, 5,
1538        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1539    *callSign = signature;
1540    // 5 : 5 input parameters
1541    std::array<VariableType, 5> params = {
1542        VariableType::NATIVE_POINTER(),
1543        VariableType::NATIVE_POINTER(),
1544        VariableType::JS_ANY(),
1545        VariableType::INT32(),
1546        VariableType::JS_ANY(),
1547    };
1548    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1549}
1550
1551DEF_CALL_SIGNATURE(BaselineStobjbyvalueImm16V8V8)
1552{
1553    // 5 : 5 input parameters
1554    CallSignature signature("BaselineStobjbyvalueImm16V8V8", 0, 5,
1555        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1556    *callSign = signature;
1557    // 5 : 5 input parameters
1558    std::array<VariableType, 5> params = {
1559        VariableType::NATIVE_POINTER(),
1560        VariableType::NATIVE_POINTER(),
1561        VariableType::JS_ANY(),
1562        VariableType::INT32(),
1563        VariableType::JS_ANY(),
1564    };
1565    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1566}
1567
1568DEF_CALL_SIGNATURE(BaselineStownbyvalueImm8V8V8)
1569{
1570    // 5 : 5 input parameters
1571    CallSignature signature("BaselineStownbyvalueImm8V8V8", 0, 5,
1572        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1573    *callSign = signature;
1574    // 5 : 5 input parameters
1575    std::array<VariableType, 5> params = {
1576        VariableType::NATIVE_POINTER(),
1577        VariableType::NATIVE_POINTER(),
1578        VariableType::INT32(),
1579        VariableType::INT32(),
1580        VariableType::INT32(),
1581    };
1582    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1583}
1584
1585DEF_CALL_SIGNATURE(BaselineStownbyvalueImm16V8V8)
1586{
1587    // 5 : 5 input parameters
1588    CallSignature signature("BaselineStownbyvalueImm16V8V8", 0, 5,
1589        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1590    *callSign = signature;
1591    // 5 : 5 input parameters
1592    std::array<VariableType, 5> params = {
1593        VariableType::NATIVE_POINTER(),
1594        VariableType::NATIVE_POINTER(),
1595        VariableType::JS_ANY(),
1596        VariableType::JS_ANY(),
1597        VariableType::INT32(),
1598    };
1599    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1600}
1601
1602DEF_CALL_SIGNATURE(BaselineLdsuperbyvalueImm8V8)
1603{
1604    // 4 : 4 input parameters
1605    CallSignature signature("BaselineLdsuperbyvalueImm8V8", 0, 4,
1606        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1607    *callSign = signature;
1608    // 4 : 4 input parameters
1609    std::array<VariableType, 4> params = {
1610        VariableType::NATIVE_POINTER(),
1611        VariableType::NATIVE_POINTER(),
1612        VariableType::JS_ANY(),
1613        VariableType::JS_ANY(),
1614    };
1615    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1616}
1617
1618DEF_CALL_SIGNATURE(BaselineLdsuperbyvalueImm16V8)
1619{
1620    // 4 : 4 input parameters
1621    CallSignature signature("BaselineLdsuperbyvalueImm16V8", 0, 4,
1622        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1623    *callSign = signature;
1624    // 4 : 4 input parameters
1625    std::array<VariableType, 4> params = {
1626        VariableType::NATIVE_POINTER(),
1627        VariableType::NATIVE_POINTER(),
1628        VariableType::JS_ANY(),
1629        VariableType::JS_ANY(),
1630    };
1631    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1632}
1633
1634DEF_CALL_SIGNATURE(BaselineStsuperbyvalueImm8V8V8)
1635{
1636    // 4 : 4 input parameters
1637    CallSignature signature("BaselineStsuperbyvalueImm8V8V8", 0, 4,
1638        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1639    *callSign = signature;
1640    // 4 : 4 input parameters
1641    std::array<VariableType, 4> params = {
1642        VariableType::NATIVE_POINTER(),
1643        VariableType::NATIVE_POINTER(),
1644        VariableType::JS_ANY(),
1645        VariableType::JS_ANY(),
1646    };
1647    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1648}
1649
1650DEF_CALL_SIGNATURE(BaselineStsuperbyvalueImm16V8V8)
1651{
1652    // 4 : 4 input parameters
1653    CallSignature signature("BaselineStsuperbyvalueImm16V8V8", 0, 4,
1654        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1655    *callSign = signature;
1656    // 4 : 4 input parameters
1657    std::array<VariableType, 4> params = {
1658        VariableType::NATIVE_POINTER(),
1659        VariableType::NATIVE_POINTER(),
1660        VariableType::JS_ANY(),
1661        VariableType::JS_ANY(),
1662    };
1663    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1664}
1665
1666DEF_CALL_SIGNATURE(BaselineLdobjbyindexImm8Imm16)
1667{
1668    // 4 : 4 input parameters
1669    CallSignature signature("BaselineLdobjbyindexImm8Imm16", 0, 4,
1670        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1671    *callSign = signature;
1672    // 4 : 4 input parameters
1673    std::array<VariableType, 4> params = {
1674        VariableType::NATIVE_POINTER(),
1675        VariableType::NATIVE_POINTER(),
1676        VariableType::INT32(),
1677        VariableType::INT32(),
1678    };
1679    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1680}
1681
1682DEF_CALL_SIGNATURE(BaselineLdobjbyindexImm16Imm16)
1683{
1684    // 4 : 4 input parameters
1685    CallSignature signature("BaselineLdobjbyindexImm16Imm16", 0, 4,
1686        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1687    *callSign = signature;
1688    // 4 : 4 input parameters
1689    std::array<VariableType, 4> params = {
1690        VariableType::NATIVE_POINTER(),
1691        VariableType::NATIVE_POINTER(),
1692        VariableType::INT32(),
1693        VariableType::INT32(),
1694    };
1695    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1696}
1697
1698DEF_CALL_SIGNATURE(BaselineStobjbyindexImm8V8Imm16)
1699{
1700    // 4 : 4 input parameters
1701    CallSignature signature("BaselineStobjbyindexImm8V8Imm16", 0, 4,
1702        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1703    *callSign = signature;
1704    // 4 : 4 input parameters
1705    std::array<VariableType, 4> params = {
1706        VariableType::NATIVE_POINTER(),
1707        VariableType::NATIVE_POINTER(),
1708        VariableType::JS_ANY(),
1709        VariableType::INT32(),
1710    };
1711    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1712}
1713
1714DEF_CALL_SIGNATURE(BaselineStobjbyindexImm16V8Imm16)
1715{
1716    // 5 : 5 input parameters
1717    CallSignature signature("BaselineStobjbyindexImm16V8Imm16", 0, 5,
1718        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1719    *callSign = signature;
1720    // 5 : 5 input parameters
1721    std::array<VariableType, 5> params = {
1722        VariableType::NATIVE_POINTER(),
1723        VariableType::NATIVE_POINTER(),
1724        VariableType::JS_ANY(),
1725        VariableType::INT32(),
1726        VariableType::INT32(),
1727    };
1728    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1729}
1730
1731DEF_CALL_SIGNATURE(BaselineStownbyindexImm8V8Imm16)
1732{
1733    // 5 : 5 input parameters
1734    CallSignature signature("BaselineStownbyindexImm8V8Imm16", 0, 5,
1735        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1736    *callSign = signature;
1737    // 5 : 5 input parameters
1738    std::array<VariableType, 5> params = {
1739        VariableType::NATIVE_POINTER(),
1740        VariableType::NATIVE_POINTER(),
1741        VariableType::JS_ANY(),
1742        VariableType::INT32(),
1743        VariableType::INT32(),
1744    };
1745    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1746}
1747
1748DEF_CALL_SIGNATURE(BaselineStownbyindexImm16V8Imm16)
1749{
1750    // 5 : 5 input parameters
1751    CallSignature signature("BaselineStownbyindexImm16V8Imm16", 0, 5,
1752        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1753    *callSign = signature;
1754    // 5 : 5 input parameters
1755    std::array<VariableType, 5> params = {
1756        VariableType::NATIVE_POINTER(),
1757        VariableType::NATIVE_POINTER(),
1758        VariableType::JS_ANY(),
1759        VariableType::INT32(),
1760        VariableType::INT32(),
1761    };
1762    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1763}
1764
1765DEF_CALL_SIGNATURE(BaselineAsyncfunctionresolveV8)
1766{
1767    // 4 : 4 input parameters
1768    CallSignature signature("BaselineAsyncfunctionresolveV8", 0, 4,
1769        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1770    *callSign = signature;
1771    // 4 : 4 input parameters
1772    std::array<VariableType, 4> params = {
1773        VariableType::NATIVE_POINTER(),
1774        VariableType::NATIVE_POINTER(),
1775        VariableType::JS_ANY(),
1776        VariableType::JS_ANY(),
1777    };
1778    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1779}
1780
1781DEF_CALL_SIGNATURE(BaselineAsyncfunctionrejectV8)
1782{
1783    // 4 : 4 input parameters
1784    CallSignature signature("BaselineAsyncfunctionrejectV8", 0, 4,
1785        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1786    *callSign = signature;
1787    // 4 : 4 input parameters
1788    std::array<VariableType, 4> params = {
1789        VariableType::NATIVE_POINTER(),
1790        VariableType::NATIVE_POINTER(),
1791        VariableType::JS_ANY(),
1792        VariableType::JS_ANY(),
1793    };
1794    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1795}
1796
1797DEF_CALL_SIGNATURE(BaselineCopyrestargsImm8)
1798{
1799    // 4 : 4 input parameters
1800    CallSignature signature("BaselineCopyrestargsImm8", 0, 4,
1801        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1802    *callSign = signature;
1803    // 4 : 4 input parameters
1804    std::array<VariableType, 4> params = {
1805        VariableType::NATIVE_POINTER(),
1806        VariableType::NATIVE_POINTER(),
1807        VariableType::JS_ANY(),
1808        VariableType::INT32(),
1809    };
1810    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1811}
1812
1813DEF_CALL_SIGNATURE(BaselineLdlexvarImm4Imm4)
1814{
1815    // 3 : 3 input parameters
1816    CallSignature signature("BaselineLdlexvarImm4Imm4", 0, 3,
1817        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1818    *callSign = signature;
1819    // 3 : 3 input parameters
1820    std::array<VariableType, 3> params = {
1821        VariableType::NATIVE_POINTER(),
1822        VariableType::INT32(),
1823        VariableType::INT32(),
1824    };
1825    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1826}
1827
1828DEF_CALL_SIGNATURE(BaselineStlexvarImm4Imm4)
1829{
1830    // 5 : 5 input parameters
1831    CallSignature signature("BaselineStlexvarImm4Imm4", 0, 5,
1832        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1833    *callSign = signature;
1834    // 5 : 5 input parameters
1835    std::array<VariableType, 5> params = {
1836        VariableType::NATIVE_POINTER(),
1837        VariableType::NATIVE_POINTER(),
1838        VariableType::JS_ANY(),
1839        VariableType::INT32(),
1840        VariableType::INT32(),
1841    };
1842    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1843}
1844
1845DEF_CALL_SIGNATURE(BaselineGetmodulenamespaceImm8)
1846{
1847    // 2 : 2 input parameters
1848    CallSignature signature("BaselineGetmodulenamespaceImm8", 0, 2,
1849        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1850    *callSign = signature;
1851    // 2 : 2 input parameters
1852    std::array<VariableType, 2> params = {
1853        VariableType::NATIVE_POINTER(),
1854        VariableType::INT32(),
1855    };
1856    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1857}
1858
1859DEF_CALL_SIGNATURE(BaselineStmodulevarImm8)
1860{
1861    // 3 : 3 input parameters
1862    CallSignature signature("BaselineStmodulevarImm8", 0, 3,
1863        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1864    *callSign = signature;
1865    // 3 : 3 input parameters
1866    std::array<VariableType, 3> params = {
1867        VariableType::NATIVE_POINTER(),
1868        VariableType::JS_ANY(),
1869        VariableType::INT8(),
1870    };
1871    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1872}
1873
1874DEF_CALL_SIGNATURE(BaselineTrystglobalbynameImm8Id16)
1875{
1876    // 4 : 4 input parameters
1877    CallSignature signature("BaselineTrystglobalbynameImm8Id16", 0, 4,
1878        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1879    *callSign = signature;
1880    // 4 : 4 input parameters
1881    std::array<VariableType, 4> params = {
1882        VariableType::NATIVE_POINTER(),
1883        VariableType::NATIVE_POINTER(),
1884        VariableType::INT32(),
1885        VariableType::INT32(),
1886    };
1887    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1888}
1889
1890DEF_CALL_SIGNATURE(BaselineTryldglobalbynameImm16Id16)
1891{
1892    // 4 : 4 input parameters
1893    CallSignature signature("BaselineTryldglobalbynameImm16Id16", 0, 4,
1894        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1895    *callSign = signature;
1896    // 4 : 4 input parameters
1897    std::array<VariableType, 4> params = {
1898        VariableType::NATIVE_POINTER(),
1899        VariableType::NATIVE_POINTER(),
1900        VariableType::INT32(),
1901        VariableType::INT32(),
1902    };
1903    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1904}
1905
1906DEF_CALL_SIGNATURE(BaselineTrystglobalbynameImm16Id16)
1907{
1908    // 4 : 4 input parameters
1909    CallSignature signature("BaselineTrystglobalbynameImm16Id16", 0, 4,
1910        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1911    *callSign = signature;
1912    // 4 : 4 input parameters
1913    std::array<VariableType, 4> params = {
1914        VariableType::NATIVE_POINTER(),
1915        VariableType::NATIVE_POINTER(),
1916        VariableType::INT32(),
1917        VariableType::INT32(),
1918    };
1919    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1920}
1921
1922DEF_CALL_SIGNATURE(BaselineLdglobalvarImm16Id16)
1923{
1924    // 4 : 4 input parameters
1925    CallSignature signature("BaselineLdglobalvarImm16Id16", 0, 4,
1926        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1927    *callSign = signature;
1928    // 4 : 4 input parameters
1929    std::array<VariableType, 4> params = {
1930        VariableType::NATIVE_POINTER(),
1931        VariableType::NATIVE_POINTER(),
1932        VariableType::INT32(),
1933        VariableType::INT32(),
1934    };
1935    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1936}
1937
1938DEF_CALL_SIGNATURE(BaselineStglobalvarImm16Id16)
1939{
1940    // 5 : 5 input parameters
1941    CallSignature signature("BaselineStglobalvarImm16Id16", 0, 5,
1942        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1943    *callSign = signature;
1944    // 5 : 5 input parameters
1945    std::array<VariableType, 5> params = {
1946        VariableType::NATIVE_POINTER(),
1947        VariableType::NATIVE_POINTER(),
1948        VariableType::JS_ANY(),
1949        VariableType::INT32(),
1950        VariableType::INT32(),
1951    };
1952    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1953}
1954
1955DEF_CALL_SIGNATURE(BaselineLdobjbynameImm8Id16)
1956{
1957    // 4 : 4 input parameters
1958    CallSignature signature("BaselineLdobjbynameImm8Id16", 0, 4,
1959        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1960    *callSign = signature;
1961    // 4 : 4 input parameters
1962    std::array<VariableType, 4> params = {
1963        VariableType::NATIVE_POINTER(),
1964        VariableType::NATIVE_POINTER(),
1965        VariableType::INT32(),
1966        VariableType::INT32(),
1967    };
1968    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1969}
1970
1971DEF_CALL_SIGNATURE(BaselineLdobjbynameImm16Id16)
1972{
1973    // 4 : 4 input parameters
1974    CallSignature signature("BaselineLdobjbynameImm16Id16", 0, 4,
1975        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1976    *callSign = signature;
1977    // 4 : 4 input parameters
1978    std::array<VariableType, 4> params = {
1979        VariableType::NATIVE_POINTER(),
1980        VariableType::NATIVE_POINTER(),
1981        VariableType::INT32(),
1982        VariableType::INT32(),
1983    };
1984    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1985}
1986
1987DEF_CALL_SIGNATURE(BaselineStobjbynameImm8Id16V8)
1988{
1989    // 5 : 5 input parameters
1990    CallSignature signature("BaselineStobjbynameImm8Id16V8", 0, 5,
1991        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1992    *callSign = signature;
1993    // 5 : 5 input parameters
1994    std::array<VariableType, 5> params = {
1995        VariableType::NATIVE_POINTER(),
1996        VariableType::NATIVE_POINTER(),
1997        VariableType::INT32(),
1998        VariableType::INT32(),
1999        VariableType::JS_ANY(),
2000    };
2001    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2002}
2003
2004DEF_CALL_SIGNATURE(BaselineStobjbynameImm16Id16V8)
2005{
2006    // 5 : 5 input parameters
2007    CallSignature signature("BaselineStobjbynameImm16Id16V8", 0, 5,
2008        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2009    *callSign = signature;
2010    // 5 : 5 input parameters
2011    std::array<VariableType, 5> params = {
2012        VariableType::NATIVE_POINTER(),
2013        VariableType::NATIVE_POINTER(),
2014        VariableType::INT32(),
2015        VariableType::INT32(),
2016        VariableType::JS_ANY(),
2017    };
2018    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2019}
2020
2021DEF_CALL_SIGNATURE(BaselineStownbynameImm8Id16V8)
2022{
2023    // 5 : 5 input parameters
2024    CallSignature signature("BaselineStownbynameImm8Id16V8", 0, 5,
2025        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2026    *callSign = signature;
2027    // 5 : 5 input parameters
2028    std::array<VariableType, 5> params = {
2029        VariableType::NATIVE_POINTER(),
2030        VariableType::NATIVE_POINTER(),
2031        VariableType::INT32(),
2032        VariableType::INT32(),
2033        VariableType::INT32(),
2034    };
2035    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2036}
2037
2038DEF_CALL_SIGNATURE(BaselineStownbynameImm16Id16V8)
2039{
2040    // 5 : 5 input parameters
2041    CallSignature signature("BaselineStownbynameImm16Id16V8", 0, 5,
2042        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2043    *callSign = signature;
2044    // 5 : 5 input parameters
2045    std::array<VariableType, 5> params = {
2046        VariableType::NATIVE_POINTER(),
2047        VariableType::NATIVE_POINTER(),
2048        VariableType::JS_ANY(),
2049        VariableType::INT32(),
2050        VariableType::INT32(),
2051    };
2052    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2053}
2054
2055DEF_CALL_SIGNATURE(BaselineLdsuperbynameImm8Id16)
2056{
2057    // 3 : 3 input parameters
2058    CallSignature signature("BaselineLdsuperbynameImm8Id16", 0, 3,
2059        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2060    *callSign = signature;
2061    // 3 : 3 input parameters
2062    std::array<VariableType, 3> params = {
2063        VariableType::NATIVE_POINTER(),
2064        VariableType::NATIVE_POINTER(),
2065        VariableType::INT32(),
2066    };
2067    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2068}
2069
2070DEF_CALL_SIGNATURE(BaselineLdsuperbynameImm16Id16)
2071{
2072    // 3 : 3 input parameters
2073    CallSignature signature("BaselineLdsuperbynameImm16Id16", 0, 3,
2074        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2075    *callSign = signature;
2076    // 3 : 3 input parameters
2077    std::array<VariableType, 3> params = {
2078        VariableType::NATIVE_POINTER(),
2079        VariableType::NATIVE_POINTER(),
2080        VariableType::INT32(),
2081    };
2082    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2083}
2084
2085DEF_CALL_SIGNATURE(BaselineStsuperbynameImm8Id16V8)
2086{
2087    // 5 : 5 input parameters
2088    CallSignature signature("BaselineStsuperbynameImm8Id16V8", 0, 5,
2089        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2090    *callSign = signature;
2091    // 5 : 5 input parameters
2092    std::array<VariableType, 5> params = {
2093        VariableType::NATIVE_POINTER(),
2094        VariableType::NATIVE_POINTER(),
2095        VariableType::JS_ANY(),
2096        VariableType::JS_ANY(),
2097        VariableType::INT32(),
2098    };
2099    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2100}
2101
2102DEF_CALL_SIGNATURE(BaselineStsuperbynameImm16Id16V8)
2103{
2104    // 5 : 5 input parameters
2105    CallSignature signature("BaselineStsuperbynameImm16Id16V8", 0, 5,
2106        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2107    *callSign = signature;
2108    // 5 : 5 input parameters
2109    std::array<VariableType, 5> params = {
2110        VariableType::NATIVE_POINTER(),
2111        VariableType::NATIVE_POINTER(),
2112        VariableType::JS_ANY(),
2113        VariableType::JS_ANY(),
2114        VariableType::INT32(),
2115    };
2116    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2117}
2118
2119DEF_CALL_SIGNATURE(BaselineLdlocalmodulevarImm8)
2120{
2121    // 2 : 2 input parameters
2122    CallSignature signature("BaselineLdlocalmodulevarImm8", 0, 2,
2123        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2124    *callSign = signature;
2125    // 2 : 2 input parameters
2126    std::array<VariableType, 2> params = {
2127        VariableType::NATIVE_POINTER(),
2128        VariableType::INT8(),
2129    };
2130    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2131}
2132
2133DEF_CALL_SIGNATURE(BaselineStconsttoglobalrecordImm16Id16)
2134{
2135    // 4 : 4 input parameters
2136    CallSignature signature("BaselineStconsttoglobalrecordImm16Id16", 0, 4,
2137        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2138    *callSign = signature;
2139    // 4 : 4 input parameters
2140    std::array<VariableType, 4> params = {
2141        VariableType::NATIVE_POINTER(),
2142        VariableType::NATIVE_POINTER(),
2143        VariableType::JS_ANY(),
2144        VariableType::INT32(),
2145    };
2146    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2147}
2148
2149// GLUE, ACC, RECEIVER, PROP_KEY
2150DEF_CALL_SIGNATURE(BaselineStownbyvaluewithnamesetImm8V8V8)
2151{
2152    // 5 : 5 input parameters
2153    CallSignature signature("BaselineStownbyvaluewithnamesetImm8V8V8", 0, 5,
2154        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2155    *callSign = signature;
2156    // 5 : 5 input parameters
2157    std::array<VariableType, 5> params = {
2158        VariableType::NATIVE_POINTER(),
2159        VariableType::NATIVE_POINTER(),
2160        VariableType::INT32(),
2161        VariableType::INT32(),
2162        VariableType::INT32(),
2163    };
2164    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2165}
2166
2167// GLUE, ACC, RECEIVER, PROP_KEY
2168DEF_CALL_SIGNATURE(BaselineStownbyvaluewithnamesetImm16V8V8)
2169{
2170    // 5 : 5 input parameters
2171    CallSignature signature("BaselineStownbyvaluewithnamesetImm16V8V8", 0, 5,
2172        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2173    *callSign = signature;
2174    // 5 : 5 input parameters
2175    std::array<VariableType, 5> params = {
2176        VariableType::NATIVE_POINTER(),
2177        VariableType::NATIVE_POINTER(),
2178        VariableType::JS_ANY(),
2179        VariableType::JS_ANY(),
2180        VariableType::INT32(),
2181    };
2182    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2183}
2184
2185// GLUE, ACC, CONST_POOL, STRING_ID, RECEIVER
2186DEF_CALL_SIGNATURE(BaselineStownbynamewithnamesetImm8Id16V8)
2187{
2188    // 5 : 5 input parameters
2189    CallSignature signature("BaselineStownbynamewithnamesetImm8Id16V8", 0, 5,
2190        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2191    *callSign = signature;
2192    // 5 : 5 input parameters
2193    std::array<VariableType, 5> params = {
2194        VariableType::NATIVE_POINTER(),
2195        VariableType::NATIVE_POINTER(),
2196        VariableType::INT32(),
2197        VariableType::INT32(),
2198        VariableType::INT32(),
2199    };
2200    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2201}
2202
2203// GLUE, ACC, CONST_POOL, STRING_ID, RECEIVER
2204DEF_CALL_SIGNATURE(BaselineStownbynamewithnamesetImm16Id16V8)
2205{
2206    // 5 : 5 input parameters
2207    CallSignature signature("BaselineStownbynamewithnamesetImm16Id16V8", 0, 5,
2208        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2209    *callSign = signature;
2210    // 5 : 5 input parameters
2211    std::array<VariableType, 5> params = {
2212        VariableType::NATIVE_POINTER(),
2213        VariableType::NATIVE_POINTER(),
2214        VariableType::INT32(),
2215        VariableType::JS_ANY(),
2216        VariableType::INT32(),
2217    };
2218    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2219}
2220
2221// GLUE, CONST_POOL, STRING_ID
2222DEF_CALL_SIGNATURE(BaselineLdbigintId16)
2223{
2224    // 3 : 3 input parameters
2225    CallSignature signature("BaselineLdbigintId16", 0, 3,
2226        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2227    *callSign = signature;
2228    // 3 : 3 input parameters
2229    std::array<VariableType, 3> params = {
2230        VariableType::NATIVE_POINTER(),
2231        VariableType::NATIVE_POINTER(),
2232        VariableType::INT32(),
2233    };
2234    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2235}
2236
2237// IMM
2238DEF_CALL_SIGNATURE(BaselineFldaiImm64)
2239{
2240    // 1 : 1 input parameters
2241    CallSignature signature("BaselineFldaiImm64", 0, 1,
2242        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2243    *callSign = signature;
2244    // 1 : 1 input parameters
2245    std::array<VariableType, 1> params = {
2246        VariableType::INT64(),
2247    };
2248    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2249}
2250
2251// GLUE, ACC, SP, PC, CONST_POOL, PROFILE_TYPE_INFO, HOTNESS_COUNTER
2252DEF_CALL_SIGNATURE(BaselineReturn)
2253{
2254    // 3 : 3 input parameters
2255    CallSignature signature("BaselineReturn", 0, 3,
2256        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2257    *callSign = signature;
2258    // 3 : 3 input parameters
2259    std::array<VariableType, 3> params = {
2260        VariableType::NATIVE_POINTER(),
2261        VariableType::NATIVE_POINTER(),
2262        VariableType::INT32(),
2263    };
2264    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2265}
2266
2267
2268// ACC, LEVEL, SLOT, FRAME
2269DEF_CALL_SIGNATURE(BaselineLdlexvarImm8Imm8)
2270{
2271    // 3 : 3 input parameters
2272    CallSignature signature("BaselineLdlexvarImm8Imm8", 0, 3,
2273        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2274    *callSign = signature;
2275    // 3 : 3 input parameters
2276    std::array<VariableType, 3> params = {
2277        VariableType::INT32(),
2278        VariableType::INT32(),
2279        VariableType::NATIVE_POINTER(),
2280    };
2281    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2282}
2283
2284// GLUE, ACC, LEVEL, SLOT, FRAME
2285DEF_CALL_SIGNATURE(BaselineStlexvarImm8Imm8)
2286{
2287    // 5 : 5 input parameters
2288    CallSignature signature("BaselineStlexvarImm8Imm8", 0, 5,
2289        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2290    *callSign = signature;
2291    // 5 : 5 input parameters
2292    std::array<VariableType, 5> params = {
2293        VariableType::NATIVE_POINTER(),
2294        VariableType::JS_ANY(),
2295        VariableType::INT32(),
2296        VariableType::INT32(),
2297        VariableType::NATIVE_POINTER(),
2298    };
2299    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2300}
2301
2302// GLUE
2303DEF_CALL_SIGNATURE(BaselineJnstricteqV8Imm16)
2304{
2305    // 1 : 1 input parameters
2306    CallSignature signature("BaselineJnstricteqV8Imm16", 0, 1,
2307        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2308    *callSign = signature;
2309    // 1 : 1 input parameters
2310    std::array<VariableType, 1> params = {
2311        VariableType::NATIVE_POINTER(),
2312    };
2313    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2314}
2315
2316// GLUE, SP, ACC, V0
2317DEF_CALL_SIGNATURE(BaselineAsyncgeneratorrejectV8)
2318{
2319    // 4 : 4 input parameters
2320    CallSignature signature("BaselineAsyncgeneratorrejectV8", 0, 4,
2321        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2322    *callSign = signature;
2323    // 4 : 4 input parameters
2324    std::array<VariableType, 4> params = {
2325        VariableType::NATIVE_POINTER(),
2326        VariableType::NATIVE_POINTER(),
2327        VariableType::JS_ANY(),
2328        VariableType::INT8(),
2329    };
2330    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2331}
2332
2333// GLUE, ACC, INDEX
2334DEF_CALL_SIGNATURE(BaselineSetgeneratorstateImm8)
2335{
2336    // 3 : 3 input parameters
2337    CallSignature signature("BaselineSetgeneratorstateImm8", 0, 3,
2338        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2339    *callSign = signature;
2340    // 3 : 3 input parameters
2341    std::array<VariableType, 3> params = {
2342        VariableType::NATIVE_POINTER(),
2343        VariableType::JS_ANY(),
2344        VariableType::INT32(),
2345    };
2346    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2347}
2348
2349// GLUE, SP, ACC
2350DEF_CALL_SIGNATURE(BaselineGetasynciteratorImm8)
2351{
2352    // 3 : 3 input parameters
2353    CallSignature signature("BaselineGetasynciteratorImm8", 0, 3,
2354        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2355    *callSign = signature;
2356    // 3 : 3 input parameters
2357    std::array<VariableType, 3> params = {
2358        VariableType::NATIVE_POINTER(),
2359        VariableType::NATIVE_POINTER(),
2360        VariableType::JS_ANY(),
2361    };
2362    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2363}
2364
2365//  GLUE, SP, ACC, INDEX0, INDEX1, ENV
2366DEF_CALL_SIGNATURE(BaselineLdPrivatePropertyImm8Imm16Imm16)
2367{
2368    // 6 : 6 input parameters
2369    CallSignature signature("BaselineLdPrivatePropertyImm8Imm16Imm16", 0, 6,
2370        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2371    *callSign = signature;
2372    // 6 : 6 input parameters
2373    std::array<VariableType, 6> params = {
2374        VariableType::NATIVE_POINTER(),
2375        VariableType::NATIVE_POINTER(),
2376        VariableType::JS_ANY(),
2377        VariableType::INT32(),
2378        VariableType::INT32(),
2379        VariableType::JS_POINTER(),
2380    };
2381    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2382}
2383
2384// GLUE, SP, INDEX0, INDEX1, INDEX2
2385DEF_CALL_SIGNATURE(BaselineStPrivatePropertyImm8Imm16Imm16V8)
2386{
2387    // 5 : 5 input parameters
2388    CallSignature signature("BaselineStPrivatePropertyImm8Imm16Imm16V8", 0, 5,
2389        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2390    *callSign = signature;
2391    // 5 : 5 input parameters
2392    std::array<VariableType, 5> params = {
2393        VariableType::NATIVE_POINTER(),
2394        VariableType::NATIVE_POINTER(),
2395        VariableType::INT32(),
2396        VariableType::INT32(),
2397        VariableType::INT8(),
2398    };
2399    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2400}
2401
2402// GLUE, SP, ACC, INDEX0, INDEX1, ENV
2403DEF_CALL_SIGNATURE(BaselineTestInImm8Imm16Imm16)
2404{
2405    // 6 : 6 input parameters
2406    CallSignature signature("BaselineTestInImm8Imm16Imm16", 0, 6,
2407        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2408    *callSign = signature;
2409    // 6 : 6 input parameters
2410    std::array<VariableType, 6> params = {
2411        VariableType::NATIVE_POINTER(),
2412        VariableType::NATIVE_POINTER(),
2413        VariableType::JS_ANY(),
2414        VariableType::INT32(),
2415        VariableType::INT32(),
2416        VariableType::JS_POINTER(),
2417    };
2418    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2419}
2420
2421// SP
2422DEF_CALL_SIGNATURE(BaselineDeprecatedLdlexenvPrefNone)
2423{
2424    // 1 : 1 input parameters
2425    CallSignature signature("BaselineDeprecatedLdlexenvPrefNone", 0, 1,
2426        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2427    *callSign = signature;
2428    // 1 : 1 input parameters
2429    std::array<VariableType, 1> params = {
2430        VariableType::NATIVE_POINTER(),
2431    };
2432    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2433}
2434
2435// GLUE, SP, V0, V1, V2
2436DEF_CALL_SIGNATURE(BaselineWideCreateobjectwithexcludedkeysPrefImm16V8V8)
2437{
2438    // 5 : 5 input parameters
2439    CallSignature signature("BaselineWideCreateobjectwithexcludedkeysPrefImm16V8V8", 0, 5,
2440        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2441    *callSign = signature;
2442    // 5 : 5 input parameters
2443    std::array<VariableType, 5> params = {
2444        VariableType::NATIVE_POINTER(),
2445        VariableType::NATIVE_POINTER(),
2446        VariableType::INT16(),
2447        VariableType::INT8(),
2448        VariableType::INT16(),
2449    };
2450    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2451}
2452
2453// GLUE, SP, ACC
2454DEF_CALL_SIGNATURE(BaselineThrowPrefNone)
2455{
2456    // 3 : 3 input parameters
2457    CallSignature signature("BaselineThrowPrefNone", 0, 3,
2458        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2459    *callSign = signature;
2460    // 3 : 3 input parameters
2461    std::array<VariableType, 3> params = {
2462        VariableType::NATIVE_POINTER(),
2463        VariableType::NATIVE_POINTER(),
2464        VariableType::JS_ANY(),
2465    };
2466    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2467}
2468
2469// GLUE, SP
2470DEF_CALL_SIGNATURE(BaselineDeprecatedPoplexenvPrefNone)
2471{
2472    // 2 : 2 input parameters
2473    CallSignature signature("BaselineDeprecatedPoplexenvPrefNone", 0, 2,
2474        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2475    *callSign = signature;
2476    // 2 : 2 input parameters
2477    std::array<VariableType, 2> params = {
2478        VariableType::NATIVE_POINTER(),
2479        VariableType::NATIVE_POINTER(),
2480    };
2481    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2482}
2483
2484// GLUE, SP, NUM_ARGS, IDX, HOTNESS_COUNTER, SLOT_ID
2485DEF_CALL_SIGNATURE(BaselineWideNewobjrangePrefImm16V8)
2486{
2487    // 6 : 6 input parameters
2488    CallSignature signature("BaselineWideNewobjrangePrefImm16V8", 0, 6,
2489        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2490    *callSign = signature;
2491    /// 6 : 6 input parameters
2492    std::array<VariableType, 6> params = {
2493        VariableType::NATIVE_POINTER(),
2494        VariableType::NATIVE_POINTER(),
2495        VariableType::INT16(),
2496        VariableType::INT16(),
2497        VariableType::INT32(),
2498        VariableType::INT32(),
2499    };
2500    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2501}
2502
2503// GLUE, SP
2504DEF_CALL_SIGNATURE(BaselineThrowNotexistsPrefNone)
2505{
2506    // 2 : 2 input parameters
2507    CallSignature signature("BaselineThrowNotexistsPrefNone", 0, 2,
2508        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2509    *callSign = signature;
2510    // 2 : 2 input parameters
2511    std::array<VariableType, 2> params = {
2512        VariableType::NATIVE_POINTER(),
2513        VariableType::NATIVE_POINTER(),
2514    };
2515    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2516}
2517
2518// GLUE, SP, V0, V1
2519DEF_CALL_SIGNATURE(BaselineDeprecatedGetiteratornextPrefV8V8)
2520{
2521    // 4 : 4 input parameters
2522    CallSignature signature("BaselineDeprecatedGetiteratornextPrefV8V8", 0, 4,
2523        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2524    *callSign = signature;
2525    // 4 : 4 input parameters
2526    std::array<VariableType, 4> params = {
2527        VariableType::NATIVE_POINTER(),
2528        VariableType::NATIVE_POINTER(),
2529        VariableType::INT8(),
2530        VariableType::INT8(),
2531    };
2532    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2533}
2534
2535// GLUE, SP, ACC, NUM_VARS
2536DEF_CALL_SIGNATURE(BaselineWideNewlexenvPrefImm16)
2537{
2538    // 4 : 4 input parameters
2539    CallSignature signature("BaselineWideNewlexenvPrefImm16", 0, 4,
2540        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2541    *callSign = signature;
2542    // 4 : 4 input parameters
2543    std::array<VariableType, 4> params = {
2544        VariableType::NATIVE_POINTER(),
2545        VariableType::NATIVE_POINTER(),
2546        VariableType::JS_ANY(),
2547        VariableType::INT32(),
2548    };
2549    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2550}
2551
2552// GLUE, SP
2553DEF_CALL_SIGNATURE(BaselineThrowPatternnoncoerciblePrefNone)
2554{
2555    // 2 : 2 input parameters
2556    CallSignature signature("BaselineThrowPatternnoncoerciblePrefNone", 0, 2,
2557        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2558    *callSign = signature;
2559    // 2 : 2 input parameters
2560    std::array<VariableType, 2> params = {
2561        VariableType::NATIVE_POINTER(),
2562        VariableType::NATIVE_POINTER(),
2563    };
2564    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2565}
2566
2567// GLUE, IMM_I16, FUNC, SLOT_ID, PROFILE_TYPE_INFO, PC
2568DEF_CALL_SIGNATURE(BaselineDeprecatedCreatearraywithbufferPrefImm16)
2569{
2570    // 6 : 6 input parameters
2571    CallSignature signature("BaselineDeprecatedCreatearraywithbufferPrefImm16", 0, 6,
2572        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2573    *callSign = signature;
2574    /// 6 : 6 input parameters
2575    std::array<VariableType, 6> params = {
2576        VariableType::NATIVE_POINTER(),
2577        VariableType::NATIVE_POINTER(),
2578        VariableType::INT16(),
2579        VariableType::INT32(),
2580        VariableType::JS_POINTER(),
2581        VariableType::NATIVE_POINTER(),
2582    };
2583    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2584}
2585
2586// GLUE, SP, ACC, NUM_VARS, SCOPE_ID
2587DEF_CALL_SIGNATURE(BaselineWideNewlexenvwithnamePrefImm16Id16)
2588{
2589    // 5 : 5 input parameters
2590    CallSignature signature("BaselineWideNewlexenvwithnamePrefImm16Id16", 0, 5,
2591        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2592    *callSign = signature;
2593    // 5 : 5 input parameters
2594    std::array<VariableType, 5> params = {
2595        VariableType::NATIVE_POINTER(),
2596        VariableType::NATIVE_POINTER(),
2597        VariableType::JS_ANY(),
2598        VariableType::INT16(),
2599        VariableType::INT16(),
2600    };
2601    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2602}
2603
2604// GLUE, SP
2605DEF_CALL_SIGNATURE(BaselineThrowDeletesuperpropertyPrefNone)
2606{
2607    // 2 : 2 input parameters
2608    CallSignature signature("BaselineThrowDeletesuperpropertyPrefNone", 0, 2,
2609        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2610    *callSign = signature;
2611    // 2 : 2 input parameters
2612    std::array<VariableType, 2> params = {
2613        VariableType::NATIVE_POINTER(),
2614        VariableType::NATIVE_POINTER(),
2615    };
2616    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2617}
2618
2619// GLUE, IMM_I16, CONST_POOL, FRAME
2620DEF_CALL_SIGNATURE(BaselineDeprecatedCreateobjectwithbufferPrefImm16)
2621{
2622    // 3 : 3 input parameters
2623    CallSignature signature("BaselineDeprecatedCreateobjectwithbufferPrefImm16", 0, 3,
2624        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2625    *callSign = signature;
2626    // 3 : 3 input parameters
2627    std::array<VariableType, 3> params = {
2628        VariableType::NATIVE_POINTER(),
2629        VariableType::INT16(),
2630        VariableType::NATIVE_POINTER(),
2631    };
2632    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2633}
2634
2635DEF_CALL_SIGNATURE(BaselineNewobjrangeImm8Imm8V8)
2636{
2637    // 5 : 5 input parameters
2638    CallSignature signature("BaselineNewobjrangeImm8Imm8V8", 0, 5,
2639        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2640    *callSign = signature;
2641    // 5 : 5 input parameters
2642    std::array<VariableType, 5> params = {
2643        VariableType::NATIVE_POINTER(),
2644        VariableType::NATIVE_POINTER(),
2645        VariableType::INT32(),
2646        VariableType::INT32(),
2647        VariableType::INT32(),
2648    };
2649    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2650}
2651
2652DEF_CALL_SIGNATURE(BaselineNewobjrangeImm16Imm8V8)
2653{
2654    // 5 : 5 input parameters
2655    CallSignature signature("BaselineNewobjrangeImm16Imm8V8", 0, 5,
2656        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2657    *callSign = signature;
2658    // 5 : 5 input parameters
2659    std::array<VariableType, 5> params = {
2660        VariableType::NATIVE_POINTER(),
2661        VariableType::NATIVE_POINTER(),
2662        VariableType::INT16(),
2663        VariableType::INT16(),
2664        VariableType::INT32(),
2665    };
2666    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2667}
2668
2669// GLUE, SP, ACC, ACTUAL_NUM_ARGS, VREG_ID, HOTNESS_COUNTER
2670DEF_CALL_SIGNATURE(BaselineWideCallrangePrefImm16V8)
2671{
2672    // 6 : 6 input parameters
2673    CallSignature signature("BaselineWideCallrangePrefImm16V8", 0, 6,
2674        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2675    *callSign = signature;
2676    // 6 : 6 input parameters
2677    std::array<VariableType, 6> params = {
2678        VariableType::NATIVE_POINTER(),
2679        VariableType::NATIVE_POINTER(),
2680        VariableType::JS_ANY(),
2681        VariableType::INT32(),
2682        VariableType::INT8(),
2683        VariableType::INT32(),
2684    };
2685    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2686}
2687
2688// GLUE, SP, V0
2689DEF_CALL_SIGNATURE(BaselineThrowConstassignmentPrefV8)
2690{
2691    // 3 : 3 input parameters
2692    CallSignature signature("BaselineThrowConstassignmentPrefV8", 0, 3,
2693        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2694    *callSign = signature;
2695    // 3 : 3 input parameters
2696    std::array<VariableType, 3> params = {
2697        VariableType::NATIVE_POINTER(),
2698        VariableType::NATIVE_POINTER(),
2699        VariableType::JS_ANY(),
2700    };
2701    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2702}
2703
2704// GLUE, SP, V0
2705DEF_CALL_SIGNATURE(BaselineDeprecatedTonumberPrefV8)
2706{
2707    // 3 : 3 input parameters
2708    CallSignature signature("BaselineDeprecatedTonumberPrefV8", 0, 3,
2709        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2710    *callSign = signature;
2711    // 3 : 3 input parameters
2712    std::array<VariableType, 3> params = {
2713        VariableType::NATIVE_POINTER(),
2714        VariableType::NATIVE_POINTER(),
2715        VariableType::INT8(),
2716    };
2717    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2718}
2719
2720// GLUE, SP, ACC, ACTUAL_NUM_ARGS, VREG_ID, HOTNESS_COUNTER
2721DEF_CALL_SIGNATURE(BaselineWideCallthisrangePrefImm16V8)
2722{
2723    // 6 : 6 input parameters
2724    CallSignature signature("BaselineWideCallthisrangePrefImm16V8", 0, 6,
2725        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2726    *callSign = signature;
2727    // 6 : 6 input parameters
2728    std::array<VariableType, 6> params = {
2729        VariableType::NATIVE_POINTER(),
2730        VariableType::NATIVE_POINTER(),
2731        VariableType::JS_ANY(),
2732        VariableType::INT32(),
2733        VariableType::INT8(),
2734        VariableType::INT32(),
2735    };
2736    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2737}
2738
2739// GLUE, SP, V0
2740DEF_CALL_SIGNATURE(BaselineThrowIfnotobjectPrefV8)
2741{
2742    // 3 : 3 input parameters
2743    CallSignature signature("BaselineThrowIfnotobjectPrefV8", 0, 3,
2744        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2745    *callSign = signature;
2746    // 3 : 3 input parameters
2747    std::array<VariableType, 3> params = {
2748        VariableType::NATIVE_POINTER(),
2749        VariableType::NATIVE_POINTER(),
2750        VariableType::JS_ANY(),
2751    };
2752    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2753}
2754
2755// GLUE, SP, V0
2756DEF_CALL_SIGNATURE(BaselineDeprecatedTonumericPrefV8)
2757{
2758    // 3 : 3 input parameters
2759    CallSignature signature("BaselineDeprecatedTonumericPrefV8", 0, 3,
2760        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2761    *callSign = signature;
2762    // 3 : 3 input parameters
2763    std::array<VariableType, 3> params = {
2764        VariableType::NATIVE_POINTER(),
2765        VariableType::NATIVE_POINTER(),
2766        VariableType::INT8(),
2767    };
2768    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2769}
2770
2771
2772// GLUE, SP, RANGE, V0
2773DEF_CALL_SIGNATURE(BaselineWideSupercallthisrangePrefImm16V8)
2774{
2775    // 4 : 4 input parameters
2776    CallSignature signature("BaselineWideSupercallthisrangePrefImm16V8", 0, 4,
2777        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2778    *callSign = signature;
2779    // 4 : 4 input parameters
2780    std::array<VariableType, 4> params = {
2781        VariableType::NATIVE_POINTER(),
2782        VariableType::NATIVE_POINTER(),
2783        VariableType::INT16(),
2784        VariableType::INT16(),
2785    };
2786    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2787}
2788
2789// GLUE, SP, V0, V1
2790DEF_CALL_SIGNATURE(BaselineThrowUndefinedifholePrefV8V8)
2791{
2792    // 4 : 4 input parameters
2793    CallSignature signature("BaselineThrowUndefinedifholePrefV8V8", 0, 4,
2794        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2795    *callSign = signature;
2796    // 4 : 4 input parameters
2797    std::array<VariableType, 4> params = {
2798        VariableType::NATIVE_POINTER(),
2799        VariableType::NATIVE_POINTER(),
2800        VariableType::INT8(),
2801        VariableType::INT8(),
2802    };
2803    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2804}
2805
2806// GLUE, CONST_POOL, STRING_ID
2807DEF_CALL_SIGNATURE(BaselineThrowUndefinedifholewithnamePrefId16)
2808{
2809    // 3 : 3 input parameters
2810    CallSignature signature("BaselineThrowUndefinedifholewithnamePrefId16", 0, 3,
2811        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2812    *callSign = signature;
2813    // 3 : 3 input parameters
2814    std::array<VariableType, 3> params = {
2815        VariableType::NATIVE_POINTER(),
2816        VariableType::NATIVE_POINTER(),
2817        VariableType::INT32(),
2818    };
2819    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2820}
2821
2822// GLUE, SP, V0
2823DEF_CALL_SIGNATURE(BaselineDeprecatedNegPrefV8)
2824{
2825    // 3 : 3 input parameters
2826    CallSignature signature("BaselineDeprecatedNegPrefV8", 0, 3,
2827        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2828    *callSign = signature;
2829    // 3 : 3 input parameters
2830    std::array<VariableType, 3> params = {
2831        VariableType::NATIVE_POINTER(),
2832        VariableType::NATIVE_POINTER(),
2833        VariableType::INT8(),
2834    };
2835    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2836}
2837
2838// GLUE, SP, ACC, RANGE, V0
2839DEF_CALL_SIGNATURE(BaselineWideSupercallarrowrangePrefImm16V8)
2840{
2841    // 5 : 5 input parameters
2842    CallSignature signature("BaselineWideSupercallarrowrangePrefImm16V8", 0, 5,
2843        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2844    *callSign = signature;
2845    // 5 : 5 input parameters
2846    std::array<VariableType, 5> params = {
2847        VariableType::NATIVE_POINTER(),
2848        VariableType::NATIVE_POINTER(),
2849        VariableType::JS_ANY(),
2850        VariableType::INT16(),
2851        VariableType::INT16(),
2852    };
2853    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2854}
2855
2856// GLUE, SP, ACC, IMM
2857DEF_CALL_SIGNATURE(BaselineThrowIfsupernotcorrectcallPrefImm8)
2858{
2859    // 4 : 4 input parameters
2860    CallSignature signature("BaselineThrowIfsupernotcorrectcallPrefImm8", 0, 4,
2861        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2862    *callSign = signature;
2863    // 4 : 4 input parameters
2864    std::array<VariableType, 4> params = {
2865        VariableType::NATIVE_POINTER(),
2866        VariableType::NATIVE_POINTER(),
2867        VariableType::JS_ANY(),
2868        VariableType::INT8(),
2869    };
2870    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2871}
2872
2873// GLUE, SP, INDEX
2874DEF_CALL_SIGNATURE(BaselineDeprecatedNotPrefV8)
2875{
2876    // 3 : 3 input parameters
2877    CallSignature signature("BaselineDeprecatedNotPrefV8", 0, 3,
2878        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2879    *callSign = signature;
2880    // 3 : 3 input parameters
2881    std::array<VariableType, 3> params = {
2882        VariableType::NATIVE_POINTER(),
2883        VariableType::NATIVE_POINTER(),
2884        VariableType::INT8(),
2885    };
2886    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2887}
2888
2889// GLUE, ACC, INDEX
2890DEF_CALL_SIGNATURE(BaselineWideLdobjbyindexPrefImm32)
2891{
2892    // 4 : 4 input parameters
2893    CallSignature signature("BaselineWideLdobjbyindexPrefImm32", 0, 4,
2894        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2895    *callSign = signature;
2896    // 4 : 4 input parameters
2897    std::array<VariableType, 4> params = {
2898        VariableType::NATIVE_POINTER(),
2899        VariableType::NATIVE_POINTER(),
2900        VariableType::INT32(),
2901        VariableType::INT32(),
2902    };
2903    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2904}
2905
2906// GLUE, SP, ACC, IMM
2907DEF_CALL_SIGNATURE(BaselineThrowIfsupernotcorrectcallPrefImm16)
2908{
2909    // 4 : 4 input parameters
2910    CallSignature signature("BaselineThrowIfsupernotcorrectcallPrefImm16", 0, 4,
2911        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2912    *callSign = signature;
2913    // 4 : 4 input parameters
2914    std::array<VariableType, 4> params = {
2915        VariableType::NATIVE_POINTER(),
2916        VariableType::NATIVE_POINTER(),
2917        VariableType::JS_ANY(),
2918        VariableType::INT16(),
2919    };
2920    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2921}
2922
2923// GLUE, SP, V0
2924DEF_CALL_SIGNATURE(BaselineDeprecatedIncPrefV8)
2925{
2926    // 3 : 3 input parameters
2927    CallSignature signature("BaselineDeprecatedIncPrefV8", 0, 3,
2928        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2929    *callSign = signature;
2930    // 3 : 3 input parameters
2931    std::array<VariableType, 3> params = {
2932        VariableType::NATIVE_POINTER(),
2933        VariableType::NATIVE_POINTER(),
2934        VariableType::INT8(),
2935    };
2936    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2937}
2938
2939// GLUE, SP, ACC, V0, INDEX
2940DEF_CALL_SIGNATURE(BaselineWideStobjbyindexPrefV8Imm32)
2941{
2942    // 5 : 5 input parameters
2943    CallSignature signature("BaselineWideStobjbyindexPrefV8Imm32", 0, 5,
2944        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2945    *callSign = signature;
2946    // 5 : 5 input parameters
2947    std::array<VariableType, 5> params = {
2948        VariableType::NATIVE_POINTER(),
2949        VariableType::NATIVE_POINTER(),
2950        VariableType::INT32(),
2951        VariableType::INT32(),
2952        VariableType::INT32(),
2953    };
2954    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2955}
2956
2957// GLUE, SP, INDEX
2958DEF_CALL_SIGNATURE(BaselineDeprecatedDecPrefV8)
2959{
2960    // 3 : 3 input parameters
2961    CallSignature signature("BaselineDeprecatedDecPrefV8", 0, 3,
2962        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2963    *callSign = signature;
2964    // 3 : 3 input parameters
2965    std::array<VariableType, 3> params = {
2966        VariableType::NATIVE_POINTER(),
2967        VariableType::NATIVE_POINTER(),
2968        VariableType::INT8(),
2969    };
2970    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2971}
2972
2973// GLUE, SP, ACC, V0, INDEX
2974DEF_CALL_SIGNATURE(BaselineWideStownbyindexPrefV8Imm32)
2975{
2976    // 5 : 5 input parameters
2977    CallSignature signature("BaselineWideStownbyindexPrefV8Imm32", 0, 5,
2978        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2979    *callSign = signature;
2980    // 5 : 5 input parameters
2981    std::array<VariableType, 5> params = {
2982        VariableType::NATIVE_POINTER(),
2983        VariableType::NATIVE_POINTER(),
2984        VariableType::INT32(),
2985        VariableType::INT32(),
2986        VariableType::INT32(),
2987    };
2988    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2989}
2990
2991// GLUE, SP, FUNC_REG, HOTNESS_COUNTER
2992DEF_CALL_SIGNATURE(BaselineDeprecatedCallarg0PrefV8)
2993{
2994    // 4 : 4 input parameters
2995    CallSignature signature("BaselineDeprecatedCallarg0PrefV8", 0, 4,
2996        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2997    *callSign = signature;
2998    // 4 : 4 input parameters
2999    std::array<VariableType, 4> params = {
3000        VariableType::NATIVE_POINTER(),
3001        VariableType::NATIVE_POINTER(),
3002        VariableType::INT8(),
3003        VariableType::INT32(),
3004    };
3005    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3006}
3007
3008// GLUE, SP, INDEX
3009DEF_CALL_SIGNATURE(BaselineWideCopyrestargsPrefImm16)
3010{
3011    // 3 : 3 input parameters
3012    CallSignature signature("BaselineWideCopyrestargsPrefImm16", 0, 3,
3013        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3014    *callSign = signature;
3015    // 3 : 3 input parameters
3016    std::array<VariableType, 3> params = {
3017        VariableType::NATIVE_POINTER(),
3018        VariableType::NATIVE_POINTER(),
3019        VariableType::INT32(),
3020    };
3021    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3022}
3023
3024// GLUE, SP, FUNC_REG, A0, HOTNESS_COUNTER
3025DEF_CALL_SIGNATURE(BaselineDeprecatedCallarg1PrefV8V8)
3026{
3027    // 5 : 5 input parameters
3028    CallSignature signature("BaselineDeprecatedCallarg1PrefV8V8", 0, 5,
3029        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3030    *callSign = signature;
3031    // 5 : 5 input parameters
3032    std::array<VariableType, 5> params = {
3033        VariableType::NATIVE_POINTER(),
3034        VariableType::NATIVE_POINTER(),
3035        VariableType::INT8(),
3036        VariableType::INT8(),
3037        VariableType::INT32(),
3038    };
3039    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3040}
3041
3042// SP, LEVEL, SLOT
3043DEF_CALL_SIGNATURE(BaselineWideLdlexvarPrefImm16Imm16)
3044{
3045    // 3 : 3 input parameters
3046    CallSignature signature("BaselineWideLdlexvarPrefImm16Imm16", 0, 3,
3047        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3048    *callSign = signature;
3049    // 3 : 3 input parameters
3050    std::array<VariableType, 3> params = {
3051        VariableType::NATIVE_POINTER(),
3052        VariableType::INT32(),
3053        VariableType::INT32(),
3054    };
3055    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3056}
3057
3058// GLUE, SP, FUNC_REG, A0, A1, HOTNESS_COUNTER
3059DEF_CALL_SIGNATURE(BaselineDeprecatedCallargs2PrefV8V8V8)
3060{
3061    // 6 : 6 input parameters
3062    CallSignature signature("BaselineDeprecatedCallargs2PrefV8V8V8", 0, 6,
3063        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3064    *callSign = signature;
3065    // 6 : 6 input parameters
3066    std::array<VariableType, 6> params = {
3067        VariableType::NATIVE_POINTER(),
3068        VariableType::NATIVE_POINTER(),
3069        VariableType::INT8(),
3070        VariableType::INT8(),
3071        VariableType::INT8(),
3072        VariableType::INT32(),
3073    };
3074    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3075}
3076
3077// GLUE, SP, ACC, LEVEL, SLOT
3078DEF_CALL_SIGNATURE(BaselineWideStlexvarPrefImm16Imm16)
3079{
3080    // 5 : 5 input parameters
3081    CallSignature signature("BaselineWideStlexvarPrefImm16Imm16", 0, 5,
3082        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3083    *callSign = signature;
3084    // 5 : 5 input parameters
3085    std::array<VariableType, 5> params = {
3086        VariableType::NATIVE_POINTER(),
3087        VariableType::NATIVE_POINTER(),
3088        VariableType::JS_ANY(),
3089        VariableType::INT32(),
3090        VariableType::INT32(),
3091    };
3092    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3093}
3094
3095// GLUE, SP, FUNC_REG, A0, A1, A2
3096DEF_CALL_SIGNATURE(BaselineDeprecatedCallargs3PrefV8V8V8V8)
3097{
3098    // 6 : 6 input parameters
3099    CallSignature signature("BaselineDeprecatedCallargs3PrefV8V8V8V8", 0, 6,
3100        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3101    *callSign = signature;
3102    // 6 : 6 input parameters
3103    std::array<VariableType, 6> params = {
3104        VariableType::NATIVE_POINTER(),
3105        VariableType::NATIVE_POINTER(),
3106        VariableType::INT8(),
3107        VariableType::INT8(),
3108        VariableType::INT8(),
3109        VariableType::INT8(),
3110    };
3111    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3112}
3113
3114// GLUE, INDEX
3115DEF_CALL_SIGNATURE(BaselineWideGetmodulenamespacePrefImm16)
3116{
3117    // 2 : 2 input parameters
3118    CallSignature signature("BaselineWideGetmodulenamespacePrefImm16", 0, 2,
3119        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3120    *callSign = signature;
3121    // 2 : 2 input parameters
3122    std::array<VariableType, 2> params = {
3123        VariableType::NATIVE_POINTER(),
3124        VariableType::INT16(),
3125    };
3126    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3127}
3128
3129//  GLUE, SP, INDEX, FUNC_REG, HOTNESS_COUNTER
3130DEF_CALL_SIGNATURE(BaselineDeprecatedCallrangePrefImm16V8)
3131{
3132    // 5 : 5 input parameters
3133    CallSignature signature("BaselineDeprecatedCallrangePrefImm16V8", 0, 5,
3134        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3135    *callSign = signature;
3136    // 5 : 5 input parameters
3137    std::array<VariableType, 5> params = {
3138        VariableType::NATIVE_POINTER(),
3139        VariableType::NATIVE_POINTER(),
3140        VariableType::INT32(),
3141        VariableType::INT8(),
3142        VariableType::INT32(),
3143    };
3144    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3145}
3146
3147// GLUE, ACC, INDEX
3148DEF_CALL_SIGNATURE(BaselineWideStmodulevarPrefImm16)
3149{
3150    // 3 : 3 input parameters
3151    CallSignature signature("BaselineWideStmodulevarPrefImm16", 0, 3,
3152        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3153    *callSign = signature;
3154    // 3 : 3 input parameters
3155    std::array<VariableType, 3> params = {
3156        VariableType::NATIVE_POINTER(),
3157        VariableType::JS_ANY(),
3158        VariableType::INT16(),
3159    };
3160    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3161}
3162
3163// GLUE, SP, V0, V1, V2
3164DEF_CALL_SIGNATURE(BaselineDeprecatedCallspreadPrefV8V8V8)
3165{
3166    // 5 : 5 input parameters
3167    CallSignature signature("BaselineDeprecatedCallspreadPrefV8V8V8", 0, 5,
3168        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3169    *callSign = signature;
3170    // 5 : 5 input parameters
3171    std::array<VariableType, 5> params = {
3172        VariableType::NATIVE_POINTER(),
3173        VariableType::NATIVE_POINTER(),
3174        VariableType::INT8(),
3175        VariableType::INT8(),
3176        VariableType::INT8(),
3177    };
3178    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3179}
3180
3181// GLUE, INDEX
3182DEF_CALL_SIGNATURE(BaselineWideLdlocalmodulevarPrefImm16)
3183{
3184    // 2 : 2 input parameters
3185    CallSignature signature("BaselineWideLdlocalmodulevarPrefImm16", 0, 2,
3186        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3187    *callSign = signature;
3188    // 2 : 2 input parameters
3189    std::array<VariableType, 2> params = {
3190        VariableType::NATIVE_POINTER(),
3191        VariableType::INT16(),
3192    };
3193    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3194}
3195
3196// GLUE, SP, INDEX, FUNC_REG, HOTNESS_COUNTER
3197DEF_CALL_SIGNATURE(BaselineDeprecatedCallthisrangePrefImm16V8)
3198{
3199    // 5 : 5 input parameters
3200    CallSignature signature("BaselineDeprecatedCallthisrangePrefImm16V8", 0, 5,
3201        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3202    *callSign = signature;
3203    // 5 : 5 input parameters
3204    std::array<VariableType, 5> params = {
3205        VariableType::NATIVE_POINTER(),
3206        VariableType::NATIVE_POINTER(),
3207        VariableType::INT32(),
3208        VariableType::INT8(),
3209        VariableType::INT32(),
3210    };
3211    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3212}
3213
3214// GLUE, INDEX
3215DEF_CALL_SIGNATURE(BaselineWideLdexternalmodulevarPrefImm16)
3216{
3217    // 2 : 2 input parameters
3218    CallSignature signature("BaselineWideLdexternalmodulevarPrefImm16", 0, 2,
3219        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3220    *callSign = signature;
3221    // 2 : 2 input parameters
3222    std::array<VariableType, 2> params = {
3223        VariableType::NATIVE_POINTER(),
3224        VariableType::INT16(),
3225    };
3226    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3227}
3228
3229// GLUE, SP, METHOD_ID, LITERAL_ID, LENGTH, VREG_IDS
3230DEF_CALL_SIGNATURE(BaselineDeprecatedDefineclasswithbufferPrefId16Imm16Imm16V8V8)
3231{
3232    // 6 : 6 input parameters
3233    CallSignature signature("BaselineDeprecatedDefineclasswithbufferPrefId16Imm16Imm16V8V8", 0, 6,
3234        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3235    *callSign = signature;
3236    // 6 : 6 input parameters
3237    std::array<VariableType, 6> params = {
3238        VariableType::NATIVE_POINTER(),
3239        VariableType::NATIVE_POINTER(),
3240        VariableType::INT32(),
3241        VariableType::INT32(),
3242        VariableType::INT32(),
3243        VariableType::INT32(),
3244    };
3245    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3246}
3247
3248// GLUE, SP, INDEX
3249DEF_CALL_SIGNATURE(BaselineWideLdpatchvarPrefImm16)
3250{
3251    // 3 : 3 input parameters
3252    CallSignature signature("BaselineWideLdpatchvarPrefImm16", 0, 3,
3253        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3254    *callSign = signature;
3255    // 3 : 3 input parameters
3256    std::array<VariableType, 3> params = {
3257        VariableType::NATIVE_POINTER(),
3258        VariableType::NATIVE_POINTER(),
3259        VariableType::INT32(),
3260    };
3261    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3262}
3263
3264// GLUE, SP, ACC, V0, FUNC
3265DEF_CALL_SIGNATURE(BaselineDeprecatedResumegeneratorPrefV8)
3266{
3267    // 4 : 4 input parameters
3268    CallSignature signature("BaselineDeprecatedResumegeneratorPrefV8", 0, 4,
3269        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3270    *callSign = signature;
3271    // 4 : 4 input parameters
3272    std::array<VariableType, 4> params = {
3273        VariableType::NATIVE_POINTER(),
3274        VariableType::NATIVE_POINTER(),
3275        VariableType::JS_ANY(),
3276        VariableType::INT8(),
3277    };
3278    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3279}
3280
3281// GLUE, SP, ACC, INDEX
3282DEF_CALL_SIGNATURE(BaselineWideStpatchvarPrefImm16)
3283{
3284    // 4 : 4 input parameters
3285    CallSignature signature("BaselineWideStpatchvarPrefImm16", 0, 4,
3286        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3287    *callSign = signature;
3288    // 4 : 4 input parameters
3289    std::array<VariableType, 4> params = {
3290        VariableType::NATIVE_POINTER(),
3291        VariableType::NATIVE_POINTER(),
3292        VariableType::JS_ANY(),
3293        VariableType::INT32(),
3294    };
3295    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3296}
3297
3298// SP, ACC, V0
3299DEF_CALL_SIGNATURE(BaselineDeprecatedGetresumemodePrefV8)
3300{
3301    // 3 : 3 input parameters
3302    CallSignature signature("BaselineDeprecatedGetresumemodePrefV8", 0, 3,
3303        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3304    *callSign = signature;
3305    // 3 : 3 input parameters
3306    std::array<VariableType, 3> params = {
3307        VariableType::NATIVE_POINTER(),
3308        VariableType::JS_ANY(),
3309        VariableType::INT8(),
3310    };
3311    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3312}
3313
3314// GLUE, SP, V0
3315DEF_CALL_SIGNATURE(BaselineDeprecatedGettemplateobjectPrefV8)
3316{
3317    // 3 : 3 input parameters
3318    CallSignature signature("BaselineDeprecatedGettemplateobjectPrefV8", 0, 3,
3319        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3320    *callSign = signature;
3321    // 3 : 3 input parameters
3322    std::array<VariableType, 3> params = {
3323        VariableType::NATIVE_POINTER(),
3324        VariableType::NATIVE_POINTER(),
3325        VariableType::INT8(),
3326    };
3327    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3328}
3329
3330// GLUE, SP, V0, V1
3331DEF_CALL_SIGNATURE(BaselineDeprecatedDelobjpropPrefV8V8)
3332{
3333    // 4 : 4 input parameters
3334    CallSignature signature("BaselineDeprecatedDelobjpropPrefV8V8", 0, 4,
3335        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3336    *callSign = signature;
3337    // 4 : 4 input parameters
3338    std::array<VariableType, 4> params = {
3339        VariableType::NATIVE_POINTER(),
3340        VariableType::NATIVE_POINTER(),
3341        VariableType::INT8(),
3342        VariableType::INT8(),
3343    };
3344    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3345}
3346
3347// GLUE, SP, PC, V0, V1
3348DEF_CALL_SIGNATURE(BaselineDeprecatedSuspendgeneratorPrefV8V8)
3349{
3350    // 5 : 5 input parameters
3351    CallSignature signature("BaselineDeprecatedSuspendgeneratorPrefV8V8", 0, 5,
3352        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3353    *callSign = signature;
3354    // 5 : 5 input parameters
3355    std::array<VariableType, 5> params = {
3356        VariableType::NATIVE_POINTER(),
3357        VariableType::NATIVE_POINTER(),
3358        VariableType::INT32(),
3359        VariableType::INT8(),
3360        VariableType::INT8(),
3361    };
3362    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3363}
3364
3365// GLUE, SP, PC, V0, V1
3366DEF_CALL_SIGNATURE(BaselineSuspendgeneratorV8)
3367{
3368    // 4 : 4 input parameters
3369    CallSignature signature("BaselineSuspendgeneratorV8", 0, 4,
3370        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3371    *callSign = signature;
3372    // 4 : 4 input parameters
3373    std::array<VariableType, 4> params = {
3374        VariableType::NATIVE_POINTER(),
3375        VariableType::NATIVE_POINTER(),
3376        VariableType::INT32(),
3377        VariableType::INT32(),
3378    };
3379    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3380}
3381
3382// GLUE, SP, V0, V1
3383DEF_CALL_SIGNATURE(BaselineDeprecatedAsyncfunctionawaituncaughtPrefV8V8)
3384{
3385    // 4 : 4 input parameters
3386    CallSignature signature("BaselineDeprecatedAsyncfunctionawaituncaughtPrefV8V8", 0, 4,
3387        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3388    *callSign = signature;
3389    // 4 : 4 input parameters
3390    std::array<VariableType, 4> params = {
3391        VariableType::NATIVE_POINTER(),
3392        VariableType::NATIVE_POINTER(),
3393        VariableType::INT8(),
3394        VariableType::INT8(),
3395    };
3396    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3397}
3398
3399// GLUE, SP, V0, V1
3400DEF_CALL_SIGNATURE(BaselineDeprecatedCopydatapropertiesPrefV8V8)
3401{
3402    // 4 : 4 input parameters
3403    CallSignature signature("BaselineDeprecatedCopydatapropertiesPrefV8V8", 0, 4,
3404        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3405    *callSign = signature;
3406    // 4 : 4 input parameters
3407    std::array<VariableType, 4> params = {
3408        VariableType::NATIVE_POINTER(),
3409        VariableType::NATIVE_POINTER(),
3410        VariableType::INT8(),
3411        VariableType::INT8(),
3412    };
3413    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3414}
3415
3416// GLUE, SP, ACC, V0, V1
3417DEF_CALL_SIGNATURE(BaselineDeprecatedSetobjectwithprotoPrefV8V8)
3418{
3419    // 5 : 5 input parameters
3420    CallSignature signature("BaselineDeprecatedSetobjectwithprotoPrefV8V8", 0, 5,
3421        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3422    *callSign = signature;
3423    // 5 : 5 input parameters
3424    std::array<VariableType, 5> params = {
3425        VariableType::NATIVE_POINTER(),
3426        VariableType::NATIVE_POINTER(),
3427        VariableType::JS_ANY(),
3428        VariableType::INT8(),
3429        VariableType::INT8(),
3430    };
3431    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3432}
3433
3434// GLUE, SP, V0, V1
3435DEF_CALL_SIGNATURE(BaselineDeprecatedLdobjbyvaluePrefV8V8)
3436{
3437    // 4 : 4 input parameters
3438    CallSignature signature("BaselineDeprecatedLdobjbyvaluePrefV8V8", 0, 4,
3439        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3440    *callSign = signature;
3441    // 4 : 4 input parameters
3442    std::array<VariableType, 4> params = {
3443        VariableType::NATIVE_POINTER(),
3444        VariableType::NATIVE_POINTER(),
3445        VariableType::INT8(),
3446        VariableType::INT8(),
3447    };
3448    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3449}
3450
3451// GLUE, SP, V0, V1
3452DEF_CALL_SIGNATURE(BaselineDeprecatedLdsuperbyvaluePrefV8V8)
3453{
3454    // 4 : 4 input parameters
3455    CallSignature signature("BaselineDeprecatedLdsuperbyvaluePrefV8V8", 0, 4,
3456        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3457    *callSign = signature;
3458    // 4 : 4 input parameters
3459    std::array<VariableType, 4> params = {
3460        VariableType::NATIVE_POINTER(),
3461        VariableType::NATIVE_POINTER(),
3462        VariableType::INT8(),
3463        VariableType::INT8(),
3464    };
3465    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3466}
3467
3468// GLUE, SP, V0, INDEX
3469DEF_CALL_SIGNATURE(BaselineDeprecatedLdobjbyindexPrefV8Imm32)
3470{
3471    // 4 : 4 input parameters
3472    CallSignature signature("BaselineDeprecatedLdobjbyindexPrefV8Imm32", 0, 4,
3473        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3474    *callSign = signature;
3475    // 4 : 4 input parameters
3476    std::array<VariableType, 4> params = {
3477        VariableType::NATIVE_POINTER(),
3478        VariableType::NATIVE_POINTER(),
3479        VariableType::INT8(),
3480        VariableType::INT32(),
3481    };
3482    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3483}
3484
3485// GLUE, SP, V0, V1
3486DEF_CALL_SIGNATURE(BaselineDeprecatedAsyncfunctionresolvePrefV8V8V8)
3487{
3488    // 4 : 4 input parameters
3489    CallSignature signature("BaselineDeprecatedAsyncfunctionresolvePrefV8V8V8", 0, 4,
3490        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3491    *callSign = signature;
3492    // 4 : 4 input parameters
3493    std::array<VariableType, 4> params = {
3494        VariableType::NATIVE_POINTER(),
3495        VariableType::NATIVE_POINTER(),
3496        VariableType::INT8(),
3497        VariableType::INT8(),
3498    };
3499    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3500}
3501
3502// GLUE, SP, V0, V1
3503DEF_CALL_SIGNATURE(BaselineDeprecatedAsyncfunctionrejectPrefV8V8V8)
3504{
3505    // 4 : 4 input parameters
3506    CallSignature signature("BaselineDeprecatedAsyncfunctionrejectPrefV8V8V8", 0, 4,
3507        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3508    *callSign = signature;
3509    // 4 : 4 input parameters
3510    std::array<VariableType, 4> params = {
3511        VariableType::NATIVE_POINTER(),
3512        VariableType::NATIVE_POINTER(),
3513        VariableType::INT8(),
3514        VariableType::INT8(),
3515    };
3516    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3517}
3518
3519// GLUE, SP, LEVEL, SLOT, V0
3520DEF_CALL_SIGNATURE(BaselineDeprecatedStlexvarPrefImm4Imm4V8)
3521{
3522      // 5 : 5 input parameters
3523    CallSignature signature("BaselineDeprecatedStlexvarPrefImm4Imm4V8", 0, 5,
3524        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3525    *callSign = signature;
3526    // 5 : 5 input parameters
3527    std::array<VariableType, 5> params = {
3528        VariableType::NATIVE_POINTER(),
3529        VariableType::NATIVE_POINTER(),
3530        VariableType::INT32(),
3531        VariableType::INT32(),
3532        VariableType::INT8(),
3533    };
3534    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3535}
3536
3537// GLUE, SP, LEVEL, SLOT, V0
3538DEF_CALL_SIGNATURE(BaselineDeprecatedStlexvarPrefImm8Imm8V8)
3539{
3540    // 5 : 5 input parameters
3541    CallSignature signature("BaselineDeprecatedStlexvarPrefImm8Imm8V8", 0, 5,
3542        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3543    *callSign = signature;
3544    // 5 : 5 input parameters
3545    std::array<VariableType, 5> params = {
3546        VariableType::NATIVE_POINTER(),
3547        VariableType::NATIVE_POINTER(),
3548        VariableType::INT32(),
3549        VariableType::INT32(),
3550        VariableType::INT8(),
3551    };
3552    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3553}
3554
3555// GLUE, SP, LEVEL, SLOT, V0
3556DEF_CALL_SIGNATURE(BaselineDeprecatedStlexvarPrefImm16Imm16V8)
3557{
3558     // 5 : 5 input parameters
3559    CallSignature signature("BaselineDeprecatedStlexvarPrefImm16Imm16V8", 0, 5,
3560        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3561    *callSign = signature;
3562    // 5 : 5 input parameters
3563    std::array<VariableType, 5> params = {
3564        VariableType::NATIVE_POINTER(),
3565        VariableType::NATIVE_POINTER(),
3566        VariableType::INT32(),
3567        VariableType::INT32(),
3568        VariableType::INT8(),
3569    };
3570    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3571}
3572
3573// GLUE, STRING_ID, CONST_POOL
3574DEF_CALL_SIGNATURE(BaselineDeprecatedGetmodulenamespacePrefId32)
3575{
3576    // 3 : 3 input parameters
3577    CallSignature signature("BaselineDeprecatedGetmodulenamespacePrefId32", 0, 3,
3578        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3579    *callSign = signature;
3580    // 3 : 3 input parameters
3581    std::array<VariableType, 3> params = {
3582        VariableType::NATIVE_POINTER(),
3583        VariableType::INT32(),
3584        VariableType::NATIVE_POINTER(),
3585    };
3586    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3587}
3588
3589// GLUE, ACC, STRING_ID, CONST_POOL
3590DEF_CALL_SIGNATURE(BaselineDeprecatedStmodulevarPrefId32)
3591{
3592    // 4 : 4 input parameters
3593    CallSignature signature("BaselineDeprecatedStmodulevarPrefId32", 0, 4,
3594        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3595    *callSign = signature;
3596    // 4 : 4 input parameters
3597    std::array<VariableType, 4> params = {
3598        VariableType::NATIVE_POINTER(),
3599        VariableType::JS_ANY(),
3600        VariableType::INT32(),
3601        VariableType::NATIVE_POINTER(),
3602    };
3603    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3604}
3605
3606// GLUE, SP, V0, STRING_ID, CONST_POOL
3607DEF_CALL_SIGNATURE(BaselineDeprecatedLdobjbynamePrefId32V8)
3608{
3609    // 4 : 4 input parameters
3610    CallSignature signature("BaselineDeprecatedLdobjbynamePrefId32V8", 0, 4,
3611        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3612    *callSign = signature;
3613    // 4 : 4 input parameters
3614    std::array<VariableType, 4> params = {
3615        VariableType::NATIVE_POINTER(),
3616        VariableType::NATIVE_POINTER(),
3617        VariableType::INT8(),
3618        VariableType::INT32(),
3619    };
3620    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3621}
3622
3623// GLUE, SP, STRING_ID, V0
3624DEF_CALL_SIGNATURE(BaselineDeprecatedLdsuperbynamePrefId32V8)
3625{
3626    // 4 : 4 input parameters
3627    CallSignature signature("BaselineDeprecatedLdsuperbynamePrefId32V8", 0, 4,
3628        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3629    *callSign = signature;
3630    // 4 : 4 input parameters
3631    std::array<VariableType, 4> params = {
3632        VariableType::NATIVE_POINTER(),
3633        VariableType::NATIVE_POINTER(),
3634        VariableType::INT32(),
3635        VariableType::INT8(),
3636    };
3637    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3638}
3639
3640// GLUE, STRING_ID, FLAG_I8, CONST_POOL
3641DEF_CALL_SIGNATURE(BaselineDeprecatedLdmodulevarPrefId32Imm8)
3642{
3643    // 4 : 4 input parameters
3644    CallSignature signature("BaselineDeprecatedLdmodulevarPrefId32Imm8", 0, 4,
3645        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3646    *callSign = signature;
3647    // 4 : 4 input parameters
3648    std::array<VariableType, 4> params = {
3649        VariableType::NATIVE_POINTER(),
3650        VariableType::INT32(),
3651        VariableType::INT8(),
3652        VariableType::NATIVE_POINTER(),
3653    };
3654    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3655}
3656
3657// GLUE, ACC, STRING_ID, CONST_POOL
3658DEF_CALL_SIGNATURE(BaselineDeprecatedStconsttoglobalrecordPrefId32)
3659{
3660    // 4 : 4 input parameters
3661    CallSignature signature("BaselineDeprecatedStconsttoglobalrecordPrefId32", 0, 4,
3662        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3663    *callSign = signature;
3664    // 4 : 4 input parameters
3665    std::array<VariableType, 4> params = {
3666        VariableType::NATIVE_POINTER(),
3667        VariableType::JS_ANY(),
3668        VariableType::INT32(),
3669        VariableType::NATIVE_POINTER(),
3670    };
3671    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3672}
3673
3674// GLUE, ACC, STRING_ID, CONST_POOL
3675DEF_CALL_SIGNATURE(BaselineDeprecatedStlettoglobalrecordPrefId32)
3676{
3677    // 4 : 4 input parameters
3678    CallSignature signature("BaselineDeprecatedStlettoglobalrecordPrefId32", 0, 4,
3679        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3680    *callSign = signature;
3681    // 4 : 4 input parameters
3682    std::array<VariableType, 4> params = {
3683        VariableType::NATIVE_POINTER(),
3684        VariableType::JS_ANY(),
3685        VariableType::INT32(),
3686        VariableType::NATIVE_POINTER(),
3687    };
3688    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3689}
3690
3691// GLUE, ACC, STRING_ID, CONST_POOL
3692DEF_CALL_SIGNATURE(BaselineDeprecatedStclasstoglobalrecordPrefId32)
3693{
3694    // 4 : 4 input parameters
3695    CallSignature signature("BaselineDeprecatedStclasstoglobalrecordPrefId32", 0, 4,
3696        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3697    *callSign = signature;
3698    // 4 : 4 input parameters
3699    std::array<VariableType, 4> params = {
3700        VariableType::NATIVE_POINTER(),
3701        VariableType::JS_ANY(),
3702        VariableType::INT32(),
3703        VariableType::NATIVE_POINTER(),
3704    };
3705    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3706}
3707
3708// SP
3709DEF_CALL_SIGNATURE(BaselineDeprecatedLdhomeobjectPrefNone)
3710{
3711    // 1 : 1 input parameters
3712    CallSignature signature("BaselineDeprecatedLdhomeobjectPrefNone", 0, 1,
3713        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3714    *callSign = signature;
3715    // 1 : 1 input parameters
3716    std::array<VariableType, 1> params = {
3717        VariableType::NATIVE_POINTER(),
3718    };
3719    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3720}
3721
3722// GLUE, ACC, CONSTPOOL, IMM_I16, FUNC
3723DEF_CALL_SIGNATURE(BaselineDeprecatedCreateobjecthavingmethodPrefImm16)
3724{
3725     // 4 : 4 input parameters
3726    CallSignature signature("BaselineDeprecatedCreateobjecthavingmethodPrefImm16", 0, 4,
3727        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3728    *callSign = signature;
3729    // 4 : 4 input parameters
3730    std::array<VariableType, 4> params = {
3731        VariableType::NATIVE_POINTER(),
3732        VariableType::JS_ANY(),
3733        VariableType::NATIVE_POINTER(),
3734        VariableType::INT16(),
3735    };
3736    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3737}
3738
3739//  GLUE, ACC, VREG, FUNC
3740DEF_CALL_SIGNATURE(BaselineDeprecatedDynamicimportPrefV8)
3741{
3742    // 4 : 4 input parameters
3743    CallSignature signature("BaselineDeprecatedDynamicimportPrefV8", 0, 4,
3744        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3745    *callSign = signature;
3746    // 4 : 4 input parameters
3747    std::array<VariableType, 4> params = {
3748        VariableType::NATIVE_POINTER(),
3749        VariableType::NATIVE_POINTER(),
3750        VariableType::JS_ANY(),
3751        VariableType::JS_ANY(),
3752    };
3753    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3754}
3755
3756// GLUE, ACC, FUNC
3757DEF_CALL_SIGNATURE(BaselineCallRuntimeNotifyConcurrentResultPrefNone)
3758{
3759    // 3 : 3 input parameters
3760    CallSignature signature("BaselineCallRuntimeNotifyConcurrentResultPrefNone", 0, 3,
3761        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3762    *callSign = signature;
3763    // 3 : 3 input parameters
3764    std::array<VariableType, 3> params = {
3765        VariableType::NATIVE_POINTER(),
3766        VariableType::NATIVE_POINTER(),
3767        VariableType::JS_ANY(),
3768    };
3769    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3770}
3771
3772// GLUE, SP, SLOT_ID, STRING_ID, V0
3773DEF_CALL_SIGNATURE(BaselineDefineFieldByNameImm8Id16V8)
3774{
3775    // 5 : 5 input parameters
3776    CallSignature signature("BaselineDefineFieldByNameImm8Id16V8", 0, 5,
3777        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3778    *callSign = signature;
3779    // 5 : 5 input parameters
3780    std::array<VariableType, 5> params = {
3781        VariableType::NATIVE_POINTER(),
3782        VariableType::NATIVE_POINTER(),
3783        VariableType::INT32(),
3784        VariableType::INT32(),
3785        VariableType::INT32(),
3786    };
3787    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3788}
3789
3790DEF_CALL_SIGNATURE(BaselineDefinePropertyByNameImm8Id16V8)
3791{
3792    // 5 : 5 input parameters
3793    CallSignature signature("BaselineDefinePropertyByNameImm8Id16V8", 0, 5,
3794        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3795    *callSign = signature;
3796    // 5 : 5 input parameters
3797    std::array<VariableType, 5> params = {
3798        VariableType::NATIVE_POINTER(),
3799        VariableType::NATIVE_POINTER(),
3800        VariableType::INT32(),
3801        VariableType::INT32(),
3802        VariableType::INT32(),
3803    };
3804    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3805}
3806
3807// GLUE, SP, ACC, V0, V1
3808DEF_CALL_SIGNATURE(BaselineCallRuntimeDefineFieldByValuePrefImm8V8V8)
3809{
3810    // 5 : 5 input parameters
3811    CallSignature signature("BaselineCallRuntimeDefineFieldByValuePrefImm8V8V8", 0, 5,
3812        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3813    *callSign = signature;
3814    // 5 : 5 input parameters
3815    std::array<VariableType, 5> params = {
3816        VariableType::NATIVE_POINTER(),
3817        VariableType::NATIVE_POINTER(),
3818        VariableType::JS_ANY(),
3819        VariableType::INT8(),
3820        VariableType::INT8(),
3821    };
3822    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3823}
3824
3825// GLUE, ACC, INDEX, V0
3826DEF_CALL_SIGNATURE(BaselineCallRuntimeDefineFieldByIndexPrefImm8Imm32V8)
3827{
3828    // 5 : 5 input parameters
3829    CallSignature signature("BaselineCallRuntimeDefineFieldByIndexPrefImm8Imm32V8", 0, 5,
3830        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3831    *callSign = signature;
3832    // 5 : 5 input parameters
3833    std::array<VariableType, 5> params = {
3834        VariableType::NATIVE_POINTER(),
3835        VariableType::NATIVE_POINTER(),
3836        VariableType::JS_ANY(),
3837        VariableType::INT32(),
3838        VariableType::INT8(),
3839    };
3840    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3841}
3842
3843DEF_CALL_SIGNATURE(BaselineCallRuntimeToPropertyKeyPrefNone)
3844{
3845    // 3 : 3 input parameters
3846    CallSignature signature("BaselineCallRuntimeToPropertyKeyPrefNone", 0, 3,
3847        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3848    *callSign = signature;
3849    // 3 : 3 input parameters
3850    std::array<VariableType, 3> params = {
3851        VariableType::NATIVE_POINTER(),
3852        VariableType::NATIVE_POINTER(),
3853        VariableType::JS_ANY(),
3854    };
3855    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3856}
3857
3858// GLUE, SP, COUNT, LITERAL_ID
3859DEF_CALL_SIGNATURE(BaselineCallRuntimeCreatePrivatePropertyPrefImm16Id16)
3860{
3861    // 4 : 4 input parameters
3862    CallSignature signature("BaselineCallRuntimeCreatePrivatePropertyPrefImm16Id16", 0, 4,
3863        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3864    *callSign = signature;
3865    // 4 : 4 input parameters
3866    std::array<VariableType, 4> params = {
3867        VariableType::NATIVE_POINTER(),
3868        VariableType::NATIVE_POINTER(),
3869        VariableType::INT32(),
3870        VariableType::INT32(),
3871    };
3872    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3873}
3874
3875// GLUE, SP, ACC, LEVEL_INDEX, SLOT_INDEX, V0
3876DEF_CALL_SIGNATURE(BaselineCallRuntimeDefinePrivatePropertyPrefImm8Imm16Imm16V8)
3877{
3878    // 6 : 6 input parameters
3879    CallSignature signature("BaselineCallRuntimeDefinePrivatePropertyPrefImm8Imm16Imm16V8", 0, 6,
3880        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3881    *callSign = signature;
3882    // 6 : 6 input parameters
3883    std::array<VariableType, 6> params = {
3884        VariableType::NATIVE_POINTER(),
3885        VariableType::NATIVE_POINTER(),
3886        VariableType::JS_ANY(),
3887        VariableType::INT32(),
3888        VariableType::INT32(),
3889        VariableType::INT8(),
3890    };
3891    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3892}
3893
3894//  GLUE, SP, ACC, V0, HOTNESS_COUNTER, SLOT_ID
3895DEF_CALL_SIGNATURE(BaselineCallRuntimeCallInitPrefImm8V8)
3896{
3897    // 6 : 6 input parameters
3898    CallSignature signature("BaselineCallRuntimeCallInitPrefImm8V8", 0, 6,
3899        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3900    *callSign = signature;
3901    // 6 : 6 input parameters
3902    std::array<VariableType, 6> params = {
3903        VariableType::NATIVE_POINTER(),
3904        VariableType::NATIVE_POINTER(),
3905        VariableType::JS_ANY(),
3906        VariableType::INT8(),
3907        VariableType::INT32(),
3908        VariableType::INT32(),
3909    };
3910    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3911}
3912
3913// GLUE, SP, METHOD_ID, LITERAL_ID, LENGTH, V0
3914DEF_CALL_SIGNATURE(BaselineCallRuntimeDefineSendableClassPrefImm16Id16Id16Imm16V8)
3915{
3916    // 6 : 6 input parameters
3917    CallSignature signature("BaselineCallRuntimeDefineSendableClassPrefImm16Id16Id16Imm16V8", 0, 6,
3918        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3919    *callSign = signature;
3920    // 6 : 6 input parameters
3921    std::array<VariableType, 6> params = {
3922        VariableType::NATIVE_POINTER(),
3923        VariableType::NATIVE_POINTER(),
3924        VariableType::INT16(),
3925        VariableType::INT16(),
3926        VariableType::INT16(),
3927        VariableType::INT8(),
3928    };
3929    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3930}
3931
3932DEF_CALL_SIGNATURE(BaselineCallRuntimeLdSendableClassPrefImm16)
3933{
3934    // 3 : 3 input parameters
3935    CallSignature signature("BaselineCallRuntimeLdSendableClassPrefImm16", 0, 3,
3936        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3937    *callSign = signature;
3938    // 3 : 3 input parameters
3939    std::array<VariableType, 3> params = {
3940        VariableType::NATIVE_POINTER(),
3941        VariableType::NATIVE_POINTER(),
3942        VariableType::INT16(),
3943    };
3944    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3945}
3946
3947DEF_CALL_SIGNATURE(BaselineCallRuntimeIstruePrefImm8)
3948{
3949    // 4 : 4 input parameters
3950    CallSignature signature("BaselineCallRuntimeIstruePrefImm8", 0, 4,
3951        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3952    *callSign = signature;
3953    // 4 : 4 input parameters
3954    std::array<VariableType, 4> params = {
3955        VariableType::NATIVE_POINTER(),
3956        VariableType::NATIVE_POINTER(),
3957        VariableType::JS_ANY(),
3958        VariableType::INT32(),
3959    };
3960    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3961}
3962
3963DEF_CALL_SIGNATURE(BaselineCallRuntimeIsfalsePrefImm8)
3964{
3965    // 4 : 4 input parameters
3966    CallSignature signature("BaselineCallRuntimeIsfalsePrefImm8", 0, 4,
3967        ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3968    *callSign = signature;
3969    // 4 : 4 input parameters
3970    std::array<VariableType, 4> params = {
3971        VariableType::NATIVE_POINTER(),
3972        VariableType::NATIVE_POINTER(),
3973        VariableType::JS_ANY(),
3974        VariableType::INT32(),
3975    };
3976    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3977}
3978
3979// GLUE, ACC, SP
3980DEF_CALL_SIGNATURE(BaselineReturnundefined)
3981{
3982    // 3 : 3 input parameters
3983    CallSignature signature("BaselineReturnundefined", 0, 3,
3984        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3985    *callSign = signature;
3986    // 3 : 3 input parameters
3987    std::array<VariableType, 3> params = {
3988        VariableType::NATIVE_POINTER(),
3989        VariableType::NATIVE_POINTER(),
3990        VariableType::INT32(),
3991    };
3992
3993    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3994}
3995
3996// GLUE, SP, ACC
3997DEF_CALL_SIGNATURE(BaselineExceptionHandler)
3998{
3999    // 3 : 3 input parameters
4000    CallSignature signature("BaselineExceptionHandler", 0, 3,
4001        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
4002    *callSign = signature;
4003    // 3 : 3 input parameters
4004    std::array<VariableType, 3> params = {
4005        VariableType::NATIVE_POINTER(),
4006        VariableType::NATIVE_POINTER(),
4007        VariableType::JS_ANY(),
4008    };
4009    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
4010}
4011
4012// GLUE, SP, OFFSET
4013DEF_CALL_SIGNATURE(BaselineUpdateHotness)
4014{
4015    // 3 : 3 input parameters
4016    CallSignature signature("BaselineUpdateHotness", 0, 3,
4017        ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
4018    *callSign = signature;
4019    // 3 : 3 input parameters
4020    std::array<VariableType, 3> params = {
4021        VariableType::NATIVE_POINTER(),
4022        VariableType::NATIVE_POINTER(),
4023        VariableType::INT32(),
4024    };
4025    BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
4026}
4027}  // namespace panda::ecmascript::kungfu
4028