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
 730 #ifdef darwin_TARGET_OS
 731 #define f0  32
 732 #define f1  33
 733 #define f2  34
 734 #define f3  35
 735 #define f4  36
 736 #define f5  37
 737 #define f6  38
 738 #define f7  39
 739 #define f8  40
 740 #define f9  41
 741 #define f10 42
 742 #define f11 43
 743 #define f12 44
 744 #define f13 45
 745 #define f14 46
 746 #define f15 47
 747 #define f16 48
 748 #define f17 49
 749 #define f18 50
 750 #define f19 51
 751 #define f20 52
 752 #define f21 53
 753 #define f22 54
 754 #define f23 55
 755 #define f24 56
 756 #define f25 57
 757 #define f26 58
 758 #define f27 59
 759 #define f28 60
 760 #define f29 61
 761 #define f30 62
 762 #define f31 63
 763 #else
 764 #define fr0  32
 765 #define fr1  33
 766 #define fr2  34
 767 #define fr3  35
 768 #define fr4  36
 769 #define fr5  37
 770 #define fr6  38
 771 #define fr7  39
 772 #define fr8  40
 773 #define fr9  41
 774 #define fr10 42
 775 #define fr11 43
 776 #define fr12 44
 777 #define fr13 45
 778 #define fr14 46
 779 #define fr15 47
 780 #define fr16 48
 781 #define fr17 49
 782 #define fr18 50
 783 #define fr19 51
 784 #define fr20 52
 785 #define fr21 53
 786 #define fr22 54
 787 #define fr23 55
 788 #define fr24 56
 789 #define fr25 57
 790 #define fr26 58
 791 #define fr27 59
 792 #define fr28 60
 793 #define fr29 61
 794 #define fr30 62
 795 #define fr31 63
 796 #endif
 797 #endif
 798 \end{code}
 799
 800 \begin{code}
 801 baseRegOffset :: MagicId -> Int
 802
 803 baseRegOffset (VanillaReg _ 1#)      = OFFSET_R1
 804 baseRegOffset (VanillaReg _ 2#)      = OFFSET_R2
 805 baseRegOffset (VanillaReg _ 3#)      = OFFSET_R3
 806 baseRegOffset (VanillaReg _ 4#)      = OFFSET_R4
 807 baseRegOffset (VanillaReg _ 5#)      = OFFSET_R5
 808 baseRegOffset (VanillaReg _ 6#)      = OFFSET_R6
 809 baseRegOffset (VanillaReg _ 7#)      = OFFSET_R7
 810 baseRegOffset (VanillaReg _ 8#)      = OFFSET_R8
 811 baseRegOffset (VanillaReg _ 9#)      = OFFSET_R9
 812 baseRegOffset (VanillaReg _ 10#)     = OFFSET_R10
 813 baseRegOffset (FloatReg  1#)         = OFFSET_F1
 814 baseRegOffset (FloatReg  2#)         = OFFSET_F2
 815 baseRegOffset (FloatReg  3#)         = OFFSET_F3
 816 baseRegOffset (FloatReg  4#)         = OFFSET_F4
 817 baseRegOffset (DoubleReg 1#)         = OFFSET_D1
 818 baseRegOffset (DoubleReg 2#)         = OFFSET_D2
 819 baseRegOffset Sp                     = OFFSET_Sp
 820 baseRegOffset SpLim                  = OFFSET_SpLim
 821 #ifdef OFFSET_L1
 822 baseRegOffset (LongReg _ 1#)         = OFFSET_L1
 823 #endif
 824 baseRegOffset Hp                     = OFFSET_Hp
 825 baseRegOffset HpLim                  = OFFSET_HpLim
 826 baseRegOffset CurrentTSO             = OFFSET_CurrentTSO
 827 baseRegOffset CurrentNursery         = OFFSET_CurrentNursery
 828 baseRegOffset HpAlloc                = OFFSET_HpAlloc
 829 #ifdef NCG_DEBUG
 830 baseRegOffset BaseReg                = panic "baseRegOffset:BaseReg"
 831 baseRegOffset CurCostCentre          = panic "baseRegOffset:CurCostCentre"
 832 baseRegOffset VoidReg                = panic "baseRegOffset:VoidReg"
 833 #endif
 834 \end{code}
 835
 836 \begin{code}
 837 callerSaves :: MagicId -> Bool
 838
 839 #ifdef CALLER_SAVES_Base
 840 callerSaves BaseReg                     = True
 841 #endif
 842 #ifdef CALLER_SAVES_R1
 843 callerSaves (VanillaReg _ ILIT(1))      = True
 844 #endif
 845 #ifdef CALLER_SAVES_R2
 846 callerSaves (VanillaReg _ ILIT(2))      = True
 847 #endif
 848 #ifdef CALLER_SAVES_R3
 849 callerSaves (VanillaReg _ ILIT(3))      = True
 850 #endif
 851 #ifdef CALLER_SAVES_R4
 852 callerSaves (VanillaReg _ ILIT(4))      = True
 853 #endif
 854 #ifdef CALLER_SAVES_R5
 855 callerSaves (VanillaReg _ ILIT(5))      = True
 856 #endif
 857 #ifdef CALLER_SAVES_R6
 858 callerSaves (VanillaReg _ ILIT(6))      = True
 859 #endif
 860 #ifdef CALLER_SAVES_R7
 861 callerSaves (VanillaReg _ ILIT(7))      = True
 862 #endif
 863 #ifdef CALLER_SAVES_R8
 864 callerSaves (VanillaReg _ ILIT(8))      = True
 865 #endif
 866 #ifdef CALLER_SAVES_F1
 867 callerSaves (FloatReg 1#)               = True
 868 #endif
 869 #ifdef CALLER_SAVES_F2
 870 callerSaves (FloatReg 2#)               = True
 871 #endif
 872 #ifdef CALLER_SAVES_F3
 873 callerSaves (FloatReg 3#)               = True
 874 #endif
 875 #ifdef CALLER_SAVES_F4
 876 callerSaves (FloatReg 4#)               = True
 877 #endif
 878 #ifdef CALLER_SAVES_D1
 879 callerSaves (DoubleReg 1#)              = True
 880 #endif
 881 #ifdef CALLER_SAVES_D2
 882 callerSaves (DoubleReg 2#)              = True
 883 #endif
 884 #ifdef CALLER_SAVES_L1
 885 callerSaves (LongReg _ ILIT(1))         = True
 886 #endif
 887 #ifdef CALLER_SAVES_Sp
 888 callerSaves Sp                          = True
 889 #endif
 890 #ifdef CALLER_SAVES_SpLim
 891 callerSaves SpLim                       = True
 892 #endif
 893 #ifdef CALLER_SAVES_Hp
 894 callerSaves Hp                          = True
 895 #endif
 896 #ifdef CALLER_SAVES_HpLim
 897 callerSaves HpLim                       = True
 898 #endif
 899 #ifdef CALLER_SAVES_CurrentTSO
 900 callerSaves CurrentTSO                  = True
 901 #endif
 902 #ifdef CALLER_SAVES_CurrentNursery
 903 callerSaves CurrentNursery              = True
 904 #endif
 905 callerSaves _                           = False
 906 \end{code}
 907
 908 \begin{code}
 909 magicIdRegMaybe :: MagicId -> Maybe Reg
 910
 911 #ifdef REG_Base
 912 magicIdRegMaybe BaseReg                 = Just (RealReg REG_Base)
 913 #endif
 914 #ifdef REG_R1
 915 magicIdRegMaybe (VanillaReg _ 1#)       = Just (RealReg REG_R1)
 916 #endif
 917 #ifdef REG_R2
 918 magicIdRegMaybe (VanillaReg _ 2#)       = Just (RealReg REG_R2)
 919 #endif
 920 #ifdef REG_R3
 921 magicIdRegMaybe (VanillaReg _ 3#)       = Just (RealReg REG_R3)
 922 #endif
 923 #ifdef REG_R4
 924 magicIdRegMaybe (VanillaReg _ 4#)       = Just (RealReg REG_R4)
 925 #endif
 926 #ifdef REG_R5
 927 magicIdRegMaybe (VanillaReg _ 5#)       = Just (RealReg REG_R5)
 928 #endif
 929 #ifdef REG_R6
 930 magicIdRegMaybe (VanillaReg _ 6#)       = Just (RealReg REG_R6)
 931 #endif
 932 #ifdef REG_R7
 933 magicIdRegMaybe (VanillaReg _ 7#)       = Just (RealReg REG_R7)
 934 #endif
 935 #ifdef REG_R8
 936 magicIdRegMaybe (VanillaReg _ 8#)       = Just (RealReg REG_R8)
 937 #endif
 938 #ifdef REG_R9
 939 magicIdRegMaybe (VanillaReg _ 9#)       = Just (RealReg REG_R9)
 940 #endif
 941 #ifdef REG_R10
 942 magicIdRegMaybe (VanillaReg _ 10#)      = Just (RealReg REG_R10)
 943 #endif
 944 #ifdef REG_F1
 945 magicIdRegMaybe (FloatReg 1#)   = Just (RealReg REG_F1)
 946 #endif
 947 #ifdef REG_F2
 948 magicIdRegMaybe (FloatReg 2#)   = Just (RealReg REG_F2)
 949 #endif
 950 #ifdef REG_F3
 951 magicIdRegMaybe (FloatReg 3#)   = Just (RealReg REG_F3)
 952 #endif
 953 #ifdef REG_F4
 954 magicIdRegMaybe (FloatReg 4#)   = Just (RealReg REG_F4)
 955 #endif
 956 #ifdef REG_D1
 957 magicIdRegMaybe (DoubleReg 1#)  = Just (RealReg REG_D1)
 958 #endif
 959 #ifdef REG_D2
 960 magicIdRegMaybe (DoubleReg 2#)  = Just (RealReg REG_D2)
 961 #endif
 962 #ifdef REG_Sp
 963 magicIdRegMaybe Sp                      = Just (RealReg REG_Sp)
 964 #endif
 965 #ifdef REG_Lng1
 966 magicIdRegMaybe (LongReg _ ILIT(1))     = Just (RealReg REG_Lng1)
 967 #endif
 968 #ifdef REG_Lng2
 969 magicIdRegMaybe (LongReg _ ILIT(2))     = Just (RealReg REG_Lng2)
 970 #endif
 971 #ifdef REG_SpLim
 972 magicIdRegMaybe SpLim                   = Just (RealReg REG_SpLim)
 973 #endif
 974 #ifdef REG_Hp
 975 magicIdRegMaybe Hp                      = Just (RealReg REG_Hp)
 976 #endif
 977 #ifdef REG_HpLim
 978 magicIdRegMaybe HpLim                   = Just (RealReg REG_HpLim)
 979 #endif
 980 #ifdef REG_CurrentTSO
 981 magicIdRegMaybe CurrentTSO              = Just (RealReg REG_CurrentTSO)
 982 #endif
 983 #ifdef REG_CurrentNursery
 984 magicIdRegMaybe CurrentNursery          = Just (RealReg REG_CurrentNursery)
 985 #endif
 986 magicIdRegMaybe _                       = Nothing
 987 \end{code}
 988
 989 \begin{code}
 990 -------------------------------
 991 -- allMachRegs is the complete set of machine regs.
 992 allMachRegNos :: [Int]
 993 allMachRegNos
 994    = IF_ARCH_alpha( [0..63],
 995      IF_ARCH_i386(  [0..13],
 996      IF_ARCH_sparc( ([0..31]
 997                      ++ [f0,f2 .. nCG_FirstFloatReg-1]
 998                      ++ [nCG_FirstFloatReg .. f31]),
 999      IF_ARCH_powerpc([0..63],
1000                    ))))
1001 -- allocatableRegs is allMachRegNos with the fixed-use regs removed.
1002 -- i.e., these are the regs for which we are prepared to allow the
1003 -- register allocator to attempt to map VRegs to.
1004 allocatableRegs :: [Reg]
1005 allocatableRegs
1006    = let isFree i = isFastTrue (freeReg i)
1007      in  map RealReg (filter isFree allMachRegNos)
1008
1009 -------------------------------
1010 -- these are the regs which we cannot assume stay alive over a
1011 -- C call.
1012 callClobberedRegs :: [Reg]
1013 callClobberedRegs
1014   =
1015 #if alpha_TARGET_ARCH
1016     [0, 1, 2, 3, 4, 5, 6, 7, 8,
1017      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1018      fReg 0, fReg 1, fReg 10, fReg 11, fReg 12, fReg 13, fReg 14, fReg 15,
1019      fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21, fReg 22, fReg 23,
1020      fReg 24, fReg 25, fReg 26, fReg 27, fReg 28, fReg 29, fReg 30]
1021 #endif /* alpha_TARGET_ARCH */
1022 #if i386_TARGET_ARCH
1023     -- caller-saves registers
1024     map RealReg [eax,ecx,edx,fake0,fake1,fake2,fake3,fake4,fake5]
1025 #endif /* i386_TARGET_ARCH */
1026 #if sparc_TARGET_ARCH
1027     map RealReg
1028         ( oReg 7 :
1029           [oReg i | i <- [0..5]] ++
1030           [gReg i | i <- [1..7]] ++
1031           [fReg i | i <- [0..31]] )
1032 #endif /* sparc_TARGET_ARCH */
1033 #if powerpc_TARGET_ARCH
1034     map RealReg ([0..12] ++ map fReg [0..13])
1035 #endif /* powerpc_TARGET_ARCH */
1036
1037 -------------------------------
1038 -- argRegs is the set of regs which are read for an n-argument call to C.
1039 -- For archs which pass all args on the stack (x86), is empty.
1040 -- Sparc passes up to the first 6 args in regs.
1041 -- Dunno about Alpha.
1042 argRegs :: Int -> [Reg]
1043
1044 #if i386_TARGET_ARCH
1045 argRegs _ = panic "MachRegs.argRegs(x86): should not be used!"
1046 #endif
1047
1048 #if alpha_TARGET_ARCH
1049 argRegs 0 = []
1050 argRegs 1 = freeMappedRegs [16, fReg 16]
1051 argRegs 2 = freeMappedRegs [16, 17, fReg 16, fReg 17]
1052 argRegs 3 = freeMappedRegs [16, 17, 18, fReg 16, fReg 17, fReg 18]
1053 argRegs 4 = freeMappedRegs [16, 17, 18, 19, fReg 16, fReg 17, fReg 18, fReg 19]
1054 argRegs 5 = freeMappedRegs [16, 17, 18, 19, 20, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20]
1055 argRegs 6 = freeMappedRegs [16, 17, 18, 19, 20, 21, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21]
1056 argRegs _ = panic "MachRegs.argRegs(alpha): don't know about >6 arguments!"
1057 #endif /* alpha_TARGET_ARCH */
1058
1059 #if sparc_TARGET_ARCH
1060 argRegs 0 = []
1061 argRegs 1 = map (RealReg . oReg) [0]
1062 argRegs 2 = map (RealReg . oReg) [0,1]
1063 argRegs 3 = map (RealReg . oReg) [0,1,2]
1064 argRegs 4 = map (RealReg . oReg) [0,1,2,3]
1065 argRegs 5 = map (RealReg . oReg) [0,1,2,3,4]
1066 argRegs 6 = map (RealReg . oReg) [0,1,2,3,4,5]
1067 argRegs _ = panic "MachRegs.argRegs(sparc): don't know about >6 arguments!"
1068 #endif /* sparc_TARGET_ARCH */
1069
1070 #if powerpc_TARGET_ARCH
1071 argRegs 0 = []
1072 argRegs 1 = map RealReg [3]
1073 argRegs 2 = map RealReg [3,4]
1074 argRegs 3 = map RealReg [3..5]
1075 argRegs 4 = map RealReg [3..6]
1076 argRegs 5 = map RealReg [3..7]
1077 argRegs 6 = map RealReg [3..8]
1078 argRegs 7 = map RealReg [3..9]
1079 argRegs 8 = map RealReg [3..10]
1080 argRegs _ = panic "MachRegs.argRegs(powerpc): don't know about >8 arguments!"
1081 #endif /* powerpc_TARGET_ARCH */
1082
1083 -------------------------------
1084 -- all of the arg regs ??
1085 #if alpha_TARGET_ARCH
1086 allArgRegs :: [(Reg, Reg)]
1087 allArgRegs = [(realReg i, realReg (fReg i)) | i <- [16..21]]
1088 #endif /* alpha_TARGET_ARCH */
1089
1090 #if sparc_TARGET_ARCH
1091 allArgRegs :: [Reg]
1092 allArgRegs = map RealReg [oReg i | i <- [0..5]]
1093 #endif /* sparc_TARGET_ARCH */
1094
1095 #if i386_TARGET_ARCH
1096 allArgRegs :: [Reg]
1097 allArgRegs = panic "MachRegs.allArgRegs(x86): should not be used!"
1098 #endif
1099
1100 #if powerpc_TARGET_ARCH
1101 allArgRegs :: [Reg]
1102 allArgRegs = map RealReg [3..10]
1103 allFPArgRegs :: [Reg]
1104 allFPArgRegs = map (RealReg . fReg) [1..13]
1105 #endif /* powerpc_TARGET_ARCH */
1106 \end{code}
1107
1108 \begin{code}
1109 freeReg :: Int -> FastBool
1110
1111 #if alpha_TARGET_ARCH
1112 freeReg 26 = fastBool False  -- return address (ra)
1113 freeReg 28 = fastBool False  -- reserved for the assembler (at)
1114 freeReg 29 = fastBool False  -- global pointer (gp)
1115 freeReg 30 = fastBool False  -- stack pointer (sp)
1116 freeReg 31 = fastBool False  -- always zero (zeroh)
1117 freeReg 63 = fastBool False  -- always zero (f31)
1118 #endif
1119
1120 #if i386_TARGET_ARCH
1121 freeReg esp = fastBool False  --        %esp is the C stack pointer
1122 #endif
1123
1124 #if sparc_TARGET_ARCH
1125 freeReg g0 = fastBool False  -- %g0 is always 0.
1126 freeReg g5 = fastBool False  -- %g5 is reserved (ABI).
1127 freeReg g6 = fastBool False  -- %g6 is reserved (ABI).
1128 freeReg g7 = fastBool False  -- %g7 is reserved (ABI).
1129 freeReg i6 = fastBool False  -- %i6 is our frame pointer.
1130 freeReg i7 = fastBool False  -- %i7 tends to have ret-addr-ish things
1131 freeReg o6 = fastBool False  -- %o6 is our stack pointer.
1132 freeReg o7 = fastBool False  -- %o7 holds ret addrs (???)
1133 freeReg f0 = fastBool False  --  %f0/%f1 are the C fp return registers.
1134 freeReg f1 = fastBool False
1135 #endif
1136
1137 #if powerpc_TARGET_ARCH
1138 freeReg 0 = fastBool False -- Hack: r0 can't be used in all insns, but it's actually free
1139 freeReg 1 = fastBool False -- The Stack Pointer
1140 #if !darwin_TARGET_OS
1141  -- most non-darwin powerpc OSes use r2 as a TOC pointer or something like that
1142 freeReg 2 = fastBool False
1143 #endif
1144 #endif
1145
1146 #ifdef REG_Base
1147 freeReg REG_Base = fastBool False
1148 #endif
1149 #ifdef REG_R1
1150 freeReg REG_R1   = fastBool False
1151 #endif
1152 #ifdef REG_R2
1153 freeReg REG_R2   = fastBool False
1154 #endif
1155 #ifdef REG_R3
1156 freeReg REG_R3   = fastBool False
1157 #endif
1158 #ifdef REG_R4
1159 freeReg REG_R4   = fastBool False
1160 #endif
1161 #ifdef REG_R5
1162 freeReg REG_R5   = fastBool False
1163 #endif
1164 #ifdef REG_R6
1165 freeReg REG_R6   = fastBool False
1166 #endif
1167 #ifdef REG_R7
1168 freeReg REG_R7   = fastBool False
1169 #endif
1170 #ifdef REG_R8
1171 freeReg REG_R8   = fastBool False
1172 #endif
1173 #ifdef REG_F1
1174 freeReg REG_F1 = fastBool False
1175 #endif
1176 #ifdef REG_F2
1177 freeReg REG_F2 = fastBool False
1178 #endif
1179 #ifdef REG_F3
1180 freeReg REG_F3 = fastBool False
1181 #endif
1182 #ifdef REG_F4
1183 freeReg REG_F4 = fastBool False
1184 #endif
1185 #ifdef REG_D1
1186 freeReg REG_D1 = fastBool False
1187 #endif
1188 #ifdef REG_D2
1189 freeReg REG_D2 = fastBool False
1190 #endif
1191 #ifdef REG_Sp
1192 freeReg REG_Sp   = fastBool False
1193 #endif
1194 #ifdef REG_Su
1195 freeReg REG_Su   = fastBool False
1196 #endif
1197 #ifdef REG_SpLim
1198 freeReg REG_SpLim = fastBool False
1199 #endif
1200 #ifdef REG_Hp
1201 freeReg REG_Hp   = fastBool False
1202 #endif
1203 #ifdef REG_HpLim
1204 freeReg REG_HpLim = fastBool False
1205 #endif
1206 freeReg n               = fastBool True
1207 \end{code}