ghc/compiler/nativeGen/MachRegs.lhs

   1 %
   2 % (c) The AQUA Project, Glasgow University, 1996-1998
   3 %
   4 \section[MachRegs]{Machine-specific info about registers}
   5
   6 Also includes stuff about immediate operands, which are
   7 often/usually quite entangled with registers.
   8
   9 (Immediates could be untangled from registers at some cost in tangled
  10 modules --- the pleasure has been foregone.)
  11
  12 \begin{code}
  13 #include "nativeGen/NCG.h"
  14
  15 module MachRegs (
  16
  17         RegClass(..), regClass,
  18         VRegUnique(..), pprVRegUnique, getHiVRegFromLo,
  19         Reg(..), isRealReg, isVirtualReg, getVRegUnique,
  20         allocatableRegs, argRegs, allArgRegs, callClobberedRegs,
  21
  22         Imm(..),
  23         MachRegsAddr(..),
  24
  25         addrOffset,
  26         baseRegOffset,
  27         callerSaves,
  28         freeReg,
  29         getNewRegNCG,
  30         mkVReg,
  31         get_MagicId_reg_or_addr,
  32         get_MagicId_addr,
  33         get_Regtable_addr_from_offset,
  34         spRel,
  35         strImmLit
  36
  37 #if alpha_TARGET_ARCH
  38         , allArgRegs
  39         , fits8Bits
  40         , fReg
  41         , gp, pv, ra, sp, t9, t10, t11, t12, v0, f0, zeroh
  42 #endif
  43 #if i386_TARGET_ARCH
  44         , eax, ebx, ecx, edx, esi, esp
  45         , fake0, fake1, fake2, fake3, fake4, fake5
  46 #endif
  47 #if sparc_TARGET_ARCH
  48         , fits13Bits
  49         , fpRel, gReg, iReg, lReg, oReg, largeOffsetError
  50         , fp, sp, g0, g1, g2, o0, o1, f0, f6, f8, f26, f27
  51
  52 #endif
  53 #if powerpc_TARGET_ARCH
  54         , allFPArgRegs
  55         , fits16Bits
  56         , sp
  57         , r3, r4, r27, r28
  58         , f1, f20, f21
  59 #endif
  60     ) where
  61
  62 #include "HsVersions.h"
  63
  64 import AbsCSyn          ( MagicId(..) )
  65 import CLabel           ( CLabel, mkMainCapabilityLabel )
  66 import MachOp           ( MachOp(..) )
  67 import PrimRep          ( PrimRep(..), isFloatingRep )
  68 import Stix             ( StixExpr(..), StixReg(..),
  69                           getUniqueNat, returnNat, thenNat, NatM )
  70 import Unique           ( mkPseudoUnique2, Uniquable(..), Unique )
  71 import Pretty
  72 import Outputable       ( Outputable(..), pprPanic, panic )
  73 import qualified Outputable
  74 import FastTypes
  75 \end{code}
  76
  77 % - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  78
  79 \begin{code}
  80 data Imm
  81   = ImmInt      Int
  82   | ImmInteger  Integer     -- Sigh.
  83   | ImmCLbl     CLabel      -- AbstractC Label (with baggage)
  84   | ImmLab      Bool Doc    -- Simple string label (underscore-able)
  85                              -- Bool==True ==> in a different DLL
  86   | ImmLit      Doc    -- Simple string
  87   | ImmIndex    CLabel Int
  88   | ImmFloat    Rational
  89   | ImmDouble   Rational
  90   IF_ARCH_sparc(
  91   | LO Imm                  -- Possible restrictions...
  92   | HI Imm
  93   ,IF_ARCH_powerpc(
  94   | LO Imm
  95   | HI Imm
  96   | HA Imm      -- high halfword adjusted
  97   ,))
  98 strImmLit s = ImmLit (text s)
  99 \end{code}
 100
 101 % - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 102
 103 \begin{code}
 104 data MachRegsAddr
 105 #if alpha_TARGET_ARCH
 106   = AddrImm     Imm
 107   | AddrReg     Reg
 108   | AddrRegImm  Reg Imm
 109 #endif
 110
 111 #if i386_TARGET_ARCH
 112   = AddrBaseIndex       Base Index Displacement
 113   | ImmAddr             Imm Int
 114
 115 type Base         = Maybe Reg
 116 type Index        = Maybe (Reg, Int)    -- Int is 2, 4 or 8
 117 type Displacement = Imm
 118 #endif
 119
 120 #if sparc_TARGET_ARCH
 121   = AddrRegReg  Reg Reg
 122   | AddrRegImm  Reg Imm
 123 #endif
 124
 125 #if powerpc_TARGET_ARCH
 126   = AddrRegReg  Reg Reg
 127   | AddrRegImm  Reg Imm
 128 #endif
 129
 130 addrOffset :: MachRegsAddr -> Int -> Maybe MachRegsAddr
 131
 132 addrOffset addr off
 133   = case addr of
 134 #if alpha_TARGET_ARCH
 135       _ -> panic "MachMisc.addrOffset not defined for Alpha"
 136 #endif
 137 #if i386_TARGET_ARCH
 138       ImmAddr i off0      -> Just (ImmAddr i (off0 + off))
 139       AddrBaseIndex r i (ImmInt n) -> Just (AddrBaseIndex r i (ImmInt (n + off)))
 140       AddrBaseIndex r i (ImmInteger n)
 141         -> Just (AddrBaseIndex r i (ImmInt (fromInteger (n + toInteger off))))
 142       _ -> Nothing
 143 #endif
 144 #if sparc_TARGET_ARCH
 145       AddrRegImm r (ImmInt n)
 146        | fits13Bits n2 -> Just (AddrRegImm r (ImmInt n2))
 147        | otherwise     -> Nothing
 148        where n2 = n + off
 149
 150       AddrRegImm r (ImmInteger n)
 151        | fits13Bits n2 -> Just (AddrRegImm r (ImmInt (fromInteger n2)))
 152        | otherwise     -> Nothing
 153        where n2 = n + toInteger off
 154
 155       AddrRegReg r (RealReg 0)
 156        | fits13Bits off -> Just (AddrRegImm r (ImmInt off))
 157        | otherwise     -> Nothing
 158
 159       _ -> Nothing
 160
 161 #endif {-sparc-}
 162 #if powerpc_TARGET_ARCH
 163       AddrRegImm r (ImmInt n)
 164        | fits16Bits n2 -> Just (AddrRegImm r (ImmInt n2))
 165        | otherwise     -> Nothing
 166        where n2 = n + off
 167
 168       AddrRegImm r (ImmInteger n)
 169        | fits16Bits n2 -> Just (AddrRegImm r (ImmInt (fromInteger n2)))
 170        | otherwise     -> Nothing
 171        where n2 = n + toInteger off
 172
 173       AddrRegReg r (RealReg 0)
 174        | fits16Bits off -> Just (AddrRegImm r (ImmInt off))
 175        | otherwise     -> Nothing
 176
 177       _ -> Nothing
 178 #endif {-powerpc-}
 179
 180 -----------------
 181 #if alpha_TARGET_ARCH
 182
 183 fits8Bits :: Integer -> Bool
 184 fits8Bits i = i >= -256 && i < 256
 185
 186 #endif
 187
 188 #if sparc_TARGET_ARCH
 189
 190 {-# SPECIALIZE fits13Bits :: Int -> Bool, Integer -> Bool #-}
 191 fits13Bits :: Integral a => a -> Bool
 192 fits13Bits x = x >= -4096 && x < 4096
 193
 194 -----------------
 195 largeOffsetError i
 196   = error ("ERROR: SPARC native-code generator cannot handle large offset ("
 197            ++show i++");\nprobably because of large constant data structures;" ++
 198            "\nworkaround: use -fvia-C on this module.\n")
 199
 200 #endif {-sparc-}
 201
 202 #if powerpc_TARGET_ARCH
 203 fits16Bits :: Integral a => a -> Bool
 204 fits16Bits x = x >= -32768 && x < 32768
 205 #endif
 206 \end{code}
 207
 208 % - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 209
 210 @stgReg@: we map STG registers onto appropriate Stix Trees.  Either
 211 they map to real machine registers or stored as offsets from BaseReg.
 212 Given a MagicId, get_MagicId_reg_or_addr produces either the real
 213 register it is in, on this platform, or a StixExpr denoting the
 214 address in the register table holding it.  get_MagicId_addr always
 215 produces the register table address for it.
 216
 217 \begin{code}
 218 get_MagicId_reg_or_addr       :: MagicId -> Either Reg StixExpr
 219 get_MagicId_addr              :: MagicId -> StixExpr
 220 get_Regtable_addr_from_offset :: Int -> StixExpr
 221
 222 get_MagicId_reg_or_addr mid
 223    = case magicIdRegMaybe mid of
 224         Just rr -> Left rr
 225         Nothing -> Right (get_MagicId_addr mid)
 226
 227 get_MagicId_addr BaseReg
 228    = -- This arch doesn't have BaseReg in a register, so we have to
 229      -- use &MainRegTable.r instead.
 230      StIndex PtrRep (StCLbl mkMainCapabilityLabel)
 231                     (StInt (toInteger OFFW_Capability_r))
 232 get_MagicId_addr mid
 233    = get_Regtable_addr_from_offset (baseRegOffset mid)
 234
 235 get_Regtable_addr_from_offset offset_in_words
 236    = let ptr_to_RegTable
 237             = case magicIdRegMaybe BaseReg of
 238                  Nothing
 239                     -> -- This arch doesn't have BaseReg in a register, so we have to
 240                        -- use &MainRegTable.r instead.
 241                        StIndex PtrRep (StCLbl mkMainCapabilityLabel)
 242                                       (StInt (toInteger OFFW_Capability_r))
 243                  Just _
 244                     -> -- It's in a reg, so leave it as it is
 245                        StReg (StixMagicId BaseReg)
 246      in
 247          StIndex PtrRep ptr_to_RegTable (StInt (toInteger offset_in_words))
 248 \end{code}
 249
 250 % - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 251
 252 @spRel@ gives us a stack relative addressing mode for volatile
 253 temporaries and for excess call arguments.  @fpRel@, where
 254 applicable, is the same but for the frame pointer.
 255
 256 \begin{code}
 257 spRel :: Int    -- desired stack offset in words, positive or negative
 258       -> MachRegsAddr
 259
 260 spRel n
 261 #if i386_TARGET_ARCH
 262   = AddrBaseIndex (Just esp) Nothing (ImmInt (n * BYTES_PER_WORD))
 263 #else
 264   = AddrRegImm sp (ImmInt (n * BYTES_PER_WORD))
 265 #endif
 266
 267 #if sparc_TARGET_ARCH
 268 fpRel :: Int -> MachRegsAddr
 269     -- Duznae work for offsets greater than 13 bits; we just hope for
 270     -- the best
 271 fpRel n
 272   = AddrRegImm fp (ImmInt (n * BYTES_PER_WORD))
 273 #endif
 274 \end{code}
 275
 276 %************************************************************************
 277 %*                                                                      *
 278 \subsection[Reg]{Real registers}
 279 %*                                                                      *
 280 %************************************************************************
 281
 282 RealRegs are machine regs which are available for allocation, in the
 283 usual way.  We know what class they are, because that's part of the
 284 processor's architecture.
 285
 286 VirtualRegs are virtual registers.  The register allocator will
 287 eventually have to map them into RealRegs, or into spill slots.
 288 VirtualRegs are allocated on the fly, usually to represent a single
 289 value in the abstract assembly code (i.e. dynamic registers are
 290 usually single assignment).  With the new register allocator, the
 291 single assignment restriction isn't necessary to get correct code,
 292 although a better register allocation will result if single assignment
 293 is used -- because the allocator maps a VirtualReg into a single
 294 RealReg, even if the VirtualReg has multiple live ranges.
 295
 296 Virtual regs can be of either class, so that info is attached.
 297
 298 \begin{code}
 299
 300 data VRegUnique
 301    = VRegUniqueLo Unique                -- lower part of a split quantity
 302    | VRegUniqueHi Unique                -- upper part thereof
 303      deriving (Eq, Ord)
 304
 305 instance Show VRegUnique where
 306    show (VRegUniqueLo u) = show u
 307    show (VRegUniqueHi u) = "_hi_" ++ show u
 308
 309 pprVRegUnique :: VRegUnique -> Outputable.SDoc
 310 pprVRegUnique
 311    = Outputable.text . show
 312
 313 -- Determine the upper-half vreg for a 64-bit quantity on a 32-bit platform
 314 -- when supplied with the vreg for the lower-half of the quantity.
 315 getHiVRegFromLo (VirtualRegI (VRegUniqueLo u))
 316    = VirtualRegI (VRegUniqueHi u)
 317 getHiVRegFromLo other
 318    = pprPanic "getHiVRegFromLo" (ppr other)
 319
 320 data RegClass
 321    = RcInteger
 322    | RcFloat
 323    | RcDouble
 324      deriving Eq
 325
 326 data Reg
 327    = RealReg     Int
 328    | VirtualRegI VRegUnique
 329    | VirtualRegF VRegUnique
 330    | VirtualRegD VRegUnique
 331
 332 unRealReg (RealReg i) = i
 333 unRealReg vreg        = pprPanic "unRealReg on VirtualReg" (ppr vreg)
 334
 335 getVRegUnique :: Reg -> VRegUnique
 336 getVRegUnique (VirtualRegI vu) = vu
 337 getVRegUnique (VirtualRegF vu) = vu
 338 getVRegUnique (VirtualRegD vu) = vu
 339 getVRegUnique rreg             = pprPanic "getVRegUnique on RealReg" (ppr rreg)
 340
 341 mkVReg :: Unique -> PrimRep -> Reg
 342 mkVReg u pk
 343 #if sparc_TARGET_ARCH
 344    = case pk of
 345         FloatRep  -> VirtualRegF (VRegUniqueLo u)
 346         DoubleRep -> VirtualRegD (VRegUniqueLo u)
 347         other     -> VirtualRegI (VRegUniqueLo u)
 348 #else
 349    = if isFloatingRep pk then VirtualRegD (VRegUniqueLo u)
 350                          else VirtualRegI (VRegUniqueLo u)
 351 #endif
 352
 353 isVirtualReg (RealReg _)     = False
 354 isVirtualReg (VirtualRegI _) = True
 355 isVirtualReg (VirtualRegF _) = True
 356 isVirtualReg (VirtualRegD _) = True
 357 isRealReg = not . isVirtualReg
 358
 359 getNewRegNCG :: PrimRep -> NatM Reg
 360 getNewRegNCG pk
 361    = getUniqueNat `thenNat` \ u -> returnNat (mkVReg u pk)
 362
 363 instance Eq Reg where
 364    (==) (RealReg i1)     (RealReg i2)     = i1 == i2
 365    (==) (VirtualRegI u1) (VirtualRegI u2) = u1 == u2
 366    (==) (VirtualRegF u1) (VirtualRegF u2) = u1 == u2
 367    (==) (VirtualRegD u1) (VirtualRegD u2) = u1 == u2
 368    (==) reg1             reg2             = False
 369
 370 instance Ord Reg where
 371    compare (RealReg i1)     (RealReg i2)     = compare i1 i2
 372    compare (RealReg _)      (VirtualRegI _)  = LT
 373    compare (RealReg _)      (VirtualRegF _)  = LT
 374    compare (RealReg _)      (VirtualRegD _)  = LT
 375
 376    compare (VirtualRegI _)  (RealReg _)      = GT
 377    compare (VirtualRegI u1) (VirtualRegI u2) = compare u1 u2
 378    compare (VirtualRegI _)  (VirtualRegF _)  = LT
 379    compare (VirtualRegI _)  (VirtualRegD _)  = LT
 380
 381    compare (VirtualRegF _)  (RealReg _)      = GT
 382    compare (VirtualRegF _)  (VirtualRegI _)  = GT
 383    compare (VirtualRegF u1) (VirtualRegF u2) = compare u1 u2
 384    compare (VirtualRegF _)  (VirtualRegD _)  = LT
 385
 386    compare (VirtualRegD _)  (RealReg _)      = GT
 387    compare (VirtualRegD _)  (VirtualRegI _)  = GT
 388    compare (VirtualRegD _)  (VirtualRegF _)  = GT
 389    compare (VirtualRegD u1) (VirtualRegD u2) = compare u1 u2
 390
 391
 392 instance Show Reg where
 393     show (RealReg i)     = showReg i
 394     show (VirtualRegI u) = "%vI_" ++ show u
 395     show (VirtualRegF u) = "%vF_" ++ show u
 396     show (VirtualRegD u) = "%vD_" ++ show u
 397
 398 instance Outputable Reg where
 399     ppr r = Outputable.text (show r)
 400 \end{code}
 401
 402 ** Machine-specific Reg stuff: **
 403
 404 The Alpha has 64 registers of interest; 32 integer registers and 32 floating
 405 point registers.  The mapping of STG registers to alpha machine registers
 406 is defined in StgRegs.h.  We are, of course, prepared for any eventuality.
 407 \begin{code}
 408 #if alpha_TARGET_ARCH
 409 fReg :: Int -> Int
 410 fReg x = (32 + x)
 411
 412 v0, f0, ra, pv, gp, sp, zeroh :: Reg
 413 v0    = realReg 0
 414 f0    = realReg (fReg 0)
 415 ra    = FixedReg ILIT(26)
 416 pv    = t12
 417 gp    = FixedReg ILIT(29)
 418 sp    = FixedReg ILIT(30)
 419 zeroh = FixedReg ILIT(31) -- "zero" is used in 1.3 (MonadZero method)
 420
 421 t9, t10, t11, t12 :: Reg
 422 t9  = realReg 23
 423 t10 = realReg 24
 424 t11 = realReg 25
 425 t12 = realReg 27
 426 #endif
 427 \end{code}
 428
 429 Intel x86 architecture:
 430 - All registers except 7 (esp) are available for use.
 431 - Only ebx, esi, edi and esp are available across a C call (they are callee-saves).
 432 - Registers 0-7 have 16-bit counterparts (ax, bx etc.)
 433 - Registers 0-3 have 8 bit counterparts (ah, bh etc.)
 434 - Registers 8-13 are fakes; we pretend x86 has 6 conventionally-addressable
 435   fp registers, and 3-operand insns for them, and we translate this into
 436   real stack-based x86 fp code after register allocation.
 437
 438 The fp registers are all Double registers; we don't have any RcFloat class
 439 regs.  @regClass@ barfs if you give it a VirtualRegF, and mkVReg above should
 440 never generate them.
 441
 442 \begin{code}
 443 #if i386_TARGET_ARCH
 444
 445 fake0, fake1, fake2, fake3, fake4, fake5,
 446        eax, ebx, ecx, edx, esp, ebp, esi, edi :: Reg
 447 eax   = RealReg 0
 448 ebx   = RealReg 1
 449 ecx   = RealReg 2
 450 edx   = RealReg 3
 451 esi   = RealReg 4
 452 edi   = RealReg 5
 453 ebp   = RealReg 6
 454 esp   = RealReg 7
 455 fake0 = RealReg 8
 456 fake1 = RealReg 9
 457 fake2 = RealReg 10
 458 fake3 = RealReg 11
 459 fake4 = RealReg 12
 460 fake5 = RealReg 13
 461
 462 regClass (RealReg i)     = if i < 8 then RcInteger else RcDouble
 463 regClass (VirtualRegI u) = RcInteger
 464 regClass (VirtualRegD u) = RcDouble
 465 regClass (VirtualRegF u) = pprPanic "regClass(x86):VirtualRegF"
 466                                     (ppr (VirtualRegF u))
 467
 468 regNames
 469    = ["%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi", "%ebp", "%esp",
 470       "%fake0", "%fake1", "%fake2", "%fake3", "%fake4", "%fake5", "%fake6"]
 471
 472 showReg :: Int -> String
 473 showReg n
 474    = if   n >= 0 && n < 14
 475      then regNames !! n
 476      else "%unknown_x86_real_reg_" ++ show n
 477
 478 #endif
 479 \end{code}
 480
 481 The SPARC has 64 registers of interest; 32 integer registers and 32
 482 floating point registers.  The mapping of STG registers to SPARC
 483 machine registers is defined in StgRegs.h.  We are, of course,
 484 prepared for any eventuality.
 485
 486 The whole fp-register pairing thing on sparcs is a huge nuisance.  See
 487 fptools/ghc/includes/MachRegs.h for a description of what's going on
 488 here.
 489
 490 \begin{code}
 491 #if sparc_TARGET_ARCH
 492
 493 gReg,lReg,iReg,oReg,fReg :: Int -> Int
 494 gReg x = x
 495 oReg x = (8 + x)
 496 lReg x = (16 + x)
 497 iReg x = (24 + x)
 498 fReg x = (32 + x)
 499
 500 nCG_FirstFloatReg :: Int
 501 nCG_FirstFloatReg = unRealReg NCG_FirstFloatReg
 502
 503 regClass (VirtualRegI u) = RcInteger
 504 regClass (VirtualRegF u) = RcFloat
 505 regClass (VirtualRegD u) = RcDouble
 506 regClass (RealReg i) | i < 32                = RcInteger
 507                      | i < nCG_FirstFloatReg = RcDouble
 508                      | otherwise             = RcFloat
 509
 510 showReg :: Int -> String
 511 showReg n
 512    | n >= 0  && n < 8   = "%g" ++ show n
 513    | n >= 8  && n < 16  = "%o" ++ show (n-8)
 514    | n >= 16 && n < 24  = "%l" ++ show (n-16)
 515    | n >= 24 && n < 32  = "%i" ++ show (n-24)
 516    | n >= 32 && n < 64  = "%f" ++ show (n-32)
 517    | otherwise          = "%unknown_sparc_real_reg_" ++ show n
 518
 519 g0, g1, g2, fp, sp, o0, o1, f0, f1, f6, f8, f22, f26, f27 :: Reg
 520
 521 f6  = RealReg (fReg 6)
 522 f8  = RealReg (fReg 8)
 523 f22 = RealReg (fReg 22)
 524 f26 = RealReg (fReg 26)
 525 f27 = RealReg (fReg 27)
 526
 527
 528 -- g0 is useful for codegen; is always zero, and writes to it vanish.
 529 g0  = RealReg (gReg 0)
 530 g1  = RealReg (gReg 1)
 531 g2  = RealReg (gReg 2)
 532
 533 -- FP, SP, int and float return (from C) regs.
 534 fp  = RealReg (iReg 6)
 535 sp  = RealReg (oReg 6)
 536 o0  = RealReg (oReg 0)
 537 o1  = RealReg (oReg 1)
 538 f0  = RealReg (fReg 0)
 539 f1  = RealReg (fReg 1)
 540
 541 #endif
 542 \end{code}
 543
 544 The PowerPC has 64 registers of interest; 32 integer registers and 32 floating
 545 point registers.
 546 \begin{code}
 547 #if powerpc_TARGET_ARCH
 548 fReg :: Int -> Int
 549 fReg x = (32 + x)
 550
 551 regClass (VirtualRegI u) = RcInteger
 552 regClass (VirtualRegF u) = RcFloat
 553 regClass (VirtualRegD u) = RcDouble
 554 regClass (RealReg i) | i < 32                = RcInteger
 555                      | otherwise             = RcDouble
 556                   --   | i < nCG_FirstFloatReg = RcDouble
 557                   --   | otherwise             = RcFloat
 558
 559 showReg :: Int -> String
 560 showReg n
 561     | n >= 0 && n <= 31   = "%r" ++ show n
 562     | n >= 32 && n <= 63  = "%f" ++ show (n - 32)
 563     | otherwise           = "%unknown_powerpc_real_reg_" ++ show n
 564
 565 sp = RealReg 1
 566 r3 = RealReg 3
 567 r4 = RealReg 4
 568 r27 = RealReg 27
 569 r28 = RealReg 28
 570 f1 = RealReg $ fReg 1
 571 f20 = RealReg $ fReg 20
 572 f21 = RealReg $ fReg 21
 573 #endif
 574 \end{code}
 575
 576 Redefine the literals used for machine-registers with non-numeric
 577 names in the header files.  Gag me with a spoon, eh?
 578 \begin{code}
 579 #if alpha_TARGET_ARCH
 580 #define f0 32
 581 #define f1 33
 582 #define f2 34
 583 #define f3 35
 584 #define f4 36
 585 #define f5 37
 586 #define f6 38
 587 #define f7 39
 588 #define f8 40
 589 #define f9 41
 590 #define f10 42
 591 #define f11 43
 592 #define f12 44
 593 #define f13 45
 594 #define f14 46
 595 #define f15 47
 596 #define f16 48
 597 #define f17 49
 598 #define f18 50
 599 #define f19 51
 600 #define f20 52
 601 #define f21 53
 602 #define f22 54
 603 #define f23 55
 604 #define f24 56
 605 #define f25 57
 606 #define f26 58
 607 #define f27 59
 608 #define f28 60
 609 #define f29 61
 610 #define f30 62
 611 #define f31 63
 612 #endif
 613 #if i386_TARGET_ARCH
 614 #define eax 0
 615 #define ebx 1
 616 #define ecx 2
 617 #define edx 3
 618 #define esi 4
 619 #define edi 5
 620 #define ebp 6
 621 #define esp 7
 622 #define fake0 8
 623 #define fake1 9
 624 #define fake2 10
 625 #define fake3 11
 626 #define fake4 12
 627 #define fake5 13
 628 #endif
 629 #if sparc_TARGET_ARCH
 630 #define g0 0
 631 #define g1 1
 632 #define g2 2
 633 #define g3 3
 634 #define g4 4
 635 #define g5 5
 636 #define g6 6
 637 #define g7 7
 638 #define o0 8
 639 #define o1 9
 640 #define o2 10
 641 #define o3 11
 642 #define o4 12
 643 #define o5 13
 644 #define o6 14
 645 #define o7 15
 646 #define l0 16
 647 #define l1 17
 648 #define l2 18
 649 #define l3 19
 650 #define l4 20
 651 #define l5 21
 652 #define l6 22
 653 #define l7 23
 654 #define i0 24
 655 #define i1 25
 656 #define i2 26
 657 #define i3 27
 658 #define i4 28
 659 #define i5 29
 660 #define i6 30
 661 #define i7 31
 662
 663 #define f0  32
 664 #define f1  33
 665 #define f2  34
 666 #define f3  35
 667 #define f4  36
 668 #define f5  37
 669 #define f6  38
 670 #define f7  39
 671 #define f8  40
 672 #define f9  41
 673 #define f10 42
 674 #define f11 43
 675 #define f12 44
 676 #define f13 45
 677 #define f14 46
 678 #define f15 47
 679 #define f16 48
 680 #define f17 49
 681 #define f18 50
 682 #define f19 51
 683 #define f20 52
 684 #define f21 53
 685 #define f22 54
 686 #define f23 55
 687 #define f24 56
 688 #define f25 57
 689 #define f26 58
 690 #define f27 59
 691 #define f28 60
 692 #define f29 61
 693 #define f30 62
 694 #define f31 63
 695 #endif
 696
 697 #if powerpc_TARGET_ARCH
 698 #define r0 0
 699 #define r1 1
 700 #define r2 2
 701 #define r3 3
 702 #define r4 4
 703 #define r5 5
 704 #define r6 6
 705 #define r7 7
 706 #define r8 8
 707 #define r9 9
 708 #define r10 10
 709 #define r11 11
 710 #define r12 12
 711 #define r13 13
 712 #define r14 14
 713 #define r15 15
 714 #define r16 16
 715 #define r17 17
 716 #define r18 18
 717 #define r19 19
 718 #define r20 20
 719 #define r21 21
 720 #define r22 22
 721 #define r23 23
 722 #define r24 24
 723 #define r25 25
 724 #define r26 26
 725 #define r27 27
 726 #define r28 28
 727 #define r29 29
 728 #define r30 30
 729 #define r31 31
 730 #define f0  32
 731 #define f1  33
 732 #define f2  34
 733 #define f3  35
 734 #define f4  36
 735 #define f5  37
 736 #define f6  38
 737 #define f7  39
 738 #define f8  40
 739 #define f9  41
 740 #define f10 42
 741 #define f11 43
 742 #define f12 44
 743 #define f13 45
 744 #define f14 46
 745 #define f15 47
 746 #define f16 48
 747 #define f17 49
 748 #define f18 50
 749 #define f19 51
 750 #define f20 52
 751 #define f21 53
 752 #define f22 54
 753 #define f23 55
 754 #define f24 56
 755 #define f25 57
 756 #define f26 58
 757 #define f27 59
 758 #define f28 60
 759 #define f29 61
 760 #define f30 62
 761 #define f31 63
 762 #endif
 763 \end{code}
 764
 765 \begin{code}
 766 baseRegOffset :: MagicId -> Int
 767
 768 baseRegOffset (VanillaReg _ 1#)      = OFFSET_R1
 769 baseRegOffset (VanillaReg _ 2#)      = OFFSET_R2
 770 baseRegOffset (VanillaReg _ 3#)      = OFFSET_R3
 771 baseRegOffset (VanillaReg _ 4#)      = OFFSET_R4
 772 baseRegOffset (VanillaReg _ 5#)      = OFFSET_R5
 773 baseRegOffset (VanillaReg _ 6#)      = OFFSET_R6
 774 baseRegOffset (VanillaReg _ 7#)      = OFFSET_R7
 775 baseRegOffset (VanillaReg _ 8#)      = OFFSET_R8
 776 baseRegOffset (VanillaReg _ 9#)      = OFFSET_R9
 777 baseRegOffset (VanillaReg _ 10#)     = OFFSET_R10
 778 baseRegOffset (FloatReg  1#)         = OFFSET_F1
 779 baseRegOffset (FloatReg  2#)         = OFFSET_F2
 780 baseRegOffset (FloatReg  3#)         = OFFSET_F3
 781 baseRegOffset (FloatReg  4#)         = OFFSET_F4
 782 baseRegOffset (DoubleReg 1#)         = OFFSET_D1
 783 baseRegOffset (DoubleReg 2#)         = OFFSET_D2
 784 baseRegOffset Sp                     = OFFSET_Sp
 785 baseRegOffset SpLim                  = OFFSET_SpLim
 786 #ifdef OFFSET_L1
 787 baseRegOffset (LongReg _ 1#)         = OFFSET_L1
 788 #endif
 789 baseRegOffset Hp                     = OFFSET_Hp
 790 baseRegOffset HpLim                  = OFFSET_HpLim
 791 baseRegOffset CurrentTSO             = OFFSET_CurrentTSO
 792 baseRegOffset CurrentNursery         = OFFSET_CurrentNursery
 793 baseRegOffset HpAlloc                = OFFSET_HpAlloc
 794 #ifdef NCG_DEBUG
 795 baseRegOffset BaseReg                = panic "baseRegOffset:BaseReg"
 796 baseRegOffset CurCostCentre          = panic "baseRegOffset:CurCostCentre"
 797 baseRegOffset VoidReg                = panic "baseRegOffset:VoidReg"
 798 #endif
 799 \end{code}
 800
 801 \begin{code}
 802 callerSaves :: MagicId -> Bool
 803
 804 #ifdef CALLER_SAVES_Base
 805 callerSaves BaseReg                     = True
 806 #endif
 807 #ifdef CALLER_SAVES_R1
 808 callerSaves (VanillaReg _ ILIT(1))      = True
 809 #endif
 810 #ifdef CALLER_SAVES_R2
 811 callerSaves (VanillaReg _ ILIT(2))      = True
 812 #endif
 813 #ifdef CALLER_SAVES_R3
 814 callerSaves (VanillaReg _ ILIT(3))      = True
 815 #endif
 816 #ifdef CALLER_SAVES_R4
 817 callerSaves (VanillaReg _ ILIT(4))      = True
 818 #endif
 819 #ifdef CALLER_SAVES_R5
 820 callerSaves (VanillaReg _ ILIT(5))      = True
 821 #endif
 822 #ifdef CALLER_SAVES_R6
 823 callerSaves (VanillaReg _ ILIT(6))      = True
 824 #endif
 825 #ifdef CALLER_SAVES_R7
 826 callerSaves (VanillaReg _ ILIT(7))      = True
 827 #endif
 828 #ifdef CALLER_SAVES_R8
 829 callerSaves (VanillaReg _ ILIT(8))      = True
 830 #endif
 831 #ifdef CALLER_SAVES_F1
 832 callerSaves (FloatReg 1#)               = True
 833 #endif
 834 #ifdef CALLER_SAVES_F2
 835 callerSaves (FloatReg 2#)               = True
 836 #endif
 837 #ifdef CALLER_SAVES_F3
 838 callerSaves (FloatReg 3#)               = True
 839 #endif
 840 #ifdef CALLER_SAVES_F4
 841 callerSaves (FloatReg 4#)               = True
 842 #endif
 843 #ifdef CALLER_SAVES_D1
 844 callerSaves (DoubleReg 1#)              = True
 845 #endif
 846 #ifdef CALLER_SAVES_D2
 847 callerSaves (DoubleReg 2#)              = True
 848 #endif
 849 #ifdef CALLER_SAVES_L1
 850 callerSaves (LongReg _ ILIT(1))         = True
 851 #endif
 852 #ifdef CALLER_SAVES_Sp
 853 callerSaves Sp                          = True
 854 #endif
 855 #ifdef CALLER_SAVES_SpLim
 856 callerSaves SpLim                       = True
 857 #endif
 858 #ifdef CALLER_SAVES_Hp
 859 callerSaves Hp                          = True
 860 #endif
 861 #ifdef CALLER_SAVES_HpLim
 862 callerSaves HpLim                       = True
 863 #endif
 864 #ifdef CALLER_SAVES_CurrentTSO
 865 callerSaves CurrentTSO                  = True
 866 #endif
 867 #ifdef CALLER_SAVES_CurrentNursery
 868 callerSaves CurrentNursery              = True
 869 #endif
 870 callerSaves _                           = False
 871 \end{code}
 872
 873 \begin{code}
 874 magicIdRegMaybe :: MagicId -> Maybe Reg
 875
 876 #ifdef REG_Base
 877 magicIdRegMaybe BaseReg                 = Just (RealReg REG_Base)
 878 #endif
 879 #ifdef REG_R1
 880 magicIdRegMaybe (VanillaReg _ 1#)       = Just (RealReg REG_R1)
 881 #endif
 882 #ifdef REG_R2
 883 magicIdRegMaybe (VanillaReg _ 2#)       = Just (RealReg REG_R2)
 884 #endif
 885 #ifdef REG_R3
 886 magicIdRegMaybe (VanillaReg _ 3#)       = Just (RealReg REG_R3)
 887 #endif
 888 #ifdef REG_R4
 889 magicIdRegMaybe (VanillaReg _ 4#)       = Just (RealReg REG_R4)
 890 #endif
 891 #ifdef REG_R5
 892 magicIdRegMaybe (VanillaReg _ 5#)       = Just (RealReg REG_R5)
 893 #endif
 894 #ifdef REG_R6
 895 magicIdRegMaybe (VanillaReg _ 6#)       = Just (RealReg REG_R6)
 896 #endif
 897 #ifdef REG_R7
 898 magicIdRegMaybe (VanillaReg _ 7#)       = Just (RealReg REG_R7)
 899 #endif
 900 #ifdef REG_R8
 901 magicIdRegMaybe (VanillaReg _ 8#)       = Just (RealReg REG_R8)
 902 #endif
 903 #ifdef REG_R9
 904 magicIdRegMaybe (VanillaReg _ 9#)       = Just (RealReg REG_R9)
 905 #endif
 906 #ifdef REG_R10
 907 magicIdRegMaybe (VanillaReg _ 10#)      = Just (RealReg REG_R10)
 908 #endif
 909 #ifdef REG_F1
 910 magicIdRegMaybe (FloatReg 1#)   = Just (RealReg REG_F1)
 911 #endif
 912 #ifdef REG_F2
 913 magicIdRegMaybe (FloatReg 2#)   = Just (RealReg REG_F2)
 914 #endif
 915 #ifdef REG_F3
 916 magicIdRegMaybe (FloatReg 3#)   = Just (RealReg REG_F3)
 917 #endif
 918 #ifdef REG_F4
 919 magicIdRegMaybe (FloatReg 4#)   = Just (RealReg REG_F4)
 920 #endif
 921 #ifdef REG_D1
 922 magicIdRegMaybe (DoubleReg 1#)  = Just (RealReg REG_D1)
 923 #endif
 924 #ifdef REG_D2
 925 magicIdRegMaybe (DoubleReg 2#)  = Just (RealReg REG_D2)
 926 #endif
 927 #ifdef REG_Sp
 928 magicIdRegMaybe Sp                      = Just (RealReg REG_Sp)
 929 #endif
 930 #ifdef REG_Lng1
 931 magicIdRegMaybe (LongReg _ ILIT(1))     = Just (RealReg REG_Lng1)
 932 #endif
 933 #ifdef REG_Lng2
 934 magicIdRegMaybe (LongReg _ ILIT(2))     = Just (RealReg REG_Lng2)
 935 #endif
 936 #ifdef REG_SpLim
 937 magicIdRegMaybe SpLim                   = Just (RealReg REG_SpLim)
 938 #endif
 939 #ifdef REG_Hp
 940 magicIdRegMaybe Hp                      = Just (RealReg REG_Hp)
 941 #endif
 942 #ifdef REG_HpLim
 943 magicIdRegMaybe HpLim                   = Just (RealReg REG_HpLim)
 944 #endif
 945 #ifdef REG_CurrentTSO
 946 magicIdRegMaybe CurrentTSO              = Just (RealReg REG_CurrentTSO)
 947 #endif
 948 #ifdef REG_CurrentNursery
 949 magicIdRegMaybe CurrentNursery          = Just (RealReg REG_CurrentNursery)
 950 #endif
 951 magicIdRegMaybe _                       = Nothing
 952 \end{code}
 953
 954 \begin{code}
 955 -------------------------------
 956 -- allMachRegs is the complete set of machine regs.
 957 allMachRegNos :: [Int]
 958 allMachRegNos
 959    = IF_ARCH_alpha( [0..63],
 960      IF_ARCH_i386(  [0..13],
 961      IF_ARCH_sparc( ([0..31]
 962                      ++ [f0,f2 .. nCG_FirstFloatReg-1]
 963                      ++ [nCG_FirstFloatReg .. f31]),
 964      IF_ARCH_powerpc([0..63],
 965                    ))))
 966 -- allocatableRegs is allMachRegNos with the fixed-use regs removed.
 967 -- i.e., these are the regs for which we are prepared to allow the
 968 -- register allocator to attempt to map VRegs to.
 969 allocatableRegs :: [Reg]
 970 allocatableRegs
 971    = let isFree i = isFastTrue (freeReg i)
 972      in  map RealReg (filter isFree allMachRegNos)
 973
 974 -------------------------------
 975 -- these are the regs which we cannot assume stay alive over a
 976 -- C call.
 977 callClobberedRegs :: [Reg]
 978 callClobberedRegs
 979   =
 980 #if alpha_TARGET_ARCH
 981     [0, 1, 2, 3, 4, 5, 6, 7, 8,
 982      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
 983      fReg 0, fReg 1, fReg 10, fReg 11, fReg 12, fReg 13, fReg 14, fReg 15,
 984      fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21, fReg 22, fReg 23,
 985      fReg 24, fReg 25, fReg 26, fReg 27, fReg 28, fReg 29, fReg 30]
 986 #endif {- alpha_TARGET_ARCH -}
 987 #if i386_TARGET_ARCH
 988     -- caller-saves registers
 989     map RealReg [eax,ecx,edx,fake0,fake1,fake2,fake3,fake4,fake5]
 990 #endif {- i386_TARGET_ARCH -}
 991 #if sparc_TARGET_ARCH
 992     map RealReg
 993         ( oReg 7 :
 994           [oReg i | i <- [0..5]] ++
 995           [gReg i | i <- [1..7]] ++
 996           [fReg i | i <- [0..31]] )
 997 #endif {- sparc_TARGET_ARCH -}
 998 #if powerpc_TARGET_ARCH
 999     map RealReg ([0..12] ++ map fReg [0..13])
1000 #endif {- powerpc_TARGET_ARCH -}
1001
1002 -------------------------------
1003 -- argRegs is the set of regs which are read for an n-argument call to C.
1004 -- For archs which pass all args on the stack (x86), is empty.
1005 -- Sparc passes up to the first 6 args in regs.
1006 -- Dunno about Alpha.
1007 argRegs :: Int -> [Reg]
1008
1009 #if i386_TARGET_ARCH
1010 argRegs _ = panic "MachRegs.argRegs(x86): should not be used!"
1011 #endif
1012
1013 #if alpha_TARGET_ARCH
1014 argRegs 0 = []
1015 argRegs 1 = freeMappedRegs [16, fReg 16]
1016 argRegs 2 = freeMappedRegs [16, 17, fReg 16, fReg 17]
1017 argRegs 3 = freeMappedRegs [16, 17, 18, fReg 16, fReg 17, fReg 18]
1018 argRegs 4 = freeMappedRegs [16, 17, 18, 19, fReg 16, fReg 17, fReg 18, fReg 19]
1019 argRegs 5 = freeMappedRegs [16, 17, 18, 19, 20, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20]
1020 argRegs 6 = freeMappedRegs [16, 17, 18, 19, 20, 21, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21]
1021 argRegs _ = panic "MachRegs.argRegs(alpha): don't know about >6 arguments!"
1022 #endif {- alpha_TARGET_ARCH -}
1023
1024 #if sparc_TARGET_ARCH
1025 argRegs 0 = []
1026 argRegs 1 = map (RealReg . oReg) [0]
1027 argRegs 2 = map (RealReg . oReg) [0,1]
1028 argRegs 3 = map (RealReg . oReg) [0,1,2]
1029 argRegs 4 = map (RealReg . oReg) [0,1,2,3]
1030 argRegs 5 = map (RealReg . oReg) [0,1,2,3,4]
1031 argRegs 6 = map (RealReg . oReg) [0,1,2,3,4,5]
1032 argRegs _ = panic "MachRegs.argRegs(sparc): don't know about >6 arguments!"
1033 #endif {- sparc_TARGET_ARCH -}
1034
1035 #if powerpc_TARGET_ARCH
1036 argRegs 0 = []
1037 argRegs 1 = map RealReg [3]
1038 argRegs 2 = map RealReg [3,4]
1039 argRegs 3 = map RealReg [3..5]
1040 argRegs 4 = map RealReg [3..6]
1041 argRegs 5 = map RealReg [3..7]
1042 argRegs 6 = map RealReg [3..8]
1043 argRegs 7 = map RealReg [3..9]
1044 argRegs 8 = map RealReg [3..10]
1045 argRegs _ = panic "MachRegs.argRegs(powerpc): don't know about >8 arguments!"
1046 #endif {- powerpc_TARGET_ARCH -}
1047
1048 -------------------------------
1049 -- all of the arg regs ??
1050 #if alpha_TARGET_ARCH
1051 allArgRegs :: [(Reg, Reg)]
1052 allArgRegs = [(realReg i, realReg (fReg i)) | i <- [16..21]]
1053 #endif {- alpha_TARGET_ARCH -}
1054
1055 #if sparc_TARGET_ARCH
1056 allArgRegs :: [Reg]
1057 allArgRegs = map RealReg [oReg i | i <- [0..5]]
1058 #endif {- sparc_TARGET_ARCH -}
1059
1060 #if i386_TARGET_ARCH
1061 allArgRegs :: [Reg]
1062 allArgRegs = panic "MachRegs.allArgRegs(x86): should not be used!"
1063 #endif
1064
1065 #if powerpc_TARGET_ARCH
1066 allArgRegs :: [Reg]
1067 allArgRegs = map RealReg [3..10]
1068 allFPArgRegs :: [Reg]
1069 allFPArgRegs = map (RealReg . fReg) [1..13]
1070 #endif {- powerpc_TARGET_ARCH -}
1071 \end{code}
1072
1073 \begin{code}
1074 freeReg :: Int -> FastBool
1075
1076 #if alpha_TARGET_ARCH
1077 freeReg 26 = fastBool False  -- return address (ra)
1078 freeReg 28 = fastBool False  -- reserved for the assembler (at)
1079 freeReg 29 = fastBool False  -- global pointer (gp)
1080 freeReg 30 = fastBool False  -- stack pointer (sp)
1081 freeReg 31 = fastBool False  -- always zero (zeroh)
1082 freeReg 63 = fastBool False  -- always zero (f31)
1083 #endif
1084
1085 #if i386_TARGET_ARCH
1086 freeReg esp = fastBool False  --        %esp is the C stack pointer
1087 #endif
1088
1089 #if sparc_TARGET_ARCH
1090 freeReg g0 = fastBool False  -- %g0 is always 0.
1091 freeReg g5 = fastBool False  -- %g5 is reserved (ABI).
1092 freeReg g6 = fastBool False  -- %g6 is reserved (ABI).
1093 freeReg g7 = fastBool False  -- %g7 is reserved (ABI).
1094 freeReg i6 = fastBool False  -- %i6 is our frame pointer.
1095 freeReg i7 = fastBool False  -- %i7 tends to have ret-addr-ish things
1096 freeReg o6 = fastBool False  -- %o6 is our stack pointer.
1097 freeReg o7 = fastBool False  -- %o7 holds ret addrs (???)
1098 freeReg f0 = fastBool False  --  %f0/%f1 are the C fp return registers.
1099 freeReg f1 = fastBool False
1100 #endif
1101
1102 #if powerpc_TARGET_ARCH
1103 freeReg 0 = fastBool False -- Hack: r0 can't be used in all insns, but it's actually free
1104 freeReg 1 = fastBool False -- The Stack Pointer
1105 #if !darwin_TARGET_OS
1106  -- most non-darwin powerpc OSes use r2 as a TOC pointer or something like that
1107 freeReg 2 = fastBool False
1108 #endif
1109 #endif
1110
1111 #ifdef REG_Base
1112 freeReg REG_Base = fastBool False
1113 #endif
1114 #ifdef REG_R1
1115 freeReg REG_R1   = fastBool False
1116 #endif
1117 #ifdef REG_R2
1118 freeReg REG_R2   = fastBool False
1119 #endif
1120 #ifdef REG_R3
1121 freeReg REG_R3   = fastBool False
1122 #endif
1123 #ifdef REG_R4
1124 freeReg REG_R4   = fastBool False
1125 #endif
1126 #ifdef REG_R5
1127 freeReg REG_R5   = fastBool False
1128 #endif
1129 #ifdef REG_R6
1130 freeReg REG_R6   = fastBool False
1131 #endif
1132 #ifdef REG_R7
1133 freeReg REG_R7   = fastBool False
1134 #endif
1135 #ifdef REG_R8
1136 freeReg REG_R8   = fastBool False
1137 #endif
1138 #ifdef REG_F1
1139 freeReg REG_F1 = fastBool False
1140 #endif
1141 #ifdef REG_F2
1142 freeReg REG_F2 = fastBool False
1143 #endif
1144 #ifdef REG_F3
1145 freeReg REG_F3 = fastBool False
1146 #endif
1147 #ifdef REG_F4
1148 freeReg REG_F4 = fastBool False
1149 #endif
1150 #ifdef REG_D1
1151 freeReg REG_D1 = fastBool False
1152 #endif
1153 #ifdef REG_D2
1154 freeReg REG_D2 = fastBool False
1155 #endif
1156 #ifdef REG_Sp
1157 freeReg REG_Sp   = fastBool False
1158 #endif
1159 #ifdef REG_Su
1160 freeReg REG_Su   = fastBool False
1161 #endif
1162 #ifdef REG_SpLim
1163 freeReg REG_SpLim = fastBool False
1164 #endif
1165 #ifdef REG_Hp
1166 freeReg REG_Hp   = fastBool False
1167 #endif
1168 #ifdef REG_HpLim
1169 freeReg REG_HpLim = fastBool False
1170 #endif
1171 freeReg n               = fastBool True
1172 \end{code}