compiler/nativeGen/RegsBase.hs

   1
   2 module RegsBase (
   3         RegNo,
   4         Reg(..),
   5         isRealReg,
   6         unRealReg,
   7         isVirtualReg,
   8         renameVirtualReg,
   9
  10         RegClass(..)
  11 )
  12
  13 where
  14
  15 import Outputable       ( Outputable(..) )
  16 import qualified Outputable
  17 import Panic
  18 import Unique
  19
  20 -- ---------------------------------------------------------------------------
  21 -- Registers
  22
  23 -- RealRegs are machine regs which are available for allocation, in
  24 -- the usual way.  We know what class they are, because that's part of
  25 -- the processor's architecture.
  26
  27 -- VirtualRegs are virtual registers.  The register allocator will
  28 -- eventually have to map them into RealRegs, or into spill slots.
  29 -- VirtualRegs are allocated on the fly, usually to represent a single
  30 -- value in the abstract assembly code (i.e. dynamic registers are
  31 -- usually single assignment).  With the new register allocator, the
  32 -- single assignment restriction isn't necessary to get correct code,
  33 -- although a better register allocation will result if single
  34 -- assignment is used -- because the allocator maps a VirtualReg into
  35 -- a single RealReg, even if the VirtualReg has multiple live ranges.
  36
  37 -- Virtual regs can be of either class, so that info is attached.
  38
  39 type RegNo
  40         = Int
  41
  42 data Reg
  43         = RealReg      {-# UNPACK #-} !RegNo
  44         | VirtualRegI  {-# UNPACK #-} !Unique
  45         | VirtualRegHi {-# UNPACK #-} !Unique  -- High part of 2-word register
  46         | VirtualRegF  {-# UNPACK #-} !Unique
  47         | VirtualRegD  {-# UNPACK #-} !Unique
  48         deriving (Eq, Ord)
  49
  50
  51 -- We like to have Uniques for Reg so that we can make UniqFM and UniqSets
  52 -- in the register allocator.
  53 instance Uniquable Reg where
  54         getUnique (RealReg i)      = mkUnique 'C' i
  55         getUnique (VirtualRegI u)  = u
  56         getUnique (VirtualRegHi u) = u
  57         getUnique (VirtualRegF u)  = u
  58         getUnique (VirtualRegD u)  = u
  59
  60
  61 isRealReg :: Reg -> Bool
  62 isRealReg = not . isVirtualReg
  63
  64 -- | Take the RegNo from a real reg
  65 unRealReg :: Reg -> RegNo
  66 unRealReg (RealReg i)   = i
  67 unRealReg _             = panic "unRealReg on VirtualReg"
  68
  69 isVirtualReg :: Reg -> Bool
  70 isVirtualReg (RealReg _)      = False
  71 isVirtualReg (VirtualRegI _)  = True
  72 isVirtualReg (VirtualRegHi _) = True
  73 isVirtualReg (VirtualRegF _)  = True
  74 isVirtualReg (VirtualRegD _)  = True
  75
  76
  77 renameVirtualReg :: Unique -> Reg -> Reg
  78 renameVirtualReg u r
  79  = case r of
  80         RealReg _       -> error "renameVirtualReg: can't change unique on a real reg"
  81         VirtualRegI _   -> VirtualRegI  u
  82         VirtualRegHi _  -> VirtualRegHi u
  83         VirtualRegF _   -> VirtualRegF  u
  84         VirtualRegD _   -> VirtualRegD  u
  85
  86
  87 -- RegClass --------------------------------------------------------------------
  88 data RegClass
  89    = RcInteger
  90    | RcFloat
  91    | RcDouble
  92      deriving Eq
  93
  94 instance Uniquable RegClass where
  95     getUnique RcInteger = mkUnique 'L' 0
  96     getUnique RcFloat   = mkUnique 'L' 1
  97     getUnique RcDouble  = mkUnique 'L' 2
  98
  99 instance Outputable RegClass where
 100     ppr RcInteger       = Outputable.text "I"
 101     ppr RcFloat         = Outputable.text "F"
 102     ppr RcDouble        = Outputable.text "D"
 103
 104
 105