# Copyright (c) 2014-2018, The Monero Project # # All rights reserved. # # Redistribution and use in source and binary forms, with or without modification, are # permitted provided that the following conditions are met: # # 1. Redistributions of source code must retain the above copyright notice, this list of # conditions and the following disclaimer. # # 2. Redistributions in binary form must reproduce the above copyright notice, this list # of conditions and the following disclaimer in the documentation and/or other # materials provided with the distribution. # # 3. Neither the name of the copyright holder nor the names of its contributors may be # used to endorse or promote products derived from this software without specific # prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL # THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # # Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers list(INSERT CMAKE_MODULE_PATH 0 "${CMAKE_SOURCE_DIR}/cmake") include(CheckCCompilerFlag) include(CheckCXXCompilerFlag) include(CheckLinkerFlag) include(CheckLibraryExists) include(CheckFunctionExists) if (IOS) INCLUDE(CmakeLists_IOS.txt) endif() cmake_minimum_required(VERSION 2.8.7) project(monero) function (die msg) if (NOT WIN32) string(ASCII 27 Esc) set(ColourReset "${Esc}[m") set(BoldRed "${Esc}[1;31m") else () set(ColourReset "") set(BoldRed "") endif () message(FATAL_ERROR "${BoldRed}${msg}${ColourReset}") endfunction () function (add_c_flag_if_supported flag var) string(REPLACE "-" "_" supported ${flag}_c) check_c_compiler_flag(${flag} ${supported}) if(${${supported}}) set(${var} "${${var}} ${flag}" PARENT_SCOPE) endif() endfunction() function (add_cxx_flag_if_supported flag var) string(REPLACE "-" "_" supported ${flag}_cxx) check_cxx_compiler_flag(${flag} ${supported}) if(${${supported}}) set(${var} "${${var}} ${flag}" PARENT_SCOPE) endif() endfunction() function (add_linker_flag_if_supported flag var) string(REPLACE "-" "_" supported ${flag}_ld) string(REPLACE "," "_" supported ${flag}_ld) check_linker_flag(${flag} ${supported}) if(${${supported}}) set(${var} "${${var}} ${flag}" PARENT_SCOPE) endif() endfunction() function (add_definition_if_function_found function var) string(REPLACE "-" "_" supported ${function}_function) check_function_exists(${function} ${supported}) if(${${supported}}) add_definitions("-D${var}") endif() endfunction() function (add_definition_if_library_exists library function header var) string(REPLACE "-" "_" supported ${function}_library) check_library_exists(${library} ${function} ${header} ${supported}) if(${${supported}}) add_definitions("-D${var}") endif() endfunction() if(NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE) message(STATUS "Setting default build type: ${CMAKE_BUILD_TYPE}") endif() string(TOLOWER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE_LOWER) # ARCH defines the target architecture, either by an explicit identifier or # one of the following two keywords. By default, ARCH a value of 'native': # target arch = host arch, binary is not portable. When ARCH is set to the # string 'default', no -march arg is passed, which creates a binary that is # portable across processors in the same family as host processor. In cases # when ARCH is not set to an explicit identifier, cmake's builtin is used # to identify the target architecture, to direct logic in this cmake script. # Since ARCH is a cached variable, it will not be set on first cmake invocation. if (NOT ARCH OR ARCH STREQUAL "" OR ARCH STREQUAL "native" OR ARCH STREQUAL "default") set(ARCH_ID "${CMAKE_SYSTEM_PROCESSOR}") else() set(ARCH_ID "${ARCH}") endif() string(TOLOWER "${ARCH_ID}" ARM_ID) string(SUBSTRING "${ARM_ID}" 0 3 ARM_TEST) if (ARM_TEST STREQUAL "arm") set(ARM 1) string(SUBSTRING "${ARM_ID}" 0 5 ARM_TEST) if (ARM_TEST STREQUAL "armv6") set(ARM6 1) endif() if (ARM_TEST STREQUAL "armv7") set(ARM7 1) endif() endif() if (ARM_ID STREQUAL "aarch64" OR ARM_ID STREQUAL "arm64" OR ARM_ID STREQUAL "armv8-a") set(ARM 1) set(ARM8 1) set(ARCH "armv8-a") endif() if(ARCH_ID STREQUAL "ppc64le") set(PPC64LE 1) endif() if(WIN32 OR ARM) set(OPT_FLAGS_RELEASE "-O2") else() set(OPT_FLAGS_RELEASE "-Ofast") endif() # BUILD_TAG is used to select the build type to check for a new version if(BUILD_TAG) message(STATUS "Building build tag ${BUILD_TAG}") add_definitions("-DBUILD_TAG=${BUILD_TAG}") else() message(STATUS "Building without build tag") endif() # Update and init submodules by default if(NOT MANUAL_SUBMODULES) find_package(Git) if(GIT_FOUND) message(STATUS "Initializing submodules") execute_process(COMMAND git "submodule" "update" "--init" "--recursive" WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}) endif() endif() set(CMAKE_C_FLAGS_RELEASE "-DNDEBUG ${OPT_FLAGS_RELEASE}") set(CMAKE_CXX_FLAGS_RELEASE "-DNDEBUG ${OPT_FLAGS_RELEASE}") # set this to 0 if per-block checkpoint needs to be disabled set(PER_BLOCK_CHECKPOINT 1) if(PER_BLOCK_CHECKPOINT) add_definitions("-DPER_BLOCK_CHECKPOINT") endif() list(INSERT CMAKE_MODULE_PATH 0 "${CMAKE_SOURCE_DIR}/cmake") if (NOT DEFINED ENV{DEVELOPER_LOCAL_TOOLS}) message(STATUS "Could not find DEVELOPER_LOCAL_TOOLS in env (not required)") set(BOOST_IGNORE_SYSTEM_PATHS_DEFAULT OFF) elseif ("$ENV{DEVELOPER_LOCAL_TOOLS}" EQUAL 1) message(STATUS "Found: env DEVELOPER_LOCAL_TOOLS = 1") set(BOOST_IGNORE_SYSTEM_PATHS_DEFAULT ON) else() message(STATUS "Found: env DEVELOPER_LOCAL_TOOLS = 0") set(BOOST_IGNORE_SYSTEM_PATHS_DEFAULT OFF) endif() message(STATUS "BOOST_IGNORE_SYSTEM_PATHS defaults to ${BOOST_IGNORE_SYSTEM_PATHS_DEFAULT}") option(BOOST_IGNORE_SYSTEM_PATHS "Ignore boost system paths for local boost installation" ${BOOST_IGNORE_SYSTEM_PATHS_DEFAULT}) if (NOT DEFINED ENV{DEVELOPER_LIBUNBOUND_OLD}) message(STATUS "Could not find DEVELOPER_LIBUNBOUND_OLD in env (not required)") elseif ("$ENV{DEVELOPER_LIBUNBOUND_OLD}" EQUAL 1) message(STATUS "Found: env DEVELOPER_LIBUNBOUND_OLD = 1, will use the work around") add_definitions(-DDEVELOPER_LIBUNBOUND_OLD) elseif ("$ENV{DEVELOPER_LIBUNBOUND_OLD}" EQUAL 0) message(STATUS "Found: env DEVELOPER_LIBUNBOUND_OLD = 0") else() message(STATUS "Found: env DEVELOPER_LIBUNBOUND_OLD with bad value. Will NOT use the work around") endif() set_property(GLOBAL PROPERTY USE_FOLDERS ON) enable_testing() option(BUILD_DOCUMENTATION "Build the Doxygen documentation." ON) option(BUILD_TESTS "Build tests." OFF) # Check whether we're on a 32-bit or 64-bit system if(CMAKE_SIZEOF_VOID_P EQUAL "8") set(DEFAULT_BUILD_64 ON) else() set(DEFAULT_BUILD_64 OFF) endif() option(BUILD_64 "Build for 64-bit? 'OFF' builds for 32-bit." ${DEFAULT_BUILD_64}) if(BUILD_64) set(ARCH_WIDTH "64") else() set(ARCH_WIDTH "32") endif() message(STATUS "Building for a ${ARCH_WIDTH}-bit system") # Check if we're on FreeBSD so we can exclude the local miniupnpc (it should be installed from ports instead) # CMAKE_SYSTEM_NAME checks are commonly known, but specifically taken from libsdl's CMakeLists if(CMAKE_SYSTEM_NAME MATCHES "kFreeBSD.*|FreeBSD") set(FREEBSD TRUE) endif() # Check if we're on DragonFly BSD. See the README.md for build instructions. if(CMAKE_SYSTEM_NAME MATCHES "DragonFly.*") set(DRAGONFLY TRUE) endif() # Check if we're on OpenBSD. See the README.md for build instructions. if(CMAKE_SYSTEM_NAME MATCHES "kOpenBSD.*|OpenBSD.*") set(OPENBSD TRUE) endif() # TODO: check bsdi, NetBSD, to see if they need the same FreeBSD changes # # elseif(CMAKE_SYSTEM_NAME MATCHES "kNetBSD.*|NetBSD.*") # set(NETBSD TRUE) # elseif(CMAKE_SYSTEM_NAME MATCHES ".*BSDI.*") # set(BSDI TRUE) include_directories(external/rapidjson/include external/easylogging++ src contrib/epee/include external) if(APPLE) include_directories(SYSTEM /usr/include/malloc) if(POLICY CMP0042) cmake_policy(SET CMP0042 NEW) endif() endif() if(MSVC OR MINGW) set(DEFAULT_STATIC true) else() set(DEFAULT_STATIC false) endif() option(STATIC "Link libraries statically" ${DEFAULT_STATIC}) # This is a CMake built-in switch that concerns internal libraries if (NOT DEFINED BUILD_SHARED_LIBS AND NOT STATIC AND CMAKE_BUILD_TYPE_LOWER STREQUAL "debug") set(BUILD_SHARED_LIBS ON) endif() if (BUILD_SHARED_LIBS) message(STATUS "Building internal libraries with position independent code") add_definitions("-DBUILD_SHARED_LIBS") else() message(STATUS "Building internal libraries as static") endif() set(PIC_FLAG "-fPIC") if(MINGW) string(REGEX MATCH "^[^/]:/[^/]*" msys2_install_path "${CMAKE_C_COMPILER}") message(STATUS "MSYS location: ${msys2_install_path}") set(CMAKE_INCLUDE_PATH "${msys2_install_path}/mingw${ARCH_WIDTH}/include") # This is necessary because otherwise CMake will make Boost libraries -lfoo # rather than a full path. Unfortunately, this makes the shared libraries get # linked due to a bug in CMake which misses putting -static flags around the # -lfoo arguments. set(DEFLIB ${msys2_install_path}/mingw${ARCH_WIDTH}/lib) list(REMOVE_ITEM CMAKE_C_IMPLICIT_LINK_DIRECTORIES ${DEFLIB}) list(REMOVE_ITEM CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES ${DEFLIB}) endif() if(STATIC) if(MSVC) set(CMAKE_FIND_LIBRARY_SUFFIXES .lib .dll.a .a ${CMAKE_FIND_LIBRARY_SUFFIXES}) else() set(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES}) endif() set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DZMQ_STATIC") endif() if(SANITIZE) if (MSVC) message(FATAL_ERROR "Cannot sanitize with MSVC") else() message(STATUS "Using ASAN") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address") endif() endif() # Set default blockchain storage location: # memory was the default in Cryptonote before Monero implemented LMDB, it still works but is unnecessary. # set(DATABASE memory) set(DATABASE lmdb) if (DEFINED ENV{DATABASE}) set(DATABASE $ENV{DATABASE}) message(STATUS "DATABASE set: ${DATABASE}") else() message(STATUS "Could not find DATABASE in env (not required unless you want to change database type from default: ${DATABASE})") endif() set(BERKELEY_DB_OVERRIDE 0) if (DEFINED ENV{BERKELEY_DB}) set(BERKELEY_DB_OVERRIDE 1) set(BERKELEY_DB $ENV{BERKELEY_DB}) elseif() set(BERKELEY_DB 0) endif() if (DATABASE STREQUAL "lmdb") message(STATUS "Using LMDB as default DB type") set(BLOCKCHAIN_DB DB_LMDB) add_definitions("-DDEFAULT_DB_TYPE=\"lmdb\"") elseif (DATABASE STREQUAL "berkeleydb") find_package(BerkeleyDB) if(NOT BERKELEY_DB) die("Found BerkeleyDB includes, but could not find BerkeleyDB library. Please make sure you have installed libdb and libdb-dev / libdb++-dev or the equivalent.") else() message(STATUS "Found BerkeleyDB include (db.h) in ${BERKELEY_DB_INCLUDE_DIR}") if(BERKELEY_DB_LIBRARIES) message(STATUS "Found BerkeleyDB shared library") set(BDB_STATIC false CACHE BOOL "BDB Static flag") set(BDB_INCLUDE ${BERKELEY_DB_INCLUDE_DIR} CACHE STRING "BDB include path") set(BDB_LIBRARY ${BERKELEY_DB_LIBRARIES} CACHE STRING "BDB library name") set(BDB_LIBRARY_DIRS "" CACHE STRING "BDB Library dirs") set(BERKELEY_DB 1) else() die("Found BerkeleyDB includes, but could not find BerkeleyDB library. Please make sure you have installed libdb and libdb-dev / libdb++-dev or the equivalent.") endif() endif() message(STATUS "Using Berkeley DB as default DB type") add_definitions("-DDEFAULT_DB_TYPE=\"berkeley\"") else() die("Invalid database type: ${DATABASE}") endif() if(BERKELEY_DB) add_definitions("-DBERKELEY_DB") endif() add_definitions("-DBLOCKCHAIN_DB=${BLOCKCHAIN_DB}") # Can't install hook in static build on OSX, because OSX linker does not support --wrap # On ARM, having libunwind package (with .so's only) installed breaks static link. # When possible, avoid stack tracing using libunwind in favor of using easylogging++. if (APPLE) set(DEFAULT_STACK_TRACE OFF) set(LIBUNWIND_LIBRARIES "") elseif (DEPENDS AND NOT LINUX) set(DEFAULT_STACK_TRACE OFF) set(LIBUNWIND_LIBRARIES "") elseif(CMAKE_C_COMPILER_ID STREQUAL "GNU" AND NOT MINGW) set(DEFAULT_STACK_TRACE ON) set(STACK_TRACE_LIB "easylogging++") # for diag output only set(LIBUNWIND_LIBRARIES "") elseif (ARM AND STATIC) set(DEFAULT_STACK_TRACE OFF) set(LIBUNWIND_LIBRARIES "") else() find_package(Libunwind) if(LIBUNWIND_FOUND) set(DEFAULT_STACK_TRACE ON) set(STACK_TRACE_LIB "libunwind") # for diag output only else() set(DEFAULT_STACK_TRACE OFF) set(LIBUNWIND_LIBRARIES "") endif() endif() option(STACK_TRACE "Install a hook that dumps stack on exception" ${DEFAULT_STACK_TRACE}) if(STACK_TRACE) message(STATUS "Stack trace on exception enabled (using ${STACK_TRACE_LIB})") else() message(STATUS "Stack trace on exception disabled") endif() if (UNIX AND NOT APPLE) # Note that at the time of this writing the -Wstrict-prototypes flag added below will make this fail set(THREADS_PREFER_PTHREAD_FLAG ON) find_package(Threads) endif() # Handle OpenSSL, used for sha256sum on binary updates and light wallet ssl http if (CMAKE_SYSTEM_NAME MATCHES "(SunOS|Solaris)") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthreads") endif () if (APPLE AND NOT IOS) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=x86-64 -fvisibility=default") if (NOT OpenSSL_DIR) EXECUTE_PROCESS(COMMAND brew --prefix openssl OUTPUT_VARIABLE OPENSSL_ROOT_DIR OUTPUT_STRIP_TRAILING_WHITESPACE) message(STATUS "Using OpenSSL found at ${OPENSSL_ROOT_DIR}") endif() endif() find_package(OpenSSL REQUIRED) message(STATUS "Using OpenSSL include dir at ${OPENSSL_INCLUDE_DIR}") include_directories(${OPENSSL_INCLUDE_DIR}) if(STATIC AND NOT IOS) if(UNIX) set(OPENSSL_LIBRARIES "${OPENSSL_LIBRARIES};${CMAKE_DL_LIBS};${CMAKE_THREAD_LIBS_INIT}") endif() endif() find_package(PCSC) add_definition_if_library_exists(c memset_s "string.h" HAVE_MEMSET_S) add_definition_if_library_exists(c explicit_bzero "strings.h" HAVE_EXPLICIT_BZERO) add_definition_if_function_found(strptime HAVE_STRPTIME) add_definitions(-DAUTO_INITIALIZE_EASYLOGGINGPP) # Generate header for embedded translations add_subdirectory(translations) include_directories("${CMAKE_CURRENT_BINARY_DIR}/translations") add_subdirectory(external) # Final setup for libunbound include_directories(${UNBOUND_INCLUDE}) link_directories(${UNBOUND_LIBRARY_DIRS}) # Final setup for easylogging++ include_directories(${EASYLOGGING_INCLUDE}) link_directories(${EASYLOGGING_LIBRARY_DIRS}) # Final setup for liblmdb include_directories(${LMDB_INCLUDE}) # Final setup for Berkeley DB if (BERKELEY_DB) include_directories(${BDB_INCLUDE}) endif() # Final setup for libunwind include_directories(${LIBUNWIND_INCLUDE}) link_directories(${LIBUNWIND_LIBRARY_DIRS}) # Final setup for libpcsc if (PCSC_FOUND) message(STATUS "Using PCSC include dir at ${PCSC_INCLUDE_DIR}") add_definitions(-DHAVE_PCSC) include_directories(${PCSC_INCLUDE_DIR}) link_directories(${LIBPCSC_LIBRARY_DIRS}) else (PCSC_FOUND) message(STATUS "Could not find PCSC") endif() if(MSVC) add_definitions("/bigobj /MP /W3 /GS- /D_CRT_SECURE_NO_WARNINGS /wd4996 /wd4345 /D_WIN32_WINNT=0x0600 /DWIN32_LEAN_AND_MEAN /DGTEST_HAS_TR1_TUPLE=0 /FIinline_c.h /D__SSE4_1__") # set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /Dinline=__inline") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /STACK:10485760") if(STATIC) foreach(VAR CMAKE_C_FLAGS_DEBUG CMAKE_CXX_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELEASE) string(REPLACE "/MD" "/MT" ${VAR} "${${VAR}}") endforeach() endif() include_directories(SYSTEM src/platform/msc) else() include(TestCXXAcceptsFlag) if (NOT ARM6) set(ARCH native CACHE STRING "CPU to build for: -march value or 'default' to not pass -march at all") endif() message(STATUS "Building on ${CMAKE_SYSTEM_PROCESSOR} for ${ARCH}") if(ARCH STREQUAL "default") set(ARCH_FLAG "") elseif(PPC64LE) set(ARCH_FLAG "-mcpu=${ARCH}") elseif(IOS AND ARCH STREQUAL "arm64") message(STATUS "IOS: Changing arch from arm64 to armv8") set(ARCH_FLAG "-march=armv8") else() set(ARCH_FLAG "-march=${ARCH}") if(ARCH STREQUAL "native") check_c_compiler_flag(-march=native CC_SUPPORTS_MARCH_NATIVE) if (NOT CC_SUPPORTS_MARCH_NATIVE) check_c_compiler_flag(-mtune=native CC_SUPPORTS_MTUNE_NATIVE) if (CC_SUPPORTS_MTUNE_NATIVE) set(ARCH_FLAG "-mtune=${ARCH}") else() set(ARCH_FLAG "") endif() endif() endif() endif() set(WARNINGS "-Wall -Wextra -Wpointer-arith -Wundef -Wvla -Wwrite-strings -Wno-error=extra -Wno-error=deprecated-declarations -Wno-unused-parameter -Wno-unused-variable -Wno-error=unused-variable -Wno-error=undef -Wno-error=uninitialized") if(NOT MINGW) set(WARNINGS_AS_ERRORS_FLAG "-Werror") endif() if(CMAKE_C_COMPILER_ID STREQUAL "Clang") if(ARM) set(WARNINGS "${WARNINGS} -Wno-error=inline-asm") endif() else() set(WARNINGS "${WARNINGS} -Wlogical-op -Wno-error=maybe-uninitialized -Wno-error=cpp") endif() if(MINGW) set(WARNINGS "${WARNINGS} -Wno-error=unused-value -Wno-error=unused-but-set-variable") set(MINGW_FLAG "${MINGW_FLAG} -DWIN32_LEAN_AND_MEAN") set(Boost_THREADAPI win32) include_directories(SYSTEM src/platform/mingw) # mingw doesn't support LTO (multiple definition errors at link time) set(USE_LTO_DEFAULT false) set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--stack,10485760") if(NOT BUILD_64) add_definitions(-DWINVER=0x0501 -D_WIN32_WINNT=0x0501) endif() endif() set(C_WARNINGS "-Waggregate-return -Wnested-externs -Wold-style-definition -Wstrict-prototypes") set(CXX_WARNINGS "-Wno-reorder -Wno-missing-field-initializers") try_compile(STATIC_ASSERT_RES "${CMAKE_CURRENT_BINARY_DIR}/static-assert" "${CMAKE_CURRENT_SOURCE_DIR}/cmake/test-static-assert.c" COMPILE_DEFINITIONS "-std=c11") if(STATIC_ASSERT_RES) set(STATIC_ASSERT_FLAG "") else() set(STATIC_ASSERT_FLAG "-Dstatic_assert=_Static_assert") endif() try_compile(STATIC_ASSERT_CPP_RES "${CMAKE_CURRENT_BINARY_DIR}/static-assert" "${CMAKE_CURRENT_SOURCE_DIR}/cmake/test-static-assert.cpp" COMPILE_DEFINITIONS "-std=c++11") if(STATIC_ASSERT_CPP_RES) set(STATIC_ASSERT_CPP_FLAG "") else() set(STATIC_ASSERT_CPP_FLAG "-Dstatic_assert=_Static_assert") endif() option(COVERAGE "Enable profiling for test coverage report" 0) if(COVERAGE) message(STATUS "Building with profiling for test coverage report") set(COVERAGE_FLAGS "-fprofile-arcs -ftest-coverage --coverage") endif() # With GCC 6.1.1 the compiled binary malfunctions due to aliasing. Until that # is fixed in the code (Issue #847), force compiler to be conservative. set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-strict-aliasing") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-strict-aliasing") # if those don't work for your compiler, single it out where appropriate if(CMAKE_BUILD_TYPE STREQUAL "Release") set(C_SECURITY_FLAGS "${C_SECURITY_FLAGS} -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1") set(CXX_SECURITY_FLAGS "${CXX_SECURITY_FLAGS} -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1") endif() # warnings add_c_flag_if_supported(-Wformat C_SECURITY_FLAGS) add_cxx_flag_if_supported(-Wformat CXX_SECURITY_FLAGS) add_c_flag_if_supported(-Wformat-security C_SECURITY_FLAGS) add_cxx_flag_if_supported(-Wformat-security CXX_SECURITY_FLAGS) # -fstack-protector if (NOT WIN32) add_c_flag_if_supported(-fstack-protector C_SECURITY_FLAGS) add_cxx_flag_if_supported(-fstack-protector CXX_SECURITY_FLAGS) add_c_flag_if_supported(-fstack-protector-strong C_SECURITY_FLAGS) add_cxx_flag_if_supported(-fstack-protector-strong CXX_SECURITY_FLAGS) endif() add_c_flag_if_supported(-mmitigate-rop C_SECURITY_FLAGS) add_cxx_flag_if_supported(-mmitigate-rop CXX_SECURITY_FLAGS) # linker if (NOT WIN32) # Windows binaries die on startup with PIE add_linker_flag_if_supported(-pie LD_SECURITY_FLAGS) endif() add_linker_flag_if_supported(-Wl,-z,relro LD_SECURITY_FLAGS) add_linker_flag_if_supported(-Wl,-z,now LD_SECURITY_FLAGS) add_linker_flag_if_supported(-Wl,-z,noexecstack noexecstack_SUPPORTED) if (noexecstack_SUPPORTED) set(LD_SECURITY_FLAGS "${LD_SECURITY_FLAGS} -Wl,-z,noexecstack") set(LD_RAW_FLAGS ${LD_RAW_FLAGS} -z noexecstack) endif() add_linker_flag_if_supported(-Wl,-z,noexecheap noexecheap_SUPPORTED) if (noexecheap_SUPPORTED) set(LD_SECURITY_FLAGS "${LD_SECURITY_FLAGS} -Wl,-z,noexecheap") set(LD_RAW_FLAGS ${LD_RAW_FLAGS} -z noexecheap) endif() # some windows linker bits if (WIN32) add_linker_flag_if_supported(-Wl,--dynamicbase LD_SECURITY_FLAGS) add_linker_flag_if_supported(-Wl,--nxcompat LD_SECURITY_FLAGS) endif() message(STATUS "Using C security hardening flags: ${C_SECURITY_FLAGS}") message(STATUS "Using C++ security hardening flags: ${CXX_SECURITY_FLAGS}") message(STATUS "Using linker security hardening flags: ${LD_SECURITY_FLAGS}") option(NO_AES "Explicitly disable AES support" ${NO_AES}) if(NO_AES) message(STATUS "AES support explicitly disabled") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DNO_AES") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNO_AES") elseif(NOT ARM AND NOT PPC64LE) message(STATUS "AES support enabled") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -maes") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -maes") elseif(PPC64LE) message(STATUS "AES support not available on ppc64le") elseif(ARM6) message(STATUS "AES support not available on ARMv6") elseif(ARM7) message(STATUS "AES support not available on ARMv7") elseif(ARM8) CHECK_CXX_ACCEPTS_FLAG("-march=${ARCH}+crypto" ARCH_PLUS_CRYPTO) if(ARCH_PLUS_CRYPTO) message(STATUS "Crypto extensions enabled for ARMv8") set(ARCH_FLAG "-march=${ARCH}+crypto") else() message(STATUS "Crypto extensions unavailable on your ARMv8 device") endif() else() message(STATUS "AES support disabled") endif() set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c11 -D_GNU_SOURCE ${MINGW_FLAG} ${STATIC_ASSERT_FLAG} ${WARNINGS} ${C_WARNINGS} ${ARCH_FLAG} ${COVERAGE_FLAGS} ${PIC_FLAG} ${C_SECURITY_FLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -D_GNU_SOURCE ${MINGW_FLAG} ${STATIC_ASSERT_CPP_FLAG} ${WARNINGS} ${CXX_WARNINGS} ${ARCH_FLAG} ${COVERAGE_FLAGS} ${PIC_FLAG} ${CXX_SECURITY_FLAGS}") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${LD_SECURITY_FLAGS}") # With GCC 6.1.1 the compiled binary malfunctions due to aliasing. Until that # is fixed in the code (Issue #847), force compiler to be conservative. set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-strict-aliasing") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-strict-aliasing") if(ARM) message(STATUS "Setting FPU Flags for ARM Processors") #NB NEON hardware does not fully implement the IEEE 754 standard for floating-point arithmetic #Need custom assembly code to take full advantage of NEON SIMD #Cortex-A5/9 -mfpu=neon-fp16 #Cortex-A7/15 -mfpu=neon-vfpv4 #Cortex-A8 -mfpu=neon #ARMv8 -FP and SIMD on by default for all ARM8v-A series, NO -mfpu setting needed #For custom -mtune, processor IDs for ARMv8-A series: #0xd04 - Cortex-A35 #0xd07 - Cortex-A57 #0xd08 - Cortex-A72 #0xd03 - Cortex-A73 if(NOT ARM8) CHECK_CXX_ACCEPTS_FLAG(-mfpu=vfp3-d16 CXX_ACCEPTS_VFP3_D16) CHECK_CXX_ACCEPTS_FLAG(-mfpu=vfp4 CXX_ACCEPTS_VFP4) CHECK_CXX_ACCEPTS_FLAG(-mfloat-abi=hard CXX_ACCEPTS_MFLOAT_HARD) CHECK_CXX_ACCEPTS_FLAG(-mfloat-abi=softfp CXX_ACCEPTS_MFLOAT_SOFTFP) endif() if(ARM8) CHECK_CXX_ACCEPTS_FLAG(-mfix-cortex-a53-835769 CXX_ACCEPTS_MFIX_CORTEX_A53_835769) CHECK_CXX_ACCEPTS_FLAG(-mfix-cortex-a53-843419 CXX_ACCEPTS_MFIX_CORTEX_A53_843419) endif() if(ARM6) message(STATUS "Selecting VFP for ARMv6") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfpu=vfp") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpu=vfp") if(DEPENDS) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -marm") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -marm") endif() endif(ARM6) if(ARM7) if(CXX_ACCEPTS_VFP3_D16 AND NOT CXX_ACCEPTS_VFP4) message(STATUS "Selecting VFP3 for ARMv7") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfpu=vfp3-d16") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpu=vfp3-d16") endif() if(CXX_ACCEPTS_VFP4) message(STATUS "Selecting VFP4 for ARMv7") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfpu=vfp4") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpu=vfp4") endif() if(CXX_ACCEPTS_MFLOAT_HARD) message(STATUS "Setting Hardware ABI for Floating Point") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfloat-abi=hard") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfloat-abi=hard") endif() if(CXX_ACCEPTS_MFLOAT_SOFTFP AND NOT CXX_ACCEPTS_MFLOAT_HARD) message(STATUS "Setting Software ABI for Floating Point") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfloat-abi=softfp") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfloat-abi=softfp") endif() endif(ARM7) if(ARM8) if(CXX_ACCEPTS_MFIX_CORTEX_A53_835769) message(STATUS "Enabling Cortex-A53 workaround 835769") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfix-cortex-a53-835769") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfix-cortex-a53-835769") endif() if(CXX_ACCEPTS_MFIX_CORTEX_A53_843419) message(STATUS "Enabling Cortex-A53 workaround 843419") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfix-cortex-a53-843419") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfix-cortex-a53-843419") endif() endif(ARM8) endif(ARM) if(ANDROID AND NOT BUILD_GUI_DEPS STREQUAL "ON" OR IOS) #From Android 5: "only position independent executables (PIE) are supported" message(STATUS "Enabling PIE executable") set(PIC_FLAG "") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIE") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIE") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_CXX_FLAGS} -fPIE -pie") endif() if(APPLE) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -DGTEST_HAS_TR1_TUPLE=0") endif() set(DEBUG_FLAGS "-g3") if(CMAKE_C_COMPILER_ID STREQUAL "GNU" AND NOT (CMAKE_C_COMPILER_VERSION VERSION_LESS 4.8)) set(DEBUG_FLAGS "${DEBUG_FLAGS} -Og ") else() set(DEBUG_FLAGS "${DEBUG_FLAGS} -O0 ") endif() if(NOT DEFINED USE_LTO_DEFAULT) set(USE_LTO_DEFAULT false) endif() set(USE_LTO ${USE_LTO_DEFAULT} CACHE BOOL "Use Link-Time Optimization (Release mode only)") if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang") # There is a clang bug that does not allow to compile code that uses AES-NI intrinsics if -flto is enabled, so explicitly disable set(USE_LTO false) endif() if(USE_LTO) set(RELEASE_FLAGS "${RELEASE_FLAGS} -flto") if(STATIC) set(RELEASE_FLAGS "${RELEASE_FLAGS} -ffat-lto-objects") endif() # Since gcc 4.9 the LTO format is non-standard (slim), so we need the gcc-specific ar and ranlib binaries if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND NOT (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9.0) AND NOT OPENBSD AND NOT DRAGONFLY) # When invoking cmake on distributions on which gcc's binaries are prefixed # with an arch-specific triplet, the user must specify -DCHOST= if (DEFINED CHOST) set(CMAKE_AR "${CHOST}-gcc-ar") set(CMAKE_RANLIB "${CHOST}-gcc-ranlib") else() set(CMAKE_AR "gcc-ar") set(CMAKE_RANLIB "gcc-ranlib") endif() endif() endif() set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${DEBUG_FLAGS}") set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${DEBUG_FLAGS}") set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${RELEASE_FLAGS}") set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${RELEASE_FLAGS}") if(STATIC) # STATIC already configures most deps to be linked in statically, # here we make more deps static if the platform permits it if (MINGW) # On Windows, this is as close to fully-static as we get: # this leaves only deps on /c/Windows/system32/*.dll set(STATIC_FLAGS "-static") elseif (NOT (APPLE OR FREEBSD OR OPENBSD OR DRAGONFLY)) # On Linux, we don't support fully static build, but these can be static set(STATIC_FLAGS "-static-libgcc -static-libstdc++") endif() set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${STATIC_FLAGS} ") endif() endif() if (${BOOST_IGNORE_SYSTEM_PATHS} STREQUAL "ON") set(Boost_NO_SYSTEM_PATHS TRUE) endif() set(OLD_LIB_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES}) if(STATIC) if(MINGW) set(CMAKE_FIND_LIBRARY_SUFFIXES .a) endif() set(Boost_USE_STATIC_LIBS ON) set(Boost_USE_STATIC_RUNTIME ON) endif() find_package(Boost 1.58 QUIET REQUIRED COMPONENTS system filesystem thread date_time chrono regex serialization program_options locale) set(CMAKE_FIND_LIBRARY_SUFFIXES ${OLD_LIB_SUFFIXES}) if(NOT Boost_FOUND) die("Could not find Boost libraries, please make sure you have installed Boost or libboost-all-dev (1.58) or the equivalent") elseif(Boost_FOUND) message(STATUS "Found Boost Version: ${Boost_VERSION}") if (Boost_VERSION VERSION_LESS 106200 AND NOT (OPENSSL_VERSION VERSION_LESS 1.1)) message(FATAL_ERROR "Boost older than 1.62 is too old to link with OpenSSL 1.1 or newer. " "Update Boost or install OpenSSL 1.0 and set path to it when running cmake: " "cmake -DOPENSSL_ROOT_DIR='/usr/include/openssl-1.0;/usr/lib/openssl-1.0'") endif() endif() include_directories(SYSTEM ${Boost_INCLUDE_DIRS}) if(MINGW) set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wa,-mbig-obj") set(EXTRA_LIBRARIES mswsock;ws2_32;iphlpapi) if(DEPENDS) set(ICU_LIBRARIES ${Boost_LOCALE_LIBRARY} sicuio sicuin sicuuc sicudt sicutu iconv) else() set(ICU_LIBRARIES ${Boost_LOCALE_LIBRARY} icuio icuin icuuc icudt icutu iconv) endif() elseif(APPLE OR OPENBSD OR ANDROID) set(EXTRA_LIBRARIES "") elseif(FREEBSD) set(EXTRA_LIBRARIES execinfo) elseif(DRAGONFLY) find_library(COMPAT compat) set(EXTRA_LIBRARIES execinfo ${COMPAT}) elseif(CMAKE_SYSTEM_NAME MATCHES "(SunOS|Solaris)") set(EXTRA_LIBRARIES socket nsl resolv) elseif(NOT MSVC) find_library(RT rt) set(EXTRA_LIBRARIES ${RT}) endif() list(APPEND EXTRA_LIBRARIES ${CMAKE_DL_LIBS}) option(USE_READLINE "Build with GNU readline support." ON) if(USE_READLINE) find_package(Readline) if(READLINE_FOUND AND GNU_READLINE_FOUND) add_definitions(-DHAVE_READLINE) include_directories(${Readline_INCLUDE_DIR}) message(STATUS "Found readline library at: ${Readline_ROOT_DIR}") set(EPEE_READLINE epee_readline) else() message(STATUS "Could not find GNU readline library so building without readline support") endif() endif() if(ANDROID) set(ATOMIC libatomic.a) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=user-defined-warnings") endif() if(CMAKE_C_COMPILER_ID STREQUAL "Clang" AND ARCH_WIDTH EQUAL "32" AND NOT IOS AND NOT FREEBSD) find_library(ATOMIC atomic) list(APPEND EXTRA_LIBRARIES ${ATOMIC}) endif() find_path(ZMQ_INCLUDE_PATH zmq.hpp) find_library(ZMQ_LIB zmq) find_library(PGM_LIBRARY pgm) find_library(NORM_LIBRARY norm) find_library(SODIUM_LIBRARY sodium) if(NOT ZMQ_INCLUDE_PATH) message(FATAL_ERROR "Could not find required header zmq.hpp") endif() if(NOT ZMQ_LIB) message(FATAL_ERROR "Could not find required libzmq") endif() if(PGM_LIBRARY) set(ZMQ_LIB "${ZMQ_LIB};${PGM_LIBRARY}") endif() if(NORM_LIBRARY) set(ZMQ_LIB "${ZMQ_LIB};${NORM_LIBRARY}") endif() if(SODIUM_LIBRARY) set(ZMQ_LIB "${ZMQ_LIB};${SODIUM_LIBRARY}") endif() add_subdirectory(contrib) add_subdirectory(src) if(BUILD_TESTS) add_subdirectory(tests) endif() if(BUILD_DOCUMENTATION) set(DOC_GRAPHS "YES" CACHE STRING "Create dependency graphs (needs graphviz)") set(DOC_FULLGRAPHS "NO" CACHE STRING "Create call/callee graphs (large)") find_program(DOT_PATH dot) if (DOT_PATH STREQUAL "DOT_PATH-NOTFOUND") message("Doxygen: graphviz not found - graphs disabled") set(DOC_GRAPHS "NO") endif() find_package(Doxygen) if(DOXYGEN_FOUND) configure_file("cmake/Doxyfile.in" "Doxyfile" @ONLY) configure_file("cmake/Doxygen.extra.css.in" "Doxygen.extra.css" @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() endif() # when ON - will install libwallet_merged into "lib" option(BUILD_GUI_DEPS "Build GUI dependencies." OFF) # This is not nice, distribution packagers should not enable this, but depend # on libunbound shipped with their distribution instead option(INSTALL_VENDORED_LIBUNBOUND "Install libunbound binary built from source vendored with this repo." OFF) CHECK_C_COMPILER_FLAG(-std=c11 HAVE_C11)