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