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