ghc/includes/MachRegs.h

   1 /* -----------------------------------------------------------------------------
   2  * $Id: MachRegs.h,v 1.13 2002/12/11 15:36:37 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 /* 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 Motorola 680x0 register mapping
 224
 225    A Sun3 (mc680x0) has eight address registers, \tr{a0} to \tr{a7}, and
 226    eight data registers, \tr{d0} to \tr{d7}.  Address operations have to
 227    be done through address registers; data registers are used for
 228    comparison values and data.
 229
 230    Here's the register-usage picture for m68k boxes with GCC.
 231
 232    \begin{tabular}{ll}
 233    a0 & used directly by GCC \\
 234    a1 & used directly by GCC \\
 235    \\
 236    a2..a5 & callee-saved: available for STG registers \\
 237    & (a5 may be special, ``global'' register for PIC?) \\
 238    \\
 239    a6 & C-stack frame pointer \\
 240    a7 & C-stack pointer \\
 241    \\
 242    d0 & used directly by GCC \\
 243    d1 & used directly by GCC \\
 244    d2 & really needed for local optimisation by GCC \\
 245    \\
 246    d3..d7 & callee-saved: available for STG registers
 247    \\
 248    fp0 & call-clobbered \\
 249    fp1 & call-clobbered \\
 250    fp2..fp7 & callee-saved: available for STG registers
 251    \end{tabular}
 252    -------------------------------------------------------------------------- */
 253
 254 #if m68k_TARGET_ARCH
 255
 256 #define REG(x) __asm__(#x)
 257
 258 #define REG_Base        a2
 259
 260 #define REG_Sp          a3
 261 #define REG_SpLim       d3
 262
 263 #define REG_Hp          d4
 264 #define REG_HpLim       d5
 265
 266 #define REG_R1          a5
 267 #define REG_R2          d6
 268 #define MAX_REAL_VANILLA_REG 2
 269
 270 #define REG_Ret         d7
 271
 272 #define REG_F1          fp2
 273 #define REG_F2          fp3
 274 #define REG_F3          fp4
 275 #define REG_F4          fp5
 276
 277 #define REG_D1          fp6
 278 #define REG_D2          fp7
 279
 280 #endif /* m68k */
 281
 282 /* -----------------------------------------------------------------------------
 283    The DECstation (MIPS) register mapping
 284
 285    Here's at least some simple stuff about registers on a MIPS.
 286
 287    \tr{s0}--\tr{s7} are callee-save integer registers; they are our
 288    ``prize'' stolen registers.  There is also a wad of callee-save
 289    floating-point registers, \tr{$f20}--\tr{$f31}; we'll use some of
 290    those.
 291
 292    \tr{t0}--\tr{t9} are caller-save (``temporary?'') integer registers.
 293    We can steal some, but we might have to save/restore around ccalls.
 294    -------------------------------------------------------------------------- */
 295
 296 #if mipsel_TARGET_ARCH || mipseb_TARGET_ARCH
 297
 298 #define REG(x) __asm__("$" #x)
 299
 300 #define CALLER_SAVES_R1
 301 #define CALLER_SAVES_R2
 302 #define CALLER_SAVES_R3
 303 #define CALLER_SAVES_R4
 304 #define CALLER_SAVES_R5
 305 #define CALLER_SAVES_R6
 306 #define CALLER_SAVES_R7
 307 #define CALLER_SAVES_R8
 308
 309 #define CALLER_SAVES_USER
 310
 311 #define REG_R1          9
 312 #define REG_R2          10
 313 #define REG_R3          11
 314 #define REG_R4          12
 315 #define REG_R5          13
 316 #define REG_R6          14
 317 #define REG_R7          15
 318 #define REG_R8          24
 319
 320 #define REG_F1          f20
 321 #define REG_F2          f22
 322 #define REG_F3          f24
 323 #define REG_F4          f26
 324
 325 #define REG_D1          f28
 326 #define REG_D2          f30
 327
 328 #define REG_Sp          16
 329 #define REG_SpLim       18
 330
 331 #define REG_Hp          19
 332 #define REG_HpLim       20
 333
 334 #endif /* mipse[lb] */
 335
 336 /* -----------------------------------------------------------------------------
 337    The PowerPC register mapping
 338
 339    0            system glue?    (caller-save, volatile)
 340    1            SP              (callee-save, non-volatile)
 341    2            RTOC            (callee-save, non-volatile)
 342    3-10         args/return     (caller-save, volatile)
 343    11,12        system glue?    (caller-save, volatile)
 344    13-31                        (callee-save, non-volatile)
 345
 346    f0                           (caller-save, volatile)
 347    f1-f13       args/return     (caller-save, volatile)
 348    f14-f31                      (callee-save, non-volatile)
 349
 350    \tr{13}--\tr{31} are wonderful callee-save registers.
 351    \tr{0}--\tr{12} are caller-save registers.
 352
 353    \tr{%f14}--\tr{%f31} are callee-save floating-point registers.
 354
 355    I think we can do the Whole Business with callee-save registers only!
 356    -------------------------------------------------------------------------- */
 357
 358 #if powerpc_TARGET_ARCH || rs6000_TARGET_ARCH
 359
 360 #define REG(x) __asm__(#x)
 361
 362 #define REG_R1          r14
 363 #define REG_R2          r15
 364 #define REG_R3          r16
 365 #define REG_R4          r17
 366 #define REG_R5          r18
 367 #define REG_R6          r19
 368 #define REG_R7          r20
 369 #define REG_R8          r21
 370
 371 #define REG_F1          f14
 372 #define REG_F2          f15
 373 #define REG_F3          f16
 374 #define REG_F4          f17
 375
 376 #define REG_D1          f18
 377 #define REG_D2          f19
 378
 379 #define REG_Sp          r22
 380 #define REG_SpLim       r24
 381
 382 #define REG_Hp          r25
 383 #define REG_HpLim       r26
 384
 385 #define NCG_SpillTmp_I1 r27
 386 #define NCG_SpillTmp_I2 r28
 387
 388 #define NCG_SpillTmp_D1 f20
 389 #define NCG_SpillTmp_D2 f21
 390
 391 #endif /* powerpc */
 392
 393 /* -----------------------------------------------------------------------------
 394    The IA64 register mapping
 395
 396    We place the general registers in the locals area of the register stack,
 397    so that the call mechanism takes care of saving them for us.  We reserve
 398    the first 16 for gcc's use - since gcc uses the highest used register to
 399    determine the register stack frame size, this gives us a constant size
 400    register stack frame.
 401
 402    \tr{f16-f32} are the callee-saved floating point registers.
 403    -------------------------------------------------------------------------- */
 404
 405 #ifdef ia64_TARGET_ARCH
 406
 407 #define REG(x) __asm__(#x)
 408
 409 #define REG_R1          loc16
 410 #define REG_R2          loc17
 411 #define REG_R3          loc18
 412 #define REG_R4          loc19
 413 #define REG_R5          loc20
 414 #define REG_R6          loc21
 415 #define REG_R7          loc22
 416 #define REG_R8          loc23
 417
 418 #define REG_F1          f16
 419 #define REG_F2          f17
 420 #define REG_F3          f18
 421 #define REG_F4          f19
 422
 423 #define REG_D1          f20
 424 #define REG_D2          f21
 425
 426 #define REG_Sp          loc24
 427 #define REG_SpLim       loc26
 428
 429 #define REG_Hp          loc27
 430 #define REG_HpLim       loc28
 431
 432 #endif /* ia64 */
 433
 434 /* -----------------------------------------------------------------------------
 435    The Sun SPARC register mapping
 436
 437    The SPARC register (window) story: Remember, within the Haskell
 438    Threaded World, we essentially ``shut down'' the register-window
 439    mechanism---the window doesn't move at all while in this World.  It
 440    *does* move, of course, if we call out to arbitrary~C...
 441
 442    The %i, %l, and %o registers (8 each) are the input, local, and
 443    output registers visible in one register window.  The 8 %g (global)
 444    registers are visible all the time.
 445
 446    %o0..%o7             not available; can be zapped by callee
 447                           (%o6 is C-stack ptr; %o7 hold ret addrs)
 448    %i0..%i7             available (except %i6 is used as frame ptr)
 449                           (and %i7 tends to have ret-addr-ish things)
 450    %l0..%l7             available
 451    %g0..%g4             not available; prone to stomping by division, etc.
 452    %g5..%g7             not available; reserved for the OS
 453
 454    Note: %g3 is *definitely* clobbered in the builtin divide code (and
 455    our save/restore machinery is NOT GOOD ENOUGH for that); discretion
 456    being the better part of valor, we also don't take %g4.
 457
 458    The paired nature of the floating point registers causes complications for
 459    the native code generator.  For convenience, we pretend that the first 22
 460    fp regs %f0 .. %f21 are actually 11 double regs, and the remaining 10 are
 461    float (single) regs.  The NCG acts accordingly.  That means that the
 462    following FP assignment is rather fragile, and should only be changed
 463    with extreme care.  The current scheme is:
 464
 465       %f0 /%f1    FP return from C
 466       %f2 /%f3    D1
 467       %f4 /%f5    D2
 468       %f6 /%f7    ncg double spill tmp #1
 469       %f8 /%f9    ncg double spill tmp #2
 470       %f10/%f11   allocatable
 471       %f12/%f13   allocatable
 472       %f14/%f15   allocatable
 473       %f16/%f17   allocatable
 474       %f18/%f19   allocatable
 475       %f20/%f21   allocatable
 476
 477       %f22        F1
 478       %f23        F2
 479       %f24        F3
 480       %f25        F4
 481       %f26        ncg single spill tmp #1
 482       %f27        ncg single spill tmp #2
 483       %f28        allocatable
 484       %f29        allocatable
 485       %f30        allocatable
 486       %f31        allocatable
 487
 488    -------------------------------------------------------------------------- */
 489
 490 #if sparc_TARGET_ARCH
 491
 492 #define REG(x) __asm__("%" #x)
 493
 494 #define CALLER_SAVES_USER
 495
 496 #define CALLER_SAVES_F1
 497 #define CALLER_SAVES_F2
 498 #define CALLER_SAVES_F3
 499 #define CALLER_SAVES_F4
 500 #define CALLER_SAVES_D1
 501 #define CALLER_SAVES_D2
 502
 503 #define REG_R1          l1
 504 #define REG_R2          l2
 505 #define REG_R3          l3
 506 #define REG_R4          l4
 507 #define REG_R5          l5
 508 #define REG_R6          l6
 509 #define REG_R7          l7
 510 #define REG_R8          i5
 511
 512 #define REG_F1          f22
 513 #define REG_F2          f23
 514 #define REG_F3          f24
 515 #define REG_F4          f25
 516 #define REG_D1          f2
 517 #define REG_D2          f4
 518
 519 #define REG_Sp          i0
 520 #define REG_SpLim       i2
 521
 522 #define REG_Hp          i3
 523 #define REG_HpLim       i4
 524
 525 #define NCG_SpillTmp_I1 g1
 526 #define NCG_SpillTmp_I2 g2
 527 #define NCG_SpillTmp_F1 f26
 528 #define NCG_SpillTmp_F2 f27
 529 #define NCG_SpillTmp_D1 f6
 530 #define NCG_SpillTmp_D2 f8
 531
 532 #define NCG_FirstFloatReg f22
 533
 534 #endif /* sparc */
 535
 536 #endif /* NO_REGS */
 537
 538 /* -----------------------------------------------------------------------------
 539  * These constants define how many stg registers will be used for
 540  * passing arguments (and results, in the case of an unboxed-tuple
 541  * return).
 542  *
 543  * We usually set MAX_REAL_VANILLA_REG and co. to be the number of the
 544  * highest STG register to occupy a real machine register, otherwise
 545  * the calling conventions will needlessly shuffle data between the
 546  * stack and memory-resident STG registers.  We might occasionally
 547  * set these macros to other values for testing, though.
 548  *
 549  * Registers above these values might still be used, for instance to
 550  * communicate with PrimOps and RTS functions.
 551  */
 552
 553 #ifndef MAX_REAL_VANILLA_REG
 554 #  if   defined(REG_R8)
 555 #  define MAX_REAL_VANILLA_REG 8
 556 #  elif defined(REG_R7)
 557 #  define MAX_REAL_VANILLA_REG 7
 558 #  elif defined(REG_R6)
 559 #  define MAX_REAL_VANILLA_REG 6
 560 #  elif defined(REG_R5)
 561 #  define MAX_REAL_VANILLA_REG 5
 562 #  elif defined(REG_R4)
 563 #  define MAX_REAL_VANILLA_REG 4
 564 #  elif defined(REG_R3)
 565 #  define MAX_REAL_VANILLA_REG 3
 566 #  elif defined(REG_R2)
 567 #  define MAX_REAL_VANILLA_REG 2
 568 #  elif defined(REG_R1)
 569 #  define MAX_REAL_VANILLA_REG 1
 570 #  else
 571 #  define MAX_REAL_VANILLA_REG 0
 572 #  endif
 573 #endif
 574
 575 #ifndef MAX_REAL_FLOAT_REG
 576 #  if   defined(REG_F4)
 577 #  define MAX_REAL_FLOAT_REG 4
 578 #  elif defined(REG_F3)
 579 #  define MAX_REAL_FLOAT_REG 3
 580 #  elif defined(REG_F2)
 581 #  define MAX_REAL_FLOAT_REG 2
 582 #  elif defined(REG_F1)
 583 #  define MAX_REAL_FLOAT_REG 1
 584 #  else
 585 #  define MAX_REAL_FLOAT_REG 0
 586 #  endif
 587 #endif
 588
 589 #ifndef MAX_REAL_DOUBLE_REG
 590 #  if   defined(REG_D2)
 591 #  define MAX_REAL_DOUBLE_REG 2
 592 #  elif defined(REG_D1)
 593 #  define MAX_REAL_DOUBLE_REG 1
 594 #  else
 595 #  define MAX_REAL_DOUBLE_REG 0
 596 #  endif
 597 #endif
 598
 599 #ifndef MAX_REAL_LONG_REG
 600 #  if   defined(REG_L1)
 601 #  define MAX_REAL_LONG_REG 1
 602 #  else
 603 #  define MAX_REAL_LONG_REG 0
 604 #  endif
 605 #endif
 606
 607 /* define NO_ARG_REGS if we have no argument registers at all (we can
 608  * optimise certain code paths using this predicate).
 609  */
 610 #if MAX_REAL_VANILLA_REG < 2
 611 #define NO_ARG_REGS
 612 #else
 613 #undef NO_ARG_REGS
 614 #endif
 615
 616 #endif /* MACHREGS_H */