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