ghc/includes/MachRegs.h

   1 /* -----------------------------------------------------------------------------
   2  * $Id: MachRegs.h,v 1.4 1999/02/05 16:02:23 simonm 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, Su, 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    s1   $10     Su
  73    s2   $11     SpLim
  74    s3   $12     Hp
  75    s4   $13     HpLim
  76    t8   $22     NCG_reserved
  77    t12  $27     NCG_reserved
  78    -------------------------------------------------------------------------- */
  79
  80 #if defined(alpha_TARGET_ARCH)
  81 # define REG(x) __asm__("$" #x)
  82
  83 #  define CALLER_SAVES_R2
  84 #  define CALLER_SAVES_R3
  85 #  define CALLER_SAVES_R4
  86 #  define CALLER_SAVES_R5
  87 #  define CALLER_SAVES_R6
  88 #  define CALLER_SAVES_R7
  89 #  define CALLER_SAVES_R8
  90
  91 #  define CALLER_SAVES_USER
  92
  93 #  define REG_R1        14
  94 #  define REG_R2        2
  95 #  define REG_R3        3
  96 #  define REG_R4        4
  97 #  define REG_R5        5
  98 #  define REG_R6        6
  99 #  define REG_R7        7
 100 #  define REG_R8        8
 101
 102 #  define REG_F1        f2
 103 #  define REG_F2        f3
 104 #  define REG_F3        f4
 105 #  define REG_F4        f5
 106
 107 #  define REG_D1        f6
 108 #  define REG_D2        f7
 109
 110 #  define REG_Sp        9
 111 #  define REG_Su        10
 112 #  define REG_SpLim     11
 113
 114 #  define REG_Hp        12
 115 #  define REG_HpLim     13
 116
 117 #  define NCG_Reserved_I1 22
 118 #  define NCG_Reserved_I2 27
 119 #  define NCG_Reserved_F1 f29
 120 #  define NCG_Reserved_F2 f30
 121
 122 #endif /* alpha_TARGET_ARCH */
 123
 124 /* -----------------------------------------------------------------------------
 125    The HP-PA register mapping
 126
 127    We cater for HP-PA 1.1.
 128
 129    \tr{%r0}--\tr{%r1} are special.
 130    \tr{%r2} is the return pointer.
 131    \tr{%r3} is the frame pointer.
 132    \tr{%r4}--\tr{%r18} are callee-save registers.
 133    \tr{%r19} is a linkage table register for HPUX 8.0 shared libraries.
 134    \tr{%r20}--\tr{%r22} are caller-save registers.
 135    \tr{%r23}--\tr{%r26} are parameter registers.
 136    \tr{%r27} is a global data pointer.
 137    \tr{%r28}--\tr{%r29} are temporaries.
 138    \tr{%r30} is the stack pointer.
 139    \tr{%r31} is a temporary.
 140
 141    \tr{%fr12}--\tr{%fr15} are some callee-save floating-point registers.
 142    \tr{%fr8}--\tr{%fr11} are some available caller-save fl-pt registers.
 143    -------------------------------------------------------------------------- */
 144
 145 #if hppa1_1_TARGET_ARCH
 146
 147 #define REG(x) __asm__("%" #x)
 148
 149 #define REG_R1          r11
 150 #define REG_R2          r12
 151 #define REG_R3          r13
 152 #define REG_R4          r14
 153 #define REG_R5          r15
 154 #define REG_R6          r16
 155 #define REG_R7          r17
 156 #define REG_R8          r18
 157
 158 #define REG_F1          fr12
 159 #define REG_F2          fr12R
 160 #define REG_F3          fr13
 161 #define REG_F4          fr13R
 162
 163 #define REG_D1          fr20    /* L & R */
 164 #define REG_D2          fr21    /* L & R */
 165
 166 #define REG_Sp          r4
 167 #define REG_Su          r5
 168 #define REG_SpLim       r6
 169
 170 #define REG_Hp          r7
 171 #define REG_HpLim       r8
 172
 173 #define NCG_Reserved_I1 r28
 174 #define NCG_Reserved_I2 r29
 175 #define NCG_Reserved_F1 fr8
 176 #define NCG_Reserved_F2 fr8R
 177 #define NCG_Reserved_D1 fr10
 178 #define NCG_Reserved_D2 fr11
 179
 180 #endif /* hppa */
 181
 182 /* -----------------------------------------------------------------------------
 183    The Intel iX86 register mapping
 184
 185    Ok, we've only got 6 general purpose registers, a frame pointer and a
 186    stack pointer.  \tr{%eax} and \tr{%edx} are return values from C functions,
 187    hence they get trashed across ccalls and are caller saves. \tr{%ebx},
 188    \tr{%esi}, \tr{%edi}, \tr{%ebp} are all callee-saves.
 189
 190    Reg     STG-Reg
 191    ---------------
 192    ebx     Base
 193    ebp     Sp
 194    esi     R1
 195    edi     Hp
 196
 197    Leaving Su, SpLim, and HpLim out of the picture.
 198    -------------------------------------------------------------------------- */
 199
 200
 201 #if i386_TARGET_ARCH
 202
 203 #define REG(x) __asm__("%" #x)
 204
 205 #define REG_Base    ebx
 206 #define REG_Sp      ebp
 207
 208 #if STOLEN_X86_REGS >= 3
 209 # define REG_R1     esi
 210 #endif
 211
 212 #if STOLEN_X86_REGS >= 4
 213 # define REG_Hp     edi
 214 #endif
 215
 216 #define MAX_REAL_VANILLA_REG 1  /* always, since it defines the entry conv */
 217 #define MAX_REAL_FLOAT_REG   0
 218 #define MAX_REAL_DOUBLE_REG  0
 219 #define MAX_REAL_LONG_REG    0
 220
 221 #endif /* iX86 */
 222
 223 /* -----------------------------------------------------------------------------
 224    The Motorola 680x0 register mapping
 225
 226    A Sun3 (mc680x0) has eight address registers, \tr{a0} to \tr{a7}, and
 227    eight data registers, \tr{d0} to \tr{d7}.  Address operations have to
 228    be done through address registers; data registers are used for
 229    comparison values and data.
 230
 231    Here's the register-usage picture for m68k boxes with GCC.
 232
 233    \begin{tabular}{ll}
 234    a0 & used directly by GCC \\
 235    a1 & used directly by GCC \\
 236    \\
 237    a2..a5 & callee-saved: available for STG registers \\
 238    & (a5 may be special, ``global'' register for PIC?) \\
 239    \\
 240    a6 & C-stack frame pointer \\
 241    a7 & C-stack pointer \\
 242    \\
 243    d0 & used directly by GCC \\
 244    d1 & used directly by GCC \\
 245    d2 & really needed for local optimisation by GCC \\
 246    \\
 247    d3..d7 & callee-saved: available for STG registers
 248    \\
 249    fp0 & call-clobbered \\
 250    fp1 & call-clobbered \\
 251    fp2..fp7 & callee-saved: available for STG registers
 252    \end{tabular}
 253    -------------------------------------------------------------------------- */
 254
 255 #if m68k_TARGET_ARCH
 256
 257 #define REG(x) __asm__(#x)
 258
 259 #define REG_Base        a2
 260
 261 #define REG_Sp          a3
 262 #define REG_Su          a4
 263 #define REG_SpLim       d3
 264
 265 #define REG_Hp          d4
 266 #define REG_HpLim       d5
 267
 268 #define REG_R1          a5
 269 #define REG_R2          d6
 270 #define MAX_REAL_VANILLA_REG 2
 271
 272 #define REG_Ret         d7
 273
 274 #define REG_F1          fp2
 275 #define REG_F2          fp3
 276 #define REG_F3          fp4
 277 #define REG_F4          fp5
 278
 279 #define REG_D1          fp6
 280 #define REG_D2          fp7
 281
 282 #endif /* m68k */
 283
 284 /* -----------------------------------------------------------------------------
 285    The DECstation (MIPS) register mapping
 286
 287    Here's at least some simple stuff about registers on a MIPS.
 288
 289    \tr{s0}--\tr{s7} are callee-save integer registers; they are our
 290    ``prize'' stolen registers.  There is also a wad of callee-save
 291    floating-point registers, \tr{$f20}--\tr{$f31}; we'll use some of
 292    those.
 293
 294    \tr{t0}--\tr{t9} are caller-save (``temporary?'') integer registers.
 295    We can steal some, but we might have to save/restore around ccalls.
 296    -------------------------------------------------------------------------- */
 297
 298 #if mipsel_TARGET_ARCH || mipseb_TARGET_ARCH
 299
 300 #define REG(x) __asm__("$" #x)
 301
 302 #define CALLER_SAVES_R1
 303 #define CALLER_SAVES_R2
 304 #define CALLER_SAVES_R3
 305 #define CALLER_SAVES_R4
 306 #define CALLER_SAVES_R5
 307 #define CALLER_SAVES_R6
 308 #define CALLER_SAVES_R7
 309 #define CALLER_SAVES_R8
 310
 311 #define CALLER_SAVES_USER
 312
 313 #define REG_R1          9
 314 #define REG_R2          10
 315 #define REG_R3          11
 316 #define REG_R4          12
 317 #define REG_R5          13
 318 #define REG_R6          14
 319 #define REG_R7          15
 320 #define REG_R8          24
 321
 322 #define REG_F1          f20
 323 #define REG_F2          f22
 324 #define REG_F3          f24
 325 #define REG_F4          f26
 326
 327 #define REG_D1          f28
 328 #define REG_D2          f30
 329
 330 #define REG_Sp          16
 331 #define REG_Su          17
 332 #define REG_SpLim       18
 333
 334 #define REG_Hp          19
 335 #define REG_HpLim       20
 336
 337 #endif /* mipse[lb] */
 338
 339 /* -----------------------------------------------------------------------------
 340    The PowerPC register mapping
 341
 342    0            system glue?    (caller-save, volatile)
 343    1            SP              (callee-save, non-volatile)
 344    2            RTOC            (callee-save, non-volatile)
 345    3-10         args/return     (caller-save, volatile)
 346    11,12        system glue?    (caller-save, volatile)
 347    13-31                        (callee-save, non-volatile)
 348
 349    f0                           (caller-save, volatile)
 350    f1-f13       args/return     (caller-save, volatile)
 351    f14-f31                      (callee-save, non-volatile)
 352
 353    \tr{13}--\tr{31} are wonderful callee-save registers.
 354    \tr{0}--\tr{12} are caller-save registers.
 355
 356    \tr{%f14}--\tr{%f31} are callee-save floating-point registers.
 357
 358    I think we can do the Whole Business with callee-save registers only!
 359    -------------------------------------------------------------------------- */
 360
 361 #if powerpc_TARGET_ARCH || rs6000_TARGET_ARCH
 362
 363 #define REG(x) __asm__(#x)
 364
 365 #define REG_R1          r14
 366 #define REG_R2          r15
 367 #define REG_R3          r16
 368 #define REG_R4          r17
 369 #define REG_R5          r18
 370 #define REG_R6          r19
 371 #define REG_R7          r20
 372 #define REG_R8          r21
 373
 374 #define REG_F1          fr14
 375 #define REG_F2          fr15
 376 #define REG_F3          fr16
 377 #define REG_F4          fr17
 378
 379 #define REG_D1          fr18
 380 #define REG_D2          fr19
 381
 382 #define REG_Sp          r22
 383 #define REG_Su          r23
 384 #define REG_SpLim       r24
 385
 386 #define REG_Hp          r25
 387 #define REG_HpLim       r26
 388
 389 #endif /* powerpc */
 390
 391 /* -----------------------------------------------------------------------------
 392    The Sun SPARC register mapping
 393
 394    The SPARC register (window) story: Remember, within the Haskell
 395    Threaded World, we essentially ``shut down'' the register-window
 396    mechanism---the window doesn't move at all while in this World.  It
 397    *does* move, of course, if we call out to arbitrary~C...
 398
 399    The %i, %l, and %o registers (8 each) are the input, local, and
 400    output registers visible in one register window.  The 8 %g (global)
 401    registers are visible all the time.
 402
 403    %o0..%o7             not available; can be zapped by callee
 404                           (%o6 is C-stack ptr; %o7 hold ret addrs)
 405    %i0..%i7             available (except %i6 is used as frame ptr)
 406                           (and %i7 tends to have ret-addr-ish things)
 407    %l0..%l7             available
 408    %g0..%g4             not available; prone to stomping by division, etc.
 409    %g5..%g7             not available; reserved for the OS
 410
 411    Note: %g3 is *definitely* clobbered in the builtin divide code (and
 412    our save/restore machinery is NOT GOOD ENOUGH for that); discretion
 413    being the better part of valor, we also don't take %g4.
 414    -------------------------------------------------------------------------- */
 415
 416 #if sparc_TARGET_ARCH
 417
 418 #define REG(x) __asm__("%" #x)
 419
 420 #define CALLER_SAVES_USER
 421
 422 #define CALLER_SAVES_F1
 423 #define CALLER_SAVES_F2
 424 #define CALLER_SAVES_F3
 425 #define CALLER_SAVES_F4
 426 #define CALLER_SAVES_D1
 427 #define CALLER_SAVES_D2
 428
 429 #define REG_R1          l1
 430 #define REG_R2          l2
 431 #define REG_R3          l3
 432 #define REG_R4          l4
 433 #define REG_R5          l5
 434 #define REG_R6          l6
 435 #define REG_R7          l7
 436 #define REG_R8          i5
 437
 438 #define REG_F1          f2
 439 #define REG_F2          f3
 440 #define REG_F3          f4
 441 #define REG_F4          f5
 442 #define REG_D1          f6
 443 #define REG_D2          f8
 444
 445 #define REG_Sp          i0
 446 #define REG_Su          i1
 447 #define REG_SpLim       i2
 448
 449 #define REG_Hp          i3
 450 #define REG_HpLim       i4
 451
 452 #define NCG_Reserved_I1 g1
 453 #define NCG_Reserved_I2 g2
 454 #define NCG_Reserved_F1 f14
 455 #define NCG_Reserved_F2 f15
 456 #define NCG_Reserved_D1 f16
 457 #define NCG_Reserved_D2 f18
 458
 459 #endif /* sparc */
 460
 461 /* These constants define how many stg registers are *actually* in
 462  * registers: the code generator uses this information to avoid
 463  * generating code to load/store registers which are really offsets
 464  * from BaseReg.
 465  *
 466  * Registers above these values might still be used, for instance to
 467  * communicate with PrimOps and RTS functions.
 468  */
 469
 470 #ifndef MAX_REAL_VANILLA_REG
 471 #define MAX_REAL_VANILLA_REG 8
 472 #endif
 473
 474 #ifndef MAX_REAL_FLOAT_REG
 475 #define MAX_REAL_FLOAT_REG 4
 476 #endif
 477
 478 #ifndef MAX_REAL_DOUBLE_REG
 479 #define MAX_REAL_DOUBLE_REG 2
 480 #endif
 481
 482 #endif /* NO_REGS */
 483
 484 #endif /* MACHREGS_H */