1 /* ----------------------------------------------------------------------------
2 * $Id: InfoTables.h,v 1.20 2001/03/02 16:12:18 simonmar 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_SHOULD_SPARK(c) (!(closureFlags(c) & _NS))
144 #define closure_STATIC(c) ( closureFlags(c) & _STA)
145 #define closure_THUNK(c) ( closureFlags(c) & _THU)
146 #define closure_MUTABLE(c) ( closureFlags(c) & _MUT)
147 #define closure_UNPOINTED(c) ( closureFlags(c) & _UPT)
148 #define closure_SRT(c) ( closureFlags(c) & _SRT)
149 #define closure_IND(c) ( closureFlags(c) & _IND)
151 /* same as above but for info-ptr rather than closure */
152 #define ipFlags(ip) (closure_flags[ip->type])
154 #define ip_HNF(ip) ( ipFlags(ip) & _HNF)
155 #define ip_BITMAP(ip) ( ipFlags(ip) & _BTM)
156 #define ip_SHOULD_SPARK(ip) (!(ipFlags(ip) & _NS))
157 #define ip_STATIC(ip) ( ipFlags(ip) & _STA)
158 #define ip_THUNK(ip) ( ipFlags(ip) & _THU)
159 #define ip_MUTABLE(ip) ( ipFlags(ip) & _MUT)
160 #define ip_UNPOINTED(ip) ( ipFlags(ip) & _UPT)
161 #define ip_SRT(ip) ( ipFlags(ip) & _SRT)
162 #define ip_IND(ip) ( ipFlags(ip) & _IND)
164 /* -----------------------------------------------------------------------------
166 -------------------------------------------------------------------------- */
168 /* A large bitmap. Small 32-bit ones live in the info table, but sometimes
169 * 32 bits isn't enough and we have to generate a larger one. (sizes
170 * differ for 64-bit machines.
179 * Stuff describing the closure layout. Well, actually, it might
180 * contain the selector index for a THUNK_SELECTOR. If we're on a
181 * 64-bit architecture then we can enlarge some of these fields, since
182 * the union contains a pointer field.
187 #if SIZEOF_VOID_P == 8
188 StgWord32 ptrs; /* number of pointers */
189 StgWord32 nptrs; /* number of non-pointers */
191 StgWord16 ptrs; /* number of pointers */
192 StgWord16 nptrs; /* number of non-pointers */
196 StgWord bitmap; /* bit pattern, 1 = pointer, 0 = non-pointer */
197 StgWord selector_offset; /* used in THUNK_SELECTORs */
198 StgLargeBitmap* large_bitmap; /* pointer to large bitmap structure */
203 * Info tables. All info tables are the same type, to simplify code
204 * generation. However, the mangler removes any unused SRT fields
205 * from the asm to save space (convention: if srt_len is zero, or the
206 * type is a CONSTR_ type, then the SRT field isn't present.
209 typedef StgClosure* StgSRT[];
211 typedef struct _StgInfoTable {
212 StgSRT *srt; /* pointer to the SRT table */
213 #if defined(PAR) || defined(GRAN)
214 struct _StgInfoTable *rbh_infoptr;
222 StgClosureInfo layout; /* closure layout info (pointer-sized) */
223 #if SIZEOF_VOID_P == 8
224 StgWord32 type; /* } These 2 elements fit into 64 bits */
225 StgWord32 srt_len; /* } */
227 StgWord type : 16; /* } These 2 elements fit into 32 bits */
228 StgWord srt_len : 16; /* } */
230 #ifdef TABLES_NEXT_TO_CODE
238 /* Info tables are read-only, therefore we uniformly declare them with
239 * C's const attribute. This isn't just a nice thing to do: it's
240 * necessary because the garbage collector has to distinguish between
241 * closure pointers and info table pointers when traversing the
242 * stack. We distinguish the two by checking whether the pointer is
243 * into text-space or not.
246 #define INFO_TBL_CONST const
248 #endif /* INFOTABLES_H */