ghc/includes/MachRegs.lh

   1 %
   2 % (c) The GRASP Project, Glasgow University, 1994
   3 %
   4 \section[MachRegs-decls]{Architecture-specific register mappings}
   5
   6 NB: THIS FILE IS INCLUDED IN HASKELL SOURCE!
   7
   8 \begin{code}
   9 #ifndef MACHREGS_H
  10 #define MACHREGS_H
  11
  12 #if defined(__STG_GCC_REGS__) || defined(COMPILING_GHC)
  13
  14 #include "StgMachDeps.h"
  15
  16 \end{code}
  17
  18 %************************************************************************
  19 %*                                                                      *
  20 \subsection[register-tricks]{Things to watch out for}
  21 %*                                                                      *
  22 %************************************************************************
  23
  24 Here we collect random pieces of lore about register mapping.  It is a
  25 delicate topic.
  26
  27 The best place to get a blow-by-blow account of the register story for
  28 a particular machine architecture is in the ``main mapping'' section
  29 (\sectionref{main-mapping-StgRegs}).
  30
  31 %************************************************************************
  32 %*                                                                      *
  33 \subsubsection{Using callee-saves registers}
  34 %*                                                                      *
  35 %************************************************************************
  36
  37 Mostly we map variables to callee-saves registers.  These are
  38 best---the only thing you have to worry about is that whoever starts
  39 up a wadge of code that uses them does, in fact, save them!  (i.e.,
  40 observes the callee-save convention).
  41
  42 To see what GCC thinks is a callee-save register:  Look at the
  43 \tr{FIXED_REGISTERS} and \tr{CALL_USED_REGISTERS} tables for an
  44 architecture.  A register that is marked as \tr{0} in both tables is
  45 callee-save.
  46
  47 Of course, whatever you do, it isn't wise to grab {\em all} available
  48 registers, because then GCC has nothing to use for temporaries, etc.
  49
  50 %************************************************************************
  51 %*                                                                      *
  52 \subsubsection{Using caller-saves registers}
  53 %*                                                                      *
  54 %************************************************************************
  55
  56 Using callee-saves registers only isn't really good enough.  For
  57 example, on a SPARC, {\em none} of the floating-point registers are
  58 callee-save, so it's caller-save registers or terrible performance...
  59 Also, modern RISC architectures normally offer about eight callee-save
  60 registers; we'd really rather steal more machine registers.
  61
  62 We need to be extra careful with stolen caller-save registers.  We
  63 don't want to save them {\em all} across every call to a C function
  64 (specifically @ccall@s).  Here is table of what STG registers {\em
  65 must} be saved across @ccalls@ if they are held in caller-save
  66 registers:
  67 \begin{verbatim}
  68 SpA, SuA,                   must be saved *every time* if
  69 SpB, SuB, Hp, HpLim         in a caller-save reg (to be avoided)
  70
  71 TagReg                      Usually won't be in a register, unless we have a
  72                             register glut.  In any event, it needn't be saved;
  73                             it isn't live at ccalls.
  74                             CLAIM: it isn't alive during other PrimOps either!
  75
  76 R1 (Node), R2 ... R8        must be saved if in a caller-save reg *and*
  77 FltReg1 .. n                its value survives over the ccall [rare] (the
  78 DblReg1 .. n                code-generator knows this...)
  79
  80 BaseReg,                    better choices for caller-saves regs than the
  81 StkStub,...                 other system regs, since they only need to be
  82                             restored, and never saved.  (For PAR, BaseReg
  83                             is not fixed, and must be saved.)
  84 \end{verbatim}
  85
  86 So: the compiler emits suitable \tr{CALLER_SAVE_<reg-name>} macros
  87 before a ccall, and corresponding \tr{...RESTORE...}s afterwards.  It
  88 {\em always} emits them for @BaseReg@ and friends; it emits them only
  89 for the known-to-be-live @R1@, ..., \tr{DoubleRegN} and friends.
  90
  91 Notice that PrimOps like arbitrary-precision arithmetic can trigger
  92 GC, so everything gets saved on the stack safely.
  93
  94 Special care needs to be taken for ``invisible'' calls to C functions.
  95 In particular, we freely generate calls to \tr{{PK,UNPK}_{FLT,DBL}},
  96 to construct and deconstruct floats and doubles.  These {\em must} be
  97 inlined by @gcc@, because otherwise they trash floating point
  98 registers.  So you have to compile with at least @gcc -O@ if you want
  99 registerisation.
 100
 101 Morals: We try {\em very hard} to keep @BaseReg@ and friends in
 102 callee-save registers.  If we have callee-save registers available for
 103 @R1@ (@Node@), etc., we use them on the more-heavily-used
 104 ``low-numbered'' registers.  As the likelihood of having to do a
 105 SAVE/RESTORE for @R6@ (for example) is near zero, it's OK to assign it
 106 a caller-save register.
 107
 108 On machines with register-based calling conventions, never try to steal
 109 argument or return registers, for two reasons:  (1) it breaks the
 110 callWrapper approach (saves and restores have to be done inline), and
 111 (2) it means that you have to be extremely careful about setting up
 112 arguments for calls (and may in fact have to introduce temporaries to
 113 handle simultaneous assignments to/from the argument registers).
 114
 115 %************************************************************************
 116 %*                                                                      *
 117 \subsubsection[mapping-alpha]{The DEC Alpha register mapping}
 118 %*                                                                      *
 119 %************************************************************************
 120
 121 Alpha registers
 122 \tr{$9}--\tr{$14} are our ``prize'' callee-save registers.
 123 \tr{$15} is the frame pointer, and \tr{$16}--\tr{$21} are argument
 124 registers.  (These are off-limits.)  We can steal some of the \tr{$22}-and-up
 125 caller-save registers provided we do the appropriate save/restore stuff.
 126
 127 \tr{$f2}--\tr{$f9} are some callee-save floating-point registers.
 128
 129 We cannot use \tr{$23} (aka t9), \tr{$24} (aka t10), \tr{$25} (aka
 130 t11), \tr{$27} (aka pv), or \tr{$28} (aka at), because they are
 131 occasionally required by the assembler to handle non-primitive
 132 instructions (e.g. ldb, remq).  Sigh!
 133
 134 Cheat sheet for GDB:
 135 \begin{verbatim}
 136 GDB     here    Main map
 137 ===     ====    ========
 138 t0      $1      R1
 139 t1      $2      R2
 140 t2      $3      R3
 141 t3      $4      R4
 142 t4      $5      R5
 143 t5      $6      R6
 144 t6      $7      R7
 145 t7      $8      R8
 146 s0      $9      SpA
 147 s1      $10     SuA
 148 s2      $11     SpB
 149 s3      $12     SuB
 150 s4      $13     Hp
 151 s5      $14     HpLim
 152 fp      $15     RetReg
 153 t8      $22     NCG_reserved
 154 t12     $27     NCG_reserved
 155 \end{verbatim}
 156
 157 \begin{code}
 158
 159 #if defined(alpha_TARGET_ARCH)
 160 # define REG(x) __asm__("$" #x)
 161
 162 # if defined(MARK_REG_MAP)
 163 #  define REG_Mark      9
 164 #  define REG_MStack    10
 165 #  define REG_MRoot     11
 166 #  define REG_BitArray    12
 167 #  define REG_HeapBase  13
 168 #  define REG_HeapLim   14
 169 # else
 170 # if defined(SCAN_REG_MAP)
 171 #  define REG_Scan      9
 172 #  define REG_New       10
 173 #  define REG_LinkLim   11
 174 # else
 175 # if defined(SCAV_REG_MAP)
 176 #  define REG_Scav      9
 177 #  define REG_ToHp      10
 178 # if defined(GCap) || defined(GCgn)
 179 #  define REG_OldGen    11
 180 # endif /* GCap || GCgn */
 181
 182 # else  /* default: MAIN_REG_MAP */
 183 /* callee saves */
 184 #  define CALLEE_SAVES_FltReg1
 185 #  define CALLEE_SAVES_FltReg2
 186 #  define CALLEE_SAVES_FltReg3
 187 #  define CALLEE_SAVES_FltReg4
 188 #  define CALLEE_SAVES_DblReg1
 189 #  define CALLEE_SAVES_DblReg2
 190 #  define CALLEE_SAVES_SpA
 191 #  define CALLEE_SAVES_SuA
 192 #  define CALLEE_SAVES_SpB
 193 #  define CALLEE_SAVES_SuB
 194 #  define CALLEE_SAVES_Hp
 195 #  define CALLEE_SAVES_HpLim
 196
 197 #  define CALLEE_SAVES_Ret
 198
 199 /* caller saves */
 200 #  define CALLER_SAVES_R1
 201 #  define CALLER_SAVES_R2
 202 #  define CALLER_SAVES_R3
 203 #  define CALLER_SAVES_R4
 204 #  define CALLER_SAVES_R5
 205 #  define CALLER_SAVES_R6
 206 #  define CALLER_SAVES_R7
 207 #  define CALLER_SAVES_R8
 208
 209 #  define CALLER_SAVES_USER
 210
 211 #  define REG_R1        1
 212 #  define REG_R2        2
 213 #  define REG_R3        3
 214 #  define REG_R4        4
 215 #  define REG_R5        5
 216 #  define REG_R6        6
 217 #  define REG_R7        7
 218 #  define REG_R8        8
 219
 220 #  define REG_Flt1      f2
 221 #  define REG_Flt2      f3
 222 #  define REG_Flt3      f4
 223 #  define REG_Flt4      f5
 224
 225 #  define REG_Dbl1      f6
 226 #  define REG_Dbl2      f7
 227
 228 #  define REG_SpA       9
 229 #  define REG_SuA       10
 230 #  define REG_SpB       11
 231 #  define REG_SuB       12
 232
 233 #  define REG_Hp        13
 234 #  define REG_HpLim     14
 235
 236 #  define REG_Ret       15
 237
 238 #  define NCG_Reserved_I1 22
 239 #  define NCG_Reserved_I2 27
 240 #  define NCG_Reserved_F1 f29
 241 #  define NCG_Reserved_F2 f30
 242
 243 # endif /* !SCAV_REG_MAP */
 244 # endif /* !SCAN_REG_MAP */
 245 # endif /* !MARK_REG_MAP */
 246
 247 #endif /* alpha */
 248 \end{code}
 249
 250 %************************************************************************
 251 %*                                                                      *
 252 \subsubsection[mapping-hpux]{The HP-PA register mapping}
 253 %*                                                                      *
 254 %************************************************************************
 255
 256 We cater for HP-PA 1.1.
 257
 258 \tr{%r0}--\tr{%r1} are special.
 259 \tr{%r2} is the return pointer.
 260 \tr{%r3} is the frame pointer.
 261 \tr{%r4}--\tr{%r18} are callee-save registers.
 262 \tr{%r19} is a linkage table register for HPUX 8.0 shared libraries.
 263 \tr{%r20}--\tr{%r22} are caller-save registers.
 264 \tr{%r23}--\tr{%r26} are parameter registers.
 265 \tr{%r27} is a global data pointer.
 266 \tr{%r28}--\tr{%r29} are temporaries.
 267 \tr{%r30} is the stack pointer.
 268 \tr{%r31} is a temporary.
 269
 270 \tr{%fr12}--\tr{%fr15} are some callee-save floating-point registers.
 271 \tr{%fr8}--\tr{%fr11} are some available caller-save fl-pt registers.
 272
 273 \begin{code}
 274 #if hppa1_1_TARGET_ARCH
 275
 276 #define REG(x) __asm__("%" #x)
 277
 278 #if defined(MARK_REG_MAP)
 279 #define REG_Mark        r4
 280 #define REG_MStack      r5
 281 #define REG_MRoot       r6
 282 #define REG_BitArray    r7
 283 #define REG_HeapBase    r8
 284 #define REG_HeapLim     r9
 285 #else
 286 #if defined(SCAN_REG_MAP)
 287 #define REG_Scan        r4
 288 #define REG_New         r5
 289 #define REG_LinkLim     r6
 290 #else
 291 #if defined(SCAV_REG_MAP)
 292 #define REG_Scav        r4
 293 #define REG_ToHp        r5
 294 #if defined(GCap) || defined(GCgn)
 295 #define REG_OldGen      r6
 296 #endif  /* GCap || GCgn */
 297 #else   /* default: MAIN_REG_MAP */
 298
 299 /* callee saves */
 300 #define CALLEE_SAVES_FltReg1
 301 #define CALLEE_SAVES_FltReg2
 302 #define CALLEE_SAVES_FltReg3
 303 #define CALLEE_SAVES_FltReg4
 304 #define CALLEE_SAVES_DblReg1
 305 #define CALLEE_SAVES_DblReg2
 306 #define CALLEE_SAVES_SpA
 307 #define CALLEE_SAVES_SuA
 308 #define CALLEE_SAVES_SpB
 309 #define CALLEE_SAVES_SuB
 310 #define CALLEE_SAVES_Hp
 311 #define CALLEE_SAVES_HpLim
 312
 313 #define CALLEE_SAVES_Ret
 314
 315 #define CALLEE_SAVES_R1
 316 #define CALLEE_SAVES_R2
 317 #define CALLEE_SAVES_R3
 318 #define CALLEE_SAVES_R4
 319 #define CALLEE_SAVES_R5
 320 #define CALLEE_SAVES_R6
 321 #define CALLEE_SAVES_R7
 322 #define CALLEE_SAVES_R8
 323
 324 /* caller saves -- none */
 325
 326 #define REG_R1          r11
 327 #define REG_R2          r12
 328 #define REG_R3          r13
 329 #define REG_R4          r14
 330 #define REG_R5          r15
 331 #define REG_R6          r16
 332 #define REG_R7          r17
 333 #define REG_R8          r18
 334
 335 #define REG_Flt1        fr12
 336 #define REG_Flt2        fr12R
 337 #define REG_Flt3        fr13
 338 #define REG_Flt4        fr13R
 339
 340 #define REG_Dbl1        fr20    /* L & R */
 341 #define REG_Dbl2        fr21    /* L & R */
 342
 343 #define REG_SpA         r4
 344 #define REG_SuA         r5
 345 #define REG_SpB         r6
 346 #define REG_SuB         r7
 347
 348 #define REG_Hp          r8
 349 #define REG_HpLim       r9
 350
 351 #define REG_Ret         r10
 352
 353 /* #define REG_StkStub          r2 */
 354
 355 #define NCG_Reserved_I1 r28
 356 #define NCG_Reserved_I2 r29
 357 #define NCG_Reserved_F1 fr8
 358 #define NCG_Reserved_F2 fr8R
 359 #define NCG_Reserved_D1 fr10
 360 #define NCG_Reserved_D2 fr11
 361
 362 #endif  /* SCAV_REG_MAP */
 363 #endif  /* SCAN_REG_MAP */
 364 #endif  /* MARK_REG_MAP */
 365
 366 #endif /* hppa */
 367 \end{code}
 368
 369 %************************************************************************
 370 %*                                                                      *
 371 \subsubsection[mapping-iX86]{The Intel iX86 register mapping}
 372 %*                                                                      *
 373 %************************************************************************
 374
 375 Ok, we've only got 6 general purpose registers, a frame pointer and a
 376 stack pointer.  \tr{%eax} and \tr{%edx} are return values from C functions,
 377 hence they get trashed across ccalls and are caller saves. \tr{%ebx},
 378 \tr{%esi}, \tr{%edi}, \tr{%ebp} are all callee-saves.
 379
 380 We only steal \tr{%ebx} for base registers.  SIGH.  SimonM also took
 381 \tr{%esi} for SpA and \tr{%edi} for SpB.  Maybe later.
 382
 383 \begin{code}
 384 #if i386_TARGET_ARCH
 385
 386 #define REG(x) __asm__("%" #x)
 387
 388 #if defined(MARK_REG_MAP)
 389 #define REG_MarkBase    ebx
 390 #define REG_Mark        ebp
 391 #define REG_MStack      esi
 392 #define REG_MRoot       edi
 393
 394 #else
 395 #if defined(SCAN_REG_MAP)
 396 #define REG_Scan        ebx
 397 #define REG_New         ebp
 398 #define REG_LinkLim     esi
 399
 400 #else
 401 #if defined(SCAV_REG_MAP)
 402 #define REG_Scav        ebx
 403 #define REG_ToHp        ebp
 404 #if defined(GCap) || defined(GCgn)
 405 #define REG_OldGen      esi
 406 #endif  /* GCap || GCgn */
 407
 408 #else   /* default: MAIN_REG_MAP */
 409
 410 /* callee saves */
 411 #define CALLEE_SAVES_Base
 412 #define CALLEE_SAVES_SpB
 413
 414 /* caller saves -- none */
 415
 416 /* After trying to steal 4 regs, ... crash:
 417
 418    works again if:
 419    - give back esi
 420    - give back edi
 421    - give back edi & ebp
 422
 423    does not work if
 424    - give back ebp
 425 */
 426
 427 /* SpB and R1 are the two heaviest hitters, followed by SpA */
 428 #define REG_Base    ebx
 429 #define REG_SpB     ebp
 430 #if STOLEN_X86_REGS >= 3
 431 # define REG_R1     esi
 432 # define CALLEE_SAVES_R1
 433 #endif
 434 #if STOLEN_X86_REGS >= 4
 435 # define REG_SpA    edi
 436 # define CALLEE_SAVES_SpA
 437 #endif
 438 /* the mangler will put Hp in %esp!!! */
 439 #if defined(MANGLING_X86_SP) && MANGLING_X86_SP == 0
 440 Oops! You should not be here if not mangling %esp!
 441 #endif
 442 #if STOLEN_X86_REGS >= 5
 443 # define REG_R2    ecx
 444 # define CALLER_SAVES_R2
 445 #endif
 446
 447 #endif  /* SCAV_REG_MAP */
 448 #endif  /* SCAN_REG_MAP */
 449 #endif  /* MARK_REG_MAP */
 450
 451 #endif /* iX86 */
 452 \end{code}
 453
 454 %************************************************************************
 455 %*                                                                      *
 456 \subsubsection[mapping-m68k]{The Motorola 680x0 register mapping}
 457 %*                                                                      *
 458 %************************************************************************
 459
 460 A Sun3 (mc680x0) has eight address registers, \tr{a0} to \tr{a7}, and
 461 eight data registers, \tr{d0} to \tr{d7}.  Address operations have to
 462 be done through address registers; data registers are used for
 463 comparison values and data.
 464
 465 Here's the register-usage picture for m68k boxes with GCC.
 466
 467 \begin{tabular}{ll}
 468 a0 & used directly by GCC \\
 469 a1 & used directly by GCC \\
 470 \\
 471 a2..a5 & callee-saved: available for STG registers \\
 472        & (a5 may be special, ``global'' register for PIC?) \\
 473 \\
 474 a6 & C-stack frame pointer \\
 475 a7 & C-stack pointer \\
 476 \\
 477 d0 & used directly by GCC \\
 478 d1 & used directly by GCC \\
 479 d2 & really needed for local optimisation by GCC \\
 480 \\
 481 d3..d7 & callee-saved: available for STG registers
 482 \\
 483 fp0 & call-clobbered \\
 484 fp1 & call-clobbered \\
 485 fp2..fp7 & callee-saved: available for STG registers
 486 \end{tabular}
 487
 488 \begin{code}
 489 #if m68k_TARGET_ARCH
 490
 491 #define REG(x) __asm__(#x)
 492
 493 #if defined(FLUSH_REG_MAP)
 494 #define REG_FlushP      a2
 495 #define REG_FStack      a3
 496 #define REG_FlushTemp   a4
 497 #else
 498 #if defined(MARK_REG_MAP)
 499 #define REG_Mark        a2
 500 #define REG_MStack      a3
 501 #define REG_MRoot       a4
 502 #define REG_BitArray    a5
 503 #define REG_HeapBase    d3
 504 #define REG_HeapLim     d4
 505 #else
 506 #if defined(SCAN_REG_MAP)
 507 #define REG_Scan        a2
 508 #define REG_New         a3
 509 #define REG_LinkLim     a4
 510 #else
 511 #if defined(SCAV_REG_MAP)
 512 #define REG_Scav        a2
 513 #define REG_ToHp        a3
 514 #if defined(GCap)
 515 #define REG_OldGen      a4
 516 #else
 517 #if defined(GCgn)
 518 #define REG_OldGen      a4
 519 #define REG_AllocGen    a5
 520 #define REG_OldHp       d3
 521 #endif  /* GCap */
 522 #endif  /* GCgn */
 523 #else   /* default: MAIN_REG_MAP */
 524
 525 /* callee saves */
 526 #define CALLEE_SAVES_FltReg1
 527 #define CALLEE_SAVES_DblReg1
 528 #if !defined(CONCURRENT)
 529 # define CALLEE_SAVES_FltReg2
 530 # define CALLEE_SAVES_FltReg3
 531 # define CALLEE_SAVES_FltReg4
 532 # define CALLEE_SAVES_DblReg2
 533 #endif
 534 #define CALLEE_SAVES_Base
 535 #define CALLEE_SAVES_SpB
 536 #define CALLEE_SAVES_SpA
 537 #define CALLEE_SAVES_Hp
 538 #define CALLEE_SAVES_SuA
 539 #define CALLEE_SAVES_SuB
 540
 541 #define CALLEE_SAVES_R1
 542 #define CALLEE_SAVES_R2
 543 #define CALLEE_SAVES_Ret
 544
 545 /* caller saves -- none */
 546
 547 #define REG_Base        a2
 548
 549 #define REG_SpB         a3
 550 #define REG_SpA         a4
 551
 552 #define REG_Hp          d3
 553 #define REG_SuA         d4
 554 #define REG_SuB         d5
 555
 556 #define REG_R1          a5
 557 #define REG_R2          d6
 558
 559 #define REG_Ret         d7
 560
 561 #define REG_Flt1        fp2
 562 #if !defined(CONCURRENT)
 563 /* The extra float registers are not worth the tradeoff in
 564    context-switch time for most programs (for now, at least).
 565 */
 566 #define REG_Flt2        fp3
 567 #define REG_Flt3        fp4
 568 #define REG_Flt4        fp5
 569 #endif
 570
 571 #define REG_Dbl1        fp6
 572 /* The extra double registers are not worth the tradeoff in
 573    context-switch time for most programs (for now, at least).
 574 */
 575 #if !defined(CONCURRENT)
 576 #define REG_Dbl2        fp7
 577 #endif
 578
 579 #endif  /* SCAV_REG_MAP */
 580 #endif  /* SCAN_REG_MAP */
 581 #endif  /* MARK_REG_MAP */
 582 #endif  /* FLUSH_REG_MAP */
 583
 584 #endif /* m68k */
 585 \end{code}
 586
 587 %************************************************************************
 588 %*                                                                      *
 589 \subsubsection[mapping-mipsel]{The DECstation (MIPS) register mapping}
 590 %*                                                                      *
 591 %************************************************************************
 592
 593 Here's at least some simple stuff about registers on a MIPS.
 594
 595 \tr{s0}--\tr{s7} are callee-save integer registers; they are our
 596 ``prize'' stolen registers.  There is also a wad of callee-save
 597 floating-point registers, \tr{$f20}--\tr{$f31}; we'll use some of
 598 those.
 599
 600 \tr{t0}--\tr{t9} are caller-save (``temporary?'') integer registers.
 601 We can steal some, but we might have to save/restore around ccalls.
 602
 603 \begin{code}
 604 #if mipsel_TARGET_ARCH || mipseb_TARGET_ARCH
 605
 606 #define REG(x) __asm__("$" #x)
 607
 608 #if defined(MARK_REG_MAP)
 609 #define REG_Mark        16
 610 #define REG_MStack      17
 611 #define REG_MRoot       18
 612 #define REG_BitArray    19
 613 #define REG_HeapBase    20
 614 #define REG_HeapLim     21
 615 #else
 616 #if defined(SCAN_REG_MAP)
 617 #define REG_Scan        16
 618 #define REG_New         17
 619 #define REG_LinkLim     18
 620 #else
 621 #if defined(SCAV_REG_MAP)
 622 #define REG_Scav        16
 623 #define REG_ToHp        17
 624 #if defined(GCap) || defined(GCgn)
 625 #define REG_OldGen      18
 626 #endif  /* GCap || GCgn */
 627 #else   /* default: MAIN_REG_MAP */
 628
 629 /* callee saves */
 630 #define CALLEE_SAVES_FltReg1
 631 #define CALLEE_SAVES_FltReg2
 632 #define CALLEE_SAVES_FltReg3
 633 #define CALLEE_SAVES_FltReg4
 634 #define CALLEE_SAVES_DblReg1
 635 #define CALLEE_SAVES_DblReg2
 636 #define CALLEE_SAVES_SpA
 637 #define CALLEE_SAVES_SuA
 638 #define CALLEE_SAVES_SpB
 639 #define CALLEE_SAVES_SuB
 640 #define CALLEE_SAVES_Hp
 641 #define CALLEE_SAVES_HpLim
 642
 643 #define CALLEE_SAVES_Ret
 644
 645 /* caller saves */
 646 #define CALLER_SAVES_R1
 647 #define CALLER_SAVES_R2
 648 #define CALLER_SAVES_R3
 649 #define CALLER_SAVES_R4
 650 #define CALLER_SAVES_R5
 651 #define CALLER_SAVES_R6
 652 #define CALLER_SAVES_R7
 653 #define CALLER_SAVES_R8
 654
 655 #define CALLER_SAVES_USER
 656
 657 #define REG_R1          9
 658 #define REG_R2          10
 659 #define REG_R3          11
 660 #define REG_R4          12
 661 #define REG_R5          13
 662 #define REG_R6          14
 663 #define REG_R7          15
 664 #define REG_R8          24
 665
 666 #define REG_Flt1        f20
 667 #define REG_Flt2        f22
 668 #define REG_Flt3        f24
 669 #define REG_Flt4        f26
 670
 671 #define REG_Dbl1        f28
 672 #define REG_Dbl2        f30
 673
 674 #define REG_SpA         16
 675 #define REG_SuA         17
 676 #define REG_SpB         18
 677 #define REG_SuB         19
 678
 679 #define REG_Hp          20
 680 #define REG_HpLim       21
 681
 682 #define REG_Ret         22
 683
 684 #define REG_StkStub     23
 685
 686 #endif  /* SCAV_REG_MAP */
 687 #endif  /* SCAN_REG_MAP */
 688 #endif  /* MARK_REG_MAP */
 689
 690 #endif /* mipse[lb] */
 691 \end{code}
 692
 693 %************************************************************************
 694 %*                                                                      *
 695 \subsubsection[mapping-rs6000]{The IBM RS6000 register mapping}
 696 %*                                                                      *
 697 %************************************************************************
 698
 699 \tr{r13}--\tr{r31} are wonderful callee-save registers.
 700 \tr{r4}--\tr{r8}, \tr{r10}, and \tr{r11} are caller-save registers.
 701
 702 \tr{%fr14}--\tr{%fr31} are callee-save floating-point registers.
 703
 704 I think we can do the Whole Business with callee-save registers only!
 705
 706 UTTERLY UNTESTED
 707
 708 \begin{code}
 709 #if rs6000_TARGET_ARCH
 710
 711 #define REG_Base        ????
 712 #define REG_R1
 713 #define REG_SpA
 714 #define REG_SpB
 715 #define REG_Hp
 716
 717 #define REG_Flt1
 718 #define REG_Flt2
 719 #define REG_Flt3
 720 #define REG_Flt4
 721 #define REG_Dbl1
 722 #define REG_Dbl2
 723
 724 #endif /* rs6000 */
 725 \end{code}
 726
 727 %************************************************************************
 728 %*                                                                      *
 729 \subsubsection[mapping-sparc]{The Sun SPARC register mapping}
 730 %*                                                                      *
 731 %************************************************************************
 732
 733 The SPARC register (window) story: Remember, within the Haskell
 734 Threaded World, we essentially ``shut down'' the register-window
 735 mechanism---the window doesn't move at all while in this World.  It
 736 {\em does} move, of course, if we call out to arbitrary~C...
 737
 738 The \tr{%i}, \tr{%l}, and \tr{%o} registers (8 each) are the input,
 739 local, and output registers visible in one register window.  The 8
 740 \tr{%g} (global) registers are visible all the time.
 741
 742 \begin{tabular}{ll}
 743 \tr{%o0}..\tr{%o7} & not available; can be zapped by callee \\
 744                    & (\tr{%o6} is C-stack ptr; \tr{%o7} hold ret addrs) \\
 745 \tr{%i0}..\tr{%i7} & available (except \tr{%i6} is used as frame ptr) \\
 746                    & (and \tr{%i7} tends to have ret-addr-ish things) \\
 747 \tr{%l0}..\tr{%l7} & available \\
 748 \tr{%g0}..\tr{%g4} & not available; prone to stomping by division, etc.\\
 749 \tr{%g5}..\tr{%g7} & not available; reserved for the OS \\
 750 \end{tabular}
 751
 752 Note: \tr{%g3} is {\em definitely} clobbered in the builtin divide
 753 code (and our save/restore machinery is NOT GOOD ENOUGH for that);
 754 discretion being the better part of valor, we also don't take
 755 \tr{%g4}.
 756
 757 \begin{code}
 758 #if sparc_TARGET_ARCH
 759
 760 #define REG(x) __asm__("%" #x)
 761
 762 #if defined(MARK_REG_MAP)
 763 #define REG_Mark        i0
 764 #define REG_MStack      i1
 765 #define REG_MRoot       i2
 766 #define REG_BitArray    i3
 767 #define REG_HeapBase    i4
 768 #define REG_HeapLim     i5
 769 #else
 770 #if defined(SCAN_REG_MAP)
 771 #define REG_ScanBase    g4
 772 #else
 773 #if defined(SCAV_REG_MAP)
 774 #define REG_ScavBase    g4
 775 #else   /* default: MAIN_REG_MAP */
 776
 777 /* callee saves (nothing) */
 778
 779 /* caller saves (fp registers and maybe Activity) */
 780
 781 #if defined(DO_SPAT_PROFILING)
 782 #define CALLER_SAVES_SYSTEM
 783 #define CALLER_SAVES_Activity
 784 #endif
 785
 786 #define CALLER_SAVES_USER
 787
 788 #define CALLER_SAVES_FltReg1
 789 #define CALLER_SAVES_FltReg2
 790 #define CALLER_SAVES_FltReg3
 791 #define CALLER_SAVES_FltReg4
 792 #define CALLER_SAVES_DblReg1
 793 #define CALLER_SAVES_DblReg2
 794
 795 #define REG_R1          l1
 796 #define REG_R2          l2
 797 #define REG_R3          l3
 798 #define REG_R4          l4
 799 #define REG_R5          l5
 800 #define REG_R6          l6
 801 #define REG_R7          l7
 802
 803 #define REG_Flt1        f2
 804 #define REG_Flt2        f3
 805 #define REG_Flt3        f4
 806 #define REG_Flt4        f5
 807 #define REG_Dbl1        f6
 808 #define REG_Dbl2        f8
 809
 810 #if defined(DO_SPAT_PROFILING)
 811 #define REG_Activity    g5
 812 #endif
 813
 814 #define REG_SpA         i0
 815 #define REG_SuA         i1
 816 #define REG_SpB         i2
 817 #define REG_SuB         i3
 818
 819 #define REG_Hp          i4
 820 #define REG_HpLim       i5
 821
 822 #define REG_Ret         l0
 823
 824 #define REG_StkStub     i7
 825
 826 #define NCG_Reserved_I1 g1
 827 #define NCG_Reserved_I2 g2
 828 #define NCG_Reserved_F1 f14
 829 #define NCG_Reserved_F2 f15
 830 #define NCG_Reserved_D1 f16
 831 #define NCG_Reserved_D2 f18
 832
 833 #endif  /* SCAV_REG_MAP */
 834 #endif  /* SCAN_REG_MAP */
 835 #endif  /* MARK_REG_MAP */
 836
 837 #endif /* sparc */
 838 \end{code}
 839
 840 Concluding multi-slurp protection:
 841 \begin{code}
 842
 843 #endif  /* __STG_GCC_REGS__ || COMPILING_GHC */
 844
 845 #endif /* MACHREGS_H */
 846 \end{code}
 847