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