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 IMP_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           ( mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3,
  73                           Unique{-instance Ord3-}
  74                         )
  75 import UniqSupply       ( getUnique, returnUs, thenUs, UniqSM(..) )
  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 Ord3 Reg where
 335     cmp = cmpReg
 336
 337 instance Eq Reg where
 338     a == b = case (a `cmp` b) of { EQ_ -> True;  _ -> False }
 339     a /= b = case (a `cmp` b) of { EQ_ -> False; _ -> True  }
 340
 341 instance Ord Reg where
 342     a <= b = case (a `cmp` b) of { LT_ -> True; EQ_ -> True;  GT__ -> False }
 343     a <  b = case (a `cmp` b) of { LT_ -> True; EQ_ -> False; GT__ -> False }
 344     a >= b = case (a `cmp` b) of { LT_ -> False; EQ_ -> True;  GT__ -> True  }
 345     a >  b = case (a `cmp` b) of { LT_ -> False; EQ_ -> False; GT__ -> True  }
 346     _tagCmp a b = case (a `cmp` b) of { LT_ -> _LT; EQ_ -> _EQ; GT__ -> _GT }
 347
 348 instance Uniquable Reg where
 349     uniqueOf (UnmappedReg u _) = u
 350     uniqueOf (FixedReg i)      = mkPseudoUnique1 IBOX(i)
 351     uniqueOf (MappedReg i)     = mkPseudoUnique2 IBOX(i)
 352     uniqueOf (MemoryReg i _)   = mkPseudoUnique3 i
 353 \end{code}
 354
 355 \begin{code}
 356 type RegNo = Int
 357
 358 realReg :: RegNo -> Reg
 359 realReg n@IBOX(i)
 360   = if _IS_TRUE_(freeReg i) then MappedReg i else FixedReg i
 361
 362 extractMappedRegNos :: [Reg] -> [RegNo]
 363
 364 extractMappedRegNos regs
 365   = foldr ex [] regs
 366   where
 367     ex (MappedReg i) acc = IBOX(i) : acc  -- we'll take it
 368     ex _             acc = acc            -- leave it out
 369 \end{code}
 370
 371 ** Machine-specific Reg stuff: **
 372
 373 The Alpha has 64 registers of interest; 32 integer registers and 32 floating
 374 point registers.  The mapping of STG registers to alpha machine registers
 375 is defined in StgRegs.h.  We are, of course, prepared for any eventuality.
 376 \begin{code}
 377 #if alpha_TARGET_ARCH
 378 fReg :: Int -> Int
 379 fReg x = (32 + x)
 380
 381 v0, f0, ra, pv, gp, sp, zero :: Reg
 382 v0   = realReg 0
 383 f0   = realReg (fReg 0)
 384 ra   = FixedReg ILIT(26)
 385 pv   = t12
 386 gp   = FixedReg ILIT(29)
 387 sp   = FixedReg ILIT(30)
 388 zero = FixedReg ILIT(31)
 389
 390 t9, t10, t11, t12 :: Reg
 391 t9  = realReg 23
 392 t10 = realReg 24
 393 t11 = realReg 25
 394 t12 = realReg 27
 395 #endif
 396 \end{code}
 397
 398 Intel x86 architecture:
 399 - All registers except 7 (esp) are available for use.
 400 - Only ebx, esi, edi and esp are available across a C call (they are callee-saves).
 401 - Registers 0-7 have 16-bit counterparts (ax, bx etc.)
 402 - Registers 0-3 have 8 bit counterparts (ah, bh etc.)
 403 - Registers 8-15 hold extended floating point values.
 404 \begin{code}
 405 #if i386_TARGET_ARCH
 406
 407 gReg,fReg :: Int -> Int
 408 gReg x = x
 409 fReg x = (8 + x)
 410
 411 st0, st1, st2, st3, st4, st5, st6, st7, eax, ebx, ecx, edx, esp :: Reg
 412 eax = case (gReg 0) of { IBOX(g0) -> FixedReg g0 }
 413 ebx = case (gReg 1) of { IBOX(g1) -> FixedReg g1 }
 414 ecx = case (gReg 2) of { IBOX(g2) -> FixedReg g2 }
 415 edx = case (gReg 3) of { IBOX(g3) -> FixedReg g3 }
 416 esi = case (gReg 4) of { IBOX(g4) -> FixedReg g4 }
 417 edi = case (gReg 5) of { IBOX(g5) -> FixedReg g5 }
 418 ebp = case (gReg 6) of { IBOX(g6) -> FixedReg g6 }
 419 esp = case (gReg 7) of { IBOX(g7) -> FixedReg g7 }
 420 st0 = realReg  (fReg 0)
 421 st1 = realReg  (fReg 1)
 422 st2 = realReg  (fReg 2)
 423 st3 = realReg  (fReg 3)
 424 st4 = realReg  (fReg 4)
 425 st5 = realReg  (fReg 5)
 426 st6 = realReg  (fReg 6)
 427 st7 = realReg  (fReg 7)
 428
 429 #endif
 430 \end{code}
 431
 432 The SPARC has 64 registers of interest; 32 integer registers and 32
 433 floating point registers.  The mapping of STG registers to SPARC
 434 machine registers is defined in StgRegs.h.  We are, of course,
 435 prepared for any eventuality.
 436
 437 \begin{code}
 438 #if sparc_TARGET_ARCH
 439
 440 gReg,lReg,iReg,oReg,fReg :: Int -> Int
 441 gReg x = x
 442 oReg x = (8 + x)
 443 lReg x = (16 + x)
 444 iReg x = (24 + x)
 445 fReg x = (32 + x)
 446
 447 fPair :: Reg -> Reg
 448 fPair (FixedReg i) = FixedReg (i _ADD_ ILIT(1))
 449 fPair (MappedReg i) = MappedReg (i _ADD_ ILIT(1))
 450
 451 g0, fp, sp, o0, f0 :: Reg
 452 g0 = case (gReg 0) of { IBOX(g0) -> FixedReg g0 }
 453 fp = case (iReg 6) of { IBOX(i6) -> FixedReg i6 }
 454 sp = case (oReg 6) of { IBOX(o6) -> FixedReg o6 }
 455 o0 = realReg  (oReg 0)
 456 f0 = realReg  (fReg 0)
 457
 458 #endif
 459 \end{code}
 460
 461 Redefine the literals used for machine-registers with non-numeric
 462 names in the header files.  Gag me with a spoon, eh?
 463 \begin{code}
 464 #if alpha_TARGET_ARCH
 465 #define f0 32
 466 #define f1 33
 467 #define f2 34
 468 #define f3 35
 469 #define f4 36
 470 #define f5 37
 471 #define f6 38
 472 #define f7 39
 473 #define f8 40
 474 #define f9 41
 475 #define f10 42
 476 #define f11 43
 477 #define f12 44
 478 #define f13 45
 479 #define f14 46
 480 #define f15 47
 481 #define f16 48
 482 #define f17 49
 483 #define f18 50
 484 #define f19 51
 485 #define f20 52
 486 #define f21 53
 487 #define f22 54
 488 #define f23 55
 489 #define f24 56
 490 #define f25 57
 491 #define f26 58
 492 #define f27 59
 493 #define f28 60
 494 #define f29 61
 495 #define f30 62
 496 #define f31 63
 497 #endif
 498 #if i386_TARGET_ARCH
 499 #define eax 0
 500 #define ebx 1
 501 #define ecx 2
 502 #define edx 3
 503 #define esi 4
 504 #define edi 5
 505 #define ebp 6
 506 #define esp 7
 507 #define st0 8
 508 #define st1 9
 509 #define st2 10
 510 #define st3 11
 511 #define st4 12
 512 #define st5 13
 513 #define st6 14
 514 #define st7 15
 515 #endif
 516 #if sparc_TARGET_ARCH
 517 #define g0 0
 518 #define g1 1
 519 #define g2 2
 520 #define g3 3
 521 #define g4 4
 522 #define g5 5
 523 #define g6 6
 524 #define g7 7
 525 #define o0 8
 526 #define o1 9
 527 #define o2 10
 528 #define o3 11
 529 #define o4 12
 530 #define o5 13
 531 #define o6 14
 532 #define o7 15
 533 #define l0 16
 534 #define l1 17
 535 #define l2 18
 536 #define l3 19
 537 #define l4 20
 538 #define l5 21
 539 #define l6 22
 540 #define l7 23
 541 #define i0 24
 542 #define i1 25
 543 #define i2 26
 544 #define i3 27
 545 #define i4 28
 546 #define i5 29
 547 #define i6 30
 548 #define i7 31
 549 #define f0 32
 550 #define f1 33
 551 #define f2 34
 552 #define f3 35
 553 #define f4 36
 554 #define f5 37
 555 #define f6 38
 556 #define f7 39
 557 #define f8 40
 558 #define f9 41
 559 #define f10 42
 560 #define f11 43
 561 #define f12 44
 562 #define f13 45
 563 #define f14 46
 564 #define f15 47
 565 #define f16 48
 566 #define f17 49
 567 #define f18 50
 568 #define f19 51
 569 #define f20 52
 570 #define f21 53
 571 #define f22 54
 572 #define f23 55
 573 #define f24 56
 574 #define f25 57
 575 #define f26 58
 576 #define f27 59
 577 #define f28 60
 578 #define f29 61
 579 #define f30 62
 580 #define f31 63
 581 #endif
 582 \end{code}
 583
 584 \begin{code}
 585 baseRegOffset :: MagicId -> Int
 586
 587 baseRegOffset StkOReg                = OFFSET_StkO
 588 baseRegOffset (VanillaReg _ ILIT(1)) = OFFSET_R1
 589 baseRegOffset (VanillaReg _ ILIT(2)) = OFFSET_R2
 590 baseRegOffset (VanillaReg _ ILIT(3)) = OFFSET_R3
 591 baseRegOffset (VanillaReg _ ILIT(4)) = OFFSET_R4
 592 baseRegOffset (VanillaReg _ ILIT(5)) = OFFSET_R5
 593 baseRegOffset (VanillaReg _ ILIT(6)) = OFFSET_R6
 594 baseRegOffset (VanillaReg _ ILIT(7)) = OFFSET_R7
 595 baseRegOffset (VanillaReg _ ILIT(8)) = OFFSET_R8
 596 baseRegOffset (FloatReg  ILIT(1))    = OFFSET_Flt1
 597 baseRegOffset (FloatReg  ILIT(2))    = OFFSET_Flt2
 598 baseRegOffset (FloatReg  ILIT(3))    = OFFSET_Flt3
 599 baseRegOffset (FloatReg  ILIT(4))    = OFFSET_Flt4
 600 baseRegOffset (DoubleReg ILIT(1))    = OFFSET_Dbl1
 601 baseRegOffset (DoubleReg ILIT(2))    = OFFSET_Dbl2
 602 baseRegOffset TagReg                 = OFFSET_Tag
 603 baseRegOffset RetReg                 = OFFSET_Ret
 604 baseRegOffset SpA                    = OFFSET_SpA
 605 baseRegOffset SuA                    = OFFSET_SuA
 606 baseRegOffset SpB                    = OFFSET_SpB
 607 baseRegOffset SuB                    = OFFSET_SuB
 608 baseRegOffset Hp                     = OFFSET_Hp
 609 baseRegOffset HpLim                  = OFFSET_HpLim
 610 baseRegOffset LivenessReg            = OFFSET_Liveness
 611 #ifdef DEBUG
 612 baseRegOffset BaseReg                = panic "baseRegOffset:BaseReg"
 613 baseRegOffset StdUpdRetVecReg        = panic "baseRegOffset:StgUpdRetVecReg"
 614 baseRegOffset StkStubReg             = panic "baseRegOffset:StkStubReg"
 615 baseRegOffset CurCostCentre          = panic "baseRegOffset:CurCostCentre"
 616 baseRegOffset VoidReg                = panic "baseRegOffset:VoidReg"
 617 #endif
 618 \end{code}
 619
 620 \begin{code}
 621 callerSaves :: MagicId -> Bool
 622
 623 #ifdef CALLER_SAVES_Base
 624 callerSaves BaseReg                     = True
 625 #endif
 626 #ifdef CALLER_SAVES_StkO
 627 callerSaves StkOReg                     = True
 628 #endif
 629 #ifdef CALLER_SAVES_R1
 630 callerSaves (VanillaReg _ ILIT(1))      = True
 631 #endif
 632 #ifdef CALLER_SAVES_R2
 633 callerSaves (VanillaReg _ ILIT(2))      = True
 634 #endif
 635 #ifdef CALLER_SAVES_R3
 636 callerSaves (VanillaReg _ ILIT(3))      = True
 637 #endif
 638 #ifdef CALLER_SAVES_R4
 639 callerSaves (VanillaReg _ ILIT(4))      = True
 640 #endif
 641 #ifdef CALLER_SAVES_R5
 642 callerSaves (VanillaReg _ ILIT(5))      = True
 643 #endif
 644 #ifdef CALLER_SAVES_R6
 645 callerSaves (VanillaReg _ ILIT(6))      = True
 646 #endif
 647 #ifdef CALLER_SAVES_R7
 648 callerSaves (VanillaReg _ ILIT(7))      = True
 649 #endif
 650 #ifdef CALLER_SAVES_R8
 651 callerSaves (VanillaReg _ ILIT(8))      = True
 652 #endif
 653 #ifdef CALLER_SAVES_FltReg1
 654 callerSaves (FloatReg ILIT(1))          = True
 655 #endif
 656 #ifdef CALLER_SAVES_FltReg2
 657 callerSaves (FloatReg ILIT(2))          = True
 658 #endif
 659 #ifdef CALLER_SAVES_FltReg3
 660 callerSaves (FloatReg ILIT(3))          = True
 661 #endif
 662 #ifdef CALLER_SAVES_FltReg4
 663 callerSaves (FloatReg ILIT(4))          = True
 664 #endif
 665 #ifdef CALLER_SAVES_DblReg1
 666 callerSaves (DoubleReg ILIT(1))         = True
 667 #endif
 668 #ifdef CALLER_SAVES_DblReg2
 669 callerSaves (DoubleReg ILIT(2))         = True
 670 #endif
 671 #ifdef CALLER_SAVES_Tag
 672 callerSaves TagReg                      = True
 673 #endif
 674 #ifdef CALLER_SAVES_Ret
 675 callerSaves RetReg                      = True
 676 #endif
 677 #ifdef CALLER_SAVES_SpA
 678 callerSaves SpA                         = True
 679 #endif
 680 #ifdef CALLER_SAVES_SuA
 681 callerSaves SuA                         = True
 682 #endif
 683 #ifdef CALLER_SAVES_SpB
 684 callerSaves SpB                         = True
 685 #endif
 686 #ifdef CALLER_SAVES_SuB
 687 callerSaves SuB                         = True
 688 #endif
 689 #ifdef CALLER_SAVES_Hp
 690 callerSaves Hp                          = True
 691 #endif
 692 #ifdef CALLER_SAVES_HpLim
 693 callerSaves HpLim                       = True
 694 #endif
 695 #ifdef CALLER_SAVES_Liveness
 696 callerSaves LivenessReg                 = True
 697 #endif
 698 #ifdef CALLER_SAVES_StdUpdRetVec
 699 callerSaves StdUpdRetVecReg             = True
 700 #endif
 701 #ifdef CALLER_SAVES_StkStub
 702 callerSaves StkStubReg                  = True
 703 #endif
 704 callerSaves _                           = False
 705 \end{code}
 706
 707 \begin{code}
 708 magicIdRegMaybe :: MagicId -> Maybe Reg
 709
 710 #ifdef REG_Base
 711 magicIdRegMaybe BaseReg                 = Just (FixedReg ILIT(REG_Base))
 712 #endif
 713 #ifdef REG_StkO
 714 magicIdRegMaybe StkOReg                 = Just (FixedReg ILIT(REG_StkOReg))
 715 #endif
 716 #ifdef REG_R1
 717 magicIdRegMaybe (VanillaReg _ ILIT(1))  = Just (FixedReg ILIT(REG_R1))
 718 #endif
 719 #ifdef REG_R2
 720 magicIdRegMaybe (VanillaReg _ ILIT(2))  = Just (FixedReg ILIT(REG_R2))
 721 #endif
 722 #ifdef REG_R3
 723 magicIdRegMaybe (VanillaReg _ ILIT(3))  = Just (FixedReg ILIT(REG_R3))
 724 #endif
 725 #ifdef REG_R4
 726 magicIdRegMaybe (VanillaReg _ ILIT(4))  = Just (FixedReg ILIT(REG_R4))
 727 #endif
 728 #ifdef REG_R5
 729 magicIdRegMaybe (VanillaReg _ ILIT(5))  = Just (FixedReg ILIT(REG_R5))
 730 #endif
 731 #ifdef REG_R6
 732 magicIdRegMaybe (VanillaReg _ ILIT(6))  = Just (FixedReg ILIT(REG_R6))
 733 #endif
 734 #ifdef REG_R7
 735 magicIdRegMaybe (VanillaReg _ ILIT(7))  = Just (FixedReg ILIT(REG_R7))
 736 #endif
 737 #ifdef REG_R8
 738 magicIdRegMaybe (VanillaReg _ ILIT(8))  = Just (FixedReg ILIT(REG_R8))
 739 #endif
 740 #ifdef REG_Flt1
 741 magicIdRegMaybe (FloatReg ILIT(1))      = Just (FixedReg ILIT(REG_Flt1))
 742 #endif
 743 #ifdef REG_Flt2
 744 magicIdRegMaybe (FloatReg ILIT(2))      = Just (FixedReg ILIT(REG_Flt2))
 745 #endif
 746 #ifdef REG_Flt3
 747 magicIdRegMaybe (FloatReg ILIT(3))      = Just (FixedReg ILIT(REG_Flt3))
 748 #endif
 749 #ifdef REG_Flt4
 750 magicIdRegMaybe (FloatReg ILIT(4))      = Just (FixedReg ILIT(REG_Flt4))
 751 #endif
 752 #ifdef REG_Dbl1
 753 magicIdRegMaybe (DoubleReg ILIT(1))     = Just (FixedReg ILIT(REG_Dbl1))
 754 #endif
 755 #ifdef REG_Dbl2
 756 magicIdRegMaybe (DoubleReg ILIT(2))     = Just (FixedReg ILIT(REG_Dbl2))
 757 #endif
 758 #ifdef REG_Tag
 759 magicIdRegMaybe TagReg                  = Just (FixedReg ILIT(REG_TagReg))
 760 #endif
 761 #ifdef REG_Ret
 762 magicIdRegMaybe RetReg                  = Just (FixedReg ILIT(REG_Ret))
 763 #endif
 764 #ifdef REG_SpA
 765 magicIdRegMaybe SpA                     = Just (FixedReg ILIT(REG_SpA))
 766 #endif
 767 #ifdef REG_SuA
 768 magicIdRegMaybe SuA                     = Just (FixedReg ILIT(REG_SuA))
 769 #endif
 770 #ifdef REG_SpB
 771 magicIdRegMaybe SpB                     = Just (FixedReg ILIT(REG_SpB))
 772 #endif
 773 #ifdef REG_SuB
 774 magicIdRegMaybe SuB                     = Just (FixedReg ILIT(REG_SuB))
 775 #endif
 776 #ifdef REG_Hp
 777 magicIdRegMaybe Hp                      = Just (FixedReg ILIT(REG_Hp))
 778 #endif
 779 #ifdef REG_HpLim
 780 magicIdRegMaybe HpLim                   = Just (FixedReg ILIT(REG_HpLim))
 781 #endif
 782 #ifdef REG_Liveness
 783 magicIdRegMaybe LivenessReg             = Just (FixedReg ILIT(REG_Liveness))
 784 #endif
 785 #ifdef REG_StdUpdRetVec
 786 magicIdRegMaybe StdUpdRetVecReg         = Just (FixedReg ILIT(REG_StdUpdRetVec))
 787 #endif
 788 #ifdef REG_StkStub
 789 magicIdRegMaybe StkStubReg              = Just (FixedReg ILIT(REG_StkStub))
 790 #endif
 791 magicIdRegMaybe _                       = Nothing
 792 \end{code}
 793
 794 %************************************************************************
 795 %*                                                                      *
 796 \subsection{Free, reserved, call-clobbered, and argument registers}
 797 %*                                                                      *
 798 %************************************************************************
 799
 800 @freeRegs@ is the list of registers we can use in register allocation.
 801 @freeReg@ (below) says if a particular register is free.
 802
 803 With a per-instruction clobber list, we might be able to get some of
 804 these back, but it's probably not worth the hassle.
 805
 806 @callClobberedRegs@ ... the obvious.
 807
 808 @argRegs@: assuming a call with N arguments, what registers will be
 809 used to hold arguments?  (NB: it doesn't know whether the arguments
 810 are integer or floating-point...)
 811
 812 \begin{code}
 813 reservedRegs :: [RegNo]
 814 reservedRegs
 815 #if alpha_TARGET_ARCH
 816   = [NCG_Reserved_I1, NCG_Reserved_I2,
 817      NCG_Reserved_F1, NCG_Reserved_F2]
 818 #endif
 819 #if i386_TARGET_ARCH
 820   = [{-certainly cannot afford any!-}]
 821 #endif
 822 #if sparc_TARGET_ARCH
 823   = [NCG_Reserved_I1, NCG_Reserved_I2,
 824      NCG_Reserved_F1, NCG_Reserved_F2,
 825      NCG_Reserved_D1, NCG_Reserved_D2]
 826 #endif
 827
 828 -------------------------------
 829 freeRegs :: [Reg]
 830 freeRegs
 831   = freeMappedRegs IF_ARCH_alpha( [0..63],
 832                    IF_ARCH_i386(  [0..15],
 833                    IF_ARCH_sparc( [0..63],)))
 834
 835 -------------------------------
 836 callClobberedRegs :: [Reg]
 837 callClobberedRegs
 838   = freeMappedRegs
 839 #if alpha_TARGET_ARCH
 840     [0, 1, 2, 3, 4, 5, 6, 7, 8,
 841      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
 842      fReg 0, fReg 1, fReg 10, fReg 11, fReg 12, fReg 13, fReg 14, fReg 15,
 843      fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21, fReg 22, fReg 23,
 844      fReg 24, fReg 25, fReg 26, fReg 27, fReg 28, fReg 29, fReg 30]
 845 #endif {- alpha_TARGET_ARCH -}
 846 #if i386_TARGET_ARCH
 847     [{-none-}]
 848 #endif {- i386_TARGET_ARCH -}
 849 #if sparc_TARGET_ARCH
 850     ( oReg 7 :
 851       [oReg i | i <- [0..5]] ++
 852       [gReg i | i <- [1..7]] ++
 853       [fReg i | i <- [0..31]] )
 854 #endif {- sparc_TARGET_ARCH -}
 855
 856 -------------------------------
 857 argRegs :: Int -> [Reg]
 858
 859 argRegs 0 = []
 860 #if alpha_TARGET_ARCH
 861 argRegs 1 = freeMappedRegs [16, fReg 16]
 862 argRegs 2 = freeMappedRegs [16, 17, fReg 16, fReg 17]
 863 argRegs 3 = freeMappedRegs [16, 17, 18, fReg 16, fReg 17, fReg 18]
 864 argRegs 4 = freeMappedRegs [16, 17, 18, 19, fReg 16, fReg 17, fReg 18, fReg 19]
 865 argRegs 5 = freeMappedRegs [16, 17, 18, 19, 20, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20]
 866 argRegs 6 = freeMappedRegs [16, 17, 18, 19, 20, 21, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21]
 867 #endif {- alpha_TARGET_ARCH -}
 868 #if i386_TARGET_ARCH
 869 argRegs _ = panic "MachRegs.argRegs: doesn't work on I386"
 870 #endif {- i386_TARGET_ARCH -}
 871 #if sparc_TARGET_ARCH
 872 argRegs 1 = freeMappedRegs (map oReg [0])
 873 argRegs 2 = freeMappedRegs (map oReg [0,1])
 874 argRegs 3 = freeMappedRegs (map oReg [0,1,2])
 875 argRegs 4 = freeMappedRegs (map oReg [0,1,2,3])
 876 argRegs 5 = freeMappedRegs (map oReg [0,1,2,3,4])
 877 argRegs 6 = freeMappedRegs (map oReg [0,1,2,3,4,5])
 878 #endif {- sparc_TARGET_ARCH -}
 879 argRegs _ = panic "MachRegs.argRegs: don't know about >6 arguments!"
 880
 881 -------------------------------
 882
 883 #if alpha_TARGET_ARCH
 884 allArgRegs :: [(Reg, Reg)]
 885
 886 allArgRegs = [(realReg i, realReg (fReg i)) | i <- [16..21]]
 887 #endif {- alpha_TARGET_ARCH -}
 888
 889 #if sparc_TARGET_ARCH
 890 allArgRegs :: [Reg]
 891
 892 allArgRegs = map realReg [oReg i | i <- [0..5]]
 893 #endif {- sparc_TARGET_ARCH -}
 894
 895 -------------------------------
 896 freeMappedRegs :: [Int] -> [Reg]
 897
 898 freeMappedRegs nums
 899   = foldr free [] nums
 900   where
 901     free IBOX(i) acc
 902       = if _IS_TRUE_(freeReg i) then (MappedReg i) : acc else acc
 903 \end{code}
 904
 905 \begin{code}
 906 freeReg :: FAST_INT -> FAST_BOOL
 907
 908 #if alpha_TARGET_ARCH
 909 freeReg ILIT(26) = _FALSE_  -- return address (ra)
 910 freeReg ILIT(28) = _FALSE_  -- reserved for the assembler (at)
 911 freeReg ILIT(29) = _FALSE_  -- global pointer (gp)
 912 freeReg ILIT(30) = _FALSE_  -- stack pointer (sp)
 913 freeReg ILIT(31) = _FALSE_  -- always zero (zero)
 914 freeReg ILIT(63) = _FALSE_  -- always zero (f31)
 915 #endif
 916
 917 #if i386_TARGET_ARCH
 918 freeReg ILIT(esp) = _FALSE_  -- %esp is the C stack pointer
 919 #endif
 920
 921 #if sparc_TARGET_ARCH
 922 freeReg ILIT(g0) = _FALSE_  --  %g0 is always 0.
 923 freeReg ILIT(g5) = _FALSE_  --  %g5 is reserved (ABI).
 924 freeReg ILIT(g6) = _FALSE_  --  %g6 is reserved (ABI).
 925 freeReg ILIT(g7) = _FALSE_  --  %g7 is reserved (ABI).
 926 freeReg ILIT(i6) = _FALSE_  --  %i6 is our frame pointer.
 927 freeReg ILIT(o6) = _FALSE_  --  %o6 is our stack pointer.
 928 #endif
 929
 930 #ifdef REG_Base
 931 freeReg ILIT(REG_Base) = _FALSE_
 932 #endif
 933 #ifdef REG_StkO
 934 freeReg ILIT(REG_StkO) = _FALSE_
 935 #endif
 936 #ifdef REG_R1
 937 freeReg ILIT(REG_R1)   = _FALSE_
 938 #endif
 939 #ifdef REG_R2
 940 freeReg ILIT(REG_R2)   = _FALSE_
 941 #endif
 942 #ifdef REG_R3
 943 freeReg ILIT(REG_R3)   = _FALSE_
 944 #endif
 945 #ifdef REG_R4
 946 freeReg ILIT(REG_R4)   = _FALSE_
 947 #endif
 948 #ifdef REG_R5
 949 freeReg ILIT(REG_R5)   = _FALSE_
 950 #endif
 951 #ifdef REG_R6
 952 freeReg ILIT(REG_R6)   = _FALSE_
 953 #endif
 954 #ifdef REG_R7
 955 freeReg ILIT(REG_R7)   = _FALSE_
 956 #endif
 957 #ifdef REG_R8
 958 freeReg ILIT(REG_R8)   = _FALSE_
 959 #endif
 960 #ifdef REG_Flt1
 961 freeReg ILIT(REG_Flt1) = _FALSE_
 962 #endif
 963 #ifdef REG_Flt2
 964 freeReg ILIT(REG_Flt2) = _FALSE_
 965 #endif
 966 #ifdef REG_Flt3
 967 freeReg ILIT(REG_Flt3) = _FALSE_
 968 #endif
 969 #ifdef REG_Flt4
 970 freeReg ILIT(REG_Flt4) = _FALSE_
 971 #endif
 972 #ifdef REG_Dbl1
 973 freeReg ILIT(REG_Dbl1) = _FALSE_
 974 #endif
 975 #ifdef REG_Dbl2
 976 freeReg ILIT(REG_Dbl2) = _FALSE_
 977 #endif
 978 #ifdef REG_Tag
 979 freeReg ILIT(REG_Tag)  = _FALSE_
 980 #endif
 981 #ifdef REG_Ret
 982 freeReg ILIT(REG_Ret)  = _FALSE_
 983 #endif
 984 #ifdef REG_SpA
 985 freeReg ILIT(REG_SpA)  = _FALSE_
 986 #endif
 987 #ifdef REG_SuA
 988 freeReg ILIT(REG_SuA)  = _FALSE_
 989 #endif
 990 #ifdef REG_SpB
 991 freeReg ILIT(REG_SpB)  = _FALSE_
 992 #endif
 993 #ifdef REG_SuB
 994 freeReg ILIT(REG_SuB)  = _FALSE_
 995 #endif
 996 #ifdef REG_Hp
 997 freeReg ILIT(REG_Hp)   = _FALSE_
 998 #endif
 999 #ifdef REG_HpLim
1000 freeReg ILIT(REG_HpLim) = _FALSE_
1001 #endif
1002 #ifdef REG_Liveness
1003 freeReg ILIT(REG_Liveness) = _FALSE_
1004 #endif
1005 #ifdef REG_StdUpdRetVec
1006 freeReg ILIT(REG_StdUpdRetVec) = _FALSE_
1007 #endif
1008 #ifdef REG_StkStub
1009 freeReg ILIT(REG_StkStub) = _FALSE_
1010 #endif
1011 freeReg _ = _TRUE_
1012 freeReg n
1013   -- we hang onto two double regs for dedicated
1014   -- use; this is not necessary on Alphas and
1015   -- may not be on other non-SPARCs.
1016 #ifdef REG_Dbl1
1017   | n _EQ_ (ILIT(REG_Dbl1) _ADD_ ILIT(1)) = _FALSE_
1018 #endif
1019 #ifdef REG_Dbl2
1020   | n _EQ_ (ILIT(REG_Dbl2) _ADD_ ILIT(1)) = _FALSE_
1021 #endif
1022   | otherwise = _TRUE_
1023 \end{code}