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