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