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