[project @ 2001-07-22 03:28:25 by chak]
[ghc-hetmet.git] / ghc / rts / Storage.h
index e32e9ad..6bd9be2 100644 (file)
@@ -1,5 +1,5 @@
 /* -----------------------------------------------------------------------------
- * $Id: Storage.h,v 1.24 2001/01/26 14:36:40 simonpj Exp $
+ * $Id: Storage.h,v 1.32 2001/05/03 16:33:27 simonmar Exp $
  *
  * (c) The GHC Team, 1998-1999
  *
@@ -81,11 +81,6 @@ extern void PleaseStopAllocating(void);
 extern void   GarbageCollect(void (*get_roots)(void),rtsBool force_major_gc);
 extern StgClosure *MarkRoot(StgClosure *p);
 
-/* Temporary measure to ensure we retain all the dynamically-loaded CAFs */
-#ifdef GHCI
-extern void markCafs( void );
-#endif
-
 /* -----------------------------------------------------------------------------
    Generational garbage collection support
 
@@ -103,6 +98,13 @@ extern void markCafs( void );
 
    -------------------------------------------------------------------------- */
 
+/*
+ * Storage manager mutex
+ */
+#ifdef SMP
+extern pthread_mutex_t sm_mutex;
+#endif
+
 /* ToDo: shouldn't recordMutable and recordOldToNewPtrs acquire some
  * kind of lock in the SMP case?
  */
@@ -162,11 +164,17 @@ recordOldToNewPtrs(StgMutClosure *p)
 
 /* In the DEBUG case, we also zero out the slop of the old closure,
  * so that the sanity checker can tell where the next closure is.
+ *
+ * Two important invariants: we should never try to update a closure
+ * to point to itself, and the closure being updated should not
+ * already have been updated (the mutable list will get messed up
+ * otherwise).
  */
 #define updateWithIndirection(info, p1, p2)                            \
   {                                                                    \
     bdescr *bd;                                                                \
                                                                        \
+    ASSERT( p1 != p2 && !closure_IND(p1) );                            \
     bd = Bdescr((P_)p1);                                               \
     if (bd->gen->no == 0) {                                            \
       ((StgInd *)p1)->indirectee = p2;                                 \
@@ -174,12 +182,14 @@ recordOldToNewPtrs(StgMutClosure *p)
       TICK_UPD_NEW_IND();                                              \
     } else {                                                           \
       if (info != &stg_BLACKHOLE_BQ_info) {                            \
-       {                                                               \
+       {                                                               \
           StgInfoTable *inf = get_itbl(p1);                            \
          nat np = inf->layout.payload.ptrs,                            \
              nw = inf->layout.payload.nptrs, i;                        \
-         for (i = np; i < np + nw; i++) {                              \
-            ((StgClosure *)p1)->payload[i] = 0;                        \
+          if (inf->type != THUNK_SELECTOR) {                           \
+             for (i = np; i < np + nw; i++) {                          \
+               ((StgClosure *)p1)->payload[i] = 0;                     \
+             }                                                         \
           }                                                            \
         }                                                              \
         ACQUIRE_LOCK(&sm_mutex);                                       \
@@ -198,6 +208,7 @@ recordOldToNewPtrs(StgMutClosure *p)
  */
 #define updateWithStaticIndirection(info, p1, p2)                      \
   {                                                                    \
+    ASSERT( p1 != p2 && !closure_IND(p1) );                            \
     ASSERT( ((StgMutClosure*)p1)->mut_link == NULL );                  \
                                                                        \
     ACQUIRE_LOCK(&sm_mutex);                                           \
@@ -216,6 +227,7 @@ updateWithPermIndirection(const StgInfoTable *info, StgClosure *p1, StgClosure *
 {
   bdescr *bd;
 
+  ASSERT( p1 != p2 && !closure_IND(p1) );
   bd = Bdescr((P_)p1);
   if (bd->gen->no == 0) {
     ((StgInd *)p1)->indirectee = p2;
@@ -239,25 +251,10 @@ updateWithPermIndirection(const StgInfoTable *info, StgClosure *p1, StgClosure *
    The CAF table - used to let us revert CAFs
    -------------------------------------------------------------------------- */
 
-#if defined(INTERPRETER)
-typedef struct StgCAFTabEntry_ {
-    StgClosure*   closure;
-    StgInfoTable* origItbl;
-} StgCAFTabEntry;
-
-extern void addToECafTable ( StgClosure* closure, StgInfoTable* origItbl );
-extern void clearECafTable ( void );
-
-extern StgCAF*         ecafList;
-extern StgCAFTabEntry* ecafTable;
-extern StgInt          usedECafTable;
-extern StgInt          sizeECafTable;
-#endif
-
 #if defined(DEBUG)
 void printMutOnceList(generation *gen);
 void printMutableList(generation *gen);
-#endif DEBUG
+#endif /* DEBUG */
 
 /* --------------------------------------------------------------------------
                       Address space layout macros
@@ -342,7 +339,6 @@ void printMutableList(generation *gen);
 extern void* TEXT_SECTION_END_MARKER_DECL;
 extern void* DATA_SECTION_END_MARKER_DECL;
 
-#if defined(INTERPRETER) || defined(GHCI)
 /* Take into account code sections in dynamically loaded object files. */
 #define IS_CODE_PTR(p) (  ((P_)(p) < (P_)&TEXT_SECTION_END_MARKER) \
                        || is_dynamically_loaded_code_or_rodata_ptr((char *)p) )
@@ -351,11 +347,6 @@ extern void* DATA_SECTION_END_MARKER_DECL;
                        || is_dynamically_loaded_rwdata_ptr((char *)p) )
 #define IS_USER_PTR(p) ( ((P_)(p) >= (P_)&DATA_SECTION_END_MARKER) \
                        && is_not_dynamically_loaded_ptr((char *)p) )
-#else
-#define IS_CODE_PTR(p) ((P_)(p) < (P_)&TEXT_SECTION_END_MARKER)
-#define IS_DATA_PTR(p) ((P_)(p) >= (P_)&TEXT_SECTION_END_MARKER && (P_)(p) < (P_)&DATA_SECTION_END_MARKER)
-#define IS_USER_PTR(p) ((P_)(p) >= (P_)&DATA_SECTION_END_MARKER)
-#endif
 
 /* The HEAP_ALLOCED test below is called FOR EVERY SINGLE CLOSURE
  * during GC.  It needs to be FAST.
@@ -456,7 +447,7 @@ extern int is_heap_alloced(const void* x);
    LOOKS_LIKE_STATIC() 
        - distinguishes between static and heap allocated data.
  */
-#if defined(ENABLE_WIN32_DLL_SUPPORT) && !defined(INTERPRETER)
+#if defined(ENABLE_WIN32_DLL_SUPPORT)
             /* definitely do not enable for mingw DietHEP */
 #define LOOKS_LIKE_STATIC(r) (!(HEAP_ALLOCED(r)))
 
@@ -486,20 +477,9 @@ extern int is_heap_alloced(const void* x);
    infotables for constructors on the (writable) C heap.
    -------------------------------------------------------------------------- */
 
-#ifdef INTERPRETER
-#  ifdef USE_MINIINTERPRETER
-     /* yoiks: one of the dreaded pointer equality tests */
-#    define IS_HUGS_CONSTR_INFO(info) \
-            (((StgInfoTable *)(info))->entry == (StgFunPtr)&Hugs_CONSTR_entry)
-#  else
-#    define IS_HUGS_CONSTR_INFO(info) 0 /* ToDo: more than mildly bogus */
-#  endif
-#elif GHCI
-   /* not accurate by any means, but stops the assertions failing... */
-#  define IS_HUGS_CONSTR_INFO(info)  IS_USER_PTR(info)
-#else
-#  define IS_HUGS_CONSTR_INFO(info) 0 /* ToDo: more than mildly bogus */
-#endif
+/* not accurate by any means, but stops the assertions failing... */
+/* TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO */
+#define IS_HUGS_CONSTR_INFO(info)  IS_USER_PTR(info)
 
 /* LOOKS_LIKE_GHC_INFO is called moderately often during GC, but
  * Certainly not as often as HEAP_ALLOCED.
@@ -534,9 +514,6 @@ static __inline__ StgOffset THUNK_SELECTOR_sizeW ( void )
 static __inline__ StgOffset BLACKHOLE_sizeW ( void )                    
 { return sizeofW(StgHeader) + MIN_UPD_SIZE; }
 
-static __inline__ StgOffset CAF_sizeW ( void )                    
-{ return sizeofW(StgCAF); }
-
 /* --------------------------------------------------------------------------
  * Sizes of closures
  * ------------------------------------------------------------------------*/
@@ -558,5 +535,5 @@ static __inline__ StgOffset mut_arr_ptrs_sizeW( StgMutArrPtrs* x )
 static __inline__ StgWord tso_sizeW ( StgTSO *tso )
 { return TSO_STRUCT_SIZEW + tso->stack_size; }
 
-#endif STORAGE_H
+#endif /* STORAGE_H */