1 /* -----------------------------------------------------------------------------
3 * (c) The GHC Team, 1998-2004
7 * ---------------------------------------------------------------------------*/
12 #pragma GCC visibility push(hidden)
14 /* -----------------------------------------------------------------------------
17 We have two layers of update macros. The top layer, UPD_IND() and
18 friends perform all the work of an update. In detail:
20 - if the closure being updated is a blocking queue, then all the
21 threads waiting on the blocking queue are updated.
23 - then the lower level updateWithIndirection() macro is invoked
24 to actually replace the closure with an indirection (see below).
26 -------------------------------------------------------------------------- */
29 # define UPD_IND(updclosure, heapptr) \
30 UPD_REAL_IND(updclosure,INFO_PTR(stg_IND_info),heapptr,SEMI)
31 # define UPD_SPEC_IND(updclosure, ind_info, heapptr, and_then) \
32 UPD_REAL_IND(updclosure,ind_info,heapptr,and_then)
34 /* These macros have to work in both C and C--, so here's the
40 #define INFO_PTR(info) info
44 #define INFO_PTR(info) &info
45 #define StgBlockingQueue_blocking_queue(closure) \
46 (((StgBlockingQueue *)closure)->blocking_queue)
49 /* krc: there used to be an UPD_REAL_IND and an
50 UPD_PERM_IND, the latter of which was used for
51 ticky and cost-centre profiling.
52 for now, we just have UPD_REAL_IND. */
53 #define UPD_REAL_IND(updclosure, ind_info, heapptr, and_then) \
55 updateWithIndirection(ind_info, \
61 /* -----------------------------------------------------------------------------
62 Awaken any threads waiting on a blocking queue (BLACKHOLE_BQ).
63 -------------------------------------------------------------------------- */
65 /* -----------------------------------------------------------------------------
66 Updates: lower-level macros which update a closure with an
67 indirection to another closure.
69 There are several variants of this code.
72 -------------------------------------------------------------------------- */
75 * We call LDV_recordDead_FILL_SLOP_DYNAMIC(p1) regardless of the generation in
79 * After all, we do *NOT* need to call LDV_RECORD_CREATE() for both IND and
80 * IND_OLDGEN closures because they are inherently used. But, it corrupts
81 * the invariants that every closure keeps its creation time in the profiling
82 * field. So, we call LDV_RECORD_CREATE().
85 /* In the DEBUG case, we also zero out the slop of the old closure,
86 * so that the sanity checker can tell where the next closure is.
88 * Two important invariants: we should never try to update a closure
89 * to point to itself, and the closure being updated should not
90 * already have been updated (the mutable list will get messed up
93 * NB. We do *not* do this in THREADED_RTS mode, because when we have the
94 * possibility of multiple threads entering the same closure, zeroing
95 * the slop in one of the threads would have a disastrous effect on
96 * the other (seen in the wild!).
100 #define FILL_SLOP(p) \
104 inf = %GET_STD_INFO(p); \
105 if (%INFO_TYPE(inf) != HALF_W_(BLACKHOLE) \
106 && %INFO_TYPE(inf) != HALF_W_(CAF_BLACKHOLE)) { \
107 if (%INFO_TYPE(inf) == HALF_W_(THUNK_SELECTOR)) { \
108 sz = BYTES_TO_WDS(SIZEOF_StgSelector_NoThunkHdr); \
110 if (%INFO_TYPE(inf) == HALF_W_(AP_STACK)) { \
111 sz = StgAP_STACK_size(p) + BYTES_TO_WDS(SIZEOF_StgAP_STACK_NoThunkHdr); \
113 if (%INFO_TYPE(inf) == HALF_W_(AP)) { \
114 sz = TO_W_(StgAP_n_args(p)) + BYTES_TO_WDS(SIZEOF_StgAP_NoThunkHdr); \
116 sz = TO_W_(%INFO_PTRS(inf)) + TO_W_(%INFO_NPTRS(inf)); \
123 StgThunk_payload(p,i) = 0; \
129 #else /* !CMINUSMINUS */
132 FILL_SLOP(StgClosure *p)
134 StgInfoTable *inf = get_itbl(p);
141 // we already filled in the slop when we overwrote the thunk
142 // with BLACKHOLE, and also an evacuated BLACKHOLE is only the
145 sz = sizeofW(StgSelector) - sizeofW(StgThunkHeader);
148 sz = ((StgAP *)p)->n_args + sizeofW(StgAP) - sizeofW(StgThunkHeader);
151 sz = ((StgAP_STACK *)p)->size + sizeofW(StgAP_STACK) - sizeofW(StgThunkHeader);
154 sz = inf->layout.payload.ptrs + inf->layout.payload.nptrs;
157 for (i = 0; i < sz; i++) {
158 ((StgThunk *)p)->payload[i] = 0;
164 #endif /* CMINUSMINUS */
166 #if !defined(DEBUG) || defined(THREADED_RTS)
167 #define DEBUG_FILL_SLOP(p) /* do nothing */
169 #define DEBUG_FILL_SLOP(p) FILL_SLOP(p)
172 /* We have two versions of this macro (sadly), one for use in C-- code,
173 * and the other for C.
175 * The and_then argument is a performance hack so that we can paste in
176 * the continuation code directly. It helps shave a couple of
177 * instructions off the common case in the update code, which is
178 * worthwhile (the update code is often part of the inner loop).
179 * (except that gcc now appears to common up this code again and
180 * invert the optimisation. Grrrr --SDM).
183 #define generation(n) (W_[generations] + n*SIZEOF_generation)
184 #define updateWithIndirection(ind_info, p1, p2, and_then) \
187 DEBUG_FILL_SLOP(p1); \
188 LDV_RECORD_DEAD_FILL_SLOP_DYNAMIC(p1); \
189 StgInd_indirectee(p1) = p2; \
190 prim %write_barrier() []; \
192 if (bdescr_gen_no(bd) != 0 :: CInt) { \
193 recordMutableCap(p1, TO_W_(bdescr_gen_no(bd)), R1); \
194 SET_INFO(p1, stg_IND_OLDGEN_info); \
195 LDV_RECORD_CREATE(p1); \
196 TICK_UPD_OLD_IND(); \
199 SET_INFO(p1, ind_info); \
200 LDV_RECORD_CREATE(p1); \
201 TICK_UPD_NEW_IND(); \
205 #define updateWithIndirection(ind_info, p1, p2, and_then) \
209 ASSERT( (P_)p1 != (P_)p2 ); \
210 /* not necessarily true: ASSERT( !closure_IND(p1) ); */ \
211 /* occurs in RaiseAsync.c:raiseAsync() */ \
212 DEBUG_FILL_SLOP(p1); \
213 LDV_RECORD_DEAD_FILL_SLOP_DYNAMIC(p1); \
214 ((StgInd *)p1)->indirectee = p2; \
216 bd = Bdescr((P_)p1); \
217 if (bd->gen_no != 0) { \
218 recordMutableGenLock(p1, bd->gen_no); \
219 SET_INFO(p1, &stg_IND_OLDGEN_info); \
220 TICK_UPD_OLD_IND(); \
223 SET_INFO(p1, ind_info); \
224 LDV_RECORD_CREATE(p1); \
225 TICK_UPD_NEW_IND(); \
229 #endif /* CMINUSMINUS */
231 #pragma GCC visibility pop
233 #endif /* UPDATES_H */