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
18 #if defined(__clang__)
19 #pragma clang diagnostic push
20 #pragma clang diagnostic ignored "-Wshadow"
21 #pragma clang diagnostic ignored "-Wunused-parameter"
22 #elif defined(__GNUC__)
23 #pragma GCC diagnostic push
24 #pragma GCC diagnostic ignored "-Wshadow"
25 #pragma GCC diagnostic ignored "-Wunused-parameter"
26 #endif
27
28
29 #if defined(__clang__)
30 #pragma clang diagnostic pop
31 #elif defined(__GNUC__)
32 #pragma GCC diagnostic pop
33 #endif
34
35 namespace panda::ecmascript::kungfu {
36 #define BINARY_CALL_SIGNATURE(name) \
37 /* 3 : 3 input parameters */ \
38 CallSignature signature(#name, 0, 3, \
39 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); \
40 *callSign = signature; \
41 /* 3 : 3 input parameters */ \
42 std::array<VariableType, 3> params = { \
43 VariableType::NATIVE_POINTER(), \
44 VariableType::JS_ANY(), \
45 VariableType::JS_ANY(), \
46 }; \
47 callSign->SetParameters(params.data()); \
48 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
49
DEF_CALL_SIGNATURE(Add)50 DEF_CALL_SIGNATURE(Add)
51 {
52 BINARY_CALL_SIGNATURE(Add)
53 }
54
DEF_CALL_SIGNATURE(Sub)55 DEF_CALL_SIGNATURE(Sub)
56 {
57 BINARY_CALL_SIGNATURE(Sub)
58 }
59
DEF_CALL_SIGNATURE(Mul)60 DEF_CALL_SIGNATURE(Mul)
61 {
62 BINARY_CALL_SIGNATURE(Mul)
63 }
64
DEF_CALL_SIGNATURE(Div)65 DEF_CALL_SIGNATURE(Div)
66 {
67 BINARY_CALL_SIGNATURE(Div)
68 }
69
DEF_CALL_SIGNATURE(Mod)70 DEF_CALL_SIGNATURE(Mod)
71 {
72 BINARY_CALL_SIGNATURE(Mod)
73 }
74
DEF_CALL_SIGNATURE(Equal)75 DEF_CALL_SIGNATURE(Equal)
76 {
77 BINARY_CALL_SIGNATURE(Equal)
78 }
79
DEF_CALL_SIGNATURE(NotEqual)80 DEF_CALL_SIGNATURE(NotEqual)
81 {
82 BINARY_CALL_SIGNATURE(NotEqual)
83 }
84
DEF_CALL_SIGNATURE(StrictEqual)85 DEF_CALL_SIGNATURE(StrictEqual)
86 {
87 BINARY_CALL_SIGNATURE(StrictEqual)
88 }
89
DEF_CALL_SIGNATURE(StrictNotEqual)90 DEF_CALL_SIGNATURE(StrictNotEqual)
91 {
92 BINARY_CALL_SIGNATURE(StrictNotEqual)
93 }
94
DEF_CALL_SIGNATURE(Less)95 DEF_CALL_SIGNATURE(Less)
96 {
97 BINARY_CALL_SIGNATURE(Less)
98 }
99
DEF_CALL_SIGNATURE(LessEq)100 DEF_CALL_SIGNATURE(LessEq)
101 {
102 BINARY_CALL_SIGNATURE(LessEq)
103 }
104
DEF_CALL_SIGNATURE(Greater)105 DEF_CALL_SIGNATURE(Greater)
106 {
107 BINARY_CALL_SIGNATURE(Greater)
108 }
109
DEF_CALL_SIGNATURE(GreaterEq)110 DEF_CALL_SIGNATURE(GreaterEq)
111 {
112 BINARY_CALL_SIGNATURE(GreaterEq)
113 }
114
DEF_CALL_SIGNATURE(Shl)115 DEF_CALL_SIGNATURE(Shl)
116 {
117 BINARY_CALL_SIGNATURE(Shl)
118 }
119
DEF_CALL_SIGNATURE(Shr)120 DEF_CALL_SIGNATURE(Shr)
121 {
122 BINARY_CALL_SIGNATURE(Shr)
123 }
124
DEF_CALL_SIGNATURE(Ashr)125 DEF_CALL_SIGNATURE(Ashr)
126 {
127 BINARY_CALL_SIGNATURE(Ashr)
128 }
129
DEF_CALL_SIGNATURE(And)130 DEF_CALL_SIGNATURE(And)
131 {
132 BINARY_CALL_SIGNATURE(And)
133 }
134
DEF_CALL_SIGNATURE(Or)135 DEF_CALL_SIGNATURE(Or)
136 {
137 BINARY_CALL_SIGNATURE(Or)
138 }
139
DEF_CALL_SIGNATURE(Xor)140 DEF_CALL_SIGNATURE(Xor)
141 {
142 BINARY_CALL_SIGNATURE(Xor)
143 }
144
145 #ifndef NDEBUG
DEF_CALL_SIGNATURE(MulGCTest)146 DEF_CALL_SIGNATURE(MulGCTest)
147 {
148 // 3 : 3 input parameters
149 CallSignature MulGC("MulGCTest", 0, 3, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
150 *callSign = MulGC;
151 // 3 : 3 input parameters
152 std::array<VariableType, 3> params = {
153 VariableType::NATIVE_POINTER(),
154 VariableType::INT64(),
155 VariableType::INT64(),
156 };
157 callSign->SetParameters(params.data());
158 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
159 }
160 #else
DEF_CALL_SIGNATURE(MulGCTest)161 DEF_CALL_SIGNATURE(MulGCTest) {}
162 #endif
163
164 #define UNARY_CALL_SIGNATURE(name) \
165 /* 2 : 2 input parameters */ \
166 CallSignature signature(#name, 0, 2, \
167 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); \
168 *callSign = signature; \
169 /* 2 : 2 input parameters */ \
170 std::array<VariableType, 2> params = { \
171 VariableType::NATIVE_POINTER(), \
172 VariableType::JS_ANY(), \
173 }; \
174 callSign->SetParameters(params.data()); \
175 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
176
DEF_CALL_SIGNATURE(Inc)177 DEF_CALL_SIGNATURE(Inc)
178 {
179 UNARY_CALL_SIGNATURE(Inc)
180 }
181
DEF_CALL_SIGNATURE(Dec)182 DEF_CALL_SIGNATURE(Dec)
183 {
184 UNARY_CALL_SIGNATURE(Dec)
185 }
186
DEF_CALL_SIGNATURE(Neg)187 DEF_CALL_SIGNATURE(Neg)
188 {
189 UNARY_CALL_SIGNATURE(Neg)
190 }
191
DEF_CALL_SIGNATURE(Not)192 DEF_CALL_SIGNATURE(Not)
193 {
194 UNARY_CALL_SIGNATURE(Not)
195 }
196
DEF_CALL_SIGNATURE(ToBooleanTrue)197 DEF_CALL_SIGNATURE(ToBooleanTrue)
198 {
199 UNARY_CALL_SIGNATURE(ToBooleanTrue)
200 }
201
DEF_CALL_SIGNATURE(ToBooleanFalse)202 DEF_CALL_SIGNATURE(ToBooleanFalse)
203 {
204 UNARY_CALL_SIGNATURE(ToBooleanFalse)
205 }
206
DEF_CALL_SIGNATURE(TypeOf)207 DEF_CALL_SIGNATURE(TypeOf)
208 {
209 // 2 input parameters
210 CallSignature TypeOf("TypeOf", 0, 2, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_POINTER());
211 *callSign = TypeOf;
212 // 2 input parameters
213 std::array<VariableType, 2> params = {
214 VariableType::NATIVE_POINTER(), // glue
215 VariableType::JS_ANY(), // ACC
216 };
217 callSign->SetParameters(params.data());
218 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
219 }
220
DEF_CALL_SIGNATURE(JSTaggedValueHasProperty)221 DEF_CALL_SIGNATURE(JSTaggedValueHasProperty)
222 {
223 BINARY_CALL_SIGNATURE(JSTaggedValueHasProperty)
224 }
225
DEF_CALL_SIGNATURE(SetPropertyByName)226 DEF_CALL_SIGNATURE(SetPropertyByName)
227 {
228 // 6 : 6 input parameters
229 CallSignature setPropertyByName("SetPropertyByName", 0, 6, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
230 *callSign = setPropertyByName;
231 // 6 : 6 input parameters
232 std::array<VariableType, 6> params = {
233 VariableType::NATIVE_POINTER(), // glue
234 VariableType::JS_ANY(), // receiver
235 VariableType::INT64(), // key
236 VariableType::JS_ANY(), // value
237 VariableType::JS_ANY(), // jsFunc
238 VariableType::INT32(), // slot id
239 };
240 callSign->SetParameters(params.data());
241 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
242 }
243
DEF_CALL_SIGNATURE(DeprecatedSetPropertyByName)244 DEF_CALL_SIGNATURE(DeprecatedSetPropertyByName)
245 {
246 // 4 : 4 input parameters
247 CallSignature setPropertyByName("DeprecatedSetPropertyByName", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
248 VariableType::JS_ANY());
249 *callSign = setPropertyByName;
250 // 4 : 4 input parameters
251 std::array<VariableType, 4> params = {
252 VariableType::NATIVE_POINTER(),
253 VariableType::JS_POINTER(),
254 VariableType::JS_POINTER(),
255 VariableType::JS_ANY()
256 };
257 callSign->SetParameters(params.data());
258 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
259 }
260
DEF_CALL_SIGNATURE(GetPropertyByNameWithMega)261 DEF_CALL_SIGNATURE(GetPropertyByNameWithMega)
262 {
263 // 7 : 7 input parameters
264 CallSignature getPropertyByName("GetPropertyByNameWithMega", 0, 7, ArgumentsOrder::DEFAULT_ORDER,
265 VariableType::JS_ANY());
266 *callSign = getPropertyByName;
267 // 7 : 7 input parameters
268 std::array<VariableType, 7> params = {
269 VariableType::NATIVE_POINTER(), // glue
270 VariableType::JS_ANY(), // receiver
271 VariableType::INT64(), // key
272 VariableType::NATIVE_POINTER(), // MegaStubCache
273 VariableType::JS_ANY(), // prop
274 VariableType::JS_ANY(), // jsFunc
275 VariableType::INT32(), // slot id
276 };
277 callSign->SetParameters(params.data());
278 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
279 }
280
DEF_CALL_SIGNATURE(SetPropertyByNameWithMega)281 DEF_CALL_SIGNATURE(SetPropertyByNameWithMega)
282 {
283 // 8 : 8 input parameters
284 CallSignature setPropertyByName("SetPropertyByNameWithMega", 0, 8, ArgumentsOrder::DEFAULT_ORDER,
285 VariableType::JS_ANY());
286 *callSign = setPropertyByName;
287 // 8 : 8 input parameters
288 std::array<VariableType, 8> params = {
289 VariableType::NATIVE_POINTER(), // glue
290 VariableType::JS_ANY(), // receiver
291 VariableType::INT64(), // key
292 VariableType::JS_ANY(), // value
293 VariableType::NATIVE_POINTER(), // MegaStubCache
294 VariableType::JS_ANY(), // prop
295 VariableType::JS_ANY(), // jsFunc
296 VariableType::INT32(), // slot id
297 };
298 callSign->SetParameters(params.data());
299 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
300 }
301
302
DEF_CALL_SIGNATURE(SetPropertyByNameWithOwn)303 DEF_CALL_SIGNATURE(SetPropertyByNameWithOwn)
304 {
305 // 4 : 4 input parameters
306 CallSignature setPropertyByNameWithOwn("SetPropertyByNameWithOwn", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
307 VariableType::JS_ANY());
308 *callSign = setPropertyByNameWithOwn;
309 // 4 : 4 input parameters
310 std::array<VariableType, 4> params = {
311 VariableType::NATIVE_POINTER(),
312 VariableType::JS_POINTER(),
313 VariableType::JS_POINTER(),
314 VariableType::JS_ANY()
315 };
316 callSign->SetParameters(params.data());
317 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
318 }
319
DEF_CALL_SIGNATURE(SetPropertyByValue)320 DEF_CALL_SIGNATURE(SetPropertyByValue)
321 {
322 // 6 : 6 input parameters
323 CallSignature setPropertyByName("SetPropertyByValue", 0, 6, ArgumentsOrder::DEFAULT_ORDER,
324 VariableType::JS_ANY());
325 *callSign = setPropertyByName;
326 // 6 : 6 input parameters
327 std::array<VariableType, 6> params = {
328 VariableType::NATIVE_POINTER(), // glue
329 VariableType::JS_POINTER(), // receiver
330 VariableType::JS_ANY(), // key
331 VariableType::JS_ANY(), // value
332 VariableType::JS_ANY(), // jsFunc
333 VariableType::INT32(), // slot id
334 };
335 callSign->SetParameters(params.data());
336 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
337 }
338
DEF_CALL_SIGNATURE(Definefunc)339 DEF_CALL_SIGNATURE(Definefunc)
340 {
341 // 6 : 6 input parameters
342 CallSignature definefunc("Definefunc", 0, 6, ArgumentsOrder::DEFAULT_ORDER,
343 VariableType::JS_ANY());
344 *callSign = definefunc;
345 // 6 : 6 input parameters
346 std::array<VariableType, 6> params = {
347 VariableType::NATIVE_POINTER(), // glue
348 VariableType::JS_ANY(), // jsFunc
349 VariableType::INT32(), // methodId
350 VariableType::INT32(), // length
351 VariableType::JS_ANY(), // lexEnv
352 VariableType::INT32(), // slotId
353 };
354 callSign->SetParameters(params.data());
355 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
356 }
357
DEF_CALL_SIGNATURE(DefineField)358 DEF_CALL_SIGNATURE(DefineField)
359 {
360 // 4 : 4 input parameters
361 CallSignature defineField("DefineField", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
362 VariableType::JS_ANY());
363 *callSign = defineField;
364 // 4 : 4 input parameters
365 std::array<VariableType, 4> params = {
366 VariableType::NATIVE_POINTER(), // glue
367 VariableType::JS_ANY(), // receiver
368 VariableType::JS_ANY(), // key
369 VariableType::JS_ANY(), // acc
370 };
371 callSign->SetParameters(params.data());
372 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
373 }
374
DEF_CALL_SIGNATURE(ConvertCharToInt32)375 DEF_CALL_SIGNATURE(ConvertCharToInt32)
376 {
377 // 2 : 2 input parameters
378 CallSignature convertCharToInt32("ConvertCharToInt32", 0, 2, ArgumentsOrder::DEFAULT_ORDER,
379 VariableType::INT32());
380 *callSign = convertCharToInt32;
381 // 2 : 2 input parameters
382 std::array<VariableType, 2> params = {
383 VariableType::NATIVE_POINTER(), // glue
384 VariableType::INT32(), // charcode
385 };
386 callSign->SetParameters(params.data());
387 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
388 }
389
DEF_CALL_SIGNATURE(ConvertCharToDouble)390 DEF_CALL_SIGNATURE(ConvertCharToDouble)
391 {
392 // 2 : 2 input parameters
393 CallSignature convertCharToDouble("ConvertCharToDouble", 0, 2, ArgumentsOrder::DEFAULT_ORDER,
394 VariableType::FLOAT64());
395 *callSign = convertCharToDouble;
396 // 2 : 2 input parameters
397 std::array<VariableType, 2> params = {
398 VariableType::NATIVE_POINTER(), // glue
399 VariableType::INT32(), // charcode
400 };
401 callSign->SetParameters(params.data());
402 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
403 }
404
DEF_CALL_SIGNATURE(DeprecatedSetPropertyByValue)405 DEF_CALL_SIGNATURE(DeprecatedSetPropertyByValue)
406 {
407 // 4 : 4 input parameters
408 CallSignature setPropertyByName("DeprecatedSetPropertyByValue", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
409 VariableType::JS_ANY());
410 *callSign = setPropertyByName;
411 // 4 : 4 input parameters
412 std::array<VariableType, 4> params = {
413 VariableType::NATIVE_POINTER(),
414 VariableType::JS_POINTER(),
415 VariableType::JS_ANY(),
416 VariableType::JS_ANY()
417 };
418 callSign->SetParameters(params.data());
419 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
420 }
421
DEF_CALL_SIGNATURE(SetPropertyByValueWithOwn)422 DEF_CALL_SIGNATURE(SetPropertyByValueWithOwn)
423 {
424 // 4 : 4 input parameters
425 CallSignature setPropertyByValueWithOwn("SetPropertyByValueWithOwn", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
426 VariableType::JS_ANY());
427 *callSign = setPropertyByValueWithOwn;
428 // 4 : 4 input parameters
429 std::array<VariableType, 4> params = {
430 VariableType::NATIVE_POINTER(),
431 VariableType::JS_POINTER(),
432 VariableType::JS_ANY(),
433 VariableType::JS_ANY()
434 };
435 callSign->SetParameters(params.data());
436 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
437 }
438
DEF_CALL_SIGNATURE(GetPropertyByName)439 DEF_CALL_SIGNATURE(GetPropertyByName)
440 {
441 // 5 : 5 input parameters
442 CallSignature getPropertyByName("GetPropertyByName", 0, 5, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
443 *callSign = getPropertyByName;
444 // 5 : 5 input parameters
445 std::array<VariableType, 5> params = {
446 VariableType::NATIVE_POINTER(), // glue
447 VariableType::JS_ANY(), // receiver
448 VariableType::INT64(), // key
449 VariableType::JS_ANY(), // jsFunc
450 VariableType::INT32(), // slot id
451 };
452 callSign->SetParameters(params.data());
453 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
454 }
455
DEF_CALL_SIGNATURE(IsIn)456 DEF_CALL_SIGNATURE(IsIn)
457 {
458 BINARY_CALL_SIGNATURE(IsIn)
459 }
460
DEF_CALL_SIGNATURE(Instanceof)461 DEF_CALL_SIGNATURE(Instanceof)
462 {
463 // 5 : 5 input parameters
464 CallSignature instanceof("Instanceof", 0, 5, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
465 *callSign = instanceof;
466 // 5 : 5 input parameters
467 std::array<VariableType, 5> params = {
468 VariableType::NATIVE_POINTER(), // glue
469 VariableType::JS_ANY(), // object
470 VariableType::JS_ANY(), // target
471 VariableType::JS_ANY(), // jsFunc
472 VariableType::INT32(), // slot id
473 };
474 callSign->SetParameters(params.data());
475 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
476 }
477
DEF_CALL_SIGNATURE(DeprecatedGetPropertyByName)478 DEF_CALL_SIGNATURE(DeprecatedGetPropertyByName)
479 {
480 // 3 : 3 input parameters
481 CallSignature getPropertyByName("DeprecatedGetPropertyByName", 0, 3, ArgumentsOrder::DEFAULT_ORDER,
482 VariableType::JS_ANY());
483 *callSign = getPropertyByName;
484 // 3 : 3 input parameters
485 std::array<VariableType, 3> params = {
486 VariableType::NATIVE_POINTER(), // glue
487 VariableType::JS_ANY(), // receiver
488 VariableType::JS_POINTER(), // key
489 };
490 callSign->SetParameters(params.data());
491 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
492 }
493
DEF_CALL_SIGNATURE(TryLdGlobalByName)494 DEF_CALL_SIGNATURE(TryLdGlobalByName)
495 {
496 // 4 : 4 input parameters
497 CallSignature signature("TryLdGlobalByName", 0, 4, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
498 *callSign = signature;
499 // 4 : 4 input parameters
500 std::array<VariableType, 4> params = {
501 VariableType::NATIVE_POINTER(), // glue
502 VariableType::INT64(), // key
503 VariableType::JS_ANY(), // jsFunc
504 VariableType::INT32(), // slot id
505 };
506 callSign->SetParameters(params.data());
507 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
508 }
509
DEF_CALL_SIGNATURE(TryStGlobalByName)510 DEF_CALL_SIGNATURE(TryStGlobalByName)
511 {
512 // 5 : 5 input parameters
513 CallSignature signature("TryStGlobalByName", 0, 5, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
514 *callSign = signature;
515 // 5 : 5 input parameters
516 std::array<VariableType, 5> params = {
517 VariableType::NATIVE_POINTER(), // glue
518 VariableType::INT64(), // key
519 VariableType::JS_ANY(), // value
520 VariableType::JS_ANY(), // jsFunc
521 VariableType::INT32(), // slot id
522 };
523 callSign->SetParameters(params.data());
524 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
525 }
526
DEF_CALL_SIGNATURE(LdGlobalVar)527 DEF_CALL_SIGNATURE(LdGlobalVar)
528 {
529 // 4 : 4 input parameters
530 CallSignature signature("LdGlobalVar", 0, 4, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
531 *callSign = signature;
532 // 4 : 4 input parameters
533 std::array<VariableType, 4> params = {
534 VariableType::NATIVE_POINTER(), // glue
535 VariableType::INT64(), // key
536 VariableType::JS_ANY(), // jsFunc
537 VariableType::INT32(), // slot id
538 };
539 callSign->SetParameters(params.data());
540 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
541 }
542
DEF_CALL_SIGNATURE(StGlobalVar)543 DEF_CALL_SIGNATURE(StGlobalVar)
544 {
545 // 5 : 5 input parameters
546 CallSignature signature("StGlobalVar", 0, 5, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
547 *callSign = signature;
548 // 5 : 5 input parameters
549 std::array<VariableType, 5> params = {
550 VariableType::NATIVE_POINTER(), // glue
551 VariableType::INT64(), // string id
552 VariableType::JS_ANY(), // value
553 VariableType::JS_ANY(), // jsFunc
554 VariableType::INT32(), // slot id
555 };
556 callSign->SetParameters(params.data());
557 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
558 }
DEF_CALL_SIGNATURE(StOwnByValue)559 DEF_CALL_SIGNATURE(StOwnByValue)
560 {
561 // 4 : 4 input parameters
562 CallSignature signature("StOwnByValue", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
563 VariableType::JS_ANY());
564 *callSign = signature;
565 // 4 : 4 input parameters
566 std::array<VariableType, 4> params = {
567 VariableType::NATIVE_POINTER(),
568 VariableType::JS_POINTER(),
569 VariableType::JS_ANY(),
570 VariableType::JS_ANY()
571 };
572 callSign->SetParameters(params.data());
573 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
574 }
DEF_CALL_SIGNATURE(StOwnByIndex)575 DEF_CALL_SIGNATURE(StOwnByIndex)
576 {
577 // 4 : 4 input parameters
578 CallSignature signature("StOwnByIndex", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
579 VariableType::JS_ANY()); // hole or undefined
580 *callSign = signature;
581 // 4 : 4 input parameters
582 std::array<VariableType, 4> params = {
583 VariableType::NATIVE_POINTER(),
584 VariableType::JS_POINTER(),
585 VariableType::INT32(),
586 VariableType::JS_ANY()
587 };
588 callSign->SetParameters(params.data());
589 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
590 }
DEF_CALL_SIGNATURE(StOwnByName)591 DEF_CALL_SIGNATURE(StOwnByName)
592 {
593 // 4 : 4 input parameters
594 CallSignature signature("StOwnByName", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
595 VariableType::JS_ANY());
596 *callSign = signature;
597 // 4 : 4 input parameters
598 std::array<VariableType, 4> params = {
599 VariableType::NATIVE_POINTER(),
600 VariableType::JS_POINTER(),
601 VariableType::JS_POINTER(),
602 VariableType::JS_ANY()
603 };
604 callSign->SetParameters(params.data());
605 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
606 }
DEF_CALL_SIGNATURE(StOwnByValueWithNameSet)607 DEF_CALL_SIGNATURE(StOwnByValueWithNameSet)
608 {
609 // 4 : 4 input parameters
610 CallSignature signature("StOwnByValueWithNameSet", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
611 VariableType::JS_ANY());
612 *callSign = signature;
613 // 4 : 4 input parameters
614 std::array<VariableType, 4> params = {
615 VariableType::NATIVE_POINTER(),
616 VariableType::JS_POINTER(),
617 VariableType::JS_ANY(),
618 VariableType::JS_ANY()
619 };
620 callSign->SetParameters(params.data());
621 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
622 }
DEF_CALL_SIGNATURE(StOwnByNameWithNameSet)623 DEF_CALL_SIGNATURE(StOwnByNameWithNameSet)
624 {
625 // 4 : 4 input parameters
626 CallSignature signature("StOwnByNameWithNameSet", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
627 VariableType::JS_ANY());
628 *callSign = signature;
629 // 4 : 4 input parameters
630 std::array<VariableType, 4> params = {
631 VariableType::NATIVE_POINTER(),
632 VariableType::JS_POINTER(),
633 VariableType::JS_POINTER(),
634 VariableType::JS_ANY()
635 };
636 callSign->SetParameters(params.data());
637 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
638 }
DEF_CALL_SIGNATURE(StObjByIndex)639 DEF_CALL_SIGNATURE(StObjByIndex)
640 {
641 // 4 : 4 input parameters
642 CallSignature signature("StObjByIndex", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
643 VariableType::JS_ANY()); // hole or undefined
644 *callSign = signature;
645 // 4 : 4 input parameters
646 std::array<VariableType, 4> params = {
647 VariableType::NATIVE_POINTER(),
648 VariableType::JS_POINTER(),
649 VariableType::INT32(),
650 VariableType::JS_ANY()
651 };
652 callSign->SetParameters(params.data());
653 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
654 }
DEF_CALL_SIGNATURE(LdObjByIndex)655 DEF_CALL_SIGNATURE(LdObjByIndex)
656 {
657 // 3 : 3 input parameters
658 CallSignature signature("LdObjByIndex", 0, 3, ArgumentsOrder::DEFAULT_ORDER,
659 VariableType::JS_ANY());
660 *callSign = signature;
661 // 3 : 3 input parameters
662 std::array<VariableType, 3> params = {
663 VariableType::NATIVE_POINTER(), // glue
664 VariableType::JS_ANY(), // receiver
665 VariableType::INT32(), // index
666 };
667 callSign->SetParameters(params.data());
668 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
669 }
670
DEF_CALL_SIGNATURE(GetPropertyByIndex)671 DEF_CALL_SIGNATURE(GetPropertyByIndex)
672 {
673 // 3 : 3 input parameters
674 CallSignature getPropertyByIndex("GetPropertyByIndex", 0, 3, ArgumentsOrder::DEFAULT_ORDER,
675 VariableType::JS_ANY());
676 *callSign = getPropertyByIndex;
677 // 3 : 3 input parameters
678 std::array<VariableType, 3> params = {
679 VariableType::NATIVE_POINTER(), // glue
680 VariableType::JS_ANY(), // receiver
681 VariableType::INT32(), // index
682 };
683 callSign->SetParameters(params.data());
684 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
685 }
686
DEF_CALL_SIGNATURE(SetPropertyByIndex)687 DEF_CALL_SIGNATURE(SetPropertyByIndex)
688 {
689 // 4 : 4 input parameters
690 CallSignature setPropertyByIndex("SetPropertyByIndex", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
691 VariableType::JS_ANY()); // hole or undefined
692 *callSign = setPropertyByIndex;
693 // 4 : 4 input parameters
694 std::array<VariableType, 4> params = {
695 VariableType::NATIVE_POINTER(),
696 VariableType::JS_POINTER(),
697 VariableType::INT32(),
698 VariableType::JS_ANY()
699 };
700 callSign->SetParameters(params.data());
701 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
702 }
703
DEF_CALL_SIGNATURE(SetPropertyByIndexWithOwn)704 DEF_CALL_SIGNATURE(SetPropertyByIndexWithOwn)
705 {
706 // 4 : 4 input parameters
707 CallSignature setPropertyByIndexWithOwn("SetPropertyByIndexWithOwn", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
708 VariableType::JS_ANY()); // hole or undefined
709 *callSign = setPropertyByIndexWithOwn;
710 // 4 : 4 input parameters
711 std::array<VariableType, 4> params = {
712 VariableType::NATIVE_POINTER(),
713 VariableType::JS_POINTER(),
714 VariableType::INT32(),
715 VariableType::JS_ANY()
716 };
717 callSign->SetParameters(params.data());
718 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
719 }
720
DEF_CALL_SIGNATURE(GetPropertyByValue)721 DEF_CALL_SIGNATURE(GetPropertyByValue)
722 {
723 // 5 : 5 input parameters
724 CallSignature getPropertyByValue("GetPropertyByValue", 0, 5, ArgumentsOrder::DEFAULT_ORDER,
725 VariableType::JS_ANY());
726 *callSign = getPropertyByValue;
727 // 5 : 5 input parameters
728 std::array<VariableType, 5> params = {
729 VariableType::NATIVE_POINTER(), // glue
730 VariableType::JS_POINTER(), // receiver
731 VariableType::JS_ANY(), // key
732 VariableType::JS_ANY(), // jsFunc
733 VariableType::INT32(), // slot id
734 };
735 callSign->SetParameters(params.data());
736 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
737 }
738
DEF_CALL_SIGNATURE(DeprecatedGetPropertyByValue)739 DEF_CALL_SIGNATURE(DeprecatedGetPropertyByValue)
740 {
741 // 3 : 3 input parameters
742 CallSignature getPropertyByValue("DeprecatedGetPropertyByValue", 0, 3, ArgumentsOrder::DEFAULT_ORDER,
743 VariableType::JS_ANY());
744 *callSign = getPropertyByValue;
745 // 3 : 3 input parameters
746 std::array<VariableType, 3> params = {
747 VariableType::NATIVE_POINTER(),
748 VariableType::JS_POINTER(),
749 VariableType::JS_ANY(),
750 };
751 callSign->SetParameters(params.data());
752 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
753 }
754
DEF_CALL_SIGNATURE(TryLoadICByName)755 DEF_CALL_SIGNATURE(TryLoadICByName)
756 {
757 // 4 : 4 input parameters
758 CallSignature tryLoadICByName("TryLoadICByName", 0, 4,
759 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
760 *callSign = tryLoadICByName;
761 // 4 : 4 input parameters
762 std::array<VariableType, 4> params = {
763 VariableType::NATIVE_POINTER(),
764 VariableType::JS_ANY(),
765 VariableType::JS_ANY(),
766 VariableType::JS_ANY(),
767 };
768 callSign->SetParameters(params.data());
769 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
770 }
771
DEF_CALL_SIGNATURE(TryLoadICByValue)772 DEF_CALL_SIGNATURE(TryLoadICByValue)
773 {
774 // 5 : 5 input parameters
775 CallSignature tryLoadICByValue("TryLoadICByValue", 0, 5,
776 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
777 *callSign = tryLoadICByValue;
778 // 5 : 5 input parameters
779 std::array<VariableType, 5> params = {
780 VariableType::NATIVE_POINTER(),
781 VariableType::JS_ANY(),
782 VariableType::JS_ANY(),
783 VariableType::JS_ANY(),
784 VariableType::JS_ANY(),
785 };
786 callSign->SetParameters(params.data());
787 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
788 }
789
DEF_CALL_SIGNATURE(TryStoreICByName)790 DEF_CALL_SIGNATURE(TryStoreICByName)
791 {
792 // 5 : 5 input parameters
793 CallSignature tryStoreICByName("TryStoreICByName", 0, 5,
794 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); // undefined or hole
795 *callSign = tryStoreICByName;
796 // 5 : 5 input parameters
797 std::array<VariableType, 5> params = {
798 VariableType::NATIVE_POINTER(),
799 VariableType::JS_POINTER(),
800 VariableType::JS_ANY(),
801 VariableType::JS_ANY(),
802 VariableType::JS_POINTER(),
803 };
804 callSign->SetParameters(params.data());
805 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
806 }
807
DEF_CALL_SIGNATURE(TryStoreICByValue)808 DEF_CALL_SIGNATURE(TryStoreICByValue)
809 {
810 // 6 : 6 input parameters
811 CallSignature tryStoreICByValue("TryStoreICByValue", 0, 6,
812 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); // undefined or hole
813 *callSign = tryStoreICByValue;
814 // 6 : 6 input parameters
815 std::array<VariableType, 6> params = {
816 VariableType::NATIVE_POINTER(),
817 VariableType::JS_POINTER(),
818 VariableType::JS_ANY(),
819 VariableType::JS_ANY(),
820 VariableType::JS_ANY(),
821 VariableType::JS_POINTER(),
822 };
823 callSign->SetParameters(params.data());
824 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
825 }
826
827 #define SETVALUEBARRIER_CALL_ARGS_SIGNATURE_COMMON(name) \
828 /* 6 : 4 input parameters + 2 fake parameter */ \
829 CallSignature signature(#name, 0, 6, \
830 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID()); \
831 *callSign = signature; \
832 /* 6 : 4 input parameters + 2 fake parameter */ \
833 std::array<VariableType, 6> params = { \
834 VariableType::NATIVE_POINTER(), \
835 VariableType::JS_POINTER(), \
836 VariableType::NATIVE_POINTER(), \
837 VariableType::JS_ANY(), \
838 VariableType::INT64(), \
839 VariableType::INT64(), \
840 }; \
841 callSign->SetParameters(params.data()); \
842 callSign->SetGCLeafFunction(true); \
843 callSign->SetCallConv(CallSignature::CallConv::CCallConv); \
844 \
845 std::vector<CallSignature::ParamAttr> paramAttrs = { \
846 CallSignature::ParamAttr::NoAttr, \
847 CallSignature::ParamAttr::NoAttr, \
848 CallSignature::ParamAttr::NoAttr, \
849 CallSignature::ParamAttr::NoAttr, \
850 CallSignature::ParamAttr::Dead, \
851 CallSignature::ParamAttr::Dead, \
852 }; \
853 callSign->SetParamAttr(std::move(paramAttrs))
854
DEF_CALL_SIGNATURE(SetValueWithBarrier)855 DEF_CALL_SIGNATURE(SetValueWithBarrier)
856 {
857 SETVALUEBARRIER_CALL_ARGS_SIGNATURE_COMMON(SetValueWithBarrier);
858 }
859
DEF_CALL_SIGNATURE(SetNonSValueWithBarrier)860 DEF_CALL_SIGNATURE(SetNonSValueWithBarrier)
861 {
862 SETVALUEBARRIER_CALL_ARGS_SIGNATURE_COMMON(SetNonSValueWithBarrier);
863 }
864
DEF_CALL_SIGNATURE(SetSValueWithBarrier)865 DEF_CALL_SIGNATURE(SetSValueWithBarrier)
866 {
867 SETVALUEBARRIER_CALL_ARGS_SIGNATURE_COMMON(SetSValueWithBarrier);
868 }
869
DEF_CALL_SIGNATURE(ASMFastWriteBarrier)870 DEF_CALL_SIGNATURE(ASMFastWriteBarrier)
871 {
872 SETVALUEBARRIER_CALL_ARGS_SIGNATURE_COMMON(ASMFastWriteBarrier);
873 callSign->SetTargetKind(CallSignature::TargetKind::ASM_CALL_BARRIER_STUB);
874 }
875
DEF_CALL_SIGNATURE(VerifyBarrier)876 DEF_CALL_SIGNATURE(VerifyBarrier)
877 {
878 SETVALUEBARRIER_CALL_ARGS_SIGNATURE_COMMON(VerifyBarrier);
879 }
880
881 #undef SETVALUEBARRIER_CALL_ARGS_SIGNATURE_COMMON
882
DEF_CALL_SIGNATURE(NewThisObjectChecked)883 DEF_CALL_SIGNATURE(NewThisObjectChecked)
884 {
885 // 2 : 2 input parameters
886 CallSignature signature("NewThisObjectChecked", 0, 2,
887 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
888 *callSign = signature;
889 // 2 : 2 input parameters
890 std::array<VariableType, 2> params = {
891 VariableType::NATIVE_POINTER(), // glue
892 VariableType::JS_ANY(), // ctor
893 };
894 callSign->SetParameters(params.data());
895 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
896 }
897
DEF_CALL_SIGNATURE(ConstructorCheck)898 DEF_CALL_SIGNATURE(ConstructorCheck)
899 {
900 // 4 : 4 input parameters
901 CallSignature signature("ConstructorCheck", 0, 4,
902 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
903 *callSign = signature;
904 // 4 : 4 input parameters
905 std::array<VariableType, 4> params = {
906 VariableType::NATIVE_POINTER(), // glue
907 VariableType::JS_ANY(), // ctor
908 VariableType::JS_ANY(), // result
909 VariableType::JS_ANY(), // thisObj
910 };
911 callSign->SetParameters(params.data());
912 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
913 }
914
DEF_CALL_SIGNATURE(CreateEmptyArray)915 DEF_CALL_SIGNATURE(CreateEmptyArray)
916 {
917 // 5 : 5 input parameters
918 CallSignature signature("CreateEmptyArray", 0, 5,
919 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
920 *callSign = signature;
921 // 5 : 5 input parameters
922 std::array<VariableType, 5> params = {
923 VariableType::NATIVE_POINTER(), // glue
924 VariableType::JS_ANY(), // jsFunc
925 VariableType::JS_ANY(), // pc
926 VariableType::INT32(), // profileTypeInfo
927 VariableType::INT32(), // slotId
928 };
929 callSign->SetParameters(params.data());
930 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
931 }
932
DEF_CALL_SIGNATURE(CreateArrayWithBuffer)933 DEF_CALL_SIGNATURE(CreateArrayWithBuffer)
934 {
935 // 6 : 6 input parameters
936 CallSignature signature("CreateArrayWithBuffer", 0, 6,
937 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
938 *callSign = signature;
939 // 6 : 6 input parameters
940 std::array<VariableType, 6> params = {
941 VariableType::NATIVE_POINTER(), // glue
942 VariableType::INT32(), // index
943 VariableType::JS_ANY(), // jsFunc
944 VariableType::JS_ANY(), // pc
945 VariableType::INT32(), // profileTypeInfo
946 VariableType::INT32(), // slotId
947 };
948 callSign->SetParameters(params.data());
949 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
950 }
951
DEF_CALL_SIGNATURE(CreateObjectHavingMethod)952 DEF_CALL_SIGNATURE(CreateObjectHavingMethod)
953 {
954 // 3 : 3 input parameters
955 CallSignature signature("CreateObjectHavingMethod", 0, 3,
956 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
957 *callSign = signature;
958 // 3 : 3 input parameters
959 std::array<VariableType, 3> params = {
960 VariableType::NATIVE_POINTER(), // glue
961 VariableType::JS_ANY(), // obj
962 VariableType::JS_ANY(), // levEnv
963 };
964 callSign->SetParameters(params.data());
965 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
966 }
967
DEF_CALL_SIGNATURE(CopyRestArgs)968 DEF_CALL_SIGNATURE(CopyRestArgs)
969 {
970 // 5 : 5 input parameters
971 CallSignature signature("CopyRestArgs", 0, 5,
972 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
973 *callSign = signature;
974 // 5 : 5 input parameters
975 std::array<VariableType, 5> params = {
976 VariableType::NATIVE_POINTER(), // glue
977 VariableType::NATIVE_POINTER(), // actual argv
978 VariableType::INT32(), // startIdx
979 VariableType::INT32(), // numArgs
980 VariableType::JS_ANY(), // actual argv Array
981 };
982 callSign->SetParameters(params.data());
983 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
984 }
985
DEF_CALL_SIGNATURE(NewJSObject)986 DEF_CALL_SIGNATURE(NewJSObject)
987 {
988 // 2 : 2 input parameters
989 CallSignature signature("NewJSObject", 0, 2,
990 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
991 *callSign = signature;
992 // 2 : 2 input parameters
993 std::array<VariableType, 2> params = {
994 VariableType::NATIVE_POINTER(), // glue
995 VariableType::JS_ANY(), // hclass
996 };
997 callSign->SetParameters(params.data());
998 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
999 }
1000
DEF_CALL_SIGNATURE(NewLexicalEnv)1001 DEF_CALL_SIGNATURE(NewLexicalEnv)
1002 {
1003 // 3 : 3 input parameters
1004 CallSignature signature("NewLexicalEnv", 0, 3,
1005 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1006 *callSign = signature;
1007 // 3 : 3 input parameters
1008 std::array<VariableType, 3> params = {
1009 VariableType::NATIVE_POINTER(), // glue
1010 VariableType::JS_ANY(), // parent
1011 VariableType::INT32(), // numArgs
1012 };
1013 callSign->SetParameters(params.data());
1014 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1015 }
1016
DEF_CALL_SIGNATURE(GetUnmappedArgs)1017 DEF_CALL_SIGNATURE(GetUnmappedArgs)
1018 {
1019 // 4 : 4 input parameters
1020 CallSignature signature("GetUnmappedArgs", 0, 4,
1021 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1022 *callSign = signature;
1023 // 4 : 4 input parameters
1024 std::array<VariableType, 4> params = {
1025 VariableType::NATIVE_POINTER(), // glue
1026 VariableType::NATIVE_POINTER(), // actual argv
1027 VariableType::INT32(), // numArgs
1028 VariableType::JS_ANY(), // actual argv Array
1029 };
1030 callSign->SetParameters(params.data());
1031 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1032 }
1033
DEF_CALL_SIGNATURE(GetCallSpreadArgs)1034 DEF_CALL_SIGNATURE(GetCallSpreadArgs)
1035 {
1036 // 2 : 2 input parameters
1037 CallSignature signature("GetCallSpreadArgs", 0, 2,
1038 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1039 *callSign = signature;
1040 // 2 : 2 input parameters
1041 std::array<VariableType, 2> params = {
1042 VariableType::NATIVE_POINTER(), // glue
1043 VariableType::JS_ANY(), // array
1044 };
1045 callSign->SetParameters(params.data());
1046 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1047 }
1048
DEF_CALL_SIGNATURE(GetTaggedArrayPtrTest)1049 DEF_CALL_SIGNATURE(GetTaggedArrayPtrTest)
1050 {
1051 // 2 : 2 input parameters
1052 CallSignature getTaggedArrayPtr("GetTaggedArrayPtrTest", 0, 2, ArgumentsOrder::DEFAULT_ORDER,
1053 VariableType::JS_POINTER());
1054 *callSign = getTaggedArrayPtr;
1055 // 2 : 2 input parameters
1056 std::array<VariableType, 2> params = {
1057 VariableType::NATIVE_POINTER(),
1058 VariableType::JS_ANY(),
1059 };
1060 callSign->SetParameters(params.data());
1061 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
1062 }
1063
DEF_CALL_SIGNATURE(Builtins)1064 DEF_CALL_SIGNATURE(Builtins)
1065 {
1066 // 9 : 9 input parameters
1067 CallSignature builtins("Builtins", 0, 9,
1068 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1069 *callSign = builtins;
1070 std::array<VariableType, 9> params = { // 9 : 9 input parameters
1071 VariableType::NATIVE_POINTER(), // glue
1072 VariableType::NATIVE_POINTER(), // native code
1073 VariableType::JS_ANY(), // func
1074 VariableType::JS_ANY(), // new target
1075 VariableType::JS_ANY(), // this
1076 VariableType::NATIVE_POINTER(), // argc
1077 VariableType::JS_ANY(), // arg0
1078 VariableType::JS_ANY(), // arg1
1079 VariableType::JS_ANY(), // arg2
1080 };
1081 #if ENABLE_NEXT_OPTIMIZATION
1082 callSign->SetVariadicArgs(false);
1083 #else
1084 callSign->SetVariadicArgs(true);
1085 #endif
1086 callSign->SetParameters(params.data());
1087 callSign->SetTargetKind(CallSignature::TargetKind::BUILTINS_STUB);
1088 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1089 }
1090
DEF_CALL_SIGNATURE(BuiltinsWithArgv)1091 DEF_CALL_SIGNATURE(BuiltinsWithArgv)
1092 {
1093 // 7 : 7 input parameters
1094 CallSignature builtinsWtihArgv("BuiltinsWithArgv", 0, 7,
1095 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1096 *callSign = builtinsWtihArgv;
1097 std::array<VariableType, 7> params = { // 7 : 7 input parameters
1098 VariableType::NATIVE_POINTER(), // glue
1099 VariableType::NATIVE_POINTER(), // nativeCode
1100 VariableType::JS_ANY(), // func
1101 VariableType::JS_ANY(), // new target
1102 VariableType::JS_ANY(), // this
1103 VariableType::NATIVE_POINTER(), // argc
1104 VariableType::NATIVE_POINTER(), // argv
1105 };
1106 callSign->SetParameters(params.data());
1107 callSign->SetTargetKind(CallSignature::TargetKind::BUILTINS_WITH_ARGV_STUB);
1108 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1109 }
1110
DEF_CALL_SIGNATURE(BytecodeHandler)1111 DEF_CALL_SIGNATURE(BytecodeHandler)
1112 {
1113 // 7 : 7 input parameters
1114 CallSignature bytecodeHandler("BytecodeHandler", 0, 7,
1115 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1116 *callSign = bytecodeHandler;
1117 // 7 : 7 input parameters
1118 std::array<VariableType, 7> params = {
1119 VariableType::NATIVE_POINTER(),
1120 VariableType::NATIVE_POINTER(),
1121 VariableType::NATIVE_POINTER(),
1122 VariableType::JS_POINTER(),
1123 VariableType::JS_POINTER(),
1124 VariableType::JS_ANY(),
1125 VariableType::INT32(),
1126 };
1127 callSign->SetParameters(params.data());
1128 callSign->SetTargetKind(CallSignature::TargetKind::BYTECODE_HANDLER);
1129 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
1130 }
1131
DEF_CALL_SIGNATURE(BytecodeDebuggerHandler)1132 DEF_CALL_SIGNATURE(BytecodeDebuggerHandler)
1133 {
1134 // 7 : 7 input parameters
1135 CallSignature bytecodeHandler("BytecodeDebuggerHandler", 0, 7,
1136 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1137 *callSign = bytecodeHandler;
1138 // 7 : 7 input parameters
1139 std::array<VariableType, 7> params = { VariableType::NATIVE_POINTER(),
1140 VariableType::NATIVE_POINTER(),
1141 VariableType::NATIVE_POINTER(),
1142 VariableType::JS_POINTER(),
1143 VariableType::JS_POINTER(),
1144 VariableType::JS_ANY(),
1145 VariableType::INT32() };
1146 callSign->SetParameters(params.data());
1147 callSign->SetTargetKind(CallSignature::TargetKind::BYTECODE_DEBUGGER_HANDLER);
1148 }
1149
DEF_CALL_SIGNATURE(CallRuntime)1150 DEF_CALL_SIGNATURE(CallRuntime)
1151 {
1152 /* 3 : 3 input parameters */
1153 CallSignature runtimeCallTrampoline("CallRuntime", 0, 3,
1154 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1155 *callSign = runtimeCallTrampoline;
1156 /* 3 : 3 input parameters */
1157 std::array<VariableType, 3> params = {
1158 VariableType::NATIVE_POINTER(),
1159 VariableType::INT64(),
1160 VariableType::INT64(),
1161 };
1162 callSign->SetVariadicArgs(true);
1163 callSign->SetParameters(params.data());
1164 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
1165 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1166 }
1167
DEF_CALL_SIGNATURE(AsmInterpreterEntry)1168 DEF_CALL_SIGNATURE(AsmInterpreterEntry)
1169 {
1170 /* 3 : 3 input parameters */
1171 CallSignature asmInterpreterEntry("AsmInterpreterEntry", 0, 3,
1172 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1173 *callSign = asmInterpreterEntry;
1174 /* 3 : 3 input parameters */
1175 std::array<VariableType, 3> params = {
1176 VariableType::NATIVE_POINTER(), // glue
1177 VariableType::INT32(), // argc
1178 VariableType::NATIVE_POINTER(), // argv
1179 };
1180 callSign->SetParameters(params.data());
1181 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1182 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1183 }
1184
1185 #define BASELINE_CALL_ARGS_SIGNATURE_COMMON(name) \
1186 /* 1 : 1 input parameters */ \
1187 CallSignature signature(#name, 0, 1, \
1188 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); \
1189 *callSign = signature; \
1190 std::array<VariableType, 1> params = { /* 1: 1 input parameters */ \
1191 VariableType::NATIVE_POINTER(), \
1192 }; \
1193 callSign->SetVariadicArgs(true); \
1194 callSign->SetParameters(params.data()); \
1195 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC); \
1196 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
1197
DEF_CALL_SIGNATURE(CallArg0AndCheckToBaseline)1198 DEF_CALL_SIGNATURE(CallArg0AndCheckToBaseline)
1199 {
1200 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallArg0AndCheckToBaseline)
1201 }
1202
DEF_CALL_SIGNATURE(CallArg1AndCheckToBaseline)1203 DEF_CALL_SIGNATURE(CallArg1AndCheckToBaseline)
1204 {
1205 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallArg1AndCheckToBaseline)
1206 }
1207
DEF_CALL_SIGNATURE(CallArgs2AndCheckToBaseline)1208 DEF_CALL_SIGNATURE(CallArgs2AndCheckToBaseline)
1209 {
1210 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallArgs2AndCheckToBaseline)
1211 }
1212
DEF_CALL_SIGNATURE(CallArgs3AndCheckToBaseline)1213 DEF_CALL_SIGNATURE(CallArgs3AndCheckToBaseline)
1214 {
1215 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallArgs3AndCheckToBaseline)
1216 }
1217
DEF_CALL_SIGNATURE(CallThisArg0AndCheckToBaseline)1218 DEF_CALL_SIGNATURE(CallThisArg0AndCheckToBaseline)
1219 {
1220 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallThisArg0AndCheckToBaseline)
1221 }
1222
DEF_CALL_SIGNATURE(CallThisArg1AndCheckToBaseline)1223 DEF_CALL_SIGNATURE(CallThisArg1AndCheckToBaseline)
1224 {
1225 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallThisArg1AndCheckToBaseline)
1226 }
1227
DEF_CALL_SIGNATURE(CallThisArgs2AndCheckToBaseline)1228 DEF_CALL_SIGNATURE(CallThisArgs2AndCheckToBaseline)
1229 {
1230 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallThisArgs2AndCheckToBaseline)
1231 }
1232
DEF_CALL_SIGNATURE(CallThisArgs3AndCheckToBaseline)1233 DEF_CALL_SIGNATURE(CallThisArgs3AndCheckToBaseline)
1234 {
1235 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallThisArgs3AndCheckToBaseline)
1236 }
1237
DEF_CALL_SIGNATURE(CallRangeAndCheckToBaseline)1238 DEF_CALL_SIGNATURE(CallRangeAndCheckToBaseline)
1239 {
1240 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallRangeAndCheckToBaseline)
1241 }
1242
DEF_CALL_SIGNATURE(CallNewAndCheckToBaseline)1243 DEF_CALL_SIGNATURE(CallNewAndCheckToBaseline)
1244 {
1245 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallNewAndCheckToBaseline)
1246 }
1247
DEF_CALL_SIGNATURE(SuperCallAndCheckToBaseline)1248 DEF_CALL_SIGNATURE(SuperCallAndCheckToBaseline)
1249 {
1250 BASELINE_CALL_ARGS_SIGNATURE_COMMON(SuperCallAndCheckToBaseline)
1251 }
1252
DEF_CALL_SIGNATURE(CallThisRangeAndCheckToBaseline)1253 DEF_CALL_SIGNATURE(CallThisRangeAndCheckToBaseline)
1254 {
1255 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallThisRangeAndCheckToBaseline)
1256 }
1257
DEF_CALL_SIGNATURE(CallArg0AndDispatchFromBaseline)1258 DEF_CALL_SIGNATURE(CallArg0AndDispatchFromBaseline)
1259 {
1260 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallArg0AndDispatchFromBaseline)
1261 }
1262
DEF_CALL_SIGNATURE(CallArg1AndDispatchFromBaseline)1263 DEF_CALL_SIGNATURE(CallArg1AndDispatchFromBaseline)
1264 {
1265 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallArg1AndDispatchFromBaseline)
1266 }
1267
DEF_CALL_SIGNATURE(CallArgs2AndDispatchFromBaseline)1268 DEF_CALL_SIGNATURE(CallArgs2AndDispatchFromBaseline)
1269 {
1270 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallArgs2AndDispatchFromBaseline)
1271 }
1272
DEF_CALL_SIGNATURE(CallArgs3AndDispatchFromBaseline)1273 DEF_CALL_SIGNATURE(CallArgs3AndDispatchFromBaseline)
1274 {
1275 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallArgs3AndDispatchFromBaseline)
1276 }
1277
DEF_CALL_SIGNATURE(CallThisArg0AndDispatchFromBaseline)1278 DEF_CALL_SIGNATURE(CallThisArg0AndDispatchFromBaseline)
1279 {
1280 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallThisArg0AndDispatchFromBaseline)
1281 }
1282
DEF_CALL_SIGNATURE(CallThisArg1AndDispatchFromBaseline)1283 DEF_CALL_SIGNATURE(CallThisArg1AndDispatchFromBaseline)
1284 {
1285 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallThisArg1AndDispatchFromBaseline)
1286 }
1287
DEF_CALL_SIGNATURE(CallThisArgs2AndDispatchFromBaseline)1288 DEF_CALL_SIGNATURE(CallThisArgs2AndDispatchFromBaseline)
1289 {
1290 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallThisArgs2AndDispatchFromBaseline)
1291 }
1292
DEF_CALL_SIGNATURE(CallThisArgs3AndDispatchFromBaseline)1293 DEF_CALL_SIGNATURE(CallThisArgs3AndDispatchFromBaseline)
1294 {
1295 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallThisArgs3AndDispatchFromBaseline)
1296 }
1297
DEF_CALL_SIGNATURE(CallRangeAndDispatchFromBaseline)1298 DEF_CALL_SIGNATURE(CallRangeAndDispatchFromBaseline)
1299 {
1300 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallRangeAndDispatchFromBaseline)
1301 }
1302
DEF_CALL_SIGNATURE(CallNewAndDispatchFromBaseline)1303 DEF_CALL_SIGNATURE(CallNewAndDispatchFromBaseline)
1304 {
1305 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallNewAndDispatchFromBaseline)
1306 }
1307
DEF_CALL_SIGNATURE(SuperCallAndDispatchFromBaseline)1308 DEF_CALL_SIGNATURE(SuperCallAndDispatchFromBaseline)
1309 {
1310 BASELINE_CALL_ARGS_SIGNATURE_COMMON(SuperCallAndDispatchFromBaseline)
1311 }
1312
DEF_CALL_SIGNATURE(CallThisRangeAndDispatchFromBaseline)1313 DEF_CALL_SIGNATURE(CallThisRangeAndDispatchFromBaseline)
1314 {
1315 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallThisRangeAndDispatchFromBaseline)
1316 }
1317
DEF_CALL_SIGNATURE(CallArg0AndCheckToBaselineFromBaseline)1318 DEF_CALL_SIGNATURE(CallArg0AndCheckToBaselineFromBaseline)
1319 {
1320 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallArg0AndCheckToBaselineFromBaseline)
1321 }
1322
DEF_CALL_SIGNATURE(CallArg1AndCheckToBaselineFromBaseline)1323 DEF_CALL_SIGNATURE(CallArg1AndCheckToBaselineFromBaseline)
1324 {
1325 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallArg1AndCheckToBaselineFromBaseline)
1326 }
1327
DEF_CALL_SIGNATURE(CallArgs2AndCheckToBaselineFromBaseline)1328 DEF_CALL_SIGNATURE(CallArgs2AndCheckToBaselineFromBaseline)
1329 {
1330 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallArgs2AndCheckToBaselineFromBaseline)
1331 }
1332
DEF_CALL_SIGNATURE(CallArgs3AndCheckToBaselineFromBaseline)1333 DEF_CALL_SIGNATURE(CallArgs3AndCheckToBaselineFromBaseline)
1334 {
1335 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallArgs3AndCheckToBaselineFromBaseline)
1336 }
1337
DEF_CALL_SIGNATURE(CallThisArg0AndCheckToBaselineFromBaseline)1338 DEF_CALL_SIGNATURE(CallThisArg0AndCheckToBaselineFromBaseline)
1339 {
1340 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallThisArg0AndCheckToBaselineFromBaseline)
1341 }
1342
DEF_CALL_SIGNATURE(CallThisArg1AndCheckToBaselineFromBaseline)1343 DEF_CALL_SIGNATURE(CallThisArg1AndCheckToBaselineFromBaseline)
1344 {
1345 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallThisArg1AndCheckToBaselineFromBaseline)
1346 }
1347
DEF_CALL_SIGNATURE(CallThisArgs2AndCheckToBaselineFromBaseline)1348 DEF_CALL_SIGNATURE(CallThisArgs2AndCheckToBaselineFromBaseline)
1349 {
1350 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallThisArgs2AndCheckToBaselineFromBaseline)
1351 }
1352
DEF_CALL_SIGNATURE(CallThisArgs3AndCheckToBaselineFromBaseline)1353 DEF_CALL_SIGNATURE(CallThisArgs3AndCheckToBaselineFromBaseline)
1354 {
1355 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallThisArgs3AndCheckToBaselineFromBaseline)
1356 }
1357
DEF_CALL_SIGNATURE(CallRangeAndCheckToBaselineFromBaseline)1358 DEF_CALL_SIGNATURE(CallRangeAndCheckToBaselineFromBaseline)
1359 {
1360 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallRangeAndCheckToBaselineFromBaseline)
1361 }
1362
DEF_CALL_SIGNATURE(CallNewAndCheckToBaselineFromBaseline)1363 DEF_CALL_SIGNATURE(CallNewAndCheckToBaselineFromBaseline)
1364 {
1365 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallNewAndCheckToBaselineFromBaseline)
1366 }
1367
DEF_CALL_SIGNATURE(SuperCallAndCheckToBaselineFromBaseline)1368 DEF_CALL_SIGNATURE(SuperCallAndCheckToBaselineFromBaseline)
1369 {
1370 BASELINE_CALL_ARGS_SIGNATURE_COMMON(SuperCallAndCheckToBaselineFromBaseline)
1371 }
1372
DEF_CALL_SIGNATURE(CallThisRangeAndCheckToBaselineFromBaseline)1373 DEF_CALL_SIGNATURE(CallThisRangeAndCheckToBaselineFromBaseline)
1374 {
1375 BASELINE_CALL_ARGS_SIGNATURE_COMMON(CallThisRangeAndCheckToBaselineFromBaseline)
1376 }
1377
DEF_CALL_SIGNATURE(GetBaselineBuiltinFp)1378 DEF_CALL_SIGNATURE(GetBaselineBuiltinFp)
1379 {
1380 /* 1 : 1 input parameters */
1381 CallSignature getBaselineBuiltinFp("GetBaselineBuiltinFp", 0, 1,
1382 ArgumentsOrder::DEFAULT_ORDER, VariableType::NATIVE_POINTER());
1383 *callSign = getBaselineBuiltinFp;
1384 std::array<VariableType, 1> params = { /* 1 : 1 input parameters */
1385 VariableType::NATIVE_POINTER(), // glue
1386 };
1387 callSign->SetVariadicArgs(true);
1388 callSign->SetParameters(params.data());
1389 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1390 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1391 }
1392
DEF_CALL_SIGNATURE(GeneratorReEnterAsmInterp)1393 DEF_CALL_SIGNATURE(GeneratorReEnterAsmInterp)
1394 {
1395 /* 2 : 2 input parameters */
1396 CallSignature generatorReEnterAsmInterp("GeneratorReEnterAsmInterp", 0, 2,
1397 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1398 *callSign = generatorReEnterAsmInterp;
1399 std::array<VariableType, 2> params = { /* 2 : 2 input parameters */
1400 VariableType::NATIVE_POINTER(), // glue
1401 VariableType::JS_POINTER(), // context
1402 };
1403 callSign->SetParameters(params.data());
1404 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1405 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1406 }
1407
DEF_CALL_SIGNATURE(CallRuntimeWithArgv)1408 DEF_CALL_SIGNATURE(CallRuntimeWithArgv)
1409 {
1410 /* 4 : 4 input parameters */
1411 CallSignature runtimeCallTrampoline("CallRuntimeWithArgv", 0, 4,
1412 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1413 *callSign = runtimeCallTrampoline;
1414 std::array<VariableType, 4> params = { /* 4 : 4 input parameters */
1415 VariableType::NATIVE_POINTER(), // glue
1416 VariableType::INT64(), // runtimeId
1417 VariableType::INT64(), // argc
1418 VariableType::NATIVE_POINTER(), // argv
1419 };
1420 callSign->SetVariadicArgs(false);
1421 callSign->SetParameters(params.data());
1422 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_VARARGS);
1423 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1424 }
1425
1426 #define AOT_CALL_SIGNATURE(name) \
1427 /* 6 : 6 input parameters */ \
1428 CallSignature signature(#name, 0, 6, \
1429 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); \
1430 *callSign = signature; \
1431 std::array<VariableType, 6> params = { /* 6 : 6 input parameters */ \
1432 VariableType::NATIVE_POINTER(), /* glue */ \
1433 VariableType::INT64(), /* actual argC */ \
1434 VariableType::NATIVE_POINTER(), /* actual argV */ \
1435 VariableType::JS_ANY(), /* call target */ \
1436 VariableType::JS_ANY(), /* new target */ \
1437 VariableType::JS_ANY(), /* thisobj */ \
1438 }; \
1439 callSign->SetVariadicArgs(true); \
1440 callSign->SetParameters(params.data()); \
1441 callSign->SetCallConv(CallSignature::CallConv::WebKitJSCallConv);
1442
1443 #define FAST_AOT_CALL_SIGNATURE(name) \
1444 /* 3 : 3 input parameters */ \
1445 CallSignature signature(#name, 0, 3, \
1446 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); \
1447 *callSign = signature; \
1448 std::array<VariableType, 3> params = { /* 3 : 3 input parameters */ \
1449 VariableType::NATIVE_POINTER(), /* glue */ \
1450 VariableType::JS_ANY(), /* call target */ \
1451 VariableType::JS_ANY(), /* thisobj */ \
1452 }; \
1453 callSign->SetVariadicArgs(true); \
1454 callSign->SetParameters(params.data()); \
1455 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1456
DEF_CALL_SIGNATURE(OptimizedCallAndPushArgv)1457 DEF_CALL_SIGNATURE(OptimizedCallAndPushArgv)
1458 {
1459 AOT_CALL_SIGNATURE(OptimizedCallAndPushArgv)
1460 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1461 }
1462
DEF_CALL_SIGNATURE(OptimizedFastCallAndPushArgv)1463 DEF_CALL_SIGNATURE(OptimizedFastCallAndPushArgv)
1464 {
1465 /* 6 : 6 input parameters */
1466 CallSignature optimizedFastCallAndPushArgv("OptimizedFastCallAndPushArgv", 0, 6,
1467 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1468 *callSign = optimizedFastCallAndPushArgv;
1469 std::array<VariableType, 6> params = { /* 6 : 6 input parameters */
1470 VariableType::NATIVE_POINTER(), // glue
1471 VariableType::INT64(), // actual argC
1472 VariableType::NATIVE_POINTER(), // actual argV
1473 VariableType::JS_ANY(), // call target
1474 VariableType::JS_ANY(), // new target
1475 VariableType::JS_ANY(), // thisobj
1476 };
1477 callSign->SetVariadicArgs(true);
1478 callSign->SetParameters(params.data());
1479 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1480 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1481 }
1482
DEF_CALL_SIGNATURE(JSCall)1483 DEF_CALL_SIGNATURE(JSCall)
1484 {
1485 AOT_CALL_SIGNATURE(JSCall)
1486 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1487 }
1488
DEF_CALL_SIGNATURE(JSOptimizedCall)1489 DEF_CALL_SIGNATURE(JSOptimizedCall)
1490 {
1491 AOT_CALL_SIGNATURE(JSOptimizedCall)
1492 callSign->SetTargetKind(CallSignature::TargetKind::OPTIMIZED_STUB);
1493 }
1494
DEF_CALL_SIGNATURE(JSCallNew)1495 DEF_CALL_SIGNATURE(JSCallNew)
1496 {
1497 AOT_CALL_SIGNATURE(JSCallNew)
1498 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1499 }
1500
DEF_CALL_SIGNATURE(JSOptimizedFastCall)1501 DEF_CALL_SIGNATURE(JSOptimizedFastCall)
1502 {
1503 FAST_AOT_CALL_SIGNATURE(JSOptimizedFastCall)
1504 callSign->SetTargetKind(CallSignature::TargetKind::OPTIMIZED_FAST_CALL_STUB);
1505 }
1506
DEF_CALL_SIGNATURE(AOTCallToAsmInterBridge)1507 DEF_CALL_SIGNATURE(AOTCallToAsmInterBridge)
1508 {
1509 AOT_CALL_SIGNATURE(AOTCallToAsmInterBridge)
1510 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1511 }
1512
DEF_CALL_SIGNATURE(FastCallToAsmInterBridge)1513 DEF_CALL_SIGNATURE(FastCallToAsmInterBridge)
1514 {
1515 FAST_AOT_CALL_SIGNATURE(FastCallToAsmInterBridge)
1516 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1517 }
1518
DEF_CALL_SIGNATURE(JSProxyCallInternalWithArgV)1519 DEF_CALL_SIGNATURE(JSProxyCallInternalWithArgV)
1520 {
1521 // 2 : 2 input parameters
1522 CallSignature jSProxyCallInternalWithArgV("JSProxyCallInternalWithArgV", 0, 2,
1523 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1524 *callSign = jSProxyCallInternalWithArgV;
1525 std::array<VariableType, 2> params = { // 2 : 2 input parameters
1526 VariableType::NATIVE_POINTER(), // glue
1527 VariableType::JS_ANY(), // call target
1528 };
1529 callSign->SetParameters(params.data());
1530 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1531 callSign->SetGCLeafFunction(true);
1532 callSign->SetTailCall(true);
1533 }
1534
DEF_CALL_SIGNATURE(JSFunctionEntry)1535 DEF_CALL_SIGNATURE(JSFunctionEntry)
1536 {
1537 // 5 : 5 input parameters
1538 CallSignature jsCallFunctionEntry("JSFunctionEntry", 0, 5,
1539 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1540 *callSign = jsCallFunctionEntry;
1541 std::array<VariableType, 5> params = { // 5 : 5 input parameters
1542 VariableType::NATIVE_POINTER(), // glue
1543 VariableType::INT64(), // argc
1544 VariableType::NATIVE_POINTER(), // argv
1545 VariableType::NATIVE_POINTER(), // prevFp
1546 VariableType::BOOL(), // isNew
1547 };
1548 callSign->SetParameters(params.data());
1549 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1550 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1551 }
1552
DEF_CALL_SIGNATURE(OptimizedFastCallEntry)1553 DEF_CALL_SIGNATURE(OptimizedFastCallEntry)
1554 {
1555 // 4 : 4 input parameters
1556 CallSignature optimizedFastCallEntry("OptimizedFastCallEntry", 0, 4,
1557 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1558 *callSign = optimizedFastCallEntry;
1559 std::array<VariableType, 4> params = { // 4 : 4 input parameters
1560 VariableType::NATIVE_POINTER(), // glue
1561 VariableType::INT64(), // argc
1562 VariableType::NATIVE_POINTER(), // argv
1563 VariableType::NATIVE_POINTER(), // prevFp
1564 };
1565 callSign->SetParameters(params.data());
1566 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1567 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1568 }
1569
DEF_CALL_SIGNATURE(ResumeRspAndDispatch)1570 DEF_CALL_SIGNATURE(ResumeRspAndDispatch)
1571 {
1572 // 8 : 8 input parameters
1573 CallSignature resumeRspAndDispatch("ResumeRspAndDispatch", 0, 8,
1574 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1575 *callSign = resumeRspAndDispatch;
1576 std::array<VariableType, 8> params = { // 8 : 8 input parameters
1577 VariableType::NATIVE_POINTER(),
1578 VariableType::NATIVE_POINTER(),
1579 VariableType::NATIVE_POINTER(),
1580 VariableType::JS_POINTER(),
1581 VariableType::JS_POINTER(),
1582 VariableType::JS_ANY(),
1583 VariableType::INT32(),
1584 VariableType::NATIVE_POINTER(),
1585 };
1586 callSign->SetParameters(params.data());
1587 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1588 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
1589 }
1590
DEF_CALL_SIGNATURE(ResumeRspAndReturn)1591 DEF_CALL_SIGNATURE(ResumeRspAndReturn)
1592 {
1593 // 3 : 3 input parameters
1594 CallSignature resumeRspAndReturn("ResumeRspAndReturn", 0, 3,
1595 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1596 *callSign = resumeRspAndReturn;
1597 std::array<VariableType, 3> params = { // 3 : 3 input parameters
1598 VariableType::JS_ANY(),
1599 VariableType::NATIVE_POINTER(),
1600 VariableType::NATIVE_POINTER(),
1601 };
1602 callSign->SetParameters(params.data());
1603 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1604 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
1605 }
1606
DEF_CALL_SIGNATURE(ResumeRspAndReturnBaseline)1607 DEF_CALL_SIGNATURE(ResumeRspAndReturnBaseline)
1608 {
1609 // 4 : 4 input parameters
1610 CallSignature resumeRspAndReturnBaseline("ResumeRspAndReturnBaseline", 0, 4,
1611 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1612 *callSign = resumeRspAndReturnBaseline;
1613 std::array<VariableType, 4> params = { // 4 : 4 input parameters
1614 VariableType::JS_ANY(), // %r13 - acc
1615 VariableType::NATIVE_POINTER(), // %rbp - prevSp
1616 VariableType::NATIVE_POINTER(), // %r12 - sp
1617 VariableType::NATIVE_POINTER(), // %rbx - jumpSizeAfterCall
1618 };
1619 callSign->SetParameters(params.data());
1620 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1621 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
1622 }
1623
DEF_CALL_SIGNATURE(ResumeCaughtFrameAndDispatch)1624 DEF_CALL_SIGNATURE(ResumeCaughtFrameAndDispatch)
1625 {
1626 // 7 : 7 input parameters
1627 CallSignature resumeCaughtFrameAndDispatch("ResumeCaughtFrameAndDispatch", 0, 7,
1628 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1629 *callSign = resumeCaughtFrameAndDispatch;
1630 // 7 : 7 input parameters
1631 std::array<VariableType, 7> params = {
1632 VariableType::NATIVE_POINTER(),
1633 VariableType::NATIVE_POINTER(),
1634 VariableType::NATIVE_POINTER(),
1635 VariableType::JS_POINTER(),
1636 VariableType::JS_POINTER(),
1637 VariableType::JS_ANY(),
1638 VariableType::INT32(),
1639 };
1640 callSign->SetParameters(params.data());
1641 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1642 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
1643 }
1644
DEF_CALL_SIGNATURE(ResumeUncaughtFrameAndReturn)1645 DEF_CALL_SIGNATURE(ResumeUncaughtFrameAndReturn)
1646 {
1647 // 3 : 3 input parameters
1648 CallSignature resumeUncaughtFrameAndReturn("ResumeUncaughtFrameAndReturn", 0, 3,
1649 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1650 *callSign = resumeUncaughtFrameAndReturn;
1651 std::array<VariableType, 3> params = { // 3 : 3 input parameters
1652 VariableType::NATIVE_POINTER(),
1653 VariableType::NATIVE_POINTER(),
1654 VariableType::JS_ANY(),
1655 };
1656 callSign->SetParameters(params.data());
1657 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1658 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
1659 }
1660
DEF_CALL_SIGNATURE(ResumeRspAndRollback)1661 DEF_CALL_SIGNATURE(ResumeRspAndRollback)
1662 {
1663 // 8 : 8 input parameters
1664 CallSignature resumeRspAndRollback("ResumeRspAndRollback", 0, 8,
1665 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1666 *callSign = resumeRspAndRollback;
1667 std::array<VariableType, 8> params = { // 8 : 8 input parameters
1668 VariableType::NATIVE_POINTER(),
1669 VariableType::NATIVE_POINTER(),
1670 VariableType::NATIVE_POINTER(),
1671 VariableType::JS_POINTER(),
1672 VariableType::JS_POINTER(),
1673 VariableType::JS_ANY(),
1674 VariableType::INT32(),
1675 VariableType::NATIVE_POINTER(),
1676 };
1677 callSign->SetParameters(params.data());
1678 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1679 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
1680 }
1681
DEF_CALL_SIGNATURE(JSHClassFindProtoTransitions)1682 DEF_CALL_SIGNATURE(JSHClassFindProtoTransitions)
1683 {
1684 // 3 : 3 input parameters
1685 CallSignature bigIntSameValueZero("JSHClassFindProtoTransitions", 0, 3,
1686 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1687 *callSign = bigIntSameValueZero;
1688 std::array<VariableType, 3> params = { // 3 : 3 input parameters
1689 VariableType::JS_POINTER(),
1690 VariableType::JS_POINTER(),
1691 VariableType::JS_POINTER(),
1692 };
1693 callSign->SetParameters(params.data());
1694 callSign->SetGCLeafFunction(true);
1695 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1696 }
1697
DEF_CALL_SIGNATURE(FinishObjSizeTracking)1698 DEF_CALL_SIGNATURE(FinishObjSizeTracking)
1699 {
1700 // 1 : 1 input parameters
1701 CallSignature finishObjSizeTracking("FinishObjSizeTracking", 0, 1,
1702 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1703 *callSign = finishObjSizeTracking;
1704 std::array<VariableType, 1> params = { // 1 : 1 input parameters
1705 VariableType::JS_POINTER(),
1706 };
1707 callSign->SetParameters(params.data());
1708 callSign->SetGCLeafFunction(true);
1709 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1710 }
1711
DEF_CALL_SIGNATURE(NumberHelperStringToDouble)1712 DEF_CALL_SIGNATURE(NumberHelperStringToDouble)
1713 {
1714 // 1 : 1 input parameters
1715 CallSignature bigIntSameValueZero("NumberHelperStringToDouble", 0, 1,
1716 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1717 *callSign = bigIntSameValueZero;
1718 std::array<VariableType, 1> params = { // 1 : 1 input parameters
1719 VariableType::JS_POINTER(),
1720 };
1721 callSign->SetParameters(params.data());
1722 callSign->SetGCLeafFunction(true);
1723 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1724 }
1725
DEF_CALL_SIGNATURE(CallBigIntAsIntN)1726 DEF_CALL_SIGNATURE(CallBigIntAsIntN)
1727 {
1728 // 2 : 2 input parameters
1729 CallSignature signature("CallBigIntAsIntN", 0, 2, ArgumentsOrder::DEFAULT_ORDER,
1730 VariableType::JS_POINTER());
1731 *callSign = signature;
1732 std::array<VariableType, 2> params = { // 2 : 2 input parameters
1733 VariableType::FLOAT64(),
1734 VariableType::JS_POINTER()
1735 };
1736 callSign->SetParameters(params.data());
1737 callSign->SetGCLeafFunction(true);
1738 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1739 }
1740
DEF_CALL_SIGNATURE(CallBigIntAsUintN)1741 DEF_CALL_SIGNATURE(CallBigIntAsUintN)
1742 {
1743 // 2 : 2 input parameters
1744 CallSignature signature("CallBigIntAsUintN", 0, 2, ArgumentsOrder::DEFAULT_ORDER,
1745 VariableType::JS_POINTER());
1746 *callSign = signature;
1747 std::array<VariableType, 2> params = { // 2 : 2 input parameters
1748 VariableType::FLOAT64(),
1749 VariableType::JS_POINTER(),
1750 };
1751 callSign->SetParameters(params.data());
1752 callSign->SetGCLeafFunction(true);
1753 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1754 }
1755
DEF_CALL_SIGNATURE(GetStringToListCacheArray)1756 DEF_CALL_SIGNATURE(GetStringToListCacheArray)
1757 {
1758 // 1 : 1 input parameters
1759 CallSignature callSignature("GetStringToListCacheArray", 0, 1,
1760 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1761 *callSign = callSignature;
1762 std::array<VariableType, 1> params = { // 1 : 1 input parameters
1763 VariableType::NATIVE_POINTER(),
1764 };
1765 callSign->SetParameters(params.data());
1766 callSign->SetGCLeafFunction(true);
1767 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1768 }
1769
DEF_CALL_SIGNATURE(BigIntEquals)1770 DEF_CALL_SIGNATURE(BigIntEquals)
1771 {
1772 // 2 : 2 input parameters
1773 CallSignature bigIntEquals("BigIntEquals", 0, 2,
1774 ArgumentsOrder::DEFAULT_ORDER, VariableType::BOOL());
1775 *callSign = bigIntEquals;
1776 std::array<VariableType, 2> params = { // 2 : 2 input parameters
1777 VariableType::JS_POINTER(),
1778 VariableType::JS_POINTER(),
1779 };
1780 callSign->SetParameters(params.data());
1781 callSign->SetGCLeafFunction(true);
1782 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1783 }
1784
DEF_CALL_SIGNATURE(IntLexicographicCompare)1785 DEF_CALL_SIGNATURE(IntLexicographicCompare)
1786 {
1787 // 2 : 2 input parameters
1788 CallSignature intLexicographicCompare("IntLexicographicCompare", 0, 2,
1789 ArgumentsOrder::DEFAULT_ORDER, VariableType::INT32());
1790 *callSign = intLexicographicCompare;
1791 std::array<VariableType, 2> params = { // 2 : 2 input parameters
1792 VariableType::JS_ANY(),
1793 VariableType::JS_ANY()
1794 };
1795 callSign->SetParameters(params.data());
1796 callSign->SetGCLeafFunction(true);
1797 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1798 }
1799
DEF_CALL_SIGNATURE(DoubleLexicographicCompare)1800 DEF_CALL_SIGNATURE(DoubleLexicographicCompare)
1801 {
1802 // 2 : 2 input parameters
1803 CallSignature doubleLexicographicCompare("DoubleLexicographicCompare", 0, 2,
1804 ArgumentsOrder::DEFAULT_ORDER, VariableType::INT32());
1805 *callSign = doubleLexicographicCompare;
1806 std::array<VariableType, 2> params = { // 2 : 2 input parameters
1807 VariableType::JS_ANY(),
1808 VariableType::JS_ANY()
1809 };
1810 callSign->SetParameters(params.data());
1811 callSign->SetGCLeafFunction(true);
1812 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1813 }
1814
DEF_CALL_SIGNATURE(FastArraySortString)1815 DEF_CALL_SIGNATURE(FastArraySortString)
1816 {
1817 // 2 : 2 input parameters
1818 CallSignature fastArraySortString("FastArraySortString", 0, 2,
1819 ArgumentsOrder::DEFAULT_ORDER, VariableType::INT32());
1820 *callSign = fastArraySortString;
1821 std::array<VariableType, 3> params = { // 3 : 3 input parameters
1822 VariableType::NATIVE_POINTER(),
1823 VariableType::JS_ANY(),
1824 VariableType::JS_ANY()
1825 };
1826 callSign->SetParameters(params.data());
1827 callSign->SetGCLeafFunction(true);
1828 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1829 }
1830
DEF_CALL_SIGNATURE(StringToNumber)1831 DEF_CALL_SIGNATURE(StringToNumber)
1832 {
1833 // 4 : 4 input parameters
1834 CallSignature stringToNumber("StringToDoubleWithRadix", 0, 2,
1835 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1836 *callSign = stringToNumber;
1837 std::array<VariableType, 2> params = { // 2 : 2 input parameters
1838 VariableType::JS_POINTER(),
1839 VariableType::INT32(),
1840 };
1841 callSign->SetParameters(params.data());
1842 callSign->SetGCLeafFunction(true);
1843 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1844 }
1845
DEF_CALL_SIGNATURE(ArrayTrim)1846 DEF_CALL_SIGNATURE(ArrayTrim)
1847 {
1848 // 3 : 3 input parameters
1849 CallSignature ArrayTrim("ArrayTrim", 0, 3, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1850 *callSign = ArrayTrim;
1851 std::array<VariableType, 3> params = { // 3 : 3 input parameters
1852 VariableType::NATIVE_POINTER(),
1853 VariableType::JS_POINTER(),
1854 VariableType::INT64()
1855 };
1856 callSign->SetParameters(params.data());
1857 callSign->SetGCLeafFunction(true);
1858 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1859 }
1860
DEF_CALL_SIGNATURE(BigIntSameValueZero)1861 DEF_CALL_SIGNATURE(BigIntSameValueZero)
1862 {
1863 // 1 : 1 input parameters
1864 CallSignature bigIntSameValueZero("BigIntSameValueZero", 0, 2,
1865 ArgumentsOrder::DEFAULT_ORDER, VariableType::BOOL());
1866 *callSign = bigIntSameValueZero;
1867 std::array<VariableType, 2> params = { // 2 : 2 input parameters
1868 VariableType::JS_POINTER(),
1869 VariableType::JS_POINTER(),
1870 };
1871 callSign->SetParameters(params.data());
1872 callSign->SetGCLeafFunction(true);
1873 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1874 }
1875
DEF_CALL_SIGNATURE(StringGetStart)1876 DEF_CALL_SIGNATURE(StringGetStart)
1877 {
1878 CallSignature stringGetStart("StringGetStart", 0, 4, ArgumentsOrder::DEFAULT_ORDER, VariableType::INT32());
1879 *callSign = stringGetStart;
1880 std::array<VariableType, 4> params = { // 4 : four input parameters
1881 VariableType::BOOL(),
1882 VariableType::JS_POINTER(),
1883 VariableType::INT32(),
1884 VariableType::INT32(),
1885 };
1886 callSign->SetParameters(params.data());
1887 callSign->SetGCLeafFunction(true);
1888 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1889 }
1890
DEF_CALL_SIGNATURE(StringGetEnd)1891 DEF_CALL_SIGNATURE(StringGetEnd)
1892 {
1893 CallSignature stringGetEnd("StringGetEnd", 0, 5, ArgumentsOrder::DEFAULT_ORDER, VariableType::INT32());
1894 *callSign = stringGetEnd;
1895 std::array<VariableType, 5> params = { // 5 : five input parameters
1896 VariableType::BOOL(),
1897 VariableType::JS_POINTER(),
1898 VariableType::INT32(),
1899 VariableType::INT32(),
1900 VariableType::INT32(),
1901 };
1902 callSign->SetParameters(params.data());
1903 callSign->SetGCLeafFunction(true);
1904 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1905 }
1906
DEF_CALL_SIGNATURE(ReverseTypedArray)1907 DEF_CALL_SIGNATURE(ReverseTypedArray)
1908 {
1909 CallSignature reverseTypedArray("ReverseTypedArray", 0, 1,
1910 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1911 *callSign = reverseTypedArray;
1912 std::array<VariableType, 1> params = {
1913 VariableType::NATIVE_POINTER(),
1914 };
1915 callSign->SetParameters(params.data());
1916 callSign->SetGCLeafFunction(true);
1917 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1918 }
1919
DEF_CALL_SIGNATURE(ReverseArray)1920 DEF_CALL_SIGNATURE(ReverseArray)
1921 {
1922 constexpr size_t paramCount = 2;
1923 // 3 : 3 input parameters
1924 CallSignature ArrayReverse("ReverseArray", 0, paramCount,
1925 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1926 *callSign = ArrayReverse;
1927 // 3 : 3 input parameters
1928 std::array<VariableType, paramCount> params = {
1929 VariableType::NATIVE_POINTER(),
1930 VariableType::INT32()
1931 };
1932 callSign->SetParameters(params.data());
1933 callSign->SetGCLeafFunction(true);
1934 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1935 }
1936
DEF_CALL_SIGNATURE(SortTypedArray)1937 DEF_CALL_SIGNATURE(SortTypedArray)
1938 {
1939 CallSignature sortTypedArray("SortTypedArray", 0, 1,
1940 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1941 *callSign = sortTypedArray;
1942 std::array<VariableType, 1> params = {
1943 VariableType::NATIVE_POINTER(),
1944 };
1945 callSign->SetParameters(params.data());
1946 callSign->SetGCLeafFunction(true);
1947 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1948 }
1949
DEF_CALL_SIGNATURE(FillObject)1950 DEF_CALL_SIGNATURE(FillObject)
1951 {
1952 constexpr size_t paramCount = 3;
1953 // 3 : 3 input parameters
1954 CallSignature ObjectFill("FillObject", 0, paramCount,
1955 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1956 *callSign = ObjectFill;
1957 // 3 : 3 input parameters
1958 std::array<VariableType, paramCount> params = {
1959 VariableType::NATIVE_POINTER(),
1960 VariableType::JS_ANY(),
1961 VariableType::INT32()
1962 };
1963 callSign->SetParameters(params.data());
1964 callSign->SetGCLeafFunction(true);
1965 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1966 }
1967
DEF_CALL_SIGNATURE(IsFastRegExp)1968 DEF_CALL_SIGNATURE(IsFastRegExp)
1969 {
1970 // 3 : 3 input parameters
1971 CallSignature isFastRegExp("IsFastRegExp", 0, 2,
1972 ArgumentsOrder::DEFAULT_ORDER, VariableType::BOOL());
1973 *callSign = isFastRegExp;
1974 std::array<VariableType, 2> params = { // 2 : 2 input parameters
1975 VariableType::NATIVE_POINTER(),
1976 VariableType::JS_ANY()
1977 };
1978 callSign->SetParameters(params.data());
1979 callSign->SetGCLeafFunction(true);
1980 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1981 }
1982
DEF_CALL_SIGNATURE(LrInt)1983 DEF_CALL_SIGNATURE(LrInt)
1984 {
1985 constexpr size_t paramCount = 1;
1986 // 1 : 1 input parameters
1987 CallSignature lrInt("LrInt", 0, paramCount, ArgumentsOrder::DEFAULT_ORDER, VariableType::INT8());
1988 *callSign = lrInt;
1989 std::array<VariableType, paramCount> params = {
1990 VariableType::FLOAT64(),
1991 };
1992 callSign->SetParameters(params.data());
1993 callSign->SetGCLeafFunction(true);
1994 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1995 }
1996
1997 #define PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE_COMMON(name) \
1998 /* 1 : 1 input parameters */ \
1999 CallSignature signature(#name, 0, 1, \
2000 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); \
2001 *callSign = signature; \
2002 std::array<VariableType, 1> params = { /* 1: 1 input parameters */ \
2003 VariableType::NATIVE_POINTER(), \
2004 }; \
2005 callSign->SetVariadicArgs(true); \
2006 callSign->SetParameters(params.data()); \
2007 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2008
2009 #define PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(name) \
2010 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE_COMMON(name) \
2011 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
2012
2013 #define PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_SIGNATURE(name) \
2014 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE_COMMON(name) \
2015 callSign->SetCallConv(CallSignature::CallConv::WebKitJSCallConv);
2016
2017 #define PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(name) \
2018 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE_COMMON(name) \
2019 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2020
DEF_CALL_SIGNATURE(PushCallArgsAndDispatchNative)2021 DEF_CALL_SIGNATURE(PushCallArgsAndDispatchNative)
2022 {
2023 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_SIGNATURE(PushCallArgsAndDispatchNative)
2024 }
2025
DEF_CALL_SIGNATURE(PushCallArg0AndDispatch)2026 DEF_CALL_SIGNATURE(PushCallArg0AndDispatch)
2027 {
2028 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallArg0AndDispatch)
2029 }
2030
DEF_CALL_SIGNATURE(PushCallArg1AndDispatch)2031 DEF_CALL_SIGNATURE(PushCallArg1AndDispatch)
2032 {
2033 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallArg1AndDispatch)
2034 }
2035
DEF_CALL_SIGNATURE(PushCallArgs2AndDispatch)2036 DEF_CALL_SIGNATURE(PushCallArgs2AndDispatch)
2037 {
2038 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallArgs2AndDispatch)
2039 }
2040
DEF_CALL_SIGNATURE(PushCallArgs3AndDispatch)2041 DEF_CALL_SIGNATURE(PushCallArgs3AndDispatch)
2042 {
2043 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallArgs3AndDispatch)
2044 }
2045
DEF_CALL_SIGNATURE(PushCallThisArg0AndDispatch)2046 DEF_CALL_SIGNATURE(PushCallThisArg0AndDispatch)
2047 {
2048 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallThisArg0AndDispatch)
2049 }
2050
DEF_CALL_SIGNATURE(PushCallThisArg1AndDispatch)2051 DEF_CALL_SIGNATURE(PushCallThisArg1AndDispatch)
2052 {
2053 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallThisArg1AndDispatch)
2054 }
2055
DEF_CALL_SIGNATURE(PushCallThisArgs2AndDispatch)2056 DEF_CALL_SIGNATURE(PushCallThisArgs2AndDispatch)
2057 {
2058 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallThisArgs2AndDispatch)
2059 }
2060
DEF_CALL_SIGNATURE(PushCallThisArgs3AndDispatch)2061 DEF_CALL_SIGNATURE(PushCallThisArgs3AndDispatch)
2062 {
2063 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallThisArgs3AndDispatch)
2064 }
2065
DEF_CALL_SIGNATURE(PushCallRangeAndDispatchNative)2066 DEF_CALL_SIGNATURE(PushCallRangeAndDispatchNative)
2067 {
2068 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(PushCallRangeAndDispatchNative)
2069 }
2070
DEF_CALL_SIGNATURE(PushCallNewAndDispatchNative)2071 DEF_CALL_SIGNATURE(PushCallNewAndDispatchNative)
2072 {
2073 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(PushCallNewAndDispatchNative)
2074 }
2075
DEF_CALL_SIGNATURE(PushNewTargetAndDispatchNative)2076 DEF_CALL_SIGNATURE(PushNewTargetAndDispatchNative)
2077 {
2078 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(PushNewTargetAndDispatchNative)
2079 }
2080
DEF_CALL_SIGNATURE(PushCallNewAndDispatch)2081 DEF_CALL_SIGNATURE(PushCallNewAndDispatch)
2082 {
2083 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallNewAndDispatch)
2084 }
2085
DEF_CALL_SIGNATURE(PushSuperCallAndDispatch)2086 DEF_CALL_SIGNATURE(PushSuperCallAndDispatch)
2087 {
2088 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushSuperCallAndDispatch)
2089 }
2090
DEF_CALL_SIGNATURE(PushCallRangeAndDispatch)2091 DEF_CALL_SIGNATURE(PushCallRangeAndDispatch)
2092 {
2093 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallRangeAndDispatch)
2094 }
2095
DEF_CALL_SIGNATURE(PushCallThisRangeAndDispatch)2096 DEF_CALL_SIGNATURE(PushCallThisRangeAndDispatch)
2097 {
2098 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallThisRangeAndDispatch)
2099 }
2100
DEF_CALL_SIGNATURE(CallGetter)2101 DEF_CALL_SIGNATURE(CallGetter)
2102 {
2103 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(CallGetter)
2104 }
2105
DEF_CALL_SIGNATURE(CallSetter)2106 DEF_CALL_SIGNATURE(CallSetter)
2107 {
2108 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(CallSetter)
2109 }
2110
DEF_CALL_SIGNATURE(CallContainersArgs2)2111 DEF_CALL_SIGNATURE(CallContainersArgs2)
2112 {
2113 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(CallContainersArgs2)
2114 }
2115
DEF_CALL_SIGNATURE(CallContainersArgs3)2116 DEF_CALL_SIGNATURE(CallContainersArgs3)
2117 {
2118 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(CallContainersArgs3)
2119 }
2120
DEF_CALL_SIGNATURE(CallReturnWithArgv)2121 DEF_CALL_SIGNATURE(CallReturnWithArgv)
2122 {
2123 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(CallReturnWithArgv)
2124 }
2125
DEF_CALL_SIGNATURE(CallGetterToBaseline)2126 DEF_CALL_SIGNATURE(CallGetterToBaseline)
2127 {
2128 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(CallGetterToBaseline)
2129 }
2130
DEF_CALL_SIGNATURE(CallSetterToBaseline)2131 DEF_CALL_SIGNATURE(CallSetterToBaseline)
2132 {
2133 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(CallSetterToBaseline)
2134 }
2135
DEF_CALL_SIGNATURE(CallContainersArgs2ToBaseline)2136 DEF_CALL_SIGNATURE(CallContainersArgs2ToBaseline)
2137 {
2138 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(CallContainersArgs2ToBaseline)
2139 }
2140
DEF_CALL_SIGNATURE(CallContainersArgs3ToBaseline)2141 DEF_CALL_SIGNATURE(CallContainersArgs3ToBaseline)
2142 {
2143 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(CallContainersArgs3ToBaseline)
2144 }
2145
DEF_CALL_SIGNATURE(CallReturnWithArgvToBaseline)2146 DEF_CALL_SIGNATURE(CallReturnWithArgvToBaseline)
2147 {
2148 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(CallReturnWithArgvToBaseline)
2149 }
2150
DEF_CALL_SIGNATURE(JSCallWithArgV)2151 DEF_CALL_SIGNATURE(JSCallWithArgV)
2152 {
2153 // 5 : 5 input parameters
2154 CallSignature jSCallWithArgV("JSCallWithArgV", 0, 5,
2155 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2156 *callSign = jSCallWithArgV;
2157 // 5 : 5 input parameters
2158 std::array<VariableType, 5> params = {
2159 VariableType::NATIVE_POINTER(), // glue
2160 VariableType::INT64(), // actualNumArgs
2161 VariableType::JS_ANY(), // jsfunc
2162 VariableType::JS_ANY(), // newTarget
2163 VariableType::JS_ANY(), // this
2164 };
2165 callSign->SetVariadicArgs(true);
2166 callSign->SetParameters(params.data());
2167 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2168 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2169 }
2170
DEF_CALL_SIGNATURE(JSFastCallWithArgV)2171 DEF_CALL_SIGNATURE(JSFastCallWithArgV)
2172 {
2173 // 4 : 4 input parameters
2174 CallSignature jSFastCallWithArgV("JSFastCallWithArgV", 0, 4,
2175 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2176 *callSign = jSFastCallWithArgV;
2177 // 4 : 4 input parameters
2178 std::array<VariableType, 4> params = {
2179 VariableType::NATIVE_POINTER(), // glue
2180 VariableType::JS_ANY(), // jsfunc
2181 VariableType::JS_ANY(), // this
2182 VariableType::INT64(), // actualNumArgs
2183 };
2184 callSign->SetVariadicArgs(true);
2185 callSign->SetParameters(params.data());
2186 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2187 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2188 }
2189
DEF_CALL_SIGNATURE(JSFastCallWithArgVAndPushArgv)2190 DEF_CALL_SIGNATURE(JSFastCallWithArgVAndPushArgv)
2191 {
2192 // 4 : 4 input parameters
2193 CallSignature jSCallWithArgV("JSFastCallWithArgVAndPushArgv", 0, 4,
2194 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2195 *callSign = jSCallWithArgV;
2196 // 4 : 4 input parameters
2197 std::array<VariableType, 4> params = {
2198 VariableType::NATIVE_POINTER(), // glue
2199 VariableType::JS_ANY(), // jsfunc
2200 VariableType::JS_ANY(), // this
2201 VariableType::INT64(), // actualNumArgs
2202 };
2203 callSign->SetVariadicArgs(true);
2204 callSign->SetParameters(params.data());
2205 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2206 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2207 }
2208
DEF_CALL_SIGNATURE(JSCallWithArgVAndPushArgv)2209 DEF_CALL_SIGNATURE(JSCallWithArgVAndPushArgv)
2210 {
2211 // 5 : 5 input parameters
2212 CallSignature jSCallWithArgVAndPushArgv("JSCallWithArgVAndPushArgv", 0, 5,
2213 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2214 *callSign = jSCallWithArgVAndPushArgv;
2215 // 5 : 5 input parameters
2216 std::array<VariableType, 5> params = {
2217 VariableType::NATIVE_POINTER(), // glue
2218 VariableType::INT64(), // actualNumArgs
2219 VariableType::JS_ANY(), // jsfunc
2220 VariableType::JS_ANY(), // newTarget
2221 VariableType::JS_ANY(), // this
2222 };
2223 callSign->SetVariadicArgs(true);
2224 callSign->SetParameters(params.data());
2225 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2226 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2227 }
2228
DEF_CALL_SIGNATURE(CallOptimized)2229 DEF_CALL_SIGNATURE(CallOptimized)
2230 {
2231 // 6 : 6 input parameters
2232 CallSignature callOptimized("CallOptimized", 0, 6,
2233 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2234 *callSign = callOptimized;
2235 std::array<VariableType, 6> params = { // 6 : 6 input parameters
2236 VariableType::NATIVE_POINTER(), // glue
2237 VariableType::INT64(), // actual argC
2238 VariableType::NATIVE_POINTER(), // actual argV
2239 VariableType::JS_ANY(), // call target
2240 VariableType::JS_ANY(), // new target
2241 VariableType::JS_ANY(), // thisobj
2242 };
2243 callSign->SetVariadicArgs(true);
2244 callSign->SetParameters(params.data());
2245 callSign->SetCallConv(CallSignature::CallConv::WebKitJSCallConv);
2246 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2247 }
2248
DEF_CALL_SIGNATURE(SuperCallWithArgV)2249 DEF_CALL_SIGNATURE(SuperCallWithArgV)
2250 {
2251 // 5 : 5 input parameters
2252 CallSignature superCallWithArgV("SuperCallWithArgV", 0, 5,
2253 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2254 *callSign = superCallWithArgV;
2255 // 5 : 5 input parameters
2256 std::array<VariableType, 5> params = {
2257 VariableType::NATIVE_POINTER(), // glue
2258 VariableType::INT64(), // actualNumArgs
2259 VariableType::JS_ANY(), // jsfunc
2260 VariableType::JS_ANY(), // newTarget
2261 VariableType::JS_ANY(), // this
2262 };
2263 callSign->SetVariadicArgs(true);
2264 callSign->SetParameters(params.data());
2265 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2266 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2267 }
2268
DEF_CALL_SIGNATURE(Dump)2269 DEF_CALL_SIGNATURE(Dump)
2270 {
2271 constexpr size_t N_INPUT_PARAMETERS = 1;
2272 CallSignature dump("Dump", 0, N_INPUT_PARAMETERS,
2273 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2274 *callSign = dump;
2275 std::array<VariableType, N_INPUT_PARAMETERS> params = {
2276 VariableType::JS_POINTER() // Tagged value of the object to be dumped
2277 };
2278 callSign->SetParameters(params.data());
2279 callSign->SetGCLeafFunction(true);
2280 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2281 }
2282
DEF_CALL_SIGNATURE(DebugDump)2283 DEF_CALL_SIGNATURE(DebugDump)
2284 {
2285 constexpr size_t N_INPUT_PARAMETERS = 1;
2286 CallSignature debugDump("DebugDump", 0, N_INPUT_PARAMETERS,
2287 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2288 *callSign = debugDump;
2289 std::array<VariableType, N_INPUT_PARAMETERS> params = {
2290 VariableType::JS_POINTER() // Tagged value of the object to be dumped
2291 };
2292 callSign->SetParameters(params.data());
2293 callSign->SetGCLeafFunction(true);
2294 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2295 }
2296
DEF_CALL_SIGNATURE(DumpWithHint)2297 DEF_CALL_SIGNATURE(DumpWithHint)
2298 {
2299 constexpr size_t N_INPUT_PARAMETERS = 2;
2300 CallSignature dumpWithHint("DumpWithHint", 0, N_INPUT_PARAMETERS,
2301 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2302 *callSign = dumpWithHint;
2303 std::array<VariableType, N_INPUT_PARAMETERS> params = {
2304 VariableType::NATIVE_POINTER(), // String created via CircuitBuilder::StringPtr()
2305 VariableType::JS_POINTER() // Tagged value of the object to be dumped
2306 };
2307 callSign->SetParameters(params.data());
2308 callSign->SetGCLeafFunction(true);
2309 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2310 }
2311
DEF_CALL_SIGNATURE(DebugDumpWithHint)2312 DEF_CALL_SIGNATURE(DebugDumpWithHint)
2313 {
2314 constexpr size_t N_INPUT_PARAMETERS = 2;
2315 CallSignature debugDumpWithHint("DebugDumpWithHint", 0, N_INPUT_PARAMETERS,
2316 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2317 *callSign = debugDumpWithHint;
2318 std::array<VariableType, N_INPUT_PARAMETERS> params = {
2319 VariableType::NATIVE_POINTER(), // String created via CircuitBuilder::StringPtr()
2320 VariableType::JS_POINTER() // Tagged value of the object to be dumped
2321 };
2322 callSign->SetParameters(params.data());
2323 callSign->SetGCLeafFunction(true);
2324 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2325 }
2326
DEF_CALL_SIGNATURE(DebugPrint)2327 DEF_CALL_SIGNATURE(DebugPrint)
2328 {
2329 // 1 : 1 input parameters
2330 CallSignature debugPrint("DebugPrint", 0, 1,
2331 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2332 *callSign = debugPrint;
2333 // 1 : 1 input parameters
2334 std::array<VariableType, 1> params = {
2335 VariableType::INT32(),
2336 };
2337 callSign->SetVariadicArgs(true);
2338 callSign->SetParameters(params.data());
2339 callSign->SetGCLeafFunction(true);
2340 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2341 }
2342
DEF_CALL_SIGNATURE(DebugPrintCustom)2343 DEF_CALL_SIGNATURE(DebugPrintCustom)
2344 {
2345 // 1 : 1 input parameters
2346 CallSignature debugPrintCustom("DebugPrintCustom", 0, 1,
2347 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2348 *callSign = debugPrintCustom;
2349 // 1 : 1 input parameters
2350 std::array<VariableType, 1> params = {
2351 VariableType::NATIVE_POINTER() // Format string created via CircuitBuilder::StringPtr()
2352 };
2353 callSign->SetVariadicArgs(true);
2354 callSign->SetParameters(params.data());
2355 callSign->SetGCLeafFunction(true);
2356 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2357 }
2358
DEF_CALL_SIGNATURE(DebugPrintInstruction)2359 DEF_CALL_SIGNATURE(DebugPrintInstruction)
2360 {
2361 // 2 : 2 input parameters
2362 CallSignature debugPrintInstruction("DebugPrintInstruction", 0, 2,
2363 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2364 *callSign = debugPrintInstruction;
2365 // 2 : 2 input parameters
2366 std::array<VariableType, 2> params = {
2367 VariableType::NATIVE_POINTER(),
2368 VariableType::NATIVE_POINTER(),
2369 };
2370 callSign->SetVariadicArgs(true);
2371 callSign->SetParameters(params.data());
2372 callSign->SetGCLeafFunction(true);
2373 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2374 }
2375
DEF_CALL_SIGNATURE(CollectingOpcodes)2376 DEF_CALL_SIGNATURE(CollectingOpcodes)
2377 {
2378 // 2 : 2 input parameters
2379 CallSignature collectingOpcodes("CollectingOpcodes", 0, 2,
2380 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2381 *callSign = collectingOpcodes;
2382 // 2 : 2 input parameters
2383 std::array<VariableType, 2> params = {
2384 VariableType::NATIVE_POINTER(),
2385 VariableType::NATIVE_POINTER(),
2386 };
2387 callSign->SetVariadicArgs(true);
2388 callSign->SetParameters(params.data());
2389 callSign->SetGCLeafFunction(true);
2390 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2391 }
2392
DEF_CALL_SIGNATURE(DebugOsrEntry)2393 DEF_CALL_SIGNATURE(DebugOsrEntry)
2394 {
2395 // 2 : 2 input parameters
2396 CallSignature debugOsrEntry("DebugOsrEntry", 0, 2,
2397 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2398 *callSign = debugOsrEntry;
2399 // 2 : 2 input parameters
2400 std::array<VariableType, 2> params = {
2401 VariableType::NATIVE_POINTER(),
2402 VariableType::NATIVE_POINTER(),
2403 };
2404 callSign->SetVariadicArgs(true);
2405 callSign->SetParameters(params.data());
2406 callSign->SetGCLeafFunction(true);
2407 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2408 }
2409
DEF_CALL_SIGNATURE(Comment)2410 DEF_CALL_SIGNATURE(Comment)
2411 {
2412 // 1 : 1 input parameters
2413 CallSignature comment("Comment", 0, 1,
2414 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2415 *callSign = comment;
2416 // 1 : 1 input parameters
2417 std::array<VariableType, 1> params = {
2418 VariableType::NATIVE_POINTER(),
2419 };
2420 callSign->SetParameters(params.data());
2421 callSign->SetGCLeafFunction(true);
2422 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2423 }
2424
DEF_CALL_SIGNATURE(FatalPrint)2425 DEF_CALL_SIGNATURE(FatalPrint)
2426 {
2427 // 1 : 1 input parameters
2428 CallSignature fatalPrint("FatalPrint", 0, 1,
2429 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2430 *callSign = fatalPrint;
2431 // 1 : 1 input parameters
2432 std::array<VariableType, 1> params = {
2433 VariableType::INT32(),
2434 };
2435 callSign->SetVariadicArgs(true);
2436 callSign->SetParameters(params.data());
2437 callSign->SetGCLeafFunction(true);
2438 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2439 }
2440
DEF_CALL_SIGNATURE(FatalPrintCustom)2441 DEF_CALL_SIGNATURE(FatalPrintCustom)
2442 {
2443 // 1 : 1 input parameters
2444 CallSignature fatalPrintCustom("FatalPrintCustom", 0, 1,
2445 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2446 *callSign = fatalPrintCustom;
2447 // 1 : 1 input parameters
2448 std::array<VariableType, 1> params = {
2449 VariableType::NATIVE_POINTER() // Format string created via CircuitBuilder::StringPtr()
2450 };
2451 callSign->SetVariadicArgs(true);
2452 callSign->SetParameters(params.data());
2453 callSign->SetGCLeafFunction(true);
2454 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2455 }
2456
DEF_CALL_SIGNATURE(GetActualArgvNoGC)2457 DEF_CALL_SIGNATURE(GetActualArgvNoGC)
2458 {
2459 CallSignature index("GetActualArgvNoGC", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::NATIVE_POINTER());
2460 *callSign = index;
2461 std::array<VariableType, 1> params = {
2462 VariableType::NATIVE_POINTER(),
2463 };
2464 callSign->SetParameters(params.data());
2465 callSign->SetGCLeafFunction(true);
2466 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2467 }
2468
DEF_CALL_SIGNATURE(InsertOldToNewRSet)2469 DEF_CALL_SIGNATURE(InsertOldToNewRSet)
2470 {
2471 // 3 : 3 input parameters
2472 CallSignature index("InsertOldToNewRSet", 0, 3, ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2473 *callSign = index;
2474 // 3 : 3 input parameters
2475 std::array<VariableType, 3> params = {
2476 VariableType::NATIVE_POINTER(),
2477 VariableType::JS_POINTER(),
2478 VariableType::NATIVE_POINTER(),
2479 };
2480 callSign->SetParameters(params.data());
2481 callSign->SetGCLeafFunction(true);
2482 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2483 }
2484
DEF_CALL_SIGNATURE(InsertLocalToShareRSet)2485 DEF_CALL_SIGNATURE(InsertLocalToShareRSet)
2486 {
2487 // 3 : 3 input parameters
2488 CallSignature index("InsertLocalToShareRSet", 0, 3, ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2489 *callSign = index;
2490 // 3 : 3 input parameters
2491 std::array<VariableType, 3> params = {
2492 VariableType::NATIVE_POINTER(),
2493 VariableType::JS_POINTER(),
2494 VariableType::NATIVE_POINTER(),
2495 };
2496 callSign->SetParameters(params.data());
2497 callSign->SetGCLeafFunction(true);
2498 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2499 }
2500
DEF_CALL_SIGNATURE(SetBitAtomic)2501 DEF_CALL_SIGNATURE(SetBitAtomic)
2502 {
2503 // 3 : 3 input parameters
2504 CallSignature index("SetBitAtomic", 0, 3, ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2505 *callSign = index;
2506 // 3 : 3 input parameters
2507 std::array<VariableType, 3> params = {
2508 VariableType::NATIVE_POINTER(),
2509 VariableType::INT32(),
2510 VariableType::INT32()
2511 };
2512 callSign->SetParameters(params.data());
2513 callSign->SetGCLeafFunction(true);
2514 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2515 }
2516
2517 #define DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(NAME) \
2518 DEF_CALL_SIGNATURE(NAME) \
2519 { \
2520 /* 1 : 1 input parameters */ \
2521 CallSignature index(#NAME, 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::FLOAT64()); \
2522 *callSign = index; \
2523 /* 1 : 1 input parameters */ \
2524 std::array<VariableType, 1> params = { \
2525 VariableType::FLOAT64(), \
2526 }; \
2527 callSign->SetParameters(params.data()); \
2528 callSign->SetGCLeafFunction(true); \
2529 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC); \
2530 }
2531
2532 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatAcos)
DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatAcosh)2533 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatAcosh)
2534 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatAsin)
2535 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatAsinh)
2536 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatAtan)
2537 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatAtanh)
2538 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatCos)
2539 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatCosh)
2540 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatSin)
2541 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatSinh)
2542 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatTan)
2543 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatTanh)
2544 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatExp)
2545 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatExpm1)
2546 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatTrunc)
2547 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatFloor)
2548 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatLog)
2549 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatLog2)
2550 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatLog10)
2551 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatLog1p)
2552 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatCbrt)
2553 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatClz32)
2554 DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME(FloatCeil)
2555
2556 #undef DEF_FLOAT_UNARY_CALL_SIGNATURE_BY_NAME
2557
2558 #define DEF_FLOAT_BINARY_CALL_SIGNATURE_BY_NAME(NAME) \
2559 DEF_CALL_SIGNATURE(NAME) \
2560 { \
2561 /* 2 : 2 input parameters */ \
2562 CallSignature index(#NAME, 0, 2, ArgumentsOrder::DEFAULT_ORDER, VariableType::FLOAT64()); \
2563 *callSign = index; \
2564 /* 2 : 2 input parameters */ \
2565 std::array<VariableType, 2> params = { \
2566 VariableType::FLOAT64(), \
2567 VariableType::FLOAT64(), \
2568 }; \
2569 callSign->SetParameters(params.data()); \
2570 callSign->SetGCLeafFunction(true); \
2571 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC); \
2572 }
2573
2574 DEF_FLOAT_BINARY_CALL_SIGNATURE_BY_NAME(FloatMod)
2575 DEF_FLOAT_BINARY_CALL_SIGNATURE_BY_NAME(FloatAtan2)
2576 DEF_FLOAT_BINARY_CALL_SIGNATURE_BY_NAME(FloatPow)
2577
2578 #undef DEF_FLOAT_BINARY_CALL_SIGNATURE_BY_NAME
2579
2580 DEF_CALL_SIGNATURE(CallDateNow)
2581 {
2582 CallSignature signature("CallDateNow", 0, 0, ArgumentsOrder::DEFAULT_ORDER,
2583 VariableType::FLOAT64());
2584 *callSign = signature;
2585 callSign->SetGCLeafFunction(true);
2586 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2587 }
2588
DEF_CALL_SIGNATURE(UpdateFieldType)2589 DEF_CALL_SIGNATURE(UpdateFieldType)
2590 {
2591 // 2 : 2 input parameters
2592 CallSignature index("UpdateFieldType", 0, 2, ArgumentsOrder::DEFAULT_ORDER, VariableType::INT32());
2593 *callSign = index;
2594 // 2 : 2 input parameters
2595 std::array<VariableType, 2> params = {
2596 VariableType::JS_ANY(),
2597 VariableType::INT64(),
2598 };
2599 callSign->SetParameters(params.data());
2600 callSign->SetGCLeafFunction(true);
2601 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2602 }
2603
DEF_CALL_SIGNATURE(DoubleToInt)2604 DEF_CALL_SIGNATURE(DoubleToInt)
2605 {
2606 // 2 : 2 input parameters
2607 CallSignature index("DoubleToInt", 0, 2, ArgumentsOrder::DEFAULT_ORDER, VariableType::INT32());
2608 *callSign = index;
2609 // 2 : 2 input parameters
2610 std::array<VariableType, 2> params = {
2611 VariableType::FLOAT64(),
2612 VariableType::NATIVE_POINTER(),
2613 };
2614 callSign->SetParameters(params.data());
2615 callSign->SetGCLeafFunction(true);
2616 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2617 }
2618
DEF_CALL_SIGNATURE(SaturateTruncDoubleToInt32)2619 DEF_CALL_SIGNATURE(SaturateTruncDoubleToInt32)
2620 {
2621 // 1 : 1 input parameters
2622 CallSignature index("SaturateTruncDoubleToInt32", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::INT32());
2623 *callSign = index;
2624 // 1 : 1 input parameters
2625 std::array<VariableType, 1> params = {
2626 VariableType::FLOAT64(),
2627 };
2628 callSign->SetParameters(params.data());
2629 callSign->SetGCLeafFunction(true);
2630 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2631 }
2632
DEF_CALL_SIGNATURE(MarkingBarrier)2633 DEF_CALL_SIGNATURE(MarkingBarrier)
2634 {
2635 // 4 : 4 input parameters
2636 CallSignature index("MarkingBarrier", 0, 4, ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2637 *callSign = index;
2638 // 4 : 4 input parameters
2639 std::array<VariableType, 4> params = {
2640 VariableType::NATIVE_POINTER(),
2641 VariableType::JS_POINTER(),
2642 VariableType::NATIVE_POINTER(),
2643 VariableType::JS_POINTER()
2644 };
2645 callSign->SetParameters(params.data());
2646 callSign->SetGCLeafFunction(true);
2647 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2648 }
2649
DEF_CALL_SIGNATURE(SharedGCMarkingBarrier)2650 DEF_CALL_SIGNATURE(SharedGCMarkingBarrier)
2651 {
2652 // 4 : 4 input parameters
2653 CallSignature index("SharedGCMarkingBarrier", 0, 4, ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2654 *callSign = index;
2655 // 4 : 4 input parameters
2656 std::array<VariableType, 4> params = {
2657 VariableType::NATIVE_POINTER(),
2658 VariableType::JS_POINTER(),
2659 VariableType::NATIVE_POINTER(),
2660 VariableType::JS_POINTER(),
2661 };
2662 callSign->SetParameters(params.data());
2663 callSign->SetGCLeafFunction(true);
2664 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2665 }
2666
DEF_CALL_SIGNATURE(CallArg0Stub)2667 DEF_CALL_SIGNATURE(CallArg0Stub)
2668 {
2669 // 2 : 2 input parameters
2670 CallSignature callArg0Stub("callArg0Stub", 0, 2,
2671 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2672 *callSign = callArg0Stub;
2673 // 2 : 2 input parameters
2674 std::array<VariableType, 2> params = {
2675 VariableType::NATIVE_POINTER(), // glue
2676 VariableType::JS_ANY(), // func
2677 };
2678 callSign->SetParameters(params.data());
2679 }
2680
DEF_CALL_SIGNATURE(CallArg1Stub)2681 DEF_CALL_SIGNATURE(CallArg1Stub)
2682 {
2683 // 3 : 3 input parameters
2684 CallSignature callArg1Stub("callArg1Stub", 0, 3,
2685 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2686 *callSign = callArg1Stub;
2687 // 3 : 3 input parameters
2688 std::array<VariableType, 3> params = {
2689 VariableType::NATIVE_POINTER(), // glue
2690 VariableType::JS_ANY(), // func
2691 VariableType::JS_ANY() // a0
2692 };
2693 callSign->SetParameters(params.data());
2694 }
2695
DEF_CALL_SIGNATURE(CallArg2Stub)2696 DEF_CALL_SIGNATURE(CallArg2Stub)
2697 {
2698 // 4 : 4 input parameters
2699 CallSignature callArg2Stub("callArg2Stub", 0, 4,
2700 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2701 *callSign = callArg2Stub;
2702 // 4 : 4 input parameters
2703 std::array<VariableType, 4> params = {
2704 VariableType::NATIVE_POINTER(), // glue
2705 VariableType::JS_ANY(), // func
2706 VariableType::JS_ANY(), // a0
2707 VariableType::JS_ANY() // a1
2708 };
2709 callSign->SetParameters(params.data());
2710 }
2711
DEF_CALL_SIGNATURE(CallArg3Stub)2712 DEF_CALL_SIGNATURE(CallArg3Stub)
2713 {
2714 // 5 : 5 input parameters
2715 CallSignature callArg3Stub("callArg3Stub", 0, 5,
2716 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2717 *callSign = callArg3Stub;
2718 // 5 : 5 input parameters
2719 std::array<VariableType, 5> params = {
2720 VariableType::NATIVE_POINTER(), // glue
2721 VariableType::JS_ANY(), // func
2722 VariableType::JS_ANY(), // a0
2723 VariableType::JS_ANY(), // a1
2724 VariableType::JS_ANY() // a2
2725 };
2726 callSign->SetParameters(params.data());
2727 }
2728
DEF_CALL_SIGNATURE(CallThis0Stub)2729 DEF_CALL_SIGNATURE(CallThis0Stub)
2730 {
2731 // 3 : 3 input parameters
2732 CallSignature callThis0Stub("callThis0Stub", 0, 3,
2733 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2734 *callSign = callThis0Stub;
2735 // 3 : 3 input parameters
2736 std::array<VariableType, 3> params = {
2737 VariableType::NATIVE_POINTER(), // glue
2738 VariableType::JS_ANY(), // func
2739 VariableType::JS_ANY(), // this
2740 };
2741 callSign->SetParameters(params.data());
2742 }
2743
DEF_CALL_SIGNATURE(CallThis1Stub)2744 DEF_CALL_SIGNATURE(CallThis1Stub)
2745 {
2746 // 4 : 4 input parameters
2747 CallSignature callThis1Stub("callThis1Stub", 0, 4,
2748 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2749 *callSign = callThis1Stub;
2750 // 4 : 4 input parameters
2751 std::array<VariableType, 4> params = {
2752 VariableType::NATIVE_POINTER(), // glue
2753 VariableType::JS_ANY(), // func
2754 VariableType::JS_ANY(), // this
2755 VariableType::JS_ANY() // a0
2756 };
2757 callSign->SetParameters(params.data());
2758 }
2759
DEF_CALL_SIGNATURE(CallThis2Stub)2760 DEF_CALL_SIGNATURE(CallThis2Stub)
2761 {
2762 // 5 : 5 input parameters
2763 CallSignature callThis2Stub("callThis2Stub", 0, 5,
2764 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2765 *callSign = callThis2Stub;
2766 // 5 : 5 input parameters
2767 std::array<VariableType, 5> params = {
2768 VariableType::NATIVE_POINTER(), // glue
2769 VariableType::JS_ANY(), // func
2770 VariableType::JS_ANY(), // this
2771 VariableType::JS_ANY(), // a0
2772 VariableType::JS_ANY() // a1
2773 };
2774 callSign->SetParameters(params.data());
2775 }
2776
DEF_CALL_SIGNATURE(CallThis3Stub)2777 DEF_CALL_SIGNATURE(CallThis3Stub)
2778 {
2779 // 6 : 6 input parameters
2780 CallSignature callThis3Stub("callThis3Stub", 0, 6,
2781 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2782 *callSign = callThis3Stub;
2783 // 6 : 6 input parameters
2784 std::array<VariableType, 6> params = {
2785 VariableType::NATIVE_POINTER(), // glue
2786 VariableType::JS_ANY(), // func
2787 VariableType::JS_ANY(), // this
2788 VariableType::JS_ANY(), // a0
2789 VariableType::JS_ANY(), // a1
2790 VariableType::JS_ANY() // a2
2791 };
2792 callSign->SetParameters(params.data());
2793 }
2794
DEF_CALL_SIGNATURE(CallArg0)2795 DEF_CALL_SIGNATURE(CallArg0)
2796 {
2797 // 2 : 2 input parameters
2798 CallSignature callArg0("callArg0", 0, 2,
2799 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2800 *callSign = callArg0;
2801 // 2 : 2 input parameters
2802 std::array<VariableType, 2> params = {
2803 VariableType::NATIVE_POINTER(),
2804 VariableType::JS_ANY()
2805 };
2806 callSign->SetParameters(params.data());
2807 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
2808 }
2809
DEF_CALL_SIGNATURE(CallArg1)2810 DEF_CALL_SIGNATURE(CallArg1)
2811 {
2812 // 3 : 3 input parameters
2813 CallSignature callArg1("callArg1", 0, 3,
2814 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2815 *callSign = callArg1;
2816 // 3 : 3 input parameters
2817 std::array<VariableType, 3> params = {
2818 VariableType::NATIVE_POINTER(),
2819 VariableType::JS_ANY(),
2820 VariableType::JS_ANY()
2821 };
2822 callSign->SetParameters(params.data());
2823 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
2824 }
2825
DEF_CALL_SIGNATURE(CallArgs2)2826 DEF_CALL_SIGNATURE(CallArgs2)
2827 {
2828 // 4 : 4 input parameters
2829 CallSignature callArgs2("callArgs2", 0, 4,
2830 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2831 *callSign = callArgs2;
2832 // 4 : 4 input parameters
2833 std::array<VariableType, 4> params = {
2834 VariableType::NATIVE_POINTER(),
2835 VariableType::JS_ANY(),
2836 VariableType::JS_ANY(),
2837 VariableType::JS_ANY()
2838 };
2839 callSign->SetParameters(params.data());
2840 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
2841 }
2842
DEF_CALL_SIGNATURE(CallArgs3)2843 DEF_CALL_SIGNATURE(CallArgs3)
2844 {
2845 // 5 : 5 input parameters
2846 CallSignature callArgs3("callArgs3", 0, 5,
2847 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2848 *callSign = callArgs3;
2849 // 5 : 5 input parameters
2850 std::array<VariableType, 5> params = {
2851 VariableType::NATIVE_POINTER(),
2852 VariableType::JS_ANY(),
2853 VariableType::JS_ANY(),
2854 VariableType::JS_ANY(),
2855 VariableType::JS_ANY()
2856 };
2857 callSign->SetParameters(params.data());
2858 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
2859 }
2860
DEF_CALL_SIGNATURE(CallThisRange)2861 DEF_CALL_SIGNATURE(CallThisRange)
2862 {
2863 // 3 : 3 input parameters
2864 CallSignature callThisRange("callThisRange", 0, 3,
2865 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2866 *callSign = callThisRange;
2867 // 3 : 3 input parameters
2868 std::array<VariableType, 3> params = {
2869 VariableType::NATIVE_POINTER(),
2870 VariableType::JS_ANY(),
2871 VariableType::JS_ANY()
2872 };
2873 callSign->SetVariadicArgs(true);
2874 callSign->SetParameters(params.data());
2875 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
2876 }
2877
DEF_CALL_SIGNATURE(CallRange)2878 DEF_CALL_SIGNATURE(CallRange)
2879 {
2880 // 2 : 2 input parameters
2881 CallSignature callRange("callRange", 0, 2,
2882 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2883 *callSign = callRange;
2884 // 2 : 2 input parameters
2885 std::array<VariableType, 2> params = {
2886 VariableType::NATIVE_POINTER(),
2887 VariableType::JS_ANY()
2888 };
2889 callSign->SetVariadicArgs(true);
2890 callSign->SetParameters(params.data());
2891 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
2892 }
2893
DEF_CALL_SIGNATURE(JsProxyCallInternal)2894 DEF_CALL_SIGNATURE(JsProxyCallInternal)
2895 {
2896 // 4 : 4 input parameters
2897 CallSignature proxyCallInternal("JsProxyCallInternal", 0, 4,
2898 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_POINTER());
2899 *callSign = proxyCallInternal;
2900 // 4 : 4 input parameters
2901 std::array<VariableType, 4> params = {
2902 VariableType::NATIVE_POINTER(), // glue
2903 VariableType::INT64(), // actual argC
2904 VariableType::JS_POINTER(), // callTarget
2905 VariableType::NATIVE_POINTER(), // argv
2906 };
2907 callSign->SetVariadicArgs(false);
2908 callSign->SetParameters(params.data());
2909 callSign->SetTailCall(true);
2910 callSign->SetGCLeafFunction(true);
2911 callSign->SetTargetKind(CallSignature::TargetKind::COMMON_STUB);
2912 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2913 }
2914
DEF_CALL_SIGNATURE(JsBoundCallInternal)2915 DEF_CALL_SIGNATURE(JsBoundCallInternal)
2916 {
2917 // 6 : 6 input parameters
2918 CallSignature boundCallInternal("JsBoundCallInternal", 0, 6,
2919 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_POINTER());
2920 *callSign = boundCallInternal;
2921 // 6 : 6 input parameters
2922 std::array<VariableType, 6> params = {
2923 VariableType::NATIVE_POINTER(), // glue
2924 VariableType::INT64(), // actual argC
2925 VariableType::JS_POINTER(), // callTarget
2926 VariableType::NATIVE_POINTER(), // argv
2927 VariableType::JS_POINTER(), // this
2928 VariableType::JS_POINTER(), // new
2929 };
2930 callSign->SetVariadicArgs(false);
2931 callSign->SetParameters(params.data());
2932 callSign->SetTailCall(true);
2933 callSign->SetGCLeafFunction(true);
2934 callSign->SetTargetKind(CallSignature::TargetKind::COMMON_STUB);
2935 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2936 }
2937
DEF_CALL_SIGNATURE(DeoptHandlerAsm)2938 DEF_CALL_SIGNATURE(DeoptHandlerAsm)
2939 {
2940 // 1 : 1 input parameters
2941 CallSignature deoptHandlerAsm("DeoptHandlerAsm", 0, 3,
2942 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
2943 *callSign = deoptHandlerAsm;
2944 std::array<VariableType, 3> params = { // 3 : 3 input parameters
2945 VariableType::NATIVE_POINTER(), // glue
2946 VariableType::NATIVE_POINTER(), // deoptType
2947 VariableType::NATIVE_POINTER(), // depth
2948 };
2949 callSign->SetVariadicArgs(false);
2950 callSign->SetParameters(params.data());
2951 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
2952 callSign->SetTargetKind(CallSignature::TargetKind::DEOPT_STUB);
2953 }
2954
DEF_CALL_SIGNATURE(TimeClip)2955 DEF_CALL_SIGNATURE(TimeClip)
2956 {
2957 // 1 : 1 input parameters
2958 CallSignature index("TimeClip", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::FLOAT64());
2959 *callSign = index;
2960 // 1 : 1 input parameters
2961 std::array<VariableType, 1> params = {
2962 VariableType::FLOAT64(),
2963 };
2964 callSign->SetParameters(params.data());
2965 callSign->SetGCLeafFunction(true);
2966 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2967 }
2968
DEF_CALL_SIGNATURE(SetDateValues)2969 DEF_CALL_SIGNATURE(SetDateValues)
2970 {
2971 // 3 : 3 input parameters
2972 CallSignature index("SetDateValues", 0, 3, ArgumentsOrder::DEFAULT_ORDER, VariableType::FLOAT64());
2973 *callSign = index;
2974 // 3 : 3 input parameters
2975 std::array<VariableType, 3> params = {
2976 VariableType::FLOAT64(),
2977 VariableType::FLOAT64(),
2978 VariableType::FLOAT64(),
2979 };
2980 callSign->SetParameters(params.data());
2981 callSign->SetGCLeafFunction(true);
2982 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2983 }
2984
DEF_CALL_SIGNATURE(StartCallTimer)2985 DEF_CALL_SIGNATURE(StartCallTimer)
2986 {
2987 CallSignature index("StartCallTimer", 0, 3, ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
2988 *callSign = index;
2989 // 3 : 3 input parameters
2990 std::array<VariableType, 3> params = {
2991 VariableType::NATIVE_POINTER(),
2992 VariableType::JS_ANY(),
2993 VariableType::BOOL()
2994 };
2995 callSign->SetParameters(params.data());
2996 callSign->SetGCLeafFunction(true);
2997 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
2998 }
2999
DEF_CALL_SIGNATURE(EndCallTimer)3000 DEF_CALL_SIGNATURE(EndCallTimer)
3001 {
3002 CallSignature index("EndCallTimer", 0, 2, ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3003 *callSign = index;
3004 // 2 : 2 input parameters
3005 std::array<VariableType, 2> params = {
3006 VariableType::NATIVE_POINTER(),
3007 VariableType::JS_ANY()
3008 };
3009 callSign->SetParameters(params.data());
3010 callSign->SetGCLeafFunction(true);
3011 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
3012 }
3013
DEF_CALL_SIGNATURE(GetSingleCharCodeByIndex)3014 DEF_CALL_SIGNATURE(GetSingleCharCodeByIndex)
3015 {
3016 // 3 : 3 input parameters
3017 CallSignature signature("GetSingleCharCodeByIndex", 0, 3,
3018 ArgumentsOrder::DEFAULT_ORDER, VariableType::INT32());
3019 *callSign = signature;
3020 // 3 : 3 input parameters
3021 std::array<VariableType, 3> params = {
3022 VariableType::NATIVE_POINTER(), // glue
3023 VariableType::JS_ANY(), // ecmaString
3024 VariableType::INT32(), // index
3025 };
3026 callSign->SetParameters(params.data());
3027 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
3028 }
3029
DEF_CALL_SIGNATURE(CreateStringBySingleCharCode)3030 DEF_CALL_SIGNATURE(CreateStringBySingleCharCode)
3031 {
3032 // 2 : 2 input parameters
3033 CallSignature signature("CreateStringByCharCode", 0, 2,
3034 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3035 *callSign = signature;
3036 // 2 : 2 input parameters
3037 std::array<VariableType, 2> params = {
3038 VariableType::NATIVE_POINTER(), // glue
3039 VariableType::INT32(), // charcode
3040 };
3041 callSign->SetParameters(params.data());
3042 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
3043 }
3044
DEF_CALL_SIGNATURE(Getpropiterator)3045 DEF_CALL_SIGNATURE(Getpropiterator)
3046 {
3047 // 2 : 2 input parameters
3048 CallSignature signature("Getpropiterator", 0, 2,
3049 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3050 *callSign = signature;
3051 // 2 : 2 input parameters
3052 std::array<VariableType, 2> params = {
3053 VariableType::NATIVE_POINTER(), // glue
3054 VariableType::JS_ANY(), // object
3055 };
3056 callSign->SetParameters(params.data());
3057 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
3058 }
3059
DEF_CALL_SIGNATURE(Getnextpropname)3060 DEF_CALL_SIGNATURE(Getnextpropname)
3061 {
3062 // 2 : 2 input parameters
3063 CallSignature signature("Getnextpropname", 0, 2,
3064 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3065 *callSign = signature;
3066 // 2 : 2 input parameters
3067 std::array<VariableType, 2> params = {
3068 VariableType::NATIVE_POINTER(), // glue
3069 VariableType::JS_ANY(), // iter
3070 };
3071 callSign->SetParameters(params.data());
3072 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
3073 }
3074
DEF_CALL_SIGNATURE(CreateJSSetIterator)3075 DEF_CALL_SIGNATURE(CreateJSSetIterator)
3076 {
3077 UNARY_CALL_SIGNATURE(CreateJSSetIterator)
3078 }
3079
DEF_CALL_SIGNATURE(JSSetEntries)3080 DEF_CALL_SIGNATURE(JSSetEntries)
3081 {
3082 UNARY_CALL_SIGNATURE(JSSetEntries)
3083 }
3084
DEF_CALL_SIGNATURE(CreateJSMapIterator)3085 DEF_CALL_SIGNATURE(CreateJSMapIterator)
3086 {
3087 UNARY_CALL_SIGNATURE(CreateJSMapIterator)
3088 }
3089
DEF_CALL_SIGNATURE(JSMapKeys)3090 DEF_CALL_SIGNATURE(JSMapKeys)
3091 {
3092 UNARY_CALL_SIGNATURE(JSMapKeys)
3093 }
3094
DEF_CALL_SIGNATURE(JSMapValues)3095 DEF_CALL_SIGNATURE(JSMapValues)
3096 {
3097 UNARY_CALL_SIGNATURE(JSMapValues)
3098 }
3099
DEF_CALL_SIGNATURE(JSMapGet)3100 DEF_CALL_SIGNATURE(JSMapGet)
3101 {
3102 BINARY_CALL_SIGNATURE(JSMapGet)
3103 }
3104
DEF_CALL_SIGNATURE(StringIteratorNext)3105 DEF_CALL_SIGNATURE(StringIteratorNext)
3106 {
3107 UNARY_CALL_SIGNATURE(StringIteratorNext)
3108 }
3109
DEF_CALL_SIGNATURE(ArrayIteratorNext)3110 DEF_CALL_SIGNATURE(ArrayIteratorNext)
3111 {
3112 UNARY_CALL_SIGNATURE(ArrayIteratorNext)
3113 }
3114
DEF_CALL_SIGNATURE(MapIteratorNext)3115 DEF_CALL_SIGNATURE(MapIteratorNext)
3116 {
3117 UNARY_CALL_SIGNATURE(MapIteratorNext)
3118 }
3119
DEF_CALL_SIGNATURE(SetIteratorNext)3120 DEF_CALL_SIGNATURE(SetIteratorNext)
3121 {
3122 UNARY_CALL_SIGNATURE(SetIteratorNext)
3123 }
3124
DEF_CALL_SIGNATURE(GetIterator)3125 DEF_CALL_SIGNATURE(GetIterator)
3126 {
3127 UNARY_CALL_SIGNATURE(GetIterator)
3128 }
3129
DEF_CALL_SIGNATURE(JSMapHas)3130 DEF_CALL_SIGNATURE(JSMapHas)
3131 {
3132 *callSign = CallSignature("JSMapHas", 0, ArgumentsOrder::DEFAULT_ORDER, VariableType::BOOL(),
3133 {
3134 VariableType::NATIVE_POINTER(), // glue
3135 VariableType::JS_ANY(), // obj
3136 VariableType::JS_ANY(), // key
3137 });
3138 }
3139
DEF_CALL_SIGNATURE(JSSetHas)3140 DEF_CALL_SIGNATURE(JSSetHas)
3141 {
3142 *callSign = CallSignature("JSSetHas", 0, ArgumentsOrder::DEFAULT_ORDER, VariableType::BOOL(),
3143 {
3144 VariableType::NATIVE_POINTER(), // glue
3145 VariableType::JS_ANY(), // obj
3146 VariableType::JS_ANY(), // key
3147 });
3148 }
3149
DEF_CALL_SIGNATURE(JSMapDelete)3150 DEF_CALL_SIGNATURE(JSMapDelete)
3151 {
3152 *callSign = CallSignature("JSMapDelete", 0, ArgumentsOrder::DEFAULT_ORDER, VariableType::BOOL(),
3153 {
3154 VariableType::NATIVE_POINTER(), // glue
3155 VariableType::JS_ANY(), // obj
3156 VariableType::JS_ANY(), // key
3157 });
3158 }
3159
DEF_CALL_SIGNATURE(JSSetDelete)3160 DEF_CALL_SIGNATURE(JSSetDelete)
3161 {
3162 *callSign = CallSignature("JSSetDelete", 0, ArgumentsOrder::DEFAULT_ORDER, VariableType::BOOL(),
3163 {
3164 VariableType::NATIVE_POINTER(), // glue
3165 VariableType::JS_ANY(), // obj
3166 VariableType::JS_ANY(), // key
3167 });
3168 }
3169
DEF_CALL_SIGNATURE(JSSetAdd)3170 DEF_CALL_SIGNATURE(JSSetAdd)
3171 {
3172 *callSign = CallSignature("JSSetAdd", 0, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY(),
3173 {
3174 VariableType::NATIVE_POINTER(), // glue
3175 VariableType::JS_ANY(), // obj
3176 VariableType::JS_ANY(), // key
3177 });
3178 }
3179
DEF_CALL_SIGNATURE(FastStringEqual)3180 DEF_CALL_SIGNATURE(FastStringEqual)
3181 {
3182 // 3 : 3 input parameters
3183 CallSignature signature("FastStringEqual", 0, 3,
3184 ArgumentsOrder::DEFAULT_ORDER, VariableType::BOOL());
3185 *callSign = signature;
3186 // 3 : 3 input parameters
3187 std::array<VariableType, 3> params = {
3188 VariableType::NATIVE_POINTER(), // glue
3189 VariableType::JS_ANY(), // ecmaString1
3190 VariableType::JS_ANY(), // ecmaString2
3191 };
3192 callSign->SetParameters(params.data());
3193 }
3194
DEF_CALL_SIGNATURE(FastStringAdd)3195 DEF_CALL_SIGNATURE(FastStringAdd)
3196 {
3197 // 3 : 3 input parameters
3198 CallSignature signature("FastStringAdd", 0, 3,
3199 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3200 *callSign = signature;
3201 // 3 : 3 input parameters
3202 std::array<VariableType, 3> params = {
3203 VariableType::NATIVE_POINTER(), // glue
3204 VariableType::JS_ANY(), // ecmaString1
3205 VariableType::JS_ANY(), // ecmaString2
3206 };
3207 callSign->SetParameters(params.data());
3208 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
3209 }
3210
DEF_CALL_SIGNATURE(StringAdd)3211 DEF_CALL_SIGNATURE(StringAdd)
3212 {
3213 // 4 : 4 input parameters
3214 CallSignature signature("StringAdd", 0, 4,
3215 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3216 *callSign = signature;
3217 // 4 : 4 input parameters
3218 std::array<VariableType, 4> params = {
3219 VariableType::NATIVE_POINTER(), // glue
3220 VariableType::JS_ANY(), // ecmaString1
3221 VariableType::JS_ANY(), // ecmaString2
3222 VariableType::INT32(), // stringadd status
3223 };
3224 callSign->SetParameters(params.data());
3225 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
3226 }
3227
DEF_CALL_SIGNATURE(DeleteObjectProperty)3228 DEF_CALL_SIGNATURE(DeleteObjectProperty)
3229 {
3230 // 3 : 3 input parameters
3231 CallSignature signature("DeleteObjectProperty", 0, 3,
3232 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3233 *callSign = signature;
3234 // 3 : 3 input parameters
3235 std::array<VariableType, 3> params = {
3236 VariableType::NATIVE_POINTER(), // glue
3237 VariableType::JS_ANY(), // object
3238 VariableType::JS_ANY(), // prop
3239 };
3240 callSign->SetParameters(params.data());
3241 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
3242 }
3243
DEF_CALL_SIGNATURE(CopyTypedArrayBuffer)3244 DEF_CALL_SIGNATURE(CopyTypedArrayBuffer)
3245 {
3246 // 6 : 6 input parameters
3247 CallSignature CopyTypedArrayBuffer("CopyTypedArrayBuffer", 0, 6,
3248 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3249 *callSign = CopyTypedArrayBuffer;
3250 // 6 : 6 input parameters
3251 std::array<VariableType, 6> params = {
3252 VariableType::NATIVE_POINTER(),
3253 VariableType::JS_POINTER(),
3254 VariableType::JS_POINTER(),
3255 VariableType::INT32(),
3256 VariableType::INT32(),
3257 VariableType::INT32()
3258 };
3259 callSign->SetParameters(params.data());
3260 callSign->SetGCLeafFunction(true);
3261 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
3262 }
3263
DEF_CALL_SIGNATURE(CreateJSTypedArrayEntries)3264 DEF_CALL_SIGNATURE(CreateJSTypedArrayEntries)
3265 {
3266 // 2 : 2 input parameters
3267 CallSignature signature("CreateJSTypedArrayEntries", 0, 2,
3268 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3269 *callSign = signature;
3270 // 2 : 2 input parameters
3271 std::array<VariableType, 2> params = {
3272 VariableType::NATIVE_POINTER(), // glue
3273 VariableType::JS_ANY(), // obj
3274 };
3275 callSign->SetParameters(params.data());
3276 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
3277 }
3278
DEF_CALL_SIGNATURE(SameValue)3279 DEF_CALL_SIGNATURE(SameValue)
3280 {
3281 // 3 : 3 input parameters
3282 CallSignature signature("SameValue", 0, 3,
3283 ArgumentsOrder::DEFAULT_ORDER, VariableType::BOOL());
3284 *callSign = signature;
3285 // 3 : 3 input parameters
3286 std::array<VariableType, 3> params = {
3287 VariableType::NATIVE_POINTER(), // glue
3288 VariableType::JS_ANY(), // left
3289 VariableType::JS_ANY(), // right
3290 };
3291 callSign->SetParameters(params.data());
3292 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
3293 }
3294
DEF_CALL_SIGNATURE(CreateJSTypedArrayKeys)3295 DEF_CALL_SIGNATURE(CreateJSTypedArrayKeys)
3296 {
3297 // 2 : 2 input parameters
3298 CallSignature signature("CreateJSTypedArrayKeys", 0, 2,
3299 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3300 *callSign = signature;
3301 // 2 : 2 input parameters
3302 std::array<VariableType, 2> params = {
3303 VariableType::NATIVE_POINTER(), // glue
3304 VariableType::JS_ANY(), // obj
3305 };
3306 callSign->SetParameters(params.data());
3307 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
3308 }
3309
DEF_CALL_SIGNATURE(CreateJSTypedArrayValues)3310 DEF_CALL_SIGNATURE(CreateJSTypedArrayValues)
3311 {
3312 // 2 : 2 input parameters
3313 CallSignature signature("CreateJSTypedArrayValues", 0, 2,
3314 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
3315 *callSign = signature;
3316 // 2 : 2 input parameters
3317 std::array<VariableType, 2> params = {
3318 VariableType::NATIVE_POINTER(), // glue
3319 VariableType::JS_ANY(), // obj
3320 };
3321 callSign->SetParameters(params.data());
3322 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
3323 }
3324
DEF_CALL_SIGNATURE(GrowElementsCapacity)3325 DEF_CALL_SIGNATURE(GrowElementsCapacity)
3326 {
3327 // 6 : 6 input parameters
3328 CallSignature growElementsCapacity("GrowElementsCapacity", 0, 3, ArgumentsOrder::DEFAULT_ORDER,
3329 VariableType::JS_ANY());
3330 *callSign = growElementsCapacity;
3331 // 6 : 6 input parameters
3332 std::array<VariableType, 3> params = { // 3 : 3 input parameters
3333 VariableType::NATIVE_POINTER(), // glue
3334 VariableType::JS_ANY(), // thisValue
3335 VariableType::INT32(), // newlength
3336 };
3337 callSign->SetParameters(params.data());
3338 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
3339 }
3340 #define CREATE_RSET_SIGNATURE_COMMON(name) \
3341 CallSignature signature(#name, 0, 1, \
3342 ArgumentsOrder::DEFAULT_ORDER, VariableType::NATIVE_POINTER()); \
3343 *callSign = signature; \
3344 std::array<VariableType, 1> params = { \
3345 VariableType::NATIVE_POINTER(), \
3346 }; \
3347 callSign->SetParameters(params.data()); \
3348 callSign->SetGCLeafFunction(true); \
3349 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC)
3350
DEF_CALL_SIGNATURE(CreateLocalToShare)3351 DEF_CALL_SIGNATURE(CreateLocalToShare)
3352 {
3353 CREATE_RSET_SIGNATURE_COMMON(CreateLocalToShare);
3354 }
3355
DEF_CALL_SIGNATURE(CreateOldToNew)3356 DEF_CALL_SIGNATURE(CreateOldToNew)
3357 {
3358 CREATE_RSET_SIGNATURE_COMMON(CreateOldToNew);
3359 }
3360
3361 #undef CREATE_RSET_SIGNATURE_COMMON
3362
DEF_CALL_SIGNATURE(BatchBarrier)3363 DEF_CALL_SIGNATURE(BatchBarrier)
3364 {
3365 constexpr size_t paramCount = 4;
3366 CallSignature signature("BatchBarrier", 0, paramCount, ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3367 *callSign = signature;
3368 std::array<VariableType, paramCount> params = {
3369 VariableType::NATIVE_POINTER(),
3370 VariableType::NATIVE_POINTER(),
3371 VariableType::NATIVE_POINTER(),
3372 VariableType::INT32(),
3373 };
3374 callSign->SetParameters(params.data());
3375 callSign->SetGCLeafFunction(true);
3376 callSign->SetCallConv(CallSignature::CallConv::CCallConv);;
3377 }
DEF_CALL_SIGNATURE(ReverseBarrier)3378 DEF_CALL_SIGNATURE(ReverseBarrier)
3379 {
3380 constexpr size_t paramCount = 4;
3381 CallSignature signature("ReverseBarrier", 0, paramCount, ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3382 *callSign = signature;
3383 std::array<VariableType, paramCount> params = {
3384 VariableType::NATIVE_POINTER(),
3385 VariableType::NATIVE_POINTER(),
3386 VariableType::NATIVE_POINTER(),
3387 VariableType::INT32(),
3388 };
3389 callSign->SetParameters(params.data());
3390 callSign->SetGCLeafFunction(true);
3391 callSign->SetCallConv(CallSignature::CallConv::CCallConv);;
3392 }
3393
DEF_CALL_SIGNATURE(ObjectCopy)3394 DEF_CALL_SIGNATURE(ObjectCopy)
3395 {
3396 constexpr size_t paramCount = 3;
3397 // 3 : 3 input parameters
3398 CallSignature ArrayCopy("ObjectCopy", 0, paramCount,
3399 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3400 *callSign = ArrayCopy;
3401 // 3 : 3 input parameters
3402 std::array<VariableType, paramCount> params = {
3403 VariableType::NATIVE_POINTER(),
3404 VariableType::NATIVE_POINTER(),
3405 VariableType::INT32()
3406 };
3407 callSign->SetParameters(params.data());
3408 callSign->SetGCLeafFunction(true);
3409 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
3410 }
3411
DEF_CALL_SIGNATURE(MoveBarrierInRegion)3412 DEF_CALL_SIGNATURE(MoveBarrierInRegion)
3413 {
3414 constexpr size_t paramCount = 5;
3415 CallSignature signature("MoveBarrierInRegion", 0, paramCount, ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
3416 *callSign = signature;
3417 std::array<VariableType, paramCount> params = {
3418 VariableType::NATIVE_POINTER(),
3419 VariableType::NATIVE_POINTER(),
3420 VariableType::NATIVE_POINTER(),
3421 VariableType::INT32(),
3422 VariableType::NATIVE_POINTER(),
3423 };
3424 callSign->SetParameters(params.data());
3425 callSign->SetGCLeafFunction(true);
3426 callSign->SetCallConv(CallSignature::CallConv::CCallConv);;
3427 }
3428
DEF_CALL_SIGNATURE(MoveBarrierCrossRegion)3429 DEF_CALL_SIGNATURE(MoveBarrierCrossRegion)
3430 {
3431 constexpr size_t paramCount = 6;
3432 CallSignature signature("MoveBarrierCrossRegion", 0, paramCount, ArgumentsOrder::DEFAULT_ORDER,
3433 VariableType::VOID());
3434 *callSign = signature;
3435 std::array<VariableType, paramCount> params = {
3436 VariableType::NATIVE_POINTER(),
3437 VariableType::NATIVE_POINTER(),
3438 VariableType::NATIVE_POINTER(),
3439 VariableType::INT32(),
3440 VariableType::NATIVE_POINTER(),
3441 VariableType::NATIVE_POINTER(),
3442 };
3443 callSign->SetParameters(params.data());
3444 callSign->SetGCLeafFunction(true);
3445 callSign->SetCallConv(CallSignature::CallConv::CCallConv);;
3446 }
3447
DEF_CALL_SIGNATURE(FindEntryFromNameDictionary)3448 DEF_CALL_SIGNATURE(FindEntryFromNameDictionary)
3449 {
3450 constexpr size_t paramCount = 3;
3451 CallSignature signature("FindEntryFromNameDictionary", 0, paramCount, ArgumentsOrder::DEFAULT_ORDER,
3452 VariableType::INT32());
3453 *callSign = signature;
3454 std::array<VariableType, paramCount> params = {
3455 VariableType::NATIVE_POINTER(),
3456 VariableType::JS_ANY(),
3457 VariableType::JS_ANY(),
3458 };
3459 callSign->SetParameters(params.data());
3460 callSign->SetCallConv(CallSignature::CallConv::CCallConv);;
3461 }
3462 } // namespace panda::ecmascript::kungfu
3463