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,
35 -- | An identifier for a primitive real machine register.
39 -- VirtualRegs are virtual registers. The register allocator will
40 -- eventually have to map them into RealRegs, or into spill slots.
42 -- VirtualRegs are allocated on the fly, usually to represent a single
43 -- value in the abstract assembly code (i.e. dynamic registers are
44 -- usually single assignment).
46 -- The single assignment restriction isn't necessary to get correct code,
47 -- although a better register allocation will result if single
48 -- assignment is used -- because the allocator maps a VirtualReg into
49 -- a single RealReg, even if the VirtualReg has multiple live ranges.
51 -- Virtual regs can be of either class, so that info is attached.
54 = VirtualRegI {-# UNPACK #-} !Unique
55 | VirtualRegHi {-# UNPACK #-} !Unique -- High part of 2-word register
56 | VirtualRegF {-# UNPACK #-} !Unique
57 | VirtualRegD {-# UNPACK #-} !Unique
58 deriving (Eq, Show, Ord)
60 instance Uniquable VirtualReg where
68 instance Outputable VirtualReg where
71 VirtualRegI u -> text "%vI_" <> pprUnique u
72 VirtualRegHi u -> text "%vHi_" <> pprUnique u
73 VirtualRegF u -> text "%vF_" <> pprUnique u
74 VirtualRegD u -> text "%vD_" <> pprUnique u
77 renameVirtualReg :: Unique -> VirtualReg -> VirtualReg
80 VirtualRegI _ -> VirtualRegI u
81 VirtualRegHi _ -> VirtualRegHi u
82 VirtualRegF _ -> VirtualRegF u
83 VirtualRegD _ -> VirtualRegD u
86 classOfVirtualReg :: VirtualReg -> RegClass
89 VirtualRegI{} -> RcInteger
90 VirtualRegHi{} -> RcInteger
91 VirtualRegF{} -> RcFloat
92 VirtualRegD{} -> RcDouble
95 -- Determine the upper-half vreg for a 64-bit quantity on a 32-bit platform
96 -- when supplied with the vreg for the lower-half of the quantity.
97 -- (NB. Not reversible).
98 getHiVirtualRegFromLo :: VirtualReg -> VirtualReg
99 getHiVirtualRegFromLo reg
101 -- makes a pseudo-unique with tag 'H'
102 VirtualRegI u -> VirtualRegHi (newTagUnique u 'H')
103 _ -> panic "Reg.getHiVirtualRegFromLo"
105 getHiVRegFromLo :: Reg -> Reg
108 RegVirtual vr -> RegVirtual (getHiVirtualRegFromLo vr)
109 RegReal _ -> panic "Reg.getHiVRegFromLo"
112 ------------------------------------------------------------------------------------
113 -- | RealRegs are machine regs which are available for allocation, in
114 -- the usual way. We know what class they are, because that's part of
115 -- the processor's architecture.
117 -- RealRegPairs are pairs of real registers that are allocated together
118 -- to hold a larger value, such as with Double regs on SPARC.
121 = RealRegSingle {-# UNPACK #-} !RegNo
122 | RealRegPair {-# UNPACK #-} !RegNo {-# UNPACK #-} !RegNo
123 deriving (Eq, Show, Ord)
125 instance Uniquable RealReg where
128 RealRegSingle i -> mkRegSingleUnique i
129 RealRegPair r1 r2 -> mkRegPairUnique (r1 * 65536 + r2)
131 instance Outputable RealReg where
134 RealRegSingle i -> text "%r" <> int i
135 RealRegPair r1 r2 -> text "%r(" <> int r1 <> text "|" <> int r2 <> text ")"
137 regNosOfRealReg :: RealReg -> [RegNo]
140 RealRegSingle r1 -> [r1]
141 RealRegPair r1 r2 -> [r1, r2]
144 realRegsAlias :: RealReg -> RealReg -> Bool
145 realRegsAlias rr1 rr2
146 = not $ null $ intersect (regNosOfRealReg rr1) (regNosOfRealReg rr2)
148 --------------------------------------------------------------------------------
149 -- | A register, either virtual or real
151 = RegVirtual {-# UNPACK #-} !VirtualReg
152 | RegReal {-# UNPACK #-} !RealReg
155 regSingle :: RegNo -> Reg
156 regSingle regNo = RegReal $ RealRegSingle regNo
158 regPair :: RegNo -> RegNo -> Reg
159 regPair regNo1 regNo2 = RegReal $ RealRegPair regNo1 regNo2
162 -- We like to have Uniques for Reg so that we can make UniqFM and UniqSets
163 -- in the register allocator.
164 instance Uniquable Reg where
167 RegVirtual vr -> getUnique vr
168 RegReal rr -> getUnique rr
170 -- | Print a reg in a generic manner
171 -- If you want the architecture specific names, then use the pprReg
172 -- function from the appropriate Ppr module.
173 instance Outputable Reg where
176 RegVirtual vr -> ppr vr
180 isRealReg :: Reg -> Bool
184 RegVirtual _ -> False
186 takeRealReg :: Reg -> Maybe RealReg
189 RegReal rr -> Just rr
193 isVirtualReg :: Reg -> Bool
199 takeVirtualReg :: Reg -> Maybe VirtualReg
203 RegVirtual vr -> Just vr
206 -- | The patch function supplied by the allocator maps VirtualReg to RealReg
207 -- regs, but sometimes we want to apply it to plain old Reg.
209 liftPatchFnToRegReg :: (VirtualReg -> RealReg) -> (Reg -> Reg)
210 liftPatchFnToRegReg patchF reg
212 RegVirtual vr -> RegReal (patchF vr)