Do not link ghc stage1 using -threaded, only for stage2 or 3

[ghc-hetmet.git] / rts / RtsAPI.c

diff --git a/rts/RtsAPI.c b/rts/RtsAPI.c
index 525ead2..911e703 100644 (file)
--- a/rts/RtsAPI.c
+++ b/rts/RtsAPI.c
@@ -74,6 +74,31 @@ rts_mkInt32 (Capability *cap, HsInt32 i)
   return p;
 }
 
+
+#ifdef sparc_HOST_ARCH
+/* The closures returned by allocateLocal are only guaranteed to be 32 bit
+   aligned, because that's the size of pointers. SPARC v9 can't do
+   misaligned loads/stores, so we have to write the 64bit word in chunks         */
+
+HaskellObj
+rts_mkInt64 (Capability *cap, HsInt64 i_)
+{
+  StgInt64 i   = (StgInt64)i_;
+  StgInt32 *tmp;
+
+  StgClosure *p = (StgClosure *)allocateLocal(cap,CONSTR_sizeW(0,2));
+  SET_HDR(p, I64zh_con_info, CCS_SYSTEM);
+
+  tmp    = (StgInt32*)&(p->payload[0]);
+
+  tmp[0] = (StgInt32)((StgInt64)i >> 32);
+  tmp[1] = (StgInt32)i;                /* truncate high 32 bits */
+
+  return p;
+}
+
+#else
+
 HaskellObj
 rts_mkInt64 (Capability *cap, HsInt64 i)
 {
@@ -85,6 +110,9 @@ rts_mkInt64 (Capability *cap, HsInt64 i)
   return p;
 }
 
+#endif /* sparc_HOST_ARCH */
+
+
 HaskellObj
 rts_mkWord (Capability *cap, HsWord i)
 {
@@ -124,6 +152,31 @@ rts_mkWord32 (Capability *cap, HsWord32 w)
   return p;
 }
 
+
+#ifdef sparc_HOST_ARCH
+/* The closures returned by allocateLocal are only guaranteed to be 32 bit
+   aligned, because that's the size of pointers. SPARC v9 can't do
+   misaligned loads/stores, so we have to write the 64bit word in chunks         */
+
+HaskellObj
+rts_mkWord64 (Capability *cap, HsWord64 w_)
+{
+  StgWord64 w = (StgWord64)w_;
+  StgWord32 *tmp;
+
+  StgClosure *p = (StgClosure *)allocateLocal(cap,CONSTR_sizeW(0,2));
+  /* see mk_Int8 comment */
+  SET_HDR(p, W64zh_con_info, CCS_SYSTEM);
+  
+  tmp    = (StgWord32*)&(p->payload[0]);
+
+  tmp[0] = (StgWord32)((StgWord64)w >> 32);
+  tmp[1] = (StgWord32)w;       /* truncate high 32 bits */
+  return p;
+}
+
+#else
+
 HaskellObj
 rts_mkWord64 (Capability *cap, HsWord64 w)
 {
@@ -137,6 +190,9 @@ rts_mkWord64 (Capability *cap, HsWord64 w)
   return p;
 }
 
+#endif
+
+
 HaskellObj
 rts_mkFloat (Capability *cap, HsFloat f)
 {
@@ -264,6 +320,27 @@ rts_getInt32 (HaskellObj p)
   return (HsInt32)(HsInt)(UNTAG_CLOSURE(p)->payload[0]);
 }
 
+
+#ifdef sparc_HOST_ARCH
+/* The closures returned by allocateLocal are only guaranteed to be 32 bit
+   aligned, because that's the size of pointers. SPARC v9 can't do
+   misaligned loads/stores, so we have to read the 64bit word in chunks         */
+
+HsInt64
+rts_getInt64 (HaskellObj p)
+{
+    HsInt32* tmp;
+    // See comment above:
+    // ASSERT(p->header.info == I64zh_con_info ||
+    //        p->header.info == I64zh_static_info);
+    tmp = (HsInt32*)&(UNTAG_CLOSURE(p)->payload[0]);
+
+    HsInt64 i  = (HsInt64)((HsInt64)(tmp[0]) << 32) | (HsInt64)tmp[1];
+    return i;
+}
+
+#else
+
 HsInt64
 rts_getInt64 (HaskellObj p)
 {
@@ -274,6 +351,10 @@ rts_getInt64 (HaskellObj p)
     tmp = (HsInt64*)&(UNTAG_CLOSURE(p)->payload[0]);
     return *tmp;
 }
+
+#endif /* sparc_HOST_ARCH */
+
+
 HsWord
 rts_getWord (HaskellObj p)
 {
@@ -311,6 +392,26 @@ rts_getWord32 (HaskellObj p)
 }
 
 
+#ifdef sparc_HOST_ARCH
+/* The closures returned by allocateLocal are only guaranteed to be 32 bit
+   aligned, because that's the size of pointers. SPARC v9 can't do
+   misaligned loads/stores, so we have to write the 64bit word in chunks         */
+
+HsWord64
+rts_getWord64 (HaskellObj p)
+{
+    HsInt32* tmp;
+    // See comment above:
+    // ASSERT(p->header.info == I64zh_con_info ||
+    //        p->header.info == I64zh_static_info);
+    tmp = (HsInt32*)&(UNTAG_CLOSURE(p)->payload[0]);
+
+    HsInt64 i  = (HsWord64)((HsWord64)(tmp[0]) << 32) | (HsWord64)tmp[1];
+    return i;
+}
+
+#else
+
 HsWord64
 rts_getWord64 (HaskellObj p)
 {
@@ -322,6 +423,9 @@ rts_getWord64 (HaskellObj p)
     return *tmp;
 }
 
+#endif
+
+
 HsFloat
 rts_getFloat (HaskellObj p)
 {
@@ -587,18 +691,20 @@ rts_unlock (Capability *cap)
     task = cap->running_task;
     ASSERT_FULL_CAPABILITY_INVARIANTS(cap,task);
 
-    // slightly delicate ordering of operations below, pay attention!
-
-    // We are no longer a bound task/thread.  This is important,
-    // because the GC can run when we release the Capability below,
-    // and we don't want it to treat this as a live TSO pointer.
-    task->tso = NULL;
-
     // Now release the Capability.  With the capability released, GC
     // may happen.  NB. does not try to put the current Task on the
     // worker queue.
-    releaseCapability(cap);
+    // NB. keep cap->lock held while we call boundTaskExiting().  This
+    // is necessary during shutdown, where we want the invariant that
+    // after shutdownCapability(), all the Tasks associated with the
+    // Capability have completed their shutdown too.  Otherwise we
+    // could have boundTaskExiting()/workerTaskStop() running at some
+    // random point in the future, which causes problems for
+    // freeTaskManager().
+    ACQUIRE_LOCK(&cap->lock);
+    releaseCapability_(cap,rtsFalse);
 
     // Finally, we can release the Task to the free list.
     boundTaskExiting(task);
+    RELEASE_LOCK(&cap->lock);
 }