ghc/includes/MachRegs.h

   1 /* -----------------------------------------------------------------------------
   2  * $Id: MachRegs.h,v 1.3 1999/01/18 14:31:50 sof Exp $
   3  *
   4  * Registers used in STG code.  Might or might not correspond to
   5  * actual machine registers.
   6  *
   7  * ---------------------------------------------------------------------------*/
   8
   9 #ifndef MACHREGS_H
  10 #define MACHREGS_H
  11
  12 /* This file is #included into Haskell code in the compiler: #defines
  13  * only in here please.
  14  */
  15
  16 /* define NO_REGS to omit register declarations - used in RTS C code
  17  * that needs all the STG definitions but not the global register
  18  * settings.
  19  */
  20 #ifndef NO_REGS
  21
  22 /* ----------------------------------------------------------------------------
  23    Caller saves and callee-saves regs.
  24
  25    Caller-saves regs have to be saved around C-calls made from STG
  26    land, so this file defines CALLER_SAVES_<reg> for each <reg> that
  27    is designated caller-saves in that machine's C calling convention.
  28
  29    Additionally, the following macros should be defined when
  30
  31      CALLER_SAVES_USER          one or more of R<n>, F, D
  32                                 are caller-saves.
  33
  34      CALLER_SAVES_SYSTEM        one or more of Sp, Su, SpLim, Hp, HpLim
  35                                 are caller-saves.
  36
  37    This is so that the callWrapper mechanism knows which kind of
  38    wrapper to generate for certain types of C call.
  39    -------------------------------------------------------------------------- */
  40
  41 /* -----------------------------------------------------------------------------
  42    The DEC Alpha register mapping
  43
  44    Alpha registers
  45    \tr{$9}--\tr{$14} are our ``prize'' callee-save registers.
  46    \tr{$15} is the frame pointer, and \tr{$16}--\tr{$21} are argument
  47    registers.  (These are off-limits.)  We can steal some of the \tr{$22}-and-up
  48    caller-save registers provided we do the appropriate save/restore stuff.
  49
  50    \tr{$f2}--\tr{$f9} are some callee-save floating-point registers.
  51
  52    We cannot use \tr{$23} (aka t9), \tr{$24} (aka t10), \tr{$25} (aka
  53    t11), \tr{$27} (aka pv), or \tr{$28} (aka at), because they are
  54    occasionally required by the assembler to handle non-primitive
  55    instructions (e.g. ldb, remq).  Sigh!
  56
  57    Cheat sheet for GDB:
  58
  59    GDB  here    Main map
  60    ===  ====    ========
  61    s5   $14     R1
  62    t1   $2      R2
  63    t2   $3      R3
  64    t3   $4      R4
  65    t4   $5      R5
  66    t5   $6      R6
  67    t6   $7      R7
  68    t7   $8      R8
  69    s0   $9      Sp
  70    s1   $10     Su
  71    s2   $11     SpLim
  72    s3   $12     Hp
  73    s4   $13     HpLim
  74    t8   $22     NCG_reserved
  75    t12  $27     NCG_reserved
  76    -------------------------------------------------------------------------- */
  77
  78 #if defined(alpha_TARGET_ARCH)
  79 # define REG(x) __asm__("$" #x)
  80
  81 #  define CALLER_SAVES_R2
  82 #  define CALLER_SAVES_R3
  83 #  define CALLER_SAVES_R4
  84 #  define CALLER_SAVES_R5
  85 #  define CALLER_SAVES_R6
  86 #  define CALLER_SAVES_R7
  87 #  define CALLER_SAVES_R8
  88
  89 #  define CALLER_SAVES_USER
  90
  91 #  define REG_R1        14
  92 #  define REG_R2        2
  93 #  define REG_R3        3
  94 #  define REG_R4        4
  95 #  define REG_R5        5
  96 #  define REG_R6        6
  97 #  define REG_R7        7
  98 #  define REG_R8        8
  99
 100 #  define REG_F1        f2
 101 #  define REG_F2        f3
 102 #  define REG_F3        f4
 103 #  define REG_F4        f5
 104
 105 #  define REG_D1        f6
 106 #  define REG_D2        f7
 107
 108 #  define REG_Sp        9
 109 #  define REG_Su        10
 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_Su          r5
 166 #define REG_SpLim       r6
 167
 168 #define REG_Hp          r7
 169 #define REG_HpLim       r8
 170
 171 #define NCG_Reserved_I1 r28
 172 #define NCG_Reserved_I2 r29
 173 #define NCG_Reserved_F1 fr8
 174 #define NCG_Reserved_F2 fr8R
 175 #define NCG_Reserved_D1 fr10
 176 #define NCG_Reserved_D2 fr11
 177
 178 #endif /* hppa */
 179
 180 /* -----------------------------------------------------------------------------
 181    The Intel iX86 register mapping
 182
 183    Ok, we've only got 6 general purpose registers, a frame pointer and a
 184    stack pointer.  \tr{%eax} and \tr{%edx} are return values from C functions,
 185    hence they get trashed across ccalls and are caller saves. \tr{%ebx},
 186    \tr{%esi}, \tr{%edi}, \tr{%ebp} are all callee-saves.
 187
 188    Reg     STG-Reg
 189    ---------------
 190    ebx     Base
 191    ebp     Sp
 192    esi     R1
 193    edi     Hp
 194
 195    Leaving Su, SpLim, and HpLim out of the picture.
 196    -------------------------------------------------------------------------- */
 197
 198
 199 #if i386_TARGET_ARCH
 200
 201 #define REG(x) __asm__("%" #x)
 202
 203 #define REG_Base    ebx
 204 #define REG_Sp      ebp
 205
 206 #if STOLEN_X86_REGS >= 3
 207 # define REG_R1     esi
 208 #endif
 209
 210 #if STOLEN_X86_REGS >= 4
 211 # define REG_Hp     edi
 212 #endif
 213
 214 #define MAX_REAL_VANILLA_REG 1  /* always, since it defines the entry conv */
 215 #define MAX_REAL_FLOAT_REG   0
 216 #define MAX_REAL_DOUBLE_REG  0
 217 #define MAX_REAL_LONG_REG    0
 218
 219 #endif /* iX86 */
 220
 221 /* -----------------------------------------------------------------------------
 222    The Motorola 680x0 register mapping
 223
 224    A Sun3 (mc680x0) has eight address registers, \tr{a0} to \tr{a7}, and
 225    eight data registers, \tr{d0} to \tr{d7}.  Address operations have to
 226    be done through address registers; data registers are used for
 227    comparison values and data.
 228
 229    Here's the register-usage picture for m68k boxes with GCC.
 230
 231    \begin{tabular}{ll}
 232    a0 & used directly by GCC \\
 233    a1 & used directly by GCC \\
 234    \\
 235    a2..a5 & callee-saved: available for STG registers \\
 236    & (a5 may be special, ``global'' register for PIC?) \\
 237    \\
 238    a6 & C-stack frame pointer \\
 239    a7 & C-stack pointer \\
 240    \\
 241    d0 & used directly by GCC \\
 242    d1 & used directly by GCC \\
 243    d2 & really needed for local optimisation by GCC \\
 244    \\
 245    d3..d7 & callee-saved: available for STG registers
 246    \\
 247    fp0 & call-clobbered \\
 248    fp1 & call-clobbered \\
 249    fp2..fp7 & callee-saved: available for STG registers
 250    \end{tabular}
 251    -------------------------------------------------------------------------- */
 252
 253 #if m68k_TARGET_ARCH
 254
 255 #define REG(x) __asm__(#x)
 256
 257 #define REG_Base        a2
 258
 259 #define REG_Sp          a3
 260 #define REG_Su          a4
 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_Su          17
 330 #define REG_SpLim       18
 331
 332 #define REG_Hp          19
 333 #define REG_HpLim       20
 334
 335 #endif /* mipse[lb] */
 336
 337 /* -----------------------------------------------------------------------------
 338    The PowerPC register mapping
 339
 340    0            system glue?    (caller-save, volatile)
 341    1            SP              (callee-save, non-volatile)
 342    2            RTOC            (callee-save, non-volatile)
 343    3-10         args/return     (caller-save, volatile)
 344    11,12        system glue?    (caller-save, volatile)
 345    13-31                        (callee-save, non-volatile)
 346
 347    f0                           (caller-save, volatile)
 348    f1-f13       args/return     (caller-save, volatile)
 349    f14-f31                      (callee-save, non-volatile)
 350
 351    \tr{13}--\tr{31} are wonderful callee-save registers.
 352    \tr{0}--\tr{12} are caller-save registers.
 353
 354    \tr{%f14}--\tr{%f31} are callee-save floating-point registers.
 355
 356    I think we can do the Whole Business with callee-save registers only!
 357    -------------------------------------------------------------------------- */
 358
 359 #if powerpc_TARGET_ARCH || rs6000_TARGET_ARCH
 360
 361 #define REG(x) __asm__(#x)
 362
 363 #define REG_R1          r14
 364 #define REG_R2          r15
 365 #define REG_R3          r16
 366 #define REG_R4          r17
 367 #define REG_R5          r18
 368 #define REG_R6          r19
 369 #define REG_R7          r20
 370 #define REG_R8          r21
 371
 372 #define REG_F1          fr14
 373 #define REG_F2          fr15
 374 #define REG_F3          fr16
 375 #define REG_F4          fr17
 376
 377 #define REG_D1          fr18
 378 #define REG_D2          fr19
 379
 380 #define REG_Sp          r22
 381 #define REG_Su          r23
 382 #define REG_SpLim       r24
 383
 384 #define REG_Hp          r25
 385 #define REG_HpLim       r26
 386
 387 #endif /* powerpc */
 388
 389 /* -----------------------------------------------------------------------------
 390    The Sun SPARC register mapping
 391
 392    The SPARC register (window) story: Remember, within the Haskell
 393    Threaded World, we essentially ``shut down'' the register-window
 394    mechanism---the window doesn't move at all while in this World.  It
 395    *does* move, of course, if we call out to arbitrary~C...
 396
 397    The %i, %l, and %o registers (8 each) are the input, local, and
 398    output registers visible in one register window.  The 8 %g (global)
 399    registers are visible all the time.
 400
 401    %o0..%o7             not available; can be zapped by callee
 402                           (%o6 is C-stack ptr; %o7 hold ret addrs)
 403    %i0..%i7             available (except %i6 is used as frame ptr)
 404                           (and %i7 tends to have ret-addr-ish things)
 405    %l0..%l7             available
 406    %g0..%g4             not available; prone to stomping by division, etc.
 407    %g5..%g7             not available; reserved for the OS
 408
 409    Note: %g3 is *definitely* clobbered in the builtin divide code (and
 410    our save/restore machinery is NOT GOOD ENOUGH for that); discretion
 411    being the better part of valor, we also don't take %g4.
 412    -------------------------------------------------------------------------- */
 413
 414 #if sparc_TARGET_ARCH
 415
 416 #define REG(x) __asm__("%" #x)
 417
 418 #define CALLER_SAVES_USER
 419
 420 #define CALLER_SAVES_F1
 421 #define CALLER_SAVES_F2
 422 #define CALLER_SAVES_F3
 423 #define CALLER_SAVES_F4
 424 #define CALLER_SAVES_D1
 425 #define CALLER_SAVES_D2
 426
 427 #define REG_R1          l1
 428 #define REG_R2          l2
 429 #define REG_R3          l3
 430 #define REG_R4          l4
 431 #define REG_R5          l5
 432 #define REG_R6          l6
 433 #define REG_R7          l7
 434 #define REG_R8          i5
 435
 436 #define REG_F1          f2
 437 #define REG_F2          f3
 438 #define REG_F3          f4
 439 #define REG_F4          f5
 440 #define REG_D1          f6
 441 #define REG_D2          f8
 442
 443 #define REG_Sp          i0
 444 #define REG_Su          i1
 445 #define REG_SpLim       i2
 446
 447 #define REG_Hp          i3
 448 #define REG_HpLim       i4
 449
 450 #define NCG_Reserved_I1 g1
 451 #define NCG_Reserved_I2 g2
 452 #define NCG_Reserved_F1 f14
 453 #define NCG_Reserved_F2 f15
 454 #define NCG_Reserved_D1 f16
 455 #define NCG_Reserved_D2 f18
 456
 457 #endif /* sparc */
 458
 459 /* These constants define how many stg registers are *actually* in
 460  * registers: the code generator uses this information to avoid
 461  * generating code to load/store registers which are really offsets
 462  * from BaseReg.
 463  *
 464  * Registers above these values might still be used, for instance to
 465  * communicate with PrimOps and RTS functions.
 466  */
 467
 468 #ifndef MAX_REAL_VANILLA_REG
 469 #define MAX_REAL_VANILLA_REG 8
 470 #endif
 471
 472 #ifndef MAX_REAL_FLOAT_REG
 473 #define MAX_REAL_FLOAT_REG 4
 474 #endif
 475
 476 #ifndef MAX_REAL_DOUBLE_REG
 477 #define MAX_REAL_DOUBLE_REG 2
 478 #endif
 479
 480 #endif /* NO_REGS */
 481
 482 #endif /* MACHREGS_H */