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,
28 -- Temp primRepHint, typeHint,
29 isFollowableArg, isVoidArg,
30 isFloatingArg, is64BitArg,
31 separateByPtrFollowness,
32 cgRepSizeW, cgRepSizeB,
35 typeCgRep, idCgRep, tyConCgRep,
37 -- Closure repesentation
38 SMRep(..), ClosureType(..),
40 fixedHdrSize, arrWordsHdrSize, arrPtrsHdrSize,
41 profHdrSize, thunkHdrSize,
42 smRepClosureType, smRepClosureTypeInt,
47 #include "../includes/MachDeps.h"
49 import CmmExpr -- CmmType and friends
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 -> CmmType
141 argMachRep PtrArg = gcWord
142 argMachRep NonPtrArg = bWord
143 argMachRep LongArg = b64
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 idCgRep :: Id -> CgRep
160 idCgRep x = typeCgRep . idType $ x
162 tyConCgRep :: TyCon -> CgRep
163 tyConCgRep = primRepToCgRep . tyConPrimRep
165 typeCgRep :: Type -> CgRep
166 typeCgRep = primRepToCgRep . typePrimRep
169 Whether or not the thing is a pointer that the garbage-collector
170 should follow. Or, to put it another (less confusing) way, whether
171 the object in question is a heap object.
173 Depending on the outcome, this predicate determines what stack
174 the pointer/object possibly will have to be saved onto, and the
175 computation of GC liveness info.
178 isFollowableArg :: CgRep -> Bool -- True <=> points to a heap object
179 isFollowableArg PtrArg = True
180 isFollowableArg other = False
182 isVoidArg :: CgRep -> Bool
183 isVoidArg VoidArg = True
184 isVoidArg other = False
186 nonVoidArg :: CgRep -> Bool
187 nonVoidArg VoidArg = False
188 nonVoidArg other = True
190 -- isFloatingArg is used to distinguish @Double@ and @Float@ which
191 -- cause inadvertent numeric conversions if you aren't jolly careful.
192 -- See codeGen/CgCon:cgTopRhsCon.
194 isFloatingArg :: CgRep -> Bool
195 isFloatingArg DoubleArg = True
196 isFloatingArg FloatArg = True
197 isFloatingArg _ = False
199 is64BitArg :: CgRep -> Bool
200 is64BitArg LongArg = True
205 separateByPtrFollowness :: [(CgRep,a)] -> ([(CgRep,a)], [(CgRep,a)])
206 -- Returns (ptrs, non-ptrs)
207 separateByPtrFollowness things
208 = sep_things things [] []
209 -- accumulating params for follow-able and don't-follow things...
211 sep_things [] bs us = (reverse bs, reverse us)
212 sep_things ((PtrArg,a):ts) bs us = sep_things ts ((PtrArg,a):bs) us
213 sep_things (t :ts) bs us = sep_things ts bs (t:us)
217 cgRepSizeB :: CgRep -> ByteOff
218 cgRepSizeB DoubleArg = dOUBLE_SIZE
219 cgRepSizeB LongArg = wORD64_SIZE
220 cgRepSizeB VoidArg = 0
221 cgRepSizeB _ = wORD_SIZE
223 cgRepSizeW :: CgRep -> ByteOff
224 cgRepSizeW DoubleArg = dOUBLE_SIZE `quot` wORD_SIZE
225 cgRepSizeW LongArg = wORD64_SIZE `quot` wORD_SIZE
226 cgRepSizeW VoidArg = 0
229 retAddrSizeW :: WordOff
230 retAddrSizeW = 1 -- One word
233 %************************************************************************
235 \subsubsection[SMRep-datatype]{@SMRep@---storage manager representation}
237 %************************************************************************
241 -- static closure have an extra static link field at the end.
242 = GenericRep -- GC routines consult sizes in info tbl
243 Bool -- True <=> This is a static closure. Affects how
244 -- we garbage-collect it
246 !Int -- # non-ptr words
247 ClosureType -- closure type
251 data ClosureType -- Corresponds 1-1 with the varieties of closures
252 -- implemented by the RTS. Compare with ghc/includes/ClosureTypes.h
260 Size of a closure header.
263 fixedHdrSize :: WordOff
264 fixedHdrSize = sTD_HDR_SIZE + profHdrSize + granHdrSize
266 profHdrSize :: WordOff
267 profHdrSize | opt_SccProfilingOn = pROF_HDR_SIZE
270 granHdrSize :: WordOff
271 granHdrSize | opt_GranMacros = gRAN_HDR_SIZE
274 arrWordsHdrSize :: ByteOff
275 arrWordsHdrSize = fixedHdrSize*wORD_SIZE + sIZEOF_StgArrWords_NoHdr
277 arrPtrsHdrSize :: ByteOff
278 arrPtrsHdrSize = fixedHdrSize*wORD_SIZE + sIZEOF_StgMutArrPtrs_NoHdr
280 -- Thunks have an extra header word on SMP, so the update doesn't
281 -- splat the payload.
282 thunkHdrSize :: WordOff
283 thunkHdrSize = fixedHdrSize + smp_hdr
284 where smp_hdr = sIZEOF_StgSMPThunkHeader `quot` wORD_SIZE
288 isStaticRep :: SMRep -> Bool
289 isStaticRep (GenericRep is_static _ _ _) = is_static
290 isStaticRep BlackHoleRep = False
294 #include "../includes/ClosureTypes.h"
295 -- Defines CONSTR, CONSTR_1_0 etc
297 -- krc: only called by tickyDynAlloc in CgTicky; return
298 -- Nothing for a black hole so we can at least make something work.
299 smRepClosureType :: SMRep -> Maybe ClosureType
300 smRepClosureType (GenericRep _ _ _ ty) = Just ty
301 smRepClosureType BlackHoleRep = Nothing
303 smRepClosureTypeInt :: SMRep -> StgHalfWord
304 smRepClosureTypeInt (GenericRep False 1 0 Constr) = CONSTR_1_0
305 smRepClosureTypeInt (GenericRep False 0 1 Constr) = CONSTR_0_1
306 smRepClosureTypeInt (GenericRep False 2 0 Constr) = CONSTR_2_0
307 smRepClosureTypeInt (GenericRep False 1 1 Constr) = CONSTR_1_1
308 smRepClosureTypeInt (GenericRep False 0 2 Constr) = CONSTR_0_2
309 smRepClosureTypeInt (GenericRep False _ _ Constr) = CONSTR
311 smRepClosureTypeInt (GenericRep False 1 0 Fun) = FUN_1_0
312 smRepClosureTypeInt (GenericRep False 0 1 Fun) = FUN_0_1
313 smRepClosureTypeInt (GenericRep False 2 0 Fun) = FUN_2_0
314 smRepClosureTypeInt (GenericRep False 1 1 Fun) = FUN_1_1
315 smRepClosureTypeInt (GenericRep False 0 2 Fun) = FUN_0_2
316 smRepClosureTypeInt (GenericRep False _ _ Fun) = FUN
318 smRepClosureTypeInt (GenericRep False 1 0 Thunk) = THUNK_1_0
319 smRepClosureTypeInt (GenericRep False 0 1 Thunk) = THUNK_0_1
320 smRepClosureTypeInt (GenericRep False 2 0 Thunk) = THUNK_2_0
321 smRepClosureTypeInt (GenericRep False 1 1 Thunk) = THUNK_1_1
322 smRepClosureTypeInt (GenericRep False 0 2 Thunk) = THUNK_0_2
323 smRepClosureTypeInt (GenericRep False _ _ Thunk) = THUNK
325 smRepClosureTypeInt (GenericRep False _ _ ThunkSelector) = THUNK_SELECTOR
327 smRepClosureTypeInt (GenericRep True _ _ Constr) = CONSTR_STATIC
328 smRepClosureTypeInt (GenericRep True _ _ ConstrNoCaf) = CONSTR_NOCAF_STATIC
329 smRepClosureTypeInt (GenericRep True _ _ Fun) = FUN_STATIC
330 smRepClosureTypeInt (GenericRep True _ _ Thunk) = THUNK_STATIC
332 smRepClosureTypeInt BlackHoleRep = BLACKHOLE
334 smRepClosureTypeInt rep = panic "smRepClosuretypeint"
337 -- We export these ones
338 rET_SMALL = (RET_SMALL :: StgHalfWord)
339 rET_BIG = (RET_BIG :: StgHalfWord)