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