Pull some small things off the bottom of #637

src/snmalloc/mem/corealloc.h

@@ -450,19 +450,25 @@ namespace snmalloc
      */
     SNMALLOC_FAST_PATH bool has_messages()
     {
-      auto domesticate = [local_state = backend_state_ptr()](
-                           freelist::QueuePtr p) SNMALLOC_FAST_PATH_LAMBDA {
-        if constexpr (Config::Options.QueueHeadsAreTame)
-        {
-          return freelist::HeadPtr::unsafe_from(p.unsafe_ptr());
-        }
-        else
-        {
+      auto local_state = backend_state_ptr();
+      auto domesticate_head =
+        [local_state](freelist::QueuePtr p) SNMALLOC_FAST_PATH_LAMBDA {
+          if constexpr (Config::Options.QueueHeadsAreTame)
+          {
+            UNUSED(local_state);
+            return freelist::HeadPtr::unsafe_from(p.unsafe_ptr());
+          }
+          else
+          {
+            return capptr_domesticate<Config>(local_state, p);
+          }
+        };
+      auto domesticate_queue =
+        [local_state](freelist::QueuePtr p) SNMALLOC_FAST_PATH_LAMBDA {
           return capptr_domesticate<Config>(local_state, p);
-        }
-      };
+        };
 
-      return !(message_queue().can_dequeue(domesticate));
+      return message_queue().can_dequeue(domesticate_head, domesticate_queue);
     }
 
     /**

src/snmalloc/mem/metadata.h

@@ -589,19 +589,19 @@ namespace snmalloc
    * Entry stored in the pagemap.  See docs/AddressSpace.md for the full
    * FrontendMetaEntry lifecycle.
    */
-  template<typename BackendSlabMetadata>
+  template<typename SlabMetadataType>
   class FrontendMetaEntry : public MetaEntryBase
   {
     /**
      * Ensure that the template parameter is valid.
      */
     static_assert(
-      std::is_convertible_v<BackendSlabMetadata, FrontendSlabMetadata_Trait>,
+      std::is_convertible_v<SlabMetadataType, FrontendSlabMetadata_Trait>,
       "The front end requires that the back end provides slab metadata that is "
       "compatible with the front-end's structure");
 
   public:
-    using SlabMetadata = BackendSlabMetadata;
+    using SlabMetadata = SlabMetadataType;
 
     constexpr FrontendMetaEntry() = default;
 
@@ -612,9 +612,8 @@ namespace snmalloc
      * `get_remote_and_sizeclass`.
      */
     SNMALLOC_FAST_PATH
-    FrontendMetaEntry(BackendSlabMetadata* meta, uintptr_t remote_and_sizeclass)
-    : MetaEntryBase(
-        unsafe_to_uintptr<BackendSlabMetadata>(meta), remote_and_sizeclass)
+    FrontendMetaEntry(SlabMetadata* meta, uintptr_t remote_and_sizeclass)
+    : MetaEntryBase(unsafe_to_uintptr<SlabMetadata>(meta), remote_and_sizeclass)
     {
       SNMALLOC_ASSERT_MSG(
         (REMOTE_BACKEND_MARKER & remote_and_sizeclass) == 0,
@@ -645,12 +644,10 @@ namespace snmalloc
      * guarded by an assert that this chunk is being used as a slab (i.e., has
      * an associated owning allocator).
      */
-    [[nodiscard]] SNMALLOC_FAST_PATH BackendSlabMetadata*
-    get_slab_metadata() const
+    [[nodiscard]] SNMALLOC_FAST_PATH SlabMetadata* get_slab_metadata() const
     {
       SNMALLOC_ASSERT(get_remote() != nullptr);
-      return unsafe_from_uintptr<BackendSlabMetadata>(
-        meta & ~META_BOUNDARY_BIT);
+      return unsafe_from_uintptr<SlabMetadata>(meta & ~META_BOUNDARY_BIT);
     }
   };
 

src/snmalloc/mem/remoteallocator.h

@@ -87,11 +87,12 @@ namespace snmalloc
       return fnt;
     }
 
-    template<typename Domesticator_head>
-    inline bool can_dequeue(Domesticator_head domesticate_head)
+    template<typename Domesticator_head, typename Domesticator_queue>
+    inline bool can_dequeue(
+      Domesticator_head domesticate_head, Domesticator_queue domesticate_queue)
     {
       return domesticate_head(front.load())
-               ->atomic_read_next(key_global, domesticate_head) == nullptr;
+               ->atomic_read_next(key_global, domesticate_queue) != nullptr;
     }
 
     /**

src/snmalloc/override/libc.h

@@ -74,7 +74,10 @@ namespace snmalloc::libc
       // Guard memcpy as GCC is assuming not nullptr for ptr after the memcpy
       // otherwise.
       if (SNMALLOC_UNLIKELY(sz != 0))
+      {
+        SNMALLOC_ASSUME(ptr != nullptr);
         ::memcpy(p, ptr, sz);
+      }
       a.dealloc(ptr);
     }
     else if (SNMALLOC_LIKELY(size == 0))
@@ -174,4 +177,4 @@ namespace snmalloc::libc
     *memptr = p;
     return 0;
   }
-} // namespace snmalloc::libc
+} // namespace snmalloc::libc