2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
6 Storage manager representation of closures
8 This is here, rather than in ClosureInfo, just to keep nhc happy.
9 Other modules should access this info through ClosureInfo.
13 -- The above warning supression flag is a temporary kludge.
14 -- While working on this module you are encouraged to remove it and fix
15 -- any warnings in the module. See
16 -- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
22 hALF_WORD_SIZE, hALF_WORD_SIZE_IN_BITS,
25 -- Argument/return representations
26 CgRep(..), nonVoidArg,
27 argMachRep, primRepToCgRep, primRepHint,
28 isFollowableArg, isVoidArg,
29 isFloatingArg, is64BitArg,
30 separateByPtrFollowness,
31 cgRepSizeW, cgRepSizeB,
34 typeCgRep, idCgRep, tyConCgRep, typeHint,
36 -- Closure repesentation
37 SMRep(..), ClosureType(..),
39 fixedHdrSize, arrWordsHdrSize, arrPtrsHdrSize,
40 profHdrSize, thunkHdrSize,
41 smRepClosureType, smRepClosureTypeInt,
46 #include "HsVersions.h"
47 #include "../includes/MachDeps.h"
62 %************************************************************************
66 %************************************************************************
69 type WordOff = Int -- Word offset, or word count
70 type ByteOff = Int -- Byte offset, or byte count
73 StgWord is a type representing an StgWord on the target platform.
76 #if SIZEOF_HSWORD == 4
78 type StgHalfWord = Word16
79 hALF_WORD_SIZE = 2 :: ByteOff
80 hALF_WORD_SIZE_IN_BITS = 16 :: Int
81 #elif SIZEOF_HSWORD == 8
83 type StgHalfWord = Word32
84 hALF_WORD_SIZE = 4 :: ByteOff
85 hALF_WORD_SIZE_IN_BITS = 32 :: Int
87 #error unknown SIZEOF_HSWORD
92 %************************************************************************
96 %************************************************************************
98 An CgRep is an abstraction of a Type which tells the code generator
99 all it needs to know about the calling convention for arguments (and
100 results) of that type. In particular, the ArgReps of a function's
101 arguments are used to decide which of the RTS's generic apply
102 functions to call when applying an unknown function.
104 It contains more information than the back-end data type MachRep,
105 so one can easily convert from CgRep -> MachRep. (Except that
106 there's no MachRep for a VoidRep.)
109 pointers from non-pointers (we sort the pointers together
110 when building closures)
112 void from other types: a void argument is different from no argument
114 All 64-bit types map to the same CgRep, because they're passed in the
115 same register, but a PtrArg is still different from an NonPtrArg
116 because the function's entry convention has to take into account the
117 pointer-hood of arguments for the purposes of describing the stack on
118 entry to the garbage collector.
123 | PtrArg -- Word-sized heap pointer, followed
124 -- by the garbage collector
125 | NonPtrArg -- Word-sized non-pointer
126 -- (including addresses not followed by GC)
127 | LongArg -- 64-bit non-pointer
128 | FloatArg -- 32-bit float
129 | DoubleArg -- 64-bit float
132 instance Outputable CgRep where
133 ppr VoidArg = ptext SLIT("V_")
134 ppr PtrArg = ptext SLIT("P_")
135 ppr NonPtrArg = ptext SLIT("I_")
136 ppr LongArg = ptext SLIT("L_")
137 ppr FloatArg = ptext SLIT("F_")
138 ppr DoubleArg = ptext SLIT("D_")
140 argMachRep :: CgRep -> MachRep
141 argMachRep PtrArg = wordRep
142 argMachRep NonPtrArg = wordRep
143 argMachRep LongArg = I64
144 argMachRep FloatArg = F32
145 argMachRep DoubleArg = F64
146 argMachRep VoidArg = panic "argMachRep:VoidRep"
148 primRepToCgRep :: PrimRep -> CgRep
149 primRepToCgRep VoidRep = VoidArg
150 primRepToCgRep PtrRep = PtrArg
151 primRepToCgRep IntRep = NonPtrArg
152 primRepToCgRep WordRep = NonPtrArg
153 primRepToCgRep Int64Rep = LongArg
154 primRepToCgRep Word64Rep = LongArg
155 primRepToCgRep AddrRep = NonPtrArg
156 primRepToCgRep FloatRep = FloatArg
157 primRepToCgRep DoubleRep = DoubleArg
159 primRepHint :: PrimRep -> MachHint
160 primRepHint VoidRep = panic "primRepHint:VoidRep"
161 primRepHint PtrRep = PtrHint
162 primRepHint IntRep = SignedHint
163 primRepHint WordRep = NoHint
164 primRepHint Int64Rep = SignedHint
165 primRepHint Word64Rep = NoHint
166 primRepHint AddrRep = PtrHint -- NB! PtrHint, but NonPtrArg
167 primRepHint FloatRep = FloatHint
168 primRepHint DoubleRep = FloatHint
170 idCgRep :: Id -> CgRep
171 idCgRep x = typeCgRep . idType $ x
173 tyConCgRep :: TyCon -> CgRep
174 tyConCgRep = primRepToCgRep . tyConPrimRep
176 typeCgRep :: Type -> CgRep
177 typeCgRep = primRepToCgRep . typePrimRep
179 typeHint :: Type -> MachHint
180 typeHint = primRepHint . typePrimRep
183 Whether or not the thing is a pointer that the garbage-collector
184 should follow. Or, to put it another (less confusing) way, whether
185 the object in question is a heap object.
187 Depending on the outcome, this predicate determines what stack
188 the pointer/object possibly will have to be saved onto, and the
189 computation of GC liveness info.
192 isFollowableArg :: CgRep -> Bool -- True <=> points to a heap object
193 isFollowableArg PtrArg = True
194 isFollowableArg other = False
196 isVoidArg :: CgRep -> Bool
197 isVoidArg VoidArg = True
198 isVoidArg other = False
200 nonVoidArg :: CgRep -> Bool
201 nonVoidArg VoidArg = False
202 nonVoidArg other = True
204 -- isFloatingArg is used to distinguish @Double@ and @Float@ which
205 -- cause inadvertent numeric conversions if you aren't jolly careful.
206 -- See codeGen/CgCon:cgTopRhsCon.
208 isFloatingArg :: CgRep -> Bool
209 isFloatingArg DoubleArg = True
210 isFloatingArg FloatArg = True
211 isFloatingArg _ = False
213 is64BitArg :: CgRep -> Bool
214 is64BitArg LongArg = True
219 separateByPtrFollowness :: [(CgRep,a)] -> ([(CgRep,a)], [(CgRep,a)])
220 -- Returns (ptrs, non-ptrs)
221 separateByPtrFollowness things
222 = sep_things things [] []
223 -- accumulating params for follow-able and don't-follow things...
225 sep_things [] bs us = (reverse bs, reverse us)
226 sep_things ((PtrArg,a):ts) bs us = sep_things ts ((PtrArg,a):bs) us
227 sep_things (t :ts) bs us = sep_things ts bs (t:us)
231 cgRepSizeB :: CgRep -> ByteOff
232 cgRepSizeB DoubleArg = dOUBLE_SIZE
233 cgRepSizeB LongArg = wORD64_SIZE
234 cgRepSizeB VoidArg = 0
235 cgRepSizeB _ = wORD_SIZE
237 cgRepSizeW :: CgRep -> ByteOff
238 cgRepSizeW DoubleArg = dOUBLE_SIZE `quot` wORD_SIZE
239 cgRepSizeW LongArg = wORD64_SIZE `quot` wORD_SIZE
240 cgRepSizeW VoidArg = 0
243 retAddrSizeW :: WordOff
244 retAddrSizeW = 1 -- One word
247 %************************************************************************
249 \subsubsection[SMRep-datatype]{@SMRep@---storage manager representation}
251 %************************************************************************
255 -- static closure have an extra static link field at the end.
256 = GenericRep -- GC routines consult sizes in info tbl
257 Bool -- True <=> This is a static closure. Affects how
258 -- we garbage-collect it
260 !Int -- # non-ptr words
261 ClosureType -- closure type
265 data ClosureType -- Corresponds 1-1 with the varieties of closures
266 -- implemented by the RTS. Compare with ghc/includes/ClosureTypes.h
274 Size of a closure header.
277 fixedHdrSize :: WordOff
278 fixedHdrSize = sTD_HDR_SIZE + profHdrSize + granHdrSize
280 profHdrSize :: WordOff
281 profHdrSize | opt_SccProfilingOn = pROF_HDR_SIZE
284 granHdrSize :: WordOff
285 granHdrSize | opt_GranMacros = gRAN_HDR_SIZE
288 arrWordsHdrSize :: ByteOff
289 arrWordsHdrSize = fixedHdrSize*wORD_SIZE + sIZEOF_StgArrWords_NoHdr
291 arrPtrsHdrSize :: ByteOff
292 arrPtrsHdrSize = fixedHdrSize*wORD_SIZE + sIZEOF_StgMutArrPtrs_NoHdr
294 -- Thunks have an extra header word on SMP, so the update doesn't
295 -- splat the payload.
296 thunkHdrSize :: WordOff
297 thunkHdrSize = fixedHdrSize + smp_hdr
298 where smp_hdr = sIZEOF_StgSMPThunkHeader `quot` wORD_SIZE
302 isStaticRep :: SMRep -> Bool
303 isStaticRep (GenericRep is_static _ _ _) = is_static
304 isStaticRep BlackHoleRep = False
308 #include "../includes/ClosureTypes.h"
309 -- Defines CONSTR, CONSTR_1_0 etc
311 -- krc: only called by tickyDynAlloc in CgTicky; return
312 -- Nothing for a black hole so we can at least make something work.
313 smRepClosureType :: SMRep -> Maybe ClosureType
314 smRepClosureType (GenericRep _ _ _ ty) = Just ty
315 smRepClosureType BlackHoleRep = Nothing
317 smRepClosureTypeInt :: SMRep -> StgHalfWord
318 smRepClosureTypeInt (GenericRep False 1 0 Constr) = CONSTR_1_0
319 smRepClosureTypeInt (GenericRep False 0 1 Constr) = CONSTR_0_1
320 smRepClosureTypeInt (GenericRep False 2 0 Constr) = CONSTR_2_0
321 smRepClosureTypeInt (GenericRep False 1 1 Constr) = CONSTR_1_1
322 smRepClosureTypeInt (GenericRep False 0 2 Constr) = CONSTR_0_2
323 smRepClosureTypeInt (GenericRep False _ _ Constr) = CONSTR
325 smRepClosureTypeInt (GenericRep False 1 0 Fun) = FUN_1_0
326 smRepClosureTypeInt (GenericRep False 0 1 Fun) = FUN_0_1
327 smRepClosureTypeInt (GenericRep False 2 0 Fun) = FUN_2_0
328 smRepClosureTypeInt (GenericRep False 1 1 Fun) = FUN_1_1
329 smRepClosureTypeInt (GenericRep False 0 2 Fun) = FUN_0_2
330 smRepClosureTypeInt (GenericRep False _ _ Fun) = FUN
332 smRepClosureTypeInt (GenericRep False 1 0 Thunk) = THUNK_1_0
333 smRepClosureTypeInt (GenericRep False 0 1 Thunk) = THUNK_0_1
334 smRepClosureTypeInt (GenericRep False 2 0 Thunk) = THUNK_2_0
335 smRepClosureTypeInt (GenericRep False 1 1 Thunk) = THUNK_1_1
336 smRepClosureTypeInt (GenericRep False 0 2 Thunk) = THUNK_0_2
337 smRepClosureTypeInt (GenericRep False _ _ Thunk) = THUNK
339 smRepClosureTypeInt (GenericRep False _ _ ThunkSelector) = THUNK_SELECTOR
341 smRepClosureTypeInt (GenericRep True _ _ Constr) = CONSTR_STATIC
342 smRepClosureTypeInt (GenericRep True _ _ ConstrNoCaf) = CONSTR_NOCAF_STATIC
343 smRepClosureTypeInt (GenericRep True _ _ Fun) = FUN_STATIC
344 smRepClosureTypeInt (GenericRep True _ _ Thunk) = THUNK_STATIC
346 smRepClosureTypeInt BlackHoleRep = BLACKHOLE
348 smRepClosureTypeInt rep = panic "smRepClosuretypeint"
351 -- We export these ones
352 rET_SMALL = (RET_SMALL :: StgHalfWord)
353 rET_BIG = (RET_BIG :: StgHalfWord)