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