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