1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "ecmascript/compiler/call_signature.h"
17 #include "ecmascript/compiler/variable_type.h"
18
19 #if defined(__clang__)
20 #pragma clang diagnostic push
21 #pragma clang diagnostic ignored "-Wshadow"
22 #pragma clang diagnostic ignored "-Wunused-parameter"
23 #elif defined(__GNUC__)
24 #pragma GCC diagnostic push
25 #pragma GCC diagnostic ignored "-Wshadow"
26 #pragma GCC diagnostic ignored "-Wunused-parameter"
27 #endif
28
29 #include "llvm-c/Core.h"
30 #include "llvm/Support/Host.h"
31
32 #if defined(__clang__)
33 #pragma clang diagnostic pop
34 #elif defined(__GNUC__)
35 #pragma GCC diagnostic pop
36 #endif
37
38 namespace panda::ecmascript::kungfu {
39 #define BINARY_CALL_SIGNATURE(name) \
40 /* 3 : 3 input parameters */ \
41 CallSignature signature(#name, 0, 3, \
42 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); \
43 *callSign = signature; \
44 /* 3 : 3 input parameters */ \
45 std::array<VariableType, 3> params = { \
46 VariableType::NATIVE_POINTER(), \
47 VariableType::JS_ANY(), \
48 VariableType::JS_ANY(), \
49 }; \
50 callSign->SetParameters(params.data()); \
51 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
52
DEF_CALL_SIGNATURE(Add)53 DEF_CALL_SIGNATURE(Add)
54 {
55 BINARY_CALL_SIGNATURE(Add)
56 }
57
DEF_CALL_SIGNATURE(Sub)58 DEF_CALL_SIGNATURE(Sub)
59 {
60 BINARY_CALL_SIGNATURE(Sub)
61 }
62
DEF_CALL_SIGNATURE(Mul)63 DEF_CALL_SIGNATURE(Mul)
64 {
65 BINARY_CALL_SIGNATURE(Mul)
66 }
67
DEF_CALL_SIGNATURE(Div)68 DEF_CALL_SIGNATURE(Div)
69 {
70 BINARY_CALL_SIGNATURE(Div)
71 }
72
DEF_CALL_SIGNATURE(Mod)73 DEF_CALL_SIGNATURE(Mod)
74 {
75 BINARY_CALL_SIGNATURE(Mod)
76 }
77
DEF_CALL_SIGNATURE(Equal)78 DEF_CALL_SIGNATURE(Equal)
79 {
80 BINARY_CALL_SIGNATURE(Equal)
81 }
82
DEF_CALL_SIGNATURE(NotEqual)83 DEF_CALL_SIGNATURE(NotEqual)
84 {
85 BINARY_CALL_SIGNATURE(NotEqual)
86 }
87
DEF_CALL_SIGNATURE(StrictEqual)88 DEF_CALL_SIGNATURE(StrictEqual)
89 {
90 BINARY_CALL_SIGNATURE(StrictEqual)
91 }
92
DEF_CALL_SIGNATURE(StrictNotEqual)93 DEF_CALL_SIGNATURE(StrictNotEqual)
94 {
95 BINARY_CALL_SIGNATURE(StrictNotEqual)
96 }
97
DEF_CALL_SIGNATURE(Less)98 DEF_CALL_SIGNATURE(Less)
99 {
100 BINARY_CALL_SIGNATURE(Less)
101 }
102
DEF_CALL_SIGNATURE(LessEq)103 DEF_CALL_SIGNATURE(LessEq)
104 {
105 BINARY_CALL_SIGNATURE(LessEq)
106 }
107
DEF_CALL_SIGNATURE(Greater)108 DEF_CALL_SIGNATURE(Greater)
109 {
110 BINARY_CALL_SIGNATURE(Greater)
111 }
112
DEF_CALL_SIGNATURE(GreaterEq)113 DEF_CALL_SIGNATURE(GreaterEq)
114 {
115 BINARY_CALL_SIGNATURE(GreaterEq)
116 }
117
DEF_CALL_SIGNATURE(Shl)118 DEF_CALL_SIGNATURE(Shl)
119 {
120 BINARY_CALL_SIGNATURE(Shl)
121 }
122
DEF_CALL_SIGNATURE(Shr)123 DEF_CALL_SIGNATURE(Shr)
124 {
125 BINARY_CALL_SIGNATURE(Shr)
126 }
127
DEF_CALL_SIGNATURE(Ashr)128 DEF_CALL_SIGNATURE(Ashr)
129 {
130 BINARY_CALL_SIGNATURE(Ashr)
131 }
132
DEF_CALL_SIGNATURE(And)133 DEF_CALL_SIGNATURE(And)
134 {
135 BINARY_CALL_SIGNATURE(And)
136 }
137
DEF_CALL_SIGNATURE(Or)138 DEF_CALL_SIGNATURE(Or)
139 {
140 BINARY_CALL_SIGNATURE(Or)
141 }
142
DEF_CALL_SIGNATURE(Xor)143 DEF_CALL_SIGNATURE(Xor)
144 {
145 BINARY_CALL_SIGNATURE(Xor)
146 }
147
148 #ifndef NDEBUG
DEF_CALL_SIGNATURE(MulGCTest)149 DEF_CALL_SIGNATURE(MulGCTest)
150 {
151 // 3 : 3 input parameters
152 CallSignature MulGC("MulGCTest", 0, 3, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
153 *callSign = MulGC;
154 // 3 : 3 input parameters
155 std::array<VariableType, 3> params = {
156 VariableType::NATIVE_POINTER(),
157 VariableType::INT64(),
158 VariableType::INT64(),
159 };
160 callSign->SetParameters(params.data());
161 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
162 }
163 #else
DEF_CALL_SIGNATURE(MulGCTest)164 DEF_CALL_SIGNATURE(MulGCTest) {}
165 #endif
166
167 #define UNARY_CALL_SIGNATURE(name) \
168 /* 2 : 2 input parameters */ \
169 CallSignature signature(#name, 0, 2, \
170 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); \
171 *callSign = signature; \
172 /* 2 : 2 input parameters */ \
173 std::array<VariableType, 2> params = { \
174 VariableType::NATIVE_POINTER(), \
175 VariableType::JS_ANY(), \
176 }; \
177 callSign->SetParameters(params.data()); \
178 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
179
DEF_CALL_SIGNATURE(Inc)180 DEF_CALL_SIGNATURE(Inc)
181 {
182 UNARY_CALL_SIGNATURE(Inc)
183 }
184
DEF_CALL_SIGNATURE(Dec)185 DEF_CALL_SIGNATURE(Dec)
186 {
187 UNARY_CALL_SIGNATURE(Dec)
188 }
189
DEF_CALL_SIGNATURE(Neg)190 DEF_CALL_SIGNATURE(Neg)
191 {
192 UNARY_CALL_SIGNATURE(Neg)
193 }
194
DEF_CALL_SIGNATURE(Not)195 DEF_CALL_SIGNATURE(Not)
196 {
197 UNARY_CALL_SIGNATURE(Not)
198 }
199
DEF_CALL_SIGNATURE(ToBooleanTrue)200 DEF_CALL_SIGNATURE(ToBooleanTrue)
201 {
202 UNARY_CALL_SIGNATURE(ToBooleanTrue)
203 }
204
DEF_CALL_SIGNATURE(ToBooleanFalse)205 DEF_CALL_SIGNATURE(ToBooleanFalse)
206 {
207 UNARY_CALL_SIGNATURE(ToBooleanFalse)
208 }
209
DEF_CALL_SIGNATURE(TypeOf)210 DEF_CALL_SIGNATURE(TypeOf)
211 {
212 // 2 input parameters
213 CallSignature TypeOf("TypeOf", 0, 2, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_POINTER());
214 *callSign = TypeOf;
215 // 2 input parameters
216 std::array<VariableType, 2> params = {
217 VariableType::NATIVE_POINTER(), // glue
218 VariableType::JS_ANY(), // ACC
219 };
220 callSign->SetParameters(params.data());
221 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
222 }
223
DEF_CALL_SIGNATURE(SetPropertyByName)224 DEF_CALL_SIGNATURE(SetPropertyByName)
225 {
226 // 6 : 6 input parameters
227 CallSignature setPropertyByName("SetPropertyByName", 0, 6, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
228 *callSign = setPropertyByName;
229 // 6 : 6 input parameters
230 std::array<VariableType, 6> params = {
231 VariableType::NATIVE_POINTER(), // glue
232 VariableType::JS_ANY(), // receiver
233 VariableType::INT64(), // key
234 VariableType::JS_ANY(), // value
235 VariableType::JS_ANY(), // jsFunc
236 VariableType::INT32(), // slot id
237 };
238 callSign->SetParameters(params.data());
239 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
240 }
241
DEF_CALL_SIGNATURE(DeprecatedSetPropertyByName)242 DEF_CALL_SIGNATURE(DeprecatedSetPropertyByName)
243 {
244 // 4 : 4 input parameters
245 CallSignature setPropertyByName("DeprecatedSetPropertyByName", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
246 VariableType::JS_ANY());
247 *callSign = setPropertyByName;
248 // 4 : 4 input parameters
249 std::array<VariableType, 4> params = {
250 VariableType::NATIVE_POINTER(),
251 VariableType::JS_POINTER(),
252 VariableType::JS_POINTER(),
253 VariableType::JS_ANY()
254 };
255 callSign->SetParameters(params.data());
256 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
257 }
258
DEF_CALL_SIGNATURE(SetPropertyByNameWithOwn)259 DEF_CALL_SIGNATURE(SetPropertyByNameWithOwn)
260 {
261 // 4 : 4 input parameters
262 CallSignature setPropertyByNameWithOwn("SetPropertyByNameWithOwn", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
263 VariableType::JS_ANY());
264 *callSign = setPropertyByNameWithOwn;
265 // 4 : 4 input parameters
266 std::array<VariableType, 4> params = {
267 VariableType::NATIVE_POINTER(),
268 VariableType::JS_POINTER(),
269 VariableType::JS_POINTER(),
270 VariableType::JS_ANY()
271 };
272 callSign->SetParameters(params.data());
273 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
274 }
275
DEF_CALL_SIGNATURE(SetPropertyByValue)276 DEF_CALL_SIGNATURE(SetPropertyByValue)
277 {
278 // 6 : 6 input parameters
279 CallSignature setPropertyByName("SetPropertyByValue", 0, 6, ArgumentsOrder::DEFAULT_ORDER,
280 VariableType::JS_ANY());
281 *callSign = setPropertyByName;
282 // 6 : 6 input parameters
283 std::array<VariableType, 6> params = {
284 VariableType::NATIVE_POINTER(), // glue
285 VariableType::JS_POINTER(), // receiver
286 VariableType::JS_ANY(), // key
287 VariableType::JS_ANY(), // value
288 VariableType::JS_ANY(), // jsFunc
289 VariableType::INT32(), // slot id
290 };
291 callSign->SetParameters(params.data());
292 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
293 }
294
DEF_CALL_SIGNATURE(DeprecatedSetPropertyByValue)295 DEF_CALL_SIGNATURE(DeprecatedSetPropertyByValue)
296 {
297 // 4 : 4 input parameters
298 CallSignature setPropertyByName("DeprecatedSetPropertyByValue", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
299 VariableType::JS_ANY());
300 *callSign = setPropertyByName;
301 // 4 : 4 input parameters
302 std::array<VariableType, 4> params = {
303 VariableType::NATIVE_POINTER(),
304 VariableType::JS_POINTER(),
305 VariableType::JS_ANY(),
306 VariableType::JS_ANY()
307 };
308 callSign->SetParameters(params.data());
309 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
310 }
311
DEF_CALL_SIGNATURE(SetPropertyByValueWithOwn)312 DEF_CALL_SIGNATURE(SetPropertyByValueWithOwn)
313 {
314 // 4 : 4 input parameters
315 CallSignature setPropertyByValueWithOwn("SetPropertyByValueWithOwn", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
316 VariableType::JS_ANY());
317 *callSign = setPropertyByValueWithOwn;
318 // 4 : 4 input parameters
319 std::array<VariableType, 4> params = {
320 VariableType::NATIVE_POINTER(),
321 VariableType::JS_POINTER(),
322 VariableType::JS_ANY(),
323 VariableType::JS_ANY()
324 };
325 callSign->SetParameters(params.data());
326 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
327 }
328
DEF_CALL_SIGNATURE(GetPropertyByName)329 DEF_CALL_SIGNATURE(GetPropertyByName)
330 {
331 // 5 : 5 input parameters
332 CallSignature getPropertyByName("GetPropertyByName", 0, 5, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
333 *callSign = getPropertyByName;
334 // 5 : 5 input parameters
335 std::array<VariableType, 5> params = {
336 VariableType::NATIVE_POINTER(), // glue
337 VariableType::JS_ANY(), // receiver
338 VariableType::INT64(), // key
339 VariableType::JS_ANY(), // jsFunc
340 VariableType::INT32(), // slot id
341 };
342 callSign->SetParameters(params.data());
343 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
344 }
345
DEF_CALL_SIGNATURE(Instanceof)346 DEF_CALL_SIGNATURE(Instanceof)
347 {
348 // 5 : 5 input parameters
349 CallSignature instanceof("Instanceof", 0, 5, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
350 *callSign = instanceof;
351 // 5 : 5 input parameters
352 std::array<VariableType, 5> params = {
353 VariableType::NATIVE_POINTER(), // glue
354 VariableType::JS_ANY(), // object
355 VariableType::JS_ANY(), // target
356 VariableType::JS_ANY(), // jsFunc
357 VariableType::INT32(), // slot id
358 };
359 callSign->SetParameters(params.data());
360 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
361 }
362
DEF_CALL_SIGNATURE(DeprecatedGetPropertyByName)363 DEF_CALL_SIGNATURE(DeprecatedGetPropertyByName)
364 {
365 // 3 : 3 input parameters
366 CallSignature getPropertyByName("DeprecatedGetPropertyByName", 0, 3, ArgumentsOrder::DEFAULT_ORDER,
367 VariableType::JS_ANY());
368 *callSign = getPropertyByName;
369 // 3 : 3 input parameters
370 std::array<VariableType, 3> params = {
371 VariableType::NATIVE_POINTER(), // glue
372 VariableType::JS_ANY(), // receiver
373 VariableType::JS_POINTER(), // key
374 };
375 callSign->SetParameters(params.data());
376 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
377 }
378
DEF_CALL_SIGNATURE(TryLdGlobalByName)379 DEF_CALL_SIGNATURE(TryLdGlobalByName)
380 {
381 // 4 : 4 input parameters
382 CallSignature signature("TryLdGlobalByName", 0, 4, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
383 *callSign = signature;
384 // 4 : 4 input parameters
385 std::array<VariableType, 4> params = {
386 VariableType::NATIVE_POINTER(), // glue
387 VariableType::INT64(), // key
388 VariableType::JS_ANY(), // jsFunc
389 VariableType::INT32(), // slot id
390 };
391 callSign->SetParameters(params.data());
392 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
393 }
394
DEF_CALL_SIGNATURE(TryStGlobalByName)395 DEF_CALL_SIGNATURE(TryStGlobalByName)
396 {
397 // 5 : 5 input parameters
398 CallSignature signature("TryStGlobalByName", 0, 5, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
399 *callSign = signature;
400 // 5 : 5 input parameters
401 std::array<VariableType, 5> params = {
402 VariableType::NATIVE_POINTER(), // glue
403 VariableType::INT64(), // key
404 VariableType::JS_ANY(), // value
405 VariableType::JS_ANY(), // jsFunc
406 VariableType::INT32(), // slot id
407 };
408 callSign->SetParameters(params.data());
409 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
410 }
411
DEF_CALL_SIGNATURE(LdGlobalVar)412 DEF_CALL_SIGNATURE(LdGlobalVar)
413 {
414 // 4 : 4 input parameters
415 CallSignature signature("LdGlobalVar", 0, 4, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
416 *callSign = signature;
417 // 4 : 4 input parameters
418 std::array<VariableType, 4> params = {
419 VariableType::NATIVE_POINTER(), // glue
420 VariableType::INT64(), // key
421 VariableType::JS_ANY(), // jsFunc
422 VariableType::INT32(), // slot id
423 };
424 callSign->SetParameters(params.data());
425 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
426 }
427
DEF_CALL_SIGNATURE(StGlobalVar)428 DEF_CALL_SIGNATURE(StGlobalVar)
429 {
430 // 5 : 5 input parameters
431 CallSignature signature("StGlobalVar", 0, 5, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
432 *callSign = signature;
433 // 5 : 5 input parameters
434 std::array<VariableType, 5> params = {
435 VariableType::NATIVE_POINTER(), // glue
436 VariableType::INT64(), // string id
437 VariableType::JS_ANY(), // value
438 VariableType::JS_ANY(), // jsFunc
439 VariableType::INT32(), // slot id
440 };
441 callSign->SetParameters(params.data());
442 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
443 }
DEF_CALL_SIGNATURE(StOwnByValue)444 DEF_CALL_SIGNATURE(StOwnByValue)
445 {
446 // 4 : 4 input parameters
447 CallSignature signature("StOwnByValue", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
448 VariableType::JS_ANY());
449 *callSign = signature;
450 // 4 : 4 input parameters
451 std::array<VariableType, 4> params = {
452 VariableType::NATIVE_POINTER(),
453 VariableType::JS_POINTER(),
454 VariableType::JS_ANY(),
455 VariableType::JS_ANY()
456 };
457 callSign->SetParameters(params.data());
458 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
459 }
DEF_CALL_SIGNATURE(StOwnByIndex)460 DEF_CALL_SIGNATURE(StOwnByIndex)
461 {
462 // 4 : 4 input parameters
463 CallSignature signature("StOwnByIndex", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
464 VariableType::JS_ANY()); // hole or undefined
465 *callSign = signature;
466 // 4 : 4 input parameters
467 std::array<VariableType, 4> params = {
468 VariableType::NATIVE_POINTER(),
469 VariableType::JS_POINTER(),
470 VariableType::INT32(),
471 VariableType::JS_ANY()
472 };
473 callSign->SetParameters(params.data());
474 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
475 }
DEF_CALL_SIGNATURE(StOwnByName)476 DEF_CALL_SIGNATURE(StOwnByName)
477 {
478 // 4 : 4 input parameters
479 CallSignature signature("StOwnByName", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
480 VariableType::JS_ANY());
481 *callSign = signature;
482 // 4 : 4 input parameters
483 std::array<VariableType, 4> params = {
484 VariableType::NATIVE_POINTER(),
485 VariableType::JS_POINTER(),
486 VariableType::JS_POINTER(),
487 VariableType::JS_ANY()
488 };
489 callSign->SetParameters(params.data());
490 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
491 }
DEF_CALL_SIGNATURE(StOwnByValueWithNameSet)492 DEF_CALL_SIGNATURE(StOwnByValueWithNameSet)
493 {
494 // 4 : 4 input parameters
495 CallSignature signature("StOwnByValueWithNameSet", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
496 VariableType::JS_ANY());
497 *callSign = signature;
498 // 4 : 4 input parameters
499 std::array<VariableType, 4> params = {
500 VariableType::NATIVE_POINTER(),
501 VariableType::JS_POINTER(),
502 VariableType::JS_ANY(),
503 VariableType::JS_ANY()
504 };
505 callSign->SetParameters(params.data());
506 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
507 }
DEF_CALL_SIGNATURE(StOwnByNameWithNameSet)508 DEF_CALL_SIGNATURE(StOwnByNameWithNameSet)
509 {
510 // 4 : 4 input parameters
511 CallSignature signature("StOwnByNameWithNameSet", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
512 VariableType::JS_ANY());
513 *callSign = signature;
514 // 4 : 4 input parameters
515 std::array<VariableType, 4> params = {
516 VariableType::NATIVE_POINTER(),
517 VariableType::JS_POINTER(),
518 VariableType::JS_POINTER(),
519 VariableType::JS_ANY()
520 };
521 callSign->SetParameters(params.data());
522 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
523 }
DEF_CALL_SIGNATURE(StObjByIndex)524 DEF_CALL_SIGNATURE(StObjByIndex)
525 {
526 // 4 : 4 input parameters
527 CallSignature signature("StObjByIndex", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
528 VariableType::JS_ANY()); // hole or undefined
529 *callSign = signature;
530 // 4 : 4 input parameters
531 std::array<VariableType, 4> params = {
532 VariableType::NATIVE_POINTER(),
533 VariableType::JS_POINTER(),
534 VariableType::INT32(),
535 VariableType::JS_ANY()
536 };
537 callSign->SetParameters(params.data());
538 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
539 }
DEF_CALL_SIGNATURE(LdObjByIndex)540 DEF_CALL_SIGNATURE(LdObjByIndex)
541 {
542 // 3 : 3 input parameters
543 CallSignature signature("LdObjByIndex", 0, 3, ArgumentsOrder::DEFAULT_ORDER,
544 VariableType::JS_ANY());
545 *callSign = signature;
546 // 3 : 3 input parameters
547 std::array<VariableType, 3> params = {
548 VariableType::NATIVE_POINTER(), // glue
549 VariableType::JS_ANY(), // receiver
550 VariableType::INT32(), // index
551 };
552 callSign->SetParameters(params.data());
553 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
554 }
555
DEF_CALL_SIGNATURE(GetPropertyByIndex)556 DEF_CALL_SIGNATURE(GetPropertyByIndex)
557 {
558 // 3 : 3 input parameters
559 CallSignature getPropertyByIndex("GetPropertyByIndex", 0, 3, ArgumentsOrder::DEFAULT_ORDER,
560 VariableType::JS_ANY());
561 *callSign = getPropertyByIndex;
562 // 3 : 3 input parameters
563 std::array<VariableType, 3> params = {
564 VariableType::NATIVE_POINTER(), // glue
565 VariableType::JS_ANY(), // receiver
566 VariableType::INT32(), // index
567 };
568 callSign->SetParameters(params.data());
569 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
570 }
571
DEF_CALL_SIGNATURE(SetPropertyByIndex)572 DEF_CALL_SIGNATURE(SetPropertyByIndex)
573 {
574 // 4 : 4 input parameters
575 CallSignature setPropertyByIndex("SetPropertyByIndex", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
576 VariableType::JS_ANY()); // hole or undefined
577 *callSign = setPropertyByIndex;
578 // 4 : 4 input parameters
579 std::array<VariableType, 4> params = {
580 VariableType::NATIVE_POINTER(),
581 VariableType::JS_POINTER(),
582 VariableType::INT32(),
583 VariableType::JS_ANY()
584 };
585 callSign->SetParameters(params.data());
586 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
587 }
588
DEF_CALL_SIGNATURE(SetPropertyByIndexWithOwn)589 DEF_CALL_SIGNATURE(SetPropertyByIndexWithOwn)
590 {
591 // 4 : 4 input parameters
592 CallSignature setPropertyByIndexWithOwn("SetPropertyByIndexWithOwn", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
593 VariableType::JS_ANY()); // hole or undefined
594 *callSign = setPropertyByIndexWithOwn;
595 // 4 : 4 input parameters
596 std::array<VariableType, 4> params = {
597 VariableType::NATIVE_POINTER(),
598 VariableType::JS_POINTER(),
599 VariableType::INT32(),
600 VariableType::JS_ANY()
601 };
602 callSign->SetParameters(params.data());
603 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
604 }
605
DEF_CALL_SIGNATURE(GetPropertyByValue)606 DEF_CALL_SIGNATURE(GetPropertyByValue)
607 {
608 // 5 : 5 input parameters
609 CallSignature getPropertyByValue("GetPropertyByValue", 0, 5, ArgumentsOrder::DEFAULT_ORDER,
610 VariableType::JS_ANY());
611 *callSign = getPropertyByValue;
612 // 5 : 5 input parameters
613 std::array<VariableType, 5> params = {
614 VariableType::NATIVE_POINTER(), // glue
615 VariableType::JS_POINTER(), // receiver
616 VariableType::JS_ANY(), // key
617 VariableType::JS_ANY(), // jsFunc
618 VariableType::INT32(), // slot id
619 };
620 callSign->SetParameters(params.data());
621 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
622 }
623
DEF_CALL_SIGNATURE(DeprecatedGetPropertyByValue)624 DEF_CALL_SIGNATURE(DeprecatedGetPropertyByValue)
625 {
626 // 3 : 3 input parameters
627 CallSignature getPropertyByValue("DeprecatedGetPropertyByValue", 0, 3, ArgumentsOrder::DEFAULT_ORDER,
628 VariableType::JS_ANY());
629 *callSign = getPropertyByValue;
630 // 3 : 3 input parameters
631 std::array<VariableType, 3> params = {
632 VariableType::NATIVE_POINTER(),
633 VariableType::JS_POINTER(),
634 VariableType::JS_ANY(),
635 };
636 callSign->SetParameters(params.data());
637 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
638 }
639
DEF_CALL_SIGNATURE(TryLoadICByName)640 DEF_CALL_SIGNATURE(TryLoadICByName)
641 {
642 // 4 : 4 input parameters
643 CallSignature tryLoadICByName("TryLoadICByName", 0, 4,
644 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
645 *callSign = tryLoadICByName;
646 // 4 : 4 input parameters
647 std::array<VariableType, 4> params = {
648 VariableType::NATIVE_POINTER(),
649 VariableType::JS_ANY(),
650 VariableType::JS_ANY(),
651 VariableType::JS_ANY(),
652 };
653 callSign->SetParameters(params.data());
654 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
655 }
656
DEF_CALL_SIGNATURE(TryLoadICByValue)657 DEF_CALL_SIGNATURE(TryLoadICByValue)
658 {
659 // 5 : 5 input parameters
660 CallSignature tryLoadICByValue("TryLoadICByValue", 0, 5,
661 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
662 *callSign = tryLoadICByValue;
663 // 5 : 5 input parameters
664 std::array<VariableType, 5> params = {
665 VariableType::NATIVE_POINTER(),
666 VariableType::JS_ANY(),
667 VariableType::JS_ANY(),
668 VariableType::JS_ANY(),
669 VariableType::JS_ANY(),
670 };
671 callSign->SetParameters(params.data());
672 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
673 }
674
DEF_CALL_SIGNATURE(TryStoreICByName)675 DEF_CALL_SIGNATURE(TryStoreICByName)
676 {
677 // 5 : 5 input parameters
678 CallSignature tryStoreICByName("TryStoreICByName", 0, 5,
679 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); // undefined or hole
680 *callSign = tryStoreICByName;
681 // 5 : 5 input parameters
682 std::array<VariableType, 5> params = {
683 VariableType::NATIVE_POINTER(),
684 VariableType::JS_POINTER(),
685 VariableType::JS_ANY(),
686 VariableType::JS_ANY(),
687 VariableType::JS_POINTER(),
688 };
689 callSign->SetParameters(params.data());
690 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
691 }
692
DEF_CALL_SIGNATURE(TryStoreICByValue)693 DEF_CALL_SIGNATURE(TryStoreICByValue)
694 {
695 // 6 : 6 input parameters
696 CallSignature tryStoreICByValue("TryStoreICByValue", 0, 6,
697 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); // undefined or hole
698 *callSign = tryStoreICByValue;
699 // 6 : 6 input parameters
700 std::array<VariableType, 6> params = {
701 VariableType::NATIVE_POINTER(),
702 VariableType::JS_POINTER(),
703 VariableType::JS_ANY(),
704 VariableType::JS_ANY(),
705 VariableType::JS_ANY(),
706 VariableType::JS_POINTER(),
707 };
708 callSign->SetParameters(params.data());
709 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
710 }
711
DEF_CALL_SIGNATURE(SetValueWithBarrier)712 DEF_CALL_SIGNATURE(SetValueWithBarrier)
713 {
714 // 4 : 4 input parameters
715 CallSignature setValueWithBarrier("SetValueWithBarrier", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
716 VariableType::VOID());
717 *callSign = setValueWithBarrier;
718
719 std::array<VariableType, 4> params = { // 4 : 4 input parameters
720 VariableType::NATIVE_POINTER(),
721 VariableType::JS_POINTER(),
722 VariableType::NATIVE_POINTER(),
723 VariableType::JS_ANY()
724 };
725 callSign->SetParameters(params.data());
726 callSign->SetGCLeafFunction(true);
727 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
728 }
729
DEF_CALL_SIGNATURE(NewThisObjectChecked)730 DEF_CALL_SIGNATURE(NewThisObjectChecked)
731 {
732 // 2 : 2 input parameters
733 CallSignature signature("NewThisObjectChecked", 0, 2,
734 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
735 *callSign = signature;
736 // 2 : 2 input parameters
737 std::array<VariableType, 2> params = {
738 VariableType::NATIVE_POINTER(), // glue
739 VariableType::JS_ANY(), // ctor
740 };
741 callSign->SetParameters(params.data());
742 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
743 }
744
DEF_CALL_SIGNATURE(ConstructorCheck)745 DEF_CALL_SIGNATURE(ConstructorCheck)
746 {
747 // 4 : 4 input parameters
748 CallSignature signature("ConstructorCheck", 0, 4,
749 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
750 *callSign = signature;
751 // 4 : 4 input parameters
752 std::array<VariableType, 4> params = {
753 VariableType::NATIVE_POINTER(), // glue
754 VariableType::JS_ANY(), // ctor
755 VariableType::JS_ANY(), // result
756 VariableType::JS_ANY(), // thisObj
757 };
758 callSign->SetParameters(params.data());
759 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
760 }
761
DEF_CALL_SIGNATURE(CreateEmptyArray)762 DEF_CALL_SIGNATURE(CreateEmptyArray)
763 {
764 // 5 : 5 input parameters
765 CallSignature signature("CreateEmptyArray", 0, 5,
766 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
767 *callSign = signature;
768 // 5 : 5 input parameters
769 std::array<VariableType, 5> params = {
770 VariableType::NATIVE_POINTER(), // glue
771 VariableType::JS_ANY(), // jsFunc
772 VariableType::JS_ANY(), // pc
773 VariableType::INT32(), // profileTypeInfo
774 VariableType::INT32(), // slotId
775 };
776 callSign->SetParameters(params.data());
777 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
778 }
779
DEF_CALL_SIGNATURE(CreateArrayWithBuffer)780 DEF_CALL_SIGNATURE(CreateArrayWithBuffer)
781 {
782 // 6 : 6 input parameters
783 CallSignature signature("CreateArrayWithBuffer", 0, 6,
784 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
785 *callSign = signature;
786 // 6 : 6 input parameters
787 std::array<VariableType, 6> params = {
788 VariableType::NATIVE_POINTER(), // glue
789 VariableType::INT32(), // index
790 VariableType::JS_ANY(), // jsFunc
791 VariableType::JS_ANY(), // pc
792 VariableType::INT32(), // profileTypeInfo
793 VariableType::INT32(), // slotId
794 };
795 callSign->SetParameters(params.data());
796 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
797 }
798
DEF_CALL_SIGNATURE(NewJSObject)799 DEF_CALL_SIGNATURE(NewJSObject)
800 {
801 // 2 : 2 input parameters
802 CallSignature signature("NewJSObject", 0, 2,
803 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
804 *callSign = signature;
805 // 2 : 2 input parameters
806 std::array<VariableType, 2> params = {
807 VariableType::NATIVE_POINTER(), // glue
808 VariableType::JS_ANY(), // hclass
809 };
810 callSign->SetParameters(params.data());
811 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
812 }
813
DEF_CALL_SIGNATURE(NewLexicalEnv)814 DEF_CALL_SIGNATURE(NewLexicalEnv)
815 {
816 // 3 : 3 input parameters
817 CallSignature signature("NewLexicalEnv", 0, 3,
818 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
819 *callSign = signature;
820 // 3 : 3 input parameters
821 std::array<VariableType, 3> params = {
822 VariableType::NATIVE_POINTER(), // glue
823 VariableType::JS_ANY(), // parent
824 VariableType::INT32(), // numArgs
825 };
826 callSign->SetParameters(params.data());
827 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
828 }
829
DEF_CALL_SIGNATURE(GetUnmapedArgs)830 DEF_CALL_SIGNATURE(GetUnmapedArgs)
831 {
832 // 2 : 2 input parameters
833 CallSignature signature("GetUnmapedArgs", 0, 2,
834 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
835 *callSign = signature;
836 // 2 : 2 input parameters
837 std::array<VariableType, 2> params = {
838 VariableType::NATIVE_POINTER(), // glue
839 VariableType::INT32(), // numArgs
840 };
841 callSign->SetParameters(params.data());
842 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
843 }
844
DEF_CALL_SIGNATURE(GetTaggedArrayPtrTest)845 DEF_CALL_SIGNATURE(GetTaggedArrayPtrTest)
846 {
847 // 2 : 2 input parameters
848 CallSignature getTaggedArrayPtr("GetTaggedArrayPtrTest", 0, 2, ArgumentsOrder::DEFAULT_ORDER,
849 VariableType::JS_POINTER());
850 *callSign = getTaggedArrayPtr;
851 // 2 : 2 input parameters
852 std::array<VariableType, 2> params = {
853 VariableType::NATIVE_POINTER(),
854 VariableType::JS_ANY(),
855 };
856 callSign->SetParameters(params.data());
857 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
858 }
859
DEF_CALL_SIGNATURE(Builtins)860 DEF_CALL_SIGNATURE(Builtins)
861 {
862 // 9 : 9 input parameters
863 CallSignature builtins("Builtins", 0, 9,
864 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
865 *callSign = builtins;
866 std::array<VariableType, 9> params = { // 9 : 9 input parameters
867 VariableType::NATIVE_POINTER(), // glue
868 VariableType::NATIVE_POINTER(), // native code
869 VariableType::JS_ANY(), // func
870 VariableType::JS_ANY(), // new target
871 VariableType::JS_ANY(), // this
872 VariableType::NATIVE_POINTER(), // argc
873 VariableType::JS_ANY(), // arg0
874 VariableType::JS_ANY(), // arg1
875 VariableType::JS_ANY(), // arg2
876 };
877 callSign->SetVariadicArgs(true);
878 callSign->SetParameters(params.data());
879 callSign->SetTargetKind(CallSignature::TargetKind::BUILTINS_STUB);
880 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
881 }
882
DEF_CALL_SIGNATURE(BuiltinsWithArgv)883 DEF_CALL_SIGNATURE(BuiltinsWithArgv)
884 {
885 // 7 : 7 input parameters
886 CallSignature builtinsWtihArgv("Builtins", 0, 7,
887 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
888 *callSign = builtinsWtihArgv;
889 std::array<VariableType, 7> params = { // 7 : 7 input parameters
890 VariableType::NATIVE_POINTER(), // glue
891 VariableType::NATIVE_POINTER(), // nativeCode
892 VariableType::JS_ANY(), // func
893 VariableType::JS_ANY(), // new target
894 VariableType::JS_ANY(), // this
895 VariableType::NATIVE_POINTER(), // argc
896 VariableType::NATIVE_POINTER(), // argv
897 };
898 callSign->SetParameters(params.data());
899 callSign->SetTargetKind(CallSignature::TargetKind::BUILTINS_WITH_ARGV_STUB);
900 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
901 }
902
DEF_CALL_SIGNATURE(BytecodeHandler)903 DEF_CALL_SIGNATURE(BytecodeHandler)
904 {
905 // 7 : 7 input parameters
906 CallSignature bytecodeHandler("BytecodeHandler", 0, 7,
907 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
908 *callSign = bytecodeHandler;
909 // 7 : 7 input parameters
910 std::array<VariableType, 7> params = {
911 VariableType::NATIVE_POINTER(),
912 VariableType::NATIVE_POINTER(),
913 VariableType::NATIVE_POINTER(),
914 VariableType::JS_POINTER(),
915 VariableType::JS_POINTER(),
916 VariableType::JS_ANY(),
917 VariableType::INT32(),
918 };
919 callSign->SetParameters(params.data());
920 callSign->SetTargetKind(CallSignature::TargetKind::BYTECODE_HANDLER);
921 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
922 }
923
DEF_CALL_SIGNATURE(BytecodeDebuggerHandler)924 DEF_CALL_SIGNATURE(BytecodeDebuggerHandler)
925 {
926 // 7 : 7 input parameters
927 CallSignature bytecodeHandler("BytecodeDebuggerHandler", 0, 7,
928 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
929 *callSign = bytecodeHandler;
930 // 7 : 7 input parameters
931 std::array<VariableType, 7> params = { VariableType::NATIVE_POINTER(),
932 VariableType::NATIVE_POINTER(),
933 VariableType::NATIVE_POINTER(),
934 VariableType::JS_POINTER(),
935 VariableType::JS_POINTER(),
936 VariableType::JS_ANY(),
937 VariableType::INT32() };
938 callSign->SetParameters(params.data());
939 callSign->SetTargetKind(CallSignature::TargetKind::BYTECODE_DEBUGGER_HANDLER);
940 }
941
DEF_CALL_SIGNATURE(CallRuntime)942 DEF_CALL_SIGNATURE(CallRuntime)
943 {
944 /* 3 : 3 input parameters */
945 CallSignature runtimeCallTrampoline("CallRuntime", 0, 3,
946 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
947 *callSign = runtimeCallTrampoline;
948 /* 3 : 3 input parameters */
949 std::array<VariableType, 3> params = {
950 VariableType::NATIVE_POINTER(),
951 VariableType::INT64(),
952 VariableType::INT64(),
953 };
954 callSign->SetVariadicArgs(true);
955 callSign->SetParameters(params.data());
956 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
957 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
958 }
959
DEF_CALL_SIGNATURE(AsmInterpreterEntry)960 DEF_CALL_SIGNATURE(AsmInterpreterEntry)
961 {
962 /* 3 : 3 input parameters */
963 CallSignature asmInterpreterEntry("AsmInterpreterEntry", 0, 3,
964 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
965 *callSign = asmInterpreterEntry;
966 /* 3 : 3 input parameters */
967 std::array<VariableType, 3> params = {
968 VariableType::NATIVE_POINTER(), // glue
969 VariableType::INT32(), // argc
970 VariableType::NATIVE_POINTER(), // argv
971 };
972 callSign->SetParameters(params.data());
973 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
974 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
975 }
976
DEF_CALL_SIGNATURE(GeneratorReEnterAsmInterp)977 DEF_CALL_SIGNATURE(GeneratorReEnterAsmInterp)
978 {
979 /* 2 : 2 input parameters */
980 CallSignature generatorReEnterAsmInterp("GeneratorReEnterAsmInterp", 0, 2,
981 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
982 *callSign = generatorReEnterAsmInterp;
983 std::array<VariableType, 2> params = { /* 2 : 2 input parameters */
984 VariableType::NATIVE_POINTER(), // glue
985 VariableType::JS_POINTER(), // context
986 };
987 callSign->SetParameters(params.data());
988 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
989 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
990 }
991
DEF_CALL_SIGNATURE(CallRuntimeWithArgv)992 DEF_CALL_SIGNATURE(CallRuntimeWithArgv)
993 {
994 /* 4 : 4 input parameters */
995 CallSignature runtimeCallTrampoline("CallRuntimeWithArgv", 0, 4,
996 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
997 *callSign = runtimeCallTrampoline;
998 std::array<VariableType, 4> params = { /* 4 : 4 input parameters */
999 VariableType::NATIVE_POINTER(), // glue
1000 VariableType::INT64(), // runtimeId
1001 VariableType::INT64(), // argc
1002 VariableType::NATIVE_POINTER(), // argv
1003 };
1004 callSign->SetVariadicArgs(false);
1005 callSign->SetParameters(params.data());
1006 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_VARARGS);
1007 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1008 }
1009
DEF_CALL_SIGNATURE(OptimizedCallAndPushUndefined)1010 DEF_CALL_SIGNATURE(OptimizedCallAndPushUndefined)
1011 {
1012 /* 5 : 5 input parameters */
1013 CallSignature optimizedCallAndPushUndefined("OptimizedCallAndPushUndefined", 0, 5,
1014 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1015 *callSign = optimizedCallAndPushUndefined;
1016 std::array<VariableType, 5> params = { /* 5 : 5 input parameters */
1017 VariableType::NATIVE_POINTER(), // glue
1018 VariableType::INT64(), // actual argC
1019 VariableType::JS_ANY(), // call target
1020 VariableType::JS_ANY(), // new target
1021 VariableType::JS_ANY(), // thisobj
1022 };
1023 callSign->SetVariadicArgs(true);
1024 callSign->SetParameters(params.data());
1025 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1026 callSign->SetCallConv(CallSignature::CallConv::WebKitJSCallConv);
1027 }
1028
DEF_CALL_SIGNATURE(OptimizedFastCallAndPushUndefined)1029 DEF_CALL_SIGNATURE(OptimizedFastCallAndPushUndefined)
1030 {
1031 /* 5 : 5 input parameters */
1032 CallSignature optimizedFastCallAndPushUndefined("OptimizedFastCallAndPushUndefined", 0, 5,
1033 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1034 *callSign = optimizedFastCallAndPushUndefined;
1035 std::array<VariableType, 5> params = { /* 5 : 5 input parameters */
1036 VariableType::NATIVE_POINTER(), // glue
1037 VariableType::INT64(), // actual argC
1038 VariableType::JS_ANY(), // call target
1039 VariableType::JS_ANY(), // new target
1040 VariableType::JS_ANY(), // thisobj
1041 };
1042 callSign->SetVariadicArgs(true);
1043 callSign->SetParameters(params.data());
1044 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1045 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1046 }
1047
DEF_CALL_SIGNATURE(JSCall)1048 DEF_CALL_SIGNATURE(JSCall)
1049 {
1050 // 6 : 6 input parameters
1051 CallSignature jSCall("JSCall", 0, 5,
1052 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1053 *callSign = jSCall;
1054 std::array<VariableType, 5> params = { // 5 : 5 input parameters
1055 VariableType::NATIVE_POINTER(), // glue
1056 VariableType::INT64(), // actual argC
1057 VariableType::JS_ANY(), // call target
1058 VariableType::JS_ANY(), // new target
1059 VariableType::JS_ANY(), // thisobj
1060 };
1061 callSign->SetVariadicArgs(true);
1062 callSign->SetParameters(params.data());
1063 callSign->SetCallConv(CallSignature::CallConv::WebKitJSCallConv);
1064 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1065 }
1066
DEF_CALL_SIGNATURE(JSOptimizedCall)1067 DEF_CALL_SIGNATURE(JSOptimizedCall)
1068 {
1069 // 6 : 6 input parameters
1070 CallSignature jSCall("JSOptimizedCall", 0, 5,
1071 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1072 *callSign = jSCall;
1073 std::array<VariableType, 5> params = { // 5 : 5 input parameters
1074 VariableType::NATIVE_POINTER(), // glue
1075 VariableType::INT64(), // actual argC
1076 VariableType::JS_ANY(), // call target
1077 VariableType::JS_ANY(), // new target
1078 VariableType::JS_ANY(), // thisobj
1079 };
1080 callSign->SetVariadicArgs(true);
1081 callSign->SetParameters(params.data());
1082 callSign->SetCallConv(CallSignature::CallConv::WebKitJSCallConv);
1083 callSign->SetTargetKind(CallSignature::TargetKind::OPTIMIZED_STUB);
1084 }
1085
DEF_CALL_SIGNATURE(JSOptimizedFastCall)1086 DEF_CALL_SIGNATURE(JSOptimizedFastCall)
1087 {
1088 // 3 : 3 input parameters
1089 CallSignature jSCall("JSOptimizedFastCall", 0, 3,
1090 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1091 *callSign = jSCall;
1092 std::array<VariableType, 3> params = { // 3 : 3 input parameters
1093 VariableType::NATIVE_POINTER(), // glue
1094 VariableType::JS_ANY(), // call target
1095 VariableType::JS_ANY(), // thisobj
1096 };
1097 callSign->SetVariadicArgs(true);
1098 callSign->SetParameters(params.data());
1099 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1100 callSign->SetTargetKind(CallSignature::TargetKind::OPTIMIZED_FAST_CALL_STUB);
1101 }
1102
DEF_CALL_SIGNATURE(JSCallNew)1103 DEF_CALL_SIGNATURE(JSCallNew)
1104 {
1105 // 6 : 6 input parameters
1106 CallSignature jSCallNew("JSCallNew", 0, 5,
1107 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1108 *callSign = jSCallNew;
1109 std::array<VariableType, 5> params = { // 5 : 5 input parameters
1110 VariableType::NATIVE_POINTER(), // glue
1111 VariableType::INT64(), // actual argC
1112 VariableType::JS_ANY(), // call target
1113 VariableType::JS_ANY(), // new target
1114 VariableType::JS_ANY(), // thisobj
1115 };
1116 callSign->SetVariadicArgs(true);
1117 callSign->SetParameters(params.data());
1118 callSign->SetCallConv(CallSignature::CallConv::WebKitJSCallConv);
1119 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1120 }
1121
DEF_CALL_SIGNATURE(JSProxyCallInternalWithArgV)1122 DEF_CALL_SIGNATURE(JSProxyCallInternalWithArgV)
1123 {
1124 // 2 : 2 input parameters
1125 CallSignature jSProxyCallInternalWithArgV("JSProxyCallInternalWithArgV", 0, 2,
1126 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1127 *callSign = jSProxyCallInternalWithArgV;
1128 std::array<VariableType, 2> params = { // 2 : 2 input parameters
1129 VariableType::NATIVE_POINTER(), // glue
1130 VariableType::JS_ANY(), // call target
1131 };
1132 callSign->SetParameters(params.data());
1133 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1134 callSign->SetGCLeafFunction(true);
1135 callSign->SetTailCall(true);
1136 }
1137
DEF_CALL_SIGNATURE(JSFunctionEntry)1138 DEF_CALL_SIGNATURE(JSFunctionEntry)
1139 {
1140 // 5 : 5 input parameters
1141 CallSignature jsCallFunctionEntry("JSFunctionEntry", 0, 5,
1142 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1143 *callSign = jsCallFunctionEntry;
1144 std::array<VariableType, 5> params = { // 5 : 5 input parameters
1145 VariableType::NATIVE_POINTER(), // glue
1146 VariableType::INT64(), // argc
1147 VariableType::NATIVE_POINTER(), // argv
1148 VariableType::NATIVE_POINTER(), // prevFp
1149 VariableType::BOOL(), // isNew
1150 };
1151 callSign->SetParameters(params.data());
1152 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1153 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1154 }
1155
DEF_CALL_SIGNATURE(OptimizedFastCallEntry)1156 DEF_CALL_SIGNATURE(OptimizedFastCallEntry)
1157 {
1158 // 4 : 4 input parameters
1159 CallSignature optimizedFastCallEntry("OptimizedFastCallEntry", 0, 4,
1160 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1161 *callSign = optimizedFastCallEntry;
1162 std::array<VariableType, 4> params = { // 4 : 4 input parameters
1163 VariableType::NATIVE_POINTER(), // glue
1164 VariableType::INT64(), // argc
1165 VariableType::NATIVE_POINTER(), // argv
1166 VariableType::NATIVE_POINTER(), // prevFp
1167 };
1168 callSign->SetParameters(params.data());
1169 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1170 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1171 }
1172
DEF_CALL_SIGNATURE(ResumeRspAndDispatch)1173 DEF_CALL_SIGNATURE(ResumeRspAndDispatch)
1174 {
1175 // 8 : 8 input parameters
1176 CallSignature resumeRspAndDispatch("ResumeRspAndDispatch", 0, 8,
1177 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1178 *callSign = resumeRspAndDispatch;
1179 std::array<VariableType, 8> params = { // 8 : 8 input parameters
1180 VariableType::NATIVE_POINTER(),
1181 VariableType::NATIVE_POINTER(),
1182 VariableType::NATIVE_POINTER(),
1183 VariableType::JS_POINTER(),
1184 VariableType::JS_POINTER(),
1185 VariableType::JS_ANY(),
1186 VariableType::INT32(),
1187 VariableType::NATIVE_POINTER(),
1188 };
1189 callSign->SetParameters(params.data());
1190 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1191 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
1192 }
1193
DEF_CALL_SIGNATURE(ResumeRspAndReturn)1194 DEF_CALL_SIGNATURE(ResumeRspAndReturn)
1195 {
1196 // 3 : 3 input parameters
1197 CallSignature resumeRspAndReturn("ResumeRspAndReturn", 0, 3,
1198 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1199 *callSign = resumeRspAndReturn;
1200 std::array<VariableType, 3> params = { // 3 : 3 input parameters
1201 VariableType::JS_ANY(),
1202 VariableType::NATIVE_POINTER(),
1203 VariableType::NATIVE_POINTER(),
1204 };
1205 callSign->SetParameters(params.data());
1206 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1207 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
1208 }
1209
DEF_CALL_SIGNATURE(ResumeCaughtFrameAndDispatch)1210 DEF_CALL_SIGNATURE(ResumeCaughtFrameAndDispatch)
1211 {
1212 // 7 : 7 input parameters
1213 CallSignature resumeCaughtFrameAndDispatch("ResumeCaughtFrameAndDispatch", 0, 7,
1214 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1215 *callSign = resumeCaughtFrameAndDispatch;
1216 // 7 : 7 input parameters
1217 std::array<VariableType, 7> params = {
1218 VariableType::NATIVE_POINTER(),
1219 VariableType::NATIVE_POINTER(),
1220 VariableType::NATIVE_POINTER(),
1221 VariableType::JS_POINTER(),
1222 VariableType::JS_POINTER(),
1223 VariableType::JS_ANY(),
1224 VariableType::INT32(),
1225 };
1226 callSign->SetParameters(params.data());
1227 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1228 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
1229 }
1230
DEF_CALL_SIGNATURE(ResumeUncaughtFrameAndReturn)1231 DEF_CALL_SIGNATURE(ResumeUncaughtFrameAndReturn)
1232 {
1233 // 3 : 3 input parameters
1234 CallSignature resumeUncaughtFrameAndReturn("ResumeUncaughtFrameAndReturn", 0, 3,
1235 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1236 *callSign = resumeUncaughtFrameAndReturn;
1237 std::array<VariableType, 3> params = { // 3 : 3 input parameters
1238 VariableType::NATIVE_POINTER(),
1239 VariableType::NATIVE_POINTER(),
1240 VariableType::JS_ANY(),
1241 };
1242 callSign->SetParameters(params.data());
1243 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1244 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
1245 }
1246
DEF_CALL_SIGNATURE(ResumeRspAndRollback)1247 DEF_CALL_SIGNATURE(ResumeRspAndRollback)
1248 {
1249 // 8 : 8 input parameters
1250 CallSignature resumeRspAndRollback("ResumeRspAndRollback", 0, 8,
1251 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1252 *callSign = resumeRspAndRollback;
1253 std::array<VariableType, 8> params = { // 8 : 8 input parameters
1254 VariableType::NATIVE_POINTER(),
1255 VariableType::NATIVE_POINTER(),
1256 VariableType::NATIVE_POINTER(),
1257 VariableType::JS_POINTER(),
1258 VariableType::JS_POINTER(),
1259 VariableType::JS_ANY(),
1260 VariableType::INT32(),
1261 VariableType::NATIVE_POINTER(),
1262 };
1263 callSign->SetParameters(params.data());
1264 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1265 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
1266 }
1267
DEF_CALL_SIGNATURE(StringsAreEquals)1268 DEF_CALL_SIGNATURE(StringsAreEquals)
1269 {
1270 // 2 : 2 input parameters
1271 CallSignature stringsAreEquals("StringsAreEquals", 0, 2,
1272 ArgumentsOrder::DEFAULT_ORDER, VariableType::BOOL());
1273 *callSign = stringsAreEquals;
1274 std::array<VariableType, 2> params = { // 2 : 2 input parameters
1275 VariableType::JS_POINTER(),
1276 VariableType::JS_POINTER(),
1277 };
1278 callSign->SetParameters(params.data());
1279 callSign->SetGCLeafFunction(true);
1280 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1281 }
1282
DEF_CALL_SIGNATURE(JSHClassFindProtoTransitions)1283 DEF_CALL_SIGNATURE(JSHClassFindProtoTransitions)
1284 {
1285 // 3 : 3 input parameters
1286 CallSignature bigIntSameValueZero("JSHClassFindProtoTransitions", 0, 3,
1287 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1288 *callSign = bigIntSameValueZero;
1289 std::array<VariableType, 3> params = { // 3 : 3 input parameters
1290 VariableType::JS_POINTER(),
1291 VariableType::JS_POINTER(),
1292 VariableType::JS_POINTER(),
1293 };
1294 callSign->SetParameters(params.data());
1295 callSign->SetGCLeafFunction(true);
1296 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1297 }
1298
DEF_CALL_SIGNATURE(NumberHelperStringToDouble)1299 DEF_CALL_SIGNATURE(NumberHelperStringToDouble)
1300 {
1301 // 1 : 1 input parameters
1302 CallSignature bigIntSameValueZero("NumberHelperStringToDouble", 0, 1,
1303 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1304 *callSign = bigIntSameValueZero;
1305 std::array<VariableType, 1> params = { // 1 : 1 input parameters
1306 VariableType::JS_POINTER(),
1307 };
1308 callSign->SetParameters(params.data());
1309 callSign->SetGCLeafFunction(true);
1310 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1311 }
1312
DEF_CALL_SIGNATURE(GetStringToListCacheArray)1313 DEF_CALL_SIGNATURE(GetStringToListCacheArray)
1314 {
1315 // 1 : 1 input parameters
1316 CallSignature callSignature("GetStringToListCacheArray", 0, 1,
1317 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1318 *callSign = callSignature;
1319 std::array<VariableType, 1> params = { // 1 : 1 input parameters
1320 VariableType::NATIVE_POINTER(),
1321 };
1322 callSign->SetParameters(params.data());
1323 callSign->SetGCLeafFunction(true);
1324 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1325 }
1326
DEF_CALL_SIGNATURE(BigIntEquals)1327 DEF_CALL_SIGNATURE(BigIntEquals)
1328 {
1329 // 2 : 2 input parameters
1330 CallSignature bigIntEquals("BigIntEquals", 0, 2,
1331 ArgumentsOrder::DEFAULT_ORDER, VariableType::BOOL());
1332 *callSign = bigIntEquals;
1333 std::array<VariableType, 2> params = { // 2 : 2 input parameters
1334 VariableType::JS_POINTER(),
1335 VariableType::JS_POINTER(),
1336 };
1337 callSign->SetParameters(params.data());
1338 callSign->SetGCLeafFunction(true);
1339 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1340 }
1341
DEF_CALL_SIGNATURE(FastArraySort)1342 DEF_CALL_SIGNATURE(FastArraySort)
1343 {
1344 // 2 : 2 input parameters
1345 CallSignature fastArraySort("FastArraySort", 0, 2, ArgumentsOrder::DEFAULT_ORDER, VariableType::INT32());
1346 *callSign = fastArraySort;
1347 std::array<VariableType, 2> params = { // 2 : 2 input parameters
1348 VariableType::JS_ANY(),
1349 VariableType::JS_ANY()
1350 };
1351 callSign->SetParameters(params.data());
1352 callSign->SetGCLeafFunction(true);
1353 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1354 }
1355
DEF_CALL_SIGNATURE(LocaleCompareNoGc)1356 DEF_CALL_SIGNATURE(LocaleCompareNoGc)
1357 {
1358 // 4 : 4 input parameters
1359 CallSignature localeCompareNoGc("LocaleCompareNoGc", 0, 4,
1360 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1361 *callSign = localeCompareNoGc;
1362 std::array<VariableType, 4> params = { // 4 : 4 input parameters
1363 VariableType::NATIVE_POINTER(),
1364 VariableType::JS_POINTER(),
1365 VariableType::JS_POINTER(),
1366 VariableType::JS_POINTER(),
1367 };
1368 callSign->SetParameters(params.data());
1369 callSign->SetGCLeafFunction(true);
1370 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1371 }
1372
DEF_CALL_SIGNATURE(ArrayTrim)1373 DEF_CALL_SIGNATURE(ArrayTrim)
1374 {
1375 // 3 : 3 input parameters
1376 CallSignature ArrayTrim("ArrayTrim", 0, 3, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1377 *callSign = ArrayTrim;
1378 std::array<VariableType, 3> params = { // 3 : 3 input parameters
1379 VariableType::NATIVE_POINTER(),
1380 VariableType::JS_POINTER(),
1381 VariableType::INT64()
1382 };
1383 callSign->SetParameters(params.data());
1384 callSign->SetGCLeafFunction(true);
1385 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1386 }
1387
DEF_CALL_SIGNATURE(BigIntSameValueZero)1388 DEF_CALL_SIGNATURE(BigIntSameValueZero)
1389 {
1390 // 1 : 1 input parameters
1391 CallSignature bigIntSameValueZero("BigIntSameValueZero", 0, 2,
1392 ArgumentsOrder::DEFAULT_ORDER, VariableType::BOOL());
1393 *callSign = bigIntSameValueZero;
1394 std::array<VariableType, 2> params = { // 2 : 2 input parameters
1395 VariableType::JS_POINTER(),
1396 VariableType::JS_POINTER(),
1397 };
1398 callSign->SetParameters(params.data());
1399 callSign->SetGCLeafFunction(true);
1400 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1401 }
1402
DEF_CALL_SIGNATURE(StringGetStart)1403 DEF_CALL_SIGNATURE(StringGetStart)
1404 {
1405 CallSignature stringGetStart("StringGetStart", 0, 4, ArgumentsOrder::DEFAULT_ORDER, VariableType::INT32());
1406 *callSign = stringGetStart;
1407 std::array<VariableType, 4> params = { // 4 : four input parameters
1408 VariableType::BOOL(),
1409 VariableType::JS_POINTER(),
1410 VariableType::INT32(),
1411 VariableType::INT32(),
1412 };
1413 callSign->SetParameters(params.data());
1414 callSign->SetGCLeafFunction(true);
1415 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1416 }
1417
DEF_CALL_SIGNATURE(StringGetEnd)1418 DEF_CALL_SIGNATURE(StringGetEnd)
1419 {
1420 CallSignature stringGetEnd("StringGetEnd", 0, 5, ArgumentsOrder::DEFAULT_ORDER, VariableType::INT32());
1421 *callSign = stringGetEnd;
1422 std::array<VariableType, 5> params = { // 5 : five input parameters
1423 VariableType::BOOL(),
1424 VariableType::JS_POINTER(),
1425 VariableType::INT32(),
1426 VariableType::INT32(),
1427 VariableType::INT32(),
1428 };
1429 callSign->SetParameters(params.data());
1430 callSign->SetGCLeafFunction(true);
1431 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1432 }
1433
1434 #define PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE_COMMON(name) \
1435 /* 1 : 1 input parameters */ \
1436 CallSignature signature(#name, 0, 1, \
1437 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); \
1438 *callSign = signature; \
1439 std::array<VariableType, 1> params = { /* 1: 1 input parameters */ \
1440 VariableType::NATIVE_POINTER(), \
1441 }; \
1442 callSign->SetVariadicArgs(true); \
1443 callSign->SetParameters(params.data()); \
1444 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1445
1446 #define PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(name) \
1447 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE_COMMON(name) \
1448 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
1449
1450 #define PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_SIGNATURE(name) \
1451 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE_COMMON(name) \
1452 callSign->SetCallConv(CallSignature::CallConv::WebKitJSCallConv);
1453
1454 #define PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(name) \
1455 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE_COMMON(name) \
1456 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1457
DEF_CALL_SIGNATURE(PushCallArgsAndDispatchNative)1458 DEF_CALL_SIGNATURE(PushCallArgsAndDispatchNative)
1459 {
1460 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_SIGNATURE(PushCallArgsAndDispatchNative)
1461 }
1462
DEF_CALL_SIGNATURE(PushCallArg0AndDispatch)1463 DEF_CALL_SIGNATURE(PushCallArg0AndDispatch)
1464 {
1465 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallArg0AndDispatch)
1466 }
1467
DEF_CALL_SIGNATURE(PushCallArg1AndDispatch)1468 DEF_CALL_SIGNATURE(PushCallArg1AndDispatch)
1469 {
1470 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallArg1AndDispatch)
1471 }
1472
DEF_CALL_SIGNATURE(PushCallArgs2AndDispatch)1473 DEF_CALL_SIGNATURE(PushCallArgs2AndDispatch)
1474 {
1475 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallArgs2AndDispatch)
1476 }
1477
DEF_CALL_SIGNATURE(PushCallArgs3AndDispatch)1478 DEF_CALL_SIGNATURE(PushCallArgs3AndDispatch)
1479 {
1480 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallArgs3AndDispatch)
1481 }
1482
DEF_CALL_SIGNATURE(PushCallThisArg0AndDispatch)1483 DEF_CALL_SIGNATURE(PushCallThisArg0AndDispatch)
1484 {
1485 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallThisArg0AndDispatch)
1486 }
1487
DEF_CALL_SIGNATURE(PushCallThisArg1AndDispatch)1488 DEF_CALL_SIGNATURE(PushCallThisArg1AndDispatch)
1489 {
1490 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallThisArg1AndDispatch)
1491 }
1492
DEF_CALL_SIGNATURE(PushCallThisArgs2AndDispatch)1493 DEF_CALL_SIGNATURE(PushCallThisArgs2AndDispatch)
1494 {
1495 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallThisArgs2AndDispatch)
1496 }
1497
DEF_CALL_SIGNATURE(PushCallThisArgs3AndDispatch)1498 DEF_CALL_SIGNATURE(PushCallThisArgs3AndDispatch)
1499 {
1500 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallThisArgs3AndDispatch)
1501 }
1502
DEF_CALL_SIGNATURE(PushCallRangeAndDispatchNative)1503 DEF_CALL_SIGNATURE(PushCallRangeAndDispatchNative)
1504 {
1505 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(PushCallRangeAndDispatchNative)
1506 }
1507
DEF_CALL_SIGNATURE(PushCallNewAndDispatchNative)1508 DEF_CALL_SIGNATURE(PushCallNewAndDispatchNative)
1509 {
1510 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(PushCallNewAndDispatchNative)
1511 }
1512
DEF_CALL_SIGNATURE(PushNewTargetAndDispatchNative)1513 DEF_CALL_SIGNATURE(PushNewTargetAndDispatchNative)
1514 {
1515 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(PushNewTargetAndDispatchNative)
1516 }
1517
DEF_CALL_SIGNATURE(PushCallNewAndDispatch)1518 DEF_CALL_SIGNATURE(PushCallNewAndDispatch)
1519 {
1520 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallNewAndDispatch)
1521 }
1522
DEF_CALL_SIGNATURE(PushSuperCallAndDispatch)1523 DEF_CALL_SIGNATURE(PushSuperCallAndDispatch)
1524 {
1525 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushSuperCallAndDispatch)
1526 }
1527
DEF_CALL_SIGNATURE(PushCallRangeAndDispatch)1528 DEF_CALL_SIGNATURE(PushCallRangeAndDispatch)
1529 {
1530 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallRangeAndDispatch)
1531 }
1532
DEF_CALL_SIGNATURE(PushCallThisRangeAndDispatch)1533 DEF_CALL_SIGNATURE(PushCallThisRangeAndDispatch)
1534 {
1535 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallThisRangeAndDispatch)
1536 }
1537
DEF_CALL_SIGNATURE(CallGetter)1538 DEF_CALL_SIGNATURE(CallGetter)
1539 {
1540 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(CallGetter)
1541 }
1542
DEF_CALL_SIGNATURE(CallSetter)1543 DEF_CALL_SIGNATURE(CallSetter)
1544 {
1545 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(CallSetter)
1546 }
1547
DEF_CALL_SIGNATURE(CallContainersArgs3)1548 DEF_CALL_SIGNATURE(CallContainersArgs3)
1549 {
1550 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(CallContainersArgs3)
1551 }
1552
DEF_CALL_SIGNATURE(CallReturnWithArgv)1553 DEF_CALL_SIGNATURE(CallReturnWithArgv)
1554 {
1555 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(CallReturnWithArgv)
1556 }
1557
DEF_CALL_SIGNATURE(JSCallWithArgV)1558 DEF_CALL_SIGNATURE(JSCallWithArgV)
1559 {
1560 // 5 : 5 input parameters
1561 CallSignature jSCallWithArgV("JSCallWithArgV", 0, 5,
1562 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1563 *callSign = jSCallWithArgV;
1564 // 5 : 5 input parameters
1565 std::array<VariableType, 5> params = {
1566 VariableType::NATIVE_POINTER(), // glue
1567 VariableType::INT64(), // actualNumArgs
1568 VariableType::JS_ANY(), // jsfunc
1569 VariableType::JS_ANY(), // newTarget
1570 VariableType::JS_ANY(), // this
1571 };
1572 callSign->SetVariadicArgs(true);
1573 callSign->SetParameters(params.data());
1574 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1575 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1576 }
1577
DEF_CALL_SIGNATURE(JSFastCallWithArgV)1578 DEF_CALL_SIGNATURE(JSFastCallWithArgV)
1579 {
1580 // 4 : 4 input parameters
1581 CallSignature jSFastCallWithArgV("JSFastCallWithArgV", 0, 4,
1582 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1583 *callSign = jSFastCallWithArgV;
1584 // 4 : 4 input parameters
1585 std::array<VariableType, 4> params = {
1586 VariableType::NATIVE_POINTER(), // glue
1587 VariableType::JS_ANY(), // jsfunc
1588 VariableType::JS_ANY(), // this
1589 VariableType::INT64(), // actualNumArgs
1590 };
1591 callSign->SetVariadicArgs(true);
1592 callSign->SetParameters(params.data());
1593 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1594 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1595 }
1596
DEF_CALL_SIGNATURE(JSFastCallWithArgVAndPushUndefined)1597 DEF_CALL_SIGNATURE(JSFastCallWithArgVAndPushUndefined)
1598 {
1599 // 4 : 4 input parameters
1600 CallSignature jSCallWithArgV("JSFastCallWithArgVAndPushUndefined", 0, 4,
1601 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1602 *callSign = jSCallWithArgV;
1603 // 4 : 4 input parameters
1604 std::array<VariableType, 4> params = {
1605 VariableType::NATIVE_POINTER(), // glue
1606 VariableType::JS_ANY(), // jsfunc
1607 VariableType::JS_ANY(), // this
1608 VariableType::INT64(), // actualNumArgs
1609 };
1610 callSign->SetVariadicArgs(true);
1611 callSign->SetParameters(params.data());
1612 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1613 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1614 }
1615
DEF_CALL_SIGNATURE(JSCallWithArgVAndPushUndefined)1616 DEF_CALL_SIGNATURE(JSCallWithArgVAndPushUndefined)
1617 {
1618 // 5 : 5 input parameters
1619 CallSignature jSCallWithArgVAndPushUndefined("JSCallWithArgVAndPushUndefined", 0, 5,
1620 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1621 *callSign = jSCallWithArgVAndPushUndefined;
1622 // 5 : 5 input parameters
1623 std::array<VariableType, 5> params = {
1624 VariableType::NATIVE_POINTER(), // glue
1625 VariableType::INT64(), // actualNumArgs
1626 VariableType::JS_ANY(), // jsfunc
1627 VariableType::JS_ANY(), // newTarget
1628 VariableType::JS_ANY(), // this
1629 };
1630 callSign->SetVariadicArgs(true);
1631 callSign->SetParameters(params.data());
1632 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1633 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1634 }
1635
DEF_CALL_SIGNATURE(CallOptimized)1636 DEF_CALL_SIGNATURE(CallOptimized)
1637 {
1638 // 5 : 5 input parameters
1639 CallSignature jSCall("CallOptimized", 0, 5,
1640 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1641 *callSign = jSCall;
1642 std::array<VariableType, 5> params = { // 5 : 5 input parameters
1643 VariableType::NATIVE_POINTER(), // glue
1644 VariableType::INT64(), // actual argC
1645 VariableType::JS_ANY(), // call target
1646 VariableType::JS_ANY(), // new target
1647 VariableType::JS_ANY(), // thisobj
1648 };
1649 callSign->SetVariadicArgs(true);
1650 callSign->SetParameters(params.data());
1651 callSign->SetCallConv(CallSignature::CallConv::WebKitJSCallConv);
1652 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1653 }
1654
DEF_CALL_SIGNATURE(Dump)1655 DEF_CALL_SIGNATURE(Dump)
1656 {
1657 constexpr size_t N_INPUT_PARAMETERS = 1;
1658 CallSignature dump("Dump", 0, N_INPUT_PARAMETERS,
1659 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1660 *callSign = dump;
1661 std::array<VariableType, N_INPUT_PARAMETERS> params = {
1662 VariableType::JS_POINTER() // Tagged value of the object to be dumped
1663 };
1664 callSign->SetParameters(params.data());
1665 callSign->SetGCLeafFunction(true);
1666 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1667 }
1668
DEF_CALL_SIGNATURE(DebugDump)1669 DEF_CALL_SIGNATURE(DebugDump)
1670 {
1671 constexpr size_t N_INPUT_PARAMETERS = 1;
1672 CallSignature debugDump("DebugDump", 0, N_INPUT_PARAMETERS,
1673 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1674 *callSign = debugDump;
1675 std::array<VariableType, N_INPUT_PARAMETERS> params = {
1676 VariableType::JS_POINTER() // Tagged value of the object to be dumped
1677 };
1678 callSign->SetParameters(params.data());
1679 callSign->SetGCLeafFunction(true);
1680 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1681 }
1682
DEF_CALL_SIGNATURE(DumpWithHint)1683 DEF_CALL_SIGNATURE(DumpWithHint)
1684 {
1685 constexpr size_t N_INPUT_PARAMETERS = 2;
1686 CallSignature dumpWithHint("DumpWithHint", 0, N_INPUT_PARAMETERS,
1687 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1688 *callSign = dumpWithHint;
1689 std::array<VariableType, N_INPUT_PARAMETERS> params = {
1690 VariableType::NATIVE_POINTER(), // String created via CircuitBuilder::StringPtr()
1691 VariableType::JS_POINTER() // Tagged value of the object to be dumped
1692 };
1693 callSign->SetParameters(params.data());
1694 callSign->SetGCLeafFunction(true);
1695 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1696 }
1697
DEF_CALL_SIGNATURE(DebugDumpWithHint)1698 DEF_CALL_SIGNATURE(DebugDumpWithHint)
1699 {
1700 constexpr size_t N_INPUT_PARAMETERS = 2;
1701 CallSignature debugDumpWithHint("DebugDumpWithHint", 0, N_INPUT_PARAMETERS,
1702 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1703 *callSign = debugDumpWithHint;
1704 std::array<VariableType, N_INPUT_PARAMETERS> params = {
1705 VariableType::NATIVE_POINTER(), // String created via CircuitBuilder::StringPtr()
1706 VariableType::JS_POINTER() // Tagged value of the object to be dumped
1707 };
1708 callSign->SetParameters(params.data());
1709 callSign->SetGCLeafFunction(true);
1710 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1711 }
1712
DEF_CALL_SIGNATURE(DebugPrint)1713 DEF_CALL_SIGNATURE(DebugPrint)
1714 {
1715 // 1 : 1 input parameters
1716 CallSignature debugPrint("DebugPrint", 0, 1,
1717 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1718 *callSign = debugPrint;
1719 // 1 : 1 input parameters
1720 std::array<VariableType, 1> params = {
1721 VariableType::INT32(),
1722 };
1723 callSign->SetVariadicArgs(true);
1724 callSign->SetParameters(params.data());
1725 callSign->SetGCLeafFunction(true);
1726 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1727 }
1728
DEF_CALL_SIGNATURE(DebugPrintCustom)1729 DEF_CALL_SIGNATURE(DebugPrintCustom)
1730 {
1731 // 1 : 1 input parameters
1732 CallSignature debugPrintCustom("DebugPrintCustom", 0, 1,
1733 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1734 *callSign = debugPrintCustom;
1735 // 1 : 1 input parameters
1736 std::array<VariableType, 1> params = {
1737 VariableType::NATIVE_POINTER() // Format string created via CircuitBuilder::StringPtr()
1738 };
1739 callSign->SetVariadicArgs(true);
1740 callSign->SetParameters(params.data());
1741 callSign->SetGCLeafFunction(true);
1742 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1743 }
1744
DEF_CALL_SIGNATURE(DebugPrintInstruction)1745 DEF_CALL_SIGNATURE(DebugPrintInstruction)
1746 {
1747 // 2 : 2 input parameters
1748 CallSignature debugPrintInstruction("DebugPrintInstruction", 0, 2,
1749 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1750 *callSign = debugPrintInstruction;
1751 // 2 : 2 input parameters
1752 std::array<VariableType, 2> params = {
1753 VariableType::NATIVE_POINTER(),
1754 VariableType::NATIVE_POINTER(),
1755 };
1756 callSign->SetVariadicArgs(true);
1757 callSign->SetParameters(params.data());
1758 callSign->SetGCLeafFunction(true);
1759 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1760 }
1761
DEF_CALL_SIGNATURE(Comment)1762 DEF_CALL_SIGNATURE(Comment)
1763 {
1764 // 1 : 1 input parameters
1765 CallSignature comment("Comment", 0, 1,
1766 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1767 *callSign = comment;
1768 // 1 : 1 input parameters
1769 std::array<VariableType, 1> params = {
1770 VariableType::NATIVE_POINTER(),
1771 };
1772 callSign->SetParameters(params.data());
1773 callSign->SetGCLeafFunction(true);
1774 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1775 }
1776
DEF_CALL_SIGNATURE(FatalPrint)1777 DEF_CALL_SIGNATURE(FatalPrint)
1778 {
1779 // 1 : 1 input parameters
1780 CallSignature fatalPrint("FatalPrint", 0, 1,
1781 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1782 *callSign = fatalPrint;
1783 // 1 : 1 input parameters
1784 std::array<VariableType, 1> params = {
1785 VariableType::INT32(),
1786 };
1787 callSign->SetVariadicArgs(true);
1788 callSign->SetParameters(params.data());
1789 callSign->SetGCLeafFunction(true);
1790 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1791 }
1792
DEF_CALL_SIGNATURE(FatalPrintCustom)1793 DEF_CALL_SIGNATURE(FatalPrintCustom)
1794 {
1795 // 1 : 1 input parameters
1796 CallSignature fatalPrintCustom("FatalPrintCustom", 0, 1,
1797 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1798 *callSign = fatalPrintCustom;
1799 // 1 : 1 input parameters
1800 std::array<VariableType, 1> params = {
1801 VariableType::NATIVE_POINTER() // Format string created via CircuitBuilder::StringPtr()
1802 };
1803 callSign->SetVariadicArgs(true);
1804 callSign->SetParameters(params.data());
1805 callSign->SetGCLeafFunction(true);
1806 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1807 }
1808
DEF_CALL_SIGNATURE(GetActualArgvNoGC)1809 DEF_CALL_SIGNATURE(GetActualArgvNoGC)
1810 {
1811 CallSignature index("GetActualArgvNoGC", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::NATIVE_POINTER());
1812 *callSign = index;
1813 std::array<VariableType, 1> params = {
1814 VariableType::NATIVE_POINTER(),
1815 };
1816 callSign->SetParameters(params.data());
1817 callSign->SetGCLeafFunction(true);
1818 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1819 }
1820
DEF_CALL_SIGNATURE(InsertOldToNewRSet)1821 DEF_CALL_SIGNATURE(InsertOldToNewRSet)
1822 {
1823 // 3 : 3 input parameters
1824 CallSignature index("InsertOldToNewRSet", 0, 3, ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1825 *callSign = index;
1826 // 3 : 3 input parameters
1827 std::array<VariableType, 3> params = {
1828 VariableType::NATIVE_POINTER(),
1829 VariableType::JS_POINTER(),
1830 VariableType::NATIVE_POINTER(),
1831 };
1832 callSign->SetParameters(params.data());
1833 callSign->SetGCLeafFunction(true);
1834 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1835 }
1836
DEF_CALL_SIGNATURE(FloatMod)1837 DEF_CALL_SIGNATURE(FloatMod)
1838 {
1839 // 2 : 2 input parameters
1840 CallSignature index("FloatMod", 0, 2, ArgumentsOrder::DEFAULT_ORDER, VariableType::FLOAT64());
1841 *callSign = index;
1842 // 2 : 2 input parameters
1843 std::array<VariableType, 2> params = {
1844 VariableType::FLOAT64(),
1845 VariableType::FLOAT64(),
1846 };
1847 callSign->SetParameters(params.data());
1848 callSign->SetGCLeafFunction(true);
1849 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1850 }
1851
DEF_CALL_SIGNATURE(FloatSqrt)1852 DEF_CALL_SIGNATURE(FloatSqrt)
1853 {
1854 // 1 : 1 input parameters
1855 CallSignature index("FloatSqrt", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1856 *callSign = index;
1857 // 1 : 1 input parameters
1858 std::array<VariableType, 1> params = {
1859 VariableType::FLOAT64(),
1860 };
1861 callSign->SetParameters(params.data());
1862 callSign->SetGCLeafFunction(true);
1863 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1864 }
1865
DEF_CALL_SIGNATURE(FloatCos)1866 DEF_CALL_SIGNATURE(FloatCos)
1867 {
1868 // 1 : 1 input parameters
1869 CallSignature index("FloatCos", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1870 *callSign = index;
1871 // 1 : 1 input parameters
1872 std::array<VariableType, 1> params = {
1873 VariableType::FLOAT64(),
1874 };
1875 callSign->SetParameters(params.data());
1876 callSign->SetGCLeafFunction(true);
1877 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1878 }
1879
DEF_CALL_SIGNATURE(FloatSin)1880 DEF_CALL_SIGNATURE(FloatSin)
1881 {
1882 // 1 : 1 input parameters
1883 CallSignature index("FloatSin", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1884 *callSign = index;
1885 // 1 : 1 input parameters
1886 std::array<VariableType, 1> params = {
1887 VariableType::FLOAT64(),
1888 };
1889 callSign->SetParameters(params.data());
1890 callSign->SetGCLeafFunction(true);
1891 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1892 }
1893
DEF_CALL_SIGNATURE(FloatACos)1894 DEF_CALL_SIGNATURE(FloatACos)
1895 {
1896 // 1 : 1 input parameters
1897 CallSignature index("FloatACos", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1898 *callSign = index;
1899 // 1 : 1 input parameters
1900 std::array<VariableType, 1> params = {
1901 VariableType::FLOAT64(),
1902 };
1903 callSign->SetParameters(params.data());
1904 callSign->SetGCLeafFunction(true);
1905 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1906 }
1907
DEF_CALL_SIGNATURE(FloatATan)1908 DEF_CALL_SIGNATURE(FloatATan)
1909 {
1910 // 1 : 1 input parameters
1911 CallSignature index("FloatATan", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1912 *callSign = index;
1913 // 1 : 1 input parameters
1914 std::array<VariableType, 1> params = {
1915 VariableType::FLOAT64(),
1916 };
1917 callSign->SetParameters(params.data());
1918 callSign->SetGCLeafFunction(true);
1919 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1920 }
1921
DEF_CALL_SIGNATURE(FloatFloor)1922 DEF_CALL_SIGNATURE(FloatFloor)
1923 {
1924 // 1 : 1 input parameters
1925 CallSignature index("FloatFloor", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1926 *callSign = index;
1927 // 1 : 1 input parameters
1928 std::array<VariableType, 1> params = {
1929 VariableType::FLOAT64(),
1930 };
1931 callSign->SetParameters(params.data());
1932 callSign->SetGCLeafFunction(true);
1933 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1934 }
1935
DEF_CALL_SIGNATURE(FindElementWithCache)1936 DEF_CALL_SIGNATURE(FindElementWithCache)
1937 {
1938 // 4 : 4 input parameters
1939 CallSignature index("FindElementWithCache", 0, 4, ArgumentsOrder::DEFAULT_ORDER, VariableType::INT32());
1940 *callSign = index;
1941 // 4 : 4 input parameters
1942 std::array<VariableType, 4> params = {
1943 VariableType::NATIVE_POINTER(),
1944 VariableType::JS_ANY(),
1945 VariableType::JS_ANY(),
1946 VariableType::INT32(),
1947 };
1948 callSign->SetParameters(params.data());
1949 callSign->SetGCLeafFunction(true);
1950 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1951 }
1952
DEF_CALL_SIGNATURE(DoubleToInt)1953 DEF_CALL_SIGNATURE(DoubleToInt)
1954 {
1955 // 2 : 2 input parameters
1956 CallSignature index("DoubleToInt", 0, 2, ArgumentsOrder::DEFAULT_ORDER, VariableType::INT32());
1957 *callSign = index;
1958 // 2 : 2 input parameters
1959 std::array<VariableType, 2> params = {
1960 VariableType::FLOAT64(),
1961 VariableType::NATIVE_POINTER(),
1962 };
1963 callSign->SetParameters(params.data());
1964 callSign->SetGCLeafFunction(true);
1965 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1966 }
1967
DEF_CALL_SIGNATURE(DoubleToLength)1968 DEF_CALL_SIGNATURE(DoubleToLength)
1969 {
1970 // 1 : 1 input parameters
1971 CallSignature index("DoubleToLength", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1972 *callSign = index;
1973 // 1 : 1 input parameters
1974 std::array<VariableType, 1> params = {
1975 VariableType::FLOAT64(),
1976 };
1977 callSign->SetParameters(params.data());
1978 callSign->SetGCLeafFunction(true);
1979 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1980 }
1981
DEF_CALL_SIGNATURE(MarkingBarrier)1982 DEF_CALL_SIGNATURE(MarkingBarrier)
1983 {
1984 // 4 : 4 input parameters
1985 CallSignature index("MarkingBarrier", 0, 4, ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1986 *callSign = index;
1987 // 4 : 4 input parameters
1988 std::array<VariableType, 4> params = {
1989 VariableType::NATIVE_POINTER(),
1990 VariableType::JS_POINTER(),
1991 VariableType::NATIVE_POINTER(),
1992 VariableType::JS_POINTER()
1993 };
1994 callSign->SetParameters(params.data());
1995 callSign->SetGCLeafFunction(true);
1996 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1997 }
1998
DEF_CALL_SIGNATURE(StoreBarrier)1999 DEF_CALL_SIGNATURE(StoreBarrier)
2000 {
2001 // 4 : 4 input parameters
2002 CallSignature index("StoreBarrier", 0, 4, ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2003 *callSign = index;
2004 // 4 : 4 input parameters
2005 std::array<VariableType, 4> params = {
2006 VariableType::NATIVE_POINTER(),
2007 VariableType::JS_POINTER(),
2008 VariableType::NATIVE_POINTER(),
2009 VariableType::JS_POINTER()
2010 };
2011 callSign->SetParameters(params.data());
2012 callSign->SetGCLeafFunction(true);
2013 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2014 }
2015
DEF_CALL_SIGNATURE(CallArg0)2016 DEF_CALL_SIGNATURE(CallArg0)
2017 {
2018 // 2 : 2 input parameters
2019 CallSignature callArg0("callArg0", 0, 2,
2020 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2021 *callSign = callArg0;
2022 // 2 : 2 input parameters
2023 std::array<VariableType, 2> params = {
2024 VariableType::NATIVE_POINTER(),
2025 VariableType::JS_ANY()
2026 };
2027 callSign->SetParameters(params.data());
2028 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
2029 }
2030
DEF_CALL_SIGNATURE(CallArg1)2031 DEF_CALL_SIGNATURE(CallArg1)
2032 {
2033 // 3 : 3 input parameters
2034 CallSignature callArg1("callArg1", 0, 3,
2035 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2036 *callSign = callArg1;
2037 // 3 : 3 input parameters
2038 std::array<VariableType, 3> params = {
2039 VariableType::NATIVE_POINTER(),
2040 VariableType::JS_ANY(),
2041 VariableType::JS_ANY()
2042 };
2043 callSign->SetParameters(params.data());
2044 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
2045 }
2046
DEF_CALL_SIGNATURE(CallArgs2)2047 DEF_CALL_SIGNATURE(CallArgs2)
2048 {
2049 // 4 : 4 input parameters
2050 CallSignature callArgs2("callArgs2", 0, 4,
2051 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2052 *callSign = callArgs2;
2053 // 4 : 4 input parameters
2054 std::array<VariableType, 4> params = {
2055 VariableType::NATIVE_POINTER(),
2056 VariableType::JS_ANY(),
2057 VariableType::JS_ANY(),
2058 VariableType::JS_ANY()
2059 };
2060 callSign->SetParameters(params.data());
2061 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
2062 }
2063
DEF_CALL_SIGNATURE(CallArgs3)2064 DEF_CALL_SIGNATURE(CallArgs3)
2065 {
2066 // 5 : 5 input parameters
2067 CallSignature callArgs3("callArgs3", 0, 5,
2068 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2069 *callSign = callArgs3;
2070 // 5 : 5 input parameters
2071 std::array<VariableType, 5> params = {
2072 VariableType::NATIVE_POINTER(),
2073 VariableType::JS_ANY(),
2074 VariableType::JS_ANY(),
2075 VariableType::JS_ANY(),
2076 VariableType::JS_ANY()
2077 };
2078 callSign->SetParameters(params.data());
2079 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
2080 }
2081
DEF_CALL_SIGNATURE(CallThisRange)2082 DEF_CALL_SIGNATURE(CallThisRange)
2083 {
2084 // 3 : 3 input parameters
2085 CallSignature callThisRange("callThisRange", 0, 3,
2086 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2087 *callSign = callThisRange;
2088 // 3 : 3 input parameters
2089 std::array<VariableType, 3> params = {
2090 VariableType::NATIVE_POINTER(),
2091 VariableType::JS_ANY(),
2092 VariableType::JS_ANY()
2093 };
2094 callSign->SetVariadicArgs(true);
2095 callSign->SetParameters(params.data());
2096 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
2097 }
2098
DEF_CALL_SIGNATURE(CallRange)2099 DEF_CALL_SIGNATURE(CallRange)
2100 {
2101 // 2 : 2 input parameters
2102 CallSignature callRange("callRange", 0, 2,
2103 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2104 *callSign = callRange;
2105 // 2 : 2 input parameters
2106 std::array<VariableType, 2> params = {
2107 VariableType::NATIVE_POINTER(),
2108 VariableType::JS_ANY()
2109 };
2110 callSign->SetVariadicArgs(true);
2111 callSign->SetParameters(params.data());
2112 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
2113 }
2114
DEF_CALL_SIGNATURE(JsProxyCallInternal)2115 DEF_CALL_SIGNATURE(JsProxyCallInternal)
2116 {
2117 // 4 : 4 input parameters
2118 CallSignature proxyCallInternal("JsProxyCallInternal", 0, 4,
2119 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_POINTER());
2120 *callSign = proxyCallInternal;
2121 // 4 : 4 input parameters
2122 std::array<VariableType, 4> params = {
2123 VariableType::NATIVE_POINTER(), // glue
2124 VariableType::INT64(), // actual argC
2125 VariableType::JS_POINTER(), // callTarget
2126 VariableType::NATIVE_POINTER(), // argv
2127 };
2128 callSign->SetVariadicArgs(false);
2129 callSign->SetParameters(params.data());
2130 callSign->SetTailCall(true);
2131 callSign->SetGCLeafFunction(true);
2132 callSign->SetTargetKind(CallSignature::TargetKind::COMMON_STUB);
2133 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2134 }
2135
DEF_CALL_SIGNATURE(JsBoundCallInternal)2136 DEF_CALL_SIGNATURE(JsBoundCallInternal)
2137 {
2138 // 6 : 6 input parameters
2139 CallSignature boundCallInternal("JsBoundCallInternal", 0, 6,
2140 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_POINTER());
2141 *callSign = boundCallInternal;
2142 // 6 : 6 input parameters
2143 std::array<VariableType, 6> params = {
2144 VariableType::NATIVE_POINTER(), // glue
2145 VariableType::INT64(), // actual argC
2146 VariableType::JS_POINTER(), // callTarget
2147 VariableType::NATIVE_POINTER(), // argv
2148 VariableType::JS_POINTER(), // this
2149 VariableType::JS_POINTER(), // new
2150 };
2151 callSign->SetVariadicArgs(false);
2152 callSign->SetParameters(params.data());
2153 callSign->SetTailCall(true);
2154 callSign->SetGCLeafFunction(true);
2155 callSign->SetTargetKind(CallSignature::TargetKind::COMMON_STUB);
2156 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2157 }
2158
DEF_CALL_SIGNATURE(TryToElementsIndexOrFindInStringTable)2159 DEF_CALL_SIGNATURE(TryToElementsIndexOrFindInStringTable)
2160 {
2161 // 2 : 2 input parameters
2162 CallSignature tryToElementsIndexOrFindInStringTable("TryToElementsIndexOrFindInStringTable", 0, 2,
2163 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2164 *callSign = tryToElementsIndexOrFindInStringTable;
2165 // 2 : 2 input parameters
2166 std::array<VariableType, 2> params = {
2167 VariableType::NATIVE_POINTER(),
2168 VariableType::JS_POINTER(),
2169 };
2170 callSign->SetParameters(params.data());
2171 callSign->SetGCLeafFunction(true);
2172 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2173 }
2174
DEF_CALL_SIGNATURE(TryGetInternString)2175 DEF_CALL_SIGNATURE(TryGetInternString)
2176 {
2177 // 2 : 2 input parameters
2178 CallSignature tryGetInternString("TryGetInternString", 0, 2,
2179 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2180 *callSign = tryGetInternString;
2181 // 2 : 2 input parameters
2182 std::array<VariableType, 2> params = {
2183 VariableType::NATIVE_POINTER(),
2184 VariableType::JS_POINTER(),
2185 };
2186 callSign->SetParameters(params.data());
2187 callSign->SetGCLeafFunction(true);
2188 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2189 }
2190
DEF_CALL_SIGNATURE(CreateArrayFromList)2191 DEF_CALL_SIGNATURE(CreateArrayFromList)
2192 {
2193 // 3 : 3 input parameters
2194 CallSignature createArrayFromList("CreateArrayFromList", 0, 3, ArgumentsOrder::DEFAULT_ORDER,
2195 VariableType::JS_POINTER());
2196 *callSign = createArrayFromList;
2197 // 3 : 3 input parameters
2198 std::array<VariableType, 3> params = {
2199 VariableType::NATIVE_POINTER(),
2200 VariableType::INT32(),
2201 VariableType::NATIVE_POINTER(),
2202 };
2203
2204 callSign->SetParameters(params.data());
2205 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_VARARGS);
2206 }
2207
DEF_CALL_SIGNATURE(DeoptHandlerAsm)2208 DEF_CALL_SIGNATURE(DeoptHandlerAsm)
2209 {
2210 // 1 : 1 input parameters
2211 CallSignature deoptHandlerAsm("DeoptHandlerAsm", 0, 3,
2212 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2213 *callSign = deoptHandlerAsm;
2214 std::array<VariableType, 3> params = { // 3 : 3 input parameters
2215 VariableType::NATIVE_POINTER(), // glue
2216 VariableType::NATIVE_POINTER(), // deoptType
2217 VariableType::NATIVE_POINTER(), // depth
2218 };
2219 callSign->SetVariadicArgs(false);
2220 callSign->SetParameters(params.data());
2221 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2222 callSign->SetTargetKind(CallSignature::TargetKind::DEOPT_STUB);
2223 }
2224
DEF_CALL_SIGNATURE(TimeClip)2225 DEF_CALL_SIGNATURE(TimeClip)
2226 {
2227 // 1 : 1 input parameters
2228 CallSignature index("TimeClip", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::FLOAT64());
2229 *callSign = index;
2230 // 1 : 1 input parameters
2231 std::array<VariableType, 1> params = {
2232 VariableType::FLOAT64(),
2233 };
2234 callSign->SetParameters(params.data());
2235 callSign->SetGCLeafFunction(true);
2236 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2237 }
2238
DEF_CALL_SIGNATURE(SetDateValues)2239 DEF_CALL_SIGNATURE(SetDateValues)
2240 {
2241 // 3 : 3 input parameters
2242 CallSignature index("SetDateValues", 0, 3, ArgumentsOrder::DEFAULT_ORDER, VariableType::FLOAT64());
2243 *callSign = index;
2244 // 3 : 3 input parameters
2245 std::array<VariableType, 3> params = {
2246 VariableType::FLOAT64(),
2247 VariableType::FLOAT64(),
2248 VariableType::FLOAT64(),
2249 };
2250 callSign->SetParameters(params.data());
2251 callSign->SetGCLeafFunction(true);
2252 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2253 }
2254
DEF_CALL_SIGNATURE(StartCallTimer)2255 DEF_CALL_SIGNATURE(StartCallTimer)
2256 {
2257 CallSignature index("StartCallTimer", 0, 3, ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2258 *callSign = index;
2259 // 3 : 3 input parameters
2260 std::array<VariableType, 3> params = {
2261 VariableType::NATIVE_POINTER(),
2262 VariableType::JS_ANY(),
2263 VariableType::BOOL()
2264 };
2265 callSign->SetParameters(params.data());
2266 callSign->SetGCLeafFunction(true);
2267 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2268 }
2269
DEF_CALL_SIGNATURE(EndCallTimer)2270 DEF_CALL_SIGNATURE(EndCallTimer)
2271 {
2272 CallSignature index("EndCallTimer", 0, 2, ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2273 *callSign = index;
2274 // 2 : 2 input parameters
2275 std::array<VariableType, 2> params = {
2276 VariableType::NATIVE_POINTER(),
2277 VariableType::JS_ANY()
2278 };
2279 callSign->SetParameters(params.data());
2280 callSign->SetGCLeafFunction(true);
2281 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2282 }
2283
DEF_CALL_SIGNATURE(GetSingleCharCodeByIndex)2284 DEF_CALL_SIGNATURE(GetSingleCharCodeByIndex)
2285 {
2286 // 3 : 3 input parameters
2287 CallSignature signature("GetSingleCharCodeByIndex", 0, 3,
2288 ArgumentsOrder::DEFAULT_ORDER, VariableType::INT32());
2289 *callSign = signature;
2290 // 3 : 3 input parameters
2291 std::array<VariableType, 3> params = {
2292 VariableType::NATIVE_POINTER(), // glue
2293 VariableType::JS_ANY(), // ecmaString
2294 VariableType::INT32(), // index
2295 };
2296 callSign->SetParameters(params.data());
2297 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2298 }
2299
DEF_CALL_SIGNATURE(CreateStringBySingleCharCode)2300 DEF_CALL_SIGNATURE(CreateStringBySingleCharCode)
2301 {
2302 // 2 : 2 input parameters
2303 CallSignature signature("CreateStringByCharCode", 0, 2,
2304 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2305 *callSign = signature;
2306 // 2 : 2 input parameters
2307 std::array<VariableType, 2> params = {
2308 VariableType::NATIVE_POINTER(), // glue
2309 VariableType::INT32(), // charcode
2310 };
2311 callSign->SetParameters(params.data());
2312 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2313 }
2314
DEF_CALL_SIGNATURE(Getpropiterator)2315 DEF_CALL_SIGNATURE(Getpropiterator)
2316 {
2317 // 2 : 2 input parameters
2318 CallSignature signature("Getpropiterator", 0, 2,
2319 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2320 *callSign = signature;
2321 // 2 : 2 input parameters
2322 std::array<VariableType, 2> params = {
2323 VariableType::NATIVE_POINTER(), // glue
2324 VariableType::JS_ANY(), // object
2325 };
2326 callSign->SetParameters(params.data());
2327 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2328 }
2329
DEF_CALL_SIGNATURE(Getnextpropname)2330 DEF_CALL_SIGNATURE(Getnextpropname)
2331 {
2332 // 2 : 2 input parameters
2333 CallSignature signature("Getnextpropname", 0, 2,
2334 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2335 *callSign = signature;
2336 // 2 : 2 input parameters
2337 std::array<VariableType, 2> params = {
2338 VariableType::NATIVE_POINTER(), // glue
2339 VariableType::JS_ANY(), // iter
2340 };
2341 callSign->SetParameters(params.data());
2342 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2343 }
2344
DEF_CALL_SIGNATURE(CreateJSSetIterator)2345 DEF_CALL_SIGNATURE(CreateJSSetIterator)
2346 {
2347 // 2 : 2 input parameters
2348 CallSignature signature("CreateJSSetIterator", 0, 2,
2349 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2350 *callSign = signature;
2351 // 2 : 2 input parameters
2352 std::array<VariableType, 2> params = {
2353 VariableType::NATIVE_POINTER(), // glue
2354 VariableType::JS_ANY(), // obj
2355 };
2356 callSign->SetParameters(params.data());
2357 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2358 }
2359
DEF_CALL_SIGNATURE(CreateJSMapIterator)2360 DEF_CALL_SIGNATURE(CreateJSMapIterator)
2361 {
2362 // 2 : 2 input parameters
2363 CallSignature signature("CreateJSMapIterator", 0, 2,
2364 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2365 *callSign = signature;
2366 // 2 : 2 input parameters
2367 std::array<VariableType, 2> params = {
2368 VariableType::NATIVE_POINTER(), // glue
2369 VariableType::JS_ANY(), // obj
2370 };
2371 callSign->SetParameters(params.data());
2372 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2373 }
2374
DEF_CALL_SIGNATURE(FastStringEqual)2375 DEF_CALL_SIGNATURE(FastStringEqual)
2376 {
2377 // 3 : 3 input parameters
2378 CallSignature signature("FastStringEqual", 0, 3,
2379 ArgumentsOrder::DEFAULT_ORDER, VariableType::BOOL());
2380 *callSign = signature;
2381 // 3 : 3 input parameters
2382 std::array<VariableType, 3> params = {
2383 VariableType::NATIVE_POINTER(), // glue
2384 VariableType::JS_ANY(), // ecmaString1
2385 VariableType::JS_ANY(), // ecmaString2
2386 };
2387 callSign->SetParameters(params.data());
2388 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2389 }
2390
DEF_CALL_SIGNATURE(FastStringAdd)2391 DEF_CALL_SIGNATURE(FastStringAdd)
2392 {
2393 // 3 : 3 input parameters
2394 CallSignature signature("FastStringAdd", 0, 3,
2395 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2396 *callSign = signature;
2397 // 3 : 3 input parameters
2398 std::array<VariableType, 3> params = {
2399 VariableType::NATIVE_POINTER(), // glue
2400 VariableType::JS_ANY(), // ecmaString1
2401 VariableType::JS_ANY(), // ecmaString2
2402 };
2403 callSign->SetParameters(params.data());
2404 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2405 }
2406
DEF_CALL_SIGNATURE(DeleteObjectProperty)2407 DEF_CALL_SIGNATURE(DeleteObjectProperty)
2408 {
2409 // 3 : 3 input parameters
2410 CallSignature signature("DeleteObjectProperty", 0, 3,
2411 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2412 *callSign = signature;
2413 // 3 : 3 input parameters
2414 std::array<VariableType, 3> params = {
2415 VariableType::NATIVE_POINTER(), // glue
2416 VariableType::JS_ANY(), // object
2417 VariableType::JS_ANY(), // prop
2418 };
2419 callSign->SetParameters(params.data());
2420 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2421 }
2422 } // namespace panda::ecmascript::kungfu
2423