/compiler/nativeGen/Alpha/Regs.hs

https://github.com/nominolo/ghc · Haskell · 323 lines · 3 code · 4 blank · 316 comment · 0 complexity · 731f8f7522f4e4749f764b322fa66958 MD5 · raw file 

    

  1. -- -----------------------------------------------------------------------------
    2. 

  2. --
    3. 

  3. -- (c) The University of Glasgow 1994-2004
    4. 

  4. -- 
    5. 

  5. -- Alpha support is rotted and incomplete.
    6. 

  6. -- -----------------------------------------------------------------------------
    7. 

  7. 

  8. 

  9. module Alpha.Regs (
    10. 

  10. {-
    11. 

  11. 	Size(..),
    12. 

  12. 	AddrMode(..),
    13. 

  13. 	fits8Bits,
    14. 

  14. 	fReg,
    15. 

  15. 	gp, pv, ra, sp, t9, t10, t11, t12, v0, f0, zeroh
    16. 

  16. -}
    17. 

  17. )
    18. 

  18. 

  19. where
    20. 

  20. 

  21. {-
    22. 

  22. #include "nativeGen/NCG.h"
    23. 

  23. #include "HsVersions.h"
    24. 

  24. #include "../includes/stg/MachRegs.h"
    25. 

  25. 

  26. import RegsBase
    27. 

  27. 

  28. import BlockId
    29. 

  29. import Cmm
    30. 

  30. import CLabel           ( CLabel, mkMainCapabilityLabel )
    31. 

  31. import Pretty
    32. 

  32. import Outputable	( Outputable(..), pprPanic, panic )
    33. 

  33. import qualified Outputable
    34. 

  34. import Unique
    35. 

  35. import UniqSet
    36. 

  36. import Constants
    37. 

  37. import FastTypes
    38. 

  38. import FastBool
    39. 

  39. import UniqFM
    40. 

  40. 

  41. 

  42. data Size
    43. 

  43. 	= B	    -- byte
    44. 

  44. 	| Bu
    45. 

  45. --	| W	    -- word (2 bytes): UNUSED
    46. 

  46. --	| Wu    -- : UNUSED
    47. 

  47. 	| L	    -- longword (4 bytes)
    48. 

  48. 	| Q	    -- quadword (8 bytes)
    49. 

  49. --	| FF    -- VAX F-style floating pt: UNUSED
    50. 

  50. --	| GF    -- VAX G-style floating pt: UNUSED
    51. 

  51. --	| DF    -- VAX D-style floating pt: UNUSED
    52. 

  52. --	| SF    -- IEEE single-precision floating pt: UNUSED
    53. 

  53. 	| TF    -- IEEE double-precision floating pt
    54. 

  54. 	deriving Eq
    55. 

  55. 

  56. 

  57. data AddrMode
    58. 

  58. 	= AddrImm	Imm
    59. 

  59. 	| AddrReg	Reg
    60. 

  60. 	| AddrRegImm	Reg Imm
    61. 

  61. 

  62. 

  63. addrOffset :: AddrMode -> Int -> Maybe AddrMode
    64. 

  64. addrOffset addr off
    65. 

  65.   = case addr of
    66. 

  66.       _ -> panic "MachMisc.addrOffset not defined for Alpha"
    67. 

  67. 

  68. fits8Bits :: Integer -> Bool
    69. 

  69. fits8Bits i = i >= -256 && i < 256
    70. 

  70. 

  71. 

  72. -- The Alpha has 64 registers of interest; 32 integer registers and 32 floating
    73. 

  73. -- point registers.  The mapping of STG registers to alpha machine registers
    74. 

  74. -- is defined in StgRegs.h.  We are, of course, prepared for any eventuality.
    75. 

  75. 

  76. fReg :: Int -> RegNo
    77. 

  77. fReg x = (32 + x)
    78. 

  78. 

  79. v0, f0, ra, pv, gp, sp, zeroh :: Reg
    80. 

  80. v0    = realReg 0
    81. 

  81. f0    = realReg (fReg 0)
    82. 

  82. ra    = FixedReg ILIT(26)
    83. 

  83. pv    = t12
    84. 

  84. gp    = FixedReg ILIT(29)
    85. 

  85. sp    = FixedReg ILIT(30)
    86. 

  86. zeroh = FixedReg ILIT(31) -- "zero" is used in 1.3 (MonadZero method)
    87. 

  87. 

  88. t9, t10, t11, t12 :: Reg
    89. 

  89. t9  = realReg 23
    90. 

  90. t10 = realReg 24
    91. 

  91. t11 = realReg 25
    92. 

  92. t12 = realReg 27
    93. 

  93. 

  94. 

  95. #define f0 32
    96. 

  96. #define f1 33
    97. 

  97. #define f2 34
    98. 

  98. #define f3 35
    99. 

  99. #define f4 36
    100. 

  100. #define f5 37
    101. 

  101. #define f6 38
    102. 

  102. #define f7 39
    103. 

  103. #define f8 40
    104. 

  104. #define f9 41
    105. 

  105. #define f10 42
    106. 

  106. #define f11 43
    107. 

  107. #define f12 44
    108. 

  108. #define f13 45
    109. 

  109. #define f14 46
    110. 

  110. #define f15 47
    111. 

  111. #define f16 48
    112. 

  112. #define f17 49
    113. 

  113. #define f18 50
    114. 

  114. #define f19 51
    115. 

  115. #define f20 52
    116. 

  116. #define f21 53
    117. 

  117. #define f22 54
    118. 

  118. #define f23 55
    119. 

  119. #define f24 56
    120. 

  120. #define f25 57
    121. 

  121. #define f26 58
    122. 

  122. #define f27 59
    123. 

  123. #define f28 60
    124. 

  124. #define f29 61
    125. 

  125. #define f30 62
    126. 

  126. #define f31 63
    127. 

  127. 

  128. 

  129. -- allMachRegs is the complete set of machine regs.
    130. 

  130. allMachRegNos :: [RegNo]
    131. 

  131. allMachRegNos	= [0..63]
    132. 

  132. 

  133. 

  134. -- these are the regs which we cannot assume stay alive over a
    135. 

  135. -- C call.  
    136. 

  136. callClobberedRegs :: [Reg]
    137. 

  137. callClobberedRegs
    138. 

  138.  =	[0, 1, 2, 3, 4, 5, 6, 7, 8,
    139. 

  139. 	 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    140. 

  140. 	 fReg 0, fReg 1, fReg 10, fReg 11, fReg 12, fReg 13, fReg 14, fReg 15,
    141. 

  141. 	 fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21, fReg 22, fReg 23,
    142. 

  142. 	 fReg 24, fReg 25, fReg 26, fReg 27, fReg 28, fReg 29, fReg 30]
    143. 

  143. 

  144. 

  145. -- argRegs is the set of regs which are read for an n-argument call to C.
    146. 

  146. -- For archs which pass all args on the stack (x86), is empty.
    147. 

  147. -- Sparc passes up to the first 6 args in regs.
    148. 

  148. -- Dunno about Alpha.
    149. 

  149. argRegs :: RegNo -> [Reg]
    150. 

  150. 

  151. argRegs 0 = []
    152. 

  152. argRegs 1 = freeMappedRegs [16, fReg 16]
    153. 

  153. argRegs 2 = freeMappedRegs [16, 17, fReg 16, fReg 17]
    154. 

  154. argRegs 3 = freeMappedRegs [16, 17, 18, fReg 16, fReg 17, fReg 18]
    155. 

  155. argRegs 4 = freeMappedRegs [16, 17, 18, 19, fReg 16, fReg 17, fReg 18, fReg 19]
    156. 

  156. argRegs 5 = freeMappedRegs [16, 17, 18, 19, 20, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20]
    157. 

  157. argRegs 6 = freeMappedRegs [16, 17, 18, 19, 20, 21, fReg 16, fReg 17, fReg 18, fReg 19, fReg 20, fReg 21]
    158. 

  158. argRegs _ = panic "MachRegs.argRegs(alpha): don't know about >6 arguments!"
    159. 

  159. 

  160. 

  161. -- all of the arg regs ??
    162. 

  162. allArgRegs :: [(Reg, Reg)]
    163. 

  163. allArgRegs = [(realReg i, realReg (fReg i)) | i <- [16..21]]
    164. 

  164. 

  165. 

  166. -- horror show -----------------------------------------------------------------
    167. 

  167. 

  168. freeReg :: RegNo -> FastBool
    169. 

  169. 

  170. freeReg 26 = fastBool False  -- return address (ra)
    171. 

  171. freeReg 28 = fastBool False  -- reserved for the assembler (at)
    172. 

  172. freeReg 29 = fastBool False  -- global pointer (gp)
    173. 

  173. freeReg 30 = fastBool False  -- stack pointer (sp)
    174. 

  174. freeReg 31 = fastBool False  -- always zero (zeroh)
    175. 

  175. freeReg 63 = fastBool False  -- always zero (f31)
    176. 

  176. 

  177. #ifdef REG_Base
    178. 

  178. freeReg REG_Base = fastBool False
    179. 

  179. #endif
    180. 

  180. #ifdef REG_R1
    181. 

  181. freeReg REG_R1   = fastBool False
    182. 

  182. #endif	
    183. 

  183. #ifdef REG_R2  
    184. 

  184. freeReg REG_R2   = fastBool False
    185. 

  185. #endif	
    186. 

  186. #ifdef REG_R3  
    187. 

  187. freeReg REG_R3   = fastBool False
    188. 

  188. #endif	
    189. 

  189. #ifdef REG_R4  
    190. 

  190. freeReg REG_R4   = fastBool False
    191. 

  191. #endif	
    192. 

  192. #ifdef REG_R5  
    193. 

  193. freeReg REG_R5   = fastBool False
    194. 

  194. #endif	
    195. 

  195. #ifdef REG_R6  
    196. 

  196. freeReg REG_R6   = fastBool False
    197. 

  197. #endif	
    198. 

  198. #ifdef REG_R7  
    199. 

  199. freeReg REG_R7   = fastBool False
    200. 

  200. #endif	
    201. 

  201. #ifdef REG_R8  
    202. 

  202. freeReg REG_R8   = fastBool False
    203. 

  203. #endif
    204. 

  204. #ifdef REG_F1
    205. 

  205. freeReg REG_F1 = fastBool False
    206. 

  206. #endif
    207. 

  207. #ifdef REG_F2
    208. 

  208. freeReg REG_F2 = fastBool False
    209. 

  209. #endif
    210. 

  210. #ifdef REG_F3
    211. 

  211. freeReg REG_F3 = fastBool False
    212. 

  212. #endif
    213. 

  213. #ifdef REG_F4
    214. 

  214. freeReg REG_F4 = fastBool False
    215. 

  215. #endif
    216. 

  216. #ifdef REG_D1
    217. 

  217. freeReg REG_D1 = fastBool False
    218. 

  218. #endif
    219. 

  219. #ifdef REG_D2
    220. 

  220. freeReg REG_D2 = fastBool False
    221. 

  221. #endif
    222. 

  222. #ifdef REG_Sp 
    223. 

  223. freeReg REG_Sp   = fastBool False
    224. 

  224. #endif 
    225. 

  225. #ifdef REG_Su
    226. 

  226. freeReg REG_Su   = fastBool False
    227. 

  227. #endif 
    228. 

  228. #ifdef REG_SpLim 
    229. 

  229. freeReg REG_SpLim = fastBool False
    230. 

  230. #endif 
    231. 

  231. #ifdef REG_Hp 
    232. 

  232. freeReg REG_Hp   = fastBool False
    233. 

  233. #endif
    234. 

  234. #ifdef REG_HpLim
    235. 

  235. freeReg REG_HpLim = fastBool False
    236. 

  236. #endif
    237. 

  237. freeReg n               = fastBool True
    238. 

  238. 

  239. 

  240. --  | Returns 'Nothing' if this global register is not stored
    241. 

  241. -- in a real machine register, otherwise returns @'Just' reg@, where
    242. 

  242. -- reg is the machine register it is stored in.
    243. 

  243. 

  244. globalRegMaybe :: GlobalReg -> Maybe Reg
    245. 

  245. 

  246. #ifdef REG_Base
    247. 

  247. globalRegMaybe BaseReg			= Just (RealReg REG_Base)
    248. 

  248. #endif
    249. 

  249. #ifdef REG_R1
    250. 

  250. globalRegMaybe (VanillaReg 1 _)		= Just (RealReg REG_R1)
    251. 

  251. #endif 
    252. 

  252. #ifdef REG_R2 
    253. 

  253. globalRegMaybe (VanillaReg 2 _)		= Just (RealReg REG_R2)
    254. 

  254. #endif 
    255. 

  255. #ifdef REG_R3 
    256. 

  256. globalRegMaybe (VanillaReg 3 _) 	= Just (RealReg REG_R3)
    257. 

  257. #endif 
    258. 

  258. #ifdef REG_R4 
    259. 

  259. globalRegMaybe (VanillaReg 4 _)		= Just (RealReg REG_R4)
    260. 

  260. #endif 
    261. 

  261. #ifdef REG_R5 
    262. 

  262. globalRegMaybe (VanillaReg 5 _)		= Just (RealReg REG_R5)
    263. 

  263. #endif 
    264. 

  264. #ifdef REG_R6 
    265. 

  265. globalRegMaybe (VanillaReg 6 _)		= Just (RealReg REG_R6)
    266. 

  266. #endif 
    267. 

  267. #ifdef REG_R7 
    268. 

  268. globalRegMaybe (VanillaReg 7 _)		= Just (RealReg REG_R7)
    269. 

  269. #endif 
    270. 

  270. #ifdef REG_R8 
    271. 

  271. globalRegMaybe (VanillaReg 8 _)		= Just (RealReg REG_R8)
    272. 

  272. #endif
    273. 

  273. #ifdef REG_R9 
    274. 

  274. globalRegMaybe (VanillaReg 9 _)		= Just (RealReg REG_R9)
    275. 

  275. #endif
    276. 

  276. #ifdef REG_R10 
    277. 

  277. globalRegMaybe (VanillaReg 10 _)	= Just (RealReg REG_R10)
    278. 

  278. #endif
    279. 

  279. #ifdef REG_F1
    280. 

  280. globalRegMaybe (FloatReg 1)		= Just (RealReg REG_F1)
    281. 

  281. #endif				 	
    282. 

  282. #ifdef REG_F2			 	
    283. 

  283. globalRegMaybe (FloatReg 2)		= Just (RealReg REG_F2)
    284. 

  284. #endif				 	
    285. 

  285. #ifdef REG_F3			 	
    286. 

  286. globalRegMaybe (FloatReg 3)		= Just (RealReg REG_F3)
    287. 

  287. #endif				 	
    288. 

  288. #ifdef REG_F4			 	
    289. 

  289. globalRegMaybe (FloatReg 4)		= Just (RealReg REG_F4)
    290. 

  290. #endif				 	
    291. 

  291. #ifdef REG_D1			 	
    292. 

  292. globalRegMaybe (DoubleReg 1)		= Just (RealReg REG_D1)
    293. 

  293. #endif				 	
    294. 

  294. #ifdef REG_D2			 	
    295. 

  295. globalRegMaybe (DoubleReg 2)		= Just (RealReg REG_D2)
    296. 

  296. #endif
    297. 

  297. #ifdef REG_Sp	    
    298. 

  298. globalRegMaybe Sp		   	= Just (RealReg REG_Sp)
    299. 

  299. #endif
    300. 

  300. #ifdef REG_Lng1			 	
    301. 

  301. globalRegMaybe (LongReg 1)		= Just (RealReg REG_Lng1)
    302. 

  302. #endif				 	
    303. 

  303. #ifdef REG_Lng2			 	
    304. 

  304. globalRegMaybe (LongReg 2)		= Just (RealReg REG_Lng2)
    305. 

  305. #endif
    306. 

  306. #ifdef REG_SpLim	    			
    307. 

  307. globalRegMaybe SpLim		   	= Just (RealReg REG_SpLim)
    308. 

  308. #endif	    				
    309. 

  309. #ifdef REG_Hp	   			
    310. 

  310. globalRegMaybe Hp		   	= Just (RealReg REG_Hp)
    311. 

  311. #endif	    				
    312. 

  312. #ifdef REG_HpLim      			
    313. 

  313. globalRegMaybe HpLim		   	= Just (RealReg REG_HpLim)
    314. 

  314. #endif	    				
    315. 

  315. #ifdef REG_CurrentTSO      			
    316. 

  316. globalRegMaybe CurrentTSO	   	= Just (RealReg REG_CurrentTSO)
    317. 

  317. #endif	    				
    318. 

  318. #ifdef REG_CurrentNursery      			
    319. 

  319. globalRegMaybe CurrentNursery	   	= Just (RealReg REG_CurrentNursery)
    320. 

  320. #endif	    				
    321. 

  321. globalRegMaybe _		   	= Nothing
    322. 

  322. 

  323. -}
    324.