Make visibility=hidden symbols private on macos

Fixes #20

CMakeLists.txt

@@ -1,15 +1,26 @@
 cmake_minimum_required(VERSION 3.18)
 project(
   conflict-set
-  VERSION 0.0.1
+  VERSION 0.0.2
   DESCRIPTION
     "A data structure for optimistic concurrency control on ranges of bitwise-lexicographically-ordered keys."
   HOMEPAGE_URL "https://git.weaselab.dev/weaselab/conflict-set"
   LANGUAGES C CXX)
 set(CMAKE_CXX_STANDARD 20)
 
+include(CMakePushCheckState)
+include(CheckCXXCompilerFlag)
+include(CheckIncludeFileCXX)
+include(CheckCXXSourceCompiles)
+
 set(DEFAULT_BUILD_TYPE "Release")
 
+if(EMSCRIPTEN OR CMAKE_SYSTEM_NAME STREQUAL WASI)
+  set(WASM ON)
+else()
+  set(WASM OFF)
+endif()
+
 if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
   message(
     STATUS
@@ -23,7 +34,23 @@ if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
 endif()
 
 add_compile_options(-fdata-sections -ffunction-sections -Wswitch-enum
-                    -Werror=switch-enum)
+                    -Werror=switch-enum -fPIC)
+
+set(full_relro_flags "-pie;LINKER:-z,relro,-z,now,-z,noexecstack")
+cmake_push_check_state()
+list(APPEND CMAKE_REQUIRED_LINK_OPTIONS ${full_relro_flags})
+check_cxx_source_compiles("int main(){}" HAS_FULL_RELRO FAIL_REGEX "warning:")
+if(HAS_FULL_RELRO)
+  add_link_options(${full_relro_flags})
+endif()
+cmake_pop_check_state()
+
+set(version_script_flags LINKER:--version-script=${CMAKE_SOURCE_DIR}/linker.map)
+cmake_push_check_state()
+list(APPEND CMAKE_REQUIRED_LINK_OPTIONS ${version_script_flags})
+check_cxx_source_compiles("int main(){}" HAS_VERSION_SCRIPT FAIL_REGEX
+                          "warning:")
+cmake_pop_check_state()
 
 option(USE_SIMD_FALLBACK
        "Use fallback implementations of functions that use SIMD" OFF)
@@ -32,10 +59,7 @@ option(USE_SIMD_FALLBACK
 # https://valgrind.org/docs/manual/manual-core-adv.html#manual-core-adv.clientreq
 include_directories(SYSTEM ${CMAKE_SOURCE_DIR}/third_party/valgrind)
 
-if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Wno-invalid-offsetof>)
-  add_compile_options(-Wno-maybe-uninitialized
-                      $<$<COMPILE_LANGUAGE:CXX>:-Wno-invalid-offsetof>)
-endif()
 
 if(APPLE)
   add_link_options(-Wl,-dead_strip)
@@ -43,10 +67,22 @@ else()
   add_link_options(-Wl,--gc-sections)
 endif()
 
-include(CheckIncludeFileCXX)
+if(EMSCRIPTEN)
-include(CMakePushCheckState)
+  # https://github.com/emscripten-core/emscripten/issues/15377#issuecomment-1285167486
+  add_link_options(-lnodefs.js -lnoderawfs.js)
+  add_link_options(-s ALLOW_MEMORY_GROWTH)
+endif()
 
 if(NOT USE_SIMD_FALLBACK)
+  cmake_push_check_state()
+  list(APPEND CMAKE_REQUIRED_FLAGS -msimd128)
+  check_include_file_cxx("wasm_simd128.h" HAS_WASM_SIMD)
+  if(HAS_WASM_SIMD)
+    add_compile_options(-msimd128)
+    add_compile_definitions(HAS_WASM_SIMD)
+  endif()
+  cmake_pop_check_state()
+
   cmake_push_check_state()
   list(APPEND CMAKE_REQUIRED_FLAGS -mavx)
   check_include_file_cxx("immintrin.h" HAS_AVX)
@@ -64,13 +100,13 @@ endif()
 
 set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "")
 
-add_library(${PROJECT_NAME}_object OBJECT ConflictSet.cpp)
+add_library(${PROJECT_NAME}-object OBJECT ConflictSet.cpp)
-target_compile_options(${PROJECT_NAME}_object PRIVATE -fPIC -fno-exceptions
+target_compile_options(${PROJECT_NAME}-object PRIVATE -fno-exceptions
                                                       -fvisibility=hidden)
-target_include_directories(${PROJECT_NAME}_object
+target_include_directories(${PROJECT_NAME}-object
                            PRIVATE ${CMAKE_SOURCE_DIR}/include)
 
-add_library(${PROJECT_NAME} SHARED $<TARGET_OBJECTS:${PROJECT_NAME}_object>)
+add_library(${PROJECT_NAME} SHARED $<TARGET_OBJECTS:${PROJECT_NAME}-object>)
 set_target_properties(
   ${PROJECT_NAME} PROPERTIES LIBRARY_OUTPUT_DIRECTORY
                              "${CMAKE_BINARY_DIR}/radix_tree")
@@ -78,24 +114,31 @@ if(NOT CMAKE_BUILD_TYPE STREQUAL Debug)
   set_target_properties(${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE C)
 endif()
 
-if(NOT APPLE)
+if(HAS_VERSION_SCRIPT)
   target_link_options(${PROJECT_NAME} PRIVATE
                       LINKER:--version-script=${CMAKE_SOURCE_DIR}/linker.map)
 endif()
 
 add_library(${PROJECT_NAME}-static STATIC
-            $<TARGET_OBJECTS:${PROJECT_NAME}_object>)
+            $<TARGET_OBJECTS:${PROJECT_NAME}-object>)
 if(NOT CMAKE_BUILD_TYPE STREQUAL Debug)
   set_target_properties(${PROJECT_NAME}-static PROPERTIES LINKER_LANGUAGE C)
 endif()
 
-if(NOT APPLE AND CMAKE_OBJCOPY)
+if(APPLE)
   add_custom_command(
-    TARGET conflict-set-static
+    TARGET ${PROJECT_NAME}-static
+    PRE_BUILD
+    COMMAND ${CMAKE_SOURCE_DIR}/privatize_symbols_macos.sh
+            $<TARGET_OBJECTS:${PROJECT_NAME}-object>)
+else()
+  add_custom_command(
+    TARGET ${PROJECT_NAME}-static
     POST_BUILD
     COMMAND
       ${CMAKE_OBJCOPY} --keep-global-symbols=${CMAKE_SOURCE_DIR}/symbols.txt
-      $<TARGET_FILE:${PROJECT_NAME}-static>)
+      $<TARGET_FILE:${PROJECT_NAME}-static> || echo
+      "Proceeding with all symbols global in static library")
 endif()
 
 set(TEST_FLAGS -Wall -Wextra -Wunreachable-code -Wpedantic -UNDEBUG)
@@ -104,30 +147,51 @@ include(CTest)
 
 if(BUILD_TESTING)
 
+  # corpus tests, which are tests curated by libfuzzer. The goal is to get broad
+  # coverage with a small number of tests.
+
+  file(GLOB CORPUS_TESTS ${CMAKE_SOURCE_DIR}/corpus/*)
+
+  # extra testing that relies on shared libraries, which aren't available with
+  # wasm
+  if(NOT WASM)
     # Shared library version of FoundationDB's skip list implementation
     add_library(skip_list SHARED SkipList.cpp)
-  target_compile_options(skip_list PRIVATE -fPIC -fno-exceptions
+    target_compile_options(skip_list PRIVATE -fno-exceptions
                                              -fvisibility=hidden)
     target_include_directories(skip_list PUBLIC ${CMAKE_SOURCE_DIR}/include)
     set_target_properties(skip_list PROPERTIES LIBRARY_OUTPUT_DIRECTORY
                                                "${CMAKE_BINARY_DIR}/skip_list")
     set_target_properties(skip_list PROPERTIES OUTPUT_NAME ${PROJECT_NAME})
-  set_target_properties(skip_list PROPERTIES VERSION ${PROJECT_VERSION}
+    set_target_properties(
-                                             SOVERSION ${PROJECT_VERSION_MAJOR})
+      skip_list PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION
+                                                      ${PROJECT_VERSION_MAJOR})
 
     # Shared library version of a std::unordered_map-based conflict set (point
     # queries only)
     add_library(hash_table SHARED HashTable.cpp)
-  target_compile_options(hash_table PRIVATE -fPIC -fno-exceptions
+    target_compile_options(hash_table PRIVATE -fno-exceptions
                                               -fvisibility=hidden)
     target_include_directories(hash_table PUBLIC ${CMAKE_SOURCE_DIR}/include)
-  set_target_properties(hash_table PROPERTIES LIBRARY_OUTPUT_DIRECTORY
+    set_target_properties(
+      hash_table PROPERTIES LIBRARY_OUTPUT_DIRECTORY
                             "${CMAKE_BINARY_DIR}/hash_table")
     set_target_properties(hash_table PROPERTIES OUTPUT_NAME ${PROJECT_NAME})
     set_target_properties(
       hash_table PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION
                                                        ${PROJECT_VERSION_MAJOR})
 
+    add_executable(driver_skip_list TestDriver.cpp)
+    target_compile_options(driver_skip_list PRIVATE ${TEST_FLAGS})
+    target_link_libraries(driver_skip_list PRIVATE skip_list)
+
+    foreach(TEST ${CORPUS_TESTS})
+      get_filename_component(hash ${TEST} NAME)
+      add_test(NAME skip_list_${hash} COMMAND driver_skip_list ${TEST})
+    endforeach()
+  endif()
+
+  # ad hoc testing
   add_executable(conflict_set_main ConflictSet.cpp)
   target_include_directories(conflict_set_main
                              PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
@@ -154,10 +218,7 @@ if(BUILD_TESTING)
     endif()
   endif()
 
-  # corpus tests
+  # whitebox tests
-
-  file(GLOB CORPUS_TESTS ${CMAKE_SOURCE_DIR}/corpus/*)
-
   add_executable(fuzz_driver ConflictSet.cpp FuzzTestDriver.cpp)
   target_compile_options(fuzz_driver PRIVATE ${TEST_FLAGS})
   if(NOT CMAKE_CROSSCOMPILING)
@@ -172,8 +233,7 @@ if(BUILD_TESTING)
     add_test(NAME conflict_set_fuzz_${hash} COMMAND fuzz_driver ${TEST})
   endforeach()
 
-  # tsan
+  # tsan tests
-
   if(NOT CMAKE_CROSSCOMPILING AND NOT CMAKE_BUILD_TYPE STREQUAL Debug)
     add_executable(tsan_driver ConflictSet.cpp FuzzTestDriver.cpp)
     target_compile_options(tsan_driver PRIVATE ${TEST_FLAGS} -fsanitize=thread)
@@ -187,24 +247,26 @@ if(BUILD_TESTING)
     endforeach()
   endif()
 
+  # blackbox tests
   add_executable(driver TestDriver.cpp)
   target_compile_options(driver PRIVATE ${TEST_FLAGS})
   target_link_libraries(driver PRIVATE ${PROJECT_NAME})
+  foreach(TEST ${CORPUS_TESTS})
+    get_filename_component(hash ${TEST} NAME)
+    add_test(NAME conflict_set_blackbox_${hash} COMMAND driver ${TEST})
+  endforeach()
 
+  # scripted tests. Written manually to fill in anything libfuzzer couldn't
+  # find.
   add_executable(script_test ScriptTest.cpp)
   target_compile_options(script_test PRIVATE ${TEST_FLAGS})
   target_link_libraries(script_test PRIVATE ${PROJECT_NAME})
-
   file(GLOB SCRIPT_TESTS ${CMAKE_SOURCE_DIR}/script_tests/*)
   foreach(TEST ${SCRIPT_TESTS})
     get_filename_component(name ${TEST} NAME)
     add_test(NAME conflict_set_script_${name} COMMAND script_test ${TEST})
   endforeach()
 
-  add_executable(driver_skip_list TestDriver.cpp)
-  target_compile_options(driver_skip_list PRIVATE ${TEST_FLAGS})
-  target_link_libraries(driver_skip_list PRIVATE skip_list)
-
   find_program(VALGRIND_EXE valgrind)
   if(VALGRIND_EXE AND NOT CMAKE_CROSSCOMPILING)
     add_test(NAME conflict_set_blackbox_valgrind
@@ -212,12 +274,6 @@ if(BUILD_TESTING)
                      $<TARGET_FILE:driver> ${CORPUS_TESTS})
   endif()
 
-  foreach(TEST ${CORPUS_TESTS})
-    get_filename_component(hash ${TEST} NAME)
-    add_test(NAME conflict_set_blackbox_${hash} COMMAND driver ${TEST})
-    add_test(NAME skip_list_${hash} COMMAND driver_skip_list ${TEST})
-  endforeach()
-
   # api smoke tests
 
   # c90
@@ -238,7 +294,10 @@ if(BUILD_TESTING)
                         PROPERTIES CXX_STANDARD_REQUIRED ON)
   add_test(NAME conflict_set_cxx_api_test COMMAND conflict_set_cxx_api_test)
 
-  if(NOT APPLE AND NOT CMAKE_BUILD_TYPE STREQUAL Debug)
+  # symbol visibility tests
+  if(NOT WASM
+     AND NOT APPLE
+     AND NOT CMAKE_BUILD_TYPE STREQUAL Debug)
     add_test(
       NAME conflict_set_shared_symbols
       COMMAND ${CMAKE_SOURCE_DIR}/test_symbols.sh
@@ -251,15 +310,14 @@ if(BUILD_TESTING)
   endif()
 
   # bench
-
   add_executable(conflict_set_bench Bench.cpp)
   target_link_libraries(conflict_set_bench PRIVATE ${PROJECT_NAME})
   set_target_properties(conflict_set_bench PROPERTIES SKIP_BUILD_RPATH ON)
-
   add_executable(real_data_bench RealDataBench.cpp)
   target_link_libraries(real_data_bench PRIVATE ${PROJECT_NAME})
   set_target_properties(real_data_bench PROPERTIES SKIP_BUILD_RPATH ON)
 endif()
+
 # packaging
 
 set(CPACK_PACKAGE_CONTACT andrew@weaselab.dev)
@@ -297,12 +355,12 @@ set_target_properties(
 
 install(
   TARGETS ${PROJECT_NAME} ${PROJECT_NAME}-static
-  EXPORT conflict-setConfig
+  EXPORT ${PROJECT_NAME}Config
   ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
   LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
   RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 install(DIRECTORY include/
         DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME})
 
-install(EXPORT conflict-setConfig
+install(EXPORT ${PROJECT_NAME}Config
-        DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/conflict-set/cmake)
+        DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/cmake)

Internal.h

@@ -154,6 +154,7 @@ inline void *operator new[](size_t size, std::align_val_t align,
 
 /// align must be a power of two
 template <class T> T *align_up(T *t, size_t align) {
+  assert(std::popcount(align) == 1);
   auto unaligned = uintptr_t(t);
   auto aligned = (unaligned + align - 1) & ~(align - 1);
   return reinterpret_cast<T *>(reinterpret_cast<char *>(t) + aligned -
@@ -162,6 +163,7 @@ template <class T> T *align_up(T *t, size_t align) {
 
 /// align must be a power of two
 constexpr inline int align_up(uint32_t unaligned, uint32_t align) {
+  assert(std::popcount(align) == 1);
   return (unaligned + align - 1) & ~(align - 1);
 }
 
@@ -177,12 +179,10 @@ struct Arena::ArenaImpl {
   uint8_t *begin() { return reinterpret_cast<uint8_t *>(this + 1); }
 };
 
-static_assert(sizeof(Arena::ArenaImpl) == 16);
-static_assert(alignof(Arena::ArenaImpl) == 8);
-
 inline Arena::Arena(int initialSize) : impl(nullptr) {
   if (initialSize > 0) {
-    auto allocationSize = align_up(initialSize + sizeof(ArenaImpl), 16);
+    auto allocationSize =
+        align_up(initialSize + sizeof(ArenaImpl), alignof(ArenaImpl));
     impl = (Arena::ArenaImpl *)safe_malloc(allocationSize);
     impl->prev = nullptr;
     impl->capacity = allocationSize - sizeof(ArenaImpl);
@@ -218,7 +218,7 @@ inline void *operator new(size_t size, std::align_val_t align, Arena &arena) {
                           (arena.impl ? std::max<int>(sizeof(Arena::ArenaImpl),
                                                       arena.impl->capacity * 2)
                                       : 0)),
-        16);
+        alignof(Arena::ArenaImpl));
     auto *impl = (Arena::ArenaImpl *)safe_malloc(allocationSize);
     impl->prev = arena.impl;
     impl->capacity = allocationSize - sizeof(Arena::ArenaImpl);

RealDataBench.cpp

@@ -1,8 +1,11 @@
 #include <ConflictSet.h>
 
+#include <cerrno>
 #include <chrono>
+#include <cstdio>
 #include <cstring>
 #include <fcntl.h>
+#include <string_view>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <unistd.h>

privatize_symbols_macos.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+# This has the effect of making visibility=hidden symbols private in object files
+for obj in "$@" ; do
+  ld -r $obj -o $obj.tmp && mv $obj.tmp $obj
+done