compiler/nativeGen/Alpha/Regs.hs

   1 -- -----------------------------------------------------------------------------
   2 --
   3 -- (c) The University of Glasgow 1994-2004
   4 --
   5 -- Alpha support is rotted and incomplete.
   6 -- -----------------------------------------------------------------------------
   7
   8
   9 module Alpha.Regs (
  10 {-
  11         Size(..),
  12         AddrMode(..),
  13         fits8Bits,
  14         fReg,
  15         gp, pv, ra, sp, t9, t10, t11, t12, v0, f0, zeroh
  16 -}
  17 )
  18
  19 where
  20
  21 {-
  22 #include "nativeGen/NCG.h"
  23 #include "HsVersions.h"
  24 #include "../includes/MachRegs.h"
  25
  26 import RegsBase
  27
  28 import BlockId
  29 import Cmm
  30 import CgUtils          ( get_GlobalReg_addr )
  31 import CLabel           ( CLabel, mkMainCapabilityLabel )
  32 import Pretty
  33 import Outputable       ( Outputable(..), pprPanic, panic )
  34 import qualified Outputable
  35 import Unique
  36 import UniqSet
  37 import Constants
  38 import FastTypes
  39 import FastBool
  40 import UniqFM
  41
  42
  43 data Size
  44         = B         -- byte
  45         | Bu
  46 --      | W         -- word (2 bytes): UNUSED
  47 --      | Wu    -- : UNUSED
  48         | L         -- longword (4 bytes)
  49         | Q         -- quadword (8 bytes)
  50 --      | FF    -- VAX F-style floating pt: UNUSED
  51 --      | GF    -- VAX G-style floating pt: UNUSED
  52 --      | DF    -- VAX D-style floating pt: UNUSED
  53 --      | SF    -- IEEE single-precision floating pt: UNUSED
  54         | TF    -- IEEE double-precision floating pt
  55         deriving Eq
  56
  57
  58 data AddrMode
  59         = AddrImm       Imm
  60         | AddrReg       Reg
  61         | AddrRegImm    Reg Imm
  62
  63
  64 addrOffset :: AddrMode -> Int -> Maybe AddrMode
  65 addrOffset addr off
  66   = case addr of
  67       _ -> panic "MachMisc.addrOffset not defined for Alpha"
  68
  69 fits8Bits :: Integer -> Bool
  70 fits8Bits i = i >= -256 && i < 256
  71
  72
  73 -- The Alpha has 64 registers of interest; 32 integer registers and 32 floating
  74 -- point registers.  The mapping of STG registers to alpha machine registers
  75 -- is defined in StgRegs.h.  We are, of course, prepared for any eventuality.
  76
  77 fReg :: Int -> RegNo
  78 fReg x = (32 + x)
  79
  80 v0, f0, ra, pv, gp, sp, zeroh :: Reg
  81 v0    = realReg 0
  82 f0    = realReg (fReg 0)
  83 ra    = FixedReg ILIT(26)
  84 pv    = t12
  85 gp    = FixedReg ILIT(29)
  86 sp    = FixedReg ILIT(30)
  87 zeroh = FixedReg ILIT(31) -- "zero" is used in 1.3 (MonadZero method)
  88
  89 t9, t10, t11, t12 :: Reg
  90 t9  = realReg 23
  91 t10 = realReg 24
  92 t11 = realReg 25
  93 t12 = realReg 27
  94
  95
  96 #define f0 32
  97 #define f1 33
  98 #define f2 34
  99 #define f3 35
 100 #define f4 36
 101 #define f5 37
 102 #define f6 38
 103 #define f7 39
 104 #define f8 40
 105 #define f9 41
 106 #define f10 42
 107 #define f11 43
 108 #define f12 44
 109 #define f13 45
 110 #define f14 46
 111 #define f15 47
 112 #define f16 48
 113 #define f17 49
 114 #define f18 50
 115 #define f19 51
 116 #define f20 52
 117 #define f21 53
 118 #define f22 54
 119 #define f23 55
 120 #define f24 56
 121 #define f25 57
 122 #define f26 58
 123 #define f27 59
 124 #define f28 60
 125 #define f29 61
 126 #define f30 62
 127 #define f31 63
 128
 129
 130 -- allMachRegs is the complete set of machine regs.
 131 allMachRegNos :: [RegNo]
 132 allMachRegNos   = [0..63]
 133
 134
 135 -- these are the regs which we cannot assume stay alive over a
 136 -- C call.
 137 callClobberedRegs :: [Reg]
 138 callClobberedRegs
 139  =      [0, 1, 2, 3, 4, 5, 6, 7, 8,
 140          16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
 141          fReg 0, fReg 1, fReg 10, fReg 11, fReg 12, fReg 13, fReg 14, fReg 15,
 142          fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21, fReg 22, fReg 23,
 143          fReg 24, fReg 25, fReg 26, fReg 27, fReg 28, fReg 29, fReg 30]
 144
 145
 146 -- argRegs is the set of regs which are read for an n-argument call to C.
 147 -- For archs which pass all args on the stack (x86), is empty.
 148 -- Sparc passes up to the first 6 args in regs.
 149 -- Dunno about Alpha.
 150 argRegs :: RegNo -> [Reg]
 151
 152 argRegs 0 = []
 153 argRegs 1 = freeMappedRegs [16, fReg 16]
 154 argRegs 2 = freeMappedRegs [16, 17, fReg 16, fReg 17]
 155 argRegs 3 = freeMappedRegs [16, 17, 18, fReg 16, fReg 17, fReg 18]
 156 argRegs 4 = freeMappedRegs [16, 17, 18, 19, fReg 16, fReg 17, fReg 18, fReg 19]
 157 argRegs 5 = freeMappedRegs [16, 17, 18, 19, 20, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20]
 158 argRegs 6 = freeMappedRegs [16, 17, 18, 19, 20, 21, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21]
 159 argRegs _ = panic "MachRegs.argRegs(alpha): don't know about >6 arguments!"
 160
 161
 162 -- all of the arg regs ??
 163 allArgRegs :: [(Reg, Reg)]
 164 allArgRegs = [(realReg i, realReg (fReg i)) | i <- [16..21]]
 165
 166
 167 -- horror show -----------------------------------------------------------------
 168
 169 freeReg :: RegNo -> FastBool
 170
 171 freeReg 26 = fastBool False  -- return address (ra)
 172 freeReg 28 = fastBool False  -- reserved for the assembler (at)
 173 freeReg 29 = fastBool False  -- global pointer (gp)
 174 freeReg 30 = fastBool False  -- stack pointer (sp)
 175 freeReg 31 = fastBool False  -- always zero (zeroh)
 176 freeReg 63 = fastBool False  -- always zero (f31)
 177
 178 #ifdef REG_Base
 179 freeReg REG_Base = fastBool False
 180 #endif
 181 #ifdef REG_R1
 182 freeReg REG_R1   = fastBool False
 183 #endif
 184 #ifdef REG_R2
 185 freeReg REG_R2   = fastBool False
 186 #endif
 187 #ifdef REG_R3
 188 freeReg REG_R3   = fastBool False
 189 #endif
 190 #ifdef REG_R4
 191 freeReg REG_R4   = fastBool False
 192 #endif
 193 #ifdef REG_R5
 194 freeReg REG_R5   = fastBool False
 195 #endif
 196 #ifdef REG_R6
 197 freeReg REG_R6   = fastBool False
 198 #endif
 199 #ifdef REG_R7
 200 freeReg REG_R7   = fastBool False
 201 #endif
 202 #ifdef REG_R8
 203 freeReg REG_R8   = fastBool False
 204 #endif
 205 #ifdef REG_F1
 206 freeReg REG_F1 = fastBool False
 207 #endif
 208 #ifdef REG_F2
 209 freeReg REG_F2 = fastBool False
 210 #endif
 211 #ifdef REG_F3
 212 freeReg REG_F3 = fastBool False
 213 #endif
 214 #ifdef REG_F4
 215 freeReg REG_F4 = fastBool False
 216 #endif
 217 #ifdef REG_D1
 218 freeReg REG_D1 = fastBool False
 219 #endif
 220 #ifdef REG_D2
 221 freeReg REG_D2 = fastBool False
 222 #endif
 223 #ifdef REG_Sp
 224 freeReg REG_Sp   = fastBool False
 225 #endif
 226 #ifdef REG_Su
 227 freeReg REG_Su   = fastBool False
 228 #endif
 229 #ifdef REG_SpLim
 230 freeReg REG_SpLim = fastBool False
 231 #endif
 232 #ifdef REG_Hp
 233 freeReg REG_Hp   = fastBool False
 234 #endif
 235 #ifdef REG_HpLim
 236 freeReg REG_HpLim = fastBool False
 237 #endif
 238 freeReg n               = fastBool True
 239
 240
 241 --  | Returns 'Nothing' if this global register is not stored
 242 -- in a real machine register, otherwise returns @'Just' reg@, where
 243 -- reg is the machine register it is stored in.
 244
 245 globalRegMaybe :: GlobalReg -> Maybe Reg
 246
 247 #ifdef REG_Base
 248 globalRegMaybe BaseReg                  = Just (RealReg REG_Base)
 249 #endif
 250 #ifdef REG_R1
 251 globalRegMaybe (VanillaReg 1 _)         = Just (RealReg REG_R1)
 252 #endif
 253 #ifdef REG_R2
 254 globalRegMaybe (VanillaReg 2 _)         = Just (RealReg REG_R2)
 255 #endif
 256 #ifdef REG_R3
 257 globalRegMaybe (VanillaReg 3 _)         = Just (RealReg REG_R3)
 258 #endif
 259 #ifdef REG_R4
 260 globalRegMaybe (VanillaReg 4 _)         = Just (RealReg REG_R4)
 261 #endif
 262 #ifdef REG_R5
 263 globalRegMaybe (VanillaReg 5 _)         = Just (RealReg REG_R5)
 264 #endif
 265 #ifdef REG_R6
 266 globalRegMaybe (VanillaReg 6 _)         = Just (RealReg REG_R6)
 267 #endif
 268 #ifdef REG_R7
 269 globalRegMaybe (VanillaReg 7 _)         = Just (RealReg REG_R7)
 270 #endif
 271 #ifdef REG_R8
 272 globalRegMaybe (VanillaReg 8 _)         = Just (RealReg REG_R8)
 273 #endif
 274 #ifdef REG_R9
 275 globalRegMaybe (VanillaReg 9 _)         = Just (RealReg REG_R9)
 276 #endif
 277 #ifdef REG_R10
 278 globalRegMaybe (VanillaReg 10 _)        = Just (RealReg REG_R10)
 279 #endif
 280 #ifdef REG_F1
 281 globalRegMaybe (FloatReg 1)             = Just (RealReg REG_F1)
 282 #endif
 283 #ifdef REG_F2
 284 globalRegMaybe (FloatReg 2)             = Just (RealReg REG_F2)
 285 #endif
 286 #ifdef REG_F3
 287 globalRegMaybe (FloatReg 3)             = Just (RealReg REG_F3)
 288 #endif
 289 #ifdef REG_F4
 290 globalRegMaybe (FloatReg 4)             = Just (RealReg REG_F4)
 291 #endif
 292 #ifdef REG_D1
 293 globalRegMaybe (DoubleReg 1)            = Just (RealReg REG_D1)
 294 #endif
 295 #ifdef REG_D2
 296 globalRegMaybe (DoubleReg 2)            = Just (RealReg REG_D2)
 297 #endif
 298 #ifdef REG_Sp
 299 globalRegMaybe Sp                       = Just (RealReg REG_Sp)
 300 #endif
 301 #ifdef REG_Lng1
 302 globalRegMaybe (LongReg 1)              = Just (RealReg REG_Lng1)
 303 #endif
 304 #ifdef REG_Lng2
 305 globalRegMaybe (LongReg 2)              = Just (RealReg REG_Lng2)
 306 #endif
 307 #ifdef REG_SpLim
 308 globalRegMaybe SpLim                    = Just (RealReg REG_SpLim)
 309 #endif
 310 #ifdef REG_Hp
 311 globalRegMaybe Hp                       = Just (RealReg REG_Hp)
 312 #endif
 313 #ifdef REG_HpLim
 314 globalRegMaybe HpLim                    = Just (RealReg REG_HpLim)
 315 #endif
 316 #ifdef REG_CurrentTSO
 317 globalRegMaybe CurrentTSO               = Just (RealReg REG_CurrentTSO)
 318 #endif
 319 #ifdef REG_CurrentNursery
 320 globalRegMaybe CurrentNursery           = Just (RealReg REG_CurrentNursery)
 321 #endif
 322 globalRegMaybe _                        = Nothing
 323
 324 -}