ghc/includes/MachRegs.h

   1 /* -----------------------------------------------------------------------------
   2  * $Id: MachRegs.h,v 1.2 1998/12/02 13:21:13 simonm 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
 218 #endif /* iX86 */
 219
 220 /* -----------------------------------------------------------------------------
 221    The Motorola 680x0 register mapping
 222
 223    A Sun3 (mc680x0) has eight address registers, \tr{a0} to \tr{a7}, and
 224    eight data registers, \tr{d0} to \tr{d7}.  Address operations have to
 225    be done through address registers; data registers are used for
 226    comparison values and data.
 227
 228    Here's the register-usage picture for m68k boxes with GCC.
 229
 230    \begin{tabular}{ll}
 231    a0 & used directly by GCC \\
 232    a1 & used directly by GCC \\
 233    \\
 234    a2..a5 & callee-saved: available for STG registers \\
 235    & (a5 may be special, ``global'' register for PIC?) \\
 236    \\
 237    a6 & C-stack frame pointer \\
 238    a7 & C-stack pointer \\
 239    \\
 240    d0 & used directly by GCC \\
 241    d1 & used directly by GCC \\
 242    d2 & really needed for local optimisation by GCC \\
 243    \\
 244    d3..d7 & callee-saved: available for STG registers
 245    \\
 246    fp0 & call-clobbered \\
 247    fp1 & call-clobbered \\
 248    fp2..fp7 & callee-saved: available for STG registers
 249    \end{tabular}
 250    -------------------------------------------------------------------------- */
 251
 252 #if m68k_TARGET_ARCH
 253
 254 #define REG(x) __asm__(#x)
 255
 256 #define REG_Base        a2
 257
 258 #define REG_Sp          a3
 259 #define REG_Su          a4
 260 #define REG_SpLim       d3
 261
 262 #define REG_Hp          d4
 263 #define REG_HpLim       d5
 264
 265 #define REG_R1          a5
 266 #define REG_R2          d6
 267 #define MAX_REAL_VANILLA_REG 2
 268
 269 #define REG_Ret         d7
 270
 271 #define REG_F1          fp2
 272 #define REG_F2          fp3
 273 #define REG_F3          fp4
 274 #define REG_F4          fp5
 275
 276 #define REG_D1          fp6
 277 #define REG_D2          fp7
 278
 279 #endif /* m68k */
 280
 281 /* -----------------------------------------------------------------------------
 282    The DECstation (MIPS) register mapping
 283
 284    Here's at least some simple stuff about registers on a MIPS.
 285
 286    \tr{s0}--\tr{s7} are callee-save integer registers; they are our
 287    ``prize'' stolen registers.  There is also a wad of callee-save
 288    floating-point registers, \tr{$f20}--\tr{$f31}; we'll use some of
 289    those.
 290
 291    \tr{t0}--\tr{t9} are caller-save (``temporary?'') integer registers.
 292    We can steal some, but we might have to save/restore around ccalls.
 293    -------------------------------------------------------------------------- */
 294
 295 #if mipsel_TARGET_ARCH || mipseb_TARGET_ARCH
 296
 297 #define REG(x) __asm__("$" #x)
 298
 299 #define CALLER_SAVES_R1
 300 #define CALLER_SAVES_R2
 301 #define CALLER_SAVES_R3
 302 #define CALLER_SAVES_R4
 303 #define CALLER_SAVES_R5
 304 #define CALLER_SAVES_R6
 305 #define CALLER_SAVES_R7
 306 #define CALLER_SAVES_R8
 307
 308 #define CALLER_SAVES_USER
 309
 310 #define REG_R1          9
 311 #define REG_R2          10
 312 #define REG_R3          11
 313 #define REG_R4          12
 314 #define REG_R5          13
 315 #define REG_R6          14
 316 #define REG_R7          15
 317 #define REG_R8          24
 318
 319 #define REG_F1          f20
 320 #define REG_F2          f22
 321 #define REG_F3          f24
 322 #define REG_F4          f26
 323
 324 #define REG_D1          f28
 325 #define REG_D2          f30
 326
 327 #define REG_Sp          16
 328 #define REG_Su          17
 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          fr14
 372 #define REG_F2          fr15
 373 #define REG_F3          fr16
 374 #define REG_F4          fr17
 375
 376 #define REG_D1          fr18
 377 #define REG_D2          fr19
 378
 379 #define REG_Sp          r22
 380 #define REG_Su          r23
 381 #define REG_SpLim       r24
 382
 383 #define REG_Hp          r25
 384 #define REG_HpLim       r26
 385
 386 #endif /* powerpc */
 387
 388 /* -----------------------------------------------------------------------------
 389    The Sun SPARC register mapping
 390
 391    The SPARC register (window) story: Remember, within the Haskell
 392    Threaded World, we essentially ``shut down'' the register-window
 393    mechanism---the window doesn't move at all while in this World.  It
 394    *does* move, of course, if we call out to arbitrary~C...
 395
 396    The %i, %l, and %o registers (8 each) are the input, local, and
 397    output registers visible in one register window.  The 8 %g (global)
 398    registers are visible all the time.
 399
 400    %o0..%o7             not available; can be zapped by callee
 401                           (%o6 is C-stack ptr; %o7 hold ret addrs)
 402    %i0..%i7             available (except %i6 is used as frame ptr)
 403                           (and %i7 tends to have ret-addr-ish things)
 404    %l0..%l7             available
 405    %g0..%g4             not available; prone to stomping by division, etc.
 406    %g5..%g7             not available; reserved for the OS
 407
 408    Note: %g3 is *definitely* clobbered in the builtin divide code (and
 409    our save/restore machinery is NOT GOOD ENOUGH for that); discretion
 410    being the better part of valor, we also don't take %g4.
 411    -------------------------------------------------------------------------- */
 412
 413 #if sparc_TARGET_ARCH
 414
 415 #define REG(x) __asm__("%" #x)
 416
 417 #define CALLER_SAVES_USER
 418
 419 #define CALLER_SAVES_F1
 420 #define CALLER_SAVES_F2
 421 #define CALLER_SAVES_F3
 422 #define CALLER_SAVES_F4
 423 #define CALLER_SAVES_D1
 424 #define CALLER_SAVES_D2
 425
 426 #define REG_R1          l1
 427 #define REG_R2          l2
 428 #define REG_R3          l3
 429 #define REG_R4          l4
 430 #define REG_R5          l5
 431 #define REG_R6          l6
 432 #define REG_R7          l7
 433 #define REG_R8          i5
 434
 435 #define REG_F1          f2
 436 #define REG_F2          f3
 437 #define REG_F3          f4
 438 #define REG_F4          f5
 439 #define REG_D1          f6
 440 #define REG_D2          f8
 441
 442 #define REG_Sp          i0
 443 #define REG_Su          i1
 444 #define REG_SpLim       i2
 445
 446 #define REG_Hp          i3
 447 #define REG_HpLim       i4
 448
 449 #define NCG_Reserved_I1 g1
 450 #define NCG_Reserved_I2 g2
 451 #define NCG_Reserved_F1 f14
 452 #define NCG_Reserved_F2 f15
 453 #define NCG_Reserved_D1 f16
 454 #define NCG_Reserved_D2 f18
 455
 456 #endif /* sparc */
 457
 458 /* These constants define how many stg registers are *actually* in
 459  * registers: the code generator uses this information to avoid
 460  * generating code to load/store registers which are really offsets
 461  * from BaseReg.
 462  *
 463  * Registers above these values might still be used, for instance to
 464  * communicate with PrimOps and RTS functions.
 465  */
 466
 467 #ifndef MAX_REAL_VANILLA_REG
 468 #define MAX_REAL_VANILLA_REG 8
 469 #endif
 470
 471 #ifndef MAX_REAL_FLOAT_REG
 472 #define MAX_REAL_FLOAT_REG 4
 473 #endif
 474
 475 #ifndef MAX_REAL_DOUBLE_REG
 476 #define MAX_REAL_DOUBLE_REG 2
 477 #endif
 478
 479 #endif /* NO_REGS */
 480
 481 #endif /* MACHREGS_H */