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