Commit 3ce4cf85 authored by Simon Marlow's avatar Simon Marlow

Rename primops from foozh_fast to stg_foozh

For consistency with other RTS exported symbols
parent 02ec05e6
......@@ -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")
......
......@@ -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
......
......@@ -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;
}
......@@ -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
......
......@@ -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
......
......@@ -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