1 /* ----------------------------------------------------------------------------
2 * $Id: InfoTables.h,v 1.21 2001/03/22 03:51:09 hwloidl Exp $
4 * (c) The GHC Team, 1998-1999
8 * -------------------------------------------------------------------------- */
13 /* -----------------------------------------------------------------------------
15 -------------------------------------------------------------------------- */
24 #else /* !PROFILING */
30 #endif /* PROFILING */
32 /* -----------------------------------------------------------------------------
34 -------------------------------------------------------------------------- */
36 #if 0 && (defined(PAR) || defined(GRAN))
39 // ToDo: use this in StgInfoTable (mutually recursive) -- HWL
42 StgInfoTable *rbh_infoptr; /* infoptr to the RBH */
54 Copied from ghc-0.29; ToDo: check this code -- HWL
56 In the parallel system, all updatable closures have corresponding
57 revertible black holes. When we are assembly-mangling, we guarantee
58 that the revertible black hole code precedes the normal entry code, so
59 that the RBH info table resides at a fixed offset from the normal info
60 table. Otherwise, we add the RBH info table pointer to the end of the
61 normal info table and vice versa.
63 Currently has to use a !RBH_MAGIC_OFFSET setting.
64 Still todo: init of par.infoptr field in all infotables!!
67 #if defined(PAR) || defined(GRAN)
69 # ifdef RBH_MAGIC_OFFSET
71 # error magic offset not yet implemented
73 # define RBH_INFO_WORDS 0
74 # define INCLUDE_RBH_INFO(infoptr)
76 # define RBH_INFOPTR(infoptr) (((P_)infoptr) - RBH_MAGIC_OFFSET)
77 # define REVERT_INFOPTR(infoptr) (((P_)infoptr) + RBH_MAGIC_OFFSET)
81 # define RBH_INFO_WORDS 1
82 # define INCLUDE_RBH_INFO(info) rbh_infoptr : &(info)
84 # define RBH_INFOPTR(infoptr) (((StgInfoTable *)(infoptr))->rbh_infoptr)
85 # define REVERT_INFOPTR(infoptr) (((StgInfoTable *)(infoptr))->rbh_infoptr)
89 /* see ParallelRts.h */
91 //StgClosure *convertToRBH(StgClosure *closure);
93 //void convertFromRBH(StgClosure *closure);
95 //void convertToFetchMe(StgPtr closure, globalAddr *ga);
100 /* -----------------------------------------------------------------------------
102 -------------------------------------------------------------------------- */
110 #else /* !DEBUG_CLOSURE */
116 #endif /* DEBUG_CLOSURE */
118 /* The type flags provide quick access to certain properties of a closure. */
120 #define _HNF (1<<0) /* head normal form? */
121 #define _BTM (1<<1) /* bitmap-style layout? */
122 #define _NS (1<<2) /* non-sparkable */
123 #define _STA (1<<3) /* static? */
124 #define _THU (1<<4) /* thunk? */
125 #define _MUT (1<<5) /* mutable? */
126 #define _UPT (1<<6) /* unpointed? */
127 #define _SRT (1<<7) /* has an SRT? */
128 #define _IND (1<<8) /* is an indirection? */
130 #define isSTATIC(flags) ((flags) &_STA)
131 #define isMUTABLE(flags) ((flags) &_MUT)
132 #define isBITMAP(flags) ((flags) &_BTM)
133 #define isTHUNK(flags) ((flags) &_THU)
134 #define isUNPOINTED(flags) ((flags) &_UPT)
135 #define hasSRT(flags) ((flags) &_SRT)
137 extern StgWord16 closure_flags[];
139 #define closureFlags(c) (closure_flags[get_itbl(c)->type])
141 #define closure_HNF(c) ( closureFlags(c) & _HNF)
142 #define closure_BITMAP(c) ( closureFlags(c) & _BTM)
143 #define closure_NON_SPARK(c) ( (closureFlags(c) & _NS))
144 #define closure_SHOULD_SPARK(c) (!(closureFlags(c) & _NS))
145 #define closure_STATIC(c) ( closureFlags(c) & _STA)
146 #define closure_THUNK(c) ( closureFlags(c) & _THU)
147 #define closure_MUTABLE(c) ( closureFlags(c) & _MUT)
148 #define closure_UNPOINTED(c) ( closureFlags(c) & _UPT)
149 #define closure_SRT(c) ( closureFlags(c) & _SRT)
150 #define closure_IND(c) ( closureFlags(c) & _IND)
152 /* same as above but for info-ptr rather than closure */
153 #define ipFlags(ip) (closure_flags[ip->type])
155 #define ip_HNF(ip) ( ipFlags(ip) & _HNF)
156 #define ip_BITMAP(ip) ( ipFlags(ip) & _BTM)
157 #define ip_SHOULD_SPARK(ip) (!(ipFlags(ip) & _NS))
158 #define ip_STATIC(ip) ( ipFlags(ip) & _STA)
159 #define ip_THUNK(ip) ( ipFlags(ip) & _THU)
160 #define ip_MUTABLE(ip) ( ipFlags(ip) & _MUT)
161 #define ip_UNPOINTED(ip) ( ipFlags(ip) & _UPT)
162 #define ip_SRT(ip) ( ipFlags(ip) & _SRT)
163 #define ip_IND(ip) ( ipFlags(ip) & _IND)
165 /* -----------------------------------------------------------------------------
167 -------------------------------------------------------------------------- */
169 /* A large bitmap. Small 32-bit ones live in the info table, but sometimes
170 * 32 bits isn't enough and we have to generate a larger one. (sizes
171 * differ for 64-bit machines.
180 * Stuff describing the closure layout. Well, actually, it might
181 * contain the selector index for a THUNK_SELECTOR. If we're on a
182 * 64-bit architecture then we can enlarge some of these fields, since
183 * the union contains a pointer field.
188 #if SIZEOF_VOID_P == 8
189 StgWord32 ptrs; /* number of pointers */
190 StgWord32 nptrs; /* number of non-pointers */
192 StgWord16 ptrs; /* number of pointers */
193 StgWord16 nptrs; /* number of non-pointers */
197 StgWord bitmap; /* bit pattern, 1 = pointer, 0 = non-pointer */
198 StgWord selector_offset; /* used in THUNK_SELECTORs */
199 StgLargeBitmap* large_bitmap; /* pointer to large bitmap structure */
204 * Info tables. All info tables are the same type, to simplify code
205 * generation. However, the mangler removes any unused SRT fields
206 * from the asm to save space (convention: if srt_len is zero, or the
207 * type is a CONSTR_ type, then the SRT field isn't present.
210 typedef StgClosure* StgSRT[];
212 typedef struct _StgInfoTable {
213 StgSRT *srt; /* pointer to the SRT table */
214 #if defined(PAR) || defined(GRAN)
215 struct _StgInfoTable *rbh_infoptr;
223 StgClosureInfo layout; /* closure layout info (pointer-sized) */
224 #if SIZEOF_VOID_P == 8
225 StgWord32 type; /* } These 2 elements fit into 64 bits */
226 StgWord32 srt_len; /* } */
228 StgWord type : 16; /* } These 2 elements fit into 32 bits */
229 StgWord srt_len : 16; /* } */
231 #ifdef TABLES_NEXT_TO_CODE
239 /* Info tables are read-only, therefore we uniformly declare them with
240 * C's const attribute. This isn't just a nice thing to do: it's
241 * necessary because the garbage collector has to distinguish between
242 * closure pointers and info table pointers when traversing the
243 * stack. We distinguish the two by checking whether the pointer is
244 * into text-space or not.
247 #define INFO_TBL_CONST const
249 #endif /* INFOTABLES_H */