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