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