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         showSDoc (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 #ifdef OFFSET_Lng1
 600 baseRegOffset (LongReg _ ILIT(1))    = OFFSET_Lng1
 601 #endif
 602 #ifdef OFFSET_Lng2
 603 baseRegOffset (LongReg _ ILIT(2))    = OFFSET_Lng2
 604 #endif
 605 baseRegOffset TagReg                 = OFFSET_Tag
 606 baseRegOffset RetReg                 = OFFSET_Ret
 607 baseRegOffset SpA                    = OFFSET_SpA
 608 baseRegOffset SuA                    = OFFSET_SuA
 609 baseRegOffset SpB                    = OFFSET_SpB
 610 baseRegOffset SuB                    = OFFSET_SuB
 611 baseRegOffset Hp                     = OFFSET_Hp
 612 baseRegOffset HpLim                  = OFFSET_HpLim
 613 baseRegOffset LivenessReg            = OFFSET_Liveness
 614 #ifdef DEBUG
 615 baseRegOffset BaseReg                = panic "baseRegOffset:BaseReg"
 616 baseRegOffset StdUpdRetVecReg        = panic "baseRegOffset:StgUpdRetVecReg"
 617 baseRegOffset StkStubReg             = panic "baseRegOffset:StkStubReg"
 618 baseRegOffset CurCostCentre          = panic "baseRegOffset:CurCostCentre"
 619 baseRegOffset VoidReg                = panic "baseRegOffset:VoidReg"
 620 #endif
 621 \end{code}
 622
 623 \begin{code}
 624 callerSaves :: MagicId -> Bool
 625
 626 #ifdef CALLER_SAVES_Base
 627 callerSaves BaseReg                     = True
 628 #endif
 629 #ifdef CALLER_SAVES_StkO
 630 callerSaves StkOReg                     = True
 631 #endif
 632 #ifdef CALLER_SAVES_R1
 633 callerSaves (VanillaReg _ ILIT(1))      = True
 634 #endif
 635 #ifdef CALLER_SAVES_R2
 636 callerSaves (VanillaReg _ ILIT(2))      = True
 637 #endif
 638 #ifdef CALLER_SAVES_R3
 639 callerSaves (VanillaReg _ ILIT(3))      = True
 640 #endif
 641 #ifdef CALLER_SAVES_R4
 642 callerSaves (VanillaReg _ ILIT(4))      = True
 643 #endif
 644 #ifdef CALLER_SAVES_R5
 645 callerSaves (VanillaReg _ ILIT(5))      = True
 646 #endif
 647 #ifdef CALLER_SAVES_R6
 648 callerSaves (VanillaReg _ ILIT(6))      = True
 649 #endif
 650 #ifdef CALLER_SAVES_R7
 651 callerSaves (VanillaReg _ ILIT(7))      = True
 652 #endif
 653 #ifdef CALLER_SAVES_R8
 654 callerSaves (VanillaReg _ ILIT(8))      = True
 655 #endif
 656 #ifdef CALLER_SAVES_FltReg1
 657 callerSaves (FloatReg ILIT(1))          = True
 658 #endif
 659 #ifdef CALLER_SAVES_FltReg2
 660 callerSaves (FloatReg ILIT(2))          = True
 661 #endif
 662 #ifdef CALLER_SAVES_FltReg3
 663 callerSaves (FloatReg ILIT(3))          = True
 664 #endif
 665 #ifdef CALLER_SAVES_FltReg4
 666 callerSaves (FloatReg ILIT(4))          = True
 667 #endif
 668 #ifdef CALLER_SAVES_DblReg1
 669 callerSaves (DoubleReg ILIT(1))         = True
 670 #endif
 671 #ifdef CALLER_SAVES_DblReg2
 672 callerSaves (DoubleReg ILIT(2))         = True
 673 #endif
 674 #ifdef CALLER_SAVES_LngReg1
 675 callerSaves (LongReg _ ILIT(1))         = True
 676 #endif
 677 #ifdef CALLER_SAVES_LngReg2
 678 callerSaves (LongReg _ ILIT(2))         = True
 679 #endif
 680 #ifdef CALLER_SAVES_Tag
 681 callerSaves TagReg                      = True
 682 #endif
 683 #ifdef CALLER_SAVES_Ret
 684 callerSaves RetReg                      = True
 685 #endif
 686 #ifdef CALLER_SAVES_SpA
 687 callerSaves SpA                         = True
 688 #endif
 689 #ifdef CALLER_SAVES_SuA
 690 callerSaves SuA                         = True
 691 #endif
 692 #ifdef CALLER_SAVES_SpB
 693 callerSaves SpB                         = True
 694 #endif
 695 #ifdef CALLER_SAVES_SuB
 696 callerSaves SuB                         = True
 697 #endif
 698 #ifdef CALLER_SAVES_Hp
 699 callerSaves Hp                          = True
 700 #endif
 701 #ifdef CALLER_SAVES_HpLim
 702 callerSaves HpLim                       = True
 703 #endif
 704 #ifdef CALLER_SAVES_Liveness
 705 callerSaves LivenessReg                 = True
 706 #endif
 707 #ifdef CALLER_SAVES_StdUpdRetVec
 708 callerSaves StdUpdRetVecReg             = True
 709 #endif
 710 #ifdef CALLER_SAVES_StkStub
 711 callerSaves StkStubReg                  = True
 712 #endif
 713 callerSaves _                           = False
 714 \end{code}
 715
 716 \begin{code}
 717 magicIdRegMaybe :: MagicId -> Maybe Reg
 718
 719 #ifdef REG_Base
 720 magicIdRegMaybe BaseReg                 = Just (FixedReg ILIT(REG_Base))
 721 #endif
 722 #ifdef REG_StkO
 723 magicIdRegMaybe StkOReg                 = Just (FixedReg ILIT(REG_StkOReg))
 724 #endif
 725 #ifdef REG_R1
 726 magicIdRegMaybe (VanillaReg _ ILIT(1))  = Just (FixedReg ILIT(REG_R1))
 727 #endif
 728 #ifdef REG_R2
 729 magicIdRegMaybe (VanillaReg _ ILIT(2))  = Just (FixedReg ILIT(REG_R2))
 730 #endif
 731 #ifdef REG_R3
 732 magicIdRegMaybe (VanillaReg _ ILIT(3))  = Just (FixedReg ILIT(REG_R3))
 733 #endif
 734 #ifdef REG_R4
 735 magicIdRegMaybe (VanillaReg _ ILIT(4))  = Just (FixedReg ILIT(REG_R4))
 736 #endif
 737 #ifdef REG_R5
 738 magicIdRegMaybe (VanillaReg _ ILIT(5))  = Just (FixedReg ILIT(REG_R5))
 739 #endif
 740 #ifdef REG_R6
 741 magicIdRegMaybe (VanillaReg _ ILIT(6))  = Just (FixedReg ILIT(REG_R6))
 742 #endif
 743 #ifdef REG_R7
 744 magicIdRegMaybe (VanillaReg _ ILIT(7))  = Just (FixedReg ILIT(REG_R7))
 745 #endif
 746 #ifdef REG_R8
 747 magicIdRegMaybe (VanillaReg _ ILIT(8))  = Just (FixedReg ILIT(REG_R8))
 748 #endif
 749 #ifdef REG_Flt1
 750 magicIdRegMaybe (FloatReg ILIT(1))      = Just (FixedReg ILIT(REG_Flt1))
 751 #endif
 752 #ifdef REG_Flt2
 753 magicIdRegMaybe (FloatReg ILIT(2))      = Just (FixedReg ILIT(REG_Flt2))
 754 #endif
 755 #ifdef REG_Flt3
 756 magicIdRegMaybe (FloatReg ILIT(3))      = Just (FixedReg ILIT(REG_Flt3))
 757 #endif
 758 #ifdef REG_Flt4
 759 magicIdRegMaybe (FloatReg ILIT(4))      = Just (FixedReg ILIT(REG_Flt4))
 760 #endif
 761 #ifdef REG_Dbl1
 762 magicIdRegMaybe (DoubleReg ILIT(1))     = Just (FixedReg ILIT(REG_Dbl1))
 763 #endif
 764 #ifdef REG_Dbl2
 765 magicIdRegMaybe (DoubleReg ILIT(2))     = Just (FixedReg ILIT(REG_Dbl2))
 766 #endif
 767 #ifdef REG_Lng1
 768 magicIdRegMaybe (LongReg _ ILIT(1))     = Just (FixedReg ILIT(REG_Lng1))
 769 #endif
 770 #ifdef REG_Lng2
 771 magicIdRegMaybe (LongReg _ ILIT(2))     = Just (FixedReg ILIT(REG_Lng2))
 772 #endif
 773 #ifdef REG_Tag
 774 magicIdRegMaybe TagReg                  = Just (FixedReg ILIT(REG_TagReg))
 775 #endif
 776 #ifdef REG_Ret
 777 magicIdRegMaybe RetReg                  = Just (FixedReg ILIT(REG_Ret))
 778 #endif
 779 #ifdef REG_SpA
 780 magicIdRegMaybe SpA                     = Just (FixedReg ILIT(REG_SpA))
 781 #endif
 782 #ifdef REG_SuA
 783 magicIdRegMaybe SuA                     = Just (FixedReg ILIT(REG_SuA))
 784 #endif
 785 #ifdef REG_SpB
 786 magicIdRegMaybe SpB                     = Just (FixedReg ILIT(REG_SpB))
 787 #endif
 788 #ifdef REG_SuB
 789 magicIdRegMaybe SuB                     = Just (FixedReg ILIT(REG_SuB))
 790 #endif
 791 #ifdef REG_Hp
 792 magicIdRegMaybe Hp                      = Just (FixedReg ILIT(REG_Hp))
 793 #endif
 794 #ifdef REG_HpLim
 795 magicIdRegMaybe HpLim                   = Just (FixedReg ILIT(REG_HpLim))
 796 #endif
 797 #ifdef REG_Liveness
 798 magicIdRegMaybe LivenessReg             = Just (FixedReg ILIT(REG_Liveness))
 799 #endif
 800 #ifdef REG_StdUpdRetVec
 801 magicIdRegMaybe StdUpdRetVecReg         = Just (FixedReg ILIT(REG_StdUpdRetVec))
 802 #endif
 803 #ifdef REG_StkStub
 804 magicIdRegMaybe StkStubReg              = Just (FixedReg ILIT(REG_StkStub))
 805 #endif
 806 magicIdRegMaybe _                       = Nothing
 807 \end{code}
 808
 809 %************************************************************************
 810 %*                                                                      *
 811 \subsection{Free, reserved, call-clobbered, and argument registers}
 812 %*                                                                      *
 813 %************************************************************************
 814
 815 @freeRegs@ is the list of registers we can use in register allocation.
 816 @freeReg@ (below) says if a particular register is free.
 817
 818 With a per-instruction clobber list, we might be able to get some of
 819 these back, but it's probably not worth the hassle.
 820
 821 @callClobberedRegs@ ... the obvious.
 822
 823 @argRegs@: assuming a call with N arguments, what registers will be
 824 used to hold arguments?  (NB: it doesn't know whether the arguments
 825 are integer or floating-point...)
 826
 827 \begin{code}
 828 reservedRegs :: [RegNo]
 829 reservedRegs
 830 #if alpha_TARGET_ARCH
 831   = [NCG_Reserved_I1, NCG_Reserved_I2,
 832      NCG_Reserved_F1, NCG_Reserved_F2]
 833 #endif
 834 #if i386_TARGET_ARCH
 835   = [{-certainly cannot afford any!-}]
 836 #endif
 837 #if sparc_TARGET_ARCH
 838   = [NCG_Reserved_I1, NCG_Reserved_I2,
 839      NCG_Reserved_F1, NCG_Reserved_F2,
 840      NCG_Reserved_D1, NCG_Reserved_D2]
 841 #endif
 842
 843 -------------------------------
 844 freeRegs :: [Reg]
 845 freeRegs
 846   = freeMappedRegs IF_ARCH_alpha( [0..63],
 847                    IF_ARCH_i386(  [0..15],
 848                    IF_ARCH_sparc( [0..63],)))
 849
 850 -------------------------------
 851 callClobberedRegs :: [Reg]
 852 callClobberedRegs
 853   = freeMappedRegs
 854 #if alpha_TARGET_ARCH
 855     [0, 1, 2, 3, 4, 5, 6, 7, 8,
 856      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
 857      fReg 0, fReg 1, fReg 10, fReg 11, fReg 12, fReg 13, fReg 14, fReg 15,
 858      fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21, fReg 22, fReg 23,
 859      fReg 24, fReg 25, fReg 26, fReg 27, fReg 28, fReg 29, fReg 30]
 860 #endif {- alpha_TARGET_ARCH -}
 861 #if i386_TARGET_ARCH
 862     [{-none-}]
 863 #endif {- i386_TARGET_ARCH -}
 864 #if sparc_TARGET_ARCH
 865     ( oReg 7 :
 866       [oReg i | i <- [0..5]] ++
 867       [gReg i | i <- [1..7]] ++
 868       [fReg i | i <- [0..31]] )
 869 #endif {- sparc_TARGET_ARCH -}
 870
 871 -------------------------------
 872 argRegs :: Int -> [Reg]
 873
 874 argRegs 0 = []
 875 #if alpha_TARGET_ARCH
 876 argRegs 1 = freeMappedRegs [16, fReg 16]
 877 argRegs 2 = freeMappedRegs [16, 17, fReg 16, fReg 17]
 878 argRegs 3 = freeMappedRegs [16, 17, 18, fReg 16, fReg 17, fReg 18]
 879 argRegs 4 = freeMappedRegs [16, 17, 18, 19, fReg 16, fReg 17, fReg 18, fReg 19]
 880 argRegs 5 = freeMappedRegs [16, 17, 18, 19, 20, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20]
 881 argRegs 6 = freeMappedRegs [16, 17, 18, 19, 20, 21, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21]
 882 #endif {- alpha_TARGET_ARCH -}
 883 #if i386_TARGET_ARCH
 884 argRegs _ = panic "MachRegs.argRegs: doesn't work on I386"
 885 #endif {- i386_TARGET_ARCH -}
 886 #if sparc_TARGET_ARCH
 887 argRegs 1 = freeMappedRegs (map oReg [0])
 888 argRegs 2 = freeMappedRegs (map oReg [0,1])
 889 argRegs 3 = freeMappedRegs (map oReg [0,1,2])
 890 argRegs 4 = freeMappedRegs (map oReg [0,1,2,3])
 891 argRegs 5 = freeMappedRegs (map oReg [0,1,2,3,4])
 892 argRegs 6 = freeMappedRegs (map oReg [0,1,2,3,4,5])
 893 #endif {- sparc_TARGET_ARCH -}
 894 argRegs _ = panic "MachRegs.argRegs: don't know about >6 arguments!"
 895
 896 -------------------------------
 897
 898 #if alpha_TARGET_ARCH
 899 allArgRegs :: [(Reg, Reg)]
 900
 901 allArgRegs = [(realReg i, realReg (fReg i)) | i <- [16..21]]
 902 #endif {- alpha_TARGET_ARCH -}
 903
 904 #if sparc_TARGET_ARCH
 905 allArgRegs :: [Reg]
 906
 907 allArgRegs = map realReg [oReg i | i <- [0..5]]
 908 #endif {- sparc_TARGET_ARCH -}
 909
 910 -------------------------------
 911 freeMappedRegs :: [Int] -> [Reg]
 912
 913 freeMappedRegs nums
 914   = foldr free [] nums
 915   where
 916     free IBOX(i) acc
 917       = if _IS_TRUE_(freeReg i) then (MappedReg i) : acc else acc
 918 \end{code}
 919
 920 \begin{code}
 921 freeReg :: FAST_INT -> FAST_BOOL
 922
 923 #if alpha_TARGET_ARCH
 924 freeReg ILIT(26) = _FALSE_  -- return address (ra)
 925 freeReg ILIT(28) = _FALSE_  -- reserved for the assembler (at)
 926 freeReg ILIT(29) = _FALSE_  -- global pointer (gp)
 927 freeReg ILIT(30) = _FALSE_  -- stack pointer (sp)
 928 freeReg ILIT(31) = _FALSE_  -- always zero (zeroh)
 929 freeReg ILIT(63) = _FALSE_  -- always zero (f31)
 930 #endif
 931
 932 #if i386_TARGET_ARCH
 933 freeReg ILIT(esp) = _FALSE_  -- %esp is the C stack pointer
 934 #endif
 935
 936 #if sparc_TARGET_ARCH
 937 freeReg ILIT(g0) = _FALSE_  --  %g0 is always 0.
 938 freeReg ILIT(g5) = _FALSE_  --  %g5 is reserved (ABI).
 939 freeReg ILIT(g6) = _FALSE_  --  %g6 is reserved (ABI).
 940 freeReg ILIT(g7) = _FALSE_  --  %g7 is reserved (ABI).
 941 freeReg ILIT(i6) = _FALSE_  --  %i6 is our frame pointer.
 942 freeReg ILIT(o6) = _FALSE_  --  %o6 is our stack pointer.
 943 #endif
 944
 945 #ifdef REG_Base
 946 freeReg ILIT(REG_Base) = _FALSE_
 947 #endif
 948 #ifdef REG_StkO
 949 freeReg ILIT(REG_StkO) = _FALSE_
 950 #endif
 951 #ifdef REG_R1
 952 freeReg ILIT(REG_R1)   = _FALSE_
 953 #endif
 954 #ifdef REG_R2
 955 freeReg ILIT(REG_R2)   = _FALSE_
 956 #endif
 957 #ifdef REG_R3
 958 freeReg ILIT(REG_R3)   = _FALSE_
 959 #endif
 960 #ifdef REG_R4
 961 freeReg ILIT(REG_R4)   = _FALSE_
 962 #endif
 963 #ifdef REG_R5
 964 freeReg ILIT(REG_R5)   = _FALSE_
 965 #endif
 966 #ifdef REG_R6
 967 freeReg ILIT(REG_R6)   = _FALSE_
 968 #endif
 969 #ifdef REG_R7
 970 freeReg ILIT(REG_R7)   = _FALSE_
 971 #endif
 972 #ifdef REG_R8
 973 freeReg ILIT(REG_R8)   = _FALSE_
 974 #endif
 975 #ifdef REG_Flt1
 976 freeReg ILIT(REG_Flt1) = _FALSE_
 977 #endif
 978 #ifdef REG_Flt2
 979 freeReg ILIT(REG_Flt2) = _FALSE_
 980 #endif
 981 #ifdef REG_Flt3
 982 freeReg ILIT(REG_Flt3) = _FALSE_
 983 #endif
 984 #ifdef REG_Flt4
 985 freeReg ILIT(REG_Flt4) = _FALSE_
 986 #endif
 987 #ifdef REG_Dbl1
 988 freeReg ILIT(REG_Dbl1) = _FALSE_
 989 #endif
 990 #ifdef REG_Dbl2
 991 freeReg ILIT(REG_Dbl2) = _FALSE_
 992 #endif
 993 #ifdef REG_Tag
 994 freeReg ILIT(REG_Tag)  = _FALSE_
 995 #endif
 996 #ifdef REG_Ret
 997 freeReg ILIT(REG_Ret)  = _FALSE_
 998 #endif
 999 #ifdef REG_SpA
1000 freeReg ILIT(REG_SpA)  = _FALSE_
1001 #endif
1002 #ifdef REG_SuA
1003 freeReg ILIT(REG_SuA)  = _FALSE_
1004 #endif
1005 #ifdef REG_SpB
1006 freeReg ILIT(REG_SpB)  = _FALSE_
1007 #endif
1008 #ifdef REG_SuB
1009 freeReg ILIT(REG_SuB)  = _FALSE_
1010 #endif
1011 #ifdef REG_Hp
1012 freeReg ILIT(REG_Hp)   = _FALSE_
1013 #endif
1014 #ifdef REG_HpLim
1015 freeReg ILIT(REG_HpLim) = _FALSE_
1016 #endif
1017 #ifdef REG_Liveness
1018 freeReg ILIT(REG_Liveness) = _FALSE_
1019 #endif
1020 #ifdef REG_StdUpdRetVec
1021 freeReg ILIT(REG_StdUpdRetVec) = _FALSE_
1022 #endif
1023 #ifdef REG_StkStub
1024 freeReg ILIT(REG_StkStub) = _FALSE_
1025 #endif
1026 freeReg _ = _TRUE_
1027 freeReg n
1028   -- we hang onto two double regs for dedicated
1029   -- use; this is not necessary on Alphas and
1030   -- may not be on other non-SPARCs.
1031 #ifdef REG_Dbl1
1032   | n _EQ_ (ILIT(REG_Dbl1) _ADD_ ILIT(1)) = _FALSE_
1033 #endif
1034 #ifdef REG_Dbl2
1035   | n _EQ_ (ILIT(REG_Dbl2) _ADD_ ILIT(1)) = _FALSE_
1036 #endif
1037   | otherwise = _TRUE_
1038 \end{code}