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