isDataTyCon should be False for all type families, even data type families
[ghc-hetmet.git] / compiler / codeGen / SMRep.lhs
1 %
2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 %
5
6 Storage manager representation of closures
7
8 This is here, rather than in ClosureInfo, just to keep nhc happy.
9 Other modules should access this info through ClosureInfo.
10
11 \begin{code}
12 module SMRep (
13         -- Words and bytes
14         StgWord, StgHalfWord, 
15         hALF_WORD_SIZE, hALF_WORD_SIZE_IN_BITS,
16         WordOff, ByteOff,
17
18         -- Argument/return representations
19         CgRep(..), nonVoidArg,
20         argMachRep, primRepToCgRep, primRepHint,
21         isFollowableArg, isVoidArg, 
22         isFloatingArg, isNonPtrArg, is64BitArg,
23         separateByPtrFollowness,
24         cgRepSizeW, cgRepSizeB,
25         retAddrSizeW,
26
27         typeCgRep, idCgRep, tyConCgRep, typeHint,
28
29         -- Closure repesentation
30         SMRep(..), ClosureType(..),
31         isStaticRep,
32         fixedHdrSize, arrWordsHdrSize, arrPtrsHdrSize,
33         profHdrSize, thunkHdrSize,
34         smRepClosureType, smRepClosureTypeInt,
35
36         rET_SMALL, rET_BIG
37     ) where
38
39 #include "HsVersions.h"
40 #include "../includes/MachDeps.h"
41
42 import Id
43 import Type
44 import TyCon
45 import MachOp
46 import StaticFlags
47 import Constants
48 import Outputable
49
50 import Data.Word
51 \end{code}
52
53
54 %************************************************************************
55 %*                                                                      *
56                 Words and bytes
57 %*                                                                      *
58 %************************************************************************
59
60 \begin{code}
61 type WordOff = Int      -- Word offset, or word count
62 type ByteOff = Int      -- Byte offset, or byte count
63 \end{code}
64
65 StgWord is a type representing an StgWord on the target platform.
66
67 \begin{code}
68 #if SIZEOF_HSWORD == 4
69 type StgWord     = Word32
70 type StgHalfWord = Word16
71 hALF_WORD_SIZE = 2 :: ByteOff
72 hALF_WORD_SIZE_IN_BITS = 16 :: Int
73 #elif SIZEOF_HSWORD == 8
74 type StgWord     = Word64
75 type StgHalfWord = Word32
76 hALF_WORD_SIZE = 4 :: ByteOff
77 hALF_WORD_SIZE_IN_BITS = 32 :: Int
78 #else
79 #error unknown SIZEOF_HSWORD
80 #endif
81 \end{code}
82
83
84 %************************************************************************
85 %*                                                                      *
86                         CgRep
87 %*                                                                      *
88 %************************************************************************
89
90 An CgRep is an abstraction of a Type which tells the code generator
91 all it needs to know about the calling convention for arguments (and
92 results) of that type.  In particular, the ArgReps of a function's
93 arguments are used to decide which of the RTS's generic apply
94 functions to call when applying an unknown function.
95
96 It contains more information than the back-end data type MachRep,
97 so one can easily convert from CgRep -> MachRep.  (Except that
98 there's no MachRep for a VoidRep.)
99
100 It distinguishes 
101         pointers from non-pointers (we sort the pointers together
102         when building closures)
103
104         void from other types: a void argument is different from no argument
105
106 All 64-bit types map to the same CgRep, because they're passed in the
107 same register, but a PtrArg is still different from an NonPtrArg
108 because the function's entry convention has to take into account the
109 pointer-hood of arguments for the purposes of describing the stack on
110 entry to the garbage collector.
111
112 \begin{code}
113 data CgRep 
114   = VoidArg     -- Void
115   | PtrArg      -- Word-sized Ptr
116   | NonPtrArg   -- Word-sized non-pointer
117   | LongArg     -- 64-bit non-pointer
118   | FloatArg    -- 32-bit float
119   | DoubleArg   -- 64-bit float
120   deriving Eq
121
122 instance Outputable CgRep where
123     ppr VoidArg   = ptext SLIT("V_")
124     ppr PtrArg    = ptext SLIT("P_")
125     ppr NonPtrArg = ptext SLIT("I_")
126     ppr LongArg   = ptext SLIT("L_")
127     ppr FloatArg  = ptext SLIT("F_")
128     ppr DoubleArg = ptext SLIT("D_")
129
130 argMachRep :: CgRep -> MachRep
131 argMachRep PtrArg    = wordRep
132 argMachRep NonPtrArg = wordRep
133 argMachRep LongArg   = I64
134 argMachRep FloatArg  = F32
135 argMachRep DoubleArg = F64
136 argMachRep VoidArg   = panic "argMachRep:VoidRep"
137
138 primRepToCgRep :: PrimRep -> CgRep
139 primRepToCgRep VoidRep    = VoidArg
140 primRepToCgRep PtrRep     = PtrArg
141 primRepToCgRep IntRep     = NonPtrArg
142 primRepToCgRep WordRep    = NonPtrArg
143 primRepToCgRep Int64Rep   = LongArg
144 primRepToCgRep Word64Rep  = LongArg
145 primRepToCgRep AddrRep    = NonPtrArg
146 primRepToCgRep FloatRep   = FloatArg
147 primRepToCgRep DoubleRep  = DoubleArg
148
149 primRepHint :: PrimRep -> MachHint
150 primRepHint VoidRep     = panic "primRepHint:VoidRep"
151 primRepHint PtrRep      = PtrHint
152 primRepHint IntRep      = SignedHint
153 primRepHint WordRep     = NoHint
154 primRepHint Int64Rep    = SignedHint
155 primRepHint Word64Rep   = NoHint
156 primRepHint AddrRep     = PtrHint -- NB! PtrHint, but NonPtrArg
157 primRepHint FloatRep    = FloatHint
158 primRepHint DoubleRep   = FloatHint
159
160 idCgRep :: Id -> CgRep
161 idCgRep x = typeCgRep . idType $ x
162
163 tyConCgRep :: TyCon -> CgRep
164 tyConCgRep = primRepToCgRep . tyConPrimRep
165
166 typeCgRep :: Type -> CgRep
167 typeCgRep = primRepToCgRep . typePrimRep 
168
169 typeHint :: Type -> MachHint
170 typeHint = primRepHint . typePrimRep
171 \end{code}
172
173 Whether or not the thing is a pointer that the garbage-collector
174 should follow. Or, to put it another (less confusing) way, whether
175 the object in question is a heap object. 
176
177 Depending on the outcome, this predicate determines what stack
178 the pointer/object possibly will have to be saved onto, and the
179 computation of GC liveness info.
180
181 \begin{code}
182 isFollowableArg :: CgRep -> Bool  -- True <=> points to a heap object
183 isFollowableArg PtrArg  = True
184 isFollowableArg other = False
185
186 isVoidArg :: CgRep -> Bool
187 isVoidArg VoidArg = True
188 isVoidArg other   = False
189
190 nonVoidArg :: CgRep -> Bool
191 nonVoidArg VoidArg = False
192 nonVoidArg other   = True
193
194 -- isFloatingArg is used to distinguish @Double@ and @Float@ which
195 -- cause inadvertent numeric conversions if you aren't jolly careful.
196 -- See codeGen/CgCon:cgTopRhsCon.
197
198 isFloatingArg :: CgRep -> Bool
199 isFloatingArg DoubleArg = True
200 isFloatingArg FloatArg  = True
201 isFloatingArg _         = False
202
203 isNonPtrArg :: CgRep -> Bool
204 -- Identify anything which is one word large and not a pointer.
205 isNonPtrArg NonPtrArg = True
206 isNonPtrArg other     = False
207
208 is64BitArg :: CgRep -> Bool
209 is64BitArg LongArg = True
210 is64BitArg _       = False
211 \end{code}
212
213 \begin{code}
214 separateByPtrFollowness :: [(CgRep,a)] -> ([(CgRep,a)], [(CgRep,a)])
215 -- Returns (ptrs, non-ptrs)
216 separateByPtrFollowness things
217   = sep_things things [] []
218     -- accumulating params for follow-able and don't-follow things...
219   where
220     sep_things []              bs us = (reverse bs, reverse us)
221     sep_things ((PtrArg,a):ts) bs us = sep_things ts ((PtrArg,a):bs) us
222     sep_things (t         :ts) bs us = sep_things ts bs              (t:us)
223 \end{code}
224
225 \begin{code}
226 cgRepSizeB :: CgRep -> ByteOff
227 cgRepSizeB DoubleArg = dOUBLE_SIZE
228 cgRepSizeB LongArg   = wORD64_SIZE
229 cgRepSizeB VoidArg   = 0
230 cgRepSizeB _         = wORD_SIZE
231
232 cgRepSizeW :: CgRep -> ByteOff
233 cgRepSizeW DoubleArg = dOUBLE_SIZE `quot` wORD_SIZE
234 cgRepSizeW LongArg   = wORD64_SIZE `quot` wORD_SIZE
235 cgRepSizeW VoidArg   = 0
236 cgRepSizeW _         = 1
237
238 retAddrSizeW :: WordOff
239 retAddrSizeW = 1        -- One word
240 \end{code}
241
242 %************************************************************************
243 %*                                                                      *
244 \subsubsection[SMRep-datatype]{@SMRep@---storage manager representation}
245 %*                                                                      *
246 %************************************************************************
247
248 \begin{code}
249 data SMRep
250      -- static closure have an extra static link field at the end.
251   = GenericRep          -- GC routines consult sizes in info tbl
252         Bool            -- True <=> This is a static closure.  Affects how 
253                         --          we garbage-collect it
254         !Int            --  # ptr words
255         !Int            --  # non-ptr words
256         ClosureType     -- closure type
257
258   | BlackHoleRep
259
260 data ClosureType        -- Corresponds 1-1 with the varieties of closures
261                         -- implemented by the RTS.  Compare with ghc/includes/ClosureTypes.h
262     = Constr
263     | ConstrNoCaf
264     | Fun
265     | Thunk
266     | ThunkSelector
267 \end{code}
268
269 Size of a closure header.
270
271 \begin{code}
272 fixedHdrSize :: WordOff
273 fixedHdrSize = sTD_HDR_SIZE + profHdrSize + granHdrSize
274
275 profHdrSize  :: WordOff
276 profHdrSize  | opt_SccProfilingOn   = pROF_HDR_SIZE
277              | otherwise            = 0
278
279 granHdrSize  :: WordOff
280 granHdrSize  | opt_GranMacros       = gRAN_HDR_SIZE
281              | otherwise            = 0
282
283 arrWordsHdrSize   :: ByteOff
284 arrWordsHdrSize   = fixedHdrSize*wORD_SIZE + sIZEOF_StgArrWords_NoHdr
285
286 arrPtrsHdrSize    :: ByteOff
287 arrPtrsHdrSize    = fixedHdrSize*wORD_SIZE + sIZEOF_StgMutArrPtrs_NoHdr
288
289 -- Thunks have an extra header word on SMP, so the update doesn't 
290 -- splat the payload.
291 thunkHdrSize :: WordOff
292 thunkHdrSize = fixedHdrSize + smp_hdr
293         where smp_hdr = sIZEOF_StgSMPThunkHeader `quot` wORD_SIZE
294 \end{code}
295
296 \begin{code}
297 isStaticRep :: SMRep -> Bool
298 isStaticRep (GenericRep is_static _ _ _) = is_static
299 isStaticRep BlackHoleRep                 = False
300 \end{code}
301
302 \begin{code}
303 #include "../includes/ClosureTypes.h"
304 -- Defines CONSTR, CONSTR_1_0 etc
305
306 -- krc: only called by tickyDynAlloc in CgTicky; return
307 -- Nothing for a black hole so we can at least make something work.
308 smRepClosureType :: SMRep -> Maybe ClosureType
309 smRepClosureType (GenericRep _ _ _ ty) = Just ty
310 smRepClosureType BlackHoleRep          = Nothing
311
312 smRepClosureTypeInt :: SMRep -> Int
313 smRepClosureTypeInt (GenericRep False 1 0 Constr) = CONSTR_1_0
314 smRepClosureTypeInt (GenericRep False 0 1 Constr) = CONSTR_0_1
315 smRepClosureTypeInt (GenericRep False 2 0 Constr) = CONSTR_2_0
316 smRepClosureTypeInt (GenericRep False 1 1 Constr) = CONSTR_1_1
317 smRepClosureTypeInt (GenericRep False 0 2 Constr) = CONSTR_0_2
318 smRepClosureTypeInt (GenericRep False _ _ Constr) = CONSTR
319
320 smRepClosureTypeInt (GenericRep False 1 0 Fun) = FUN_1_0
321 smRepClosureTypeInt (GenericRep False 0 1 Fun) = FUN_0_1
322 smRepClosureTypeInt (GenericRep False 2 0 Fun) = FUN_2_0
323 smRepClosureTypeInt (GenericRep False 1 1 Fun) = FUN_1_1
324 smRepClosureTypeInt (GenericRep False 0 2 Fun) = FUN_0_2
325 smRepClosureTypeInt (GenericRep False _ _ Fun) = FUN
326
327 smRepClosureTypeInt (GenericRep False 1 0 Thunk) = THUNK_1_0
328 smRepClosureTypeInt (GenericRep False 0 1 Thunk) = THUNK_0_1
329 smRepClosureTypeInt (GenericRep False 2 0 Thunk) = THUNK_2_0
330 smRepClosureTypeInt (GenericRep False 1 1 Thunk) = THUNK_1_1
331 smRepClosureTypeInt (GenericRep False 0 2 Thunk) = THUNK_0_2
332 smRepClosureTypeInt (GenericRep False _ _ Thunk) = THUNK
333
334 smRepClosureTypeInt (GenericRep False _ _ ThunkSelector) =  THUNK_SELECTOR
335
336 smRepClosureTypeInt (GenericRep True _ _ Constr)      = CONSTR_STATIC
337 smRepClosureTypeInt (GenericRep True _ _ ConstrNoCaf) = CONSTR_NOCAF_STATIC
338 smRepClosureTypeInt (GenericRep True _ _ Fun)         = FUN_STATIC
339 smRepClosureTypeInt (GenericRep True _ _ Thunk)       = THUNK_STATIC
340
341 smRepClosureTypeInt BlackHoleRep = BLACKHOLE
342
343 smRepClosureTypeInt rep = panic "smRepClosuretypeint"
344
345
346 -- We export these ones
347 rET_SMALL     = (RET_SMALL     :: Int)
348 rET_BIG       = (RET_BIG       :: Int)
349 \end{code}
350