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