ghc/includes/MachRegs.h

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