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