Source/JavaScriptCore: Qt build fix. Add a return to make the compiler happy.
[WebKit-https.git] / Source / JavaScriptCore / dfg / DFGGPRInfo.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 DFGGPRInfo_h
27 #define DFGGPRInfo_h
28
29 #include <wtf/Platform.h>
30
31 #if ENABLE(DFG_JIT)
32
33 #include "DFGRegisterBank.h"
34 #include "MacroAssembler.h"
35
36 namespace JSC { namespace DFG {
37
38 typedef MacroAssembler::RegisterID GPRReg;
39 #define InvalidGPRReg ((::JSC::DFG::GPRReg)-1)
40
41 #if USE(JSVALUE64)
42 class JSValueRegs {
43 public:
44     JSValueRegs()
45         : m_gpr(InvalidGPRReg)
46     {
47     }
48     
49     explicit JSValueRegs(GPRReg gpr)
50         : m_gpr(gpr)
51     {
52     }
53     
54     static JSValueRegs payloadOnly(GPRReg gpr)
55     {
56         return JSValueRegs(gpr);
57     }
58     
59     bool operator!() const { return m_gpr == InvalidGPRReg; }
60     
61     GPRReg gpr() const { return m_gpr; }
62     GPRReg payloadGPR() const { return m_gpr; }
63     
64 private:
65     GPRReg m_gpr;
66 };
67
68 class JSValueSource {
69 public:
70     JSValueSource()
71         : m_offset(notAddress())
72         , m_base(InvalidGPRReg)
73     {
74     }
75     
76     JSValueSource(JSValueRegs regs)
77         : m_offset(notAddress())
78         , m_base(regs.gpr())
79     {
80     }
81     
82     explicit JSValueSource(GPRReg gpr)
83         : m_offset(notAddress())
84         , m_base(gpr)
85     {
86     }
87     
88     JSValueSource(MacroAssembler::Address address)
89         : m_offset(address.offset)
90         , m_base(address.base)
91     {
92         ASSERT(m_offset != notAddress());
93         ASSERT(m_base != InvalidGPRReg);
94     }
95     
96     static JSValueSource unboxedCell(GPRReg payloadGPR)
97     {
98         return JSValueSource(payloadGPR);
99     }
100     
101     bool operator!() const { return m_base == InvalidGPRReg; }
102     
103     bool isAddress() const { return m_offset != notAddress(); }
104     
105     int32_t offset() const
106     {
107         ASSERT(isAddress());
108         return m_offset;
109     }
110     
111     GPRReg base() const
112     {
113         ASSERT(isAddress());
114         return m_base;
115     }
116     
117     GPRReg gpr() const
118     {
119         ASSERT(!isAddress());
120         return m_base;
121     }
122     
123     MacroAssembler::Address asAddress() const { return MacroAssembler::Address(base(), offset()); }
124     
125 private:
126     static inline int32_t notAddress() { return 0x80000000; }     
127           
128     int32_t m_offset;
129     GPRReg m_base;
130 };
131 #endif
132
133 #if USE(JSVALUE32_64)
134 class JSValueRegs {
135 public:
136     JSValueRegs()
137         : m_tagGPR(static_cast<int8_t>(InvalidGPRReg))
138         , m_payloadGPR(static_cast<int8_t>(InvalidGPRReg))
139     {
140     }
141     
142     JSValueRegs(GPRReg tagGPR, GPRReg payloadGPR)
143         : m_tagGPR(tagGPR)
144         , m_payloadGPR(payloadGPR)
145     {
146     }
147     
148     static JSValueRegs payloadOnly(GPRReg gpr)
149     {
150         return JSValueRegs(InvalidGPRReg, gpr);
151     }
152     
153     bool operator!() const
154     {
155         return static_cast<GPRReg>(m_tagGPR) == InvalidGPRReg
156             && static_cast<GPRReg>(m_payloadGPR) == InvalidGPRReg;
157     }
158     
159     GPRReg tagGPR() const { return static_cast<GPRReg>(m_tagGPR); }
160     GPRReg payloadGPR() const { return static_cast<GPRReg>(m_payloadGPR); }
161     GPRReg gpr(WhichValueWord which) const
162     {
163         switch (which) {
164         case TagWord:
165             return tagGPR();
166         case PayloadWord:
167             return payloadGPR();
168         }
169         ASSERT_NOT_REACHED();
170         return tagGPR();
171     }
172
173 private:
174     int8_t m_tagGPR;
175     int8_t m_payloadGPR;
176 };
177
178 class JSValueSource {
179 public:
180     JSValueSource()
181         : m_offset(notAddress())
182         , m_baseOrTag(static_cast<int8_t>(InvalidGPRReg))
183         , m_payload(static_cast<int8_t>(InvalidGPRReg))
184         , m_tagType(0)
185     {
186     }
187     
188     JSValueSource(JSValueRegs regs)
189         : m_offset(notAddress())
190         , m_baseOrTag(regs.tagGPR())
191         , m_payload(regs.payloadGPR())
192         , m_tagType(0)
193     {
194     }
195     
196     JSValueSource(GPRReg tagGPR, GPRReg payloadGPR)
197         : m_offset(notAddress())
198         , m_baseOrTag(static_cast<int8_t>(tagGPR))
199         , m_payload(static_cast<int8_t>(payloadGPR))
200         , m_tagType(0)
201     {
202     }
203     
204     JSValueSource(MacroAssembler::Address address)
205         : m_offset(address.offset)
206         , m_baseOrTag(static_cast<int8_t>(address.base))
207         , m_payload(static_cast<int8_t>(InvalidGPRReg))
208         , m_tagType(0)
209     {
210         ASSERT(m_offset != notAddress());
211         ASSERT(static_cast<GPRReg>(m_baseOrTag) != InvalidGPRReg);
212     }
213     
214     static JSValueSource unboxedCell(GPRReg payloadGPR)
215     {
216         JSValueSource result;
217         result.m_offset = notAddress();
218         result.m_baseOrTag = static_cast<int8_t>(InvalidGPRReg);
219         result.m_payload = static_cast<int8_t>(payloadGPR);
220         result.m_tagType = static_cast<int8_t>(JSValue::CellTag);
221         return result;
222     }
223     
224     bool operator!() const
225     {
226         return static_cast<GPRReg>(m_baseOrTag) == InvalidGPRReg
227             && static_cast<GPRReg>(m_payload) == InvalidGPRReg;
228     }
229     
230     bool isAddress() const
231     {
232         ASSERT(!!*this);
233         return m_offset != notAddress();
234     }
235     
236     int32_t offset() const
237     {
238         ASSERT(isAddress());
239         return m_offset;
240     }
241     
242     GPRReg base() const
243     {
244         ASSERT(isAddress());
245         return static_cast<GPRReg>(m_baseOrTag);
246     }
247     
248     GPRReg tagGPR() const
249     {
250         ASSERT(!isAddress() && static_cast<GPRReg>(m_baseOrTag) != InvalidGPRReg);
251         return static_cast<GPRReg>(m_baseOrTag);
252     }
253     
254     GPRReg payloadGPR() const
255     {
256         ASSERT(!isAddress());
257         return static_cast<GPRReg>(m_payload);
258     }
259     
260     bool hasKnownTag() const
261     {
262         ASSERT(!!*this);
263         ASSERT(!isAddress());
264         return static_cast<GPRReg>(m_baseOrTag) == InvalidGPRReg;
265     }
266     
267     uint32_t tag() const
268     {
269         return static_cast<int32_t>(m_tagType);
270     }
271     
272     MacroAssembler::Address asAddress(unsigned additionalOffset = 0) const { return MacroAssembler::Address(base(), offset() + additionalOffset); }
273     
274 private:
275     static inline int32_t notAddress() { return 0x80000000; }     
276           
277     int32_t m_offset;
278     int8_t m_baseOrTag;
279     int8_t m_payload; 
280     int8_t m_tagType; // Contains the low bits of the tag.
281 };
282 #endif
283
284 #if CPU(X86)
285 #define NUMBER_OF_ARGUMENT_REGISTERS 0
286
287 class GPRInfo {
288 public:
289     typedef GPRReg RegisterType;
290     static const unsigned numberOfRegisters = 5;
291     static const unsigned numberOfArgumentRegisters = NUMBER_OF_ARGUMENT_REGISTERS;
292
293     // Temporary registers.
294     static const GPRReg regT0 = X86Registers::eax;
295     static const GPRReg regT1 = X86Registers::edx;
296     static const GPRReg regT2 = X86Registers::ecx;
297     static const GPRReg regT3 = X86Registers::ebx;
298     static const GPRReg regT4 = X86Registers::esi;
299     // These registers match the baseline JIT.
300     static const GPRReg cachedResultRegister = regT0;
301     static const GPRReg cachedResultRegister2 = regT1;
302     static const GPRReg callFrameRegister = X86Registers::edi;
303     // These constants provide the names for the general purpose argument & return value registers.
304     static const GPRReg argumentGPR0 = X86Registers::ecx; // regT2
305     static const GPRReg argumentGPR1 = X86Registers::edx; // regT1
306     static const GPRReg nonArgGPR0 = X86Registers::eax; // regT0
307     static const GPRReg nonArgGPR1 = X86Registers::ebx; // regT3
308     static const GPRReg nonArgGPR2 = X86Registers::esi; // regT4
309     static const GPRReg returnValueGPR = X86Registers::eax; // regT0
310     static const GPRReg returnValueGPR2 = X86Registers::edx; // regT1
311     static const GPRReg nonPreservedNonReturnGPR = X86Registers::ecx;
312
313     static GPRReg toRegister(unsigned index)
314     {
315         ASSERT(index < numberOfRegisters);
316         static const GPRReg registerForIndex[numberOfRegisters] = { regT0, regT1, regT2, regT3, regT4 };
317         return registerForIndex[index];
318     }
319
320     static unsigned toIndex(GPRReg reg)
321     {
322         ASSERT(reg != InvalidGPRReg);
323         ASSERT(static_cast<int>(reg) < 8);
324         static const unsigned indexForRegister[8] = { 0, 2, 1, 3, InvalidIndex, InvalidIndex, 4, InvalidIndex };
325         unsigned result = indexForRegister[reg];
326         ASSERT(result != InvalidIndex);
327         return result;
328     }
329
330     static const char* debugName(GPRReg reg)
331     {
332         ASSERT(reg != InvalidGPRReg);
333         ASSERT(static_cast<int>(reg) < 8);
334         static const char* nameForRegister[8] = {
335             "eax", "ecx", "edx", "ebx",
336             "esp", "ebp", "esi", "edi",
337         };
338         return nameForRegister[reg];
339     }
340 private:
341
342     static const unsigned InvalidIndex = 0xffffffff;
343 };
344
345 #endif
346
347 #if CPU(X86_64)
348 #define NUMBER_OF_ARGUMENT_REGISTERS 6
349
350 class GPRInfo {
351 public:
352     typedef GPRReg RegisterType;
353     static const unsigned numberOfRegisters = 9;
354     static const unsigned numberOfArgumentRegisters = NUMBER_OF_ARGUMENT_REGISTERS;
355
356     // These registers match the baseline JIT.
357     static const GPRReg cachedResultRegister = X86Registers::eax;
358     static const GPRReg callFrameRegister = X86Registers::r13;
359     static const GPRReg tagTypeNumberRegister = X86Registers::r14;
360     static const GPRReg tagMaskRegister = X86Registers::r15;
361     // Temporary registers.
362     static const GPRReg regT0 = X86Registers::eax;
363     static const GPRReg regT1 = X86Registers::edx;
364     static const GPRReg regT2 = X86Registers::ecx;
365     static const GPRReg regT3 = X86Registers::ebx;
366     static const GPRReg regT4 = X86Registers::edi;
367     static const GPRReg regT5 = X86Registers::esi;
368     static const GPRReg regT6 = X86Registers::r8;
369     static const GPRReg regT7 = X86Registers::r9;
370     static const GPRReg regT8 = X86Registers::r10;
371     // These constants provide the names for the general purpose argument & return value registers.
372     static const GPRReg argumentGPR0 = X86Registers::edi; // regT4
373     static const GPRReg argumentGPR1 = X86Registers::esi; // regT5
374     static const GPRReg argumentGPR2 = X86Registers::edx; // regT1
375     static const GPRReg argumentGPR3 = X86Registers::ecx; // regT2
376     static const GPRReg argumentGPR4 = X86Registers::r8;  // regT6
377     static const GPRReg argumentGPR5 = X86Registers::r9;  // regT7
378     static const GPRReg nonArgGPR0 = X86Registers::eax; // regT0
379     static const GPRReg nonArgGPR1 = X86Registers::ebx; // regT3
380     static const GPRReg nonArgGPR2 = X86Registers::r10; // regT8
381     static const GPRReg returnValueGPR = X86Registers::eax; // regT0
382     static const GPRReg returnValueGPR2 = X86Registers::edx; // regT1
383     static const GPRReg nonPreservedNonReturnGPR = X86Registers::esi;
384
385     static GPRReg toRegister(unsigned index)
386     {
387         ASSERT(index < numberOfRegisters);
388         static const GPRReg registerForIndex[numberOfRegisters] = { regT0, regT1, regT2, regT3, regT4, regT5, regT6, regT7, regT8 };
389         return registerForIndex[index];
390     }
391     
392     static GPRReg toArgumentRegister(unsigned index)
393     {
394         ASSERT(index < numberOfArgumentRegisters);
395         static const GPRReg registerForIndex[numberOfArgumentRegisters] = { argumentGPR0, argumentGPR1, argumentGPR2, argumentGPR3, argumentGPR4, argumentGPR5 };
396         return registerForIndex[index];
397     }
398     
399     static unsigned toIndex(GPRReg reg)
400     {
401         ASSERT(reg != InvalidGPRReg);
402         ASSERT(static_cast<int>(reg) < 16);
403         static const unsigned indexForRegister[16] = { 0, 2, 1, 3, InvalidIndex, InvalidIndex, 5, 4, 6, 7, 8, InvalidIndex, InvalidIndex, InvalidIndex, InvalidIndex, InvalidIndex };
404         unsigned result = indexForRegister[reg];
405         ASSERT(result != InvalidIndex);
406         return result;
407     }
408
409     static const char* debugName(GPRReg reg)
410     {
411         ASSERT(reg != InvalidGPRReg);
412         ASSERT(static_cast<int>(reg) < 16);
413         static const char* nameForRegister[16] = {
414             "rax", "rcx", "rdx", "rbx",
415             "rsp", "rbp", "rsi", "rdi",
416             "r8", "r9", "r10", "r11",
417             "r12", "r13", "r14", "r15"
418         };
419         return nameForRegister[reg];
420     }
421 private:
422
423     static const unsigned InvalidIndex = 0xffffffff;
424 };
425
426 #endif
427
428 #if CPU(ARM)
429 #define NUMBER_OF_ARGUMENT_REGISTERS 4
430
431 class GPRInfo {
432 public:
433     typedef GPRReg RegisterType;
434     static const unsigned numberOfRegisters = 8;
435     static const unsigned numberOfArgumentRegisters = NUMBER_OF_ARGUMENT_REGISTERS;
436
437     // Temporary registers.
438     static const GPRReg regT0 = ARMRegisters::r0;
439     static const GPRReg regT1 = ARMRegisters::r1;
440     static const GPRReg regT2 = ARMRegisters::r2;
441     static const GPRReg regT3 = ARMRegisters::r4;
442     static const GPRReg regT4 = ARMRegisters::r8;
443     static const GPRReg regT5 = ARMRegisters::r9;
444     static const GPRReg regT6 = ARMRegisters::r10;
445     static const GPRReg regT7 = ARMRegisters::r11;
446     // These registers match the baseline JIT.
447     static const GPRReg cachedResultRegister = regT0;
448     static const GPRReg cachedResultRegister2 = regT1;
449     static const GPRReg callFrameRegister = ARMRegisters::r5;
450     // These constants provide the names for the general purpose argument & return value registers.
451     static const GPRReg argumentGPR0 = ARMRegisters::r0; // regT0
452     static const GPRReg argumentGPR1 = ARMRegisters::r1; // regT1
453     static const GPRReg argumentGPR2 = ARMRegisters::r2; // regT2
454     // FIXME: r3 is currently used be the MacroAssembler as a temporary - it seems
455     // This could threoretically be a problem if this is used in code generation
456     // between the arguments being set up, and the call being made. That said,
457     // any change introducing a problem here is likely to be immediately apparent!
458     static const GPRReg argumentGPR3 = ARMRegisters::r3; // FIXME!
459     static const GPRReg nonArgGPR0 = ARMRegisters::r4; // regT3
460     static const GPRReg nonArgGPR1 = ARMRegisters::r8; // regT4
461     static const GPRReg nonArgGPR2 = ARMRegisters::r9; // regT5
462     static const GPRReg returnValueGPR = ARMRegisters::r0; // regT0
463     static const GPRReg returnValueGPR2 = ARMRegisters::r1; // regT1
464     static const GPRReg nonPreservedNonReturnGPR = ARMRegisters::r2;
465
466     static GPRReg toRegister(unsigned index)
467     {
468         ASSERT(index < numberOfRegisters);
469         static const GPRReg registerForIndex[numberOfRegisters] = { regT0, regT1, regT2, regT3, regT4, regT5, regT6, regT7 };
470         return registerForIndex[index];
471     }
472
473     static unsigned toIndex(GPRReg reg)
474     {
475         ASSERT(static_cast<unsigned>(reg) != InvalidGPRReg);
476         ASSERT(static_cast<unsigned>(reg) < 16);
477         static const unsigned indexForRegister[16] = { 0, 1, 2, InvalidIndex, 3, InvalidIndex, InvalidIndex, InvalidIndex, 4, 5, 6, 7, InvalidIndex, InvalidIndex, InvalidIndex, InvalidIndex };
478         unsigned result = indexForRegister[reg];
479         ASSERT(result != InvalidIndex);
480         return result;
481     }
482
483     static const char* debugName(GPRReg reg)
484     {
485         ASSERT(static_cast<unsigned>(reg) != InvalidGPRReg);
486         ASSERT(static_cast<unsigned>(reg) < 16);
487         static const char* nameForRegister[16] = {
488             "r0", "r1", "r2", "r3",
489             "r4", "r5", "r6", "r7",
490             "r8", "r9", "r10", "r11",
491             "r12", "r13", "r14", "r15"
492         };
493         return nameForRegister[reg];
494     }
495 private:
496
497     static const unsigned InvalidIndex = 0xffffffff;
498 };
499
500 #endif
501
502 #if CPU(MIPS)
503 #define NUMBER_OF_ARGUMENT_REGISTERS 4
504
505 class GPRInfo {
506 public:
507     typedef GPRReg RegisterType;
508     static const unsigned numberOfRegisters = 6;
509     static const unsigned numberOfArgumentRegisters = NUMBER_OF_ARGUMENT_REGISTERS;
510
511     // Temporary registers.
512     static const GPRReg regT0 = MIPSRegisters::v0;
513     static const GPRReg regT1 = MIPSRegisters::v1;
514     static const GPRReg regT2 = MIPSRegisters::t4;
515     static const GPRReg regT3 = MIPSRegisters::t5;
516     static const GPRReg regT4 = MIPSRegisters::t6;
517     static const GPRReg regT5 = MIPSRegisters::t7;
518     // These registers match the baseline JIT.
519     static const GPRReg cachedResultRegister = regT0;
520     static const GPRReg cachedResultRegister2 = regT1;
521     static const GPRReg callFrameRegister = MIPSRegisters::s0;
522     // These constants provide the names for the general purpose argument & return value registers.
523     static const GPRReg argumentGPR0 = MIPSRegisters::a0;
524     static const GPRReg argumentGPR1 = MIPSRegisters::a1;
525     static const GPRReg argumentGPR2 = MIPSRegisters::a2;
526     static const GPRReg argumentGPR3 = MIPSRegisters::a3;
527     static const GPRReg nonArgGPR0 = regT2;
528     static const GPRReg nonArgGPR1 = regT3;
529     static const GPRReg nonArgGPR2 = regT4;
530     static const GPRReg returnValueGPR = regT0;
531     static const GPRReg returnValueGPR2 = regT1;
532     static const GPRReg nonPreservedNonReturnGPR = regT5;
533
534     static GPRReg toRegister(unsigned index)
535     {
536         ASSERT(index < numberOfRegisters);
537         static const GPRReg registerForIndex[numberOfRegisters] = { regT0, regT1, regT2, regT3, regT4, regT5 };
538         return registerForIndex[index];
539     }
540
541     static unsigned toIndex(GPRReg reg)
542     {
543         ASSERT(reg != InvalidGPRReg);
544         ASSERT(reg < 16);
545         static const unsigned indexForRegister[16] = { InvalidIndex, InvalidIndex, 0, 1, InvalidIndex, InvalidIndex, InvalidIndex, InvalidIndex, InvalidIndex, InvalidIndex, InvalidIndex, InvalidIndex, 2, 3, 4, 5 };
546         unsigned result = indexForRegister[reg];
547         ASSERT(result != InvalidIndex);
548         return result;
549     }
550
551     static const char* debugName(GPRReg reg)
552     {
553         ASSERT(reg != InvalidGPRReg);
554         ASSERT(reg < 16);
555         static const char* nameForRegister[16] = {
556             "zero", "at", "v0", "v1",
557             "a0", "a1", "a2", "a3",
558             "t0", "t1", "t2", "t3",
559             "t4", "t5", "t6", "t7"
560         };
561         return nameForRegister[reg];
562     }
563 private:
564
565     static const unsigned InvalidIndex = 0xffffffff;
566 };
567
568 #endif
569
570 #if CPU(SH4)
571 #define NUMBER_OF_ARGUMENT_REGISTERS 4
572
573 class GPRInfo {
574 public:
575     typedef GPRReg RegisterType;
576     static const unsigned numberOfRegisters = 10;
577
578     // Temporary registers.
579     static const GPRReg regT0 = SH4Registers::r0;
580     static const GPRReg regT1 = SH4Registers::r1;
581     static const GPRReg regT2 = SH4Registers::r2;
582     static const GPRReg regT3 = SH4Registers::r10;
583     static const GPRReg regT4 = SH4Registers::r4;
584     static const GPRReg regT5 = SH4Registers::r5;
585     static const GPRReg regT6 = SH4Registers::r6;
586     static const GPRReg regT7 = SH4Registers::r7;
587     static const GPRReg regT8 = SH4Registers::r8;
588     static const GPRReg regT9 = SH4Registers::r9;
589     // These registers match the baseline JIT.
590     static const GPRReg cachedResultRegister = regT0;
591     static const GPRReg cachedResultRegister2 = regT1;
592     static const GPRReg callFrameRegister = SH4Registers::fp;
593     // These constants provide the names for the general purpose argument & return value registers.
594     static const GPRReg argumentGPR0 = regT4;
595     static const GPRReg argumentGPR1 = regT5;
596     static const GPRReg argumentGPR2 = regT6;
597     static const GPRReg argumentGPR3 = regT7;
598     static const GPRReg nonArgGPR0 = regT3;
599     static const GPRReg nonArgGPR1 = regT8;
600     static const GPRReg nonArgGPR2 = regT9;
601     static const GPRReg returnValueGPR = regT0;
602     static const GPRReg returnValueGPR2 = regT1;
603     static const GPRReg nonPreservedNonReturnGPR = regT2;
604
605     static GPRReg toRegister(unsigned index)
606     {
607         ASSERT(index < numberOfRegisters);
608         static const GPRReg registerForIndex[numberOfRegisters] = { regT0, regT1, regT2, regT3, regT4, regT5, regT6, regT7, regT8, regT9 };
609         return registerForIndex[index];
610     }
611
612     static unsigned toIndex(GPRReg reg)
613     {
614         ASSERT(reg != InvalidGPRReg);
615         ASSERT(reg < 14);
616         static const unsigned indexForRegister[14] = { 0, 1, 2, InvalidIndex, 4, 5, 6, 7, 8, 9, 3, InvalidIndex, InvalidIndex, InvalidIndex };
617         unsigned result = indexForRegister[reg];
618         ASSERT(result != InvalidIndex);
619         return result;
620     }
621
622     static const char* debugName(GPRReg reg)
623     {
624         ASSERT(reg != InvalidGPRReg);
625         ASSERT(reg < 16);
626         static const char* nameForRegister[16] = {
627             "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
628             "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
629         };
630         return nameForRegister[reg];
631     }
632
633 private:
634     static const unsigned InvalidIndex = 0xffffffff;
635 };
636
637 #endif
638
639 typedef RegisterBank<GPRInfo>::iterator gpr_iterator;
640
641 } } // namespace JSC::DFG
642
643 #endif
644 #endif