Upgrade snmalloc from 0.7.1 to 0.7.2 (#7163)

Author: achamayou

3rdparty/exported/snmalloc/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.14)
+cmake_minimum_required(VERSION 3.21)
 project(snmalloc CXX)
 
 if (NOT CMAKE_BUILD_TYPE)
@@ -32,22 +32,29 @@ option(SNMALLOC_ENABLE_FUZZING "Enable fuzzing instrumentation tests" OFF)
 option(SNMALLOC_USE_SELF_VENDORED_STL "Avoid using system STL" OFF)
 # Options that apply only if we're not building the header-only library
 cmake_dependent_option(SNMALLOC_RUST_SUPPORT "Build static library for rust" OFF "NOT SNMALLOC_HEADER_ONLY_LIBRARY" OFF)
+cmake_dependent_option(SNMALLOC_RUST_LIBC_API "Include libc API in the rust library" OFF "SNMALLOC_RUST_SUPPORT" OFF)
 cmake_dependent_option(SNMALLOC_STATIC_LIBRARY "Build static libraries" ON "NOT SNMALLOC_HEADER_ONLY_LIBRARY" OFF)
 cmake_dependent_option(SNMALLOC_CHECK_LOADS "Perform bounds checks on the source argument to memcpy with heap objects" OFF "NOT SNMALLOC_HEADER_ONLY_LIBRARY" OFF)
 cmake_dependent_option(SNMALLOC_OPTIMISE_FOR_CURRENT_MACHINE "Compile for current machine architecture" Off "NOT SNMALLOC_HEADER_ONLY_LIBRARY" OFF)
 cmake_dependent_option(SNMALLOC_PAGEID "Set an id to memory regions" OFF "NOT SNMALLOC_PAGEID" OFF)
+
+# GwpAsan secondary allocator
+option(SNMALLOC_ENABLE_GWP_ASAN_INTEGRATION "Enable GwpAsan as a secondary allocator" OFF)
+set(SNMALLOC_GWP_ASAN_INCLUDE_PATH "" CACHE PATH "GwpAsan header directory")
+set(SNMALLOC_GWP_ASAN_LIBRARY_PATH "" CACHE PATH "GwpAsan library directory")
+
 if (NOT SNMALLOC_HEADER_ONLY_LIBRARY)
   # Pick a sensible default for the thread cleanup mechanism
   if (${CMAKE_SYSTEM_NAME} STREQUAL FreeBSD)
     set(SNMALLOC_CLEANUP_DEFAULT THREAD_CLEANUP)
   elseif (UNIX AND NOT APPLE)
-    set(SNMALLOC_CLEANUP_DEFAULT PTHREAD_DESTRUCTORS)
+    set(SNMALLOC_CLEANUP_DEFAULT CXX11_THREAD_ATEXIT_DIRECT)
   else ()
     set(SNMALLOC_CLEANUP_DEFAULT CXX11_DESTRUCTORS)
   endif()
   # Specify the thread cleanup mechanism to use.
-  set(SNMALLOC_CLEANUP ${SNMALLOC_CLEANUP_DEFAULT} CACHE STRING "The mechanism that snmalloc will use for thread destructors.  Valid options are: CXX11_DESTRUCTORS (use C++11 destructors, may depend on the C++ runtime library), PTHREAD_DESTRUCTORS (use pthreads, may interact badly with C++ on some platforms, such as macOS) THREAD_CLEANUP (depend on an explicit call to _malloc_thread_cleanup on thread exit, supported by FreeBSD's threading implementation and possibly elsewhere)")
-  set_property(CACHE SNMALLOC_CLEANUP PROPERTY STRINGS THREAD_CLEANUP PTHREAD_DESTRUCTORS CXX11_DESTRUCTORS)
+  set(SNMALLOC_CLEANUP ${SNMALLOC_CLEANUP_DEFAULT} CACHE STRING "The mechanism that snmalloc will use for thread destructors.  Valid options are: CXX11_DESTRUCTORS (use C++11 destructors, may depend on the C++ runtime library), CXX11_THREAD_ATEXIT_DIRECT (use the glibc call for libstdc++ directly), PTHREAD_DESTRUCTORS (use pthreads, may interact badly with C++ on some platforms, such as macOS) THREAD_CLEANUP (depend on an explicit call to _malloc_thread_cleanup on thread exit, supported by FreeBSD's threading implementation and possibly elsewhere)")
+  set_property(CACHE SNMALLOC_CLEANUP PROPERTY STRINGS THREAD_CLEANUP PTHREAD_DESTRUCTORS CXX11_THREAD_ATEXIT_DIRECT CXX11_DESTRUCTORS)
 
   set(SNMALLOC_STATIC_LIBRARY_PREFIX "sn_" CACHE STRING "Static library function prefix")
   set(SNMALLOC_COMPILER_SUPPORT_IPO FALSE)
@@ -114,6 +121,19 @@ int main()
  SNMALLOC_LINKER_SUPPORT_NOSTDLIBXX)
 set(CMAKE_REQUIRED_LINK_OPTIONS "")
 
+# Detect if pthread_atfork works
+CHECK_CXX_SOURCE_COMPILES("
+#include <pthread.h>
+void prepare() {}
+void parent() {}
+void child() {}
+int main() {
+  pthread_atfork(prepare, parent, child);
+  return 0;
+}
+" SNMALLOC_PTHREAD_ATFORK_WORKS)
+
+
 if (NOT MSVC AND NOT (SNMALLOC_CLEANUP STREQUAL CXX11_DESTRUCTORS))
   # If the target compiler doesn't support -nostdlib++ then we must enable C at
   # the global scope for the fallbacks to work.
@@ -241,6 +261,20 @@ if(SNMALLOC_USE_SELF_VENDORED_STL)
   target_compile_definitions(snmalloc INTERFACE SNMALLOC_USE_SELF_VENDORED_STL)
 endif()
 
+if (SNMALLOC_ENABLE_GWP_ASAN_INTEGRATION)
+  if (NOT EXISTS ${SNMALLOC_GWP_ASAN_INCLUDE_PATH})
+    message(FATAL_ERROR "GwpAsan cannot be enabled without setting SNMALLOC_GWP_ASAN_INCLUDE_PATH")
+  endif()
+  if (NOT EXISTS ${SNMALLOC_GWP_ASAN_LIBRARY_PATH})
+    message(FATAL_ERROR "GwpAsan cannot be enabled without setting SNMALLOC_GWP_ASAN_LIBRARY_PATH")
+  endif()
+  message(STATUS "GwpAsan is enabled: ${SNMALLOC_GWP_ASAN_LIBRARY_PATH}/libclang_rt.gwp_asan-${CMAKE_SYSTEM_PROCESSOR}.a")
+  target_include_directories(snmalloc INTERFACE ${SNMALLOC_GWP_ASAN_INCLUDE_PATH})
+  target_link_directories(snmalloc INTERFACE ${SNMALLOC_GWP_ASAN_LIBRARY_PATH})
+  target_compile_definitions(snmalloc INTERFACE -DSNMALLOC_ENABLE_GWP_ASAN_INTEGRATION)
+  target_link_libraries(snmalloc INTERFACE clang_rt.gwp_asan-${CMAKE_SYSTEM_PROCESSOR})
+endif()
+
 # https://learn.microsoft.com/en-us/cpp/build/reference/zc-cplusplus
 if(MSVC)
   target_compile_options(snmalloc INTERFACE "/Zc:__cplusplus")
@@ -300,6 +334,7 @@ add_as_define(SNMALLOC_QEMU_WORKAROUND)
 add_as_define(SNMALLOC_TRACING)
 add_as_define(SNMALLOC_CI_BUILD)
 add_as_define(SNMALLOC_PLATFORM_HAS_GETENTROPY)
+add_as_define(SNMALLOC_PTHREAD_ATFORK_WORKS)
 add_as_define(SNMALLOC_HAS_LINUX_RANDOM_H)
 add_as_define(SNMALLOC_HAS_LINUX_FUTEX_H)
 if (SNMALLOC_NO_REALLOCARRAY)
@@ -344,7 +379,7 @@ endif()
 function(add_warning_flags name)
   target_compile_options(${name} PRIVATE
     $<$<CXX_COMPILER_ID:MSVC>:/Zi /W4 /WX /wd4127 /wd4324 /wd4201>
-    $<$<NOT:$<OR:$<CXX_COMPILER_ID:MSVC>,$<STREQUAL:${CMAKE_CXX_SIMULATE_ID},MSVC>>>:-fno-exceptions -fno-rtti -Wall -Wextra -Werror -Wundef>
+    $<$<NOT:$<OR:$<CXX_COMPILER_ID:MSVC>,$<STREQUAL:${CMAKE_CXX_SIMULATE_ID},MSVC>>>:-fno-rtti -Wall -Wextra -Werror -Wundef>
     $<$<CXX_COMPILER_ID:Clang>:-Wsign-conversion -Wconversion>)
   target_link_options(${name} PRIVATE 
     $<$<BOOL:${SNMALLOC_LINKER_SUPPORT_NO_ALLOW_SHLIB_UNDEF}>:-Wl,--no-undefined>
@@ -465,32 +500,32 @@ if(NOT SNMALLOC_HEADER_ONLY_LIBRARY)
   if(SNMALLOC_OPTIMISE_FOR_CURRENT_MACHINE)
     check_cxx_compiler_flag(-march=native SUPPORT_MARCH_NATIVE)
     if (NOT SUPPORT_MARCH_NATIVE)
-      message_once(WARNING "Compiler does not support `-march=native` required by SNMALLOC_OPTIMISE_FOR_CURRENT_MACHINE")
+      message(WARNING "Compiler does not support `-march=native` required by SNMALLOC_OPTIMISE_FOR_CURRENT_MACHINE")
       set(SNMALLOC_OPTIMISE_FOR_CURRENT_MACHINE FALSE)
     endif()
-endif()
+  endif()
 
 
-  function(add_shim name type)
-    add_library(${name} ${type} ${ARGN})
+  function(compile name TYPE ${ARGN})
+    add_library(${name} ${TYPE} ${ARGN})
     target_link_libraries(${name} snmalloc)
-    set_target_properties(${name} PROPERTIES CXX_VISIBILITY_PRESET hidden INTERPROCEDURAL_OPTIMIZATION ${SNMALLOC_COMPILER_SUPPORT_IPO})
     target_compile_definitions(${name} PRIVATE "SNMALLOC_USE_${SNMALLOC_CLEANUP}")
 
-    if(MSVC)
-      target_compile_definitions(${name} INTERFACE -D_HAS_EXCEPTIONS=0)
-    endif()
-
     add_warning_flags(${name})
     if(NOT MSVC)
       target_compile_definitions(${name} PRIVATE "SNMALLOC_EXPORT=__attribute__((visibility(\"default\")))")
-      target_compile_options(${name} PRIVATE
-        -fomit-frame-pointer -ffunction-sections)
+      set_target_properties(${name} PROPERTIES CXX_VISIBILITY_PRESET hidden INTERPROCEDURAL_OPTIMIZATION ${SNMALLOC_COMPILER_SUPPORT_IPO})
+      # Make debugging harder, and code faster.
+      target_compile_options(${name} PRIVATE -fomit-frame-pointer)
+
+      set_property(TARGET ${name} PROPERTY POSITION_INDEPENDENT_CODE ON)
 
+      # Check for prefetch write support.
       check_cxx_compiler_flag("-Werror -Wextra -Wall -mprfchw" SUPPORT_PREFETCH_WRITE)
       if (SUPPORT_PREFETCH_WRITE)
         target_compile_options(${name} PRIVATE -mprfchw)
       endif()
+
       # Static TLS model is unsupported on Haiku.
       if (SNMALLOC_STATIC_MODE_TLS)
         target_compile_options(${name} PRIVATE -ftls-model=initial-exec)
@@ -501,18 +536,8 @@ endif()
         target_compile_options(${name} PRIVATE -march=native)
       endif()
 
-      # Ensure that we do not link against C++ stdlib when compiling shims.
-      # If the compiler supports excluding the C++ stdlib implementation, use
-      # it.  Otherwise, fall back to linking the library as if it were C, which
-      # has roughly the same effect.
-      if (NOT ${SNMALLOC_CLEANUP} STREQUAL CXX11_DESTRUCTORS)
-        if (SNMALLOC_LINKER_SUPPORT_NOSTDLIBXX)
-          target_link_options(${name} PRIVATE -nostdlib++)
-        else()
-          set_target_properties(${name} PROPERTIES LINKER_LANGUAGE C)
-        endif()
-      endif()
       # Remove all the duplicate new/malloc and free/delete definitions
+      target_compile_options(${name} PRIVATE -ffunction-sections)
       target_link_options(${name} PRIVATE $<$<BOOL:${LLD_WORKS}>:$<$<BOOL:${SNMALLOC_LINK_ICF}>:-Wl,--icf=all> -fuse-ld=lld>)
     endif()
 
@@ -521,55 +546,65 @@ endif()
     target_compile_definitions(${name} PRIVATE
       SNMALLOC_PAGEID=$<IF:$<BOOL:${SNMALLOC_PAGEID}>,true,false>)
 
-    install(TARGETS ${name} EXPORT snmallocConfig)
+    if(MSVC)
+    else()
+      # We can't do --nostdlib++ as we are using exceptions, but we 
+      # can make it a static dependency, which we aren't really using
+      # as the interesting stuff for exceptions is in libgcc_s
+      target_link_options(${name} PRIVATE -static-libstdc++)
+    endif()
 
+    if (SNMALLOC_RUST_LIBC_API)
+      target_compile_definitions(${name} PRIVATE SNMALLOC_RUST_LIBC_API)
+    endif()
+    install(TARGETS ${name} EXPORT snmallocConfig)
   endfunction()
 
-  set(SHIM_FILES src/snmalloc/override/malloc.cc src/snmalloc/override/new.cc)
-  set(SHIM_FILES_MEMCPY src/snmalloc/override/memcpy.cc)
+  # Various files for overriding libc/rust behaviours.
+  set(MALLOC src/snmalloc/override/malloc.cc)
+  set(NEW src/snmalloc/override/new.cc)
+  set(MEMCPY src/snmalloc/override/memcpy.cc)
+  set(RUST src/snmalloc/override/rust.cc)
 
-  add_shim(snmalloc-new-override STATIC src/snmalloc/override/new.cc)
+  set(ALLOC ${MALLOC} ${NEW})
+  set(ALL ${ALLOC} ${MEMCPY})
 
   if (SNMALLOC_STATIC_LIBRARY)
-    add_shim(snmallocshim-static STATIC ${SHIM_FILES})
+    compile(snmallocshim-static STATIC ${ALLOC})
     target_compile_definitions(snmallocshim-static PRIVATE
             SNMALLOC_STATIC_LIBRARY_PREFIX=${SNMALLOC_STATIC_LIBRARY_PREFIX})
   endif ()
 
+  compile(snmalloc-new-override STATIC ${NEW})
+
   if(NOT WIN32)
-    add_shim(snmallocshim SHARED ${SHIM_FILES})
+    compile(snmallocshim SHARED ${ALLOC})
+
     if (SNMALLOC_MEMCPY_OVERRIDE)
-      add_shim(snmallocshim-checks-memcpy-only SHARED ${SHIM_FILES} ${SHIM_FILES_MEMCPY})
-      add_shim(snmallocshim-checks SHARED ${SHIM_FILES} ${SHIM_FILES_MEMCPY})
+      compile(snmallocshim-checks-memcpy-only SHARED ${ALL})
+      compile(snmallocshim-checks SHARED ${ALL})
     else()
-    add_shim(snmallocshim-checks SHARED ${SHIM_FILES})
+      compile(snmallocshim-checks SHARED ${ALLOC})
     endif()
     target_compile_definitions(snmallocshim-checks PRIVATE SNMALLOC_CHECK_CLIENT)
+  
+    compile(snmalloc-minimal SHARED ${MALLOC})
+    target_compile_options(snmalloc-minimal PRIVATE -fno-exceptions)
+    if (SNMALLOC_LINKER_SUPPORT_NOSTDLIBXX AND NOT ${SNMALLOC_CLEANUP} STREQUAL CXX11_DESTRUCTORS)
+      target_compile_options(snmalloc-minimal PRIVATE -fno-exceptions -nostdlib++)
+    endif ()
   endif()
 
   if(SNMALLOC_RUST_SUPPORT)
-    add_shim(snmallocshim-rust STATIC src/snmalloc/override/rust.cc)
-    add_shim(snmallocshim-checks-rust STATIC src/snmalloc/override/rust.cc)
+    compile(snmallocshim-rust STATIC ${RUST})
+    compile(snmallocshim-checks-rust STATIC ${RUST})
     target_compile_definitions(snmallocshim-checks-rust PRIVATE SNMALLOC_CHECK_CLIENT)
   endif()
 
   if (SNMALLOC_BUILD_TESTING)
-    if (WIN32
-    OR (CMAKE_SYSTEM_NAME STREQUAL NetBSD)
-    OR (CMAKE_SYSTEM_NAME STREQUAL OpenBSD)
-    OR (CMAKE_SYSTEM_NAME STREQUAL SunOS))
-    # Windows does not support aligned allocation well enough
-    # for pass through.
-    # NetBSD, OpenBSD and DragonFlyBSD do not support malloc*size calls.
-      set(FLAVOURS fast;check)
-    else()
-      set(FLAVOURS fast;check;malloc)
-    endif()
+    set(FLAVOURS fast;check)
 
     foreach(FLAVOUR ${FLAVOURS})
-      if (${FLAVOUR} STREQUAL "malloc")
-        set(DEFINES SNMALLOC_PASS_THROUGH)
-      endif()
       if (${FLAVOUR} STREQUAL "check")
         set(DEFINES SNMALLOC_CHECK_CLIENT)
       endif()
@@ -599,7 +634,7 @@ endif()
 
     foreach (MITIGATION ${MITIGATIONS})
       set(DEFINES "SNMALLOC_CHECK_CLIENT_MITIGATIONS=${MITIGATION}")
-      add_shim(snmallocshim-${MITIGATION} SHARED ${SHIM_FILES})
+      compile(snmallocshim-${MITIGATION} SHARED ${ALLOC})
       target_compile_definitions(snmallocshim-${MITIGATION} PRIVATE ${DEFINES})
       if (SNMALLOC_BUILD_TESTING)
         make_tests(${MITIGATION} ${DEFINES})
@@ -614,7 +649,7 @@ endif()
       set(MITIGATIONSET "${MITIGATIONSET}+${MITIGATION}")
       message(STATUS "MITIGATIONSET: ${COUNT} -> ${MITIGATIONSET}")
       set(DEFINES "-DSNMALLOC_CHECK_CLIENT_MITIGATIONS=${MITIGATIONSET}")
-      add_shim(snmallocshim-${MITIGATIONNAME} SHARED ${SHIM_FILES})
+      compile(snmallocshim-${MITIGATIONNAME} SHARED ${ALLOC})
       target_compile_definitions(snmallocshim-${MITIGATIONNAME} PRIVATE ${DEFINES})
       if (SNMALLOC_BUILD_TESTING)
         make_tests(${MITIGATIONNAME} ${DEFINES})
@@ -633,19 +668,24 @@ install(TARGETS EXPORT snmallocConfig DESTINATION ${CMAKE_INSTALL_LIBDIR}
   PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/snmalloc)
 
 install(DIRECTORY src/snmalloc/aal DESTINATION include/snmalloc)
-install(DIRECTORY src/snmalloc/ds DESTINATION include/snmalloc)
-install(DIRECTORY src/snmalloc/override DESTINATION include/snmalloc)
 install(DIRECTORY src/snmalloc/backend DESTINATION include/snmalloc)
+install(DIRECTORY src/snmalloc/backend_helpers DESTINATION include/snmalloc)
+install(DIRECTORY src/snmalloc/ds DESTINATION include/snmalloc)
+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/override DESTINATION include/snmalloc)
 install(DIRECTORY src/snmalloc/pal DESTINATION include/snmalloc)
+install(DIRECTORY src/snmalloc/stl DESTINATION include/snmalloc)
 install(FILES
     src/test/measuretime.h
     src/test/opt.h
     src/test/setup.h
     src/test/usage.h
     src/test/xoroshiro.h
   DESTINATION include/snmalloc/test
-  )
+)
 install(FILES src/snmalloc/snmalloc.h;src/snmalloc/snmalloc_core.h;src/snmalloc/snmalloc_front.h DESTINATION include/snmalloc)
 
 install(EXPORT snmallocConfig

3rdparty/exported/snmalloc/src/snmalloc/README.md

@@ -20,7 +20,7 @@ These are arranged in a hierarchy such that each of the directories may include
    This includes data structures such as pagemap implementations (efficient maps from a chunk address to associated metadata) and buddy allocators for managing address-space ranges.
  - `backend/` provides some example implementations for snmalloc embeddings that provide a global memory allocator for an address space.
    Users may ignore this entirely and use the types in `mem/` with a custom back end to expose an snmalloc instance with specific behaviour.
-   Layers above this can be used with a custom configuration by defining `SNMALLOC_PROVIDE_OWN_CONFIG` and exporting a type as `snmalloc::Alloc` that defines the type of an `snmalloc::LocalAllocator` template specialisation.
+   Layers above this can be used with a custom configuration by defining `SNMALLOC_PROVIDE_OWN_CONFIG` and exporting a type as `snmalloc::Config` that defines the configuration.
  - `global/` provides some front-end components that assume that snmalloc is available in a global configuration.
  - `override/` builds on top of `global/` to provide specific implementations with compatibility with external specifications (for example C `malloc`, C++ `operator new`, jemalloc's `*allocx`, or Rust's `std::alloc`).
 

3rdparty/exported/snmalloc/src/snmalloc/backend/backend.h

@@ -59,7 +59,6 @@ namespace snmalloc
 
       if (p == nullptr)
       {
-        errno = ENOMEM;
         return nullptr;
       }
 
@@ -112,7 +111,6 @@ namespace snmalloc
 
       if (meta == nullptr)
       {
-        errno = ENOMEM;
         return {nullptr, nullptr};
       }
 
@@ -124,7 +122,6 @@ namespace snmalloc
       if (p == nullptr)
       {
         local_state.get_meta_range().dealloc_range(meta_cap, meta_size);
-        errno = ENOMEM;
 #ifdef SNMALLOC_TRACING
         message<1024>("Out of memory");
 #endif

3rdparty/exported/snmalloc/src/snmalloc/backend/fixedglobalconfig.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "../backend_helpers/backend_helpers.h"
+#include "../mem/secondary/default.h"
 #include "snmalloc/stl/type_traits.h"
 #include "standard_range.h"
 
@@ -13,12 +14,14 @@ namespace snmalloc
    */
   template<
     SNMALLOC_CONCEPT(IsPAL) PAL,
-    typename ClientMetaDataProvider = NoClientMetaDataProvider>
+    typename ClientMetaDataProvider = NoClientMetaDataProvider,
+    typename SecondaryAllocator_ = DefaultSecondaryAllocator>
   class FixedRangeConfig final : public CommonConfig
   {
   public:
     using PagemapEntry = DefaultPagemapEntry<ClientMetaDataProvider>;
     using ClientMeta = ClientMetaDataProvider;
+    using SecondaryAllocator = SecondaryAllocator_;
 
   private:
     using ConcretePagemap =
@@ -41,7 +44,7 @@ namespace snmalloc
   public:
     using LocalState = StandardLocalState<PAL, Pagemap>;
 
-    using GlobalPoolState = PoolState<CoreAllocator<FixedRangeConfig>>;
+    using GlobalPoolState = PoolState<Allocator<FixedRangeConfig>>;
 
     using Backend =
       BackendAllocator<PAL, PagemapEntry, Pagemap, Authmap, LocalState>;
@@ -75,15 +78,6 @@ namespace snmalloc
       return opts;
     }();
 
-    // This needs to be a forward reference as the
-    // thread local state will need to know about this.
-    // This may allocate, so must be called once a thread
-    // local allocator exists.
-    static void register_clean_up()
-    {
-      snmalloc::register_clean_up();
-    }
-
     static void init(LocalState* local_state, void* base, size_t length)
     {
       UNUSED(local_state);