1 /* ----------------------------------------------------------------------------
2 * $Id: ClosureMacros.h,v 1.19 1999/08/03 15:44:21 simonmar Exp $
4 * (c) The GHC Team, 1998-1999
6 * Macros for building and manipulating closures
8 * -------------------------------------------------------------------------- */
10 #ifndef CLOSUREMACROS_H
11 #define CLOSUREMACROS_H
13 /* -----------------------------------------------------------------------------
16 The compiler tries to abstract away from the actual value of this
18 -------------------------------------------------------------------------- */
20 #define _FHS sizeof(StgHeader)
22 /* -----------------------------------------------------------------------------
23 Info tables are slammed up against the entry code, and the label
24 for the info table is at the *end* of the table itself. This
25 inline function adjusts an info pointer to point to the beginning
26 of the table, so we can use standard C structure indexing on it.
28 Note: this works for SRT info tables as long as you don't want to
29 access the SRT, since they are laid out the same with the SRT
30 pointer as the first word in the table.
32 NOTES ABOUT MANGLED C VS. MINI-INTERPRETER:
34 A couple of definitions:
36 "info pointer" The first word of the closure. Might point
37 to either the end or the beginning of the
38 info table, depending on whether we're using
39 the mini interpretter or not. GET_INFO(c)
40 retrieves the info pointer of a closure.
42 "info table" The info table structure associated with a
43 closure. This is always a pointer to the
44 beginning of the structure, so we can
45 use standard C structure indexing to pull out
46 the fields. get_itbl(c) returns a pointer to
47 the info table for closure c.
49 An address of the form xxxx_info points to the end of the info
50 table or the beginning of the info table depending on whether we're
51 mangling or not respectively. So,
53 c->header.info = xxx_info
55 makes absolute sense, whether mangling or not.
57 -------------------------------------------------------------------------- */
59 #define INIT_INFO(i) info : &(i)
60 #define SET_INFO(c,i) ((c)->header.info = (i))
61 #define GET_INFO(c) ((c)->header.info)
63 #ifdef TABLES_NEXT_TO_CODE
64 #define INIT_ENTRY(e) code : {}
65 #define GET_ENTRY(c) ((StgFunPtr)((c)->header.info))
66 #define ENTRY_CODE(info) (info)
67 #define INFO_PTR_TO_STRUCT(info) ((StgInfoTable *)(info) - 1)
68 static __inline__ StgFunPtr get_entry(const StgInfoTable *itbl) {
69 return (StgFunPtr)(itbl+1);
72 #define INIT_ENTRY(e) entry : (F_)(e)
73 #define GET_ENTRY(c) ((c)->header.info->entry)
74 #define ENTRY_CODE(info) (((StgInfoTable *)info)->entry)
75 #define INFO_PTR_TO_STRUCT(info) ((StgInfoTable *)info)
76 static __inline__ StgFunPtr get_entry(const StgInfoTable *itbl) {
81 #define get_itbl(c) (INFO_PTR_TO_STRUCT((c)->header.info))
83 /* -----------------------------------------------------------------------------
84 Macros for distinguishing data pointers from code pointers
85 -------------------------------------------------------------------------- */
87 * We use some symbols inserted automatically by the linker to decide
88 * whether a pointer points to text, data, or user space. These tests
89 * assume that text is lower in the address space than data, which in
90 * turn is lower than user allocated memory.
92 * If this assumption is false (say on some strange architecture) then
93 * the tests IS_CODE_PTR and IS_DATA_PTR below will need to be
94 * modified (and that should be all that's necessary).
96 * _start } start of read-only text space
97 * _etext } end of read-only text space
98 * _end } end of read-write data space
102 extern void* TEXT_SECTION_END_MARKER_DECL;
103 extern void* DATA_SECTION_END_MARKER_DECL;
106 /* Take into account code sections in dynamically loaded object files. */
107 #define IS_CODE_PTR(p) ( ((P_)(p) < (P_)&TEXT_SECTION_END_MARKER) \
108 || is_dynamically_loaded_code_or_rodata_ptr(p) )
109 #define IS_DATA_PTR(p) ( ((P_)(p) >= (P_)&TEXT_SECTION_END_MARKER && \
110 (P_)(p) < (P_)&DATA_SECTION_END_MARKER) \
111 || is_dynamically_loaded_rwdata_ptr(p) )
112 #define IS_USER_PTR(p) ( ((P_)(p) >= (P_)&DATA_SECTION_END_MARKER) \
113 && is_not_dynamically_loaded_ptr(p) )
115 #define IS_CODE_PTR(p) ((P_)(p) < (P_)&TEXT_SECTION_END_MARKER)
116 #define IS_DATA_PTR(p) ((P_)(p) >= (P_)&TEXT_SECTION_END_MARKER && (P_)(p) < (P_)&DATA_SECTION_END_MARKER)
117 #define IS_USER_PTR(p) ((P_)(p) >= (P_)&DATA_SECTION_END_MARKER)
122 #ifdef HAVE_WIN32_DLL_SUPPORT
123 extern int is_heap_alloced(const void* x);
124 # define HEAP_ALLOCED(x) (is_heap_alloced(x))
126 # define HEAP_ALLOCED(x) IS_USER_PTR(x)
129 /* When working with Win32 DLLs, static closures are identified by
130 being prefixed with a zero word. This is needed so that we can
131 distinguish between pointers to static closures and (reversed!)
134 This 'scheme' breaks down for closure tables such as CHARLIKE,
135 so we catch these separately.
137 LOOKS_LIKE_STATIC_CLOSURE()
138 - discriminates between static closures and info tbls
139 (needed by LOOKS_LIKE_GHC_INFO() below - [Win32 DLLs only.])
141 - distinguishes between static and heap allocated data.
143 #ifdef HAVE_WIN32_DLL_SUPPORT
144 #define LOOKS_LIKE_STATIC(r) (!(HEAP_ALLOCED(r)))
146 /* Tiresome predicates needed to check for pointers into the closure tables */
147 #define IS_CHARLIKE_CLOSURE(p) ( (P_)(p) >= (P_)CHARLIKE_closure && (char*)(p) <= ((char*)CHARLIKE_closure + 255 * sizeof(StgIntCharlikeClosure)) )
148 #define IS_INTLIKE_CLOSURE(p) ( (P_)(p) >= (P_)INTLIKE_closure && (char*)(p) <= ((char*)INTLIKE_closure + 32 * sizeof(StgIntCharlikeClosure)) )
150 #define LOOKS_LIKE_STATIC_CLOSURE(r) (((*(((unsigned long *)(r))-1)) == 0) || IS_CHARLIKE_CLOSURE(r) || IS_INTLIKE_CLOSURE(r))
152 #define LOOKS_LIKE_STATIC(r) IS_DATA_PTR(r)
153 #define LOOKS_LIKE_STATIC_CLOSURE(r) IS_DATA_PTR(r)
157 /* -----------------------------------------------------------------------------
158 Macros for distinguishing infotables from closures.
160 You'd think it'd be easy to tell an info pointer from a closure pointer:
161 closures live on the heap and infotables are in read only memory. Right?
162 Wrong! Static closures live in read only memory and Hugs allocates
163 infotables for constructors on the (writable) C heap.
165 ToDo: in the combined Hugs-GHC system, the following are but crude
166 approximations. This absolutely has to be fixed.
167 -------------------------------------------------------------------------- */
170 #ifdef USE_MINIINTERPRETER
171 /* yoiks: one of the dreaded pointer equality tests */
172 #define IS_HUGS_CONSTR_INFO(info) (((StgInfoTable *)(info))->entry == (StgFunPtr)&Hugs_CONSTR_entry)
174 #define IS_HUGS_CONSTR_INFO(info) 0 /* ToDo: more than mildly bogus */
177 #define IS_HUGS_CONSTR_INFO(info) 0 /* ToDo: more than mildly bogus */
180 #ifdef HAVE_WIN32_DLL_SUPPORT
181 # define LOOKS_LIKE_GHC_INFO(info) (!HEAP_ALLOCED(info) && !LOOKS_LIKE_STATIC_CLOSURE(info))
183 # define LOOKS_LIKE_GHC_INFO(info) IS_CODE_PTR(info)
186 /* -----------------------------------------------------------------------------
187 Macros for calculating how big a closure will be (used during allocation)
188 -------------------------------------------------------------------------- */
190 /* ToDo: replace unsigned int by nat. The only fly in the ointment is that
191 * nat comes from Rts.h which many folk dont include. Sigh!
193 static __inline__ StgOffset AP_sizeW ( unsigned int n_args )
194 { return sizeofW(StgAP_UPD) + n_args; }
196 static __inline__ StgOffset PAP_sizeW ( unsigned int n_args )
197 { return sizeofW(StgPAP) + n_args; }
199 static __inline__ StgOffset CONSTR_sizeW( unsigned int p, unsigned int np )
200 { return sizeofW(StgHeader) + p + np; }
202 static __inline__ StgOffset BCO_sizeW ( unsigned int p, unsigned int np, unsigned int is )
203 { return sizeofW(StgBCO) + p + np + (is+sizeof(StgWord)-1)/sizeof(StgWord); }
205 static __inline__ StgOffset THUNK_SELECTOR_sizeW ( void )
206 { return sizeofW(StgHeader) + MIN_UPD_SIZE; }
208 static __inline__ StgOffset BLACKHOLE_sizeW ( void )
209 { return sizeofW(StgHeader) + MIN_UPD_SIZE; }
211 static __inline__ StgOffset CAF_sizeW ( void )
212 { return sizeofW(StgCAF); }
214 /* --------------------------------------------------------------------------
216 * ------------------------------------------------------------------------*/
218 static __inline__ StgOffset size_fromITBL( const StgInfoTable* itbl )
219 { return sizeof(StgClosure)
220 + sizeof(StgPtr) * itbl->layout.payload.ptrs
221 + sizeof(StgWord) * itbl->layout.payload.nptrs; }
223 static __inline__ StgOffset sizeW_fromITBL( const StgInfoTable* itbl )
224 { return sizeofW(StgClosure)
225 + sizeofW(StgPtr) * itbl->layout.payload.ptrs
226 + sizeofW(StgWord) * itbl->layout.payload.nptrs; }
228 static __inline__ StgOffset pap_size( StgPAP* x )
229 { return sizeof(StgPAP)
230 + sizeof(StgWord) * x->n_args; }
232 static __inline__ StgOffset pap_sizeW( StgPAP* x )
233 { return PAP_sizeW(x->n_args); }
235 /* These two functions give the same result - but have slightly
238 static __inline__ StgOffset arr_words_sizeW( StgArrWords* x )
239 { return sizeofW(StgArrWords) + x->words; }
240 static __inline__ StgOffset mut_arr_ptrs_sizeW( StgMutArrPtrs* x )
241 { return sizeofW(StgMutArrPtrs) + x->ptrs; }
243 static __inline__ StgWord bco_sizeW( StgBCO* bco )
244 { return BCO_sizeW(bco->n_ptrs,bco->n_words,bco->n_instrs); }
246 static __inline__ StgWord tso_sizeW ( StgTSO *tso )
247 { return TSO_STRUCT_SIZEW + tso->stack_size; }
249 /* -----------------------------------------------------------------------------
250 Macros for building closures
251 -------------------------------------------------------------------------- */
254 #define SET_PROF_HDR(c,ccs_) (c)->header.prof.ccs = ccs_
255 #define SET_STATIC_PROF_HDR(ccs_) prof : { ccs : ccs_ },
257 #define SET_PROF_HDR(c,ccs)
258 #define SET_STATIC_PROF_HDR(ccs)
262 #define SET_GRAN_HDR(c,pe) (c)->header.gran.procs = pe
263 #define SET_STATIC_GRAN_HDR gran : { procs : Everywhere },
265 #define SET_GRAN_HDR(c,pe)
266 #define SET_STATIC_GRAN_HDR
269 /* there is no PAR header, as far as I can tell -- SDM */
272 #define SET_PAR_HDR(c,stuff)
273 #define SET_STATIC_PAR_HDR(stuff)
275 #define SET_PAR_HDR(c,stuff)
276 #define SET_STATIC_PAR_HDR(stuff)
280 #define SET_TICKY_HDR(c,stuff) /* old: (c)->header.ticky.updated = stuff */
281 #define SET_STATIC_TICKY_HDR(stuff) /* old: ticky : { updated : stuff } */
283 #define SET_TICKY_HDR(c,stuff)
284 #define SET_STATIC_TICKY_HDR(stuff)
286 #define SET_HDR(c,info,ccs) \
289 SET_GRAN_HDR((StgClosure *)(c),ThisPE); \
290 SET_PAR_HDR((StgClosure *)(c),LOCAL_GA); \
291 SET_PROF_HDR((StgClosure *)(c),ccs); \
292 SET_TICKY_HDR((StgClosure *)(c),0); \
295 #define SET_ARR_HDR(c,info,costCentreStack,n_words) \
296 SET_HDR(c,info,costCentreStack); \
297 (c)->words = n_words;
299 /* -----------------------------------------------------------------------------
300 Static closures are defined as follows:
303 SET_STATIC_HDR(PrelBase_CZh_closure,PrelBase_CZh_info,costCentreStack,const);
305 The info argument must have type 'StgInfoTable' or
306 'StgSRTInfoTable', since we use '&' to get its address in the macro.
307 -------------------------------------------------------------------------- */
309 #define SET_STATIC_HDR(label,info,costCentreStack,closure_class,info_class) \
311 closure_class StgClosure label = { \
312 STATIC_HDR(info,costCentreStack)
314 #define STATIC_HDR(info,ccs) \
317 SET_STATIC_GRAN_HDR \
318 SET_STATIC_PAR_HDR(LOCAL_GA) \
319 SET_STATIC_PROF_HDR(ccs) \
320 SET_STATIC_TICKY_HDR(0) \
323 /* how to get hold of the static link field for a static closure.
325 * Note that we have to use (*cast(T*,&e)) instead of cast(T,e)
326 * because C won't let us take the address of a casted expression. Huh?
328 #define STATIC_LINK(info,p) \
329 (*stgCast(StgClosure**,&((p)->payload[info->layout.payload.ptrs + \
330 info->layout.payload.nptrs])))
331 /* These macros are optimised versions of the above for certain
332 * closure types. They *must* be equivalent to the generic
335 #define FUN_STATIC_LINK(p) ((p)->payload[0])
336 #define THUNK_STATIC_LINK(p) ((p)->payload[2])
337 #define IND_STATIC_LINK(p) ((p)->payload[1])
339 #define STATIC_LINK2(info,p) \
340 (*stgCast(StgClosure**,&((p)->payload[info->layout.payload.ptrs + \
341 info->layout.payload.nptrs + 1])))
343 /* -----------------------------------------------------------------------------
344 INTLIKE and CHARLIKE closures.
345 -------------------------------------------------------------------------- */
347 #define CHARLIKE_CLOSURE(n) ((P_)&CHARLIKE_closure[n])
348 #define INTLIKE_CLOSURE(n) ((P_)&INTLIKE_closure[(n)-MIN_INTLIKE])
350 /* -----------------------------------------------------------------------------
351 Closure Tables (for enumerated data types)
352 -------------------------------------------------------------------------- */
354 #define CLOSURE_TBL(lbl) const StgClosure *lbl[] = {
356 /* -----------------------------------------------------------------------------
358 -------------------------------------------------------------------------- */
360 #define payloadPtr( c, i ) (*stgCast(StgPtr*, ((c)->payload+(i))))
361 #define payloadCPtr( c, i ) (*stgCast(StgClosure**, ((c)->payload+(i))))
362 #define payloadWord( c, i ) (*stgCast(StgWord*, ((c)->payload+(i))))
364 /* -----------------------------------------------------------------------------
366 -------------------------------------------------------------------------- */
368 /* constructors don't have SRTs */
369 #define GET_TAG(info) (INFO_PTR_TO_STRUCT(info)->srt_len)
371 /* -----------------------------------------------------------------------------
373 -------------------------------------------------------------------------- */
375 #define bcoConstPtr( bco, i ) (*stgCast(StgPtr*, ((bco)->payload+(i))))
376 #define bcoConstCPtr( bco, i ) (*stgCast(StgClosurePtr*,((bco)->payload+(i))))
377 #define bcoConstInfoPtr( bco, i )(*stgCast(StgInfoTable**,((bco)->payload+(bco)->n_ptrs+i)))
378 #define bcoConstInt( bco, i ) (*stgCast(StgInt*, ((bco)->payload+(bco)->n_ptrs+i)))
379 #define bcoConstInt64( bco, i ) (PK_Int64(stgCast(StgWord*,(bco)->payload+(bco)->n_ptrs+i)))
380 #define bcoConstWord( bco, i ) (*stgCast(StgWord*, ((bco)->payload+(bco)->n_ptrs+i)))
381 #define bcoConstAddr( bco, i ) (*stgCast(StgAddr*, ((bco)->payload+(bco)->n_ptrs+i)))
382 #define bcoConstChar( bco, i ) (*stgCast(StgChar*, ((bco)->payload+(bco)->n_ptrs+i)))
383 #define bcoConstFloat( bco, i ) (PK_FLT(stgCast(StgWord*,(bco)->payload+(bco)->n_ptrs+i)))
384 #define bcoConstDouble( bco, i ) (PK_DBL(stgCast(StgWord*,(bco)->payload+(bco)->n_ptrs+i)))
385 #define bcoInstr( bco, i ) (stgCast(StgWord8*, ((bco)->payload+(bco)->n_ptrs+(bco)->n_words))[i])
386 static __inline__ StgInt bcoInstr16 ( StgBCO* bco, unsigned int i )
387 { StgInt x = (bcoInstr(bco,i) << 8) + bcoInstr(bco,i+1); return x; }
389 #endif /* CLOSUREMACROS_H */