ghc/includes/MachRegs.h

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