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