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