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