Remove some GC abstraction breaking in the debugger

I don't think we'll be able to provide GC_base in every possible
GC - whippet doesn't expose it, for example, and really I'd like to
not require interior pointer work anyway. Using boehm's GC_base
outside of boehmGarbageCollection.cc is right out anyway.

Author: Bike

include/clasp/gctools/memoryManagement.h

@@ -22,6 +22,8 @@
 // Define compile-time flags that effect structure sizes
 //
 #include <atomic>
+#include <set>
+#include <utility> // pair
 #include <clasp/gctools/configure_memory.h>
 #include <clasp/gctools/hardErrors.h>
 
@@ -1296,7 +1298,7 @@ typedef void (*PointerFix)(uintptr_t* clientAddress, uintptr_t client, uintptr_t
 
 void mapAllObjects(void (*)(Tagged, void*), void*);
 std::set<Tagged> setOfAllObjects();
-std::set<Tagged*> memtest(std::set<core::T_sp>&);
+std::set<std::pair<Tagged, Tagged*>> memtest(std::set<core::T_sp>&);
 size_t objectSize(BaseHeader_s* header);
 
 bool is_memory_readable(const void* address, size_t bytes = 8);

src/core/debugger.cc

@@ -490,20 +490,7 @@ std::string dbg_safe_repr_depth(int depth, void* raw) {
     ss << "#<EXCEEDED-DEPTH>";
     return ss.str();
   }
-  gctools::Header_s* header = (gctools::Header_s*)GC_base(raw);
-  if (header==NULL) {
-    ss << "#<NON-GC-POINTER=" << (void*)raw<<">";
-    return ss.str();
-  }
-  gctools::clasp_ptr_t client = NULL;
-  if (header->_badge_stamp_wtag_mtag.stampP()) {
-    client = (gctools::clasp_ptr_t)((uintptr_t)gctools::HeaderPtrToGeneralPtr<core::General_O>((gctools::clasp_ptr_t)header) | GENERAL_TAG);
-  } else if (header->_badge_stamp_wtag_mtag.consObjectP()) {
-    client = (gctools::clasp_ptr_t)((uintptr_t)gctools::HeaderPtrToConsPtr(header) | CONS_TAG);
-  } else if (header->_badge_stamp_wtag_mtag.weakObjectP()) {
-    client = (gctools::clasp_ptr_t)((uintptr_t)gctools::HeaderPtrToWeakPtr(header) | GENERAL_TAG);
-  }
-  core::T_sp obj((gc::Tagged)client);
+  core::T_sp obj((gc::Tagged)raw);
   if (obj.generalp()) {
     if (gc::IsA<core::Symbol_sp>(obj)) {
       core::Symbol_sp sym = gc::As_unsafe<core::Symbol_sp>(obj);

src/gctools/gcFunctions.cc

@@ -400,13 +400,14 @@ bool memory_test() {
     result = false;
     core::lisp_write(fmt::format("{} corrupt objects in memory test\n", corrupt.size()));
     size_t idx = 0;
-    for (const auto& field : corrupt) {
-      auto cur = *field;
-      void* base = GC_base(field);
+    for (const auto& cur : corrupt) {
+      Tagged base = cur.first;
+      Tagged* field = cur.second;
+      Tagged corruptObj = *field;
       if (base) {
-        core::lisp_write(fmt::format("#{} -> {} @{} base: {} == {}\n", idx, (void*)cur, (void*)field, (void*)base, (std::string)dbg_safe_repr(base)));
+        core::lisp_write(fmt::format("#{} -> {} @{} base: {} == {}\n", idx, (void*)corruptObj, (void*)field, (void*)base, dbg_safe_repr((void*)base)));
       } else {
-        core::lisp_write(fmt::format("#{} -> {} @{} base: NULL\n", idx, (void*)cur, (void*)field ));
+        core::lisp_write(fmt::format("#{} -> {} @{} base: [root]", idx, (void*)corruptObj, (void*)field ));
       }
       idx++;
     }

src/gctools/memoryManagement.cc

@@ -28,6 +28,8 @@ THE SOFTWARE.
 
 #define DEBUG_LEVEL_NONE
 
+#include <stack>
+#include <utility> // pair
 #include <unistd.h>
 #include <fcntl.h>
 #include <clasp/core/foundation.h>
@@ -881,9 +883,9 @@ void walkRoots(RootWalkCallback&& callback) {
 // #define HEADER_PTR_TO_WEAK_PTR(_header_) headerPointerToGeneralPointer((gctools::Header_s*)_header_)
 
 #define ADDR_T uintptr_t
-#define EXTRA_ARGUMENTS , std::stack<Tagged*>& markStack
+#define EXTRA_ARGUMENTS , Tagged containingObject, std::stack<std::pair<Tagged, Tagged*>>& markStack
 
-#define POINTER_FIX(_ptr_) markStack.push(reinterpret_cast<Tagged*>(_ptr_))
+#define POINTER_FIX(_ptr_) markStack.emplace(containingObject, reinterpret_cast<Tagged*>(_ptr_))
 
 #define OBJECT_SCAN mw_obj_scan
 #define OBJECT_SKIP mw_obj_skip
@@ -910,12 +912,14 @@ void walkRoots(RootWalkCallback&& callback) {
 template <class Callback>
 static void mapAllObjectsInternal(std::set<Tagged>& markSet,
                                   Callback callback) {
-  std::stack<Tagged*> markStack;
+  std::stack<std::pair<Tagged, Tagged*>> markStack;
 
-  walkRoots([&](Tagged* rootf) { markStack.push(rootf); }); // process all roots
+  // process all roots
+  walkRoots([&](Tagged* rootf) { markStack.emplace(0, rootf); });
 
   while (!markStack.empty()) {
-    Tagged* field = markStack.top(); markStack.pop(); // pop a field
+    // pop a field. we don't need the containing object.
+    Tagged* field = markStack.top().second; markStack.pop();
     Tagged tagged = *field;
 
     switch(ptag(tagged)) {
@@ -927,8 +931,8 @@ static void mapAllObjectsInternal(std::set<Tagged>& markSet,
         // the mw_foo_scan functions push all fields of the object
         // onto the markStack to keep the loop going.
         if (header->_badge_stamp_wtag_mtag.weakObjectP())
-          mw_weak_scan(client, markStack);
-        else mw_obj_scan(client, markStack);
+          mw_weak_scan(client, tagged, markStack);
+        else mw_obj_scan(client, tagged, markStack);
         // now's the time to callback. Could also go before the scan
         callback(tagged);
       }
@@ -937,7 +941,7 @@ static void mapAllObjectsInternal(std::set<Tagged>& markSet,
       if (!markSet.contains(tagged)) {
         markSet.insert(tagged);
         uintptr_t client = untag_object(tagged);
-        mw_cons_scan(client, markStack);
+        mw_cons_scan(client, tagged, markStack);
         callback(tagged);
       }
     } break;
@@ -961,19 +965,25 @@ std::set<Tagged> setOfAllObjects() {
 // Check that all fields in all objects point to valid objects.
 // Also check for functions that can't be resolved with dlsym, since that's
 // important for snapshot save.
-// Return the set of tagged pointers located in fields that are not valid.
-std::set<Tagged*> memtest(std::set<core::T_sp>& dladdrFailed) {
-  std::stack<Tagged*> markStack;
+// Return the set of corrupt fields, represented as pairs of a non-corrupt
+// object and the address of a field within that object; the object contained
+// in that field is corrupt.
+// If a corrupt object is accessible in multiple fields, only one field containing
+// it is returned.
+std::set<std::pair<Tagged, Tagged*>> memtest(std::set<core::T_sp>& dladdrFailed) {
+  std::stack<std::pair<Tagged, Tagged*>> markStack;
   std::set<Tagged> markSet;
-  std::set<Tagged*> corrupt;
+  std::set<std::pair<Tagged, Tagged*>> corrupt;
 
   std::set<void*> uniqueEntryPoints;
 
-  walkRoots([&](Tagged* rootAddr) { markStack.push(rootAddr); });
+  walkRoots([&](Tagged* rootAddr) { markStack.emplace(0, rootAddr); });
 
   while (!markStack.empty()) {
-    Tagged* field = markStack.top(); markStack.pop();
-    gctools::Tagged tagged = *field;
+    auto p = markStack.top(); markStack.pop();
+    Tagged containingObject = p.first;
+    Tagged* field = p.second;
+    Tagged tagged = *field;
 
     switch (tagged & ptag_mask) {
     case general_tag: {
@@ -983,9 +993,9 @@ std::set<Tagged*> memtest(std::set<core::T_sp>& dladdrFailed) {
         Header_s* header = (Header_s*)GeneralPtrToHeaderPtr((void*)client);
         if (header->isValidGeneralObject()) {
           if (header->_badge_stamp_wtag_mtag.weakObjectP())
-            mw_weak_scan(client, markStack);
+            mw_weak_scan(client, tagged, markStack);
           else {
-            mw_obj_scan(client, markStack);
+            mw_obj_scan(client, tagged, markStack);
             // If this is a function, check its dladdrability.
             core::T_sp tobj(tagged);
             if (tobj.isA<core::SimpleFun_O>()) {
@@ -1005,7 +1015,7 @@ std::set<Tagged*> memtest(std::set<core::T_sp>& dladdrFailed) {
             }*/
           }
         } else {
-          corrupt.insert(field);
+          corrupt.emplace(containingObject, field);
         }
       }
     } break;
@@ -1015,9 +1025,9 @@ std::set<Tagged*> memtest(std::set<core::T_sp>& dladdrFailed) {
         uintptr_t client = tagged & ptr_mask;
         ConsHeader_s* header = (ConsHeader_s*)ConsPtrToHeaderPtr((void*)client);
         if (header->isValidConsObject())
-          mw_cons_scan(client, markStack);
+          mw_cons_scan(client, tagged, markStack);
         else {
-          corrupt.insert(field);
+          corrupt.emplace(containingObject, field);
         }
       }
     } break;
@@ -1040,7 +1050,7 @@ std::set<Tagged*> memtest(std::set<core::T_sp>& dladdrFailed) {
     case UNBOUND_TAG: // FIXME: put const definition in pointer_tagging.h somewhere?
         break; // immediate, nothing to do
     default: // unknown tag - object is corrupt
-        corrupt.insert(field); break;
+        corrupt.emplace(containingObject, field); break;
     }
   }
   return corrupt;