2 % (c) The AQUA Project, Glasgow University, 1996-1998
4 \section[MachRegs]{Machine-specific info about registers}
6 Also includes stuff about immediate operands, which are
7 often/usually quite entangled with registers.
9 (Immediates could be untangled from registers at some cost in tangled
10 modules --- the pleasure has been foregone.)
13 #include "nativeGen/NCG.h"
45 , gp, pv, ra, sp, t9, t10, t11, t12, v0, f0, zeroh
48 , eax, ebx, ecx, edx, esi, esp
49 , fake0, fake1, fake2, fake3, fake4, fake5
54 , fPair, fpRel, gReg, iReg, lReg, oReg, largeOffsetError
60 #include "HsVersions.h"
62 import AbsCSyn ( MagicId(..) )
63 import AbsCUtils ( magicIdPrimRep )
64 import CLabel ( CLabel )
65 import PrimOp ( PrimOp(..) )
66 import PrimRep ( PrimRep(..) )
67 import Stix ( sStLitLbl, StixTree(..), StixReg(..) )
68 import Unique ( mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3,
71 import UniqSupply ( getUniqueUs, returnUs, thenUs, UniqSM )
75 % - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
80 | ImmInteger Integer -- Sigh.
81 | ImmCLbl CLabel -- AbstractC Label (with baggage)
82 | ImmLab SDoc -- Simple string label (underscore-able)
83 | ImmLit SDoc -- Simple string
87 | LO Imm -- Possible restrictions...
90 strImmLit s = ImmLit (text s)
93 % - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
104 = AddrBaseIndex Base Index Displacement
107 type Base = Maybe Reg
108 type Index = Maybe (Reg, Int) -- Int is 2, 4 or 8
109 type Displacement = Imm
112 #if sparc_TARGET_ARCH
117 addrOffset :: MachRegsAddr -> Int -> Maybe MachRegsAddr
121 #if alpha_TARGET_ARCH
122 _ -> panic "MachMisc.addrOffset not defined for Alpha"
125 ImmAddr i off0 -> Just (ImmAddr i (off0 + off))
126 AddrBaseIndex r i (ImmInt n) -> Just (AddrBaseIndex r i (ImmInt (n + off)))
127 AddrBaseIndex r i (ImmInteger n)
128 -> Just (AddrBaseIndex r i (ImmInt (fromInteger (n + toInteger off))))
131 #if sparc_TARGET_ARCH
132 AddrRegImm r (ImmInt n)
133 | fits13Bits n2 -> Just (AddrRegImm r (ImmInt n2))
134 | otherwise -> Nothing
137 AddrRegImm r (ImmInteger n)
138 | fits13Bits n2 -> Just (AddrRegImm r (ImmInt (fromInteger n2)))
139 | otherwise -> Nothing
140 where n2 = n + toInteger off
142 AddrRegReg r (FixedReg ILIT(0))
143 | fits13Bits off -> Just (AddrRegImm r (ImmInt off))
144 | otherwise -> Nothing
151 #if alpha_TARGET_ARCH
153 fits8Bits :: Integer -> Bool
154 fits8Bits i = i >= -256 && i < 256
158 #if sparc_TARGET_ARCH
160 fits13Bits :: Int -> Bool
163 fits13Bits :: Integer -> Bool
166 fits13Bits :: Integral a => a -> Bool
167 fits13Bits x = x >= -4096 && x < 4096
171 = 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")
176 % - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
178 @stgReg@: we map STG registers onto appropriate Stix Trees. First, we
179 handle the two constants, @STK_STUB_closure@ and @vtbl_StdUpdFrame@.
180 The rest are either in real machine registers or stored as offsets
184 data RegLoc = Save StixTree | Always StixTree
187 Trees for register save locations:
189 saveLoc :: MagicId -> StixTree
191 saveLoc reg = case (stgReg reg) of {Always loc -> loc; Save loc -> loc}
195 stgReg :: MagicId -> RegLoc
198 = case (magicIdRegMaybe x) of
199 Just _ -> Save nonReg
200 Nothing -> Always nonReg
202 offset = baseRegOffset x
204 baseLoc = case (magicIdRegMaybe BaseReg) of
205 Just _ -> StReg (StixMagicId BaseReg)
206 Nothing -> sStLitLbl SLIT("MainRegTable")
209 BaseReg -> sStLitLbl SLIT("MainRegTable")
211 _ -> StInd (magicIdPrimRep x)
212 (StPrim IntAddOp [baseLoc,
213 StInt (toInteger (offset*BYTES_PER_WORD))])
216 % - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
218 @spRel@ gives us a stack relative addressing mode for volatile
219 temporaries and for excess call arguments. @fpRel@, where
220 applicable, is the same but for the frame pointer.
223 spRel :: Int -- desired stack offset in words, positive or negative
228 = AddrBaseIndex (Just esp) Nothing (ImmInt (n * BYTES_PER_WORD))
230 = AddrRegImm sp (ImmInt (n * BYTES_PER_WORD))
233 #if sparc_TARGET_ARCH
234 fpRel :: Int -> MachRegsAddr
235 -- Duznae work for offsets greater than 13 bits; we just hope for
238 = AddrRegImm fp (ImmInt (n * BYTES_PER_WORD))
242 %************************************************************************
244 \subsection[Reg]{Real registers}
246 %************************************************************************
248 Static Registers correspond to actual machine registers. These should
249 be avoided until the last possible moment.
251 Dynamic registers are allocated on the fly, usually to represent a single
252 value in the abstract assembly code (i.e. dynamic registers are usually
253 single assignment). Ultimately, they are mapped to available machine
254 registers before spitting out the code.
258 = FixedReg FAST_INT -- A pre-allocated machine register
260 | MappedReg FAST_INT -- A dynamically allocated machine register
262 | MemoryReg Int PrimRep -- A machine "register" actually held in
263 -- a memory allocated table of
264 -- registers which didn't fit in real
267 | UnmappedReg Unique PrimRep -- One of an infinite supply of registers,
268 -- always mapped to one of the earlier
269 -- two (?) before we're done.
270 mkReg :: Unique -> PrimRep -> Reg
273 getNewRegNCG :: PrimRep -> UniqSM Reg
275 = getUniqueUs `thenUs` \ u ->
276 returnUs (UnmappedReg u pk)
278 instance Text Reg where
279 showsPrec _ (FixedReg i) = showString "%" . shows IBOX(i)
280 showsPrec _ (MappedReg i) = showString "%" . shows IBOX(i)
281 showsPrec _ (MemoryReg i _) = showString "%M" . shows i
282 showsPrec _ (UnmappedReg i _) = showString "%U" . shows i
285 instance Outputable Reg where
286 ppr r = text (show r)
289 cmpReg (FixedReg i) (FixedReg i') = cmp_ihash i i'
290 cmpReg (MappedReg i) (MappedReg i') = cmp_ihash i i'
291 cmpReg (MemoryReg i _) (MemoryReg i' _) = i `compare` i'
292 cmpReg (UnmappedReg u _) (UnmappedReg u' _) = compare u u'
294 = let tag1 = tagReg r1
297 if tag1 _LT_ tag2 then LT else GT
299 tagReg (FixedReg _) = (ILIT(1) :: FAST_INT)
300 tagReg (MappedReg _) = ILIT(2)
301 tagReg (MemoryReg _ _) = ILIT(3)
302 tagReg (UnmappedReg _ _) = ILIT(4)
304 cmp_ihash :: FAST_INT -> FAST_INT -> Ordering
305 cmp_ihash a1 a2 = if a1 _EQ_ a2 then EQ else if a1 _LT_ a2 then LT else GT
307 instance Eq Reg where
308 a == b = case (a `compare` b) of { EQ -> True; _ -> False }
309 a /= b = case (a `compare` b) of { EQ -> False; _ -> True }
311 instance Ord Reg where
312 a <= b = case (a `compare` b) of { LT -> True; EQ -> True; GT -> False }
313 a < b = case (a `compare` b) of { LT -> True; EQ -> False; GT -> False }
314 a >= b = case (a `compare` b) of { LT -> False; EQ -> True; GT -> True }
315 a > b = case (a `compare` b) of { LT -> False; EQ -> False; GT -> True }
316 compare a b = cmpReg a b
318 instance Uniquable Reg where
319 getUnique (UnmappedReg u _) = u
320 getUnique (FixedReg i) = mkPseudoUnique1 IBOX(i)
321 getUnique (MappedReg i) = mkPseudoUnique2 IBOX(i)
322 getUnique (MemoryReg i _) = mkPseudoUnique3 i
328 realReg :: RegNo -> Reg
330 = if _IS_TRUE_(freeReg i) then MappedReg i else FixedReg i
332 extractMappedRegNos :: [Reg] -> [RegNo]
334 extractMappedRegNos regs
337 ex (MappedReg i) acc = IBOX(i) : acc -- we'll take it
338 ex _ acc = acc -- leave it out
341 ** Machine-specific Reg stuff: **
343 The Alpha has 64 registers of interest; 32 integer registers and 32 floating
344 point registers. The mapping of STG registers to alpha machine registers
345 is defined in StgRegs.h. We are, of course, prepared for any eventuality.
347 #if alpha_TARGET_ARCH
351 v0, f0, ra, pv, gp, sp, zeroh :: Reg
353 f0 = realReg (fReg 0)
354 ra = FixedReg ILIT(26)
356 gp = FixedReg ILIT(29)
357 sp = FixedReg ILIT(30)
358 zeroh = FixedReg ILIT(31) -- "zero" is used in 1.3 (MonadZero method)
360 t9, t10, t11, t12 :: Reg
368 Intel x86 architecture:
369 - All registers except 7 (esp) are available for use.
370 - Only ebx, esi, edi and esp are available across a C call (they are callee-saves).
371 - Registers 0-7 have 16-bit counterparts (ax, bx etc.)
372 - Registers 0-3 have 8 bit counterparts (ah, bh etc.)
373 - Registers 8-13 are fakes; we pretend x86 has 6 conventionally-addressable
374 fp registers, and 3-operand insns for them, and we translate this into
375 real stack-based x86 fp code after register allocation.
380 gReg,fReg :: Int -> Int
384 fake0, fake1, fake2, fake3, fake4, fake5, eax, ebx, ecx, edx, esp :: Reg
385 eax = realReg (gReg 0)
386 ebx = realReg (gReg 1)
387 ecx = realReg (gReg 2)
388 edx = realReg (gReg 3)
389 esi = realReg (gReg 4)
390 edi = realReg (gReg 5)
391 ebp = realReg (gReg 6)
392 esp = realReg (gReg 7)
393 fake0 = realReg (fReg 0)
394 fake1 = realReg (fReg 1)
395 fake2 = realReg (fReg 2)
396 fake3 = realReg (fReg 3)
397 fake4 = realReg (fReg 4)
398 fake5 = realReg (fReg 5)
402 The SPARC has 64 registers of interest; 32 integer registers and 32
403 floating point registers. The mapping of STG registers to SPARC
404 machine registers is defined in StgRegs.h. We are, of course,
405 prepared for any eventuality.
408 #if sparc_TARGET_ARCH
410 gReg,lReg,iReg,oReg,fReg :: Int -> Int
418 fPair (FixedReg i) = FixedReg (i _ADD_ ILIT(1))
419 fPair (MappedReg i) = MappedReg (i _ADD_ ILIT(1))
421 g0, fp, sp, o0, f0 :: Reg
422 g0 = case (gReg 0) of { IBOX(g0) -> FixedReg g0 }
423 fp = case (iReg 6) of { IBOX(i6) -> FixedReg i6 }
424 sp = case (oReg 6) of { IBOX(o6) -> FixedReg o6 }
425 o0 = realReg (oReg 0)
426 f0 = realReg (fReg 0)
431 Redefine the literals used for machine-registers with non-numeric
432 names in the header files. Gag me with a spoon, eh?
434 #if alpha_TARGET_ARCH
484 #if sparc_TARGET_ARCH
553 baseRegOffset :: MagicId -> Int
555 baseRegOffset (VanillaReg _ ILIT(1)) = OFFSET_R1
556 baseRegOffset (VanillaReg _ ILIT(2)) = OFFSET_R2
557 baseRegOffset (VanillaReg _ ILIT(3)) = OFFSET_R3
558 baseRegOffset (VanillaReg _ ILIT(4)) = OFFSET_R4
559 baseRegOffset (VanillaReg _ ILIT(5)) = OFFSET_R5
560 baseRegOffset (VanillaReg _ ILIT(6)) = OFFSET_R6
561 baseRegOffset (VanillaReg _ ILIT(7)) = OFFSET_R7
562 baseRegOffset (VanillaReg _ ILIT(8)) = OFFSET_R8
563 baseRegOffset (FloatReg ILIT(1)) = OFFSET_F1
564 baseRegOffset (FloatReg ILIT(2)) = OFFSET_F2
565 baseRegOffset (FloatReg ILIT(3)) = OFFSET_F3
566 baseRegOffset (FloatReg ILIT(4)) = OFFSET_F4
567 baseRegOffset (DoubleReg ILIT(1)) = OFFSET_D1
568 baseRegOffset (DoubleReg ILIT(2)) = OFFSET_D2
569 baseRegOffset Sp = OFFSET_Sp
570 baseRegOffset Su = OFFSET_Su
571 baseRegOffset SpLim = OFFSET_SpLim
573 baseRegOffset (LongReg _ ILIT(1)) = OFFSET_Lng1
576 baseRegOffset (LongReg _ ILIT(2)) = OFFSET_Lng2
578 baseRegOffset Hp = OFFSET_Hp
579 baseRegOffset HpLim = OFFSET_HpLim
581 baseRegOffset BaseReg = panic "baseRegOffset:BaseReg"
582 baseRegOffset CurCostCentre = panic "baseRegOffset:CurCostCentre"
583 baseRegOffset VoidReg = panic "baseRegOffset:VoidReg"
588 callerSaves :: MagicId -> Bool
590 #ifdef CALLER_SAVES_Base
591 callerSaves BaseReg = True
593 #ifdef CALLER_SAVES_R1
594 callerSaves (VanillaReg _ ILIT(1)) = True
596 #ifdef CALLER_SAVES_R2
597 callerSaves (VanillaReg _ ILIT(2)) = True
599 #ifdef CALLER_SAVES_R3
600 callerSaves (VanillaReg _ ILIT(3)) = True
602 #ifdef CALLER_SAVES_R4
603 callerSaves (VanillaReg _ ILIT(4)) = True
605 #ifdef CALLER_SAVES_R5
606 callerSaves (VanillaReg _ ILIT(5)) = True
608 #ifdef CALLER_SAVES_R6
609 callerSaves (VanillaReg _ ILIT(6)) = True
611 #ifdef CALLER_SAVES_R7
612 callerSaves (VanillaReg _ ILIT(7)) = True
614 #ifdef CALLER_SAVES_R8
615 callerSaves (VanillaReg _ ILIT(8)) = True
617 #ifdef CALLER_SAVES_F1
618 callerSaves (FloatReg ILIT(1)) = True
620 #ifdef CALLER_SAVES_F2
621 callerSaves (FloatReg ILIT(2)) = True
623 #ifdef CALLER_SAVES_F3
624 callerSaves (FloatReg ILIT(3)) = True
626 #ifdef CALLER_SAVES_F4
627 callerSaves (FloatReg ILIT(4)) = True
629 #ifdef CALLER_SAVES_D1
630 callerSaves (DoubleReg ILIT(1)) = True
632 #ifdef CALLER_SAVES_D2
633 callerSaves (DoubleReg ILIT(2)) = True
635 #ifdef CALLER_SAVES_L1
636 callerSaves (LongReg _ ILIT(1)) = True
638 #ifdef CALLER_SAVES_Sp
639 callerSaves Sp = True
641 #ifdef CALLER_SAVES_Su
642 callerSaves Su = True
644 #ifdef CALLER_SAVES_SpLim
645 callerSaves SpLim = True
647 #ifdef CALLER_SAVES_Hp
648 callerSaves Hp = True
650 #ifdef CALLER_SAVES_HpLim
651 callerSaves HpLim = True
653 callerSaves _ = False
657 magicIdRegMaybe :: MagicId -> Maybe Reg
660 magicIdRegMaybe BaseReg = Just (FixedReg ILIT(REG_Base))
663 magicIdRegMaybe (VanillaReg _ ILIT(1)) = Just (FixedReg ILIT(REG_R1))
666 magicIdRegMaybe (VanillaReg _ ILIT(2)) = Just (FixedReg ILIT(REG_R2))
669 magicIdRegMaybe (VanillaReg _ ILIT(3)) = Just (FixedReg ILIT(REG_R3))
672 magicIdRegMaybe (VanillaReg _ ILIT(4)) = Just (FixedReg ILIT(REG_R4))
675 magicIdRegMaybe (VanillaReg _ ILIT(5)) = Just (FixedReg ILIT(REG_R5))
678 magicIdRegMaybe (VanillaReg _ ILIT(6)) = Just (FixedReg ILIT(REG_R6))
681 magicIdRegMaybe (VanillaReg _ ILIT(7)) = Just (FixedReg ILIT(REG_R7))
684 magicIdRegMaybe (VanillaReg _ ILIT(8)) = Just (FixedReg ILIT(REG_R8))
687 magicIdRegMaybe (FloatReg ILIT(1)) = Just (FixedReg ILIT(REG_F1))
690 magicIdRegMaybe (FloatReg ILIT(2)) = Just (FixedReg ILIT(REG_F2))
693 magicIdRegMaybe (FloatReg ILIT(3)) = Just (FixedReg ILIT(REG_F3))
696 magicIdRegMaybe (FloatReg ILIT(4)) = Just (FixedReg ILIT(REG_F4))
699 magicIdRegMaybe (DoubleReg ILIT(1)) = Just (FixedReg ILIT(REG_D1))
702 magicIdRegMaybe (DoubleReg ILIT(2)) = Just (FixedReg ILIT(REG_D2))
705 magicIdRegMaybe Sp = Just (FixedReg ILIT(REG_Sp))
708 magicIdRegMaybe (LongReg _ ILIT(1)) = Just (FixedReg ILIT(REG_Lng1))
711 magicIdRegMaybe (LongReg _ ILIT(2)) = Just (FixedReg ILIT(REG_Lng2))
714 magicIdRegMaybe Su = Just (FixedReg ILIT(REG_Su))
717 magicIdRegMaybe SpLim = Just (FixedReg ILIT(REG_SpLim))
720 magicIdRegMaybe Hp = Just (FixedReg ILIT(REG_Hp))
723 magicIdRegMaybe HpLim = Just (FixedReg ILIT(REG_HpLim))
725 magicIdRegMaybe _ = Nothing
728 %************************************************************************
730 \subsection{Free, reserved, call-clobbered, and argument registers}
732 %************************************************************************
734 @freeRegs@ is the list of registers we can use in register allocation.
735 @freeReg@ (below) says if a particular register is free.
737 With a per-instruction clobber list, we might be able to get some of
738 these back, but it's probably not worth the hassle.
740 @callClobberedRegs@ ... the obvious.
742 @argRegs@: assuming a call with N arguments, what registers will be
743 used to hold arguments? (NB: it doesn't know whether the arguments
744 are integer or floating-point...)
747 reservedRegs :: [RegNo]
749 #if alpha_TARGET_ARCH
750 = [NCG_Reserved_I1, NCG_Reserved_I2,
751 NCG_Reserved_F1, NCG_Reserved_F2]
754 = [{-certainly cannot afford any!-}]
756 #if sparc_TARGET_ARCH
757 = [NCG_Reserved_I1, NCG_Reserved_I2,
758 NCG_Reserved_F1, NCG_Reserved_F2,
759 NCG_Reserved_D1, NCG_Reserved_D2]
762 -------------------------------
765 = freeMappedRegs IF_ARCH_alpha( [0..63],
766 IF_ARCH_i386( [0..13],
767 IF_ARCH_sparc( [0..63],)))
769 -------------------------------
770 callClobberedRegs :: [Reg]
773 #if alpha_TARGET_ARCH
774 [0, 1, 2, 3, 4, 5, 6, 7, 8,
775 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
776 fReg 0, fReg 1, fReg 10, fReg 11, fReg 12, fReg 13, fReg 14, fReg 15,
777 fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21, fReg 22, fReg 23,
778 fReg 24, fReg 25, fReg 26, fReg 27, fReg 28, fReg 29, fReg 30]
779 #endif {- alpha_TARGET_ARCH -}
782 #endif {- i386_TARGET_ARCH -}
783 #if sparc_TARGET_ARCH
785 [oReg i | i <- [0..5]] ++
786 [gReg i | i <- [1..7]] ++
787 [fReg i | i <- [0..31]] )
788 #endif {- sparc_TARGET_ARCH -}
790 -------------------------------
791 argRegs :: Int -> [Reg]
795 argRegs _ = panic "MachRegs.argRegs: doesn't work on I386"
797 #if alpha_TARGET_ARCH
798 argRegs 1 = freeMappedRegs [16, fReg 16]
799 argRegs 2 = freeMappedRegs [16, 17, fReg 16, fReg 17]
800 argRegs 3 = freeMappedRegs [16, 17, 18, fReg 16, fReg 17, fReg 18]
801 argRegs 4 = freeMappedRegs [16, 17, 18, 19, fReg 16, fReg 17, fReg 18, fReg 19]
802 argRegs 5 = freeMappedRegs [16, 17, 18, 19, 20, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20]
803 argRegs 6 = freeMappedRegs [16, 17, 18, 19, 20, 21, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21]
804 #endif {- alpha_TARGET_ARCH -}
805 #if sparc_TARGET_ARCH
806 argRegs 1 = freeMappedRegs (map oReg [0])
807 argRegs 2 = freeMappedRegs (map oReg [0,1])
808 argRegs 3 = freeMappedRegs (map oReg [0,1,2])
809 argRegs 4 = freeMappedRegs (map oReg [0,1,2,3])
810 argRegs 5 = freeMappedRegs (map oReg [0,1,2,3,4])
811 argRegs 6 = freeMappedRegs (map oReg [0,1,2,3,4,5])
812 #endif {- sparc_TARGET_ARCH -}
813 argRegs _ = panic "MachRegs.argRegs: don't know about >6 arguments!"
814 #endif {- i386_TARGET_ARCH -}
816 -------------------------------
818 #if alpha_TARGET_ARCH
819 allArgRegs :: [(Reg, Reg)]
821 allArgRegs = [(realReg i, realReg (fReg i)) | i <- [16..21]]
822 #endif {- alpha_TARGET_ARCH -}
824 #if sparc_TARGET_ARCH
827 allArgRegs = map realReg [oReg i | i <- [0..5]]
828 #endif {- sparc_TARGET_ARCH -}
830 -------------------------------
831 freeMappedRegs :: [Int] -> [Reg]
837 = if _IS_TRUE_(freeReg i) then (MappedReg i) : acc else acc
841 freeReg :: FAST_INT -> FAST_BOOL
843 #if alpha_TARGET_ARCH
844 freeReg ILIT(26) = _FALSE_ -- return address (ra)
845 freeReg ILIT(28) = _FALSE_ -- reserved for the assembler (at)
846 freeReg ILIT(29) = _FALSE_ -- global pointer (gp)
847 freeReg ILIT(30) = _FALSE_ -- stack pointer (sp)
848 freeReg ILIT(31) = _FALSE_ -- always zero (zeroh)
849 freeReg ILIT(63) = _FALSE_ -- always zero (f31)
853 freeReg ILIT(esp) = _FALSE_ -- %esp is the C stack pointer
856 #if sparc_TARGET_ARCH
857 freeReg ILIT(g0) = _FALSE_ -- %g0 is always 0.
858 freeReg ILIT(g5) = _FALSE_ -- %g5 is reserved (ABI).
859 freeReg ILIT(g6) = _FALSE_ -- %g6 is reserved (ABI).
860 freeReg ILIT(g7) = _FALSE_ -- %g7 is reserved (ABI).
861 freeReg ILIT(i6) = _FALSE_ -- %i6 is our frame pointer.
862 freeReg ILIT(o6) = _FALSE_ -- %o6 is our stack pointer.
866 freeReg ILIT(REG_Base) = _FALSE_
869 freeReg ILIT(REG_R1) = _FALSE_
872 freeReg ILIT(REG_R2) = _FALSE_
875 freeReg ILIT(REG_R3) = _FALSE_
878 freeReg ILIT(REG_R4) = _FALSE_
881 freeReg ILIT(REG_R5) = _FALSE_
884 freeReg ILIT(REG_R6) = _FALSE_
887 freeReg ILIT(REG_R7) = _FALSE_
890 freeReg ILIT(REG_R8) = _FALSE_
893 freeReg ILIT(REG_F1) = _FALSE_
896 freeReg ILIT(REG_F2) = _FALSE_
899 freeReg ILIT(REG_F3) = _FALSE_
902 freeReg ILIT(REG_F4) = _FALSE_
905 freeReg ILIT(REG_D1) = _FALSE_
908 freeReg ILIT(REG_D2) = _FALSE_
911 freeReg ILIT(REG_Sp) = _FALSE_
914 freeReg ILIT(REG_Su) = _FALSE_
917 freeReg ILIT(REG_SpLim) = _FALSE_
920 freeReg ILIT(REG_Hp) = _FALSE_
923 freeReg ILIT(REG_HpLim) = _FALSE_
926 -- we hang onto two double regs for dedicated
927 -- use; this is not necessary on Alphas and
928 -- may not be on other non-SPARCs.
930 | n _EQ_ (ILIT(REG_D1) _ADD_ ILIT(1)) = _FALSE_
933 | n _EQ_ (ILIT(REG_D2) _ADD_ ILIT(1)) = _FALSE_