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