Use SNMALLOC_API macro for non-template API functions

Introduce SNMALLOC_API macro for public API functions (dealloc,
debug_teardown, libc::malloc, etc.) that need standalone definitions
when compiled into a static library.

Defaults to SNMALLOC_FAST_PATH_INLINE (normal header-only usage).
testlib.cc defines SNMALLOC_API as NOINLINE on MSVC before including
snmalloc.h, producing strong definitions that ARM64EC exit-thunks
can reference. On GCC/Clang, __attribute__((used)) via the existing
SNMALLOC_USED_FUNCTION annotation suffices.

Author: mjp41

BUILD.bazel

@@ -6,6 +6,7 @@ filegroup(
         [
             "src/snmalloc/**/*",
             "src/test/*.h",
+            "src/test/*.cc",
             "CMakeLists.txt",
         ],
     ),
@@ -39,6 +40,7 @@ CMAKE_FLAGS = {
     "SNMALLOC_USE_SELF_VENDORED_STL": "OFF",
     "SNMALLOC_IPO": "ON",
     "USE_SNMALLOC_STATS": "ON",
+    "SNMALLOC_BUILD_TESTING": "OFF",
 } | select({
     ":release_with_debug": {"CMAKE_BUILD_TYPE": "RelWithDebInfo"},
     ":release": {"CMAKE_BUILD_TYPE": "Release"},

CMakeLists.txt

@@ -801,6 +801,7 @@ install(DIRECTORY src/snmalloc/ds_aal DESTINATION include/snmalloc)
 install(DIRECTORY src/snmalloc/ds_core DESTINATION include/snmalloc)
 install(DIRECTORY src/snmalloc/global DESTINATION include/snmalloc)
 install(DIRECTORY src/snmalloc/mem DESTINATION include/snmalloc)
+install(DIRECTORY src/snmalloc/mitigations DESTINATION include/snmalloc)
 install(DIRECTORY src/snmalloc/override DESTINATION include/snmalloc)
 install(DIRECTORY src/snmalloc/pal DESTINATION include/snmalloc)
 install(DIRECTORY src/snmalloc/stl DESTINATION include/snmalloc)

src/snmalloc/global/globalalloc.h

@@ -3,6 +3,14 @@
 #include "../mem/mem.h"
 #include "threadalloc.h"
 
+// Non-template API functions use SNMALLOC_API for their linkage specifier.
+// Normally inline; can be overridden to NOINLINE (via SNMALLOC_API_NOINLINE)
+// to produce strong definitions in a standalone compilation unit.
+#ifndef SNMALLOC_API
+#  define SNMALLOC_API SNMALLOC_USED_FUNCTION SNMALLOC_FAST_PATH_INLINE
+#  define SNMALLOC_API_SLOW SNMALLOC_USED_FUNCTION inline
+#endif
+
 namespace snmalloc
 {
   template<SNMALLOC_CONCEPT(IsConfig) Config_ = Config>
@@ -363,12 +371,12 @@ namespace snmalloc
       aligned_size(align, size));
   }
 
-  SNMALLOC_USED_FUNCTION SNMALLOC_FAST_PATH_INLINE void dealloc(void* p)
+  SNMALLOC_API void dealloc(void* p)
   {
     ThreadAlloc::get().dealloc<ThreadAlloc::CheckInit>(p);
   }
 
-  SNMALLOC_USED_FUNCTION SNMALLOC_FAST_PATH_INLINE void
+  SNMALLOC_API void
   dealloc(void* p, size_t size)
   {
     check_size(p, size);
@@ -382,15 +390,15 @@ namespace snmalloc
     ThreadAlloc::get().dealloc<ThreadAlloc::CheckInit>(p);
   }
 
-  SNMALLOC_USED_FUNCTION SNMALLOC_FAST_PATH_INLINE void
+  SNMALLOC_API void
   dealloc(void* p, size_t size, size_t align)
   {
     auto rsize = aligned_size(align, size);
     check_size(p, rsize);
     ThreadAlloc::get().dealloc<ThreadAlloc::CheckInit>(p);
   }
 
-  SNMALLOC_USED_FUNCTION SNMALLOC_FAST_PATH_INLINE void debug_teardown()
+  SNMALLOC_API void debug_teardown()
   {
     return ThreadAlloc::teardown();
   }

src/snmalloc/global/libc.h

@@ -19,22 +19,22 @@ namespace snmalloc::libc
     return err;
   }
 
-  SNMALLOC_USED_FUNCTION inline void* __malloc_end_pointer(void* ptr)
+  SNMALLOC_API_SLOW void* __malloc_end_pointer(void* ptr)
   {
     return snmalloc::external_pointer<OnePastEnd>(ptr);
   }
 
-  SNMALLOC_USED_FUNCTION inline void* __malloc_start_pointer(void* ptr)
+  SNMALLOC_API_SLOW void* __malloc_start_pointer(void* ptr)
   {
     return snmalloc::external_pointer<Start>(ptr);
   }
 
-  SNMALLOC_USED_FUNCTION inline void* __malloc_last_byte_pointer(void* ptr)
+  SNMALLOC_API_SLOW void* __malloc_last_byte_pointer(void* ptr)
   {
     return snmalloc::external_pointer<End>(ptr);
   }
 
-  SNMALLOC_USED_FUNCTION SNMALLOC_FAST_PATH_INLINE void* malloc(size_t size)
+  SNMALLOC_API void* malloc(size_t size)
   {
     return snmalloc::alloc(size);
   }
@@ -43,7 +43,7 @@ namespace snmalloc::libc
    * Allocate for a pre-computed small sizeclass.
    * Use is_small_sizeclass() + size_to_sizeclass_const() to get the class.
    */
-  SNMALLOC_USED_FUNCTION SNMALLOC_FAST_PATH_INLINE void*
+  SNMALLOC_API void*
   malloc_small(smallsizeclass_t sizeclass)
   {
     return snmalloc::alloc(sizeclass);
@@ -52,30 +52,30 @@ namespace snmalloc::libc
   /**
    * Allocate zeroed memory for a pre-computed small sizeclass.
    */
-  SNMALLOC_USED_FUNCTION SNMALLOC_FAST_PATH_INLINE void*
+  SNMALLOC_API void*
   malloc_small_zero(smallsizeclass_t sizeclass)
   {
     return snmalloc::alloc<Zero>(sizeclass);
   }
 
-  SNMALLOC_USED_FUNCTION SNMALLOC_FAST_PATH_INLINE void free(void* ptr)
+  SNMALLOC_API void free(void* ptr)
   {
     dealloc(ptr);
   }
 
-  SNMALLOC_USED_FUNCTION SNMALLOC_FAST_PATH_INLINE void
+  SNMALLOC_API void
   free_sized(void* ptr, size_t size)
   {
     dealloc(ptr, size);
   }
 
-  SNMALLOC_USED_FUNCTION SNMALLOC_FAST_PATH_INLINE void
+  SNMALLOC_API void
   free_aligned_sized(void* ptr, size_t alignment, size_t size)
   {
     dealloc(ptr, size, alignment);
   }
 
-  SNMALLOC_USED_FUNCTION SNMALLOC_FAST_PATH_INLINE void*
+  SNMALLOC_API void*
   calloc(size_t nmemb, size_t size)
   {
     bool overflow = false;
@@ -87,7 +87,7 @@ namespace snmalloc::libc
     return alloc<Zero>(sz);
   }
 
-  SNMALLOC_USED_FUNCTION SNMALLOC_FAST_PATH_INLINE void*
+  SNMALLOC_API void*
   realloc(void* ptr, size_t size)
   {
     // Glibc treats
@@ -137,12 +137,12 @@ namespace snmalloc::libc
     return p;
   }
 
-  SNMALLOC_USED_FUNCTION inline size_t malloc_usable_size(const void* ptr)
+  SNMALLOC_API_SLOW size_t malloc_usable_size(const void* ptr)
   {
     return alloc_size(ptr);
   }
 
-  SNMALLOC_USED_FUNCTION inline void*
+  SNMALLOC_API_SLOW void*
   reallocarray(void* ptr, size_t nmemb, size_t size)
   {
     bool overflow = false;
@@ -154,7 +154,7 @@ namespace snmalloc::libc
     return realloc(ptr, sz);
   }
 
-  SNMALLOC_USED_FUNCTION inline int
+  SNMALLOC_API_SLOW int
   reallocarr(void* ptr_, size_t nmemb, size_t size)
   {
     int err = errno;
@@ -190,7 +190,7 @@ namespace snmalloc::libc
     return 0;
   }
 
-  SNMALLOC_USED_FUNCTION inline void*
+  SNMALLOC_API_SLOW void*
   memalign(size_t alignment, size_t size)
   {
     if (SNMALLOC_UNLIKELY(alignment == 0 || !bits::is_pow2(alignment)))
@@ -201,13 +201,13 @@ namespace snmalloc::libc
     return alloc_aligned(alignment, size);
   }
 
-  SNMALLOC_USED_FUNCTION inline void*
+  SNMALLOC_API_SLOW void*
   aligned_alloc(size_t alignment, size_t size)
   {
     return memalign(alignment, size);
   }
 
-  SNMALLOC_USED_FUNCTION inline int
+  SNMALLOC_API_SLOW int
   posix_memalign(void** memptr, size_t alignment, size_t size)
   {
     if (SNMALLOC_UNLIKELY(

src/test/snmalloc_testlib.cc

@@ -22,6 +22,15 @@
  *     ODR-conflicting with the templates).
  */
 
+// On MSVC (where SNMALLOC_USED_FUNCTION is empty), override the testlib
+// inline macros to produce strong (non-inline) definitions so the linker
+// can resolve ARM64EC exit-thunks. On GCC/Clang, __attribute__((used))
+// already handles this.
+#ifdef _MSC_VER
+#  define SNMALLOC_API NOINLINE
+#  define SNMALLOC_API_SLOW NOINLINE
+#endif
+
 #include <snmalloc/snmalloc.h>
 
 namespace snmalloc
@@ -167,41 +176,6 @@ namespace snmalloc
   {
     Aal::pause();
   }
-
-  // -- Force emission of inline functions for MSVC (where USED_FUNCTION is
-  // empty). Taking the address of each inline function forces the compiler to
-  // emit a definition in this TU, making it available to testlib consumers.
-
-  SNMALLOC_USED_FUNCTION static const volatile void* force_emit_global[] = {
-    reinterpret_cast<volatile void*>(
-      static_cast<void (*)(void*)>(&dealloc)),
-    reinterpret_cast<volatile void*>(
-      static_cast<void (*)(void*, size_t)>(&dealloc)),
-    reinterpret_cast<volatile void*>(
-      static_cast<void (*)(void*, size_t, size_t)>(&dealloc)),
-    reinterpret_cast<volatile void*>(&debug_teardown),
-  };
-
-  namespace libc
-  {
-    SNMALLOC_USED_FUNCTION static const volatile void* force_emit_libc[] = {
-      reinterpret_cast<volatile void*>(&__malloc_start_pointer),
-      reinterpret_cast<volatile void*>(&__malloc_last_byte_pointer),
-      reinterpret_cast<volatile void*>(&__malloc_end_pointer),
-      reinterpret_cast<volatile void*>(&malloc),
-      reinterpret_cast<volatile void*>(&free),
-      reinterpret_cast<volatile void*>(
-        static_cast<void* (*)(size_t, size_t)>(&calloc)),
-      reinterpret_cast<volatile void*>(
-        static_cast<void* (*)(void*, size_t)>(&realloc)),
-      reinterpret_cast<volatile void*>(&malloc_usable_size),
-      reinterpret_cast<volatile void*>(&memalign),
-      reinterpret_cast<volatile void*>(&aligned_alloc),
-      reinterpret_cast<volatile void*>(&posix_memalign),
-      reinterpret_cast<volatile void*>(&malloc_small),
-      reinterpret_cast<volatile void*>(&malloc_small_zero),
-    };
-  } // namespace libc
 } // namespace snmalloc
 
 // -- override/malloc.cc symbols with testlib_ prefix -----------------------