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