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