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         {-# INLINE   isSqueesed    #-}
 620         isSqueesed cI cF ufm
 621           = case ufm of
 622                 NodeUFM _ _ left right
 623                  -> case isSqueesed cI cF right of
 624                         (# s, cI', cF' #)
 625                          -> case s of
 626                                 False   -> isSqueesed cI' cF' left
 627                                 True    -> (# True, cI', cF' #)
 628
 629                 LeafUFM _ reg
 630                  -> case regClass reg of
 631                         RcInteger
 632                          -> case cI +# _ILIT(1) of
 633                                 cI' -> (# cI' >=# ALLOCATABLE_REGS_INTEGER, cI', cF #)
 634
 635                         RcDouble
 636                          -> case cF +# _ILIT(1) of
 637                                 cF' -> (# cF' >=# ALLOCATABLE_REGS_DOUBLE,  cI, cF' #)
 638
 639                 EmptyUFM
 640                  ->     (# False, cI, cF #)
 641
 642    in case isSqueesed (_ILIT(0)) (_ILIT(0)) conflicts of
 643         (# False, cI', cF' #)
 644          -> case isSqueesed cI' cF' exclusions of
 645                 (# s, _, _ #)   -> not s
 646
 647         (# True, _, _ #)
 648          -> False
 649
 650
 651
 652 -- -----------------------------------------------------------------------------
 653 -- Machine-specific register stuff
 654
 655 -- The Alpha has 64 registers of interest; 32 integer registers and 32 floating
 656 -- point registers.  The mapping of STG registers to alpha machine registers
 657 -- is defined in StgRegs.h.  We are, of course, prepared for any eventuality.
 658
 659 #if alpha_TARGET_ARCH
 660 fReg :: Int -> RegNo
 661 fReg x = (32 + x)
 662
 663 v0, f0, ra, pv, gp, sp, zeroh :: Reg
 664 v0    = realReg 0
 665 f0    = realReg (fReg 0)
 666 ra    = FixedReg ILIT(26)
 667 pv    = t12
 668 gp    = FixedReg ILIT(29)
 669 sp    = FixedReg ILIT(30)
 670 zeroh = FixedReg ILIT(31) -- "zero" is used in 1.3 (MonadZero method)
 671
 672 t9, t10, t11, t12 :: Reg
 673 t9  = realReg 23
 674 t10 = realReg 24
 675 t11 = realReg 25
 676 t12 = realReg 27
 677 #endif
 678
 679 {-
 680 Intel x86 architecture:
 681 - All registers except 7 (esp) are available for use.
 682 - Only ebx, esi, edi and esp are available across a C call (they are callee-saves).
 683 - Registers 0-7 have 16-bit counterparts (ax, bx etc.)
 684 - Registers 0-3 have 8 bit counterparts (ah, bh etc.)
 685 - Registers 8-13 are fakes; we pretend x86 has 6 conventionally-addressable
 686   fp registers, and 3-operand insns for them, and we translate this into
 687   real stack-based x86 fp code after register allocation.
 688
 689 The fp registers are all Double registers; we don't have any RcFloat class
 690 regs.  @regClass@ barfs if you give it a VirtualRegF, and mkVReg above should
 691 never generate them.
 692 -}
 693
 694 #if i386_TARGET_ARCH
 695
 696 fake0, fake1, fake2, fake3, fake4, fake5,
 697        eax, ebx, ecx, edx, esp, ebp, esi, edi :: Reg
 698 eax   = RealReg 0
 699 ebx   = RealReg 1
 700 ecx   = RealReg 2
 701 edx   = RealReg 3
 702 esi   = RealReg 4
 703 edi   = RealReg 5
 704 ebp   = RealReg 6
 705 esp   = RealReg 7
 706 fake0 = RealReg 8
 707 fake1 = RealReg 9
 708 fake2 = RealReg 10
 709 fake3 = RealReg 11
 710 fake4 = RealReg 12
 711 fake5 = RealReg 13
 712
 713
 714 -- On x86, we might want to have an 8-bit RegClass, which would
 715 -- contain just regs 1-4 (the others don't have 8-bit versions).
 716 -- However, we can get away without this at the moment because the
 717 -- only allocatable integer regs are also 8-bit compatible (1, 3, 4).
 718 regClass (RealReg i)     = if i < 8 then RcInteger else RcDouble
 719 regClass (VirtualRegI  u) = RcInteger
 720 regClass (VirtualRegHi u) = RcInteger
 721 regClass (VirtualRegD  u) = RcDouble
 722 regClass (VirtualRegF  u) = pprPanic "regClass(x86):VirtualRegF"
 723                                     (ppr (VirtualRegF u))
 724
 725 regNames
 726    = ["%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi", "%ebp", "%esp",
 727       "%fake0", "%fake1", "%fake2", "%fake3", "%fake4", "%fake5", "%fake6"]
 728
 729 showReg :: RegNo -> String
 730 showReg n
 731    = if   n >= 0 && n < 14
 732      then regNames !! n
 733      else "%unknown_x86_real_reg_" ++ show n
 734
 735
 736 #endif
 737
 738 {-
 739 AMD x86_64 architecture:
 740 - Registers 0-16 have 32-bit counterparts (eax, ebx etc.)
 741 - Registers 0-7 have 16-bit counterparts (ax, bx etc.)
 742 - Registers 0-3 have 8 bit counterparts (ah, bh etc.)
 743
 744 -}
 745
 746 #if x86_64_TARGET_ARCH
 747
 748 rax, rbx, rcx, rdx, rsp, rbp, rsi, rdi,
 749   r8, r9, r10, r11, r12, r13, r14, r15,
 750   xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7,
 751   xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15 :: Reg
 752
 753 rax   = RealReg 0
 754 rbx   = RealReg 1
 755 rcx   = RealReg 2
 756 rdx   = RealReg 3
 757 rsi   = RealReg 4
 758 rdi   = RealReg 5
 759 rbp   = RealReg 6
 760 rsp   = RealReg 7
 761 r8    = RealReg 8
 762 r9    = RealReg 9
 763 r10   = RealReg 10
 764 r11   = RealReg 11
 765 r12   = RealReg 12
 766 r13   = RealReg 13
 767 r14   = RealReg 14
 768 r15   = RealReg 15
 769 xmm0  = RealReg 16
 770 xmm1  = RealReg 17
 771 xmm2  = RealReg 18
 772 xmm3  = RealReg 19
 773 xmm4  = RealReg 20
 774 xmm5  = RealReg 21
 775 xmm6  = RealReg 22
 776 xmm7  = RealReg 23
 777 xmm8  = RealReg 24
 778 xmm9  = RealReg 25
 779 xmm10 = RealReg 26
 780 xmm11 = RealReg 27
 781 xmm12 = RealReg 28
 782 xmm13 = RealReg 29
 783 xmm14 = RealReg 30
 784 xmm15 = RealReg 31
 785
 786  -- so we can re-use some x86 code:
 787 eax = rax
 788 ebx = rbx
 789 ecx = rcx
 790 edx = rdx
 791 esi = rsi
 792 edi = rdi
 793 ebp = rbp
 794 esp = rsp
 795
 796 xmm n = RealReg (16+n)
 797
 798 -- On x86, we might want to have an 8-bit RegClass, which would
 799 -- contain just regs 1-4 (the others don't have 8-bit versions).
 800 -- However, we can get away without this at the moment because the
 801 -- only allocatable integer regs are also 8-bit compatible (1, 3, 4).
 802 regClass (RealReg i)     = if i < 16 then RcInteger else RcDouble
 803 regClass (VirtualRegI  u) = RcInteger
 804 regClass (VirtualRegHi u) = RcInteger
 805 regClass (VirtualRegD  u) = RcDouble
 806 regClass (VirtualRegF  u) = pprPanic "regClass(x86_64):VirtualRegF"
 807                                     (ppr (VirtualRegF u))
 808
 809 regNames
 810  = ["%rax", "%rbx", "%rcx", "%rdx", "%rsi", "%rdi", "%rbp", "%rsp" ]
 811
 812 showReg :: RegNo -> String
 813 showReg n
 814   | n >= 16 = "%xmm" ++ show (n-16)
 815   | n >= 8  = "%r" ++ show n
 816   | otherwise = regNames !! n
 817
 818 #endif
 819
 820 {-
 821 The SPARC has 64 registers of interest; 32 integer registers and 32
 822 floating point registers.  The mapping of STG registers to SPARC
 823 machine registers is defined in StgRegs.h.  We are, of course,
 824 prepared for any eventuality.
 825
 826 The whole fp-register pairing thing on sparcs is a huge nuisance.  See
 827 fptools/ghc/includes/MachRegs.h for a description of what's going on
 828 here.
 829 -}
 830
 831 #if sparc_TARGET_ARCH
 832
 833 gReg,lReg,iReg,oReg,fReg :: Int -> RegNo
 834 gReg x = x
 835 oReg x = (8 + x)
 836 lReg x = (16 + x)
 837 iReg x = (24 + x)
 838 fReg x = (32 + x)
 839
 840 nCG_FirstFloatReg :: RegNo
 841 nCG_FirstFloatReg = unRealReg NCG_FirstFloatReg
 842
 843 regClass (VirtualRegI u) = RcInteger
 844 regClass (VirtualRegF u) = RcFloat
 845 regClass (VirtualRegD u) = RcDouble
 846 regClass (RealReg i) | i < 32                = RcInteger
 847                      | i < nCG_FirstFloatReg = RcDouble
 848                      | otherwise             = RcFloat
 849
 850 showReg :: RegNo -> String
 851 showReg n
 852    | n >= 0  && n < 8   = "%g" ++ show n
 853    | n >= 8  && n < 16  = "%o" ++ show (n-8)
 854    | n >= 16 && n < 24  = "%l" ++ show (n-16)
 855    | n >= 24 && n < 32  = "%i" ++ show (n-24)
 856    | n >= 32 && n < 64  = "%f" ++ show (n-32)
 857    | otherwise          = "%unknown_sparc_real_reg_" ++ show n
 858
 859 g0, g1, g2, fp, sp, o0, o1, f0, f1, f6, f8, f22, f26, f27 :: Reg
 860
 861 f6  = RealReg (fReg 6)
 862 f8  = RealReg (fReg 8)
 863 f22 = RealReg (fReg 22)
 864 f26 = RealReg (fReg 26)
 865 f27 = RealReg (fReg 27)
 866
 867
 868 -- g0 is useful for codegen; is always zero, and writes to it vanish.
 869 g0  = RealReg (gReg 0)
 870 g1  = RealReg (gReg 1)
 871 g2  = RealReg (gReg 2)
 872
 873 -- FP, SP, int and float return (from C) regs.
 874 fp  = RealReg (iReg 6)
 875 sp  = RealReg (oReg 6)
 876 o0  = RealReg (oReg 0)
 877 o1  = RealReg (oReg 1)
 878 f0  = RealReg (fReg 0)
 879 f1  = RealReg (fReg 1)
 880
 881 #endif
 882
 883 {-
 884 The PowerPC has 64 registers of interest; 32 integer registers and 32 floating
 885 point registers.
 886 -}
 887
 888 #if powerpc_TARGET_ARCH
 889 fReg :: Int -> RegNo
 890 fReg x = (32 + x)
 891
 892 regClass (VirtualRegI  u) = RcInteger
 893 regClass (VirtualRegHi u) = RcInteger
 894 regClass (VirtualRegF  u) = pprPanic "regClass(ppc):VirtualRegF"
 895                                     (ppr (VirtualRegF u))
 896 regClass (VirtualRegD u) = RcDouble
 897 regClass (RealReg i) | i < 32                = RcInteger
 898                      | otherwise             = RcDouble
 899
 900 showReg :: RegNo -> String
 901 showReg n
 902     | n >= 0 && n <= 31   = "%r" ++ show n
 903     | n >= 32 && n <= 63  = "%f" ++ show (n - 32)
 904     | otherwise           = "%unknown_powerpc_real_reg_" ++ show n
 905
 906 sp = RealReg 1
 907 r3 = RealReg 3
 908 r4 = RealReg 4
 909 r27 = RealReg 27
 910 r28 = RealReg 28
 911 f1 = RealReg $ fReg 1
 912 f20 = RealReg $ fReg 20
 913 f21 = RealReg $ fReg 21
 914 #endif
 915
 916 {-
 917 Redefine the literals used for machine-registers with non-numeric
 918 names in the header files.  Gag me with a spoon, eh?
 919 -}
 920
 921 #if alpha_TARGET_ARCH
 922 #define f0 32
 923 #define f1 33
 924 #define f2 34
 925 #define f3 35
 926 #define f4 36
 927 #define f5 37
 928 #define f6 38
 929 #define f7 39
 930 #define f8 40
 931 #define f9 41
 932 #define f10 42
 933 #define f11 43
 934 #define f12 44
 935 #define f13 45
 936 #define f14 46
 937 #define f15 47
 938 #define f16 48
 939 #define f17 49
 940 #define f18 50
 941 #define f19 51
 942 #define f20 52
 943 #define f21 53
 944 #define f22 54
 945 #define f23 55
 946 #define f24 56
 947 #define f25 57
 948 #define f26 58
 949 #define f27 59
 950 #define f28 60
 951 #define f29 61
 952 #define f30 62
 953 #define f31 63
 954 #endif
 955 #if i386_TARGET_ARCH
 956 #define eax 0
 957 #define ebx 1
 958 #define ecx 2
 959 #define edx 3
 960 #define esi 4
 961 #define edi 5
 962 #define ebp 6
 963 #define esp 7
 964 #define fake0 8
 965 #define fake1 9
 966 #define fake2 10
 967 #define fake3 11
 968 #define fake4 12
 969 #define fake5 13
 970 #endif
 971
 972 #if x86_64_TARGET_ARCH
 973 #define rax   0
 974 #define rbx   1
 975 #define rcx   2
 976 #define rdx   3
 977 #define rsi   4
 978 #define rdi   5
 979 #define rbp   6
 980 #define rsp   7
 981 #define r8    8
 982 #define r9    9
 983 #define r10   10
 984 #define r11   11
 985 #define r12   12
 986 #define r13   13
 987 #define r14   14
 988 #define r15   15
 989 #define xmm0  16
 990 #define xmm1  17
 991 #define xmm2  18
 992 #define xmm3  19
 993 #define xmm4  20
 994 #define xmm5  21
 995 #define xmm6  22
 996 #define xmm7  23
 997 #define xmm8  24
 998 #define xmm9  25
 999 #define xmm10 26
1000 #define xmm11 27
1001 #define xmm12 28
1002 #define xmm13 29
1003 #define xmm14 30
1004 #define xmm15 31
1005 #endif
1006
1007 #if sparc_TARGET_ARCH
1008 #define g0 0
1009 #define g1 1
1010 #define g2 2
1011 #define g3 3
1012 #define g4 4
1013 #define g5 5
1014 #define g6 6
1015 #define g7 7
1016 #define o0 8
1017 #define o1 9
1018 #define o2 10
1019 #define o3 11
1020 #define o4 12
1021 #define o5 13
1022 #define o6 14
1023 #define o7 15
1024 #define l0 16
1025 #define l1 17
1026 #define l2 18
1027 #define l3 19
1028 #define l4 20
1029 #define l5 21
1030 #define l6 22
1031 #define l7 23
1032 #define i0 24
1033 #define i1 25
1034 #define i2 26
1035 #define i3 27
1036 #define i4 28
1037 #define i5 29
1038 #define i6 30
1039 #define i7 31
1040
1041 #define f0  32
1042 #define f1  33
1043 #define f2  34
1044 #define f3  35
1045 #define f4  36
1046 #define f5  37
1047 #define f6  38
1048 #define f7  39
1049 #define f8  40
1050 #define f9  41
1051 #define f10 42
1052 #define f11 43
1053 #define f12 44
1054 #define f13 45
1055 #define f14 46
1056 #define f15 47
1057 #define f16 48
1058 #define f17 49
1059 #define f18 50
1060 #define f19 51
1061 #define f20 52
1062 #define f21 53
1063 #define f22 54
1064 #define f23 55
1065 #define f24 56
1066 #define f25 57
1067 #define f26 58
1068 #define f27 59
1069 #define f28 60
1070 #define f29 61
1071 #define f30 62
1072 #define f31 63
1073 #endif
1074
1075 #if powerpc_TARGET_ARCH
1076 #define r0 0
1077 #define r1 1
1078 #define r2 2
1079 #define r3 3
1080 #define r4 4
1081 #define r5 5
1082 #define r6 6
1083 #define r7 7
1084 #define r8 8
1085 #define r9 9
1086 #define r10 10
1087 #define r11 11
1088 #define r12 12
1089 #define r13 13
1090 #define r14 14
1091 #define r15 15
1092 #define r16 16
1093 #define r17 17
1094 #define r18 18
1095 #define r19 19
1096 #define r20 20
1097 #define r21 21
1098 #define r22 22
1099 #define r23 23
1100 #define r24 24
1101 #define r25 25
1102 #define r26 26
1103 #define r27 27
1104 #define r28 28
1105 #define r29 29
1106 #define r30 30
1107 #define r31 31
1108
1109 #ifdef darwin_TARGET_OS
1110 #define f0  32
1111 #define f1  33
1112 #define f2  34
1113 #define f3  35
1114 #define f4  36
1115 #define f5  37
1116 #define f6  38
1117 #define f7  39
1118 #define f8  40
1119 #define f9  41
1120 #define f10 42
1121 #define f11 43
1122 #define f12 44
1123 #define f13 45
1124 #define f14 46
1125 #define f15 47
1126 #define f16 48
1127 #define f17 49
1128 #define f18 50
1129 #define f19 51
1130 #define f20 52
1131 #define f21 53
1132 #define f22 54
1133 #define f23 55
1134 #define f24 56
1135 #define f25 57
1136 #define f26 58
1137 #define f27 59
1138 #define f28 60
1139 #define f29 61
1140 #define f30 62
1141 #define f31 63
1142 #else
1143 #define fr0  32
1144 #define fr1  33
1145 #define fr2  34
1146 #define fr3  35
1147 #define fr4  36
1148 #define fr5  37
1149 #define fr6  38
1150 #define fr7  39
1151 #define fr8  40
1152 #define fr9  41
1153 #define fr10 42
1154 #define fr11 43
1155 #define fr12 44
1156 #define fr13 45
1157 #define fr14 46
1158 #define fr15 47
1159 #define fr16 48
1160 #define fr17 49
1161 #define fr18 50
1162 #define fr19 51
1163 #define fr20 52
1164 #define fr21 53
1165 #define fr22 54
1166 #define fr23 55
1167 #define fr24 56
1168 #define fr25 57
1169 #define fr26 58
1170 #define fr27 59
1171 #define fr28 60
1172 #define fr29 61
1173 #define fr30 62
1174 #define fr31 63
1175 #endif
1176 #endif
1177
1178
1179 -- allMachRegs is the complete set of machine regs.
1180 allMachRegNos :: [RegNo]
1181 allMachRegNos
1182    = IF_ARCH_alpha( [0..63],
1183      IF_ARCH_i386(  [0..13],
1184      IF_ARCH_x86_64( [0..31],
1185      IF_ARCH_sparc( ([0..31]
1186                      ++ [f0,f2 .. nCG_FirstFloatReg-1]
1187                      ++ [nCG_FirstFloatReg .. f31]),
1188      IF_ARCH_powerpc([0..63],
1189                    )))))
1190
1191 -- allocatableRegs is allMachRegNos with the fixed-use regs removed.
1192 -- i.e., these are the regs for which we are prepared to allow the
1193 -- register allocator to attempt to map VRegs to.
1194 allocatableRegs :: [RegNo]
1195 allocatableRegs
1196    = let isFree i = isFastTrue (freeReg i)
1197      in  filter isFree allMachRegNos
1198
1199
1200 -- | The number of regs in each class.
1201 --      We go via top level CAFs to ensure that we're not recomputing
1202 --      the length of these lists each time the fn is called.
1203 allocatableRegsInClass :: RegClass -> Int
1204 allocatableRegsInClass cls
1205  = case cls of
1206         RcInteger       -> allocatableRegsInteger
1207         RcDouble        -> allocatableRegsDouble
1208
1209 allocatableRegsInteger
1210         = length $ filter (\r -> regClass r == RcInteger)
1211                  $ map RealReg allocatableRegs
1212
1213 allocatableRegsDouble
1214         = length $ filter (\r -> regClass r == RcDouble)
1215                  $ map RealReg allocatableRegs
1216
1217
1218 -- these are the regs which we cannot assume stay alive over a
1219 -- C call.
1220 callClobberedRegs :: [Reg]
1221 callClobberedRegs
1222   =
1223 #if alpha_TARGET_ARCH
1224     [0, 1, 2, 3, 4, 5, 6, 7, 8,
1225      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1226      fReg 0, fReg 1, fReg 10, fReg 11, fReg 12, fReg 13, fReg 14, fReg 15,
1227      fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21, fReg 22, fReg 23,
1228      fReg 24, fReg 25, fReg 26, fReg 27, fReg 28, fReg 29, fReg 30]
1229 #endif /* alpha_TARGET_ARCH */
1230 #if i386_TARGET_ARCH
1231     -- caller-saves registers
1232     map RealReg [eax,ecx,edx,fake0,fake1,fake2,fake3,fake4,fake5]
1233 #endif /* i386_TARGET_ARCH */
1234 #if x86_64_TARGET_ARCH
1235     -- caller-saves registers
1236     map RealReg ([rax,rcx,rdx,rsi,rdi,r8,r9,r10,r11] ++ [16..31])
1237        -- all xmm regs are caller-saves
1238 #endif /* x86_64_TARGET_ARCH */
1239 #if sparc_TARGET_ARCH
1240     map RealReg
1241         ( oReg 7 :
1242           [oReg i | i <- [0..5]] ++
1243           [gReg i | i <- [1..7]] ++
1244           [fReg i | i <- [0..31]] )
1245 #endif /* sparc_TARGET_ARCH */
1246 #if powerpc_TARGET_ARCH
1247 #if darwin_TARGET_OS
1248     map RealReg (0:[2..12] ++ map fReg [0..13])
1249 #elif linux_TARGET_OS
1250     map RealReg (0:[2..13] ++ map fReg [0..13])
1251 #endif
1252 #endif /* powerpc_TARGET_ARCH */
1253
1254
1255 -- argRegs is the set of regs which are read for an n-argument call to C.
1256 -- For archs which pass all args on the stack (x86), is empty.
1257 -- Sparc passes up to the first 6 args in regs.
1258 -- Dunno about Alpha.
1259 argRegs :: RegNo -> [Reg]
1260
1261 #if i386_TARGET_ARCH
1262 argRegs _ = panic "MachRegs.argRegs(x86): should not be used!"
1263 #endif
1264
1265 #if x86_64_TARGET_ARCH
1266 argRegs _ = panic "MachRegs.argRegs(x86_64): should not be used!"
1267 #endif
1268
1269 #if alpha_TARGET_ARCH
1270 argRegs 0 = []
1271 argRegs 1 = freeMappedRegs [16, fReg 16]
1272 argRegs 2 = freeMappedRegs [16, 17, fReg 16, fReg 17]
1273 argRegs 3 = freeMappedRegs [16, 17, 18, fReg 16, fReg 17, fReg 18]
1274 argRegs 4 = freeMappedRegs [16, 17, 18, 19, fReg 16, fReg 17, fReg 18, fReg 19]
1275 argRegs 5 = freeMappedRegs [16, 17, 18, 19, 20, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20]
1276 argRegs 6 = freeMappedRegs [16, 17, 18, 19, 20, 21, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21]
1277 argRegs _ = panic "MachRegs.argRegs(alpha): don't know about >6 arguments!"
1278 #endif /* alpha_TARGET_ARCH */
1279
1280 #if sparc_TARGET_ARCH
1281 argRegs 0 = []
1282 argRegs 1 = map (RealReg . oReg) [0]
1283 argRegs 2 = map (RealReg . oReg) [0,1]
1284 argRegs 3 = map (RealReg . oReg) [0,1,2]
1285 argRegs 4 = map (RealReg . oReg) [0,1,2,3]
1286 argRegs 5 = map (RealReg . oReg) [0,1,2,3,4]
1287 argRegs 6 = map (RealReg . oReg) [0,1,2,3,4,5]
1288 argRegs _ = panic "MachRegs.argRegs(sparc): don't know about >6 arguments!"
1289 #endif /* sparc_TARGET_ARCH */
1290
1291 #if powerpc_TARGET_ARCH
1292 argRegs 0 = []
1293 argRegs 1 = map RealReg [3]
1294 argRegs 2 = map RealReg [3,4]
1295 argRegs 3 = map RealReg [3..5]
1296 argRegs 4 = map RealReg [3..6]
1297 argRegs 5 = map RealReg [3..7]
1298 argRegs 6 = map RealReg [3..8]
1299 argRegs 7 = map RealReg [3..9]
1300 argRegs 8 = map RealReg [3..10]
1301 argRegs _ = panic "MachRegs.argRegs(powerpc): don't know about >8 arguments!"
1302 #endif /* powerpc_TARGET_ARCH */
1303
1304
1305 -- all of the arg regs ??
1306 #if alpha_TARGET_ARCH
1307 allArgRegs :: [(Reg, Reg)]
1308 allArgRegs = [(realReg i, realReg (fReg i)) | i <- [16..21]]
1309 #endif /* alpha_TARGET_ARCH */
1310
1311 #if sparc_TARGET_ARCH
1312 allArgRegs :: [Reg]
1313 allArgRegs = map RealReg [oReg i | i <- [0..5]]
1314 #endif /* sparc_TARGET_ARCH */
1315
1316 #if i386_TARGET_ARCH
1317 allArgRegs :: [Reg]
1318 allArgRegs = panic "MachRegs.allArgRegs(x86): should not be used!"
1319 #endif
1320
1321 #if x86_64_TARGET_ARCH
1322 allArgRegs :: [Reg]
1323 allArgRegs = map RealReg [rdi,rsi,rdx,rcx,r8,r9]
1324 allFPArgRegs :: [Reg]
1325 allFPArgRegs = map RealReg [xmm0 .. xmm7]
1326 #endif
1327
1328 #if powerpc_TARGET_ARCH
1329 allArgRegs :: [Reg]
1330 allArgRegs = map RealReg [3..10]
1331 allFPArgRegs :: [Reg]
1332 #if darwin_TARGET_OS
1333 allFPArgRegs = map (RealReg . fReg) [1..13]
1334 #elif linux_TARGET_OS
1335 allFPArgRegs = map (RealReg . fReg) [1..8]
1336 #endif
1337 #endif /* powerpc_TARGET_ARCH */
1338 \end{code}
1339
1340 \begin{code}
1341 freeReg :: RegNo -> FastBool
1342
1343 #if alpha_TARGET_ARCH
1344 freeReg 26 = fastBool False  -- return address (ra)
1345 freeReg 28 = fastBool False  -- reserved for the assembler (at)
1346 freeReg 29 = fastBool False  -- global pointer (gp)
1347 freeReg 30 = fastBool False  -- stack pointer (sp)
1348 freeReg 31 = fastBool False  -- always zero (zeroh)
1349 freeReg 63 = fastBool False  -- always zero (f31)
1350 #endif
1351
1352 #if i386_TARGET_ARCH
1353 freeReg esp = fastBool False  --        %esp is the C stack pointer
1354 #endif
1355
1356 #if x86_64_TARGET_ARCH
1357 freeReg rsp = fastBool False  --        %rsp is the C stack pointer
1358 #endif
1359
1360 #if sparc_TARGET_ARCH
1361 freeReg g0 = fastBool False  -- %g0 is always 0.
1362 freeReg g5 = fastBool False  -- %g5 is reserved (ABI).
1363 freeReg g6 = fastBool False  -- %g6 is reserved (ABI).
1364 freeReg g7 = fastBool False  -- %g7 is reserved (ABI).
1365 freeReg i6 = fastBool False  -- %i6 is our frame pointer.
1366 freeReg i7 = fastBool False  -- %i7 tends to have ret-addr-ish things
1367 freeReg o6 = fastBool False  -- %o6 is our stack pointer.
1368 freeReg o7 = fastBool False  -- %o7 holds ret addrs (???)
1369 freeReg f0 = fastBool False  --  %f0/%f1 are the C fp return registers.
1370 freeReg f1 = fastBool False
1371 #endif
1372
1373 #if powerpc_TARGET_ARCH
1374 freeReg 0 = fastBool False -- Hack: r0 can't be used in all insns, but it's actually free
1375 freeReg 1 = fastBool False -- The Stack Pointer
1376 #if !darwin_TARGET_OS
1377  -- most non-darwin powerpc OSes use r2 as a TOC pointer or something like that
1378 freeReg 2 = fastBool False
1379 #endif
1380 #endif
1381
1382 #ifdef REG_Base
1383 freeReg REG_Base = fastBool False
1384 #endif
1385 #ifdef REG_R1
1386 freeReg REG_R1   = fastBool False
1387 #endif
1388 #ifdef REG_R2
1389 freeReg REG_R2   = fastBool False
1390 #endif
1391 #ifdef REG_R3
1392 freeReg REG_R3   = fastBool False
1393 #endif
1394 #ifdef REG_R4
1395 freeReg REG_R4   = fastBool False
1396 #endif
1397 #ifdef REG_R5
1398 freeReg REG_R5   = fastBool False
1399 #endif
1400 #ifdef REG_R6
1401 freeReg REG_R6   = fastBool False
1402 #endif
1403 #ifdef REG_R7
1404 freeReg REG_R7   = fastBool False
1405 #endif
1406 #ifdef REG_R8
1407 freeReg REG_R8   = fastBool False
1408 #endif
1409 #ifdef REG_F1
1410 freeReg REG_F1 = fastBool False
1411 #endif
1412 #ifdef REG_F2
1413 freeReg REG_F2 = fastBool False
1414 #endif
1415 #ifdef REG_F3
1416 freeReg REG_F3 = fastBool False
1417 #endif
1418 #ifdef REG_F4
1419 freeReg REG_F4 = fastBool False
1420 #endif
1421 #ifdef REG_D1
1422 freeReg REG_D1 = fastBool False
1423 #endif
1424 #ifdef REG_D2
1425 freeReg REG_D2 = fastBool False
1426 #endif
1427 #ifdef REG_Sp
1428 freeReg REG_Sp   = fastBool False
1429 #endif
1430 #ifdef REG_Su
1431 freeReg REG_Su   = fastBool False
1432 #endif
1433 #ifdef REG_SpLim
1434 freeReg REG_SpLim = fastBool False
1435 #endif
1436 #ifdef REG_Hp
1437 freeReg REG_Hp   = fastBool False
1438 #endif
1439 #ifdef REG_HpLim
1440 freeReg REG_HpLim = fastBool False
1441 #endif
1442 freeReg n               = fastBool True
1443
1444
1445 --  | Returns 'Nothing' if this global register is not stored
1446 -- in a real machine register, otherwise returns @'Just' reg@, where
1447 -- reg is the machine register it is stored in.
1448
1449 globalRegMaybe :: GlobalReg -> Maybe Reg
1450
1451 #ifdef REG_Base
1452 globalRegMaybe BaseReg                  = Just (RealReg REG_Base)
1453 #endif
1454 #ifdef REG_R1
1455 globalRegMaybe (VanillaReg 1 _)         = Just (RealReg REG_R1)
1456 #endif
1457 #ifdef REG_R2
1458 globalRegMaybe (VanillaReg 2 _)         = Just (RealReg REG_R2)
1459 #endif
1460 #ifdef REG_R3
1461 globalRegMaybe (VanillaReg 3 _)         = Just (RealReg REG_R3)
1462 #endif
1463 #ifdef REG_R4
1464 globalRegMaybe (VanillaReg 4 _)         = Just (RealReg REG_R4)
1465 #endif
1466 #ifdef REG_R5
1467 globalRegMaybe (VanillaReg 5 _)         = Just (RealReg REG_R5)
1468 #endif
1469 #ifdef REG_R6
1470 globalRegMaybe (VanillaReg 6 _)         = Just (RealReg REG_R6)
1471 #endif
1472 #ifdef REG_R7
1473 globalRegMaybe (VanillaReg 7 _)         = Just (RealReg REG_R7)
1474 #endif
1475 #ifdef REG_R8
1476 globalRegMaybe (VanillaReg 8 _)         = Just (RealReg REG_R8)
1477 #endif
1478 #ifdef REG_R9
1479 globalRegMaybe (VanillaReg 9 _)         = Just (RealReg REG_R9)
1480 #endif
1481 #ifdef REG_R10
1482 globalRegMaybe (VanillaReg 10 _)        = Just (RealReg REG_R10)
1483 #endif
1484 #ifdef REG_F1
1485 globalRegMaybe (FloatReg 1)             = Just (RealReg REG_F1)
1486 #endif
1487 #ifdef REG_F2
1488 globalRegMaybe (FloatReg 2)             = Just (RealReg REG_F2)
1489 #endif
1490 #ifdef REG_F3
1491 globalRegMaybe (FloatReg 3)             = Just (RealReg REG_F3)
1492 #endif
1493 #ifdef REG_F4
1494 globalRegMaybe (FloatReg 4)             = Just (RealReg REG_F4)
1495 #endif
1496 #ifdef REG_D1
1497 globalRegMaybe (DoubleReg 1)            = Just (RealReg REG_D1)
1498 #endif
1499 #ifdef REG_D2
1500 globalRegMaybe (DoubleReg 2)            = Just (RealReg REG_D2)
1501 #endif
1502 #ifdef REG_Sp
1503 globalRegMaybe Sp                       = Just (RealReg REG_Sp)
1504 #endif
1505 #ifdef REG_Lng1
1506 globalRegMaybe (LongReg 1)              = Just (RealReg REG_Lng1)
1507 #endif
1508 #ifdef REG_Lng2
1509 globalRegMaybe (LongReg 2)              = Just (RealReg REG_Lng2)
1510 #endif
1511 #ifdef REG_SpLim
1512 globalRegMaybe SpLim                    = Just (RealReg REG_SpLim)
1513 #endif
1514 #ifdef REG_Hp
1515 globalRegMaybe Hp                       = Just (RealReg REG_Hp)
1516 #endif
1517 #ifdef REG_HpLim
1518 globalRegMaybe HpLim                    = Just (RealReg REG_HpLim)
1519 #endif
1520 #ifdef REG_CurrentTSO
1521 globalRegMaybe CurrentTSO               = Just (RealReg REG_CurrentTSO)
1522 #endif
1523 #ifdef REG_CurrentNursery
1524 globalRegMaybe CurrentNursery           = Just (RealReg REG_CurrentNursery)
1525 #endif
1526 globalRegMaybe _                        = Nothing
1527
1528
1529 \end{code}