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