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          l6
 628 #define REG_R7          l7
 629 #define REG_R8          i5
 630
 631 #define REG_F1          f22
 632 #define REG_F2          f23
 633 #define REG_F3          f24
 634 #define REG_F4          f25
 635 #define REG_D1          f2
 636 #define REG_D2          f4
 637
 638 #define REG_Sp          i0
 639 #define REG_SpLim       i2
 640
 641 #define REG_Hp          i3
 642 #define REG_HpLim       i4
 643
 644 #define NCG_SpillTmp_I1 g1
 645 #define NCG_SpillTmp_I2 g2
 646 #define NCG_SpillTmp_F1 f26
 647 #define NCG_SpillTmp_F2 f27
 648 #define NCG_SpillTmp_D1 f6
 649 #define NCG_SpillTmp_D2 f8
 650
 651 #define NCG_FirstFloatReg f22
 652
 653 #endif /* sparc */
 654
 655 #endif /* NO_REGS */
 656
 657 /* -----------------------------------------------------------------------------
 658  * These constants define how many stg registers will be used for
 659  * passing arguments (and results, in the case of an unboxed-tuple
 660  * return).
 661  *
 662  * We usually set MAX_REAL_VANILLA_REG and co. to be the number of the
 663  * highest STG register to occupy a real machine register, otherwise
 664  * the calling conventions will needlessly shuffle data between the
 665  * stack and memory-resident STG registers.  We might occasionally
 666  * set these macros to other values for testing, though.
 667  *
 668  * Registers above these values might still be used, for instance to
 669  * communicate with PrimOps and RTS functions.
 670  */
 671
 672 #ifndef MAX_REAL_VANILLA_REG
 673 #  if   defined(REG_R8)
 674 #  define MAX_REAL_VANILLA_REG 8
 675 #  elif defined(REG_R7)
 676 #  define MAX_REAL_VANILLA_REG 7
 677 #  elif defined(REG_R6)
 678 #  define MAX_REAL_VANILLA_REG 6
 679 #  elif defined(REG_R5)
 680 #  define MAX_REAL_VANILLA_REG 5
 681 #  elif defined(REG_R4)
 682 #  define MAX_REAL_VANILLA_REG 4
 683 #  elif defined(REG_R3)
 684 #  define MAX_REAL_VANILLA_REG 3
 685 #  elif defined(REG_R2)
 686 #  define MAX_REAL_VANILLA_REG 2
 687 #  elif defined(REG_R1)
 688 #  define MAX_REAL_VANILLA_REG 1
 689 #  else
 690 #  define MAX_REAL_VANILLA_REG 0
 691 #  endif
 692 #endif
 693
 694 #ifndef MAX_REAL_FLOAT_REG
 695 #  if   defined(REG_F4)
 696 #  define MAX_REAL_FLOAT_REG 4
 697 #  elif defined(REG_F3)
 698 #  define MAX_REAL_FLOAT_REG 3
 699 #  elif defined(REG_F2)
 700 #  define MAX_REAL_FLOAT_REG 2
 701 #  elif defined(REG_F1)
 702 #  define MAX_REAL_FLOAT_REG 1
 703 #  else
 704 #  define MAX_REAL_FLOAT_REG 0
 705 #  endif
 706 #endif
 707
 708 #ifndef MAX_REAL_DOUBLE_REG
 709 #  if   defined(REG_D2)
 710 #  define MAX_REAL_DOUBLE_REG 2
 711 #  elif defined(REG_D1)
 712 #  define MAX_REAL_DOUBLE_REG 1
 713 #  else
 714 #  define MAX_REAL_DOUBLE_REG 0
 715 #  endif
 716 #endif
 717
 718 #ifndef MAX_REAL_LONG_REG
 719 #  if   defined(REG_L1)
 720 #  define MAX_REAL_LONG_REG 1
 721 #  else
 722 #  define MAX_REAL_LONG_REG 0
 723 #  endif
 724 #endif
 725
 726 /* define NO_ARG_REGS if we have no argument registers at all (we can
 727  * optimise certain code paths using this predicate).
 728  */
 729 #if MAX_REAL_VANILLA_REG < 2
 730 #define NO_ARG_REGS
 731 #else
 732 #undef NO_ARG_REGS
 733 #endif
 734
 735 #endif /* MACHREGS_H */