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