8f0cd5cf7b
It is quite difficult to maintain current Windows CI, because it uses pre-compiled dependencies stored on wolt.com server and there is low chance to find someone who is able to update it.
887 lines
36 KiB
CMake
887 lines
36 KiB
CMake
cmake_minimum_required(VERSION 3.2)
|
|
|
|
set(CMAKE_CXX_STANDARD 17)
|
|
set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
|
|
|
|
if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR AND NOT MSVC_IDE)
|
|
message(FATAL_ERROR "In-source builds are not allowed.
|
|
Please create a directory and run cmake from there, passing the path to this source directory as the last argument.
|
|
This process created the file `CMakeCache.txt' and the directory `CMakeFiles'. Please delete them.")
|
|
endif()
|
|
|
|
# detect if this is included as subproject and if so expose
|
|
# some variables to its parent scope
|
|
get_directory_property(BUILD_AS_SUBPROJECT PARENT_DIRECTORY)
|
|
if(BUILD_AS_SUBPROJECT)
|
|
message(STATUS "Building libosrm as subproject.")
|
|
endif()
|
|
|
|
# set OSRM_BUILD_DIR location (might be used in various scripts)
|
|
if (NOT WIN32 AND NOT DEFINED ENV{OSRM_BUILD_DIR})
|
|
set(ENV{OSRM_BUILD_DIR} ${CMAKE_CURRENT_BINARY_DIR})
|
|
endif()
|
|
|
|
option(ENABLE_CONAN "Use conan for dependencies" OFF)
|
|
option(ENABLE_CCACHE "Speed up incremental rebuilds via ccache" ON)
|
|
option(BUILD_TOOLS "Build OSRM tools" OFF)
|
|
option(BUILD_PACKAGE "Build OSRM package" OFF)
|
|
option(BUILD_ROUTED "Build osrm-routed HTTP server" ON)
|
|
option(ENABLE_ASSERTIONS "Use assertions in release mode" OFF)
|
|
option(ENABLE_DEBUG_LOGGING "Use debug logging in release mode" OFF)
|
|
option(ENABLE_COVERAGE "Build with coverage instrumentalisation" OFF)
|
|
option(ENABLE_SANITIZER "Use memory sanitizer for Debug build" OFF)
|
|
option(ENABLE_LTO "Use LTO if available" OFF)
|
|
option(ENABLE_FUZZING "Fuzz testing using LLVM's libFuzzer" OFF)
|
|
option(ENABLE_GOLD_LINKER "Use GNU gold linker if available" ON)
|
|
option(ENABLE_NODE_BINDINGS "Build NodeJs bindings" OFF)
|
|
option(ENABLE_GLIBC_WORKAROUND "Workaround GLIBC symbol exports" OFF)
|
|
option(ENABLE_CLANG_TIDY "Enables clang-tidy checks" OFF)
|
|
|
|
if (ENABLE_CLANG_TIDY)
|
|
find_program(CLANG_TIDY_COMMAND NAMES clang-tidy)
|
|
if(NOT CLANG_TIDY_COMMAND)
|
|
message(FATAL_ERROR "ENABLE_CLANG_TIDY is ON but clang-tidy is not found!")
|
|
else()
|
|
message(STATUS "Found clang-tidy at ${CLANG_TIDY_COMMAND}")
|
|
set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND};--warnings-as-errors=*")
|
|
endif()
|
|
endif()
|
|
|
|
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
|
|
|
|
# be compatible with version handling before cmake 3.x
|
|
if (POLICY CMP0048)
|
|
cmake_policy(SET CMP0048 OLD)
|
|
endif()
|
|
if (POLICY CMP0057)
|
|
cmake_policy(SET CMP0057 NEW)
|
|
endif()
|
|
if (POLICY CMP0074)
|
|
cmake_policy(SET CMP0074 NEW)
|
|
endif()
|
|
project(OSRM C CXX)
|
|
|
|
include(JSONParser)
|
|
file(READ "package.json" packagejsonraw)
|
|
sbeParseJson(packagejson packagejsonraw)
|
|
|
|
if (packagejson.version MATCHES "^([0-9]+)\.([0-9]+)\.([0-9]+)")
|
|
set(OSRM_VERSION_MAJOR ${CMAKE_MATCH_1})
|
|
set(OSRM_VERSION_MINOR ${CMAKE_MATCH_2})
|
|
set(OSRM_VERSION_PATCH ${CMAKE_MATCH_3})
|
|
|
|
set(OSRM_VERSION "${OSRM_VERSION_MAJOR}.${OSRM_VERSION_MINOR}.${OSRM_VERSION_PATCH}")
|
|
else()
|
|
message(FATAL_ERROR "Version from package.json cannot be parsed, expected semver compatible X.Y.Z, but found ${packagejson.version}")
|
|
endif()
|
|
|
|
if (MSVC)
|
|
add_definitions("-DOSRM_PROJECT_DIR=\"${CMAKE_CURRENT_SOURCE_DIR}\"")
|
|
else()
|
|
add_definitions(-DOSRM_PROJECT_DIR="${CMAKE_CURRENT_SOURCE_DIR}")
|
|
endif()
|
|
|
|
# these two functions build up custom variables:
|
|
# DEPENDENCIES_INCLUDE_DIRS and OSRM_DEFINES
|
|
# These variables we want to pass to
|
|
# include_directories and add_definitions for both
|
|
# this build and for sharing externally via pkg-config
|
|
|
|
function(add_dependency_includes)
|
|
if(${ARGC} GREATER 0)
|
|
list(APPEND DEPENDENCIES_INCLUDE_DIRS "${ARGV}")
|
|
set(DEPENDENCIES_INCLUDE_DIRS "${DEPENDENCIES_INCLUDE_DIRS}" PARENT_SCOPE)
|
|
endif()
|
|
endfunction(add_dependency_includes)
|
|
|
|
function(add_dependency_defines defines)
|
|
list(APPEND OSRM_DEFINES "${defines}")
|
|
set(OSRM_DEFINES "${OSRM_DEFINES}" PARENT_SCOPE)
|
|
endfunction(add_dependency_defines)
|
|
|
|
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
|
|
include(CheckCXXCompilerFlag)
|
|
include(FindPackageHandleStandardArgs)
|
|
include(GNUInstallDirs)
|
|
|
|
set(bitness 32)
|
|
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
|
|
set(bitness 64)
|
|
message(STATUS "Building on a 64 bit system")
|
|
else()
|
|
message(STATUS "Building on a 32 bit system")
|
|
endif()
|
|
|
|
if(WIN32 AND MSVC_VERSION LESS 1900)
|
|
message(FATAL_ERROR "Building with Microsoft compiler needs Latest Visual Studio 2015 (Community or better)")
|
|
endif()
|
|
|
|
# Strictly require GCC>=5.0 and Clang>=3.4 - GCC 4.8 is already too old for C++14.
|
|
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
|
|
if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
|
|
message(FATAL_ERROR "GCC>=5.0 required. In case you are on Ubuntu upgrade via ppa:ubuntu-toolchain-r/test")
|
|
endif()
|
|
elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
|
|
if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.4)
|
|
message(FATAL_ERROR "Clang>=3.4 required. In case you are on Ubuntu upgrade via http://apt.llvm.org")
|
|
endif()
|
|
endif()
|
|
|
|
include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR}/include/)
|
|
include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/include/)
|
|
include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/sol2-3.3.0/include)
|
|
include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/variant/include)
|
|
|
|
set(BOOST_COMPONENTS date_time chrono filesystem iostreams program_options regex system thread unit_test_framework)
|
|
|
|
configure_file(
|
|
${CMAKE_CURRENT_SOURCE_DIR}/include/util/version.hpp.in
|
|
${CMAKE_CURRENT_BINARY_DIR}/include/util/version.hpp
|
|
)
|
|
file(GLOB UtilGlob src/util/*.cpp src/util/*/*.cpp)
|
|
file(GLOB ExtractorGlob src/extractor/*.cpp src/extractor/*/*.cpp)
|
|
file(GLOB GuidanceGlob src/guidance/*.cpp src/extractor/intersection/*.cpp)
|
|
file(GLOB PartitionerGlob src/partitioner/*.cpp)
|
|
file(GLOB CustomizerGlob src/customize/*.cpp)
|
|
file(GLOB ContractorGlob src/contractor/*.cpp)
|
|
file(GLOB UpdaterGlob src/updater/*.cpp)
|
|
file(GLOB StorageGlob src/storage/*.cpp)
|
|
file(GLOB ServerGlob src/server/*.cpp src/server/**/*.cpp)
|
|
file(GLOB EngineGlob src/engine/*.cpp src/engine/**/*.cpp)
|
|
file(GLOB ErrorcodesGlob src/osrm/errorcodes.cpp)
|
|
|
|
add_library(UTIL OBJECT ${UtilGlob})
|
|
add_library(EXTRACTOR OBJECT ${ExtractorGlob})
|
|
add_library(GUIDANCE OBJECT ${GuidanceGlob})
|
|
add_library(PARTITIONER OBJECT ${PartitionerGlob})
|
|
add_library(CUSTOMIZER OBJECT ${CustomizerGlob})
|
|
add_library(CONTRACTOR OBJECT ${ContractorGlob})
|
|
add_library(UPDATER OBJECT ${UpdaterGlob})
|
|
add_library(STORAGE OBJECT ${StorageGlob})
|
|
add_library(ENGINE OBJECT ${EngineGlob})
|
|
|
|
if (BUILD_ROUTED)
|
|
add_library(SERVER OBJECT ${ServerGlob})
|
|
add_executable(osrm-routed src/tools/routed.cpp $<TARGET_OBJECTS:SERVER> $<TARGET_OBJECTS:UTIL>)
|
|
endif()
|
|
|
|
set_target_properties(UTIL PROPERTIES LINKER_LANGUAGE CXX)
|
|
|
|
add_executable(osrm-extract src/tools/extract.cpp)
|
|
add_executable(osrm-partition src/tools/partition.cpp)
|
|
add_executable(osrm-customize src/tools/customize.cpp)
|
|
add_executable(osrm-contract src/tools/contract.cpp)
|
|
add_executable(osrm-datastore src/tools/store.cpp $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
|
|
add_library(osrm src/osrm/osrm.cpp $<TARGET_OBJECTS:ENGINE> $<TARGET_OBJECTS:STORAGE> $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
|
|
add_library(osrm_contract src/osrm/contractor.cpp $<TARGET_OBJECTS:CONTRACTOR> $<TARGET_OBJECTS:UTIL>)
|
|
add_library(osrm_extract src/osrm/extractor.cpp $<TARGET_OBJECTS:EXTRACTOR> $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
|
|
add_library(osrm_guidance $<TARGET_OBJECTS:GUIDANCE> $<TARGET_OBJECTS:UTIL>)
|
|
add_library(osrm_partition src/osrm/partitioner.cpp $<TARGET_OBJECTS:PARTITIONER> $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
|
|
add_library(osrm_customize src/osrm/customizer.cpp $<TARGET_OBJECTS:CUSTOMIZER> $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
|
|
add_library(osrm_update $<TARGET_OBJECTS:UPDATER> $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
|
|
add_library(osrm_store $<TARGET_OBJECTS:STORAGE> $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
|
|
|
|
if(ENABLE_GOLD_LINKER)
|
|
execute_process(COMMAND ${CMAKE_C_COMPILER} -fuse-ld=gold -Wl,--version ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
|
|
if("${LD_VERSION}" MATCHES "GNU gold")
|
|
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fuse-ld=gold -Wl,--disable-new-dtags")
|
|
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fuse-ld=gold -Wl,--disable-new-dtags")
|
|
set(OSRM_LDFLAGS "${OSRM_LDFLAGS} -fuse-ld=gold -Wl,--disable-new-dtags")
|
|
message(STATUS "Using GNU gold as linker.")
|
|
|
|
# Issue 2785: check gold binutils version and don't use gc-sections for versions prior 2.25
|
|
string(REGEX REPLACE ".*\\(GNU Binutils[^\\)0-9]+([0-9]+\\.[0-9]+)[^\\)]*\\).*" "\\1" GOLD_BINUTILS_VERSION "${LD_VERSION}")
|
|
if ("${GOLD_BINUTILS_VERSION}" VERSION_LESS "2.26")
|
|
message(STATUS "Disabling gc-sections on gold binutils < 2.26, see: https://sourceware.org/bugzilla/show_bug.cgi?id=17639")
|
|
set(LD_AVOID_GC_SECTIONS TRUE)
|
|
endif()
|
|
else()
|
|
message(WARNING "GNU gold linker isn't available.")
|
|
set(ENABLE_GOLD_LINKER OFF)
|
|
endif()
|
|
endif()
|
|
|
|
# Explicitly set the build type to Release if no other type is specified
|
|
# on the command line. Without this, cmake defaults to an unoptimized,
|
|
# non-debug build, which almost nobody wants.
|
|
if(NOT CMAKE_BUILD_TYPE)
|
|
message(STATUS "No build type specified, defaulting to Release")
|
|
set(CMAKE_BUILD_TYPE Release)
|
|
endif()
|
|
|
|
if(CMAKE_BUILD_TYPE MATCHES Debug)
|
|
message(STATUS "Configuring OSRM in debug mode")
|
|
elseif(CMAKE_BUILD_TYPE MATCHES Release)
|
|
message(STATUS "Configuring OSRM in release mode")
|
|
elseif(CMAKE_BUILD_TYPE MATCHES RelWithDebInfo)
|
|
message(STATUS "Configuring OSRM in release mode with debug flags")
|
|
elseif(CMAKE_BUILD_TYPE MATCHES MinRelSize)
|
|
message(STATUS "Configuring OSRM in release mode with minimized size")
|
|
else()
|
|
message(STATUS "Unrecognized build type - will use cmake defaults")
|
|
endif()
|
|
|
|
# Additional logic for the different build types
|
|
if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo)
|
|
message(STATUS "Configuring debug mode flags")
|
|
set(ENABLE_ASSERTIONS ON)
|
|
set(ENABLE_DEBUG_LOGGING ON)
|
|
endif()
|
|
|
|
if(NOT CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
|
|
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -fno-inline -fno-omit-frame-pointer")
|
|
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-inline -fno-omit-frame-pointer")
|
|
endif()
|
|
|
|
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
|
|
set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -ggdb")
|
|
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Og -ggdb")
|
|
endif()
|
|
|
|
|
|
if(CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo)
|
|
message(STATUS "Configuring release mode optimizations")
|
|
# Check if LTO is available
|
|
check_cxx_compiler_flag("-Wl,-flto" LTO_AVAILABLE)
|
|
|
|
if(ENABLE_LTO AND LTO_AVAILABLE)
|
|
set(OLD_CXX_FLAGS ${CMAKE_CXX_FLAGS})
|
|
# GCC in addition allows parallelizing LTO
|
|
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
|
|
include(ProcessorCount)
|
|
ProcessorCount(NPROC)
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -flto=${NPROC}")
|
|
else()
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -flto")
|
|
endif()
|
|
set(CHECK_LTO_SRC "int main(){return 0;}")
|
|
check_cxx_source_compiles("${CHECK_LTO_SRC}" LTO_WORKS)
|
|
if(LTO_WORKS)
|
|
message(STATUS "LTO working")
|
|
set(OSRM_CXXFLAGS "${OSRM_CXXFLAGS} -flto")
|
|
set(OSRM_LDFLAGS "${OSRM_LDFLAGS} -flto")
|
|
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -flto")
|
|
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -flto")
|
|
set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -flto")
|
|
else()
|
|
message(STATUS "LTO broken")
|
|
set(CMAKE_CXX_FLAGS "${OLD_CXX_FLAGS}")
|
|
set(ENABLE_LTO Off)
|
|
endif()
|
|
|
|
# Since gcc 4.9 the LTO format is non-standart ('slim'), so we need to use the build-in tools
|
|
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND NOT MINGW)
|
|
find_program(GCC_AR gcc-ar)
|
|
find_program(GCC_RANLIB gcc-ranlib)
|
|
if ("${GCC_AR}" STREQUAL "GCC_AR-NOTFOUND" OR "${GCC_RANLIB}" STREQUAL "GCC_RANLIB-NOTFOUND")
|
|
message(WARNING "GCC specific binutils not found. In case of linker issues export env vars: AR=gcc-ar, NM=gcc-nm, RANLIB=gcc-ranlib")
|
|
else()
|
|
message(STATUS "Using GCC specific binutils for LTO:")
|
|
message(STATUS " ${GCC_AR}")
|
|
message(STATUS " ${GCC_RANLIB}")
|
|
set(CMAKE_AR ${GCC_AR})
|
|
set(CMAKE_RANLIB ${GCC_RANLIB})
|
|
endif()
|
|
endif()
|
|
|
|
# Same for clang LTO requires their own toolchain
|
|
if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
|
|
find_program(LLVM_AR llvm-ar)
|
|
find_program(LLVM_RANLIB llvm-ranlib)
|
|
if ("${LLVM_AR}" STREQUAL "LLVM_AR-NOTFOUND" OR "${LLVM_RANLIB}" STREQUAL "LLVM_RANLIB-NOTFOUND")
|
|
message(WARNING "LLVM specific binutils not found.")
|
|
else()
|
|
message(STATUS "Using LLVM specific binutils for LTO:")
|
|
message(STATUS " ${LLVM_AR}")
|
|
message(STATUS " ${LLVM_RANLIB}")
|
|
set(CMAKE_AR ${LLVM_AR})
|
|
set(CMAKE_RANLIB ${LLVM_RANLIB})
|
|
endif()
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
# TODO: this was added for Mason, we are not sure if it is true after migration to Conan
|
|
if(UNIX AND NOT APPLE AND ENABLE_CONAN AND (LTO_WORKS OR ENABLE_GOLD_LINKER))
|
|
message(WARNING "ENABLE_CONAN and ENABLE_LTO/ENABLE_GOLD_LINKER may not work on all linux systems currently")
|
|
endif()
|
|
|
|
set(MAYBE_COVERAGE_LIBRARIES "")
|
|
if (ENABLE_COVERAGE)
|
|
if (NOT CMAKE_BUILD_TYPE MATCHES "Debug")
|
|
message(ERROR "ENABLE_COVERAGE=ON only make sense with a Debug build")
|
|
endif()
|
|
message(STATUS "Enabling coverage")
|
|
set(MAYBE_COVERAGE_LIBRARIES "-lgcov")
|
|
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -ftest-coverage -fprofile-arcs")
|
|
endif()
|
|
|
|
|
|
if (ENABLE_SANITIZER)
|
|
set(SANITIZER_FLAGS "-g -fsanitize=address -fsanitize-address-use-after-scope -fsanitize=undefined -fno-omit-frame-pointer")
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SANITIZER_FLAGS}")
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SANITIZER_FLAGS}")
|
|
set(OSRM_CXXFLAGS "${OSRM_CXXFLAGS} ${SANITIZER_FLAGS}")
|
|
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${SANITIZER_FLAGS}")
|
|
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${SANITIZER_FLAGS}")
|
|
endif()
|
|
|
|
# Configuring compilers
|
|
set(OSRM_WARNING_FLAGS "-Werror=all -Werror=extra -Werror=uninitialized -Werror=unreachable-code -Werror=unused-variable -Werror=unreachable-code -Wno-error=cpp -Wpedantic")
|
|
if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OSRM_WARNING_FLAGS} -Werror=strict-overflow=2 -Wno-error=unused-local-typedef -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fPIC -fcolor-diagnostics -ftemplate-depth=1024 -Wno-unused-command-line-argument")
|
|
elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
|
|
set(COLOR_FLAG "-fdiagnostics-color=auto")
|
|
check_cxx_compiler_flag("-fdiagnostics-color=auto" HAS_COLOR_FLAG)
|
|
if(NOT HAS_COLOR_FLAG)
|
|
set(COLOR_FLAG "")
|
|
endif()
|
|
# using GCC
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OSRM_WARNING_FLAGS} -Werror=strict-overflow=1 -Wno-error=maybe-uninitialized -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 ${COLOR_FLAG} -fPIC -ftemplate-depth=1024")
|
|
|
|
if(WIN32) # using mingw
|
|
add_dependency_defines(-DWIN32)
|
|
set(OPTIONAL_SOCKET_LIBS ws2_32 wsock32)
|
|
endif()
|
|
|
|
# -fpermissive is required for parallel_do Intel TBB internal issue with GCC < 5
|
|
# https://github.com/Project-OSRM/osrm-backend/pull/3603#issuecomment-277688589
|
|
if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
|
|
message(STATUS "Adding -fpermissive for GCC version < 5 bug (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51048). See #3603.")
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fpermissive")
|
|
endif()
|
|
|
|
elseif(CMAKE_CXX_COMPILER_ID MATCHES "Intel")
|
|
# using Intel C++
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-intel -wd10237 -Wall -ipo -fPIC")
|
|
elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
|
|
# using Visual Studio C++
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj") # avoid compiler error C1128 from scripting_environment_lua.cpp
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /DWIN32_LEAN_AND_MEAN") # avoid compiler error C2011 from dual #include of winsock.h and winsock2.h
|
|
add_dependency_defines(-DBOOST_LIB_DIAGNOSTIC)
|
|
add_dependency_defines(-D_CRT_SECURE_NO_WARNINGS)
|
|
add_dependency_defines(-DNOMINMAX) # avoid min and max macros that can break compilation
|
|
add_dependency_defines(-D_USE_MATH_DEFINES) #needed for M_PI with cmath.h
|
|
add_dependency_defines(-D_WIN32_WINNT=0x0501)
|
|
add_dependency_defines(-DXML_STATIC)
|
|
find_library(ws2_32_LIBRARY_PATH ws2_32)
|
|
target_link_libraries(osrm-extract wsock32 ws2_32)
|
|
endif()
|
|
|
|
# Configuring linker
|
|
execute_process(COMMAND ${CMAKE_CXX_COMPILER} "-Wl,--version" ERROR_QUIET OUTPUT_VARIABLE LINKER_VERSION)
|
|
# For ld.gold and ld.bfs (the GNU linkers) we optimize hard
|
|
if("${LINKER_VERSION}" MATCHES "GNU gold" OR "${LINKER_VERSION}" MATCHES "GNU ld")
|
|
message(STATUS "Setting linker optimizations")
|
|
if(NOT (CMAKE_CXX_COMPILER_ID MATCHES "MSVC" OR "${LD_AVOID_GC_SECTIONS}"))
|
|
# Tell compiler to put every function in separate section, linker can then match sections and functions
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffunction-sections -fdata-sections")
|
|
# Tell linker to do dead code and data eminination during link time discarding sections
|
|
set(LINKER_FLAGS "${LINKER_FLAGS} -Wl,--gc-sections")
|
|
endif()
|
|
# Default linker optimization flags
|
|
set(LINKER_FLAGS "${LINKER_FLAGS} -Wl,-O1 -Wl,--hash-style=gnu -Wl,--sort-common")
|
|
|
|
else()
|
|
message(STATUS "Using unknown linker, not setting linker optimizations")
|
|
endif ()
|
|
set(OSRM_LDFLAGS "${OSRM_LDFLAGS} ${LINKER_FLAGS}")
|
|
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${LINKER_FLAGS}")
|
|
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${LINKER_FLAGS}")
|
|
set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${LINKER_FLAGS}")
|
|
|
|
# Activate C++1y
|
|
if(NOT CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
|
|
set(OSRM_CXXFLAGS "${OSRM_CXXFLAGS} -std=c++17")
|
|
endif()
|
|
|
|
# Configuring other platform dependencies
|
|
if(APPLE)
|
|
execute_process(COMMAND xcrun --sdk macosx --show-sdk-path OUTPUT_VARIABLE CMAKE_OSX_SYSROOT OUTPUT_STRIP_TRAILING_WHITESPACE)
|
|
exec_program(uname ARGS -v OUTPUT_VARIABLE DARWIN_VERSION)
|
|
string(REGEX MATCH "[0-9]+" DARWIN_VERSION ${DARWIN_VERSION})
|
|
if(OSXLIBSTD)
|
|
message(STATUS "linking against ${OSXLIBSTD}")
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=${OSXLIBSTD}")
|
|
elseif(DARWIN_VERSION GREATER 12)
|
|
message(STATUS "linking against libc++")
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
|
|
endif()
|
|
endif()
|
|
|
|
if(UNIX AND NOT APPLE)
|
|
set(MAYBE_RT_LIBRARY -lrt)
|
|
endif()
|
|
|
|
find_package(Threads REQUIRED)
|
|
|
|
# Third-party libraries
|
|
set(RAPIDJSON_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/rapidjson/include")
|
|
include_directories(SYSTEM ${RAPIDJSON_INCLUDE_DIR})
|
|
|
|
set(MICROTAR_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/microtar/src")
|
|
include_directories(SYSTEM ${MICROTAR_INCLUDE_DIR})
|
|
|
|
set(MBXGEOM_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/geometry.hpp-0.9.2/include")
|
|
include_directories(SYSTEM ${MBXGEOM_INCLUDE_DIR})
|
|
set(CHEAPRULER_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/cheap-ruler-cpp-2.5.4/include")
|
|
include_directories(SYSTEM ${CHEAPRULER_INCLUDE_DIR})
|
|
|
|
add_library(MICROTAR OBJECT "${CMAKE_CURRENT_SOURCE_DIR}/third_party/microtar/src/microtar.c")
|
|
set_property(TARGET MICROTAR PROPERTY POSITION_INDEPENDENT_CODE ON)
|
|
|
|
set(PROTOZERO_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/protozero/include")
|
|
include_directories(SYSTEM ${PROTOZERO_INCLUDE_DIR})
|
|
|
|
set(VTZERO_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/vtzero/include")
|
|
include_directories(SYSTEM ${VTZERO_INCLUDE_DIR})
|
|
|
|
set(FLATBUFFERS_BUILD_TESTS OFF CACHE BOOL "Disable the build of Flatbuffers tests and samples.")
|
|
set(FLATBUFFERS_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/flatbuffers")
|
|
set(FLATBUFFERS_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/flatbuffers/include")
|
|
include_directories(SYSTEM ${FLATBUFFERS_INCLUDE_DIR})
|
|
add_subdirectory(${FLATBUFFERS_SRC_DIR}
|
|
${CMAKE_CURRENT_BINARY_DIR}/flatbuffers-build
|
|
EXCLUDE_FROM_ALL)
|
|
|
|
# see https://stackoverflow.com/questions/70898030/boost-link-error-using-conan-find-package
|
|
if (MSVC)
|
|
add_definitions(-DBOOST_ALL_NO_LIB)
|
|
endif()
|
|
|
|
if(ENABLE_CONAN)
|
|
message(STATUS "Installing dependencies via Conan")
|
|
|
|
# Conan will generate Find*.cmake files to build directory, so we use them with the highest priority
|
|
list(INSERT CMAKE_MODULE_PATH 0 ${CMAKE_BINARY_DIR})
|
|
list(INSERT CMAKE_PREFIX_PATH 0 ${CMAKE_BINARY_DIR})
|
|
|
|
include(${CMAKE_CURRENT_LIST_DIR}/cmake/conan.cmake)
|
|
|
|
set(CONAN_BOOST_VERSION 1.79.0)
|
|
set(CONAN_BZIP2_VERSION 1.0.8)
|
|
set(CONAN_EXPAT_VERSION 2.2.10)
|
|
set(CONAN_LUA_VERSION 5.4.4)
|
|
set(CONAN_TBB_VERSION 2020.3)
|
|
|
|
set(CONAN_SYSTEM_INCLUDES ON)
|
|
|
|
# TODO:
|
|
# if we link TBB dynamically osrm-extract.exe finishes on the first access to any TBB symbol
|
|
# with exit code = -1073741515, which means that program cannot load required DLL.
|
|
if (MSVC)
|
|
set(TBB_SHARED False)
|
|
else()
|
|
set(TBB_SHARED True)
|
|
endif()
|
|
|
|
conan_cmake_run(
|
|
REQUIRES
|
|
boost/${CONAN_BOOST_VERSION}
|
|
bzip2/${CONAN_BZIP2_VERSION}
|
|
expat/${CONAN_EXPAT_VERSION}
|
|
lua/${CONAN_LUA_VERSION}
|
|
tbb/${CONAN_TBB_VERSION}
|
|
BASIC_SETUP
|
|
BUILD missing
|
|
GENERATORS cmake_find_package
|
|
KEEP_RPATHS
|
|
NO_OUTPUT_DIRS
|
|
OPTIONS boost:filesystem_version=3 # https://stackoverflow.com/questions/73392648/error-with-boost-filesystem-version-in-cmake
|
|
tbb:shared=${TBB_SHARED}
|
|
)
|
|
|
|
add_dependency_includes(${CONAN_INCLUDE_DIRS_BOOST})
|
|
add_dependency_includes(${CONAN_INCLUDE_DIRS_BZIP2})
|
|
add_dependency_includes(${CONAN_INCLUDE_DIRS_EXPAT})
|
|
add_dependency_includes(${CONAN_INCLUDE_DIRS_LUA})
|
|
add_dependency_includes(${CONAN_INCLUDE_DIRS_TBB})
|
|
|
|
set(Boost_USE_STATIC_LIBS ON)
|
|
find_package(Boost REQUIRED EXACT ${CONAN_BOOST_VERSION} COMPONENTS ${BOOST_COMPONENTS})
|
|
set(Boost_DATE_TIME_LIBRARY "${Boost_date_time_LIB_TARGETS}")
|
|
set(Boost_CHRONO_LIBRARY "${Boost_chrono_LIB_TARGETS}")
|
|
set(Boost_PROGRAM_OPTIONS_LIBRARY "${Boost_program_options_LIB_TARGETS}")
|
|
set(Boost_FILESYSTEM_LIBRARY "${Boost_filesystem_LIB_TARGETS}")
|
|
set(Boost_IOSTREAMS_LIBRARY "${Boost_iostreams_LIB_TARGETS}")
|
|
set(Boost_THREAD_LIBRARY "${Boost_thread_LIB_TARGETS}")
|
|
set(Boost_SYSTEM_LIBRARY "${Boost_system_LIB_TARGETS}")
|
|
set(Boost_ZLIB_LIBRARY "${Boost_zlib_LIB_TARGETS}")
|
|
set(Boost_REGEX_LIBRARY "${Boost_regex_LIB_TARGETS}")
|
|
set(Boost_UNIT_TEST_FRAMEWORK_LIBRARY "${Boost_unit_test_framework_LIB_TARGETS}")
|
|
|
|
find_package(BZip2 REQUIRED)
|
|
find_package(EXPAT REQUIRED)
|
|
find_package(lua REQUIRED)
|
|
set(LUA_LIBRARIES ${lua_LIBRARIES})
|
|
|
|
find_package(TBB REQUIRED)
|
|
|
|
|
|
# note: we avoid calling find_package(Osmium ...) here to ensure that the
|
|
# expat and bzip2 are used from conan rather than the system
|
|
include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/libosmium/include)
|
|
else()
|
|
if (BUILD_ROUTED)
|
|
# osrm-routed requires newer boost:asio
|
|
find_package(Boost 1.70 REQUIRED COMPONENTS ${BOOST_COMPONENTS})
|
|
else()
|
|
find_package(Boost 1.60 REQUIRED COMPONENTS ${BOOST_COMPONENTS})
|
|
endif()
|
|
add_dependency_includes(${Boost_INCLUDE_DIRS})
|
|
|
|
find_package(TBB REQUIRED)
|
|
add_dependency_includes(${TBB_INCLUDE_DIR})
|
|
if(WIN32)
|
|
set(TBB_LIBRARIES optimized ${TBB_LIBRARY} optimized ${TBB_MALLOC_LIBRARY} debug ${TBB_LIBRARY_DEBUG} debug ${TBB_MALLOC_LIBRARY_DEBUG})
|
|
endif()
|
|
|
|
find_package(EXPAT REQUIRED)
|
|
add_dependency_includes(${EXPAT_INCLUDE_DIRS})
|
|
|
|
find_package(BZip2 REQUIRED)
|
|
add_dependency_includes(${BZIP2_INCLUDE_DIR})
|
|
|
|
find_package(Lua 5.2 REQUIRED)
|
|
if (LUA_FOUND)
|
|
message(STATUS "Using Lua ${LUA_VERSION_STRING}")
|
|
endif()
|
|
|
|
add_dependency_includes(${LUA_INCLUDE_DIR})
|
|
|
|
# add a target to generate API documentation with Doxygen
|
|
find_package(Doxygen)
|
|
if(DOXYGEN_FOUND)
|
|
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
|
|
add_custom_target(doc
|
|
${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
|
|
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
|
|
COMMENT "Generating API documentation with Doxygen" VERBATIM
|
|
)
|
|
endif()
|
|
|
|
# note libosmium depends on expat and bzip2
|
|
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/third_party/libosmium/cmake")
|
|
if(NOT OSMIUM_INCLUDE_DIR)
|
|
set(OSMIUM_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/libosmium/include")
|
|
endif()
|
|
find_package(Osmium REQUIRED COMPONENTS io)
|
|
include_directories(SYSTEM ${OSMIUM_INCLUDE_DIR})
|
|
endif()
|
|
|
|
# prefix compilation with ccache by default if available and on clang or gcc
|
|
if(ENABLE_CCACHE AND (CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "GNU"))
|
|
find_program(CCACHE_FOUND ccache)
|
|
if(CCACHE_FOUND)
|
|
message(STATUS "Using ccache to speed up incremental builds")
|
|
set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
|
|
set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
|
|
set(ENV{CCACHE_CPP2} "true")
|
|
endif()
|
|
endif()
|
|
|
|
# even with conan builds we want to link to system zlib
|
|
# to ensure that osrm binaries play well with other binaries like nodejs
|
|
find_package(ZLIB REQUIRED)
|
|
add_dependency_includes(${ZLIB_INCLUDE_DIRS})
|
|
|
|
add_dependency_defines(-DBOOST_SPIRIT_USE_PHOENIX_V3)
|
|
add_dependency_defines(-DBOOST_RESULT_OF_USE_DECLTYPE)
|
|
add_dependency_defines(-DBOOST_FILESYSTEM_NO_DEPRECATED)
|
|
|
|
add_definitions(${OSRM_DEFINES})
|
|
include_directories(SYSTEM ${DEPENDENCIES_INCLUDE_DIRS})
|
|
|
|
set(BOOST_BASE_LIBRARIES
|
|
${Boost_DATE_TIME_LIBRARY}
|
|
${Boost_CHRONO_LIBRARY}
|
|
${Boost_FILESYSTEM_LIBRARY}
|
|
${Boost_IOSTREAMS_LIBRARY}
|
|
${Boost_THREAD_LIBRARY}
|
|
${Boost_SYSTEM_LIBRARY})
|
|
|
|
set(BOOST_ENGINE_LIBRARIES
|
|
${Boost_ZLIB_LIBRARY}
|
|
${Boost_REGEX_LIBRARY}
|
|
${BOOST_BASE_LIBRARIES})
|
|
|
|
# Binaries
|
|
target_link_libraries(osrm-datastore osrm_store ${Boost_PROGRAM_OPTIONS_LIBRARY})
|
|
target_link_libraries(osrm-extract osrm_extract ${Boost_PROGRAM_OPTIONS_LIBRARY})
|
|
target_link_libraries(osrm-partition osrm_partition ${Boost_PROGRAM_OPTIONS_LIBRARY})
|
|
target_link_libraries(osrm-customize osrm_customize ${Boost_PROGRAM_OPTIONS_LIBRARY})
|
|
target_link_libraries(osrm-contract osrm_contract ${Boost_PROGRAM_OPTIONS_LIBRARY})
|
|
if (BUILD_ROUTED)
|
|
target_link_libraries(osrm-routed osrm ${Boost_PROGRAM_OPTIONS_LIBRARY} ${OPTIONAL_SOCKET_LIBS} ${ZLIB_LIBRARY})
|
|
endif()
|
|
|
|
set(EXTRACTOR_LIBRARIES
|
|
${BZIP2_LIBRARIES}
|
|
${Boost_REGEX_LIBRARY}
|
|
${BOOST_BASE_LIBRARIES}
|
|
${CMAKE_THREAD_LIBS_INIT}
|
|
${EXPAT_LIBRARIES}
|
|
${LUA_LIBRARIES}
|
|
${OSMIUM_LIBRARIES}
|
|
${TBB_LIBRARIES}
|
|
${ZLIB_LIBRARY}
|
|
${MAYBE_COVERAGE_LIBRARIES})
|
|
set(GUIDANCE_LIBRARIES
|
|
${BOOST_BASE_LIBRARIES}
|
|
${CMAKE_THREAD_LIBS_INIT}
|
|
${LUA_LIBRARIES}
|
|
${TBB_LIBRARIES}
|
|
${MAYBE_COVERAGE_LIBRARIES})
|
|
set(PARTITIONER_LIBRARIES
|
|
${BOOST_ENGINE_LIBRARIES}
|
|
${CMAKE_THREAD_LIBS_INIT}
|
|
${TBB_LIBRARIES}
|
|
${MAYBE_RT_LIBRARY}
|
|
${MAYBE_COVERAGE_LIBRARIES}
|
|
${ZLIB_LIBRARY})
|
|
set(CUSTOMIZER_LIBRARIES
|
|
${BOOST_ENGINE_LIBRARIES}
|
|
${CMAKE_THREAD_LIBS_INIT}
|
|
${TBB_LIBRARIES}
|
|
${MAYBE_RT_LIBRARY}
|
|
${MAYBE_COVERAGE_LIBRARIES})
|
|
set(UPDATER_LIBRARIES
|
|
${BOOST_BASE_LIBRARIES}
|
|
${CMAKE_THREAD_LIBS_INIT}
|
|
${TBB_LIBRARIES}
|
|
${MAYBE_RT_LIBRARY}
|
|
${MAYBE_COVERAGE_LIBRARIES}
|
|
${ZLIB_LIBRARY})
|
|
set(CONTRACTOR_LIBRARIES
|
|
${BOOST_BASE_LIBRARIES}
|
|
${CMAKE_THREAD_LIBS_INIT}
|
|
${LUA_LIBRARIES}
|
|
${TBB_LIBRARIES}
|
|
${MAYBE_RT_LIBRARY}
|
|
${MAYBE_COVERAGE_LIBRARIES})
|
|
set(ENGINE_LIBRARIES
|
|
${BOOST_ENGINE_LIBRARIES}
|
|
${CMAKE_THREAD_LIBS_INIT}
|
|
${TBB_LIBRARIES}
|
|
${MAYBE_RT_LIBRARY}
|
|
${MAYBE_COVERAGE_LIBRARIES}
|
|
${ZLIB_LIBRARY})
|
|
set(STORAGE_LIBRARIES
|
|
${BOOST_BASE_LIBRARIES}
|
|
${CMAKE_THREAD_LIBS_INIT}
|
|
${TBB_LIBRARIES}
|
|
${MAYBE_RT_LIBRARY}
|
|
${MAYBE_COVERAGE_LIBRARIES})
|
|
set(UTIL_LIBRARIES
|
|
${BOOST_BASE_LIBRARIES}
|
|
${CMAKE_THREAD_LIBS_INIT}
|
|
${TBB_LIBRARIES}
|
|
${MAYBE_COVERAGE_LIBRARIES}
|
|
${ZLIB_LIBRARY})
|
|
|
|
# Libraries
|
|
target_link_libraries(osrm ${ENGINE_LIBRARIES})
|
|
target_link_libraries(osrm_update ${UPDATER_LIBRARIES})
|
|
target_link_libraries(osrm_contract ${CONTRACTOR_LIBRARIES} osrm_update osrm_store)
|
|
target_link_libraries(osrm_extract osrm_guidance ${EXTRACTOR_LIBRARIES})
|
|
target_link_libraries(osrm_partition ${PARTITIONER_LIBRARIES})
|
|
target_link_libraries(osrm_customize ${CUSTOMIZER_LIBRARIES} osrm_update osrm_store)
|
|
target_link_libraries(osrm_store ${STORAGE_LIBRARIES})
|
|
|
|
# BUILD_COMPONENTS
|
|
add_executable(osrm-components src/tools/components.cpp $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
|
|
target_link_libraries(osrm-components ${TBB_LIBRARIES} ${BOOST_BASE_LIBRARIES} ${UTIL_LIBRARIES})
|
|
install(TARGETS osrm-components DESTINATION bin)
|
|
|
|
if(BUILD_TOOLS)
|
|
message(STATUS "Activating OSRM internal tools")
|
|
add_executable(osrm-io-benchmark src/tools/io-benchmark.cpp $<TARGET_OBJECTS:UTIL>)
|
|
target_link_libraries(osrm-io-benchmark ${BOOST_BASE_LIBRARIES} ${TBB_LIBRARIES})
|
|
|
|
install(TARGETS osrm-io-benchmark DESTINATION bin)
|
|
endif()
|
|
|
|
if (ENABLE_ASSERTIONS)
|
|
message(STATUS "Enabling assertions")
|
|
add_definitions(-DBOOST_ENABLE_ASSERT_HANDLER)
|
|
endif()
|
|
|
|
if (ENABLE_DEBUG_LOGGING)
|
|
message(STATUS "Enabling debug logging")
|
|
add_definitions(-DENABLE_DEBUG_LOGGING)
|
|
endif()
|
|
|
|
# Add RPATH info to executables so that when they are run after being installed
|
|
# (i.e., from /usr/local/bin/) the linker can find library dependencies. For
|
|
# more info see http://www.cmake.org/Wiki/CMake_RPATH_handling
|
|
set_property(TARGET osrm-extract PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
|
|
set_property(TARGET osrm-partition PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
|
|
set_property(TARGET osrm-contract PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
|
|
set_property(TARGET osrm-datastore PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
|
|
if (BUILD_ROUTED)
|
|
set_property(TARGET osrm-routed PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
|
|
endif()
|
|
|
|
file(GLOB VariantGlob third_party/variant/include/mapbox/*.hpp)
|
|
file(GLOB FlatbuffersGlob third_party/flatbuffers/include/flatbuffers/*.h)
|
|
file(GLOB LibraryGlob include/osrm/*.hpp)
|
|
file(GLOB ParametersGlob include/engine/api/*_parameters.hpp)
|
|
set(ApiHeader include/engine/api/base_result.hpp)
|
|
set(EngineHeader include/engine/status.hpp include/engine/engine_config.hpp include/engine/hint.hpp include/engine/bearing.hpp include/engine/approach.hpp include/engine/phantom_node.hpp)
|
|
set(UtilHeader include/util/coordinate.hpp include/util/json_container.hpp include/util/typedefs.hpp include/util/alias.hpp include/util/exception.hpp include/util/bearing.hpp)
|
|
set(ExtractorHeader include/extractor/extractor.hpp include/storage/io_config.hpp include/extractor/extractor_config.hpp include/extractor/travel_mode.hpp)
|
|
set(PartitionerHeader include/partitioner/partitioner.hpp include/partitioner/partitioner_config.hpp)
|
|
set(ContractorHeader include/contractor/contractor.hpp include/contractor/contractor_config.hpp)
|
|
set(StorageHeader include/storage/storage.hpp include/storage/io_config.hpp include/storage/storage_config.hpp)
|
|
install(FILES ${EngineHeader} DESTINATION include/osrm/engine)
|
|
install(FILES ${UtilHeader} DESTINATION include/osrm/util)
|
|
install(FILES ${StorageHeader} DESTINATION include/osrm/storage)
|
|
install(FILES ${ExtractorHeader} DESTINATION include/osrm/extractor)
|
|
install(FILES ${PartitionerHeader} DESTINATION include/osrm/partitioner)
|
|
install(FILES ${ContractorHeader} DESTINATION include/osrm/contractor)
|
|
install(FILES ${LibraryGlob} DESTINATION include/osrm)
|
|
install(FILES ${ParametersGlob} DESTINATION include/osrm/engine/api)
|
|
install(FILES ${ApiHeader} DESTINATION include/osrm/engine/api)
|
|
install(FILES ${VariantGlob} DESTINATION include/mapbox)
|
|
install(FILES ${FlatbuffersGlob} DESTINATION include/flatbuffers)
|
|
install(TARGETS osrm-extract DESTINATION bin)
|
|
install(TARGETS osrm-partition DESTINATION bin)
|
|
install(TARGETS osrm-customize DESTINATION bin)
|
|
install(TARGETS osrm-contract DESTINATION bin)
|
|
install(TARGETS osrm-datastore DESTINATION bin)
|
|
if (BUILD_ROUTED)
|
|
install(TARGETS osrm-routed DESTINATION bin)
|
|
endif()
|
|
install(TARGETS osrm DESTINATION lib)
|
|
install(TARGETS osrm_extract DESTINATION lib)
|
|
install(TARGETS osrm_partition DESTINATION lib)
|
|
install(TARGETS osrm_customize DESTINATION lib)
|
|
install(TARGETS osrm_update DESTINATION lib)
|
|
install(TARGETS osrm_contract DESTINATION lib)
|
|
install(TARGETS osrm_store DESTINATION lib)
|
|
install(TARGETS osrm_guidance DESTINATION lib)
|
|
|
|
|
|
# Install profiles and support library to /usr/local/share/osrm/profiles by default
|
|
set(DefaultProfilesDir profiles)
|
|
install(DIRECTORY ${DefaultProfilesDir} DESTINATION share/osrm)
|
|
|
|
# Setup exporting variables for pkgconfig and subproject
|
|
#
|
|
|
|
if(BUILD_PACKAGE)
|
|
include(CPackConfig)
|
|
include(CPack)
|
|
endif()
|
|
|
|
function(JOIN VALUES GLUE OUTPUT)
|
|
string (REPLACE ";" "${GLUE}" _TMP_STR "${VALUES}")
|
|
set (${OUTPUT} "${_TMP_STR}" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
JOIN("${OSRM_DEFINES}" " " TMP_OSRM_DEFINES)
|
|
set(LibOSRM_CXXFLAGS "${OSRM_CXXFLAGS} ${TMP_OSRM_DEFINES}")
|
|
set(LibOSRM_LDFLAGS "${OSRM_LDFLAGS}")
|
|
|
|
if(BUILD_AS_SUBPROJECT)
|
|
set(LibOSRM_CXXFLAGS "${LibOSRM_CXXFLAGS}" PARENT_SCOPE)
|
|
set(LibOSRM_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include" PARENT_SCOPE)
|
|
set(LibOSRM_LIBRARY_DIR "${CMAKE_CURRENT_BINARY_DIR}" PARENT_SCOPE)
|
|
set(LibOSRM_LIBRARIES "osrm" PARENT_SCOPE)
|
|
set(LibOSRM_DEPENDENT_LIBRARIES "${ENGINE_LIBRARIES}" PARENT_SCOPE)
|
|
set(LibOSRM_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/include"
|
|
"${CMAKE_CURRENT_SOURCE_DIR}/include/osrm"
|
|
"${CMAKE_CURRENT_SOURCE_DIR}/third_party"
|
|
"${DEPENDENCIES_INCLUDE_DIRS}" PARENT_SCOPE)
|
|
set(LibOSRM_LIBRARY_DIRS "${LibOSRM_LIBRARY_DIR}" PARENT_SCOPE)
|
|
endif()
|
|
|
|
# pkgconfig defines
|
|
set(PKGCONFIG_OSRM_CXXFLAGS "${LibOSRM_CXXFLAGS}")
|
|
set(PKGCONFIG_OSRM_LDFLAGS "${LibOSRM_LDFLAGS}")
|
|
set(PKGCONFIG_LIBRARY_DIR "${CMAKE_INSTALL_PREFIX}/lib")
|
|
set(PKGCONFIG_INCLUDE_DIR "${CMAKE_INSTALL_PREFIX}/include")
|
|
|
|
list(APPEND DEPENDENCIES_INCLUDE_DIRS "${PKGCONFIG_INCLUDE_DIR}")
|
|
list(APPEND DEPENDENCIES_INCLUDE_DIRS "${PKGCONFIG_INCLUDE_DIR}/osrm")
|
|
JOIN("-I${DEPENDENCIES_INCLUDE_DIRS}" " -I" PKGCONFIG_OSRM_INCLUDE_FLAGS)
|
|
|
|
# Boost uses imported targets, we need to use a generator expression to extract
|
|
# the link libraries to be written to the pkg-config file.
|
|
# Conan defines dependencies as CMake targets too, that's why we do the same for them.
|
|
foreach(engine_lib ${ENGINE_LIBRARIES})
|
|
if("${engine_lib}" MATCHES "^Boost.*" OR "${engine_lib}" MATCHES "^CONAN_LIB.*")
|
|
list(APPEND PKGCONFIG_DEPENDENT_LIBRARIES "$<TARGET_LINKER_FILE:${engine_lib}>")
|
|
else()
|
|
list(APPEND PKGCONFIG_DEPENDENT_LIBRARIES "${engine_lib}")
|
|
endif()
|
|
endforeach(engine_lib)
|
|
JOIN("${PKGCONFIG_DEPENDENT_LIBRARIES}" " " PKGCONFIG_OSRM_DEPENDENT_LIBRARIES)
|
|
|
|
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkgconfig.in pkgconfig.configured @ONLY)
|
|
file(GENERATE
|
|
OUTPUT
|
|
${PROJECT_BINARY_DIR}/libosrm.pc
|
|
INPUT
|
|
${PROJECT_BINARY_DIR}/pkgconfig.configured)
|
|
|
|
install(FILES ${PROJECT_BINARY_DIR}/libosrm.pc DESTINATION ${PKGCONFIG_LIBRARY_DIR}/pkgconfig)
|
|
|
|
# uninstall target
|
|
configure_file(
|
|
"${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in"
|
|
"${CMAKE_CURRENT_BINARY_DIR}/cmake/cmake_uninstall.cmake"
|
|
IMMEDIATE @ONLY)
|
|
|
|
add_custom_target(uninstall
|
|
COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake/cmake_uninstall.cmake)
|
|
|
|
|
|
# Modular build system: each directory registered here provides its own CMakeLists.txt
|
|
add_subdirectory(unit_tests)
|
|
add_subdirectory(src/benchmarks)
|
|
|
|
if (ENABLE_GLIBC_WORKAROUND)
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DGLIBC_WORKAROUND")
|
|
endif()
|
|
|
|
if (ENABLE_NODE_BINDINGS)
|
|
add_subdirectory(src/nodejs)
|
|
endif()
|
|
|
|
|
|
if (ENABLE_FUZZING)
|
|
# Requires libosrm being built with sanitizers; make configurable and default to ubsan
|
|
set(FUZZ_SANITIZER "undefined" CACHE STRING "Sanitizer to be used for Fuzz testing")
|
|
set_property(CACHE FUZZ_SANITIZER PROPERTY STRINGS "undefined" "integer" "address" "memory" "thread" "leak")
|
|
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize-coverage=edge,indirect-calls,8bit-counters -fsanitize=address")
|
|
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address")
|
|
set(OSRM_LDFLAGS "${OSRM_LDFLAGS} -fsanitize=address")
|
|
|
|
message(STATUS "Using -fsanitize=${FUZZ_SANITIZER} for Fuzz testing")
|
|
|
|
add_subdirectory(fuzz)
|
|
endif ()
|
|
|
|
|
|
# add headers sanity check target that includes all headers independently
|
|
# make sure we have all deps for the nodejs sub project's includes (nan, node)
|
|
if (ENABLE_NODE_BINDINGS)
|
|
set(check_headers_dir "${PROJECT_BINARY_DIR}/check-headers")
|
|
file(GLOB_RECURSE headers_to_check
|
|
${PROJECT_BINARY_DIR}/*.hpp
|
|
${PROJECT_SOURCE_DIR}/include/*.hpp)
|
|
foreach(header ${headers_to_check})
|
|
get_filename_component(filename ${header} NAME_WE)
|
|
set(filename "${check_headers_dir}/${filename}.cpp")
|
|
if (NOT EXISTS ${filename})
|
|
file(WRITE ${filename} "#include \"${header}\"\n")
|
|
endif()
|
|
list(APPEND sources ${filename})
|
|
endforeach()
|
|
add_library(check-headers STATIC EXCLUDE_FROM_ALL ${sources})
|
|
set_target_properties(check-headers PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${check_headers_dir})
|
|
endif()
|