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