/* -----------------------------------------------------------------------------
- * $Id: PrimOps.hc,v 1.83 2001/08/08 10:50:37 simonmar Exp $
+ * $Id: PrimOps.hc,v 1.102 2002/10/22 11:01:19 simonmar Exp $
*
* (c) The GHC Team, 1998-2000
*
#include "Storage.h"
#include "BlockAlloc.h" /* tmp */
#include "StablePriv.h"
-#include "HeapStackCheck.h"
#include "StgRun.h"
#include "Itimer.h"
#include "Prelude.h"
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#include <stdlib.h>
+
/* ** temporary **
classes CCallable and CReturnable don't really exist, but the
#define BYTES_TO_STGWORDS(n) ((n) + sizeof(W_) - 1)/sizeof(W_)
-FN_(newByteArrayzh_fast) \
- { \
- W_ size, stuff_size, n; \
- StgArrWords* p; \
- FB_ \
- MAYBE_GC(NO_PTRS,newByteArrayzh_fast); \
- n = R1.w; \
- stuff_size = BYTES_TO_STGWORDS(n); \
- size = sizeofW(StgArrWords)+ stuff_size; \
- p = (StgArrWords *)RET_STGCALL1(P_,allocate,size); \
- TICK_ALLOC_PRIM(sizeofW(StgArrWords),stuff_size,0); \
- SET_HDR(p, &stg_ARR_WORDS_info, CCCS); \
- p->words = stuff_size; \
- TICK_RET_UNBOXED_TUP(1) \
- RET_P(p); \
- FE_ \
+FN_(newByteArrayzh_fast)
+ {
+ W_ size, stuff_size, n;
+ StgArrWords* p;
+ FB_
+ MAYBE_GC(NO_PTRS,newByteArrayzh_fast);
+ n = R1.w;
+ stuff_size = BYTES_TO_STGWORDS(n);
+ size = sizeofW(StgArrWords)+ stuff_size;
+ p = (StgArrWords *)RET_STGCALL1(P_,allocate,size);
+ TICK_ALLOC_PRIM(sizeofW(StgArrWords),stuff_size,0);
+ SET_HDR(p, &stg_ARR_WORDS_info, CCCS);
+ p->words = stuff_size;
+ TICK_RET_UNBOXED_TUP(1)
+ RET_P(p);
+ FE_
}
-FN_(newPinnedByteArrayzh_fast) \
- { \
- W_ size, stuff_size, n; \
- StgArrWords* p; \
- FB_ \
- MAYBE_GC(NO_PTRS,newPinnedByteArrayzh_fast); \
- n = R1.w; \
- stuff_size = BYTES_TO_STGWORDS(n); \
- size = sizeofW(StgArrWords)+ stuff_size; \
- p = (StgArrWords *)RET_STGCALL1(P_,allocatePinned,size); \
- TICK_ALLOC_PRIM(sizeofW(StgArrWords),stuff_size,0); \
- SET_HDR(p, &stg_ARR_WORDS_info, CCCS); \
- p->words = stuff_size; \
- TICK_RET_UNBOXED_TUP(1) \
- RET_P(p); \
- FE_ \
+FN_(newPinnedByteArrayzh_fast)
+ {
+ W_ size, stuff_size, n;
+ StgArrWords* p;
+ FB_
+ MAYBE_GC(NO_PTRS,newPinnedByteArrayzh_fast);
+ n = R1.w;
+ stuff_size = BYTES_TO_STGWORDS(n);
+
+ // We want an 8-byte aligned array. allocatePinned() gives us
+ // 8-byte aligned memory by default, but we want to align the
+ // *goods* inside the ArrWords object, so we have to check the
+ // size of the ArrWords header and adjust our size accordingly.
+ size = sizeofW(StgArrWords)+ stuff_size;
+ if ((sizeof(StgArrWords) & 7) != 0) {
+ size++;
+ }
+
+ p = (StgArrWords *)RET_STGCALL1(P_,allocatePinned,size);
+ TICK_ALLOC_PRIM(sizeofW(StgArrWords),stuff_size,0);
+
+ // Again, if the ArrWords header isn't a multiple of 8 bytes, we
+ // have to push the object forward one word so that the goods
+ // fall on an 8-byte boundary.
+ if ((sizeof(StgArrWords) & 7) != 0) {
+ ((StgPtr)p)++;
+ }
+
+ SET_HDR(p, &stg_ARR_WORDS_info, CCCS);
+ p->words = stuff_size;
+ TICK_RET_UNBOXED_TUP(1)
+ RET_P(p);
+ FE_
}
FN_(newArrayzh_fast)
FE_
}
+FN_(atomicModifyMutVarzh_fast)
+{
+ StgMutVar* mv;
+ StgClosure *z, *x, *y, *r;
+ FB_
+ /* Args: R1.p :: MutVar#, R2.p :: a -> (a,b) */
+
+ /* If x is the current contents of the MutVar#, then
+ We want to make the new contents point to
+
+ (sel_0 (f x))
+
+ and the return value is
+
+ (sel_1 (f x))
+
+ obviously we can share (f x).
+
+ z = [stg_ap_2 f x] (max (HS + 2) MIN_UPD_SIZE)
+ y = [stg_sel_0 z] (max (HS + 1) MIN_UPD_SIZE)
+ r = [stg_sel_1 z] (max (HS + 1) MIN_UPD_SIZE)
+ */
+
+#define THUNK_SIZE(n) (sizeofW(StgHeader) + stg_max((n), MIN_UPD_SIZE))
+#define SIZE (THUNK_SIZE(2) + THUNK_SIZE(1) + THUNK_SIZE(1))
+
+ HP_CHK_GEN_TICKY(SIZE, R1_PTR|R2_PTR, atomicModifyMutVarzh_fast,);
+ CCS_ALLOC(CCCS,SIZE);
+
+ x = ((StgMutVar *)R1.cl)->var;
+
+ TICK_ALLOC_UP_THK(2,0); // XXX
+ z = (StgClosure *) Hp - THUNK_SIZE(2) + 1;
+ SET_HDR(z, &stg_ap_2_upd_info, CCCS);
+ z->payload[0] = R2.cl;
+ z->payload[1] = x;
+
+ TICK_ALLOC_UP_THK(1,1); // XXX
+ y = (StgClosure *) (StgPtr)z - THUNK_SIZE(1);
+ SET_HDR(y, &stg_sel_0_upd_info, CCCS);
+ y->payload[0] = z;
+
+ ((StgMutVar *)R1.cl)->var = y;
+
+ TICK_ALLOC_UP_THK(1,1); // XXX
+ r = (StgClosure *) (StgPtr)y - THUNK_SIZE(1);
+ SET_HDR(r, &stg_sel_1_upd_info, CCCS);
+ r->payload[0] = z;
+
+ RET_P(r);
+ JMP_(ENTRY_CODE(Sp[0]));
+ FE_
+}
+
/* -----------------------------------------------------------------------------
Foreign Object Primitives
-
-------------------------------------------------------------------------- */
FN_(mkForeignObjzh_fast)
}
/* kill it */
+#ifdef PROFILING
+ // @LDV profiling
+ // A weak pointer is inherently used, so we do not need to call
+ // LDV_recordDead_FILL_SLOP_DYNAMIC():
+ // LDV_recordDead_FILL_SLOP_DYNAMIC((StgClosure *)w);
+ // or, LDV_recordDead():
+ // LDV_recordDead((StgClosure *)w, sizeofW(StgWeak) - sizeofW(StgProfHeader));
+ // Furthermore, when PROFILING is turned on, dead weak pointers are exactly as
+ // large as weak pointers, so there is no need to fill the slop, either.
+ // See stg_DEAD_WEAK_info in StgMiscClosures.hc.
+#endif
+ //
+ // Todo: maybe use SET_HDR() and remove LDV_recordCreate()?
+ //
w->header.info = &stg_DEAD_WEAK_info;
+#ifdef PROFILING
+ // @LDV profiling
+ LDV_recordCreate((StgClosure *)w);
+#endif
f = ((StgWeak *)w)->finalizer;
w->link = ((StgWeak *)w)->link;
FE_
}
+FN_(deRefWeakzh_fast)
+{
+ /* R1.p = weak ptr */
+ StgWeak* w;
+ I_ code;
+ P_ val;
+ FB_
+ w = (StgWeak*)R1.p;
+ if (w->header.info == &stg_WEAK_info) {
+ code = 1;
+ val = (P_)((StgWeak *)w)->value;
+ } else {
+ code = 0;
+ val = (P_)w;
+ }
+ RET_NP(code,val);
+ FE_
+}
+
/* -----------------------------------------------------------------------------
Arbitrary-precision Integer operations.
-------------------------------------------------------------------------- */
GMP_TAKE2_RET2(quotRemIntegerzh_fast, mpz_tdiv_qr);
GMP_TAKE2_RET2(divModIntegerzh_fast, mpz_fdiv_qr);
+
+FN_(gcdIntzh_fast)
+{
+ /* R1 = the first Int#; R2 = the second Int# */
+ mp_limb_t aa;
+ I_ r;
+ FB_
+ aa = (mp_limb_t)(R1.i);
+ r = RET_STGCALL3(StgInt, mpn_gcd_1, (mp_limb_t *)(&aa), 1, (mp_limb_t)(R2.i));
+
+ R1.i = r;
+ /* Result parked in R1, return via info-pointer at TOS */
+ JMP_(ENTRY_CODE(Sp[0]));
+ FE_
+}
+
+FN_(gcdIntegerIntzh_fast)
+{
+ /* R1 = s1; R2 = d1; R3 = the int */
+ I_ r;
+ FB_
+ r = RET_STGCALL3(StgInt,mpn_gcd_1,(mp_limb_t *)(BYTE_ARR_CTS(R2.p)), R1.i, R3.i);
+
+ R1.i = r;
+ /* Result parked in R1, return via info-pointer at TOS */
+ JMP_(ENTRY_CODE(Sp[0]));
+ FE_
+}
+
+FN_(cmpIntegerIntzh_fast)
+{
+ /* R1 = s1; R2 = d1; R3 = the int */
+ I_ usize;
+ I_ vsize;
+ I_ v_digit;
+ mp_limb_t u_digit;
+ FB_
+
+ usize = R1.i;
+ vsize = 0;
+ v_digit = R3.i;
+
+ // paraphrased from mpz_cmp_si() in the GMP sources
+ if (v_digit > 0) {
+ vsize = 1;
+ } else if (v_digit < 0) {
+ vsize = -1;
+ v_digit = -v_digit;
+ }
+
+ if (usize != vsize) {
+ R1.i = usize - vsize; JMP_(ENTRY_CODE(Sp[0]));
+ }
+
+ if (usize == 0) {
+ R1.i = 0; JMP_(ENTRY_CODE(Sp[0]));
+ }
+
+ u_digit = *(mp_limb_t *)(BYTE_ARR_CTS(R2.p));
+
+ if (u_digit == (mp_limb_t) (unsigned long) v_digit) {
+ R1.i = 0; JMP_(ENTRY_CODE(Sp[0]));
+ }
+
+ if (u_digit > (mp_limb_t) (unsigned long) v_digit) {
+ R1.i = usize;
+ } else {
+ R1.i = -usize;
+ }
+
+ JMP_(ENTRY_CODE(Sp[0]));
+ FE_
+}
+
+FN_(cmpIntegerzh_fast)
+{
+ /* R1 = s1; R2 = d1; R3 = s2; R4 = d2 */
+ I_ usize;
+ I_ vsize;
+ I_ size;
+ StgPtr up, vp;
+ int cmp;
+ FB_
+
+ // paraphrased from mpz_cmp() in the GMP sources
+ usize = R1.i;
+ vsize = R3.i;
+
+ if (usize != vsize) {
+ R1.i = usize - vsize; JMP_(ENTRY_CODE(Sp[0]));
+ }
+
+ if (usize == 0) {
+ R1.i = 0; JMP_(ENTRY_CODE(Sp[0]));
+ }
+
+ size = abs(usize);
+
+ up = BYTE_ARR_CTS(R2.p);
+ vp = BYTE_ARR_CTS(R4.p);
+
+ cmp = RET_STGCALL3(I_, mpn_cmp, (mp_limb_t *)up, (mp_limb_t *)vp, size);
+
+ if (cmp == 0) {
+ R1.i = 0; JMP_(ENTRY_CODE(Sp[0]));
+ }
+
+ if ((cmp < 0) == (usize < 0)) {
+ R1.i = 1;
+ } else {
+ R1.i = (-1);
+ }
+ /* Result parked in R1, return via info-pointer at TOS */
+ JMP_(ENTRY_CODE(Sp[0]));
+ FE_
+}
+
+FN_(integer2Intzh_fast)
+{
+ /* R1 = s; R2 = d */
+ I_ r, s;
+ FB_
+ s = R1.i;
+ if (s == 0)
+ r = 0;
+ else {
+ r = ((mp_limb_t *) (BYTE_ARR_CTS(R2.p)))[0];
+ if (s < 0) r = -r;
+ }
+ /* Result parked in R1, return via info-pointer at TOS */
+ R1.i = r;
+ JMP_(ENTRY_CODE(Sp[0]));
+ FE_
+}
+
+FN_(integer2Wordzh_fast)
+{
+ /* R1 = s; R2 = d */
+ I_ s;
+ W_ r;
+ FB_
+ s = R1.i;
+ if (s == 0)
+ r = 0;
+ else {
+ r = ((mp_limb_t *) (BYTE_ARR_CTS(R2.p)))[0];
+ if (s < 0) r = -r;
+ }
+ /* Result parked in R1, return via info-pointer at TOS */
+ R1.w = r;
+ JMP_(ENTRY_CODE(Sp[0]));
+ FE_
+}
+
+
FN_(decodeFloatzh_fast)
{
MP_INT mantissa;
/* create it right now, return ThreadID in R1 */
R1.t = RET_STGCALL2(StgTSO *, createIOThread,
- RtsFlags.GcFlags.initialStkSize, R1.cl);
+ RtsFlags.GcFlags.initialStkSize, R1.cl);
STGCALL1(scheduleThread, R1.t);
/* switch at the earliest opportunity */
context_switch = 1;
+ RET_P(R1.t);
+ FE_
+}
+
+FN_(forkProcesszh_fast)
+{
+ pid_t pid;
+
+ FB_
+ /* args: none */
+ /* result: Pid */
+
+ R1.i = RET_STGCALL1(StgInt, forkProcess, CurrentTSO);
+
JMP_(ENTRY_CODE(Sp[0]));
+
FE_
}
FE_
}
+FN_(myThreadIdzh_fast)
+{
+ /* no args. */
+ FB_
+ RET_P((P_)CurrentTSO);
+ FE_
+}
+
+FN_(labelThreadzh_fast)
+{
+ FB_
+ /* args:
+ R1.p = ThreadId#
+ R2.p = Addr# */
+#ifdef DEBUG
+ STGCALL2(labelThread,R1.p,(char *)R2.p);
+#endif
+ JMP_(ENTRY_CODE(Sp[0]));
+ FE_
+}
+
+
/* -----------------------------------------------------------------------------
* MVar primitives
*
*
* -------------------------------------------------------------------------- */
+FN_(isEmptyMVarzh_fast)
+{
+ /* args: R1 = MVar closure */
+ I_ r;
+ FB_
+ r = (I_)((GET_INFO((StgMVar*)(R1.p))) == &stg_EMPTY_MVAR_info);
+ RET_N(r);
+ FE_
+}
+
+
FN_(newMVarzh_fast)
{
StgMVar *mvar;
FE_
}
-#define PerformTake(tso, value) ({ \
- (tso)->sp[1] = (W_)value; \
- (tso)->sp[0] = (W_)&stg_gc_unpt_r1_ret_info; \
+/* If R1 isn't available, pass it on the stack */
+#ifdef REG_R1
+#define PerformTake(tso, value) ({ \
+ (tso)->sp[1] = (W_)value; \
+ (tso)->sp[0] = (W_)&stg_gc_unpt_r1_info; \
+ })
+#else
+#define PerformTake(tso, value) ({ \
+ (tso)->sp[1] = (W_)value; \
+ (tso)->sp[0] = (W_)&stg_ut_1_0_unreg_info; \
})
+#endif
+
#define PerformPut(tso) ({ \
StgClosure *val = (StgClosure *)(tso)->sp[2]; \
- (tso)->sp[2] = (W_)&stg_gc_noregs_ret_info; \
+ (tso)->sp[2] = (W_)&stg_gc_noregs_info; \
(tso)->sp += 2; \
val; \
})
/* unlock in the SMP case */
SET_INFO(mvar,&stg_FULL_MVAR_info);
#endif
- TICK_RET_UNBOXED_TUP(1);
- RET_P(val);
} else {
/* No further putMVars, MVar is now empty */
+ mvar->value = (StgClosure *)&stg_END_TSO_QUEUE_closure;
/* do this last... we might have locked the MVar in the SMP case,
* and writing the info pointer will unlock it.
*/
SET_INFO(mvar,&stg_EMPTY_MVAR_info);
- mvar->value = (StgClosure *)&stg_END_TSO_QUEUE_closure;
- TICK_RET_UNBOXED_TUP(1);
- RET_P(val);
}
+
+ TICK_RET_UNBOXED_TUP(1);
+ RET_NP((I_)1, val);
FE_
}
RET_P(sn_obj);
}
+
+FN_(makeStablePtrzh_fast)
+{
+ /* Args: R1 = a */
+ StgStablePtr sp;
+ FB_
+ MAYBE_GC(R1_PTR, makeStablePtrzh_fast);
+ sp = RET_STGCALL1(StgStablePtr,getStablePtr,R1.p);
+ RET_N(sp);
+ FE_
+}
+
+FN_(deRefStablePtrzh_fast)
+{
+ /* Args: R1 = the stable ptr */
+ P_ r;
+ StgStablePtr sp;
+ FB_
+ sp = (StgStablePtr)R1.w;
+ r = stable_ptr_table[(StgWord)sp].addr;
+ RET_P(r);
+ FE_
+}
+
/* -----------------------------------------------------------------------------
Bytecode object primitives
------------------------------------------------------------------------- */