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