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 #include "llvm-c/Core.h"
29 #include "llvm/Support/Host.h"
30
31 #if defined(__clang__)
32 #pragma clang diagnostic pop
33 #elif defined(__GNUC__)
34 #pragma GCC diagnostic pop
35 #endif
36
37 namespace panda::ecmascript::kungfu {
38 #define BINARY_CALL_SIGNATURE(name) \
39 /* 3 : 3 input parameters */ \
40 CallSignature signature(#name, 0, 3, \
41 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); \
42 *callSign = signature; \
43 /* 3 : 3 input parameters */ \
44 std::array<VariableType, 3> params = { \
45 VariableType::NATIVE_POINTER(), \
46 VariableType::JS_ANY(), \
47 VariableType::JS_ANY(), \
48 }; \
49 callSign->SetParameters(params.data()); \
50 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
51
DEF_CALL_SIGNATURE(Add)52 DEF_CALL_SIGNATURE(Add)
53 {
54 BINARY_CALL_SIGNATURE(Add)
55 }
56
DEF_CALL_SIGNATURE(Sub)57 DEF_CALL_SIGNATURE(Sub)
58 {
59 BINARY_CALL_SIGNATURE(Sub)
60 }
61
DEF_CALL_SIGNATURE(Mul)62 DEF_CALL_SIGNATURE(Mul)
63 {
64 BINARY_CALL_SIGNATURE(Mul)
65 }
66
DEF_CALL_SIGNATURE(Div)67 DEF_CALL_SIGNATURE(Div)
68 {
69 BINARY_CALL_SIGNATURE(Div)
70 }
71
DEF_CALL_SIGNATURE(Mod)72 DEF_CALL_SIGNATURE(Mod)
73 {
74 BINARY_CALL_SIGNATURE(Mod)
75 }
76
DEF_CALL_SIGNATURE(Equal)77 DEF_CALL_SIGNATURE(Equal)
78 {
79 BINARY_CALL_SIGNATURE(Equal)
80 }
81
DEF_CALL_SIGNATURE(NotEqual)82 DEF_CALL_SIGNATURE(NotEqual)
83 {
84 BINARY_CALL_SIGNATURE(NotEqual)
85 }
86
DEF_CALL_SIGNATURE(Less)87 DEF_CALL_SIGNATURE(Less)
88 {
89 BINARY_CALL_SIGNATURE(Less)
90 }
91
DEF_CALL_SIGNATURE(LessEq)92 DEF_CALL_SIGNATURE(LessEq)
93 {
94 BINARY_CALL_SIGNATURE(LessEq)
95 }
96
DEF_CALL_SIGNATURE(Greater)97 DEF_CALL_SIGNATURE(Greater)
98 {
99 BINARY_CALL_SIGNATURE(Greater)
100 }
101
DEF_CALL_SIGNATURE(GreaterEq)102 DEF_CALL_SIGNATURE(GreaterEq)
103 {
104 BINARY_CALL_SIGNATURE(GreaterEq)
105 }
106
DEF_CALL_SIGNATURE(Shl)107 DEF_CALL_SIGNATURE(Shl)
108 {
109 BINARY_CALL_SIGNATURE(Shl)
110 }
111
DEF_CALL_SIGNATURE(Shr)112 DEF_CALL_SIGNATURE(Shr)
113 {
114 BINARY_CALL_SIGNATURE(Shr)
115 }
116
DEF_CALL_SIGNATURE(Ashr)117 DEF_CALL_SIGNATURE(Ashr)
118 {
119 BINARY_CALL_SIGNATURE(Ashr)
120 }
121
DEF_CALL_SIGNATURE(And)122 DEF_CALL_SIGNATURE(And)
123 {
124 BINARY_CALL_SIGNATURE(And)
125 }
126
DEF_CALL_SIGNATURE(Or)127 DEF_CALL_SIGNATURE(Or)
128 {
129 BINARY_CALL_SIGNATURE(Or)
130 }
131
DEF_CALL_SIGNATURE(Xor)132 DEF_CALL_SIGNATURE(Xor)
133 {
134 BINARY_CALL_SIGNATURE(Xor)
135 }
136
DEF_CALL_SIGNATURE(Instanceof)137 DEF_CALL_SIGNATURE(Instanceof)
138 {
139 BINARY_CALL_SIGNATURE(Instanceof)
140 }
141
142 #ifndef NDEBUG
DEF_CALL_SIGNATURE(MulGCTest)143 DEF_CALL_SIGNATURE(MulGCTest)
144 {
145 // 3 : 3 input parameters
146 CallSignature MulGC("MulGCTest", 0, 3, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
147 *callSign = MulGC;
148 // 3 : 3 input parameters
149 std::array<VariableType, 3> params = {
150 VariableType::NATIVE_POINTER(),
151 VariableType::INT64(),
152 VariableType::INT64(),
153 };
154 callSign->SetParameters(params.data());
155 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
156 }
157 #else
DEF_CALL_SIGNATURE(MulGCTest)158 DEF_CALL_SIGNATURE(MulGCTest) {}
159 #endif
160
161 #define UNARY_CALL_SIGNATURE(name) \
162 /* 2 : 2 input parameters */ \
163 CallSignature signature(#name, 0, 2, \
164 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); \
165 *callSign = signature; \
166 /* 2 : 2 input parameters */ \
167 std::array<VariableType, 2> params = { \
168 VariableType::NATIVE_POINTER(), \
169 VariableType::JS_ANY(), \
170 }; \
171 callSign->SetParameters(params.data()); \
172 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
173
DEF_CALL_SIGNATURE(Inc)174 DEF_CALL_SIGNATURE(Inc)
175 {
176 UNARY_CALL_SIGNATURE(Inc)
177 }
178
DEF_CALL_SIGNATURE(Dec)179 DEF_CALL_SIGNATURE(Dec)
180 {
181 UNARY_CALL_SIGNATURE(Dec)
182 }
183
DEF_CALL_SIGNATURE(Neg)184 DEF_CALL_SIGNATURE(Neg)
185 {
186 UNARY_CALL_SIGNATURE(Neg)
187 }
188
DEF_CALL_SIGNATURE(Not)189 DEF_CALL_SIGNATURE(Not)
190 {
191 UNARY_CALL_SIGNATURE(Not)
192 }
193
DEF_CALL_SIGNATURE(ToBoolean)194 DEF_CALL_SIGNATURE(ToBoolean)
195 {
196 UNARY_CALL_SIGNATURE(ToBoolean)
197 }
198
DEF_CALL_SIGNATURE(TypeOf)199 DEF_CALL_SIGNATURE(TypeOf)
200 {
201 // 2 input parameters
202 CallSignature TypeOf("TypeOf", 0, 2, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_POINTER());
203 *callSign = TypeOf;
204 // 2 input parameters
205 std::array<VariableType, 2> params = {
206 VariableType::NATIVE_POINTER(), // glue
207 VariableType::JS_ANY(), // ACC
208 };
209 callSign->SetParameters(params.data());
210 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
211 }
212
DEF_CALL_SIGNATURE(SetPropertyByName)213 DEF_CALL_SIGNATURE(SetPropertyByName)
214 {
215 // 6 : 6 input parameters
216 CallSignature setPropertyByName("SetPropertyByName", 0, 6, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
217 *callSign = setPropertyByName;
218 // 6 : 6 input parameters
219 std::array<VariableType, 6> params = {
220 VariableType::NATIVE_POINTER(), // glue
221 VariableType::JS_ANY(), // receiver
222 VariableType::JS_POINTER(), // key
223 VariableType::JS_ANY(), // value
224 VariableType::JS_POINTER(), // profileTypeInfo
225 VariableType::INT32(), // slot id
226 };
227 callSign->SetParameters(params.data());
228 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
229 }
230
DEF_CALL_SIGNATURE(DeprecatedSetPropertyByName)231 DEF_CALL_SIGNATURE(DeprecatedSetPropertyByName)
232 {
233 // 4 : 4 input parameters
234 CallSignature setPropertyByName("DeprecatedSetPropertyByName", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
235 VariableType::JS_ANY());
236 *callSign = setPropertyByName;
237 // 4 : 4 input parameters
238 std::array<VariableType, 4> params = {
239 VariableType::NATIVE_POINTER(),
240 VariableType::JS_POINTER(),
241 VariableType::JS_POINTER(),
242 VariableType::JS_ANY()
243 };
244 callSign->SetParameters(params.data());
245 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
246 }
247
DEF_CALL_SIGNATURE(SetPropertyByNameWithOwn)248 DEF_CALL_SIGNATURE(SetPropertyByNameWithOwn)
249 {
250 // 4 : 4 input parameters
251 CallSignature setPropertyByNameWithOwn("SetPropertyByNameWithOwn", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
252 VariableType::JS_ANY());
253 *callSign = setPropertyByNameWithOwn;
254 // 4 : 4 input parameters
255 std::array<VariableType, 4> params = {
256 VariableType::NATIVE_POINTER(),
257 VariableType::JS_POINTER(),
258 VariableType::JS_POINTER(),
259 VariableType::JS_ANY()
260 };
261 callSign->SetParameters(params.data());
262 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
263 }
264
DEF_CALL_SIGNATURE(SetPropertyByValue)265 DEF_CALL_SIGNATURE(SetPropertyByValue)
266 {
267 // 6 : 6 input parameters
268 CallSignature setPropertyByName("SetPropertyByValue", 0, 6, ArgumentsOrder::DEFAULT_ORDER,
269 VariableType::JS_ANY());
270 *callSign = setPropertyByName;
271 // 6 : 6 input parameters
272 std::array<VariableType, 6> params = {
273 VariableType::NATIVE_POINTER(),
274 VariableType::JS_POINTER(),
275 VariableType::JS_ANY(),
276 VariableType::JS_ANY(),
277 VariableType::JS_POINTER(),
278 VariableType::INT32(),
279 };
280 callSign->SetParameters(params.data());
281 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
282 }
283
DEF_CALL_SIGNATURE(DeprecatedSetPropertyByValue)284 DEF_CALL_SIGNATURE(DeprecatedSetPropertyByValue)
285 {
286 // 4 : 4 input parameters
287 CallSignature setPropertyByName("DeprecatedSetPropertyByValue", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
288 VariableType::JS_ANY());
289 *callSign = setPropertyByName;
290 // 4 : 4 input parameters
291 std::array<VariableType, 4> params = {
292 VariableType::NATIVE_POINTER(),
293 VariableType::JS_POINTER(),
294 VariableType::JS_ANY(),
295 VariableType::JS_ANY()
296 };
297 callSign->SetParameters(params.data());
298 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
299 }
300
DEF_CALL_SIGNATURE(SetPropertyByValueWithOwn)301 DEF_CALL_SIGNATURE(SetPropertyByValueWithOwn)
302 {
303 // 4 : 4 input parameters
304 CallSignature setPropertyByValueWithOwn("SetPropertyByValueWithOwn", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
305 VariableType::JS_ANY());
306 *callSign = setPropertyByValueWithOwn;
307 // 4 : 4 input parameters
308 std::array<VariableType, 4> params = {
309 VariableType::NATIVE_POINTER(),
310 VariableType::JS_POINTER(),
311 VariableType::JS_ANY(),
312 VariableType::JS_ANY()
313 };
314 callSign->SetParameters(params.data());
315 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
316 }
317
DEF_CALL_SIGNATURE(GetPropertyByName)318 DEF_CALL_SIGNATURE(GetPropertyByName)
319 {
320 // 5 : 5 input parameters
321 CallSignature getPropertyByName("GetPropertyByName", 0, 5, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
322 *callSign = getPropertyByName;
323 // 5 : 5 input parameters
324 std::array<VariableType, 5> params = {
325 VariableType::NATIVE_POINTER(), // glue
326 VariableType::JS_ANY(), // receiver
327 VariableType::JS_POINTER(), // key
328 VariableType::JS_POINTER(), // profileTypeInfo
329 VariableType::INT32(), // slot id
330 };
331 callSign->SetParameters(params.data());
332 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
333 }
334
DEF_CALL_SIGNATURE(DeprecatedGetPropertyByName)335 DEF_CALL_SIGNATURE(DeprecatedGetPropertyByName)
336 {
337 // 3 : 3 input parameters
338 CallSignature getPropertyByName("DeprecatedGetPropertyByName", 0, 3, ArgumentsOrder::DEFAULT_ORDER,
339 VariableType::JS_ANY());
340 *callSign = getPropertyByName;
341 // 3 : 3 input parameters
342 std::array<VariableType, 3> params = {
343 VariableType::NATIVE_POINTER(), // glue
344 VariableType::JS_ANY(), // receiver
345 VariableType::JS_POINTER(), // key
346 };
347 callSign->SetParameters(params.data());
348 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
349 }
350
DEF_CALL_SIGNATURE(TryLdGlobalByName)351 DEF_CALL_SIGNATURE(TryLdGlobalByName)
352 {
353 // 4 : 4 input parameters
354 CallSignature signature("TryLdGlobalByName", 0, 4, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
355 *callSign = signature;
356 // 4 : 4 input parameters
357 std::array<VariableType, 4> params = {
358 VariableType::NATIVE_POINTER(), // glue
359 VariableType::JS_POINTER(), // key
360 VariableType::JS_POINTER(), // profileTypeInfo
361 VariableType::INT32(), // slot id
362 };
363 callSign->SetParameters(params.data());
364 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
365 }
366
DEF_CALL_SIGNATURE(TryStGlobalByName)367 DEF_CALL_SIGNATURE(TryStGlobalByName)
368 {
369 // 5 : 5 input parameters
370 CallSignature signature("TryStGlobalByName", 0, 5, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
371 *callSign = signature;
372 // 5 : 5 input parameters
373 std::array<VariableType, 5> params = {
374 VariableType::NATIVE_POINTER(), // glue
375 VariableType::JS_POINTER(), // key
376 VariableType::JS_ANY(), // value
377 VariableType::JS_POINTER(), // profileTypeInfo
378 VariableType::INT32(), // slot id
379 };
380 callSign->SetParameters(params.data());
381 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
382 }
383
DEF_CALL_SIGNATURE(LdGlobalVar)384 DEF_CALL_SIGNATURE(LdGlobalVar)
385 {
386 // 4 : 4 input parameters
387 CallSignature signature("LdGlobalVar", 0, 4, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
388 *callSign = signature;
389 // 4 : 4 input parameters
390 std::array<VariableType, 4> params = {
391 VariableType::NATIVE_POINTER(), // glue
392 VariableType::JS_POINTER(), // key
393 VariableType::JS_POINTER(), // profileTypeInfo
394 VariableType::INT32(), // slot id
395 };
396 callSign->SetParameters(params.data());
397 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
398 }
399
DEF_CALL_SIGNATURE(StGlobalVar)400 DEF_CALL_SIGNATURE(StGlobalVar)
401 {
402 // 5 : 5 input parameters
403 CallSignature signature("StGlobalVar", 0, 5, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
404 *callSign = signature;
405 // 5 : 5 input parameters
406 std::array<VariableType, 5> params = {
407 VariableType::NATIVE_POINTER(), // glue
408 VariableType::JS_POINTER(), // key
409 VariableType::JS_ANY(), // value
410 VariableType::JS_POINTER(), // profileTypeInfo
411 VariableType::INT32(), // slot id
412 };
413 callSign->SetParameters(params.data());
414 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
415 }
416
DEF_CALL_SIGNATURE(GetPropertyByIndex)417 DEF_CALL_SIGNATURE(GetPropertyByIndex)
418 {
419 // 3 : 3 input parameters
420 CallSignature getPropertyByIndex("GetPropertyByIndex", 0, 3, ArgumentsOrder::DEFAULT_ORDER,
421 VariableType::JS_ANY());
422 *callSign = getPropertyByIndex;
423 // 3 : 3 input parameters
424 std::array<VariableType, 3> params = {
425 VariableType::NATIVE_POINTER(), // glue
426 VariableType::JS_ANY(), // receiver
427 VariableType::INT32(), // index
428 };
429 callSign->SetParameters(params.data());
430 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
431 }
432
DEF_CALL_SIGNATURE(SetPropertyByIndex)433 DEF_CALL_SIGNATURE(SetPropertyByIndex)
434 {
435 // 4 : 4 input parameters
436 CallSignature setPropertyByIndex("SetPropertyByIndex", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
437 VariableType::JS_ANY()); // hole or undefined
438 *callSign = setPropertyByIndex;
439 // 4 : 4 input parameters
440 std::array<VariableType, 4> params = {
441 VariableType::NATIVE_POINTER(),
442 VariableType::JS_POINTER(),
443 VariableType::INT32(),
444 VariableType::JS_ANY()
445 };
446 callSign->SetParameters(params.data());
447 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
448 }
449
DEF_CALL_SIGNATURE(SetPropertyByIndexWithOwn)450 DEF_CALL_SIGNATURE(SetPropertyByIndexWithOwn)
451 {
452 // 4 : 4 input parameters
453 CallSignature setPropertyByIndexWithOwn("SetPropertyByIndexWithOwn", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
454 VariableType::JS_ANY()); // hole or undefined
455 *callSign = setPropertyByIndexWithOwn;
456 // 4 : 4 input parameters
457 std::array<VariableType, 4> params = {
458 VariableType::NATIVE_POINTER(),
459 VariableType::JS_POINTER(),
460 VariableType::INT32(),
461 VariableType::JS_ANY()
462 };
463 callSign->SetParameters(params.data());
464 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
465 }
466
DEF_CALL_SIGNATURE(GetPropertyByValue)467 DEF_CALL_SIGNATURE(GetPropertyByValue)
468 {
469 // 5 : 5 input parameters
470 CallSignature getPropertyByValue("GetPropertyByValue", 0, 5, ArgumentsOrder::DEFAULT_ORDER,
471 VariableType::JS_ANY());
472 *callSign = getPropertyByValue;
473 // 5 : 5 input parameters
474 std::array<VariableType, 5> params = {
475 VariableType::NATIVE_POINTER(),
476 VariableType::JS_POINTER(),
477 VariableType::JS_ANY(),
478 VariableType::JS_POINTER(),
479 VariableType::INT32(),
480 };
481 callSign->SetParameters(params.data());
482 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
483 }
484
DEF_CALL_SIGNATURE(DeprecatedGetPropertyByValue)485 DEF_CALL_SIGNATURE(DeprecatedGetPropertyByValue)
486 {
487 // 3 : 3 input parameters
488 CallSignature getPropertyByValue("DeprecatedGetPropertyByValue", 0, 3, ArgumentsOrder::DEFAULT_ORDER,
489 VariableType::JS_ANY());
490 *callSign = getPropertyByValue;
491 // 3 : 3 input parameters
492 std::array<VariableType, 3> params = {
493 VariableType::NATIVE_POINTER(),
494 VariableType::JS_POINTER(),
495 VariableType::JS_ANY(),
496 };
497 callSign->SetParameters(params.data());
498 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
499 }
500
DEF_CALL_SIGNATURE(TryLoadICByName)501 DEF_CALL_SIGNATURE(TryLoadICByName)
502 {
503 // 4 : 4 input parameters
504 CallSignature tryLoadICByName("TryLoadICByName", 0, 4,
505 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
506 *callSign = tryLoadICByName;
507 // 4 : 4 input parameters
508 std::array<VariableType, 4> params = {
509 VariableType::NATIVE_POINTER(),
510 VariableType::JS_ANY(),
511 VariableType::JS_ANY(),
512 VariableType::JS_ANY(),
513 };
514 callSign->SetParameters(params.data());
515 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
516 }
517
DEF_CALL_SIGNATURE(TryLoadICByValue)518 DEF_CALL_SIGNATURE(TryLoadICByValue)
519 {
520 // 5 : 5 input parameters
521 CallSignature tryLoadICByValue("TryLoadICByValue", 0, 5,
522 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
523 *callSign = tryLoadICByValue;
524 // 5 : 5 input parameters
525 std::array<VariableType, 5> params = {
526 VariableType::NATIVE_POINTER(),
527 VariableType::JS_ANY(),
528 VariableType::JS_ANY(),
529 VariableType::JS_ANY(),
530 VariableType::JS_ANY(),
531 };
532 callSign->SetParameters(params.data());
533 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
534 }
535
DEF_CALL_SIGNATURE(TryStoreICByName)536 DEF_CALL_SIGNATURE(TryStoreICByName)
537 {
538 // 5 : 5 input parameters
539 CallSignature tryStoreICByName("TryStoreICByName", 0, 5,
540 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); // undefined or hole
541 *callSign = tryStoreICByName;
542 // 5 : 5 input parameters
543 std::array<VariableType, 5> params = {
544 VariableType::NATIVE_POINTER(),
545 VariableType::JS_POINTER(),
546 VariableType::JS_ANY(),
547 VariableType::JS_ANY(),
548 VariableType::JS_POINTER(),
549 };
550 callSign->SetParameters(params.data());
551 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
552 }
553
DEF_CALL_SIGNATURE(TryStoreICByValue)554 DEF_CALL_SIGNATURE(TryStoreICByValue)
555 {
556 // 6 : 6 input parameters
557 CallSignature tryStoreICByValue("TryStoreICByValue", 0, 6,
558 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); // undefined or hole
559 *callSign = tryStoreICByValue;
560 // 6 : 6 input parameters
561 std::array<VariableType, 6> params = {
562 VariableType::NATIVE_POINTER(),
563 VariableType::JS_POINTER(),
564 VariableType::JS_ANY(),
565 VariableType::JS_ANY(),
566 VariableType::JS_ANY(),
567 VariableType::JS_POINTER(),
568 };
569 callSign->SetParameters(params.data());
570 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
571 }
572
DEF_CALL_SIGNATURE(SetValueWithBarrier)573 DEF_CALL_SIGNATURE(SetValueWithBarrier)
574 {
575 // 4 : 4 input parameters
576 CallSignature setValueWithBarrier("SetValueWithBarrier", 0, 4, ArgumentsOrder::DEFAULT_ORDER,
577 VariableType::VOID());
578 *callSign = setValueWithBarrier;
579
580 std::array<VariableType, 4> params = { // 4 : 4 input parameters
581 VariableType::NATIVE_POINTER(),
582 VariableType::JS_POINTER(),
583 VariableType::NATIVE_POINTER(),
584 VariableType::JS_ANY()
585 };
586 callSign->SetParameters(params.data());
587 callSign->SetGCLeafFunction(true);
588 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
589 }
590
DEF_CALL_SIGNATURE(NewThisObjectChecked)591 DEF_CALL_SIGNATURE(NewThisObjectChecked)
592 {
593 // 2 : 2 input parameters
594 CallSignature signature("NewThisObjectChecked", 0, 2,
595 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
596 *callSign = signature;
597 // 2 : 2 input parameters
598 std::array<VariableType, 2> params = {
599 VariableType::NATIVE_POINTER(), // glue
600 VariableType::JS_ANY(), // ctor
601 };
602 callSign->SetParameters(params.data());
603 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
604 }
605
DEF_CALL_SIGNATURE(ConstructorCheck)606 DEF_CALL_SIGNATURE(ConstructorCheck)
607 {
608 // 4 : 4 input parameters
609 CallSignature signature("ConstructorCheck", 0, 4,
610 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
611 *callSign = signature;
612 // 4 : 4 input parameters
613 std::array<VariableType, 4> params = {
614 VariableType::NATIVE_POINTER(), // glue
615 VariableType::JS_ANY(), // ctor
616 VariableType::JS_ANY(), // result
617 VariableType::JS_ANY(), // thisObj
618 };
619 callSign->SetParameters(params.data());
620 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
621 }
622
DEF_CALL_SIGNATURE(NewLexicalEnv)623 DEF_CALL_SIGNATURE(NewLexicalEnv)
624 {
625 // 3 : 3 input parameters
626 CallSignature signature("NewLexicalEnv", 0, 3,
627 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
628 *callSign = signature;
629 // 3 : 3 input parameters
630 std::array<VariableType, 3> params = {
631 VariableType::NATIVE_POINTER(), // glue
632 VariableType::JS_ANY(), // parent
633 VariableType::INT32(), // numArgs
634 };
635 callSign->SetParameters(params.data());
636 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
637 }
638
DEF_CALL_SIGNATURE(GetUnmapedArgs)639 DEF_CALL_SIGNATURE(GetUnmapedArgs)
640 {
641 // 2 : 2 input parameters
642 CallSignature signature("GetUnmapedArgs", 0, 2,
643 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
644 *callSign = signature;
645 // 2 : 2 input parameters
646 std::array<VariableType, 2> params = {
647 VariableType::NATIVE_POINTER(), // glue
648 VariableType::INT32(), // numArgs
649 };
650 callSign->SetParameters(params.data());
651 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
652 }
653
DEF_CALL_SIGNATURE(GetTaggedArrayPtrTest)654 DEF_CALL_SIGNATURE(GetTaggedArrayPtrTest)
655 {
656 // 2 : 2 input parameters
657 CallSignature getTaggedArrayPtr("GetTaggedArrayPtrTest", 0, 2, ArgumentsOrder::DEFAULT_ORDER,
658 VariableType::JS_POINTER());
659 *callSign = getTaggedArrayPtr;
660 // 2 : 2 input parameters
661 std::array<VariableType, 2> params = {
662 VariableType::NATIVE_POINTER(),
663 VariableType::JS_ANY(),
664 };
665 callSign->SetParameters(params.data());
666 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
667 }
668
DEF_CALL_SIGNATURE(Builtins)669 DEF_CALL_SIGNATURE(Builtins)
670 {
671 // 9 : 9 input parameters
672 CallSignature builtins("Builtins", 0, 9,
673 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
674 *callSign = builtins;
675 std::array<VariableType, 9> params = { // 9 : 9 input parameters
676 VariableType::NATIVE_POINTER(), // glue
677 VariableType::NATIVE_POINTER(), // native code
678 VariableType::JS_ANY(), // func
679 VariableType::JS_ANY(), // new target
680 VariableType::JS_ANY(), // this
681 VariableType::NATIVE_POINTER(), // argc
682 VariableType::JS_ANY(), // arg0
683 VariableType::JS_ANY(), // arg1
684 VariableType::JS_ANY(), // arg2
685 };
686 callSign->SetVariadicArgs(true);
687 callSign->SetParameters(params.data());
688 callSign->SetTargetKind(CallSignature::TargetKind::BUILTINS_STUB);
689 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
690 }
691
DEF_CALL_SIGNATURE(BuiltinsWithArgv)692 DEF_CALL_SIGNATURE(BuiltinsWithArgv)
693 {
694 // 7 : 7 input parameters
695 CallSignature builtinsWtihArgv("Builtins", 0, 7,
696 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
697 *callSign = builtinsWtihArgv;
698 std::array<VariableType, 7> params = { // 7 : 7 input parameters
699 VariableType::NATIVE_POINTER(), // glue
700 VariableType::NATIVE_POINTER(), // nativeCode
701 VariableType::JS_ANY(), // func
702 VariableType::JS_ANY(), // new target
703 VariableType::JS_ANY(), // this
704 VariableType::NATIVE_POINTER(), // argc
705 VariableType::NATIVE_POINTER(), // argv
706 };
707 callSign->SetParameters(params.data());
708 callSign->SetTargetKind(CallSignature::TargetKind::BUILTINS_WITH_ARGV_STUB);
709 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
710 }
711
DEF_CALL_SIGNATURE(BytecodeHandler)712 DEF_CALL_SIGNATURE(BytecodeHandler)
713 {
714 // 7 : 7 input parameters
715 CallSignature bytecodeHandler("BytecodeHandler", 0, 7,
716 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
717 *callSign = bytecodeHandler;
718 // 7 : 7 input parameters
719 std::array<VariableType, 7> params = {
720 VariableType::NATIVE_POINTER(),
721 VariableType::NATIVE_POINTER(),
722 VariableType::NATIVE_POINTER(),
723 VariableType::JS_POINTER(),
724 VariableType::JS_POINTER(),
725 VariableType::JS_ANY(),
726 VariableType::INT32(),
727 };
728 callSign->SetParameters(params.data());
729 callSign->SetTargetKind(CallSignature::TargetKind::BYTECODE_HANDLER);
730 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
731 }
732
DEF_CALL_SIGNATURE(BytecodeDebuggerHandler)733 DEF_CALL_SIGNATURE(BytecodeDebuggerHandler)
734 {
735 // 7 : 7 input parameters
736 CallSignature bytecodeHandler("BytecodeDebuggerHandler", 0, 7,
737 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
738 *callSign = bytecodeHandler;
739 // 7 : 7 input parameters
740 std::array<VariableType, 7> params = { VariableType::NATIVE_POINTER(),
741 VariableType::NATIVE_POINTER(),
742 VariableType::NATIVE_POINTER(),
743 VariableType::JS_POINTER(),
744 VariableType::JS_POINTER(),
745 VariableType::JS_ANY(),
746 VariableType::INT32() };
747 callSign->SetParameters(params.data());
748 callSign->SetTargetKind(CallSignature::TargetKind::BYTECODE_DEBUGGER_HANDLER);
749 }
750
DEF_CALL_SIGNATURE(CallRuntime)751 DEF_CALL_SIGNATURE(CallRuntime)
752 {
753 /* 3 : 3 input parameters */
754 CallSignature runtimeCallTrampoline("CallRuntime", 0, 3,
755 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
756 *callSign = runtimeCallTrampoline;
757 /* 3 : 3 input parameters */
758 std::array<VariableType, 3> params = {
759 VariableType::NATIVE_POINTER(),
760 VariableType::INT64(),
761 VariableType::INT64(),
762 };
763 callSign->SetVariadicArgs(true);
764 callSign->SetParameters(params.data());
765 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
766 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
767 }
768
DEF_CALL_SIGNATURE(AsmInterpreterEntry)769 DEF_CALL_SIGNATURE(AsmInterpreterEntry)
770 {
771 /* 3 : 3 input parameters */
772 CallSignature asmInterpreterEntry("AsmInterpreterEntry", 0, 3,
773 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
774 *callSign = asmInterpreterEntry;
775 /* 3 : 3 input parameters */
776 std::array<VariableType, 3> params = {
777 VariableType::NATIVE_POINTER(), // glue
778 VariableType::INT32(), // argc
779 VariableType::NATIVE_POINTER(), // argv
780 };
781 callSign->SetParameters(params.data());
782 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
783 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
784 }
785
DEF_CALL_SIGNATURE(GeneratorReEnterAsmInterp)786 DEF_CALL_SIGNATURE(GeneratorReEnterAsmInterp)
787 {
788 /* 2 : 2 input parameters */
789 CallSignature generatorReEnterAsmInterp("GeneratorReEnterAsmInterp", 0, 2,
790 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
791 *callSign = generatorReEnterAsmInterp;
792 std::array<VariableType, 2> params = { /* 2 : 2 input parameters */
793 VariableType::NATIVE_POINTER(), // glue
794 VariableType::JS_POINTER(), // context
795 };
796 callSign->SetParameters(params.data());
797 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
798 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
799 }
800
DEF_CALL_SIGNATURE(CallRuntimeWithArgv)801 DEF_CALL_SIGNATURE(CallRuntimeWithArgv)
802 {
803 /* 4 : 4 input parameters */
804 CallSignature runtimeCallTrampoline("CallRuntimeWithArgv", 0, 4,
805 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
806 *callSign = runtimeCallTrampoline;
807 std::array<VariableType, 4> params = { /* 4 : 4 input parameters */
808 VariableType::NATIVE_POINTER(), // glue
809 VariableType::INT64(), // runtimeId
810 VariableType::INT64(), // argc
811 VariableType::NATIVE_POINTER(), // argv
812 };
813 callSign->SetVariadicArgs(false);
814 callSign->SetParameters(params.data());
815 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_VARARGS);
816 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
817 }
818
DEF_CALL_SIGNATURE(OptimizedCallOptimized)819 DEF_CALL_SIGNATURE(OptimizedCallOptimized)
820 {
821 /* 4 : 4 input parameters */
822 CallSignature runtimeCallTrampoline("OptimizedCallOptimized", 0, 4,
823 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
824 *callSign = runtimeCallTrampoline;
825 std::array<VariableType, 4> params = { /* 4 : 4 input parameters */
826 VariableType::NATIVE_POINTER(),
827 VariableType::INT64(),
828 VariableType::INT64(),
829 VariableType::NATIVE_POINTER(),
830 };
831 callSign->SetVariadicArgs(true);
832 callSign->SetParameters(params.data());
833 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
834 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
835 }
836
DEF_CALL_SIGNATURE(JSCall)837 DEF_CALL_SIGNATURE(JSCall)
838 {
839 // 6 : 6 input parameters
840 CallSignature jSCall("JSCall", 0, 6,
841 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
842 *callSign = jSCall;
843 std::array<VariableType, 6> params = { // 6 : 6 input parameters
844 VariableType::NATIVE_POINTER(), // glue
845 VariableType::JS_ANY(), // lexenv
846 VariableType::INT64(), // actual argC
847 VariableType::JS_ANY(), // call target
848 VariableType::JS_ANY(), // new target
849 VariableType::JS_ANY(), // thisobj
850 };
851 callSign->SetVariadicArgs(true);
852 callSign->SetParameters(params.data());
853 callSign->SetCallConv(CallSignature::CallConv::WebKitJSCallConv);
854 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
855 }
856
DEF_CALL_SIGNATURE(JSCallNew)857 DEF_CALL_SIGNATURE(JSCallNew)
858 {
859 // 6 : 6 input parameters
860 CallSignature jSCallNew("JSCallNew", 0, 6,
861 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
862 *callSign = jSCallNew;
863 std::array<VariableType, 6> params = { // 6 : 6 input parameters
864 VariableType::NATIVE_POINTER(), // glue
865 VariableType::JS_ANY(), // lexenv
866 VariableType::INT64(), // actual argC
867 VariableType::JS_ANY(), // call target
868 VariableType::JS_ANY(), // new target
869 VariableType::JS_ANY(), // thisobj
870 };
871 callSign->SetVariadicArgs(true);
872 callSign->SetParameters(params.data());
873 callSign->SetCallConv(CallSignature::CallConv::WebKitJSCallConv);
874 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
875 }
876
DEF_CALL_SIGNATURE(ConstructorJSCall)877 DEF_CALL_SIGNATURE(ConstructorJSCall)
878 {
879 // 6 : 6 input parameters
880 CallSignature constructorJsCall("ConstructorJSCall", 0, 6,
881 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
882 *callSign = constructorJsCall;
883 std::array<VariableType, 6> params = { // 6 : 6 input parameters
884 VariableType::NATIVE_POINTER(), // glue
885 VariableType::JS_ANY(), // lexenv
886 VariableType::INT64(), // actual argC
887 VariableType::JS_ANY(), // call target
888 VariableType::JS_ANY(), // new target
889 VariableType::JS_ANY(), // thisobj
890 };
891 callSign->SetVariadicArgs(true);
892 callSign->SetParameters(params.data());
893 callSign->SetCallConv(CallSignature::CallConv::WebKitJSCallConv);
894 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
895 }
896
DEF_CALL_SIGNATURE(JSProxyCallInternalWithArgV)897 DEF_CALL_SIGNATURE(JSProxyCallInternalWithArgV)
898 {
899 // 4 : 4 input parameters
900 CallSignature jSProxyCallInternalWithArgV("JSProxyCallInternalWithArgV", 0, 4,
901 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
902 *callSign = jSProxyCallInternalWithArgV;
903 std::array<VariableType, 4> params = { // 4 : 4 input parameters
904 VariableType::NATIVE_POINTER(), // glue
905 VariableType::INT64(), // actual argC
906 VariableType::JS_ANY(), // call target
907 VariableType::NATIVE_POINTER(), // argv
908 };
909 callSign->SetParameters(params.data());
910 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
911 callSign->SetGCLeafFunction(true);
912 callSign->SetTailCall(true);
913 }
914
DEF_CALL_SIGNATURE(JSFunctionEntry)915 DEF_CALL_SIGNATURE(JSFunctionEntry)
916 {
917 // 5 : 5 input parameters
918 CallSignature jsCallFunctionEntry("JSFunctionEntry", 0, 5,
919 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
920 *callSign = jsCallFunctionEntry;
921 std::array<VariableType, 5> params = { // 5 : 5 input parameters
922 VariableType::NATIVE_POINTER(), // glue
923 VariableType::INT64(), // argc
924 VariableType::NATIVE_POINTER(), // argv
925 VariableType::NATIVE_POINTER(), // prevFp
926 VariableType::BOOL(), // isNew
927 };
928 callSign->SetParameters(params.data());
929 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
930 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
931 }
932
DEF_CALL_SIGNATURE(ResumeRspAndDispatch)933 DEF_CALL_SIGNATURE(ResumeRspAndDispatch)
934 {
935 // 8 : 8 input parameters
936 CallSignature resumeRspAndDispatch("ResumeRspAndDispatch", 0, 8,
937 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
938 *callSign = resumeRspAndDispatch;
939 std::array<VariableType, 8> params = { // 8 : 8 input parameters
940 VariableType::NATIVE_POINTER(),
941 VariableType::NATIVE_POINTER(),
942 VariableType::NATIVE_POINTER(),
943 VariableType::JS_POINTER(),
944 VariableType::JS_POINTER(),
945 VariableType::JS_ANY(),
946 VariableType::INT32(),
947 VariableType::NATIVE_POINTER(),
948 };
949 callSign->SetParameters(params.data());
950 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
951 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
952 }
953
DEF_CALL_SIGNATURE(ResumeRspAndReturn)954 DEF_CALL_SIGNATURE(ResumeRspAndReturn)
955 {
956 // 3 : 3 input parameters
957 CallSignature resumeRspAndReturn("ResumeRspAndReturn", 0, 3,
958 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
959 *callSign = resumeRspAndReturn;
960 std::array<VariableType, 3> params = { // 3 : 3 input parameters
961 VariableType::JS_ANY(),
962 VariableType::NATIVE_POINTER(),
963 VariableType::NATIVE_POINTER(),
964 };
965 callSign->SetParameters(params.data());
966 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
967 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
968 }
969
DEF_CALL_SIGNATURE(ResumeCaughtFrameAndDispatch)970 DEF_CALL_SIGNATURE(ResumeCaughtFrameAndDispatch)
971 {
972 // 7 : 7 input parameters
973 CallSignature resumeCaughtFrameAndDispatch("ResumeCaughtFrameAndDispatch", 0, 7,
974 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
975 *callSign = resumeCaughtFrameAndDispatch;
976 // 7 : 7 input parameters
977 std::array<VariableType, 7> params = {
978 VariableType::NATIVE_POINTER(),
979 VariableType::NATIVE_POINTER(),
980 VariableType::NATIVE_POINTER(),
981 VariableType::JS_POINTER(),
982 VariableType::JS_POINTER(),
983 VariableType::JS_ANY(),
984 VariableType::INT32(),
985 };
986 callSign->SetParameters(params.data());
987 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
988 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
989 }
990
DEF_CALL_SIGNATURE(ResumeUncaughtFrameAndReturn)991 DEF_CALL_SIGNATURE(ResumeUncaughtFrameAndReturn)
992 {
993 // 3 : 3 input parameters
994 CallSignature resumeUncaughtFrameAndReturn("ResumeUncaughtFrameAndReturn", 0, 3,
995 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
996 *callSign = resumeUncaughtFrameAndReturn;
997 std::array<VariableType, 3> params = { // 3 : 3 input parameters
998 VariableType::NATIVE_POINTER(),
999 VariableType::NATIVE_POINTER(),
1000 VariableType::JS_ANY(),
1001 };
1002 callSign->SetParameters(params.data());
1003 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1004 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
1005 }
1006
DEF_CALL_SIGNATURE(StringsAreEquals)1007 DEF_CALL_SIGNATURE(StringsAreEquals)
1008 {
1009 // 2 : 2 input parameters
1010 CallSignature stringsAreEquals("StringsAreEquals", 0, 2,
1011 ArgumentsOrder::DEFAULT_ORDER, VariableType::BOOL());
1012 *callSign = stringsAreEquals;
1013 std::array<VariableType, 2> params = { // 2 : 2 input parameters
1014 VariableType::JS_POINTER(),
1015 VariableType::JS_POINTER(),
1016 };
1017 callSign->SetParameters(params.data());
1018 callSign->SetGCLeafFunction(true);
1019 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1020 }
1021
DEF_CALL_SIGNATURE(BigIntEquals)1022 DEF_CALL_SIGNATURE(BigIntEquals)
1023 {
1024 // 2 : 2 input parameters
1025 CallSignature bigIntEquals("BigIntEquals", 0, 2,
1026 ArgumentsOrder::DEFAULT_ORDER, VariableType::BOOL());
1027 *callSign = bigIntEquals;
1028 std::array<VariableType, 2> params = { // 2 : 2 input parameters
1029 VariableType::JS_POINTER(),
1030 VariableType::JS_POINTER(),
1031 };
1032 callSign->SetParameters(params.data());
1033 callSign->SetGCLeafFunction(true);
1034 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1035 }
1036
1037 #define PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE_COMMON(name) \
1038 /* 1 : 1 input parameters */ \
1039 CallSignature signature(#name, 0, 1, \
1040 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY()); \
1041 *callSign = signature; \
1042 std::array<VariableType, 1> params = { /* 1: 1 input parameters */ \
1043 VariableType::NATIVE_POINTER(), \
1044 }; \
1045 callSign->SetVariadicArgs(true); \
1046 callSign->SetParameters(params.data()); \
1047 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1048
1049 #define PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(name) \
1050 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE_COMMON(name) \
1051 callSign->SetCallConv(CallSignature::CallConv::GHCCallConv);
1052
1053 #define PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_SIGNATURE(name) \
1054 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE_COMMON(name) \
1055 callSign->SetCallConv(CallSignature::CallConv::WebKitJSCallConv);
1056
1057 #define PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(name) \
1058 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE_COMMON(name) \
1059 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1060
DEF_CALL_SIGNATURE(PushCallArgsAndDispatchNative)1061 DEF_CALL_SIGNATURE(PushCallArgsAndDispatchNative)
1062 {
1063 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_SIGNATURE(PushCallArgsAndDispatchNative)
1064 }
1065
DEF_CALL_SIGNATURE(PushCallArg0AndDispatch)1066 DEF_CALL_SIGNATURE(PushCallArg0AndDispatch)
1067 {
1068 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallArg0AndDispatch)
1069 }
1070
DEF_CALL_SIGNATURE(PushCallArg1AndDispatch)1071 DEF_CALL_SIGNATURE(PushCallArg1AndDispatch)
1072 {
1073 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallArg1AndDispatch)
1074 }
1075
DEF_CALL_SIGNATURE(PushCallArgs2AndDispatch)1076 DEF_CALL_SIGNATURE(PushCallArgs2AndDispatch)
1077 {
1078 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallArgs2AndDispatch)
1079 }
1080
DEF_CALL_SIGNATURE(PushCallArgs3AndDispatch)1081 DEF_CALL_SIGNATURE(PushCallArgs3AndDispatch)
1082 {
1083 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallArgs3AndDispatch)
1084 }
1085
DEF_CALL_SIGNATURE(PushCallThisArg0AndDispatch)1086 DEF_CALL_SIGNATURE(PushCallThisArg0AndDispatch)
1087 {
1088 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallThisArg0AndDispatch)
1089 }
1090
DEF_CALL_SIGNATURE(PushCallThisArg1AndDispatch)1091 DEF_CALL_SIGNATURE(PushCallThisArg1AndDispatch)
1092 {
1093 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallThisArg1AndDispatch)
1094 }
1095
DEF_CALL_SIGNATURE(PushCallThisArgs2AndDispatch)1096 DEF_CALL_SIGNATURE(PushCallThisArgs2AndDispatch)
1097 {
1098 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallThisArgs2AndDispatch)
1099 }
1100
DEF_CALL_SIGNATURE(PushCallThisArgs3AndDispatch)1101 DEF_CALL_SIGNATURE(PushCallThisArgs3AndDispatch)
1102 {
1103 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallThisArgs3AndDispatch)
1104 }
1105
DEF_CALL_SIGNATURE(PushCallRangeAndDispatchNative)1106 DEF_CALL_SIGNATURE(PushCallRangeAndDispatchNative)
1107 {
1108 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(PushCallRangeAndDispatchNative)
1109 }
1110
DEF_CALL_SIGNATURE(PushCallNewAndDispatchNative)1111 DEF_CALL_SIGNATURE(PushCallNewAndDispatchNative)
1112 {
1113 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(PushCallNewAndDispatchNative)
1114 }
1115
DEF_CALL_SIGNATURE(PushCallNewAndDispatch)1116 DEF_CALL_SIGNATURE(PushCallNewAndDispatch)
1117 {
1118 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallNewAndDispatch)
1119 }
1120
DEF_CALL_SIGNATURE(PushCallRangeAndDispatch)1121 DEF_CALL_SIGNATURE(PushCallRangeAndDispatch)
1122 {
1123 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallRangeAndDispatch)
1124 }
1125
DEF_CALL_SIGNATURE(PushCallThisRangeAndDispatch)1126 DEF_CALL_SIGNATURE(PushCallThisRangeAndDispatch)
1127 {
1128 PUSH_CALL_ARGS_AND_DISPATCH_SIGNATURE(PushCallThisRangeAndDispatch)
1129 }
1130
DEF_CALL_SIGNATURE(CallGetter)1131 DEF_CALL_SIGNATURE(CallGetter)
1132 {
1133 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(CallGetter)
1134 }
1135
DEF_CALL_SIGNATURE(CallSetter)1136 DEF_CALL_SIGNATURE(CallSetter)
1137 {
1138 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(CallSetter)
1139 }
1140
DEF_CALL_SIGNATURE(CallContainersArgs3)1141 DEF_CALL_SIGNATURE(CallContainersArgs3)
1142 {
1143 PUSH_CALL_ARGS_AND_DISPATCH_NATIVE_RANGE_SIGNATURE(CallContainersArgs3)
1144 }
1145
DEF_CALL_SIGNATURE(JSCallWithArgV)1146 DEF_CALL_SIGNATURE(JSCallWithArgV)
1147 {
1148 // 6 : 6 input parameters
1149 CallSignature jSCallWithArgV("JSCallWithArgV", 0, 6,
1150 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1151 *callSign = jSCallWithArgV;
1152 // 6 : 6 input parameters
1153 std::array<VariableType, 6> params = {
1154 VariableType::NATIVE_POINTER(), // glue
1155 VariableType::INT64(), // actualNumArgs
1156 VariableType::JS_ANY(), // jsfunc
1157 VariableType::JS_ANY(), // newTarget
1158 VariableType::JS_ANY(), // this
1159 VariableType::NATIVE_POINTER(), // argV
1160 };
1161 callSign->SetParameters(params.data());
1162 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1163 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1164 }
1165
DEF_CALL_SIGNATURE(JSCallNewWithArgV)1166 DEF_CALL_SIGNATURE(JSCallNewWithArgV)
1167 {
1168 // 6 : 6 input parameters
1169 CallSignature jsCallNewWithArgV("JSCallNewWithArgV", 0, 6,
1170 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1171 *callSign = jsCallNewWithArgV;
1172 // 6 : 6 input parameters
1173 std::array<VariableType, 6> params = {
1174 VariableType::NATIVE_POINTER(), // glue
1175 VariableType::INT64(), // actualNumArgs
1176 VariableType::JS_ANY(), // jsfunc
1177 VariableType::JS_ANY(), // newTarget
1178 VariableType::JS_ANY(), // this
1179 VariableType::NATIVE_POINTER(), // argV
1180 };
1181 callSign->SetParameters(params.data());
1182 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1183 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1184 }
1185
DEF_CALL_SIGNATURE(ConstructorJSCallWithArgV)1186 DEF_CALL_SIGNATURE(ConstructorJSCallWithArgV)
1187 {
1188 // 6 : 6 input parameters
1189 CallSignature constructorJSCallWithArgV("ConstructorJSCallWithArgV", 0, 6,
1190 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1191 *callSign = constructorJSCallWithArgV;
1192 // 6 : 6 input parameters
1193 std::array<VariableType, 6> params = {
1194 VariableType::NATIVE_POINTER(), // glue
1195 VariableType::INT64(), // actualNumArgs
1196 VariableType::JS_ANY(), // jsfunc
1197 VariableType::JS_ANY(), // newTarget
1198 VariableType::JS_ANY(), // this
1199 VariableType::NATIVE_POINTER(), // argV
1200 };
1201 callSign->SetParameters(params.data());
1202 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1203 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1204 }
1205
DEF_CALL_SIGNATURE(DebugPrint)1206 DEF_CALL_SIGNATURE(DebugPrint)
1207 {
1208 // 1 : 1 input parameters
1209 CallSignature debugPrint("DebugPrint", 0, 1,
1210 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1211 *callSign = debugPrint;
1212 // 1 : 1 input parameters
1213 std::array<VariableType, 1> params = {
1214 VariableType::INT32(),
1215 };
1216 callSign->SetVariadicArgs(true);
1217 callSign->SetParameters(params.data());
1218 callSign->SetGCLeafFunction(true);
1219 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1220 }
1221
DEF_CALL_SIGNATURE(DebugPrintInstruction)1222 DEF_CALL_SIGNATURE(DebugPrintInstruction)
1223 {
1224 // 2 : 2 input parameters
1225 CallSignature debugPrintInstruction("DebugPrintInstruction", 0, 2,
1226 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1227 *callSign = debugPrintInstruction;
1228 // 2 : 2 input parameters
1229 std::array<VariableType, 2> params = {
1230 VariableType::NATIVE_POINTER(),
1231 VariableType::NATIVE_POINTER(),
1232 };
1233 callSign->SetVariadicArgs(true);
1234 callSign->SetParameters(params.data());
1235 callSign->SetGCLeafFunction(true);
1236 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1237 }
1238
DEF_CALL_SIGNATURE(PGOProfiler)1239 DEF_CALL_SIGNATURE(PGOProfiler)
1240 {
1241 // 2 : 2 input parameters
1242 CallSignature pgoProfilerInstruction("PGOProfiler", 0, 2, ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1243 *callSign = pgoProfilerInstruction;
1244 // 2 : 2 input parameters
1245 std::array<VariableType, 2> params = {
1246 VariableType::NATIVE_POINTER(),
1247 VariableType::JS_ANY(),
1248 };
1249 callSign->SetVariadicArgs(true);
1250 callSign->SetParameters(params.data());
1251 callSign->SetGCLeafFunction(true);
1252 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1253 }
1254
DEF_CALL_SIGNATURE(FatalPrint)1255 DEF_CALL_SIGNATURE(FatalPrint)
1256 {
1257 // 1 : 1 input parameters
1258 CallSignature fatalPrint("FatalPrint", 0, 1,
1259 ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1260 *callSign = fatalPrint;
1261 // 1 : 1 input parameters
1262 std::array<VariableType, 1> params = {
1263 VariableType::INT32(),
1264 };
1265 callSign->SetVariadicArgs(true);
1266 callSign->SetParameters(params.data());
1267 callSign->SetGCLeafFunction(true);
1268 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1269 }
1270
DEF_CALL_SIGNATURE(GetActualArgvNoGC)1271 DEF_CALL_SIGNATURE(GetActualArgvNoGC)
1272 {
1273 CallSignature index("GetActualArgvNoGC", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::NATIVE_POINTER());
1274 *callSign = index;
1275 std::array<VariableType, 1> params = {
1276 VariableType::NATIVE_POINTER(),
1277 };
1278 callSign->SetParameters(params.data());
1279 callSign->SetGCLeafFunction(true);
1280 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1281 }
1282
DEF_CALL_SIGNATURE(InsertOldToNewRSet)1283 DEF_CALL_SIGNATURE(InsertOldToNewRSet)
1284 {
1285 // 3 : 3 input parameters
1286 CallSignature index("InsertOldToNewRSet", 0, 3, ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1287 *callSign = index;
1288 // 3 : 3 input parameters
1289 std::array<VariableType, 3> params = {
1290 VariableType::NATIVE_POINTER(),
1291 VariableType::JS_POINTER(),
1292 VariableType::NATIVE_POINTER(),
1293 };
1294 callSign->SetParameters(params.data());
1295 callSign->SetGCLeafFunction(true);
1296 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1297 }
1298
DEF_CALL_SIGNATURE(FloatMod)1299 DEF_CALL_SIGNATURE(FloatMod)
1300 {
1301 // 2 : 2 input parameters
1302 CallSignature index("FloatMod", 0, 2, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1303 *callSign = index;
1304 // 2 : 2 input parameters
1305 std::array<VariableType, 2> params = {
1306 VariableType::FLOAT64(),
1307 VariableType::FLOAT64(),
1308 };
1309 callSign->SetParameters(params.data());
1310 callSign->SetGCLeafFunction(true);
1311 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1312 }
1313
DEF_CALL_SIGNATURE(FloatSqrt)1314 DEF_CALL_SIGNATURE(FloatSqrt)
1315 {
1316 // 1 : 1 input parameters
1317 CallSignature index("FloatSqrt", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1318 *callSign = index;
1319 // 1 : 1 input parameters
1320 std::array<VariableType, 1> params = {
1321 VariableType::FLOAT64(),
1322 };
1323 callSign->SetParameters(params.data());
1324 callSign->SetGCLeafFunction(true);
1325 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1326 }
1327
DEF_CALL_SIGNATURE(FloatCos)1328 DEF_CALL_SIGNATURE(FloatCos)
1329 {
1330 // 1 : 1 input parameters
1331 CallSignature index("FloatCos", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1332 *callSign = index;
1333 // 1 : 1 input parameters
1334 std::array<VariableType, 1> params = {
1335 VariableType::FLOAT64(),
1336 };
1337 callSign->SetParameters(params.data());
1338 callSign->SetGCLeafFunction(true);
1339 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1340 }
1341
DEF_CALL_SIGNATURE(FloatSin)1342 DEF_CALL_SIGNATURE(FloatSin)
1343 {
1344 // 1 : 1 input parameters
1345 CallSignature index("FloatSin", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1346 *callSign = index;
1347 // 1 : 1 input parameters
1348 std::array<VariableType, 1> params = {
1349 VariableType::FLOAT64(),
1350 };
1351 callSign->SetParameters(params.data());
1352 callSign->SetGCLeafFunction(true);
1353 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1354 }
1355
DEF_CALL_SIGNATURE(FloatACos)1356 DEF_CALL_SIGNATURE(FloatACos)
1357 {
1358 // 1 : 1 input parameters
1359 CallSignature index("FloatACos", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1360 *callSign = index;
1361 // 1 : 1 input parameters
1362 std::array<VariableType, 1> params = {
1363 VariableType::FLOAT64(),
1364 };
1365 callSign->SetParameters(params.data());
1366 callSign->SetGCLeafFunction(true);
1367 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1368 }
1369
DEF_CALL_SIGNATURE(FloatATan)1370 DEF_CALL_SIGNATURE(FloatATan)
1371 {
1372 // 1 : 1 input parameters
1373 CallSignature index("FloatATan", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1374 *callSign = index;
1375 // 1 : 1 input parameters
1376 std::array<VariableType, 1> params = {
1377 VariableType::FLOAT64(),
1378 };
1379 callSign->SetParameters(params.data());
1380 callSign->SetGCLeafFunction(true);
1381 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1382 }
1383
DEF_CALL_SIGNATURE(FloatFloor)1384 DEF_CALL_SIGNATURE(FloatFloor)
1385 {
1386 // 1 : 1 input parameters
1387 CallSignature index("FloatFloor", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1388 *callSign = index;
1389 // 1 : 1 input parameters
1390 std::array<VariableType, 1> params = {
1391 VariableType::FLOAT64(),
1392 };
1393 callSign->SetParameters(params.data());
1394 callSign->SetGCLeafFunction(true);
1395 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1396 }
1397
DEF_CALL_SIGNATURE(FindElementWithCache)1398 DEF_CALL_SIGNATURE(FindElementWithCache)
1399 {
1400 // 4 : 4 input parameters
1401 CallSignature index("FindElementWithCache", 0, 4, ArgumentsOrder::DEFAULT_ORDER, VariableType::INT32());
1402 *callSign = index;
1403 // 4 : 4 input parameters
1404 std::array<VariableType, 4> params = {
1405 VariableType::NATIVE_POINTER(),
1406 VariableType::JS_ANY(),
1407 VariableType::JS_ANY(),
1408 VariableType::INT32(),
1409 };
1410 callSign->SetParameters(params.data());
1411 callSign->SetGCLeafFunction(true);
1412 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1413 }
1414
DEF_CALL_SIGNATURE(DoubleToInt)1415 DEF_CALL_SIGNATURE(DoubleToInt)
1416 {
1417 // 1 : 1 input parameters
1418 CallSignature index("DoubleToInt", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::INT32());
1419 *callSign = index;
1420 // 1 : 1 input parameters
1421 std::array<VariableType, 1> params = {
1422 VariableType::FLOAT64(),
1423 };
1424 callSign->SetParameters(params.data());
1425 callSign->SetGCLeafFunction(true);
1426 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1427 }
1428
DEF_CALL_SIGNATURE(MarkingBarrier)1429 DEF_CALL_SIGNATURE(MarkingBarrier)
1430 {
1431 // 4 : 4 input parameters
1432 CallSignature index("MarkingBarrier", 0, 4, ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1433 *callSign = index;
1434 // 4 : 4 input parameters
1435 std::array<VariableType, 4> params = {
1436 VariableType::NATIVE_POINTER(),
1437 VariableType::JS_POINTER(),
1438 VariableType::NATIVE_POINTER(),
1439 VariableType::JS_POINTER()
1440 };
1441 callSign->SetParameters(params.data());
1442 callSign->SetGCLeafFunction(true);
1443 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1444 }
1445
DEF_CALL_SIGNATURE(StoreBarrier)1446 DEF_CALL_SIGNATURE(StoreBarrier)
1447 {
1448 // 4 : 4 input parameters
1449 CallSignature index("StoreBarrier", 0, 4, ArgumentsOrder::DEFAULT_ORDER, VariableType::VOID());
1450 *callSign = index;
1451 // 4 : 4 input parameters
1452 std::array<VariableType, 4> params = {
1453 VariableType::NATIVE_POINTER(),
1454 VariableType::JS_POINTER(),
1455 VariableType::NATIVE_POINTER(),
1456 VariableType::JS_POINTER()
1457 };
1458 callSign->SetParameters(params.data());
1459 callSign->SetGCLeafFunction(true);
1460 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1461 }
1462
DEF_CALL_SIGNATURE(CallArg0)1463 DEF_CALL_SIGNATURE(CallArg0)
1464 {
1465 // 2 : 2 input parameters
1466 CallSignature callArg0("callArg0", 0, 2,
1467 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1468 *callSign = callArg0;
1469 // 2 : 2 input parameters
1470 std::array<VariableType, 2> params = {
1471 VariableType::NATIVE_POINTER(),
1472 VariableType::JS_ANY()
1473 };
1474 callSign->SetParameters(params.data());
1475 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
1476 }
1477
DEF_CALL_SIGNATURE(CallArg1)1478 DEF_CALL_SIGNATURE(CallArg1)
1479 {
1480 // 3 : 3 input parameters
1481 CallSignature callArg1("callArg1", 0, 3,
1482 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1483 *callSign = callArg1;
1484 // 3 : 3 input parameters
1485 std::array<VariableType, 3> params = {
1486 VariableType::NATIVE_POINTER(),
1487 VariableType::JS_ANY(),
1488 VariableType::JS_ANY()
1489 };
1490 callSign->SetParameters(params.data());
1491 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
1492 }
1493
DEF_CALL_SIGNATURE(CallArgs2)1494 DEF_CALL_SIGNATURE(CallArgs2)
1495 {
1496 // 4 : 4 input parameters
1497 CallSignature callArgs2("callArgs2", 0, 4,
1498 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1499 *callSign = callArgs2;
1500 // 4 : 4 input parameters
1501 std::array<VariableType, 4> params = {
1502 VariableType::NATIVE_POINTER(),
1503 VariableType::JS_ANY(),
1504 VariableType::JS_ANY(),
1505 VariableType::JS_ANY()
1506 };
1507 callSign->SetParameters(params.data());
1508 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
1509 }
1510
DEF_CALL_SIGNATURE(CallArgs3)1511 DEF_CALL_SIGNATURE(CallArgs3)
1512 {
1513 // 5 : 5 input parameters
1514 CallSignature callArgs3("callArgs3", 0, 5,
1515 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1516 *callSign = callArgs3;
1517 // 5 : 5 input parameters
1518 std::array<VariableType, 5> params = {
1519 VariableType::NATIVE_POINTER(),
1520 VariableType::JS_ANY(),
1521 VariableType::JS_ANY(),
1522 VariableType::JS_ANY(),
1523 VariableType::JS_ANY()
1524 };
1525 callSign->SetParameters(params.data());
1526 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
1527 }
1528
DEF_CALL_SIGNATURE(CallThisRange)1529 DEF_CALL_SIGNATURE(CallThisRange)
1530 {
1531 // 3 : 3 input parameters
1532 CallSignature callThisRange("callThisRange", 0, 3,
1533 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1534 *callSign = callThisRange;
1535 // 3 : 3 input parameters
1536 std::array<VariableType, 3> params = {
1537 VariableType::NATIVE_POINTER(),
1538 VariableType::JS_ANY(),
1539 VariableType::JS_ANY()
1540 };
1541 callSign->SetVariadicArgs(true);
1542 callSign->SetParameters(params.data());
1543 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
1544 }
1545
DEF_CALL_SIGNATURE(CallRange)1546 DEF_CALL_SIGNATURE(CallRange)
1547 {
1548 // 2 : 2 input parameters
1549 CallSignature callRange("callRange", 0, 2,
1550 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1551 *callSign = callRange;
1552 // 2 : 2 input parameters
1553 std::array<VariableType, 2> params = {
1554 VariableType::NATIVE_POINTER(),
1555 VariableType::JS_ANY()
1556 };
1557 callSign->SetVariadicArgs(true);
1558 callSign->SetParameters(params.data());
1559 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB);
1560 }
1561
DEF_CALL_SIGNATURE(JsProxyCallInternal)1562 DEF_CALL_SIGNATURE(JsProxyCallInternal)
1563 {
1564 // 4 : 4 input parameters
1565 CallSignature proxyCallInternal("JsProxyCallInternal", 0, 4,
1566 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_POINTER());
1567 *callSign = proxyCallInternal;
1568 // 4 : 4 input parameters
1569 std::array<VariableType, 4> params = {
1570 VariableType::NATIVE_POINTER(), // glue
1571 VariableType::INT64(), // actual argC
1572 VariableType::JS_POINTER(), // callTarget
1573 VariableType::NATIVE_POINTER(), // argv
1574 };
1575 callSign->SetVariadicArgs(false);
1576 callSign->SetParameters(params.data());
1577 callSign->SetTailCall(true);
1578 callSign->SetGCLeafFunction(true);
1579 callSign->SetTargetKind(CallSignature::TargetKind::COMMON_STUB);
1580 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1581 }
1582
DEF_CALL_SIGNATURE(CreateArrayFromList)1583 DEF_CALL_SIGNATURE(CreateArrayFromList)
1584 {
1585 // 3 : 3 input parameters
1586 CallSignature createArrayFromList("CreateArrayFromList", 0, 3, ArgumentsOrder::DEFAULT_ORDER,
1587 VariableType::JS_POINTER());
1588 *callSign = createArrayFromList;
1589 // 3 : 3 input parameters
1590 std::array<VariableType, 3> params = {
1591 VariableType::NATIVE_POINTER(),
1592 VariableType::INT32(),
1593 VariableType::NATIVE_POINTER(),
1594 };
1595
1596 callSign->SetParameters(params.data());
1597 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_VARARGS);
1598 }
1599
DEF_CALL_SIGNATURE(DeoptHandlerAsm)1600 DEF_CALL_SIGNATURE(DeoptHandlerAsm)
1601 {
1602 // 1 : 1 input parameters
1603 CallSignature deoptHandlerAsm("DeoptHandlerAsm", 0, 1,
1604 ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
1605 *callSign = deoptHandlerAsm;
1606 std::array<VariableType, 1> params = { // 1 : 1 input parameters
1607 VariableType::NATIVE_POINTER(), // glue
1608 };
1609 callSign->SetVariadicArgs(false);
1610 callSign->SetParameters(params.data());
1611 callSign->SetCallConv(CallSignature::CallConv::CCallConv);
1612 callSign->SetTargetKind(CallSignature::TargetKind::DEOPT_STUB);
1613 }
1614
DEF_CALL_SIGNATURE(TimeClip)1615 DEF_CALL_SIGNATURE(TimeClip)
1616 {
1617 // 1 : 1 input parameters
1618 CallSignature index("TimeClip", 0, 1, ArgumentsOrder::DEFAULT_ORDER, VariableType::FLOAT64());
1619 *callSign = index;
1620 // 1 : 1 input parameters
1621 std::array<VariableType, 1> params = {
1622 VariableType::FLOAT64(),
1623 };
1624 callSign->SetParameters(params.data());
1625 callSign->SetGCLeafFunction(true);
1626 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1627 }
1628
DEF_CALL_SIGNATURE(SetDateValues)1629 DEF_CALL_SIGNATURE(SetDateValues)
1630 {
1631 // 3 : 3 input parameters
1632 CallSignature index("SetDateValues", 0, 3, ArgumentsOrder::DEFAULT_ORDER, VariableType::FLOAT64());
1633 *callSign = index;
1634 // 3 : 3 input parameters
1635 std::array<VariableType, 3> params = {
1636 VariableType::FLOAT64(),
1637 VariableType::FLOAT64(),
1638 VariableType::FLOAT64(),
1639 };
1640 callSign->SetParameters(params.data());
1641 callSign->SetGCLeafFunction(true);
1642 callSign->SetTargetKind(CallSignature::TargetKind::RUNTIME_STUB_NO_GC);
1643 }
1644 } // namespace panda::ecmascript::kungfu
1645