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 \begin{code}
 381 #if i386_TARGET_ARCH
 382
 383 #define REG(x) __asm__("%" #x)
 384
 385 #if defined(MARK_REG_MAP)
 386 #define REG_MarkBase    ebx
 387 #define REG_Mark        ebp
 388 #define REG_MStack      esi
 389 #define REG_MRoot       edi
 390
 391 #else
 392 #if defined(SCAN_REG_MAP)
 393 #define REG_Scan        ebx
 394 #define REG_New         ebp
 395 #define REG_LinkLim     esi
 396
 397 #else
 398 #if defined(SCAV_REG_MAP)
 399 #define REG_Scav        ebx
 400 #define REG_ToHp        ebp
 401 #if defined(GCap) || defined(GCgn)
 402 /* NO: -concurrent croaks on SMevac.lc with this
 403 #define REG_OldGen      esi
 404 */
 405 #endif  /* GCap || GCgn */
 406
 407 #else   /* default: MAIN_REG_MAP */
 408
 409 /* callee saves */
 410 #define CALLEE_SAVES_Base
 411 #define CALLEE_SAVES_SpB
 412
 413 /* caller saves -- none */
 414
 415 /* After trying to steal 4 regs, ... crash:
 416
 417    works again if:
 418    - give back esi
 419    - give back edi
 420    - give back edi & ebp
 421
 422    does not work if
 423    - give back ebp
 424 */
 425
 426 /* SpB and R1 are the two heaviest hitters, followed by SpA.
 427    Hp comes next, followed closely by R2;
 428    then RetReg, then R3 and R4.
 429    At least based on some static counts.
 430    SIGH.  WDP 95/09
 431 */
 432 #define REG_Base    ebx
 433 #define REG_SpB     ebp
 434 #if STOLEN_X86_REGS >= 3
 435 # define REG_R1     esi
 436 # define CALLEE_SAVES_R1
 437 #endif
 438 #if STOLEN_X86_REGS >= 4
 439 # define REG_SpA    edi
 440 # define CALLEE_SAVES_SpA
 441 #endif
 442 #if STOLEN_X86_REGS >= 5
 443 /*
 444 # define REG_Hp    ecx
 445 # define CALLER_SAVES_Hp
 446 # define CALLER_SAVES_SYSTEM
 447 */
 448 /* because we *might* have Hp in a caller-saves register */
 449 #endif
 450
 451
 452 #endif  /* SCAV_REG_MAP */
 453 #endif  /* SCAN_REG_MAP */
 454 #endif  /* MARK_REG_MAP */
 455
 456 #endif /* iX86 */
 457 \end{code}
 458
 459 %************************************************************************
 460 %*                                                                      *
 461 \subsubsection[mapping-m68k]{The Motorola 680x0 register mapping}
 462 %*                                                                      *
 463 %************************************************************************
 464
 465 A Sun3 (mc680x0) has eight address registers, \tr{a0} to \tr{a7}, and
 466 eight data registers, \tr{d0} to \tr{d7}.  Address operations have to
 467 be done through address registers; data registers are used for
 468 comparison values and data.
 469
 470 Here's the register-usage picture for m68k boxes with GCC.
 471
 472 \begin{tabular}{ll}
 473 a0 & used directly by GCC \\
 474 a1 & used directly by GCC \\
 475 \\
 476 a2..a5 & callee-saved: available for STG registers \\
 477        & (a5 may be special, ``global'' register for PIC?) \\
 478 \\
 479 a6 & C-stack frame pointer \\
 480 a7 & C-stack pointer \\
 481 \\
 482 d0 & used directly by GCC \\
 483 d1 & used directly by GCC \\
 484 d2 & really needed for local optimisation by GCC \\
 485 \\
 486 d3..d7 & callee-saved: available for STG registers
 487 \\
 488 fp0 & call-clobbered \\
 489 fp1 & call-clobbered \\
 490 fp2..fp7 & callee-saved: available for STG registers
 491 \end{tabular}
 492
 493 \begin{code}
 494 #if m68k_TARGET_ARCH
 495
 496 #define REG(x) __asm__(#x)
 497
 498 #if defined(FLUSH_REG_MAP)
 499 #define REG_FlushP      a2
 500 #define REG_FStack      a3
 501 #define REG_FlushTemp   a4
 502 #else
 503 #if defined(MARK_REG_MAP)
 504 #define REG_Mark        a2
 505 #define REG_MStack      a3
 506 #define REG_MRoot       a4
 507 #define REG_BitArray    a5
 508 #define REG_HeapBase    d3
 509 #define REG_HeapLim     d4
 510 #else
 511 #if defined(SCAN_REG_MAP)
 512 #define REG_Scan        a2
 513 #define REG_New         a3
 514 #define REG_LinkLim     a4
 515 #else
 516 #if defined(SCAV_REG_MAP)
 517 #define REG_Scav        a2
 518 #define REG_ToHp        a3
 519 #if defined(GCap)
 520 #define REG_OldGen      a4
 521 #else
 522 #if defined(GCgn)
 523 #define REG_OldGen      a4
 524 #define REG_AllocGen    a5
 525 #define REG_OldHp       d3
 526 #endif  /* GCap */
 527 #endif  /* GCgn */
 528 #else   /* default: MAIN_REG_MAP */
 529
 530 /* callee saves */
 531 #define CALLEE_SAVES_FltReg1
 532 #define CALLEE_SAVES_DblReg1
 533 #if !defined(CONCURRENT)
 534 # define CALLEE_SAVES_FltReg2
 535 # define CALLEE_SAVES_FltReg3
 536 # define CALLEE_SAVES_FltReg4
 537 # define CALLEE_SAVES_DblReg2
 538 #endif
 539 #define CALLEE_SAVES_Base
 540 #define CALLEE_SAVES_SpB
 541 #define CALLEE_SAVES_SpA
 542 #define CALLEE_SAVES_Hp
 543 #define CALLEE_SAVES_SuA
 544 #define CALLEE_SAVES_SuB
 545
 546 #define CALLEE_SAVES_R1
 547 #define CALLEE_SAVES_R2
 548 #define CALLEE_SAVES_Ret
 549
 550 /* caller saves -- none */
 551
 552 #define REG_Base        a2
 553
 554 #define REG_SpB         a3
 555 #define REG_SpA         a4
 556
 557 #define REG_Hp          d3
 558 #define REG_SuA         d4
 559 #define REG_SuB         d5
 560
 561 #define REG_R1          a5
 562 #define REG_R2          d6
 563
 564 #define REG_Ret         d7
 565
 566 #define REG_Flt1        fp2
 567 #if !defined(CONCURRENT)
 568 /* The extra float registers are not worth the tradeoff in
 569    context-switch time for most programs (for now, at least).
 570 */
 571 #define REG_Flt2        fp3
 572 #define REG_Flt3        fp4
 573 #define REG_Flt4        fp5
 574 #endif
 575
 576 #define REG_Dbl1        fp6
 577 /* The extra double registers are not worth the tradeoff in
 578    context-switch time for most programs (for now, at least).
 579 */
 580 #if !defined(CONCURRENT)
 581 #define REG_Dbl2        fp7
 582 #endif
 583
 584 #endif  /* SCAV_REG_MAP */
 585 #endif  /* SCAN_REG_MAP */
 586 #endif  /* MARK_REG_MAP */
 587 #endif  /* FLUSH_REG_MAP */
 588
 589 #endif /* m68k */
 590 \end{code}
 591
 592 %************************************************************************
 593 %*                                                                      *
 594 \subsubsection[mapping-mipsel]{The DECstation (MIPS) register mapping}
 595 %*                                                                      *
 596 %************************************************************************
 597
 598 Here's at least some simple stuff about registers on a MIPS.
 599
 600 \tr{s0}--\tr{s7} are callee-save integer registers; they are our
 601 ``prize'' stolen registers.  There is also a wad of callee-save
 602 floating-point registers, \tr{$f20}--\tr{$f31}; we'll use some of
 603 those.
 604
 605 \tr{t0}--\tr{t9} are caller-save (``temporary?'') integer registers.
 606 We can steal some, but we might have to save/restore around ccalls.
 607
 608 \begin{code}
 609 #if mipsel_TARGET_ARCH || mipseb_TARGET_ARCH
 610
 611 #define REG(x) __asm__("$" #x)
 612
 613 #if defined(MARK_REG_MAP)
 614 #define REG_Mark        16
 615 #define REG_MStack      17
 616 #define REG_MRoot       18
 617 #define REG_BitArray    19
 618 #define REG_HeapBase    20
 619 #define REG_HeapLim     21
 620 #else
 621 #if defined(SCAN_REG_MAP)
 622 #define REG_Scan        16
 623 #define REG_New         17
 624 #define REG_LinkLim     18
 625 #else
 626 #if defined(SCAV_REG_MAP)
 627 #define REG_Scav        16
 628 #define REG_ToHp        17
 629 #if defined(GCap) || defined(GCgn)
 630 #define REG_OldGen      18
 631 #endif  /* GCap || GCgn */
 632 #else   /* default: MAIN_REG_MAP */
 633
 634 /* callee saves */
 635 #define CALLEE_SAVES_FltReg1
 636 #define CALLEE_SAVES_FltReg2
 637 #define CALLEE_SAVES_FltReg3
 638 #define CALLEE_SAVES_FltReg4
 639 #define CALLEE_SAVES_DblReg1
 640 #define CALLEE_SAVES_DblReg2
 641 #define CALLEE_SAVES_SpA
 642 #define CALLEE_SAVES_SuA
 643 #define CALLEE_SAVES_SpB
 644 #define CALLEE_SAVES_SuB
 645 #define CALLEE_SAVES_Hp
 646 #define CALLEE_SAVES_HpLim
 647
 648 #define CALLEE_SAVES_Ret
 649
 650 /* caller saves */
 651 #define CALLER_SAVES_R1
 652 #define CALLER_SAVES_R2
 653 #define CALLER_SAVES_R3
 654 #define CALLER_SAVES_R4
 655 #define CALLER_SAVES_R5
 656 #define CALLER_SAVES_R6
 657 #define CALLER_SAVES_R7
 658 #define CALLER_SAVES_R8
 659
 660 #define CALLER_SAVES_USER
 661
 662 #define REG_R1          9
 663 #define REG_R2          10
 664 #define REG_R3          11
 665 #define REG_R4          12
 666 #define REG_R5          13
 667 #define REG_R6          14
 668 #define REG_R7          15
 669 #define REG_R8          24
 670
 671 #define REG_Flt1        f20
 672 #define REG_Flt2        f22
 673 #define REG_Flt3        f24
 674 #define REG_Flt4        f26
 675
 676 #define REG_Dbl1        f28
 677 #define REG_Dbl2        f30
 678
 679 #define REG_SpA         16
 680 #define REG_SuA         17
 681 #define REG_SpB         18
 682 #define REG_SuB         19
 683
 684 #define REG_Hp          20
 685 #define REG_HpLim       21
 686
 687 #define REG_Ret         22
 688
 689 #define REG_StkStub     23
 690
 691 #endif  /* SCAV_REG_MAP */
 692 #endif  /* SCAN_REG_MAP */
 693 #endif  /* MARK_REG_MAP */
 694
 695 #endif /* mipse[lb] */
 696 \end{code}
 697
 698 %************************************************************************
 699 %*                                                                      *
 700 \subsubsection[mapping-powerpc]{The PowerPC register mapping}
 701 %*                                                                      *
 702 %************************************************************************
 703
 704 \tr{r14}--\tr{r31} are wonderful callee-save registers.
 705 \tr{r0}--\tr{r13} are caller-save registers.
 706
 707 \tr{%fr14}--\tr{%fr31} are callee-save floating-point registers.
 708
 709 I think we can do the Whole Business with callee-save registers only!
 710
 711 \begin{code}
 712 #if powerpc_TARGET_ARCH
 713
 714 #define REG(x) __asm__(#x)
 715
 716 #if defined(MARK_REG_MAP)
 717 #define REG_Mark        r14
 718 #define REG_MStack      r15
 719 #define REG_MRoot       r16
 720 #define REG_BitArray    r17
 721 #define REG_HeapBase    r18
 722 #define REG_HeapLim     r19
 723 #else
 724 #if defined(SCAN_REG_MAP)
 725 #define REG_Scan        r14
 726 #define REG_New         r15
 727 #define REG_LinkLim     r16
 728 #else
 729 #if defined(SCAV_REG_MAP)
 730 #define REG_Scav        r14
 731 #define REG_ToHp        r15
 732 #if defined(GCap) || defined(GCgn)
 733 #define REG_OldGen      r16
 734 #endif  /* GCap || GCgn */
 735 #else   /* default: MAIN_REG_MAP */
 736
 737 /* callee saves */
 738 #define CALLEE_SAVES_FltReg1
 739 #define CALLEE_SAVES_FltReg2
 740 #define CALLEE_SAVES_FltReg3
 741 #define CALLEE_SAVES_FltReg4
 742 #define CALLEE_SAVES_DblReg1
 743 #define CALLEE_SAVES_DblReg2
 744 #define CALLEE_SAVES_SpA
 745 #define CALLEE_SAVES_SuA
 746 #define CALLEE_SAVES_SpB
 747 #define CALLEE_SAVES_SuB
 748 #define CALLEE_SAVES_Hp
 749 #define CALLEE_SAVES_HpLim
 750
 751 #define CALLEE_SAVES_Ret
 752
 753 #define CALLEE_SAVES_R1
 754 #define CALLEE_SAVES_R2
 755 #define CALLEE_SAVES_R3
 756 #define CALLEE_SAVES_R4
 757 #define CALLEE_SAVES_R5
 758 #define CALLEE_SAVES_R6
 759 #define CALLEE_SAVES_R7
 760 #define CALLEE_SAVES_R8
 761
 762 #define REG_R1          r14
 763 #define REG_R2          r15
 764 #define REG_R3          r16
 765 #define REG_R4          r17
 766 #define REG_R5          r18
 767 #define REG_R6          r19
 768 #define REG_R7          r20
 769 #define REG_R8          r21
 770
 771 #define REG_Flt1        fr14
 772 #define REG_Flt2        fr15
 773 #define REG_Flt3        fr16
 774 #define REG_Flt4        fr17
 775
 776 #define REG_Dbl1        fr18
 777 #define REG_Dbl2        fr19
 778
 779 #define REG_SpA         r22
 780 #define REG_SuA         r23
 781 #define REG_SpB         r24
 782 #define REG_SuB         r25
 783
 784 #define REG_Hp          r26
 785 #define REG_HpLim       r27
 786
 787 #define REG_Ret         r28
 788
 789 #define REG_StkStub     r29
 790
 791 #endif  /* SCAV_REG_MAP */
 792 #endif  /* SCAN_REG_MAP */
 793 #endif  /* MARK_REG_MAP */
 794
 795 #endif /* powerpc */
 796 \end{code}
 797
 798 %************************************************************************
 799 %*                                                                      *
 800 \subsubsection[mapping-sparc]{The Sun SPARC register mapping}
 801 %*                                                                      *
 802 %************************************************************************
 803
 804 The SPARC register (window) story: Remember, within the Haskell
 805 Threaded World, we essentially ``shut down'' the register-window
 806 mechanism---the window doesn't move at all while in this World.  It
 807 {\em does} move, of course, if we call out to arbitrary~C...
 808
 809 The \tr{%i}, \tr{%l}, and \tr{%o} registers (8 each) are the input,
 810 local, and output registers visible in one register window.  The 8
 811 \tr{%g} (global) registers are visible all the time.
 812
 813 \begin{tabular}{ll}
 814 \tr{%o0}..\tr{%o7} & not available; can be zapped by callee \\
 815                    & (\tr{%o6} is C-stack ptr; \tr{%o7} hold ret addrs) \\
 816 \tr{%i0}..\tr{%i7} & available (except \tr{%i6} is used as frame ptr) \\
 817                    & (and \tr{%i7} tends to have ret-addr-ish things) \\
 818 \tr{%l0}..\tr{%l7} & available \\
 819 \tr{%g0}..\tr{%g4} & not available; prone to stomping by division, etc.\\
 820 \tr{%g5}..\tr{%g7} & not available; reserved for the OS \\
 821 \end{tabular}
 822
 823 Note: \tr{%g3} is {\em definitely} clobbered in the builtin divide
 824 code (and our save/restore machinery is NOT GOOD ENOUGH for that);
 825 discretion being the better part of valor, we also don't take
 826 \tr{%g4}.
 827
 828 \begin{code}
 829 #if sparc_TARGET_ARCH
 830
 831 #define REG(x) __asm__("%" #x)
 832
 833 #if defined(MARK_REG_MAP)
 834 #define REG_Mark        i0
 835 #define REG_MStack      i1
 836 #define REG_MRoot       i2
 837 #define REG_BitArray    i3
 838 #define REG_HeapBase    i4
 839 #define REG_HeapLim     i5
 840 #else
 841 #if defined(SCAN_REG_MAP)
 842 #define REG_ScanBase    g4
 843 /* NB: *not* defining this (so that everything is done w/ global variables)
 844    does *not* work; I suspect that the Sca[nv]RegTable is not being
 845    initialised somewhere... WDP 95/10
 846 */
 847 #else
 848 #if defined(SCAV_REG_MAP)
 849 #define REG_ScavBase    g4
 850 /* see comment above */
 851 #else   /* default: MAIN_REG_MAP */
 852
 853 /* callee saves (nothing) */
 854
 855 /* caller saves (fp registers) */
 856
 857 #define CALLER_SAVES_USER
 858
 859 #define CALLER_SAVES_FltReg1
 860 #define CALLER_SAVES_FltReg2
 861 #define CALLER_SAVES_FltReg3
 862 #define CALLER_SAVES_FltReg4
 863 #define CALLER_SAVES_DblReg1
 864 #define CALLER_SAVES_DblReg2
 865
 866 #define REG_R1          l1
 867 #define REG_R2          l2
 868 #define REG_R3          l3
 869 #define REG_R4          l4
 870 #define REG_R5          l5
 871 #define REG_R6          l6
 872 #define REG_R7          l7
 873
 874 #define REG_Flt1        f2
 875 #define REG_Flt2        f3
 876 #define REG_Flt3        f4
 877 #define REG_Flt4        f5
 878 #define REG_Dbl1        f6
 879 #define REG_Dbl2        f8
 880
 881 #define REG_SpA         i0
 882 #define REG_SuA         i1
 883 #define REG_SpB         i2
 884 #define REG_SuB         i3
 885
 886 #define REG_Hp          i4
 887 #define REG_HpLim       i5
 888
 889 #define REG_Ret         l0
 890
 891 #define REG_StkStub     i7
 892
 893 #define NCG_Reserved_I1 g1
 894 #define NCG_Reserved_I2 g2
 895 #define NCG_Reserved_F1 f14
 896 #define NCG_Reserved_F2 f15
 897 #define NCG_Reserved_D1 f16
 898 #define NCG_Reserved_D2 f18
 899
 900 #endif  /* SCAV_REG_MAP */
 901 #endif  /* SCAN_REG_MAP */
 902 #endif  /* MARK_REG_MAP */
 903
 904 #endif /* sparc */
 905 \end{code}
 906
 907 Concluding multi-slurp protection:
 908 \begin{code}
 909
 910 #endif  /* __STG_GCC_REGS__ || COMPILING_GHC */
 911
 912 #endif /* MACHREGS_H */
 913 \end{code}
 914