Revert "Rename _closure to _static_closure, apply naming consistently."

This reverts commit 35672072b4091d6f0031417bc160c568f22d0469.

Conflicts:
	compiler/main/DriverPipeline.hs

15 files changed, 122 insertions, 126 deletions

diff --git a/rts/Exception.cmm b/rts/Exception.cmm
index 8533e3e35e..bc55911687 100644
--- a/rts/Exception.cmm
+++ b/rts/Exception.cmm
@@ -13,7 +13,7 @@
 #include "Cmm.h"
 #include "RaiseAsync.h"
 
-import ghczmprim_GHCziTypes_True_static_closure;
+import ghczmprim_GHCziTypes_True_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) = STATIC_CLOSURE(ghczmprim_GHCziTypes_True); // dummy breakpoint info
-            Sp(1) = STATIC_CLOSURE(ghczmprim_GHCziTypes_True); // True <=> a breakpoint
+            Sp(2) = ghczmprim_GHCziTypes_True_closure; // dummy breakpoint info
+            Sp(1) = ghczmprim_GHCziTypes_True_closure; // True <=> a breakpoint
             R1 = ioAction;
             jump RET_LBL(stg_ap_pppv) [R1];
         }
diff --git a/rts/Interpreter.c b/rts/Interpreter.c
index 6fe1fcabab..f4fe816d28 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 aa44330126..4ab7cc5b09 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_static_closure)               \
-      SymI_HasProto(stg_INTLIKE_static_closure)
+      SymI_HasProto(stg_CHARLIKE_closure)               \
+      SymI_HasProto(stg_INTLIKE_closure)
 #endif
 
 
diff --git a/rts/Prelude.h b/rts/Prelude.h
index b2f9d994e7..0c54148ba2 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 ## _static_closure)[]
+#define PRELUDE_CLOSURE(i)    extern W_(i)[]
 #else
 #define PRELUDE_INFO(i)       extern const StgInfoTable DLL_IMPORT_DATA_VARNAME(i)
-#define PRELUDE_CLOSURE(i)    extern StgClosure DLL_IMPORT_DATA_VARNAME(i ## _static_closure)
+#define PRELUDE_CLOSURE(i)    extern StgClosure DLL_IMPORT_DATA_VARNAME(i)
 #endif
 
 /* Define canonical names so we can abstract away from the actual
  * modules these names are defined in.
  */
 
-PRELUDE_CLOSURE(ghczmprim_GHCziTypes_True);
-PRELUDE_CLOSURE(ghczmprim_GHCziTypes_False);
-PRELUDE_CLOSURE(base_GHCziPack_unpackCString);
-PRELUDE_CLOSURE(base_GHCziWeak_runFinalizzerBatch);
+PRELUDE_CLOSURE(ghczmprim_GHCziTypes_True_closure);
+PRELUDE_CLOSURE(ghczmprim_GHCziTypes_False_closure);
+PRELUDE_CLOSURE(base_GHCziPack_unpackCString_closure);
+PRELUDE_CLOSURE(base_GHCziWeak_runFinalizzerBatch_closure);
 
 #ifdef IN_STG_CODE
-extern W_ ZCMain_main_static_closure[];
+extern W_ ZCMain_main_closure[];
 #else
-extern StgClosure ZCMain_main_static_closure;
+extern StgClosure ZCMain_main_closure;
 #endif
 
-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_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_GHCziConcziSync_runSparks);
-PRELUDE_CLOSURE(base_GHCziConcziIO_ensureIOManagerIsRunning);
-PRELUDE_CLOSURE(base_GHCziConcziIO_ioManagerCapabilitiesChanged);
-PRELUDE_CLOSURE(base_GHCziConcziSignal_runHandlers);
+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_GHCziTopHandler_flushStdHandles);
+PRELUDE_CLOSURE(base_GHCziTopHandler_flushStdHandles_closure);
 
 PRELUDE_INFO(ghczmprim_GHCziTypes_Czh_static_info);
 PRELUDE_INFO(ghczmprim_GHCziTypes_Izh_static_info);
@@ -86,30 +86,26 @@ PRELUDE_INFO(base_GHCziWord_W64zh_con_info);
 PRELUDE_INFO(base_GHCziStable_StablePtr_static_info);
 PRELUDE_INFO(base_GHCziStable_StablePtr_con_info);
 
-#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 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 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 a0e744b1ba..16c91e9b3a 100644
--- a/rts/PrimOps.cmm
+++ b/rts/PrimOps.cmm
@@ -31,7 +31,7 @@ import pthread_mutex_unlock;
 import base_ControlziExceptionziBase_nestedAtomically_static_closure;
 import EnterCriticalSection;
 import LeaveCriticalSection;
-import ghczmprim_GHCziTypes_False_static_closure;
+import ghczmprim_GHCziTypes_False_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(STATIC_CLOSURE(base_ControlziExceptionziBase_nestedAtomically));
+        jump stg_raisezh(base_ControlziExceptionziBase_nestedAtomically_closure);
     }
 
     code = stm;
@@ -2342,13 +2342,13 @@ stg_getSparkzh ()
     W_ spark;
 
 #ifndef THREADED_RTS
-    return (0,STATIC_CLOSURE(ghczmprim_GHCziTypes_False));
+    return (0,ghczmprim_GHCziTypes_False_closure);
 #else
     (spark) = ccall findSpark(MyCapability());
     if (spark != 0) {
         return (1,spark);
     } else {
-        return (0,STATIC_CLOSURE(ghczmprim_GHCziTypes_False));
+        return (0,ghczmprim_GHCziTypes_False_closure);
     }
 #endif
 }
diff --git a/rts/RaiseAsync.c b/rts/RaiseAsync.c
index 8485e4804a..a5440e40ad 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 86d20a8c68..bfc96247aa 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);
diff --git a/rts/STM.c b/rts/STM.c
index 8b8053688e..cf97e7b648 100644
--- a/rts/STM.c
+++ b/rts/STM.c
@@ -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);
diff --git a/rts/STM.h b/rts/STM.h
index 8bfa24f239..ffec009577 100644
--- a/rts/STM.h
+++ b/rts/STM.h
@@ -209,11 +209,11 @@ void stmWriteTVar(Capability *cap,
 
 /* NULLs */
 
-#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 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 NO_TREC ((StgTRecHeader *)stg_NO_TREC_closure)
+#define NO_TREC ((StgTRecHeader *)(void *)&stg_NO_TREC_closure)
 
 /*----------------------------------------------------------------------*/
 
diff --git a/rts/StgMiscClosures.cmm b/rts/StgMiscClosures.cmm
index e546dd550e..85ecb5e0e3 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_static_closure:
+ stg_CHARLIKE_closure:
     CHARLIKE_HDR(0)
     CHARLIKE_HDR(1)
     CHARLIKE_HDR(2)
@@ -942,7 +942,7 @@ section "data" {
 }
 
 section "data" {
- stg_INTLIKE_static_closure:
+ stg_INTLIKE_closure:
     INTLIKE_HDR(-16) /* MIN_INTLIKE == -16 */
     INTLIKE_HDR(-15)
     INTLIKE_HDR(-14)
diff --git a/rts/Weak.c b/rts/Weak.c
index 3890dfb2d2..f8faa4e1f5 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 75697326ea..82d2870cde 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_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"
+         , "-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"
 #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_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"
+         , "-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"
 #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 4a860127e3..36a72a5c8e 100644
--- a/rts/posix/Signals.c
+++ b/rts/posix/Signals.c
@@ -193,7 +193,7 @@ ioManagerDie (void)
 void
 ioManagerStartCap (Capability **cap)
 {
-    rts_evalIO(cap,ensureIOManagerIsRunning_closure,NULL);
+    rts_evalIO(cap,&base_GHCziConcziIO_ensureIOManagerIsRunning_closure,NULL);
 }
 
 void
@@ -473,7 +473,7 @@ startSignalHandlers(Capability *cap)
           RtsFlags.GcFlags.initialStkSize,
               rts_apply(cap,
                   rts_apply(cap,
-                      runHandlers_closure,
+                      &base_GHCziConcziSignal_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 1a0aff0950..379d9da769 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 4d1375a32a..8140528c70 100644
--- a/rts/win32/libHSbase.def
+++ b/rts/win32/libHSbase.def
@@ -15,29 +15,29 @@ EXPORTS
 
 	base_GHCziStable_StablePtr_con_info
 
-	base_GHCziPack_unpackCString_static_closure
+	base_GHCziPack_unpackCString_closure
 
-	base_GHCziTopHandler_runIO_static_closure
-	base_GHCziTopHandler_runNonIO_static_closure
+	base_GHCziTopHandler_runIO_closure
+	base_GHCziTopHandler_runNonIO_closure
 
-	base_GHCziIOziException_stackOverflow_static_closure
-	base_GHCziIOziException_heapOverflow_static_closure
+	base_GHCziIOziException_stackOverflow_closure
+	base_GHCziIOziException_heapOverflow_closure
 
 	base_GHCziPtr_Ptr_con_info
 	base_GHCziPtr_FunPtr_con_info
 
-	base_GHCziConcziIO_ensureIOManagerIsRunning_static_closure
-	base_GHCziConcziIO_ioManagerCapabilitiesChanged_static_closure
-	base_GHCziConcziSync_runSparks_static_closure
+	base_GHCziConcziIO_ensureIOManagerIsRunning_closure
+	base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure
+	base_GHCziConcziSync_runSparks_closure
 
-	base_GHCziTopHandler_flushStdHandles_static_closure
+	base_GHCziTopHandler_flushStdHandles_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_GHCziWeak_runFinalizzerBatch_closure
+	base_GHCziPack_unpackCString_closure
+	base_GHCziIOziException_blockedIndefinitelyOnMVar_closure
+	base_GHCziIOziException_blockedIndefinitelyOnSTM_closure
+	base_GHCziIOziException_stackOverflow_closure
 
-	base_ControlziExceptionziBase_nonTermination_static_closure
-	base_ControlziExceptionziBase_nestedAtomically_static_closure
-	base_GHCziEventziThread_blockedOnBadFD_static_closure
+	base_ControlziExceptionziBase_nonTermination_closure
+	base_ControlziExceptionziBase_nestedAtomically_closure
+	base_GHCziEventziThread_blockedOnBadFD_closure