compiler/nativeGen/RegArchX86.hs

   1
   2 -- | A description of the register set of the X86.
   3 --      This isn't used directly in GHC proper.
   4 --
   5 --      See RegArchBase.hs for the reference.
   6 --      See MachRegs.hs for the actual trivColorable function used in GHC.
   7 --
   8
   9 {-# OPTIONS_GHC -w #-}
  10 -- The above warning supression flag is a temporary kludge.
  11 -- While working on this module you are encouraged to remove it and fix
  12 -- any warnings in the module. See
  13 --     http://hackage.haskell.org/trac/ghc/wiki/WorkingConventions#Warnings
  14 -- for details
  15
  16 module RegArchX86 (
  17         classOfReg,
  18         regsOfClass,
  19         regName,
  20         regAlias,
  21         worst,
  22         squeese,
  23 ) where
  24
  25 import RegArchBase              (Reg(..), RegSub(..), RegClass(..))
  26
  27 import UniqSet
  28
  29 -- | Determine the class of a register
  30 classOfReg :: Reg -> RegClass
  31 classOfReg reg
  32  = case reg of
  33         Reg c i         -> c
  34
  35         RegSub SubL16 r -> ClassG16
  36         RegSub SubL8  r -> ClassG8
  37         RegSub SubL8H r -> ClassG8
  38
  39
  40 -- | Determine all the regs that make up a certain class.
  41 --
  42 regsOfClass :: RegClass -> UniqSet Reg
  43 regsOfClass c
  44  = case c of
  45         ClassG32
  46          -> mkUniqSet     [ Reg ClassG32  i                     | i <- [0..7] ]
  47
  48         ClassG16
  49          -> mkUniqSet     [ RegSub SubL16 (Reg ClassG32 i)      | i <- [0..7] ]
  50
  51         ClassG8
  52          -> unionUniqSets
  53                 (mkUniqSet [ RegSub SubL8  (Reg ClassG32 i)     | i <- [0..3] ])
  54                 (mkUniqSet [ RegSub SubL8H (Reg ClassG32 i)     | i <- [0..3] ])
  55
  56         ClassF64
  57          -> mkUniqSet      [ Reg ClassF64  i                    | i <- [0..5] ]
  58
  59
  60 -- | Determine the common name of a reg
  61 --      returns Nothing if this reg is not part of the machine.
  62
  63 regName :: Reg -> Maybe String
  64 regName reg
  65  = case reg of
  66         Reg ClassG32 i
  67          | i <= 7       -> Just ([ "eax", "ebx", "ecx", "edx", "ebp", "esi", "edi", "esp" ] !! i)
  68
  69         RegSub SubL16 (Reg ClassG32 i)
  70          | i <= 7       -> Just ([ "ax", "bx", "cx", "dx", "bp", "si", "di", "sp"] !! i)
  71
  72         RegSub SubL8  (Reg ClassG32 i)
  73          | i <= 3       -> Just ([ "al", "bl", "cl", "dl"] !! i)
  74
  75         RegSub SubL8H (Reg ClassG32 i)
  76          | i <= 3       -> Just ([ "ah", "bh", "ch", "dh"] !! i)
  77
  78         _               -> Nothing
  79
  80
  81 -- | Which regs alias what other regs
  82 regAlias :: Reg -> UniqSet Reg
  83 regAlias reg
  84  = case reg of
  85
  86         -- 32 bit regs alias all of the subregs
  87         Reg ClassG32 i
  88
  89          -- for eax, ebx, ecx, eds
  90          |  i <= 3
  91          -> mkUniqSet $ [ Reg ClassG32 i, RegSub SubL16 reg, RegSub SubL8 reg, RegSub SubL8H reg ]
  92
  93          -- for esi, edi, esp, ebp
  94          | 4 <= i && i <= 7
  95          -> mkUniqSet $ [ Reg ClassG32 i, RegSub SubL16 reg ]
  96
  97
  98         -- 16 bit subregs alias the whole reg
  99         RegSub SubL16 r@(Reg ClassG32 i)
 100          ->     regAlias r
 101
 102         -- 8 bit subregs alias the 32 and 16, but not the other 8 bit subreg
 103         RegSub SubL8  r@(Reg ClassG32 i)
 104          -> mkUniqSet $ [ r, RegSub SubL16 r, RegSub SubL8 r ]
 105
 106         RegSub SubL8H r@(Reg ClassG32 i)
 107          -> mkUniqSet $ [ r, RegSub SubL16 r, RegSub SubL8H r ]
 108
 109         -- fp
 110         Reg ClassF64 i
 111          -> unitUniqSet reg
 112
 113         _ -> error "regAlias: invalid register"
 114
 115
 116 -- | Optimised versions of RegColorBase.{worst, squeese} specific to x86
 117
 118 worst :: Int -> RegClass -> RegClass -> Int
 119 worst n classN classC
 120  = case classN of
 121         ClassG32
 122          -> case classC of
 123                 ClassG32        -> min n 8
 124                 ClassG16        -> min n 8
 125                 ClassG8         -> min n 4
 126                 ClassF64        -> 0
 127
 128         ClassG16
 129          -> case classC of
 130                 ClassG32        -> min n 8
 131                 ClassG16        -> min n 8
 132                 ClassG8         -> min n 4
 133                 ClassF64        -> 0
 134
 135         ClassG8
 136          -> case classC of
 137                 ClassG32        -> min (n*2) 8
 138                 ClassG16        -> min (n*2) 8
 139                 ClassG8         -> min n 8
 140                 ClassF64        -> 0
 141
 142         ClassF64
 143          -> case classC of
 144                 ClassF64        -> min n 6
 145                 _               -> 0
 146
 147 squeese :: RegClass -> [(Int, RegClass)] -> Int
 148 squeese classN countCs
 149         = sum (map (\(i, classC) -> worst i classN classC) countCs)
 150
 151
 152
 153
 154