2 % (c) The GRASP Project, Glasgow University, 1994
4 \section[MachRegs-decls]{Architecture-specific register mappings}
6 NB: THIS FILE IS INCLUDED IN HASKELL SOURCE!
12 #if defined(__STG_GCC_REGS__) || defined(COMPILING_GHC)
14 #include "StgMachDeps.h"
18 %************************************************************************
20 \subsection[register-tricks]{Things to watch out for}
22 %************************************************************************
24 Here we collect random pieces of lore about register mapping. It is a
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}).
31 %************************************************************************
33 \subsubsection{Using callee-saves registers}
35 %************************************************************************
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).
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
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.
50 %************************************************************************
52 \subsubsection{Using caller-saves registers}
54 %************************************************************************
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.
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
68 SpA, SuA, must be saved *every time* if
69 SpB, SuB, Hp, HpLim in a caller-save reg (to be avoided)
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!
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...)
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.)
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.
91 Notice that PrimOps like arbitrary-precision arithmetic can trigger
92 GC, so everything gets saved on the stack safely.
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
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.
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).
115 %************************************************************************
117 \subsubsection[mapping-alpha]{The DEC Alpha register mapping}
119 %************************************************************************
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.
127 \tr{$f2}--\tr{$f9} are some callee-save floating-point registers.
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!
159 #if defined(alpha_TARGET_ARCH)
160 # define REG(x) __asm__("$" #x)
162 # if defined(MARK_REG_MAP)
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
170 # if defined(SCAN_REG_MAP)
173 # define REG_LinkLim 11
175 # if defined(SCAV_REG_MAP)
178 # if defined(GCap) || defined(GCgn)
179 # define REG_OldGen 11
180 # endif /* GCap || GCgn */
182 # else /* default: MAIN_REG_MAP */
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
197 # define CALLEE_SAVES_Ret
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
209 # define CALLER_SAVES_USER
234 # define REG_HpLim 14
238 # define NCG_Reserved_I1 22
239 # define NCG_Reserved_I2 27
240 # define NCG_Reserved_F1 f29
241 # define NCG_Reserved_F2 f30
243 # endif /* !SCAV_REG_MAP */
244 # endif /* !SCAN_REG_MAP */
245 # endif /* !MARK_REG_MAP */
250 %************************************************************************
252 \subsubsection[mapping-hpux]{The HP-PA register mapping}
254 %************************************************************************
256 We cater for HP-PA 1.1.
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.
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.
274 #if hppa1_1_TARGET_ARCH
276 #define REG(x) __asm__("%" #x)
278 #if defined(MARK_REG_MAP)
280 #define REG_MStack r5
282 #define REG_BitArray r7
283 #define REG_HeapBase r8
284 #define REG_HeapLim r9
286 #if defined(SCAN_REG_MAP)
289 #define REG_LinkLim r6
291 #if defined(SCAV_REG_MAP)
294 #if defined(GCap) || defined(GCgn)
295 #define REG_OldGen r6
296 #endif /* GCap || GCgn */
297 #else /* default: MAIN_REG_MAP */
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
313 #define CALLEE_SAVES_Ret
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
324 /* caller saves -- none */
335 #define REG_Flt1 fr12
336 #define REG_Flt2 fr12R
337 #define REG_Flt3 fr13
338 #define REG_Flt4 fr13R
340 #define REG_Dbl1 fr20 /* L & R */
341 #define REG_Dbl2 fr21 /* L & R */
353 /* #define REG_StkStub r2 */
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
362 #endif /* SCAV_REG_MAP */
363 #endif /* SCAN_REG_MAP */
364 #endif /* MARK_REG_MAP */
369 %************************************************************************
371 \subsubsection[mapping-iX86]{The Intel iX86 register mapping}
373 %************************************************************************
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.
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.
386 #define REG(x) __asm__("%" #x)
388 #if defined(MARK_REG_MAP)
389 #define REG_MarkBase ebx
391 #define REG_MStack esi
392 #define REG_MRoot edi
395 #if defined(SCAN_REG_MAP)
398 #define REG_LinkLim esi
401 #if defined(SCAV_REG_MAP)
404 #if defined(GCap) || defined(GCgn)
405 #define REG_OldGen esi
406 #endif /* GCap || GCgn */
408 #else /* default: MAIN_REG_MAP */
411 #define CALLEE_SAVES_Base
412 #define CALLEE_SAVES_SpB
414 /* caller saves -- none */
416 /* After trying to steal 4 regs, ... crash:
421 - give back edi & ebp
427 /* SpB and R1 are the two heaviest hitters, followed by SpA */
430 #if STOLEN_X86_REGS >= 3
432 # define CALLEE_SAVES_R1
434 #if STOLEN_X86_REGS >= 4
436 # define CALLEE_SAVES_SpA
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!
442 #if STOLEN_X86_REGS >= 5
444 # define CALLER_SAVES_R2
447 #endif /* SCAV_REG_MAP */
448 #endif /* SCAN_REG_MAP */
449 #endif /* MARK_REG_MAP */
454 %************************************************************************
456 \subsubsection[mapping-m68k]{The Motorola 680x0 register mapping}
458 %************************************************************************
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.
465 Here's the register-usage picture for m68k boxes with GCC.
468 a0 & used directly by GCC \\
469 a1 & used directly by GCC \\
471 a2..a5 & callee-saved: available for STG registers \\
472 & (a5 may be special, ``global'' register for PIC?) \\
474 a6 & C-stack frame pointer \\
475 a7 & C-stack pointer \\
477 d0 & used directly by GCC \\
478 d1 & used directly by GCC \\
479 d2 & really needed for local optimisation by GCC \\
481 d3..d7 & callee-saved: available for STG registers
483 fp0 & call-clobbered \\
484 fp1 & call-clobbered \\
485 fp2..fp7 & callee-saved: available for STG registers
491 #define REG(x) __asm__(#x)
493 #if defined(FLUSH_REG_MAP)
494 #define REG_FlushP a2
495 #define REG_FStack a3
496 #define REG_FlushTemp a4
498 #if defined(MARK_REG_MAP)
500 #define REG_MStack a3
502 #define REG_BitArray a5
503 #define REG_HeapBase d3
504 #define REG_HeapLim d4
506 #if defined(SCAN_REG_MAP)
509 #define REG_LinkLim a4
511 #if defined(SCAV_REG_MAP)
515 #define REG_OldGen a4
518 #define REG_OldGen a4
519 #define REG_AllocGen a5
523 #else /* default: MAIN_REG_MAP */
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
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
541 #define CALLEE_SAVES_R1
542 #define CALLEE_SAVES_R2
543 #define CALLEE_SAVES_Ret
545 /* caller saves -- none */
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).
572 /* The extra double registers are not worth the tradeoff in
573 context-switch time for most programs (for now, at least).
575 #if !defined(CONCURRENT)
579 #endif /* SCAV_REG_MAP */
580 #endif /* SCAN_REG_MAP */
581 #endif /* MARK_REG_MAP */
582 #endif /* FLUSH_REG_MAP */
587 %************************************************************************
589 \subsubsection[mapping-mipsel]{The DECstation (MIPS) register mapping}
591 %************************************************************************
593 Here's at least some simple stuff about registers on a MIPS.
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
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.
604 #if mipsel_TARGET_ARCH || mipseb_TARGET_ARCH
606 #define REG(x) __asm__("$" #x)
608 #if defined(MARK_REG_MAP)
610 #define REG_MStack 17
612 #define REG_BitArray 19
613 #define REG_HeapBase 20
614 #define REG_HeapLim 21
616 #if defined(SCAN_REG_MAP)
619 #define REG_LinkLim 18
621 #if defined(SCAV_REG_MAP)
624 #if defined(GCap) || defined(GCgn)
625 #define REG_OldGen 18
626 #endif /* GCap || GCgn */
627 #else /* default: MAIN_REG_MAP */
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
643 #define CALLEE_SAVES_Ret
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
655 #define CALLER_SAVES_USER
684 #define REG_StkStub 23
686 #endif /* SCAV_REG_MAP */
687 #endif /* SCAN_REG_MAP */
688 #endif /* MARK_REG_MAP */
690 #endif /* mipse[lb] */
693 %************************************************************************
695 \subsubsection[mapping-rs6000]{The IBM RS6000 register mapping}
697 %************************************************************************
699 \tr{r13}--\tr{r31} are wonderful callee-save registers.
700 \tr{r4}--\tr{r8}, \tr{r10}, and \tr{r11} are caller-save registers.
702 \tr{%fr14}--\tr{%fr31} are callee-save floating-point registers.
704 I think we can do the Whole Business with callee-save registers only!
709 #if rs6000_TARGET_ARCH
711 #define REG_Base ????
727 %************************************************************************
729 \subsubsection[mapping-sparc]{The Sun SPARC register mapping}
731 %************************************************************************
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...
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.
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 \\
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
758 #if sparc_TARGET_ARCH
760 #define REG(x) __asm__("%" #x)
762 #if defined(MARK_REG_MAP)
764 #define REG_MStack i1
766 #define REG_BitArray i3
767 #define REG_HeapBase i4
768 #define REG_HeapLim i5
770 #if defined(SCAN_REG_MAP)
771 #define REG_ScanBase g4
773 #if defined(SCAV_REG_MAP)
774 #define REG_ScavBase g4
775 #else /* default: MAIN_REG_MAP */
777 /* callee saves (nothing) */
779 /* caller saves (fp registers and maybe Activity) */
781 #if defined(DO_SPAT_PROFILING)
782 #define CALLER_SAVES_SYSTEM
783 #define CALLER_SAVES_Activity
786 #define CALLER_SAVES_USER
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
810 #if defined(DO_SPAT_PROFILING)
811 #define REG_Activity g5
824 #define REG_StkStub i7
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
833 #endif /* SCAV_REG_MAP */
834 #endif /* SCAN_REG_MAP */
835 #endif /* MARK_REG_MAP */
840 Concluding multi-slurp protection:
843 #endif /* __STG_GCC_REGS__ || COMPILING_GHC */
845 #endif /* MACHREGS_H */