= 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")
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
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) {
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.
*/
jump stg_ap_v_fast;
}
-asyncExceptionsBlockedzh_fast
+stg_asyncExceptionsBlockedzh
{
/* args: none */
if ((TO_W_(StgTSO_flags(CurrentTSO)) & TSO_BLOCKEX) != 0) {
}
}
-killThreadzh_fast
+stg_killThreadzh
{
/* args: R1 = TSO to kill, R2 = Exception */
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*
* 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? */
{
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;
*
* 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" {
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;
jump RET_LBL(stg_ap_pv);
}
-raiseIOzh_fast
+stg_raiseIOzh
{
/* Args :: R1 :: Exception */
- jump raisezh_fast;
+ jump stg_raisezh;
}
{
R1 = Sp(1);
Sp_adj(2);
- jump takeMVarzh_fast;
+ jump stg_takeMVarzh;
}
// code fragment executed just before we return to the scheduler
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
R2 = Sp(2);
R1 = Sp(1);
Sp_adj(3);
- jump killThreadzh_fast;
+ jump stg_killThreadzh;
}
stg_block_throwto_finally
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 \
/* 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) \
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) \
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) \
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) \
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
* 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;
#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);
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;
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];
RET_P(arr);
}
-unsafeThawArrayzh_fast
+stg_unsafeThawArrayzh
{
// SUBTLETY TO DO WITH THE OLD GEN MUTABLE LIST
//
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]);
RET_P(mv);
}
-atomicModifyMutVarzh_fast
+stg_atomicModifyMutVarzh
{
W_ mv, f, z, x, y, r, h;
/* Args: R1 :: MutVar#, R2 :: a -> (a,b) */
#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;
STRING(stg_weak_msg,"New weak pointer at %p\n")
-mkWeakzh_fast
+stg_mkWeakzh
{
/* R1 = key
R2 = value
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]);
RET_P(w);
}
-mkWeakForeignEnvzh_fast
+stg_mkWeakForeignEnvzh
{
/* R1 = key
R2 = value
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]);
RET_P(w);
}
-finalizzeWeakzh_fast
+stg_finalizzeWeakzh
{
/* R1 = weak ptr
*/
}
}
-deRefWeakzh_fast
+stg_deRefWeakzh
{
/* R1 = weak ptr */
W_ w, code, val;
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);
RET_NN(W_[mp_tmp1], W_[mp_tmp_w]);
}
-decodeDoublezu2Intzh_fast
+stg_decodeDoublezu2Intzh
{
D_ arg;
W_ p;
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);
* 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;
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;
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#
jump %ENTRY_CODE(Sp(0));
}
-isCurrentThreadBoundzh_fast
+stg_isCurrentThreadBoundzh
{
/* no args */
W_ r;
RET_N(r);
}
-threadStatuszh_fast
+stg_threadStatuszh
{
/* args: R1 :: ThreadId# */
W_ tso;
// 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 */
}
-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;
}
-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);
}
-retryzh_fast
+stg_retryzh
{
W_ frame_type;
W_ frame;
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:
}
-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;
}
-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;
/* 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") [];
RET_P(result);
}
-readTVarIOzh_fast
+stg_readTVarIOzh
{
W_ result;
RET_P(result);
}
-writeTVarzh_fast
+stg_writeTVarzh
{
W_ trec;
W_ tvar;
/* 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;
*
* -------------------------------------------------------------------------- */
-isEmptyMVarzh_fast
+stg_isEmptyMVarzh
{
/* args: R1 = MVar closure */
}
}
-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]);
StgTSO_sp(tso) = StgTSO_sp(tso) + WDS(3); \
lval = W_[StgTSO_sp(tso) - WDS(1)];
-takeMVarzh_fast
+stg_takeMVarzh
{
W_ mvar, val, info, tso;
}
-tryTakeMVarzh_fast
+stg_tryTakeMVarzh
{
W_ mvar, val, info, tso;
}
-putMVarzh_fast
+stg_putMVarzh
{
W_ mvar, val, info, tso;
}
-tryPutMVarzh_fast
+stg_tryPutMVarzh
{
W_ mvar, info, tso;
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") [];
}
-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;
Bytecode object primitives
------------------------------------------------------------------------- */
-newBCOzh_fast
+stg_newBCOzh
{
/* R1 = instrs
R2 = literals
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]);
}
-mkApUpd0zh_fast
+stg_mkApUpd0zh
{
// R1 = the BCO# for the AP
//
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);
RET_P(ap);
}
-unpackClosurezh_fast
+stg_unpackClosurezh
{
/* args: R1 = closure to analyze */
// TODO: Consider the absence of ptrs or nonptrs as a special case ?
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);
} \
W_[blocked_queue_tl] = tso;
-waitReadzh_fast
+stg_waitReadzh
{
/* args: R1 */
#ifdef THREADED_RTS
#endif
}
-waitWritezh_fast
+stg_waitWritezh
{
/* args: R1 */
#ifdef THREADED_RTS
}
-STRING(stg_delayzh_malloc_str, "delayzh_fast")
-delayzh_fast
+STRING(stg_delayzh_malloc_str, "stg_delayzh")
+stg_delayzh
{
#ifdef mingw32_HOST_OS
W_ ares;
#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;
#endif
}
-STRING(stg_asyncWritezh_malloc_str, "asyncWritezh_fast")
-asyncWritezh_fast
+STRING(stg_asyncWritezh_malloc_str, "stg_asyncWritezh")
+stg_asyncWritezh
{
W_ ares;
CInt reqID;
#endif
}
-STRING(stg_asyncDoProczh_malloc_str, "asyncDoProczh_fast")
-asyncDoProczh_fast
+STRING(stg_asyncDoProczh_malloc_str, "stg_asyncDoProczh")
+stg_asyncDoProczh
{
W_ ares;
CInt reqID;
// 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);
}
}
-getApStackValzh_fast
+stg_getApStackValzh
{
W_ ap_stack, offset, val, ok;
// 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;
ENTER();
}
-getSparkzh_fast
+stg_getSparkzh
{
W_ spark;
#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)
projects / ghc-hetmet.git / commitdiff