Cleanup after the OPTIONS parsing was moved.
[ghc-hetmet.git] / ghc / rts / Updates.h
index 06f67e9..62473b3 100644 (file)
@@ -186,32 +186,29 @@ extern void awakenBlockedQueue(StgBlockingQueueElement *q, StgClosure *node);
  * already have been updated (the mutable list will get messed up
  * otherwise).
  *
- * NB. We do *not* do this in SMP mode, because when we have the
+ * NB. We do *not* do this in THREADED_RTS mode, because when we have the
  * possibility of multiple threads entering the same closure, zeroing
  * the slop in one of the threads would have a disastrous effect on
  * the other (seen in the wild!).
  */
-#if !defined(DEBUG) || defined(SMP)
-
-#define DEBUG_FILL_SLOP(p) /* nothing */
-
-#else  /* DEBUG */
-
 #ifdef CMINUSMINUS
 
-#define DEBUG_FILL_SLOP(p)                                             \
+#define FILL_SLOP(p)                                                   \
   W_ inf;                                                              \
   W_ sz;                                                               \
   W_ i;                                                                        \
   inf = %GET_STD_INFO(p);                                              \
-  if (%INFO_TYPE(inf) == HALF_W_(THUNK_SELECTOR)) {                    \
-       StgThunk_payload(p,0) = 0;                                      \
-  } else {                                                             \
-    if (%INFO_TYPE(inf) != HALF_W_(BLACKHOLE)) {                       \
+  if (%INFO_TYPE(inf) != HALF_W_(THUNK_SELECTOR)                       \
+       && %INFO_TYPE(inf) != HALF_W_(BLACKHOLE)                        \
+       && %INFO_TYPE(inf) != HALF_W_(CAF_BLACKHOLE)) {                 \
       if (%INFO_TYPE(inf) == HALF_W_(AP_STACK)) {                      \
-          sz = StgAP_STACK_size(p) + BYTES_TO_WDS(SIZEOF_StgAP_STACK_NoHdr); \
+          sz = StgAP_STACK_size(p) + BYTES_TO_WDS(SIZEOF_StgAP_STACK_NoThunkHdr); \
       } else {                                                         \
-          sz = TO_W_(%INFO_PTRS(inf)) + TO_W_(%INFO_NPTRS(inf));       \
+          if (%INFO_TYPE(inf) == HALF_W_(AP)) {                                \
+             sz = TO_W_(StgAP_n_args(p)) +  BYTES_TO_WDS(SIZEOF_StgAP_NoThunkHdr);     \
+          } else {                                                     \
+              sz = TO_W_(%INFO_PTRS(inf)) + TO_W_(%INFO_NPTRS(inf));   \
+         }                                                             \
       }                                                                        \
       i = 0;                                                           \
       for:                                                             \
@@ -220,27 +217,27 @@ extern void awakenBlockedQueue(StgBlockingQueueElement *q, StgClosure *node);
           i = i + 1;                                                   \
           goto for;                                                    \
         }                                                              \
-  } }
+  }
 
 #else /* !CMINUSMINUS */
 
 INLINE_HEADER void
-DEBUG_FILL_SLOP(StgClosure *p)
+FILL_SLOP(StgClosure *p)
 {                                              
     StgInfoTable *inf = get_itbl(p);           
     nat i, sz;
 
     switch (inf->type) {
     case BLACKHOLE:
+    case CAF_BLACKHOLE:
+    case THUNK_SELECTOR:
        return;
+    case AP:
+       sz = ((StgAP *)p)->n_args + sizeofW(StgAP) - sizeofW(StgThunkHeader);
+       break;
     case AP_STACK:
-       sz = ((StgAP_STACK *)p)->size + sizeofW(StgAP_STACK) - sizeofW(StgHeader);
+       sz = ((StgAP_STACK *)p)->size + sizeofW(StgAP_STACK) - sizeofW(StgThunkHeader);
        break;
-    case THUNK_SELECTOR:
-#ifdef SMP
-       ((StgSelector *)p)->selectee = 0;
-#endif
-       return;
     default:
        sz = inf->layout.payload.ptrs + inf->layout.payload.nptrs;
         break;
@@ -251,7 +248,12 @@ DEBUG_FILL_SLOP(StgClosure *p)
 }
 
 #endif /* CMINUSMINUS */
-#endif /* DEBUG */
+
+#if !defined(DEBUG) || defined(THREADED_RTS)
+#define DEBUG_FILL_SLOP(p) /* do nothing */
+#else
+#define DEBUG_FILL_SLOP(p) FILL_SLOP(p)
+#endif
 
 /* We have two versions of this macro (sadly), one for use in C-- code,
  * and the other for C.
@@ -268,26 +270,24 @@ DEBUG_FILL_SLOP(StgClosure *p)
 #define updateWithIndirection(ind_info, p1, p2, and_then)      \
     W_ bd;                                                     \
                                                                \
-/*    ASSERT( p1 != p2 && !closure_IND(p1) );                  \
- */ LDV_RECORD_DEAD_FILL_SLOP_DYNAMIC(p1);                     \
-/*  foreign "C" cas(p1 "ptr", 0, stg_WHITEHOLE_info);          \
- */ bd = Bdescr(p1);                                           \
-    if (bdescr_gen_no(bd) == 0 :: CInt) {                      \
-      StgInd_indirectee(p1) = p2;                              \
-      SET_INFO(p1, ind_info);                                  \
-      LDV_RECORD_CREATE(p1);                                   \
-      TICK_UPD_NEW_IND();                                      \
-      and_then;                                                        \
-    } else {                                                   \
-      DEBUG_FILL_SLOP(p1);                                     \
-      foreign "C" recordMutableCap(p1 "ptr",                   \
-                                  MyCapability() "ptr",        \
+    DEBUG_FILL_SLOP(p1);                                       \
+    LDV_RECORD_DEAD_FILL_SLOP_DYNAMIC(p1);                     \
+    StgInd_indirectee(p1) = p2;                                        \
+    foreign "C" wb() [];                                       \
+    bd = Bdescr(p1);                                           \
+    if (bdescr_gen_no(bd) != 0 :: CInt) {                      \
+      foreign "C" recordMutableCap(p1 "ptr",                   \
+                                  MyCapability() "ptr",        \
                                   bdescr_gen_no(bd));          \
-      StgInd_indirectee(p1) = p2;                              \
       SET_INFO(p1, stg_IND_OLDGEN_info);                       \
       LDV_RECORD_CREATE(p1);                                   \
       TICK_UPD_OLD_IND();                                      \
       and_then;                                                        \
+    } else {                                                   \
+      SET_INFO(p1, ind_info);                                  \
+      LDV_RECORD_CREATE(p1);                                   \
+      TICK_UPD_NEW_IND();                                      \
+      and_then;                                                        \
   }
 #else
 #define updateWithIndirection(ind_info, p1, p2, and_then)              \
@@ -296,21 +296,21 @@ DEBUG_FILL_SLOP(StgClosure *p)
                                                                        \
     /* cas(p1, 0, &stg_WHITEHOLE_info); */                             \
     ASSERT( (P_)p1 != (P_)p2 && !closure_IND(p1) );                    \
+    DEBUG_FILL_SLOP(p1);                                               \
     LDV_RECORD_DEAD_FILL_SLOP_DYNAMIC(p1);                             \
+    ((StgInd *)p1)->indirectee = p2;                                   \
+    wb();                                                              \
     bd = Bdescr((P_)p1);                                               \
-    if (bd->gen_no == 0) {                                             \
-      ((StgInd *)p1)->indirectee = p2;                                 \
-      SET_INFO(p1, ind_info);                                          \
-      LDV_RECORD_CREATE(p1);                                           \
-      TICK_UPD_NEW_IND();                                              \
-      and_then;                                                                \
-    } else {                                                           \
-      DEBUG_FILL_SLOP(p1);                                             \
+    if (bd->gen_no != 0) {                                             \
       recordMutableGenLock(p1, &generations[bd->gen_no]);              \
-      ((StgInd *)p1)->indirectee = p2;                                 \
       SET_INFO(p1, &stg_IND_OLDGEN_info);                              \
       TICK_UPD_OLD_IND();                                              \
       and_then;                                                                \
+    } else {                                                           \
+      SET_INFO(p1, ind_info);                                          \
+      LDV_RECORD_CREATE(p1);                                           \
+      TICK_UPD_NEW_IND();                                              \
+      and_then;                                                                \
     }                                                                  \
   }
 #endif
@@ -335,25 +335,25 @@ updateWithPermIndirection(StgClosure *p1,
   LDV_RECORD_DEAD_FILL_SLOP_DYNAMIC(p1);
 
   bd = Bdescr((P_)p1);
-  if (bd->gen_no == 0) {
+  if (bd->gen_no != 0) {
+    recordMutableGenLock(p1, &generations[bd->gen_no]);
     ((StgInd *)p1)->indirectee = p2;
-    SET_INFO(p1, &stg_IND_PERM_info);
+    SET_INFO(p1, &stg_IND_OLDGEN_PERM_info);
     /*
      * @LDV profiling
      * We have just created a new closure.
      */
     LDV_RECORD_CREATE(p1);
-    TICK_UPD_NEW_PERM_IND(p1);
+    TICK_UPD_OLD_PERM_IND();
   } else {
-    recordMutableGenLock(p1, &generations[bd->gen_no]);
     ((StgInd *)p1)->indirectee = p2;
-    SET_INFO(p1, &stg_IND_OLDGEN_PERM_info);
+    SET_INFO(p1, &stg_IND_PERM_info);
     /*
      * @LDV profiling
      * We have just created a new closure.
      */
     LDV_RECORD_CREATE(p1);
-    TICK_UPD_OLD_PERM_IND();
+    TICK_UPD_NEW_PERM_IND(p1);
   }
 }
 #endif