jit/CCallHelpers.h

   1 /*
   2  * Copyright (C) 2011 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef CCallHelpers_h
  27 #define CCallHelpers_h
  28
  29 #if ENABLE(JIT)
  30
  31 #include "AssemblyHelpers.h"
  32 #include "GPRInfo.h"
  33
  34 namespace JSC {
  35
  36 class CCallHelpers : public AssemblyHelpers {
  37 public:
  38     CCallHelpers(VM* vm, CodeBlock* codeBlock = 0)
  39         : AssemblyHelpers(vm, codeBlock)
  40     {
  41     }
  42
  43     // These methods used to sort arguments into the correct registers.
  44     // On X86 we use cdecl calling conventions, which pass all arguments on the
  45     // stack. On other architectures we may need to sort values into the
  46     // correct registers.
  47 #if !NUMBER_OF_ARGUMENT_REGISTERS
  48     unsigned m_callArgumentOffset;
  49     void resetCallArguments() { m_callArgumentOffset = 0; }
  50
  51     // These methods are using internally to implement the callOperation methods.
  52     void addCallArgument(GPRReg value)
  53     {
  54         poke(value, m_callArgumentOffset++);
  55     }
  56     void addCallArgument(TrustedImm32 imm)
  57     {
  58         poke(imm, m_callArgumentOffset++);
  59     }
  60     void addCallArgument(TrustedImmPtr pointer)
  61     {
  62         poke(pointer, m_callArgumentOffset++);
  63     }
  64     void addCallArgument(FPRReg value)
  65     {
  66         storeDouble(value, Address(stackPointerRegister, m_callArgumentOffset * sizeof(void*)));
  67         m_callArgumentOffset += sizeof(double) / sizeof(void*);
  68     }
  69
  70     ALWAYS_INLINE void setupArguments(FPRReg arg1)
  71     {
  72         resetCallArguments();
  73         addCallArgument(arg1);
  74     }
  75
  76     ALWAYS_INLINE void setupArguments(FPRReg arg1, FPRReg arg2)
  77     {
  78         resetCallArguments();
  79         addCallArgument(arg1);
  80         addCallArgument(arg2);
  81     }
  82
  83     ALWAYS_INLINE void setupArguments(GPRReg arg1)
  84     {
  85         resetCallArguments();
  86         addCallArgument(arg1);
  87     }
  88
  89     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2)
  90     {
  91         resetCallArguments();
  92         addCallArgument(arg1);
  93         addCallArgument(arg2);
  94     }
  95
  96     ALWAYS_INLINE void setupArguments(TrustedImmPtr arg1, GPRReg arg2)
  97     {
  98         resetCallArguments();
  99         addCallArgument(arg1);
 100         addCallArgument(arg2);
 101     }
 102
 103     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, GPRReg arg3)
 104     {
 105         resetCallArguments();
 106         addCallArgument(arg1);
 107         addCallArgument(arg2);
 108         addCallArgument(arg3);
 109     }
 110
 111     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImmPtr arg4)
 112     {
 113         resetCallArguments();
 114         addCallArgument(arg1);
 115         addCallArgument(arg2);
 116         addCallArgument(arg3);
 117         addCallArgument(arg4);
 118     }
 119
 120     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4, GPRReg arg5)
 121     {
 122         resetCallArguments();
 123         addCallArgument(arg1);
 124         addCallArgument(arg2);
 125         addCallArgument(arg3);
 126         addCallArgument(arg4);
 127         addCallArgument(arg5);
 128     }
 129
 130     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4, GPRReg arg5, GPRReg arg6)
 131     {
 132         resetCallArguments();
 133         addCallArgument(arg1);
 134         addCallArgument(arg2);
 135         addCallArgument(arg3);
 136         addCallArgument(arg4);
 137         addCallArgument(arg5);
 138         addCallArgument(arg6);
 139     }
 140
 141     ALWAYS_INLINE void setupArguments(TrustedImmPtr arg1)
 142     {
 143         resetCallArguments();
 144         addCallArgument(arg1);
 145     }
 146
 147     ALWAYS_INLINE void setupArgumentsExecState()
 148     {
 149         resetCallArguments();
 150         addCallArgument(GPRInfo::callFrameRegister);
 151     }
 152
 153     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1)
 154     {
 155         resetCallArguments();
 156         addCallArgument(GPRInfo::callFrameRegister);
 157         addCallArgument(arg1);
 158     }
 159
 160     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1)
 161     {
 162         resetCallArguments();
 163         addCallArgument(GPRInfo::callFrameRegister);
 164         addCallArgument(arg1);
 165     }
 166
 167     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1)
 168     {
 169         resetCallArguments();
 170         addCallArgument(GPRInfo::callFrameRegister);
 171         addCallArgument(arg1);
 172     }
 173
 174     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2)
 175     {
 176         resetCallArguments();
 177         addCallArgument(GPRInfo::callFrameRegister);
 178         addCallArgument(arg1);
 179         addCallArgument(arg2);
 180     }
 181
 182     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2)
 183     {
 184         resetCallArguments();
 185         addCallArgument(GPRInfo::callFrameRegister);
 186         addCallArgument(arg1);
 187         addCallArgument(arg2);
 188     }
 189
 190     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2)
 191     {
 192         resetCallArguments();
 193         addCallArgument(GPRInfo::callFrameRegister);
 194         addCallArgument(arg1);
 195         addCallArgument(arg2);
 196     }
 197
 198     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2)
 199     {
 200         resetCallArguments();
 201         addCallArgument(GPRInfo::callFrameRegister);
 202         addCallArgument(arg1);
 203         addCallArgument(arg2);
 204     }
 205
 206     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2)
 207     {
 208         resetCallArguments();
 209         addCallArgument(GPRInfo::callFrameRegister);
 210         addCallArgument(arg1);
 211         addCallArgument(arg2);
 212     }
 213
 214     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2)
 215     {
 216         resetCallArguments();
 217         addCallArgument(GPRInfo::callFrameRegister);
 218         addCallArgument(arg1);
 219         addCallArgument(arg2);
 220     }
 221
 222     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2)
 223     {
 224         resetCallArguments();
 225         addCallArgument(GPRInfo::callFrameRegister);
 226         addCallArgument(arg1);
 227         addCallArgument(arg2);
 228     }
 229
 230     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImm32 arg2)
 231     {
 232         resetCallArguments();
 233         addCallArgument(GPRInfo::callFrameRegister);
 234         addCallArgument(arg1);
 235         addCallArgument(arg2);
 236     }
 237
 238     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImm32 arg2, TrustedImm32 arg3)
 239     {
 240         resetCallArguments();
 241         addCallArgument(GPRInfo::callFrameRegister);
 242         addCallArgument(arg1);
 243         addCallArgument(arg2);
 244         addCallArgument(arg3);
 245     }
 246
 247     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3)
 248     {
 249         resetCallArguments();
 250         addCallArgument(GPRInfo::callFrameRegister);
 251         addCallArgument(arg1);
 252         addCallArgument(arg2);
 253         addCallArgument(arg3);
 254     }
 255
 256     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3)
 257     {
 258         resetCallArguments();
 259         addCallArgument(GPRInfo::callFrameRegister);
 260         addCallArgument(arg1);
 261         addCallArgument(arg2);
 262         addCallArgument(arg3);
 263     }
 264
 265     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3)
 266     {
 267         resetCallArguments();
 268         addCallArgument(GPRInfo::callFrameRegister);
 269         addCallArgument(arg1);
 270         addCallArgument(arg2);
 271         addCallArgument(arg3);
 272     }
 273
 274     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, GPRReg arg3)
 275     {
 276         resetCallArguments();
 277         addCallArgument(GPRInfo::callFrameRegister);
 278         addCallArgument(arg1);
 279         addCallArgument(arg2);
 280         addCallArgument(arg3);
 281     }
 282
 283     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, TrustedImmPtr arg3)
 284     {
 285         resetCallArguments();
 286         addCallArgument(GPRInfo::callFrameRegister);
 287         addCallArgument(arg1);
 288         addCallArgument(arg2);
 289         addCallArgument(arg3);
 290     }
 291
 292     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3)
 293     {
 294         resetCallArguments();
 295         addCallArgument(GPRInfo::callFrameRegister);
 296         addCallArgument(arg1);
 297         addCallArgument(arg2);
 298         addCallArgument(arg3);
 299     }
 300
 301     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3)
 302     {
 303         resetCallArguments();
 304         addCallArgument(GPRInfo::callFrameRegister);
 305         addCallArgument(arg1);
 306         addCallArgument(arg2);
 307         addCallArgument(arg3);
 308     }
 309
 310     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImmPtr arg3)
 311     {
 312         resetCallArguments();
 313         addCallArgument(GPRInfo::callFrameRegister);
 314         addCallArgument(arg1);
 315         addCallArgument(arg2);
 316         addCallArgument(arg3);
 317     }
 318
 319     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2, TrustedImm32 arg3)
 320     {
 321         resetCallArguments();
 322         addCallArgument(GPRInfo::callFrameRegister);
 323         addCallArgument(arg1);
 324         addCallArgument(arg2);
 325         addCallArgument(arg3);
 326     }
 327
 328     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2, TrustedImmPtr arg3)
 329     {
 330         resetCallArguments();
 331         addCallArgument(GPRInfo::callFrameRegister);
 332         addCallArgument(arg1);
 333         addCallArgument(arg2);
 334         addCallArgument(arg3);
 335     }
 336
 337     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImmPtr arg3)
 338     {
 339         resetCallArguments();
 340         addCallArgument(GPRInfo::callFrameRegister);
 341         addCallArgument(arg1);
 342         addCallArgument(arg2);
 343         addCallArgument(arg3);
 344     }
 345
 346     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4)
 347     {
 348         resetCallArguments();
 349         addCallArgument(GPRInfo::callFrameRegister);
 350         addCallArgument(arg1);
 351         addCallArgument(arg2);
 352         addCallArgument(arg3);
 353         addCallArgument(arg4);
 354     }
 355
 356     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImm32 arg2, GPRReg arg3, TrustedImmPtr arg4)
 357     {
 358         resetCallArguments();
 359         addCallArgument(GPRInfo::callFrameRegister);
 360         addCallArgument(arg1);
 361         addCallArgument(arg2);
 362         addCallArgument(arg3);
 363         addCallArgument(arg4);
 364     }
 365
 366     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImmPtr arg4)
 367     {
 368         resetCallArguments();
 369         addCallArgument(GPRInfo::callFrameRegister);
 370         addCallArgument(arg1);
 371         addCallArgument(arg2);
 372         addCallArgument(arg3);
 373         addCallArgument(arg4);
 374     }
 375
 376     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
 377     {
 378         resetCallArguments();
 379         addCallArgument(GPRInfo::callFrameRegister);
 380         addCallArgument(arg1);
 381         addCallArgument(arg2);
 382         addCallArgument(arg3);
 383         addCallArgument(arg4);
 384         addCallArgument(arg5);
 385     }
 386
 387     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
 388     {
 389         resetCallArguments();
 390         addCallArgument(GPRInfo::callFrameRegister);
 391         addCallArgument(arg1);
 392         addCallArgument(arg2);
 393         addCallArgument(arg3);
 394         addCallArgument(arg4);
 395         addCallArgument(arg5);
 396     }
 397
 398     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4)
 399     {
 400         resetCallArguments();
 401         addCallArgument(GPRInfo::callFrameRegister);
 402         addCallArgument(arg1);
 403         addCallArgument(arg2);
 404         addCallArgument(arg3);
 405         addCallArgument(arg4);
 406     }
 407
 408     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4)
 409     {
 410         resetCallArguments();
 411         addCallArgument(GPRInfo::callFrameRegister);
 412         addCallArgument(arg1);
 413         addCallArgument(arg2);
 414         addCallArgument(arg3);
 415         addCallArgument(arg4);
 416     }
 417
 418     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3)
 419     {
 420         resetCallArguments();
 421         addCallArgument(GPRInfo::callFrameRegister);
 422         addCallArgument(arg1);
 423         addCallArgument(arg2);
 424         addCallArgument(arg3);
 425     }
 426
 427     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
 428     {
 429         resetCallArguments();
 430         addCallArgument(GPRInfo::callFrameRegister);
 431         addCallArgument(arg1);
 432         addCallArgument(arg2);
 433         addCallArgument(arg3);
 434         addCallArgument(arg4);
 435     }
 436
 437     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImm32 arg4)
 438     {
 439         resetCallArguments();
 440         addCallArgument(GPRInfo::callFrameRegister);
 441         addCallArgument(arg1);
 442         addCallArgument(arg2);
 443         addCallArgument(arg3);
 444         addCallArgument(arg4);
 445     }
 446
 447     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4)
 448     {
 449         resetCallArguments();
 450         addCallArgument(GPRInfo::callFrameRegister);
 451         addCallArgument(arg1);
 452         addCallArgument(arg2);
 453         addCallArgument(arg3);
 454         addCallArgument(arg4);
 455     }
 456
 457     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2, GPRReg arg3, GPRReg arg4)
 458     {
 459         resetCallArguments();
 460         addCallArgument(GPRInfo::callFrameRegister);
 461         addCallArgument(arg1);
 462         addCallArgument(arg2);
 463         addCallArgument(arg3);
 464         addCallArgument(arg4);
 465     }
 466
 467     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4)
 468     {
 469         resetCallArguments();
 470         addCallArgument(GPRInfo::callFrameRegister);
 471         addCallArgument(arg1);
 472         addCallArgument(arg2);
 473         addCallArgument(arg3);
 474         addCallArgument(arg4);
 475     }
 476
 477     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImmPtr arg5)
 478     {
 479         resetCallArguments();
 480         addCallArgument(GPRInfo::callFrameRegister);
 481         addCallArgument(arg1);
 482         addCallArgument(arg2);
 483         addCallArgument(arg3);
 484         addCallArgument(arg4);
 485         addCallArgument(arg5);
 486     }
 487
 488     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, TrustedImmPtr arg6)
 489     {
 490         resetCallArguments();
 491         addCallArgument(GPRInfo::callFrameRegister);
 492         addCallArgument(arg1);
 493         addCallArgument(arg2);
 494         addCallArgument(arg3);
 495         addCallArgument(arg4);
 496         addCallArgument(arg5);
 497         addCallArgument(arg6);
 498     }
 499
 500     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImm32 arg5, TrustedImmPtr arg6)
 501     {
 502         resetCallArguments();
 503         addCallArgument(GPRInfo::callFrameRegister);
 504         addCallArgument(arg1);
 505         addCallArgument(arg2);
 506         addCallArgument(arg3);
 507         addCallArgument(arg4);
 508         addCallArgument(arg5);
 509         addCallArgument(arg6);
 510     }
 511
 512     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
 513     {
 514         resetCallArguments();
 515         addCallArgument(GPRInfo::callFrameRegister);
 516         addCallArgument(arg1);
 517         addCallArgument(arg2);
 518         addCallArgument(arg3);
 519         addCallArgument(arg4);
 520     }
 521
 522     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImmPtr arg4)
 523     {
 524         resetCallArguments();
 525         addCallArgument(GPRInfo::callFrameRegister);
 526         addCallArgument(arg1);
 527         addCallArgument(arg2);
 528         addCallArgument(arg3);
 529         addCallArgument(arg4);
 530     }
 531
 532     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4)
 533     {
 534         resetCallArguments();
 535         addCallArgument(GPRInfo::callFrameRegister);
 536         addCallArgument(arg1);
 537         addCallArgument(arg2);
 538         addCallArgument(arg3);
 539         addCallArgument(arg4);
 540     }
 541
 542     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
 543     {
 544         resetCallArguments();
 545         addCallArgument(GPRInfo::callFrameRegister);
 546         addCallArgument(arg1);
 547         addCallArgument(arg2);
 548         addCallArgument(arg3);
 549         addCallArgument(arg4);
 550         addCallArgument(arg5);
 551     }
 552
 553     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
 554     {
 555         resetCallArguments();
 556         addCallArgument(GPRInfo::callFrameRegister);
 557         addCallArgument(arg1);
 558         addCallArgument(arg2);
 559         addCallArgument(arg3);
 560         addCallArgument(arg4);
 561         addCallArgument(arg5);
 562     }
 563
 564     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImmPtr arg5)
 565     {
 566         resetCallArguments();
 567         addCallArgument(GPRInfo::callFrameRegister);
 568         addCallArgument(arg1);
 569         addCallArgument(arg2);
 570         addCallArgument(arg3);
 571         addCallArgument(arg4);
 572         addCallArgument(arg5);
 573     }
 574
 575     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImmPtr arg5)
 576     {
 577         resetCallArguments();
 578         addCallArgument(GPRInfo::callFrameRegister);
 579         addCallArgument(arg1);
 580         addCallArgument(arg2);
 581         addCallArgument(arg3);
 582         addCallArgument(arg4);
 583         addCallArgument(arg5);
 584     }
 585
 586     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImm32 arg5)
 587     {
 588         resetCallArguments();
 589         addCallArgument(GPRInfo::callFrameRegister);
 590         addCallArgument(arg1);
 591         addCallArgument(arg2);
 592         addCallArgument(arg3);
 593         addCallArgument(arg4);
 594         addCallArgument(arg5);
 595     }
 596
 597     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6)
 598     {
 599         resetCallArguments();
 600         addCallArgument(GPRInfo::callFrameRegister);
 601         addCallArgument(arg1);
 602         addCallArgument(arg2);
 603         addCallArgument(arg3);
 604         addCallArgument(arg4);
 605         addCallArgument(arg5);
 606         addCallArgument(arg6);
 607     }
 608
 609
 610     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, TrustedImm32 arg6)
 611     {
 612         resetCallArguments();
 613         addCallArgument(GPRInfo::callFrameRegister);
 614         addCallArgument(arg1);
 615         addCallArgument(arg2);
 616         addCallArgument(arg3);
 617         addCallArgument(arg4);
 618         addCallArgument(arg5);
 619         addCallArgument(arg6);
 620     }
 621
 622     ALWAYS_INLINE void setupArgumentsWithExecState(FPRReg arg1, GPRReg arg2)
 623     {
 624         resetCallArguments();
 625         addCallArgument(GPRInfo::callFrameRegister);
 626         addCallArgument(arg1);
 627         addCallArgument(arg2);
 628     }
 629
 630     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, FPRReg arg3)
 631     {
 632         resetCallArguments();
 633         addCallArgument(GPRInfo::callFrameRegister);
 634         addCallArgument(arg1);
 635         addCallArgument(arg2);
 636         addCallArgument(arg3);
 637     }
 638 #endif // !NUMBER_OF_ARGUMENT_REGISTERS
 639     // These methods are suitable for any calling convention that provides for
 640     // at least 4 argument registers, e.g. X86_64, ARMv7.
 641 #if NUMBER_OF_ARGUMENT_REGISTERS >= 4
 642     template<GPRReg destA, GPRReg destB>
 643     void setupTwoStubArgsGPR(GPRReg srcA, GPRReg srcB)
 644     {
 645         // Assuming that srcA != srcB, there are 7 interesting states the registers may be in:
 646         // (1) both are already in arg regs, the right way around.
 647         // (2) both are already in arg regs, the wrong way around.
 648         // (3) neither are currently in arg registers.
 649         // (4) srcA in in its correct reg.
 650         // (5) srcA in in the incorrect reg.
 651         // (6) srcB in in its correct reg.
 652         // (7) srcB in in the incorrect reg.
 653         //
 654         // The trivial approach is to simply emit two moves, to put srcA in place then srcB in
 655         // place (the MacroAssembler will omit redundant moves). This apporach will be safe in
 656         // cases 1, 3, 4, 5, 6, and in cases where srcA==srcB. The two problem cases are 2
 657         // (requires a swap) and 7 (must move srcB first, to avoid trampling.)
 658
 659         if (srcB != destA) {
 660             // Handle the easy cases - two simple moves.
 661             move(srcA, destA);
 662             move(srcB, destB);
 663         } else if (srcA != destB) {
 664             // Handle the non-swap case - just put srcB in place first.
 665             move(srcB, destB);
 666             move(srcA, destA);
 667         } else
 668             swap(destA, destB);
 669     }
 670
 671     template<GPRReg destA, GPRReg destB, GPRReg destC>
 672     void setupThreeStubArgsGPR(GPRReg srcA, GPRReg srcB, GPRReg srcC)
 673     {
 674         // If neither of srcB/srcC are in our way, then we can move srcA into place.
 675         // Then we can use setupTwoStubArgs to fix srcB/srcC.
 676         if (srcB != destA && srcC != destA) {
 677             move(srcA, destA);
 678             setupTwoStubArgsGPR<destB, destC>(srcB, srcC);
 679             return;
 680         }
 681
 682         // If neither of srcA/srcC are in our way, then we can move srcB into place.
 683         // Then we can use setupTwoStubArgs to fix srcA/srcC.
 684         if (srcA != destB && srcC != destB) {
 685             move(srcB, destB);
 686             setupTwoStubArgsGPR<destA, destC>(srcA, srcC);
 687             return;
 688         }
 689
 690         // If neither of srcA/srcB are in our way, then we can move srcC into place.
 691         // Then we can use setupTwoStubArgs to fix srcA/srcB.
 692         if (srcA != destC && srcB != destC) {
 693             move(srcC, destC);
 694             setupTwoStubArgsGPR<destA, destB>(srcA, srcB);
 695             return;
 696         }
 697
 698         // If we get here, we haven't been able to move any of srcA/srcB/srcC.
 699         // Since all three are blocked, then all three must already be in the argument register.
 700         // But are they in the right ones?
 701
 702         // First, ensure srcA is in place.
 703         if (srcA != destA) {
 704             swap(srcA, destA);
 705
 706             // If srcA wasn't in argumentGPR1, one of srcB/srcC must be.
 707             ASSERT(srcB == destA || srcC == destA);
 708             // If srcB was in argumentGPR1 it no longer is (due to the swap).
 709             // Otherwise srcC must have been. Mark him as moved.
 710             if (srcB == destA)
 711                 srcB = srcA;
 712             else
 713                 srcC = srcA;
 714         }
 715
 716         // Either srcB & srcC need swapping, or we're all done.
 717         ASSERT((srcB == destB || srcC == destC)
 718             || (srcB == destC || srcC == destB));
 719
 720         if (srcB != destB)
 721             swap(destB, destC);
 722     }
 723
 724 #if CPU(X86_64) || CPU(ARM64)
 725     template<FPRReg destA, FPRReg destB>
 726     void setupTwoStubArgsFPR(FPRReg srcA, FPRReg srcB)
 727     {
 728         // Assuming that srcA != srcB, there are 7 interesting states the registers may be in:
 729         // (1) both are already in arg regs, the right way around.
 730         // (2) both are already in arg regs, the wrong way around.
 731         // (3) neither are currently in arg registers.
 732         // (4) srcA in in its correct reg.
 733         // (5) srcA in in the incorrect reg.
 734         // (6) srcB in in its correct reg.
 735         // (7) srcB in in the incorrect reg.
 736         //
 737         // The trivial approach is to simply emit two moves, to put srcA in place then srcB in
 738         // place (the MacroAssembler will omit redundant moves). This apporach will be safe in
 739         // cases 1, 3, 4, 5, 6, and in cases where srcA==srcB. The two problem cases are 2
 740         // (requires a swap) and 7 (must move srcB first, to avoid trampling.)
 741
 742         if (srcB != destA) {
 743             // Handle the easy cases - two simple moves.
 744             moveDouble(srcA, destA);
 745             moveDouble(srcB, destB);
 746             return;
 747         }
 748
 749         if (srcA != destB) {
 750             // Handle the non-swap case - just put srcB in place first.
 751             moveDouble(srcB, destB);
 752             moveDouble(srcA, destA);
 753             return;
 754         }
 755
 756         ASSERT(srcB == destA && srcA == destB);
 757         // Need to swap; pick a temporary register.
 758         FPRReg temp;
 759         if (destA != FPRInfo::argumentFPR3 && destA != FPRInfo::argumentFPR3)
 760             temp = FPRInfo::argumentFPR3;
 761         else if (destA != FPRInfo::argumentFPR2 && destA != FPRInfo::argumentFPR2)
 762             temp = FPRInfo::argumentFPR2;
 763         else {
 764             ASSERT(destA != FPRInfo::argumentFPR1 && destA != FPRInfo::argumentFPR1);
 765             temp = FPRInfo::argumentFPR1;
 766         }
 767         moveDouble(destA, temp);
 768         moveDouble(destB, destA);
 769         moveDouble(temp, destB);
 770     }
 771 #endif
 772     void setupStubArguments(GPRReg arg1, GPRReg arg2)
 773     {
 774         setupTwoStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2>(arg1, arg2);
 775     }
 776
 777     void setupStubArguments(GPRReg arg1, GPRReg arg2, GPRReg arg3)
 778     {
 779         setupThreeStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg1, arg2, arg3);
 780     }
 781
 782 #if CPU(MIPS) || (OS(WINDOWS) && CPU(X86_64))
 783 #define POKE_ARGUMENT_OFFSET 4
 784 #else
 785 #define POKE_ARGUMENT_OFFSET 0
 786 #endif
 787
 788 #if CPU(X86_64) || CPU(ARM64)
 789     ALWAYS_INLINE void setupArguments(FPRReg arg1)
 790     {
 791         moveDouble(arg1, FPRInfo::argumentFPR0);
 792     }
 793
 794     ALWAYS_INLINE void setupArguments(FPRReg arg1, FPRReg arg2)
 795     {
 796         setupTwoStubArgsFPR<FPRInfo::argumentFPR0, FPRInfo::argumentFPR1>(arg1, arg2);
 797     }
 798
 799     ALWAYS_INLINE void setupArgumentsWithExecState(FPRReg arg1, GPRReg arg2)
 800     {
 801 #if OS(WINDOWS) && CPU(X86_64)
 802         // On Windows, arguments map to designated registers based on the argument positions, even when there are interlaced scalar and floating point arguments.
 803         // See http://msdn.microsoft.com/en-us/library/zthk2dkh.aspx
 804         moveDouble(arg1, FPRInfo::argumentFPR1);
 805         move(arg2, GPRInfo::argumentGPR2);
 806 #else
 807         moveDouble(arg1, FPRInfo::argumentFPR0);
 808         move(arg2, GPRInfo::argumentGPR1);
 809 #endif
 810         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 811     }
 812
 813     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, FPRReg arg3)
 814     {
 815 #if OS(WINDOWS) && CPU(X86_64)
 816         // On Windows, arguments map to designated registers based on the argument positions, even when there are interlaced scalar and floating point arguments.
 817         // See http://msdn.microsoft.com/en-us/library/zthk2dkh.aspx
 818         moveDouble(arg3, FPRInfo::argumentFPR3);
 819 #else
 820         moveDouble(arg3, FPRInfo::argumentFPR0);
 821 #endif
 822         setupStubArguments(arg1, arg2);
 823         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 824     }
 825 #elif CPU(ARM)
 826 #if CPU(ARM_HARDFP)
 827     ALWAYS_INLINE void setupArguments(FPRReg arg1)
 828     {
 829         moveDouble(arg1, FPRInfo::argumentFPR0);
 830     }
 831
 832     ALWAYS_INLINE void setupArguments(FPRReg arg1, FPRReg arg2)
 833     {
 834         if (arg2 != FPRInfo::argumentFPR0) {
 835             moveDouble(arg1, FPRInfo::argumentFPR0);
 836             moveDouble(arg2, FPRInfo::argumentFPR1);
 837         } else if (arg1 != FPRInfo::argumentFPR1) {
 838             moveDouble(arg2, FPRInfo::argumentFPR1);
 839             moveDouble(arg1, FPRInfo::argumentFPR0);
 840         } else {
 841             // Swap arg1, arg2.
 842             moveDouble(FPRInfo::argumentFPR0, ARMRegisters::d2);
 843             moveDouble(FPRInfo::argumentFPR1, FPRInfo::argumentFPR0);
 844             moveDouble(ARMRegisters::d2, FPRInfo::argumentFPR1);
 845         }
 846     }
 847
 848     ALWAYS_INLINE void setupArgumentsWithExecState(FPRReg arg1, GPRReg arg2)
 849     {
 850         moveDouble(arg1, FPRInfo::argumentFPR0);
 851         move(arg2, GPRInfo::argumentGPR1);
 852         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 853     }
 854
 855     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, FPRReg arg3)
 856     {
 857         moveDouble(arg3, FPRInfo::argumentFPR0);
 858         setupStubArguments(arg1, arg2);
 859         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 860     }
 861
 862     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32, FPRReg arg2, GPRReg arg3)
 863     {
 864         moveDouble(arg2, FPRInfo::argumentFPR0);
 865         move(arg3, GPRInfo::argumentGPR1);
 866         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 867     }
 868
 869     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32, FPRReg arg4)
 870     {
 871         moveDouble(arg4, FPRInfo::argumentFPR0);
 872         setupStubArguments(arg1, arg2);
 873         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 874     }
 875
 876 #else
 877     ALWAYS_INLINE void setupArguments(FPRReg arg1)
 878     {
 879         assembler().vmov(GPRInfo::argumentGPR0, GPRInfo::argumentGPR1, arg1);
 880     }
 881
 882     ALWAYS_INLINE void setupArguments(FPRReg arg1, FPRReg arg2)
 883     {
 884         assembler().vmov(GPRInfo::argumentGPR0, GPRInfo::argumentGPR1, arg1);
 885         assembler().vmov(GPRInfo::argumentGPR2, GPRInfo::argumentGPR3, arg2);
 886     }
 887
 888     ALWAYS_INLINE void setupArgumentsWithExecState(FPRReg arg1, GPRReg arg2)
 889     {
 890         move(arg2, GPRInfo::argumentGPR3);
 891         assembler().vmov(GPRInfo::argumentGPR1, GPRInfo::argumentGPR2, arg1);
 892         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 893     }
 894
 895     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, FPRReg arg3)
 896     {
 897         setupStubArguments(arg1, arg2);
 898         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 899         assembler().vmov(GPRInfo::argumentGPR3, GPRInfo::nonArgGPR0, arg3);
 900         poke(GPRInfo::nonArgGPR0);
 901     }
 902
 903     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, FPRReg arg2, GPRReg arg3)
 904     {
 905         poke(arg3, POKE_ARGUMENT_OFFSET);
 906         move(arg1, GPRInfo::argumentGPR1);
 907         assembler().vmov(GPRInfo::argumentGPR2, GPRInfo::argumentGPR3, arg2);
 908         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 909     }
 910
 911     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, FPRReg arg4)
 912     {
 913         setupStubArguments(arg1, arg2);
 914         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 915         move(arg3, GPRInfo::argumentGPR3);
 916         assembler().vmov(GPRInfo::nonArgGPR0, GPRInfo::nonArgGPR1, arg4);
 917         poke(GPRInfo::nonArgGPR0, POKE_ARGUMENT_OFFSET);
 918         poke(GPRInfo::nonArgGPR1, POKE_ARGUMENT_OFFSET + 1);
 919     }
 920 #endif // CPU(ARM_HARDFP)
 921 #elif CPU(MIPS)
 922     ALWAYS_INLINE void setupArguments(FPRReg arg1)
 923     {
 924         moveDouble(arg1, FPRInfo::argumentFPR0);
 925     }
 926
 927     ALWAYS_INLINE void setupArguments(FPRReg arg1, FPRReg arg2)
 928     {
 929         if (arg2 != FPRInfo::argumentFPR0) {
 930             moveDouble(arg1, FPRInfo::argumentFPR0);
 931             moveDouble(arg2, FPRInfo::argumentFPR1);
 932         } else if (arg1 != FPRInfo::argumentFPR1) {
 933             moveDouble(arg2, FPRInfo::argumentFPR1);
 934             moveDouble(arg1, FPRInfo::argumentFPR0);
 935         } else {
 936             // Swap arg1, arg2.
 937             swapDouble(FPRInfo::argumentFPR0, FPRInfo::argumentFPR1);
 938         }
 939     }
 940
 941     ALWAYS_INLINE void setupArgumentsWithExecState(FPRReg arg1, GPRReg arg2)
 942     {
 943         assembler().vmov(GPRInfo::argumentGPR2, GPRInfo::argumentGPR3, arg1);
 944         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 945         poke(arg2, 4);
 946     }
 947
 948     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, FPRReg arg3)
 949     {
 950         setupStubArguments(arg1, arg2);
 951         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 952         poke(arg3, 4);
 953     }
 954
 955     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, FPRReg arg2, GPRReg arg3)
 956     {
 957         setupArgumentsWithExecState(arg2, arg3);
 958     }
 959
 960     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, FPRReg arg4)
 961     {
 962         setupArgumentsWithExecState(arg1, arg2, arg4);
 963     }
 964 #elif CPU(SH4)
 965     ALWAYS_INLINE void setupArguments(FPRReg arg1)
 966     {
 967         moveDouble(arg1, FPRInfo::argumentFPR0);
 968     }
 969
 970     ALWAYS_INLINE void setupArguments(FPRReg arg1, FPRReg arg2)
 971     {
 972         if (arg2 != FPRInfo::argumentFPR0) {
 973             moveDouble(arg1, FPRInfo::argumentFPR0);
 974             moveDouble(arg2, FPRInfo::argumentFPR1);
 975         } else if (arg1 != FPRInfo::argumentFPR1) {
 976             moveDouble(arg2, FPRInfo::argumentFPR1);
 977             moveDouble(arg1, FPRInfo::argumentFPR0);
 978         } else
 979             swapDouble(FPRInfo::argumentFPR0, FPRInfo::argumentFPR1);
 980     }
 981
 982     ALWAYS_INLINE void setupArgumentsWithExecState(FPRReg arg1, GPRReg arg2)
 983     {
 984         moveDouble(arg1, FPRInfo::argumentFPR0);
 985         move(arg2, GPRInfo::argumentGPR1);
 986         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 987     }
 988
 989     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, FPRReg arg3)
 990     {
 991         moveDouble(arg3, FPRInfo::argumentFPR0);
 992         setupStubArguments(arg1, arg2);
 993         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 994     }
 995 #else
 996 #error "JIT not supported on this platform."
 997 #endif
 998
 999     ALWAYS_INLINE void setupArguments(GPRReg arg1)
1000     {
1001         move(arg1, GPRInfo::argumentGPR0);
1002     }
1003
1004     ALWAYS_INLINE void setupArguments(TrustedImmPtr arg1, GPRReg arg2)
1005     {
1006         move(arg2, GPRInfo::argumentGPR1);
1007         move(arg1, GPRInfo::argumentGPR0);
1008     }
1009
1010     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2)
1011     {
1012         setupTwoStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1>(arg1, arg2);
1013     }
1014
1015     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, GPRReg arg3)
1016     {
1017         setupThreeStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1, GPRInfo::argumentGPR2>(arg1, arg2, arg3);
1018     }
1019
1020     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImmPtr arg4)
1021     {
1022         setupTwoStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1>(arg1, arg2);
1023         move(arg3, GPRInfo::argumentGPR2);
1024         move(arg4, GPRInfo::argumentGPR3);
1025     }
1026
1027     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
1028     {
1029         setupThreeStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1, GPRInfo::argumentGPR2>(arg1, arg2, arg3);
1030         move(arg4, GPRInfo::argumentGPR3);
1031     }
1032
1033     ALWAYS_INLINE void setupArguments(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3, TrustedImmPtr arg4)
1034     {
1035         setupTwoStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR2>(arg1, arg3);
1036         move(arg2, GPRInfo::argumentGPR1);
1037         move(arg4, GPRInfo::argumentGPR3);
1038     }
1039
1040     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4, GPRReg arg5, GPRReg arg6)
1041     {
1042         poke(arg6, POKE_ARGUMENT_OFFSET + 1);
1043         poke(arg5, POKE_ARGUMENT_OFFSET);
1044         setupTwoStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1>(arg1, arg2);
1045         move(arg3, GPRInfo::argumentGPR2);
1046         move(arg4, GPRInfo::argumentGPR3);
1047     }
1048
1049     ALWAYS_INLINE void setupArguments(TrustedImmPtr arg1)
1050     {
1051         move(arg1, GPRInfo::argumentGPR0);
1052     }
1053
1054     ALWAYS_INLINE void setupArgumentsExecState()
1055     {
1056         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1057     }
1058
1059     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1)
1060     {
1061         move(arg1, GPRInfo::argumentGPR1);
1062         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1063     }
1064
1065     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1)
1066     {
1067         move(arg1, GPRInfo::argumentGPR1);
1068         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1069     }
1070
1071     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1)
1072     {
1073         move(arg1, GPRInfo::argumentGPR1);
1074         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1075     }
1076
1077 #if OS(WINDOWS) && CPU(X86_64)
1078     ALWAYS_INLINE void setupArgumentsWithExecStateForCallWithSlowPathReturnType(TrustedImm32 arg1)
1079     {
1080         move(arg1, GPRInfo::argumentGPR2);
1081         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR1);
1082     }
1083 #endif
1084
1085     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2)
1086     {
1087         setupStubArguments(arg1, arg2);
1088         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1089     }
1090
1091     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2)
1092     {
1093         move(arg1, GPRInfo::argumentGPR1);
1094         move(arg2, GPRInfo::argumentGPR2);
1095         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1096     }
1097 #if CPU(X86_64) || CPU(ARM64)
1098     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm64 arg2)
1099     {
1100         move(arg1, GPRInfo::argumentGPR1);
1101         move(arg2, GPRInfo::argumentGPR2);
1102         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1103     }
1104
1105     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm64 arg1, GPRReg arg2)
1106     {
1107         move(arg2, GPRInfo::argumentGPR2); // Move this first, so setting arg1 does not trample!
1108         move(arg1, GPRInfo::argumentGPR1);
1109         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1110     }
1111 #endif
1112     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2)
1113     {
1114         move(arg1, GPRInfo::argumentGPR1);
1115         move(arg2, GPRInfo::argumentGPR2);
1116         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1117     }
1118
1119     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, ImmPtr arg2)
1120     {
1121         move(arg1, GPRInfo::argumentGPR1);
1122         move(arg2, GPRInfo::argumentGPR2);
1123         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1124     }
1125
1126     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2)
1127     {
1128         move(arg2, GPRInfo::argumentGPR2); // Move this first, so setting arg1 does not trample!
1129         move(arg1, GPRInfo::argumentGPR1);
1130         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1131     }
1132
1133     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2)
1134     {
1135         move(arg2, GPRInfo::argumentGPR2); // Move this first, so setting arg1 does not trample!
1136         move(arg1, GPRInfo::argumentGPR1);
1137         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1138     }
1139
1140     ALWAYS_INLINE void setupArgumentsWithExecState(ImmPtr arg1, GPRReg arg2)
1141     {
1142         move(arg2, GPRInfo::argumentGPR2); // Move this first, so setting arg1 does not trample!
1143         move(arg1, GPRInfo::argumentGPR1);
1144         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1145     }
1146
1147     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2)
1148     {
1149         move(arg1, GPRInfo::argumentGPR1);
1150         move(arg2, GPRInfo::argumentGPR2);
1151         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1152     }
1153
1154     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2)
1155     {
1156         move(arg1, GPRInfo::argumentGPR1);
1157         move(arg2, GPRInfo::argumentGPR2);
1158         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1159     }
1160
1161     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImm32 arg2)
1162     {
1163         move(arg1, GPRInfo::argumentGPR1);
1164         move(arg2, GPRInfo::argumentGPR2);
1165         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1166     }
1167
1168     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImm32 arg2, TrustedImm32 arg3)
1169     {
1170         move(arg1, GPRInfo::argumentGPR1);
1171         move(arg2, GPRInfo::argumentGPR2);
1172         move(arg3, GPRInfo::argumentGPR3);
1173         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1174     }
1175
1176     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3)
1177     {
1178         setupStubArguments(arg1, arg2, arg3);
1179         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1180     }
1181
1182     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3)
1183     {
1184         setupStubArguments(arg1, arg2);
1185         move(arg3, GPRInfo::argumentGPR3);
1186         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1187     }
1188
1189     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, GPRReg arg3)
1190     {
1191         setupTwoStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR3>(arg1, arg3);
1192         move(arg2, GPRInfo::argumentGPR2);
1193         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1194     }
1195
1196     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3)
1197     {
1198         setupTwoStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR3>(arg1, arg3);
1199         move(arg2, GPRInfo::argumentGPR2);
1200         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1201     }
1202
1203     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, TrustedImmPtr arg3)
1204     {
1205         move(arg1, GPRInfo::argumentGPR1);
1206         move(arg2, GPRInfo::argumentGPR2);
1207         move(arg3, GPRInfo::argumentGPR3);
1208         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1209     }
1210
1211     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3)
1212     {
1213         move(arg1, GPRInfo::argumentGPR1);
1214         move(arg2, GPRInfo::argumentGPR2);
1215         move(arg3, GPRInfo::argumentGPR3);
1216         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1217     }
1218
1219     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, TrustedImm32 arg3)
1220     {
1221         move(arg1, GPRInfo::argumentGPR1);
1222         move(arg2, GPRInfo::argumentGPR2);
1223         move(arg3, GPRInfo::argumentGPR3);
1224         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1225     }
1226
1227     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImmPtr arg3)
1228     {
1229         move(arg1, GPRInfo::argumentGPR1);
1230         move(arg2, GPRInfo::argumentGPR2);
1231         move(arg3, GPRInfo::argumentGPR3);
1232         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1233     }
1234
1235     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3)
1236     {
1237         setupStubArguments(arg1, arg2);
1238         move(arg3, GPRInfo::argumentGPR3);
1239         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1240     }
1241
1242     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2, GPRReg arg3)
1243     {
1244         move(arg3, GPRInfo::argumentGPR3);
1245         move(arg1, GPRInfo::argumentGPR1);
1246         move(arg2, GPRInfo::argumentGPR2);
1247         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1248     }
1249
1250     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3)
1251     {
1252         move(arg3, GPRInfo::argumentGPR3);
1253         move(arg1, GPRInfo::argumentGPR1);
1254         move(arg2, GPRInfo::argumentGPR2);
1255         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1256     }
1257
1258     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, TrustedImm32 arg3)
1259     {
1260         move(arg2, GPRInfo::argumentGPR2);
1261         move(arg1, GPRInfo::argumentGPR1);
1262         move(arg3, GPRInfo::argumentGPR3);
1263         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1264     }
1265
1266     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3)
1267     {
1268         setupTwoStubArgsGPR<GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg2, arg3);
1269         move(arg1, GPRInfo::argumentGPR1);
1270         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1271     }
1272
1273     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3)
1274     {
1275         setupTwoStubArgsGPR<GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg2, arg3);
1276         move(arg1, GPRInfo::argumentGPR1);
1277         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1278     }
1279
1280     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3)
1281     {
1282         move(arg2, GPRInfo::argumentGPR2); // In case arg2 is argumentGPR1.
1283         move(arg1, GPRInfo::argumentGPR1);
1284         move(arg3, GPRInfo::argumentGPR3);
1285         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1286     }
1287
1288     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImmPtr arg3)
1289     {
1290         move(arg2, GPRInfo::argumentGPR2); // In case arg2 is argumentGPR1.
1291         move(arg1, GPRInfo::argumentGPR1);
1292         move(arg3, GPRInfo::argumentGPR3);
1293         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1294     }
1295
1296     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2, TrustedImm32 arg3)
1297     {
1298         move(arg1, GPRInfo::argumentGPR1);
1299         move(arg2, GPRInfo::argumentGPR2);
1300         move(arg3, GPRInfo::argumentGPR3);
1301         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1302     }
1303
1304     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2, TrustedImmPtr arg3)
1305     {
1306         move(arg1, GPRInfo::argumentGPR1);
1307         move(arg2, GPRInfo::argumentGPR2);
1308         move(arg3, GPRInfo::argumentGPR3);
1309         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1310     }
1311
1312     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2, TrustedImm32 arg3)
1313     {
1314         move(arg1, GPRInfo::argumentGPR1);
1315         move(arg2, GPRInfo::argumentGPR2);
1316         move(arg3, GPRInfo::argumentGPR3);
1317         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1318     }
1319
1320 #endif // NUMBER_OF_ARGUMENT_REGISTERS >= 4
1321     // These methods are suitable for any calling convention that provides for
1322     // exactly 4 argument registers, e.g. ARMv7.
1323 #if NUMBER_OF_ARGUMENT_REGISTERS == 4
1324
1325     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4)
1326     {
1327         poke(arg4, POKE_ARGUMENT_OFFSET);
1328         setupArgumentsWithExecState(arg1, arg2, arg3);
1329     }
1330
1331     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4)
1332     {
1333         poke(arg4, POKE_ARGUMENT_OFFSET);
1334         setupArgumentsWithExecState(arg1, arg2, arg3);
1335     }
1336
1337     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3,  GPRReg arg4)
1338     {
1339         poke(arg4, POKE_ARGUMENT_OFFSET);
1340         setupArgumentsWithExecState(arg1, arg2, arg3);
1341     }
1342
1343     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4)
1344     {
1345         poke(arg4, POKE_ARGUMENT_OFFSET);
1346         setupArgumentsWithExecState(arg1, arg2, arg3);
1347     }
1348
1349     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4)
1350     {
1351         poke(arg4, POKE_ARGUMENT_OFFSET);
1352         setupArgumentsWithExecState(arg1, arg2, arg3);
1353     }
1354
1355     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
1356     {
1357         poke(arg4, POKE_ARGUMENT_OFFSET);
1358         setupArgumentsWithExecState(arg1, arg2, arg3);
1359     }
1360
1361     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImmPtr arg4)
1362     {
1363         poke(arg4, POKE_ARGUMENT_OFFSET);
1364         setupArgumentsWithExecState(arg1, arg2, arg3);
1365     }
1366
1367     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImmPtr arg5)
1368     {
1369         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1370         poke(arg4, POKE_ARGUMENT_OFFSET);
1371         setupArgumentsWithExecState(arg1, arg2, arg3);
1372     }
1373
1374     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
1375     {
1376         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1377         poke(arg4, POKE_ARGUMENT_OFFSET);
1378         setupArgumentsWithExecState(arg1, arg2, arg3);
1379     }
1380
1381     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImm32 arg4)
1382     {
1383         poke(arg4, POKE_ARGUMENT_OFFSET);
1384         setupArgumentsWithExecState(arg1, arg2, arg3);
1385     }
1386
1387     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImm32 arg4, TrustedImm32 arg5)
1388     {
1389         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1390         poke(arg4, POKE_ARGUMENT_OFFSET);
1391         setupArgumentsWithExecState(arg1, arg2, arg3);
1392     }
1393
1394     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2, GPRReg arg3, GPRReg arg4)
1395     {
1396         poke(arg4, POKE_ARGUMENT_OFFSET);
1397         setupArgumentsWithExecState(arg1, arg2, arg3);
1398     }
1399
1400     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
1401     {
1402         poke(arg4, POKE_ARGUMENT_OFFSET);
1403         setupArgumentsWithExecState(arg1, arg2, arg3);
1404     }
1405
1406     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
1407     {
1408         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1409         poke(arg4, POKE_ARGUMENT_OFFSET);
1410         setupArgumentsWithExecState(arg1, arg2, arg3);
1411     }
1412
1413     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImm32 arg5)
1414     {
1415         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1416         poke(arg4, POKE_ARGUMENT_OFFSET);
1417         setupArgumentsWithExecState(arg1, arg2, arg3);
1418     }
1419
1420     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4)
1421     {
1422         poke(arg4, POKE_ARGUMENT_OFFSET);
1423         setupArgumentsWithExecState(arg1, arg2, arg3);
1424     }
1425
1426     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
1427     {
1428         poke(arg4, POKE_ARGUMENT_OFFSET);
1429         setupArgumentsWithExecState(arg1, arg2, arg3);
1430     }
1431
1432     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImmPtr arg4)
1433     {
1434         poke(arg4, POKE_ARGUMENT_OFFSET);
1435         setupArgumentsWithExecState(arg1, arg2, arg3);
1436     }
1437
1438     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4)
1439     {
1440         poke(arg4, POKE_ARGUMENT_OFFSET);
1441         setupArgumentsWithExecState(arg1, arg2, arg3);
1442     }
1443
1444     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4)
1445     {
1446         poke(arg4, POKE_ARGUMENT_OFFSET);
1447         setupArgumentsWithExecState(arg1, arg2, arg3);
1448     }
1449
1450     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImmPtr arg4)
1451     {
1452         poke(arg4, POKE_ARGUMENT_OFFSET);
1453         setupArgumentsWithExecState(arg1, arg2, arg3);
1454     }
1455
1456     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
1457     {
1458         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1459         poke(arg4, POKE_ARGUMENT_OFFSET);
1460         setupArgumentsWithExecState(arg1, arg2, arg3);
1461     }
1462
1463     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, TrustedImm32 arg5)
1464     {
1465         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1466         poke(arg4, POKE_ARGUMENT_OFFSET);
1467         setupArgumentsWithExecState(arg1, arg2, arg3);
1468     }
1469
1470     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImmPtr arg5)
1471     {
1472         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1473         poke(arg4, POKE_ARGUMENT_OFFSET);
1474         setupArgumentsWithExecState(arg1, arg2, arg3);
1475     }
1476
1477     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
1478     {
1479         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1480         poke(arg4, POKE_ARGUMENT_OFFSET);
1481         setupArgumentsWithExecState(arg1, arg2, arg3);
1482     }
1483
1484     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
1485     {
1486         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1487         poke(arg4, POKE_ARGUMENT_OFFSET);
1488         setupArgumentsWithExecState(arg1, arg2, arg3);
1489     }
1490
1491     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
1492     {
1493         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1494         poke(arg4, POKE_ARGUMENT_OFFSET);
1495         setupArgumentsWithExecState(arg1, arg2, arg3);
1496     }
1497
1498     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
1499     {
1500         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1501         poke(arg4, POKE_ARGUMENT_OFFSET);
1502         setupArgumentsWithExecState(arg1, arg2, arg3);
1503     }
1504
1505     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, GPRReg arg4, TrustedImm32 arg5)
1506     {
1507         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1508         poke(arg4, POKE_ARGUMENT_OFFSET);
1509         setupArgumentsWithExecState(arg1, arg2, arg3);
1510     }
1511
1512     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6)
1513     {
1514         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1515         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1516         poke(arg4, POKE_ARGUMENT_OFFSET);
1517         setupArgumentsWithExecState(arg1, arg2, arg3);
1518     }
1519
1520     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, TrustedImm32 arg6)
1521     {
1522         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1523         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1524         poke(arg4, POKE_ARGUMENT_OFFSET);
1525         setupArgumentsWithExecState(arg1, arg2, arg3);
1526     }
1527
1528     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5, TrustedImm32 arg6)
1529     {
1530         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1531         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1532         poke(arg4, POKE_ARGUMENT_OFFSET);
1533         setupArgumentsWithExecState(arg1, arg2, arg3);
1534     }
1535
1536     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, GPRReg arg4, GPRReg arg5)
1537     {
1538         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1539         poke(arg4, POKE_ARGUMENT_OFFSET);
1540         setupArgumentsWithExecState(arg1, arg2, arg3);
1541     }
1542
1543     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, TrustedImm32 arg5, TrustedImmPtr arg6)
1544     {
1545         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1546         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1547         poke(arg4, POKE_ARGUMENT_OFFSET);
1548         setupArgumentsWithExecState(arg1, arg2, arg3);
1549     }
1550
1551     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, TrustedImmPtr arg6)
1552     {
1553         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1554         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1555         poke(arg4, POKE_ARGUMENT_OFFSET);
1556         setupArgumentsWithExecState(arg1, arg2, arg3);
1557     }
1558
1559     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImm32 arg5, TrustedImmPtr arg6)
1560     {
1561         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1562         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1563         poke(arg4, POKE_ARGUMENT_OFFSET);
1564         setupArgumentsWithExecState(arg1, arg2, arg3);
1565     }
1566
1567     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, TrustedImm32 arg6)
1568     {
1569         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1570         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1571         poke(arg4, POKE_ARGUMENT_OFFSET);
1572         setupArgumentsWithExecState(arg1, arg2, arg3);
1573     }
1574
1575     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, GPRReg arg5, GPRReg arg6)
1576     {
1577         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1578         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1579         poke(arg4, POKE_ARGUMENT_OFFSET);
1580         setupArgumentsWithExecState(arg1, arg2, arg3);
1581     }
1582
1583     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6, GPRReg arg7)
1584     {
1585         poke(arg7, POKE_ARGUMENT_OFFSET + 3);
1586         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1587         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1588         poke(arg4, POKE_ARGUMENT_OFFSET);
1589         setupArgumentsWithExecState(arg1, arg2, arg3);
1590     }
1591
1592     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6, GPRReg arg7)
1593     {
1594         poke(arg7, POKE_ARGUMENT_OFFSET + 3);
1595         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1596         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1597         poke(arg4, POKE_ARGUMENT_OFFSET);
1598         setupArgumentsWithExecState(arg1, arg2, arg3);
1599     }
1600
1601     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5, GPRReg arg6, GPRReg arg7)
1602     {
1603         poke(arg7, POKE_ARGUMENT_OFFSET + 3);
1604         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1605         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1606         poke(arg4, POKE_ARGUMENT_OFFSET);
1607         setupArgumentsWithExecState(arg1, arg2, arg3);
1608     }
1609
1610     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4, GPRReg arg5)
1611     {
1612         poke(arg5, POKE_ARGUMENT_OFFSET);
1613         setupTwoStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1>(arg1, arg2);
1614         move(arg3, GPRInfo::argumentGPR2);
1615         move(arg4, GPRInfo::argumentGPR3);
1616     }
1617 #endif // NUMBER_OF_ARGUMENT_REGISTERS == 4
1618
1619 #if NUMBER_OF_ARGUMENT_REGISTERS >= 5
1620     void setupStubArguments134(GPRReg arg1, GPRReg arg3, GPRReg arg4)
1621     {
1622         setupThreeStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR3, GPRInfo::argumentGPR4>(arg1, arg3, arg4);
1623     }
1624
1625     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4)
1626     {
1627         setupTwoStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR4>(arg1, arg4);
1628         move(arg2, GPRInfo::argumentGPR2);
1629         move(arg3, GPRInfo::argumentGPR3);
1630         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1631     }
1632
1633     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4)
1634     {
1635         setupStubArguments134(arg1, arg3, arg4);
1636         move(arg2, GPRInfo::argumentGPR2);
1637         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1638     }
1639
1640     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
1641     {
1642         setupTwoStubArgsGPR<GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg2, arg3);
1643         move(arg1, GPRInfo::argumentGPR1);
1644         move(arg4, GPRInfo::argumentGPR4);
1645         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1646     }
1647
1648     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4)
1649     {
1650         setupThreeStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg1, arg2, arg3);
1651         move(arg4, GPRInfo::argumentGPR4);
1652         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1653     }
1654
1655     ALWAYS_INLINE void setupArguments(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4, TrustedImmPtr arg5)
1656     {
1657         setupThreeStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg1, arg3, arg4);
1658         move(arg2, GPRInfo::argumentGPR1);
1659         move(arg5, GPRInfo::argumentGPR4);
1660     }
1661
1662     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4, GPRReg arg5)
1663     {
1664         setupThreeStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1, GPRInfo::argumentGPR4>(arg1, arg2, arg5);
1665         move(arg3, GPRInfo::argumentGPR2);
1666         move(arg4, GPRInfo::argumentGPR3);
1667     }
1668 #endif
1669
1670     void setupResults(GPRReg destA, GPRReg destB)
1671     {
1672         GPRReg srcA = GPRInfo::returnValueGPR;
1673         GPRReg srcB = GPRInfo::returnValueGPR2;
1674
1675         if (destA == InvalidGPRReg)
1676             move(srcB, destB);
1677         else if (destB == InvalidGPRReg)
1678             move(srcA, destA);
1679         else if (srcB != destA) {
1680             // Handle the easy cases - two simple moves.
1681             move(srcA, destA);
1682             move(srcB, destB);
1683         } else if (srcA != destB) {
1684             // Handle the non-swap case - just put srcB in place first.
1685             move(srcB, destB);
1686             move(srcA, destA);
1687         } else
1688             swap(destA, destB);
1689     }
1690
1691     void setupResults(JSValueRegs regs)
1692     {
1693 #if USE(JSVALUE64)
1694         move(GPRInfo::returnValueGPR, regs.gpr());
1695 #else
1696         setupResults(regs.payloadGPR(), regs.tagGPR());
1697 #endif
1698     }
1699
1700     void jumpToExceptionHandler()
1701     {
1702         // genericUnwind() leaves the handler CallFrame* in vm->callFrameForThrow,
1703         // and the address of the handler in vm->targetMachinePCForThrow.
1704         loadPtr(&vm()->targetMachinePCForThrow, GPRInfo::regT1);
1705         jump(GPRInfo::regT1);
1706     }
1707 };
1708
1709 } // namespace JSC
1710
1711 #endif // ENABLE(JIT)
1712
1713 #endif // CCallHelpers_h
1714