From 0f3205e6c40575910d50bc2cc42020ccf55e07ba Mon Sep 17 00:00:00 2001 From: simonmar Date: Fri, 22 Apr 2005 09:32:40 +0000 Subject: [PATCH] [project @ 2005-04-22 09:32:39 by simonmar] SMP: the rest of the changes to support safe thunk entry & updates. I thought the compiler changes were independent, but I ended up breaking the HEAD, so I'll have to commit the rest. non-SMP compilation should not be affected. --- ghc/includes/ClosureMacros.h | 35 +++++---- ghc/includes/Closures.h | 55 +++++++++++-- ghc/includes/Cmm.h | 20 +++++ ghc/includes/StgTypes.h | 1 - ghc/includes/Storage.h | 11 +++ ghc/includes/mkDerivedConstants.c | 2 + ghc/rts/GC.c | 153 +++++++++++++++++++++++++------------ ghc/rts/GCCompact.c | 83 +++++++++++++++----- ghc/rts/LdvProfile.c | 25 ++++-- ghc/rts/Printer.c | 30 +++++++- ghc/rts/ProfHeap.c | 27 ++++--- ghc/rts/RetainerProfile.c | 45 ++++++----- ghc/rts/Sanity.c | 90 +++++++++++++--------- ghc/rts/Schedule.c | 2 +- ghc/rts/StgStdThunks.cmm | 66 ++++++++-------- 15 files changed, 441 insertions(+), 204 deletions(-) diff --git a/ghc/includes/ClosureMacros.h b/ghc/includes/ClosureMacros.h index 11636b8..f40f6aa 100644 --- a/ghc/includes/ClosureMacros.h +++ b/ghc/includes/ClosureMacros.h @@ -161,23 +161,28 @@ /* ----------------------------------------------------------------------------- How to get hold of the static link field for a static closure. - - Note that we have to use (*cast(T*,&e)) instead of cast(T,e) - because C won't let us take the address of a casted - expression. Huh? -------------------------------------------------------------------------- */ -#define STATIC_LINK(info,p) \ - (*(StgClosure**)(&((p)->payload[info->layout.payload.ptrs + \ - info->layout.payload.nptrs]))) - -/* These macros are optimised versions of the above for certain - * closure types. They *must* be equivalent to the generic - * STATIC_LINK. - */ -#define FUN_STATIC_LINK(p) ((p)->payload[0]) -#define THUNK_STATIC_LINK(p) ((p)->payload[1]) -#define IND_STATIC_LINK(p) ((p)->payload[1]) +/* These are hard-coded. */ +#define FUN_STATIC_LINK(p) (&(p)->payload[0]) +#define THUNK_STATIC_LINK(p) (&(p)->payload[1]) +#define IND_STATIC_LINK(p) (&(p)->payload[1]) + +INLINE_HEADER StgClosure ** +STATIC_LINK(const StgInfoTable *info, StgClosure *p) +{ + switch (info->type) { + case THUNK_STATIC: + return THUNK_STATIC_LINK(p); + case FUN_STATIC: + return FUN_STATIC_LINK(p); + case IND_STATIC: + return IND_STATIC_LINK(p); + default: + return &(p)->payload[info->layout.payload.ptrs + + info->layout.payload.nptrs]; + } +} #define STATIC_LINK2(info,p) \ (*(StgClosure**)(&((p)->payload[info->layout.payload.ptrs + \ diff --git a/ghc/includes/Closures.h b/ghc/includes/Closures.h index 066fe91..39af80e 100644 --- a/ghc/includes/Closures.h +++ b/ghc/includes/Closures.h @@ -35,6 +35,17 @@ typedef struct { } StgGranHeader; /* ----------------------------------------------------------------------------- + The SMP header + + In SMP mode, we have an extra word of padding in a thunk's header. + (Note: thunks only; other closures do not have this padding word). + -------------------------------------------------------------------------- */ + +typedef struct { + StgWord pad; +} StgSMPThunkHeader; + +/* ----------------------------------------------------------------------------- The full fixed-size closure header The size of the fixed header is the sum of the optional parts plus a single @@ -42,15 +53,35 @@ typedef struct { -------------------------------------------------------------------------- */ typedef struct { - const struct _StgInfoTable* info; + const struct _StgInfoTable* info; #ifdef PROFILING - StgProfHeader prof; + StgProfHeader prof; #endif #ifdef GRAN - StgGranHeader gran; + StgGranHeader gran; #endif } StgHeader; +/* + * In SMP mode, a thunk has a padding word to take the updated value. + * This is so that the update doesn't overwrite the payload, so we can + * avoid needing to lock the thunk during entry and update. + * + * Note: this doesn't apply to THUNK_STATICs, which have no payload. + */ +typedef struct { + const struct _StgInfoTable* info; +#ifdef PROFILING + StgProfHeader prof; +#endif +#ifdef GRAN + StgGranHeader gran; +#endif +#ifdef SMP + StgSMPThunkHeader smp; +#endif +} StgThunkHeader; + /* ----------------------------------------------------------------------------- Closure Types @@ -67,7 +98,12 @@ struct StgClosure_ { }; typedef struct { - StgHeader header; + StgThunkHeader header; + struct StgClosure_ *payload[FLEXIBLE_ARRAY]; +} StgThunk; + +typedef struct { + StgThunkHeader header; StgClosure *selectee; } StgSelector; @@ -79,11 +115,16 @@ typedef struct { StgClosure *payload[FLEXIBLE_ARRAY]; } StgPAP; -/* AP closures have the same layout, for convenience */ -typedef StgPAP StgAP; +typedef struct { + StgThunkHeader header; + StgHalfWord arity; /* zero if it is an AP */ + StgHalfWord n_args; + StgClosure *fun; /* really points to a fun */ + StgClosure *payload[FLEXIBLE_ARRAY]; +} StgAP; typedef struct { - StgHeader header; + StgThunkHeader header; StgWord size; /* number of words in payload */ StgClosure *fun; StgClosure *payload[FLEXIBLE_ARRAY]; /* contains a chunk of *stack* */ diff --git a/ghc/includes/Cmm.h b/ghc/includes/Cmm.h index ff36196..e4f44d6 100644 --- a/ghc/includes/Cmm.h +++ b/ghc/includes/Cmm.h @@ -325,6 +325,26 @@ } /* ----------------------------------------------------------------------------- + Closure headers + -------------------------------------------------------------------------- */ + +/* + * This is really ugly, since we don't do the rest of StgHeader this + * way. The problem is that values from DerivedConstants.h cannot be + * dependent on the way (SMP, PROF etc.). For SIZEOF_StgHeader we get + * the value from GHC, but it seems like too much trouble to do that + * for StgThunkHeader. + */ +#ifdef SMP +#define SIZEOF_StgThunkHeader SIZEOF_StgHeader+SIZEOF_StgSMPThunkHeader +#else +#define SIZEOF_StgThunkHeader SIZEOF_StgHeader +#endif + +#define StgThunk_payload(__ptr__,__ix__) \ + W_[__ptr__+SIZEOF_StgThunkHeader+ WDS(__ix__)] + +/* ----------------------------------------------------------------------------- Closures -------------------------------------------------------------------------- */ diff --git a/ghc/includes/StgTypes.h b/ghc/includes/StgTypes.h index 393cf27..ba2adb4 100644 --- a/ghc/includes/StgTypes.h +++ b/ghc/includes/StgTypes.h @@ -48,7 +48,6 @@ typedef unsigned char StgWord8; typedef signed short StgInt16; typedef unsigned short StgWord16; - #if SIZEOF_UNSIGNED_INT == 4 typedef signed int StgInt32; typedef unsigned int StgWord32; diff --git a/ghc/includes/Storage.h b/ghc/includes/Storage.h index aebc02b..4404dfa 100644 --- a/ghc/includes/Storage.h +++ b/ghc/includes/Storage.h @@ -255,6 +255,9 @@ extern rtsBool keepCAFs; INLINE_HEADER StgOffset PAP_sizeW ( nat n_args ) { return sizeofW(StgPAP) + n_args; } +INLINE_HEADER StgOffset AP_sizeW ( nat n_args ) +{ return sizeofW(StgAP) + n_args; } + INLINE_HEADER StgOffset AP_STACK_sizeW ( nat size ) { return sizeofW(StgAP_STACK) + size; } @@ -276,9 +279,17 @@ INLINE_HEADER StgOffset sizeW_fromITBL( const StgInfoTable* itbl ) + sizeofW(StgPtr) * itbl->layout.payload.ptrs + sizeofW(StgWord) * itbl->layout.payload.nptrs; } +INLINE_HEADER StgOffset thunk_sizeW_fromITBL( const StgInfoTable* itbl ) +{ return sizeofW(StgThunk) + + sizeofW(StgPtr) * itbl->layout.payload.ptrs + + sizeofW(StgWord) * itbl->layout.payload.nptrs; } + INLINE_HEADER StgOffset ap_stack_sizeW( StgAP_STACK* x ) { return AP_STACK_sizeW(x->size); } +INLINE_HEADER StgOffset ap_sizeW( StgAP* x ) +{ return AP_sizeW(x->n_args); } + INLINE_HEADER StgOffset pap_sizeW( StgPAP* x ) { return PAP_sizeW(x->n_args); } diff --git a/ghc/includes/mkDerivedConstants.c b/ghc/includes/mkDerivedConstants.c index 330f40f..f8d01c4 100644 --- a/ghc/includes/mkDerivedConstants.c +++ b/ghc/includes/mkDerivedConstants.c @@ -232,6 +232,8 @@ main(int argc, char *argv[]) struct_field_("StgHeader_ccs", StgHeader, prof.ccs); struct_field_("StgHeader_ldvw", StgHeader, prof.hp.ldvw); + struct_size(StgSMPThunkHeader); + closure_payload(StgClosure,payload); struct_field(StgEntCounter, allocs); diff --git a/ghc/rts/GC.c b/ghc/rts/GC.c index 545ee1c..3d6d649 100644 --- a/ghc/rts/GC.c +++ b/ghc/rts/GC.c @@ -1721,9 +1721,11 @@ loop: case FUN_1_0: case FUN_0_1: case CONSTR_1_0: + return copy(q,sizeofW(StgHeader)+1,stp); + case THUNK_1_0: case THUNK_0_1: - return copy(q,sizeofW(StgHeader)+1,stp); + return copy(q,sizeofW(StgThunk)+1,stp); case THUNK_1_1: case THUNK_0_2: @@ -1735,7 +1737,7 @@ loop: stp = bd->step; } #endif - return copy(q,sizeofW(StgHeader)+2,stp); + return copy(q,sizeofW(StgThunk)+2,stp); case FUN_1_1: case FUN_0_2: @@ -1801,16 +1803,16 @@ loop: case THUNK_STATIC: if (info->srt_bitmap != 0 && major_gc && - THUNK_STATIC_LINK((StgClosure *)q) == NULL) { - THUNK_STATIC_LINK((StgClosure *)q) = static_objects; + *THUNK_STATIC_LINK((StgClosure *)q) == NULL) { + *THUNK_STATIC_LINK((StgClosure *)q) = static_objects; static_objects = (StgClosure *)q; } return q; case FUN_STATIC: if (info->srt_bitmap != 0 && major_gc && - FUN_STATIC_LINK((StgClosure *)q) == NULL) { - FUN_STATIC_LINK((StgClosure *)q) = static_objects; + *FUN_STATIC_LINK((StgClosure *)q) == NULL) { + *FUN_STATIC_LINK((StgClosure *)q) = static_objects; static_objects = (StgClosure *)q; } return q; @@ -1822,15 +1824,15 @@ loop: */ if (major_gc && ((StgIndStatic *)q)->saved_info == NULL - && IND_STATIC_LINK((StgClosure *)q) == NULL) { - IND_STATIC_LINK((StgClosure *)q) = static_objects; + && *IND_STATIC_LINK((StgClosure *)q) == NULL) { + *IND_STATIC_LINK((StgClosure *)q) = static_objects; static_objects = (StgClosure *)q; } return q; case CONSTR_STATIC: - if (major_gc && STATIC_LINK(info,(StgClosure *)q) == NULL) { - STATIC_LINK(info,(StgClosure *)q) = static_objects; + if (major_gc && *STATIC_LINK(info,(StgClosure *)q) == NULL) { + *STATIC_LINK(info,(StgClosure *)q) = static_objects; static_objects = (StgClosure *)q; } return q; @@ -1859,9 +1861,11 @@ loop: barf("evacuate: stack frame at %p\n", q); case PAP: - case AP: return copy(q,pap_sizeW((StgPAP*)q),stp); + case AP: + return copy(q,ap_sizeW((StgAP*)q),stp); + case AP_STACK: return copy(q,ap_stack_sizeW((StgAP_STACK*)q),stp); @@ -2343,15 +2347,6 @@ scavenge_fun_srt(const StgInfoTable *info) scavenge_srt((StgClosure **)GET_FUN_SRT(fun_info), fun_info->i.srt_bitmap); } -STATIC_INLINE void -scavenge_ret_srt(const StgInfoTable *info) -{ - StgRetInfoTable *ret_info; - - ret_info = itbl_to_ret_itbl(info); - scavenge_srt((StgClosure **)GET_SRT(ret_info), ret_info->i.srt_bitmap); -} - /* ----------------------------------------------------------------------------- Scavenge a TSO. -------------------------------------------------------------------------- */ @@ -2424,18 +2419,15 @@ scavenge_arg_block (StgFunInfoTable *fun_info, StgClosure **args) } STATIC_INLINE StgPtr -scavenge_PAP (StgPAP *pap) +scavenge_PAP_payload (StgClosure *fun, StgClosure **payload, StgWord size) { StgPtr p; - StgWord bitmap, size; + StgWord bitmap; StgFunInfoTable *fun_info; - - pap->fun = evacuate(pap->fun); - fun_info = get_fun_itbl(pap->fun); + + fun_info = get_fun_itbl(fun); ASSERT(fun_info->i.type != PAP); - - p = (StgPtr)pap->payload; - size = pap->n_args; + p = (StgPtr)payload; switch (fun_info->f.fun_type) { case ARG_GEN: @@ -2446,13 +2438,12 @@ scavenge_PAP (StgPAP *pap) p += size; break; case ARG_BCO: - scavenge_large_bitmap((StgPtr)pap->payload, BCO_BITMAP(pap->fun), size); + scavenge_large_bitmap((StgPtr)payload, BCO_BITMAP(fun), size); p += size; break; default: bitmap = BITMAP_BITS(stg_arg_bitmaps[fun_info->f.fun_type]); small_bitmap: - size = pap->n_args; while (size > 0) { if ((bitmap & 1) == 0) { *p = (StgWord)(StgPtr)evacuate((StgClosure *)*p); @@ -2466,6 +2457,20 @@ scavenge_PAP (StgPAP *pap) return p; } +STATIC_INLINE StgPtr +scavenge_PAP (StgPAP *pap) +{ + pap->fun = evacuate(pap->fun); + return scavenge_PAP_payload (pap->fun, pap->payload, pap->n_args); +} + +STATIC_INLINE StgPtr +scavenge_AP (StgAP *ap) +{ + ap->fun = evacuate(ap->fun); + return scavenge_PAP_payload (ap->fun, ap->payload, ap->n_args); +} + /* ----------------------------------------------------------------------------- Scavenge a given step until there are no more objects in this step to scavenge. @@ -2535,6 +2540,11 @@ scavenge(step *stp) case THUNK_2_0: scavenge_thunk_srt(info); + ((StgThunk *)p)->payload[1] = evacuate(((StgThunk *)p)->payload[1]); + ((StgThunk *)p)->payload[0] = evacuate(((StgThunk *)p)->payload[0]); + p += sizeofW(StgThunk) + 2; + break; + case CONSTR_2_0: ((StgClosure *)p)->payload[1] = evacuate(((StgClosure *)p)->payload[1]); ((StgClosure *)p)->payload[0] = evacuate(((StgClosure *)p)->payload[0]); @@ -2543,8 +2553,8 @@ scavenge(step *stp) case THUNK_1_0: scavenge_thunk_srt(info); - ((StgClosure *)p)->payload[0] = evacuate(((StgClosure *)p)->payload[0]); - p += sizeofW(StgHeader) + 1; + ((StgThunk *)p)->payload[0] = evacuate(((StgThunk *)p)->payload[0]); + p += sizeofW(StgThunk) + 1; break; case FUN_1_0: @@ -2556,7 +2566,7 @@ scavenge(step *stp) case THUNK_0_1: scavenge_thunk_srt(info); - p += sizeofW(StgHeader) + 1; + p += sizeofW(StgThunk) + 1; break; case FUN_0_1: @@ -2567,7 +2577,7 @@ scavenge(step *stp) case THUNK_0_2: scavenge_thunk_srt(info); - p += sizeofW(StgHeader) + 2; + p += sizeofW(StgThunk) + 2; break; case FUN_0_2: @@ -2578,8 +2588,8 @@ scavenge(step *stp) case THUNK_1_1: scavenge_thunk_srt(info); - ((StgClosure *)p)->payload[0] = evacuate(((StgClosure *)p)->payload[0]); - p += sizeofW(StgHeader) + 2; + ((StgThunk *)p)->payload[0] = evacuate(((StgThunk *)p)->payload[0]); + p += sizeofW(StgThunk) + 2; break; case FUN_1_1: @@ -2594,8 +2604,17 @@ scavenge(step *stp) goto gen_obj; case THUNK: + { + StgPtr end; + scavenge_thunk_srt(info); - // fall through + end = (P_)((StgThunk *)p)->payload + info->layout.payload.ptrs; + for (p = (P_)((StgThunk *)p)->payload; p < end; p++) { + *p = (StgWord)(StgPtr)evacuate((StgClosure *)*p); + } + p += info->layout.payload.nptrs; + break; + } gen_obj: case CONSTR: @@ -2680,10 +2699,13 @@ scavenge(step *stp) } case PAP: - case AP: p = scavenge_PAP((StgPAP *)p); break; + case AP: + p = scavenge_AP((StgAP *)p); + break; + case ARR_WORDS: // nothing to follow p += arr_words_sizeW((StgArrWords *)p); @@ -2914,6 +2936,10 @@ linear_scan: case THUNK_2_0: scavenge_thunk_srt(info); + ((StgThunk *)p)->payload[1] = evacuate(((StgThunk *)p)->payload[1]); + ((StgThunk *)p)->payload[0] = evacuate(((StgThunk *)p)->payload[0]); + break; + case CONSTR_2_0: ((StgClosure *)p)->payload[1] = evacuate(((StgClosure *)p)->payload[1]); ((StgClosure *)p)->payload[0] = evacuate(((StgClosure *)p)->payload[0]); @@ -2928,6 +2954,9 @@ linear_scan: case THUNK_1_0: case THUNK_1_1: scavenge_thunk_srt(info); + ((StgThunk *)p)->payload[0] = evacuate(((StgThunk *)p)->payload[0]); + break; + case CONSTR_1_0: case CONSTR_1_1: ((StgClosure *)p)->payload[0] = evacuate(((StgClosure *)p)->payload[0]); @@ -2952,8 +2981,16 @@ linear_scan: goto gen_obj; case THUNK: + { + StgPtr end; + scavenge_thunk_srt(info); - // fall through + end = (P_)((StgThunk *)p)->payload + info->layout.payload.ptrs; + for (p = (P_)((StgThunk *)p)->payload; p < end; p++) { + *p = (StgWord)(StgPtr)evacuate((StgClosure *)*p); + } + break; + } gen_obj: case CONSTR: @@ -3023,9 +3060,12 @@ linear_scan: } case PAP: - case AP: scavenge_PAP((StgPAP *)p); break; + + case AP: + scavenge_AP((StgAP *)p); + break; case MUT_ARR_PTRS: // follow everything @@ -3254,18 +3294,28 @@ scavenge_one(StgPtr p) break; } - case FUN: - case FUN_1_0: // hardly worth specialising these guys - case FUN_0_1: - case FUN_1_1: - case FUN_0_2: - case FUN_2_0: case THUNK: case THUNK_1_0: case THUNK_0_1: case THUNK_1_1: case THUNK_0_2: case THUNK_2_0: + { + StgPtr q, end; + + end = (StgPtr)((StgThunk *)p)->payload + info->layout.payload.ptrs; + for (q = (StgPtr)((StgThunk *)p)->payload; q < end; q++) { + *q = (StgWord)(StgPtr)evacuate((StgClosure *)*q); + } + break; + } + + case FUN: + case FUN_1_0: // hardly worth specialising these guys + case FUN_0_1: + case FUN_1_1: + case FUN_0_2: + case FUN_2_0: case CONSTR: case CONSTR_1_0: case CONSTR_0_1: @@ -3316,6 +3366,9 @@ scavenge_one(StgPtr p) } case PAP: + p = scavenge_AP((StgAP *)p); + break; + case AP: p = scavenge_PAP((StgPAP *)p); break; @@ -3582,8 +3635,8 @@ scavenge_static(void) /* Take this object *off* the static_objects list, * and put it on the scavenged_static_objects list. */ - static_objects = STATIC_LINK(info,p); - STATIC_LINK(info,p) = scavenged_static_objects; + static_objects = *STATIC_LINK(info,p); + *STATIC_LINK(info,p) = scavenged_static_objects; scavenged_static_objects = p; switch (info -> type) { @@ -3852,8 +3905,8 @@ zero_static_object_list(StgClosure* first_static) for (p = first_static; p != END_OF_STATIC_LIST; p = link) { info = get_itbl(p); - link = STATIC_LINK(info, p); - STATIC_LINK(info,p) = NULL; + link = *STATIC_LINK(info, p); + *STATIC_LINK(info,p) = NULL; } } diff --git a/ghc/rts/GCCompact.c b/ghc/rts/GCCompact.c index 9c03c71..43768c5 100644 --- a/ghc/rts/GCCompact.c +++ b/ghc/rts/GCCompact.c @@ -110,20 +110,22 @@ STATIC_INLINE nat obj_sizeW( StgClosure *p, StgInfoTable *info ) { switch (info->type) { + case THUNK_0_1: + case THUNK_1_0: + return sizeofW(StgThunk) + 1; case FUN_0_1: case CONSTR_0_1: case FUN_1_0: case CONSTR_1_0: - case THUNK_0_1: - case THUNK_1_0: return sizeofW(StgHeader) + 1; case THUNK_0_2: + case THUNK_1_1: + case THUNK_2_0: + return sizeofW(StgThunk) + 2; case FUN_0_2: case CONSTR_0_2: - case THUNK_1_1: case FUN_1_1: case CONSTR_1_1: - case THUNK_2_0: case FUN_2_0: case CONSTR_2_0: return sizeofW(StgHeader) + 2; @@ -171,17 +173,17 @@ thread_static( StgClosure* p ) case IND_STATIC: thread((StgPtr)&((StgInd *)p)->indirectee); - p = IND_STATIC_LINK(p); + p = *IND_STATIC_LINK(p); continue; case THUNK_STATIC: - p = THUNK_STATIC_LINK(p); + p = *THUNK_STATIC_LINK(p); continue; case FUN_STATIC: - p = FUN_STATIC_LINK(p); + p = *FUN_STATIC_LINK(p); continue; case CONSTR_STATIC: - p = STATIC_LINK(info,p); + p = *STATIC_LINK(info,p); continue; default: @@ -366,17 +368,16 @@ thread_stack(StgPtr p, StgPtr stack_end) } STATIC_INLINE StgPtr -thread_PAP (StgPAP *pap) +thread_PAP_payload (StgClosure *fun, StgClosure **payload, StgWord size) { StgPtr p; - StgWord bitmap, size; + StgWord bitmap; StgFunInfoTable *fun_info; - - fun_info = itbl_to_fun_itbl(get_threaded_info((StgPtr)pap->fun)); + + fun_info = itbl_to_fun_itbl(get_threaded_info((StgPtr)fun)); ASSERT(fun_info->i.type != PAP); - p = (StgPtr)pap->payload; - size = pap->n_args; + p = (StgPtr)payload; switch (fun_info->f.fun_type) { case ARG_GEN: @@ -387,13 +388,12 @@ thread_PAP (StgPAP *pap) p += size; break; case ARG_BCO: - thread_large_bitmap((StgPtr)pap->payload, BCO_BITMAP(pap->fun), size); + thread_large_bitmap((StgPtr)payload, BCO_BITMAP(fun), size); p += size; break; default: bitmap = BITMAP_BITS(stg_arg_bitmaps[fun_info->f.fun_type]); small_bitmap: - size = pap->n_args; while (size > 0) { if ((bitmap & 1) == 0) { thread(p); @@ -405,9 +405,26 @@ thread_PAP (StgPAP *pap) break; } + return p; +} + +STATIC_INLINE StgPtr +thread_PAP (StgPAP *pap) +{ + StgPtr p; + p = thread_PAP_payload(pap->fun, pap->payload, pap->n_args); thread((StgPtr)&pap->fun); return p; } + +STATIC_INLINE StgPtr +thread_AP (StgAP *ap) +{ + StgPtr p; + p = thread_PAP_payload(ap->fun, ap->payload, ap->n_args); + thread((StgPtr)&ap->fun); + return p; +} STATIC_INLINE StgPtr thread_AP_STACK (StgAP_STACK *ap) @@ -497,9 +514,11 @@ STATIC_INLINE StgPtr thread_obj (StgInfoTable *info, StgPtr p) { switch (info->type) { + case THUNK_0_1: + return p + sizeofW(StgThunk) + 1; + case FUN_0_1: case CONSTR_0_1: - case THUNK_0_1: return p + sizeofW(StgHeader) + 1; case FUN_1_0: @@ -508,21 +527,30 @@ thread_obj (StgInfoTable *info, StgPtr p) return p + sizeofW(StgHeader) + 1; case THUNK_1_0: - thread((StgPtr)&((StgClosure *)p)->payload[0]); - return p + sizeofW(StgHeader) + 1; + thread((StgPtr)&((StgThunk *)p)->payload[0]); + return p + sizeofW(StgThunk) + 1; case THUNK_0_2: + return p + sizeofW(StgThunk) + 2; + case FUN_0_2: case CONSTR_0_2: return p + sizeofW(StgHeader) + 2; case THUNK_1_1: + thread((StgPtr)&((StgThunk *)p)->payload[0]); + return p + sizeofW(StgThunk) + 2; + case FUN_1_1: case CONSTR_1_1: thread((StgPtr)&((StgClosure *)p)->payload[0]); return p + sizeofW(StgHeader) + 2; case THUNK_2_0: + thread((StgPtr)&((StgThunk *)p)->payload[0]); + thread((StgPtr)&((StgThunk *)p)->payload[1]); + return p + sizeofW(StgThunk) + 2; + case FUN_2_0: case CONSTR_2_0: thread((StgPtr)&((StgClosure *)p)->payload[0]); @@ -538,8 +566,19 @@ thread_obj (StgInfoTable *info, StgPtr p) return p + bco_sizeW(bco); } - case FUN: case THUNK: + { + StgPtr end; + + end = (P_)((StgThunk *)p)->payload + + info->layout.payload.ptrs; + for (p = (P_)((StgThunk *)p)->payload; p < end; p++) { + thread(p); + } + return p + info->layout.payload.nptrs; + } + + case FUN: case CONSTR: case FOREIGN: case STABLE_NAME: @@ -597,8 +636,10 @@ thread_obj (StgInfoTable *info, StgPtr p) return thread_AP_STACK((StgAP_STACK *)p); case PAP: - case AP: return thread_PAP((StgPAP *)p); + + case AP: + return thread_AP((StgAP *)p); case ARR_WORDS: return p + arr_words_sizeW((StgArrWords *)p); diff --git a/ghc/rts/LdvProfile.c b/ghc/rts/LdvProfile.c index d945008..9d21f6a 100644 --- a/ghc/rts/LdvProfile.c +++ b/ghc/rts/LdvProfile.c @@ -48,22 +48,25 @@ LDV_recordDead_FILL_SLOP_DYNAMIC( StgClosure *p ) switch (info->type) { case THUNK_1_0: case THUNK_0_1: + nw = stg_max(MIN_UPD_SIZE,1); + break; + case THUNK_2_0: case THUNK_1_1: case THUNK_0_2: case THUNK_SELECTOR: - nw = MIN_UPD_SIZE; + nw = stg_max(MIN_UPD_SIZE,2); break; + case THUNK: - nw = info->layout.payload.ptrs + info->layout.payload.nptrs; - if (nw < MIN_UPD_SIZE) - nw = MIN_UPD_SIZE; + nw = stg_max(info->layout.payload.ptrs + info->layout.payload.nptrs, + MIN_UPD_SIZE); break; case AP: - nw = sizeofW(StgPAP) - sizeofW(StgHeader) + ((StgPAP *)p)->n_args; + nw = sizeofW(StgAP) - sizeofW(StgThunkHeader) + ((StgPAP *)p)->n_args; break; case AP_STACK: - nw = sizeofW(StgAP_STACK) - sizeofW(StgHeader) + nw = sizeofW(StgAP_STACK) - sizeofW(StgThunkHeader) + ((StgAP_STACK *)p)->size; break; case CAF_BLACKHOLE: @@ -150,14 +153,20 @@ processHeapClosureForDead( StgClosure *c ) case THUNK_1_0: case THUNK_0_1: + case THUNK_SELECTOR: + size = sizeofW(StgHeader) + stg_max(MIN_UPD_SIZE, 1); + break; + case THUNK_2_0: case THUNK_1_1: case THUNK_0_2: - case THUNK_SELECTOR: - size = sizeofW(StgHeader) + MIN_UPD_SIZE; + size = sizeofW(StgHeader) + stg_max(MIN_UPD_SIZE, 2); break; case AP: + size = ap_sizeW((StgAP *)c); + break; + case PAP: size = pap_sizeW((StgPAP *)c); break; diff --git a/ghc/rts/Printer.c b/ghc/rts/Printer.c index 1bbdb35..ef474f3 100644 --- a/ghc/rts/Printer.c +++ b/ghc/rts/Printer.c @@ -97,12 +97,36 @@ printStdObjPayload( StgClosure *obj ) } static void +printThunkPayload( StgThunk *obj ) +{ + StgWord i, j; + const StgInfoTable* info; + + info = get_itbl(obj); + for (i = 0; i < info->layout.payload.ptrs; ++i) { + debugBelch(", "); + printPtr((StgPtr)obj->payload[i]); + } + for (j = 0; j < info->layout.payload.nptrs; ++j) { + debugBelch(", %pd#",obj->payload[i+j]); + } + debugBelch(")\n"); +} + +static void printStdObject( StgClosure *obj, char* tag ) { printStdObjHdr( obj, tag ); printStdObjPayload( obj ); } +static void +printThunkObject( StgThunk *obj, char* tag ) +{ + printStdObjHdr( (StgClosure *)obj, tag ); + printThunkPayload( obj ); +} + void printClosure( StgClosure *obj ) { @@ -163,9 +187,9 @@ printClosure( StgClosure *obj ) case THUNK_STATIC: /* ToDo: will this work for THUNK_STATIC too? */ #ifdef PROFILING - printStdObject(obj,info->prof.closure_desc); + printThunkObject((StgThunk *)obj,info->prof.closure_desc); #else - printStdObject(obj,"THUNK"); + printThunkObject((StgThunk *)obj,"THUNK"); #endif break; @@ -180,7 +204,7 @@ printClosure( StgClosure *obj ) case AP: { - StgPAP* ap = stgCast(StgPAP*,obj); + StgAP* ap = stgCast(StgAP*,obj); StgWord i; debugBelch("AP("); printPtr((StgPtr)ap->fun); for (i = 0; i < ap->n_args; ++i) { diff --git a/ghc/rts/ProfHeap.c b/ghc/rts/ProfHeap.c index 482895f..70cafde 100644 --- a/ghc/rts/ProfHeap.c +++ b/ghc/rts/ProfHeap.c @@ -867,9 +867,24 @@ heapCensusChain( Census *census, bdescr *bd ) switch (info->type) { + case THUNK: + size = thunk_sizeW_fromITBL(info); + break; + + case THUNK_1_1: + case THUNK_0_2: + case THUNK_2_0: + size = sizeofW(StgHeader) + stg_max(MIN_UPD_SIZE,2); + break; + + case THUNK_1_0: + case THUNK_0_1: + case THUNK_SELECTOR: + size = sizeofW(StgHeader) + stg_max(MIN_UPD_SIZE,1); + break; + case CONSTR: case FUN: - case THUNK: case IND_PERM: case IND_OLDGEN: case IND_OLDGEN_PERM: @@ -884,9 +899,6 @@ heapCensusChain( Census *census, bdescr *bd ) case FUN_1_1: case FUN_0_2: case FUN_2_0: - case THUNK_1_1: - case THUNK_0_2: - case THUNK_2_0: case CONSTR_1_0: case CONSTR_0_1: case CONSTR_1_1: @@ -909,13 +921,10 @@ heapCensusChain( Census *census, bdescr *bd ) size = sizeW_fromITBL(info); break; - case THUNK_1_0: /* ToDo - shouldn't be here */ - case THUNK_0_1: /* " ditto " */ - case THUNK_SELECTOR: - size = sizeofW(StgHeader) + MIN_UPD_SIZE; + case AP: + size = ap_sizeW((StgAP *)p); break; - case AP: case PAP: size = pap_sizeW((StgPAP *)p); break; diff --git a/ghc/rts/RetainerProfile.c b/ghc/rts/RetainerProfile.c index dfa77b0..3d51dcf 100644 --- a/ghc/rts/RetainerProfile.c +++ b/ghc/rts/RetainerProfile.c @@ -543,7 +543,8 @@ push( StgClosure *c, retainer c_child_r, StgClosure **first_child ) case THUNK: case THUNK_2_0: - init_ptrs(&se.info, get_itbl(c)->layout.payload.ptrs, (StgPtr)c->payload); + init_ptrs(&se.info, get_itbl(c)->layout.payload.ptrs, + (StgPtr)((StgThunk *)c)->payload); *first_child = find_ptrs(&se.info); if (*first_child == NULL) // no child from ptrs, so check SRT @@ -560,7 +561,7 @@ push( StgClosure *c, retainer c_child_r, StgClosure **first_child ) case THUNK_1_0: case THUNK_1_1: - *first_child = c->payload[0]; + *first_child = ((StgThunk *)c)->payload[0]; ASSERT(*first_child != NULL); init_srt_thunk(&se.info, get_thunk_itbl(c)); break; @@ -1409,39 +1410,38 @@ retainStack( StgClosure *c, retainer c_child_r, * ------------------------------------------------------------------------- */ static INLINE StgPtr -retain_PAP (StgPAP *pap, retainer c_child_r) +retain_PAP_payload (StgClosure *pap, retainer c_child_r, StgClosure *fun, + StgClosure** payload, StgWord n_args) { StgPtr p; - StgWord bitmap, size; + StgWord bitmap; StgFunInfoTable *fun_info; - retainClosure(pap->fun, (StgClosure *)pap, c_child_r); - fun_info = get_fun_itbl(pap->fun); + retainClosure(fun, pap, c_child_r); + fun_info = get_fun_itbl(fun); ASSERT(fun_info->i.type != PAP); - p = (StgPtr)pap->payload; - size = pap->n_args; + p = (StgPtr)payload; switch (fun_info->f.fun_type) { case ARG_GEN: bitmap = BITMAP_BITS(fun_info->f.b.bitmap); - p = retain_small_bitmap(p, pap->n_args, bitmap, - (StgClosure *)pap, c_child_r); + p = retain_small_bitmap(p, n_args, bitmap, + pap, c_child_r); break; case ARG_GEN_BIG: retain_large_bitmap(p, GET_FUN_LARGE_BITMAP(fun_info), - size, (StgClosure *)pap, c_child_r); - p += size; + n_args, pap, c_child_r); + p += n_args; break; case ARG_BCO: - retain_large_bitmap((StgPtr)pap->payload, BCO_BITMAP(pap->fun), - size, (StgClosure *)pap, c_child_r); - p += size; + retain_large_bitmap((StgPtr)payload, BCO_BITMAP(fun), + n_args, pap, c_child_r); + p += n_args; break; default: bitmap = BITMAP_BITS(stg_arg_bitmaps[fun_info->f.fun_type]); - p = retain_small_bitmap(p, pap->n_args, bitmap, - (StgClosure *)pap, c_child_r); + p = retain_small_bitmap(p, n_args, bitmap, pap, c_child_r); break; } return p; @@ -1679,9 +1679,18 @@ inner_loop: goto loop; case PAP: + { + StgPAP *pap = (StgPAP *)c; + retain_PAP_payload(c, c_child_r, pap->fun, pap->payload, pap->n_args); + goto loop; + } + case AP: - retain_PAP((StgPAP *)c, c_child_r); + { + StgAP *ap = (StgAP *)c; + retain_PAP_payload(c, c_child_r, ap->fun, ap->payload, ap->n_args); goto loop; + } case AP_STACK: retainClosure(((StgAP_STACK *)c)->fun, c, c_child_r); diff --git a/ghc/rts/Sanity.c b/ghc/rts/Sanity.c index 410df74..a3bd96f 100644 --- a/ghc/rts/Sanity.c +++ b/ghc/rts/Sanity.c @@ -202,6 +202,40 @@ checkStackChunk( StgPtr sp, StgPtr stack_end ) // ASSERT( p == stack_end ); -- HWL } +static void +checkPAP (StgClosure *fun, StgClosure** payload, StgWord n_args) +{ + StgClosure *p; + StgFunInfoTable *fun_info; + + ASSERT(LOOKS_LIKE_CLOSURE_PTR(fun)); + fun_info = get_fun_itbl(fun); + + p = (StgClosure *)payload; + switch (fun_info->f.fun_type) { + case ARG_GEN: + checkSmallBitmap( (StgPtr)payload, + BITMAP_BITS(fun_info->f.b.bitmap), n_args ); + break; + case ARG_GEN_BIG: + checkLargeBitmap( (StgPtr)payload, + GET_FUN_LARGE_BITMAP(fun_info), + n_args ); + break; + case ARG_BCO: + checkLargeBitmap( (StgPtr)payload, + BCO_BITMAP(fun), + n_args ); + break; + default: + checkSmallBitmap( (StgPtr)payload, + BITMAP_BITS(stg_arg_bitmaps[fun_info->f.fun_type]), + n_args ); + break; + } +} + + StgOffset checkClosure( StgClosure* p ) { @@ -244,9 +278,9 @@ checkClosure( StgClosure* p ) { nat i; for (i = 0; i < info->layout.payload.ptrs; i++) { - ASSERT(LOOKS_LIKE_CLOSURE_PTR(p->payload[i])); + ASSERT(LOOKS_LIKE_CLOSURE_PTR(((StgThunk *)p)->payload[i])); } - return stg_max(sizeW_fromITBL(info), sizeofW(StgHeader) + MIN_UPD_SIZE); + return stg_max(sizeW_fromITBL(info), sizeofW(StgHeader)+MIN_UPD_SIZE); } case FUN: @@ -345,39 +379,19 @@ checkClosure( StgClosure* p ) case CATCH_STM_FRAME: barf("checkClosure: stack frame"); - case AP: /* we can treat this as being the same as a PAP */ + case AP: + { + StgAP* ap = (StgAP *)p; + checkPAP (ap->fun, ap->payload, ap->n_args); + return ap_sizeW(ap); + } + case PAP: - { - StgFunInfoTable *fun_info; - StgPAP* pap = (StgPAP *)p; - - ASSERT(LOOKS_LIKE_CLOSURE_PTR(pap->fun)); - fun_info = get_fun_itbl(pap->fun); - - p = (StgClosure *)pap->payload; - switch (fun_info->f.fun_type) { - case ARG_GEN: - checkSmallBitmap( (StgPtr)pap->payload, - BITMAP_BITS(fun_info->f.b.bitmap), pap->n_args ); - break; - case ARG_GEN_BIG: - checkLargeBitmap( (StgPtr)pap->payload, - GET_FUN_LARGE_BITMAP(fun_info), - pap->n_args ); - break; - case ARG_BCO: - checkLargeBitmap( (StgPtr)pap->payload, - BCO_BITMAP(pap->fun), - pap->n_args ); - break; - default: - checkSmallBitmap( (StgPtr)pap->payload, - BITMAP_BITS(stg_arg_bitmaps[fun_info->f.fun_type]), - pap->n_args ); - break; - } - return pap_sizeW(pap); - } + { + StgPAP* pap = (StgPAP *)p; + checkPAP (pap->fun, pap->payload, pap->n_args); + return pap_sizeW(pap); + } case AP_STACK: { @@ -791,20 +805,20 @@ checkStaticObjects ( StgClosure* static_objects ) ASSERT(LOOKS_LIKE_CLOSURE_PTR(indirectee)); ASSERT(LOOKS_LIKE_INFO_PTR(indirectee->header.info)); - p = IND_STATIC_LINK((StgClosure *)p); + p = *IND_STATIC_LINK((StgClosure *)p); break; } case THUNK_STATIC: - p = THUNK_STATIC_LINK((StgClosure *)p); + p = *THUNK_STATIC_LINK((StgClosure *)p); break; case FUN_STATIC: - p = FUN_STATIC_LINK((StgClosure *)p); + p = *FUN_STATIC_LINK((StgClosure *)p); break; case CONSTR_STATIC: - p = STATIC_LINK(info,(StgClosure *)p); + p = *STATIC_LINK(info,(StgClosure *)p); break; default: diff --git a/ghc/rts/Schedule.c b/ghc/rts/Schedule.c index 079238d..ed76cb0 100644 --- a/ghc/rts/Schedule.c +++ b/ghc/rts/Schedule.c @@ -3782,7 +3782,7 @@ raiseAsync_(StgTSO *tso, StgClosure *exception, rtsBool stop_at_atomically) // fun field. // words = frame - sp - 1; - ap = (StgAP_STACK *)allocate(PAP_sizeW(words)); + ap = (StgAP_STACK *)allocate(AP_STACK_sizeW(words)); ap->size = words; ap->fun = (StgClosure *)sp[0]; diff --git a/ghc/rts/StgStdThunks.cmm b/ghc/rts/StgStdThunks.cmm index 386036a..4da4248 100644 --- a/ghc/rts/StgStdThunks.cmm +++ b/ghc/rts/StgStdThunks.cmm @@ -44,7 +44,7 @@ #define SELECTOR_CODE_UPD(offset) \ INFO_TABLE_RET(stg_sel_ret_##offset##_upd, RET_FRAMESIZE, RET_BITMAP, RET_SMALL) \ { \ - R1 = StgClosure_payload(R1,offset); \ + R1 = StgClosure_payload(R1,offset); \ GET_SAVED_CCCS; \ Sp = Sp + SIZEOF_StgHeader; \ ENTER(); \ @@ -60,7 +60,7 @@ ENTER_CCS_THUNK(R1); \ SAVE_CCCS(WITHUPD_FRAME_SIZE); \ W_[Sp-WITHUPD_FRAME_SIZE] = stg_sel_ret_##offset##_upd_info; \ - R1 = StgClosure_payload(R1,0); \ + R1 = StgThunk_payload(R1,0); \ Sp = Sp - WITHUPD_FRAME_SIZE; \ jump %GET_ENTRY(R1); \ } @@ -87,7 +87,7 @@ SELECTOR_CODE_UPD(15) #define SELECTOR_CODE_NOUPD(offset) \ INFO_TABLE_RET(stg_sel_ret_##offset##_noupd, RET_FRAMESIZE, RET_BITMAP, RET_SMALL) \ { \ - R1 = StgClosure_payload(R1,offset); \ + R1 = StgClosure_payload(R1,offset); \ GET_SAVED_CCCS; \ Sp = Sp + SIZEOF_StgHeader; \ jump %GET_ENTRY(R1); \ @@ -100,10 +100,10 @@ SELECTOR_CODE_UPD(15) UPD_BH_SINGLE_ENTRY(); \ LDV_ENTER(R1); \ TICK_UPDF_OMITTED(); \ - ENTER_CCS_THUNK(R1); \ + ENTER_CCS_THUNK(R1); \ SAVE_CCCS(NOUPD_FRAME_SIZE); \ W_[Sp-NOUPD_FRAME_SIZE] = stg_sel_ret_##offset##_noupd_info; \ - R1 = StgClosure_payload(R1,0); \ + R1 = StgThunk_payload(R1,0); \ Sp = Sp - NOUPD_FRAME_SIZE; \ jump %GET_ENTRY(R1); \ } @@ -151,7 +151,7 @@ INFO_TABLE(stg_ap_1_upd,1,1,THUNK_1_0,"stg_ap_1_upd_info","stg_ap_1_upd_info") LDV_ENTER(R1); ENTER_CCS_THUNK(R1); PUSH_UPD_FRAME(Sp-SIZEOF_StgUpdateFrame,R1); - R1 = StgClosure_payload(R1,0); + R1 = StgThunk_payload(R1,0); Sp = Sp - SIZEOF_StgUpdateFrame; Sp_adj(-1); // for stg_ap_0_ret jump RET_LBL(stg_ap_0); @@ -165,8 +165,8 @@ INFO_TABLE(stg_ap_2_upd,2,0,THUNK_2_0,"stg_ap_2_upd_info","stg_ap_2_upd_info") LDV_ENTER(R1); ENTER_CCS_THUNK(R1); PUSH_UPD_FRAME(Sp-SIZEOF_StgUpdateFrame,R1); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(1)] = StgClosure_payload(R1,1); - R1 = StgClosure_payload(R1,0); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(1)] = StgThunk_payload(R1,1); + R1 = StgThunk_payload(R1,0); Sp = Sp - SIZEOF_StgUpdateFrame - WDS(1); Sp_adj(-1); // for stg_ap_0_ret TICK_UNKNOWN_CALL(); @@ -182,9 +182,9 @@ INFO_TABLE(stg_ap_3_upd,3,0,THUNK,"stg_ap_3_upd_info","stg_ap_3_upd_info") LDV_ENTER(R1); ENTER_CCS_THUNK(R1); PUSH_UPD_FRAME(Sp-SIZEOF_StgUpdateFrame,R1); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(1)] = StgClosure_payload(R1,2); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(2)] = StgClosure_payload(R1,1); - R1 = StgClosure_payload(R1,0); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(1)] = StgThunk_payload(R1,2); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(2)] = StgThunk_payload(R1,1); + R1 = StgThunk_payload(R1,0); Sp = Sp - SIZEOF_StgUpdateFrame - WDS(2); Sp_adj(-1); // for stg_ap_0_ret TICK_UNKNOWN_CALL(); @@ -200,10 +200,10 @@ INFO_TABLE(stg_ap_4_upd,4,0,THUNK,"stg_ap_4_upd_info","stg_ap_4_upd_info") LDV_ENTER(R1); ENTER_CCS_THUNK(R1); PUSH_UPD_FRAME(Sp-SIZEOF_StgUpdateFrame,R1); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(1)] = StgClosure_payload(R1,3); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(2)] = StgClosure_payload(R1,2); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(3)] = StgClosure_payload(R1,1); - R1 = StgClosure_payload(R1,0); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(1)] = StgThunk_payload(R1,3); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(2)] = StgThunk_payload(R1,2); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(3)] = StgThunk_payload(R1,1); + R1 = StgThunk_payload(R1,0); Sp = Sp - SIZEOF_StgUpdateFrame - WDS(3); Sp_adj(-1); // for stg_ap_0_ret TICK_UNKNOWN_CALL(); @@ -219,11 +219,11 @@ INFO_TABLE(stg_ap_5_upd,5,0,THUNK,"stg_ap_5_upd_info","stg_ap_5_upd_info") LDV_ENTER(R1); ENTER_CCS_THUNK(R1); PUSH_UPD_FRAME(Sp-SIZEOF_StgUpdateFrame,R1); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(1)] = StgClosure_payload(R1,4); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(2)] = StgClosure_payload(R1,3); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(3)] = StgClosure_payload(R1,2); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(4)] = StgClosure_payload(R1,1); - R1 = StgClosure_payload(R1,0); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(1)] = StgThunk_payload(R1,4); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(2)] = StgThunk_payload(R1,3); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(3)] = StgThunk_payload(R1,2); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(4)] = StgThunk_payload(R1,1); + R1 = StgThunk_payload(R1,0); Sp = Sp - SIZEOF_StgUpdateFrame - WDS(4); Sp_adj(-1); // for stg_ap_0_ret TICK_UNKNOWN_CALL(); @@ -239,12 +239,12 @@ INFO_TABLE(stg_ap_6_upd,6,0,THUNK,"stg_ap_6_upd_info","stg_ap_6_upd_info") LDV_ENTER(R1); ENTER_CCS_THUNK(R1); PUSH_UPD_FRAME(Sp-SIZEOF_StgUpdateFrame,R1); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(1)] = StgClosure_payload(R1,5); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(2)] = StgClosure_payload(R1,4); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(3)] = StgClosure_payload(R1,3); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(4)] = StgClosure_payload(R1,2); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(5)] = StgClosure_payload(R1,1); - R1 = StgClosure_payload(R1,0); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(1)] = StgThunk_payload(R1,5); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(2)] = StgThunk_payload(R1,4); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(3)] = StgThunk_payload(R1,3); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(4)] = StgThunk_payload(R1,2); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(5)] = StgThunk_payload(R1,1); + R1 = StgThunk_payload(R1,0); Sp = Sp - SIZEOF_StgUpdateFrame - WDS(5); Sp_adj(-1); // for stg_ap_0_ret TICK_UNKNOWN_CALL(); @@ -260,13 +260,13 @@ INFO_TABLE(stg_ap_7_upd,7,0,THUNK,"stg_ap_7_upd_info","stg_ap_7_upd_info") LDV_ENTER(R1); ENTER_CCS_THUNK(R1); PUSH_UPD_FRAME(Sp-SIZEOF_StgUpdateFrame,R1); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(1)] = StgClosure_payload(R1,6); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(2)] = StgClosure_payload(R1,5); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(3)] = StgClosure_payload(R1,4); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(4)] = StgClosure_payload(R1,3); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(5)] = StgClosure_payload(R1,2); - W_[Sp-SIZEOF_StgUpdateFrame-WDS(6)] = StgClosure_payload(R1,1); - R1 = StgClosure_payload(R1,0); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(1)] = StgThunk_payload(R1,6); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(2)] = StgThunk_payload(R1,5); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(3)] = StgThunk_payload(R1,4); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(4)] = StgThunk_payload(R1,3); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(5)] = StgThunk_payload(R1,2); + W_[Sp-SIZEOF_StgUpdateFrame-WDS(6)] = StgThunk_payload(R1,1); + R1 = StgThunk_payload(R1,0); Sp = Sp - SIZEOF_StgUpdateFrame - WDS(6); Sp_adj(-1); // for stg_ap_0_ret TICK_UNKNOWN_CALL(); -- 1.7.10.4