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