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