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