Rename primops from foozh_fast to stg_foozh

For consistency with other RTS exported symbols

7 files changed, 262 insertions, 262 deletions

diff --git a/compiler/cmm/CLabel.hs b/compiler/cmm/CLabel.hs
index 9ba55ac7b2..a78c22f8ec 100644
--- a/compiler/cmm/CLabel.hs
+++ b/compiler/cmm/CLabel.hs
@@ -897,7 +897,7 @@ pprCLbl (RtsLabel (RtsRetFS fs))
   = ftext fs <> ptext (sLit "_ret")
 
 pprCLbl (RtsLabel (RtsPrimOp primop)) 
-  = ppr primop <> ptext (sLit "_fast")
+  = ptext (sLit "stg_") <> ppr primop
 
 pprCLbl (RtsLabel (RtsSlowTickyCtr pat)) 
   = ptext (sLit "SLOW_CALL_") <> text pat <> ptext (sLit "_ctr")
diff --git a/includes/stg/MiscClosures.h b/includes/stg/MiscClosures.h
index 1591570780..074ed314b7 100644
--- a/includes/stg/MiscClosures.h
+++ b/includes/stg/MiscClosures.h
@@ -486,113 +486,113 @@ RTS_FUN(StgReturn);
    PrimOps
    -------------------------------------------------------------------------- */
 
-RTS_FUN(plusIntegerzh_fast);
-RTS_FUN(minusIntegerzh_fast);
-RTS_FUN(timesIntegerzh_fast);
-RTS_FUN(gcdIntegerzh_fast);
-RTS_FUN(quotRemIntegerzh_fast);
-RTS_FUN(quotIntegerzh_fast);
-RTS_FUN(remIntegerzh_fast);
-RTS_FUN(divExactIntegerzh_fast);
-RTS_FUN(divModIntegerzh_fast);
-
-RTS_FUN(cmpIntegerIntzh_fast);
-RTS_FUN(cmpIntegerzh_fast);
-RTS_FUN(integer2Intzh_fast);
-RTS_FUN(integer2Wordzh_fast);
-RTS_FUN(gcdIntegerIntzh_fast);
-RTS_FUN(gcdIntzh_fast);
-
-RTS_FUN(int2Integerzh_fast);
-RTS_FUN(word2Integerzh_fast);
-
-RTS_FUN(decodeFloatzuIntzh_fast);
-RTS_FUN(decodeDoublezh_fast);
-RTS_FUN(decodeDoublezu2Intzh_fast);
-
-RTS_FUN(andIntegerzh_fast);
-RTS_FUN(orIntegerzh_fast);
-RTS_FUN(xorIntegerzh_fast);
-RTS_FUN(complementIntegerzh_fast);
+RTS_FUN(stg_plusIntegerzh);
+RTS_FUN(stg_minusIntegerzh);
+RTS_FUN(stg_timesIntegerzh);
+RTS_FUN(stg_gcdIntegerzh);
+RTS_FUN(stg_quotRemIntegerzh);
+RTS_FUN(stg_quotIntegerzh);
+RTS_FUN(stg_remIntegerzh);
+RTS_FUN(stg_divExactIntegerzh);
+RTS_FUN(stg_divModIntegerzh);
+
+RTS_FUN(stg_cmpIntegerIntzh);
+RTS_FUN(stg_cmpIntegerzh);
+RTS_FUN(stg_integer2Intzh);
+RTS_FUN(stg_integer2Wordzh);
+RTS_FUN(stg_gcdIntegerIntzh);
+RTS_FUN(stg_gcdIntzh);
+
+RTS_FUN(stg_int2Integerzh);
+RTS_FUN(stg_word2Integerzh);
+
+RTS_FUN(stg_decodeFloatzuIntzh);
+RTS_FUN(stg_decodeDoublezh);
+RTS_FUN(stg_decodeDoublezu2Intzh);
+
+RTS_FUN(stg_andIntegerzh);
+RTS_FUN(stg_orIntegerzh);
+RTS_FUN(stg_xorIntegerzh);
+RTS_FUN(stg_complementIntegerzh);
 
 #if SIZEOF_HSINT == 4
 
-RTS_FUN(int64ToIntegerzh_fast);
-RTS_FUN(word64ToIntegerzh_fast);
+RTS_FUN(stg_int64ToIntegerzh);
+RTS_FUN(stg_word64ToIntegerzh);
 
 #endif
 
-RTS_FUN(unsafeThawArrayzh_fast);
-RTS_FUN(newByteArrayzh_fast);
-RTS_FUN(newPinnedByteArrayzh_fast);
-RTS_FUN(newAlignedPinnedByteArrayzh_fast);
-RTS_FUN(newArrayzh_fast);
-
-RTS_FUN(newMutVarzh_fast);
-RTS_FUN(atomicModifyMutVarzh_fast);
-
-RTS_FUN(isEmptyMVarzh_fast);
-RTS_FUN(newMVarzh_fast);
-RTS_FUN(takeMVarzh_fast);
-RTS_FUN(putMVarzh_fast);
-RTS_FUN(tryTakeMVarzh_fast);
-RTS_FUN(tryPutMVarzh_fast);
-
-RTS_FUN(waitReadzh_fast);
-RTS_FUN(waitWritezh_fast);
-RTS_FUN(delayzh_fast);
+RTS_FUN(stg_unsafeThawArrayzh);
+RTS_FUN(stg_newByteArrayzh);
+RTS_FUN(stg_newPinnedByteArrayzh);
+RTS_FUN(stg_newAlignedPinnedByteArrayzh);
+RTS_FUN(stg_newArrayzh);
+
+RTS_FUN(stg_newMutVarzh);
+RTS_FUN(stg_atomicModifyMutVarzh);
+
+RTS_FUN(stg_isEmptyMVarzh);
+RTS_FUN(stg_newMVarzh);
+RTS_FUN(stg_takeMVarzh);
+RTS_FUN(stg_putMVarzh);
+RTS_FUN(stg_tryTakeMVarzh);
+RTS_FUN(stg_tryPutMVarzh);
+
+RTS_FUN(stg_waitReadzh);
+RTS_FUN(stg_waitWritezh);
+RTS_FUN(stg_delayzh);
 #ifdef mingw32_HOST_OS
-RTS_FUN(asyncReadzh_fast);
-RTS_FUN(asyncWritezh_fast);
-RTS_FUN(asyncDoProczh_fast);
+RTS_FUN(stg_asyncReadzh);
+RTS_FUN(stg_asyncWritezh);
+RTS_FUN(stg_asyncDoProczh);
 #endif
 
-RTS_FUN(catchzh_fast);
-RTS_FUN(raisezh_fast);
-RTS_FUN(raiseIOzh_fast);
-
-RTS_FUN(makeStableNamezh_fast);
-RTS_FUN(makeStablePtrzh_fast);
-RTS_FUN(deRefStablePtrzh_fast);
-
-RTS_FUN(forkzh_fast);
-RTS_FUN(forkOnzh_fast);
-RTS_FUN(yieldzh_fast);
-RTS_FUN(killThreadzh_fast);
-RTS_FUN(asyncExceptionsBlockedzh_fast);
-RTS_FUN(blockAsyncExceptionszh_fast);
-RTS_FUN(unblockAsyncExceptionszh_fast);
-RTS_FUN(myThreadIdzh_fast);
-RTS_FUN(labelThreadzh_fast);
-RTS_FUN(isCurrentThreadBoundzh_fast);
-RTS_FUN(threadStatuszh_fast);
-
-RTS_FUN(mkWeakzh_fast);
-RTS_FUN(mkWeakForeignzh_fast);
-RTS_FUN(mkWeakForeignEnvzh_fast);
-RTS_FUN(finalizzeWeakzh_fast);
-RTS_FUN(deRefWeakzh_fast);
-
-RTS_FUN(newBCOzh_fast);
-RTS_FUN(mkApUpd0zh_fast);
-
-RTS_FUN(retryzh_fast);
-RTS_FUN(catchRetryzh_fast);
-RTS_FUN(catchSTMzh_fast);
-RTS_FUN(atomicallyzh_fast);
-RTS_FUN(newTVarzh_fast);
-RTS_FUN(readTVarzh_fast);
-RTS_FUN(readTVarIOzh_fast);
-RTS_FUN(writeTVarzh_fast);
-RTS_FUN(checkzh_fast);
-
-RTS_FUN(unpackClosurezh_fast);
-RTS_FUN(getApStackValzh_fast);
-RTS_FUN(getSparkzh_fast);
-
-RTS_FUN(noDuplicatezh_fast);
-
-RTS_FUN(traceCcszh_fast);
+RTS_FUN(stg_catchzh);
+RTS_FUN(stg_raisezh);
+RTS_FUN(stg_raiseIOzh);
+
+RTS_FUN(stg_makeStableNamezh);
+RTS_FUN(stg_makeStablePtrzh);
+RTS_FUN(stg_deRefStablePtrzh);
+
+RTS_FUN(stg_forkzh);
+RTS_FUN(stg_forkOnzh);
+RTS_FUN(stg_yieldzh);
+RTS_FUN(stg_killThreadzh);
+RTS_FUN(stg_asyncExceptionsBlockedzh);
+RTS_FUN(stg_blockAsyncExceptionszh);
+RTS_FUN(stg_unblockAsyncExceptionszh);
+RTS_FUN(stg_myThreadIdzh);
+RTS_FUN(stg_labelThreadzh);
+RTS_FUN(stg_isCurrentThreadBoundzh);
+RTS_FUN(stg_threadStatuszh);
+
+RTS_FUN(stg_mkWeakzh);
+RTS_FUN(stg_mkWeakForeignzh);
+RTS_FUN(stg_mkWeakForeignEnvzh);
+RTS_FUN(stg_finalizzeWeakzh);
+RTS_FUN(stg_deRefWeakzh);
+
+RTS_FUN(stg_newBCOzh);
+RTS_FUN(stg_mkApUpd0zh);
+
+RTS_FUN(stg_retryzh);
+RTS_FUN(stg_catchRetryzh);
+RTS_FUN(stg_catchSTMzh);
+RTS_FUN(stg_atomicallyzh);
+RTS_FUN(stg_newTVarzh);
+RTS_FUN(stg_readTVarzh);
+RTS_FUN(stg_readTVarIOzh);
+RTS_FUN(stg_writeTVarzh);
+RTS_FUN(stg_checkzh);
+
+RTS_FUN(stg_unpackClosurezh);
+RTS_FUN(stg_getApStackValzh);
+RTS_FUN(stg_getSparkzh);
+
+RTS_FUN(stg_noDuplicatezh);
+
+RTS_FUN(stg_traceCcszh);
 
 /* Other misc stuff */
 // See wiki:Commentary/Compiler/Backends/PprC#Prototypes
diff --git a/rts/Exception.cmm b/rts/Exception.cmm
index cf8ffdf716..16b5d92b30 100644
--- a/rts/Exception.cmm
+++ b/rts/Exception.cmm
@@ -96,10 +96,10 @@ INFO_TABLE_RET( stg_blockAsyncExceptionszh_ret, RET_SMALL )
     jump %ENTRY_CODE(Sp(0));
 }
 
-blockAsyncExceptionszh_fast
+stg_blockAsyncExceptionszh
 {
     /* Args: R1 :: IO a */
-    STK_CHK_GEN( WDS(2)/* worst case */, R1_PTR, blockAsyncExceptionszh_fast);
+    STK_CHK_GEN( WDS(2)/* worst case */, R1_PTR, stg_blockAsyncExceptionszh);
 
     if ((TO_W_(StgTSO_flags(CurrentTSO)) & TSO_BLOCKEX) == 0) {
 	
@@ -119,12 +119,12 @@ blockAsyncExceptionszh_fast
     jump stg_ap_v_fast;
 }
 
-unblockAsyncExceptionszh_fast
+stg_unblockAsyncExceptionszh
 {
     CInt r;
 
     /* Args: R1 :: IO a */
-    STK_CHK_GEN( WDS(4), R1_PTR, unblockAsyncExceptionszh_fast);
+    STK_CHK_GEN( WDS(4), R1_PTR, stg_unblockAsyncExceptionszh);
     /* 4 words: one for the unblock frame, 3 for setting up the
      * stack to call maybePerformBlockedException() below.
      */
@@ -185,7 +185,7 @@ unblockAsyncExceptionszh_fast
     jump stg_ap_v_fast;
 }
 
-asyncExceptionsBlockedzh_fast
+stg_asyncExceptionsBlockedzh
 {
     /* args: none */
     if ((TO_W_(StgTSO_flags(CurrentTSO)) & TSO_BLOCKEX) != 0) {
@@ -195,7 +195,7 @@ asyncExceptionsBlockedzh_fast
     }
 }
 
-killThreadzh_fast
+stg_killThreadzh
 {
     /* args: R1 = TSO to kill, R2 = Exception */
 
@@ -207,7 +207,7 @@ killThreadzh_fast
     exception = R2;
     
     /* Needs 3 words because throwToSingleThreaded uses some stack */
-    STK_CHK_GEN( WDS(3), R1_PTR & R2_PTR, killThreadzh_fast);
+    STK_CHK_GEN( WDS(3), R1_PTR & R2_PTR, stg_killThreadzh);
 
     /* 
      * We might have killed ourselves.  In which case, better be *very*
@@ -227,7 +227,7 @@ killThreadzh_fast
          * thread?  Presumably it should behave as if throwTo just returned,
          * and then continue from there.  See #3279, #3288.  This is what
          * happens: on resumption, we will just jump to the next frame on
-         * the stack, which is the return point for killThreadzh_fast.
+         * the stack, which is the return point for stg_killThreadzh.
          */
 	SAVE_THREAD_STATE();
 	/* ToDo: what if the current thread is blocking exceptions? */
@@ -301,13 +301,13 @@ INFO_TABLE(stg_catch,2,0,FUN,"catch","catch")
 {
   R2 = StgClosure_payload(R1,1); /* h */
   R1 = StgClosure_payload(R1,0); /* x */
-  jump catchzh_fast;
+  jump stg_catchzh;
 }
 
-catchzh_fast
+stg_catchzh
 {
     /* args: R1 = m :: IO a, R2 = handler :: Exception -> IO a */
-    STK_CHK_GEN(SIZEOF_StgCatchFrame + WDS(1), R1_PTR & R2_PTR, catchzh_fast);
+    STK_CHK_GEN(SIZEOF_StgCatchFrame + WDS(1), R1_PTR & R2_PTR, stg_catchzh);
   
     /* Set up the catch frame */
     Sp = Sp - SIZEOF_StgCatchFrame;
@@ -330,13 +330,13 @@ catchzh_fast
  *
  *   raise = {err} \n {} -> raise#{err}
  *
- * It is used in raisezh_fast to update thunks on the update list
+ * It is used in stg_raisezh to update thunks on the update list
  * -------------------------------------------------------------------------- */
 
 INFO_TABLE(stg_raise,1,0,THUNK_1_0,"raise","raise")
 {
   R1 = StgThunk_payload(R1,0);
-  jump raisezh_fast;
+  jump stg_raisezh;
 }
 
 section "data" {
@@ -348,10 +348,10 @@ INFO_TABLE_RET(stg_raise_ret, RET_SMALL, P_ arg1)
   R1 = Sp(1);
   Sp = Sp + WDS(2);
   W_[no_break_on_exception] = 1;  
-  jump raisezh_fast;
+  jump stg_raisezh;
 }
 
-raisezh_fast
+stg_raisezh
 {
     W_ handler;
     W_ frame_type;
@@ -512,8 +512,8 @@ retry_pop_stack:
     jump RET_LBL(stg_ap_pv);
 }
 
-raiseIOzh_fast
+stg_raiseIOzh
 {
   /* Args :: R1 :: Exception */
-  jump raisezh_fast;
+  jump stg_raisezh;
 }
diff --git a/rts/HeapStackCheck.cmm b/rts/HeapStackCheck.cmm
index 0c1af6292e..b516ef2c09 100644
--- a/rts/HeapStackCheck.cmm
+++ b/rts/HeapStackCheck.cmm
@@ -549,7 +549,7 @@ INFO_TABLE_RET( stg_block_takemvar, RET_SMALL, P_ unused )
 {
     R1 = Sp(1);
     Sp_adj(2);
-    jump takeMVarzh_fast;
+    jump stg_takeMVarzh;
 }
 
 // code fragment executed just before we return to the scheduler
@@ -577,7 +577,7 @@ INFO_TABLE_RET( stg_block_putmvar, RET_SMALL, P_ unused1, P_ unused2 )
     R2 = Sp(2);
     R1 = Sp(1);
     Sp_adj(3);
-    jump putMVarzh_fast;
+    jump stg_putMVarzh;
 }
 
 // code fragment executed just before we return to the scheduler
@@ -626,7 +626,7 @@ INFO_TABLE_RET( stg_block_throwto, RET_SMALL, P_ unused, P_ unused )
     R2 = Sp(2);
     R1 = Sp(1);
     Sp_adj(3);
-    jump killThreadzh_fast;
+    jump stg_killThreadzh;
 }
 
 stg_block_throwto_finally
diff --git a/rts/Linker.c b/rts/Linker.c
index 0e5630dde7..1fdd7c79db 100644
--- a/rts/Linker.c
+++ b/rts/Linker.c
@@ -224,10 +224,10 @@ typedef struct _RtsSymbolVal {
     void   *addr;
 } RtsSymbolVal;
 
-#define Maybe_Stable_Names      SymI_HasProto(mkWeakzh_fast)			\
-      				SymI_HasProto(mkWeakForeignEnvzh_fast)		\
-      				SymI_HasProto(makeStableNamezh_fast)		\
-      				SymI_HasProto(finalizzeWeakzh_fast)
+#define Maybe_Stable_Names      SymI_HasProto(stg_mkWeakzh)			\
+      				SymI_HasProto(stg_mkWeakForeignEnvzh)		\
+      				SymI_HasProto(stg_makeStableNamezh)		\
+      				SymI_HasProto(stg_finalizzeWeakzh)
 
 #if !defined (mingw32_HOST_OS)
 #define RTS_POSIX_ONLY_SYMBOLS                  \
@@ -356,9 +356,9 @@ typedef struct _RtsSymbolVal {
 /* These are statically linked from the mingw libraries into the ghc
    executable, so we have to employ this hack. */
 #define RTS_MINGW_ONLY_SYMBOLS                           \
-      SymI_HasProto(asyncReadzh_fast)			 \
-      SymI_HasProto(asyncWritezh_fast)			 \
-      SymI_HasProto(asyncDoProczh_fast)			 \
+      SymI_HasProto(stg_asyncReadzh)			 \
+      SymI_HasProto(stg_asyncWritezh)			 \
+      SymI_HasProto(stg_asyncDoProczh)			 \
       SymI_HasProto(memset)                              \
       SymI_HasProto(inet_ntoa)                           \
       SymI_HasProto(inet_addr)                           \
@@ -591,29 +591,29 @@ typedef struct _RtsSymbolVal {
       SymI_HasProto(__2Int_encodeDouble)		\
       SymI_HasProto(__int_encodeFloat)			\
       SymI_HasProto(__word_encodeFloat)			\
-      SymI_HasProto(atomicallyzh_fast)			\
+      SymI_HasProto(stg_atomicallyzh)			\
       SymI_HasProto(barf)				\
       SymI_HasProto(debugBelch)				\
       SymI_HasProto(errorBelch)				\
       SymI_HasProto(sysErrorBelch)                      \
-      SymI_HasProto(asyncExceptionsBlockedzh_fast)	\
-      SymI_HasProto(blockAsyncExceptionszh_fast)	\
-      SymI_HasProto(catchzh_fast)			\
-      SymI_HasProto(catchRetryzh_fast)			\
-      SymI_HasProto(catchSTMzh_fast)			\
-      SymI_HasProto(checkzh_fast)                       \
+      SymI_HasProto(stg_asyncExceptionsBlockedzh)	\
+      SymI_HasProto(stg_blockAsyncExceptionszh)	        \
+      SymI_HasProto(stg_catchzh)			\
+      SymI_HasProto(stg_catchRetryzh)			\
+      SymI_HasProto(stg_catchSTMzh)			\
+      SymI_HasProto(stg_checkzh)                        \
       SymI_HasProto(closure_flags)                      \
       SymI_HasProto(cmp_thread)				\
       SymI_HasProto(createAdjustor)			\
-      SymI_HasProto(decodeDoublezu2Intzh_fast)		\
-      SymI_HasProto(decodeFloatzuIntzh_fast)		\
+      SymI_HasProto(stg_decodeDoublezu2Intzh)		\
+      SymI_HasProto(stg_decodeFloatzuIntzh)		\
       SymI_HasProto(defaultsHook)			\
-      SymI_HasProto(delayzh_fast)			\
-      SymI_HasProto(deRefWeakzh_fast)			\
-      SymI_HasProto(deRefStablePtrzh_fast)		\
+      SymI_HasProto(stg_delayzh)			\
+      SymI_HasProto(stg_deRefWeakzh)			\
+      SymI_HasProto(stg_deRefStablePtrzh)		\
       SymI_HasProto(dirty_MUT_VAR)			\
-      SymI_HasProto(forkzh_fast)			\
-      SymI_HasProto(forkOnzh_fast)			\
+      SymI_HasProto(stg_forkzh)			        \
+      SymI_HasProto(stg_forkOnzh)			\
       SymI_HasProto(forkProcess)			\
       SymI_HasProto(forkOS_createThread)		\
       SymI_HasProto(freeHaskellFunctionPtr)		\
@@ -634,44 +634,44 @@ typedef struct _RtsSymbolVal {
       SymI_HasProto(hs_hpc_rootModule)		        \
       SymI_HasProto(hs_hpc_module)		        \
       SymI_HasProto(initLinker)				\
-      SymI_HasProto(unpackClosurezh_fast)               \
-      SymI_HasProto(getApStackValzh_fast)               \
-      SymI_HasProto(getSparkzh_fast)                    \
-      SymI_HasProto(isCurrentThreadBoundzh_fast)	\
-      SymI_HasProto(isEmptyMVarzh_fast)			\
-      SymI_HasProto(killThreadzh_fast)			\
+      SymI_HasProto(stg_unpackClosurezh)                \
+      SymI_HasProto(stg_getApStackValzh)                \
+      SymI_HasProto(stg_getSparkzh)                     \
+      SymI_HasProto(stg_isCurrentThreadBoundzh)	        \
+      SymI_HasProto(stg_isEmptyMVarzh)			\
+      SymI_HasProto(stg_killThreadzh)			\
       SymI_HasProto(loadObj)          			\
       SymI_HasProto(insertStableSymbol) 		\
       SymI_HasProto(insertSymbol)     			\
       SymI_HasProto(lookupSymbol)     			\
-      SymI_HasProto(makeStablePtrzh_fast)		\
-      SymI_HasProto(mkApUpd0zh_fast)			\
-      SymI_HasProto(myThreadIdzh_fast)			\
-      SymI_HasProto(labelThreadzh_fast)                 \
-      SymI_HasProto(newArrayzh_fast)			\
-      SymI_HasProto(newBCOzh_fast)			\
-      SymI_HasProto(newByteArrayzh_fast)		\
+      SymI_HasProto(stg_makeStablePtrzh)		\
+      SymI_HasProto(stg_mkApUpd0zh)			\
+      SymI_HasProto(stg_myThreadIdzh)			\
+      SymI_HasProto(stg_labelThreadzh)                  \
+      SymI_HasProto(stg_newArrayzh)			\
+      SymI_HasProto(stg_newBCOzh)			\
+      SymI_HasProto(stg_newByteArrayzh)  		\
       SymI_HasProto_redirect(newCAF, newDynCAF)		\
-      SymI_HasProto(newMVarzh_fast)			\
-      SymI_HasProto(newMutVarzh_fast)			\
-      SymI_HasProto(newTVarzh_fast)			\
-      SymI_HasProto(noDuplicatezh_fast)			\
-      SymI_HasProto(atomicModifyMutVarzh_fast)		\
-      SymI_HasProto(newPinnedByteArrayzh_fast)		\
-      SymI_HasProto(newAlignedPinnedByteArrayzh_fast)	\
+      SymI_HasProto(stg_newMVarzh)			\
+      SymI_HasProto(stg_newMutVarzh)			\
+      SymI_HasProto(stg_newTVarzh)			\
+      SymI_HasProto(stg_noDuplicatezh)			\
+      SymI_HasProto(stg_atomicModifyMutVarzh)		\
+      SymI_HasProto(stg_newPinnedByteArrayzh)		\
+      SymI_HasProto(stg_newAlignedPinnedByteArrayzh)	\
       SymI_HasProto(newSpark)				\
       SymI_HasProto(performGC)				\
       SymI_HasProto(performMajorGC)			\
       SymI_HasProto(prog_argc)				\
       SymI_HasProto(prog_argv)				\
-      SymI_HasProto(putMVarzh_fast)			\
-      SymI_HasProto(raisezh_fast)			\
-      SymI_HasProto(raiseIOzh_fast)			\
-      SymI_HasProto(readTVarzh_fast)			\
-      SymI_HasProto(readTVarIOzh_fast)			\
+      SymI_HasProto(stg_putMVarzh)			\
+      SymI_HasProto(stg_raisezh)			\
+      SymI_HasProto(stg_raiseIOzh)			\
+      SymI_HasProto(stg_readTVarzh)			\
+      SymI_HasProto(stg_readTVarIOzh)			\
       SymI_HasProto(resumeThread)			\
       SymI_HasProto(resolveObjs)                        \
-      SymI_HasProto(retryzh_fast)                       \
+      SymI_HasProto(stg_retryzh)                        \
       SymI_HasProto(rts_apply)				\
       SymI_HasProto(rts_checkSchedStatus)		\
       SymI_HasProto(rts_eval)				\
@@ -793,17 +793,17 @@ typedef struct _RtsSymbolVal {
       SymI_HasProto(stg_sel_9_upd_info)			\
       SymI_HasProto(stg_upd_frame_info)			\
       SymI_HasProto(suspendThread)			\
-      SymI_HasProto(takeMVarzh_fast)			\
-      SymI_HasProto(threadStatuszh_fast)		\
-      SymI_HasProto(tryPutMVarzh_fast)			\
-      SymI_HasProto(tryTakeMVarzh_fast)			\
-      SymI_HasProto(unblockAsyncExceptionszh_fast)	\
+      SymI_HasProto(stg_takeMVarzh)			\
+      SymI_HasProto(stg_threadStatuszh)		        \
+      SymI_HasProto(stg_tryPutMVarzh)			\
+      SymI_HasProto(stg_tryTakeMVarzh)			\
+      SymI_HasProto(stg_unblockAsyncExceptionszh)	\
       SymI_HasProto(unloadObj)                          \
-      SymI_HasProto(unsafeThawArrayzh_fast)		\
-      SymI_HasProto(waitReadzh_fast)			\
-      SymI_HasProto(waitWritezh_fast)			\
-      SymI_HasProto(writeTVarzh_fast)			\
-      SymI_HasProto(yieldzh_fast)                       \
+      SymI_HasProto(stg_unsafeThawArrayzh)		\
+      SymI_HasProto(stg_waitReadzh)			\
+      SymI_HasProto(stg_waitWritezh)			\
+      SymI_HasProto(stg_writeTVarzh)			\
+      SymI_HasProto(stg_yieldzh)                        \
       SymI_NeedsProto(stg_interp_constr_entry)          \
       SymI_HasProto(alloc_blocks)                       \
       SymI_HasProto(alloc_blocks_lim)                   \
@@ -818,7 +818,7 @@ typedef struct _RtsSymbolVal {
       SymI_NeedsProto(rts_stop_on_exception)		\
       SymI_HasProto(stopTimer)				\
       SymI_HasProto(n_capabilities)			\
-      SymI_HasProto(traceCcszh_fast)                    \
+      SymI_HasProto(stg_traceCcszh)                     \
       RTS_USER_SIGNALS_SYMBOLS
 
 
diff --git a/rts/PrimOps.cmm b/rts/PrimOps.cmm
index 9efc9f1ed8..bc2d07a2dc 100644
--- a/rts/PrimOps.cmm
+++ b/rts/PrimOps.cmm
@@ -51,10 +51,10 @@ import ghczmprim_GHCziBool_False_closure;
  * round up to the nearest word for the size of the array.
  */
 
-newByteArrayzh_fast
+stg_newByteArrayzh
 {
     W_ words, payload_words, n, p;
-    MAYBE_GC(NO_PTRS,newByteArrayzh_fast);
+    MAYBE_GC(NO_PTRS,stg_newByteArrayzh);
     n = R1;
     payload_words = ROUNDUP_BYTES_TO_WDS(n);
     words = BYTES_TO_WDS(SIZEOF_StgArrWords) + payload_words;
@@ -68,11 +68,11 @@ newByteArrayzh_fast
 #define BA_ALIGN 16
 #define BA_MASK  (BA_ALIGN-1)
 
-newPinnedByteArrayzh_fast
+stg_newPinnedByteArrayzh
 {
     W_ words, bytes, payload_words, p;
 
-    MAYBE_GC(NO_PTRS,newPinnedByteArrayzh_fast);
+    MAYBE_GC(NO_PTRS,stg_newPinnedByteArrayzh);
     bytes = R1;
     /* payload_words is what we will tell the profiler we had to allocate */
     payload_words = ROUNDUP_BYTES_TO_WDS(bytes);
@@ -97,11 +97,11 @@ newPinnedByteArrayzh_fast
     RET_P(p);
 }
 
-newAlignedPinnedByteArrayzh_fast
+stg_newAlignedPinnedByteArrayzh
 {
     W_ words, bytes, payload_words, p, alignment;
 
-    MAYBE_GC(NO_PTRS,newAlignedPinnedByteArrayzh_fast);
+    MAYBE_GC(NO_PTRS,stg_newAlignedPinnedByteArrayzh);
     bytes = R1;
     alignment = R2;
 
@@ -130,13 +130,13 @@ newAlignedPinnedByteArrayzh_fast
     RET_P(p);
 }
 
-newArrayzh_fast
+stg_newArrayzh
 {
     W_ words, n, init, arr, p;
     /* Args: R1 = words, R2 = initialisation value */
 
     n = R1;
-    MAYBE_GC(R2_PTR,newArrayzh_fast);
+    MAYBE_GC(R2_PTR,stg_newArrayzh);
 
     words = BYTES_TO_WDS(SIZEOF_StgMutArrPtrs) + n;
     ("ptr" arr) = foreign "C" allocateLocal(MyCapability() "ptr",words) [R2];
@@ -158,7 +158,7 @@ newArrayzh_fast
     RET_P(arr);
 }
 
-unsafeThawArrayzh_fast
+stg_unsafeThawArrayzh
 {
   // SUBTLETY TO DO WITH THE OLD GEN MUTABLE LIST
   //
@@ -193,12 +193,12 @@ unsafeThawArrayzh_fast
    MutVar primitives
    -------------------------------------------------------------------------- */
 
-newMutVarzh_fast
+stg_newMutVarzh
 {
     W_ mv;
     /* Args: R1 = initialisation value */
 
-    ALLOC_PRIM( SIZEOF_StgMutVar, R1_PTR, newMutVarzh_fast);
+    ALLOC_PRIM( SIZEOF_StgMutVar, R1_PTR, stg_newMutVarzh);
 
     mv = Hp - SIZEOF_StgMutVar + WDS(1);
     SET_HDR(mv,stg_MUT_VAR_DIRTY_info,W_[CCCS]);
@@ -207,7 +207,7 @@ newMutVarzh_fast
     RET_P(mv);
 }
 
-atomicModifyMutVarzh_fast
+stg_atomicModifyMutVarzh
 {
     W_ mv, f, z, x, y, r, h;
     /* Args: R1 :: MutVar#,  R2 :: a -> (a,b) */
@@ -246,7 +246,7 @@ atomicModifyMutVarzh_fast
 
 #define SIZE (THUNK_2_SIZE + THUNK_1_SIZE + THUNK_1_SIZE)
 
-   HP_CHK_GEN_TICKY(SIZE, R1_PTR & R2_PTR, atomicModifyMutVarzh_fast);
+   HP_CHK_GEN_TICKY(SIZE, R1_PTR & R2_PTR, stg_atomicModifyMutVarzh);
 
    mv = R1;
    f = R2;
@@ -295,7 +295,7 @@ atomicModifyMutVarzh_fast
 
 STRING(stg_weak_msg,"New weak pointer at %p\n")
 
-mkWeakzh_fast
+stg_mkWeakzh
 {
   /* R1 = key
      R2 = value
@@ -307,7 +307,7 @@ mkWeakzh_fast
     R3 = stg_NO_FINALIZER_closure;
   }
 
-  ALLOC_PRIM( SIZEOF_StgWeak, R1_PTR & R2_PTR & R3_PTR, mkWeakzh_fast );
+  ALLOC_PRIM( SIZEOF_StgWeak, R1_PTR & R2_PTR & R3_PTR, stg_mkWeakzh );
 
   w = Hp - SIZEOF_StgWeak + WDS(1);
   SET_HDR(w, stg_WEAK_info, W_[CCCS]);
@@ -329,7 +329,7 @@ mkWeakzh_fast
   RET_P(w);
 }
 
-mkWeakForeignEnvzh_fast
+stg_mkWeakForeignEnvzh
 {
   /* R1 = key
      R2 = value
@@ -349,7 +349,7 @@ mkWeakForeignEnvzh_fast
   flag = R5;
   eptr = R6;
 
-  ALLOC_PRIM( SIZEOF_StgWeak, R1_PTR & R2_PTR, mkWeakForeignEnvzh_fast );
+  ALLOC_PRIM( SIZEOF_StgWeak, R1_PTR & R2_PTR, stg_mkWeakForeignEnvzh );
 
   w = Hp - SIZEOF_StgWeak + WDS(1);
   SET_HDR(w, stg_WEAK_info, W_[CCCS]);
@@ -383,7 +383,7 @@ mkWeakForeignEnvzh_fast
   RET_P(w);
 }
 
-finalizzeWeakzh_fast
+stg_finalizzeWeakzh
 {
   /* R1 = weak ptr
    */
@@ -435,7 +435,7 @@ finalizzeWeakzh_fast
   }
 }
 
-deRefWeakzh_fast
+stg_deRefWeakzh
 {
   /* R1 = weak ptr */
   W_ w, code, val;
@@ -455,14 +455,14 @@ deRefWeakzh_fast
    Floating point operations.
    -------------------------------------------------------------------------- */
 
-decodeFloatzuIntzh_fast
+stg_decodeFloatzuIntzh
 { 
     W_ p;
     F_ arg;
     W_ mp_tmp1;
     W_ mp_tmp_w;
 
-    STK_CHK_GEN( WDS(2), NO_PTRS, decodeFloatzuIntzh_fast );
+    STK_CHK_GEN( WDS(2), NO_PTRS, stg_decodeFloatzuIntzh );
 
     mp_tmp1  = Sp - WDS(1);
     mp_tmp_w = Sp - WDS(2);
@@ -477,7 +477,7 @@ decodeFloatzuIntzh_fast
     RET_NN(W_[mp_tmp1], W_[mp_tmp_w]);
 }
 
-decodeDoublezu2Intzh_fast
+stg_decodeDoublezu2Intzh
 { 
     D_ arg;
     W_ p;
@@ -486,7 +486,7 @@ decodeDoublezu2Intzh_fast
     W_ mp_result1;
     W_ mp_result2;
 
-    STK_CHK_GEN( WDS(4), NO_PTRS, decodeDoublezu2Intzh_fast );
+    STK_CHK_GEN( WDS(4), NO_PTRS, stg_decodeDoublezu2Intzh );
 
     mp_tmp1    = Sp - WDS(1);
     mp_tmp2    = Sp - WDS(2);
@@ -510,11 +510,11 @@ decodeDoublezu2Intzh_fast
  * Concurrency primitives
  * -------------------------------------------------------------------------- */
 
-forkzh_fast
+stg_forkzh
 {
   /* args: R1 = closure to spark */
 
-  MAYBE_GC(R1_PTR, forkzh_fast);
+  MAYBE_GC(R1_PTR, stg_forkzh);
 
   W_ closure;
   W_ threadid;
@@ -538,11 +538,11 @@ forkzh_fast
   RET_P(threadid);
 }
 
-forkOnzh_fast
+stg_forkOnzh
 {
   /* args: R1 = cpu, R2 = closure to spark */
 
-  MAYBE_GC(R2_PTR, forkOnzh_fast);
+  MAYBE_GC(R2_PTR, stg_forkOnzh);
 
   W_ cpu;
   W_ closure;
@@ -568,18 +568,18 @@ forkOnzh_fast
   RET_P(threadid);
 }
 
-yieldzh_fast
+stg_yieldzh
 {
   jump stg_yield_noregs;
 }
 
-myThreadIdzh_fast
+stg_myThreadIdzh
 {
   /* no args. */
   RET_P(CurrentTSO);
 }
 
-labelThreadzh_fast
+stg_labelThreadzh
 {
   /* args: 
 	R1 = ThreadId#
@@ -590,7 +590,7 @@ labelThreadzh_fast
   jump %ENTRY_CODE(Sp(0));
 }
 
-isCurrentThreadBoundzh_fast
+stg_isCurrentThreadBoundzh
 {
   /* no args */
   W_ r;
@@ -598,7 +598,7 @@ isCurrentThreadBoundzh_fast
   RET_N(r);
 }
 
-threadStatuszh_fast
+stg_threadStatuszh
 {
     /* args: R1 :: ThreadId# */
     W_ tso;
@@ -802,24 +802,24 @@ INFO_TABLE_RET(stg_catch_stm_frame, CATCH_STM_FRAME,
 
 // Primop definition ------------------------------------------------------------
 
-atomicallyzh_fast
+stg_atomicallyzh
 {
   W_ frame;
   W_ old_trec;
   W_ new_trec;
   
   // stmStartTransaction may allocate
-  MAYBE_GC (R1_PTR, atomicallyzh_fast); 
+  MAYBE_GC (R1_PTR, stg_atomicallyzh); 
 
   /* Args: R1 = m :: STM a */
-  STK_CHK_GEN(SIZEOF_StgAtomicallyFrame + WDS(1), R1_PTR, atomicallyzh_fast);
+  STK_CHK_GEN(SIZEOF_StgAtomicallyFrame + WDS(1), R1_PTR, stg_atomicallyzh);
 
   old_trec = StgTSO_trec(CurrentTSO);
 
   /* Nested transactions are not allowed; raise an exception */
   if (old_trec != NO_TREC) {
      R1 = base_ControlziExceptionziBase_nestedAtomically_closure;
-     jump raisezh_fast;
+     jump stg_raisezh;
   }
 
   /* Set up the atomically frame */
@@ -840,13 +840,13 @@ atomicallyzh_fast
 }
 
 
-catchSTMzh_fast
+stg_catchSTMzh
 {
   W_ frame;
   
   /* Args: R1 :: STM a */
   /* Args: R2 :: Exception -> STM a */
-  STK_CHK_GEN(SIZEOF_StgCatchSTMFrame + WDS(1), R1_PTR & R2_PTR, catchSTMzh_fast);
+  STK_CHK_GEN(SIZEOF_StgCatchSTMFrame + WDS(1), R1_PTR & R2_PTR, stg_catchSTMzh);
 
   /* Set up the catch frame */
   Sp = Sp - SIZEOF_StgCatchSTMFrame;
@@ -868,18 +868,18 @@ catchSTMzh_fast
 }
 
 
-catchRetryzh_fast
+stg_catchRetryzh
 {
   W_ frame;
   W_ new_trec;
   W_ trec;
 
   // stmStartTransaction may allocate
-  MAYBE_GC (R1_PTR & R2_PTR, catchRetryzh_fast); 
+  MAYBE_GC (R1_PTR & R2_PTR, stg_catchRetryzh); 
 
   /* Args: R1 :: STM a */
   /* Args: R2 :: STM a */
-  STK_CHK_GEN(SIZEOF_StgCatchRetryFrame + WDS(1), R1_PTR & R2_PTR, catchRetryzh_fast);
+  STK_CHK_GEN(SIZEOF_StgCatchRetryFrame + WDS(1), R1_PTR & R2_PTR, stg_catchRetryzh);
 
   /* Start a nested transaction within which to run the first code */
   trec = StgTSO_trec(CurrentTSO);
@@ -900,7 +900,7 @@ catchRetryzh_fast
 }
 
 
-retryzh_fast
+stg_retryzh
 {
   W_ frame_type;
   W_ frame;
@@ -908,7 +908,7 @@ retryzh_fast
   W_ outer;
   W_ r;
 
-  MAYBE_GC (NO_PTRS, retryzh_fast); // STM operations may allocate
+  MAYBE_GC (NO_PTRS, stg_retryzh); // STM operations may allocate
 
   // Find the enclosing ATOMICALLY_FRAME or CATCH_RETRY_FRAME
 retry_pop_stack:
@@ -973,12 +973,12 @@ retry_pop_stack:
 }
 
 
-checkzh_fast
+stg_checkzh
 {
   W_ trec, closure;
 
   /* Args: R1 = invariant closure */
-  MAYBE_GC (R1_PTR, checkzh_fast); 
+  MAYBE_GC (R1_PTR, stg_checkzh); 
 
   trec = StgTSO_trec(CurrentTSO);
   closure = R1;
@@ -990,21 +990,21 @@ checkzh_fast
 }
 
 
-newTVarzh_fast
+stg_newTVarzh
 {
   W_ tv;
   W_ new_value;
 
   /* Args: R1 = initialisation value */
 
-  MAYBE_GC (R1_PTR, newTVarzh_fast); 
+  MAYBE_GC (R1_PTR, stg_newTVarzh); 
   new_value = R1;
   ("ptr" tv) = foreign "C" stmNewTVar(MyCapability() "ptr", new_value "ptr") [];
   RET_P(tv);
 }
 
 
-readTVarzh_fast
+stg_readTVarzh
 {
   W_ trec;
   W_ tvar;
@@ -1012,7 +1012,7 @@ readTVarzh_fast
 
   /* Args: R1 = TVar closure */
 
-  MAYBE_GC (R1_PTR, readTVarzh_fast); // Call to stmReadTVar may allocate
+  MAYBE_GC (R1_PTR, stg_readTVarzh); // Call to stmReadTVar may allocate
   trec = StgTSO_trec(CurrentTSO);
   tvar = R1;
   ("ptr" result) = foreign "C" stmReadTVar(MyCapability() "ptr", trec "ptr", tvar "ptr") [];
@@ -1020,7 +1020,7 @@ readTVarzh_fast
   RET_P(result);
 }
 
-readTVarIOzh_fast
+stg_readTVarIOzh
 {
     W_ result;
 
@@ -1032,7 +1032,7 @@ again:
     RET_P(result);
 }
 
-writeTVarzh_fast
+stg_writeTVarzh
 {
   W_ trec;
   W_ tvar;
@@ -1041,7 +1041,7 @@ writeTVarzh_fast
   /* Args: R1 = TVar closure */
   /*       R2 = New value    */
 
-  MAYBE_GC (R1_PTR & R2_PTR, writeTVarzh_fast); // Call to stmWriteTVar may allocate
+  MAYBE_GC (R1_PTR & R2_PTR, stg_writeTVarzh); // Call to stmWriteTVar may allocate
   trec = StgTSO_trec(CurrentTSO);
   tvar = R1;
   new_value = R2;
@@ -1083,7 +1083,7 @@ writeTVarzh_fast
  *
  * -------------------------------------------------------------------------- */
 
-isEmptyMVarzh_fast
+stg_isEmptyMVarzh
 {
     /* args: R1 = MVar closure */
 
@@ -1094,12 +1094,12 @@ isEmptyMVarzh_fast
     }
 }
 
-newMVarzh_fast
+stg_newMVarzh
 {
     /* args: none */
     W_ mvar;
 
-    ALLOC_PRIM ( SIZEOF_StgMVar, NO_PTRS, newMVarzh_fast );
+    ALLOC_PRIM ( SIZEOF_StgMVar, NO_PTRS, stg_newMVarzh );
   
     mvar = Hp - SIZEOF_StgMVar + WDS(1);
     SET_HDR(mvar,stg_MVAR_DIRTY_info,W_[CCCS]);
@@ -1119,7 +1119,7 @@ newMVarzh_fast
     StgTSO_sp(tso) = StgTSO_sp(tso) + WDS(3);	\
     lval = W_[StgTSO_sp(tso) - WDS(1)];
 
-takeMVarzh_fast
+stg_takeMVarzh
 {
     W_ mvar, val, info, tso;
 
@@ -1208,7 +1208,7 @@ takeMVarzh_fast
 }
 
 
-tryTakeMVarzh_fast
+stg_tryTakeMVarzh
 {
     W_ mvar, val, info, tso;
 
@@ -1281,7 +1281,7 @@ tryTakeMVarzh_fast
 }
 
 
-putMVarzh_fast
+stg_putMVarzh
 {
     W_ mvar, val, info, tso;
 
@@ -1365,7 +1365,7 @@ putMVarzh_fast
 }
 
 
-tryPutMVarzh_fast
+stg_tryPutMVarzh
 {
     W_ mvar, info, tso;
 
@@ -1437,11 +1437,11 @@ tryPutMVarzh_fast
    Stable pointer primitives
    -------------------------------------------------------------------------  */
 
-makeStableNamezh_fast
+stg_makeStableNamezh
 {
     W_ index, sn_obj;
 
-    ALLOC_PRIM( SIZEOF_StgStableName, R1_PTR, makeStableNamezh_fast );
+    ALLOC_PRIM( SIZEOF_StgStableName, R1_PTR, stg_makeStableNamezh );
   
     (index) = foreign "C" lookupStableName(R1 "ptr") [];
 
@@ -1461,16 +1461,16 @@ makeStableNamezh_fast
 }
 
 
-makeStablePtrzh_fast
+stg_makeStablePtrzh
 {
     /* Args: R1 = a */
     W_ sp;
-    MAYBE_GC(R1_PTR, makeStablePtrzh_fast);
+    MAYBE_GC(R1_PTR, stg_makeStablePtrzh);
     ("ptr" sp) = foreign "C" getStablePtr(R1 "ptr") [];
     RET_N(sp);
 }
 
-deRefStablePtrzh_fast
+stg_deRefStablePtrzh
 {
     /* Args: R1 = the stable ptr */
     W_ r, sp;
@@ -1483,7 +1483,7 @@ deRefStablePtrzh_fast
    Bytecode object primitives
    -------------------------------------------------------------------------  */
 
-newBCOzh_fast
+stg_newBCOzh
 {
     /* R1 = instrs
        R2 = literals
@@ -1498,7 +1498,7 @@ newBCOzh_fast
     words = BYTES_TO_WDS(SIZEOF_StgBCO) + StgArrWords_words(bitmap_arr);
     bytes = WDS(words);
 
-    ALLOC_PRIM( bytes, R1_PTR&R2_PTR&R3_PTR&R5_PTR, newBCOzh_fast );
+    ALLOC_PRIM( bytes, R1_PTR&R2_PTR&R3_PTR&R5_PTR, stg_newBCOzh );
 
     bco = Hp - bytes + WDS(1);
     SET_HDR(bco, stg_BCO_info, W_[CCCS]);
@@ -1523,7 +1523,7 @@ for:
 }
 
 
-mkApUpd0zh_fast
+stg_mkApUpd0zh
 {
     // R1 = the BCO# for the AP
     //	
@@ -1535,7 +1535,7 @@ mkApUpd0zh_fast
     ASSERT(%INFO_TYPE(%GET_STD_INFO(R1)) == HALF_W_(BCO) &&
 	   StgBCO_arity(R1) == HALF_W_(0));
 
-    HP_CHK_GEN_TICKY(SIZEOF_StgAP, R1_PTR, mkApUpd0zh_fast);
+    HP_CHK_GEN_TICKY(SIZEOF_StgAP, R1_PTR, stg_mkApUpd0zh);
     TICK_ALLOC_UP_THK(0, 0);
     CCCS_ALLOC(SIZEOF_StgAP);
 
@@ -1548,7 +1548,7 @@ mkApUpd0zh_fast
     RET_P(ap);
 }
 
-unpackClosurezh_fast
+stg_unpackClosurezh
 {
 /* args: R1 = closure to analyze */
 // TODO: Consider the absence of ptrs or nonptrs as a special case ?
@@ -1582,7 +1582,7 @@ out:
     nptrs_arr_sz = SIZEOF_StgArrWords   + WDS(nptrs);
     ptrs_arr_sz  = SIZEOF_StgMutArrPtrs + WDS(ptrs);
 
-    ALLOC_PRIM (ptrs_arr_sz + nptrs_arr_sz, R1_PTR, unpackClosurezh_fast);
+    ALLOC_PRIM (ptrs_arr_sz + nptrs_arr_sz, R1_PTR, stg_unpackClosurezh);
 
     W_ clos;
     clos = UNTAG(R1);
@@ -1628,7 +1628,7 @@ for2:
     }							\
     W_[blocked_queue_tl] = tso;
 
-waitReadzh_fast
+stg_waitReadzh
 {
     /* args: R1 */
 #ifdef THREADED_RTS
@@ -1645,7 +1645,7 @@ waitReadzh_fast
 #endif
 }
 
-waitWritezh_fast
+stg_waitWritezh
 {
     /* args: R1 */
 #ifdef THREADED_RTS
@@ -1663,8 +1663,8 @@ waitWritezh_fast
 }
 
 
-STRING(stg_delayzh_malloc_str, "delayzh_fast")
-delayzh_fast
+STRING(stg_delayzh_malloc_str, "stg_delayzh")
+stg_delayzh
 {
 #ifdef mingw32_HOST_OS
     W_ ares;
@@ -1737,8 +1737,8 @@ while:
 
 
 #ifdef mingw32_HOST_OS
-STRING(stg_asyncReadzh_malloc_str, "asyncReadzh_fast")
-asyncReadzh_fast
+STRING(stg_asyncReadzh_malloc_str, "stg_asyncReadzh")
+stg_asyncReadzh
 {
     W_ ares;
     CInt reqID;
@@ -1765,8 +1765,8 @@ asyncReadzh_fast
 #endif
 }
 
-STRING(stg_asyncWritezh_malloc_str, "asyncWritezh_fast")
-asyncWritezh_fast
+STRING(stg_asyncWritezh_malloc_str, "stg_asyncWritezh")
+stg_asyncWritezh
 {
     W_ ares;
     CInt reqID;
@@ -1793,8 +1793,8 @@ asyncWritezh_fast
 #endif
 }
 
-STRING(stg_asyncDoProczh_malloc_str, "asyncDoProczh_fast")
-asyncDoProczh_fast
+STRING(stg_asyncDoProczh_malloc_str, "stg_asyncDoProczh")
+stg_asyncDoProczh
 {
     W_ ares;
     CInt reqID;
@@ -1826,7 +1826,7 @@ asyncDoProczh_fast
 // evaluation by the current thread are also under evaluation by
 // another thread.  It relies on *both* threads doing noDuplicate#;
 // the second one will get blocked if they are duplicating some work.
-noDuplicatezh_fast
+stg_noDuplicatezh
 {
     SAVE_THREAD_STATE();
     ASSERT(StgTSO_what_next(CurrentTSO) == ThreadRunGHC::I16);
@@ -1841,7 +1841,7 @@ noDuplicatezh_fast
     }
 }
 
-getApStackValzh_fast
+stg_getApStackValzh
 {
    W_ ap_stack, offset, val, ok;
 
@@ -1866,7 +1866,7 @@ getApStackValzh_fast
 // Write the cost center stack of the first argument on stderr; return
 // the second.  Possibly only makes sense for already evaluated
 // things?
-traceCcszh_fast
+stg_traceCcszh
 {
     W_ ccs;
 
@@ -1879,7 +1879,7 @@ traceCcszh_fast
     ENTER();
 }
 
-getSparkzh_fast
+stg_getSparkzh
 {
    W_ spark;
 
diff --git a/rts/RaiseAsync.c b/rts/RaiseAsync.c
index 39c973bd1d..4ca1cba28d 100644
--- a/rts/RaiseAsync.c
+++ b/rts/RaiseAsync.c
@@ -728,7 +728,7 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
 #if defined(PROFILING)
     /* 
      * Debugging tool: on raising an  exception, show where we are.
-     * See also Exception.cmm:raisezh_fast.
+     * See also Exception.cmm:stg_raisezh.
      * This wasn't done for asynchronous exceptions originally; see #1450 
      */
     if (RtsFlags.ProfFlags.showCCSOnException)