conflict-set/CMakeLists.txt

cmake_minimum_required(VERSION 3.18)
project(
  conflict_set
  VERSION 0.0.1
  DESCRIPTION
    "A data structure for detecting mvcc read-write conflicts in a keyspace of lexicographically-ordered byte sequences."
  LANGUAGES C CXX)
set(CMAKE_CXX_STANDARD 20)

set(DEFAULT_BUILD_TYPE "Release")

if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
  message(
    STATUS
      "Setting build type to '${DEFAULT_BUILD_TYPE}' as none was specified.")
  set(CMAKE_BUILD_TYPE
      "${DEFAULT_BUILD_TYPE}"
      CACHE STRING "Choose the type of build." FORCE)
  # Set the possible values of build type for cmake-gui
  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release"
                                               "MinSizeRel" "RelWithDebInfo")
endif()

add_compile_options(-fdata-sections -ffunction-sections
                    -Wno-return-stack-address)
if(APPLE)
  add_link_options(-Wl,-dead_strip)
else()
  add_link_options(-Wl,--gc-sections)
endif()

include(CheckIncludeFileCXX)
include(CMakePushCheckState)

cmake_push_check_state()
list(APPEND CMAKE_REQUIRED_FLAGS -mavx)
check_include_file_cxx("immintrin.h" HAS_AVX)
if(HAS_AVX)
  add_compile_options(-mavx)
  add_compile_definitions(HAS_AVX)
endif()
cmake_pop_check_state()

check_include_file_cxx("arm_neon.h" HAS_ARM_NEON)
if(HAS_ARM_NEON)
  add_compile_definitions(HAS_ARM_NEON)
endif()

add_library(${PROJECT_NAME} SHARED ConflictSet.cpp)
target_compile_options(${PROJECT_NAME} PRIVATE -fPIC -fno-exceptions
                                               -fvisibility=hidden)
target_link_options(${PROJECT_NAME} PRIVATE $<$<NOT:$<CONFIG:Debug>>:
                    -nodefaultlibs -lc>)

if(NOT APPLE)
  target_link_options(${PROJECT_NAME} PRIVATE
                      LINKER:--version-script=${CMAKE_SOURCE_DIR}/linker.map)
endif()

add_library(${PROJECT_NAME}_static STATIC ConflictSet.cpp)
target_compile_options(conflict_set_static PRIVATE -fno-exceptions
                                                   -fvisibility=hidden)
if(NOT APPLE AND CMAKE_OBJCOPY)
  add_custom_command(
    TARGET conflict_set_static
    POST_BUILD
    COMMAND
      ${CMAKE_OBJCOPY} --keep-global-symbols=${CMAKE_SOURCE_DIR}/symbols.txt
      $<TARGET_FILE:${PROJECT_NAME}_static>)
endif()

set(TEST_FLAGS -Wall -Wextra -Wpedantic -Wunreachable-code -UNDEBUG)

include(CTest)

add_executable(conflict_set_main ConflictSet.cpp)
target_include_directories(conflict_set_main
                           PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
target_compile_definitions(conflict_set_main PRIVATE ENABLE_MAIN)

# libfuzzer target, to generate/manage corpus
set(FUZZ_FLAGS "-fsanitize=fuzzer-no-link,address,undefined")
include(CheckCXXCompilerFlag)
cmake_push_check_state()
set(CMAKE_REQUIRED_LINK_OPTIONS -fsanitize=fuzzer)
check_cxx_compiler_flag(-fsanitize=fuzzer HAS_LIB_FUZZER)
cmake_pop_check_state()

if(HAS_LIB_FUZZER)
  add_executable(conflict_set_fuzz_test ConflictSet.cpp)
  target_include_directories(conflict_set_fuzz_test
                             PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
  target_compile_definitions(conflict_set_fuzz_test PRIVATE ENABLE_FUZZ)
  target_compile_options(conflict_set_fuzz_test PRIVATE ${TEST_FLAGS})
  target_compile_options(conflict_set_fuzz_test PRIVATE ${FUZZ_FLAGS})
  target_link_options(conflict_set_fuzz_test PRIVATE ${FUZZ_FLAGS}
                      -fsanitize=fuzzer)
endif()

# corpus tests

file(GLOB CORPUS_TESTS ${CMAKE_SOURCE_DIR}/corpus/*)

add_executable(conflict_set_test_driver ConflictSet.cpp TestDriver.cpp)
target_compile_options(conflict_set_test_driver PRIVATE ${TEST_FLAGS})
target_compile_definitions(conflict_set_test_driver PRIVATE ENABLE_FUZZ)
target_include_directories(conflict_set_test_driver
                           PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
foreach(TEST ${CORPUS_TESTS})
  get_filename_component(hash ${TEST} NAME)
  add_test(NAME conflict_set_corpus_${hash} COMMAND conflict_set_test_driver
                                                    ${TEST})
endforeach()

# api smoke tests

# c90
add_executable(conflict_set_c_api_test conflict_set_c_api_test.c)
target_compile_options(conflict_set_c_api_test PRIVATE ${TEST_FLAGS})
target_link_libraries(conflict_set_c_api_test PRIVATE ${PROJECT_NAME})
set_property(TARGET conflict_set_c_api_test PROPERTY C_STANDARD 90)
set_property(TARGET conflict_set_c_api_test PROPERTY C_STANDARD_REQUIRED ON)
add_test(NAME conflict_set_c_api_test COMMAND conflict_set_c_api_test)

# c++98
add_executable(conflict_set_cxx_api_test conflict_set_cxx_api_test.cpp)
target_compile_options(conflict_set_cxx_api_test PRIVATE ${TEST_FLAGS})
target_link_libraries(conflict_set_cxx_api_test PRIVATE ${PROJECT_NAME})
set_property(TARGET conflict_set_c_api_test PROPERTY CXX_STANDARD 98)
set_property(TARGET conflict_set_c_api_test PROPERTY CXX_STANDARD_REQUIRED ON)
add_test(NAME conflict_set_cxx_api_test COMMAND conflict_set_cxx_api_test)

add_test(NAME conflict_set_shared_symbols
         COMMAND ${CMAKE_SOURCE_DIR}/test_symbols.sh
                 $<TARGET_FILE:${PROJECT_NAME}> ${CMAKE_SOURCE_DIR}/symbols.txt)
add_test(
  NAME conflict_set_static_symbols
  COMMAND ${CMAKE_SOURCE_DIR}/test_symbols.sh
          $<TARGET_FILE:${PROJECT_NAME}_static> ${CMAKE_SOURCE_DIR}/symbols.txt)

# packaging

set(CPACK_PACKAGE_CONTACT andrew@weaselab.dev)
set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)
include(CPack)

include(GNUInstallDirs)

target_include_directories(
  ${PROJECT_NAME}
  PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
         $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}>)

target_include_directories(
  ${PROJECT_NAME}_static
  PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
         $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}>)

set_target_properties(
  ${PROJECT_NAME} PROPERTIES VERSION ${PROJECT_VERSION}
                             SOVERSION ${PROJECT_VERSION_MAJOR})

install(
  TARGETS ${PROJECT_NAME} ${PROJECT_NAME}_static
  EXPORT ConflictSetConfig
  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 ConflictSetConfig
        DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/ConflictSet/cmake)