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