ghc/compiler/nativeGen/MachRegs.lhs

   1 %
   2 % (c) The AQUA Project, Glasgow University, 1996
   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 "HsVersions.h"
  14 #include "nativeGen/NCG.h"
  15
  16 module MachRegs (
  17
  18         Reg(..),
  19         Imm(..),
  20         Addr(..),
  21         RegLoc(..),
  22         RegNo(..),
  23
  24         addrOffset,
  25         argRegs,
  26         baseRegOffset,
  27         callClobberedRegs,
  28         callerSaves,
  29         dblImmLit,
  30         extractMappedRegNos,
  31         freeMappedRegs,
  32         freeReg, freeRegs,
  33         getNewRegNCG,
  34         magicIdRegMaybe,
  35         mkReg,
  36         realReg,
  37         reservedRegs,
  38         saveLoc,
  39         spRel,
  40         stgReg,
  41         strImmLit
  42
  43 #if alpha_TARGET_ARCH
  44         , allArgRegs
  45         , fits8Bits
  46         , fReg
  47         , gp, pv, ra, sp, t9, t10, t11, t12, v0, f0, zero
  48 #endif
  49 #if i386_TARGET_ARCH
  50         , eax, ebx, ecx, edx, esi, esp
  51         , st0, st1, st2, st3, st4, st5, st6, st7
  52 #endif
  53 #if sparc_TARGET_ARCH
  54         , allArgRegs
  55         , fits13Bits
  56         , fPair, fpRel, gReg, iReg, lReg, oReg, largeOffsetError
  57         , fp, g0, o0, f0
  58
  59 #endif
  60     ) where
  61
  62 import Ubiq{-uitous-}
  63
  64 import AbsCSyn          ( MagicId(..) )
  65 import AbsCUtils        ( magicIdPrimRep )
  66 import Pretty           ( ppStr, ppRational, ppShow )
  67 import PrimOp           ( PrimOp(..) )
  68 import PrimRep          ( PrimRep(..) )
  69 import Stix             ( sStLitLbl, StixTree(..), StixReg(..),
  70                           CodeSegment
  71                         )
  72 import Unique           ( Unique{-instance Ord3-} )
  73 import UniqSupply       ( mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3,
  74                           getUnique, returnUs, thenUs, UniqSM(..)
  75                         )
  76 import Unpretty         ( uppStr, Unpretty(..) )
  77 import Util             ( panic )
  78 \end{code}
  79
  80 % - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  81
  82 \begin{code}
  83 data Imm
  84   = ImmInt      Int
  85   | ImmInteger  Integer     -- Sigh.
  86   | ImmCLbl     CLabel      -- AbstractC Label (with baggage)
  87   | ImmLab      Unpretty    -- Simple string label (underscore-able)
  88   | ImmLit      Unpretty    -- Simple string
  89   IF_ARCH_sparc(
  90   | LO Imm                  -- Possible restrictions...
  91   | HI Imm
  92   ,)
  93
  94 strImmLit s = ImmLit (uppStr s)
  95 dblImmLit r
  96   = strImmLit (
  97          IF_ARCH_alpha({-prepend nothing-}
  98         ,IF_ARCH_i386( '0' : 'd' :
  99         ,IF_ARCH_sparc('0' : 'r' :,)))
 100         ppShow 80 (ppRational r))
 101 \end{code}
 102
 103 % - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 104
 105 \begin{code}
 106 data Addr
 107 #if alpha_TARGET_ARCH
 108   = AddrImm     Imm
 109   | AddrReg     Reg
 110   | AddrRegImm  Reg Imm
 111 #endif
 112
 113 #if i386_TARGET_ARCH
 114   = Addr        Base Index Displacement
 115   | ImmAddr     Imm Int
 116
 117 type Base         = Maybe Reg
 118 type Index        = Maybe (Reg, Int)    -- Int is 2, 4 or 8
 119 type Displacement = Imm
 120 #endif
 121
 122 #if sparc_TARGET_ARCH
 123   = AddrRegReg  Reg Reg
 124   | AddrRegImm  Reg Imm
 125 #endif
 126
 127 addrOffset :: Addr -> Int -> Maybe Addr
 128
 129 addrOffset addr off
 130   = case addr of
 131 #if alpha_TARGET_ARCH
 132       _ -> panic "MachMisc.addrOffset not defined for Alpha"
 133 #endif
 134 #if i386_TARGET_ARCH
 135       ImmAddr i off0      -> Just (ImmAddr i (off0 + off))
 136       Addr r i (ImmInt n) -> Just (Addr r i (ImmInt (n + off)))
 137       Addr r i (ImmInteger n)
 138         -> Just (Addr r i (ImmInt (fromInteger (n + toInteger off))))
 139       _ -> Nothing
 140 #endif
 141 #if sparc_TARGET_ARCH
 142       AddrRegImm r (ImmInt n)
 143        | fits13Bits n2 -> Just (AddrRegImm r (ImmInt n2))
 144        | otherwise     -> Nothing
 145        where n2 = n + off
 146
 147       AddrRegImm r (ImmInteger n)
 148        | fits13Bits n2 -> Just (AddrRegImm r (ImmInt (fromInteger n2)))
 149        | otherwise     -> Nothing
 150        where n2 = n + toInteger off
 151
 152       AddrRegReg r (FixedReg ILIT(0))
 153        | fits13Bits off -> Just (AddrRegImm r (ImmInt off))
 154        | otherwise     -> Nothing
 155
 156       _ -> Nothing
 157
 158 #endif {-sparc-}
 159
 160 -----------------
 161 #if alpha_TARGET_ARCH
 162
 163 fits8Bits :: Integer -> Bool
 164 fits8Bits i = i >= -256 && i < 256
 165
 166 #endif
 167
 168 #if sparc_TARGET_ARCH
 169 {-# SPECIALIZE
 170     fits13Bits :: Int -> Bool
 171   #-}
 172 {-# SPECIALIZE
 173     fits13Bits :: Integer -> Bool
 174   #-}
 175
 176 fits13Bits :: Integral a => a -> Bool
 177 fits13Bits x = x >= -4096 && x < 4096
 178
 179 -----------------
 180 largeOffsetError i
 181   = error ("ERROR: SPARC native-code generator cannot handle large offset ("++show i++");\nprobably because of large constant data structures;\nworkaround: use -fvia-C on this module.\n")
 182
 183 #endif {-sparc-}
 184 \end{code}
 185
 186 % - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 187
 188 @stgReg@: we map STG registers onto appropriate Stix Trees.  First, we
 189 handle the two constants, @STK_STUB_closure@ and @vtbl_StdUpdFrame@.
 190 The rest are either in real machine registers or stored as offsets
 191 from BaseReg.
 192
 193 \begin{code}
 194 data RegLoc = Save StixTree | Always StixTree
 195 \end{code}
 196
 197 Trees for register save locations:
 198 \begin{code}
 199 saveLoc :: MagicId -> StixTree
 200
 201 saveLoc reg = case (stgReg reg) of {Always loc -> loc; Save loc -> loc}
 202 \end{code}
 203
 204 \begin{code}
 205 stgReg :: MagicId -> RegLoc
 206
 207 stgReg x
 208   = case (magicIdRegMaybe x) of
 209         Just _  -> Save   nonReg
 210         Nothing -> Always nonReg
 211   where
 212     offset = baseRegOffset x
 213
 214     baseLoc = case (magicIdRegMaybe BaseReg) of
 215       Just _  -> StReg (StixMagicId BaseReg)
 216       Nothing -> sStLitLbl SLIT("MainRegTable")
 217
 218     nonReg = case x of
 219       StkStubReg        -> sStLitLbl SLIT("STK_STUB_closure")
 220       StdUpdRetVecReg   -> sStLitLbl SLIT("vtbl_StdUpdFrame")
 221       BaseReg           -> sStLitLbl SLIT("MainRegTable")
 222         -- these Hp&HpLim cases perhaps should
 223         -- not be here for i386 (???) WDP 96/03
 224       Hp                -> StInd PtrRep (sStLitLbl SLIT("StorageMgrInfo"))
 225       HpLim             -> StInd PtrRep (sStLitLbl
 226                                 (_PK_ ("StorageMgrInfo+" ++ BYTES_PER_WORD_STR)))
 227       TagReg            -> StInd IntRep (StPrim IntSubOp [infoptr,
 228                                 StInt (1*BYTES_PER_WORD)])
 229                         where
 230                             r2      = VanillaReg PtrRep ILIT(2)
 231                             infoptr = case (stgReg r2) of
 232                                           Always t -> t
 233                                           Save   _ -> StReg (StixMagicId r2)
 234       _ -> StInd (magicIdPrimRep x)
 235                  (StPrim IntAddOp [baseLoc,
 236                         StInt (toInteger (offset*BYTES_PER_WORD))])
 237 \end{code}
 238
 239 % - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 240
 241 @spRel@ gives us a stack relative addressing mode for volatile
 242 temporaries and for excess call arguments.  @fpRel@, where
 243 applicable, is the same but for the frame pointer.
 244
 245 \begin{code}
 246 spRel :: Int    -- desired stack offset in words, positive or negative
 247       -> Addr
 248
 249 spRel n
 250 #if i386_TARGET_ARCH
 251   = Addr (Just esp) Nothing (ImmInt (n * BYTES_PER_WORD))
 252 #else
 253   = AddrRegImm sp (ImmInt (n * BYTES_PER_WORD))
 254 #endif
 255
 256 #if sparc_TARGET_ARCH
 257 fpRel :: Int -> Addr
 258     -- Duznae work for offsets greater than 13 bits; we just hope for
 259     -- the best
 260 fpRel n
 261   = AddrRegImm fp (ImmInt (n * BYTES_PER_WORD))
 262 #endif
 263 \end{code}
 264
 265 %************************************************************************
 266 %*                                                                      *
 267 \subsection[Reg]{Real registers}
 268 %*                                                                      *
 269 %************************************************************************
 270
 271 Static Registers correspond to actual machine registers.  These should
 272 be avoided until the last possible moment.
 273
 274 Dynamic registers are allocated on the fly, usually to represent a single
 275 value in the abstract assembly code (i.e. dynamic registers are usually
 276 single assignment).  Ultimately, they are mapped to available machine
 277 registers before spitting out the code.
 278
 279 \begin{code}
 280 data Reg
 281   = FixedReg  FAST_INT          -- A pre-allocated machine register
 282
 283   | MappedReg FAST_INT          -- A dynamically allocated machine register
 284
 285   | MemoryReg Int PrimRep       -- A machine "register" actually held in
 286                                 -- a memory allocated table of
 287                                 -- registers which didn't fit in real
 288                                 -- registers.
 289
 290   | UnmappedReg Unique PrimRep  -- One of an infinite supply of registers,
 291                                 -- always mapped to one of the earlier
 292                                 -- two (?)  before we're done.
 293
 294 mkReg :: Unique -> PrimRep -> Reg
 295 mkReg = UnmappedReg
 296
 297 getNewRegNCG :: PrimRep -> UniqSM Reg
 298 getNewRegNCG pk
 299   = getUnique   `thenUs` \ u ->
 300     returnUs (UnmappedReg u pk)
 301
 302 instance Text Reg where
 303     showsPrec _ (FixedReg i)    = showString "%"  . shows IBOX(i)
 304     showsPrec _ (MappedReg i)   = showString "%"  . shows IBOX(i)
 305     showsPrec _ (MemoryReg i _) = showString "%M"  . shows i
 306     showsPrec _ (UnmappedReg i _) = showString "%U" . shows i
 307
 308 #ifdef DEBUG
 309 instance Outputable Reg where
 310     ppr sty r = ppStr (show r)
 311 #endif
 312
 313 cmpReg (FixedReg i) (FixedReg i') = cmp_ihash i i'
 314 cmpReg (MappedReg i) (MappedReg i') = cmp_ihash i i'
 315 cmpReg (MemoryReg i _) (MemoryReg i' _) = cmp_i i i'
 316 cmpReg (UnmappedReg u _) (UnmappedReg u' _) = cmp u u'
 317 cmpReg r1 r2
 318   = let tag1 = tagReg r1
 319         tag2 = tagReg r2
 320     in
 321         if tag1 _LT_ tag2 then LT_ else GT_
 322     where
 323         tagReg (FixedReg _)      = (ILIT(1) :: FAST_INT)
 324         tagReg (MappedReg _)     = ILIT(2)
 325         tagReg (MemoryReg _ _)   = ILIT(3)
 326         tagReg (UnmappedReg _ _) = ILIT(4)
 327
 328 cmp_i :: Int -> Int -> TAG_
 329 cmp_i a1 a2 = if a1 == a2 then EQ_ else if a1 < a2 then LT_ else GT_
 330
 331 cmp_ihash :: FAST_INT -> FAST_INT -> TAG_
 332 cmp_ihash a1 a2 = if a1 _EQ_ a2 then EQ_ else if a1 _LT_ a2 then LT_ else GT_
 333
 334 instance Eq Reg where
 335     a == b = case cmpReg a b of { EQ_ -> True;  _ -> False }
 336     a /= b = case cmpReg a b of { EQ_ -> False; _ -> True  }
 337
 338 instance Ord Reg where
 339     a <= b = case cmpReg a b of { LT_ -> True;  EQ_ -> True;  GT__ -> False }
 340     a <  b = case cmpReg a b of { LT_ -> True;  EQ_ -> False; GT__ -> False }
 341     a >= b = case cmpReg a b of { LT_ -> False; EQ_ -> True;  GT__ -> True  }
 342     a >  b = case cmpReg a b of { LT_ -> False; EQ_ -> False; GT__ -> True  }
 343     _tagCmp a b = case cmpReg a b of { LT_ -> _LT; EQ_ -> _EQ; GT__ -> _GT }
 344
 345 instance NamedThing Reg where
 346     -- the *only* method that should be defined is "getItsUnique"!
 347     -- (so we can use UniqFMs/UniqSets on Regs
 348     getItsUnique (UnmappedReg u _) = u
 349     getItsUnique (FixedReg i)      = mkPseudoUnique1 IBOX(i)
 350     getItsUnique (MappedReg i)     = mkPseudoUnique2 IBOX(i)
 351     getItsUnique (MemoryReg i _)   = mkPseudoUnique3 i
 352 \end{code}
 353
 354 \begin{code}
 355 type RegNo = Int
 356
 357 realReg :: RegNo -> Reg
 358 realReg n@IBOX(i)
 359   = if _IS_TRUE_(freeReg i) then MappedReg i else FixedReg i
 360
 361 extractMappedRegNos :: [Reg] -> [RegNo]
 362
 363 extractMappedRegNos regs
 364   = foldr ex [] regs
 365   where
 366     ex (MappedReg i) acc = IBOX(i) : acc  -- we'll take it
 367     ex _             acc = acc            -- leave it out
 368 \end{code}
 369
 370 ** Machine-specific Reg stuff: **
 371
 372 The Alpha has 64 registers of interest; 32 integer registers and 32 floating
 373 point registers.  The mapping of STG registers to alpha machine registers
 374 is defined in StgRegs.h.  We are, of course, prepared for any eventuality.
 375 \begin{code}
 376 #if alpha_TARGET_ARCH
 377 fReg :: Int -> Int
 378 fReg x = (32 + x)
 379
 380 v0, f0, ra, pv, gp, sp, zero :: Reg
 381 v0   = realReg 0
 382 f0   = realReg (fReg 0)
 383 ra   = FixedReg ILIT(26)
 384 pv   = t12
 385 gp   = FixedReg ILIT(29)
 386 sp   = FixedReg ILIT(30)
 387 zero = FixedReg ILIT(31)
 388
 389 t9, t10, t11, t12 :: Reg
 390 t9  = realReg 23
 391 t10 = realReg 24
 392 t11 = realReg 25
 393 t12 = realReg 27
 394 #endif
 395 \end{code}
 396
 397 Intel x86 architecture:
 398 - All registers except 7 (esp) are available for use.
 399 - Only ebx, esi, edi and esp are available across a C call (they are callee-saves).
 400 - Registers 0-7 have 16-bit counterparts (ax, bx etc.)
 401 - Registers 0-3 have 8 bit counterparts (ah, bh etc.)
 402 - Registers 8-15 hold extended floating point values.
 403 \begin{code}
 404 #if i386_TARGET_ARCH
 405
 406 gReg,fReg :: Int -> Int
 407 gReg x = x
 408 fReg x = (8 + x)
 409
 410 st0, st1, st2, st3, st4, st5, st6, st7, eax, ebx, ecx, edx, esp :: Reg
 411 eax = case (gReg 0) of { IBOX(g0) -> FixedReg g0 }
 412 ebx = case (gReg 1) of { IBOX(g1) -> FixedReg g1 }
 413 ecx = case (gReg 2) of { IBOX(g2) -> FixedReg g2 }
 414 edx = case (gReg 3) of { IBOX(g3) -> FixedReg g3 }
 415 esi = case (gReg 4) of { IBOX(g4) -> FixedReg g4 }
 416 edi = case (gReg 5) of { IBOX(g5) -> FixedReg g5 }
 417 ebp = case (gReg 6) of { IBOX(g6) -> FixedReg g6 }
 418 esp = case (gReg 7) of { IBOX(g7) -> FixedReg g7 }
 419 st0 = realReg  (fReg 0)
 420 st1 = realReg  (fReg 1)
 421 st2 = realReg  (fReg 2)
 422 st3 = realReg  (fReg 3)
 423 st4 = realReg  (fReg 4)
 424 st5 = realReg  (fReg 5)
 425 st6 = realReg  (fReg 6)
 426 st7 = realReg  (fReg 7)
 427
 428 #endif
 429 \end{code}
 430
 431 The SPARC has 64 registers of interest; 32 integer registers and 32
 432 floating point registers.  The mapping of STG registers to SPARC
 433 machine registers is defined in StgRegs.h.  We are, of course,
 434 prepared for any eventuality.
 435
 436 \begin{code}
 437 #if sparc_TARGET_ARCH
 438
 439 gReg,lReg,iReg,oReg,fReg :: Int -> Int
 440 gReg x = x
 441 oReg x = (8 + x)
 442 lReg x = (16 + x)
 443 iReg x = (24 + x)
 444 fReg x = (32 + x)
 445
 446 fPair :: Reg -> Reg
 447 fPair (FixedReg i) = FixedReg (i _ADD_ ILIT(1))
 448 fPair (MappedReg i) = MappedReg (i _ADD_ ILIT(1))
 449
 450 g0, fp, sp, o0, f0 :: Reg
 451 g0 = case (gReg 0) of { IBOX(g0) -> FixedReg g0 }
 452 fp = case (iReg 6) of { IBOX(i6) -> FixedReg i6 }
 453 sp = case (oReg 6) of { IBOX(o6) -> FixedReg o6 }
 454 o0 = realReg  (oReg 0)
 455 f0 = realReg  (fReg 0)
 456
 457 #endif
 458 \end{code}
 459
 460 Redefine the literals used for machine-registers with non-numeric
 461 names in the header files.  Gag me with a spoon, eh?
 462 \begin{code}
 463 #if alpha_TARGET_ARCH
 464 #define f0 32
 465 #define f1 33
 466 #define f2 34
 467 #define f3 35
 468 #define f4 36
 469 #define f5 37
 470 #define f6 38
 471 #define f7 39
 472 #define f8 40
 473 #define f9 41
 474 #define f10 42
 475 #define f11 43
 476 #define f12 44
 477 #define f13 45
 478 #define f14 46
 479 #define f15 47
 480 #define f16 48
 481 #define f17 49
 482 #define f18 50
 483 #define f19 51
 484 #define f20 52
 485 #define f21 53
 486 #define f22 54
 487 #define f23 55
 488 #define f24 56
 489 #define f25 57
 490 #define f26 58
 491 #define f27 59
 492 #define f28 60
 493 #define f29 61
 494 #define f30 62
 495 #define f31 63
 496 #endif
 497 #if i386_TARGET_ARCH
 498 #define eax 0
 499 #define ebx 1
 500 #define ecx 2
 501 #define edx 3
 502 #define esi 4
 503 #define edi 5
 504 #define ebp 6
 505 #define esp 7
 506 #define st0 8
 507 #define st1 9
 508 #define st2 10
 509 #define st3 11
 510 #define st4 12
 511 #define st5 13
 512 #define st6 14
 513 #define st7 15
 514 #endif
 515 #if sparc_TARGET_ARCH
 516 #define g0 0
 517 #define g1 1
 518 #define g2 2
 519 #define g3 3
 520 #define g4 4
 521 #define g5 5
 522 #define g6 6
 523 #define g7 7
 524 #define o0 8
 525 #define o1 9
 526 #define o2 10
 527 #define o3 11
 528 #define o4 12
 529 #define o5 13
 530 #define o6 14
 531 #define o7 15
 532 #define l0 16
 533 #define l1 17
 534 #define l2 18
 535 #define l3 19
 536 #define l4 20
 537 #define l5 21
 538 #define l6 22
 539 #define l7 23
 540 #define i0 24
 541 #define i1 25
 542 #define i2 26
 543 #define i3 27
 544 #define i4 28
 545 #define i5 29
 546 #define i6 30
 547 #define i7 31
 548 #define f0 32
 549 #define f1 33
 550 #define f2 34
 551 #define f3 35
 552 #define f4 36
 553 #define f5 37
 554 #define f6 38
 555 #define f7 39
 556 #define f8 40
 557 #define f9 41
 558 #define f10 42
 559 #define f11 43
 560 #define f12 44
 561 #define f13 45
 562 #define f14 46
 563 #define f15 47
 564 #define f16 48
 565 #define f17 49
 566 #define f18 50
 567 #define f19 51
 568 #define f20 52
 569 #define f21 53
 570 #define f22 54
 571 #define f23 55
 572 #define f24 56
 573 #define f25 57
 574 #define f26 58
 575 #define f27 59
 576 #define f28 60
 577 #define f29 61
 578 #define f30 62
 579 #define f31 63
 580 #endif
 581 \end{code}
 582
 583 \begin{code}
 584 baseRegOffset :: MagicId -> Int
 585
 586 baseRegOffset StkOReg                = OFFSET_StkO
 587 baseRegOffset (VanillaReg _ ILIT(1)) = OFFSET_R1
 588 baseRegOffset (VanillaReg _ ILIT(2)) = OFFSET_R2
 589 baseRegOffset (VanillaReg _ ILIT(3)) = OFFSET_R3
 590 baseRegOffset (VanillaReg _ ILIT(4)) = OFFSET_R4
 591 baseRegOffset (VanillaReg _ ILIT(5)) = OFFSET_R5
 592 baseRegOffset (VanillaReg _ ILIT(6)) = OFFSET_R6
 593 baseRegOffset (VanillaReg _ ILIT(7)) = OFFSET_R7
 594 baseRegOffset (VanillaReg _ ILIT(8)) = OFFSET_R8
 595 baseRegOffset (FloatReg  ILIT(1))    = OFFSET_Flt1
 596 baseRegOffset (FloatReg  ILIT(2))    = OFFSET_Flt2
 597 baseRegOffset (FloatReg  ILIT(3))    = OFFSET_Flt3
 598 baseRegOffset (FloatReg  ILIT(4))    = OFFSET_Flt4
 599 baseRegOffset (DoubleReg ILIT(1))    = OFFSET_Dbl1
 600 baseRegOffset (DoubleReg ILIT(2))    = OFFSET_Dbl2
 601 baseRegOffset TagReg                 = OFFSET_Tag
 602 baseRegOffset RetReg                 = OFFSET_Ret
 603 baseRegOffset SpA                    = OFFSET_SpA
 604 baseRegOffset SuA                    = OFFSET_SuA
 605 baseRegOffset SpB                    = OFFSET_SpB
 606 baseRegOffset SuB                    = OFFSET_SuB
 607 baseRegOffset Hp                     = OFFSET_Hp
 608 baseRegOffset HpLim                  = OFFSET_HpLim
 609 baseRegOffset LivenessReg            = OFFSET_Liveness
 610 #ifdef DEBUG
 611 baseRegOffset BaseReg                = panic "baseRegOffset:BaseReg"
 612 baseRegOffset StdUpdRetVecReg        = panic "baseRegOffset:StgUpdRetVecReg"
 613 baseRegOffset StkStubReg             = panic "baseRegOffset:StkStubReg"
 614 baseRegOffset CurCostCentre          = panic "baseRegOffset:CurCostCentre"
 615 baseRegOffset VoidReg                = panic "baseRegOffset:VoidReg"
 616 #endif
 617 \end{code}
 618
 619 \begin{code}
 620 callerSaves :: MagicId -> Bool
 621
 622 #ifdef CALLER_SAVES_Base
 623 callerSaves BaseReg                     = True
 624 #endif
 625 #ifdef CALLER_SAVES_StkO
 626 callerSaves StkOReg                     = True
 627 #endif
 628 #ifdef CALLER_SAVES_R1
 629 callerSaves (VanillaReg _ ILIT(1))      = True
 630 #endif
 631 #ifdef CALLER_SAVES_R2
 632 callerSaves (VanillaReg _ ILIT(2))      = True
 633 #endif
 634 #ifdef CALLER_SAVES_R3
 635 callerSaves (VanillaReg _ ILIT(3))      = True
 636 #endif
 637 #ifdef CALLER_SAVES_R4
 638 callerSaves (VanillaReg _ ILIT(4))      = True
 639 #endif
 640 #ifdef CALLER_SAVES_R5
 641 callerSaves (VanillaReg _ ILIT(5))      = True
 642 #endif
 643 #ifdef CALLER_SAVES_R6
 644 callerSaves (VanillaReg _ ILIT(6))      = True
 645 #endif
 646 #ifdef CALLER_SAVES_R7
 647 callerSaves (VanillaReg _ ILIT(7))      = True
 648 #endif
 649 #ifdef CALLER_SAVES_R8
 650 callerSaves (VanillaReg _ ILIT(8))      = True
 651 #endif
 652 #ifdef CALLER_SAVES_FltReg1
 653 callerSaves (FloatReg ILIT(1))          = True
 654 #endif
 655 #ifdef CALLER_SAVES_FltReg2
 656 callerSaves (FloatReg ILIT(2))          = True
 657 #endif
 658 #ifdef CALLER_SAVES_FltReg3
 659 callerSaves (FloatReg ILIT(3))          = True
 660 #endif
 661 #ifdef CALLER_SAVES_FltReg4
 662 callerSaves (FloatReg ILIT(4))          = True
 663 #endif
 664 #ifdef CALLER_SAVES_DblReg1
 665 callerSaves (DoubleReg ILIT(1))         = True
 666 #endif
 667 #ifdef CALLER_SAVES_DblReg2
 668 callerSaves (DoubleReg ILIT(2))         = True
 669 #endif
 670 #ifdef CALLER_SAVES_Tag
 671 callerSaves TagReg                      = True
 672 #endif
 673 #ifdef CALLER_SAVES_Ret
 674 callerSaves RetReg                      = True
 675 #endif
 676 #ifdef CALLER_SAVES_SpA
 677 callerSaves SpA                         = True
 678 #endif
 679 #ifdef CALLER_SAVES_SuA
 680 callerSaves SuA                         = True
 681 #endif
 682 #ifdef CALLER_SAVES_SpB
 683 callerSaves SpB                         = True
 684 #endif
 685 #ifdef CALLER_SAVES_SuB
 686 callerSaves SuB                         = True
 687 #endif
 688 #ifdef CALLER_SAVES_Hp
 689 callerSaves Hp                          = True
 690 #endif
 691 #ifdef CALLER_SAVES_HpLim
 692 callerSaves HpLim                       = True
 693 #endif
 694 #ifdef CALLER_SAVES_Liveness
 695 callerSaves LivenessReg                 = True
 696 #endif
 697 #ifdef CALLER_SAVES_StdUpdRetVec
 698 callerSaves StdUpdRetVecReg             = True
 699 #endif
 700 #ifdef CALLER_SAVES_StkStub
 701 callerSaves StkStubReg                  = True
 702 #endif
 703 callerSaves _                           = False
 704 \end{code}
 705
 706 \begin{code}
 707 magicIdRegMaybe :: MagicId -> Maybe Reg
 708
 709 #ifdef REG_Base
 710 magicIdRegMaybe BaseReg                 = Just (FixedReg ILIT(REG_Base))
 711 #endif
 712 #ifdef REG_StkO
 713 magicIdRegMaybe StkOReg                 = Just (FixedReg ILIT(REG_StkOReg))
 714 #endif
 715 #ifdef REG_R1
 716 magicIdRegMaybe (VanillaReg _ ILIT(1))  = Just (FixedReg ILIT(REG_R1))
 717 #endif
 718 #ifdef REG_R2
 719 magicIdRegMaybe (VanillaReg _ ILIT(2))  = Just (FixedReg ILIT(REG_R2))
 720 #endif
 721 #ifdef REG_R3
 722 magicIdRegMaybe (VanillaReg _ ILIT(3))  = Just (FixedReg ILIT(REG_R3))
 723 #endif
 724 #ifdef REG_R4
 725 magicIdRegMaybe (VanillaReg _ ILIT(4))  = Just (FixedReg ILIT(REG_R4))
 726 #endif
 727 #ifdef REG_R5
 728 magicIdRegMaybe (VanillaReg _ ILIT(5))  = Just (FixedReg ILIT(REG_R5))
 729 #endif
 730 #ifdef REG_R6
 731 magicIdRegMaybe (VanillaReg _ ILIT(6))  = Just (FixedReg ILIT(REG_R6))
 732 #endif
 733 #ifdef REG_R7
 734 magicIdRegMaybe (VanillaReg _ ILIT(7))  = Just (FixedReg ILIT(REG_R7))
 735 #endif
 736 #ifdef REG_R8
 737 magicIdRegMaybe (VanillaReg _ ILIT(8))  = Just (FixedReg ILIT(REG_R8))
 738 #endif
 739 #ifdef REG_Flt1
 740 magicIdRegMaybe (FloatReg ILIT(1))      = Just (FixedReg ILIT(REG_Flt1))
 741 #endif
 742 #ifdef REG_Flt2
 743 magicIdRegMaybe (FloatReg ILIT(2))      = Just (FixedReg ILIT(REG_Flt2))
 744 #endif
 745 #ifdef REG_Flt3
 746 magicIdRegMaybe (FloatReg ILIT(3))      = Just (FixedReg ILIT(REG_Flt3))
 747 #endif
 748 #ifdef REG_Flt4
 749 magicIdRegMaybe (FloatReg ILIT(4))      = Just (FixedReg ILIT(REG_Flt4))
 750 #endif
 751 #ifdef REG_Dbl1
 752 magicIdRegMaybe (DoubleReg ILIT(1))     = Just (FixedReg ILIT(REG_Dbl1))
 753 #endif
 754 #ifdef REG_Dbl2
 755 magicIdRegMaybe (DoubleReg ILIT(2))     = Just (FixedReg ILIT(REG_Dbl2))
 756 #endif
 757 #ifdef REG_Tag
 758 magicIdRegMaybe TagReg                  = Just (FixedReg ILIT(REG_TagReg))
 759 #endif
 760 #ifdef REG_Ret
 761 magicIdRegMaybe RetReg                  = Just (FixedReg ILIT(REG_Ret))
 762 #endif
 763 #ifdef REG_SpA
 764 magicIdRegMaybe SpA                     = Just (FixedReg ILIT(REG_SpA))
 765 #endif
 766 #ifdef REG_SuA
 767 magicIdRegMaybe SuA                     = Just (FixedReg ILIT(REG_SuA))
 768 #endif
 769 #ifdef REG_SpB
 770 magicIdRegMaybe SpB                     = Just (FixedReg ILIT(REG_SpB))
 771 #endif
 772 #ifdef REG_SuB
 773 magicIdRegMaybe SuB                     = Just (FixedReg ILIT(REG_SuB))
 774 #endif
 775 #ifdef REG_Hp
 776 magicIdRegMaybe Hp                      = Just (FixedReg ILIT(REG_Hp))
 777 #endif
 778 #ifdef REG_HpLim
 779 magicIdRegMaybe HpLim                   = Just (FixedReg ILIT(REG_HpLim))
 780 #endif
 781 #ifdef REG_Liveness
 782 magicIdRegMaybe LivenessReg             = Just (FixedReg ILIT(REG_Liveness))
 783 #endif
 784 #ifdef REG_StdUpdRetVec
 785 magicIdRegMaybe StdUpdRetVecReg         = Just (FixedReg ILIT(REG_StdUpdRetVec))
 786 #endif
 787 #ifdef REG_StkStub
 788 magicIdRegMaybe StkStubReg              = Just (FixedReg ILIT(REG_StkStub))
 789 #endif
 790 magicIdRegMaybe _                       = Nothing
 791 \end{code}
 792
 793 %************************************************************************
 794 %*                                                                      *
 795 \subsection{Free, reserved, call-clobbered, and argument registers}
 796 %*                                                                      *
 797 %************************************************************************
 798
 799 @freeRegs@ is the list of registers we can use in register allocation.
 800 @freeReg@ (below) says if a particular register is free.
 801
 802 With a per-instruction clobber list, we might be able to get some of
 803 these back, but it's probably not worth the hassle.
 804
 805 @callClobberedRegs@ ... the obvious.
 806
 807 @argRegs@: assuming a call with N arguments, what registers will be
 808 used to hold arguments?  (NB: it doesn't know whether the arguments
 809 are integer or floating-point...)
 810
 811 \begin{code}
 812 reservedRegs :: [RegNo]
 813 reservedRegs
 814 #if alpha_TARGET_ARCH
 815   = [NCG_Reserved_I1, NCG_Reserved_I2,
 816      NCG_Reserved_F1, NCG_Reserved_F2]
 817 #endif
 818 #if i386_TARGET_ARCH
 819   = [{-certainly cannot afford any!-}]
 820 #endif
 821 #if sparc_TARGET_ARCH
 822   = [NCG_Reserved_I1, NCG_Reserved_I2,
 823      NCG_Reserved_F1, NCG_Reserved_F2,
 824      NCG_Reserved_D1, NCG_Reserved_D2]
 825 #endif
 826
 827 -------------------------------
 828 freeRegs :: [Reg]
 829 freeRegs
 830   = freeMappedRegs IF_ARCH_alpha( [0..63],
 831                    IF_ARCH_i386(  [0..15],
 832                    IF_ARCH_sparc( [0..63],)))
 833
 834 -------------------------------
 835 callClobberedRegs :: [Reg]
 836 callClobberedRegs
 837   = freeMappedRegs
 838 #if alpha_TARGET_ARCH
 839     [0, 1, 2, 3, 4, 5, 6, 7, 8,
 840      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
 841      fReg 0, fReg 1, fReg 10, fReg 11, fReg 12, fReg 13, fReg 14, fReg 15,
 842      fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21, fReg 22, fReg 23,
 843      fReg 24, fReg 25, fReg 26, fReg 27, fReg 28, fReg 29, fReg 30]
 844 #endif {- alpha_TARGET_ARCH -}
 845 #if i386_TARGET_ARCH
 846     [{-none-}]
 847 #endif {- i386_TARGET_ARCH -}
 848 #if sparc_TARGET_ARCH
 849     ( oReg 7 :
 850       [oReg i | i <- [0..5]] ++
 851       [gReg i | i <- [1..7]] ++
 852       [fReg i | i <- [0..31]] )
 853 #endif {- sparc_TARGET_ARCH -}
 854
 855 -------------------------------
 856 argRegs :: Int -> [Reg]
 857
 858 argRegs 0 = []
 859 #if alpha_TARGET_ARCH
 860 argRegs 1 = freeMappedRegs [16, fReg 16]
 861 argRegs 2 = freeMappedRegs [16, 17, fReg 16, fReg 17]
 862 argRegs 3 = freeMappedRegs [16, 17, 18, fReg 16, fReg 17, fReg 18]
 863 argRegs 4 = freeMappedRegs [16, 17, 18, 19, fReg 16, fReg 17, fReg 18, fReg 19]
 864 argRegs 5 = freeMappedRegs [16, 17, 18, 19, 20, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20]
 865 argRegs 6 = freeMappedRegs [16, 17, 18, 19, 20, 21, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21]
 866 #endif {- alpha_TARGET_ARCH -}
 867 #if i386_TARGET_ARCH
 868 argRegs _ = panic "MachRegs.argRegs: doesn't work on I386"
 869 #endif {- i386_TARGET_ARCH -}
 870 #if sparc_TARGET_ARCH
 871 argRegs 1 = freeMappedRegs (map oReg [0])
 872 argRegs 2 = freeMappedRegs (map oReg [0,1])
 873 argRegs 3 = freeMappedRegs (map oReg [0,1,2])
 874 argRegs 4 = freeMappedRegs (map oReg [0,1,2,3])
 875 argRegs 5 = freeMappedRegs (map oReg [0,1,2,3,4])
 876 argRegs 6 = freeMappedRegs (map oReg [0,1,2,3,4,5])
 877 #endif {- sparc_TARGET_ARCH -}
 878 argRegs _ = panic "MachRegs.argRegs: don't know about >6 arguments!"
 879
 880 -------------------------------
 881
 882 #if alpha_TARGET_ARCH
 883 allArgRegs :: [(Reg, Reg)]
 884
 885 allArgRegs = [(realReg i, realReg (fReg i)) | i <- [16..21]]
 886 #endif {- alpha_TARGET_ARCH -}
 887
 888 #if sparc_TARGET_ARCH
 889 allArgRegs :: [Reg]
 890
 891 allArgRegs = map realReg [oReg i | i <- [0..5]]
 892 #endif {- sparc_TARGET_ARCH -}
 893
 894 -------------------------------
 895 freeMappedRegs :: [Int] -> [Reg]
 896
 897 freeMappedRegs nums
 898   = foldr free [] nums
 899   where
 900     free IBOX(i) acc
 901       = if _IS_TRUE_(freeReg i) then (MappedReg i) : acc else acc
 902 \end{code}
 903
 904 \begin{code}
 905 freeReg :: FAST_INT -> FAST_BOOL
 906
 907 #if alpha_TARGET_ARCH
 908 freeReg ILIT(26) = _FALSE_  -- return address (ra)
 909 freeReg ILIT(28) = _FALSE_  -- reserved for the assembler (at)
 910 freeReg ILIT(29) = _FALSE_  -- global pointer (gp)
 911 freeReg ILIT(30) = _FALSE_  -- stack pointer (sp)
 912 freeReg ILIT(31) = _FALSE_  -- always zero (zero)
 913 freeReg ILIT(63) = _FALSE_  -- always zero (f31)
 914 #endif
 915
 916 #if i386_TARGET_ARCH
 917 freeReg ILIT(esp) = _FALSE_  -- %esp is the C stack pointer
 918 #endif
 919
 920 #if sparc_TARGET_ARCH
 921 freeReg ILIT(g0) = _FALSE_  --  %g0 is always 0.
 922 freeReg ILIT(g5) = _FALSE_  --  %g5 is reserved (ABI).
 923 freeReg ILIT(g6) = _FALSE_  --  %g6 is reserved (ABI).
 924 freeReg ILIT(g7) = _FALSE_  --  %g7 is reserved (ABI).
 925 freeReg ILIT(i6) = _FALSE_  --  %i6 is our frame pointer.
 926 freeReg ILIT(o6) = _FALSE_  --  %o6 is our stack pointer.
 927 #endif
 928
 929 #ifdef REG_Base
 930 freeReg ILIT(REG_Base) = _FALSE_
 931 #endif
 932 #ifdef REG_StkO
 933 freeReg ILIT(REG_StkO) = _FALSE_
 934 #endif
 935 #ifdef REG_R1
 936 freeReg ILIT(REG_R1)   = _FALSE_
 937 #endif
 938 #ifdef REG_R2
 939 freeReg ILIT(REG_R2)   = _FALSE_
 940 #endif
 941 #ifdef REG_R3
 942 freeReg ILIT(REG_R3)   = _FALSE_
 943 #endif
 944 #ifdef REG_R4
 945 freeReg ILIT(REG_R4)   = _FALSE_
 946 #endif
 947 #ifdef REG_R5
 948 freeReg ILIT(REG_R5)   = _FALSE_
 949 #endif
 950 #ifdef REG_R6
 951 freeReg ILIT(REG_R6)   = _FALSE_
 952 #endif
 953 #ifdef REG_R7
 954 freeReg ILIT(REG_R7)   = _FALSE_
 955 #endif
 956 #ifdef REG_R8
 957 freeReg ILIT(REG_R8)   = _FALSE_
 958 #endif
 959 #ifdef REG_Flt1
 960 freeReg ILIT(REG_Flt1) = _FALSE_
 961 #endif
 962 #ifdef REG_Flt2
 963 freeReg ILIT(REG_Flt2) = _FALSE_
 964 #endif
 965 #ifdef REG_Flt3
 966 freeReg ILIT(REG_Flt3) = _FALSE_
 967 #endif
 968 #ifdef REG_Flt4
 969 freeReg ILIT(REG_Flt4) = _FALSE_
 970 #endif
 971 #ifdef REG_Dbl1
 972 freeReg ILIT(REG_Dbl1) = _FALSE_
 973 #endif
 974 #ifdef REG_Dbl2
 975 freeReg ILIT(REG_Dbl2) = _FALSE_
 976 #endif
 977 #ifdef REG_Tag
 978 freeReg ILIT(REG_Tag)  = _FALSE_
 979 #endif
 980 #ifdef REG_Ret
 981 freeReg ILIT(REG_Ret)  = _FALSE_
 982 #endif
 983 #ifdef REG_SpA
 984 freeReg ILIT(REG_SpA)  = _FALSE_
 985 #endif
 986 #ifdef REG_SuA
 987 freeReg ILIT(REG_SuA)  = _FALSE_
 988 #endif
 989 #ifdef REG_SpB
 990 freeReg ILIT(REG_SpB)  = _FALSE_
 991 #endif
 992 #ifdef REG_SuB
 993 freeReg ILIT(REG_SuB)  = _FALSE_
 994 #endif
 995 #ifdef REG_Hp
 996 freeReg ILIT(REG_Hp)   = _FALSE_
 997 #endif
 998 #ifdef REG_HpLim
 999 freeReg ILIT(REG_HpLim) = _FALSE_
1000 #endif
1001 #ifdef REG_Liveness
1002 freeReg ILIT(REG_Liveness) = _FALSE_
1003 #endif
1004 #ifdef REG_StdUpdRetVec
1005 freeReg ILIT(REG_StdUpdRetVec) = _FALSE_
1006 #endif
1007 #ifdef REG_StkStub
1008 freeReg ILIT(REG_StkStub) = _FALSE_
1009 #endif
1010 freeReg _ = _TRUE_
1011 freeReg n
1012   -- we hang onto two double regs for dedicated
1013   -- use; this is not necessary on Alphas and
1014   -- may not be on other non-SPARCs.
1015 #ifdef REG_Dbl1
1016   | n _EQ_ (ILIT(REG_Dbl1) _ADD_ ILIT(1)) = _FALSE_
1017 #endif
1018 #ifdef REG_Dbl2
1019   | n _EQ_ (ILIT(REG_Dbl2) _ADD_ ILIT(1)) = _FALSE_
1020 #endif
1021   | otherwise = _TRUE_
1022 \end{code}