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