2 -- | An architecture independent description of a register.
3 -- This needs to stay architecture independent because it is used
4 -- by NCGMonad and the register allocators, which are shared
5 -- by all architectures.
12 isRealReg, takeRealReg,
13 isVirtualReg, takeVirtualReg,
18 getHiVirtualRegFromLo,
36 -- | An identifier for a primitive real machine register.
40 -- VirtualRegs are virtual registers. The register allocator will
41 -- eventually have to map them into RealRegs, or into spill slots.
43 -- VirtualRegs are allocated on the fly, usually to represent a single
44 -- value in the abstract assembly code (i.e. dynamic registers are
45 -- usually single assignment).
47 -- The single assignment restriction isn't necessary to get correct code,
48 -- although a better register allocation will result if single
49 -- assignment is used -- because the allocator maps a VirtualReg into
50 -- a single RealReg, even if the VirtualReg has multiple live ranges.
52 -- Virtual regs can be of either class, so that info is attached.
55 = VirtualRegI {-# UNPACK #-} !Unique
56 | VirtualRegHi {-# UNPACK #-} !Unique -- High part of 2-word register
57 | VirtualRegF {-# UNPACK #-} !Unique
58 | VirtualRegD {-# UNPACK #-} !Unique
59 deriving (Eq, Show, Ord)
61 instance Uniquable VirtualReg where
69 instance Outputable VirtualReg where
72 VirtualRegI u -> text "%vI_" <> pprUnique u
73 VirtualRegHi u -> text "%vHi_" <> pprUnique u
74 VirtualRegF u -> text "%vF_" <> pprUnique u
75 VirtualRegD u -> text "%vD_" <> pprUnique u
78 renameVirtualReg :: Unique -> VirtualReg -> VirtualReg
81 VirtualRegI _ -> VirtualRegI u
82 VirtualRegHi _ -> VirtualRegHi u
83 VirtualRegF _ -> VirtualRegF u
84 VirtualRegD _ -> VirtualRegD u
87 classOfVirtualReg :: VirtualReg -> RegClass
90 VirtualRegI{} -> RcInteger
91 VirtualRegHi{} -> RcInteger
92 VirtualRegF{} -> RcFloat
93 VirtualRegD{} -> RcDouble
96 -- Determine the upper-half vreg for a 64-bit quantity on a 32-bit platform
97 -- when supplied with the vreg for the lower-half of the quantity.
98 -- (NB. Not reversible).
99 getHiVirtualRegFromLo :: VirtualReg -> VirtualReg
100 getHiVirtualRegFromLo reg
102 -- makes a pseudo-unique with tag 'H'
103 VirtualRegI u -> VirtualRegHi (newTagUnique u 'H')
104 _ -> panic "Reg.getHiVirtualRegFromLo"
106 getHiVRegFromLo :: Reg -> Reg
109 RegVirtual vr -> RegVirtual (getHiVirtualRegFromLo vr)
110 RegReal _ -> panic "Reg.getHiVRegFromLo"
113 ------------------------------------------------------------------------------------
114 -- | RealRegs are machine regs which are available for allocation, in
115 -- the usual way. We know what class they are, because that's part of
116 -- the processor's architecture.
118 -- RealRegPairs are pairs of real registers that are allocated together
119 -- to hold a larger value, such as with Double regs on SPARC.
122 = RealRegSingle {-# UNPACK #-} !RegNo
123 | RealRegPair {-# UNPACK #-} !RegNo {-# UNPACK #-} !RegNo
124 deriving (Eq, Show, Ord)
126 instance Uniquable RealReg where
129 RealRegSingle i -> mkUnique 'S' i
130 RealRegPair r1 r2 -> mkUnique 'P' (r1 * 65536 + r2)
132 instance Outputable RealReg where
135 RealRegSingle i -> text "%r" <> int i
136 RealRegPair r1 r2 -> text "%r(" <> int r1 <> text "|" <> int r2 <> text ")"
138 regNosOfRealReg :: RealReg -> [RegNo]
141 RealRegSingle r1 -> [r1]
142 RealRegPair r1 r2 -> [r1, r2]
145 realRegsAlias :: RealReg -> RealReg -> Bool
146 realRegsAlias rr1 rr2
147 = not $ null $ intersect (regNosOfRealReg rr1) (regNosOfRealReg rr2)
149 --------------------------------------------------------------------------------
150 -- | A register, either virtual or real
152 = RegVirtual {-# UNPACK #-} !VirtualReg
153 | RegReal {-# UNPACK #-} !RealReg
156 regSingle :: RegNo -> Reg
157 regSingle regNo = RegReal $ RealRegSingle regNo
159 regPair :: RegNo -> RegNo -> Reg
160 regPair regNo1 regNo2 = RegReal $ RealRegPair regNo1 regNo2
163 -- We like to have Uniques for Reg so that we can make UniqFM and UniqSets
164 -- in the register allocator.
165 instance Uniquable Reg where
168 RegVirtual vr -> getUnique vr
169 RegReal rr -> getUnique rr
171 -- | Print a reg in a generic manner
172 -- If you want the architecture specific names, then use the pprReg
173 -- function from the appropriate Ppr module.
174 instance Outputable Reg where
177 RegVirtual vr -> ppr vr
181 isRealReg :: Reg -> Bool
185 RegVirtual _ -> False
187 takeRealReg :: Reg -> Maybe RealReg
190 RegReal rr -> Just rr
194 isVirtualReg :: Reg -> Bool
200 takeVirtualReg :: Reg -> Maybe VirtualReg
204 RegVirtual vr -> Just vr
207 -- | The patch function supplied by the allocator maps VirtualReg to RealReg
208 -- regs, but sometimes we want to apply it to plain old Reg.
210 liftPatchFnToRegReg :: (VirtualReg -> RealReg) -> (Reg -> Reg)
211 liftPatchFnToRegReg patchF reg
213 RegVirtual vr -> RegReal (patchF vr)