diff options
Diffstat (limited to 'rts')
| -rw-r--r-- | rts/Exception.cmm | 6 | ||||
| -rw-r--r-- | rts/Interpreter.c | 2 | ||||
| -rw-r--r-- | rts/Linker.c | 4 | ||||
| -rw-r--r-- | rts/Prelude.h | 86 | ||||
| -rw-r--r-- | rts/PrimOps.cmm | 8 | ||||
| -rw-r--r-- | rts/RaiseAsync.c | 4 | ||||
| -rw-r--r-- | rts/RetainerProfile.c | 2 | ||||
| -rw-r--r-- | rts/STM.c | 4 | ||||
| -rw-r--r-- | rts/STM.h | 8 | ||||
| -rw-r--r-- | rts/StgMiscClosures.cmm | 4 | ||||
| -rw-r--r-- | rts/Weak.c | 6 | ||||
| -rw-r--r-- | rts/package.conf.in | 72 | ||||
| -rw-r--r-- | rts/posix/Signals.c | 4 | ||||
| -rw-r--r-- | rts/sm/Storage.c | 4 | ||||
| -rw-r--r-- | rts/win32/libHSbase.def | 34 |
15 files changed, 126 insertions, 122 deletions
diff --git a/rts/Exception.cmm b/rts/Exception.cmm index bc55911687..8533e3e35e 100644 --- a/rts/Exception.cmm +++ b/rts/Exception.cmm @@ -13,7 +13,7 @@ #include "Cmm.h" #include "RaiseAsync.h" -import ghczmprim_GHCziTypes_True_closure; +import ghczmprim_GHCziTypes_True_static_closure; /* ----------------------------------------------------------------------------- Exception Primitives @@ -527,8 +527,8 @@ retry_pop_stack: Sp(5) = exception; Sp(4) = stg_raise_ret_info; Sp(3) = exception; // the AP_STACK - Sp(2) = ghczmprim_GHCziTypes_True_closure; // dummy breakpoint info - Sp(1) = ghczmprim_GHCziTypes_True_closure; // True <=> a breakpoint + Sp(2) = STATIC_CLOSURE(ghczmprim_GHCziTypes_True); // dummy breakpoint info + Sp(1) = STATIC_CLOSURE(ghczmprim_GHCziTypes_True); // True <=> a breakpoint R1 = ioAction; jump RET_LBL(stg_ap_pppv) [R1]; } diff --git a/rts/Interpreter.c b/rts/Interpreter.c index f4fe816d28..6fe1fcabab 100644 --- a/rts/Interpreter.c +++ b/rts/Interpreter.c @@ -879,7 +879,7 @@ run_BCO: new_aps = (StgAP_STACK *) allocate(cap, AP_STACK_sizeW(size_words)); SET_HDR(new_aps,&stg_AP_STACK_info,CCS_SYSTEM); new_aps->size = size_words; - new_aps->fun = &stg_dummy_ret_closure; + new_aps->fun = stg_dummy_ret_closure; // fill in the payload of the AP_STACK new_aps->payload[0] = (StgClosure *)&stg_apply_interp_info; diff --git a/rts/Linker.c b/rts/Linker.c index 21e5ebe97c..9897557530 100644 --- a/rts/Linker.c +++ b/rts/Linker.c @@ -1044,8 +1044,8 @@ typedef struct _RtsSymbolVal { #define RTS_INTCHAR_SYMBOLS #else #define RTS_INTCHAR_SYMBOLS \ - SymI_HasProto(stg_CHARLIKE_closure) \ - SymI_HasProto(stg_INTLIKE_closure) + SymI_HasProto(stg_CHARLIKE_static_closure) \ + SymI_HasProto(stg_INTLIKE_static_closure) #endif diff --git a/rts/Prelude.h b/rts/Prelude.h index 0c54148ba2..b2f9d994e7 100644 --- a/rts/Prelude.h +++ b/rts/Prelude.h @@ -14,42 +14,42 @@ */ #if IN_STG_CODE #define PRELUDE_INFO(i) extern W_(i)[] -#define PRELUDE_CLOSURE(i) extern W_(i)[] +#define PRELUDE_CLOSURE(i) extern W_(i ## _static_closure)[] #else #define PRELUDE_INFO(i) extern const StgInfoTable DLL_IMPORT_DATA_VARNAME(i) -#define PRELUDE_CLOSURE(i) extern StgClosure DLL_IMPORT_DATA_VARNAME(i) +#define PRELUDE_CLOSURE(i) extern StgClosure DLL_IMPORT_DATA_VARNAME(i ## _static_closure) #endif /* Define canonical names so we can abstract away from the actual * modules these names are defined in. */ -PRELUDE_CLOSURE(ghczmprim_GHCziTypes_True_closure); -PRELUDE_CLOSURE(ghczmprim_GHCziTypes_False_closure); -PRELUDE_CLOSURE(base_GHCziPack_unpackCString_closure); -PRELUDE_CLOSURE(base_GHCziWeak_runFinalizzerBatch_closure); +PRELUDE_CLOSURE(ghczmprim_GHCziTypes_True); +PRELUDE_CLOSURE(ghczmprim_GHCziTypes_False); +PRELUDE_CLOSURE(base_GHCziPack_unpackCString); +PRELUDE_CLOSURE(base_GHCziWeak_runFinalizzerBatch); #ifdef IN_STG_CODE -extern W_ ZCMain_main_closure[]; +extern W_ ZCMain_main_static_closure[]; #else -extern StgClosure ZCMain_main_closure; +extern StgClosure ZCMain_main_static_closure; #endif -PRELUDE_CLOSURE(base_GHCziIOziException_stackOverflow_closure); -PRELUDE_CLOSURE(base_GHCziIOziException_heapOverflow_closure); -PRELUDE_CLOSURE(base_GHCziIOziException_blockedIndefinitelyOnThrowTo_closure); -PRELUDE_CLOSURE(base_GHCziIOziException_blockedIndefinitelyOnMVar_closure); -PRELUDE_CLOSURE(base_GHCziIOziException_blockedIndefinitelyOnSTM_closure); -PRELUDE_CLOSURE(base_ControlziExceptionziBase_nonTermination_closure); -PRELUDE_CLOSURE(base_ControlziExceptionziBase_nestedAtomically_closure); -PRELUDE_CLOSURE(base_GHCziEventziThread_blockedOnBadFD_closure); +PRELUDE_CLOSURE(base_GHCziIOziException_stackOverflow); +PRELUDE_CLOSURE(base_GHCziIOziException_heapOverflow); +PRELUDE_CLOSURE(base_GHCziIOziException_blockedIndefinitelyOnThrowTo); +PRELUDE_CLOSURE(base_GHCziIOziException_blockedIndefinitelyOnMVar); +PRELUDE_CLOSURE(base_GHCziIOziException_blockedIndefinitelyOnSTM); +PRELUDE_CLOSURE(base_ControlziExceptionziBase_nonTermination); +PRELUDE_CLOSURE(base_ControlziExceptionziBase_nestedAtomically); +PRELUDE_CLOSURE(base_GHCziEventziThread_blockedOnBadFD); -PRELUDE_CLOSURE(base_GHCziConcziSync_runSparks_closure); -PRELUDE_CLOSURE(base_GHCziConcziIO_ensureIOManagerIsRunning_closure); -PRELUDE_CLOSURE(base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure); -PRELUDE_CLOSURE(base_GHCziConcziSignal_runHandlers_closure); +PRELUDE_CLOSURE(base_GHCziConcziSync_runSparks); +PRELUDE_CLOSURE(base_GHCziConcziIO_ensureIOManagerIsRunning); +PRELUDE_CLOSURE(base_GHCziConcziIO_ioManagerCapabilitiesChanged); +PRELUDE_CLOSURE(base_GHCziConcziSignal_runHandlers); -PRELUDE_CLOSURE(base_GHCziTopHandler_flushStdHandles_closure); +PRELUDE_CLOSURE(base_GHCziTopHandler_flushStdHandles); PRELUDE_INFO(ghczmprim_GHCziTypes_Czh_static_info); PRELUDE_INFO(ghczmprim_GHCziTypes_Izh_static_info); @@ -86,26 +86,30 @@ PRELUDE_INFO(base_GHCziWord_W64zh_con_info); PRELUDE_INFO(base_GHCziStable_StablePtr_static_info); PRELUDE_INFO(base_GHCziStable_StablePtr_con_info); -#define True_closure DLL_IMPORT_DATA_REF(ghczmprim_GHCziTypes_True_closure) -#define False_closure DLL_IMPORT_DATA_REF(ghczmprim_GHCziTypes_False_closure) -#define unpackCString_closure DLL_IMPORT_DATA_REF(base_GHCziPack_unpackCString_closure) -#define runFinalizerBatch_closure DLL_IMPORT_DATA_REF(base_GHCziWeak_runFinalizzerBatch_closure) -#define mainIO_closure (&ZCMain_main_closure) - -#define runSparks_closure DLL_IMPORT_DATA_REF(base_GHCziConcziSync_runSparks_closure) -#define ensureIOManagerIsRunning_closure DLL_IMPORT_DATA_REF(base_GHCziConcziIO_ensureIOManagerIsRunning_closure) -#define ioManagerCapabilitiesChanged_closure DLL_IMPORT_DATA_REF(base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure) -#define runHandlers_closure DLL_IMPORT_DATA_REF(base_GHCziConcziSignal_runHandlers_closure) - -#define flushStdHandles_closure DLL_IMPORT_DATA_REF(base_GHCziTopHandler_flushStdHandles_closure) - -#define stackOverflow_closure DLL_IMPORT_DATA_REF(base_GHCziIOziException_stackOverflow_closure) -#define heapOverflow_closure DLL_IMPORT_DATA_REF(base_GHCziIOziException_heapOverflow_closure) -#define blockedIndefinitelyOnMVar_closure DLL_IMPORT_DATA_REF(base_GHCziIOziException_blockedIndefinitelyOnMVar_closure) -#define blockedIndefinitelyOnSTM_closure DLL_IMPORT_DATA_REF(base_GHCziIOziException_blockedIndefinitelyOnSTM_closure) -#define nonTermination_closure DLL_IMPORT_DATA_REF(base_ControlziExceptionziBase_nonTermination_closure) -#define nestedAtomically_closure DLL_IMPORT_DATA_REF(base_ControlziExceptionziBase_nestedAtomically_closure) -#define blockedOnBadFD_closure DLL_IMPORT_DATA_REF(base_GHCziEventziThread_blockedOnBadFD_closure) +#define mainIO_closure (STATIC_CLOSURE(ZCMain_main)) + +// XXX update me +#define IMPORT_CLOSURE(name) DLL_IMPORT_DATA_REF(name ## _static_closure) + +#define True_closure IMPORT_CLOSURE(ghczmprim_GHCziTypes_True) +#define False_closure IMPORT_CLOSURE(ghczmprim_GHCziTypes_False) +#define unpackCString_closure IMPORT_CLOSURE(base_GHCziPack_unpackCString) +#define runFinalizerBatch_closure IMPORT_CLOSURE(base_GHCziWeak_runFinalizzerBatch) + +#define runSparks_closure IMPORT_CLOSURE(base_GHCziConcziSync_runSparks) +#define ensureIOManagerIsRunning_closure IMPORT_CLOSURE(base_GHCziConcziIO_ensureIOManagerIsRunning) +#define ioManagerCapabilitiesChanged_closure IMPORT_CLOSURE(base_GHCziConcziIO_ioManagerCapabilitiesChanged) +#define runHandlers_closure IMPORT_CLOSURE(base_GHCziConcziSignal_runHandlers) + +#define flushStdHandles_closure IMPORT_CLOSURE(base_GHCziTopHandler_flushStdHandles) + +#define stackOverflow_closure IMPORT_CLOSURE(base_GHCziIOziException_stackOverflow) +#define heapOverflow_closure IMPORT_CLOSURE(base_GHCziIOziException_heapOverflow) +#define blockedIndefinitelyOnMVar_closure IMPORT_CLOSURE(base_GHCziIOziException_blockedIndefinitelyOnMVar) +#define blockedIndefinitelyOnSTM_closure IMPORT_CLOSURE(base_GHCziIOziException_blockedIndefinitelyOnSTM) +#define nonTermination_closure IMPORT_CLOSURE(base_ControlziExceptionziBase_nonTermination) +#define nestedAtomically_closure IMPORT_CLOSURE(base_ControlziExceptionziBase_nestedAtomically) +#define blockedOnBadFD_closure IMPORT_CLOSURE(base_GHCziEventziThread_blockedOnBadFD) #define Czh_static_info DLL_IMPORT_DATA_REF(ghczmprim_GHCziTypes_Czh_static_info) #define Fzh_static_info DLL_IMPORT_DATA_REF(ghczmprim_GHCziTypes_Fzh_static_info) diff --git a/rts/PrimOps.cmm b/rts/PrimOps.cmm index 3e8612cea7..eb3ce2805a 100644 --- a/rts/PrimOps.cmm +++ b/rts/PrimOps.cmm @@ -31,7 +31,7 @@ import pthread_mutex_unlock; import base_ControlziExceptionziBase_nestedAtomically_closure; import EnterCriticalSection; import LeaveCriticalSection; -import ghczmprim_GHCziTypes_False_closure; +import ghczmprim_GHCziTypes_False_static_closure; #if defined(USE_MINIINTERPRETER) || !defined(mingw32_HOST_OS) import sm_mutex; #endif @@ -1171,7 +1171,7 @@ stg_atomicallyzh (P_ stm) /* Nested transactions are not allowed; raise an exception */ if (old_trec != NO_TREC) { - jump stg_raisezh(base_ControlziExceptionziBase_nestedAtomically_closure); + jump stg_raisezh(STATIC_CLOSURE(base_ControlziExceptionziBase_nestedAtomically)); } code = stm; @@ -2342,13 +2342,13 @@ stg_getSparkzh () W_ spark; #ifndef THREADED_RTS - return (0,ghczmprim_GHCziTypes_False_closure); + return (0,STATIC_CLOSURE(ghczmprim_GHCziTypes_False)); #else (spark) = ccall findSpark(MyCapability()); if (spark != 0) { return (1,spark); } else { - return (0,ghczmprim_GHCziTypes_False_closure); + return (0,STATIC_CLOSURE(ghczmprim_GHCziTypes_False)); } #endif } diff --git a/rts/RaiseAsync.c b/rts/RaiseAsync.c index a5440e40ad..8485e4804a 100644 --- a/rts/RaiseAsync.c +++ b/rts/RaiseAsync.c @@ -776,7 +776,7 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception, sp++; } else { sp--; - sp[0] = (W_)&stg_dummy_ret_closure; + sp[0] = (W_)stg_dummy_ret_closure; } frame = sp + 1; @@ -957,7 +957,7 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception, // ATOMICALLY_FRAME instance for condemned // transactions, but I don't fully understand the // interaction with STM invariants. - stack->sp[1] = (W_)&stg_NO_TREC_closure; + stack->sp[1] = (W_)stg_NO_TREC_closure; stack->sp[0] = (W_)&stg_ret_p_info; tso->what_next = ThreadRunGHC; goto done; diff --git a/rts/RetainerProfile.c b/rts/RetainerProfile.c index bfc96247aa..86d20a8c68 100644 --- a/rts/RetainerProfile.c +++ b/rts/RetainerProfile.c @@ -1748,7 +1748,7 @@ retainRoot(void *user STG_UNUSED, StgClosure **tl) c = UNTAG_CLOSURE(*tl); maybeInitRetainerSet(c); - if (c != &stg_END_TSO_QUEUE_closure && isRetainer(c)) { + if (c != stg_END_TSO_QUEUE_closure && isRetainer(c)) { retainClosure(c, c, getRetainerFrom(c)); } else { retainClosure(c, c, CCS_SYSTEM); @@ -386,11 +386,11 @@ static void unpark_tso(Capability *cap, StgTSO *tso) { // future. lockTSO(tso); if (tso->why_blocked == BlockedOnSTM && - tso->block_info.closure == &stg_STM_AWOKEN_closure) { + tso->block_info.closure == stg_STM_AWOKEN_closure) { TRACE("unpark_tso already woken up tso=%p", tso); } else if (tso -> why_blocked == BlockedOnSTM) { TRACE("unpark_tso on tso=%p", tso); - tso->block_info.closure = &stg_STM_AWOKEN_closure; + tso->block_info.closure = stg_STM_AWOKEN_closure; tryWakeupThread(cap,tso); } else { TRACE("spurious unpark_tso on tso=%p", tso); @@ -209,11 +209,11 @@ void stmWriteTVar(Capability *cap, /* NULLs */ -#define END_STM_WATCH_QUEUE ((StgTVarWatchQueue *)(void *)&stg_END_STM_WATCH_QUEUE_closure) -#define END_INVARIANT_CHECK_QUEUE ((StgInvariantCheckQueue *)(void *)&stg_END_INVARIANT_CHECK_QUEUE_closure) -#define END_STM_CHUNK_LIST ((StgTRecChunk *)(void *)&stg_END_STM_CHUNK_LIST_closure) +#define END_STM_WATCH_QUEUE ((StgTVarWatchQueue *)stg_END_STM_WATCH_QUEUE_closure) +#define END_INVARIANT_CHECK_QUEUE ((StgInvariantCheckQueue *)stg_END_INVARIANT_CHECK_QUEUE_closure) +#define END_STM_CHUNK_LIST ((StgTRecChunk *)stg_END_STM_CHUNK_LIST_closure) -#define NO_TREC ((StgTRecHeader *)(void *)&stg_NO_TREC_closure) +#define NO_TREC ((StgTRecHeader *)stg_NO_TREC_closure) /*----------------------------------------------------------------------*/ diff --git a/rts/StgMiscClosures.cmm b/rts/StgMiscClosures.cmm index 85ecb5e0e3..e546dd550e 100644 --- a/rts/StgMiscClosures.cmm +++ b/rts/StgMiscClosures.cmm @@ -682,7 +682,7 @@ INFO_TABLE_CONSTR(stg_MVAR_TSO_QUEUE,2,0,0,PRIM,"MVAR_TSO_QUEUE","MVAR_TSO_QUEUE #if !(defined(COMPILING_WINDOWS_DLL)) section "data" { - stg_CHARLIKE_closure: + stg_CHARLIKE_static_closure: CHARLIKE_HDR(0) CHARLIKE_HDR(1) CHARLIKE_HDR(2) @@ -942,7 +942,7 @@ section "data" { } section "data" { - stg_INTLIKE_closure: + stg_INTLIKE_static_closure: INTLIKE_HDR(-16) /* MIN_INTLIKE == -16 */ INTLIKE_HDR(-15) INTLIKE_HDR(-14) diff --git a/rts/Weak.c b/rts/Weak.c index f8faa4e1f5..3890dfb2d2 100644 --- a/rts/Weak.c +++ b/rts/Weak.c @@ -21,7 +21,7 @@ runCFinalizers(StgCFinalizerList *list) { StgCFinalizerList *head; for (head = list; - (StgClosure *)head != &stg_NO_FINALIZER_closure; + (StgClosure *)head != stg_NO_FINALIZER_closure; head = (StgCFinalizerList *)head->link) { if (head->flag) @@ -88,7 +88,7 @@ scheduleFinalizers(Capability *cap, StgWeak *list) // collector removes DEAD_WEAKs from the weak pointer list. ASSERT(w->header.info != &stg_DEAD_WEAK_info); - if (w->finalizer != &stg_NO_FINALIZER_closure) { + if (w->finalizer != stg_NO_FINALIZER_closure) { n++; } @@ -124,7 +124,7 @@ scheduleFinalizers(Capability *cap, StgWeak *list) n = 0; for (w = list; w; w = w->link) { - if (w->finalizer != &stg_NO_FINALIZER_closure) { + if (w->finalizer != stg_NO_FINALIZER_closure) { arr->payload[n] = w->finalizer; n++; } diff --git a/rts/package.conf.in b/rts/package.conf.in index 82d2870cde..75697326ea 100644 --- a/rts/package.conf.in +++ b/rts/package.conf.in @@ -91,24 +91,24 @@ ld-options: , "-Wl,-u,_base_GHCziPtr_Ptr_con_info" , "-Wl,-u,_base_GHCziPtr_FunPtr_con_info" , "-Wl,-u,_base_GHCziStable_StablePtr_con_info" - , "-Wl,-u,_ghczmprim_GHCziTypes_False_closure" - , "-Wl,-u,_ghczmprim_GHCziTypes_True_closure" - , "-Wl,-u,_base_GHCziPack_unpackCString_closure" - , "-Wl,-u,_base_GHCziIOziException_stackOverflow_closure" - , "-Wl,-u,_base_GHCziIOziException_heapOverflow_closure" - , "-Wl,-u,_base_ControlziExceptionziBase_nonTermination_closure" - , "-Wl,-u,_base_GHCziIOziException_blockedIndefinitelyOnMVar_closure" - , "-Wl,-u,_base_GHCziIOziException_blockedIndefinitelyOnSTM_closure" - , "-Wl,-u,_base_ControlziExceptionziBase_nestedAtomically_closure" - , "-Wl,-u,_base_GHCziEventziThread_blockedOnBadFD_closure" - , "-Wl,-u,_base_GHCziWeak_runFinalizzerBatch_closure" - , "-Wl,-u,_base_GHCziTopHandler_flushStdHandles_closure" - , "-Wl,-u,_base_GHCziTopHandler_runIO_closure" - , "-Wl,-u,_base_GHCziTopHandler_runNonIO_closure" - , "-Wl,-u,_base_GHCziConcziIO_ensureIOManagerIsRunning_closure" - , "-Wl,-u,_base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure" - , "-Wl,-u,_base_GHCziConcziSync_runSparks_closure" - , "-Wl,-u,_base_GHCziConcziSignal_runHandlers_closure" + , "-Wl,-u,_ghczmprim_GHCziTypes_False_static_closure" + , "-Wl,-u,_ghczmprim_GHCziTypes_True_static_closure" + , "-Wl,-u,_base_GHCziPack_unpackCString_static_closure" + , "-Wl,-u,_base_GHCziIOziException_stackOverflow_static_closure" + , "-Wl,-u,_base_GHCziIOziException_heapOverflow_static_closure" + , "-Wl,-u,_base_ControlziExceptionziBase_nonTermination_static_closure" + , "-Wl,-u,_base_GHCziIOziException_blockedIndefinitelyOnMVar_static_closure" + , "-Wl,-u,_base_GHCziIOziException_blockedIndefinitelyOnSTM_static_closure" + , "-Wl,-u,_base_ControlziExceptionziBase_nestedAtomically_static_closure" + , "-Wl,-u,_base_GHCziEventziThread_blockedOnBadFD_static_closure" + , "-Wl,-u,_base_GHCziWeak_runFinalizzerBatch_static_closure" + , "-Wl,-u,_base_GHCziTopHandler_flushStdHandles_static_closure" + , "-Wl,-u,_base_GHCziTopHandler_runIO_static_closure" + , "-Wl,-u,_base_GHCziTopHandler_runNonIO_static_closure" + , "-Wl,-u,_base_GHCziConcziIO_ensureIOManagerIsRunning_static_closure" + , "-Wl,-u,_base_GHCziConcziIO_ioManagerCapabilitiesChanged_static_closure" + , "-Wl,-u,_base_GHCziConcziSync_runSparks_static_closure" + , "-Wl,-u,_base_GHCziConcziSignal_runHandlers_static_closure" #else "-Wl,-u,ghczmprim_GHCziTypes_Izh_static_info" , "-Wl,-u,ghczmprim_GHCziTypes_Czh_static_info" @@ -132,24 +132,24 @@ ld-options: , "-Wl,-u,base_GHCziPtr_Ptr_con_info" , "-Wl,-u,base_GHCziPtr_FunPtr_con_info" , "-Wl,-u,base_GHCziStable_StablePtr_con_info" - , "-Wl,-u,ghczmprim_GHCziTypes_False_closure" - , "-Wl,-u,ghczmprim_GHCziTypes_True_closure" - , "-Wl,-u,base_GHCziPack_unpackCString_closure" - , "-Wl,-u,base_GHCziIOziException_stackOverflow_closure" - , "-Wl,-u,base_GHCziIOziException_heapOverflow_closure" - , "-Wl,-u,base_ControlziExceptionziBase_nonTermination_closure" - , "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnMVar_closure" - , "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnSTM_closure" - , "-Wl,-u,base_ControlziExceptionziBase_nestedAtomically_closure" - , "-Wl,-u,base_GHCziEventziThread_blockedOnBadFD_closure" - , "-Wl,-u,base_GHCziWeak_runFinalizzerBatch_closure" - , "-Wl,-u,base_GHCziTopHandler_flushStdHandles_closure" - , "-Wl,-u,base_GHCziTopHandler_runIO_closure" - , "-Wl,-u,base_GHCziTopHandler_runNonIO_closure" - , "-Wl,-u,base_GHCziConcziIO_ensureIOManagerIsRunning_closure" - , "-Wl,-u,base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure" - , "-Wl,-u,base_GHCziConcziSync_runSparks_closure" - , "-Wl,-u,base_GHCziConcziSignal_runHandlers_closure" + , "-Wl,-u,ghczmprim_GHCziTypes_False_static_closure" + , "-Wl,-u,ghczmprim_GHCziTypes_True_static_closure" + , "-Wl,-u,base_GHCziPack_unpackCString_static_closure" + , "-Wl,-u,base_GHCziIOziException_stackOverflow_static_closure" + , "-Wl,-u,base_GHCziIOziException_heapOverflow_static_closure" + , "-Wl,-u,base_ControlziExceptionziBase_nonTermination_static_closure" + , "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnMVar_static_closure" + , "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnSTM_static_closure" + , "-Wl,-u,base_ControlziExceptionziBase_nestedAtomically_static_closure" + , "-Wl,-u,base_GHCziEventziThread_blockedOnBadFD_static_closure" + , "-Wl,-u,base_GHCziWeak_runFinalizzerBatch_static_closure" + , "-Wl,-u,base_GHCziTopHandler_flushStdHandles_static_closure" + , "-Wl,-u,base_GHCziTopHandler_runIO_static_closure" + , "-Wl,-u,base_GHCziTopHandler_runNonIO_static_closure" + , "-Wl,-u,base_GHCziConcziIO_ensureIOManagerIsRunning_static_closure" + , "-Wl,-u,base_GHCziConcziIO_ioManagerCapabilitiesChanged_static_closure" + , "-Wl,-u,base_GHCziConcziSync_runSparks_static_closure" + , "-Wl,-u,base_GHCziConcziSignal_runHandlers_static_closure" #endif /* Pick up static libraries in preference over dynamic if in earlier search diff --git a/rts/posix/Signals.c b/rts/posix/Signals.c index 36a72a5c8e..4a860127e3 100644 --- a/rts/posix/Signals.c +++ b/rts/posix/Signals.c @@ -193,7 +193,7 @@ ioManagerDie (void) void ioManagerStartCap (Capability **cap) { - rts_evalIO(cap,&base_GHCziConcziIO_ensureIOManagerIsRunning_closure,NULL); + rts_evalIO(cap,ensureIOManagerIsRunning_closure,NULL); } void @@ -473,7 +473,7 @@ startSignalHandlers(Capability *cap) RtsFlags.GcFlags.initialStkSize, rts_apply(cap, rts_apply(cap, - &base_GHCziConcziSignal_runHandlers_closure, + runHandlers_closure, rts_mkPtr(cap, info)), rts_mkInt(cap, info->si_signo)))); } diff --git a/rts/sm/Storage.c b/rts/sm/Storage.c index 379d9da769..1a0aff0950 100644 --- a/rts/sm/Storage.c +++ b/rts/sm/Storage.c @@ -115,8 +115,8 @@ initStorage (void) */ /* We use the NOT_NULL variant or gcc warns that the test is always true */ ASSERT(LOOKS_LIKE_INFO_PTR_NOT_NULL((StgWord)&stg_BLOCKING_QUEUE_CLEAN_info)); - ASSERT(LOOKS_LIKE_CLOSURE_PTR(&stg_dummy_ret_closure)); - ASSERT(!HEAP_ALLOCED(&stg_dummy_ret_closure)); + ASSERT(LOOKS_LIKE_CLOSURE_PTR(stg_dummy_ret_closure)); + ASSERT(!HEAP_ALLOCED(stg_dummy_ret_closure)); if (RtsFlags.GcFlags.maxHeapSize != 0 && RtsFlags.GcFlags.heapSizeSuggestion > diff --git a/rts/win32/libHSbase.def b/rts/win32/libHSbase.def index 8140528c70..4d1375a32a 100644 --- a/rts/win32/libHSbase.def +++ b/rts/win32/libHSbase.def @@ -15,29 +15,29 @@ EXPORTS base_GHCziStable_StablePtr_con_info - base_GHCziPack_unpackCString_closure + base_GHCziPack_unpackCString_static_closure - base_GHCziTopHandler_runIO_closure - base_GHCziTopHandler_runNonIO_closure + base_GHCziTopHandler_runIO_static_closure + base_GHCziTopHandler_runNonIO_static_closure - base_GHCziIOziException_stackOverflow_closure - base_GHCziIOziException_heapOverflow_closure + base_GHCziIOziException_stackOverflow_static_closure + base_GHCziIOziException_heapOverflow_static_closure base_GHCziPtr_Ptr_con_info base_GHCziPtr_FunPtr_con_info - base_GHCziConcziIO_ensureIOManagerIsRunning_closure - base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure - base_GHCziConcziSync_runSparks_closure + base_GHCziConcziIO_ensureIOManagerIsRunning_static_closure + base_GHCziConcziIO_ioManagerCapabilitiesChanged_static_closure + base_GHCziConcziSync_runSparks_static_closure - base_GHCziTopHandler_flushStdHandles_closure + base_GHCziTopHandler_flushStdHandles_static_closure - base_GHCziWeak_runFinalizzerBatch_closure - base_GHCziPack_unpackCString_closure - base_GHCziIOziException_blockedIndefinitelyOnMVar_closure - base_GHCziIOziException_blockedIndefinitelyOnSTM_closure - base_GHCziIOziException_stackOverflow_closure + base_GHCziWeak_runFinalizzerBatch_static_closure + base_GHCziPack_unpackCString_static_closure + base_GHCziIOziException_blockedIndefinitelyOnMVar_static_closure + base_GHCziIOziException_blockedIndefinitelyOnSTM_static_closure + base_GHCziIOziException_stackOverflow_static_closure - base_ControlziExceptionziBase_nonTermination_closure - base_ControlziExceptionziBase_nestedAtomically_closure - base_GHCziEventziThread_blockedOnBadFD_closure + base_ControlziExceptionziBase_nonTermination_static_closure + base_ControlziExceptionziBase_nestedAtomically_static_closure + base_GHCziEventziThread_blockedOnBadFD_static_closure |