op_add/ValueAdd should be an IC in all JIT tiers
[WebKit.git] / Source / JavaScriptCore / jit / CCallHelpers.h
1 /*
2  * Copyright (C) 2011, 2015-2016 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 #include "RegisterMap.h"
34 #include "StackAlignment.h"
35
36 namespace JSC {
37
38 #if CPU(MIPS) || (OS(WINDOWS) && CPU(X86_64))
39 #define POKE_ARGUMENT_OFFSET 4
40 #else
41 #define POKE_ARGUMENT_OFFSET 0
42 #endif
43
44 // EncodedJSValue in JSVALUE32_64 is a 64-bit integer. When being compiled in ARM EABI, it must be aligned even-numbered register (r0, r2 or [sp]).
45 // To avoid assemblies from using wrong registers, let's occupy r1 or r3 with a dummy argument when necessary.
46 #if (COMPILER_SUPPORTS(EABI) && CPU(ARM)) || CPU(MIPS)
47 #define EABI_32BIT_DUMMY_ARG      CCallHelpers::TrustedImm32(0),
48 #else
49 #define EABI_32BIT_DUMMY_ARG
50 #endif
51
52 // JSVALUE32_64 is a 64-bit integer that cannot be put half in an argument register and half on stack when using SH4 architecture.
53 // To avoid this, let's occupy the 4th argument register (r7) with a dummy argument when necessary. This must only be done when there
54 // is no other 32-bit value argument behind this 64-bit JSValue.
55 #if CPU(SH4)
56 #define SH4_32BIT_DUMMY_ARG      CCallHelpers::TrustedImm32(0),
57 #else
58 #define SH4_32BIT_DUMMY_ARG
59 #endif
60
61 class CCallHelpers : public AssemblyHelpers {
62 public:
63     CCallHelpers(VM* vm, CodeBlock* codeBlock = 0)
64         : AssemblyHelpers(vm, codeBlock)
65     {
66     }
67     
68     // The most general helper for setting arguments that fit in a GPR, if you can compute each
69     // argument without using any argument registers. You usually want one of the setupArguments*()
70     // methods below instead of this. This thing is most useful if you have *a lot* of arguments.
71     template<typename Functor>
72     void setupArgument(unsigned argumentIndex, const Functor& functor)
73     {
74         unsigned numberOfRegs = GPRInfo::numberOfArgumentRegisters; // Disguise the constant from clang's tautological compare warning.
75         if (argumentIndex < numberOfRegs) {
76             functor(GPRInfo::toArgumentRegister(argumentIndex));
77             return;
78         }
79         
80         functor(GPRInfo::nonArgGPR0);
81         poke(GPRInfo::nonArgGPR0, POKE_ARGUMENT_OFFSET + argumentIndex - GPRInfo::numberOfArgumentRegisters);
82     }
83
84     void setupArgumentsWithExecState() { setupArgumentsExecState(); }
85
86     // These methods used to sort arguments into the correct registers.
87     // On X86 we use cdecl calling conventions, which pass all arguments on the
88     // stack. On other architectures we may need to sort values into the
89     // correct registers.
90 #if !NUMBER_OF_ARGUMENT_REGISTERS
91     unsigned m_callArgumentOffset;
92     void resetCallArguments() { m_callArgumentOffset = 0; }
93
94     // These methods are using internally to implement the callOperation methods.
95     void addCallArgument(GPRReg value)
96     {
97         poke(value, m_callArgumentOffset++);
98     }
99     void addCallArgument(TrustedImm32 imm)
100     {
101         poke(imm, m_callArgumentOffset++);
102     }
103     void addCallArgument(TrustedImmPtr pointer)
104     {
105         poke(pointer, m_callArgumentOffset++);
106     }
107     void addCallArgument(FPRReg value)
108     {
109         storeDouble(value, Address(stackPointerRegister, m_callArgumentOffset * sizeof(void*)));
110         m_callArgumentOffset += sizeof(double) / sizeof(void*);
111     }
112
113     ALWAYS_INLINE void setupArguments(FPRReg arg1)
114     {
115         resetCallArguments();
116         addCallArgument(arg1);
117     }
118
119     ALWAYS_INLINE void setupArguments(FPRReg arg1, FPRReg arg2)
120     {
121         resetCallArguments();
122         addCallArgument(arg1);
123         addCallArgument(arg2);
124     }
125
126     ALWAYS_INLINE void setupArguments(GPRReg arg1)
127     {
128         resetCallArguments();
129         addCallArgument(arg1);
130     }
131
132     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2)
133     {
134         resetCallArguments();
135         addCallArgument(arg1);
136         addCallArgument(arg2);
137     }
138     
139     ALWAYS_INLINE void setupArguments(TrustedImmPtr arg1, GPRReg arg2)
140     {
141         resetCallArguments();
142         addCallArgument(arg1);
143         addCallArgument(arg2);
144     }
145     
146     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, GPRReg arg3)
147     {
148         resetCallArguments();
149         addCallArgument(arg1);
150         addCallArgument(arg2);
151         addCallArgument(arg3);
152     }
153     
154     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImmPtr arg4)
155     {
156         resetCallArguments();
157         addCallArgument(arg1);
158         addCallArgument(arg2);
159         addCallArgument(arg3);
160         addCallArgument(arg4);
161     }
162     
163     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4, GPRReg arg5)
164     {
165         resetCallArguments();
166         addCallArgument(arg1);
167         addCallArgument(arg2);
168         addCallArgument(arg3);
169         addCallArgument(arg4);
170         addCallArgument(arg5);
171     }
172     
173     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4, GPRReg arg5, GPRReg arg6)
174     {
175         resetCallArguments();
176         addCallArgument(arg1);
177         addCallArgument(arg2);
178         addCallArgument(arg3);
179         addCallArgument(arg4);
180         addCallArgument(arg5);
181         addCallArgument(arg6);
182     }
183     
184     ALWAYS_INLINE void setupArguments(TrustedImmPtr arg1)
185     {
186         resetCallArguments();
187         addCallArgument(arg1);
188     }
189
190     ALWAYS_INLINE void setupArgumentsExecState()
191     {
192         resetCallArguments();
193         addCallArgument(GPRInfo::callFrameRegister);
194     }
195
196     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1)
197     {
198         resetCallArguments();
199         addCallArgument(GPRInfo::callFrameRegister);
200         addCallArgument(arg1);
201     }
202
203     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1)
204     {
205         resetCallArguments();
206         addCallArgument(GPRInfo::callFrameRegister);
207         addCallArgument(arg1);
208     }
209
210     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1)
211     {
212         resetCallArguments();
213         addCallArgument(GPRInfo::callFrameRegister);
214         addCallArgument(arg1);
215     }
216
217     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2)
218     {
219         resetCallArguments();
220         addCallArgument(GPRInfo::callFrameRegister);
221         addCallArgument(arg1);
222         addCallArgument(arg2);
223     }
224
225     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2)
226     {
227         resetCallArguments();
228         addCallArgument(GPRInfo::callFrameRegister);
229         addCallArgument(arg1);
230         addCallArgument(arg2);
231     }
232
233     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3)
234     {
235         resetCallArguments();
236         addCallArgument(GPRInfo::callFrameRegister);
237         addCallArgument(arg1);
238         addCallArgument(arg2);
239         addCallArgument(arg3);
240     }
241     
242     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2)
243     {
244         resetCallArguments();
245         addCallArgument(GPRInfo::callFrameRegister);
246         addCallArgument(arg1);
247         addCallArgument(arg2);
248     }
249
250     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2)
251     {
252         resetCallArguments();
253         addCallArgument(GPRInfo::callFrameRegister);
254         addCallArgument(arg1);
255         addCallArgument(arg2);
256     }
257
258     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2)
259     {
260         resetCallArguments();
261         addCallArgument(GPRInfo::callFrameRegister);
262         addCallArgument(arg1);
263         addCallArgument(arg2);
264     }
265
266     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2)
267     {
268         resetCallArguments();
269         addCallArgument(GPRInfo::callFrameRegister);
270         addCallArgument(arg1);
271         addCallArgument(arg2);
272     }
273
274     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2)
275     {
276         resetCallArguments();
277         addCallArgument(GPRInfo::callFrameRegister);
278         addCallArgument(arg1);
279         addCallArgument(arg2);
280     }
281
282     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImm32 arg2)
283     {
284         resetCallArguments();
285         addCallArgument(GPRInfo::callFrameRegister);
286         addCallArgument(arg1);
287         addCallArgument(arg2);
288     }
289
290     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImm32 arg2, TrustedImm32 arg3)
291     {
292         resetCallArguments();
293         addCallArgument(GPRInfo::callFrameRegister);
294         addCallArgument(arg1);
295         addCallArgument(arg2);
296         addCallArgument(arg3);
297     }
298
299     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3)
300     {
301         resetCallArguments();
302         addCallArgument(GPRInfo::callFrameRegister);
303         addCallArgument(arg1);
304         addCallArgument(arg2);
305         addCallArgument(arg3);
306     }
307
308     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3)
309     {
310         resetCallArguments();
311         addCallArgument(GPRInfo::callFrameRegister);
312         addCallArgument(arg1);
313         addCallArgument(arg2);
314         addCallArgument(arg3);
315     }
316
317     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3)
318     {
319         resetCallArguments();
320         addCallArgument(GPRInfo::callFrameRegister);
321         addCallArgument(arg1);
322         addCallArgument(arg2);
323         addCallArgument(arg3);
324     }
325
326     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, GPRReg arg3)
327     {
328         resetCallArguments();
329         addCallArgument(GPRInfo::callFrameRegister);
330         addCallArgument(arg1);
331         addCallArgument(arg2);
332         addCallArgument(arg3);
333     }
334
335     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3, TrustedImm32 arg4)
336     {
337         resetCallArguments();
338         addCallArgument(GPRInfo::callFrameRegister);
339         addCallArgument(arg1);
340         addCallArgument(arg2);
341         addCallArgument(arg3);
342         addCallArgument(arg4);
343     }
344
345     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4)
346     {
347         resetCallArguments();
348         addCallArgument(GPRInfo::callFrameRegister);
349         addCallArgument(arg1);
350         addCallArgument(arg2);
351         addCallArgument(arg3);
352         addCallArgument(arg4);
353     }
354
355     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, TrustedImmPtr arg3)
356     {
357         resetCallArguments();
358         addCallArgument(GPRInfo::callFrameRegister);
359         addCallArgument(arg1);
360         addCallArgument(arg2);
361         addCallArgument(arg3);
362     }
363
364     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, TrustedImm32 arg3)
365     {
366         resetCallArguments();
367         addCallArgument(GPRInfo::callFrameRegister);
368         addCallArgument(arg1);
369         addCallArgument(arg2);
370         addCallArgument(arg3);
371     }
372
373     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3)
374     {
375         resetCallArguments();
376         addCallArgument(GPRInfo::callFrameRegister);
377         addCallArgument(arg1);
378         addCallArgument(arg2);
379         addCallArgument(arg3);
380     }
381
382     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, TrustedImm32 arg5)
383     {
384         resetCallArguments();
385         addCallArgument(GPRInfo::callFrameRegister);
386         addCallArgument(arg1);
387         addCallArgument(arg2);
388         addCallArgument(arg3);
389         addCallArgument(arg4);
390         addCallArgument(arg5);
391     }
392
393     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4, TrustedImm32 arg5)
394     { 
395         resetCallArguments();
396         addCallArgument(GPRInfo::callFrameRegister);
397         addCallArgument(arg1);
398         addCallArgument(arg2);
399         addCallArgument(arg3);
400         addCallArgument(arg4);
401         addCallArgument(arg5);
402     }
403
404     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, GPRReg arg5, TrustedImm32 arg6)
405     {
406         resetCallArguments();
407         addCallArgument(GPRInfo::callFrameRegister);
408         addCallArgument(arg1);
409         addCallArgument(arg2);
410         addCallArgument(arg3);
411         addCallArgument(arg4);
412         addCallArgument(arg5);
413         addCallArgument(arg6);
414     }
415
416     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3)
417     {
418         resetCallArguments();
419         addCallArgument(GPRInfo::callFrameRegister);
420         addCallArgument(arg1);
421         addCallArgument(arg2);
422         addCallArgument(arg3);
423     }
424
425     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3)
426     {
427         resetCallArguments();
428         addCallArgument(GPRInfo::callFrameRegister);
429         addCallArgument(arg1);
430         addCallArgument(arg2);
431         addCallArgument(arg3);
432     }
433
434     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImmPtr arg3)
435     {
436         resetCallArguments();
437         addCallArgument(GPRInfo::callFrameRegister);
438         addCallArgument(arg1);
439         addCallArgument(arg2);
440         addCallArgument(arg3);
441     }
442
443     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2, TrustedImm32 arg3)
444     {
445         resetCallArguments();
446         addCallArgument(GPRInfo::callFrameRegister);
447         addCallArgument(arg1);
448         addCallArgument(arg2);
449         addCallArgument(arg3);
450     }
451
452     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2, TrustedImmPtr arg3)
453     {
454         resetCallArguments();
455         addCallArgument(GPRInfo::callFrameRegister);
456         addCallArgument(arg1);
457         addCallArgument(arg2);
458         addCallArgument(arg3);
459     }
460
461     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImmPtr arg3)
462     {
463         resetCallArguments();
464         addCallArgument(GPRInfo::callFrameRegister);
465         addCallArgument(arg1);
466         addCallArgument(arg2);
467         addCallArgument(arg3);
468     }
469
470     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4)
471     {
472         resetCallArguments();
473         addCallArgument(GPRInfo::callFrameRegister);
474         addCallArgument(arg1);
475         addCallArgument(arg2);
476         addCallArgument(arg3);
477         addCallArgument(arg4);
478     }
479     
480     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImm32 arg2, GPRReg arg3, TrustedImmPtr arg4)
481     {
482         resetCallArguments();
483         addCallArgument(GPRInfo::callFrameRegister);
484         addCallArgument(arg1);
485         addCallArgument(arg2);
486         addCallArgument(arg3);
487         addCallArgument(arg4);
488     }
489     
490     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImmPtr arg4)
491     {
492         resetCallArguments();
493         addCallArgument(GPRInfo::callFrameRegister);
494         addCallArgument(arg1);
495         addCallArgument(arg2);
496         addCallArgument(arg3);
497         addCallArgument(arg4);
498     }
499     
500     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
501     {
502         resetCallArguments();
503         addCallArgument(GPRInfo::callFrameRegister);
504         addCallArgument(arg1);
505         addCallArgument(arg2);
506         addCallArgument(arg3);
507         addCallArgument(arg4);
508         addCallArgument(arg5);
509     }
510
511     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3)
512     {
513         resetCallArguments();
514         addCallArgument(GPRInfo::callFrameRegister);
515         addCallArgument(arg1);
516         addCallArgument(arg2);
517         addCallArgument(arg3);
518     }
519
520     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4, TrustedImm32 arg5)
521     {
522         resetCallArguments();
523         addCallArgument(GPRInfo::callFrameRegister);
524         addCallArgument(arg1);
525         addCallArgument(arg2);
526         addCallArgument(arg3);
527         addCallArgument(arg4);
528         addCallArgument(arg5);
529     }
530
531     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
532     {
533         resetCallArguments();
534         addCallArgument(GPRInfo::callFrameRegister);
535         addCallArgument(arg1);
536         addCallArgument(arg2);
537         addCallArgument(arg3);
538         addCallArgument(arg4);
539         addCallArgument(arg5);
540     }
541
542     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4)
543     {
544         resetCallArguments();
545         addCallArgument(GPRInfo::callFrameRegister);
546         addCallArgument(arg1);
547         addCallArgument(arg2);
548         addCallArgument(arg3);
549         addCallArgument(arg4);
550     }
551
552     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4, TrustedImm32 arg5)
553     {
554         resetCallArguments();
555         addCallArgument(GPRInfo::callFrameRegister);
556         addCallArgument(arg1);
557         addCallArgument(arg2);
558         addCallArgument(arg3);
559         addCallArgument(arg4);
560         addCallArgument(arg5);
561     }
562
563     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4)
564     {
565         resetCallArguments();
566         addCallArgument(GPRInfo::callFrameRegister);
567         addCallArgument(arg1);
568         addCallArgument(arg2);
569         addCallArgument(arg3);
570         addCallArgument(arg4);
571     }
572
573     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4)
574     {
575         resetCallArguments();
576         addCallArgument(GPRInfo::callFrameRegister);
577         addCallArgument(arg1);
578         addCallArgument(arg2);
579         addCallArgument(arg3);
580         addCallArgument(arg4);
581     }
582
583     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, GPRReg arg5)
584     {
585         resetCallArguments();
586         addCallArgument(GPRInfo::callFrameRegister);
587         addCallArgument(arg1);
588         addCallArgument(arg2);
589         addCallArgument(arg3);
590         addCallArgument(arg4);
591         addCallArgument(arg5);
592     }
593
594     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3)
595     {
596         resetCallArguments();
597         addCallArgument(GPRInfo::callFrameRegister);
598         addCallArgument(arg1);
599         addCallArgument(arg2);
600         addCallArgument(arg3);
601     }
602
603     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
604     {
605         resetCallArguments();
606         addCallArgument(GPRInfo::callFrameRegister);
607         addCallArgument(arg1);
608         addCallArgument(arg2);
609         addCallArgument(arg3);
610         addCallArgument(arg4);
611     }
612
613     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImm32 arg4)
614     {
615         resetCallArguments();
616         addCallArgument(GPRInfo::callFrameRegister);
617         addCallArgument(arg1);
618         addCallArgument(arg2);
619         addCallArgument(arg3);
620         addCallArgument(arg4);
621     }
622
623     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4)
624     {
625         resetCallArguments();
626         addCallArgument(GPRInfo::callFrameRegister);
627         addCallArgument(arg1);
628         addCallArgument(arg2);
629         addCallArgument(arg3);
630         addCallArgument(arg4);
631     }
632
633     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2, GPRReg arg3, GPRReg arg4)
634     {
635         resetCallArguments();
636         addCallArgument(GPRInfo::callFrameRegister);
637         addCallArgument(arg1);
638         addCallArgument(arg2);
639         addCallArgument(arg3);
640         addCallArgument(arg4);
641     }
642
643     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4)
644     {
645         resetCallArguments();
646         addCallArgument(GPRInfo::callFrameRegister);
647         addCallArgument(arg1);
648         addCallArgument(arg2);
649         addCallArgument(arg3);
650         addCallArgument(arg4);
651     }
652
653     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
654     {
655         resetCallArguments();
656         addCallArgument(GPRInfo::callFrameRegister);
657         addCallArgument(arg1);
658         addCallArgument(arg2);
659         addCallArgument(arg3);
660         addCallArgument(arg4);
661         addCallArgument(arg5);
662     }
663
664     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImmPtr arg5)
665     {
666         resetCallArguments();
667         addCallArgument(GPRInfo::callFrameRegister);
668         addCallArgument(arg1);
669         addCallArgument(arg2);
670         addCallArgument(arg3);
671         addCallArgument(arg4);
672         addCallArgument(arg5);
673     }
674
675     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, TrustedImmPtr arg6)
676     {
677         resetCallArguments();
678         addCallArgument(GPRInfo::callFrameRegister);
679         addCallArgument(arg1);
680         addCallArgument(arg2);
681         addCallArgument(arg3);
682         addCallArgument(arg4);
683         addCallArgument(arg5);
684         addCallArgument(arg6);
685     }
686
687     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImm32 arg5, TrustedImmPtr arg6)
688     {
689         resetCallArguments();
690         addCallArgument(GPRInfo::callFrameRegister);
691         addCallArgument(arg1);
692         addCallArgument(arg2);
693         addCallArgument(arg3);
694         addCallArgument(arg4);
695         addCallArgument(arg5);
696         addCallArgument(arg6);
697     }
698
699     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
700     {
701         resetCallArguments();
702         addCallArgument(GPRInfo::callFrameRegister);
703         addCallArgument(arg1);
704         addCallArgument(arg2);
705         addCallArgument(arg3);
706         addCallArgument(arg4);
707     }
708
709     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImmPtr arg4)
710     {
711         resetCallArguments();
712         addCallArgument(GPRInfo::callFrameRegister);
713         addCallArgument(arg1);
714         addCallArgument(arg2);
715         addCallArgument(arg3);
716         addCallArgument(arg4);
717     }
718
719     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, TrustedImmPtr arg3, GPRReg arg4)
720     {
721         resetCallArguments();
722         addCallArgument(GPRInfo::callFrameRegister);
723         addCallArgument(arg1);
724         addCallArgument(arg2);
725         addCallArgument(arg3);
726         addCallArgument(arg4);
727     }
728
729     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4)
730     {
731         resetCallArguments();
732         addCallArgument(GPRInfo::callFrameRegister);
733         addCallArgument(arg1);
734         addCallArgument(arg2);
735         addCallArgument(arg3);
736         addCallArgument(arg4);
737     }
738
739     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, GPRReg arg3, GPRReg arg4)
740     {
741         resetCallArguments();
742         addCallArgument(GPRInfo::callFrameRegister);
743         addCallArgument(arg1);
744         addCallArgument(arg2);
745         addCallArgument(arg3);
746         addCallArgument(arg4);
747     }
748     
749     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
750     {
751         resetCallArguments();
752         addCallArgument(GPRInfo::callFrameRegister);
753         addCallArgument(arg1);
754         addCallArgument(arg2);
755         addCallArgument(arg3);
756         addCallArgument(arg4);
757         addCallArgument(arg5);
758     }
759
760     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
761     {
762         resetCallArguments();
763         addCallArgument(GPRInfo::callFrameRegister);
764         addCallArgument(arg1);
765         addCallArgument(arg2);
766         addCallArgument(arg3);
767         addCallArgument(arg4);
768         addCallArgument(arg5);
769     }
770     
771     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImmPtr arg5)
772     {
773         resetCallArguments();
774         addCallArgument(GPRInfo::callFrameRegister);
775         addCallArgument(arg1);
776         addCallArgument(arg2);
777         addCallArgument(arg3);
778         addCallArgument(arg4);
779         addCallArgument(arg5);
780     }
781
782     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImmPtr arg5)
783     {
784         resetCallArguments();
785         addCallArgument(GPRInfo::callFrameRegister);
786         addCallArgument(arg1);
787         addCallArgument(arg2);
788         addCallArgument(arg3);
789         addCallArgument(arg4);
790         addCallArgument(arg5);
791     }
792
793     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImm32 arg5)
794     {
795         resetCallArguments();
796         addCallArgument(GPRInfo::callFrameRegister);
797         addCallArgument(arg1);
798         addCallArgument(arg2);
799         addCallArgument(arg3);
800         addCallArgument(arg4);
801         addCallArgument(arg5);
802     }
803     
804     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6)
805     {
806         resetCallArguments();
807         addCallArgument(GPRInfo::callFrameRegister);
808         addCallArgument(arg1);
809         addCallArgument(arg2);
810         addCallArgument(arg3);
811         addCallArgument(arg4);
812         addCallArgument(arg5);
813         addCallArgument(arg6);
814     }
815     
816     
817     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, TrustedImm32 arg6)
818     {
819         resetCallArguments();
820         addCallArgument(GPRInfo::callFrameRegister);
821         addCallArgument(arg1);
822         addCallArgument(arg2);
823         addCallArgument(arg3);
824         addCallArgument(arg4);
825         addCallArgument(arg5);
826         addCallArgument(arg6);
827     }
828
829     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImmPtr arg5, TrustedImmPtr arg6)
830     {
831         resetCallArguments();
832         addCallArgument(GPRInfo::callFrameRegister);
833         addCallArgument(arg1);
834         addCallArgument(arg2);
835         addCallArgument(arg3);
836         addCallArgument(arg4);
837         addCallArgument(arg5);
838         addCallArgument(arg6);
839     }
840
841     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6, TrustedImmPtr arg7)
842     {
843         resetCallArguments();
844         addCallArgument(GPRInfo::callFrameRegister);
845         addCallArgument(arg1);
846         addCallArgument(arg2);
847         addCallArgument(arg3);
848         addCallArgument(arg4);
849         addCallArgument(arg5);
850         addCallArgument(arg6);
851         addCallArgument(arg7);
852     }
853
854     ALWAYS_INLINE void setupArgumentsWithExecState(FPRReg arg1, GPRReg arg2)
855     {
856         resetCallArguments();
857         addCallArgument(GPRInfo::callFrameRegister);
858         addCallArgument(arg1);
859         addCallArgument(arg2);
860     }
861
862     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, FPRReg arg3)
863     {
864         resetCallArguments();
865         addCallArgument(GPRInfo::callFrameRegister);
866         addCallArgument(arg1);
867         addCallArgument(arg2);
868         addCallArgument(arg3);
869     }
870
871     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6, GPRReg arg7, GPRReg arg8)
872     {
873         resetCallArguments();
874         addCallArgument(GPRInfo::callFrameRegister);
875         addCallArgument(arg1);
876         addCallArgument(arg2);
877         addCallArgument(arg3);
878         addCallArgument(arg4);
879         addCallArgument(arg5);
880         addCallArgument(arg6);
881         addCallArgument(arg7);
882         addCallArgument(arg8);
883     }
884
885 #endif // !NUMBER_OF_ARGUMENT_REGISTERS
886     // These methods are suitable for any calling convention that provides for
887     // at least 4 argument registers, e.g. X86_64, ARMv7.
888 #if NUMBER_OF_ARGUMENT_REGISTERS >= 4
889     template<GPRReg destA, GPRReg destB>
890     void setupTwoStubArgsGPR(GPRReg srcA, GPRReg srcB)
891     {
892         // Assuming that srcA != srcB, there are 7 interesting states the registers may be in:
893         // (1) both are already in arg regs, the right way around.
894         // (2) both are already in arg regs, the wrong way around.
895         // (3) neither are currently in arg registers.
896         // (4) srcA in in its correct reg.
897         // (5) srcA in in the incorrect reg.
898         // (6) srcB in in its correct reg.
899         // (7) srcB in in the incorrect reg.
900         //
901         // The trivial approach is to simply emit two moves, to put srcA in place then srcB in
902         // place (the MacroAssembler will omit redundant moves). This apporach will be safe in
903         // cases 1, 3, 4, 5, 6, and in cases where srcA==srcB. The two problem cases are 2
904         // (requires a swap) and 7 (must move srcB first, to avoid trampling.)
905
906         if (srcB != destA) {
907             // Handle the easy cases - two simple moves.
908             move(srcA, destA);
909             move(srcB, destB);
910         } else if (srcA != destB) {
911             // Handle the non-swap case - just put srcB in place first.
912             move(srcB, destB);
913             move(srcA, destA);
914         } else
915             swap(destA, destB);
916     }
917
918     template<GPRReg destA, GPRReg destB, GPRReg destC>
919     void setupThreeStubArgsGPR(GPRReg srcA, GPRReg srcB, GPRReg srcC)
920     {
921         // If neither of srcB/srcC are in our way, then we can move srcA into place.
922         // Then we can use setupTwoStubArgs to fix srcB/srcC.
923         if (srcB != destA && srcC != destA) {
924             move(srcA, destA);
925             setupTwoStubArgsGPR<destB, destC>(srcB, srcC);
926             return;
927         }
928         
929         // If neither of srcA/srcC are in our way, then we can move srcB into place.
930         // Then we can use setupTwoStubArgs to fix srcA/srcC.
931         if (srcA != destB && srcC != destB) {
932             move(srcB, destB);
933             setupTwoStubArgsGPR<destA, destC>(srcA, srcC);
934             return;
935         }
936         
937         // If neither of srcA/srcB are in our way, then we can move srcC into place.
938         // Then we can use setupTwoStubArgs to fix srcA/srcB.
939         if (srcA != destC && srcB != destC) {
940             move(srcC, destC);
941             setupTwoStubArgsGPR<destA, destB>(srcA, srcB);
942             return;
943         }
944         
945         // If we get here, we haven't been able to move any of srcA/srcB/srcC.
946         // Since all three are blocked, then all three must already be in the argument register.
947         // But are they in the right ones?
948         
949         // First, ensure srcA is in place.
950         if (srcA != destA) {
951             swap(srcA, destA);
952             
953             // If srcA wasn't in argumentGPR1, one of srcB/srcC must be.
954             ASSERT(srcB == destA || srcC == destA);
955             // If srcB was in argumentGPR1 it no longer is (due to the swap).
956             // Otherwise srcC must have been. Mark him as moved.
957             if (srcB == destA)
958                 srcB = srcA;
959             else
960                 srcC = srcA;
961         }
962         
963         // Either srcB & srcC need swapping, or we're all done.
964         ASSERT((srcB == destB || srcC == destC)
965             || (srcB == destC || srcC == destB));
966         
967         if (srcB != destB)
968             swap(destB, destC);
969     }
970
971     void setupFourStubArgsGPR(GPRReg destA, GPRReg destB, GPRReg destC, GPRReg destD, GPRReg srcA, GPRReg srcB, GPRReg srcC, GPRReg srcD);
972
973 #if CPU(X86_64) || CPU(ARM64)
974     template<FPRReg destA, FPRReg destB>
975     void setupTwoStubArgsFPR(FPRReg srcA, FPRReg srcB)
976     {
977         // Assuming that srcA != srcB, there are 7 interesting states the registers may be in:
978         // (1) both are already in arg regs, the right way around.
979         // (2) both are already in arg regs, the wrong way around.
980         // (3) neither are currently in arg registers.
981         // (4) srcA in in its correct reg.
982         // (5) srcA in in the incorrect reg.
983         // (6) srcB in in its correct reg.
984         // (7) srcB in in the incorrect reg.
985         //
986         // The trivial approach is to simply emit two moves, to put srcA in place then srcB in
987         // place (the MacroAssembler will omit redundant moves). This apporach will be safe in
988         // cases 1, 3, 4, 5, 6, and in cases where srcA==srcB. The two problem cases are 2
989         // (requires a swap) and 7 (must move srcB first, to avoid trampling.)
990
991         if (srcB != destA) {
992             // Handle the easy cases - two simple moves.
993             moveDouble(srcA, destA);
994             moveDouble(srcB, destB);
995             return;
996         }
997         
998         if (srcA != destB) {
999             // Handle the non-swap case - just put srcB in place first.
1000             moveDouble(srcB, destB);
1001             moveDouble(srcA, destA);
1002             return;
1003         }
1004
1005         ASSERT(srcB == destA && srcA == destB);
1006         // Need to swap; pick a temporary register.
1007         FPRReg temp;
1008         if (destA != FPRInfo::argumentFPR3 && destA != FPRInfo::argumentFPR3)
1009             temp = FPRInfo::argumentFPR3;
1010         else if (destA != FPRInfo::argumentFPR2 && destA != FPRInfo::argumentFPR2)
1011             temp = FPRInfo::argumentFPR2;
1012         else {
1013             ASSERT(destA != FPRInfo::argumentFPR1 && destA != FPRInfo::argumentFPR1);
1014             temp = FPRInfo::argumentFPR1;
1015         }
1016         moveDouble(destA, temp);
1017         moveDouble(destB, destA);
1018         moveDouble(temp, destB);
1019     }
1020 #endif
1021     void setupStubArguments(GPRReg arg1, GPRReg arg2)
1022     {
1023         setupTwoStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2>(arg1, arg2);
1024     }
1025
1026     void setupStubArguments(GPRReg arg1, GPRReg arg2, GPRReg arg3)
1027     {
1028         setupThreeStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg1, arg2, arg3);
1029     }
1030
1031 #if CPU(X86_64) || CPU(ARM64)
1032     ALWAYS_INLINE void setupArguments(FPRReg arg1)
1033     {
1034         moveDouble(arg1, FPRInfo::argumentFPR0);
1035     }
1036
1037     ALWAYS_INLINE void setupArguments(FPRReg arg1, FPRReg arg2)
1038     {
1039         setupTwoStubArgsFPR<FPRInfo::argumentFPR0, FPRInfo::argumentFPR1>(arg1, arg2);
1040     }
1041     
1042     ALWAYS_INLINE void setupArgumentsWithExecState(FPRReg arg1, GPRReg arg2)
1043     {
1044 #if OS(WINDOWS) && CPU(X86_64)
1045         // On Windows, arguments map to designated registers based on the argument positions, even when there are interlaced scalar and floating point arguments.
1046         // See http://msdn.microsoft.com/en-us/library/zthk2dkh.aspx
1047         moveDouble(arg1, FPRInfo::argumentFPR1);
1048         move(arg2, GPRInfo::argumentGPR2);
1049 #else
1050         moveDouble(arg1, FPRInfo::argumentFPR0);
1051         move(arg2, GPRInfo::argumentGPR1);
1052 #endif
1053         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1054     }
1055
1056     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, FPRReg arg3)
1057     {
1058 #if OS(WINDOWS) && CPU(X86_64)
1059         // On Windows, arguments map to designated registers based on the argument positions, even when there are interlaced scalar and floating point arguments.
1060         // See http://msdn.microsoft.com/en-us/library/zthk2dkh.aspx
1061         moveDouble(arg3, FPRInfo::argumentFPR3);
1062 #else
1063         moveDouble(arg3, FPRInfo::argumentFPR0);
1064 #endif
1065         setupStubArguments(arg1, arg2);
1066         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1067     }
1068 #elif CPU(ARM)
1069 #if CPU(ARM_HARDFP)
1070     ALWAYS_INLINE void setupArguments(FPRReg arg1)
1071     {
1072         moveDouble(arg1, FPRInfo::argumentFPR0);
1073     }
1074
1075     ALWAYS_INLINE void setupArguments(FPRReg arg1, FPRReg arg2)
1076     {
1077         if (arg2 != FPRInfo::argumentFPR0) {
1078             moveDouble(arg1, FPRInfo::argumentFPR0);
1079             moveDouble(arg2, FPRInfo::argumentFPR1);
1080         } else if (arg1 != FPRInfo::argumentFPR1) {
1081             moveDouble(arg2, FPRInfo::argumentFPR1);
1082             moveDouble(arg1, FPRInfo::argumentFPR0);
1083         } else {
1084             // Swap arg1, arg2.
1085             moveDouble(FPRInfo::argumentFPR0, ARMRegisters::d2);
1086             moveDouble(FPRInfo::argumentFPR1, FPRInfo::argumentFPR0);
1087             moveDouble(ARMRegisters::d2, FPRInfo::argumentFPR1);
1088         }
1089     }
1090
1091     ALWAYS_INLINE void setupArgumentsWithExecState(FPRReg arg1, GPRReg arg2)
1092     {
1093         moveDouble(arg1, FPRInfo::argumentFPR0);
1094         move(arg2, GPRInfo::argumentGPR1);
1095         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1096     }
1097
1098     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, FPRReg arg3)
1099     {
1100         moveDouble(arg3, FPRInfo::argumentFPR0);
1101         setupStubArguments(arg1, arg2);
1102         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1103     }
1104
1105     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32, FPRReg arg2, GPRReg arg3)
1106     {
1107         moveDouble(arg2, FPRInfo::argumentFPR0);
1108         move(arg3, GPRInfo::argumentGPR1);
1109         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1110     }
1111
1112     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32, FPRReg arg4)
1113     {
1114         moveDouble(arg4, FPRInfo::argumentFPR0);
1115         setupStubArguments(arg1, arg2);
1116         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1117     }
1118
1119 #else
1120     ALWAYS_INLINE void setupArguments(FPRReg arg1)
1121     {
1122         assembler().vmov(GPRInfo::argumentGPR0, GPRInfo::argumentGPR1, arg1);
1123     }
1124
1125     ALWAYS_INLINE void setupArguments(FPRReg arg1, FPRReg arg2)
1126     {
1127         assembler().vmov(GPRInfo::argumentGPR0, GPRInfo::argumentGPR1, arg1);
1128         assembler().vmov(GPRInfo::argumentGPR2, GPRInfo::argumentGPR3, arg2);
1129     }
1130
1131     ALWAYS_INLINE void setupArgumentsWithExecState(FPRReg arg1, GPRReg arg2)
1132     {
1133         move(arg2, GPRInfo::argumentGPR3);
1134         assembler().vmov(GPRInfo::argumentGPR1, GPRInfo::argumentGPR2, arg1);
1135         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1136     }
1137
1138     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, FPRReg arg3)
1139     {
1140         setupStubArguments(arg1, arg2);
1141         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1142         assembler().vmov(GPRInfo::argumentGPR3, GPRInfo::nonArgGPR0, arg3);
1143         poke(GPRInfo::nonArgGPR0);
1144     }
1145
1146     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, FPRReg arg2, GPRReg arg3)
1147     {
1148         poke(arg3, POKE_ARGUMENT_OFFSET);
1149         move(arg1, GPRInfo::argumentGPR1);
1150         assembler().vmov(GPRInfo::argumentGPR2, GPRInfo::argumentGPR3, arg2);
1151         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1152     }
1153
1154     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, FPRReg arg4)
1155     {
1156         setupStubArguments(arg1, arg2);
1157         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1158         move(arg3, GPRInfo::argumentGPR3);
1159         assembler().vmov(GPRInfo::nonArgGPR0, GPRInfo::nonArgGPR1, arg4);
1160         poke(GPRInfo::nonArgGPR0, POKE_ARGUMENT_OFFSET);
1161         poke(GPRInfo::nonArgGPR1, POKE_ARGUMENT_OFFSET + 1);
1162     }
1163 #endif // CPU(ARM_HARDFP)
1164 #elif CPU(MIPS)
1165     ALWAYS_INLINE void setupArguments(FPRReg arg1)
1166     {
1167         moveDouble(arg1, FPRInfo::argumentFPR0);
1168     }
1169
1170     ALWAYS_INLINE void setupArguments(FPRReg arg1, FPRReg arg2)
1171     {
1172         if (arg2 != FPRInfo::argumentFPR0) {
1173             moveDouble(arg1, FPRInfo::argumentFPR0);
1174             moveDouble(arg2, FPRInfo::argumentFPR1);
1175         } else if (arg1 != FPRInfo::argumentFPR1) {
1176             moveDouble(arg2, FPRInfo::argumentFPR1);
1177             moveDouble(arg1, FPRInfo::argumentFPR0);
1178         } else {
1179             // Swap arg1, arg2.
1180             swapDouble(FPRInfo::argumentFPR0, FPRInfo::argumentFPR1);
1181         }
1182     }
1183
1184     ALWAYS_INLINE void setupArgumentsWithExecState(FPRReg arg1, GPRReg arg2)
1185     {
1186         assembler().vmov(GPRInfo::argumentGPR2, GPRInfo::argumentGPR3, arg1);
1187         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1188         poke(arg2, 4);
1189     }
1190
1191     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, FPRReg arg3)
1192     {
1193         setupStubArguments(arg1, arg2);
1194         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1195         poke(arg3, 4);
1196     }
1197
1198     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32, FPRReg arg2, GPRReg arg3)
1199     {
1200         setupArgumentsWithExecState(arg2, arg3);
1201     }
1202
1203     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32, FPRReg arg4)
1204     {
1205         setupArgumentsWithExecState(arg1, arg2, arg4);
1206     }
1207 #elif CPU(SH4)
1208     ALWAYS_INLINE void setupArguments(FPRReg arg1)
1209     {
1210         moveDouble(arg1, FPRInfo::argumentFPR0);
1211     }
1212
1213     ALWAYS_INLINE void setupArguments(FPRReg arg1, FPRReg arg2)
1214     {
1215         if (arg2 != FPRInfo::argumentFPR0) {
1216             moveDouble(arg1, FPRInfo::argumentFPR0);
1217             moveDouble(arg2, FPRInfo::argumentFPR1);
1218         } else if (arg1 != FPRInfo::argumentFPR1) {
1219             moveDouble(arg2, FPRInfo::argumentFPR1);
1220             moveDouble(arg1, FPRInfo::argumentFPR0);
1221         } else
1222             swapDouble(FPRInfo::argumentFPR0, FPRInfo::argumentFPR1);
1223     }
1224
1225     ALWAYS_INLINE void setupArgumentsWithExecState(FPRReg arg1, GPRReg arg2)
1226     {
1227         moveDouble(arg1, FPRInfo::argumentFPR0);
1228         move(arg2, GPRInfo::argumentGPR1);
1229         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1230     }
1231
1232     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, FPRReg arg3)
1233     {
1234         moveDouble(arg3, FPRInfo::argumentFPR0);
1235         setupStubArguments(arg1, arg2);
1236         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1237     }
1238 #else
1239 #error "JIT not supported on this platform."
1240 #endif
1241
1242     ALWAYS_INLINE void setupArguments(GPRReg arg1)
1243     {
1244         move(arg1, GPRInfo::argumentGPR0);
1245     }
1246
1247     ALWAYS_INLINE void setupArguments(TrustedImmPtr arg1, GPRReg arg2)
1248     {
1249         move(arg2, GPRInfo::argumentGPR1);
1250         move(arg1, GPRInfo::argumentGPR0);
1251     }
1252     
1253     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2)
1254     {
1255         setupTwoStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1>(arg1, arg2);
1256     }
1257     
1258     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, GPRReg arg3)
1259     {
1260         setupThreeStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1, GPRInfo::argumentGPR2>(arg1, arg2, arg3);
1261     }
1262     
1263     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImmPtr arg4)
1264     {
1265         setupTwoStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1>(arg1, arg2);
1266         move(arg3, GPRInfo::argumentGPR2);
1267         move(arg4, GPRInfo::argumentGPR3);
1268     }
1269     
1270     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
1271     {
1272         setupThreeStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1, GPRInfo::argumentGPR2>(arg1, arg2, arg3);
1273         move(arg4, GPRInfo::argumentGPR3);
1274     }
1275     
1276     ALWAYS_INLINE void setupArguments(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3, TrustedImmPtr arg4)
1277     {
1278         setupTwoStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR2>(arg1, arg3);
1279         move(arg2, GPRInfo::argumentGPR1);
1280         move(arg4, GPRInfo::argumentGPR3);
1281     }
1282     
1283     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4, GPRReg arg5, GPRReg arg6)
1284     {
1285         poke(arg6, POKE_ARGUMENT_OFFSET + 1);
1286         poke(arg5, POKE_ARGUMENT_OFFSET);
1287         setupTwoStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1>(arg1, arg2);
1288         move(arg3, GPRInfo::argumentGPR2);
1289         move(arg4, GPRInfo::argumentGPR3);
1290     }
1291
1292     ALWAYS_INLINE void setupArguments(TrustedImmPtr arg1)
1293     {
1294         move(arg1, GPRInfo::argumentGPR0);
1295     }
1296
1297     ALWAYS_INLINE void setupArgumentsExecState()
1298     {
1299         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1300     }
1301
1302     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1)
1303     {
1304         move(arg1, GPRInfo::argumentGPR1);
1305         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1306     }
1307
1308     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1)
1309     {
1310         move(arg1, GPRInfo::argumentGPR1);
1311         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1312     }
1313
1314     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1)
1315     {
1316         move(arg1, GPRInfo::argumentGPR1);
1317         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1318     }
1319
1320 #if OS(WINDOWS) && CPU(X86_64)
1321     ALWAYS_INLINE void setupArgumentsWithExecStateForCallWithSlowPathReturnType(TrustedImm32 arg1)
1322     {
1323         move(arg1, GPRInfo::argumentGPR2);
1324         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR1);
1325     }
1326 #endif
1327
1328     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2)
1329     {
1330         setupStubArguments(arg1, arg2);
1331         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1332     }
1333
1334     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2)
1335     {
1336         move(arg1, GPRInfo::argumentGPR1);
1337         move(arg2, GPRInfo::argumentGPR2);
1338         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1339     }
1340 #if CPU(X86_64) || CPU(ARM64)
1341     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm64 arg2)
1342     {
1343         move(arg1, GPRInfo::argumentGPR1);
1344         move(arg2, GPRInfo::argumentGPR2);
1345         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1346     }
1347     
1348     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm64 arg1, GPRReg arg2)
1349     {
1350         move(arg2, GPRInfo::argumentGPR2); // Move this first, so setting arg1 does not trample!
1351         move(arg1, GPRInfo::argumentGPR1);
1352         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1353     }
1354 #endif
1355     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2)
1356     {
1357         move(arg1, GPRInfo::argumentGPR1);
1358         move(arg2, GPRInfo::argumentGPR2);
1359         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1360     }
1361     
1362     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, ImmPtr arg2)
1363     {
1364         move(arg1, GPRInfo::argumentGPR1);
1365         move(arg2, GPRInfo::argumentGPR2);
1366         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1367     }
1368
1369     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2)
1370     {
1371         move(arg2, GPRInfo::argumentGPR2); // Move this first, so setting arg1 does not trample!
1372         move(arg1, GPRInfo::argumentGPR1);
1373         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1374     }
1375     
1376     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2)
1377     {
1378         move(arg2, GPRInfo::argumentGPR2); // Move this first, so setting arg1 does not trample!
1379         move(arg1, GPRInfo::argumentGPR1);
1380         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1381     }
1382     
1383     ALWAYS_INLINE void setupArgumentsWithExecState(ImmPtr arg1, GPRReg arg2)
1384     {
1385         move(arg2, GPRInfo::argumentGPR2); // Move this first, so setting arg1 does not trample!
1386         move(arg1, GPRInfo::argumentGPR1);
1387         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1388     }
1389
1390     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2)
1391     {
1392         move(arg1, GPRInfo::argumentGPR1);
1393         move(arg2, GPRInfo::argumentGPR2);
1394         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1395     }
1396
1397     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2)
1398     {
1399         move(arg1, GPRInfo::argumentGPR1);
1400         move(arg2, GPRInfo::argumentGPR2);
1401         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1402     }
1403
1404     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImm32 arg2)
1405     {
1406         move(arg1, GPRInfo::argumentGPR1);
1407         move(arg2, GPRInfo::argumentGPR2);
1408         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1409     }
1410
1411     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImm32 arg2, TrustedImm32 arg3)
1412     {
1413         move(arg1, GPRInfo::argumentGPR1);
1414         move(arg2, GPRInfo::argumentGPR2);
1415         move(arg3, GPRInfo::argumentGPR3);
1416         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1417     }
1418
1419     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3)
1420     {
1421         setupStubArguments(arg1, arg2, arg3);
1422         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1423     }
1424
1425     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3)
1426     {
1427         setupStubArguments(arg1, arg2);
1428         move(arg3, GPRInfo::argumentGPR3);
1429         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1430     }
1431
1432     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, GPRReg arg3)
1433     {
1434         setupTwoStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR3>(arg1, arg3);
1435         move(arg2, GPRInfo::argumentGPR2);
1436         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1437     }
1438
1439     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3)
1440     {
1441         setupTwoStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR3>(arg1, arg3);
1442         move(arg2, GPRInfo::argumentGPR2);
1443         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1444     }
1445
1446     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, TrustedImmPtr arg3)
1447     {
1448         move(arg1, GPRInfo::argumentGPR1);
1449         move(arg2, GPRInfo::argumentGPR2);
1450         move(arg3, GPRInfo::argumentGPR3);
1451         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1452     }
1453
1454     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3)
1455     {
1456         move(arg1, GPRInfo::argumentGPR1);
1457         move(arg2, GPRInfo::argumentGPR2);
1458         move(arg3, GPRInfo::argumentGPR3);
1459         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1460     }
1461     
1462     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, TrustedImm32 arg3)
1463     {
1464         move(arg1, GPRInfo::argumentGPR1);
1465         move(arg2, GPRInfo::argumentGPR2);
1466         move(arg3, GPRInfo::argumentGPR3);
1467         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1468     }
1469
1470     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImmPtr arg3)
1471     {
1472         move(arg1, GPRInfo::argumentGPR1);
1473         move(arg2, GPRInfo::argumentGPR2);
1474         move(arg3, GPRInfo::argumentGPR3);
1475         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1476     }
1477
1478     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3)
1479     {
1480         setupStubArguments(arg1, arg2);
1481         move(arg3, GPRInfo::argumentGPR3);
1482         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1483     }
1484
1485     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2, GPRReg arg3)
1486     {
1487         move(arg3, GPRInfo::argumentGPR3);
1488         move(arg1, GPRInfo::argumentGPR1);
1489         move(arg2, GPRInfo::argumentGPR2);
1490         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1491     }
1492
1493     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2, GPRReg arg3)
1494     {
1495         move(arg3, GPRInfo::argumentGPR3);
1496         move(arg1, GPRInfo::argumentGPR1);
1497         move(arg2, GPRInfo::argumentGPR2);
1498         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1499     }
1500
1501     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3)
1502     {
1503         move(arg3, GPRInfo::argumentGPR3);
1504         move(arg1, GPRInfo::argumentGPR1);
1505         move(arg2, GPRInfo::argumentGPR2);
1506         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1507     }
1508
1509     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, TrustedImm32 arg3)
1510     {
1511         move(arg3, GPRInfo::argumentGPR3);
1512         move(arg1, GPRInfo::argumentGPR1);
1513         move(arg2, GPRInfo::argumentGPR2);
1514         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1515     }
1516
1517     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, TrustedImm32 arg3)
1518     {
1519         move(arg2, GPRInfo::argumentGPR2);
1520         move(arg1, GPRInfo::argumentGPR1);
1521         move(arg3, GPRInfo::argumentGPR3);
1522         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1523     }
1524
1525     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3)
1526     {
1527         setupTwoStubArgsGPR<GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg2, arg3);
1528         move(arg1, GPRInfo::argumentGPR1);
1529         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1530     }
1531
1532     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3)
1533     {
1534         setupTwoStubArgsGPR<GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg2, arg3);
1535         move(arg1, GPRInfo::argumentGPR1);
1536         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1537     }
1538
1539     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3)
1540     {
1541         move(arg2, GPRInfo::argumentGPR2); // In case arg2 is argumentGPR1.
1542         move(arg1, GPRInfo::argumentGPR1);
1543         move(arg3, GPRInfo::argumentGPR3);
1544         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1545     }
1546
1547     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImmPtr arg3)
1548     {
1549         move(arg2, GPRInfo::argumentGPR2); // In case arg2 is argumentGPR1.
1550         move(arg1, GPRInfo::argumentGPR1);
1551         move(arg3, GPRInfo::argumentGPR3);
1552         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1553     }
1554
1555     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2, TrustedImm32 arg3)
1556     {
1557         move(arg1, GPRInfo::argumentGPR1);
1558         move(arg2, GPRInfo::argumentGPR2);
1559         move(arg3, GPRInfo::argumentGPR3);
1560         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1561     }
1562
1563     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2, TrustedImmPtr arg3)
1564     {
1565         move(arg1, GPRInfo::argumentGPR1);
1566         move(arg2, GPRInfo::argumentGPR2);
1567         move(arg3, GPRInfo::argumentGPR3);
1568         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1569     }
1570
1571     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2, TrustedImm32 arg3)
1572     {
1573         move(arg1, GPRInfo::argumentGPR1);
1574         move(arg2, GPRInfo::argumentGPR2);
1575         move(arg3, GPRInfo::argumentGPR3);
1576         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
1577     }
1578
1579 #endif // NUMBER_OF_ARGUMENT_REGISTERS >= 4
1580     // These methods are suitable for any calling convention that provides for
1581     // exactly 4 argument registers, e.g. ARMv7.
1582 #if NUMBER_OF_ARGUMENT_REGISTERS == 4
1583
1584     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4)
1585     {
1586         poke(arg4, POKE_ARGUMENT_OFFSET);
1587         setupArgumentsWithExecState(arg1, arg2, arg3);
1588     }
1589
1590     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4)
1591     {
1592         poke(arg4, POKE_ARGUMENT_OFFSET);
1593         setupArgumentsWithExecState(arg1, arg2, arg3);
1594     }
1595
1596     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4)
1597     {
1598         poke(arg4, POKE_ARGUMENT_OFFSET);
1599         setupArgumentsWithExecState(arg1, arg2, arg3);
1600     }
1601
1602     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, GPRReg arg5)
1603     {
1604         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1605         poke(arg4, POKE_ARGUMENT_OFFSET);
1606         setupArgumentsWithExecState(arg1, arg2, arg3);
1607     }
1608
1609     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImmPtr arg5, TrustedImmPtr arg6)
1610     {
1611         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1612         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1613         poke(arg4, POKE_ARGUMENT_OFFSET);
1614         setupArgumentsWithExecState(arg1, arg2, arg3);
1615     }
1616
1617     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImmPtr arg5)
1618     {
1619         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1620         poke(arg4, POKE_ARGUMENT_OFFSET);
1621         setupArgumentsWithExecState(arg1, arg2, arg3);
1622     }
1623
1624     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3,  GPRReg arg4)
1625     {
1626         poke(arg4, POKE_ARGUMENT_OFFSET);
1627         setupArgumentsWithExecState(arg1, arg2, arg3);
1628     }
1629
1630     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4)
1631     {
1632         poke(arg4, POKE_ARGUMENT_OFFSET);
1633         setupArgumentsWithExecState(arg1, arg2, arg3);
1634     }
1635
1636     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4)
1637     {
1638         poke(arg4, POKE_ARGUMENT_OFFSET);
1639         setupArgumentsWithExecState(arg1, arg2, arg3);
1640     }
1641
1642     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
1643     {
1644         poke(arg4, POKE_ARGUMENT_OFFSET);
1645         setupArgumentsWithExecState(arg1, arg2, arg3);
1646     }
1647
1648     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImm32 arg4)
1649     {
1650         poke(arg4, POKE_ARGUMENT_OFFSET);
1651         setupArgumentsWithExecState(arg1, arg2, arg3);
1652     }
1653
1654     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4, TrustedImm32 arg5)
1655     {
1656         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1657         poke(arg4, POKE_ARGUMENT_OFFSET);
1658         setupArgumentsWithExecState(arg1, arg2, arg3);
1659     }
1660
1661 #if CPU(X86_64)
1662     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm64 arg4)
1663     {
1664         poke(arg4, POKE_ARGUMENT_OFFSET);
1665         setupArgumentsWithExecState(arg1, arg2, arg3);
1666     }
1667 #endif
1668
1669     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImmPtr arg4)
1670     {
1671         poke(arg4, POKE_ARGUMENT_OFFSET);
1672         setupArgumentsWithExecState(arg1, arg2, arg3);
1673     }
1674
1675     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
1676     {
1677         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1678         poke(arg4, POKE_ARGUMENT_OFFSET);
1679         setupArgumentsWithExecState(arg1, arg2, arg3);
1680     }
1681
1682     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5, TrustedImm32 arg6)
1683     {
1684         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1685         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1686         poke(arg4, POKE_ARGUMENT_OFFSET);
1687         setupArgumentsWithExecState(arg1, arg2, arg3);
1688     }
1689
1690     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
1691     {
1692         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1693         poke(arg4, POKE_ARGUMENT_OFFSET);
1694         setupArgumentsWithExecState(arg1, arg2, arg3);
1695     }
1696
1697     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImmPtr arg5)
1698     {
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(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
1705     {
1706         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1707         poke(arg4, POKE_ARGUMENT_OFFSET);
1708         setupArgumentsWithExecState(arg1, arg2, arg3);
1709     }
1710
1711     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImm32 arg4)
1712     {
1713         poke(arg4, POKE_ARGUMENT_OFFSET);
1714         setupArgumentsWithExecState(arg1, arg2, arg3);
1715     }
1716
1717     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, TrustedImmPtr arg3, GPRReg arg4)
1718     {
1719         poke(arg4, POKE_ARGUMENT_OFFSET);
1720         setupArgumentsWithExecState(arg1, arg2, arg3);
1721     }
1722
1723     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImm32 arg4, TrustedImm32 arg5)
1724     {
1725         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1726         poke(arg4, POKE_ARGUMENT_OFFSET);
1727         setupArgumentsWithExecState(arg1, arg2, arg3);
1728     }
1729
1730     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2, GPRReg arg3, GPRReg arg4)
1731     {
1732         poke(arg4, POKE_ARGUMENT_OFFSET);
1733         setupArgumentsWithExecState(arg1, arg2, arg3);
1734     }
1735
1736     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
1737     {
1738         poke(arg4, POKE_ARGUMENT_OFFSET);
1739         setupArgumentsWithExecState(arg1, arg2, arg3);
1740     }
1741
1742     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
1743     {
1744         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1745         poke(arg4, POKE_ARGUMENT_OFFSET);
1746         setupArgumentsWithExecState(arg1, arg2, arg3);
1747     }
1748
1749     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImm32 arg5)
1750     {
1751         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1752         poke(arg4, POKE_ARGUMENT_OFFSET);
1753         setupArgumentsWithExecState(arg1, arg2, arg3);
1754     }
1755
1756     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4)
1757     {
1758         poke(arg4, POKE_ARGUMENT_OFFSET);
1759         setupArgumentsWithExecState(arg1, arg2, arg3);
1760     }
1761
1762     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
1763     {
1764         poke(arg4, POKE_ARGUMENT_OFFSET);
1765         setupArgumentsWithExecState(arg1, arg2, arg3);
1766     }
1767
1768     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImmPtr arg4)
1769     {
1770         poke(arg4, POKE_ARGUMENT_OFFSET);
1771         setupArgumentsWithExecState(arg1, arg2, arg3);
1772     }
1773
1774     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4)
1775     {
1776         poke(arg4, POKE_ARGUMENT_OFFSET);
1777         setupArgumentsWithExecState(arg1, arg2, arg3);
1778     }
1779
1780     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4)
1781     {
1782         poke(arg4, POKE_ARGUMENT_OFFSET);
1783         setupArgumentsWithExecState(arg1, arg2, arg3);
1784     }
1785     
1786     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImmPtr arg4)
1787     {
1788         poke(arg4, POKE_ARGUMENT_OFFSET);
1789         setupArgumentsWithExecState(arg1, arg2, arg3);
1790     }
1791
1792     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4)
1793     {
1794         poke(arg4, POKE_ARGUMENT_OFFSET);
1795         setupArgumentsWithExecState(arg1, arg2, arg3);
1796     }
1797
1798     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, GPRReg arg3, GPRReg arg4)
1799     {
1800         poke(arg4, POKE_ARGUMENT_OFFSET);
1801         setupArgumentsWithExecState(arg1, arg2, arg3);
1802     }
1803
1804     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
1805     {
1806         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1807         poke(arg4, POKE_ARGUMENT_OFFSET);
1808         setupArgumentsWithExecState(arg1, arg2, arg3);
1809     }
1810
1811     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, TrustedImm32 arg5)
1812     {
1813         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1814         poke(arg4, POKE_ARGUMENT_OFFSET);
1815         setupArgumentsWithExecState(arg1, arg2, arg3);
1816     }
1817
1818     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImmPtr arg5)
1819     {
1820         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1821         poke(arg4, POKE_ARGUMENT_OFFSET);
1822         setupArgumentsWithExecState(arg1, arg2, arg3);
1823     }
1824
1825     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
1826     {
1827         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1828         poke(arg4, POKE_ARGUMENT_OFFSET);
1829         setupArgumentsWithExecState(arg1, arg2, arg3);
1830     }
1831
1832     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
1833     {
1834         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1835         poke(arg4, POKE_ARGUMENT_OFFSET);
1836         setupArgumentsWithExecState(arg1, arg2, arg3);
1837     }
1838
1839     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
1840     {
1841         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1842         poke(arg4, POKE_ARGUMENT_OFFSET);
1843         setupArgumentsWithExecState(arg1, arg2, arg3);
1844     }
1845
1846     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4, TrustedImm32 arg5)
1847     {
1848         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1849         poke(arg4, POKE_ARGUMENT_OFFSET);
1850         setupArgumentsWithExecState(arg1, arg2, arg3);
1851     }
1852
1853     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4)
1854     {
1855         poke(arg4, POKE_ARGUMENT_OFFSET);
1856         setupArgumentsWithExecState(arg1, arg2, arg3);
1857     }
1858
1859     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4, TrustedImm32 arg5)
1860     {
1861         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1862         poke(arg4, POKE_ARGUMENT_OFFSET);
1863         setupArgumentsWithExecState(arg1, arg2, arg3);
1864     }
1865
1866     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
1867     {
1868         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1869         poke(arg4, POKE_ARGUMENT_OFFSET);
1870         setupArgumentsWithExecState(arg1, arg2, arg3);
1871     }
1872
1873     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
1874     {
1875         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1876         poke(arg4, POKE_ARGUMENT_OFFSET);
1877         setupArgumentsWithExecState(arg1, arg2, arg3);
1878     }
1879
1880     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
1881     {
1882         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1883         poke(arg4, POKE_ARGUMENT_OFFSET);
1884         setupArgumentsWithExecState(arg1, arg2, arg3);
1885     }
1886
1887     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
1888     {
1889         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1890         poke(arg4, POKE_ARGUMENT_OFFSET);
1891         setupArgumentsWithExecState(arg1, arg2, arg3);
1892     }
1893
1894     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, GPRReg arg4, TrustedImm32 arg5)
1895     {
1896         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1897         poke(arg4, POKE_ARGUMENT_OFFSET);
1898         setupArgumentsWithExecState(arg1, arg2, arg3);
1899     }
1900
1901     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6)
1902     {
1903         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1904         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1905         poke(arg4, POKE_ARGUMENT_OFFSET);
1906         setupArgumentsWithExecState(arg1, arg2, arg3);
1907     }
1908
1909     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, TrustedImm32 arg6)
1910     {
1911         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1912         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1913         poke(arg4, POKE_ARGUMENT_OFFSET);
1914         setupArgumentsWithExecState(arg1, arg2, arg3);
1915     }
1916
1917     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5, TrustedImm32 arg6)
1918     {
1919         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1920         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1921         poke(arg4, POKE_ARGUMENT_OFFSET);
1922         setupArgumentsWithExecState(arg1, arg2, arg3);
1923     }
1924
1925     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6, TrustedImmPtr arg7)
1926     {
1927         poke(arg7, POKE_ARGUMENT_OFFSET + 3);
1928         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1929         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1930         poke(arg4, POKE_ARGUMENT_OFFSET);
1931         setupArgumentsWithExecState(arg1, arg2, arg3);
1932     }
1933
1934     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, GPRReg arg4, GPRReg arg5)
1935     {
1936         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1937         poke(arg4, POKE_ARGUMENT_OFFSET);
1938         setupArgumentsWithExecState(arg1, arg2, arg3);
1939     }
1940
1941     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, TrustedImm32 arg5, TrustedImmPtr arg6)
1942     {
1943         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1944         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1945         poke(arg4, POKE_ARGUMENT_OFFSET);
1946         setupArgumentsWithExecState(arg1, arg2, arg3);
1947     }
1948
1949     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, TrustedImmPtr arg6)
1950     {
1951         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1952         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1953         poke(arg4, POKE_ARGUMENT_OFFSET);
1954         setupArgumentsWithExecState(arg1, arg2, arg3);
1955     }
1956
1957     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImm32 arg5, TrustedImmPtr arg6)
1958     {
1959         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1960         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1961         poke(arg4, POKE_ARGUMENT_OFFSET);
1962         setupArgumentsWithExecState(arg1, arg2, arg3);
1963     }
1964
1965     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, TrustedImm32 arg6)
1966     {
1967         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1968         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1969         poke(arg4, POKE_ARGUMENT_OFFSET);
1970         setupArgumentsWithExecState(arg1, arg2, arg3);
1971     }
1972
1973     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, GPRReg arg5, GPRReg arg6)
1974     {
1975         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1976         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1977         poke(arg4, POKE_ARGUMENT_OFFSET);
1978         setupArgumentsWithExecState(arg1, arg2, arg3);
1979     }
1980
1981     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, GPRReg arg5, TrustedImm32 arg6)
1982     {
1983         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1984         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1985         poke(arg4, POKE_ARGUMENT_OFFSET);
1986         setupArgumentsWithExecState(arg1, arg2, arg3);
1987     }
1988
1989     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, TrustedImmPtr arg6)
1990     {
1991         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
1992         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
1993         poke(arg4, POKE_ARGUMENT_OFFSET);
1994         setupArgumentsWithExecState(arg1, arg2, arg3);
1995     }
1996
1997     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6, GPRReg arg7)
1998     {
1999         poke(arg7, POKE_ARGUMENT_OFFSET + 3);
2000         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
2001         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
2002         poke(arg4, POKE_ARGUMENT_OFFSET);
2003         setupArgumentsWithExecState(arg1, arg2, arg3);
2004     }
2005
2006     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6, GPRReg arg7)
2007     {
2008         poke(arg7, POKE_ARGUMENT_OFFSET + 3);
2009         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
2010         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
2011         poke(arg4, POKE_ARGUMENT_OFFSET);
2012         setupArgumentsWithExecState(arg1, arg2, arg3);
2013     }
2014
2015     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6, GPRReg arg7, TrustedImmPtr arg8)
2016     {
2017         poke(arg8, POKE_ARGUMENT_OFFSET + 4);
2018         poke(arg7, POKE_ARGUMENT_OFFSET + 3);
2019         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
2020         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
2021         poke(arg4, POKE_ARGUMENT_OFFSET);
2022         setupArgumentsWithExecState(arg1, arg2, arg3);
2023     }
2024
2025     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6, GPRReg arg7, GPRReg arg8)
2026     {
2027         poke(arg8, POKE_ARGUMENT_OFFSET + 4);
2028         poke(arg7, POKE_ARGUMENT_OFFSET + 3);
2029         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
2030         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
2031         poke(arg4, POKE_ARGUMENT_OFFSET);
2032         setupArgumentsWithExecState(arg1, arg2, arg3);
2033     }
2034
2035     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6, GPRReg arg7, GPRReg arg8, GPRReg arg9)
2036     {
2037         poke(arg9, POKE_ARGUMENT_OFFSET + 5);
2038         poke(arg8, POKE_ARGUMENT_OFFSET + 4);
2039         poke(arg7, POKE_ARGUMENT_OFFSET + 3);
2040         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
2041         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
2042         poke(arg4, POKE_ARGUMENT_OFFSET);
2043         setupArgumentsWithExecState(arg1, arg2, arg3);
2044     }
2045
2046     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5, GPRReg arg6, GPRReg arg7)
2047     {
2048         poke(arg7, POKE_ARGUMENT_OFFSET + 3);
2049         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
2050         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
2051         poke(arg4, POKE_ARGUMENT_OFFSET);
2052         setupArgumentsWithExecState(arg1, arg2, arg3);
2053     }
2054
2055     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImm32 arg5, GPRReg arg6, GPRReg arg7)
2056     {
2057         poke(arg7, POKE_ARGUMENT_OFFSET + 3);
2058         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
2059         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
2060         poke(arg4, POKE_ARGUMENT_OFFSET);
2061         setupArgumentsWithExecState(arg1, arg2, arg3);
2062     }
2063
2064     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4, GPRReg arg5)
2065     {
2066         poke(arg5, POKE_ARGUMENT_OFFSET);
2067         setupTwoStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1>(arg1, arg2);
2068         move(arg3, GPRInfo::argumentGPR2);
2069         move(arg4, GPRInfo::argumentGPR3);
2070     }
2071
2072     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, TrustedImm32 arg5)
2073     {
2074         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
2075         poke(arg4, POKE_ARGUMENT_OFFSET);
2076         setupArgumentsWithExecState(arg1, arg2, arg3);
2077     }
2078
2079     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImmPtr arg4, GPRReg arg5)
2080     {
2081         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
2082         poke(arg4, POKE_ARGUMENT_OFFSET);
2083         setupArgumentsWithExecState(arg1, arg2, arg3);
2084     }
2085 #endif // NUMBER_OF_ARGUMENT_REGISTERS == 4
2086
2087 #if NUMBER_OF_ARGUMENT_REGISTERS >= 5
2088     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4)
2089     {
2090         setupFourStubArgsGPR(GPRInfo::argumentGPR1, GPRInfo::argumentGPR2, GPRInfo::argumentGPR3, GPRInfo::argumentGPR4, arg1, arg2, arg3, arg4);
2091         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
2092     }
2093
2094     void setupStubArguments134(GPRReg arg1, GPRReg arg3, GPRReg arg4)
2095     {
2096         setupThreeStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR3, GPRInfo::argumentGPR4>(arg1, arg3, arg4);
2097     }
2098
2099     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
2100     {
2101         setupThreeStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg1, arg2, arg3);
2102         move(arg4, GPRInfo::argumentGPR4);
2103         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
2104     }
2105
2106     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4)
2107     {
2108         setupTwoStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR4>(arg1, arg4);
2109         move(arg2, GPRInfo::argumentGPR2);
2110         move(arg3, GPRInfo::argumentGPR3);
2111         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
2112     }
2113
2114     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4)
2115     {
2116         setupTwoStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2>(arg1, arg2);
2117         move(arg3, GPRInfo::argumentGPR3);
2118         move(arg4, GPRInfo::argumentGPR4);
2119         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
2120     }
2121
2122     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImmPtr arg4)
2123     {
2124         setupTwoStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2>(arg1, arg2);
2125         move(arg3, GPRInfo::argumentGPR3);
2126         move(arg4, GPRInfo::argumentGPR4);
2127         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
2128     }
2129
2130     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
2131     {
2132         setupThreeStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR4, GPRInfo::argumentGPR5>(arg1, arg4, arg5);
2133         move(arg2, GPRInfo::argumentGPR2);
2134         move(arg3, GPRInfo::argumentGPR3);
2135         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
2136     }
2137
2138     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4)
2139     {
2140         setupStubArguments134(arg1, arg3, arg4);
2141         move(arg2, GPRInfo::argumentGPR2);
2142         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
2143     }
2144
2145     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
2146     {
2147         setupTwoStubArgsGPR<GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg2, arg3);
2148         move(arg1, GPRInfo::argumentGPR1);
2149         move(arg4, GPRInfo::argumentGPR4);
2150         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
2151     }
2152
2153     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImm32 arg4)
2154     {
2155         move(arg2, GPRInfo::argumentGPR2); // In case arg2 is argumentGPR1.
2156         move(arg1, GPRInfo::argumentGPR1);
2157         move(arg3, GPRInfo::argumentGPR3);
2158         move(arg4, GPRInfo::argumentGPR4);
2159         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
2160     }
2161
2162     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm64 arg4)
2163     {
2164         move(arg2, GPRInfo::argumentGPR2); // In case arg2 is argumentGPR1.
2165         move(arg1, GPRInfo::argumentGPR1);
2166         move(arg3, GPRInfo::argumentGPR3);
2167         move(arg4, GPRInfo::argumentGPR4);
2168         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
2169     }
2170
2171     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4, TrustedImm32 arg5)
2172     {
2173         move(arg2, GPRInfo::argumentGPR2); // In case arg2 is argumentGPR1.
2174         move(arg1, GPRInfo::argumentGPR1);
2175         move(arg3, GPRInfo::argumentGPR3);
2176         move(arg4, GPRInfo::argumentGPR4);
2177         move(arg5, GPRInfo::argumentGPR5);
2178         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
2179     }
2180
2181     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
2182     {
2183         move(arg3, GPRInfo::argumentGPR3);
2184         move(arg1, GPRInfo::argumentGPR1);
2185         move(arg2, GPRInfo::argumentGPR2);
2186         move(arg4, GPRInfo::argumentGPR4);
2187         move(arg5, GPRInfo::argumentGPR5);
2188         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
2189     }
2190
2191     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, TrustedImm32 arg5)
2192     {
2193         setupTwoStubArgsGPR<GPRInfo::argumentGPR2, GPRInfo::argumentGPR4>(arg2, arg4);
2194         move(arg1, GPRInfo::argumentGPR1);
2195         move(arg3, GPRInfo::argumentGPR3);
2196         move(arg5, GPRInfo::argumentGPR5);
2197         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
2198     }
2199
2200     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
2201     {
2202         setupTwoStubArgsGPR<GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg2, arg3);
2203         move(arg1, GPRInfo::argumentGPR1);
2204         move(arg4, GPRInfo::argumentGPR4);
2205         move(arg5, GPRInfo::argumentGPR5);
2206         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
2207     }
2208
2209     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4)
2210     {
2211         setupThreeStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg1, arg2, arg3);
2212         move(arg4, GPRInfo::argumentGPR4);
2213         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
2214     }
2215
2216     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4)
2217     {
2218         setupThreeStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2, GPRInfo::argumentGPR4>(arg1, arg2, arg4);
2219         move(arg3, GPRInfo::argumentGPR3);
2220         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
2221     }
2222
2223     ALWAYS_INLINE void setupArguments(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4, TrustedImmPtr arg5)
2224     {
2225         setupThreeStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg1, arg3, arg4);
2226         move(arg2, GPRInfo::argumentGPR1);
2227         move(arg5, GPRInfo::argumentGPR4);
2228     }
2229
2230     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4, GPRReg arg5)
2231     {
2232         setupThreeStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1, GPRInfo::argumentGPR4>(arg1, arg2, arg5);
2233         move(arg3, GPRInfo::argumentGPR2);
2234         move(arg4, GPRInfo::argumentGPR3);
2235     }
2236 #endif
2237     
2238     void setupArgumentsWithExecState(JSValueRegs arg1, JSValueRegs arg2)
2239     {
2240 #if USE(JSVALUE64)
2241         setupArgumentsWithExecState(arg1.gpr(), arg2.gpr());
2242 #else
2243         setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR());
2244 #endif
2245     }
2246
2247     void setupArgumentsWithExecState(JSValueRegs arg1, JSValueRegs arg2, TrustedImmPtr arg3)
2248     {
2249 #if USE(JSVALUE64)
2250         setupArgumentsWithExecState(arg1.gpr(), arg2.gpr(), arg3);
2251 #else
2252         setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR(), arg3);
2253 #endif
2254     }
2255
2256     void setupArgumentsWithExecState(JSValueRegs arg1, JSValueRegs arg2, TrustedImmPtr arg3, TrustedImmPtr arg4)
2257     {
2258 #if USE(JSVALUE64)
2259         setupArgumentsWithExecState(arg1.gpr(), arg2.gpr(), arg3, arg4);
2260 #else
2261         setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR(), arg3, arg4);
2262 #endif
2263     }
2264     
2265     void setupArguments(JSValueRegs arg1)
2266     {
2267 #if USE(JSVALUE64)
2268         setupArguments(arg1.gpr());
2269 #else
2270         setupArguments(arg1.payloadGPR(), arg1.tagGPR());
2271 #endif
2272     }
2273
2274     void setupResults(GPRReg destA, GPRReg destB)
2275     {
2276         GPRReg srcA = GPRInfo::returnValueGPR;
2277         GPRReg srcB = GPRInfo::returnValueGPR2;
2278
2279         if (destA == InvalidGPRReg)
2280             move(srcB, destB);
2281         else if (destB == InvalidGPRReg)
2282             move(srcA, destA);
2283         else if (srcB != destA) {
2284             // Handle the easy cases - two simple moves.
2285             move(srcA, destA);
2286             move(srcB, destB);
2287         } else if (srcA != destB) {
2288             // Handle the non-swap case - just put srcB in place first.
2289             move(srcB, destB);
2290             move(srcA, destA);
2291         } else
2292             swap(destA, destB);
2293     }
2294     
2295     void setupResults(JSValueRegs regs)
2296     {
2297 #if USE(JSVALUE64)
2298         move(GPRInfo::returnValueGPR, regs.gpr());
2299 #else
2300         setupResults(regs.payloadGPR(), regs.tagGPR());
2301 #endif
2302     }
2303     
2304     void jumpToExceptionHandler()
2305     {
2306         // genericUnwind() leaves the handler CallFrame* in vm->callFrameForCatch,
2307         // and the address of the handler in vm->targetMachinePCForThrow.
2308         loadPtr(&vm()->targetMachinePCForThrow, GPRInfo::regT1);
2309         jump(GPRInfo::regT1);
2310     }
2311
2312     void prepareForTailCallSlow(GPRReg calleeGPR = InvalidGPRReg)
2313     {
2314         GPRReg temp1 = calleeGPR == GPRInfo::regT0 ? GPRInfo::regT3 : GPRInfo::regT0;
2315         GPRReg temp2 = calleeGPR == GPRInfo::regT1 ? GPRInfo::regT3 : GPRInfo::regT1;
2316         GPRReg temp3 = calleeGPR == GPRInfo::regT2 ? GPRInfo::regT3 : GPRInfo::regT2;
2317
2318         GPRReg newFramePointer = temp1;
2319         GPRReg newFrameSizeGPR = temp2;
2320         {
2321             // The old frame size is its number of arguments (or number of
2322             // parameters in case of arity fixup), plus the frame header size,
2323             // aligned
2324             GPRReg oldFrameSizeGPR = temp2;
2325             {
2326                 GPRReg argCountGPR = oldFrameSizeGPR;
2327                 load32(Address(framePointerRegister, CallFrameSlot::argumentCount * static_cast<int>(sizeof(Register)) + PayloadOffset), argCountGPR);
2328
2329                 {
2330                     GPRReg numParametersGPR = temp1;
2331                     {
2332                         GPRReg codeBlockGPR = numParametersGPR;
2333                         loadPtr(Address(framePointerRegister, CallFrameSlot::codeBlock * static_cast<int>(sizeof(Register))), codeBlockGPR);
2334                         load32(Address(codeBlockGPR, CodeBlock::offsetOfNumParameters()), numParametersGPR);
2335                     }
2336
2337                     ASSERT(numParametersGPR != argCountGPR);
2338                     Jump argumentCountWasNotFixedUp = branch32(BelowOrEqual, numParametersGPR, argCountGPR);
2339                     move(numParametersGPR, argCountGPR);
2340                     argumentCountWasNotFixedUp.link(this);
2341                 }
2342
2343                 add32(TrustedImm32(stackAlignmentRegisters() + CallFrame::headerSizeInRegisters - 1), argCountGPR, oldFrameSizeGPR);
2344                 and32(TrustedImm32(-stackAlignmentRegisters()), oldFrameSizeGPR);
2345                 // We assume < 2^28 arguments
2346                 mul32(TrustedImm32(sizeof(Register)), oldFrameSizeGPR, oldFrameSizeGPR);
2347             }
2348
2349             // The new frame pointer is at framePointer + oldFrameSize - newFrameSize
2350             ASSERT(newFramePointer != oldFrameSizeGPR);
2351             addPtr(framePointerRegister, oldFrameSizeGPR, newFramePointer);
2352
2353             // The new frame size is just the number of arguments plus the
2354             // frame header size, aligned
2355             ASSERT(newFrameSizeGPR != newFramePointer);
2356             load32(Address(stackPointerRegister, CallFrameSlot::argumentCount * static_cast<int>(sizeof(Register)) + PayloadOffset - sizeof(CallerFrameAndPC)),
2357                 newFrameSizeGPR);
2358             add32(TrustedImm32(stackAlignmentRegisters() + CallFrame::headerSizeInRegisters - 1), newFrameSizeGPR);
2359             and32(TrustedImm32(-stackAlignmentRegisters()), newFrameSizeGPR);
2360             // We assume < 2^28 arguments
2361             mul32(TrustedImm32(sizeof(Register)), newFrameSizeGPR, newFrameSizeGPR);
2362         }
2363
2364         GPRReg tempGPR = temp3;
2365         ASSERT(tempGPR != newFramePointer && tempGPR != newFrameSizeGPR);
2366
2367         // We don't need the current frame beyond this point. Masquerade as our
2368         // caller.
2369 #if CPU(ARM) || CPU(SH4) || CPU(ARM64)
2370         loadPtr(Address(framePointerRegister, sizeof(void*)), linkRegister);
2371         subPtr(TrustedImm32(2 * sizeof(void*)), newFrameSizeGPR);
2372 #elif CPU(MIPS)
2373         loadPtr(Address(framePointerRegister, sizeof(void*)), returnAddressRegister);
2374         subPtr(TrustedImm32(2 * sizeof(void*)), newFrameSizeGPR);
2375 #elif CPU(X86) || CPU(X86_64)
2376         loadPtr(Address(framePointerRegister, sizeof(void*)), tempGPR);
2377         push(tempGPR);
2378         subPtr(TrustedImm32(sizeof(void*)), newFrameSizeGPR);
2379 #else
2380         UNREACHABLE_FOR_PLATFORM();
2381 #endif
2382         subPtr(newFrameSizeGPR, newFramePointer);
2383         loadPtr(Address(framePointerRegister), framePointerRegister);
2384
2385
2386         // We need to move the newFrameSizeGPR slots above the stack pointer by
2387         // newFramePointer registers. We use pointer-sized chunks.
2388         MacroAssembler::Label copyLoop(label());
2389
2390         subPtr(TrustedImm32(sizeof(void*)), newFrameSizeGPR);
2391         loadPtr(BaseIndex(stackPointerRegister, newFrameSizeGPR, TimesOne), tempGPR);
2392         storePtr(tempGPR, BaseIndex(newFramePointer, newFrameSizeGPR, TimesOne));
2393
2394         branchTest32(MacroAssembler::NonZero, newFrameSizeGPR).linkTo(copyLoop, this);
2395
2396         // Ready for a jump!
2397         move(newFramePointer, stackPointerRegister);
2398     }
2399     
2400     // These operations clobber all volatile registers. They assume that there is room on the top of
2401     // stack to marshall call arguments.
2402     void logShadowChickenProloguePacket(GPRReg shadowPacket, GPRReg scratch1, GPRReg scope);
2403     void logShadowChickenTailPacket(GPRReg shadowPacket, JSValueRegs thisRegs, GPRReg scope, CodeBlock*, CallSiteIndex);
2404     // Leaves behind a pointer to the Packet we should write to in shadowPacket.
2405     void ensureShadowChickenPacket(GPRReg shadowPacket, GPRReg scratch1NonArgGPR, GPRReg scratch2);
2406 };
2407
2408 } // namespace JSC
2409
2410 #endif // ENABLE(JIT)
2411
2412 #endif // CCallHelpers_h
2413