Source/JavaScriptCore/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(TrustedImm32 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, GPRReg 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, TrustedImm32 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, GPRReg arg2, TrustedImmPtr 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, TrustedImm32 arg3)
 329     {
 330         resetCallArguments();
 331         addCallArgument(GPRInfo::callFrameRegister);
 332         addCallArgument(arg1);
 333         addCallArgument(arg2);
 334         addCallArgument(arg3);
 335     }
 336
 337     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr 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, TrustedImmPtr arg3)
 347     {
 348         resetCallArguments();
 349         addCallArgument(GPRInfo::callFrameRegister);
 350         addCallArgument(arg1);
 351         addCallArgument(arg2);
 352         addCallArgument(arg3);
 353     }
 354
 355     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4)
 356     {
 357         resetCallArguments();
 358         addCallArgument(GPRInfo::callFrameRegister);
 359         addCallArgument(arg1);
 360         addCallArgument(arg2);
 361         addCallArgument(arg3);
 362         addCallArgument(arg4);
 363     }
 364
 365     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImm32 arg2, GPRReg arg3, TrustedImmPtr arg4)
 366     {
 367         resetCallArguments();
 368         addCallArgument(GPRInfo::callFrameRegister);
 369         addCallArgument(arg1);
 370         addCallArgument(arg2);
 371         addCallArgument(arg3);
 372         addCallArgument(arg4);
 373     }
 374
 375     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImmPtr arg4)
 376     {
 377         resetCallArguments();
 378         addCallArgument(GPRInfo::callFrameRegister);
 379         addCallArgument(arg1);
 380         addCallArgument(arg2);
 381         addCallArgument(arg3);
 382         addCallArgument(arg4);
 383     }
 384
 385     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
 386     {
 387         resetCallArguments();
 388         addCallArgument(GPRInfo::callFrameRegister);
 389         addCallArgument(arg1);
 390         addCallArgument(arg2);
 391         addCallArgument(arg3);
 392         addCallArgument(arg4);
 393         addCallArgument(arg5);
 394     }
 395
 396     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
 397     {
 398         resetCallArguments();
 399         addCallArgument(GPRInfo::callFrameRegister);
 400         addCallArgument(arg1);
 401         addCallArgument(arg2);
 402         addCallArgument(arg3);
 403         addCallArgument(arg4);
 404         addCallArgument(arg5);
 405     }
 406
 407     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4, TrustedImm32 arg5)
 408     {
 409         resetCallArguments();
 410         addCallArgument(GPRInfo::callFrameRegister);
 411         addCallArgument(arg1);
 412         addCallArgument(arg2);
 413         addCallArgument(arg3);
 414         addCallArgument(arg4);
 415         addCallArgument(arg5);
 416     }
 417
 418     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4)
 419     {
 420         resetCallArguments();
 421         addCallArgument(GPRInfo::callFrameRegister);
 422         addCallArgument(arg1);
 423         addCallArgument(arg2);
 424         addCallArgument(arg3);
 425         addCallArgument(arg4);
 426     }
 427
 428     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4)
 429     {
 430         resetCallArguments();
 431         addCallArgument(GPRInfo::callFrameRegister);
 432         addCallArgument(arg1);
 433         addCallArgument(arg2);
 434         addCallArgument(arg3);
 435         addCallArgument(arg4);
 436     }
 437
 438     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, GPRReg arg5)
 439     {
 440         resetCallArguments();
 441         addCallArgument(GPRInfo::callFrameRegister);
 442         addCallArgument(arg1);
 443         addCallArgument(arg2);
 444         addCallArgument(arg3);
 445         addCallArgument(arg4);
 446         addCallArgument(arg5);
 447     }
 448
 449     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3)
 450     {
 451         resetCallArguments();
 452         addCallArgument(GPRInfo::callFrameRegister);
 453         addCallArgument(arg1);
 454         addCallArgument(arg2);
 455         addCallArgument(arg3);
 456     }
 457
 458     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
 459     {
 460         resetCallArguments();
 461         addCallArgument(GPRInfo::callFrameRegister);
 462         addCallArgument(arg1);
 463         addCallArgument(arg2);
 464         addCallArgument(arg3);
 465         addCallArgument(arg4);
 466     }
 467
 468     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImm32 arg4)
 469     {
 470         resetCallArguments();
 471         addCallArgument(GPRInfo::callFrameRegister);
 472         addCallArgument(arg1);
 473         addCallArgument(arg2);
 474         addCallArgument(arg3);
 475         addCallArgument(arg4);
 476     }
 477
 478     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4)
 479     {
 480         resetCallArguments();
 481         addCallArgument(GPRInfo::callFrameRegister);
 482         addCallArgument(arg1);
 483         addCallArgument(arg2);
 484         addCallArgument(arg3);
 485         addCallArgument(arg4);
 486     }
 487
 488     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2, GPRReg arg3, GPRReg arg4)
 489     {
 490         resetCallArguments();
 491         addCallArgument(GPRInfo::callFrameRegister);
 492         addCallArgument(arg1);
 493         addCallArgument(arg2);
 494         addCallArgument(arg3);
 495         addCallArgument(arg4);
 496     }
 497
 498     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4)
 499     {
 500         resetCallArguments();
 501         addCallArgument(GPRInfo::callFrameRegister);
 502         addCallArgument(arg1);
 503         addCallArgument(arg2);
 504         addCallArgument(arg3);
 505         addCallArgument(arg4);
 506     }
 507
 508     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
 509     {
 510         resetCallArguments();
 511         addCallArgument(GPRInfo::callFrameRegister);
 512         addCallArgument(arg1);
 513         addCallArgument(arg2);
 514         addCallArgument(arg3);
 515         addCallArgument(arg4);
 516         addCallArgument(arg5);
 517     }
 518
 519     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImmPtr arg5)
 520     {
 521         resetCallArguments();
 522         addCallArgument(GPRInfo::callFrameRegister);
 523         addCallArgument(arg1);
 524         addCallArgument(arg2);
 525         addCallArgument(arg3);
 526         addCallArgument(arg4);
 527         addCallArgument(arg5);
 528     }
 529
 530     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, TrustedImmPtr arg6)
 531     {
 532         resetCallArguments();
 533         addCallArgument(GPRInfo::callFrameRegister);
 534         addCallArgument(arg1);
 535         addCallArgument(arg2);
 536         addCallArgument(arg3);
 537         addCallArgument(arg4);
 538         addCallArgument(arg5);
 539         addCallArgument(arg6);
 540     }
 541
 542     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImm32 arg5, TrustedImmPtr arg6)
 543     {
 544         resetCallArguments();
 545         addCallArgument(GPRInfo::callFrameRegister);
 546         addCallArgument(arg1);
 547         addCallArgument(arg2);
 548         addCallArgument(arg3);
 549         addCallArgument(arg4);
 550         addCallArgument(arg5);
 551         addCallArgument(arg6);
 552     }
 553
 554     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
 555     {
 556         resetCallArguments();
 557         addCallArgument(GPRInfo::callFrameRegister);
 558         addCallArgument(arg1);
 559         addCallArgument(arg2);
 560         addCallArgument(arg3);
 561         addCallArgument(arg4);
 562     }
 563
 564     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImmPtr arg4)
 565     {
 566         resetCallArguments();
 567         addCallArgument(GPRInfo::callFrameRegister);
 568         addCallArgument(arg1);
 569         addCallArgument(arg2);
 570         addCallArgument(arg3);
 571         addCallArgument(arg4);
 572     }
 573
 574     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4)
 575     {
 576         resetCallArguments();
 577         addCallArgument(GPRInfo::callFrameRegister);
 578         addCallArgument(arg1);
 579         addCallArgument(arg2);
 580         addCallArgument(arg3);
 581         addCallArgument(arg4);
 582     }
 583
 584     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
 585     {
 586         resetCallArguments();
 587         addCallArgument(GPRInfo::callFrameRegister);
 588         addCallArgument(arg1);
 589         addCallArgument(arg2);
 590         addCallArgument(arg3);
 591         addCallArgument(arg4);
 592         addCallArgument(arg5);
 593     }
 594
 595     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
 596     {
 597         resetCallArguments();
 598         addCallArgument(GPRInfo::callFrameRegister);
 599         addCallArgument(arg1);
 600         addCallArgument(arg2);
 601         addCallArgument(arg3);
 602         addCallArgument(arg4);
 603         addCallArgument(arg5);
 604     }
 605
 606     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImmPtr arg5)
 607     {
 608         resetCallArguments();
 609         addCallArgument(GPRInfo::callFrameRegister);
 610         addCallArgument(arg1);
 611         addCallArgument(arg2);
 612         addCallArgument(arg3);
 613         addCallArgument(arg4);
 614         addCallArgument(arg5);
 615     }
 616
 617     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImmPtr arg5)
 618     {
 619         resetCallArguments();
 620         addCallArgument(GPRInfo::callFrameRegister);
 621         addCallArgument(arg1);
 622         addCallArgument(arg2);
 623         addCallArgument(arg3);
 624         addCallArgument(arg4);
 625         addCallArgument(arg5);
 626     }
 627
 628     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImm32 arg5)
 629     {
 630         resetCallArguments();
 631         addCallArgument(GPRInfo::callFrameRegister);
 632         addCallArgument(arg1);
 633         addCallArgument(arg2);
 634         addCallArgument(arg3);
 635         addCallArgument(arg4);
 636         addCallArgument(arg5);
 637     }
 638
 639     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6)
 640     {
 641         resetCallArguments();
 642         addCallArgument(GPRInfo::callFrameRegister);
 643         addCallArgument(arg1);
 644         addCallArgument(arg2);
 645         addCallArgument(arg3);
 646         addCallArgument(arg4);
 647         addCallArgument(arg5);
 648         addCallArgument(arg6);
 649     }
 650
 651
 652     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, TrustedImm32 arg6)
 653     {
 654         resetCallArguments();
 655         addCallArgument(GPRInfo::callFrameRegister);
 656         addCallArgument(arg1);
 657         addCallArgument(arg2);
 658         addCallArgument(arg3);
 659         addCallArgument(arg4);
 660         addCallArgument(arg5);
 661         addCallArgument(arg6);
 662     }
 663
 664     ALWAYS_INLINE void setupArgumentsWithExecState(FPRReg arg1, GPRReg arg2)
 665     {
 666         resetCallArguments();
 667         addCallArgument(GPRInfo::callFrameRegister);
 668         addCallArgument(arg1);
 669         addCallArgument(arg2);
 670     }
 671
 672     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, FPRReg arg3)
 673     {
 674         resetCallArguments();
 675         addCallArgument(GPRInfo::callFrameRegister);
 676         addCallArgument(arg1);
 677         addCallArgument(arg2);
 678         addCallArgument(arg3);
 679     }
 680 #endif // !NUMBER_OF_ARGUMENT_REGISTERS
 681     // These methods are suitable for any calling convention that provides for
 682     // at least 4 argument registers, e.g. X86_64, ARMv7.
 683 #if NUMBER_OF_ARGUMENT_REGISTERS >= 4
 684     template<GPRReg destA, GPRReg destB>
 685     void setupTwoStubArgsGPR(GPRReg srcA, GPRReg srcB)
 686     {
 687         // Assuming that srcA != srcB, there are 7 interesting states the registers may be in:
 688         // (1) both are already in arg regs, the right way around.
 689         // (2) both are already in arg regs, the wrong way around.
 690         // (3) neither are currently in arg registers.
 691         // (4) srcA in in its correct reg.
 692         // (5) srcA in in the incorrect reg.
 693         // (6) srcB in in its correct reg.
 694         // (7) srcB in in the incorrect reg.
 695         //
 696         // The trivial approach is to simply emit two moves, to put srcA in place then srcB in
 697         // place (the MacroAssembler will omit redundant moves). This apporach will be safe in
 698         // cases 1, 3, 4, 5, 6, and in cases where srcA==srcB. The two problem cases are 2
 699         // (requires a swap) and 7 (must move srcB first, to avoid trampling.)
 700
 701         if (srcB != destA) {
 702             // Handle the easy cases - two simple moves.
 703             move(srcA, destA);
 704             move(srcB, destB);
 705         } else if (srcA != destB) {
 706             // Handle the non-swap case - just put srcB in place first.
 707             move(srcB, destB);
 708             move(srcA, destA);
 709         } else
 710             swap(destA, destB);
 711     }
 712
 713     template<GPRReg destA, GPRReg destB, GPRReg destC>
 714     void setupThreeStubArgsGPR(GPRReg srcA, GPRReg srcB, GPRReg srcC)
 715     {
 716         // If neither of srcB/srcC are in our way, then we can move srcA into place.
 717         // Then we can use setupTwoStubArgs to fix srcB/srcC.
 718         if (srcB != destA && srcC != destA) {
 719             move(srcA, destA);
 720             setupTwoStubArgsGPR<destB, destC>(srcB, srcC);
 721             return;
 722         }
 723
 724         // If neither of srcA/srcC are in our way, then we can move srcB into place.
 725         // Then we can use setupTwoStubArgs to fix srcA/srcC.
 726         if (srcA != destB && srcC != destB) {
 727             move(srcB, destB);
 728             setupTwoStubArgsGPR<destA, destC>(srcA, srcC);
 729             return;
 730         }
 731
 732         // If neither of srcA/srcB are in our way, then we can move srcC into place.
 733         // Then we can use setupTwoStubArgs to fix srcA/srcB.
 734         if (srcA != destC && srcB != destC) {
 735             move(srcC, destC);
 736             setupTwoStubArgsGPR<destA, destB>(srcA, srcB);
 737             return;
 738         }
 739
 740         // If we get here, we haven't been able to move any of srcA/srcB/srcC.
 741         // Since all three are blocked, then all three must already be in the argument register.
 742         // But are they in the right ones?
 743
 744         // First, ensure srcA is in place.
 745         if (srcA != destA) {
 746             swap(srcA, destA);
 747
 748             // If srcA wasn't in argumentGPR1, one of srcB/srcC must be.
 749             ASSERT(srcB == destA || srcC == destA);
 750             // If srcB was in argumentGPR1 it no longer is (due to the swap).
 751             // Otherwise srcC must have been. Mark him as moved.
 752             if (srcB == destA)
 753                 srcB = srcA;
 754             else
 755                 srcC = srcA;
 756         }
 757
 758         // Either srcB & srcC need swapping, or we're all done.
 759         ASSERT((srcB == destB || srcC == destC)
 760             || (srcB == destC || srcC == destB));
 761
 762         if (srcB != destB)
 763             swap(destB, destC);
 764     }
 765
 766 #if CPU(X86_64) || CPU(ARM64)
 767     template<FPRReg destA, FPRReg destB>
 768     void setupTwoStubArgsFPR(FPRReg srcA, FPRReg srcB)
 769     {
 770         // Assuming that srcA != srcB, there are 7 interesting states the registers may be in:
 771         // (1) both are already in arg regs, the right way around.
 772         // (2) both are already in arg regs, the wrong way around.
 773         // (3) neither are currently in arg registers.
 774         // (4) srcA in in its correct reg.
 775         // (5) srcA in in the incorrect reg.
 776         // (6) srcB in in its correct reg.
 777         // (7) srcB in in the incorrect reg.
 778         //
 779         // The trivial approach is to simply emit two moves, to put srcA in place then srcB in
 780         // place (the MacroAssembler will omit redundant moves). This apporach will be safe in
 781         // cases 1, 3, 4, 5, 6, and in cases where srcA==srcB. The two problem cases are 2
 782         // (requires a swap) and 7 (must move srcB first, to avoid trampling.)
 783
 784         if (srcB != destA) {
 785             // Handle the easy cases - two simple moves.
 786             moveDouble(srcA, destA);
 787             moveDouble(srcB, destB);
 788             return;
 789         }
 790
 791         if (srcA != destB) {
 792             // Handle the non-swap case - just put srcB in place first.
 793             moveDouble(srcB, destB);
 794             moveDouble(srcA, destA);
 795             return;
 796         }
 797
 798         ASSERT(srcB == destA && srcA == destB);
 799         // Need to swap; pick a temporary register.
 800         FPRReg temp;
 801         if (destA != FPRInfo::argumentFPR3 && destA != FPRInfo::argumentFPR3)
 802             temp = FPRInfo::argumentFPR3;
 803         else if (destA != FPRInfo::argumentFPR2 && destA != FPRInfo::argumentFPR2)
 804             temp = FPRInfo::argumentFPR2;
 805         else {
 806             ASSERT(destA != FPRInfo::argumentFPR1 && destA != FPRInfo::argumentFPR1);
 807             temp = FPRInfo::argumentFPR1;
 808         }
 809         moveDouble(destA, temp);
 810         moveDouble(destB, destA);
 811         moveDouble(temp, destB);
 812     }
 813 #endif
 814     void setupStubArguments(GPRReg arg1, GPRReg arg2)
 815     {
 816         setupTwoStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2>(arg1, arg2);
 817     }
 818
 819     void setupStubArguments(GPRReg arg1, GPRReg arg2, GPRReg arg3)
 820     {
 821         setupThreeStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg1, arg2, arg3);
 822     }
 823
 824 #if CPU(MIPS) || (OS(WINDOWS) && CPU(X86_64))
 825 #define POKE_ARGUMENT_OFFSET 4
 826 #else
 827 #define POKE_ARGUMENT_OFFSET 0
 828 #endif
 829
 830 #if CPU(X86_64) || CPU(ARM64)
 831     ALWAYS_INLINE void setupArguments(FPRReg arg1)
 832     {
 833         moveDouble(arg1, FPRInfo::argumentFPR0);
 834     }
 835
 836     ALWAYS_INLINE void setupArguments(FPRReg arg1, FPRReg arg2)
 837     {
 838         setupTwoStubArgsFPR<FPRInfo::argumentFPR0, FPRInfo::argumentFPR1>(arg1, arg2);
 839     }
 840
 841     ALWAYS_INLINE void setupArgumentsWithExecState(FPRReg arg1, GPRReg arg2)
 842     {
 843 #if OS(WINDOWS) && CPU(X86_64)
 844         // On Windows, arguments map to designated registers based on the argument positions, even when there are interlaced scalar and floating point arguments.
 845         // See http://msdn.microsoft.com/en-us/library/zthk2dkh.aspx
 846         moveDouble(arg1, FPRInfo::argumentFPR1);
 847         move(arg2, GPRInfo::argumentGPR2);
 848 #else
 849         moveDouble(arg1, FPRInfo::argumentFPR0);
 850         move(arg2, GPRInfo::argumentGPR1);
 851 #endif
 852         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 853     }
 854
 855     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, FPRReg arg3)
 856     {
 857 #if OS(WINDOWS) && CPU(X86_64)
 858         // On Windows, arguments map to designated registers based on the argument positions, even when there are interlaced scalar and floating point arguments.
 859         // See http://msdn.microsoft.com/en-us/library/zthk2dkh.aspx
 860         moveDouble(arg3, FPRInfo::argumentFPR3);
 861 #else
 862         moveDouble(arg3, FPRInfo::argumentFPR0);
 863 #endif
 864         setupStubArguments(arg1, arg2);
 865         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 866     }
 867 #elif CPU(ARM)
 868 #if CPU(ARM_HARDFP)
 869     ALWAYS_INLINE void setupArguments(FPRReg arg1)
 870     {
 871         moveDouble(arg1, FPRInfo::argumentFPR0);
 872     }
 873
 874     ALWAYS_INLINE void setupArguments(FPRReg arg1, FPRReg arg2)
 875     {
 876         if (arg2 != FPRInfo::argumentFPR0) {
 877             moveDouble(arg1, FPRInfo::argumentFPR0);
 878             moveDouble(arg2, FPRInfo::argumentFPR1);
 879         } else if (arg1 != FPRInfo::argumentFPR1) {
 880             moveDouble(arg2, FPRInfo::argumentFPR1);
 881             moveDouble(arg1, FPRInfo::argumentFPR0);
 882         } else {
 883             // Swap arg1, arg2.
 884             moveDouble(FPRInfo::argumentFPR0, ARMRegisters::d2);
 885             moveDouble(FPRInfo::argumentFPR1, FPRInfo::argumentFPR0);
 886             moveDouble(ARMRegisters::d2, FPRInfo::argumentFPR1);
 887         }
 888     }
 889
 890     ALWAYS_INLINE void setupArgumentsWithExecState(FPRReg arg1, GPRReg arg2)
 891     {
 892         moveDouble(arg1, FPRInfo::argumentFPR0);
 893         move(arg2, GPRInfo::argumentGPR1);
 894         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 895     }
 896
 897     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, FPRReg arg3)
 898     {
 899         moveDouble(arg3, FPRInfo::argumentFPR0);
 900         setupStubArguments(arg1, arg2);
 901         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 902     }
 903
 904     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32, FPRReg arg2, GPRReg arg3)
 905     {
 906         moveDouble(arg2, FPRInfo::argumentFPR0);
 907         move(arg3, GPRInfo::argumentGPR1);
 908         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 909     }
 910
 911     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32, FPRReg arg4)
 912     {
 913         moveDouble(arg4, FPRInfo::argumentFPR0);
 914         setupStubArguments(arg1, arg2);
 915         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 916     }
 917
 918 #else
 919     ALWAYS_INLINE void setupArguments(FPRReg arg1)
 920     {
 921         assembler().vmov(GPRInfo::argumentGPR0, GPRInfo::argumentGPR1, arg1);
 922     }
 923
 924     ALWAYS_INLINE void setupArguments(FPRReg arg1, FPRReg arg2)
 925     {
 926         assembler().vmov(GPRInfo::argumentGPR0, GPRInfo::argumentGPR1, arg1);
 927         assembler().vmov(GPRInfo::argumentGPR2, GPRInfo::argumentGPR3, arg2);
 928     }
 929
 930     ALWAYS_INLINE void setupArgumentsWithExecState(FPRReg arg1, GPRReg arg2)
 931     {
 932         move(arg2, GPRInfo::argumentGPR3);
 933         assembler().vmov(GPRInfo::argumentGPR1, GPRInfo::argumentGPR2, arg1);
 934         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 935     }
 936
 937     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, FPRReg arg3)
 938     {
 939         setupStubArguments(arg1, arg2);
 940         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 941         assembler().vmov(GPRInfo::argumentGPR3, GPRInfo::nonArgGPR0, arg3);
 942         poke(GPRInfo::nonArgGPR0);
 943     }
 944
 945     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, FPRReg arg2, GPRReg arg3)
 946     {
 947         poke(arg3, POKE_ARGUMENT_OFFSET);
 948         move(arg1, GPRInfo::argumentGPR1);
 949         assembler().vmov(GPRInfo::argumentGPR2, GPRInfo::argumentGPR3, arg2);
 950         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 951     }
 952
 953     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, FPRReg arg4)
 954     {
 955         setupStubArguments(arg1, arg2);
 956         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 957         move(arg3, GPRInfo::argumentGPR3);
 958         assembler().vmov(GPRInfo::nonArgGPR0, GPRInfo::nonArgGPR1, arg4);
 959         poke(GPRInfo::nonArgGPR0, POKE_ARGUMENT_OFFSET);
 960         poke(GPRInfo::nonArgGPR1, POKE_ARGUMENT_OFFSET + 1);
 961     }
 962 #endif // CPU(ARM_HARDFP)
 963 #elif CPU(MIPS)
 964     ALWAYS_INLINE void setupArguments(FPRReg arg1)
 965     {
 966         moveDouble(arg1, FPRInfo::argumentFPR0);
 967     }
 968
 969     ALWAYS_INLINE void setupArguments(FPRReg arg1, FPRReg arg2)
 970     {
 971         if (arg2 != FPRInfo::argumentFPR0) {
 972             moveDouble(arg1, FPRInfo::argumentFPR0);
 973             moveDouble(arg2, FPRInfo::argumentFPR1);
 974         } else if (arg1 != FPRInfo::argumentFPR1) {
 975             moveDouble(arg2, FPRInfo::argumentFPR1);
 976             moveDouble(arg1, FPRInfo::argumentFPR0);
 977         } else {
 978             // Swap arg1, arg2.
 979             swapDouble(FPRInfo::argumentFPR0, FPRInfo::argumentFPR1);
 980         }
 981     }
 982
 983     ALWAYS_INLINE void setupArgumentsWithExecState(FPRReg arg1, GPRReg arg2)
 984     {
 985         assembler().vmov(GPRInfo::argumentGPR2, GPRInfo::argumentGPR3, arg1);
 986         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 987         poke(arg2, 4);
 988     }
 989
 990     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, FPRReg arg3)
 991     {
 992         setupStubArguments(arg1, arg2);
 993         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
 994         poke(arg3, 4);
 995     }
 996
 997     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, FPRReg arg2, GPRReg arg3)
 998     {
 999         setupArgumentsWithExecState(arg2, arg3);
1000     }
1001
1002     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, FPRReg arg4)
1003     {
1004         setupArgumentsWithExecState(arg1, arg2, arg4);
1005     }
1006 #elif CPU(SH4)
1007     ALWAYS_INLINE void setupArguments(FPRReg arg1)
1008     {
1009         moveDouble(arg1, FPRInfo::argumentFPR0);
1010     }
1011
1012     ALWAYS_INLINE void setupArguments(FPRReg arg1, FPRReg arg2)
1013     {
1014         if (arg2 != FPRInfo::argumentFPR0) {
1015             moveDouble(arg1, FPRInfo::argumentFPR0);
1016             moveDouble(arg2, FPRInfo::argumentFPR1);
1017         } else if (arg1 != FPRInfo::argumentFPR1) {
1018             moveDouble(arg2, FPRInfo::argumentFPR1);
1019             moveDouble(arg1, FPRInfo::argumentFPR0);
1020         } else
1021             swapDouble(FPRInfo::argumentFPR0, FPRInfo::argumentFPR1);
1022     }
1023
1024     ALWAYS_INLINE void setupArgumentsWithExecState(FPRReg arg1, GPRReg arg2)
1025     {
1026         moveDouble(arg1, FPRInfo::argumentFPR0);
1027         move(arg2, GPRInfo::argumentGPR1);
1028         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1029     }
1030
1031     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, FPRReg arg3)
1032     {
1033         moveDouble(arg3, FPRInfo::argumentFPR0);
1034         setupStubArguments(arg1, arg2);
1035         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1036     }
1037 #else
1038 #error "JIT not supported on this platform."
1039 #endif
1040
1041     ALWAYS_INLINE void setupArguments(GPRReg arg1)
1042     {
1043         move(arg1, GPRInfo::argumentGPR0);
1044     }
1045
1046     ALWAYS_INLINE void setupArguments(TrustedImmPtr arg1, GPRReg arg2)
1047     {
1048         move(arg2, GPRInfo::argumentGPR1);
1049         move(arg1, GPRInfo::argumentGPR0);
1050     }
1051
1052     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2)
1053     {
1054         setupTwoStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1>(arg1, arg2);
1055     }
1056
1057     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, GPRReg arg3)
1058     {
1059         setupThreeStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1, GPRInfo::argumentGPR2>(arg1, arg2, arg3);
1060     }
1061
1062     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImmPtr arg4)
1063     {
1064         setupTwoStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1>(arg1, arg2);
1065         move(arg3, GPRInfo::argumentGPR2);
1066         move(arg4, GPRInfo::argumentGPR3);
1067     }
1068
1069     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
1070     {
1071         setupThreeStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1, GPRInfo::argumentGPR2>(arg1, arg2, arg3);
1072         move(arg4, GPRInfo::argumentGPR3);
1073     }
1074
1075     ALWAYS_INLINE void setupArguments(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3, TrustedImmPtr arg4)
1076     {
1077         setupTwoStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR2>(arg1, arg3);
1078         move(arg2, GPRInfo::argumentGPR1);
1079         move(arg4, GPRInfo::argumentGPR3);
1080     }
1081
1082     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4, GPRReg arg5, GPRReg arg6)
1083     {
1084         poke(arg6, POKE_ARGUMENT_OFFSET + 1);
1085         poke(arg5, POKE_ARGUMENT_OFFSET);
1086         setupTwoStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1>(arg1, arg2);
1087         move(arg3, GPRInfo::argumentGPR2);
1088         move(arg4, GPRInfo::argumentGPR3);
1089     }
1090
1091     ALWAYS_INLINE void setupArguments(TrustedImmPtr arg1)
1092     {
1093         move(arg1, GPRInfo::argumentGPR0);
1094     }
1095
1096     ALWAYS_INLINE void setupArgumentsExecState()
1097     {
1098         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1099     }
1100
1101     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1)
1102     {
1103         move(arg1, GPRInfo::argumentGPR1);
1104         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1105     }
1106
1107     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1)
1108     {
1109         move(arg1, GPRInfo::argumentGPR1);
1110         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1111     }
1112
1113     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1)
1114     {
1115         move(arg1, GPRInfo::argumentGPR1);
1116         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1117     }
1118
1119 #if OS(WINDOWS) && CPU(X86_64)
1120     ALWAYS_INLINE void setupArgumentsWithExecStateForCallWithSlowPathReturnType(TrustedImm32 arg1)
1121     {
1122         move(arg1, GPRInfo::argumentGPR2);
1123         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR1);
1124     }
1125 #endif
1126
1127     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2)
1128     {
1129         setupStubArguments(arg1, arg2);
1130         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1131     }
1132
1133     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2)
1134     {
1135         move(arg1, GPRInfo::argumentGPR1);
1136         move(arg2, GPRInfo::argumentGPR2);
1137         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1138     }
1139 #if CPU(X86_64) || CPU(ARM64)
1140     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm64 arg2)
1141     {
1142         move(arg1, GPRInfo::argumentGPR1);
1143         move(arg2, GPRInfo::argumentGPR2);
1144         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1145     }
1146
1147     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm64 arg1, GPRReg arg2)
1148     {
1149         move(arg2, GPRInfo::argumentGPR2); // Move this first, so setting arg1 does not trample!
1150         move(arg1, GPRInfo::argumentGPR1);
1151         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1152     }
1153 #endif
1154     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 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(GPRReg arg1, ImmPtr 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, GPRReg arg2)
1169     {
1170         move(arg2, GPRInfo::argumentGPR2); // Move this first, so setting arg1 does not trample!
1171         move(arg1, GPRInfo::argumentGPR1);
1172         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1173     }
1174
1175     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2)
1176     {
1177         move(arg2, GPRInfo::argumentGPR2); // Move this first, so setting arg1 does not trample!
1178         move(arg1, GPRInfo::argumentGPR1);
1179         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1180     }
1181
1182     ALWAYS_INLINE void setupArgumentsWithExecState(ImmPtr arg1, GPRReg arg2)
1183     {
1184         move(arg2, GPRInfo::argumentGPR2); // Move this first, so setting arg1 does not trample!
1185         move(arg1, GPRInfo::argumentGPR1);
1186         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1187     }
1188
1189     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2)
1190     {
1191         move(arg1, GPRInfo::argumentGPR1);
1192         move(arg2, GPRInfo::argumentGPR2);
1193         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1194     }
1195
1196     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2)
1197     {
1198         move(arg1, GPRInfo::argumentGPR1);
1199         move(arg2, GPRInfo::argumentGPR2);
1200         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1201     }
1202
1203     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImm32 arg2)
1204     {
1205         move(arg1, GPRInfo::argumentGPR1);
1206         move(arg2, GPRInfo::argumentGPR2);
1207         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1208     }
1209
1210     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImm32 arg2, TrustedImm32 arg3)
1211     {
1212         move(arg1, GPRInfo::argumentGPR1);
1213         move(arg2, GPRInfo::argumentGPR2);
1214         move(arg3, GPRInfo::argumentGPR3);
1215         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1216     }
1217
1218     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3)
1219     {
1220         setupStubArguments(arg1, arg2, arg3);
1221         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1222     }
1223
1224     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3)
1225     {
1226         setupStubArguments(arg1, arg2);
1227         move(arg3, GPRInfo::argumentGPR3);
1228         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1229     }
1230
1231     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, GPRReg arg3)
1232     {
1233         setupTwoStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR3>(arg1, arg3);
1234         move(arg2, GPRInfo::argumentGPR2);
1235         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1236     }
1237
1238     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3)
1239     {
1240         setupTwoStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR3>(arg1, arg3);
1241         move(arg2, GPRInfo::argumentGPR2);
1242         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1243     }
1244
1245     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, TrustedImmPtr arg3)
1246     {
1247         move(arg1, GPRInfo::argumentGPR1);
1248         move(arg2, GPRInfo::argumentGPR2);
1249         move(arg3, GPRInfo::argumentGPR3);
1250         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1251     }
1252
1253     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3)
1254     {
1255         move(arg1, GPRInfo::argumentGPR1);
1256         move(arg2, GPRInfo::argumentGPR2);
1257         move(arg3, GPRInfo::argumentGPR3);
1258         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1259     }
1260
1261     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, TrustedImm32 arg3)
1262     {
1263         move(arg1, GPRInfo::argumentGPR1);
1264         move(arg2, GPRInfo::argumentGPR2);
1265         move(arg3, GPRInfo::argumentGPR3);
1266         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1267     }
1268
1269     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImmPtr arg3)
1270     {
1271         move(arg1, GPRInfo::argumentGPR1);
1272         move(arg2, GPRInfo::argumentGPR2);
1273         move(arg3, GPRInfo::argumentGPR3);
1274         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1275     }
1276
1277     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3)
1278     {
1279         setupStubArguments(arg1, arg2);
1280         move(arg3, GPRInfo::argumentGPR3);
1281         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1282     }
1283
1284     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2, GPRReg arg3)
1285     {
1286         move(arg3, GPRInfo::argumentGPR3);
1287         move(arg1, GPRInfo::argumentGPR1);
1288         move(arg2, GPRInfo::argumentGPR2);
1289         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1290     }
1291
1292     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2, GPRReg arg3)
1293     {
1294         move(arg3, GPRInfo::argumentGPR3);
1295         move(arg1, GPRInfo::argumentGPR1);
1296         move(arg2, GPRInfo::argumentGPR2);
1297         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1298     }
1299
1300     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3)
1301     {
1302         move(arg3, GPRInfo::argumentGPR3);
1303         move(arg1, GPRInfo::argumentGPR1);
1304         move(arg2, GPRInfo::argumentGPR2);
1305         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1306     }
1307
1308     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, TrustedImm32 arg3)
1309     {
1310         move(arg3, GPRInfo::argumentGPR3);
1311         move(arg1, GPRInfo::argumentGPR1);
1312         move(arg2, GPRInfo::argumentGPR2);
1313         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1314     }
1315
1316     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, TrustedImm32 arg3)
1317     {
1318         move(arg2, GPRInfo::argumentGPR2);
1319         move(arg1, GPRInfo::argumentGPR1);
1320         move(arg3, GPRInfo::argumentGPR3);
1321         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1322     }
1323
1324     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3)
1325     {
1326         setupTwoStubArgsGPR<GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg2, arg3);
1327         move(arg1, GPRInfo::argumentGPR1);
1328         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1329     }
1330
1331     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3)
1332     {
1333         setupTwoStubArgsGPR<GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg2, arg3);
1334         move(arg1, GPRInfo::argumentGPR1);
1335         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1336     }
1337
1338     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3)
1339     {
1340         move(arg2, GPRInfo::argumentGPR2); // In case arg2 is argumentGPR1.
1341         move(arg1, GPRInfo::argumentGPR1);
1342         move(arg3, GPRInfo::argumentGPR3);
1343         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1344     }
1345
1346     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImmPtr arg3)
1347     {
1348         move(arg2, GPRInfo::argumentGPR2); // In case arg2 is argumentGPR1.
1349         move(arg1, GPRInfo::argumentGPR1);
1350         move(arg3, GPRInfo::argumentGPR3);
1351         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1352     }
1353
1354     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2, TrustedImm32 arg3)
1355     {
1356         move(arg1, GPRInfo::argumentGPR1);
1357         move(arg2, GPRInfo::argumentGPR2);
1358         move(arg3, GPRInfo::argumentGPR3);
1359         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1360     }
1361
1362     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2, TrustedImmPtr arg3)
1363     {
1364         move(arg1, GPRInfo::argumentGPR1);
1365         move(arg2, GPRInfo::argumentGPR2);
1366         move(arg3, GPRInfo::argumentGPR3);
1367         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1368     }
1369
1370     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2, TrustedImm32 arg3)
1371     {
1372         move(arg1, GPRInfo::argumentGPR1);
1373         move(arg2, GPRInfo::argumentGPR2);
1374         move(arg3, GPRInfo::argumentGPR3);
1375         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1376     }
1377
1378 #endif // NUMBER_OF_ARGUMENT_REGISTERS >= 4
1379     // These methods are suitable for any calling convention that provides for
1380     // exactly 4 argument registers, e.g. ARMv7.
1381 #if NUMBER_OF_ARGUMENT_REGISTERS == 4
1382
1383     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4)
1384     {
1385         poke(arg4, POKE_ARGUMENT_OFFSET);
1386         setupArgumentsWithExecState(arg1, arg2, arg3);
1387     }
1388
1389     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4)
1390     {
1391         poke(arg4, POKE_ARGUMENT_OFFSET);
1392         setupArgumentsWithExecState(arg1, arg2, arg3);
1393     }
1394
1395     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, GPRReg arg5)
1396     {
1397         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1398         poke(arg4, POKE_ARGUMENT_OFFSET);
1399         setupArgumentsWithExecState(arg1, arg2, arg3);
1400     }
1401
1402     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3,  GPRReg arg4)
1403     {
1404         poke(arg4, POKE_ARGUMENT_OFFSET);
1405         setupArgumentsWithExecState(arg1, arg2, arg3);
1406     }
1407
1408     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4)
1409     {
1410         poke(arg4, POKE_ARGUMENT_OFFSET);
1411         setupArgumentsWithExecState(arg1, arg2, arg3);
1412     }
1413
1414     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4)
1415     {
1416         poke(arg4, POKE_ARGUMENT_OFFSET);
1417         setupArgumentsWithExecState(arg1, arg2, arg3);
1418     }
1419
1420     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
1421     {
1422         poke(arg4, POKE_ARGUMENT_OFFSET);
1423         setupArgumentsWithExecState(arg1, arg2, arg3);
1424     }
1425
1426     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImm32 arg4)
1427     {
1428         poke(arg4, POKE_ARGUMENT_OFFSET);
1429         setupArgumentsWithExecState(arg1, arg2, arg3);
1430     }
1431
1432     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr 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, TrustedImmPtr arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
1439     {
1440         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1441         poke(arg4, POKE_ARGUMENT_OFFSET);
1442         setupArgumentsWithExecState(arg1, arg2, arg3);
1443     }
1444
1445     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5, TrustedImm32 arg6)
1446     {
1447         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1448         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1449         poke(arg4, POKE_ARGUMENT_OFFSET);
1450         setupArgumentsWithExecState(arg1, arg2, arg3);
1451     }
1452
1453     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
1454     {
1455         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1456         poke(arg4, POKE_ARGUMENT_OFFSET);
1457         setupArgumentsWithExecState(arg1, arg2, arg3);
1458     }
1459
1460     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImmPtr arg5)
1461     {
1462         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1463         poke(arg4, POKE_ARGUMENT_OFFSET);
1464         setupArgumentsWithExecState(arg1, arg2, arg3);
1465     }
1466
1467     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
1468     {
1469         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1470         poke(arg4, POKE_ARGUMENT_OFFSET);
1471         setupArgumentsWithExecState(arg1, arg2, arg3);
1472     }
1473
1474     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImm32 arg4)
1475     {
1476         poke(arg4, POKE_ARGUMENT_OFFSET);
1477         setupArgumentsWithExecState(arg1, arg2, arg3);
1478     }
1479
1480     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImm32 arg4, TrustedImm32 arg5)
1481     {
1482         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1483         poke(arg4, POKE_ARGUMENT_OFFSET);
1484         setupArgumentsWithExecState(arg1, arg2, arg3);
1485     }
1486
1487     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2, GPRReg arg3, GPRReg arg4)
1488     {
1489         poke(arg4, POKE_ARGUMENT_OFFSET);
1490         setupArgumentsWithExecState(arg1, arg2, arg3);
1491     }
1492
1493     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
1494     {
1495         poke(arg4, POKE_ARGUMENT_OFFSET);
1496         setupArgumentsWithExecState(arg1, arg2, arg3);
1497     }
1498
1499     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
1500     {
1501         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1502         poke(arg4, POKE_ARGUMENT_OFFSET);
1503         setupArgumentsWithExecState(arg1, arg2, arg3);
1504     }
1505
1506     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImm32 arg5)
1507     {
1508         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1509         poke(arg4, POKE_ARGUMENT_OFFSET);
1510         setupArgumentsWithExecState(arg1, arg2, arg3);
1511     }
1512
1513     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4)
1514     {
1515         poke(arg4, POKE_ARGUMENT_OFFSET);
1516         setupArgumentsWithExecState(arg1, arg2, arg3);
1517     }
1518
1519     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
1520     {
1521         poke(arg4, POKE_ARGUMENT_OFFSET);
1522         setupArgumentsWithExecState(arg1, arg2, arg3);
1523     }
1524
1525     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImmPtr arg4)
1526     {
1527         poke(arg4, POKE_ARGUMENT_OFFSET);
1528         setupArgumentsWithExecState(arg1, arg2, arg3);
1529     }
1530
1531     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4)
1532     {
1533         poke(arg4, POKE_ARGUMENT_OFFSET);
1534         setupArgumentsWithExecState(arg1, arg2, arg3);
1535     }
1536
1537     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4)
1538     {
1539         poke(arg4, POKE_ARGUMENT_OFFSET);
1540         setupArgumentsWithExecState(arg1, arg2, arg3);
1541     }
1542
1543     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImmPtr arg4)
1544     {
1545         poke(arg4, POKE_ARGUMENT_OFFSET);
1546         setupArgumentsWithExecState(arg1, arg2, arg3);
1547     }
1548
1549     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4)
1550     {
1551         poke(arg4, POKE_ARGUMENT_OFFSET);
1552         setupArgumentsWithExecState(arg1, arg2, arg3);
1553     }
1554
1555     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
1556     {
1557         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1558         poke(arg4, POKE_ARGUMENT_OFFSET);
1559         setupArgumentsWithExecState(arg1, arg2, arg3);
1560     }
1561
1562     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, TrustedImm32 arg5)
1563     {
1564         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1565         poke(arg4, POKE_ARGUMENT_OFFSET);
1566         setupArgumentsWithExecState(arg1, arg2, arg3);
1567     }
1568
1569     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImmPtr arg5)
1570     {
1571         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1572         poke(arg4, POKE_ARGUMENT_OFFSET);
1573         setupArgumentsWithExecState(arg1, arg2, arg3);
1574     }
1575
1576     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
1577     {
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(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
1584     {
1585         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1586         poke(arg4, POKE_ARGUMENT_OFFSET);
1587         setupArgumentsWithExecState(arg1, arg2, arg3);
1588     }
1589
1590     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4, TrustedImm32 arg5)
1591     {
1592         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1593         poke(arg4, POKE_ARGUMENT_OFFSET);
1594         setupArgumentsWithExecState(arg1, arg2, arg3);
1595     }
1596
1597     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
1598     {
1599         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1600         poke(arg4, POKE_ARGUMENT_OFFSET);
1601         setupArgumentsWithExecState(arg1, arg2, arg3);
1602     }
1603
1604     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
1605     {
1606         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1607         poke(arg4, POKE_ARGUMENT_OFFSET);
1608         setupArgumentsWithExecState(arg1, arg2, arg3);
1609     }
1610
1611     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
1612     {
1613         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1614         poke(arg4, POKE_ARGUMENT_OFFSET);
1615         setupArgumentsWithExecState(arg1, arg2, arg3);
1616     }
1617
1618     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, GPRReg arg4, TrustedImm32 arg5)
1619     {
1620         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1621         poke(arg4, POKE_ARGUMENT_OFFSET);
1622         setupArgumentsWithExecState(arg1, arg2, arg3);
1623     }
1624
1625     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6)
1626     {
1627         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1628         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1629         poke(arg4, POKE_ARGUMENT_OFFSET);
1630         setupArgumentsWithExecState(arg1, arg2, arg3);
1631     }
1632
1633     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, TrustedImm32 arg6)
1634     {
1635         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1636         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1637         poke(arg4, POKE_ARGUMENT_OFFSET);
1638         setupArgumentsWithExecState(arg1, arg2, arg3);
1639     }
1640
1641     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5, TrustedImm32 arg6)
1642     {
1643         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1644         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1645         poke(arg4, POKE_ARGUMENT_OFFSET);
1646         setupArgumentsWithExecState(arg1, arg2, arg3);
1647     }
1648
1649     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, GPRReg arg4, GPRReg arg5)
1650     {
1651         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1652         poke(arg4, POKE_ARGUMENT_OFFSET);
1653         setupArgumentsWithExecState(arg1, arg2, arg3);
1654     }
1655
1656     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, TrustedImm32 arg5, TrustedImmPtr arg6)
1657     {
1658         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1659         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1660         poke(arg4, POKE_ARGUMENT_OFFSET);
1661         setupArgumentsWithExecState(arg1, arg2, arg3);
1662     }
1663
1664     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, TrustedImmPtr arg6)
1665     {
1666         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1667         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1668         poke(arg4, POKE_ARGUMENT_OFFSET);
1669         setupArgumentsWithExecState(arg1, arg2, arg3);
1670     }
1671
1672     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImm32 arg5, TrustedImmPtr arg6)
1673     {
1674         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1675         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1676         poke(arg4, POKE_ARGUMENT_OFFSET);
1677         setupArgumentsWithExecState(arg1, arg2, arg3);
1678     }
1679
1680     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, TrustedImm32 arg6)
1681     {
1682         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1683         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1684         poke(arg4, POKE_ARGUMENT_OFFSET);
1685         setupArgumentsWithExecState(arg1, arg2, arg3);
1686     }
1687
1688     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, GPRReg arg5, GPRReg arg6)
1689     {
1690         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1691         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1692         poke(arg4, POKE_ARGUMENT_OFFSET);
1693         setupArgumentsWithExecState(arg1, arg2, arg3);
1694     }
1695
1696     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, GPRReg arg5, TrustedImm32 arg6)
1697     {
1698         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1699         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1700         poke(arg4, POKE_ARGUMENT_OFFSET);
1701         setupArgumentsWithExecState(arg1, arg2, arg3);
1702     }
1703
1704     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6, GPRReg arg7)
1705     {
1706         poke(arg7, POKE_ARGUMENT_OFFSET + 3);
1707         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1708         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1709         poke(arg4, POKE_ARGUMENT_OFFSET);
1710         setupArgumentsWithExecState(arg1, arg2, arg3);
1711     }
1712
1713     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6, GPRReg arg7)
1714     {
1715         poke(arg7, POKE_ARGUMENT_OFFSET + 3);
1716         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1717         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1718         poke(arg4, POKE_ARGUMENT_OFFSET);
1719         setupArgumentsWithExecState(arg1, arg2, arg3);
1720     }
1721
1722     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5, GPRReg arg6, GPRReg arg7)
1723     {
1724         poke(arg7, POKE_ARGUMENT_OFFSET + 3);
1725         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1726         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1727         poke(arg4, POKE_ARGUMENT_OFFSET);
1728         setupArgumentsWithExecState(arg1, arg2, arg3);
1729     }
1730
1731     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4, GPRReg arg5)
1732     {
1733         poke(arg5, POKE_ARGUMENT_OFFSET);
1734         setupTwoStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1>(arg1, arg2);
1735         move(arg3, GPRInfo::argumentGPR2);
1736         move(arg4, GPRInfo::argumentGPR3);
1737     }
1738 #endif // NUMBER_OF_ARGUMENT_REGISTERS == 4
1739
1740 #if NUMBER_OF_ARGUMENT_REGISTERS >= 5
1741     void setupStubArguments134(GPRReg arg1, GPRReg arg3, GPRReg arg4)
1742     {
1743         setupThreeStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR3, GPRInfo::argumentGPR4>(arg1, arg3, arg4);
1744     }
1745
1746     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4)
1747     {
1748         setupTwoStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR4>(arg1, arg4);
1749         move(arg2, GPRInfo::argumentGPR2);
1750         move(arg3, GPRInfo::argumentGPR3);
1751         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1752     }
1753
1754     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4)
1755     {
1756         setupStubArguments134(arg1, arg3, arg4);
1757         move(arg2, GPRInfo::argumentGPR2);
1758         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1759     }
1760
1761     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
1762     {
1763         setupTwoStubArgsGPR<GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg2, arg3);
1764         move(arg1, GPRInfo::argumentGPR1);
1765         move(arg4, GPRInfo::argumentGPR4);
1766         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1767     }
1768
1769     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImm32 arg4)
1770     {
1771         move(arg2, GPRInfo::argumentGPR2); // In case arg2 is argumentGPR1.
1772         move(arg1, GPRInfo::argumentGPR1);
1773         move(arg3, GPRInfo::argumentGPR3);
1774         move(arg4, GPRInfo::argumentGPR4);
1775         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1776     }
1777
1778     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
1779     {
1780         move(arg3, GPRInfo::argumentGPR3);
1781         move(arg1, GPRInfo::argumentGPR1);
1782         move(arg2, GPRInfo::argumentGPR2);
1783         move(arg4, GPRInfo::argumentGPR4);
1784         move(arg5, GPRInfo::argumentGPR5);
1785         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1786     }
1787
1788     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
1789     {
1790         setupTwoStubArgsGPR<GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg2, arg3);
1791         move(arg1, GPRInfo::argumentGPR1);
1792         move(arg4, GPRInfo::argumentGPR4);
1793         move(arg5, GPRInfo::argumentGPR5);
1794         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1795     }
1796
1797     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4)
1798     {
1799         setupThreeStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg1, arg2, arg3);
1800         move(arg4, GPRInfo::argumentGPR4);
1801         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1802     }
1803
1804     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4)
1805     {
1806         setupThreeStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2, GPRInfo::argumentGPR4>(arg1, arg2, arg4);
1807         move(arg3, GPRInfo::argumentGPR3);
1808         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1809     }
1810
1811     ALWAYS_INLINE void setupArguments(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4, TrustedImmPtr arg5)
1812     {
1813         setupThreeStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg1, arg3, arg4);
1814         move(arg2, GPRInfo::argumentGPR1);
1815         move(arg5, GPRInfo::argumentGPR4);
1816     }
1817
1818     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4, GPRReg arg5)
1819     {
1820         setupThreeStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1, GPRInfo::argumentGPR4>(arg1, arg2, arg5);
1821         move(arg3, GPRInfo::argumentGPR2);
1822         move(arg4, GPRInfo::argumentGPR3);
1823     }
1824 #endif
1825
1826     void setupArguments(JSValueRegs arg1)
1827     {
1828 #if USE(JSVALUE64)
1829         setupArguments(arg1.gpr());
1830 #else
1831         setupArguments(arg1.payloadGPR(), arg1.tagGPR());
1832 #endif
1833     }
1834
1835     void setupResults(GPRReg destA, GPRReg destB)
1836     {
1837         GPRReg srcA = GPRInfo::returnValueGPR;
1838         GPRReg srcB = GPRInfo::returnValueGPR2;
1839
1840         if (destA == InvalidGPRReg)
1841             move(srcB, destB);
1842         else if (destB == InvalidGPRReg)
1843             move(srcA, destA);
1844         else if (srcB != destA) {
1845             // Handle the easy cases - two simple moves.
1846             move(srcA, destA);
1847             move(srcB, destB);
1848         } else if (srcA != destB) {
1849             // Handle the non-swap case - just put srcB in place first.
1850             move(srcB, destB);
1851             move(srcA, destA);
1852         } else
1853             swap(destA, destB);
1854     }
1855
1856     void setupResults(JSValueRegs regs)
1857     {
1858 #if USE(JSVALUE64)
1859         move(GPRInfo::returnValueGPR, regs.gpr());
1860 #else
1861         setupResults(regs.payloadGPR(), regs.tagGPR());
1862 #endif
1863     }
1864
1865     void jumpToExceptionHandler()
1866     {
1867         // genericUnwind() leaves the handler CallFrame* in vm->callFrameForThrow,
1868         // the topVMEntryFrame for the handler in vm->vmEntryFrameForThrow,
1869         // and the address of the handler in vm->targetMachinePCForThrow.
1870         loadPtr(&vm()->targetMachinePCForThrow, GPRInfo::regT1);
1871         jump(GPRInfo::regT1);
1872     }
1873 };
1874
1875 } // namespace JSC
1876
1877 #endif // ENABLE(JIT)
1878
1879 #endif // CCallHelpers_h
1880