From 3ce4cf858bbcae18ffc6989ca19522cb8887aab9 Mon Sep 17 00:00:00 2001 From: Simon Marlow Date: Mon, 3 Aug 2009 20:29:40 +0000 Subject: [PATCH] Rename primops from foozh_fast to stg_foozh For consistency with other RTS exported symbols --- compiler/cmm/CLabel.hs | 2 +- includes/stg/MiscClosures.h | 196 +++++++++++++++++++++---------------------- rts/Exception.cmm | 34 ++++---- rts/HeapStackCheck.cmm | 6 +- rts/Linker.c | 116 ++++++++++++------------- rts/PrimOps.cmm | 168 ++++++++++++++++++------------------- rts/RaiseAsync.c | 2 +- 7 files changed, 262 insertions(+), 262 deletions(-) diff --git a/compiler/cmm/CLabel.hs b/compiler/cmm/CLabel.hs index 9ba55ac..a78c22f 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 1591570..074ed31 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 cf8ffdf..16b5d92 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 0c1af62..b516ef2 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 0e5630d..1fdd7c7 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 9efc9f1..bc2d07a 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 39c973b..4ca1cba 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) -- 1.7.10.4