compiler/nativeGen/Reg.hs

   1
   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.
   6 --
   7 module Reg (
   8         RegNo,
   9         Reg(..),
  10         regPair,
  11         regSingle,
  12         isRealReg,      takeRealReg,
  13         isVirtualReg,   takeVirtualReg,
  14
  15         VirtualReg(..),
  16         renameVirtualReg,
  17         classOfVirtualReg,
  18         getHiVirtualRegFromLo,
  19         getHiVRegFromLo,
  20
  21         RealReg(..),
  22         regNosOfRealReg,
  23         realRegsAlias,
  24
  25         liftPatchFnToRegReg
  26 )
  27
  28 where
  29
  30 import Outputable
  31 import Unique
  32 import Panic
  33 import RegClass
  34 import Data.List
  35
  36 -- | An identifier for a primitive real machine register.
  37 type RegNo
  38         = Int
  39
  40 -- VirtualRegs are virtual registers.  The register allocator will
  41 --      eventually have to map them into RealRegs, or into spill slots.
  42 --
  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).
  46 --
  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.
  51 --
  52 --      Virtual regs can be of either class, so that info is attached.
  53 --
  54 data VirtualReg
  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)
  60
  61 instance Uniquable VirtualReg where
  62         getUnique reg
  63          = case reg of
  64                 VirtualRegI u   -> u
  65                 VirtualRegHi u  -> u
  66                 VirtualRegF u   -> u
  67                 VirtualRegD u   -> u
  68
  69 instance Outputable VirtualReg where
  70         ppr reg
  71          = case reg of
  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
  76
  77
  78 renameVirtualReg :: Unique -> VirtualReg -> VirtualReg
  79 renameVirtualReg u r
  80  = case r of
  81         VirtualRegI _   -> VirtualRegI  u
  82         VirtualRegHi _  -> VirtualRegHi u
  83         VirtualRegF _   -> VirtualRegF  u
  84         VirtualRegD _   -> VirtualRegD  u
  85
  86
  87 classOfVirtualReg :: VirtualReg -> RegClass
  88 classOfVirtualReg vr
  89  = case vr of
  90         VirtualRegI{}   -> RcInteger
  91         VirtualRegHi{}  -> RcInteger
  92         VirtualRegF{}   -> RcFloat
  93         VirtualRegD{}   -> RcDouble
  94
  95
  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
 101  = case reg of
 102         -- makes a pseudo-unique with tag 'H'
 103         VirtualRegI u   -> VirtualRegHi (newTagUnique u 'H')
 104         _               -> panic "Reg.getHiVirtualRegFromLo"
 105
 106 getHiVRegFromLo :: Reg -> Reg
 107 getHiVRegFromLo reg
 108  = case reg of
 109         RegVirtual  vr  -> RegVirtual (getHiVirtualRegFromLo vr)
 110         RegReal _       -> panic "Reg.getHiVRegFromLo"
 111
 112
 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.
 117 --
 118 --      RealRegPairs are pairs of real registers that are allocated together
 119 --      to hold a larger value, such as with Double regs on SPARC.
 120 --
 121 data RealReg
 122         = RealRegSingle {-# UNPACK #-} !RegNo
 123         | RealRegPair   {-# UNPACK #-} !RegNo {-# UNPACK #-} !RegNo
 124         deriving (Eq, Show, Ord)
 125
 126 instance Uniquable RealReg where
 127         getUnique reg
 128          = case reg of
 129                 RealRegSingle i         -> mkUnique 'S' i
 130                 RealRegPair r1 r2       -> mkUnique 'P' (r1 * 65536 + r2)
 131
 132 instance Outputable RealReg where
 133         ppr reg
 134          = case reg of
 135                 RealRegSingle i         -> text "%r"    <> int i
 136                 RealRegPair r1 r2       -> text "%r(" <> int r1 <> text "|" <> int r2 <> text ")"
 137
 138 regNosOfRealReg :: RealReg -> [RegNo]
 139 regNosOfRealReg rr
 140  = case rr of
 141         RealRegSingle r1        -> [r1]
 142         RealRegPair   r1 r2     -> [r1, r2]
 143
 144
 145 realRegsAlias :: RealReg -> RealReg -> Bool
 146 realRegsAlias rr1 rr2
 147         = not $ null $ intersect (regNosOfRealReg rr1) (regNosOfRealReg rr2)
 148
 149 --------------------------------------------------------------------------------
 150 -- | A register, either virtual or real
 151 data Reg
 152         = RegVirtual {-# UNPACK #-} !VirtualReg
 153         | RegReal    {-# UNPACK #-} !RealReg
 154         deriving (Eq, Ord)
 155
 156 regSingle :: RegNo -> Reg
 157 regSingle regNo         = RegReal $ RealRegSingle regNo
 158
 159 regPair :: RegNo -> RegNo -> Reg
 160 regPair regNo1 regNo2   = RegReal $ RealRegPair regNo1 regNo2
 161
 162
 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
 166         getUnique reg
 167          = case reg of
 168                 RegVirtual vr   -> getUnique vr
 169                 RegReal    rr   -> getUnique rr
 170
 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
 175         ppr reg
 176          = case reg of
 177                 RegVirtual vr   -> ppr vr
 178                 RegReal    rr   -> ppr rr
 179
 180
 181 isRealReg :: Reg -> Bool
 182 isRealReg reg
 183  = case reg of
 184         RegReal _       -> True
 185         RegVirtual _    -> False
 186
 187 takeRealReg :: Reg -> Maybe RealReg
 188 takeRealReg reg
 189  = case reg of
 190         RegReal rr      -> Just rr
 191         _               -> Nothing
 192
 193
 194 isVirtualReg :: Reg -> Bool
 195 isVirtualReg reg
 196  = case reg of
 197         RegReal _       -> False
 198         RegVirtual _    -> True
 199
 200 takeVirtualReg :: Reg -> Maybe VirtualReg
 201 takeVirtualReg reg
 202  = case reg of
 203         RegReal _       -> Nothing
 204         RegVirtual vr   -> Just vr
 205
 206
 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.
 209 --
 210 liftPatchFnToRegReg  :: (VirtualReg -> RealReg) -> (Reg -> Reg)
 211 liftPatchFnToRegReg patchF reg
 212  = case reg of
 213         RegVirtual vr   -> RegReal (patchF vr)
 214         RegReal _       -> reg
 215
 216