77efee1ac739180a61f13ea53e05509033c150ed
[ghc-hetmet.git] / ghc / includes / MachRegs.h
1 /* -----------------------------------------------------------------------------
2  *
3  * (c) The GHC Team, 1998-1999
4  *
5  * Registers used in STG code.  Might or might not correspond to
6  * actual machine registers.
7  *
8  * ---------------------------------------------------------------------------*/
9
10 #ifndef MACHREGS_H
11 #define MACHREGS_H
12
13 /* This file is #included into Haskell code in the compiler: #defines
14  * only in here please.
15  */
16
17 /* 
18  * Defining NO_REGS causes no global registers to be used.  NO_REGS is
19  * typically defined by GHC, via a command-line option passed to gcc,
20  * when the -funregisterised flag is given.
21  *
22  * NB. When NO_REGS is on, calling & return conventions may be
23  * different.  For example, all function arguments will be passed on
24  * the stack, and components of an unboxed tuple will be returned on
25  * the stack rather than in registers.
26  */
27 #ifndef NO_REGS
28
29 /* NOTE: when testing the platform in this file we must test either
30  * *_HOST_ARCH and *_TARGET_ARCH, depending on whether COMPILING_GHC
31  * is set.  This is because when we're compiling the RTS and HC code,
32  * the platform we're running on is the HOST, but when compiling GHC
33  * we want to know about the register mapping on the TARGET platform.
34  */
35 #ifdef COMPILING_GHC
36 #define alpha_REGS    alpha_TARGET_ARCH
37 #define hppa1_1_REGS  hppa1_1_TARGET_ARCH
38 #define i386_REGS     i386_TARGET_ARCH
39 #define x86_64_REGS   x86_64_TARGET_ARCH
40 #define m68k_REGS     m68k_TARGET_ARCH
41 #define mips_REGS     (mipsel_TARGET_ARCH || mipseb_TARGET_ARCH)
42 #define powerpc_REGS  (powerpc_TARGET_ARCH || powerpc64_TARGET_ARCH || rs6000_TARGET_ARCH)
43 #define ia64_REGS     ia64_TARGET_ARCH
44 #define sparc_REGS    sparc_TARGET_ARCH
45 #define darwin_REGS   darwin_TARGET_OS
46 #else
47 #define alpha_REGS    alpha_HOST_ARCH
48 #define hppa1_1_REGS  hppa1_1_HOST_ARCH
49 #define i386_REGS     i386_HOST_ARCH
50 #define x86_64_REGS   x86_64_HOST_ARCH
51 #define m68k_REGS     m68k_HOST_ARCH
52 #define mips_REGS     (mipsel_HOST_ARCH || mipseb_HOST_ARCH)
53 #define powerpc_REGS  (powerpc_HOST_ARCH || powerpc64_HOST_ARCH || rs6000_HOST_ARCH)
54 #define ia64_REGS     ia64_HOST_ARCH
55 #define sparc_REGS    sparc_HOST_ARCH
56 #define darwin_REGS   darwin_HOST_OS
57 #endif
58
59 /* ----------------------------------------------------------------------------
60    Caller saves and callee-saves regs.
61    
62    Caller-saves regs have to be saved around C-calls made from STG
63    land, so this file defines CALLER_SAVES_<reg> for each <reg> that
64    is designated caller-saves in that machine's C calling convention.
65
66    Additionally, the following macros should be defined when
67
68      CALLER_SAVES_USER          one or more of R<n>, F, D
69                                 are caller-saves.
70
71      CALLER_SAVES_SYSTEM        one or more of Sp, SpLim, Hp, HpLim
72                                 are caller-saves.
73
74    This is so that the callWrapper mechanism knows which kind of
75    wrapper to generate for certain types of C call.
76    -------------------------------------------------------------------------- */
77
78 /* -----------------------------------------------------------------------------
79    The DEC Alpha register mapping
80
81    Alpha registers
82    \tr{$9}--\tr{$14} are our ``prize'' callee-save registers.  
83    \tr{$15} is the frame pointer, and \tr{$16}--\tr{$21} are argument
84    registers.  (These are off-limits.)  We can steal some of the \tr{$22}-and-up 
85    caller-save registers provided we do the appropriate save/restore stuff.
86    
87    \tr{$f2}--\tr{$f9} are some callee-save floating-point registers.
88    
89    We cannot use \tr{$23} (aka t9), \tr{$24} (aka t10), \tr{$25} (aka
90    t11), \tr{$27} (aka pv), or \tr{$28} (aka at), because they are
91    occasionally required by the assembler to handle non-primitive
92    instructions (e.g. ldb, remq).  Sigh!
93    
94    Cheat sheet for GDB:
95    
96    GDB  here    Main map
97    ===  ====    ========
98    s5   $14     R1
99    t1   $2      R2
100    t2   $3      R3
101    t3   $4      R4
102    t4   $5      R5
103    t5   $6      R6
104    t6   $7      R7
105    t7   $8      R8
106    s0   $9      Sp
107    s2   $11     SpLim
108    s3   $12     Hp   
109    s4   $13     HpLim
110    t8   $22     NCG_reserved
111    t12  $27     NCG_reserved
112    -------------------------------------------------------------------------- */
113
114 #if alpha_REGS
115 # define REG(x) __asm__("$" #x)
116
117 #  define CALLER_SAVES_R2
118 #  define CALLER_SAVES_R3
119 #  define CALLER_SAVES_R4
120 #  define CALLER_SAVES_R5
121 #  define CALLER_SAVES_R6
122 #  define CALLER_SAVES_R7
123 #  define CALLER_SAVES_R8
124   
125 #  define CALLER_SAVES_USER
126   
127 #  define REG_R1        14
128 #  define REG_R2        2
129 #  define REG_R3        3
130 #  define REG_R4        4
131 #  define REG_R5        5
132 #  define REG_R6        6
133 #  define REG_R7        7
134 #  define REG_R8        8
135   
136 #  define REG_F1        f2
137 #  define REG_F2        f3
138 #  define REG_F3        f4
139 #  define REG_F4        f5
140   
141 #  define REG_D1        f6
142 #  define REG_D2        f7
143   
144 #  define REG_Sp        9
145 #  define REG_SpLim     11
146
147 #  define REG_Hp        12
148 #  define REG_HpLim     13
149   
150 #  define NCG_Reserved_I1 22
151 #  define NCG_Reserved_I2 27
152 #  define NCG_Reserved_F1 f29
153 #  define NCG_Reserved_F2 f30
154
155 #endif /* alpha_REGS */
156
157 /* -----------------------------------------------------------------------------
158    The HP-PA register mapping
159
160    We cater for HP-PA 1.1.
161    
162    \tr{%r0}--\tr{%r1} are special.
163    \tr{%r2} is the return pointer.
164    \tr{%r3} is the frame pointer.
165    \tr{%r4}--\tr{%r18} are callee-save registers.
166    \tr{%r19} is a linkage table register for HPUX 8.0 shared libraries.
167    \tr{%r20}--\tr{%r22} are caller-save registers.
168    \tr{%r23}--\tr{%r26} are parameter registers.
169    \tr{%r27} is a global data pointer.
170    \tr{%r28}--\tr{%r29} are temporaries.
171    \tr{%r30} is the stack pointer.
172    \tr{%r31} is a temporary.
173    
174    \tr{%fr12}--\tr{%fr15} are some callee-save floating-point registers.
175    \tr{%fr8}--\tr{%fr11} are some available caller-save fl-pt registers.
176    -------------------------------------------------------------------------- */
177
178 #if hppa1_1_REGS
179
180 #define REG(x) __asm__("%" #x)
181
182 #define REG_R1          r11
183 #define REG_R2          r12
184 #define REG_R3          r13
185 #define REG_R4          r14
186 #define REG_R5          r15
187 #define REG_R6          r16
188 #define REG_R7          r17
189 #define REG_R8          r18
190
191 #define REG_F1          fr12
192 #define REG_F2          fr12R
193 #define REG_F3          fr13
194 #define REG_F4          fr13R
195
196 #define REG_D1          fr20    /* L & R */
197 #define REG_D2          fr21    /* L & R */
198
199 #define REG_Sp          r4
200 #define REG_SpLim       r6
201
202 #define REG_Hp          r7
203 #define REG_HpLim       r8
204
205 #define NCG_Reserved_I1 r28
206 #define NCG_Reserved_I2 r29
207 #define NCG_Reserved_F1 fr8
208 #define NCG_Reserved_F2 fr8R
209 #define NCG_Reserved_D1 fr10
210 #define NCG_Reserved_D2 fr11
211
212 #endif /* hppa */
213
214 /* -----------------------------------------------------------------------------
215    The x86 register mapping
216
217    Ok, we've only got 6 general purpose registers, a frame pointer and a
218    stack pointer.  \tr{%eax} and \tr{%edx} are return values from C functions,
219    hence they get trashed across ccalls and are caller saves. \tr{%ebx},
220    \tr{%esi}, \tr{%edi}, \tr{%ebp} are all callee-saves.
221
222    Reg     STG-Reg
223    ---------------
224    ebx     Base
225    ebp     Sp
226    esi     R1
227    edi     Hp
228
229    Leaving SpLim, and HpLim out of the picture.
230    -------------------------------------------------------------------------- */
231
232
233 #if i386_REGS
234
235 #define REG(x) __asm__("%" #x)
236
237 #ifndef not_doing_dynamic_linking
238 #define REG_Base    ebx
239 #endif
240 #define REG_Sp      ebp
241
242 #ifndef STOLEN_X86_REGS
243 #define STOLEN_X86_REGS 4
244 #endif
245
246 #if STOLEN_X86_REGS >= 3
247 # define REG_R1     esi
248 #endif
249
250 #if STOLEN_X86_REGS >= 4
251 # define REG_Hp     edi
252 #endif
253
254 #define MAX_REAL_VANILLA_REG 1  /* always, since it defines the entry conv */
255 #define MAX_REAL_FLOAT_REG   0
256 #define MAX_REAL_DOUBLE_REG  0
257 #define MAX_REAL_LONG_REG    0
258
259 #endif /* iX86 */
260
261 /* -----------------------------------------------------------------------------
262   The x86-64 register mapping
263
264                 callee-saves
265   %rax
266   %rbx          YES
267   %rcx          arg reg, caller-saves
268   %rdx          arg reg, caller-saves
269   %rsi          arg reg, caller-saves
270   %rdi          arg reg, caller-saves
271   %rbp          YES (our *prime* register)
272   %rsp          (unavailable - stack pointer)
273   %r8           arg reg, caller-saves
274   %r9           arg reg, caller-saves
275   %r10          caller-saves
276   %r11          caller-saves
277   %r12          YES
278   %r13          YES
279   %r14          YES
280   %r15          YES
281
282   %xmm0-7       arg regs, caller-saves
283   %xmm8-15      caller-saves
284
285   A better reg mapping might be:
286
287       %rbp  Sp
288       %rbx  R1
289       %r8   R2
290       %r9   R3
291       %r10  R4
292       %r12  Hp
293       %r14  SpLim
294       %r15  HpLim
295       %xmm8-11   F1-F4
296       %xmm12-13  D1-D2
297
298   Use the caller-saves regs for Rn, because we don't always have to
299   save those (as opposed to Sp/Hp/SpLim etc. which always have to be
300   saved).
301
302   --------------------------------------------------------------------------- */
303
304 #if x86_64_REGS
305
306 #define REG(x) __asm__("%" #x)
307
308 #define REG_Base  rbx
309 #define REG_Sp    rbp
310 #define REG_Hp    r12
311 #define REG_R1    r13
312 #define REG_SpLim r14
313 #define REG_HpLim r15
314 /* ToDo: try R2/R3 instead of SpLim/HpLim? */
315
316 #define MAX_REAL_VANILLA_REG 1
317 #define MAX_REAL_FLOAT_REG   0
318 #define MAX_REAL_DOUBLE_REG  0
319 #define MAX_REAL_LONG_REG    0
320
321 #endif /* x86_64 */
322
323 /* -----------------------------------------------------------------------------
324    The Motorola 680x0 register mapping
325
326    A Sun3 (mc680x0) has eight address registers, \tr{a0} to \tr{a7}, and
327    eight data registers, \tr{d0} to \tr{d7}.  Address operations have to
328    be done through address registers; data registers are used for
329    comparison values and data.
330    
331    Here's the register-usage picture for m68k boxes with GCC.
332
333    \begin{tabular}{ll}
334    a0 & used directly by GCC \\
335    a1 & used directly by GCC \\
336    \\
337    a2..a5 & callee-saved: available for STG registers \\
338    & (a5 may be special, ``global'' register for PIC?) \\
339    \\
340    a6 & C-stack frame pointer \\
341    a7 & C-stack pointer \\
342    \\
343    d0 & used directly by GCC \\
344    d1 & used directly by GCC \\
345    d2 & really needed for local optimisation by GCC \\
346    \\
347    d3..d7 & callee-saved: available for STG registers
348    \\
349    fp0 & call-clobbered \\
350    fp1 & call-clobbered \\
351    fp2..fp7 & callee-saved: available for STG registers
352    \end{tabular}
353    -------------------------------------------------------------------------- */
354
355 #if m68k_REGS
356
357 #define REG(x) __asm__(#x)
358
359 #define REG_Base        a2
360
361 #define REG_Sp          a3
362 #define REG_SpLim       d3
363
364 #define REG_Hp          d4
365 #define REG_HpLim       d5
366
367 #define REG_R1          a5
368 #define REG_R2          d6
369 #define MAX_REAL_VANILLA_REG 2
370
371 #define REG_Ret         d7
372
373 #define REG_F1          fp2
374 #define REG_F2          fp3
375 #define REG_F3          fp4
376 #define REG_F4          fp5
377
378 #define REG_D1          fp6
379 #define REG_D2          fp7
380
381 #endif /* m68k */
382
383 /* -----------------------------------------------------------------------------
384    The DECstation (MIPS) register mapping
385
386    Here's at least some simple stuff about registers on a MIPS.
387    
388    \tr{s0}--\tr{s7} are callee-save integer registers; they are our
389    ``prize'' stolen registers.  There is also a wad of callee-save
390    floating-point registers, \tr{$f20}--\tr{$f31}; we'll use some of
391    those.
392    
393    \tr{t0}--\tr{t9} are caller-save (``temporary?'') integer registers.
394    We can steal some, but we might have to save/restore around ccalls.
395    -------------------------------------------------------------------------- */
396
397 #if mips_REGS
398
399 #define REG(x) __asm__("$" #x)
400
401 #define CALLER_SAVES_R1
402 #define CALLER_SAVES_R2
403 #define CALLER_SAVES_R3
404 #define CALLER_SAVES_R4
405 #define CALLER_SAVES_R5
406 #define CALLER_SAVES_R6
407 #define CALLER_SAVES_R7
408 #define CALLER_SAVES_R8
409
410 #define CALLER_SAVES_USER
411
412 #define REG_R1          9
413 #define REG_R2          10
414 #define REG_R3          11
415 #define REG_R4          12
416 #define REG_R5          13
417 #define REG_R6          14
418 #define REG_R7          15
419 #define REG_R8          24
420
421 #define REG_F1          f20
422 #define REG_F2          f22
423 #define REG_F3          f24
424 #define REG_F4          f26
425
426 #define REG_D1          f28
427 #define REG_D2          f30
428
429 #define REG_Sp          16
430 #define REG_SpLim       18
431
432 #define REG_Hp          19
433 #define REG_HpLim       20
434
435 #endif /* mipse[lb] */
436
437 /* -----------------------------------------------------------------------------
438    The PowerPC register mapping
439
440    0            system glue?    (caller-save, volatile)
441    1            SP              (callee-save, non-volatile)
442    2            AIX, powerpc64-linux:
443                     RTOC        (a strange special case)
444                 darwin:         
445                                 (caller-save, volatile)
446                 powerpc32-linux:
447                                 reserved for use by system
448                     
449    3-10         args/return     (caller-save, volatile)
450    11,12        system glue?    (caller-save, volatile)
451    13           on 64-bit:      reserved for thread state pointer
452                 on 32-bit:      (callee-save, non-volatile)
453    14-31                        (callee-save, non-volatile)
454    
455    f0                           (caller-save, volatile)
456    f1-f13       args/return     (caller-save, volatile)
457    f14-f31                      (callee-save, non-volatile)
458    
459    \tr{14}--\tr{31} are wonderful callee-save registers on all ppc OSes.
460    \tr{0}--\tr{12} are caller-save registers.
461    
462    \tr{%f14}--\tr{%f31} are callee-save floating-point registers.
463    
464    We can do the Whole Business with callee-save registers only!
465    -------------------------------------------------------------------------- */
466
467 #if powerpc_REGS
468
469 #define REG(x) __asm__(#x)
470
471 #define REG_R1          r14
472 #define REG_R2          r15
473 #define REG_R3          r16
474 #define REG_R4          r17
475 #define REG_R5          r18
476 #define REG_R6          r19
477 #define REG_R7          r20
478 #define REG_R8          r21
479
480 #if darwin_REGS
481
482 #define REG_F1          f14
483 #define REG_F2          f15
484 #define REG_F3          f16
485 #define REG_F4          f17
486
487 #define REG_D1          f18
488 #define REG_D2          f19
489
490 #else
491
492 #define REG_F1          fr14
493 #define REG_F2          fr15
494 #define REG_F3          fr16
495 #define REG_F4          fr17
496
497 #define REG_D1          fr18
498 #define REG_D2          fr19
499
500 #endif
501
502 #define REG_Sp          r22
503 #define REG_SpLim       r24
504
505 #define REG_Hp          r25
506 #define REG_HpLim       r26
507
508 #define REG_Base        r27
509
510 #endif /* powerpc */
511
512 /* -----------------------------------------------------------------------------
513    The IA64 register mapping
514
515    We place the general registers in the locals area of the register stack,
516    so that the call mechanism takes care of saving them for us.  We reserve
517    the first 16 for gcc's use - since gcc uses the highest used register to
518    determine the register stack frame size, this gives us a constant size
519    register stack frame.
520    
521    \tr{f16-f32} are the callee-saved floating point registers.
522    -------------------------------------------------------------------------- */
523
524 #if ia64_REGS
525
526 #define REG(x) __asm__(#x)
527
528 #define REG_R1          loc16
529 #define REG_R2          loc17
530 #define REG_R3          loc18
531 #define REG_R4          loc19
532 #define REG_R5          loc20
533 #define REG_R6          loc21
534 #define REG_R7          loc22
535 #define REG_R8          loc23
536
537 #define REG_F1          f16
538 #define REG_F2          f17
539 #define REG_F3          f18
540 #define REG_F4          f19
541
542 #define REG_D1          f20
543 #define REG_D2          f21
544
545 #define REG_Sp          loc24
546 #define REG_SpLim       loc26
547
548 #define REG_Hp          loc27
549 #define REG_HpLim       loc28
550
551 #endif /* ia64 */
552
553 /* -----------------------------------------------------------------------------
554    The Sun SPARC register mapping
555
556    The SPARC register (window) story: Remember, within the Haskell
557    Threaded World, we essentially ``shut down'' the register-window
558    mechanism---the window doesn't move at all while in this World.  It
559    *does* move, of course, if we call out to arbitrary~C...
560    
561    The %i, %l, and %o registers (8 each) are the input, local, and
562    output registers visible in one register window.  The 8 %g (global)
563    registers are visible all the time.
564    
565    %o0..%o7             not available; can be zapped by callee
566                           (%o6 is C-stack ptr; %o7 hold ret addrs)
567    %i0..%i7             available (except %i6 is used as frame ptr)
568                           (and %i7 tends to have ret-addr-ish things)
569    %l0..%l7             available
570    %g0..%g4             not available; prone to stomping by division, etc.
571    %g5..%g7             not available; reserved for the OS
572
573    Note: %g3 is *definitely* clobbered in the builtin divide code (and
574    our save/restore machinery is NOT GOOD ENOUGH for that); discretion
575    being the better part of valor, we also don't take %g4.
576
577    The paired nature of the floating point registers causes complications for
578    the native code generator.  For convenience, we pretend that the first 22
579    fp regs %f0 .. %f21 are actually 11 double regs, and the remaining 10 are
580    float (single) regs.  The NCG acts accordingly.  That means that the 
581    following FP assignment is rather fragile, and should only be changed
582    with extreme care.  The current scheme is:
583
584       %f0 /%f1    FP return from C
585       %f2 /%f3    D1
586       %f4 /%f5    D2
587       %f6 /%f7    ncg double spill tmp #1
588       %f8 /%f9    ncg double spill tmp #2
589       %f10/%f11   allocatable
590       %f12/%f13   allocatable
591       %f14/%f15   allocatable
592       %f16/%f17   allocatable
593       %f18/%f19   allocatable
594       %f20/%f21   allocatable
595
596       %f22        F1
597       %f23        F2
598       %f24        F3
599       %f25        F4
600       %f26        ncg single spill tmp #1
601       %f27        ncg single spill tmp #2
602       %f28        allocatable
603       %f29        allocatable
604       %f30        allocatable
605       %f31        allocatable
606
607    -------------------------------------------------------------------------- */
608
609 #if sparc_REGS
610
611 #define REG(x) __asm__("%" #x)
612
613 #define CALLER_SAVES_USER
614
615 #define CALLER_SAVES_F1
616 #define CALLER_SAVES_F2
617 #define CALLER_SAVES_F3
618 #define CALLER_SAVES_F4
619 #define CALLER_SAVES_D1
620 #define CALLER_SAVES_D2
621
622 #define REG_R1          l1
623 #define REG_R2          l2
624 #define REG_R3          l3
625 #define REG_R4          l4
626 #define REG_R5          l5
627 #define REG_R6          i5
628
629 #define REG_F1          f22
630 #define REG_F2          f23
631 #define REG_F3          f24
632 #define REG_F4          f25
633 #define REG_D1          f2
634 #define REG_D2          f4
635
636 #define REG_Sp          i0
637 #define REG_SpLim       i2
638
639 #define REG_Hp          i3
640 #define REG_HpLim       i4
641
642 #define NCG_SpillTmp_I1 g1
643 #define NCG_SpillTmp_I2 g2
644 #define NCG_SpillTmp_F1 f26
645 #define NCG_SpillTmp_F2 f27
646 #define NCG_SpillTmp_D1 f6
647 #define NCG_SpillTmp_D2 f8
648
649 #define NCG_FirstFloatReg f22
650
651 #endif /* sparc */
652
653 #endif /* NO_REGS */
654
655 /* -----------------------------------------------------------------------------
656  * These constants define how many stg registers will be used for
657  * passing arguments (and results, in the case of an unboxed-tuple
658  * return).
659  *
660  * We usually set MAX_REAL_VANILLA_REG and co. to be the number of the
661  * highest STG register to occupy a real machine register, otherwise
662  * the calling conventions will needlessly shuffle data between the
663  * stack and memory-resident STG registers.  We might occasionally
664  * set these macros to other values for testing, though.
665  *
666  * Registers above these values might still be used, for instance to
667  * communicate with PrimOps and RTS functions.
668  */
669
670 #ifndef MAX_REAL_VANILLA_REG
671 #  if   defined(REG_R8)
672 #  define MAX_REAL_VANILLA_REG 8
673 #  elif defined(REG_R7)
674 #  define MAX_REAL_VANILLA_REG 7
675 #  elif defined(REG_R6)
676 #  define MAX_REAL_VANILLA_REG 6
677 #  elif defined(REG_R5)
678 #  define MAX_REAL_VANILLA_REG 5
679 #  elif defined(REG_R4)
680 #  define MAX_REAL_VANILLA_REG 4
681 #  elif defined(REG_R3)
682 #  define MAX_REAL_VANILLA_REG 3
683 #  elif defined(REG_R2)
684 #  define MAX_REAL_VANILLA_REG 2
685 #  elif defined(REG_R1)
686 #  define MAX_REAL_VANILLA_REG 1
687 #  else
688 #  define MAX_REAL_VANILLA_REG 0
689 #  endif
690 #endif
691
692 #ifndef MAX_REAL_FLOAT_REG
693 #  if   defined(REG_F4)
694 #  define MAX_REAL_FLOAT_REG 4
695 #  elif defined(REG_F3)
696 #  define MAX_REAL_FLOAT_REG 3
697 #  elif defined(REG_F2)
698 #  define MAX_REAL_FLOAT_REG 2
699 #  elif defined(REG_F1)
700 #  define MAX_REAL_FLOAT_REG 1
701 #  else
702 #  define MAX_REAL_FLOAT_REG 0
703 #  endif
704 #endif
705
706 #ifndef MAX_REAL_DOUBLE_REG
707 #  if   defined(REG_D2)
708 #  define MAX_REAL_DOUBLE_REG 2
709 #  elif defined(REG_D1)
710 #  define MAX_REAL_DOUBLE_REG 1
711 #  else
712 #  define MAX_REAL_DOUBLE_REG 0
713 #  endif
714 #endif
715
716 #ifndef MAX_REAL_LONG_REG
717 #  if   defined(REG_L1)
718 #  define MAX_REAL_LONG_REG 1
719 #  else
720 #  define MAX_REAL_LONG_REG 0
721 #  endif
722 #endif
723
724 /* define NO_ARG_REGS if we have no argument registers at all (we can
725  * optimise certain code paths using this predicate).
726  */
727 #if MAX_REAL_VANILLA_REG < 2
728 #define NO_ARG_REGS 
729 #else
730 #undef NO_ARG_REGS
731 #endif
732
733 #endif /* MACHREGS_H */