Fix scanning of weak key hash tables

We have been finding intermittent memory-test failures after
registering finalizers. The problem appears to be that the Buckets
for the values, which should be strong references, were instead
allocated boehm-atomically and therefore not scanned. This led to
live objects being collected, which causes lots of weird problems.
This only happened after registering finalizers because we use a
weak key hash table for finalizers internally.

The weak key hash table code is pretty brittle and I'm replacing it
in another branch.

Author: Bike

include/clasp/gctools/gcalloc.h

@@ -33,6 +33,7 @@ THE SOFTWARE.
 // #define DEBUG_CONS_ALLOC 1
 
 #include <limits>
+#include <type_traits> // is_same_v
 #include <clasp/gctools/interrupt.h>
 #include <clasp/gctools/threadlocal.fwd.h>
 #include <clasp/gctools/snapshotSaveLoad.fwd.h>
@@ -239,8 +240,7 @@ template <class Stage, class Cons, class Register> struct ConsAllocator {
 #ifdef USE_PRECISE_GC
   static smart_ptr<Cons> snapshot_save_load_allocate(Header_s::BadgeStampWtagMtag& the_header, core::T_sp car, core::T_sp cdr) {
 #if defined(USE_BOEHM)
-    Header_s* header = reinterpret_cast<Header_s*>(ALIGNED_GC_MALLOC_KIND(
-        STAMP_UNSHIFT_WTAG(STAMPWTAG_CONS), SizeofConsHeader() + sizeof(Cons), global_cons_kind, &global_cons_kind)); // wasMTAG
+    Header_s* header = reinterpret_cast<Header_s*>(ALIGNED_GC_MALLOC_KIND(SizeofConsHeader() + sizeof(Cons), global_cons_kind)); // wasMTAG
     header->_badge_stamp_wtag_mtag._header_badge.store(the_header._header_badge.load());
     header->_badge_stamp_wtag_mtag._value = the_header._value;
 #elif defined(USE_MMTK)
@@ -892,6 +892,7 @@ template <class VT, class StrongWeakLinkType> class GCBucketAllocator<Buckets<VT
   typedef const value_type& const_reference;
   typedef std::size_t size_type;
   typedef std::ptrdiff_t difference_type;
+  static constexpr bool weakp = std::is_same_v<StrongWeakLinkType, WeakLinks>;
 
   /* constructors and destructor
    * - nothing to do because the allocator has no state
@@ -906,7 +907,7 @@ template <class VT, class StrongWeakLinkType> class GCBucketAllocator<Buckets<VT
   // allocate but don't initialize num elements of type value_type
   static gctools::tagged_pointer<container_type> allocate(Header_s::BadgeStampWtagMtag the_header, size_type num, const void* = 0) {
     size_t size = sizeof_container_with_header<container_type>(num);
-    Header_s* base = do_weak_allocation(the_header, size);
+    Header_s* base = do_weak_allocation<weakp>(the_header, size);
     container_pointer myAddress = (container_pointer)HeaderPtrToWeakPtr(base);
     if (!myAddress)
       throw_hard_error("Out of memory in allocate");
@@ -919,7 +920,7 @@ template <class VT, class StrongWeakLinkType> class GCBucketAllocator<Buckets<VT
 
   static gctools::tagged_pointer<container_type> snapshot_save_load_allocate(snapshotSaveLoad::snapshot_save_load_init_s* init) {
     size_t size = (init->_clientEnd - init->_clientStart) + SizeofWeakHeader();
-    Header_s* base = do_weak_allocation(init->_headStart->_badge_stamp_wtag_mtag, size);
+    Header_s* base = do_weak_allocation<weakp>(init->_headStart->_badge_stamp_wtag_mtag, size);
 #ifdef DEBUG_GUARD
     // Copy the source from the image save/load memory.
     base->_source = init->_headStart->_source;
@@ -971,7 +972,7 @@ template <class VT, class StrongWeakLinkType> class GCMappingAllocator<Mapping<V
   // allocate but don't initialize num elements of type value_type
   static gctools::tagged_pointer<container_type> allocate(Header_s::BadgeStampWtagMtag the_header, const VT& val) {
     size_t size = sizeof_with_header<container_type>();
-    Header_s* base = do_weak_allocation(the_header, size);
+    Header_s* base = do_weak_allocation<std::is_same_v<StrongWeakLinkType, WeakLinks>>(the_header, size);
     container_pointer myAddress = (container_pointer)HeaderPtrToWeakPtr(base);
     if (!myAddress)
       throw_hard_error("Out of memory in allocate");
@@ -999,7 +1000,7 @@ template <class VT> class GCWeakPointerAllocator {
 #ifdef DEBUG_GCWEAK
     printf("%s:%d Allocating WeakPointer with GC_MALLOC_ATOMIC\n", __FILE__, __LINE__);
 #endif
-    Header_s* base = do_weak_allocation(the_header, size);
+    Header_s* base = do_weak_allocation<true>(the_header, size);
     VT* myAddress = (VT*)HeaderPtrToWeakPtr(base);
     if (!myAddress)
       throw_hard_error("Out of memory in allocate");

include/clasp/gctools/gcalloc_boehm.h

@@ -4,12 +4,12 @@
 #define ALIGNED_GC_MALLOC(sz) MAYBE_MONITOR_ALLOC(GC_MALLOC(sz), sz)
 #define ALIGNED_GC_MALLOC_ATOMIC(sz) MAYBE_MONITOR_ALLOC(GC_MALLOC_ATOMIC(sz), sz)
 #define ALIGNED_GC_MALLOC_UNCOLLECTABLE(sz) MAYBE_MONITOR_ALLOC(GC_MALLOC_UNCOLLECTABLE(sz), sz)
-#define ALIGNED_GC_MALLOC_KIND(stmp, sz, knd, kndaddr) MAYBE_MONITOR_ALLOC(GC_malloc_kind_global(sz, knd), sz)
+#define ALIGNED_GC_MALLOC_KIND(sz, knd) MAYBE_MONITOR_ALLOC(GC_malloc_kind_global(sz, knd), sz)
 #define ALIGNED_GC_MALLOC_STRONG_WEAK_KIND(sz, knd) MAYBE_MONITOR_ALLOC(GC_malloc_kind_global(sz, knd), sz)
 #define ALIGNED_GC_MALLOC_ATOMIC_KIND(stmp, sz, knd, kndaddr)                                                                      \
   MAYBE_MONITOR_ALLOC(                                                                                                             \
       (knd == GC_I_PTRFREE) ? GC_malloc_kind_global(sz, knd) : malloc_kind_error(GC_I_PTRFREE, knd, sz, stmp, kndaddr), sz)
-#define ALIGNED_GC_MALLOC_UNCOLLECTABLE_KIND(stmp, sz, knd, kndaddr)                                                               \
+#define ALIGNED_GC_MALLOC_UNCOLLECTABLE_KIND(sz, knd)                                                                              \
   MAYBE_MONITOR_ALLOC(GC_generic_malloc_uncollectable(sz, knd), sz)
 #else
 #error "There is more work to do to support more than 3 tag bits"
@@ -24,7 +24,7 @@ template <typename Stage, typename Cons, typename... ARGS> inline Cons* do_cons_
   RAIIAllocationStage<Stage> stage(my_thread_low_level);
 #ifdef USE_PRECISE_GC
   ConsHeader_s* header = reinterpret_cast<ConsHeader_s*>(
-      ALIGNED_GC_MALLOC_KIND(STAMP_UNSHIFT_WTAG(STAMPWTAG_CONS), size, global_cons_kind, &global_cons_kind)); // wasMTAG
+      ALIGNED_GC_MALLOC_KIND(size, global_cons_kind)); // wasMTAG
 #ifdef DEBUG_BOEHMPRECISE_ALLOC
   printf("%s:%d:%s cons = %p\n", __FILE__, __LINE__, __FUNCTION__, cons);
 #endif
@@ -62,14 +62,14 @@ inline Header_s* do_atomic_allocation(const Header_s::StampWtagMtag& the_header,
   return header;
 };
 
+template <bool weakp>
 inline Header_s* do_weak_allocation(const Header_s::StampWtagMtag& the_header, size_t size) {
   size_t true_size = size;
-#ifdef USE_PRECISE_GC
-  Header_s* header = reinterpret_cast<Header_s*>(ALIGNED_GC_MALLOC_ATOMIC(true_size));
-//   Header_s* header = reinterpret_cast<Header_s*>(ALIGNED_GC_MALLOC_STRONG_WEAK_KIND_ATOMIC(true_size,global_strong_weak_kind));
-#else
-  Header_s* header = reinterpret_cast<Header_s*>(ALIGNED_GC_MALLOC_ATOMIC(true_size));
-#endif
+  Header_s* header;
+  if constexpr(weakp)
+    header = reinterpret_cast<Header_s*>(ALIGNED_GC_MALLOC_ATOMIC(true_size));
+  else
+    header = reinterpret_cast<Header_s*>(ALIGNED_GC_MALLOC_KIND(true_size, GC_I_NORMAL));
   my_thread_low_level->_Allocations.registerWeakAllocation(the_header._value, true_size);
 #ifdef DEBUG_GUARD
   memset(header, 0x00, true_size);
@@ -92,7 +92,7 @@ inline Header_s* do_general_allocation(const Header_s::StampWtagMtag& the_header
   auto stamp = the_header.stamp();
   auto& kind = global_stamp_layout[stamp].boehm._kind;
   GCTOOLS_ASSERT(kind != KIND_UNDEFINED);
-  Header_s* header = reinterpret_cast<Header_s*>(ALIGNED_GC_MALLOC_KIND(stamp, true_size, kind, &kind));
+  Header_s* header = reinterpret_cast<Header_s*>(ALIGNED_GC_MALLOC_KIND(true_size, kind));
 #ifdef DEBUG_BOEHMPRECISE_ALLOC
   printf("%s:%d:%s header = %p\n", __FILE__, __LINE__, __FUNCTION__, header);
 #endif
@@ -117,8 +117,7 @@ inline Header_s* do_uncollectable_allocation(const Header_s::StampWtagMtag& the_
 #endif
 #ifdef USE_PRECISE_GC
   Header_s* header = reinterpret_cast<Header_s*>(
-      ALIGNED_GC_MALLOC_UNCOLLECTABLE_KIND(the_header.stamp(), true_size, global_stamp_layout[the_header.stamp()].boehm._kind,
-                                           &global_stamp_layout[the_header.stamp()].boehm._kind));
+      ALIGNED_GC_MALLOC_UNCOLLECTABLE_KIND(true_size, global_stamp_layout[the_header.stamp()].boehm._kind));
 #ifdef DEBUG_BOEHMPRECISE_ALLOC
   printf("%s:%d:%s header = %p\n", __FILE__, __LINE__, __FUNCTION__, header);
 #endif