Compile testlib-only tests once for both fast and check

Testlib-only tests are mitigation-independent: compile into shared OBJECT libraries. Also fix MSVC C4701 warning in cleanup_unused and add unistd.h to protect_fork.

Author: mjp41

CMakeLists.txt

@@ -479,6 +479,16 @@ if(NOT SNMALLOC_HEADER_ONLY_LIBRARY)
     set(TEST_CLEANUP ${SNMALLOC_CLEANUP})
   endif()
 
+  # Tests that only include snmalloc_testlib.h (no snmalloc.h or snmalloc_core.h).
+  # These are mitigation-independent and can be compiled once, then linked
+  # against both fast and check testlib variants.
+  set(TESTLIB_ONLY_TESTS
+    bits first_operation memory_usage multi_atexit multi_threadatexit
+    redblack statistics teardown
+    contention external_pointer large_alloc lotsofthreads post_teardown
+    singlethread startup
+  )
+
   function(make_tests TAG DEFINES)
     foreach(TEST_CATEGORY ${TEST_CATEGORIES})
       message(VERBOSE "Adding ${TAG}/${TEST_CATEGORY} tests")
@@ -488,7 +498,32 @@ if(NOT SNMALLOC_HEADER_ONLY_LIBRARY)
         aux_source_directory(${TESTDIR}/${TEST_CATEGORY}/${TEST} SRC)
         set(TESTNAME "${TEST_CATEGORY}-${TEST}-${TAG}")
 
-        add_executable(${TESTNAME} ${SRC})
+        # Check if this test is testlib-only (mitigation-independent).
+        # If so, compile the source once into an object library and reuse
+        # across flavours.
+        list(FIND TESTLIB_ONLY_TESTS ${TEST} _testlib_only_idx)
+        set(OBJLIBNAME "${TEST_CATEGORY}-${TEST}-obj")
+        if (NOT ${_testlib_only_idx} EQUAL -1 AND NOT TARGET ${OBJLIBNAME})
+          # First flavour to see this test creates the object library.
+          add_library(${OBJLIBNAME} OBJECT ${SRC})
+          target_link_libraries(${OBJLIBNAME} snmalloc)
+          target_compile_definitions(${OBJLIBNAME} PRIVATE "SNMALLOC_USE_${TEST_CLEANUP}")
+          add_warning_flags(${OBJLIBNAME})
+          if(SNMALLOC_SANITIZER)
+            target_compile_options(${OBJLIBNAME} PRIVATE -g -fsanitize=${SNMALLOC_SANITIZER} -fno-omit-frame-pointer)
+            if (${SNMALLOC_SANITIZER} MATCHES "thread")
+              target_compile_definitions(${OBJLIBNAME} PRIVATE SNMALLOC_THREAD_SANITIZER_ENABLED)
+            endif()
+          endif()
+        endif()
+
+        if (NOT ${_testlib_only_idx} EQUAL -1)
+          # Testlib-only: link the shared object library against this
+          # flavour's testlib.
+          add_executable(${TESTNAME} $<TARGET_OBJECTS:${OBJLIBNAME}>)
+        else()
+          add_executable(${TESTNAME} ${SRC})
+        endif()
 
         if(SNMALLOC_SANITIZER)
           target_compile_options(${TESTNAME} PRIVATE -g -fsanitize=${SNMALLOC_SANITIZER} -fno-omit-frame-pointer)
@@ -551,6 +586,12 @@ if(NOT SNMALLOC_HEADER_ONLY_LIBRARY)
     if (NOT DEFINES STREQUAL " ")
       target_compile_definitions(${LIBNAME} PRIVATE ${DEFINES})
     endif()
+    if(SNMALLOC_SANITIZER)
+      target_compile_options(${LIBNAME} PRIVATE -g -fsanitize=${SNMALLOC_SANITIZER} -fno-omit-frame-pointer)
+      if (${SNMALLOC_SANITIZER} MATCHES "thread")
+        target_compile_definitions(${LIBNAME} PRIVATE SNMALLOC_THREAD_SANITIZER_ENABLED)
+      endif()
+    endif()
     add_warning_flags(${LIBNAME})
   endfunction()
 

src/snmalloc/global/globalalloc.h

@@ -17,19 +17,19 @@ namespace snmalloc
     // Handling the message queue for each stack is non-atomic.
     auto* first = AllocPool<Config_>::extract();
     auto* alloc = first;
-    decltype(alloc) last;
 
-    if (alloc != nullptr)
-    {
-      while (alloc != nullptr)
-      {
-        alloc->flush();
-        last = alloc;
-        alloc = AllocPool<Config_>::extract(alloc);
-      }
+    if (alloc == nullptr)
+      return;
 
-      AllocPool<Config_>::restore(first, last);
+    decltype(alloc) last = alloc;
+    while (alloc != nullptr)
+    {
+      alloc->flush();
+      last = alloc;
+      alloc = AllocPool<Config_>::extract(alloc);
     }
+
+    AllocPool<Config_>::restore(first, last);
   }
 
   /**

src/test/func/protect_fork/protect_fork.cc

@@ -12,6 +12,7 @@ int main()
 #  include <snmalloc/ds_core/helpers.h>
 #  include <snmalloc/ds_aal/prevent_fork.h>
 #  include <thread>
+#  include <unistd.h>
 
 void simulate_allocation()
 {