beea181c07a29e4bd65235d5f4d86c75e579f1a4
[ghc.git] / compiler / nativeGen / MachRegs.lhs
1 -- -----------------------------------------------------------------------------
2 --
3 -- (c) The University of Glasgow 1994-2004
4 -- 
5 -- Machine-specific info about registers.
6 -- 
7 -- Also includes stuff about immediate operands, which are
8 -- often/usually quite entangled with registers.
9 -- 
10 -- (Immediates could be untangled from registers at some cost in tangled
11 -- modules --- the pleasure has been foregone.)
12 -- 
13 -- -----------------------------------------------------------------------------
14
15 \begin{code}
16 {-# OPTIONS -w #-}
17 -- The above warning supression flag is a temporary kludge.
18 -- While working on this module you are encouraged to remove it and fix
19 -- any warnings in the module. See
20 --     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
21 -- for details
22
23 #include "nativeGen/NCG.h"
24
25 module MachRegs (
26
27         -- * Immediate values
28         Imm(..), strImmLit, litToImm,
29
30         -- * Addressing modes
31         AddrMode(..),
32         addrOffset,
33
34         -- * The 'Reg' type
35         RegNo,
36         Reg(..), isRealReg, isVirtualReg, renameVirtualReg,
37         RegClass(..), regClass,
38         trivColorable,
39         getHiVRegFromLo, 
40         mkVReg,
41
42         -- * Global registers
43         get_GlobalReg_reg_or_addr,
44
45         -- * Machine-dependent register-related stuff
46         allocatableRegs, argRegs, allArgRegs, callClobberedRegs,
47         allocatableRegsInClass,
48         freeReg,
49         spRel,
50
51 #if alpha_TARGET_ARCH
52         fits8Bits,
53         fReg,
54         gp, pv, ra, sp, t9, t10, t11, t12, v0, f0, zeroh,
55 #endif
56 #if i386_TARGET_ARCH
57         EABase(..), EAIndex(..),
58         eax, ebx, ecx, edx, esi, edi, ebp, esp,
59         fake0, fake1, fake2, fake3, fake4, fake5,
60         addrModeRegs,
61 #endif
62 #if x86_64_TARGET_ARCH
63         EABase(..), EAIndex(..), ripRel,
64         rax, rbx, rcx, rdx, rsi, rdi, rbp, rsp,
65         eax, ebx, ecx, edx, esi, edi, ebp, esp,
66         r8, r9, r10, r11, r12, r13, r14, r15,
67         xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7,
68         xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15,
69         xmm,
70         addrModeRegs, allFPArgRegs,
71 #endif
72 #if sparc_TARGET_ARCH
73         fits13Bits,
74         fpRel, gReg, iReg, lReg, oReg, largeOffsetError,
75         fp, sp, g0, g1, g2, o0, o1, f0, f6, f8, f26, f27,
76 #endif
77 #if powerpc_TARGET_ARCH
78         allFPArgRegs,
79         makeImmediate,
80         sp,
81         r3, r4, r27, r28,
82         f1, f20, f21,
83 #endif
84     ) where
85
86 #include "HsVersions.h"
87
88 #if i386_TARGET_ARCH
89 # define STOLEN_X86_REGS 4
90 -- HACK: go for the max
91 #endif
92
93 #include "MachRegs.h"
94
95 import Cmm
96 import MachOp           ( MachRep(..) )
97 import CgUtils          ( get_GlobalReg_addr )
98
99 import CLabel           ( CLabel, mkMainCapabilityLabel )
100 import Pretty
101 import Outputable       ( Outputable(..), pprPanic, panic )
102 import qualified Outputable
103 import Unique
104 import UniqSet
105 import Constants
106 import FastTypes
107 import UniqFM
108
109 import GHC.Exts
110
111 #if powerpc_TARGET_ARCH
112 import Data.Word        ( Word8, Word16, Word32 )
113 import Data.Int         ( Int8, Int16, Int32 )
114 #endif
115
116 -- -----------------------------------------------------------------------------
117 -- Immediates
118
119 data Imm
120   = ImmInt      Int
121   | ImmInteger  Integer     -- Sigh.
122   | ImmCLbl     CLabel      -- AbstractC Label (with baggage)
123   | ImmLit      Doc         -- Simple string
124   | ImmIndex    CLabel Int
125   | ImmFloat    Rational
126   | ImmDouble   Rational
127   | ImmConstantSum Imm Imm
128   | ImmConstantDiff Imm Imm
129 #if sparc_TARGET_ARCH
130   | LO Imm                  {- Possible restrictions... -}
131   | HI Imm
132 #endif
133 #if powerpc_TARGET_ARCH
134   | LO Imm
135   | HI Imm
136   | HA Imm      {- high halfword adjusted -}
137 #endif
138 strImmLit s = ImmLit (text s)
139
140 litToImm :: CmmLit -> Imm
141 litToImm (CmmInt i _)        = ImmInteger i
142 litToImm (CmmFloat f F32)    = ImmFloat f
143 litToImm (CmmFloat f F64)    = ImmDouble f
144 litToImm (CmmLabel l)        = ImmCLbl l
145 litToImm (CmmLabelOff l off) = ImmIndex l off
146 litToImm (CmmLabelDiffOff l1 l2 off)
147                              = ImmConstantSum
148                                (ImmConstantDiff (ImmCLbl l1) (ImmCLbl l2))
149                                (ImmInt off)
150
151 -- -----------------------------------------------------------------------------
152 -- Addressing modes
153
154 data AddrMode
155 #if alpha_TARGET_ARCH
156   = AddrImm     Imm
157   | AddrReg     Reg
158   | AddrRegImm  Reg Imm
159 #endif
160
161 #if i386_TARGET_ARCH || x86_64_TARGET_ARCH
162   = AddrBaseIndex       EABase EAIndex Displacement
163   | ImmAddr             Imm Int
164
165 data EABase       = EABaseNone  | EABaseReg Reg | EABaseRip
166 data EAIndex      = EAIndexNone | EAIndex Reg Int
167 type Displacement = Imm
168 #endif
169
170 #if sparc_TARGET_ARCH
171   = AddrRegReg  Reg Reg
172   | AddrRegImm  Reg Imm
173 #endif
174
175 #if powerpc_TARGET_ARCH
176   = AddrRegReg  Reg Reg
177   | AddrRegImm  Reg Imm
178 #endif
179
180 #if i386_TARGET_ARCH || x86_64_TARGET_ARCH
181 addrModeRegs :: AddrMode -> [Reg]
182 addrModeRegs (AddrBaseIndex b i _) =  b_regs ++ i_regs
183   where
184    b_regs = case b of { EABaseReg r -> [r]; _ -> [] }
185    i_regs = case i of { EAIndex r _ -> [r]; _ -> [] }
186 addrModeRegs _ = []
187 #endif
188
189
190 addrOffset :: AddrMode -> Int -> Maybe AddrMode
191
192 addrOffset addr off
193   = case addr of
194 #if alpha_TARGET_ARCH
195       _ -> panic "MachMisc.addrOffset not defined for Alpha"
196 #endif
197 #if i386_TARGET_ARCH || x86_64_TARGET_ARCH
198       ImmAddr i off0      -> Just (ImmAddr i (off0 + off))
199
200       AddrBaseIndex r i (ImmInt n) -> Just (AddrBaseIndex r i (ImmInt (n + off)))
201       AddrBaseIndex r i (ImmInteger n)
202         -> Just (AddrBaseIndex r i (ImmInt (fromInteger (n + toInteger off))))
203
204       AddrBaseIndex r i (ImmCLbl lbl)
205         -> Just (AddrBaseIndex r i (ImmIndex lbl off))
206
207       AddrBaseIndex r i (ImmIndex lbl ix)
208         -> Just (AddrBaseIndex r i (ImmIndex lbl (ix+off)))
209
210       _ -> Nothing  -- in theory, shouldn't happen
211 #endif
212 #if sparc_TARGET_ARCH
213       AddrRegImm r (ImmInt n)
214        | fits13Bits n2 -> Just (AddrRegImm r (ImmInt n2))
215        | otherwise     -> Nothing
216        where n2 = n + off
217
218       AddrRegImm r (ImmInteger n)
219        | fits13Bits n2 -> Just (AddrRegImm r (ImmInt (fromInteger n2)))
220        | otherwise     -> Nothing
221        where n2 = n + toInteger off
222
223       AddrRegReg r (RealReg 0)
224        | fits13Bits off -> Just (AddrRegImm r (ImmInt off))
225        | otherwise     -> Nothing
226        
227       _ -> Nothing
228 #endif /* sparc */
229 #if powerpc_TARGET_ARCH
230       AddrRegImm r (ImmInt n)
231        | fits16Bits n2 -> Just (AddrRegImm r (ImmInt n2))
232        | otherwise     -> Nothing
233        where n2 = n + off
234
235       AddrRegImm r (ImmInteger n)
236        | fits16Bits n2 -> Just (AddrRegImm r (ImmInt (fromInteger n2)))
237        | otherwise     -> Nothing
238        where n2 = n + toInteger off
239        
240       _ -> Nothing
241 #endif /* powerpc */
242
243 -----------------
244 #if alpha_TARGET_ARCH
245
246 fits8Bits :: Integer -> Bool
247 fits8Bits i = i >= -256 && i < 256
248
249 #endif
250
251 #if sparc_TARGET_ARCH
252
253 {-# SPECIALIZE fits13Bits :: Int -> Bool, Integer -> Bool #-}
254 fits13Bits :: Integral a => a -> Bool
255 fits13Bits x = x >= -4096 && x < 4096
256
257 -----------------
258 largeOffsetError i
259   = error ("ERROR: SPARC native-code generator cannot handle large offset ("
260            ++show i++");\nprobably because of large constant data structures;" ++ 
261            "\nworkaround: use -fvia-C on this module.\n")
262
263 #endif /* sparc */
264
265 #if powerpc_TARGET_ARCH
266 fits16Bits :: Integral a => a -> Bool
267 fits16Bits x = x >= -32768 && x < 32768
268
269 makeImmediate :: Integral a => MachRep -> Bool -> a -> Maybe Imm
270
271 makeImmediate rep signed x = fmap ImmInt (toI16 rep signed)
272     where
273         narrow I32 False = fromIntegral (fromIntegral x :: Word32)
274         narrow I16 False = fromIntegral (fromIntegral x :: Word16)
275         narrow I8  False = fromIntegral (fromIntegral x :: Word8)
276         narrow I32 True  = fromIntegral (fromIntegral x :: Int32)
277         narrow I16 True  = fromIntegral (fromIntegral x :: Int16)
278         narrow I8  True  = fromIntegral (fromIntegral x :: Int8)
279         
280         narrowed = narrow rep signed
281         
282         toI16 I32 True
283             | narrowed >= -32768 && narrowed < 32768 = Just narrowed
284             | otherwise = Nothing
285         toI16 I32 False
286             | narrowed >= 0 && narrowed < 65536 = Just narrowed
287             | otherwise = Nothing
288         toI16 _ _  = Just narrowed
289 #endif
290
291
292 -- @spRel@ gives us a stack relative addressing mode for volatile
293 -- temporaries and for excess call arguments.  @fpRel@, where
294 -- applicable, is the same but for the frame pointer.
295
296 spRel :: Int    -- desired stack offset in words, positive or negative
297       -> AddrMode
298
299 spRel n
300 #if defined(i386_TARGET_ARCH)
301   = AddrBaseIndex (EABaseReg esp) EAIndexNone (ImmInt (n * wORD_SIZE))
302 #elif defined(x86_64_TARGET_ARCH)
303   = AddrBaseIndex (EABaseReg rsp) EAIndexNone (ImmInt (n * wORD_SIZE))
304 #else
305   = AddrRegImm sp (ImmInt (n * wORD_SIZE))
306 #endif
307
308 #if sparc_TARGET_ARCH
309 fpRel :: Int -> AddrMode
310     -- Duznae work for offsets greater than 13 bits; we just hope for
311     -- the best
312 fpRel n
313   = AddrRegImm fp (ImmInt (n * wORD_SIZE))
314 #endif
315
316 #if x86_64_TARGET_ARCH
317 ripRel imm = AddrBaseIndex EABaseRip EAIndexNone imm
318 #endif
319
320 -- -----------------------------------------------------------------------------
321 -- Global registers
322
323 -- We map STG registers onto appropriate CmmExprs.  Either they map
324 -- to real machine registers or stored as offsets from BaseReg.  Given
325 -- a GlobalReg, get_GlobalReg_reg_or_addr produces either the real
326 -- register it is in, on this platform, or a CmmExpr denoting the
327 -- address in the register table holding it.
328 -- (See also get_GlobalReg_addr in CgUtils.)
329
330 get_GlobalReg_reg_or_addr       :: GlobalReg -> Either Reg CmmExpr
331 get_GlobalReg_reg_or_addr mid
332    = case globalRegMaybe mid of
333         Just rr -> Left rr
334         Nothing -> Right (get_GlobalReg_addr mid)
335
336 -- ---------------------------------------------------------------------------
337 -- Registers
338
339 -- RealRegs are machine regs which are available for allocation, in
340 -- the usual way.  We know what class they are, because that's part of
341 -- the processor's architecture.
342
343 -- VirtualRegs are virtual registers.  The register allocator will
344 -- eventually have to map them into RealRegs, or into spill slots.
345 -- VirtualRegs are allocated on the fly, usually to represent a single
346 -- value in the abstract assembly code (i.e. dynamic registers are
347 -- usually single assignment).  With the new register allocator, the
348 -- single assignment restriction isn't necessary to get correct code,
349 -- although a better register allocation will result if single
350 -- assignment is used -- because the allocator maps a VirtualReg into
351 -- a single RealReg, even if the VirtualReg has multiple live ranges.
352
353 -- Virtual regs can be of either class, so that info is attached.
354
355 -- Determine the upper-half vreg for a 64-bit quantity on a 32-bit platform
356 -- when supplied with the vreg for the lower-half of the quantity.
357 -- (NB. Not reversible).
358 getHiVRegFromLo (VirtualRegI u) 
359    = VirtualRegHi (newTagUnique u 'H') -- makes a pseudo-unique with tag 'H'
360 getHiVRegFromLo other 
361    = pprPanic "getHiVRegFromLo" (ppr other)
362
363 data RegClass 
364    = RcInteger 
365    | RcFloat
366    | RcDouble
367      deriving Eq
368
369 instance Uniquable RegClass where
370     getUnique RcInteger = mkUnique 'L' 0
371     getUnique RcFloat   = mkUnique 'L' 1
372     getUnique RcDouble  = mkUnique 'L' 2
373
374 type RegNo = Int
375
376 data Reg
377    = RealReg      {-# UNPACK #-} !RegNo
378    | VirtualRegI  {-# UNPACK #-} !Unique
379    | VirtualRegHi {-# UNPACK #-} !Unique  -- High part of 2-word register
380    | VirtualRegF  {-# UNPACK #-} !Unique
381    | VirtualRegD  {-# UNPACK #-} !Unique
382    deriving (Eq,Ord)
383
384 -- We like to have Uniques for Reg so that we can make UniqFM and UniqSets 
385 -- in the register allocator.
386 instance Uniquable Reg where
387    getUnique (RealReg i)      = mkUnique 'C' i
388    getUnique (VirtualRegI u)  = u
389    getUnique (VirtualRegHi u) = u
390    getUnique (VirtualRegF u)  = u
391    getUnique (VirtualRegD u)  = u
392
393 unRealReg (RealReg i) = i
394 unRealReg vreg        = pprPanic "unRealReg on VirtualReg" (ppr vreg)
395
396 mkVReg :: Unique -> MachRep -> Reg
397 mkVReg u rep
398    = case rep of
399 #if sparc_TARGET_ARCH
400         F32   -> VirtualRegF u
401 #else
402         F32   -> VirtualRegD u
403 #endif
404         F64   -> VirtualRegD u
405         other -> VirtualRegI u
406
407 isVirtualReg :: Reg -> Bool
408 isVirtualReg (RealReg _)      = False
409 isVirtualReg (VirtualRegI _)  = True
410 isVirtualReg (VirtualRegHi _) = True
411 isVirtualReg (VirtualRegF _)  = True
412 isVirtualReg (VirtualRegD _)  = True
413
414 isRealReg :: Reg -> Bool
415 isRealReg = not . isVirtualReg
416
417 renameVirtualReg :: Unique -> Reg -> Reg
418 renameVirtualReg u r
419  = case r of
420         RealReg _       -> error "renameVirtualReg: can't change unique on a real reg"
421         VirtualRegI _   -> VirtualRegI  u
422         VirtualRegHi _  -> VirtualRegHi u
423         VirtualRegF _   -> VirtualRegF  u
424         VirtualRegD _   -> VirtualRegD  u
425
426 instance Show Reg where
427     show (RealReg i)      = showReg i
428     show (VirtualRegI u)  = "%vI_" ++ show u
429     show (VirtualRegHi u) = "%vHi_" ++ show u
430     show (VirtualRegF u)  = "%vF_" ++ show u
431     show (VirtualRegD u)  = "%vD_" ++ show u
432
433 instance Outputable RegClass where
434     ppr RcInteger       = Outputable.text "I"
435     ppr RcFloat         = Outputable.text "F"
436     ppr RcDouble        = Outputable.text "D"
437
438 instance Outputable Reg where
439     ppr r = Outputable.text (show r)
440
441
442
443
444 -- trivColorable function for the graph coloring allocator
445 --      This gets hammered by scanGraph during register allocation,
446 --      so needs to be fairly efficient.
447 --
448 --      NOTE:   This only works for arcitectures with just RcInteger and RcDouble
449 --              (which are disjoint) ie. x86, x86_64 and ppc
450 --
451
452 --      BL 2007/09
453 --      Doing a nice fold over the UniqSet makes trivColorable use
454 --      32% of total compile time and 42% of total alloc when compiling SHA1.lhs from darcs.
455 {-
456 trivColorable :: RegClass -> UniqSet Reg -> UniqSet Reg -> Bool
457 trivColorable classN conflicts exclusions
458  = let
459
460         acc :: Reg -> (Int, Int) -> (Int, Int)
461         acc r (cd, cf)  
462          = case regClass r of
463                 RcInteger       -> (cd+1, cf)
464                 RcDouble        -> (cd,   cf+1)
465                 _               -> panic "MachRegs.trivColorable: reg class not handled"
466
467         tmp                     = foldUniqSet acc (0, 0) conflicts
468         (countInt,  countFloat) = foldUniqSet acc tmp    exclusions
469
470         squeese         = worst countInt   classN RcInteger
471                         + worst countFloat classN RcDouble
472
473    in   squeese < allocatableRegsInClass classN
474
475 -- | Worst case displacement
476 --      node N of classN has n neighbors of class C.
477 --
478 --      We currently only have RcInteger and RcDouble, which don't conflict at all.
479 --      This is a bit boring compared to what's in RegArchX86.
480 --
481 worst :: Int -> RegClass -> RegClass -> Int
482 worst n classN classC
483  = case classN of
484         RcInteger
485          -> case classC of
486                 RcInteger       -> min n (allocatableRegsInClass RcInteger)
487                 RcDouble        -> 0
488                 
489         RcDouble
490          -> case classC of
491                 RcDouble        -> min n (allocatableRegsInClass RcDouble)
492                 RcInteger       -> 0
493 -}
494
495
496 -- The number of allocatable regs is hard coded here so we can do a fast comparision
497 -- in trivColorable. It's ok if these numbers are _less_ than the actual number of
498 -- free regs, but they can't be more or the register conflict graph won't color.
499 --
500 -- There is an allocatableRegsInClass :: RegClass -> Int, but doing the unboxing
501 -- is too slow for us here.
502 --
503 -- Compare MachRegs.freeRegs  and MachRegs.h to get these numbers.
504 --
505 #if i386_TARGET_ARCH
506 #define ALLOCATABLE_REGS_INTEGER 3#
507 #define ALLOCATABLE_REGS_DOUBLE  6#
508 #endif
509
510 #if x86_64_TARGET_ARCH
511 #define ALLOCATABLE_REGS_INTEGER 5#
512 #define ALLOCATABLE_REGS_DOUBLE  2#
513 #endif
514
515 #if powerpc_TARGET_ARCH
516 #define ALLOCATABLE_REGS_INTEGER 16#
517 #define ALLOCATABLE_REGS_DOUBLE  26#
518 #endif
519
520 {-# INLINE regClass      #-}
521 trivColorable :: RegClass -> UniqSet Reg -> UniqSet Reg -> Bool
522 trivColorable classN conflicts exclusions
523  = {-# SCC "trivColorable" #-}
524    let
525         {-# INLINE   isSqueesed    #-}
526         isSqueesed cI cF ufm
527           = case ufm of
528                 NodeUFM _ _ left right
529                  -> case isSqueesed cI cF right of
530                         (# s, cI', cF' #)
531                          -> case s of
532                                 False   -> isSqueesed cI' cF' left
533                                 True    -> (# True, cI', cF' #)
534
535                 LeafUFM _ reg
536                  -> case regClass reg of
537                         RcInteger
538                          -> case cI +# 1# of
539                                 cI' -> (# cI' >=# ALLOCATABLE_REGS_INTEGER, cI', cF #)
540
541                         RcDouble
542                          -> case cF +# 1# of
543                                 cF' -> (# cF' >=# ALLOCATABLE_REGS_DOUBLE,  cI, cF' #)
544
545                 EmptyUFM
546                  ->     (# False, cI, cF #)
547
548    in case isSqueesed 0# 0# conflicts of
549         (# False, cI', cF' #)
550          -> case isSqueesed cI' cF' exclusions of
551                 (# s, _, _ #)   -> not s
552
553         (# True, _, _ #)
554          -> False
555
556
557
558 -- -----------------------------------------------------------------------------
559 -- Machine-specific register stuff
560
561 -- The Alpha has 64 registers of interest; 32 integer registers and 32 floating
562 -- point registers.  The mapping of STG registers to alpha machine registers
563 -- is defined in StgRegs.h.  We are, of course, prepared for any eventuality.
564
565 #if alpha_TARGET_ARCH
566 fReg :: Int -> RegNo
567 fReg x = (32 + x)
568
569 v0, f0, ra, pv, gp, sp, zeroh :: Reg
570 v0    = realReg 0
571 f0    = realReg (fReg 0)
572 ra    = FixedReg ILIT(26)
573 pv    = t12
574 gp    = FixedReg ILIT(29)
575 sp    = FixedReg ILIT(30)
576 zeroh = FixedReg ILIT(31) -- "zero" is used in 1.3 (MonadZero method)
577
578 t9, t10, t11, t12 :: Reg
579 t9  = realReg 23
580 t10 = realReg 24
581 t11 = realReg 25
582 t12 = realReg 27
583 #endif
584
585 {-
586 Intel x86 architecture:
587 - All registers except 7 (esp) are available for use.
588 - Only ebx, esi, edi and esp are available across a C call (they are callee-saves).
589 - Registers 0-7 have 16-bit counterparts (ax, bx etc.)
590 - Registers 0-3 have 8 bit counterparts (ah, bh etc.)
591 - Registers 8-13 are fakes; we pretend x86 has 6 conventionally-addressable
592   fp registers, and 3-operand insns for them, and we translate this into
593   real stack-based x86 fp code after register allocation.
594
595 The fp registers are all Double registers; we don't have any RcFloat class
596 regs.  @regClass@ barfs if you give it a VirtualRegF, and mkVReg above should
597 never generate them.
598 -}
599
600 #if i386_TARGET_ARCH
601
602 fake0, fake1, fake2, fake3, fake4, fake5, 
603        eax, ebx, ecx, edx, esp, ebp, esi, edi :: Reg
604 eax   = RealReg 0
605 ebx   = RealReg 1
606 ecx   = RealReg 2
607 edx   = RealReg 3
608 esi   = RealReg 4
609 edi   = RealReg 5
610 ebp   = RealReg 6
611 esp   = RealReg 7
612 fake0 = RealReg 8
613 fake1 = RealReg 9
614 fake2 = RealReg 10
615 fake3 = RealReg 11
616 fake4 = RealReg 12
617 fake5 = RealReg 13
618
619
620 -- On x86, we might want to have an 8-bit RegClass, which would
621 -- contain just regs 1-4 (the others don't have 8-bit versions).
622 -- However, we can get away without this at the moment because the
623 -- only allocatable integer regs are also 8-bit compatible (1, 3, 4).
624 regClass (RealReg i)     = if i < 8 then RcInteger else RcDouble
625 regClass (VirtualRegI  u) = RcInteger
626 regClass (VirtualRegHi u) = RcInteger
627 regClass (VirtualRegD  u) = RcDouble
628 regClass (VirtualRegF  u) = pprPanic "regClass(x86):VirtualRegF" 
629                                     (ppr (VirtualRegF u))
630
631 regNames 
632    = ["%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi", "%ebp", "%esp", 
633       "%fake0", "%fake1", "%fake2", "%fake3", "%fake4", "%fake5", "%fake6"]
634
635 showReg :: RegNo -> String
636 showReg n
637    = if   n >= 0 && n < 14
638      then regNames !! n
639      else "%unknown_x86_real_reg_" ++ show n
640
641
642 #endif
643
644 {-
645 AMD x86_64 architecture:
646 - Registers 0-16 have 32-bit counterparts (eax, ebx etc.)
647 - Registers 0-7 have 16-bit counterparts (ax, bx etc.)
648 - Registers 0-3 have 8 bit counterparts (ah, bh etc.)
649
650 -}
651
652 #if x86_64_TARGET_ARCH
653
654 rax, rbx, rcx, rdx, rsp, rbp, rsi, rdi, 
655   r8, r9, r10, r11, r12, r13, r14, r15,
656   xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7,
657   xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15 :: Reg
658
659 rax   = RealReg 0
660 rbx   = RealReg 1
661 rcx   = RealReg 2
662 rdx   = RealReg 3
663 rsi   = RealReg 4
664 rdi   = RealReg 5
665 rbp   = RealReg 6
666 rsp   = RealReg 7
667 r8    = RealReg 8
668 r9    = RealReg 9
669 r10   = RealReg 10
670 r11   = RealReg 11
671 r12   = RealReg 12
672 r13   = RealReg 13
673 r14   = RealReg 14
674 r15   = RealReg 15
675 xmm0  = RealReg 16
676 xmm1  = RealReg 17
677 xmm2  = RealReg 18
678 xmm3  = RealReg 19
679 xmm4  = RealReg 20
680 xmm5  = RealReg 21
681 xmm6  = RealReg 22
682 xmm7  = RealReg 23
683 xmm8  = RealReg 24
684 xmm9  = RealReg 25
685 xmm10 = RealReg 26
686 xmm11 = RealReg 27
687 xmm12 = RealReg 28
688 xmm13 = RealReg 29
689 xmm14 = RealReg 30
690 xmm15 = RealReg 31
691
692  -- so we can re-use some x86 code:
693 eax = rax
694 ebx = rbx
695 ecx = rcx
696 edx = rdx
697 esi = rsi
698 edi = rdi
699 ebp = rbp
700 esp = rsp
701
702 xmm n = RealReg (16+n)
703
704 -- On x86, we might want to have an 8-bit RegClass, which would
705 -- contain just regs 1-4 (the others don't have 8-bit versions).
706 -- However, we can get away without this at the moment because the
707 -- only allocatable integer regs are also 8-bit compatible (1, 3, 4).
708 regClass (RealReg i)     = if i < 16 then RcInteger else RcDouble
709 regClass (VirtualRegI  u) = RcInteger
710 regClass (VirtualRegHi u) = RcInteger
711 regClass (VirtualRegD  u) = RcDouble
712 regClass (VirtualRegF  u) = pprPanic "regClass(x86_64):VirtualRegF" 
713                                     (ppr (VirtualRegF u))
714
715 regNames 
716  = ["%rax", "%rbx", "%rcx", "%rdx", "%rsi", "%rdi", "%rbp", "%rsp" ]
717
718 showReg :: RegNo -> String
719 showReg n
720   | n >= 16 = "%xmm" ++ show (n-16)
721   | n >= 8  = "%r" ++ show n
722   | otherwise = regNames !! n
723
724 #endif
725
726 {-
727 The SPARC has 64 registers of interest; 32 integer registers and 32
728 floating point registers.  The mapping of STG registers to SPARC
729 machine registers is defined in StgRegs.h.  We are, of course,
730 prepared for any eventuality.
731
732 The whole fp-register pairing thing on sparcs is a huge nuisance.  See
733 fptools/ghc/includes/MachRegs.h for a description of what's going on
734 here.
735 -}
736
737 #if sparc_TARGET_ARCH
738
739 gReg,lReg,iReg,oReg,fReg :: Int -> RegNo
740 gReg x = x
741 oReg x = (8 + x)
742 lReg x = (16 + x)
743 iReg x = (24 + x)
744 fReg x = (32 + x)
745
746 nCG_FirstFloatReg :: RegNo
747 nCG_FirstFloatReg = unRealReg NCG_FirstFloatReg
748
749 regClass (VirtualRegI u) = RcInteger
750 regClass (VirtualRegF u) = RcFloat
751 regClass (VirtualRegD u) = RcDouble
752 regClass (RealReg i) | i < 32                = RcInteger 
753                      | i < nCG_FirstFloatReg = RcDouble
754                      | otherwise             = RcFloat
755
756 showReg :: RegNo -> String
757 showReg n
758    | n >= 0  && n < 8   = "%g" ++ show n
759    | n >= 8  && n < 16  = "%o" ++ show (n-8)
760    | n >= 16 && n < 24  = "%l" ++ show (n-16)
761    | n >= 24 && n < 32  = "%i" ++ show (n-24)
762    | n >= 32 && n < 64  = "%f" ++ show (n-32)
763    | otherwise          = "%unknown_sparc_real_reg_" ++ show n
764
765 g0, g1, g2, fp, sp, o0, o1, f0, f1, f6, f8, f22, f26, f27 :: Reg
766
767 f6  = RealReg (fReg 6)
768 f8  = RealReg (fReg 8)
769 f22 = RealReg (fReg 22)
770 f26 = RealReg (fReg 26)
771 f27 = RealReg (fReg 27)
772
773
774 -- g0 is useful for codegen; is always zero, and writes to it vanish.
775 g0  = RealReg (gReg 0)
776 g1  = RealReg (gReg 1)
777 g2  = RealReg (gReg 2)
778
779 -- FP, SP, int and float return (from C) regs.
780 fp  = RealReg (iReg 6)
781 sp  = RealReg (oReg 6)
782 o0  = RealReg (oReg 0)
783 o1  = RealReg (oReg 1)
784 f0  = RealReg (fReg 0)
785 f1  = RealReg (fReg 1)
786
787 #endif
788
789 {-
790 The PowerPC has 64 registers of interest; 32 integer registers and 32 floating
791 point registers.
792 -}
793
794 #if powerpc_TARGET_ARCH
795 fReg :: Int -> RegNo
796 fReg x = (32 + x)
797
798 regClass (VirtualRegI  u) = RcInteger
799 regClass (VirtualRegHi u) = RcInteger
800 regClass (VirtualRegF  u) = pprPanic "regClass(ppc):VirtualRegF" 
801                                     (ppr (VirtualRegF u))
802 regClass (VirtualRegD u) = RcDouble
803 regClass (RealReg i) | i < 32                = RcInteger 
804                      | otherwise             = RcDouble
805
806 showReg :: RegNo -> String
807 showReg n
808     | n >= 0 && n <= 31   = "%r" ++ show n
809     | n >= 32 && n <= 63  = "%f" ++ show (n - 32)
810     | otherwise           = "%unknown_powerpc_real_reg_" ++ show n
811
812 sp = RealReg 1
813 r3 = RealReg 3
814 r4 = RealReg 4
815 r27 = RealReg 27
816 r28 = RealReg 28
817 f1 = RealReg $ fReg 1
818 f20 = RealReg $ fReg 20
819 f21 = RealReg $ fReg 21
820 #endif
821
822 {-
823 Redefine the literals used for machine-registers with non-numeric
824 names in the header files.  Gag me with a spoon, eh?
825 -}
826
827 #if alpha_TARGET_ARCH
828 #define f0 32
829 #define f1 33
830 #define f2 34
831 #define f3 35
832 #define f4 36
833 #define f5 37
834 #define f6 38
835 #define f7 39
836 #define f8 40
837 #define f9 41
838 #define f10 42
839 #define f11 43
840 #define f12 44
841 #define f13 45
842 #define f14 46
843 #define f15 47
844 #define f16 48
845 #define f17 49
846 #define f18 50
847 #define f19 51
848 #define f20 52
849 #define f21 53
850 #define f22 54
851 #define f23 55
852 #define f24 56
853 #define f25 57
854 #define f26 58
855 #define f27 59
856 #define f28 60
857 #define f29 61
858 #define f30 62
859 #define f31 63
860 #endif
861 #if i386_TARGET_ARCH
862 #define eax 0
863 #define ebx 1
864 #define ecx 2
865 #define edx 3
866 #define esi 4
867 #define edi 5
868 #define ebp 6
869 #define esp 7
870 #define fake0 8
871 #define fake1 9
872 #define fake2 10
873 #define fake3 11
874 #define fake4 12
875 #define fake5 13
876 #endif
877
878 #if x86_64_TARGET_ARCH
879 #define rax   0
880 #define rbx   1
881 #define rcx   2
882 #define rdx   3
883 #define rsi   4
884 #define rdi   5
885 #define rbp   6
886 #define rsp   7
887 #define r8    8
888 #define r9    9
889 #define r10   10
890 #define r11   11
891 #define r12   12
892 #define r13   13
893 #define r14   14
894 #define r15   15
895 #define xmm0  16
896 #define xmm1  17
897 #define xmm2  18
898 #define xmm3  19
899 #define xmm4  20
900 #define xmm5  21
901 #define xmm6  22
902 #define xmm7  23
903 #define xmm8  24
904 #define xmm9  25
905 #define xmm10 26
906 #define xmm11 27
907 #define xmm12 28
908 #define xmm13 29
909 #define xmm14 30
910 #define xmm15 31
911 #endif
912
913 #if sparc_TARGET_ARCH
914 #define g0 0
915 #define g1 1
916 #define g2 2
917 #define g3 3
918 #define g4 4
919 #define g5 5
920 #define g6 6
921 #define g7 7
922 #define o0 8
923 #define o1 9
924 #define o2 10
925 #define o3 11
926 #define o4 12
927 #define o5 13
928 #define o6 14
929 #define o7 15
930 #define l0 16
931 #define l1 17
932 #define l2 18
933 #define l3 19
934 #define l4 20
935 #define l5 21
936 #define l6 22
937 #define l7 23
938 #define i0 24
939 #define i1 25
940 #define i2 26
941 #define i3 27
942 #define i4 28
943 #define i5 29
944 #define i6 30
945 #define i7 31
946
947 #define f0  32
948 #define f1  33
949 #define f2  34
950 #define f3  35
951 #define f4  36
952 #define f5  37
953 #define f6  38
954 #define f7  39
955 #define f8  40
956 #define f9  41
957 #define f10 42
958 #define f11 43
959 #define f12 44
960 #define f13 45
961 #define f14 46
962 #define f15 47
963 #define f16 48
964 #define f17 49
965 #define f18 50
966 #define f19 51
967 #define f20 52
968 #define f21 53
969 #define f22 54
970 #define f23 55
971 #define f24 56
972 #define f25 57
973 #define f26 58
974 #define f27 59
975 #define f28 60
976 #define f29 61
977 #define f30 62
978 #define f31 63
979 #endif
980
981 #if powerpc_TARGET_ARCH
982 #define r0 0
983 #define r1 1
984 #define r2 2
985 #define r3 3
986 #define r4 4
987 #define r5 5
988 #define r6 6
989 #define r7 7
990 #define r8 8
991 #define r9 9
992 #define r10 10
993 #define r11 11
994 #define r12 12
995 #define r13 13
996 #define r14 14
997 #define r15 15
998 #define r16 16
999 #define r17 17
1000 #define r18 18
1001 #define r19 19
1002 #define r20 20
1003 #define r21 21
1004 #define r22 22
1005 #define r23 23
1006 #define r24 24
1007 #define r25 25
1008 #define r26 26
1009 #define r27 27
1010 #define r28 28
1011 #define r29 29
1012 #define r30 30
1013 #define r31 31
1014
1015 #ifdef darwin_TARGET_OS
1016 #define f0  32
1017 #define f1  33
1018 #define f2  34
1019 #define f3  35
1020 #define f4  36
1021 #define f5  37
1022 #define f6  38
1023 #define f7  39
1024 #define f8  40
1025 #define f9  41
1026 #define f10 42
1027 #define f11 43
1028 #define f12 44
1029 #define f13 45
1030 #define f14 46
1031 #define f15 47
1032 #define f16 48
1033 #define f17 49
1034 #define f18 50
1035 #define f19 51
1036 #define f20 52
1037 #define f21 53
1038 #define f22 54
1039 #define f23 55
1040 #define f24 56
1041 #define f25 57
1042 #define f26 58
1043 #define f27 59
1044 #define f28 60
1045 #define f29 61
1046 #define f30 62
1047 #define f31 63
1048 #else
1049 #define fr0  32
1050 #define fr1  33
1051 #define fr2  34
1052 #define fr3  35
1053 #define fr4  36
1054 #define fr5  37
1055 #define fr6  38
1056 #define fr7  39
1057 #define fr8  40
1058 #define fr9  41
1059 #define fr10 42
1060 #define fr11 43
1061 #define fr12 44
1062 #define fr13 45
1063 #define fr14 46
1064 #define fr15 47
1065 #define fr16 48
1066 #define fr17 49
1067 #define fr18 50
1068 #define fr19 51
1069 #define fr20 52
1070 #define fr21 53
1071 #define fr22 54
1072 #define fr23 55
1073 #define fr24 56
1074 #define fr25 57
1075 #define fr26 58
1076 #define fr27 59
1077 #define fr28 60
1078 #define fr29 61
1079 #define fr30 62
1080 #define fr31 63
1081 #endif
1082 #endif
1083
1084
1085 -- allMachRegs is the complete set of machine regs.
1086 allMachRegNos :: [RegNo]
1087 allMachRegNos
1088    = IF_ARCH_alpha( [0..63],
1089      IF_ARCH_i386(  [0..13],
1090      IF_ARCH_x86_64( [0..31],
1091      IF_ARCH_sparc( ([0..31]
1092                      ++ [f0,f2 .. nCG_FirstFloatReg-1]
1093                      ++ [nCG_FirstFloatReg .. f31]),
1094      IF_ARCH_powerpc([0..63],
1095                    )))))
1096
1097 -- allocatableRegs is allMachRegNos with the fixed-use regs removed.
1098 -- i.e., these are the regs for which we are prepared to allow the
1099 -- register allocator to attempt to map VRegs to.
1100 allocatableRegs :: [RegNo]
1101 allocatableRegs
1102    = let isFree i = isFastTrue (freeReg i)
1103      in  filter isFree allMachRegNos
1104
1105
1106 -- | The number of regs in each class.
1107 --      We go via top level CAFs to ensure that we're not recomputing
1108 --      the length of these lists each time the fn is called.
1109 allocatableRegsInClass :: RegClass -> Int
1110 allocatableRegsInClass cls
1111  = case cls of
1112         RcInteger       -> allocatableRegsInteger
1113         RcDouble        -> allocatableRegsDouble
1114
1115 allocatableRegsInteger  
1116         = length $ filter (\r -> regClass r == RcInteger) 
1117                  $ map RealReg allocatableRegs
1118
1119 allocatableRegsDouble
1120         = length $ filter (\r -> regClass r == RcDouble) 
1121                  $ map RealReg allocatableRegs
1122
1123
1124 -- these are the regs which we cannot assume stay alive over a
1125 -- C call.  
1126 callClobberedRegs :: [Reg]
1127 callClobberedRegs
1128   =
1129 #if alpha_TARGET_ARCH
1130     [0, 1, 2, 3, 4, 5, 6, 7, 8,
1131      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1132      fReg 0, fReg 1, fReg 10, fReg 11, fReg 12, fReg 13, fReg 14, fReg 15,
1133      fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21, fReg 22, fReg 23,
1134      fReg 24, fReg 25, fReg 26, fReg 27, fReg 28, fReg 29, fReg 30]
1135 #endif /* alpha_TARGET_ARCH */
1136 #if i386_TARGET_ARCH
1137     -- caller-saves registers
1138     map RealReg [eax,ecx,edx,fake0,fake1,fake2,fake3,fake4,fake5]
1139 #endif /* i386_TARGET_ARCH */
1140 #if x86_64_TARGET_ARCH
1141     -- caller-saves registers
1142     map RealReg ([rax,rcx,rdx,rsi,rdi,r8,r9,r10,r11] ++ [16..31])
1143        -- all xmm regs are caller-saves
1144 #endif /* x86_64_TARGET_ARCH */
1145 #if sparc_TARGET_ARCH
1146     map RealReg 
1147         ( oReg 7 :
1148           [oReg i | i <- [0..5]] ++
1149           [gReg i | i <- [1..7]] ++
1150           [fReg i | i <- [0..31]] )
1151 #endif /* sparc_TARGET_ARCH */
1152 #if powerpc_TARGET_ARCH
1153 #if darwin_TARGET_OS
1154     map RealReg (0:[2..12] ++ map fReg [0..13])
1155 #elif linux_TARGET_OS
1156     map RealReg (0:[2..13] ++ map fReg [0..13])
1157 #endif
1158 #endif /* powerpc_TARGET_ARCH */
1159
1160
1161 -- argRegs is the set of regs which are read for an n-argument call to C.
1162 -- For archs which pass all args on the stack (x86), is empty.
1163 -- Sparc passes up to the first 6 args in regs.
1164 -- Dunno about Alpha.
1165 argRegs :: RegNo -> [Reg]
1166
1167 #if i386_TARGET_ARCH
1168 argRegs _ = panic "MachRegs.argRegs(x86): should not be used!"
1169 #endif
1170
1171 #if x86_64_TARGET_ARCH
1172 argRegs _ = panic "MachRegs.argRegs(x86_64): should not be used!"
1173 #endif
1174
1175 #if alpha_TARGET_ARCH
1176 argRegs 0 = []
1177 argRegs 1 = freeMappedRegs [16, fReg 16]
1178 argRegs 2 = freeMappedRegs [16, 17, fReg 16, fReg 17]
1179 argRegs 3 = freeMappedRegs [16, 17, 18, fReg 16, fReg 17, fReg 18]
1180 argRegs 4 = freeMappedRegs [16, 17, 18, 19, fReg 16, fReg 17, fReg 18, fReg 19]
1181 argRegs 5 = freeMappedRegs [16, 17, 18, 19, 20, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20]
1182 argRegs 6 = freeMappedRegs [16, 17, 18, 19, 20, 21, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21]
1183 argRegs _ = panic "MachRegs.argRegs(alpha): don't know about >6 arguments!"
1184 #endif /* alpha_TARGET_ARCH */
1185
1186 #if sparc_TARGET_ARCH
1187 argRegs 0 = []
1188 argRegs 1 = map (RealReg . oReg) [0]
1189 argRegs 2 = map (RealReg . oReg) [0,1]
1190 argRegs 3 = map (RealReg . oReg) [0,1,2]
1191 argRegs 4 = map (RealReg . oReg) [0,1,2,3]
1192 argRegs 5 = map (RealReg . oReg) [0,1,2,3,4]
1193 argRegs 6 = map (RealReg . oReg) [0,1,2,3,4,5]
1194 argRegs _ = panic "MachRegs.argRegs(sparc): don't know about >6 arguments!"
1195 #endif /* sparc_TARGET_ARCH */
1196
1197 #if powerpc_TARGET_ARCH
1198 argRegs 0 = []
1199 argRegs 1 = map RealReg [3]
1200 argRegs 2 = map RealReg [3,4]
1201 argRegs 3 = map RealReg [3..5]
1202 argRegs 4 = map RealReg [3..6]
1203 argRegs 5 = map RealReg [3..7]
1204 argRegs 6 = map RealReg [3..8]
1205 argRegs 7 = map RealReg [3..9]
1206 argRegs 8 = map RealReg [3..10]
1207 argRegs _ = panic "MachRegs.argRegs(powerpc): don't know about >8 arguments!"
1208 #endif /* powerpc_TARGET_ARCH */
1209
1210
1211 -- all of the arg regs ??
1212 #if alpha_TARGET_ARCH
1213 allArgRegs :: [(Reg, Reg)]
1214 allArgRegs = [(realReg i, realReg (fReg i)) | i <- [16..21]]
1215 #endif /* alpha_TARGET_ARCH */
1216
1217 #if sparc_TARGET_ARCH
1218 allArgRegs :: [Reg]
1219 allArgRegs = map RealReg [oReg i | i <- [0..5]]
1220 #endif /* sparc_TARGET_ARCH */
1221
1222 #if i386_TARGET_ARCH
1223 allArgRegs :: [Reg]
1224 allArgRegs = panic "MachRegs.allArgRegs(x86): should not be used!"
1225 #endif
1226
1227 #if x86_64_TARGET_ARCH
1228 allArgRegs :: [Reg]
1229 allArgRegs = map RealReg [rdi,rsi,rdx,rcx,r8,r9]
1230 allFPArgRegs :: [Reg]
1231 allFPArgRegs = map RealReg [xmm0 .. xmm7]
1232 #endif
1233
1234 #if powerpc_TARGET_ARCH
1235 allArgRegs :: [Reg]
1236 allArgRegs = map RealReg [3..10]
1237 allFPArgRegs :: [Reg]
1238 #if darwin_TARGET_OS
1239 allFPArgRegs = map (RealReg . fReg) [1..13]
1240 #elif linux_TARGET_OS
1241 allFPArgRegs = map (RealReg . fReg) [1..8]
1242 #endif
1243 #endif /* powerpc_TARGET_ARCH */
1244 \end{code}
1245
1246 \begin{code}
1247 freeReg :: RegNo -> FastBool
1248
1249 #if alpha_TARGET_ARCH
1250 freeReg 26 = fastBool False  -- return address (ra)
1251 freeReg 28 = fastBool False  -- reserved for the assembler (at)
1252 freeReg 29 = fastBool False  -- global pointer (gp)
1253 freeReg 30 = fastBool False  -- stack pointer (sp)
1254 freeReg 31 = fastBool False  -- always zero (zeroh)
1255 freeReg 63 = fastBool False  -- always zero (f31)
1256 #endif
1257
1258 #if i386_TARGET_ARCH
1259 freeReg esp = fastBool False  --        %esp is the C stack pointer
1260 #endif
1261
1262 #if x86_64_TARGET_ARCH
1263 freeReg rsp = fastBool False  --        %rsp is the C stack pointer
1264 #endif
1265
1266 #if sparc_TARGET_ARCH
1267 freeReg g0 = fastBool False  -- %g0 is always 0.
1268 freeReg g5 = fastBool False  -- %g5 is reserved (ABI).
1269 freeReg g6 = fastBool False  -- %g6 is reserved (ABI).
1270 freeReg g7 = fastBool False  -- %g7 is reserved (ABI).
1271 freeReg i6 = fastBool False  -- %i6 is our frame pointer.
1272 freeReg i7 = fastBool False  -- %i7 tends to have ret-addr-ish things
1273 freeReg o6 = fastBool False  -- %o6 is our stack pointer.
1274 freeReg o7 = fastBool False  -- %o7 holds ret addrs (???)
1275 freeReg f0 = fastBool False  --  %f0/%f1 are the C fp return registers.
1276 freeReg f1 = fastBool False
1277 #endif
1278
1279 #if powerpc_TARGET_ARCH
1280 freeReg 0 = fastBool False -- Hack: r0 can't be used in all insns, but it's actually free
1281 freeReg 1 = fastBool False -- The Stack Pointer
1282 #if !darwin_TARGET_OS
1283  -- most non-darwin powerpc OSes use r2 as a TOC pointer or something like that
1284 freeReg 2 = fastBool False
1285 #endif
1286 #endif
1287
1288 #ifdef REG_Base
1289 freeReg REG_Base = fastBool False
1290 #endif
1291 #ifdef REG_R1
1292 freeReg REG_R1   = fastBool False
1293 #endif  
1294 #ifdef REG_R2  
1295 freeReg REG_R2   = fastBool False
1296 #endif  
1297 #ifdef REG_R3  
1298 freeReg REG_R3   = fastBool False
1299 #endif  
1300 #ifdef REG_R4  
1301 freeReg REG_R4   = fastBool False
1302 #endif  
1303 #ifdef REG_R5  
1304 freeReg REG_R5   = fastBool False
1305 #endif  
1306 #ifdef REG_R6  
1307 freeReg REG_R6   = fastBool False
1308 #endif  
1309 #ifdef REG_R7  
1310 freeReg REG_R7   = fastBool False
1311 #endif  
1312 #ifdef REG_R8  
1313 freeReg REG_R8   = fastBool False
1314 #endif
1315 #ifdef REG_F1
1316 freeReg REG_F1 = fastBool False
1317 #endif
1318 #ifdef REG_F2
1319 freeReg REG_F2 = fastBool False
1320 #endif
1321 #ifdef REG_F3
1322 freeReg REG_F3 = fastBool False
1323 #endif
1324 #ifdef REG_F4
1325 freeReg REG_F4 = fastBool False
1326 #endif
1327 #ifdef REG_D1
1328 freeReg REG_D1 = fastBool False
1329 #endif
1330 #ifdef REG_D2
1331 freeReg REG_D2 = fastBool False
1332 #endif
1333 #ifdef REG_Sp 
1334 freeReg REG_Sp   = fastBool False
1335 #endif 
1336 #ifdef REG_Su
1337 freeReg REG_Su   = fastBool False
1338 #endif 
1339 #ifdef REG_SpLim 
1340 freeReg REG_SpLim = fastBool False
1341 #endif 
1342 #ifdef REG_Hp 
1343 freeReg REG_Hp   = fastBool False
1344 #endif
1345 #ifdef REG_HpLim
1346 freeReg REG_HpLim = fastBool False
1347 #endif
1348 freeReg n               = fastBool True
1349
1350
1351 --  | Returns 'Nothing' if this global register is not stored
1352 -- in a real machine register, otherwise returns @'Just' reg@, where
1353 -- reg is the machine register it is stored in.
1354
1355 globalRegMaybe :: GlobalReg -> Maybe Reg
1356
1357 #ifdef REG_Base
1358 globalRegMaybe BaseReg                  = Just (RealReg REG_Base)
1359 #endif
1360 #ifdef REG_R1
1361 globalRegMaybe (VanillaReg 1)           = Just (RealReg REG_R1)
1362 #endif 
1363 #ifdef REG_R2 
1364 globalRegMaybe (VanillaReg 2)           = Just (RealReg REG_R2)
1365 #endif 
1366 #ifdef REG_R3 
1367 globalRegMaybe (VanillaReg 3)           = Just (RealReg REG_R3)
1368 #endif 
1369 #ifdef REG_R4 
1370 globalRegMaybe (VanillaReg 4)           = Just (RealReg REG_R4)
1371 #endif 
1372 #ifdef REG_R5 
1373 globalRegMaybe (VanillaReg 5)           = Just (RealReg REG_R5)
1374 #endif 
1375 #ifdef REG_R6 
1376 globalRegMaybe (VanillaReg 6)           = Just (RealReg REG_R6)
1377 #endif 
1378 #ifdef REG_R7 
1379 globalRegMaybe (VanillaReg 7)           = Just (RealReg REG_R7)
1380 #endif 
1381 #ifdef REG_R8 
1382 globalRegMaybe (VanillaReg 8)           = Just (RealReg REG_R8)
1383 #endif
1384 #ifdef REG_R9 
1385 globalRegMaybe (VanillaReg 9)           = Just (RealReg REG_R9)
1386 #endif
1387 #ifdef REG_R10 
1388 globalRegMaybe (VanillaReg 10)          = Just (RealReg REG_R10)
1389 #endif
1390 #ifdef REG_F1
1391 globalRegMaybe (FloatReg 1)             = Just (RealReg REG_F1)
1392 #endif                                  
1393 #ifdef REG_F2                           
1394 globalRegMaybe (FloatReg 2)             = Just (RealReg REG_F2)
1395 #endif                                  
1396 #ifdef REG_F3                           
1397 globalRegMaybe (FloatReg 3)             = Just (RealReg REG_F3)
1398 #endif                                  
1399 #ifdef REG_F4                           
1400 globalRegMaybe (FloatReg 4)             = Just (RealReg REG_F4)
1401 #endif                                  
1402 #ifdef REG_D1                           
1403 globalRegMaybe (DoubleReg 1)            = Just (RealReg REG_D1)
1404 #endif                                  
1405 #ifdef REG_D2                           
1406 globalRegMaybe (DoubleReg 2)            = Just (RealReg REG_D2)
1407 #endif
1408 #ifdef REG_Sp       
1409 globalRegMaybe Sp                       = Just (RealReg REG_Sp)
1410 #endif
1411 #ifdef REG_Lng1                         
1412 globalRegMaybe (LongReg 1)              = Just (RealReg REG_Lng1)
1413 #endif                                  
1414 #ifdef REG_Lng2                         
1415 globalRegMaybe (LongReg 2)              = Just (RealReg REG_Lng2)
1416 #endif
1417 #ifdef REG_SpLim                                
1418 globalRegMaybe SpLim                    = Just (RealReg REG_SpLim)
1419 #endif                                  
1420 #ifdef REG_Hp                           
1421 globalRegMaybe Hp                       = Just (RealReg REG_Hp)
1422 #endif                                  
1423 #ifdef REG_HpLim                        
1424 globalRegMaybe HpLim                    = Just (RealReg REG_HpLim)
1425 #endif                                  
1426 #ifdef REG_CurrentTSO                           
1427 globalRegMaybe CurrentTSO               = Just (RealReg REG_CurrentTSO)
1428 #endif                                  
1429 #ifdef REG_CurrentNursery                       
1430 globalRegMaybe CurrentNursery           = Just (RealReg REG_CurrentNursery)
1431 #endif                                  
1432 globalRegMaybe _                        = Nothing
1433
1434
1435 \end{code}