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, callerSaveVolatileRegs,
  37
  38         -- * Machine-dependent register-related stuff
  39         allocatableRegs, argRegs, allArgRegs, callClobberedRegs,
  40         freeReg,
  41         spRel,
  42
  43 #if alpha_TARGET_ARCH
  44         fits8Bits,
  45         fReg,
  46         gp, pv, ra, sp, t9, t10, t11, t12, v0, f0, zeroh,
  47 #endif
  48 #if i386_TARGET_ARCH
  49         EABase(..), EAIndex(..),
  50         eax, ebx, ecx, edx, esi, edi, ebp, esp,
  51         fake0, fake1, fake2, fake3, fake4, fake5,
  52         addrModeRegs,
  53 #endif
  54 #if x86_64_TARGET_ARCH
  55         EABase(..), EAIndex(..), ripRel,
  56         rax, rbx, rcx, rdx, rsi, rdi, rbp, rsp,
  57         eax, ebx, ecx, edx, esi, edi, ebp, esp,
  58         r8, r9, r10, r11, r12, r13, r14, r15,
  59         xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7,
  60         xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15,
  61         xmm,
  62         addrModeRegs, allFPArgRegs,
  63 #endif
  64 #if sparc_TARGET_ARCH
  65         fits13Bits,
  66         fpRel, gReg, iReg, lReg, oReg, largeOffsetError,
  67         fp, sp, g0, g1, g2, o0, o1, f0, f6, f8, f26, f27,
  68 #endif
  69 #if powerpc_TARGET_ARCH
  70         allFPArgRegs,
  71         makeImmediate,
  72         sp,
  73         r3, r4, r27, r28,
  74         f1, f20, f21,
  75 #endif
  76     ) where
  77
  78 #include "HsVersions.h"
  79
  80 #if i386_TARGET_ARCH
  81 # define STOLEN_X86_REGS 4
  82 -- HACK: go for the max
  83 #endif
  84
  85 #include "../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 -- caller-save registers
 347
 348 -- Here we generate the sequence of saves/restores required around a
 349 -- foreign call instruction.
 350
 351 callerSaveVolatileRegs :: Maybe [GlobalReg] -> ([CmmStmt], [CmmStmt])
 352 callerSaveVolatileRegs vols = (caller_save, caller_load)
 353   where
 354     caller_save = foldr ($!) [] (map callerSaveGlobalReg    regs_to_save)
 355     caller_load = foldr ($!) [] (map callerRestoreGlobalReg regs_to_save)
 356
 357     system_regs = [Sp,SpLim,Hp,HpLim,CurrentTSO,CurrentNursery,
 358                    {-SparkHd,SparkTl,SparkBase,SparkLim,-}BaseReg ]
 359
 360     regs_to_save = system_regs ++ vol_list
 361
 362     vol_list = case vols of Nothing -> all_of_em; Just regs -> regs
 363
 364     all_of_em = [ VanillaReg n | n <- [0..mAX_Vanilla_REG] ]
 365              ++ [ FloatReg   n | n <- [0..mAX_Float_REG] ]
 366              ++ [ DoubleReg  n | n <- [0..mAX_Double_REG] ]
 367              ++ [ LongReg    n | n <- [0..mAX_Long_REG] ]
 368
 369     callerSaveGlobalReg reg next
 370         | callerSaves reg =
 371                 CmmStore (get_GlobalReg_addr reg)
 372                          (CmmReg (CmmGlobal reg)) : next
 373         | otherwise = next
 374
 375     callerRestoreGlobalReg reg next
 376         | callerSaves reg =
 377                 CmmAssign (CmmGlobal reg)
 378                           (CmmLoad (get_GlobalReg_addr reg) (globalRegRep reg))
 379                         : next
 380         | otherwise = next
 381
 382
 383 -- ---------------------------------------------------------------------------
 384 -- Registers
 385
 386 -- RealRegs are machine regs which are available for allocation, in
 387 -- the usual way.  We know what class they are, because that's part of
 388 -- the processor's architecture.
 389
 390 -- VirtualRegs are virtual registers.  The register allocator will
 391 -- eventually have to map them into RealRegs, or into spill slots.
 392 -- VirtualRegs are allocated on the fly, usually to represent a single
 393 -- value in the abstract assembly code (i.e. dynamic registers are
 394 -- usually single assignment).  With the new register allocator, the
 395 -- single assignment restriction isn't necessary to get correct code,
 396 -- although a better register allocation will result if single
 397 -- assignment is used -- because the allocator maps a VirtualReg into
 398 -- a single RealReg, even if the VirtualReg has multiple live ranges.
 399
 400 -- Virtual regs can be of either class, so that info is attached.
 401
 402 -- Determine the upper-half vreg for a 64-bit quantity on a 32-bit platform
 403 -- when supplied with the vreg for the lower-half of the quantity.
 404 -- (NB. Not reversible).
 405 getHiVRegFromLo (VirtualRegI u)
 406    = VirtualRegHi (newTagUnique u 'H') -- makes a pseudo-unique with tag 'H'
 407 getHiVRegFromLo other
 408    = pprPanic "getHiVRegFromLo" (ppr other)
 409
 410 data RegClass
 411    = RcInteger
 412    | RcFloat
 413    | RcDouble
 414      deriving Eq
 415
 416 type RegNo = Int
 417
 418 data Reg
 419    = RealReg      {-# UNPACK #-} !RegNo
 420    | VirtualRegI  {-# UNPACK #-} !Unique
 421    | VirtualRegHi {-# UNPACK #-} !Unique  -- High part of 2-word register
 422    | VirtualRegF  {-# UNPACK #-} !Unique
 423    | VirtualRegD  {-# UNPACK #-} !Unique
 424    deriving (Eq,Ord)
 425
 426 -- We like to have Uniques for Reg so that we can make UniqFM and UniqSets
 427 -- in the register allocator.
 428 instance Uniquable Reg where
 429    getUnique (RealReg i)      = mkUnique 'C' i
 430    getUnique (VirtualRegI u)  = u
 431    getUnique (VirtualRegHi u) = u
 432    getUnique (VirtualRegF u)  = u
 433    getUnique (VirtualRegD u)  = u
 434
 435 unRealReg (RealReg i) = i
 436 unRealReg vreg        = pprPanic "unRealReg on VirtualReg" (ppr vreg)
 437
 438 mkVReg :: Unique -> MachRep -> Reg
 439 mkVReg u rep
 440    = case rep of
 441 #if sparc_TARGET_ARCH
 442         F32   -> VirtualRegF u
 443 #else
 444         F32   -> VirtualRegD u
 445 #endif
 446         F64   -> VirtualRegD u
 447         other -> VirtualRegI u
 448
 449 isVirtualReg :: Reg -> Bool
 450 isVirtualReg (RealReg _)      = False
 451 isVirtualReg (VirtualRegI _)  = True
 452 isVirtualReg (VirtualRegHi _) = True
 453 isVirtualReg (VirtualRegF _)  = True
 454 isVirtualReg (VirtualRegD _)  = True
 455
 456 isRealReg :: Reg -> Bool
 457 isRealReg = not . isVirtualReg
 458
 459 instance Show Reg where
 460     show (RealReg i)      = showReg i
 461     show (VirtualRegI u)  = "%vI_" ++ show u
 462     show (VirtualRegHi u) = "%vHi_" ++ show u
 463     show (VirtualRegF u)  = "%vF_" ++ show u
 464     show (VirtualRegD u)  = "%vD_" ++ show u
 465
 466 instance Outputable Reg where
 467     ppr r = Outputable.text (show r)
 468
 469
 470 -- -----------------------------------------------------------------------------
 471 -- Machine-specific register stuff
 472
 473 -- The Alpha has 64 registers of interest; 32 integer registers and 32 floating
 474 -- point registers.  The mapping of STG registers to alpha machine registers
 475 -- is defined in StgRegs.h.  We are, of course, prepared for any eventuality.
 476
 477 #if alpha_TARGET_ARCH
 478 fReg :: Int -> RegNo
 479 fReg x = (32 + x)
 480
 481 v0, f0, ra, pv, gp, sp, zeroh :: Reg
 482 v0    = realReg 0
 483 f0    = realReg (fReg 0)
 484 ra    = FixedReg ILIT(26)
 485 pv    = t12
 486 gp    = FixedReg ILIT(29)
 487 sp    = FixedReg ILIT(30)
 488 zeroh = FixedReg ILIT(31) -- "zero" is used in 1.3 (MonadZero method)
 489
 490 t9, t10, t11, t12 :: Reg
 491 t9  = realReg 23
 492 t10 = realReg 24
 493 t11 = realReg 25
 494 t12 = realReg 27
 495 #endif
 496
 497 {-
 498 Intel x86 architecture:
 499 - All registers except 7 (esp) are available for use.
 500 - Only ebx, esi, edi and esp are available across a C call (they are callee-saves).
 501 - Registers 0-7 have 16-bit counterparts (ax, bx etc.)
 502 - Registers 0-3 have 8 bit counterparts (ah, bh etc.)
 503 - Registers 8-13 are fakes; we pretend x86 has 6 conventionally-addressable
 504   fp registers, and 3-operand insns for them, and we translate this into
 505   real stack-based x86 fp code after register allocation.
 506
 507 The fp registers are all Double registers; we don't have any RcFloat class
 508 regs.  @regClass@ barfs if you give it a VirtualRegF, and mkVReg above should
 509 never generate them.
 510 -}
 511
 512 #if i386_TARGET_ARCH
 513
 514 fake0, fake1, fake2, fake3, fake4, fake5,
 515        eax, ebx, ecx, edx, esp, ebp, esi, edi :: Reg
 516 eax   = RealReg 0
 517 ebx   = RealReg 1
 518 ecx   = RealReg 2
 519 edx   = RealReg 3
 520 esi   = RealReg 4
 521 edi   = RealReg 5
 522 ebp   = RealReg 6
 523 esp   = RealReg 7
 524 fake0 = RealReg 8
 525 fake1 = RealReg 9
 526 fake2 = RealReg 10
 527 fake3 = RealReg 11
 528 fake4 = RealReg 12
 529 fake5 = RealReg 13
 530
 531 -- On x86, we might want to have an 8-bit RegClass, which would
 532 -- contain just regs 1-4 (the others don't have 8-bit versions).
 533 -- However, we can get away without this at the moment because the
 534 -- only allocatable integer regs are also 8-bit compatible (1, 3, 4).
 535 regClass (RealReg i)     = if i < 8 then RcInteger else RcDouble
 536 regClass (VirtualRegI  u) = RcInteger
 537 regClass (VirtualRegHi u) = RcInteger
 538 regClass (VirtualRegD  u) = RcDouble
 539 regClass (VirtualRegF  u) = pprPanic "regClass(x86):VirtualRegF"
 540                                     (ppr (VirtualRegF u))
 541
 542 regNames
 543    = ["%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi", "%ebp", "%esp",
 544       "%fake0", "%fake1", "%fake2", "%fake3", "%fake4", "%fake5", "%fake6"]
 545
 546 showReg :: RegNo -> String
 547 showReg n
 548    = if   n >= 0 && n < 14
 549      then regNames !! n
 550      else "%unknown_x86_real_reg_" ++ show n
 551
 552 #endif
 553
 554 {-
 555 AMD x86_64 architecture:
 556 - Registers 0-16 have 32-bit counterparts (eax, ebx etc.)
 557 - Registers 0-7 have 16-bit counterparts (ax, bx etc.)
 558 - Registers 0-3 have 8 bit counterparts (ah, bh etc.)
 559
 560 -}
 561
 562 #if x86_64_TARGET_ARCH
 563
 564 rax, rbx, rcx, rdx, rsp, rbp, rsi, rdi,
 565   r8, r9, r10, r11, r12, r13, r14, r15,
 566   xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7,
 567   xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15 :: Reg
 568
 569 rax   = RealReg 0
 570 rbx   = RealReg 1
 571 rcx   = RealReg 2
 572 rdx   = RealReg 3
 573 rsi   = RealReg 4
 574 rdi   = RealReg 5
 575 rbp   = RealReg 6
 576 rsp   = RealReg 7
 577 r8    = RealReg 8
 578 r9    = RealReg 9
 579 r10   = RealReg 10
 580 r11   = RealReg 11
 581 r12   = RealReg 12
 582 r13   = RealReg 13
 583 r14   = RealReg 14
 584 r15   = RealReg 15
 585 xmm0  = RealReg 16
 586 xmm1  = RealReg 17
 587 xmm2  = RealReg 18
 588 xmm3  = RealReg 19
 589 xmm4  = RealReg 20
 590 xmm5  = RealReg 21
 591 xmm6  = RealReg 22
 592 xmm7  = RealReg 23
 593 xmm8  = RealReg 24
 594 xmm9  = RealReg 25
 595 xmm10 = RealReg 26
 596 xmm11 = RealReg 27
 597 xmm12 = RealReg 28
 598 xmm13 = RealReg 29
 599 xmm14 = RealReg 30
 600 xmm15 = RealReg 31
 601
 602  -- so we can re-use some x86 code:
 603 eax = rax
 604 ebx = rbx
 605 ecx = rcx
 606 edx = rdx
 607 esi = rsi
 608 edi = rdi
 609 ebp = rbp
 610 esp = rsp
 611
 612 xmm n = RealReg (16+n)
 613
 614 -- On x86, we might want to have an 8-bit RegClass, which would
 615 -- contain just regs 1-4 (the others don't have 8-bit versions).
 616 -- However, we can get away without this at the moment because the
 617 -- only allocatable integer regs are also 8-bit compatible (1, 3, 4).
 618 regClass (RealReg i)     = if i < 16 then RcInteger else RcDouble
 619 regClass (VirtualRegI  u) = RcInteger
 620 regClass (VirtualRegHi u) = RcInteger
 621 regClass (VirtualRegD  u) = RcDouble
 622 regClass (VirtualRegF  u) = pprPanic "regClass(x86_64):VirtualRegF"
 623                                     (ppr (VirtualRegF u))
 624
 625 regNames
 626  = ["%rax", "%rbx", "%rcx", "%rdx", "%rsi", "%rdi", "%rbp", "%rsp" ]
 627
 628 showReg :: RegNo -> String
 629 showReg n
 630   | n >= 16 = "%xmm" ++ show (n-16)
 631   | n >= 8  = "%r" ++ show n
 632   | otherwise = regNames !! n
 633
 634 #endif
 635
 636 {-
 637 The SPARC has 64 registers of interest; 32 integer registers and 32
 638 floating point registers.  The mapping of STG registers to SPARC
 639 machine registers is defined in StgRegs.h.  We are, of course,
 640 prepared for any eventuality.
 641
 642 The whole fp-register pairing thing on sparcs is a huge nuisance.  See
 643 fptools/ghc/includes/MachRegs.h for a description of what's going on
 644 here.
 645 -}
 646
 647 #if sparc_TARGET_ARCH
 648
 649 gReg,lReg,iReg,oReg,fReg :: Int -> RegNo
 650 gReg x = x
 651 oReg x = (8 + x)
 652 lReg x = (16 + x)
 653 iReg x = (24 + x)
 654 fReg x = (32 + x)
 655
 656 nCG_FirstFloatReg :: RegNo
 657 nCG_FirstFloatReg = unRealReg NCG_FirstFloatReg
 658
 659 regClass (VirtualRegI u) = RcInteger
 660 regClass (VirtualRegF u) = RcFloat
 661 regClass (VirtualRegD u) = RcDouble
 662 regClass (RealReg i) | i < 32                = RcInteger
 663                      | i < nCG_FirstFloatReg = RcDouble
 664                      | otherwise             = RcFloat
 665
 666 showReg :: RegNo -> String
 667 showReg n
 668    | n >= 0  && n < 8   = "%g" ++ show n
 669    | n >= 8  && n < 16  = "%o" ++ show (n-8)
 670    | n >= 16 && n < 24  = "%l" ++ show (n-16)
 671    | n >= 24 && n < 32  = "%i" ++ show (n-24)
 672    | n >= 32 && n < 64  = "%f" ++ show (n-32)
 673    | otherwise          = "%unknown_sparc_real_reg_" ++ show n
 674
 675 g0, g1, g2, fp, sp, o0, o1, f0, f1, f6, f8, f22, f26, f27 :: Reg
 676
 677 f6  = RealReg (fReg 6)
 678 f8  = RealReg (fReg 8)
 679 f22 = RealReg (fReg 22)
 680 f26 = RealReg (fReg 26)
 681 f27 = RealReg (fReg 27)
 682
 683
 684 -- g0 is useful for codegen; is always zero, and writes to it vanish.
 685 g0  = RealReg (gReg 0)
 686 g1  = RealReg (gReg 1)
 687 g2  = RealReg (gReg 2)
 688
 689 -- FP, SP, int and float return (from C) regs.
 690 fp  = RealReg (iReg 6)
 691 sp  = RealReg (oReg 6)
 692 o0  = RealReg (oReg 0)
 693 o1  = RealReg (oReg 1)
 694 f0  = RealReg (fReg 0)
 695 f1  = RealReg (fReg 1)
 696
 697 #endif
 698
 699 {-
 700 The PowerPC has 64 registers of interest; 32 integer registers and 32 floating
 701 point registers.
 702 -}
 703
 704 #if powerpc_TARGET_ARCH
 705 fReg :: Int -> RegNo
 706 fReg x = (32 + x)
 707
 708 regClass (VirtualRegI  u) = RcInteger
 709 regClass (VirtualRegHi u) = RcInteger
 710 regClass (VirtualRegF  u) = pprPanic "regClass(ppc):VirtualRegF"
 711                                     (ppr (VirtualRegF u))
 712 regClass (VirtualRegD u) = RcDouble
 713 regClass (RealReg i) | i < 32                = RcInteger
 714                      | otherwise             = RcDouble
 715
 716 showReg :: RegNo -> String
 717 showReg n
 718     | n >= 0 && n <= 31   = "%r" ++ show n
 719     | n >= 32 && n <= 63  = "%f" ++ show (n - 32)
 720     | otherwise           = "%unknown_powerpc_real_reg_" ++ show n
 721
 722 sp = RealReg 1
 723 r3 = RealReg 3
 724 r4 = RealReg 4
 725 r27 = RealReg 27
 726 r28 = RealReg 28
 727 f1 = RealReg $ fReg 1
 728 f20 = RealReg $ fReg 20
 729 f21 = RealReg $ fReg 21
 730 #endif
 731
 732 {-
 733 Redefine the literals used for machine-registers with non-numeric
 734 names in the header files.  Gag me with a spoon, eh?
 735 -}
 736
 737 #if alpha_TARGET_ARCH
 738 #define f0 32
 739 #define f1 33
 740 #define f2 34
 741 #define f3 35
 742 #define f4 36
 743 #define f5 37
 744 #define f6 38
 745 #define f7 39
 746 #define f8 40
 747 #define f9 41
 748 #define f10 42
 749 #define f11 43
 750 #define f12 44
 751 #define f13 45
 752 #define f14 46
 753 #define f15 47
 754 #define f16 48
 755 #define f17 49
 756 #define f18 50
 757 #define f19 51
 758 #define f20 52
 759 #define f21 53
 760 #define f22 54
 761 #define f23 55
 762 #define f24 56
 763 #define f25 57
 764 #define f26 58
 765 #define f27 59
 766 #define f28 60
 767 #define f29 61
 768 #define f30 62
 769 #define f31 63
 770 #endif
 771 #if i386_TARGET_ARCH
 772 #define eax 0
 773 #define ebx 1
 774 #define ecx 2
 775 #define edx 3
 776 #define esi 4
 777 #define edi 5
 778 #define ebp 6
 779 #define esp 7
 780 #define fake0 8
 781 #define fake1 9
 782 #define fake2 10
 783 #define fake3 11
 784 #define fake4 12
 785 #define fake5 13
 786 #endif
 787
 788 #if x86_64_TARGET_ARCH
 789 #define rax   0
 790 #define rbx   1
 791 #define rcx   2
 792 #define rdx   3
 793 #define rsi   4
 794 #define rdi   5
 795 #define rbp   6
 796 #define rsp   7
 797 #define r8    8
 798 #define r9    9
 799 #define r10   10
 800 #define r11   11
 801 #define r12   12
 802 #define r13   13
 803 #define r14   14
 804 #define r15   15
 805 #define xmm0  16
 806 #define xmm1  17
 807 #define xmm2  18
 808 #define xmm3  19
 809 #define xmm4  20
 810 #define xmm5  21
 811 #define xmm6  22
 812 #define xmm7  23
 813 #define xmm8  24
 814 #define xmm9  25
 815 #define xmm10 26
 816 #define xmm11 27
 817 #define xmm12 28
 818 #define xmm13 29
 819 #define xmm14 30
 820 #define xmm15 31
 821 #endif
 822
 823 #if sparc_TARGET_ARCH
 824 #define g0 0
 825 #define g1 1
 826 #define g2 2
 827 #define g3 3
 828 #define g4 4
 829 #define g5 5
 830 #define g6 6
 831 #define g7 7
 832 #define o0 8
 833 #define o1 9
 834 #define o2 10
 835 #define o3 11
 836 #define o4 12
 837 #define o5 13
 838 #define o6 14
 839 #define o7 15
 840 #define l0 16
 841 #define l1 17
 842 #define l2 18
 843 #define l3 19
 844 #define l4 20
 845 #define l5 21
 846 #define l6 22
 847 #define l7 23
 848 #define i0 24
 849 #define i1 25
 850 #define i2 26
 851 #define i3 27
 852 #define i4 28
 853 #define i5 29
 854 #define i6 30
 855 #define i7 31
 856
 857 #define f0  32
 858 #define f1  33
 859 #define f2  34
 860 #define f3  35
 861 #define f4  36
 862 #define f5  37
 863 #define f6  38
 864 #define f7  39
 865 #define f8  40
 866 #define f9  41
 867 #define f10 42
 868 #define f11 43
 869 #define f12 44
 870 #define f13 45
 871 #define f14 46
 872 #define f15 47
 873 #define f16 48
 874 #define f17 49
 875 #define f18 50
 876 #define f19 51
 877 #define f20 52
 878 #define f21 53
 879 #define f22 54
 880 #define f23 55
 881 #define f24 56
 882 #define f25 57
 883 #define f26 58
 884 #define f27 59
 885 #define f28 60
 886 #define f29 61
 887 #define f30 62
 888 #define f31 63
 889 #endif
 890
 891 #if powerpc_TARGET_ARCH
 892 #define r0 0
 893 #define r1 1
 894 #define r2 2
 895 #define r3 3
 896 #define r4 4
 897 #define r5 5
 898 #define r6 6
 899 #define r7 7
 900 #define r8 8
 901 #define r9 9
 902 #define r10 10
 903 #define r11 11
 904 #define r12 12
 905 #define r13 13
 906 #define r14 14
 907 #define r15 15
 908 #define r16 16
 909 #define r17 17
 910 #define r18 18
 911 #define r19 19
 912 #define r20 20
 913 #define r21 21
 914 #define r22 22
 915 #define r23 23
 916 #define r24 24
 917 #define r25 25
 918 #define r26 26
 919 #define r27 27
 920 #define r28 28
 921 #define r29 29
 922 #define r30 30
 923 #define r31 31
 924
 925 #ifdef darwin_TARGET_OS
 926 #define f0  32
 927 #define f1  33
 928 #define f2  34
 929 #define f3  35
 930 #define f4  36
 931 #define f5  37
 932 #define f6  38
 933 #define f7  39
 934 #define f8  40
 935 #define f9  41
 936 #define f10 42
 937 #define f11 43
 938 #define f12 44
 939 #define f13 45
 940 #define f14 46
 941 #define f15 47
 942 #define f16 48
 943 #define f17 49
 944 #define f18 50
 945 #define f19 51
 946 #define f20 52
 947 #define f21 53
 948 #define f22 54
 949 #define f23 55
 950 #define f24 56
 951 #define f25 57
 952 #define f26 58
 953 #define f27 59
 954 #define f28 60
 955 #define f29 61
 956 #define f30 62
 957 #define f31 63
 958 #else
 959 #define fr0  32
 960 #define fr1  33
 961 #define fr2  34
 962 #define fr3  35
 963 #define fr4  36
 964 #define fr5  37
 965 #define fr6  38
 966 #define fr7  39
 967 #define fr8  40
 968 #define fr9  41
 969 #define fr10 42
 970 #define fr11 43
 971 #define fr12 44
 972 #define fr13 45
 973 #define fr14 46
 974 #define fr15 47
 975 #define fr16 48
 976 #define fr17 49
 977 #define fr18 50
 978 #define fr19 51
 979 #define fr20 52
 980 #define fr21 53
 981 #define fr22 54
 982 #define fr23 55
 983 #define fr24 56
 984 #define fr25 57
 985 #define fr26 58
 986 #define fr27 59
 987 #define fr28 60
 988 #define fr29 61
 989 #define fr30 62
 990 #define fr31 63
 991 #endif
 992 #endif
 993
 994
 995 -- allMachRegs is the complete set of machine regs.
 996 allMachRegNos :: [RegNo]
 997 allMachRegNos
 998    = IF_ARCH_alpha( [0..63],
 999      IF_ARCH_i386(  [0..13],
1000      IF_ARCH_x86_64( [0..31],
1001      IF_ARCH_sparc( ([0..31]
1002                      ++ [f0,f2 .. nCG_FirstFloatReg-1]
1003                      ++ [nCG_FirstFloatReg .. f31]),
1004      IF_ARCH_powerpc([0..63],
1005                    )))))
1006
1007 -- allocatableRegs is allMachRegNos with the fixed-use regs removed.
1008 -- i.e., these are the regs for which we are prepared to allow the
1009 -- register allocator to attempt to map VRegs to.
1010 allocatableRegs :: [RegNo]
1011 allocatableRegs
1012    = let isFree i = isFastTrue (freeReg i)
1013      in  filter isFree allMachRegNos
1014
1015 -- these are the regs which we cannot assume stay alive over a
1016 -- C call.
1017 callClobberedRegs :: [Reg]
1018 callClobberedRegs
1019   =
1020 #if alpha_TARGET_ARCH
1021     [0, 1, 2, 3, 4, 5, 6, 7, 8,
1022      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1023      fReg 0, fReg 1, fReg 10, fReg 11, fReg 12, fReg 13, fReg 14, fReg 15,
1024      fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21, fReg 22, fReg 23,
1025      fReg 24, fReg 25, fReg 26, fReg 27, fReg 28, fReg 29, fReg 30]
1026 #endif /* alpha_TARGET_ARCH */
1027 #if i386_TARGET_ARCH
1028     -- caller-saves registers
1029     map RealReg [eax,ecx,edx,fake0,fake1,fake2,fake3,fake4,fake5]
1030 #endif /* i386_TARGET_ARCH */
1031 #if x86_64_TARGET_ARCH
1032     -- caller-saves registers
1033     map RealReg ([rax,rcx,rdx,rsi,rdi,r8,r9,r10,r11] ++ [16..31])
1034        -- all xmm regs are caller-saves
1035 #endif /* x86_64_TARGET_ARCH */
1036 #if sparc_TARGET_ARCH
1037     map RealReg
1038         ( oReg 7 :
1039           [oReg i | i <- [0..5]] ++
1040           [gReg i | i <- [1..7]] ++
1041           [fReg i | i <- [0..31]] )
1042 #endif /* sparc_TARGET_ARCH */
1043 #if powerpc_TARGET_ARCH
1044 #if darwin_TARGET_OS
1045     map RealReg (0:[2..12] ++ map fReg [0..13])
1046 #elif linux_TARGET_OS
1047     map RealReg (0:[2..13] ++ map fReg [0..13])
1048 #endif
1049 #endif /* powerpc_TARGET_ARCH */
1050
1051
1052 -- argRegs is the set of regs which are read for an n-argument call to C.
1053 -- For archs which pass all args on the stack (x86), is empty.
1054 -- Sparc passes up to the first 6 args in regs.
1055 -- Dunno about Alpha.
1056 argRegs :: RegNo -> [Reg]
1057
1058 #if i386_TARGET_ARCH
1059 argRegs _ = panic "MachRegs.argRegs(x86): should not be used!"
1060 #endif
1061
1062 #if x86_64_TARGET_ARCH
1063 argRegs _ = panic "MachRegs.argRegs(x86_64): should not be used!"
1064 #endif
1065
1066 #if alpha_TARGET_ARCH
1067 argRegs 0 = []
1068 argRegs 1 = freeMappedRegs [16, fReg 16]
1069 argRegs 2 = freeMappedRegs [16, 17, fReg 16, fReg 17]
1070 argRegs 3 = freeMappedRegs [16, 17, 18, fReg 16, fReg 17, fReg 18]
1071 argRegs 4 = freeMappedRegs [16, 17, 18, 19, fReg 16, fReg 17, fReg 18, fReg 19]
1072 argRegs 5 = freeMappedRegs [16, 17, 18, 19, 20, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20]
1073 argRegs 6 = freeMappedRegs [16, 17, 18, 19, 20, 21, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21]
1074 argRegs _ = panic "MachRegs.argRegs(alpha): don't know about >6 arguments!"
1075 #endif /* alpha_TARGET_ARCH */
1076
1077 #if sparc_TARGET_ARCH
1078 argRegs 0 = []
1079 argRegs 1 = map (RealReg . oReg) [0]
1080 argRegs 2 = map (RealReg . oReg) [0,1]
1081 argRegs 3 = map (RealReg . oReg) [0,1,2]
1082 argRegs 4 = map (RealReg . oReg) [0,1,2,3]
1083 argRegs 5 = map (RealReg . oReg) [0,1,2,3,4]
1084 argRegs 6 = map (RealReg . oReg) [0,1,2,3,4,5]
1085 argRegs _ = panic "MachRegs.argRegs(sparc): don't know about >6 arguments!"
1086 #endif /* sparc_TARGET_ARCH */
1087
1088 #if powerpc_TARGET_ARCH
1089 argRegs 0 = []
1090 argRegs 1 = map RealReg [3]
1091 argRegs 2 = map RealReg [3,4]
1092 argRegs 3 = map RealReg [3..5]
1093 argRegs 4 = map RealReg [3..6]
1094 argRegs 5 = map RealReg [3..7]
1095 argRegs 6 = map RealReg [3..8]
1096 argRegs 7 = map RealReg [3..9]
1097 argRegs 8 = map RealReg [3..10]
1098 argRegs _ = panic "MachRegs.argRegs(powerpc): don't know about >8 arguments!"
1099 #endif /* powerpc_TARGET_ARCH */
1100
1101
1102 -- all of the arg regs ??
1103 #if alpha_TARGET_ARCH
1104 allArgRegs :: [(Reg, Reg)]
1105 allArgRegs = [(realReg i, realReg (fReg i)) | i <- [16..21]]
1106 #endif /* alpha_TARGET_ARCH */
1107
1108 #if sparc_TARGET_ARCH
1109 allArgRegs :: [Reg]
1110 allArgRegs = map RealReg [oReg i | i <- [0..5]]
1111 #endif /* sparc_TARGET_ARCH */
1112
1113 #if i386_TARGET_ARCH
1114 allArgRegs :: [Reg]
1115 allArgRegs = panic "MachRegs.allArgRegs(x86): should not be used!"
1116 #endif
1117
1118 #if x86_64_TARGET_ARCH
1119 allArgRegs :: [Reg]
1120 allArgRegs = map RealReg [rdi,rsi,rdx,rcx,r8,r9]
1121 allFPArgRegs :: [Reg]
1122 allFPArgRegs = map RealReg [xmm0 .. xmm7]
1123 #endif
1124
1125 #if powerpc_TARGET_ARCH
1126 allArgRegs :: [Reg]
1127 allArgRegs = map RealReg [3..10]
1128 allFPArgRegs :: [Reg]
1129 #if darwin_TARGET_OS
1130 allFPArgRegs = map (RealReg . fReg) [1..13]
1131 #elif linux_TARGET_OS
1132 allFPArgRegs = map (RealReg . fReg) [1..8]
1133 #endif
1134 #endif /* powerpc_TARGET_ARCH */
1135 \end{code}
1136
1137 \begin{code}
1138 freeReg :: RegNo -> FastBool
1139
1140 #if alpha_TARGET_ARCH
1141 freeReg 26 = fastBool False  -- return address (ra)
1142 freeReg 28 = fastBool False  -- reserved for the assembler (at)
1143 freeReg 29 = fastBool False  -- global pointer (gp)
1144 freeReg 30 = fastBool False  -- stack pointer (sp)
1145 freeReg 31 = fastBool False  -- always zero (zeroh)
1146 freeReg 63 = fastBool False  -- always zero (f31)
1147 #endif
1148
1149 #if i386_TARGET_ARCH
1150 freeReg esp = fastBool False  --        %esp is the C stack pointer
1151 #endif
1152
1153 #if x86_64_TARGET_ARCH
1154 freeReg rsp = fastBool False  --        %rsp is the C stack pointer
1155 #endif
1156
1157 #if sparc_TARGET_ARCH
1158 freeReg g0 = fastBool False  -- %g0 is always 0.
1159 freeReg g5 = fastBool False  -- %g5 is reserved (ABI).
1160 freeReg g6 = fastBool False  -- %g6 is reserved (ABI).
1161 freeReg g7 = fastBool False  -- %g7 is reserved (ABI).
1162 freeReg i6 = fastBool False  -- %i6 is our frame pointer.
1163 freeReg i7 = fastBool False  -- %i7 tends to have ret-addr-ish things
1164 freeReg o6 = fastBool False  -- %o6 is our stack pointer.
1165 freeReg o7 = fastBool False  -- %o7 holds ret addrs (???)
1166 freeReg f0 = fastBool False  --  %f0/%f1 are the C fp return registers.
1167 freeReg f1 = fastBool False
1168 #endif
1169
1170 #if powerpc_TARGET_ARCH
1171 freeReg 0 = fastBool False -- Hack: r0 can't be used in all insns, but it's actually free
1172 freeReg 1 = fastBool False -- The Stack Pointer
1173 #if !darwin_TARGET_OS
1174  -- most non-darwin powerpc OSes use r2 as a TOC pointer or something like that
1175 freeReg 2 = fastBool False
1176 #endif
1177 #endif
1178
1179 #ifdef REG_Base
1180 freeReg REG_Base = fastBool False
1181 #endif
1182 #ifdef REG_R1
1183 freeReg REG_R1   = fastBool False
1184 #endif
1185 #ifdef REG_R2
1186 freeReg REG_R2   = fastBool False
1187 #endif
1188 #ifdef REG_R3
1189 freeReg REG_R3   = fastBool False
1190 #endif
1191 #ifdef REG_R4
1192 freeReg REG_R4   = fastBool False
1193 #endif
1194 #ifdef REG_R5
1195 freeReg REG_R5   = fastBool False
1196 #endif
1197 #ifdef REG_R6
1198 freeReg REG_R6   = fastBool False
1199 #endif
1200 #ifdef REG_R7
1201 freeReg REG_R7   = fastBool False
1202 #endif
1203 #ifdef REG_R8
1204 freeReg REG_R8   = fastBool False
1205 #endif
1206 #ifdef REG_F1
1207 freeReg REG_F1 = fastBool False
1208 #endif
1209 #ifdef REG_F2
1210 freeReg REG_F2 = fastBool False
1211 #endif
1212 #ifdef REG_F3
1213 freeReg REG_F3 = fastBool False
1214 #endif
1215 #ifdef REG_F4
1216 freeReg REG_F4 = fastBool False
1217 #endif
1218 #ifdef REG_D1
1219 freeReg REG_D1 = fastBool False
1220 #endif
1221 #ifdef REG_D2
1222 freeReg REG_D2 = fastBool False
1223 #endif
1224 #ifdef REG_Sp
1225 freeReg REG_Sp   = fastBool False
1226 #endif
1227 #ifdef REG_Su
1228 freeReg REG_Su   = fastBool False
1229 #endif
1230 #ifdef REG_SpLim
1231 freeReg REG_SpLim = fastBool False
1232 #endif
1233 #ifdef REG_Hp
1234 freeReg REG_Hp   = fastBool False
1235 #endif
1236 #ifdef REG_HpLim
1237 freeReg REG_HpLim = fastBool False
1238 #endif
1239 freeReg n               = fastBool True
1240
1241
1242 -- -----------------------------------------------------------------------------
1243 -- Information about global registers
1244
1245 baseRegOffset :: GlobalReg -> Int
1246
1247 baseRegOffset (VanillaReg 1)      = oFFSET_StgRegTable_rR1
1248 baseRegOffset (VanillaReg 2)      = oFFSET_StgRegTable_rR2
1249 baseRegOffset (VanillaReg 3)      = oFFSET_StgRegTable_rR3
1250 baseRegOffset (VanillaReg 4)      = oFFSET_StgRegTable_rR4
1251 baseRegOffset (VanillaReg 5)      = oFFSET_StgRegTable_rR5
1252 baseRegOffset (VanillaReg 6)      = oFFSET_StgRegTable_rR6
1253 baseRegOffset (VanillaReg 7)      = oFFSET_StgRegTable_rR7
1254 baseRegOffset (VanillaReg 8)      = oFFSET_StgRegTable_rR8
1255 baseRegOffset (VanillaReg 9)      = oFFSET_StgRegTable_rR9
1256 baseRegOffset (VanillaReg 10)     = oFFSET_StgRegTable_rR10
1257 baseRegOffset (FloatReg  1)       = oFFSET_StgRegTable_rF1
1258 baseRegOffset (FloatReg  2)       = oFFSET_StgRegTable_rF2
1259 baseRegOffset (FloatReg  3)       = oFFSET_StgRegTable_rF3
1260 baseRegOffset (FloatReg  4)       = oFFSET_StgRegTable_rF4
1261 baseRegOffset (DoubleReg 1)       = oFFSET_StgRegTable_rD1
1262 baseRegOffset (DoubleReg 2)       = oFFSET_StgRegTable_rD2
1263 baseRegOffset Sp                  = oFFSET_StgRegTable_rSp
1264 baseRegOffset SpLim               = oFFSET_StgRegTable_rSpLim
1265 baseRegOffset (LongReg 1)         = oFFSET_StgRegTable_rL1
1266 baseRegOffset Hp                  = oFFSET_StgRegTable_rHp
1267 baseRegOffset HpLim               = oFFSET_StgRegTable_rHpLim
1268 baseRegOffset CurrentTSO          = oFFSET_StgRegTable_rCurrentTSO
1269 baseRegOffset CurrentNursery      = oFFSET_StgRegTable_rCurrentNursery
1270 baseRegOffset HpAlloc             = oFFSET_StgRegTable_rHpAlloc
1271 baseRegOffset GCEnter1            = oFFSET_stgGCEnter1
1272 baseRegOffset GCFun               = oFFSET_stgGCFun
1273 #ifdef DEBUG
1274 baseRegOffset BaseReg             = panic "baseRegOffset:BaseReg"
1275 baseRegOffset _                   = panic "baseRegOffset:other"
1276 #endif
1277
1278
1279 -- | Returns 'True' if this global register is stored in a caller-saves
1280 -- machine register.
1281
1282 callerSaves :: GlobalReg -> Bool
1283
1284 #ifdef CALLER_SAVES_Base
1285 callerSaves BaseReg             = True
1286 #endif
1287 #ifdef CALLER_SAVES_R1
1288 callerSaves (VanillaReg 1)      = True
1289 #endif
1290 #ifdef CALLER_SAVES_R2
1291 callerSaves (VanillaReg 2)      = True
1292 #endif
1293 #ifdef CALLER_SAVES_R3
1294 callerSaves (VanillaReg 3)      = True
1295 #endif
1296 #ifdef CALLER_SAVES_R4
1297 callerSaves (VanillaReg 4)      = True
1298 #endif
1299 #ifdef CALLER_SAVES_R5
1300 callerSaves (VanillaReg 5)      = True
1301 #endif
1302 #ifdef CALLER_SAVES_R6
1303 callerSaves (VanillaReg 6)      = True
1304 #endif
1305 #ifdef CALLER_SAVES_R7
1306 callerSaves (VanillaReg 7)      = True
1307 #endif
1308 #ifdef CALLER_SAVES_R8
1309 callerSaves (VanillaReg 8)      = True
1310 #endif
1311 #ifdef CALLER_SAVES_F1
1312 callerSaves (FloatReg 1)        = True
1313 #endif
1314 #ifdef CALLER_SAVES_F2
1315 callerSaves (FloatReg 2)        = True
1316 #endif
1317 #ifdef CALLER_SAVES_F3
1318 callerSaves (FloatReg 3)        = True
1319 #endif
1320 #ifdef CALLER_SAVES_F4
1321 callerSaves (FloatReg 4)        = True
1322 #endif
1323 #ifdef CALLER_SAVES_D1
1324 callerSaves (DoubleReg 1)       = True
1325 #endif
1326 #ifdef CALLER_SAVES_D2
1327 callerSaves (DoubleReg 2)       = True
1328 #endif
1329 #ifdef CALLER_SAVES_L1
1330 callerSaves (LongReg 1)         = True
1331 #endif
1332 #ifdef CALLER_SAVES_Sp
1333 callerSaves Sp                  = True
1334 #endif
1335 #ifdef CALLER_SAVES_SpLim
1336 callerSaves SpLim               = True
1337 #endif
1338 #ifdef CALLER_SAVES_Hp
1339 callerSaves Hp                  = True
1340 #endif
1341 #ifdef CALLER_SAVES_HpLim
1342 callerSaves HpLim               = True
1343 #endif
1344 #ifdef CALLER_SAVES_CurrentTSO
1345 callerSaves CurrentTSO          = True
1346 #endif
1347 #ifdef CALLER_SAVES_CurrentNursery
1348 callerSaves CurrentNursery      = True
1349 #endif
1350 callerSaves _                   = False
1351
1352
1353 --  | Returns 'Nothing' if this global register is not stored
1354 -- in a real machine register, otherwise returns @'Just' reg@, where
1355 -- reg is the machine register it is stored in.
1356
1357 globalRegMaybe :: GlobalReg -> Maybe Reg
1358
1359 #ifdef REG_Base
1360 globalRegMaybe BaseReg                  = Just (RealReg REG_Base)
1361 #endif
1362 #ifdef REG_R1
1363 globalRegMaybe (VanillaReg 1)           = Just (RealReg REG_R1)
1364 #endif
1365 #ifdef REG_R2
1366 globalRegMaybe (VanillaReg 2)           = Just (RealReg REG_R2)
1367 #endif
1368 #ifdef REG_R3
1369 globalRegMaybe (VanillaReg 3)           = Just (RealReg REG_R3)
1370 #endif
1371 #ifdef REG_R4
1372 globalRegMaybe (VanillaReg 4)           = Just (RealReg REG_R4)
1373 #endif
1374 #ifdef REG_R5
1375 globalRegMaybe (VanillaReg 5)           = Just (RealReg REG_R5)
1376 #endif
1377 #ifdef REG_R6
1378 globalRegMaybe (VanillaReg 6)           = Just (RealReg REG_R6)
1379 #endif
1380 #ifdef REG_R7
1381 globalRegMaybe (VanillaReg 7)           = Just (RealReg REG_R7)
1382 #endif
1383 #ifdef REG_R8
1384 globalRegMaybe (VanillaReg 8)           = Just (RealReg REG_R8)
1385 #endif
1386 #ifdef REG_R9
1387 globalRegMaybe (VanillaReg 9)           = Just (RealReg REG_R9)
1388 #endif
1389 #ifdef REG_R10
1390 globalRegMaybe (VanillaReg 10)          = Just (RealReg REG_R10)
1391 #endif
1392 #ifdef REG_F1
1393 globalRegMaybe (FloatReg 1)             = Just (RealReg REG_F1)
1394 #endif
1395 #ifdef REG_F2
1396 globalRegMaybe (FloatReg 2)             = Just (RealReg REG_F2)
1397 #endif
1398 #ifdef REG_F3
1399 globalRegMaybe (FloatReg 3)             = Just (RealReg REG_F3)
1400 #endif
1401 #ifdef REG_F4
1402 globalRegMaybe (FloatReg 4)             = Just (RealReg REG_F4)
1403 #endif
1404 #ifdef REG_D1
1405 globalRegMaybe (DoubleReg 1)            = Just (RealReg REG_D1)
1406 #endif
1407 #ifdef REG_D2
1408 globalRegMaybe (DoubleReg 2)            = Just (RealReg REG_D2)
1409 #endif
1410 #ifdef REG_Sp
1411 globalRegMaybe Sp                       = Just (RealReg REG_Sp)
1412 #endif
1413 #ifdef REG_Lng1
1414 globalRegMaybe (LongReg 1)              = Just (RealReg REG_Lng1)
1415 #endif
1416 #ifdef REG_Lng2
1417 globalRegMaybe (LongReg 2)              = Just (RealReg REG_Lng2)
1418 #endif
1419 #ifdef REG_SpLim
1420 globalRegMaybe SpLim                    = Just (RealReg REG_SpLim)
1421 #endif
1422 #ifdef REG_Hp
1423 globalRegMaybe Hp                       = Just (RealReg REG_Hp)
1424 #endif
1425 #ifdef REG_HpLim
1426 globalRegMaybe HpLim                    = Just (RealReg REG_HpLim)
1427 #endif
1428 #ifdef REG_CurrentTSO
1429 globalRegMaybe CurrentTSO               = Just (RealReg REG_CurrentTSO)
1430 #endif
1431 #ifdef REG_CurrentNursery
1432 globalRegMaybe CurrentNursery           = Just (RealReg REG_CurrentNursery)
1433 #endif
1434 globalRegMaybe _                        = Nothing
1435
1436
1437 \end{code}