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
18 namespace 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
DEF_CALL_SIGNATURE(BaselineTryLdGLobalByNameImm8ID16)41 DEF_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
DEF_CALL_SIGNATURE(BaselineStToGlobalRecordImm16ID16)57 DEF_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
DEF_CALL_SIGNATURE(BaselineLdaStrID16)73 DEF_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
DEF_CALL_SIGNATURE(BaselineCallArg1Imm8V8)88 DEF_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
DEF_CALL_SIGNATURE(BaselineLdsymbol)104 DEF_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
DEF_CALL_SIGNATURE(BaselineLdglobal)117 DEF_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
DEF_CALL_SIGNATURE(BaselinePoplexenv)130 DEF_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
DEF_CALL_SIGNATURE(BaselineGetunmappedargs)144 DEF_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
DEF_CALL_SIGNATURE(BaselineAsyncfunctionenter)159 DEF_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
DEF_CALL_SIGNATURE(BaselineCreateasyncgeneratorobjV8)173 DEF_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
DEF_CALL_SIGNATURE(BaselineDebugger)189 DEF_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
DEF_CALL_SIGNATURE(BaselineGetpropiterator)202 DEF_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
DEF_CALL_SIGNATURE(BaselineGetiteratorImm8)217 DEF_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
DEF_CALL_SIGNATURE(BaselineGetiteratorImm16)232 DEF_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
DEF_CALL_SIGNATURE(BaselineCloseiteratorImm8V8)247 DEF_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
DEF_CALL_SIGNATURE(BaselineCloseiteratorImm16V8)262 DEF_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
DEF_CALL_SIGNATURE(BaselineAsyncgeneratorresolveV8V8V8)278 DEF_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
DEF_CALL_SIGNATURE(BaselineCreateemptyobject)296 DEF_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
DEF_CALL_SIGNATURE(BaselineCreateemptyarrayImm8)311 DEF_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
DEF_CALL_SIGNATURE(BaselineCreateemptyarrayImm16)327 DEF_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
DEF_CALL_SIGNATURE(BaselineCreategeneratorobjV8)343 DEF_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
DEF_CALL_SIGNATURE(BaselineCreateiterresultobjV8V8)359 DEF_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
DEF_CALL_SIGNATURE(BaselineCreateobjectwithexcludedkeysImm8V8V8)375 DEF_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
DEF_CALL_SIGNATURE(BaselineCallthis0Imm8V8)392 DEF_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
DEF_CALL_SIGNATURE(BaselineCreatearraywithbufferImm8Id16)408 DEF_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
DEF_CALL_SIGNATURE(BaselineCreatearraywithbufferImm16Id16)425 DEF_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
DEF_CALL_SIGNATURE(BaselineCallthis1Imm8V8V8)442 DEF_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
DEF_CALL_SIGNATURE(BaselineCallthis2Imm8V8V8V8)459 DEF_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
DEF_CALL_SIGNATURE(BaselineCreateobjectwithbufferImm8Id16)477 DEF_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
DEF_CALL_SIGNATURE(BaselineCreateobjectwithbufferImm16Id16)493 DEF_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
DEF_CALL_SIGNATURE(BaselineCreateregexpwithliteralImm8Id16Imm8)509 DEF_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
DEF_CALL_SIGNATURE(BaselineCreateregexpwithliteralImm16Id16Imm8)525 DEF_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
DEF_CALL_SIGNATURE(BaselineNewobjapplyImm8V8)541 DEF_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
DEF_CALL_SIGNATURE(BaselineNewobjapplyImm16V8)557 DEF_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
DEF_CALL_SIGNATURE(BaselineNewlexenvImm8)573 DEF_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
DEF_CALL_SIGNATURE(BaselineNewlexenvwithnameImm8Id16)589 DEF_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
DEF_CALL_SIGNATURE(BaselineAdd2Imm8V8)606 DEF_CALL_SIGNATURE(BaselineAdd2Imm8V8)
607 {
608 BINARY_OP_SIGNATURE_DESC("BaselineAdd2Imm8V8");
609 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
610 }
611
DEF_CALL_SIGNATURE(BaselineSub2Imm8V8)612 DEF_CALL_SIGNATURE(BaselineSub2Imm8V8)
613 {
614 BINARY_OP_SIGNATURE_DESC("BaselineSub2Imm8V8");
615 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
616 }
617
DEF_CALL_SIGNATURE(BaselineMul2Imm8V8)618 DEF_CALL_SIGNATURE(BaselineMul2Imm8V8)
619 {
620 BINARY_OP_SIGNATURE_DESC("BaselineMul2Imm8V8");
621 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
622 }
623
DEF_CALL_SIGNATURE(BaselineDiv2Imm8V8)624 DEF_CALL_SIGNATURE(BaselineDiv2Imm8V8)
625 {
626 BINARY_OP_SIGNATURE_DESC("BaselineDiv2Imm8V8");
627 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
628 }
629
DEF_CALL_SIGNATURE(BaselineMod2Imm8V8)630 DEF_CALL_SIGNATURE(BaselineMod2Imm8V8)
631 {
632 BINARY_OP_SIGNATURE_DESC("BaselineMod2Imm8V8");
633 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
634 }
635
DEF_CALL_SIGNATURE(BaselineEqImm8V8)636 DEF_CALL_SIGNATURE(BaselineEqImm8V8)
637 {
638 BINARY_OP_SIGNATURE_DESC("BaselineEqImm8V8");
639 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
640 }
641
DEF_CALL_SIGNATURE(BaselineNoteqImm8V8)642 DEF_CALL_SIGNATURE(BaselineNoteqImm8V8)
643 {
644 BINARY_OP_SIGNATURE_DESC("BaselineNoteqImm8V8");
645 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
646 }
647
DEF_CALL_SIGNATURE(BaselineLessImm8V8)648 DEF_CALL_SIGNATURE(BaselineLessImm8V8)
649 {
650 BINARY_OP_SIGNATURE_DESC("BaselineLessImm8V8");
651 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
652 }
653
DEF_CALL_SIGNATURE(BaselineLesseqImm8V8)654 DEF_CALL_SIGNATURE(BaselineLesseqImm8V8)
655 {
656 BINARY_OP_SIGNATURE_DESC("BaselineLesseqImm8V8");
657 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
658 }
659
DEF_CALL_SIGNATURE(BaselineGreaterImm8V8)660 DEF_CALL_SIGNATURE(BaselineGreaterImm8V8)
661 {
662 BINARY_OP_SIGNATURE_DESC("BaselineGreaterImm8V8");
663 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
664 }
665
DEF_CALL_SIGNATURE(BaselineGreatereqImm8V8)666 DEF_CALL_SIGNATURE(BaselineGreatereqImm8V8)
667 {
668 BINARY_OP_SIGNATURE_DESC("BaselineGreatereqImm8V8");
669 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
670 }
671
DEF_CALL_SIGNATURE(BaselineShl2Imm8V8)672 DEF_CALL_SIGNATURE(BaselineShl2Imm8V8)
673 {
674 BINARY_OP_SIGNATURE_DESC("BaselineShl2Imm8V8");
675 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
676 }
677
DEF_CALL_SIGNATURE(BaselineShr2Imm8V8)678 DEF_CALL_SIGNATURE(BaselineShr2Imm8V8)
679 {
680 BINARY_OP_SIGNATURE_DESC("BaselineShr2Imm8V8");
681 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
682 }
683
DEF_CALL_SIGNATURE(BaselineAshr2Imm8V8)684 DEF_CALL_SIGNATURE(BaselineAshr2Imm8V8)
685 {
686 BINARY_OP_SIGNATURE_DESC("BaselineAshr2Imm8V8");
687 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
688 }
689
DEF_CALL_SIGNATURE(BaselineAnd2Imm8V8)690 DEF_CALL_SIGNATURE(BaselineAnd2Imm8V8)
691 {
692 BINARY_OP_SIGNATURE_DESC("BaselineAnd2Imm8V8");
693 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
694 }
695
DEF_CALL_SIGNATURE(BaselineOr2Imm8V8)696 DEF_CALL_SIGNATURE(BaselineOr2Imm8V8)
697 {
698 BINARY_OP_SIGNATURE_DESC("BaselineOr2Imm8V8");
699 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
700 }
701
DEF_CALL_SIGNATURE(BaselineXor2Imm8V8)702 DEF_CALL_SIGNATURE(BaselineXor2Imm8V8)
703 {
704 BINARY_OP_SIGNATURE_DESC("BaselineXor2Imm8V8");
705 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
706 }
707
DEF_CALL_SIGNATURE(BaselineExpImm8V8)708 DEF_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
DEF_CALL_SIGNATURE(BaselineTypeofImm8)723 DEF_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
DEF_CALL_SIGNATURE(BaselineTypeofImm16)737 DEF_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
DEF_CALL_SIGNATURE(BaselineTonumberImm8)751 DEF_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
DEF_CALL_SIGNATURE(BaselineTonumericImm8)766 DEF_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
DEF_CALL_SIGNATURE(BaselineNegImm8)781 DEF_CALL_SIGNATURE(BaselineNegImm8)
782 {
783 SINGLE_OP_SIGNATURE_DESC("BaselineNegImm8");
784 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
785 }
786
DEF_CALL_SIGNATURE(BaselineNotImm8)787 DEF_CALL_SIGNATURE(BaselineNotImm8)
788 {
789 SINGLE_OP_SIGNATURE_DESC("BaselineNotImm8");
790 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
791 }
792
DEF_CALL_SIGNATURE(BaselineIncImm8)793 DEF_CALL_SIGNATURE(BaselineIncImm8)
794 {
795 SINGLE_OP_SIGNATURE_DESC("BaselineIncImm8");
796 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
797 }
798
DEF_CALL_SIGNATURE(BaselineDecImm8)799 DEF_CALL_SIGNATURE(BaselineDecImm8)
800 {
801 SINGLE_OP_SIGNATURE_DESC("BaselineDecImm8");
802 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
803 }
804
DEF_CALL_SIGNATURE(BaselineIsinImm8V8)805 DEF_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
DEF_CALL_SIGNATURE(BaselineInstanceofImm8V8)821 DEF_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
DEF_CALL_SIGNATURE(BaselineStrictnoteqImm8V8)837 DEF_CALL_SIGNATURE(BaselineStrictnoteqImm8V8)
838 {
839 BINARY_OP_SIGNATURE_DESC("BaselineStrictnoteqImm8V8");
840 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
841 }
842
DEF_CALL_SIGNATURE(BaselineStricteqImm8V8)843 DEF_CALL_SIGNATURE(BaselineStricteqImm8V8)
844 {
845 BINARY_OP_SIGNATURE_DESC("BaselineStricteqImm8V8");
846 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
847 }
848
DEF_CALL_SIGNATURE(BaselineIstrue)849 DEF_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
DEF_CALL_SIGNATURE(BaselineIsfalse)862 DEF_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
DEF_CALL_SIGNATURE(BaselineCallthis3Imm8V8V8V8V8)875 DEF_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
DEF_CALL_SIGNATURE(BaselineCallthisrangeImm8Imm8V8)892 DEF_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
DEF_CALL_SIGNATURE(BaselineSupercallthisrangeImm8Imm8V8)909 DEF_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
DEF_CALL_SIGNATURE(BaselineSupercallarrowrangeImm8Imm8V8)926 DEF_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
DEF_CALL_SIGNATURE(BaselineDefinefuncImm8Id16Imm8)943 DEF_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
DEF_CALL_SIGNATURE(BaselineDefinefuncImm16Id16Imm8)960 DEF_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
DEF_CALL_SIGNATURE(BaselineDefinemethodImm8Id16Imm8)977 DEF_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
DEF_CALL_SIGNATURE(BaselineDefinemethodImm16Id16Imm8)994 DEF_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
DEF_CALL_SIGNATURE(BaselineCallarg0Imm8)1011 DEF_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
DEF_CALL_SIGNATURE(BaselineSupercallspreadImm8V8)1026 DEF_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
DEF_CALL_SIGNATURE(BaselineApplyImm8V8V8)1043 DEF_CALL_SIGNATURE(BaselineApplyImm8V8V8)
1044 {
1045 // 5 : 5 input parameters
1046 CallSignature signature("BaselineApplyImm8V8V8", 0, 5,
1047 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1048 *callSign = signature;
1049 // 5 : 5 input parameters
1050 std::array<VariableType, 5> params = {
1051 VariableType::NATIVE_POINTER(),
1052 VariableType::NATIVE_POINTER(),
1053 VariableType::JS_ANY(),
1054 VariableType::JS_ANY(),
1055 VariableType::JS_ANY(),
1056 };
1057 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1058 }
1059
DEF_CALL_SIGNATURE(BaselineCallargs2Imm8V8V8)1060 DEF_CALL_SIGNATURE(BaselineCallargs2Imm8V8V8)
1061 {
1062 // 5 : 5 input parameters
1063 CallSignature signature("BaselineCallargs2Imm8V8V8", 0, 5,
1064 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1065 *callSign = signature;
1066 // 5 : 5 input parameters
1067 std::array<VariableType, 5> params = {
1068 VariableType::NATIVE_POINTER(),
1069 VariableType::NATIVE_POINTER(),
1070 VariableType::INT32(),
1071 VariableType::INT32(),
1072 VariableType::INT32(),
1073 };
1074 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1075 }
1076
DEF_CALL_SIGNATURE(BaselineCallargs3Imm8V8V8V8)1077 DEF_CALL_SIGNATURE(BaselineCallargs3Imm8V8V8V8)
1078 {
1079 // 6 : 6 input parameters
1080 CallSignature signature("BaselineCallargs3Imm8V8V8V8", 0, 6,
1081 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1082 *callSign = signature;
1083 // 6 : 6 input parameters
1084 std::array<VariableType, 6> params = {
1085 VariableType::NATIVE_POINTER(),
1086 VariableType::NATIVE_POINTER(),
1087 VariableType::INT32(),
1088 VariableType::INT32(),
1089 VariableType::INT32(),
1090 VariableType::INT32(),
1091 };
1092 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1093 }
1094
DEF_CALL_SIGNATURE(BaselineCallrangeImm8Imm8V8)1095 DEF_CALL_SIGNATURE(BaselineCallrangeImm8Imm8V8)
1096 {
1097 // 5 : 5 input parameters
1098 CallSignature signature("BaselineCallrangeImm8Imm8V8", 0, 5,
1099 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1100 *callSign = signature;
1101 // 5 : 5 input parameters
1102 std::array<VariableType, 5> params = {
1103 VariableType::NATIVE_POINTER(),
1104 VariableType::NATIVE_POINTER(),
1105 VariableType::INT32(),
1106 VariableType::INT32(),
1107 VariableType::INT32(),
1108 };
1109 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1110 }
1111
DEF_CALL_SIGNATURE(BaselineLdexternalmodulevarImm8)1112 DEF_CALL_SIGNATURE(BaselineLdexternalmodulevarImm8)
1113 {
1114 // 2 : 2 input parameters
1115 CallSignature signature("BaselineLdexternalmodulevarImm8", 0, 2,
1116 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1117 *callSign = signature;
1118 // 2 : 2 input parameters
1119 std::array<VariableType, 2> params = {
1120 VariableType::NATIVE_POINTER(),
1121 VariableType::INT8(),
1122 };
1123 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1124 }
1125
DEF_CALL_SIGNATURE(BaselineLdthisbynameImm8Id16)1126 DEF_CALL_SIGNATURE(BaselineLdthisbynameImm8Id16)
1127 {
1128 // 4 : 4 input parameters
1129 CallSignature signature("BaselineLdthisbynameImm8Id16", 0, 4,
1130 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1131 *callSign = signature;
1132 // 4 : 4 input parameters
1133 std::array<VariableType, 4> params = {
1134 VariableType::NATIVE_POINTER(),
1135 VariableType::NATIVE_POINTER(),
1136 VariableType::INT32(),
1137 VariableType::INT32(),
1138 };
1139 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1140 }
1141
DEF_CALL_SIGNATURE(BaselineDefinegettersetterbyvalueV8V8V8V8)1142 DEF_CALL_SIGNATURE(BaselineDefinegettersetterbyvalueV8V8V8V8)
1143 {
1144 // 4 : 4 input parameters
1145 CallSignature signature("BaselineDefinegettersetterbyvalueV8V8V8V8", 0, 4,
1146 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1147 *callSign = signature;
1148 // 4 : 4 input parameters
1149 std::array<VariableType, 4> params = {
1150 VariableType::NATIVE_POINTER(),
1151 VariableType::NATIVE_POINTER(),
1152 VariableType::INT32(),
1153 VariableType::INT32(),
1154 };
1155 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1156 }
1157
DEF_CALL_SIGNATURE(BaselineLdthisbynameImm16Id16)1158 DEF_CALL_SIGNATURE(BaselineLdthisbynameImm16Id16)
1159 {
1160 // 4 : 4 input parameters
1161 CallSignature signature("BaselineLdthisbynameImm16Id16", 0, 4,
1162 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1163 *callSign = signature;
1164 // 4 : 4 input parameters
1165 std::array<VariableType, 4> params = {
1166 VariableType::NATIVE_POINTER(),
1167 VariableType::NATIVE_POINTER(),
1168 VariableType::INT32(),
1169 VariableType::INT32(),
1170 };
1171 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1172 }
1173
DEF_CALL_SIGNATURE(BaselineStthisbynameImm8Id16)1174 DEF_CALL_SIGNATURE(BaselineStthisbynameImm8Id16)
1175 {
1176 // 4 : 4 input parameters
1177 CallSignature signature("BaselineStthisbynameImm8Id16", 0, 4,
1178 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1179 *callSign = signature;
1180 // 4 : 4 input parameters
1181 std::array<VariableType, 4> params = {
1182 VariableType::NATIVE_POINTER(),
1183 VariableType::NATIVE_POINTER(),
1184 VariableType::INT32(),
1185 VariableType::INT32(),
1186 };
1187 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1188 }
1189
DEF_CALL_SIGNATURE(BaselineStthisbynameImm16Id16)1190 DEF_CALL_SIGNATURE(BaselineStthisbynameImm16Id16)
1191 {
1192 // 4 : 4 input parameters
1193 CallSignature signature("BaselineStthisbynameImm16Id16", 0, 4,
1194 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1195 *callSign = signature;
1196 // 4 : 4 input parameters
1197 std::array<VariableType, 4> params = {
1198 VariableType::NATIVE_POINTER(),
1199 VariableType::NATIVE_POINTER(),
1200 VariableType::INT32(),
1201 VariableType::INT32(),
1202 };
1203 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1204 }
1205
DEF_CALL_SIGNATURE(BaselineLdthisbyvalueImm8)1206 DEF_CALL_SIGNATURE(BaselineLdthisbyvalueImm8)
1207 {
1208 // 3 : 3 input parameters
1209 CallSignature signature("BaselineLdthisbyvalueImm8", 0, 3,
1210 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1211 *callSign = signature;
1212 // 3 : 3 input parameters
1213 std::array<VariableType, 3> params = {
1214 VariableType::NATIVE_POINTER(),
1215 VariableType::NATIVE_POINTER(),
1216 VariableType::INT32(),
1217 };
1218 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1219 }
1220
DEF_CALL_SIGNATURE(BaselineLdthisbyvalueImm16)1221 DEF_CALL_SIGNATURE(BaselineLdthisbyvalueImm16)
1222 {
1223 // 3 : 3 input parameters
1224 CallSignature signature("BaselineLdthisbyvalueImm16", 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
DEF_CALL_SIGNATURE(BaselineStthisbyvalueImm8V8)1236 DEF_CALL_SIGNATURE(BaselineStthisbyvalueImm8V8)
1237 {
1238 // 4 : 4 input parameters
1239 CallSignature signature("BaselineStthisbyvalueImm8V8", 0, 4,
1240 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1241 *callSign = signature;
1242 // 4 : 4 input parameters
1243 std::array<VariableType, 4> params = {
1244 VariableType::NATIVE_POINTER(),
1245 VariableType::NATIVE_POINTER(),
1246 VariableType::INT32(),
1247 VariableType::JS_ANY(),
1248 };
1249 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1250 }
1251
DEF_CALL_SIGNATURE(BaselineStthisbyvalueImm16V8)1252 DEF_CALL_SIGNATURE(BaselineStthisbyvalueImm16V8)
1253 {
1254 // 4 : 4 input parameters
1255 CallSignature signature("BaselineStthisbyvalueImm16V8", 0, 4,
1256 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1257 *callSign = signature;
1258 // 4 : 4 input parameters
1259 std::array<VariableType, 4> params = {
1260 VariableType::NATIVE_POINTER(),
1261 VariableType::NATIVE_POINTER(),
1262 VariableType::INT32(),
1263 VariableType::JS_ANY(),
1264 };
1265 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1266 }
1267
DEF_CALL_SIGNATURE(BaselineDynamicimport)1268 DEF_CALL_SIGNATURE(BaselineDynamicimport)
1269 {
1270 // 2 : 2 input parameters
1271 CallSignature signature("BaselineDynamicimport", 0, 2,
1272 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1273 *callSign = signature;
1274 // 2 : 2 input parameters
1275 std::array<VariableType, 2> params = {
1276 VariableType::NATIVE_POINTER(),
1277 VariableType::NATIVE_POINTER(),
1278 };
1279 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1280 }
1281
DEF_CALL_SIGNATURE(BaselineDefineclasswithbufferImm8Id16Id16Imm16V8)1282 DEF_CALL_SIGNATURE(BaselineDefineclasswithbufferImm8Id16Id16Imm16V8)
1283 {
1284 // 6 : 6 input parameters
1285 CallSignature signature("BaselineDefineclasswithbufferImm8Id16Id16Imm16V8", 0, 6,
1286 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1287 *callSign = signature;
1288 // 6 : 6 input parameters
1289 std::array<VariableType, 6> params = {
1290 VariableType::NATIVE_POINTER(),
1291 VariableType::NATIVE_POINTER(),
1292 VariableType::INT16(),
1293 VariableType::INT16(),
1294 VariableType::INT16(),
1295 VariableType::INT8(),
1296 };
1297 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1298 }
1299
DEF_CALL_SIGNATURE(BaselineDefineclasswithbufferImm16Id16Id16Imm16V8)1300 DEF_CALL_SIGNATURE(BaselineDefineclasswithbufferImm16Id16Id16Imm16V8)
1301 {
1302 // 5 : 5 input parameters
1303 CallSignature signature("BaselineDefineclasswithbufferImm16Id16Id16Imm16V8", 0, 5,
1304 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1305 *callSign = signature;
1306 // 5 : 5 input parameters
1307 std::array<VariableType, 5> params = {
1308 VariableType::NATIVE_POINTER(),
1309 VariableType::NATIVE_POINTER(),
1310 VariableType::INT32(),
1311 VariableType::INT32(),
1312 VariableType::INT32(),
1313 };
1314 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1315 }
1316
DEF_CALL_SIGNATURE(BaselineResumegenerator)1317 DEF_CALL_SIGNATURE(BaselineResumegenerator)
1318 {
1319 // 3 : 3 input parameters
1320 CallSignature signature("BaselineResumegenerator", 0, 3,
1321 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1322 *callSign = signature;
1323 // 3 : 3 input parameters
1324 std::array<VariableType, 3> params = {
1325 VariableType::NATIVE_POINTER(),
1326 VariableType::NATIVE_POINTER(),
1327 VariableType::JS_ANY(),
1328 };
1329 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1330 }
1331
DEF_CALL_SIGNATURE(BaselineGetresumemod)1332 DEF_CALL_SIGNATURE(BaselineGetresumemod)
1333 {
1334 // 1 : 1 input parameters
1335 CallSignature signature("BaselineGetresumemod", 0, 1,
1336 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1337 *callSign = signature;
1338 // 1 : 1 input parameters
1339 std::array<VariableType, 1> params = {
1340 VariableType::JS_ANY(),
1341 };
1342 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1343 }
1344
DEF_CALL_SIGNATURE(BaselineGettemplateobjectImm8)1345 DEF_CALL_SIGNATURE(BaselineGettemplateobjectImm8)
1346 {
1347 // 3 : 3 input parameters
1348 CallSignature signature("BaselineGettemplateobjectImm8", 0, 3,
1349 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1350 *callSign = signature;
1351 // 3 : 3 input parameters
1352 std::array<VariableType, 3> params = {
1353 VariableType::NATIVE_POINTER(),
1354 VariableType::NATIVE_POINTER(),
1355 VariableType::JS_ANY(),
1356 };
1357 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1358 }
1359
DEF_CALL_SIGNATURE(BaselineGettemplateobjectImm16)1360 DEF_CALL_SIGNATURE(BaselineGettemplateobjectImm16)
1361 {
1362 // 3 : 3 input parameters
1363 CallSignature signature("BaselineGettemplateobjectImm16", 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
DEF_CALL_SIGNATURE(BaselineGetnextpropnameV8)1375 DEF_CALL_SIGNATURE(BaselineGetnextpropnameV8)
1376 {
1377 // 3 : 3 input parameters
1378 CallSignature signature("BaselineGetnextpropnameV8", 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
DEF_CALL_SIGNATURE(BaselineSetobjectwithprotoImm8V8)1390 DEF_CALL_SIGNATURE(BaselineSetobjectwithprotoImm8V8)
1391 {
1392 // 4 : 4 input parameters
1393 CallSignature signature("BaselineSetobjectwithprotoImm8V8", 0, 4,
1394 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1395 *callSign = signature;
1396 // 4 : 4 input parameters
1397 std::array<VariableType, 4> params = {
1398 VariableType::NATIVE_POINTER(),
1399 VariableType::NATIVE_POINTER(),
1400 VariableType::JS_ANY(),
1401 VariableType::JS_ANY(),
1402 };
1403 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1404 }
1405
DEF_CALL_SIGNATURE(BaselineDelobjpropV8)1406 DEF_CALL_SIGNATURE(BaselineDelobjpropV8)
1407 {
1408 // 4 : 4 input parameters
1409 CallSignature signature("BaselineDelobjpropV8", 0, 4,
1410 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1411 *callSign = signature;
1412 // 4 : 4 input parameters
1413 std::array<VariableType, 4> params = {
1414 VariableType::NATIVE_POINTER(),
1415 VariableType::NATIVE_POINTER(),
1416 VariableType::JS_ANY(),
1417 VariableType::JS_ANY(),
1418 };
1419 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1420 }
1421
DEF_CALL_SIGNATURE(BaselineAsyncfunctionawaituncaughtV8)1422 DEF_CALL_SIGNATURE(BaselineAsyncfunctionawaituncaughtV8)
1423 {
1424 // 4 : 4 input parameters
1425 CallSignature signature("BaselineAsyncfunctionawaituncaughtV8", 0, 4,
1426 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1427 *callSign = signature;
1428 // 4 : 4 input parameters
1429 std::array<VariableType, 4> params = {
1430 VariableType::NATIVE_POINTER(),
1431 VariableType::NATIVE_POINTER(),
1432 VariableType::JS_ANY(),
1433 VariableType::JS_ANY(),
1434 };
1435 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1436 }
1437
DEF_CALL_SIGNATURE(BaselineCopydatapropertiesV8)1438 DEF_CALL_SIGNATURE(BaselineCopydatapropertiesV8)
1439 {
1440 // 4 : 4 input parameters
1441 CallSignature signature("BaselineCopydatapropertiesV8", 0, 4,
1442 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1443 *callSign = signature;
1444 // 4 : 4 input parameters
1445 std::array<VariableType, 4> params = {
1446 VariableType::NATIVE_POINTER(),
1447 VariableType::NATIVE_POINTER(),
1448 VariableType::JS_ANY(),
1449 VariableType::JS_ANY(),
1450 };
1451 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1452 }
1453
DEF_CALL_SIGNATURE(BaselineStarrayspreadV8V8)1454 DEF_CALL_SIGNATURE(BaselineStarrayspreadV8V8)
1455 {
1456 // 5 : 5 input parameters
1457 CallSignature signature("BaselineStarrayspreadV8V8", 0, 5,
1458 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1459 *callSign = signature;
1460 // 5 : 5 input parameters
1461 std::array<VariableType, 5> params = {
1462 VariableType::NATIVE_POINTER(),
1463 VariableType::NATIVE_POINTER(),
1464 VariableType::JS_ANY(),
1465 VariableType::JS_ANY(),
1466 VariableType::JS_ANY(),
1467 };
1468 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1469 }
1470
DEF_CALL_SIGNATURE(BaselineSetobjectwithprotoImm16V8)1471 DEF_CALL_SIGNATURE(BaselineSetobjectwithprotoImm16V8)
1472 {
1473 // 4 : 4 input parameters
1474 CallSignature signature("BaselineSetobjectwithprotoImm16V8", 0, 4,
1475 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1476 *callSign = signature;
1477 // 4 : 4 input parameters
1478 std::array<VariableType, 4> params = {
1479 VariableType::NATIVE_POINTER(),
1480 VariableType::NATIVE_POINTER(),
1481 VariableType::JS_ANY(),
1482 VariableType::JS_ANY(),
1483 };
1484 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1485 }
1486
DEF_CALL_SIGNATURE(BaselineLdobjbyvalueImm8V8)1487 DEF_CALL_SIGNATURE(BaselineLdobjbyvalueImm8V8)
1488 {
1489 // 4 : 4 input parameters
1490 CallSignature signature("BaselineLdobjbyvalueImm8V8", 0, 4,
1491 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1492 *callSign = signature;
1493 // 4 : 4 input parameters
1494 std::array<VariableType, 4> params = {
1495 VariableType::NATIVE_POINTER(),
1496 VariableType::NATIVE_POINTER(),
1497 VariableType::JS_ANY(),
1498 VariableType::INT32(),
1499 };
1500 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1501 }
1502
DEF_CALL_SIGNATURE(BaselineLdobjbyvalueImm16V8)1503 DEF_CALL_SIGNATURE(BaselineLdobjbyvalueImm16V8)
1504 {
1505 // 4 : 4 input parameters
1506 CallSignature signature("BaselineLdobjbyvalueImm16V8", 0, 4,
1507 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1508 *callSign = signature;
1509 // 4 : 4 input parameters
1510 std::array<VariableType, 4> params = {
1511 VariableType::NATIVE_POINTER(),
1512 VariableType::NATIVE_POINTER(),
1513 VariableType::JS_ANY(),
1514 VariableType::INT32(),
1515 };
1516 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1517 }
1518
DEF_CALL_SIGNATURE(BaselineStobjbyvalueImm8V8V8)1519 DEF_CALL_SIGNATURE(BaselineStobjbyvalueImm8V8V8)
1520 {
1521 // 5 : 5 input parameters
1522 CallSignature signature("BaselineStobjbyvalueImm8V8V8", 0, 5,
1523 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1524 *callSign = signature;
1525 // 5 : 5 input parameters
1526 std::array<VariableType, 5> params = {
1527 VariableType::NATIVE_POINTER(),
1528 VariableType::NATIVE_POINTER(),
1529 VariableType::JS_ANY(),
1530 VariableType::INT32(),
1531 VariableType::JS_ANY(),
1532 };
1533 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1534 }
1535
DEF_CALL_SIGNATURE(BaselineStobjbyvalueImm16V8V8)1536 DEF_CALL_SIGNATURE(BaselineStobjbyvalueImm16V8V8)
1537 {
1538 // 5 : 5 input parameters
1539 CallSignature signature("BaselineStobjbyvalueImm16V8V8", 0, 5,
1540 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1541 *callSign = signature;
1542 // 5 : 5 input parameters
1543 std::array<VariableType, 5> params = {
1544 VariableType::NATIVE_POINTER(),
1545 VariableType::NATIVE_POINTER(),
1546 VariableType::JS_ANY(),
1547 VariableType::INT32(),
1548 VariableType::JS_ANY(),
1549 };
1550 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1551 }
1552
DEF_CALL_SIGNATURE(BaselineStownbyvalueImm8V8V8)1553 DEF_CALL_SIGNATURE(BaselineStownbyvalueImm8V8V8)
1554 {
1555 // 5 : 5 input parameters
1556 CallSignature signature("BaselineStownbyvalueImm8V8V8", 0, 5,
1557 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1558 *callSign = signature;
1559 // 5 : 5 input parameters
1560 std::array<VariableType, 5> params = {
1561 VariableType::NATIVE_POINTER(),
1562 VariableType::NATIVE_POINTER(),
1563 VariableType::INT32(),
1564 VariableType::INT32(),
1565 VariableType::INT32(),
1566 };
1567 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1568 }
1569
DEF_CALL_SIGNATURE(BaselineStownbyvalueImm16V8V8)1570 DEF_CALL_SIGNATURE(BaselineStownbyvalueImm16V8V8)
1571 {
1572 // 5 : 5 input parameters
1573 CallSignature signature("BaselineStownbyvalueImm16V8V8", 0, 5,
1574 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1575 *callSign = signature;
1576 // 5 : 5 input parameters
1577 std::array<VariableType, 5> params = {
1578 VariableType::NATIVE_POINTER(),
1579 VariableType::NATIVE_POINTER(),
1580 VariableType::JS_ANY(),
1581 VariableType::JS_ANY(),
1582 VariableType::INT32(),
1583 };
1584 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1585 }
1586
DEF_CALL_SIGNATURE(BaselineLdsuperbyvalueImm8V8)1587 DEF_CALL_SIGNATURE(BaselineLdsuperbyvalueImm8V8)
1588 {
1589 // 4 : 4 input parameters
1590 CallSignature signature("BaselineLdsuperbyvalueImm8V8", 0, 4,
1591 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1592 *callSign = signature;
1593 // 4 : 4 input parameters
1594 std::array<VariableType, 4> params = {
1595 VariableType::NATIVE_POINTER(),
1596 VariableType::NATIVE_POINTER(),
1597 VariableType::JS_ANY(),
1598 VariableType::JS_ANY(),
1599 };
1600 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1601 }
1602
DEF_CALL_SIGNATURE(BaselineLdsuperbyvalueImm16V8)1603 DEF_CALL_SIGNATURE(BaselineLdsuperbyvalueImm16V8)
1604 {
1605 // 4 : 4 input parameters
1606 CallSignature signature("BaselineLdsuperbyvalueImm16V8", 0, 4,
1607 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1608 *callSign = signature;
1609 // 4 : 4 input parameters
1610 std::array<VariableType, 4> params = {
1611 VariableType::NATIVE_POINTER(),
1612 VariableType::NATIVE_POINTER(),
1613 VariableType::JS_ANY(),
1614 VariableType::JS_ANY(),
1615 };
1616 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1617 }
1618
DEF_CALL_SIGNATURE(BaselineStsuperbyvalueImm8V8V8)1619 DEF_CALL_SIGNATURE(BaselineStsuperbyvalueImm8V8V8)
1620 {
1621 // 4 : 4 input parameters
1622 CallSignature signature("BaselineStsuperbyvalueImm8V8V8", 0, 4,
1623 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1624 *callSign = signature;
1625 // 4 : 4 input parameters
1626 std::array<VariableType, 4> params = {
1627 VariableType::NATIVE_POINTER(),
1628 VariableType::NATIVE_POINTER(),
1629 VariableType::JS_ANY(),
1630 VariableType::JS_ANY(),
1631 };
1632 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1633 }
1634
DEF_CALL_SIGNATURE(BaselineStsuperbyvalueImm16V8V8)1635 DEF_CALL_SIGNATURE(BaselineStsuperbyvalueImm16V8V8)
1636 {
1637 // 4 : 4 input parameters
1638 CallSignature signature("BaselineStsuperbyvalueImm16V8V8", 0, 4,
1639 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1640 *callSign = signature;
1641 // 4 : 4 input parameters
1642 std::array<VariableType, 4> params = {
1643 VariableType::NATIVE_POINTER(),
1644 VariableType::NATIVE_POINTER(),
1645 VariableType::JS_ANY(),
1646 VariableType::JS_ANY(),
1647 };
1648 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1649 }
1650
DEF_CALL_SIGNATURE(BaselineLdobjbyindexImm8Imm16)1651 DEF_CALL_SIGNATURE(BaselineLdobjbyindexImm8Imm16)
1652 {
1653 // 4 : 4 input parameters
1654 CallSignature signature("BaselineLdobjbyindexImm8Imm16", 0, 4,
1655 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1656 *callSign = signature;
1657 // 4 : 4 input parameters
1658 std::array<VariableType, 4> params = {
1659 VariableType::NATIVE_POINTER(),
1660 VariableType::NATIVE_POINTER(),
1661 VariableType::INT32(),
1662 VariableType::INT32(),
1663 };
1664 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1665 }
1666
DEF_CALL_SIGNATURE(BaselineLdobjbyindexImm16Imm16)1667 DEF_CALL_SIGNATURE(BaselineLdobjbyindexImm16Imm16)
1668 {
1669 // 4 : 4 input parameters
1670 CallSignature signature("BaselineLdobjbyindexImm16Imm16", 0, 4,
1671 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1672 *callSign = signature;
1673 // 4 : 4 input parameters
1674 std::array<VariableType, 4> params = {
1675 VariableType::NATIVE_POINTER(),
1676 VariableType::NATIVE_POINTER(),
1677 VariableType::INT32(),
1678 VariableType::INT32(),
1679 };
1680 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1681 }
1682
DEF_CALL_SIGNATURE(BaselineStobjbyindexImm8V8Imm16)1683 DEF_CALL_SIGNATURE(BaselineStobjbyindexImm8V8Imm16)
1684 {
1685 // 4 : 4 input parameters
1686 CallSignature signature("BaselineStobjbyindexImm8V8Imm16", 0, 4,
1687 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1688 *callSign = signature;
1689 // 4 : 4 input parameters
1690 std::array<VariableType, 4> params = {
1691 VariableType::NATIVE_POINTER(),
1692 VariableType::NATIVE_POINTER(),
1693 VariableType::JS_ANY(),
1694 VariableType::INT32(),
1695 };
1696 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1697 }
1698
DEF_CALL_SIGNATURE(BaselineStobjbyindexImm16V8Imm16)1699 DEF_CALL_SIGNATURE(BaselineStobjbyindexImm16V8Imm16)
1700 {
1701 // 5 : 5 input parameters
1702 CallSignature signature("BaselineStobjbyindexImm16V8Imm16", 0, 5,
1703 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1704 *callSign = signature;
1705 // 5 : 5 input parameters
1706 std::array<VariableType, 5> params = {
1707 VariableType::NATIVE_POINTER(),
1708 VariableType::NATIVE_POINTER(),
1709 VariableType::JS_ANY(),
1710 VariableType::INT32(),
1711 VariableType::INT32(),
1712 };
1713 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1714 }
1715
DEF_CALL_SIGNATURE(BaselineStownbyindexImm8V8Imm16)1716 DEF_CALL_SIGNATURE(BaselineStownbyindexImm8V8Imm16)
1717 {
1718 // 5 : 5 input parameters
1719 CallSignature signature("BaselineStownbyindexImm8V8Imm16", 0, 5,
1720 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1721 *callSign = signature;
1722 // 5 : 5 input parameters
1723 std::array<VariableType, 5> params = {
1724 VariableType::NATIVE_POINTER(),
1725 VariableType::NATIVE_POINTER(),
1726 VariableType::JS_ANY(),
1727 VariableType::JS_ANY(),
1728 VariableType::INT32(),
1729 };
1730 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1731 }
1732
DEF_CALL_SIGNATURE(BaselineStownbyindexImm16V8Imm16)1733 DEF_CALL_SIGNATURE(BaselineStownbyindexImm16V8Imm16)
1734 {
1735 // 5 : 5 input parameters
1736 CallSignature signature("BaselineStownbyindexImm16V8Imm16", 0, 5,
1737 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1738 *callSign = signature;
1739 // 5 : 5 input parameters
1740 std::array<VariableType, 5> params = {
1741 VariableType::NATIVE_POINTER(),
1742 VariableType::NATIVE_POINTER(),
1743 VariableType::JS_ANY(),
1744 VariableType::JS_ANY(),
1745 VariableType::INT32(),
1746 };
1747 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1748 }
1749
DEF_CALL_SIGNATURE(BaselineAsyncfunctionresolveV8)1750 DEF_CALL_SIGNATURE(BaselineAsyncfunctionresolveV8)
1751 {
1752 // 4 : 4 input parameters
1753 CallSignature signature("BaselineAsyncfunctionresolveV8", 0, 4,
1754 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1755 *callSign = signature;
1756 // 4 : 4 input parameters
1757 std::array<VariableType, 4> params = {
1758 VariableType::NATIVE_POINTER(),
1759 VariableType::NATIVE_POINTER(),
1760 VariableType::JS_ANY(),
1761 VariableType::JS_ANY(),
1762 };
1763 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1764 }
1765
DEF_CALL_SIGNATURE(BaselineAsyncfunctionrejectV8)1766 DEF_CALL_SIGNATURE(BaselineAsyncfunctionrejectV8)
1767 {
1768 // 4 : 4 input parameters
1769 CallSignature signature("BaselineAsyncfunctionrejectV8", 0, 4,
1770 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1771 *callSign = signature;
1772 // 4 : 4 input parameters
1773 std::array<VariableType, 4> params = {
1774 VariableType::NATIVE_POINTER(),
1775 VariableType::NATIVE_POINTER(),
1776 VariableType::JS_ANY(),
1777 VariableType::JS_ANY(),
1778 };
1779 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1780 }
1781
DEF_CALL_SIGNATURE(BaselineCopyrestargsImm8)1782 DEF_CALL_SIGNATURE(BaselineCopyrestargsImm8)
1783 {
1784 // 4 : 4 input parameters
1785 CallSignature signature("BaselineCopyrestargsImm8", 0, 4,
1786 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1787 *callSign = signature;
1788 // 4 : 4 input parameters
1789 std::array<VariableType, 4> params = {
1790 VariableType::NATIVE_POINTER(),
1791 VariableType::NATIVE_POINTER(),
1792 VariableType::JS_ANY(),
1793 VariableType::INT32(),
1794 };
1795 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1796 }
1797
DEF_CALL_SIGNATURE(BaselineLdlexvarImm4Imm4)1798 DEF_CALL_SIGNATURE(BaselineLdlexvarImm4Imm4)
1799 {
1800 // 3 : 3 input parameters
1801 CallSignature signature("BaselineLdlexvarImm4Imm4", 0, 3,
1802 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1803 *callSign = signature;
1804 // 3 : 3 input parameters
1805 std::array<VariableType, 3> params = {
1806 VariableType::NATIVE_POINTER(),
1807 VariableType::INT32(),
1808 VariableType::INT32(),
1809 };
1810 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1811 }
1812
DEF_CALL_SIGNATURE(BaselineStlexvarImm4Imm4)1813 DEF_CALL_SIGNATURE(BaselineStlexvarImm4Imm4)
1814 {
1815 // 5 : 5 input parameters
1816 CallSignature signature("BaselineStlexvarImm4Imm4", 0, 5,
1817 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1818 *callSign = signature;
1819 // 5 : 5 input parameters
1820 std::array<VariableType, 5> params = {
1821 VariableType::NATIVE_POINTER(),
1822 VariableType::NATIVE_POINTER(),
1823 VariableType::JS_ANY(),
1824 VariableType::INT32(),
1825 VariableType::INT32(),
1826 };
1827 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1828 }
1829
DEF_CALL_SIGNATURE(BaselineGetmodulenamespaceImm8)1830 DEF_CALL_SIGNATURE(BaselineGetmodulenamespaceImm8)
1831 {
1832 // 2 : 2 input parameters
1833 CallSignature signature("BaselineGetmodulenamespaceImm8", 0, 2,
1834 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1835 *callSign = signature;
1836 // 2 : 2 input parameters
1837 std::array<VariableType, 2> params = {
1838 VariableType::NATIVE_POINTER(),
1839 VariableType::INT32(),
1840 };
1841 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1842 }
1843
DEF_CALL_SIGNATURE(BaselineStmodulevarImm8)1844 DEF_CALL_SIGNATURE(BaselineStmodulevarImm8)
1845 {
1846 // 3 : 3 input parameters
1847 CallSignature signature("BaselineStmodulevarImm8", 0, 3,
1848 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1849 *callSign = signature;
1850 // 3 : 3 input parameters
1851 std::array<VariableType, 3> params = {
1852 VariableType::NATIVE_POINTER(),
1853 VariableType::JS_ANY(),
1854 VariableType::INT8(),
1855 };
1856 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1857 }
1858
DEF_CALL_SIGNATURE(BaselineTrystglobalbynameImm8Id16)1859 DEF_CALL_SIGNATURE(BaselineTrystglobalbynameImm8Id16)
1860 {
1861 // 4 : 4 input parameters
1862 CallSignature signature("BaselineTrystglobalbynameImm8Id16", 0, 4,
1863 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1864 *callSign = signature;
1865 // 4 : 4 input parameters
1866 std::array<VariableType, 4> params = {
1867 VariableType::NATIVE_POINTER(),
1868 VariableType::NATIVE_POINTER(),
1869 VariableType::INT32(),
1870 VariableType::INT32(),
1871 };
1872 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1873 }
1874
DEF_CALL_SIGNATURE(BaselineTryldglobalbynameImm16Id16)1875 DEF_CALL_SIGNATURE(BaselineTryldglobalbynameImm16Id16)
1876 {
1877 // 4 : 4 input parameters
1878 CallSignature signature("BaselineTryldglobalbynameImm16Id16", 0, 4,
1879 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1880 *callSign = signature;
1881 // 4 : 4 input parameters
1882 std::array<VariableType, 4> params = {
1883 VariableType::NATIVE_POINTER(),
1884 VariableType::NATIVE_POINTER(),
1885 VariableType::INT32(),
1886 VariableType::INT32(),
1887 };
1888 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1889 }
1890
DEF_CALL_SIGNATURE(BaselineTrystglobalbynameImm16Id16)1891 DEF_CALL_SIGNATURE(BaselineTrystglobalbynameImm16Id16)
1892 {
1893 // 4 : 4 input parameters
1894 CallSignature signature("BaselineTrystglobalbynameImm16Id16", 0, 4,
1895 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1896 *callSign = signature;
1897 // 4 : 4 input parameters
1898 std::array<VariableType, 4> params = {
1899 VariableType::NATIVE_POINTER(),
1900 VariableType::NATIVE_POINTER(),
1901 VariableType::INT32(),
1902 VariableType::INT32(),
1903 };
1904 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1905 }
1906
DEF_CALL_SIGNATURE(BaselineLdglobalvarImm16Id16)1907 DEF_CALL_SIGNATURE(BaselineLdglobalvarImm16Id16)
1908 {
1909 // 4 : 4 input parameters
1910 CallSignature signature("BaselineLdglobalvarImm16Id16", 0, 4,
1911 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1912 *callSign = signature;
1913 // 4 : 4 input parameters
1914 std::array<VariableType, 4> params = {
1915 VariableType::NATIVE_POINTER(),
1916 VariableType::NATIVE_POINTER(),
1917 VariableType::INT32(),
1918 VariableType::INT32(),
1919 };
1920 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1921 }
1922
DEF_CALL_SIGNATURE(BaselineStglobalvarImm16Id16)1923 DEF_CALL_SIGNATURE(BaselineStglobalvarImm16Id16)
1924 {
1925 // 5 : 5 input parameters
1926 CallSignature signature("BaselineStglobalvarImm16Id16", 0, 5,
1927 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1928 *callSign = signature;
1929 // 5 : 5 input parameters
1930 std::array<VariableType, 5> params = {
1931 VariableType::NATIVE_POINTER(),
1932 VariableType::NATIVE_POINTER(),
1933 VariableType::JS_ANY(),
1934 VariableType::INT32(),
1935 VariableType::INT32(),
1936 };
1937 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1938 }
1939
DEF_CALL_SIGNATURE(BaselineLdobjbynameImm8Id16)1940 DEF_CALL_SIGNATURE(BaselineLdobjbynameImm8Id16)
1941 {
1942 // 4 : 4 input parameters
1943 CallSignature signature("BaselineLdobjbynameImm8Id16", 0, 4,
1944 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1945 *callSign = signature;
1946 // 4 : 4 input parameters
1947 std::array<VariableType, 4> params = {
1948 VariableType::NATIVE_POINTER(),
1949 VariableType::NATIVE_POINTER(),
1950 VariableType::INT32(),
1951 VariableType::INT32(),
1952 };
1953 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1954 }
1955
DEF_CALL_SIGNATURE(BaselineLdobjbynameImm16Id16)1956 DEF_CALL_SIGNATURE(BaselineLdobjbynameImm16Id16)
1957 {
1958 // 4 : 4 input parameters
1959 CallSignature signature("BaselineLdobjbynameImm16Id16", 0, 4,
1960 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1961 *callSign = signature;
1962 // 4 : 4 input parameters
1963 std::array<VariableType, 4> params = {
1964 VariableType::NATIVE_POINTER(),
1965 VariableType::NATIVE_POINTER(),
1966 VariableType::INT32(),
1967 VariableType::INT32(),
1968 };
1969 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1970 }
1971
DEF_CALL_SIGNATURE(BaselineStobjbynameImm8Id16V8)1972 DEF_CALL_SIGNATURE(BaselineStobjbynameImm8Id16V8)
1973 {
1974 // 5 : 5 input parameters
1975 CallSignature signature("BaselineStobjbynameImm8Id16V8", 0, 5,
1976 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1977 *callSign = signature;
1978 // 5 : 5 input parameters
1979 std::array<VariableType, 5> params = {
1980 VariableType::NATIVE_POINTER(),
1981 VariableType::NATIVE_POINTER(),
1982 VariableType::INT32(),
1983 VariableType::INT32(),
1984 VariableType::JS_ANY(),
1985 };
1986 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
1987 }
1988
DEF_CALL_SIGNATURE(BaselineStobjbynameImm16Id16V8)1989 DEF_CALL_SIGNATURE(BaselineStobjbynameImm16Id16V8)
1990 {
1991 // 5 : 5 input parameters
1992 CallSignature signature("BaselineStobjbynameImm16Id16V8", 0, 5,
1993 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1994 *callSign = signature;
1995 // 5 : 5 input parameters
1996 std::array<VariableType, 5> params = {
1997 VariableType::NATIVE_POINTER(),
1998 VariableType::NATIVE_POINTER(),
1999 VariableType::INT32(),
2000 VariableType::INT32(),
2001 VariableType::JS_ANY(),
2002 };
2003 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2004 }
2005
DEF_CALL_SIGNATURE(BaselineStownbynameImm8Id16V8)2006 DEF_CALL_SIGNATURE(BaselineStownbynameImm8Id16V8)
2007 {
2008 // 5 : 5 input parameters
2009 CallSignature signature("BaselineStownbynameImm8Id16V8", 0, 5,
2010 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2011 *callSign = signature;
2012 // 5 : 5 input parameters
2013 std::array<VariableType, 5> params = {
2014 VariableType::NATIVE_POINTER(),
2015 VariableType::NATIVE_POINTER(),
2016 VariableType::INT32(),
2017 VariableType::INT32(),
2018 VariableType::INT32(),
2019 };
2020 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2021 }
2022
DEF_CALL_SIGNATURE(BaselineStownbynameImm16Id16V8)2023 DEF_CALL_SIGNATURE(BaselineStownbynameImm16Id16V8)
2024 {
2025 // 5 : 5 input parameters
2026 CallSignature signature("BaselineStownbynameImm16Id16V8", 0, 5,
2027 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2028 *callSign = signature;
2029 // 5 : 5 input parameters
2030 std::array<VariableType, 5> params = {
2031 VariableType::NATIVE_POINTER(),
2032 VariableType::NATIVE_POINTER(),
2033 VariableType::JS_ANY(),
2034 VariableType::INT32(),
2035 VariableType::INT32(),
2036 };
2037 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2038 }
2039
DEF_CALL_SIGNATURE(BaselineLdsuperbynameImm8Id16)2040 DEF_CALL_SIGNATURE(BaselineLdsuperbynameImm8Id16)
2041 {
2042 // 3 : 3 input parameters
2043 CallSignature signature("BaselineLdsuperbynameImm8Id16", 0, 3,
2044 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2045 *callSign = signature;
2046 // 3 : 3 input parameters
2047 std::array<VariableType, 3> params = {
2048 VariableType::NATIVE_POINTER(),
2049 VariableType::NATIVE_POINTER(),
2050 VariableType::INT32(),
2051 };
2052 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2053 }
2054
DEF_CALL_SIGNATURE(BaselineLdsuperbynameImm16Id16)2055 DEF_CALL_SIGNATURE(BaselineLdsuperbynameImm16Id16)
2056 {
2057 // 3 : 3 input parameters
2058 CallSignature signature("BaselineLdsuperbynameImm16Id16", 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
DEF_CALL_SIGNATURE(BaselineStsuperbynameImm8Id16V8)2070 DEF_CALL_SIGNATURE(BaselineStsuperbynameImm8Id16V8)
2071 {
2072 // 5 : 5 input parameters
2073 CallSignature signature("BaselineStsuperbynameImm8Id16V8", 0, 5,
2074 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2075 *callSign = signature;
2076 // 5 : 5 input parameters
2077 std::array<VariableType, 5> params = {
2078 VariableType::NATIVE_POINTER(),
2079 VariableType::NATIVE_POINTER(),
2080 VariableType::JS_ANY(),
2081 VariableType::JS_ANY(),
2082 VariableType::INT32(),
2083 };
2084 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2085 }
2086
DEF_CALL_SIGNATURE(BaselineStsuperbynameImm16Id16V8)2087 DEF_CALL_SIGNATURE(BaselineStsuperbynameImm16Id16V8)
2088 {
2089 // 5 : 5 input parameters
2090 CallSignature signature("BaselineStsuperbynameImm16Id16V8", 0, 5,
2091 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2092 *callSign = signature;
2093 // 5 : 5 input parameters
2094 std::array<VariableType, 5> params = {
2095 VariableType::NATIVE_POINTER(),
2096 VariableType::NATIVE_POINTER(),
2097 VariableType::JS_ANY(),
2098 VariableType::JS_ANY(),
2099 VariableType::INT32(),
2100 };
2101 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2102 }
2103
DEF_CALL_SIGNATURE(BaselineLdlocalmodulevarImm8)2104 DEF_CALL_SIGNATURE(BaselineLdlocalmodulevarImm8)
2105 {
2106 // 2 : 2 input parameters
2107 CallSignature signature("BaselineLdlocalmodulevarImm8", 0, 2,
2108 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2109 *callSign = signature;
2110 // 2 : 2 input parameters
2111 std::array<VariableType, 2> params = {
2112 VariableType::NATIVE_POINTER(),
2113 VariableType::INT8(),
2114 };
2115 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2116 }
2117
DEF_CALL_SIGNATURE(BaselineStconsttoglobalrecordImm16Id16)2118 DEF_CALL_SIGNATURE(BaselineStconsttoglobalrecordImm16Id16)
2119 {
2120 // 4 : 4 input parameters
2121 CallSignature signature("BaselineStconsttoglobalrecordImm16Id16", 0, 4,
2122 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2123 *callSign = signature;
2124 // 4 : 4 input parameters
2125 std::array<VariableType, 4> params = {
2126 VariableType::NATIVE_POINTER(),
2127 VariableType::NATIVE_POINTER(),
2128 VariableType::JS_ANY(),
2129 VariableType::INT32(),
2130 };
2131 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2132 }
2133
2134 // GLUE, ACC, RECEIVER, PROP_KEY
DEF_CALL_SIGNATURE(BaselineStownbyvaluewithnamesetImm8V8V8)2135 DEF_CALL_SIGNATURE(BaselineStownbyvaluewithnamesetImm8V8V8)
2136 {
2137 // 5 : 5 input parameters
2138 CallSignature signature("BaselineStownbyvaluewithnamesetImm8V8V8", 0, 5,
2139 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2140 *callSign = signature;
2141 // 5 : 5 input parameters
2142 std::array<VariableType, 5> params = {
2143 VariableType::NATIVE_POINTER(),
2144 VariableType::NATIVE_POINTER(),
2145 VariableType::INT32(),
2146 VariableType::INT32(),
2147 VariableType::INT32(),
2148 };
2149 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2150 }
2151
2152 // GLUE, ACC, RECEIVER, PROP_KEY
DEF_CALL_SIGNATURE(BaselineStownbyvaluewithnamesetImm16V8V8)2153 DEF_CALL_SIGNATURE(BaselineStownbyvaluewithnamesetImm16V8V8)
2154 {
2155 // 5 : 5 input parameters
2156 CallSignature signature("BaselineStownbyvaluewithnamesetImm16V8V8", 0, 5,
2157 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2158 *callSign = signature;
2159 // 5 : 5 input parameters
2160 std::array<VariableType, 5> params = {
2161 VariableType::NATIVE_POINTER(),
2162 VariableType::NATIVE_POINTER(),
2163 VariableType::JS_ANY(),
2164 VariableType::JS_ANY(),
2165 VariableType::INT32(),
2166 };
2167 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2168 }
2169
2170 // GLUE, ACC, CONST_POOL, STRING_ID, RECEIVER
DEF_CALL_SIGNATURE(BaselineStownbynamewithnamesetImm8Id16V8)2171 DEF_CALL_SIGNATURE(BaselineStownbynamewithnamesetImm8Id16V8)
2172 {
2173 // 5 : 5 input parameters
2174 CallSignature signature("BaselineStownbynamewithnamesetImm8Id16V8", 0, 5,
2175 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2176 *callSign = signature;
2177 // 5 : 5 input parameters
2178 std::array<VariableType, 5> params = {
2179 VariableType::NATIVE_POINTER(),
2180 VariableType::NATIVE_POINTER(),
2181 VariableType::INT32(),
2182 VariableType::INT32(),
2183 VariableType::INT32(),
2184 };
2185 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2186 }
2187
2188 // GLUE, ACC, CONST_POOL, STRING_ID, RECEIVER
DEF_CALL_SIGNATURE(BaselineStownbynamewithnamesetImm16Id16V8)2189 DEF_CALL_SIGNATURE(BaselineStownbynamewithnamesetImm16Id16V8)
2190 {
2191 // 5 : 5 input parameters
2192 CallSignature signature("BaselineStownbynamewithnamesetImm16Id16V8", 0, 5,
2193 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2194 *callSign = signature;
2195 // 5 : 5 input parameters
2196 std::array<VariableType, 5> params = {
2197 VariableType::NATIVE_POINTER(),
2198 VariableType::NATIVE_POINTER(),
2199 VariableType::INT32(),
2200 VariableType::JS_ANY(),
2201 VariableType::INT32(),
2202 };
2203 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2204 }
2205
2206 // GLUE, CONST_POOL, STRING_ID
DEF_CALL_SIGNATURE(BaselineLdbigintId16)2207 DEF_CALL_SIGNATURE(BaselineLdbigintId16)
2208 {
2209 // 3 : 3 input parameters
2210 CallSignature signature("BaselineLdbigintId16", 0, 3,
2211 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2212 *callSign = signature;
2213 // 3 : 3 input parameters
2214 std::array<VariableType, 3> params = {
2215 VariableType::NATIVE_POINTER(),
2216 VariableType::NATIVE_POINTER(),
2217 VariableType::INT32(),
2218 };
2219 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2220 }
2221
2222 // IMM
DEF_CALL_SIGNATURE(BaselineFldaiImm64)2223 DEF_CALL_SIGNATURE(BaselineFldaiImm64)
2224 {
2225 // 1 : 1 input parameters
2226 CallSignature signature("BaselineFldaiImm64", 0, 1,
2227 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2228 *callSign = signature;
2229 // 1 : 1 input parameters
2230 std::array<VariableType, 1> params = {
2231 VariableType::INT64(),
2232 };
2233 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2234 }
2235
2236 // GLUE, ACC, SP, PC, CONST_POOL, PROFILE_TYPE_INFO, HOTNESS_COUNTER
DEF_CALL_SIGNATURE(BaselineReturn)2237 DEF_CALL_SIGNATURE(BaselineReturn)
2238 {
2239 // 3 : 3 input parameters
2240 CallSignature signature("BaselineReturn", 0, 3,
2241 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2242 *callSign = signature;
2243 // 3 : 3 input parameters
2244 std::array<VariableType, 3> params = {
2245 VariableType::NATIVE_POINTER(),
2246 VariableType::NATIVE_POINTER(),
2247 VariableType::INT32(),
2248 };
2249 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2250 }
2251
2252
2253 // ACC, LEVEL, SLOT, FRAME
DEF_CALL_SIGNATURE(BaselineLdlexvarImm8Imm8)2254 DEF_CALL_SIGNATURE(BaselineLdlexvarImm8Imm8)
2255 {
2256 // 3 : 3 input parameters
2257 CallSignature signature("BaselineLdlexvarImm8Imm8", 0, 3,
2258 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2259 *callSign = signature;
2260 // 3 : 3 input parameters
2261 std::array<VariableType, 3> params = {
2262 VariableType::INT32(),
2263 VariableType::INT32(),
2264 VariableType::NATIVE_POINTER(),
2265 };
2266 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2267 }
2268
2269 // GLUE, ACC, LEVEL, SLOT, FRAME
DEF_CALL_SIGNATURE(BaselineStlexvarImm8Imm8)2270 DEF_CALL_SIGNATURE(BaselineStlexvarImm8Imm8)
2271 {
2272 // 5 : 5 input parameters
2273 CallSignature signature("BaselineStlexvarImm8Imm8", 0, 5,
2274 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2275 *callSign = signature;
2276 // 5 : 5 input parameters
2277 std::array<VariableType, 5> params = {
2278 VariableType::NATIVE_POINTER(),
2279 VariableType::JS_ANY(),
2280 VariableType::INT32(),
2281 VariableType::INT32(),
2282 VariableType::NATIVE_POINTER(),
2283 };
2284 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2285 }
2286
2287 // GLUE
DEF_CALL_SIGNATURE(BaselineJnstricteqV8Imm16)2288 DEF_CALL_SIGNATURE(BaselineJnstricteqV8Imm16)
2289 {
2290 // 1 : 1 input parameters
2291 CallSignature signature("BaselineJnstricteqV8Imm16", 0, 1,
2292 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2293 *callSign = signature;
2294 // 1 : 1 input parameters
2295 std::array<VariableType, 1> params = {
2296 VariableType::NATIVE_POINTER(),
2297 };
2298 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2299 }
2300
2301 // GLUE, SP, ACC, V0
DEF_CALL_SIGNATURE(BaselineAsyncgeneratorrejectV8)2302 DEF_CALL_SIGNATURE(BaselineAsyncgeneratorrejectV8)
2303 {
2304 // 4 : 4 input parameters
2305 CallSignature signature("BaselineAsyncgeneratorrejectV8", 0, 4,
2306 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2307 *callSign = signature;
2308 // 4 : 4 input parameters
2309 std::array<VariableType, 4> params = {
2310 VariableType::NATIVE_POINTER(),
2311 VariableType::NATIVE_POINTER(),
2312 VariableType::JS_ANY(),
2313 VariableType::INT8(),
2314 };
2315 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2316 }
2317
2318 // GLUE, ACC, INDEX
DEF_CALL_SIGNATURE(BaselineSetgeneratorstateImm8)2319 DEF_CALL_SIGNATURE(BaselineSetgeneratorstateImm8)
2320 {
2321 // 3 : 3 input parameters
2322 CallSignature signature("BaselineSetgeneratorstateImm8", 0, 3,
2323 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2324 *callSign = signature;
2325 // 3 : 3 input parameters
2326 std::array<VariableType, 3> params = {
2327 VariableType::NATIVE_POINTER(),
2328 VariableType::JS_ANY(),
2329 VariableType::INT32(),
2330 };
2331 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2332 }
2333
2334 // GLUE, SP, ACC
DEF_CALL_SIGNATURE(BaselineGetasynciteratorImm8)2335 DEF_CALL_SIGNATURE(BaselineGetasynciteratorImm8)
2336 {
2337 // 3 : 3 input parameters
2338 CallSignature signature("BaselineGetasynciteratorImm8", 0, 3,
2339 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2340 *callSign = signature;
2341 // 3 : 3 input parameters
2342 std::array<VariableType, 3> params = {
2343 VariableType::NATIVE_POINTER(),
2344 VariableType::NATIVE_POINTER(),
2345 VariableType::JS_ANY(),
2346 };
2347 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2348 }
2349
2350 // GLUE, SP, ACC, INDEX0, INDEX1, ENV
DEF_CALL_SIGNATURE(BaselineLdPrivatePropertyImm8Imm16Imm16)2351 DEF_CALL_SIGNATURE(BaselineLdPrivatePropertyImm8Imm16Imm16)
2352 {
2353 // 6 : 6 input parameters
2354 CallSignature signature("BaselineLdPrivatePropertyImm8Imm16Imm16", 0, 6,
2355 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2356 *callSign = signature;
2357 // 6 : 6 input parameters
2358 std::array<VariableType, 6> params = {
2359 VariableType::NATIVE_POINTER(),
2360 VariableType::NATIVE_POINTER(),
2361 VariableType::JS_ANY(),
2362 VariableType::INT32(),
2363 VariableType::INT32(),
2364 VariableType::JS_POINTER(),
2365 };
2366 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2367 }
2368
2369 // GLUE, SP, INDEX0, INDEX1, INDEX2
DEF_CALL_SIGNATURE(BaselineStPrivatePropertyImm8Imm16Imm16V8)2370 DEF_CALL_SIGNATURE(BaselineStPrivatePropertyImm8Imm16Imm16V8)
2371 {
2372 // 5 : 5 input parameters
2373 CallSignature signature("BaselineStPrivatePropertyImm8Imm16Imm16V8", 0, 5,
2374 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2375 *callSign = signature;
2376 // 5 : 5 input parameters
2377 std::array<VariableType, 5> params = {
2378 VariableType::NATIVE_POINTER(),
2379 VariableType::NATIVE_POINTER(),
2380 VariableType::INT32(),
2381 VariableType::INT32(),
2382 VariableType::INT8(),
2383 };
2384 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2385 }
2386
2387 // GLUE, SP, ACC, INDEX0, INDEX1, ENV
DEF_CALL_SIGNATURE(BaselineTestInImm8Imm16Imm16)2388 DEF_CALL_SIGNATURE(BaselineTestInImm8Imm16Imm16)
2389 {
2390 // 6 : 6 input parameters
2391 CallSignature signature("BaselineTestInImm8Imm16Imm16", 0, 6,
2392 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2393 *callSign = signature;
2394 // 6 : 6 input parameters
2395 std::array<VariableType, 6> params = {
2396 VariableType::NATIVE_POINTER(),
2397 VariableType::NATIVE_POINTER(),
2398 VariableType::JS_ANY(),
2399 VariableType::INT32(),
2400 VariableType::INT32(),
2401 VariableType::JS_POINTER(),
2402 };
2403 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2404 }
2405
2406 // SP
DEF_CALL_SIGNATURE(BaselineDeprecatedLdlexenvPrefNone)2407 DEF_CALL_SIGNATURE(BaselineDeprecatedLdlexenvPrefNone)
2408 {
2409 // 1 : 1 input parameters
2410 CallSignature signature("BaselineDeprecatedLdlexenvPrefNone", 0, 1,
2411 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2412 *callSign = signature;
2413 // 1 : 1 input parameters
2414 std::array<VariableType, 1> params = {
2415 VariableType::NATIVE_POINTER(),
2416 };
2417 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2418 }
2419
2420 // GLUE, SP, V0, V1, V2
DEF_CALL_SIGNATURE(BaselineWideCreateobjectwithexcludedkeysPrefImm16V8V8)2421 DEF_CALL_SIGNATURE(BaselineWideCreateobjectwithexcludedkeysPrefImm16V8V8)
2422 {
2423 // 5 : 5 input parameters
2424 CallSignature signature("BaselineWideCreateobjectwithexcludedkeysPrefImm16V8V8", 0, 5,
2425 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2426 *callSign = signature;
2427 // 5 : 5 input parameters
2428 std::array<VariableType, 5> params = {
2429 VariableType::NATIVE_POINTER(),
2430 VariableType::NATIVE_POINTER(),
2431 VariableType::INT16(),
2432 VariableType::INT8(),
2433 VariableType::INT16(),
2434 };
2435 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2436 }
2437
2438 // GLUE, SP, ACC
DEF_CALL_SIGNATURE(BaselineThrowPrefNone)2439 DEF_CALL_SIGNATURE(BaselineThrowPrefNone)
2440 {
2441 // 3 : 3 input parameters
2442 CallSignature signature("BaselineThrowPrefNone", 0, 3,
2443 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2444 *callSign = signature;
2445 // 3 : 3 input parameters
2446 std::array<VariableType, 3> params = {
2447 VariableType::NATIVE_POINTER(),
2448 VariableType::NATIVE_POINTER(),
2449 VariableType::JS_ANY(),
2450 };
2451 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2452 }
2453
2454 // GLUE, SP
DEF_CALL_SIGNATURE(BaselineDeprecatedPoplexenvPrefNone)2455 DEF_CALL_SIGNATURE(BaselineDeprecatedPoplexenvPrefNone)
2456 {
2457 // 2 : 2 input parameters
2458 CallSignature signature("BaselineDeprecatedPoplexenvPrefNone", 0, 2,
2459 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2460 *callSign = signature;
2461 // 2 : 2 input parameters
2462 std::array<VariableType, 2> params = {
2463 VariableType::NATIVE_POINTER(),
2464 VariableType::NATIVE_POINTER(),
2465 };
2466 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2467 }
2468
2469 // GLUE, SP, NUM_ARGS, IDX, HOTNESS_COUNTER, SLOT_ID
DEF_CALL_SIGNATURE(BaselineWideNewobjrangePrefImm16V8)2470 DEF_CALL_SIGNATURE(BaselineWideNewobjrangePrefImm16V8)
2471 {
2472 // 6 : 6 input parameters
2473 CallSignature signature("BaselineWideNewobjrangePrefImm16V8", 0, 6,
2474 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2475 *callSign = signature;
2476 /// 6 : 6 input parameters
2477 std::array<VariableType, 6> params = {
2478 VariableType::NATIVE_POINTER(),
2479 VariableType::NATIVE_POINTER(),
2480 VariableType::INT16(),
2481 VariableType::INT16(),
2482 VariableType::INT32(),
2483 VariableType::INT32(),
2484 };
2485 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2486 }
2487
2488 // GLUE, SP
DEF_CALL_SIGNATURE(BaselineThrowNotexistsPrefNone)2489 DEF_CALL_SIGNATURE(BaselineThrowNotexistsPrefNone)
2490 {
2491 // 2 : 2 input parameters
2492 CallSignature signature("BaselineThrowNotexistsPrefNone", 0, 2,
2493 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2494 *callSign = signature;
2495 // 2 : 2 input parameters
2496 std::array<VariableType, 2> params = {
2497 VariableType::NATIVE_POINTER(),
2498 VariableType::NATIVE_POINTER(),
2499 };
2500 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2501 }
2502
2503 // GLUE, SP, V0, V1
DEF_CALL_SIGNATURE(BaselineDeprecatedGetiteratornextPrefV8V8)2504 DEF_CALL_SIGNATURE(BaselineDeprecatedGetiteratornextPrefV8V8)
2505 {
2506 // 4 : 4 input parameters
2507 CallSignature signature("BaselineDeprecatedGetiteratornextPrefV8V8", 0, 4,
2508 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2509 *callSign = signature;
2510 // 4 : 4 input parameters
2511 std::array<VariableType, 4> params = {
2512 VariableType::NATIVE_POINTER(),
2513 VariableType::NATIVE_POINTER(),
2514 VariableType::INT8(),
2515 VariableType::INT8(),
2516 };
2517 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2518 }
2519
2520 // GLUE, SP, ACC, NUM_VARS
DEF_CALL_SIGNATURE(BaselineWideNewlexenvPrefImm16)2521 DEF_CALL_SIGNATURE(BaselineWideNewlexenvPrefImm16)
2522 {
2523 // 4 : 4 input parameters
2524 CallSignature signature("BaselineWideNewlexenvPrefImm16", 0, 4,
2525 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2526 *callSign = signature;
2527 // 4 : 4 input parameters
2528 std::array<VariableType, 4> params = {
2529 VariableType::NATIVE_POINTER(),
2530 VariableType::NATIVE_POINTER(),
2531 VariableType::JS_ANY(),
2532 VariableType::INT32(),
2533 };
2534 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2535 }
2536
2537 // GLUE, SP
DEF_CALL_SIGNATURE(BaselineThrowPatternnoncoerciblePrefNone)2538 DEF_CALL_SIGNATURE(BaselineThrowPatternnoncoerciblePrefNone)
2539 {
2540 // 2 : 2 input parameters
2541 CallSignature signature("BaselineThrowPatternnoncoerciblePrefNone", 0, 2,
2542 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2543 *callSign = signature;
2544 // 2 : 2 input parameters
2545 std::array<VariableType, 2> params = {
2546 VariableType::NATIVE_POINTER(),
2547 VariableType::NATIVE_POINTER(),
2548 };
2549 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2550 }
2551
2552 // GLUE, IMM_I16, FUNC, SLOT_ID, PROFILE_TYPE_INFO, PC
DEF_CALL_SIGNATURE(BaselineDeprecatedCreatearraywithbufferPrefImm16)2553 DEF_CALL_SIGNATURE(BaselineDeprecatedCreatearraywithbufferPrefImm16)
2554 {
2555 // 6 : 6 input parameters
2556 CallSignature signature("BaselineDeprecatedCreatearraywithbufferPrefImm16", 0, 6,
2557 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2558 *callSign = signature;
2559 /// 6 : 6 input parameters
2560 std::array<VariableType, 6> params = {
2561 VariableType::NATIVE_POINTER(),
2562 VariableType::NATIVE_POINTER(),
2563 VariableType::INT16(),
2564 VariableType::INT32(),
2565 VariableType::JS_POINTER(),
2566 VariableType::NATIVE_POINTER(),
2567 };
2568 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2569 }
2570
2571 // GLUE, SP, ACC, NUM_VARS, SCOPE_ID
DEF_CALL_SIGNATURE(BaselineWideNewlexenvwithnamePrefImm16Id16)2572 DEF_CALL_SIGNATURE(BaselineWideNewlexenvwithnamePrefImm16Id16)
2573 {
2574 // 5 : 5 input parameters
2575 CallSignature signature("BaselineWideNewlexenvwithnamePrefImm16Id16", 0, 5,
2576 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2577 *callSign = signature;
2578 // 5 : 5 input parameters
2579 std::array<VariableType, 5> params = {
2580 VariableType::NATIVE_POINTER(),
2581 VariableType::NATIVE_POINTER(),
2582 VariableType::JS_ANY(),
2583 VariableType::INT16(),
2584 VariableType::INT16(),
2585 };
2586 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2587 }
2588
2589 // GLUE, SP
DEF_CALL_SIGNATURE(BaselineThrowDeletesuperpropertyPrefNone)2590 DEF_CALL_SIGNATURE(BaselineThrowDeletesuperpropertyPrefNone)
2591 {
2592 // 2 : 2 input parameters
2593 CallSignature signature("BaselineThrowDeletesuperpropertyPrefNone", 0, 2,
2594 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2595 *callSign = signature;
2596 // 2 : 2 input parameters
2597 std::array<VariableType, 2> params = {
2598 VariableType::NATIVE_POINTER(),
2599 VariableType::NATIVE_POINTER(),
2600 };
2601 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2602 }
2603
2604 // GLUE, IMM_I16, CONST_POOL, FRAME
DEF_CALL_SIGNATURE(BaselineDeprecatedCreateobjectwithbufferPrefImm16)2605 DEF_CALL_SIGNATURE(BaselineDeprecatedCreateobjectwithbufferPrefImm16)
2606 {
2607 // 3 : 3 input parameters
2608 CallSignature signature("BaselineDeprecatedCreateobjectwithbufferPrefImm16", 0, 3,
2609 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2610 *callSign = signature;
2611 // 3 : 3 input parameters
2612 std::array<VariableType, 3> params = {
2613 VariableType::NATIVE_POINTER(),
2614 VariableType::INT16(),
2615 VariableType::NATIVE_POINTER(),
2616 };
2617 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2618 }
2619
DEF_CALL_SIGNATURE(BaselineNewobjrangeImm8Imm8V8)2620 DEF_CALL_SIGNATURE(BaselineNewobjrangeImm8Imm8V8)
2621 {
2622 // 5 : 5 input parameters
2623 CallSignature signature("BaselineNewobjrangeImm8Imm8V8", 0, 5,
2624 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2625 *callSign = signature;
2626 // 5 : 5 input parameters
2627 std::array<VariableType, 5> params = {
2628 VariableType::NATIVE_POINTER(),
2629 VariableType::NATIVE_POINTER(),
2630 VariableType::INT32(),
2631 VariableType::INT32(),
2632 VariableType::INT32(),
2633 };
2634 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2635 }
2636
DEF_CALL_SIGNATURE(BaselineNewobjrangeImm16Imm8V8)2637 DEF_CALL_SIGNATURE(BaselineNewobjrangeImm16Imm8V8)
2638 {
2639 // 5 : 5 input parameters
2640 CallSignature signature("BaselineNewobjrangeImm16Imm8V8", 0, 5,
2641 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2642 *callSign = signature;
2643 // 5 : 5 input parameters
2644 std::array<VariableType, 5> params = {
2645 VariableType::NATIVE_POINTER(),
2646 VariableType::NATIVE_POINTER(),
2647 VariableType::INT16(),
2648 VariableType::INT16(),
2649 VariableType::INT32(),
2650 };
2651 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2652 }
2653
2654 // GLUE, SP, ACC, ACTUAL_NUM_ARGS, VREG_ID, HOTNESS_COUNTER
DEF_CALL_SIGNATURE(BaselineWideCallrangePrefImm16V8)2655 DEF_CALL_SIGNATURE(BaselineWideCallrangePrefImm16V8)
2656 {
2657 // 6 : 6 input parameters
2658 CallSignature signature("BaselineWideCallrangePrefImm16V8", 0, 6,
2659 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2660 *callSign = signature;
2661 // 6 : 6 input parameters
2662 std::array<VariableType, 6> params = {
2663 VariableType::NATIVE_POINTER(),
2664 VariableType::NATIVE_POINTER(),
2665 VariableType::JS_ANY(),
2666 VariableType::INT32(),
2667 VariableType::INT8(),
2668 VariableType::INT32(),
2669 };
2670 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2671 }
2672
2673 // GLUE, SP, V0
DEF_CALL_SIGNATURE(BaselineThrowConstassignmentPrefV8)2674 DEF_CALL_SIGNATURE(BaselineThrowConstassignmentPrefV8)
2675 {
2676 // 3 : 3 input parameters
2677 CallSignature signature("BaselineThrowConstassignmentPrefV8", 0, 3,
2678 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2679 *callSign = signature;
2680 // 3 : 3 input parameters
2681 std::array<VariableType, 3> params = {
2682 VariableType::NATIVE_POINTER(),
2683 VariableType::NATIVE_POINTER(),
2684 VariableType::JS_ANY(),
2685 };
2686 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2687 }
2688
2689 // GLUE, SP, V0
DEF_CALL_SIGNATURE(BaselineDeprecatedTonumberPrefV8)2690 DEF_CALL_SIGNATURE(BaselineDeprecatedTonumberPrefV8)
2691 {
2692 // 3 : 3 input parameters
2693 CallSignature signature("BaselineDeprecatedTonumberPrefV8", 0, 3,
2694 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2695 *callSign = signature;
2696 // 3 : 3 input parameters
2697 std::array<VariableType, 3> params = {
2698 VariableType::NATIVE_POINTER(),
2699 VariableType::NATIVE_POINTER(),
2700 VariableType::INT8(),
2701 };
2702 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2703 }
2704
2705 // GLUE, SP, ACC, ACTUAL_NUM_ARGS, VREG_ID, HOTNESS_COUNTER
DEF_CALL_SIGNATURE(BaselineWideCallthisrangePrefImm16V8)2706 DEF_CALL_SIGNATURE(BaselineWideCallthisrangePrefImm16V8)
2707 {
2708 // 6 : 6 input parameters
2709 CallSignature signature("BaselineWideCallthisrangePrefImm16V8", 0, 6,
2710 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2711 *callSign = signature;
2712 // 6 : 6 input parameters
2713 std::array<VariableType, 6> params = {
2714 VariableType::NATIVE_POINTER(),
2715 VariableType::NATIVE_POINTER(),
2716 VariableType::JS_ANY(),
2717 VariableType::INT32(),
2718 VariableType::INT8(),
2719 VariableType::INT32(),
2720 };
2721 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2722 }
2723
2724 // GLUE, SP, V0
DEF_CALL_SIGNATURE(BaselineThrowIfnotobjectPrefV8)2725 DEF_CALL_SIGNATURE(BaselineThrowIfnotobjectPrefV8)
2726 {
2727 // 3 : 3 input parameters
2728 CallSignature signature("BaselineThrowIfnotobjectPrefV8", 0, 3,
2729 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2730 *callSign = signature;
2731 // 3 : 3 input parameters
2732 std::array<VariableType, 3> params = {
2733 VariableType::NATIVE_POINTER(),
2734 VariableType::NATIVE_POINTER(),
2735 VariableType::JS_ANY(),
2736 };
2737 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2738 }
2739
2740 // GLUE, SP, V0
DEF_CALL_SIGNATURE(BaselineDeprecatedTonumericPrefV8)2741 DEF_CALL_SIGNATURE(BaselineDeprecatedTonumericPrefV8)
2742 {
2743 // 3 : 3 input parameters
2744 CallSignature signature("BaselineDeprecatedTonumericPrefV8", 0, 3,
2745 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2746 *callSign = signature;
2747 // 3 : 3 input parameters
2748 std::array<VariableType, 3> params = {
2749 VariableType::NATIVE_POINTER(),
2750 VariableType::NATIVE_POINTER(),
2751 VariableType::INT8(),
2752 };
2753 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2754 }
2755
2756
2757 // GLUE, SP, RANGE, V0
DEF_CALL_SIGNATURE(BaselineWideSupercallthisrangePrefImm16V8)2758 DEF_CALL_SIGNATURE(BaselineWideSupercallthisrangePrefImm16V8)
2759 {
2760 // 4 : 4 input parameters
2761 CallSignature signature("BaselineWideSupercallthisrangePrefImm16V8", 0, 4,
2762 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2763 *callSign = signature;
2764 // 4 : 4 input parameters
2765 std::array<VariableType, 4> params = {
2766 VariableType::NATIVE_POINTER(),
2767 VariableType::NATIVE_POINTER(),
2768 VariableType::INT16(),
2769 VariableType::INT16(),
2770 };
2771 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2772 }
2773
2774 // GLUE, SP, V0, V1
DEF_CALL_SIGNATURE(BaselineThrowUndefinedifholePrefV8V8)2775 DEF_CALL_SIGNATURE(BaselineThrowUndefinedifholePrefV8V8)
2776 {
2777 // 4 : 4 input parameters
2778 CallSignature signature("BaselineThrowUndefinedifholePrefV8V8", 0, 4,
2779 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2780 *callSign = signature;
2781 // 4 : 4 input parameters
2782 std::array<VariableType, 4> params = {
2783 VariableType::NATIVE_POINTER(),
2784 VariableType::NATIVE_POINTER(),
2785 VariableType::INT8(),
2786 VariableType::INT8(),
2787 };
2788 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2789 }
2790
2791 // GLUE, CONST_POOL, STRING_ID
DEF_CALL_SIGNATURE(BaselineThrowUndefinedifholewithnamePrefId16)2792 DEF_CALL_SIGNATURE(BaselineThrowUndefinedifholewithnamePrefId16)
2793 {
2794 // 3 : 3 input parameters
2795 CallSignature signature("BaselineThrowUndefinedifholewithnamePrefId16", 0, 3,
2796 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2797 *callSign = signature;
2798 // 3 : 3 input parameters
2799 std::array<VariableType, 3> params = {
2800 VariableType::NATIVE_POINTER(),
2801 VariableType::NATIVE_POINTER(),
2802 VariableType::INT32(),
2803 };
2804 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2805 }
2806
2807 // GLUE, SP, V0
DEF_CALL_SIGNATURE(BaselineDeprecatedNegPrefV8)2808 DEF_CALL_SIGNATURE(BaselineDeprecatedNegPrefV8)
2809 {
2810 // 3 : 3 input parameters
2811 CallSignature signature("BaselineDeprecatedNegPrefV8", 0, 3,
2812 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2813 *callSign = signature;
2814 // 3 : 3 input parameters
2815 std::array<VariableType, 3> params = {
2816 VariableType::NATIVE_POINTER(),
2817 VariableType::NATIVE_POINTER(),
2818 VariableType::INT8(),
2819 };
2820 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2821 }
2822
2823 // GLUE, SP, ACC, RANGE, V0
DEF_CALL_SIGNATURE(BaselineWideSupercallarrowrangePrefImm16V8)2824 DEF_CALL_SIGNATURE(BaselineWideSupercallarrowrangePrefImm16V8)
2825 {
2826 // 5 : 5 input parameters
2827 CallSignature signature("BaselineWideSupercallarrowrangePrefImm16V8", 0, 5,
2828 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2829 *callSign = signature;
2830 // 5 : 5 input parameters
2831 std::array<VariableType, 5> params = {
2832 VariableType::NATIVE_POINTER(),
2833 VariableType::NATIVE_POINTER(),
2834 VariableType::JS_ANY(),
2835 VariableType::INT16(),
2836 VariableType::INT16(),
2837 };
2838 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2839 }
2840
2841 // GLUE, SP, ACC, IMM
DEF_CALL_SIGNATURE(BaselineThrowIfsupernotcorrectcallPrefImm8)2842 DEF_CALL_SIGNATURE(BaselineThrowIfsupernotcorrectcallPrefImm8)
2843 {
2844 // 4 : 4 input parameters
2845 CallSignature signature("BaselineThrowIfsupernotcorrectcallPrefImm8", 0, 4,
2846 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2847 *callSign = signature;
2848 // 4 : 4 input parameters
2849 std::array<VariableType, 4> params = {
2850 VariableType::NATIVE_POINTER(),
2851 VariableType::NATIVE_POINTER(),
2852 VariableType::JS_ANY(),
2853 VariableType::INT8(),
2854 };
2855 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2856 }
2857
2858 // GLUE, SP, INDEX
DEF_CALL_SIGNATURE(BaselineDeprecatedNotPrefV8)2859 DEF_CALL_SIGNATURE(BaselineDeprecatedNotPrefV8)
2860 {
2861 // 3 : 3 input parameters
2862 CallSignature signature("BaselineDeprecatedNotPrefV8", 0, 3,
2863 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2864 *callSign = signature;
2865 // 3 : 3 input parameters
2866 std::array<VariableType, 3> params = {
2867 VariableType::NATIVE_POINTER(),
2868 VariableType::NATIVE_POINTER(),
2869 VariableType::INT8(),
2870 };
2871 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2872 }
2873
2874 // GLUE, ACC, INDEX
DEF_CALL_SIGNATURE(BaselineWideLdobjbyindexPrefImm32)2875 DEF_CALL_SIGNATURE(BaselineWideLdobjbyindexPrefImm32)
2876 {
2877 // 4 : 4 input parameters
2878 CallSignature signature("BaselineWideLdobjbyindexPrefImm32", 0, 4,
2879 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2880 *callSign = signature;
2881 // 4 : 4 input parameters
2882 std::array<VariableType, 4> params = {
2883 VariableType::NATIVE_POINTER(),
2884 VariableType::NATIVE_POINTER(),
2885 VariableType::INT32(),
2886 VariableType::INT32(),
2887 };
2888 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2889 }
2890
2891 // GLUE, SP, ACC, IMM
DEF_CALL_SIGNATURE(BaselineThrowIfsupernotcorrectcallPrefImm16)2892 DEF_CALL_SIGNATURE(BaselineThrowIfsupernotcorrectcallPrefImm16)
2893 {
2894 // 4 : 4 input parameters
2895 CallSignature signature("BaselineThrowIfsupernotcorrectcallPrefImm16", 0, 4,
2896 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2897 *callSign = signature;
2898 // 4 : 4 input parameters
2899 std::array<VariableType, 4> params = {
2900 VariableType::NATIVE_POINTER(),
2901 VariableType::NATIVE_POINTER(),
2902 VariableType::JS_ANY(),
2903 VariableType::INT16(),
2904 };
2905 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2906 }
2907
2908 // GLUE, SP, V0
DEF_CALL_SIGNATURE(BaselineDeprecatedIncPrefV8)2909 DEF_CALL_SIGNATURE(BaselineDeprecatedIncPrefV8)
2910 {
2911 // 3 : 3 input parameters
2912 CallSignature signature("BaselineDeprecatedIncPrefV8", 0, 3,
2913 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2914 *callSign = signature;
2915 // 3 : 3 input parameters
2916 std::array<VariableType, 3> params = {
2917 VariableType::NATIVE_POINTER(),
2918 VariableType::NATIVE_POINTER(),
2919 VariableType::INT8(),
2920 };
2921 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2922 }
2923
2924 // GLUE, SP, ACC, V0, INDEX
DEF_CALL_SIGNATURE(BaselineWideStobjbyindexPrefV8Imm32)2925 DEF_CALL_SIGNATURE(BaselineWideStobjbyindexPrefV8Imm32)
2926 {
2927 // 5 : 5 input parameters
2928 CallSignature signature("BaselineWideStobjbyindexPrefV8Imm32", 0, 5,
2929 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2930 *callSign = signature;
2931 // 5 : 5 input parameters
2932 std::array<VariableType, 5> params = {
2933 VariableType::NATIVE_POINTER(),
2934 VariableType::NATIVE_POINTER(),
2935 VariableType::INT32(),
2936 VariableType::INT32(),
2937 VariableType::INT32(),
2938 };
2939 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2940 }
2941
2942 // GLUE, SP, INDEX
DEF_CALL_SIGNATURE(BaselineDeprecatedDecPrefV8)2943 DEF_CALL_SIGNATURE(BaselineDeprecatedDecPrefV8)
2944 {
2945 // 3 : 3 input parameters
2946 CallSignature signature("BaselineDeprecatedDecPrefV8", 0, 3,
2947 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2948 *callSign = signature;
2949 // 3 : 3 input parameters
2950 std::array<VariableType, 3> params = {
2951 VariableType::NATIVE_POINTER(),
2952 VariableType::NATIVE_POINTER(),
2953 VariableType::INT8(),
2954 };
2955 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2956 }
2957
2958 // GLUE, SP, ACC, V0, INDEX
DEF_CALL_SIGNATURE(BaselineWideStownbyindexPrefV8Imm32)2959 DEF_CALL_SIGNATURE(BaselineWideStownbyindexPrefV8Imm32)
2960 {
2961 // 5 : 5 input parameters
2962 CallSignature signature("BaselineWideStownbyindexPrefV8Imm32", 0, 5,
2963 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2964 *callSign = signature;
2965 // 5 : 5 input parameters
2966 std::array<VariableType, 5> params = {
2967 VariableType::NATIVE_POINTER(),
2968 VariableType::NATIVE_POINTER(),
2969 VariableType::INT32(),
2970 VariableType::INT32(),
2971 VariableType::INT32(),
2972 };
2973 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2974 }
2975
2976 // GLUE, SP, FUNC_REG, HOTNESS_COUNTER
DEF_CALL_SIGNATURE(BaselineDeprecatedCallarg0PrefV8)2977 DEF_CALL_SIGNATURE(BaselineDeprecatedCallarg0PrefV8)
2978 {
2979 // 4 : 4 input parameters
2980 CallSignature signature("BaselineDeprecatedCallarg0PrefV8", 0, 4,
2981 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2982 *callSign = signature;
2983 // 4 : 4 input parameters
2984 std::array<VariableType, 4> params = {
2985 VariableType::NATIVE_POINTER(),
2986 VariableType::NATIVE_POINTER(),
2987 VariableType::INT8(),
2988 VariableType::INT32(),
2989 };
2990 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
2991 }
2992
2993 // GLUE, SP, INDEX
DEF_CALL_SIGNATURE(BaselineWideCopyrestargsPrefImm16)2994 DEF_CALL_SIGNATURE(BaselineWideCopyrestargsPrefImm16)
2995 {
2996 // 3 : 3 input parameters
2997 CallSignature signature("BaselineWideCopyrestargsPrefImm16", 0, 3,
2998 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2999 *callSign = signature;
3000 // 3 : 3 input parameters
3001 std::array<VariableType, 3> params = {
3002 VariableType::NATIVE_POINTER(),
3003 VariableType::NATIVE_POINTER(),
3004 VariableType::INT32(),
3005 };
3006 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3007 }
3008
3009 // GLUE, SP, FUNC_REG, A0, HOTNESS_COUNTER
DEF_CALL_SIGNATURE(BaselineDeprecatedCallarg1PrefV8V8)3010 DEF_CALL_SIGNATURE(BaselineDeprecatedCallarg1PrefV8V8)
3011 {
3012 // 5 : 5 input parameters
3013 CallSignature signature("BaselineDeprecatedCallarg1PrefV8V8", 0, 5,
3014 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3015 *callSign = signature;
3016 // 5 : 5 input parameters
3017 std::array<VariableType, 5> params = {
3018 VariableType::NATIVE_POINTER(),
3019 VariableType::NATIVE_POINTER(),
3020 VariableType::INT8(),
3021 VariableType::INT8(),
3022 VariableType::INT32(),
3023 };
3024 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3025 }
3026
3027 // SP, LEVEL, SLOT
DEF_CALL_SIGNATURE(BaselineWideLdlexvarPrefImm16Imm16)3028 DEF_CALL_SIGNATURE(BaselineWideLdlexvarPrefImm16Imm16)
3029 {
3030 // 3 : 3 input parameters
3031 CallSignature signature("BaselineWideLdlexvarPrefImm16Imm16", 0, 3,
3032 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3033 *callSign = signature;
3034 // 3 : 3 input parameters
3035 std::array<VariableType, 3> params = {
3036 VariableType::NATIVE_POINTER(),
3037 VariableType::INT32(),
3038 VariableType::INT32(),
3039 };
3040 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3041 }
3042
3043 // GLUE, SP, FUNC_REG, A0, A1, HOTNESS_COUNTER
DEF_CALL_SIGNATURE(BaselineDeprecatedCallargs2PrefV8V8V8)3044 DEF_CALL_SIGNATURE(BaselineDeprecatedCallargs2PrefV8V8V8)
3045 {
3046 // 6 : 6 input parameters
3047 CallSignature signature("BaselineDeprecatedCallargs2PrefV8V8V8", 0, 6,
3048 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3049 *callSign = signature;
3050 // 6 : 6 input parameters
3051 std::array<VariableType, 6> params = {
3052 VariableType::NATIVE_POINTER(),
3053 VariableType::NATIVE_POINTER(),
3054 VariableType::INT8(),
3055 VariableType::INT8(),
3056 VariableType::INT8(),
3057 VariableType::INT32(),
3058 };
3059 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3060 }
3061
3062 // GLUE, SP, ACC, LEVEL, SLOT
DEF_CALL_SIGNATURE(BaselineWideStlexvarPrefImm16Imm16)3063 DEF_CALL_SIGNATURE(BaselineWideStlexvarPrefImm16Imm16)
3064 {
3065 // 5 : 5 input parameters
3066 CallSignature signature("BaselineWideStlexvarPrefImm16Imm16", 0, 5,
3067 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3068 *callSign = signature;
3069 // 5 : 5 input parameters
3070 std::array<VariableType, 5> params = {
3071 VariableType::NATIVE_POINTER(),
3072 VariableType::NATIVE_POINTER(),
3073 VariableType::JS_ANY(),
3074 VariableType::INT32(),
3075 VariableType::INT32(),
3076 };
3077 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3078 }
3079
3080 // GLUE, SP, FUNC_REG, A0, A1, A2
DEF_CALL_SIGNATURE(BaselineDeprecatedCallargs3PrefV8V8V8V8)3081 DEF_CALL_SIGNATURE(BaselineDeprecatedCallargs3PrefV8V8V8V8)
3082 {
3083 // 6 : 6 input parameters
3084 CallSignature signature("BaselineDeprecatedCallargs3PrefV8V8V8V8", 0, 6,
3085 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3086 *callSign = signature;
3087 // 6 : 6 input parameters
3088 std::array<VariableType, 6> params = {
3089 VariableType::NATIVE_POINTER(),
3090 VariableType::NATIVE_POINTER(),
3091 VariableType::INT8(),
3092 VariableType::INT8(),
3093 VariableType::INT8(),
3094 VariableType::INT8(),
3095 };
3096 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3097 }
3098
3099 // GLUE, INDEX
DEF_CALL_SIGNATURE(BaselineWideGetmodulenamespacePrefImm16)3100 DEF_CALL_SIGNATURE(BaselineWideGetmodulenamespacePrefImm16)
3101 {
3102 // 2 : 2 input parameters
3103 CallSignature signature("BaselineWideGetmodulenamespacePrefImm16", 0, 2,
3104 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3105 *callSign = signature;
3106 // 2 : 2 input parameters
3107 std::array<VariableType, 2> params = {
3108 VariableType::NATIVE_POINTER(),
3109 VariableType::INT16(),
3110 };
3111 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3112 }
3113
3114 // GLUE, SP, INDEX, FUNC_REG, HOTNESS_COUNTER
DEF_CALL_SIGNATURE(BaselineDeprecatedCallrangePrefImm16V8)3115 DEF_CALL_SIGNATURE(BaselineDeprecatedCallrangePrefImm16V8)
3116 {
3117 // 5 : 5 input parameters
3118 CallSignature signature("BaselineDeprecatedCallrangePrefImm16V8", 0, 5,
3119 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3120 *callSign = signature;
3121 // 5 : 5 input parameters
3122 std::array<VariableType, 5> params = {
3123 VariableType::NATIVE_POINTER(),
3124 VariableType::NATIVE_POINTER(),
3125 VariableType::INT32(),
3126 VariableType::INT8(),
3127 VariableType::INT32(),
3128 };
3129 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3130 }
3131
3132 // GLUE, ACC, INDEX
DEF_CALL_SIGNATURE(BaselineWideStmodulevarPrefImm16)3133 DEF_CALL_SIGNATURE(BaselineWideStmodulevarPrefImm16)
3134 {
3135 // 3 : 3 input parameters
3136 CallSignature signature("BaselineWideStmodulevarPrefImm16", 0, 3,
3137 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3138 *callSign = signature;
3139 // 3 : 3 input parameters
3140 std::array<VariableType, 3> params = {
3141 VariableType::NATIVE_POINTER(),
3142 VariableType::JS_ANY(),
3143 VariableType::INT16(),
3144 };
3145 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3146 }
3147
3148 // GLUE, SP, V0, V1, V2
DEF_CALL_SIGNATURE(BaselineDeprecatedCallspreadPrefV8V8V8)3149 DEF_CALL_SIGNATURE(BaselineDeprecatedCallspreadPrefV8V8V8)
3150 {
3151 // 5 : 5 input parameters
3152 CallSignature signature("BaselineDeprecatedCallspreadPrefV8V8V8", 0, 5,
3153 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3154 *callSign = signature;
3155 // 5 : 5 input parameters
3156 std::array<VariableType, 5> params = {
3157 VariableType::NATIVE_POINTER(),
3158 VariableType::NATIVE_POINTER(),
3159 VariableType::INT8(),
3160 VariableType::INT8(),
3161 VariableType::INT8(),
3162 };
3163 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3164 }
3165
3166 // GLUE, INDEX
DEF_CALL_SIGNATURE(BaselineWideLdlocalmodulevarPrefImm16)3167 DEF_CALL_SIGNATURE(BaselineWideLdlocalmodulevarPrefImm16)
3168 {
3169 // 2 : 2 input parameters
3170 CallSignature signature("BaselineWideLdlocalmodulevarPrefImm16", 0, 2,
3171 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3172 *callSign = signature;
3173 // 2 : 2 input parameters
3174 std::array<VariableType, 2> params = {
3175 VariableType::NATIVE_POINTER(),
3176 VariableType::INT16(),
3177 };
3178 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3179 }
3180
3181 // GLUE, SP, INDEX, FUNC_REG, HOTNESS_COUNTER
DEF_CALL_SIGNATURE(BaselineDeprecatedCallthisrangePrefImm16V8)3182 DEF_CALL_SIGNATURE(BaselineDeprecatedCallthisrangePrefImm16V8)
3183 {
3184 // 5 : 5 input parameters
3185 CallSignature signature("BaselineDeprecatedCallthisrangePrefImm16V8", 0, 5,
3186 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3187 *callSign = signature;
3188 // 5 : 5 input parameters
3189 std::array<VariableType, 5> params = {
3190 VariableType::NATIVE_POINTER(),
3191 VariableType::NATIVE_POINTER(),
3192 VariableType::INT32(),
3193 VariableType::INT8(),
3194 VariableType::INT32(),
3195 };
3196 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3197 }
3198
3199 // GLUE, INDEX
DEF_CALL_SIGNATURE(BaselineWideLdexternalmodulevarPrefImm16)3200 DEF_CALL_SIGNATURE(BaselineWideLdexternalmodulevarPrefImm16)
3201 {
3202 // 2 : 2 input parameters
3203 CallSignature signature("BaselineWideLdexternalmodulevarPrefImm16", 0, 2,
3204 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3205 *callSign = signature;
3206 // 2 : 2 input parameters
3207 std::array<VariableType, 2> params = {
3208 VariableType::NATIVE_POINTER(),
3209 VariableType::INT16(),
3210 };
3211 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3212 }
3213
3214 // GLUE, SP, METHOD_ID, LITERAL_ID, LENGTH, VREG_IDS
DEF_CALL_SIGNATURE(BaselineDeprecatedDefineclasswithbufferPrefId16Imm16Imm16V8V8)3215 DEF_CALL_SIGNATURE(BaselineDeprecatedDefineclasswithbufferPrefId16Imm16Imm16V8V8)
3216 {
3217 // 6 : 6 input parameters
3218 CallSignature signature("BaselineDeprecatedDefineclasswithbufferPrefId16Imm16Imm16V8V8", 0, 6,
3219 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3220 *callSign = signature;
3221 // 6 : 6 input parameters
3222 std::array<VariableType, 6> params = {
3223 VariableType::NATIVE_POINTER(),
3224 VariableType::NATIVE_POINTER(),
3225 VariableType::INT32(),
3226 VariableType::INT32(),
3227 VariableType::INT32(),
3228 VariableType::INT32(),
3229 };
3230 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3231 }
3232
3233 // GLUE, SP, INDEX
DEF_CALL_SIGNATURE(BaselineWideLdpatchvarPrefImm16)3234 DEF_CALL_SIGNATURE(BaselineWideLdpatchvarPrefImm16)
3235 {
3236 // 3 : 3 input parameters
3237 CallSignature signature("BaselineWideLdpatchvarPrefImm16", 0, 3,
3238 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3239 *callSign = signature;
3240 // 3 : 3 input parameters
3241 std::array<VariableType, 3> params = {
3242 VariableType::NATIVE_POINTER(),
3243 VariableType::NATIVE_POINTER(),
3244 VariableType::INT32(),
3245 };
3246 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3247 }
3248
3249 // GLUE, SP, ACC, V0, FUNC
DEF_CALL_SIGNATURE(BaselineDeprecatedResumegeneratorPrefV8)3250 DEF_CALL_SIGNATURE(BaselineDeprecatedResumegeneratorPrefV8)
3251 {
3252 // 4 : 4 input parameters
3253 CallSignature signature("BaselineDeprecatedResumegeneratorPrefV8", 0, 4,
3254 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3255 *callSign = signature;
3256 // 4 : 4 input parameters
3257 std::array<VariableType, 4> params = {
3258 VariableType::NATIVE_POINTER(),
3259 VariableType::NATIVE_POINTER(),
3260 VariableType::JS_ANY(),
3261 VariableType::INT8(),
3262 };
3263 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3264 }
3265
3266 // GLUE, SP, ACC, INDEX
DEF_CALL_SIGNATURE(BaselineWideStpatchvarPrefImm16)3267 DEF_CALL_SIGNATURE(BaselineWideStpatchvarPrefImm16)
3268 {
3269 // 4 : 4 input parameters
3270 CallSignature signature("BaselineWideStpatchvarPrefImm16", 0, 4,
3271 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3272 *callSign = signature;
3273 // 4 : 4 input parameters
3274 std::array<VariableType, 4> params = {
3275 VariableType::NATIVE_POINTER(),
3276 VariableType::NATIVE_POINTER(),
3277 VariableType::JS_ANY(),
3278 VariableType::INT32(),
3279 };
3280 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3281 }
3282
3283 // SP, ACC, V0
DEF_CALL_SIGNATURE(BaselineDeprecatedGetresumemodePrefV8)3284 DEF_CALL_SIGNATURE(BaselineDeprecatedGetresumemodePrefV8)
3285 {
3286 // 3 : 3 input parameters
3287 CallSignature signature("BaselineDeprecatedGetresumemodePrefV8", 0, 3,
3288 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3289 *callSign = signature;
3290 // 3 : 3 input parameters
3291 std::array<VariableType, 3> params = {
3292 VariableType::NATIVE_POINTER(),
3293 VariableType::JS_ANY(),
3294 VariableType::INT8(),
3295 };
3296 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3297 }
3298
3299 // GLUE, SP, V0
DEF_CALL_SIGNATURE(BaselineDeprecatedGettemplateobjectPrefV8)3300 DEF_CALL_SIGNATURE(BaselineDeprecatedGettemplateobjectPrefV8)
3301 {
3302 // 3 : 3 input parameters
3303 CallSignature signature("BaselineDeprecatedGettemplateobjectPrefV8", 0, 3,
3304 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3305 *callSign = signature;
3306 // 3 : 3 input parameters
3307 std::array<VariableType, 3> params = {
3308 VariableType::NATIVE_POINTER(),
3309 VariableType::NATIVE_POINTER(),
3310 VariableType::INT8(),
3311 };
3312 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3313 }
3314
3315 // GLUE, SP, V0, V1
DEF_CALL_SIGNATURE(BaselineDeprecatedDelobjpropPrefV8V8)3316 DEF_CALL_SIGNATURE(BaselineDeprecatedDelobjpropPrefV8V8)
3317 {
3318 // 4 : 4 input parameters
3319 CallSignature signature("BaselineDeprecatedDelobjpropPrefV8V8", 0, 4,
3320 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3321 *callSign = signature;
3322 // 4 : 4 input parameters
3323 std::array<VariableType, 4> params = {
3324 VariableType::NATIVE_POINTER(),
3325 VariableType::NATIVE_POINTER(),
3326 VariableType::INT8(),
3327 VariableType::INT8(),
3328 };
3329 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3330 }
3331
3332 // GLUE, SP, PC, V0, V1
DEF_CALL_SIGNATURE(BaselineDeprecatedSuspendgeneratorPrefV8V8)3333 DEF_CALL_SIGNATURE(BaselineDeprecatedSuspendgeneratorPrefV8V8)
3334 {
3335 // 5 : 5 input parameters
3336 CallSignature signature("BaselineDeprecatedSuspendgeneratorPrefV8V8", 0, 5,
3337 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3338 *callSign = signature;
3339 // 5 : 5 input parameters
3340 std::array<VariableType, 5> params = {
3341 VariableType::NATIVE_POINTER(),
3342 VariableType::NATIVE_POINTER(),
3343 VariableType::INT32(),
3344 VariableType::INT8(),
3345 VariableType::INT8(),
3346 };
3347 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3348 }
3349
3350 // GLUE, SP, PC, V0, V1
DEF_CALL_SIGNATURE(BaselineSuspendgeneratorV8)3351 DEF_CALL_SIGNATURE(BaselineSuspendgeneratorV8)
3352 {
3353 // 4 : 4 input parameters
3354 CallSignature signature("BaselineSuspendgeneratorV8", 0, 4,
3355 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3356 *callSign = signature;
3357 // 4 : 4 input parameters
3358 std::array<VariableType, 4> params = {
3359 VariableType::NATIVE_POINTER(),
3360 VariableType::NATIVE_POINTER(),
3361 VariableType::INT32(),
3362 VariableType::INT32(),
3363 };
3364 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3365 }
3366
3367 // GLUE, SP, V0, V1
DEF_CALL_SIGNATURE(BaselineDeprecatedAsyncfunctionawaituncaughtPrefV8V8)3368 DEF_CALL_SIGNATURE(BaselineDeprecatedAsyncfunctionawaituncaughtPrefV8V8)
3369 {
3370 // 4 : 4 input parameters
3371 CallSignature signature("BaselineDeprecatedAsyncfunctionawaituncaughtPrefV8V8", 0, 4,
3372 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3373 *callSign = signature;
3374 // 4 : 4 input parameters
3375 std::array<VariableType, 4> params = {
3376 VariableType::NATIVE_POINTER(),
3377 VariableType::NATIVE_POINTER(),
3378 VariableType::INT8(),
3379 VariableType::INT8(),
3380 };
3381 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3382 }
3383
3384 // GLUE, SP, V0, V1
DEF_CALL_SIGNATURE(BaselineDeprecatedCopydatapropertiesPrefV8V8)3385 DEF_CALL_SIGNATURE(BaselineDeprecatedCopydatapropertiesPrefV8V8)
3386 {
3387 // 4 : 4 input parameters
3388 CallSignature signature("BaselineDeprecatedCopydatapropertiesPrefV8V8", 0, 4,
3389 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3390 *callSign = signature;
3391 // 4 : 4 input parameters
3392 std::array<VariableType, 4> params = {
3393 VariableType::NATIVE_POINTER(),
3394 VariableType::NATIVE_POINTER(),
3395 VariableType::INT8(),
3396 VariableType::INT8(),
3397 };
3398 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3399 }
3400
3401 // GLUE, SP, ACC, V0, V1
DEF_CALL_SIGNATURE(BaselineDeprecatedSetobjectwithprotoPrefV8V8)3402 DEF_CALL_SIGNATURE(BaselineDeprecatedSetobjectwithprotoPrefV8V8)
3403 {
3404 // 5 : 5 input parameters
3405 CallSignature signature("BaselineDeprecatedSetobjectwithprotoPrefV8V8", 0, 5,
3406 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3407 *callSign = signature;
3408 // 5 : 5 input parameters
3409 std::array<VariableType, 5> params = {
3410 VariableType::NATIVE_POINTER(),
3411 VariableType::NATIVE_POINTER(),
3412 VariableType::JS_ANY(),
3413 VariableType::INT8(),
3414 VariableType::INT8(),
3415 };
3416 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3417 }
3418
3419 // GLUE, SP, V0, V1
DEF_CALL_SIGNATURE(BaselineDeprecatedLdobjbyvaluePrefV8V8)3420 DEF_CALL_SIGNATURE(BaselineDeprecatedLdobjbyvaluePrefV8V8)
3421 {
3422 // 4 : 4 input parameters
3423 CallSignature signature("BaselineDeprecatedLdobjbyvaluePrefV8V8", 0, 4,
3424 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3425 *callSign = signature;
3426 // 4 : 4 input parameters
3427 std::array<VariableType, 4> params = {
3428 VariableType::NATIVE_POINTER(),
3429 VariableType::NATIVE_POINTER(),
3430 VariableType::INT8(),
3431 VariableType::INT8(),
3432 };
3433 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3434 }
3435
3436 // GLUE, SP, V0, V1
DEF_CALL_SIGNATURE(BaselineDeprecatedLdsuperbyvaluePrefV8V8)3437 DEF_CALL_SIGNATURE(BaselineDeprecatedLdsuperbyvaluePrefV8V8)
3438 {
3439 // 4 : 4 input parameters
3440 CallSignature signature("BaselineDeprecatedLdsuperbyvaluePrefV8V8", 0, 4,
3441 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3442 *callSign = signature;
3443 // 4 : 4 input parameters
3444 std::array<VariableType, 4> params = {
3445 VariableType::NATIVE_POINTER(),
3446 VariableType::NATIVE_POINTER(),
3447 VariableType::INT8(),
3448 VariableType::INT8(),
3449 };
3450 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3451 }
3452
3453 // GLUE, SP, V0, INDEX
DEF_CALL_SIGNATURE(BaselineDeprecatedLdobjbyindexPrefV8Imm32)3454 DEF_CALL_SIGNATURE(BaselineDeprecatedLdobjbyindexPrefV8Imm32)
3455 {
3456 // 4 : 4 input parameters
3457 CallSignature signature("BaselineDeprecatedLdobjbyindexPrefV8Imm32", 0, 4,
3458 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3459 *callSign = signature;
3460 // 4 : 4 input parameters
3461 std::array<VariableType, 4> params = {
3462 VariableType::NATIVE_POINTER(),
3463 VariableType::NATIVE_POINTER(),
3464 VariableType::INT8(),
3465 VariableType::INT32(),
3466 };
3467 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3468 }
3469
3470 // GLUE, SP, V0, V1
DEF_CALL_SIGNATURE(BaselineDeprecatedAsyncfunctionresolvePrefV8V8V8)3471 DEF_CALL_SIGNATURE(BaselineDeprecatedAsyncfunctionresolvePrefV8V8V8)
3472 {
3473 // 4 : 4 input parameters
3474 CallSignature signature("BaselineDeprecatedAsyncfunctionresolvePrefV8V8V8", 0, 4,
3475 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3476 *callSign = signature;
3477 // 4 : 4 input parameters
3478 std::array<VariableType, 4> params = {
3479 VariableType::NATIVE_POINTER(),
3480 VariableType::NATIVE_POINTER(),
3481 VariableType::INT8(),
3482 VariableType::INT8(),
3483 };
3484 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3485 }
3486
3487 // GLUE, SP, V0, V1
DEF_CALL_SIGNATURE(BaselineDeprecatedAsyncfunctionrejectPrefV8V8V8)3488 DEF_CALL_SIGNATURE(BaselineDeprecatedAsyncfunctionrejectPrefV8V8V8)
3489 {
3490 // 4 : 4 input parameters
3491 CallSignature signature("BaselineDeprecatedAsyncfunctionrejectPrefV8V8V8", 0, 4,
3492 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3493 *callSign = signature;
3494 // 4 : 4 input parameters
3495 std::array<VariableType, 4> params = {
3496 VariableType::NATIVE_POINTER(),
3497 VariableType::NATIVE_POINTER(),
3498 VariableType::INT8(),
3499 VariableType::INT8(),
3500 };
3501 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3502 }
3503
3504 // GLUE, SP, LEVEL, SLOT, V0
DEF_CALL_SIGNATURE(BaselineDeprecatedStlexvarPrefImm4Imm4V8)3505 DEF_CALL_SIGNATURE(BaselineDeprecatedStlexvarPrefImm4Imm4V8)
3506 {
3507 // 5 : 5 input parameters
3508 CallSignature signature("BaselineDeprecatedStlexvarPrefImm4Imm4V8", 0, 5,
3509 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3510 *callSign = signature;
3511 // 5 : 5 input parameters
3512 std::array<VariableType, 5> params = {
3513 VariableType::NATIVE_POINTER(),
3514 VariableType::NATIVE_POINTER(),
3515 VariableType::INT32(),
3516 VariableType::INT32(),
3517 VariableType::INT8(),
3518 };
3519 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3520 }
3521
3522 // GLUE, SP, LEVEL, SLOT, V0
DEF_CALL_SIGNATURE(BaselineDeprecatedStlexvarPrefImm8Imm8V8)3523 DEF_CALL_SIGNATURE(BaselineDeprecatedStlexvarPrefImm8Imm8V8)
3524 {
3525 // 5 : 5 input parameters
3526 CallSignature signature("BaselineDeprecatedStlexvarPrefImm8Imm8V8", 0, 5,
3527 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3528 *callSign = signature;
3529 // 5 : 5 input parameters
3530 std::array<VariableType, 5> params = {
3531 VariableType::NATIVE_POINTER(),
3532 VariableType::NATIVE_POINTER(),
3533 VariableType::INT32(),
3534 VariableType::INT32(),
3535 VariableType::INT8(),
3536 };
3537 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3538 }
3539
3540 // GLUE, SP, LEVEL, SLOT, V0
DEF_CALL_SIGNATURE(BaselineDeprecatedStlexvarPrefImm16Imm16V8)3541 DEF_CALL_SIGNATURE(BaselineDeprecatedStlexvarPrefImm16Imm16V8)
3542 {
3543 // 5 : 5 input parameters
3544 CallSignature signature("BaselineDeprecatedStlexvarPrefImm16Imm16V8", 0, 5,
3545 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3546 *callSign = signature;
3547 // 5 : 5 input parameters
3548 std::array<VariableType, 5> params = {
3549 VariableType::NATIVE_POINTER(),
3550 VariableType::NATIVE_POINTER(),
3551 VariableType::INT32(),
3552 VariableType::INT32(),
3553 VariableType::INT8(),
3554 };
3555 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3556 }
3557
3558 // GLUE, STRING_ID, CONST_POOL
DEF_CALL_SIGNATURE(BaselineDeprecatedGetmodulenamespacePrefId32)3559 DEF_CALL_SIGNATURE(BaselineDeprecatedGetmodulenamespacePrefId32)
3560 {
3561 // 3 : 3 input parameters
3562 CallSignature signature("BaselineDeprecatedGetmodulenamespacePrefId32", 0, 3,
3563 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3564 *callSign = signature;
3565 // 3 : 3 input parameters
3566 std::array<VariableType, 3> params = {
3567 VariableType::NATIVE_POINTER(),
3568 VariableType::INT32(),
3569 VariableType::NATIVE_POINTER(),
3570 };
3571 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3572 }
3573
3574 // GLUE, ACC, STRING_ID, CONST_POOL
DEF_CALL_SIGNATURE(BaselineDeprecatedStmodulevarPrefId32)3575 DEF_CALL_SIGNATURE(BaselineDeprecatedStmodulevarPrefId32)
3576 {
3577 // 4 : 4 input parameters
3578 CallSignature signature("BaselineDeprecatedStmodulevarPrefId32", 0, 4,
3579 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3580 *callSign = signature;
3581 // 4 : 4 input parameters
3582 std::array<VariableType, 4> params = {
3583 VariableType::NATIVE_POINTER(),
3584 VariableType::JS_ANY(),
3585 VariableType::INT32(),
3586 VariableType::NATIVE_POINTER(),
3587 };
3588 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3589 }
3590
3591 // GLUE, SP, V0, STRING_ID, CONST_POOL
DEF_CALL_SIGNATURE(BaselineDeprecatedLdobjbynamePrefId32V8)3592 DEF_CALL_SIGNATURE(BaselineDeprecatedLdobjbynamePrefId32V8)
3593 {
3594 // 4 : 4 input parameters
3595 CallSignature signature("BaselineDeprecatedLdobjbynamePrefId32V8", 0, 4,
3596 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3597 *callSign = signature;
3598 // 4 : 4 input parameters
3599 std::array<VariableType, 4> params = {
3600 VariableType::NATIVE_POINTER(),
3601 VariableType::NATIVE_POINTER(),
3602 VariableType::INT8(),
3603 VariableType::INT32(),
3604 };
3605 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3606 }
3607
3608 // GLUE, SP, STRING_ID, V0
DEF_CALL_SIGNATURE(BaselineDeprecatedLdsuperbynamePrefId32V8)3609 DEF_CALL_SIGNATURE(BaselineDeprecatedLdsuperbynamePrefId32V8)
3610 {
3611 // 4 : 4 input parameters
3612 CallSignature signature("BaselineDeprecatedLdsuperbynamePrefId32V8", 0, 4,
3613 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3614 *callSign = signature;
3615 // 4 : 4 input parameters
3616 std::array<VariableType, 4> params = {
3617 VariableType::NATIVE_POINTER(),
3618 VariableType::NATIVE_POINTER(),
3619 VariableType::INT32(),
3620 VariableType::INT8(),
3621 };
3622 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3623 }
3624
3625 // GLUE, STRING_ID, FLAG_I8, CONST_POOL
DEF_CALL_SIGNATURE(BaselineDeprecatedLdmodulevarPrefId32Imm8)3626 DEF_CALL_SIGNATURE(BaselineDeprecatedLdmodulevarPrefId32Imm8)
3627 {
3628 // 4 : 4 input parameters
3629 CallSignature signature("BaselineDeprecatedLdmodulevarPrefId32Imm8", 0, 4,
3630 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3631 *callSign = signature;
3632 // 4 : 4 input parameters
3633 std::array<VariableType, 4> params = {
3634 VariableType::NATIVE_POINTER(),
3635 VariableType::INT32(),
3636 VariableType::INT8(),
3637 VariableType::NATIVE_POINTER(),
3638 };
3639 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3640 }
3641
3642 // GLUE, ACC, STRING_ID, CONST_POOL
DEF_CALL_SIGNATURE(BaselineDeprecatedStconsttoglobalrecordPrefId32)3643 DEF_CALL_SIGNATURE(BaselineDeprecatedStconsttoglobalrecordPrefId32)
3644 {
3645 // 4 : 4 input parameters
3646 CallSignature signature("BaselineDeprecatedStconsttoglobalrecordPrefId32", 0, 4,
3647 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3648 *callSign = signature;
3649 // 4 : 4 input parameters
3650 std::array<VariableType, 4> params = {
3651 VariableType::NATIVE_POINTER(),
3652 VariableType::JS_ANY(),
3653 VariableType::INT32(),
3654 VariableType::NATIVE_POINTER(),
3655 };
3656 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3657 }
3658
3659 // GLUE, ACC, STRING_ID, CONST_POOL
DEF_CALL_SIGNATURE(BaselineDeprecatedStlettoglobalrecordPrefId32)3660 DEF_CALL_SIGNATURE(BaselineDeprecatedStlettoglobalrecordPrefId32)
3661 {
3662 // 4 : 4 input parameters
3663 CallSignature signature("BaselineDeprecatedStlettoglobalrecordPrefId32", 0, 4,
3664 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3665 *callSign = signature;
3666 // 4 : 4 input parameters
3667 std::array<VariableType, 4> params = {
3668 VariableType::NATIVE_POINTER(),
3669 VariableType::JS_ANY(),
3670 VariableType::INT32(),
3671 VariableType::NATIVE_POINTER(),
3672 };
3673 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3674 }
3675
3676 // GLUE, ACC, STRING_ID, CONST_POOL
DEF_CALL_SIGNATURE(BaselineDeprecatedStclasstoglobalrecordPrefId32)3677 DEF_CALL_SIGNATURE(BaselineDeprecatedStclasstoglobalrecordPrefId32)
3678 {
3679 // 4 : 4 input parameters
3680 CallSignature signature("BaselineDeprecatedStclasstoglobalrecordPrefId32", 0, 4,
3681 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3682 *callSign = signature;
3683 // 4 : 4 input parameters
3684 std::array<VariableType, 4> params = {
3685 VariableType::NATIVE_POINTER(),
3686 VariableType::JS_ANY(),
3687 VariableType::INT32(),
3688 VariableType::NATIVE_POINTER(),
3689 };
3690 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3691 }
3692
3693 // SP
DEF_CALL_SIGNATURE(BaselineDeprecatedLdhomeobjectPrefNone)3694 DEF_CALL_SIGNATURE(BaselineDeprecatedLdhomeobjectPrefNone)
3695 {
3696 // 1 : 1 input parameters
3697 CallSignature signature("BaselineDeprecatedLdhomeobjectPrefNone", 0, 1,
3698 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3699 *callSign = signature;
3700 // 1 : 1 input parameters
3701 std::array<VariableType, 1> params = {
3702 VariableType::NATIVE_POINTER(),
3703 };
3704 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3705 }
3706
3707 // GLUE, ACC, CONSTPOOL, IMM_I16, FUNC
DEF_CALL_SIGNATURE(BaselineDeprecatedCreateobjecthavingmethodPrefImm16)3708 DEF_CALL_SIGNATURE(BaselineDeprecatedCreateobjecthavingmethodPrefImm16)
3709 {
3710 // 4 : 4 input parameters
3711 CallSignature signature("BaselineDeprecatedCreateobjecthavingmethodPrefImm16", 0, 4,
3712 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3713 *callSign = signature;
3714 // 4 : 4 input parameters
3715 std::array<VariableType, 4> params = {
3716 VariableType::NATIVE_POINTER(),
3717 VariableType::JS_ANY(),
3718 VariableType::NATIVE_POINTER(),
3719 VariableType::INT16(),
3720 };
3721 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3722 }
3723
3724 // GLUE, ACC, VREG, FUNC
DEF_CALL_SIGNATURE(BaselineDeprecatedDynamicimportPrefV8)3725 DEF_CALL_SIGNATURE(BaselineDeprecatedDynamicimportPrefV8)
3726 {
3727 // 4 : 4 input parameters
3728 CallSignature signature("BaselineDeprecatedDynamicimportPrefV8", 0, 4,
3729 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3730 *callSign = signature;
3731 // 4 : 4 input parameters
3732 std::array<VariableType, 4> params = {
3733 VariableType::NATIVE_POINTER(),
3734 VariableType::NATIVE_POINTER(),
3735 VariableType::JS_ANY(),
3736 VariableType::JS_ANY(),
3737 };
3738 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3739 }
3740
3741 // GLUE, ACC, FUNC
DEF_CALL_SIGNATURE(BaselineCallRuntimeNotifyConcurrentResultPrefNone)3742 DEF_CALL_SIGNATURE(BaselineCallRuntimeNotifyConcurrentResultPrefNone)
3743 {
3744 // 3 : 3 input parameters
3745 CallSignature signature("BaselineCallRuntimeNotifyConcurrentResultPrefNone", 0, 3,
3746 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3747 *callSign = signature;
3748 // 3 : 3 input parameters
3749 std::array<VariableType, 3> params = {
3750 VariableType::NATIVE_POINTER(),
3751 VariableType::NATIVE_POINTER(),
3752 VariableType::JS_ANY(),
3753 };
3754 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3755 }
3756
3757 // GLUE, SP, SLOT_ID, STRING_ID, V0
DEF_CALL_SIGNATURE(BaselineDefineFieldByNameImm8Id16V8)3758 DEF_CALL_SIGNATURE(BaselineDefineFieldByNameImm8Id16V8)
3759 {
3760 // 5 : 5 input parameters
3761 CallSignature signature("BaselineDefineFieldByNameImm8Id16V8", 0, 5,
3762 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3763 *callSign = signature;
3764 // 5 : 5 input parameters
3765 std::array<VariableType, 5> params = {
3766 VariableType::NATIVE_POINTER(),
3767 VariableType::NATIVE_POINTER(),
3768 VariableType::INT32(),
3769 VariableType::INT32(),
3770 VariableType::INT32(),
3771 };
3772 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3773 }
3774
DEF_CALL_SIGNATURE(BaselineDefinePropertyByNameImm8Id16V8)3775 DEF_CALL_SIGNATURE(BaselineDefinePropertyByNameImm8Id16V8)
3776 {
3777 // 5 : 5 input parameters
3778 CallSignature signature("BaselineDefinePropertyByNameImm8Id16V8", 0, 5,
3779 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3780 *callSign = signature;
3781 // 5 : 5 input parameters
3782 std::array<VariableType, 5> params = {
3783 VariableType::NATIVE_POINTER(),
3784 VariableType::NATIVE_POINTER(),
3785 VariableType::INT32(),
3786 VariableType::INT32(),
3787 VariableType::INT32(),
3788 };
3789 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3790 }
3791
3792 // GLUE, SP, ACC, V0, V1
DEF_CALL_SIGNATURE(BaselineCallRuntimeDefineFieldByValuePrefImm8V8V8)3793 DEF_CALL_SIGNATURE(BaselineCallRuntimeDefineFieldByValuePrefImm8V8V8)
3794 {
3795 // 5 : 5 input parameters
3796 CallSignature signature("BaselineCallRuntimeDefineFieldByValuePrefImm8V8V8", 0, 5,
3797 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3798 *callSign = signature;
3799 // 5 : 5 input parameters
3800 std::array<VariableType, 5> params = {
3801 VariableType::NATIVE_POINTER(),
3802 VariableType::NATIVE_POINTER(),
3803 VariableType::JS_ANY(),
3804 VariableType::INT8(),
3805 VariableType::INT8(),
3806 };
3807 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3808 }
3809
3810 // GLUE, ACC, INDEX, V0
DEF_CALL_SIGNATURE(BaselineCallRuntimeDefineFieldByIndexPrefImm8Imm32V8)3811 DEF_CALL_SIGNATURE(BaselineCallRuntimeDefineFieldByIndexPrefImm8Imm32V8)
3812 {
3813 // 5 : 5 input parameters
3814 CallSignature signature("BaselineCallRuntimeDefineFieldByIndexPrefImm8Imm32V8", 0, 5,
3815 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3816 *callSign = signature;
3817 // 5 : 5 input parameters
3818 std::array<VariableType, 5> params = {
3819 VariableType::NATIVE_POINTER(),
3820 VariableType::NATIVE_POINTER(),
3821 VariableType::JS_ANY(),
3822 VariableType::INT32(),
3823 VariableType::INT8(),
3824 };
3825 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3826 }
3827
DEF_CALL_SIGNATURE(BaselineCallRuntimeToPropertyKeyPrefNone)3828 DEF_CALL_SIGNATURE(BaselineCallRuntimeToPropertyKeyPrefNone)
3829 {
3830 // 3 : 3 input parameters
3831 CallSignature signature("BaselineCallRuntimeToPropertyKeyPrefNone", 0, 3,
3832 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3833 *callSign = signature;
3834 // 3 : 3 input parameters
3835 std::array<VariableType, 3> params = {
3836 VariableType::NATIVE_POINTER(),
3837 VariableType::NATIVE_POINTER(),
3838 VariableType::JS_ANY(),
3839 };
3840 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3841 }
3842
3843 // GLUE, SP, COUNT, LITERAL_ID
DEF_CALL_SIGNATURE(BaselineCallRuntimeCreatePrivatePropertyPrefImm16Id16)3844 DEF_CALL_SIGNATURE(BaselineCallRuntimeCreatePrivatePropertyPrefImm16Id16)
3845 {
3846 // 4 : 4 input parameters
3847 CallSignature signature("BaselineCallRuntimeCreatePrivatePropertyPrefImm16Id16", 0, 4,
3848 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3849 *callSign = signature;
3850 // 4 : 4 input parameters
3851 std::array<VariableType, 4> params = {
3852 VariableType::NATIVE_POINTER(),
3853 VariableType::NATIVE_POINTER(),
3854 VariableType::INT32(),
3855 VariableType::INT32(),
3856 };
3857 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3858 }
3859
3860 // GLUE, SP, ACC, LEVEL_INDEX, SLOT_INDEX, V0
DEF_CALL_SIGNATURE(BaselineCallRuntimeDefinePrivatePropertyPrefImm8Imm16Imm16V8)3861 DEF_CALL_SIGNATURE(BaselineCallRuntimeDefinePrivatePropertyPrefImm8Imm16Imm16V8)
3862 {
3863 // 6 : 6 input parameters
3864 CallSignature signature("BaselineCallRuntimeDefinePrivatePropertyPrefImm8Imm16Imm16V8", 0, 6,
3865 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3866 *callSign = signature;
3867 // 6 : 6 input parameters
3868 std::array<VariableType, 6> params = {
3869 VariableType::NATIVE_POINTER(),
3870 VariableType::NATIVE_POINTER(),
3871 VariableType::JS_ANY(),
3872 VariableType::INT32(),
3873 VariableType::INT32(),
3874 VariableType::INT8(),
3875 };
3876 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3877 }
3878
3879 // GLUE, SP, ACC, V0, HOTNESS_COUNTER, SLOT_ID
DEF_CALL_SIGNATURE(BaselineCallRuntimeCallInitPrefImm8V8)3880 DEF_CALL_SIGNATURE(BaselineCallRuntimeCallInitPrefImm8V8)
3881 {
3882 // 6 : 6 input parameters
3883 CallSignature signature("BaselineCallRuntimeCallInitPrefImm8V8", 0, 6,
3884 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3885 *callSign = signature;
3886 // 6 : 6 input parameters
3887 std::array<VariableType, 6> params = {
3888 VariableType::NATIVE_POINTER(),
3889 VariableType::NATIVE_POINTER(),
3890 VariableType::JS_ANY(),
3891 VariableType::INT8(),
3892 VariableType::INT32(),
3893 VariableType::INT32(),
3894 };
3895 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3896 }
3897
3898 // GLUE, SP, METHOD_ID, LITERAL_ID, LENGTH, V0
DEF_CALL_SIGNATURE(BaselineCallRuntimeDefineSendableClassPrefImm16Id16Id16Imm16V8)3899 DEF_CALL_SIGNATURE(BaselineCallRuntimeDefineSendableClassPrefImm16Id16Id16Imm16V8)
3900 {
3901 // 6 : 6 input parameters
3902 CallSignature signature("BaselineCallRuntimeDefineSendableClassPrefImm16Id16Id16Imm16V8", 0, 6,
3903 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3904 *callSign = signature;
3905 // 6 : 6 input parameters
3906 std::array<VariableType, 6> params = {
3907 VariableType::NATIVE_POINTER(),
3908 VariableType::NATIVE_POINTER(),
3909 VariableType::INT16(),
3910 VariableType::INT16(),
3911 VariableType::INT16(),
3912 VariableType::INT8(),
3913 };
3914 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3915 }
3916
DEF_CALL_SIGNATURE(BaselineCallRuntimeLdSendableClassPrefImm16)3917 DEF_CALL_SIGNATURE(BaselineCallRuntimeLdSendableClassPrefImm16)
3918 {
3919 // 3 : 3 input parameters
3920 CallSignature signature("BaselineCallRuntimeLdSendableClassPrefImm16", 0, 3,
3921 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3922 *callSign = signature;
3923 // 3 : 3 input parameters
3924 std::array<VariableType, 3> params = {
3925 VariableType::NATIVE_POINTER(),
3926 VariableType::NATIVE_POINTER(),
3927 VariableType::INT16(),
3928 };
3929 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3930 }
3931
DEF_CALL_SIGNATURE(BaselineCallRuntimeIstruePrefImm8)3932 DEF_CALL_SIGNATURE(BaselineCallRuntimeIstruePrefImm8)
3933 {
3934 // 4 : 4 input parameters
3935 CallSignature signature("BaselineCallRuntimeIstruePrefImm8", 0, 4,
3936 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3937 *callSign = signature;
3938 // 4 : 4 input parameters
3939 std::array<VariableType, 4> params = {
3940 VariableType::NATIVE_POINTER(),
3941 VariableType::NATIVE_POINTER(),
3942 VariableType::JS_ANY(),
3943 VariableType::INT32(),
3944 };
3945 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3946 }
3947
DEF_CALL_SIGNATURE(BaselineCallRuntimeIsfalsePrefImm8)3948 DEF_CALL_SIGNATURE(BaselineCallRuntimeIsfalsePrefImm8)
3949 {
3950 // 4 : 4 input parameters
3951 CallSignature signature("BaselineCallRuntimeIsfalsePrefImm8", 0, 4,
3952 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3953 *callSign = signature;
3954 // 4 : 4 input parameters
3955 std::array<VariableType, 4> params = {
3956 VariableType::NATIVE_POINTER(),
3957 VariableType::NATIVE_POINTER(),
3958 VariableType::JS_ANY(),
3959 VariableType::INT32(),
3960 };
3961 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3962 }
3963
3964 // GLUE, ACC, SP
DEF_CALL_SIGNATURE(BaselineReturnundefined)3965 DEF_CALL_SIGNATURE(BaselineReturnundefined)
3966 {
3967 // 3 : 3 input parameters
3968 CallSignature signature("BaselineReturnundefined", 0, 3,
3969 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3970 *callSign = signature;
3971 // 3 : 3 input parameters
3972 std::array<VariableType, 3> params = {
3973 VariableType::NATIVE_POINTER(),
3974 VariableType::NATIVE_POINTER(),
3975 VariableType::INT32(),
3976 };
3977
3978 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3979 }
3980
3981 // GLUE, SP, ACC
DEF_CALL_SIGNATURE(BaselineExceptionHandler)3982 DEF_CALL_SIGNATURE(BaselineExceptionHandler)
3983 {
3984 // 3 : 3 input parameters
3985 CallSignature signature("BaselineExceptionHandler", 0, 3,
3986 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3987 *callSign = signature;
3988 // 3 : 3 input parameters
3989 std::array<VariableType, 3> params = {
3990 VariableType::NATIVE_POINTER(),
3991 VariableType::NATIVE_POINTER(),
3992 VariableType::JS_ANY(),
3993 };
3994 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
3995 }
3996
3997 // GLUE, SP, OFFSET
DEF_CALL_SIGNATURE(BaselineUpdateHotness)3998 DEF_CALL_SIGNATURE(BaselineUpdateHotness)
3999 {
4000 // 3 : 3 input parameters
4001 CallSignature signature("BaselineUpdateHotness", 0, 3,
4002 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
4003 *callSign = signature;
4004 // 3 : 3 input parameters
4005 std::array<VariableType, 3> params = {
4006 VariableType::NATIVE_POINTER(),
4007 VariableType::NATIVE_POINTER(),
4008 VariableType::INT32(),
4009 };
4010 BASELINE_STUB_CALL_SIGNATURE_COMMON_SET();
4011 }
4012 } // namespace panda::ecmascript::kungfu
4013