ghc/includes/MachRegs.h

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