From b655068107d14f2643854b2efa2ce1304af2f7e2 Mon Sep 17 00:00:00 2001 From: AlefLm Date: Fri, 6 Dec 2024 23:56:12 +0000 Subject: [PATCH 01/19] secp256k1: CMake build system added --- src/secp256k1/CMakeLists.txt | 385 ++++++++++++++++++ src/secp256k1/cmake/CheckArm32Assembly.cmake | 6 + .../cmake/CheckMemorySanitizer.cmake | 18 + .../cmake/CheckStringOptionValue.cmake | 10 + src/secp256k1/cmake/CheckX86_64Assembly.cmake | 14 + src/secp256k1/cmake/FindGMP.cmake | 46 +++ src/secp256k1/cmake/FindValgrind.cmake | 41 ++ .../cmake/GeneratePkgConfigFile.cmake | 8 + src/secp256k1/cmake/TryAppendCFlags.cmake | 24 ++ .../cmake/arm-linux-gnueabihf.toolchain.cmake | 3 + src/secp256k1/cmake/config.cmake.in | 5 + src/secp256k1/cmake/source_arm32.s | 9 + .../cmake/x86_64-w64-mingw32.toolchain.cmake | 3 + src/secp256k1/src/CMakeLists.txt | 181 ++++++++ src/secp256k1/src/secp256k1.c | 4 - 15 files changed, 753 insertions(+), 4 deletions(-) create mode 100644 src/secp256k1/CMakeLists.txt create mode 100644 src/secp256k1/cmake/CheckArm32Assembly.cmake create mode 100644 src/secp256k1/cmake/CheckMemorySanitizer.cmake create mode 100644 src/secp256k1/cmake/CheckStringOptionValue.cmake create mode 100644 src/secp256k1/cmake/CheckX86_64Assembly.cmake create mode 100644 src/secp256k1/cmake/FindGMP.cmake create mode 100644 src/secp256k1/cmake/FindValgrind.cmake create mode 100644 src/secp256k1/cmake/GeneratePkgConfigFile.cmake create mode 100644 src/secp256k1/cmake/TryAppendCFlags.cmake create mode 100644 src/secp256k1/cmake/arm-linux-gnueabihf.toolchain.cmake create mode 100644 src/secp256k1/cmake/config.cmake.in create mode 100644 src/secp256k1/cmake/source_arm32.s create mode 100644 src/secp256k1/cmake/x86_64-w64-mingw32.toolchain.cmake create mode 100644 src/secp256k1/src/CMakeLists.txt diff --git a/src/secp256k1/CMakeLists.txt b/src/secp256k1/CMakeLists.txt new file mode 100644 index 0000000000..6b4bc2b54e --- /dev/null +++ b/src/secp256k1/CMakeLists.txt @@ -0,0 +1,385 @@ +cmake_minimum_required(VERSION 3.16) + +#============================= +# Project / Package metadata +#============================= +project(libsecp256k1 + # The package (a.k.a. release) version is based on semantic versioning 2.0.0 of + # the API. All changes in experimental modules are treated as + # backwards-compatible and therefore at most increase the minor version. + VERSION 0.6.0 + DESCRIPTION "Optimized C library for ECDSA signatures and secret/public key operations on curve secp256k1." + HOMEPAGE_URL "https://github.com/bitcoin-core/secp256k1" + LANGUAGES C CXX +) +enable_testing() +list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake) + +if(CMAKE_VERSION VERSION_LESS 3.21) + # Emulates CMake 3.21+ behavior. + if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR) + set(PROJECT_IS_TOP_LEVEL ON) + set(${PROJECT_NAME}_IS_TOP_LEVEL ON) + else() + set(PROJECT_IS_TOP_LEVEL OFF) + set(${PROJECT_NAME}_IS_TOP_LEVEL OFF) + endif() +endif() + +# The library version is based on libtool versioning of the ABI. The set of +# rules for updating the version can be found here: +# https://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html +# All changes in experimental modules are treated as if they don't affect the +# interface and therefore only increase the revision. +set(${PROJECT_NAME}_LIB_VERSION_CURRENT 5) +set(${PROJECT_NAME}_LIB_VERSION_REVISION 0) +set(${PROJECT_NAME}_LIB_VERSION_AGE 0) + +#============================= +# Language setup +#============================= +set(CMAKE_C_STANDARD 90) +set(CMAKE_C_EXTENSIONS OFF) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_EXTENSIONS OFF) + +#============================= +# Libraries +#============================= +find_package(GMP 6.2.1 REQUIRED) +find_package(OpenSSL 1.1.1 REQUIRED) + +#============================= +# Configurable options +#============================= +option(BUILD_SHARED_LIBS "Build shared libraries." ON) +option(SECP256K1_DISABLE_SHARED "Disable shared library. Overrides BUILD_SHARED_LIBS." OFF) +if(SECP256K1_DISABLE_SHARED) + set(BUILD_SHARED_LIBS OFF) +endif() + +option(SECP256K1_INSTALL "Enable installation." ${PROJECT_IS_TOP_LEVEL}) + +# Include main repo include directory +# TODO: Fix these and make them target properties. +# Project should only have ../include in include path. +# Not ${CMAKE_CURRENT_SOURCE_DIR} +include_directories(${CMAKE_CURRENT_SOURCE_DIR}) +include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include) +include_directories(${CMAKE_CURRENT_SOURCE_DIR}/src) + +## Modules + +# We declare all options before processing them, to make sure we can express +# dependendencies while processing. +option(SECP256K1_ENABLE_MODULE_ECDH "Enable ECDH module." ON) +option(SECP256K1_ENABLE_MODULE_RECOVERY "Enable ECDSA pubkey recovery module." ON) + +# Processing must be done in a topological sorting of the dependency graph +# (dependent module first). +if(SECP256K1_ENABLE_MODULE_RECOVERY) + add_compile_definitions(ENABLE_MODULE_RECOVERY=1) +endif() + +if(SECP256K1_ENABLE_MODULE_ECDH) + add_compile_definitions(ENABLE_MODULE_ECDH=1) +endif() + +set(SECP256K1_ECMULT_WINDOW_SIZE 15 CACHE STRING "Window size for ecmult precomputation for verification, specified as integer in range [2..24]. The default value is a reasonable setting for desktop machines (currently 15). [default=15]") +set_property(CACHE SECP256K1_ECMULT_WINDOW_SIZE PROPERTY STRINGS 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24) +include(CheckStringOptionValue) +check_string_option_value(SECP256K1_ECMULT_WINDOW_SIZE) +add_compile_definitions(ECMULT_WINDOW_SIZE=${SECP256K1_ECMULT_WINDOW_SIZE}) + +set(SECP256K1_ECMULT_GEN_KB 86 CACHE STRING "The size of the precomputed table for signing in multiples of 1024 bytes (on typical platforms). Larger values result in possibly better signing or key generation performance at the cost of a larger table. Valid choices are 2, 22, 86. The default value is a reasonable setting for desktop machines (currently 86). [default=86]") +set_property(CACHE SECP256K1_ECMULT_GEN_KB PROPERTY STRINGS 2 22 86) +check_string_option_value(SECP256K1_ECMULT_GEN_KB) +if(SECP256K1_ECMULT_GEN_KB EQUAL 2) + add_compile_definitions(COMB_BLOCKS=2) + add_compile_definitions(COMB_TEETH=5) +elseif(SECP256K1_ECMULT_GEN_KB EQUAL 22) + add_compile_definitions(COMB_BLOCKS=11) + add_compile_definitions(COMB_TEETH=6) +elseif(SECP256K1_ECMULT_GEN_KB EQUAL 86) + add_compile_definitions(COMB_BLOCKS=43) + add_compile_definitions(COMB_TEETH=6) +endif() + +set(SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY "OFF" CACHE STRING "Test-only override of the (autodetected by the C code) \"widemul\" setting. Legal values are: \"OFF\", \"int128_struct\", \"int128\" or \"int64\". [default=OFF]") +set_property(CACHE SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY PROPERTY STRINGS "OFF" "int128_struct" "int128" "int64") +check_string_option_value(SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY) +if(SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY) + string(TOUPPER "${SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY}" widemul_upper_value) + add_compile_definitions(USE_FORCE_WIDEMUL_${widemul_upper_value}=1) +endif() +mark_as_advanced(FORCE SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY) + +set(SECP256K1_ASM "AUTO" CACHE STRING "Assembly to use: \"AUTO\", \"OFF\", \"x86_64\" or \"arm32\" (experimental). [default=AUTO]") +set_property(CACHE SECP256K1_ASM PROPERTY STRINGS "AUTO" "OFF" "x86_64" "arm32") +check_string_option_value(SECP256K1_ASM) +if(SECP256K1_ASM STREQUAL "arm32") + enable_language(ASM) + include(CheckArm32Assembly) + check_arm32_assembly() + if(HAVE_ARM32_ASM) + add_compile_definitions(USE_EXTERNAL_ASM=1) + else() + message(FATAL_ERROR "ARM32 assembly requested but not available.") + endif() +elseif(SECP256K1_ASM) + include(CheckX86_64Assembly) + check_x86_64_assembly() + if(HAVE_X86_64_ASM) + set(SECP256K1_ASM "x86_64") + add_compile_definitions(USE_ASM_X86_64=1) + elseif(SECP256K1_ASM STREQUAL "AUTO") + set(SECP256K1_ASM "OFF") + else() + message(FATAL_ERROR "x86_64 assembly requested but not available.") + endif() +endif() + +option(SECP256K1_EXPERIMENTAL "Allow experimental configuration options." OFF) +if(NOT SECP256K1_EXPERIMENTAL) + if(SECP256K1_ASM STREQUAL "arm32") + message(FATAL_ERROR "ARM32 assembly is experimental. Use -DSECP256K1_EXPERIMENTAL=ON to allow.") + endif() +endif() + +set(SECP256K1_VALGRIND "AUTO" CACHE STRING "Build with extra checks for running inside Valgrind. [default=AUTO]") +set_property(CACHE SECP256K1_VALGRIND PROPERTY STRINGS "AUTO" "OFF" "ON") +check_string_option_value(SECP256K1_VALGRIND) +if(SECP256K1_VALGRIND) + find_package(Valgrind MODULE) + if(Valgrind_FOUND) + set(SECP256K1_VALGRIND ON) + include_directories(${Valgrind_INCLUDE_DIR}) + add_compile_definitions(VALGRIND) + elseif(SECP256K1_VALGRIND STREQUAL "AUTO") + set(SECP256K1_VALGRIND OFF) + else() + message(FATAL_ERROR "Valgrind support requested but valgrind/memcheck.h header not available.") + endif() +endif() + +option(SECP256K1_BUILD_BENCHMARK "Build benchmarks." ON) +option(SECP256K1_BUILD_TESTS "Build tests." ON) +option(SECP256K1_BUILD_EXHAUSTIVE_TESTS "Build exhaustive tests." ON) + +# Redefine configuration flags. +# We leave assertions on, because they are only used in the examples, and we want them always on there. +if(MSVC) + string(REGEX REPLACE "/DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}") + string(REGEX REPLACE "/DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}") + string(REGEX REPLACE "/DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL}") +else() + string(REGEX REPLACE "-DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}") + string(REGEX REPLACE "-DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}") + string(REGEX REPLACE "-DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL}") + # Prefer -O2 optimization level. (-O3 is CMake's default for Release for many compilers.) + string(REGEX REPLACE "-O3( |$)" "-O2\\1" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}") +endif() + +# Define custom "Coverage" build type. +set(CMAKE_C_FLAGS_COVERAGE "${CMAKE_C_FLAGS_RELWITHDEBINFO} -O0 -DCOVERAGE=1 --coverage" CACHE STRING + "Flags used by the C compiler during \"Coverage\" builds." + FORCE +) +set(CMAKE_EXE_LINKER_FLAGS_COVERAGE "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO} --coverage" CACHE STRING + "Flags used for linking binaries during \"Coverage\" builds." + FORCE +) +set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE "${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO} --coverage" CACHE STRING + "Flags used by the shared libraries linker during \"Coverage\" builds." + FORCE +) +mark_as_advanced( + CMAKE_C_FLAGS_COVERAGE + CMAKE_EXE_LINKER_FLAGS_COVERAGE + CMAKE_SHARED_LINKER_FLAGS_COVERAGE +) + +if(PROJECT_IS_TOP_LEVEL) + get_property(is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) + set(default_build_type "RelWithDebInfo") + if(is_multi_config) + set(CMAKE_CONFIGURATION_TYPES "${default_build_type}" "Release" "Debug" "MinSizeRel" "Coverage" CACHE STRING + "Supported configuration types." + FORCE + ) + else() + set_property(CACHE CMAKE_BUILD_TYPE PROPERTY + STRINGS "${default_build_type}" "Release" "Debug" "MinSizeRel" "Coverage" + ) + if(NOT CMAKE_BUILD_TYPE) + 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 + ) + endif() + endif() +endif() + +include(TryAppendCFlags) +if(MSVC) + # Keep the following commands ordered lexicographically. + try_append_c_flags(/W3) # Production quality warning level. + try_append_c_flags(/wd4146) # Disable warning C4146 "unary minus operator applied to unsigned type, result still unsigned". + try_append_c_flags(/wd4244) # Disable warning C4244 "'conversion' conversion from 'type1' to 'type2', possible loss of data". + try_append_c_flags(/wd4267) # Disable warning C4267 "'var' : conversion from 'size_t' to 'type', possible loss of data". + # Eliminate deprecation warnings for the older, less secure functions. + add_compile_definitions(_CRT_SECURE_NO_WARNINGS) +else() + # Keep the following commands ordered lexicographically. + try_append_c_flags(-pedantic) + try_append_c_flags(-Wall) # GCC >= 2.95 and probably many other compilers. + try_append_c_flags(-Wcast-align) # GCC >= 2.95. + try_append_c_flags(-Wcast-align=strict) # GCC >= 8.0. + try_append_c_flags(-Wconditional-uninitialized) # Clang >= 3.0 only. + try_append_c_flags(-Wextra) # GCC >= 3.4, this is the newer name of -W, which we don't use because older GCCs will warn about unused functions. + try_append_c_flags(-Wnested-externs) + try_append_c_flags(-Wno-long-long) # GCC >= 3.0, -Wlong-long is implied by -pedantic. + try_append_c_flags(-Wno-overlength-strings) # GCC >= 4.2, -Woverlength-strings is implied by -pedantic. + try_append_c_flags(-Wno-unused-function) # GCC >= 3.0, -Wunused-function is implied by -Wall. + try_append_c_flags(-Wreserved-identifier) # Clang >= 13.0 only. + try_append_c_flags(-Wshadow) + try_append_c_flags(-Wstrict-prototypes) + try_append_c_flags(-Wundef) +endif() + +set(CMAKE_C_VISIBILITY_PRESET default) +set(CMAKE_CXX_VISIBILITY_PRESET default) + +set(SECP256K1_APPEND_CFLAGS "" CACHE STRING "Compiler flags that are appended to the command line after all other flags added by the build system. This variable is intended for debugging and special builds.") +if(SECP256K1_APPEND_CFLAGS) + # Appending to this low-level rule variable is the only way to + # guarantee that the flags appear at the end of the command line. + string(APPEND CMAKE_C_COMPILE_OBJECT " ${SECP256K1_APPEND_CFLAGS}") +endif() + +set(SECP256K1_APPEND_LDFLAGS "" CACHE STRING "Linker flags that are appended to the command line after all other flags added by the build system. This variable is intended for debugging and special builds.") +if(SECP256K1_APPEND_LDFLAGS) + # Appending to this low-level rule variable is the only way to + # guarantee that the flags appear at the end of the command line. + string(APPEND CMAKE_C_CREATE_SHARED_LIBRARY " ${SECP256K1_APPEND_LDFLAGS}") + string(APPEND CMAKE_C_LINK_EXECUTABLE " ${SECP256K1_APPEND_LDFLAGS}") +endif() + +if(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY) + set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin) +endif() +if(NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY) + set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib) +endif() +if(NOT CMAKE_ARCHIVE_OUTPUT_DIRECTORY) + set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib) +endif() + +# secp256k1 configuration +include(CheckTypeSize) +check_type_size("__int128" SIZEOF__int128) +message(STATUS "Size of __int128 : ${SIZEOF__int128}") + +if(${SIZEOF__int128} EQUAL 16) + add_compile_definitions(HAVE___INT128=1) +else() + message(FATAL_ERROR "secp256k1 requires __int128 type.") +endif() + +# Select field implementation +if(CMAKE_SIZEOF_VOID_P EQUAL 8) + # 64 bits + add_compile_definitions(USE_FIELD_5X52=1) # Define this symbol to use the FIELD_5X52 implementation + add_compile_definitions(USE_SCALAR_4X64=1) # Define this symbol to use the 4x64 scalar implementation + +elseif(CMAKE_SIZEOF_VOID_P EQUAL 4) + # 32 bits + add_compile_definitions(USE_FIELD_10X26=1) # Define this symbol to use the FIELD_10X26 implementation + add_compile_definitions(USE_SCALAR_8X32=1) # Define this symbol to use the 8x32 scalar implementation +else() + message(FATAL_ERROR "Invalid architecture.") +endif() + +add_subdirectory(src) + +message("\n") +message("secp256k1 configure summary") +message("===========================") +message("Build artifacts:") +if(BUILD_SHARED_LIBS) + set(library_type "Shared") +else() + set(library_type "Static") +endif() + +message(" library type ........................ ${library_type}") +message("Optional modules:") +message(" ECDH ................................ ${SECP256K1_ENABLE_MODULE_ECDH}") +message(" ECDSA pubkey recovery ............... ${SECP256K1_ENABLE_MODULE_RECOVERY}") +message("Parameters:") +message(" ecmult window size .................. ${SECP256K1_ECMULT_WINDOW_SIZE}") +message(" ecmult gen table size ............... ${SECP256K1_ECMULT_GEN_KB} KiB") +message("Optional features:") +message(" assembly ............................ ${SECP256K1_ASM}") +if(SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY) + message(" wide multiplication (test-only) ..... ${SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY}") +endif() +message("Optional binaries:") +message(" benchmark ........................... ${SECP256K1_BUILD_BENCHMARK}") +message(" noverify_tests ...................... ${SECP256K1_BUILD_TESTS}") +set(tests_status "${SECP256K1_BUILD_TESTS}") +if(CMAKE_BUILD_TYPE STREQUAL "Coverage") + set(tests_status OFF) +endif() +message(" tests ............................... ${tests_status}") +message(" exhaustive tests .................... ${SECP256K1_BUILD_EXHAUSTIVE_TESTS}") +message("") +if(CMAKE_CROSSCOMPILING) + set(cross_status "TRUE, for ${CMAKE_SYSTEM_NAME}, ${CMAKE_SYSTEM_PROCESSOR}") +else() + set(cross_status "FALSE") +endif() +message("Cross compiling ....................... ${cross_status}") +message("Valgrind .............................. ${SECP256K1_VALGRIND}") +get_directory_property(definitions COMPILE_DEFINITIONS) +string(REPLACE ";" " " definitions "${definitions}") +message("Preprocessor defined macros ........... ${definitions}") +message("C compiler ............................ ${CMAKE_C_COMPILER_ID} ${CMAKE_C_COMPILER_VERSION}, ${CMAKE_C_COMPILER}") +message("CFLAGS ................................ ${CMAKE_C_FLAGS}") +get_directory_property(compile_options COMPILE_OPTIONS) +string(REPLACE ";" " " compile_options "${compile_options}") +message("Compile options ....................... " ${compile_options}) +if(NOT is_multi_config) + message("Build type:") + message(" - CMAKE_BUILD_TYPE ................... ${CMAKE_BUILD_TYPE}") + string(TOUPPER "${CMAKE_BUILD_TYPE}" build_type) + message(" - CFLAGS ............................. ${CMAKE_C_FLAGS_${build_type}}") + message(" - LDFLAGS for executables ............ ${CMAKE_EXE_LINKER_FLAGS_${build_type}}") + message(" - LDFLAGS for shared libraries ....... ${CMAKE_SHARED_LINKER_FLAGS_${build_type}}") +else() + message("Supported configurations .............. ${CMAKE_CONFIGURATION_TYPES}") + message("RelWithDebInfo configuration:") + message(" - CFLAGS ............................. ${CMAKE_C_FLAGS_RELWITHDEBINFO}") + message(" - LDFLAGS for executables ............ ${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO}") + message(" - LDFLAGS for shared libraries ....... ${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO}") + message("Debug configuration:") + message(" - CFLAGS ............................. ${CMAKE_C_FLAGS_DEBUG}") + message(" - LDFLAGS for executables ............ ${CMAKE_EXE_LINKER_FLAGS_DEBUG}") + message(" - LDFLAGS for shared libraries ....... ${CMAKE_SHARED_LINKER_FLAGS_DEBUG}") +endif() +if(SECP256K1_APPEND_CFLAGS) + message("SECP256K1_APPEND_CFLAGS ............... ${SECP256K1_APPEND_CFLAGS}") +endif() +if(SECP256K1_APPEND_LDFLAGS) + message("SECP256K1_APPEND_LDFLAGS .............. ${SECP256K1_APPEND_LDFLAGS}") +endif() +message("") +if(SECP256K1_EXPERIMENTAL) + message( + " ******\n" + " WARNING: experimental build\n" + " Experimental features do not have stable APIs or properties, and may not be safe for production use.\n" + " ******\n" + ) +endif() \ No newline at end of file diff --git a/src/secp256k1/cmake/CheckArm32Assembly.cmake b/src/secp256k1/cmake/CheckArm32Assembly.cmake new file mode 100644 index 0000000000..baeeff0292 --- /dev/null +++ b/src/secp256k1/cmake/CheckArm32Assembly.cmake @@ -0,0 +1,6 @@ +function(check_arm32_assembly) + try_compile(HAVE_ARM32_ASM + ${PROJECT_BINARY_DIR}/check_arm32_assembly + SOURCES ${PROJECT_SOURCE_DIR}/cmake/source_arm32.s + ) +endfunction() diff --git a/src/secp256k1/cmake/CheckMemorySanitizer.cmake b/src/secp256k1/cmake/CheckMemorySanitizer.cmake new file mode 100644 index 0000000000..d9ef681e65 --- /dev/null +++ b/src/secp256k1/cmake/CheckMemorySanitizer.cmake @@ -0,0 +1,18 @@ +include_guard(GLOBAL) +include(CheckCSourceCompiles) + +function(check_memory_sanitizer output) + set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY) + check_c_source_compiles(" + #if defined(__has_feature) + # if __has_feature(memory_sanitizer) + /* MemorySanitizer is enabled. */ + # elif + # error \"MemorySanitizer is disabled.\" + # endif + #else + # error \"__has_feature is not defined.\" + #endif + " HAVE_MSAN) + set(${output} ${HAVE_MSAN} PARENT_SCOPE) +endfunction() diff --git a/src/secp256k1/cmake/CheckStringOptionValue.cmake b/src/secp256k1/cmake/CheckStringOptionValue.cmake new file mode 100644 index 0000000000..5a4d939b9e --- /dev/null +++ b/src/secp256k1/cmake/CheckStringOptionValue.cmake @@ -0,0 +1,10 @@ +function(check_string_option_value option) + get_property(expected_values CACHE ${option} PROPERTY STRINGS) + if(expected_values) + if(${option} IN_LIST expected_values) + return() + endif() + message(FATAL_ERROR "${option} value is \"${${option}}\", but must be one of ${expected_values}.") + endif() + message(AUTHOR_WARNING "The STRINGS property must be set before invoking `check_string_option_value' function.") +endfunction() diff --git a/src/secp256k1/cmake/CheckX86_64Assembly.cmake b/src/secp256k1/cmake/CheckX86_64Assembly.cmake new file mode 100644 index 0000000000..ae82cd476e --- /dev/null +++ b/src/secp256k1/cmake/CheckX86_64Assembly.cmake @@ -0,0 +1,14 @@ +include(CheckCSourceCompiles) + +function(check_x86_64_assembly) + check_c_source_compiles(" + #include + + int main() + { + uint64_t a = 11, tmp; + __asm__ __volatile__(\"movq $0x100000000,%1; mulq %%rsi\" : \"+a\"(a) : \"S\"(tmp) : \"cc\", \"%rdx\"); + } + " HAVE_X86_64_ASM) + set(HAVE_X86_64_ASM ${HAVE_X86_64_ASM} PARENT_SCOPE) +endfunction() diff --git a/src/secp256k1/cmake/FindGMP.cmake b/src/secp256k1/cmake/FindGMP.cmake new file mode 100644 index 0000000000..87a4ec5db7 --- /dev/null +++ b/src/secp256k1/cmake/FindGMP.cmake @@ -0,0 +1,46 @@ +find_package(PkgConfig QUIET) +if(PKG_CONFIG_FOUND) + pkg_check_modules(PC_GMP QUIET gmp) +endif() + +find_path(GMP_INCLUDES + NAMES + gmp.h + HINTS + $ENV{GMPDIR} + ${INCLUDE_INSTALL_DIR} + ${PC_GMP_INCLUDE_DIRS} + /usr/include + /usr/local/include +) + +find_library(GMP_LIBRARIES + NAMES gmp + HINTS + $ENV{GMPDIR} + ${LIB_INSTALL_DIR} + ${PC_GMP_LIBRARY_DIRS} + /usr/lib + /usr/local/lib +) + +# Define this symbol if libgmp is installed +add_compile_definitions(HAVE_LIBGMP=1) +# Define this symbol to use the gmp implementation for num +add_compile_definitions(USE_NUM_GMP=1) +# Define this symbol to use the num-based field inverse implementation +add_compile_definitions(USE_FIELD_INV_NUM=1) +# Define this symbol to use the num-based scalar inverse implementation +add_compile_definitions(USE_SCALAR_INV_NUM=1) + +if(GMP_INCLUDES) + file(STRINGS "${GMP_INCLUDES}/gmp.h" gmp_version_str REGEX "^#define[\t ]+__GNU_MP_VERSION[\t ]+[0-9]+") + string(REGEX REPLACE "^#define[\t ]+__GNU_MP_VERSION[\t ]+([0-9]+).*" "\\1" GMP_VERSION_MAJOR "${gmp_version_str}") + + file(STRINGS "${GMP_INCLUDES}/gmp.h" gmp_version_str REGEX "^#define[\t ]+__GNU_MP_VERSION_MINOR[\t ]+[0-9]+") + string(REGEX REPLACE "^#define[\t ]+__GNU_MP_VERSION_MINOR[\t ]+([0-9]+).*" "\\1" GMP_VERSION_MINOR "${gmp_version_str}") + + set(GMP_VERSION "${GMP_VERSION_MAJOR}.${GMP_VERSION_MINOR}") + message(STATUS "GMP_VERSION_MAJOR : ${GMP_VERSION_MAJOR}") + message(STATUS "GMP_VERSION_MINOR : ${GMP_VERSION_MINOR}") +endif() \ No newline at end of file diff --git a/src/secp256k1/cmake/FindValgrind.cmake b/src/secp256k1/cmake/FindValgrind.cmake new file mode 100644 index 0000000000..3af5e691e4 --- /dev/null +++ b/src/secp256k1/cmake/FindValgrind.cmake @@ -0,0 +1,41 @@ +if(CMAKE_HOST_APPLE) + find_program(BREW_COMMAND brew) + execute_process( + COMMAND ${BREW_COMMAND} --prefix valgrind + OUTPUT_VARIABLE valgrind_brew_prefix + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE + ) +endif() + +set(hints_paths) +if(valgrind_brew_prefix) + set(hints_paths ${valgrind_brew_prefix}/include) +endif() + +find_path(Valgrind_INCLUDE_DIR + NAMES valgrind/memcheck.h + HINTS ${hints_paths} +) + +if(Valgrind_INCLUDE_DIR) + include(CheckCSourceCompiles) + set(CMAKE_REQUIRED_INCLUDES ${Valgrind_INCLUDE_DIR}) + check_c_source_compiles(" + #include + #if defined(NVALGRIND) + # error \"Valgrind does not support this platform.\" + #endif + + int main() {} + " Valgrind_WORKS) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Valgrind + REQUIRED_VARS Valgrind_INCLUDE_DIR Valgrind_WORKS +) + +mark_as_advanced( + Valgrind_INCLUDE_DIR +) diff --git a/src/secp256k1/cmake/GeneratePkgConfigFile.cmake b/src/secp256k1/cmake/GeneratePkgConfigFile.cmake new file mode 100644 index 0000000000..9c1d7f1ddd --- /dev/null +++ b/src/secp256k1/cmake/GeneratePkgConfigFile.cmake @@ -0,0 +1,8 @@ +function(generate_pkg_config_file in_file) + set(prefix ${CMAKE_INSTALL_PREFIX}) + set(exec_prefix \${prefix}) + set(libdir \${exec_prefix}/${CMAKE_INSTALL_LIBDIR}) + set(includedir \${prefix}/${CMAKE_INSTALL_INCLUDEDIR}) + set(PACKAGE_VERSION ${PROJECT_VERSION}) + configure_file(${in_file} ${PROJECT_NAME}.pc @ONLY) +endfunction() diff --git a/src/secp256k1/cmake/TryAppendCFlags.cmake b/src/secp256k1/cmake/TryAppendCFlags.cmake new file mode 100644 index 0000000000..1d81a9317a --- /dev/null +++ b/src/secp256k1/cmake/TryAppendCFlags.cmake @@ -0,0 +1,24 @@ +include(CheckCCompilerFlag) + +function(secp256k1_check_c_flags_internal flags output) + string(MAKE_C_IDENTIFIER "${flags}" result) + string(TOUPPER "${result}" result) + set(result "C_SUPPORTS_${result}") + if(NOT MSVC) + set(CMAKE_REQUIRED_FLAGS "-Werror") + endif() + + # This avoids running a linker. + set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY) + check_c_compiler_flag("${flags}" ${result}) + + set(${output} ${${result}} PARENT_SCOPE) +endfunction() + +# Append flags to the COMPILE_OPTIONS directory property if CC accepts them. +macro(try_append_c_flags) + secp256k1_check_c_flags_internal("${ARGV}" result) + if(result) + add_compile_options(${ARGV}) + endif() +endmacro() diff --git a/src/secp256k1/cmake/arm-linux-gnueabihf.toolchain.cmake b/src/secp256k1/cmake/arm-linux-gnueabihf.toolchain.cmake new file mode 100644 index 0000000000..0d91912b6d --- /dev/null +++ b/src/secp256k1/cmake/arm-linux-gnueabihf.toolchain.cmake @@ -0,0 +1,3 @@ +set(CMAKE_SYSTEM_NAME Linux) +set(CMAKE_SYSTEM_PROCESSOR arm) +set(CMAKE_C_COMPILER arm-linux-gnueabihf-gcc) diff --git a/src/secp256k1/cmake/config.cmake.in b/src/secp256k1/cmake/config.cmake.in new file mode 100644 index 0000000000..46b180ab19 --- /dev/null +++ b/src/secp256k1/cmake/config.cmake.in @@ -0,0 +1,5 @@ +@PACKAGE_INIT@ + +include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@-targets.cmake") + +check_required_components(@PROJECT_NAME@) diff --git a/src/secp256k1/cmake/source_arm32.s b/src/secp256k1/cmake/source_arm32.s new file mode 100644 index 0000000000..d3d9347057 --- /dev/null +++ b/src/secp256k1/cmake/source_arm32.s @@ -0,0 +1,9 @@ +.syntax unified +.eabi_attribute 24, 1 +.eabi_attribute 25, 1 +.text +.global main +main: + ldr r0, =0x002A + mov r7, #1 + swi 0 diff --git a/src/secp256k1/cmake/x86_64-w64-mingw32.toolchain.cmake b/src/secp256k1/cmake/x86_64-w64-mingw32.toolchain.cmake new file mode 100644 index 0000000000..96119b72d1 --- /dev/null +++ b/src/secp256k1/cmake/x86_64-w64-mingw32.toolchain.cmake @@ -0,0 +1,3 @@ +set(CMAKE_SYSTEM_NAME Windows) +set(CMAKE_SYSTEM_PROCESSOR x86_64) +set(CMAKE_C_COMPILER x86_64-w64-mingw32-gcc) diff --git a/src/secp256k1/src/CMakeLists.txt b/src/secp256k1/src/CMakeLists.txt new file mode 100644 index 0000000000..f0d641287c --- /dev/null +++ b/src/secp256k1/src/CMakeLists.txt @@ -0,0 +1,181 @@ +# Must be included before CMAKE_INSTALL_INCLUDEDIR is used. +include(GNUInstallDirs) + +# Add objects explicitly rather than linking to the object libs to keep them +# from being exported. +add_library(secp256k1 OBJECT secp256k1.c) + +target_link_libraries(secp256k1 PUBLIC gmp) + +set_property(TARGET secp256k1 PROPERTY POSITION_INDEPENDENT_CODE ON) + +add_library(secp256k1pp + cpp/GroupElement.cpp + cpp/MultiExponent.cpp + cpp/Scalar.cpp +) + +target_link_libraries(secp256k1 + PUBLIC + gmp + PRIVATE + OpenSSL::Crypto +) + +target_link_libraries(secp256k1pp + PUBLIC secp256k1 +) + +add_library(secp256k1_asm INTERFACE) +if(SECP256K1_ASM STREQUAL "arm32") + add_library(secp256k1_asm_arm OBJECT EXCLUDE_FROM_ALL) + target_sources(secp256k1_asm_arm PUBLIC + asm/field_10x26_arm.s + ) + target_sources(secp256k1 PRIVATE $) + target_link_libraries(secp256k1_asm INTERFACE secp256k1_asm_arm) +endif() + +if(WIN32) + # Define our export symbol only for shared libs. + set_target_properties(secp256k1 PROPERTIES DEFINE_SYMBOL SECP256K1_DLL_EXPORT) + target_compile_definitions(secp256k1 INTERFACE $<$>:SECP256K1_STATIC>) +endif() + +# Object libs don't know if they're being built for a shared or static lib. +# Grab the PIC property from secp256k1 which knows. +get_target_property(use_pic secp256k1 POSITION_INDEPENDENT_CODE) + +target_include_directories(secp256k1 INTERFACE + # Add the include path for parent projects so that they don't have to manually add it. + $>:${PROJECT_SOURCE_DIR}/include>> + $ +) + +# This emulates Libtool to make sure Libtool and CMake agree on the ABI version, +# see below "Calculate the version variables" in build-aux/ltmain.sh. +math(EXPR ${PROJECT_NAME}_soversion "${${PROJECT_NAME}_LIB_VERSION_CURRENT} - ${${PROJECT_NAME}_LIB_VERSION_AGE}") +set_target_properties(secp256k1 PROPERTIES + SOVERSION ${${PROJECT_NAME}_soversion} +) +if(CMAKE_SYSTEM_NAME STREQUAL "Linux") + set_target_properties(secp256k1 PROPERTIES + VERSION ${${PROJECT_NAME}_soversion}.${${PROJECT_NAME}_LIB_VERSION_AGE}.${${PROJECT_NAME}_LIB_VERSION_REVISION} + ) +elseif(APPLE) + if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.17) + math(EXPR ${PROJECT_NAME}_compatibility_version "${${PROJECT_NAME}_LIB_VERSION_CURRENT} + 1") + set_target_properties(secp256k1 PROPERTIES + MACHO_COMPATIBILITY_VERSION ${${PROJECT_NAME}_compatibility_version} + MACHO_CURRENT_VERSION ${${PROJECT_NAME}_compatibility_version}.${${PROJECT_NAME}_LIB_VERSION_REVISION} + ) + unset(${PROJECT_NAME}_compatibility_version) + elseif(BUILD_SHARED_LIBS) + message(WARNING + "The 'compatibility version' and 'current version' values of the DYLIB " + "will diverge from the values set by the GNU Libtool. To ensure " + "compatibility, it is recommended to upgrade CMake to at least version 3.17." + ) + endif() +elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows") + set(${PROJECT_NAME}_windows "secp256k1") + if(MSVC) + set(${PROJECT_NAME}_windows "${PROJECT_NAME}") + endif() + set_target_properties(secp256k1 PROPERTIES + ARCHIVE_OUTPUT_NAME "${${PROJECT_NAME}_windows}" + RUNTIME_OUTPUT_NAME "${${PROJECT_NAME}_windows}-${${PROJECT_NAME}_soversion}" + ) + unset(${PROJECT_NAME}_windows) +endif() +unset(${PROJECT_NAME}_soversion) + +if(SECP256K1_BUILD_BENCHMARK) + add_executable(bench_ecdh bench_ecdh.c) + target_link_libraries(bench_ecdh PUBLIC secp256k1) + add_executable(bench_recover bench_recover.c) + target_link_libraries(bench_recover PUBLIC secp256k1) + add_executable(bench_sign bench_sign.c) + target_link_libraries(bench_sign PUBLIC secp256k1) + add_executable(bench_verify bench_verify.c) + target_link_libraries(bench_verify PUBLIC secp256k1) + add_executable(bench_internal bench_internal.c) + target_link_libraries(bench_internal PUBLIC secp256k1_asm gmp) +endif() + +if(SECP256K1_BUILD_TESTS) + add_executable(noverify_tests tests.c) + target_compile_definitions(noverify_tests PRIVATE VERIFY) + target_link_libraries(noverify_tests secp256k1_asm gmp) + add_test(NAME secp256k1_noverify_tests COMMAND noverify_tests) + if(NOT CMAKE_BUILD_TYPE STREQUAL "Coverage") + add_executable(tests tests.c) + target_compile_definitions(tests PRIVATE VERIFY) + target_link_libraries(tests secp256k1_asm gmp) + add_test(NAME secp256k1_tests COMMAND tests) + endif() +endif() + +if(SECP256K1_BUILD_EXHAUSTIVE_TESTS) + # Note: do not include secp256k1_precomputed in exhaustive_tests (it uses runtime-generated tables). + add_executable(exhaustive_tests tests_exhaustive.c) + target_link_libraries(exhaustive_tests secp256k1_asm gmp) + target_compile_definitions(exhaustive_tests PRIVATE $<$>:VERIFY>) + add_test(NAME secp256k1_exhaustive_tests COMMAND exhaustive_tests) +endif() + +if(SECP256K1_INSTALL) + install(TARGETS secp256k1 + EXPORT ${PROJECT_NAME}-targets + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + ) + set(${PROJECT_NAME}_headers + "${PROJECT_SOURCE_DIR}/include/secp256k1.h" + ) + if(SECP256K1_ENABLE_MODULE_ECDH) + list(APPEND ${PROJECT_NAME}_headers "${PROJECT_SOURCE_DIR}/include/secp256k1_ecdh.h") + endif() + if(SECP256K1_ENABLE_MODULE_RECOVERY) + list(APPEND ${PROJECT_NAME}_headers "${PROJECT_SOURCE_DIR}/include/secp256k1_recovery.h") + endif() + if(SECP256K1_ENABLE_MODULE_SCHNORR) + list(APPEND ${PROJECT_NAME}_headers "${PROJECT_SOURCE_DIR}/include/secp256k1_schnorr.h") + endif() + install(FILES ${${PROJECT_NAME}_headers} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} + ) + + install(EXPORT ${PROJECT_NAME}-targets + FILE ${PROJECT_NAME}-targets.cmake + NAMESPACE ${PROJECT_NAME}:: + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME} + ) + + include(CMakePackageConfigHelpers) + configure_package_config_file( + ${PROJECT_SOURCE_DIR}/cmake/config.cmake.in + ${PROJECT_NAME}-config.cmake + INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME} + NO_SET_AND_CHECK_MACRO + ) + write_basic_package_version_file(${PROJECT_NAME}-config-version.cmake + COMPATIBILITY SameMinorVersion + ) + + install( + FILES + ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config.cmake + ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME} + ) + + include(GeneratePkgConfigFile) + generate_pkg_config_file(${PROJECT_SOURCE_DIR}/libsecp256k1.pc.in) + install( + FILES + ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc + DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig + ) +endif() diff --git a/src/secp256k1/src/secp256k1.c b/src/secp256k1/src/secp256k1.c index fb8b882faa..60d36c1cf9 100755 --- a/src/secp256k1/src/secp256k1.c +++ b/src/secp256k1/src/secp256k1.c @@ -552,10 +552,6 @@ int secp256k1_ec_pubkey_combine(const secp256k1_context* ctx, secp256k1_pubkey * # include "modules/ecdh/main_impl.h" #endif -#ifdef ENABLE_MODULE_SCHNORR -# include "modules/schnorr/main_impl.h" -#endif - #ifdef ENABLE_MODULE_RECOVERY # include "modules/recovery/main_impl.h" #endif From 8f134da152ce4968be19676695b58ca2af59beb2 Mon Sep 17 00:00:00 2001 From: AlefLm Date: Sun, 15 Dec 2024 00:53:41 +0000 Subject: [PATCH 02/19] cmake: add cmake folder --- cmake/bitcoin-build-config.h.in | 150 ++++++++++++ cmake/ccache.cmake | 28 +++ cmake/cov_tool_wrapper.sh.in | 5 + cmake/crc32c.cmake | 123 ++++++++++ cmake/introspection.cmake | 227 ++++++++++++++++++ cmake/leveldb.cmake | 105 ++++++++ cmake/minisketch.cmake | 91 +++++++ cmake/module/AddBoostIfNeeded.cmake | 78 ++++++ cmake/module/AddWindowsResources.cmake | 14 ++ .../module/CheckSourceCompilesAndLinks.cmake | 39 +++ cmake/module/FindBerkeleyDB.cmake | 133 ++++++++++ cmake/module/FindLibevent.cmake | 86 +++++++ cmake/module/FindQRencode.cmake | 71 ++++++ cmake/module/FindQt.cmake | 66 +++++ cmake/module/FindUSDT.cmake | 67 ++++++ cmake/module/FindZeroMQ.cmake | 41 ++++ cmake/module/FlagsSummary.cmake | 74 ++++++ cmake/module/GenerateHeaders.cmake | 21 ++ cmake/module/GenerateSetupNsi.cmake | 18 ++ cmake/module/GetTargetInterface.cmake | 53 ++++ cmake/module/Maintenance.cmake | 151 ++++++++++++ cmake/module/ProcessConfigurations.cmake | 175 ++++++++++++++ .../module/TestAppendRequiredLibraries.cmake | 92 +++++++ cmake/module/TryAppendCXXFlags.cmake | 125 ++++++++++ cmake/module/TryAppendLinkerFlag.cmake | 78 ++++++ cmake/module/WarnAboutGlobalProperties.cmake | 36 +++ cmake/script/Coverage.cmake | 89 +++++++ cmake/script/CoverageFuzz.cmake | 53 ++++ cmake/script/CoverageInclude.cmake.in | 59 +++++ cmake/script/GenerateBuildInfo.cmake | 113 +++++++++ cmake/script/GenerateHeaderFromJson.cmake | 22 ++ cmake/script/GenerateHeaderFromRaw.cmake | 23 ++ cmake/script/macos_zip.sh | 12 + cmake/tests.cmake | 15 ++ 34 files changed, 2533 insertions(+) create mode 100644 cmake/bitcoin-build-config.h.in create mode 100644 cmake/ccache.cmake create mode 100644 cmake/cov_tool_wrapper.sh.in create mode 100644 cmake/crc32c.cmake create mode 100644 cmake/introspection.cmake create mode 100644 cmake/leveldb.cmake create mode 100644 cmake/minisketch.cmake create mode 100644 cmake/module/AddBoostIfNeeded.cmake create mode 100644 cmake/module/AddWindowsResources.cmake create mode 100644 cmake/module/CheckSourceCompilesAndLinks.cmake create mode 100644 cmake/module/FindBerkeleyDB.cmake create mode 100644 cmake/module/FindLibevent.cmake create mode 100644 cmake/module/FindQRencode.cmake create mode 100644 cmake/module/FindQt.cmake create mode 100644 cmake/module/FindUSDT.cmake create mode 100644 cmake/module/FindZeroMQ.cmake create mode 100644 cmake/module/FlagsSummary.cmake create mode 100644 cmake/module/GenerateHeaders.cmake create mode 100644 cmake/module/GenerateSetupNsi.cmake create mode 100644 cmake/module/GetTargetInterface.cmake create mode 100644 cmake/module/Maintenance.cmake create mode 100644 cmake/module/ProcessConfigurations.cmake create mode 100644 cmake/module/TestAppendRequiredLibraries.cmake create mode 100644 cmake/module/TryAppendCXXFlags.cmake create mode 100644 cmake/module/TryAppendLinkerFlag.cmake create mode 100644 cmake/module/WarnAboutGlobalProperties.cmake create mode 100644 cmake/script/Coverage.cmake create mode 100644 cmake/script/CoverageFuzz.cmake create mode 100644 cmake/script/CoverageInclude.cmake.in create mode 100644 cmake/script/GenerateBuildInfo.cmake create mode 100644 cmake/script/GenerateHeaderFromJson.cmake create mode 100644 cmake/script/GenerateHeaderFromRaw.cmake create mode 100755 cmake/script/macos_zip.sh create mode 100644 cmake/tests.cmake diff --git a/cmake/bitcoin-build-config.h.in b/cmake/bitcoin-build-config.h.in new file mode 100644 index 0000000000..56e0519fac --- /dev/null +++ b/cmake/bitcoin-build-config.h.in @@ -0,0 +1,150 @@ +// Copyright (c) 2023-present The Bitcoin Core developers +// Distributed under the MIT software license, see the accompanying +// file COPYING or https://opensource.org/license/mit/. + +#ifndef BITCOIN_CONFIG_H +#define BITCOIN_CONFIG_H + +/* Version Build */ +#define CLIENT_VERSION_BUILD @CLIENT_VERSION_BUILD@ + +/* Version is release */ +#define CLIENT_VERSION_IS_RELEASE @CLIENT_VERSION_IS_RELEASE@ + +/* Major version */ +#define CLIENT_VERSION_MAJOR @CLIENT_VERSION_MAJOR@ + +/* Minor version */ +#define CLIENT_VERSION_MINOR @CLIENT_VERSION_MINOR@ + +/* Copyright holder(s) before %s replacement */ +#define COPYRIGHT_HOLDERS "@COPYRIGHT_HOLDERS@" + +/* Copyright holder(s) */ +#define COPYRIGHT_HOLDERS_FINAL "@COPYRIGHT_HOLDERS_FINAL@" + +/* Replacement for %s in copyright holders string */ +#define COPYRIGHT_HOLDERS_SUBSTITUTION "@CLIENT_NAME@" + +/* Copyright year */ +#define COPYRIGHT_YEAR @COPYRIGHT_YEAR@ + +/* Define this symbol to build code that uses ARMv8 SHA-NI intrinsics */ +#cmakedefine ENABLE_ARM_SHANI 1 + +/* Define this symbol to build code that uses AVX2 intrinsics */ +#cmakedefine ENABLE_AVX2 1 + +/* Define if external signer support is enabled */ +#cmakedefine ENABLE_EXTERNAL_SIGNER 1 + +/* Define this symbol to build code that uses SSE4.1 intrinsics */ +#cmakedefine ENABLE_SSE41 1 + +/* Define to 1 to enable tracepoints for Userspace, Statically Defined Tracing + */ +#cmakedefine ENABLE_TRACING 1 + +/* Define to 1 to enable wallet functions. */ +#cmakedefine ENABLE_WALLET 1 + +/* Define this symbol to build code that uses x86 SHA-NI intrinsics */ +#cmakedefine ENABLE_X86_SHANI 1 + +/* Define to 1 if you have the declaration of `fork', and to 0 if you don't. + */ +#cmakedefine01 HAVE_DECL_FORK + +/* Define to 1 if you have the declaration of `freeifaddrs', and to 0 if you + don't. */ +#cmakedefine01 HAVE_DECL_FREEIFADDRS + +/* Define to 1 if you have the declaration of `getifaddrs', and to 0 if you + don't. */ +#cmakedefine01 HAVE_DECL_GETIFADDRS + +/* Define to 1 if you have the declaration of `pipe2', and to 0 if you don't. + */ +#cmakedefine01 HAVE_DECL_PIPE2 + +/* Define to 1 if you have the declaration of `setsid', and to 0 if you don't. + */ +#cmakedefine01 HAVE_DECL_SETSID + +/* Define to 1 if fdatasync is available. */ +#cmakedefine HAVE_FDATASYNC 1 + +/* Define this symbol if the BSD getentropy system call is available with + sys/random.h */ +#cmakedefine HAVE_GETENTROPY_RAND 1 + +/* Define this symbol if the Linux getrandom function call is available */ +#cmakedefine HAVE_GETRANDOM 1 + +/* Define this symbol if you have malloc_info */ +#cmakedefine HAVE_MALLOC_INFO 1 + +/* Define this symbol if you have mallopt with M_ARENA_MAX */ +#cmakedefine HAVE_MALLOPT_ARENA_MAX 1 + +/* Define to 1 if O_CLOEXEC flag is available. */ +#cmakedefine01 HAVE_O_CLOEXEC + +/* Define this symbol if you have posix_fallocate */ +#cmakedefine HAVE_POSIX_FALLOCATE 1 + +/* Define this symbol if platform supports unix domain sockets */ +#cmakedefine HAVE_SOCKADDR_UN 1 + +/* Define this symbol to build code that uses getauxval */ +#cmakedefine HAVE_STRONG_GETAUXVAL 1 + +/* Define this symbol if the BSD sysctl() is available */ +#cmakedefine HAVE_SYSCTL 1 + +/* Define this symbol if the BSD sysctl(KERN_ARND) is available */ +#cmakedefine HAVE_SYSCTL_ARND 1 + +/* Define to 1 if std::system or ::wsystem is available. */ +#cmakedefine HAVE_SYSTEM 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_PRCTL_H 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_RESOURCES_H 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_VMMETER_H 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_VM_VM_PARAM_H 1 + +/* Define to the address where bug reports for this package should be sent. */ +#define CLIENT_BUGREPORT "@CLIENT_BUGREPORT@" + +/* Define to the full name of this package. */ +#define CLIENT_NAME "@CLIENT_NAME@" + +/* Define to the home page for this package. */ +#define CLIENT_URL "@PROJECT_HOMEPAGE_URL@" + +/* Define to the version of this package. */ +#define CLIENT_VERSION_STRING "@CLIENT_VERSION_STRING@" + +/* Define to 1 if strerror_r returns char *. */ +#cmakedefine STRERROR_R_CHAR_P 1 + +/* Define if BDB support should be compiled in */ +#cmakedefine USE_BDB 1 + +/* Define if dbus support should be compiled in */ +#cmakedefine USE_DBUS 1 + +/* Define if QR support should be compiled in */ +#cmakedefine USE_QRCODE 1 + +/* Define if sqlite support should be compiled in */ +#cmakedefine USE_SQLITE 1 + +#endif //BITCOIN_CONFIG_H diff --git a/cmake/ccache.cmake b/cmake/ccache.cmake new file mode 100644 index 0000000000..d1cc204c8e --- /dev/null +++ b/cmake/ccache.cmake @@ -0,0 +1,28 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +if(NOT MSVC) + find_program(CCACHE_EXECUTABLE ccache) + if(CCACHE_EXECUTABLE) + execute_process( + COMMAND readlink -f ${CMAKE_CXX_COMPILER} + OUTPUT_VARIABLE compiler_resolved_link + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + if(CCACHE_EXECUTABLE STREQUAL compiler_resolved_link AND NOT WITH_CCACHE) + list(APPEND configure_warnings + "Disabling ccache was attempted using -DWITH_CCACHE=${WITH_CCACHE}, but ccache masquerades as the compiler." + ) + set(WITH_CCACHE ON) + elseif(WITH_CCACHE) + list(APPEND CMAKE_C_COMPILER_LAUNCHER ${CCACHE_EXECUTABLE}) + list(APPEND CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE_EXECUTABLE}) + endif() + else() + set(WITH_CCACHE OFF) + endif() +endif() + +mark_as_advanced(CCACHE_EXECUTABLE) diff --git a/cmake/cov_tool_wrapper.sh.in b/cmake/cov_tool_wrapper.sh.in new file mode 100644 index 0000000000..f6b7ff3419 --- /dev/null +++ b/cmake/cov_tool_wrapper.sh.in @@ -0,0 +1,5 @@ +# Copyright (c) 2024-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +exec @COV_TOOL@ "$@" diff --git a/cmake/crc32c.cmake b/cmake/crc32c.cmake new file mode 100644 index 0000000000..16fde7f95d --- /dev/null +++ b/cmake/crc32c.cmake @@ -0,0 +1,123 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +# This file is part of the transition from Autotools to CMake. Once CMake +# support has been merged we should switch to using the upstream CMake +# buildsystem. + +include(CheckCXXSourceCompiles) + +# Check for __builtin_prefetch support in the compiler. +check_cxx_source_compiles(" + int main() { + char data = 0; + const char* address = &data; + __builtin_prefetch(address, 0, 0); + return 0; + } + " HAVE_BUILTIN_PREFETCH +) + +# Check for _mm_prefetch support in the compiler. +check_cxx_source_compiles(" + #if defined(_MSC_VER) + #include + #else + #include + #endif + + int main() { + char data = 0; + const char* address = &data; + _mm_prefetch(address, _MM_HINT_NTA); + return 0; + } + " HAVE_MM_PREFETCH +) + +# Check for SSE4.2 support in the compiler. +if(MSVC) + set(SSE42_CXXFLAGS /arch:AVX) +else() + set(SSE42_CXXFLAGS -msse4.2) +endif() +check_cxx_source_compiles_with_flags("${SSE42_CXXFLAGS}" " + #include + #if defined(_MSC_VER) + #include + #elif defined(__GNUC__) && defined(__SSE4_2__) + #include + #endif + + int main() { + uint64_t l = 0; + l = _mm_crc32_u8(l, 0); + l = _mm_crc32_u32(l, 0); + l = _mm_crc32_u64(l, 0); + return l; + } + " HAVE_SSE42 +) + +# Check for ARMv8 w/ CRC and CRYPTO extensions support in the compiler. +set(ARM64_CRC_CXXFLAGS -march=armv8-a+crc+crypto) +check_cxx_source_compiles_with_flags("${ARM64_CRC_CXXFLAGS}" " + #include + #include + + int main() { + #ifdef __aarch64__ + __crc32cb(0, 0); __crc32ch(0, 0); __crc32cw(0, 0); __crc32cd(0, 0); + vmull_p64(0, 0); + #else + #error crc32c library does not support hardware acceleration on 32-bit ARM + #endif + return 0; + } + " HAVE_ARM64_CRC32C +) + +add_library(crc32c_common INTERFACE) +target_compile_definitions(crc32c_common INTERFACE + HAVE_BUILTIN_PREFETCH=$ + HAVE_MM_PREFETCH=$ + HAVE_STRONG_GETAUXVAL=$ + BYTE_ORDER_BIG_ENDIAN=$ + HAVE_SSE42=$ + HAVE_ARM64_CRC32C=$ +) +target_link_libraries(crc32c_common INTERFACE + core_interface +) + +add_library(crc32c STATIC EXCLUDE_FROM_ALL + ${PROJECT_SOURCE_DIR}/src/crc32c/src/crc32c.cc + ${PROJECT_SOURCE_DIR}/src/crc32c/src/crc32c_portable.cc +) +target_include_directories(crc32c + PUBLIC + $ +) +target_link_libraries(crc32c PRIVATE crc32c_common) +set_target_properties(crc32c PROPERTIES EXPORT_COMPILE_COMMANDS OFF) + +if(HAVE_SSE42) + add_library(crc32c_sse42 STATIC EXCLUDE_FROM_ALL + ${PROJECT_SOURCE_DIR}/src/crc32c/src/crc32c_sse42.cc + ) + target_compile_options(crc32c_sse42 PRIVATE ${SSE42_CXXFLAGS}) + target_link_libraries(crc32c_sse42 PRIVATE crc32c_common) + set_target_properties(crc32c_sse42 PROPERTIES EXPORT_COMPILE_COMMANDS OFF) + target_link_libraries(crc32c PRIVATE crc32c_sse42) +endif() + +if(HAVE_ARM64_CRC32C) + add_library(crc32c_arm64 STATIC EXCLUDE_FROM_ALL + ${PROJECT_SOURCE_DIR}/src/crc32c/src/crc32c_arm64.cc + ) + target_compile_options(crc32c_arm64 PRIVATE ${ARM64_CRC_CXXFLAGS}) + target_link_libraries(crc32c_arm64 PRIVATE crc32c_common) + set_target_properties(crc32c_arm64 PROPERTIES EXPORT_COMPILE_COMMANDS OFF) + target_link_libraries(crc32c PRIVATE crc32c_arm64) +endif() diff --git a/cmake/introspection.cmake b/cmake/introspection.cmake new file mode 100644 index 0000000000..29c93869a7 --- /dev/null +++ b/cmake/introspection.cmake @@ -0,0 +1,227 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +include(CheckCXXSourceCompiles) +include(CheckCXXSymbolExists) +include(CheckIncludeFileCXX) + +# The following HAVE_{HEADER}_H variables go to the bitcoin-build-config.h header. +check_include_file_cxx(sys/prctl.h HAVE_SYS_PRCTL_H) +check_include_file_cxx(sys/resources.h HAVE_SYS_RESOURCES_H) +check_include_file_cxx(sys/vmmeter.h HAVE_SYS_VMMETER_H) +check_include_file_cxx(vm/vm_param.h HAVE_VM_VM_PARAM_H) + +check_cxx_symbol_exists(O_CLOEXEC "fcntl.h" HAVE_O_CLOEXEC) +check_cxx_symbol_exists(fdatasync "unistd.h" HAVE_FDATASYNC) +check_cxx_symbol_exists(fork "unistd.h" HAVE_DECL_FORK) +check_cxx_symbol_exists(pipe2 "unistd.h" HAVE_DECL_PIPE2) +check_cxx_symbol_exists(setsid "unistd.h" HAVE_DECL_SETSID) + +check_include_file_cxx(sys/types.h HAVE_SYS_TYPES_H) +check_include_file_cxx(ifaddrs.h HAVE_IFADDRS_H) +if(HAVE_SYS_TYPES_H AND HAVE_IFADDRS_H) + include(TestAppendRequiredLibraries) + test_append_socket_library(core_interface) +endif() + +include(TestAppendRequiredLibraries) +test_append_atomic_library(core_interface) + +check_cxx_symbol_exists(std::system "cstdlib" HAVE_STD_SYSTEM) +check_cxx_symbol_exists(::_wsystem "stdlib.h" HAVE__WSYSTEM) +if(HAVE_STD_SYSTEM OR HAVE__WSYSTEM) + set(HAVE_SYSTEM 1) +endif() + +check_cxx_source_compiles(" + #include + + int main() + { + char buf[100]; + char* p{strerror_r(0, buf, sizeof buf)}; + (void)p; + } + " STRERROR_R_CHAR_P +) + +# Check for malloc_info (for memory statistics information in getmemoryinfo). +check_cxx_symbol_exists(malloc_info "malloc.h" HAVE_MALLOC_INFO) + +# Check for mallopt(M_ARENA_MAX) (to set glibc arenas). +check_cxx_source_compiles(" + #include + + int main() + { + mallopt(M_ARENA_MAX, 1); + } + " HAVE_MALLOPT_ARENA_MAX +) + +# Check for posix_fallocate(). +check_cxx_source_compiles(" + // same as in src/util/fs_helpers.cpp + #ifdef __linux__ + #ifdef _POSIX_C_SOURCE + #undef _POSIX_C_SOURCE + #endif + #define _POSIX_C_SOURCE 200112L + #endif // __linux__ + #include + + int main() + { + return posix_fallocate(0, 0, 0); + } + " HAVE_POSIX_FALLOCATE +) + +# Check for strong getauxval() support in the system headers. +check_cxx_source_compiles(" + #include + + int main() + { + getauxval(AT_HWCAP); + } + " HAVE_STRONG_GETAUXVAL +) + +# Check for UNIX sockets. +check_cxx_source_compiles(" + #include + #include + + int main() + { + struct sockaddr_un addr; + addr.sun_family = AF_UNIX; + } + " HAVE_SOCKADDR_UN +) + +# Check for different ways of gathering OS randomness: +# - Linux getrandom() +check_cxx_source_compiles(" + #include + + int main() + { + getrandom(nullptr, 32, 0); + } + " HAVE_GETRANDOM +) + +# - BSD getentropy() +check_cxx_source_compiles(" + #include + + int main() + { + getentropy(nullptr, 32); + } + " HAVE_GETENTROPY_RAND +) + + +# - BSD sysctl() +check_cxx_source_compiles(" + #include + #include + + #ifdef __linux__ + #error Don't use sysctl on Linux, it's deprecated even when it works + #endif + + int main() + { + sysctl(nullptr, 2, nullptr, nullptr, nullptr, 0); + } + " HAVE_SYSCTL +) + +# - BSD sysctl(KERN_ARND) +check_cxx_source_compiles(" + #include + #include + + #ifdef __linux__ + #error Don't use sysctl on Linux, it's deprecated even when it works + #endif + + int main() + { + static int name[2] = {CTL_KERN, KERN_ARND}; + sysctl(name, 2, nullptr, nullptr, nullptr, 0); + } + " HAVE_SYSCTL_ARND +) + +if(NOT MSVC) + include(CheckSourceCompilesAndLinks) + + # Check for SSE4.1 intrinsics. + set(SSE41_CXXFLAGS -msse4.1) + check_cxx_source_compiles_with_flags("${SSE41_CXXFLAGS}" " + #include + + int main() + { + __m128i a = _mm_set1_epi32(0); + __m128i b = _mm_set1_epi32(1); + __m128i r = _mm_blend_epi16(a, b, 0xFF); + return _mm_extract_epi32(r, 3); + } + " HAVE_SSE41 + ) + set(ENABLE_SSE41 ${HAVE_SSE41}) + + # Check for AVX2 intrinsics. + set(AVX2_CXXFLAGS -mavx -mavx2) + check_cxx_source_compiles_with_flags("${AVX2_CXXFLAGS}" " + #include + + int main() + { + __m256i l = _mm256_set1_epi32(0); + return _mm256_extract_epi32(l, 7); + } + " HAVE_AVX2 + ) + set(ENABLE_AVX2 ${HAVE_AVX2}) + + # Check for x86 SHA-NI intrinsics. + set(X86_SHANI_CXXFLAGS -msse4 -msha) + check_cxx_source_compiles_with_flags("${X86_SHANI_CXXFLAGS}" " + #include + + int main() + { + __m128i i = _mm_set1_epi32(0); + __m128i j = _mm_set1_epi32(1); + __m128i k = _mm_set1_epi32(2); + return _mm_extract_epi32(_mm_sha256rnds2_epu32(i, j, k), 0); + } + " HAVE_X86_SHANI + ) + set(ENABLE_X86_SHANI ${HAVE_X86_SHANI}) + + # Check for ARMv8 SHA-NI intrinsics. + set(ARM_SHANI_CXXFLAGS -march=armv8-a+crypto) + check_cxx_source_compiles_with_flags("${ARM_SHANI_CXXFLAGS}" " + #include + + int main() + { + uint32x4_t a, b, c; + vsha256h2q_u32(a, b, c); + vsha256hq_u32(a, b, c); + vsha256su0q_u32(a, b); + vsha256su1q_u32(a, b, c); + } + " HAVE_ARM_SHANI + ) + set(ENABLE_ARM_SHANI ${HAVE_ARM_SHANI}) +endif() diff --git a/cmake/leveldb.cmake b/cmake/leveldb.cmake new file mode 100644 index 0000000000..823a5d8e3d --- /dev/null +++ b/cmake/leveldb.cmake @@ -0,0 +1,105 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +# This file is part of the transition from Autotools to CMake. Once CMake +# support has been merged we should switch to using the upstream CMake +# buildsystem. + +include(CheckCXXSymbolExists) +check_cxx_symbol_exists(F_FULLFSYNC "fcntl.h" HAVE_FULLFSYNC) + +add_library(leveldb STATIC EXCLUDE_FROM_ALL + ${PROJECT_SOURCE_DIR}/src/leveldb/db/builder.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/db/c.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/db/db_impl.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/db/db_iter.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/db/dbformat.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/db/dumpfile.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/db/filename.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/db/log_reader.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/db/log_writer.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/db/memtable.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/db/repair.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/db/table_cache.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/db/version_edit.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/db/version_set.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/db/write_batch.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/table/block.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/table/block_builder.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/table/filter_block.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/table/format.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/table/iterator.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/table/merger.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/table/table.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/table/table_builder.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/table/two_level_iterator.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/util/arena.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/util/bloom.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/util/cache.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/util/coding.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/util/comparator.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/util/crc32c.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/util/env.cc + $<$>:${PROJECT_SOURCE_DIR}/src/leveldb/util/env_posix.cc> + $<$:${PROJECT_SOURCE_DIR}/src/leveldb/util/env_windows.cc> + ${PROJECT_SOURCE_DIR}/src/leveldb/util/filter_policy.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/util/hash.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/util/histogram.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/util/logging.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/util/options.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/util/status.cc + ${PROJECT_SOURCE_DIR}/src/leveldb/helpers/memenv/memenv.cc +) + +target_compile_definitions(leveldb + PRIVATE + HAVE_SNAPPY=0 + HAVE_CRC32C=1 + HAVE_FDATASYNC=$ + HAVE_FULLFSYNC=$ + HAVE_O_CLOEXEC=$ + FALLTHROUGH_INTENDED=[[fallthrough]] + LEVELDB_IS_BIG_ENDIAN=$ + $<$>:LEVELDB_PLATFORM_POSIX> + $<$:LEVELDB_PLATFORM_WINDOWS> + $<$:_UNICODE;UNICODE> +) +if(MINGW) + target_compile_definitions(leveldb + PRIVATE + __USE_MINGW_ANSI_STDIO=1 + ) +endif() + +target_include_directories(leveldb + PRIVATE + $ + PUBLIC + $ +) + +add_library(nowarn_leveldb_interface INTERFACE) +if(MSVC) + target_compile_options(nowarn_leveldb_interface INTERFACE + /wd4722 + ) + target_compile_definitions(nowarn_leveldb_interface INTERFACE + _CRT_NONSTDC_NO_WARNINGS + ) +else() + target_compile_options(nowarn_leveldb_interface INTERFACE + -Wno-conditional-uninitialized + -Wno-suggest-override + ) +endif() + +target_link_libraries(leveldb PRIVATE + core_interface + nowarn_leveldb_interface + crc32c +) + +set_target_properties(leveldb PROPERTIES + EXPORT_COMPILE_COMMANDS OFF +) diff --git a/cmake/minisketch.cmake b/cmake/minisketch.cmake new file mode 100644 index 0000000000..bb93c80467 --- /dev/null +++ b/cmake/minisketch.cmake @@ -0,0 +1,91 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +# Check for clmul instructions support. +if(MSVC) + set(CLMUL_CXXFLAGS) +else() + set(CLMUL_CXXFLAGS -mpclmul) +endif() +check_cxx_source_compiles_with_flags("${CLMUL_CXXFLAGS}" " + #include + #include + + int main() + { + __m128i a = _mm_cvtsi64_si128((uint64_t)7); + __m128i b = _mm_clmulepi64_si128(a, a, 37); + __m128i c = _mm_srli_epi64(b, 41); + __m128i d = _mm_xor_si128(b, c); + uint64_t e = _mm_cvtsi128_si64(d); + return e == 0; + } + " HAVE_CLMUL +) + +add_library(minisketch_common INTERFACE) +target_compile_definitions(minisketch_common INTERFACE + DISABLE_DEFAULT_FIELDS + ENABLE_FIELD_32 +) +if(MSVC) + target_compile_options(minisketch_common INTERFACE + /wd4060 + /wd4065 + /wd4146 + /wd4244 + /wd4267 + ) +endif() + +if(HAVE_CLMUL) + add_library(minisketch_clmul OBJECT EXCLUDE_FROM_ALL + ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/clmul_1byte.cpp + ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/clmul_2bytes.cpp + ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/clmul_3bytes.cpp + ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/clmul_4bytes.cpp + ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/clmul_5bytes.cpp + ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/clmul_6bytes.cpp + ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/clmul_7bytes.cpp + ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/clmul_8bytes.cpp + ) + target_compile_definitions(minisketch_clmul PUBLIC HAVE_CLMUL) + target_compile_options(minisketch_clmul PRIVATE ${CLMUL_CXXFLAGS}) + target_link_libraries(minisketch_clmul + PRIVATE + core_interface + minisketch_common + ) + set_target_properties(minisketch_clmul PROPERTIES + EXPORT_COMPILE_COMMANDS OFF + ) +endif() + +add_library(minisketch STATIC EXCLUDE_FROM_ALL + ${PROJECT_SOURCE_DIR}/src/minisketch/src/minisketch.cpp + ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/generic_1byte.cpp + ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/generic_2bytes.cpp + ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/generic_3bytes.cpp + ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/generic_4bytes.cpp + ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/generic_5bytes.cpp + ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/generic_6bytes.cpp + ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/generic_7bytes.cpp + ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/generic_8bytes.cpp +) + +target_include_directories(minisketch + PUBLIC + $ +) + +target_link_libraries(minisketch + PRIVATE + core_interface + minisketch_common + $ +) + +set_target_properties(minisketch PROPERTIES + EXPORT_COMPILE_COMMANDS OFF +) diff --git a/cmake/module/AddBoostIfNeeded.cmake b/cmake/module/AddBoostIfNeeded.cmake new file mode 100644 index 0000000000..ecd0d6f2ab --- /dev/null +++ b/cmake/module/AddBoostIfNeeded.cmake @@ -0,0 +1,78 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +function(add_boost_if_needed) + #[=[ + TODO: Not all targets, which will be added in the future, require + Boost. Therefore, a proper check will be appropriate here. + + Implementation notes: + Although only Boost headers are used to build Bitcoin Core, + we still leverage a standard CMake's approach to handle + dependencies, i.e., the Boost::headers "library". + A command target_link_libraries(target PRIVATE Boost::headers) + will propagate Boost::headers usage requirements to the target. + For Boost::headers such usage requirements is an include + directory and other added INTERFACE properties. + ]=] + + # We cannot rely on find_package(Boost ...) to work properly without + # Boost_NO_BOOST_CMAKE set until we require a more recent Boost because + # upstream did not ship proper CMake files until 1.82.0. + # Until then, we rely on CMake's FindBoost module. + # See: https://cmake.org/cmake/help/latest/policy/CMP0167.html + if(POLICY CMP0167) + cmake_policy(SET CMP0167 OLD) + endif() + set(Boost_NO_BOOST_CMAKE ON) + find_package(Boost 1.73.0 REQUIRED) + mark_as_advanced(Boost_INCLUDE_DIR) + set_target_properties(Boost::headers PROPERTIES IMPORTED_GLOBAL TRUE) + target_compile_definitions(Boost::headers INTERFACE + # We don't use multi_index serialization. + BOOST_MULTI_INDEX_DISABLE_SERIALIZATION + ) + if(DEFINED VCPKG_TARGET_TRIPLET) + # Workaround for https://github.com/microsoft/vcpkg/issues/36955. + target_compile_definitions(Boost::headers INTERFACE + BOOST_NO_USER_CONFIG + ) + endif() + + # Prevent use of std::unary_function, which was removed in C++17, + # and will generate warnings with newer compilers for Boost + # older than 1.80. + # See: https://github.com/boostorg/config/pull/430. + set(CMAKE_REQUIRED_DEFINITIONS -DBOOST_NO_CXX98_FUNCTION_BASE) + set(CMAKE_REQUIRED_INCLUDES ${Boost_INCLUDE_DIR}) + include(CMakePushCheckState) + cmake_push_check_state() + include(TryAppendCXXFlags) + set(CMAKE_REQUIRED_FLAGS ${working_compiler_werror_flag}) + set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY) + check_cxx_source_compiles(" + #include + " NO_DIAGNOSTICS_BOOST_NO_CXX98_FUNCTION_BASE + ) + cmake_pop_check_state() + if(NO_DIAGNOSTICS_BOOST_NO_CXX98_FUNCTION_BASE) + target_compile_definitions(Boost::headers INTERFACE + BOOST_NO_CXX98_FUNCTION_BASE + ) + else() + set(CMAKE_REQUIRED_DEFINITIONS) + endif() + + # Some package managers, such as vcpkg, vendor Boost.Test separately + # from the rest of the headers, so we have to check for it individually. + if(BUILD_TESTS AND DEFINED VCPKG_TARGET_TRIPLET) + list(APPEND CMAKE_REQUIRED_DEFINITIONS -DBOOST_TEST_NO_MAIN) + include(CheckIncludeFileCXX) + check_include_file_cxx(boost/test/included/unit_test.hpp HAVE_BOOST_INCLUDED_UNIT_TEST_H) + if(NOT HAVE_BOOST_INCLUDED_UNIT_TEST_H) + message(FATAL_ERROR "Building test_bitcoin executable requested but boost/test/included/unit_test.hpp header not available.") + endif() + endif() + +endfunction() diff --git a/cmake/module/AddWindowsResources.cmake b/cmake/module/AddWindowsResources.cmake new file mode 100644 index 0000000000..a9b4f51f73 --- /dev/null +++ b/cmake/module/AddWindowsResources.cmake @@ -0,0 +1,14 @@ +# Copyright (c) 2024-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +include_guard(GLOBAL) + +macro(add_windows_resources target rc_file) + if(WIN32) + target_sources(${target} PRIVATE ${rc_file}) + set_property(SOURCE ${rc_file} + APPEND PROPERTY COMPILE_DEFINITIONS WINDRES_PREPROC + ) + endif() +endmacro() diff --git a/cmake/module/CheckSourceCompilesAndLinks.cmake b/cmake/module/CheckSourceCompilesAndLinks.cmake new file mode 100644 index 0000000000..88c897d524 --- /dev/null +++ b/cmake/module/CheckSourceCompilesAndLinks.cmake @@ -0,0 +1,39 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +include_guard(GLOBAL) +include(CheckCXXSourceCompiles) +include(CMakePushCheckState) + +# This avoids running the linker. +set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY) + +macro(check_cxx_source_links source) + set(CMAKE_TRY_COMPILE_TARGET_TYPE EXECUTABLE) + check_cxx_source_compiles("${source}" ${ARGN}) + set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY) +endmacro() + +macro(check_cxx_source_compiles_with_flags flags source) + cmake_push_check_state(RESET) + set(CMAKE_REQUIRED_FLAGS ${flags}) + list(JOIN CMAKE_REQUIRED_FLAGS " " CMAKE_REQUIRED_FLAGS) + check_cxx_source_compiles("${source}" ${ARGN}) + cmake_pop_check_state() +endmacro() + +macro(check_cxx_source_links_with_flags flags source) + cmake_push_check_state(RESET) + set(CMAKE_REQUIRED_FLAGS ${flags}) + list(JOIN CMAKE_REQUIRED_FLAGS " " CMAKE_REQUIRED_FLAGS) + check_cxx_source_links("${source}" ${ARGN}) + cmake_pop_check_state() +endmacro() + +macro(check_cxx_source_links_with_libs libs source) + cmake_push_check_state(RESET) + set(CMAKE_REQUIRED_LIBRARIES "${libs}") + check_cxx_source_links("${source}" ${ARGN}) + cmake_pop_check_state() +endmacro() diff --git a/cmake/module/FindBerkeleyDB.cmake b/cmake/module/FindBerkeleyDB.cmake new file mode 100644 index 0000000000..03a3cce10c --- /dev/null +++ b/cmake/module/FindBerkeleyDB.cmake @@ -0,0 +1,133 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +#[=======================================================================[ +FindBerkeleyDB +-------------- + +Finds the Berkeley DB headers and library. + +Imported Targets +^^^^^^^^^^^^^^^^ + +This module provides imported target ``BerkeleyDB::BerkeleyDB``, if +Berkeley DB has been found. + +Result Variables +^^^^^^^^^^^^^^^^ + +This module defines the following variables: + +``BerkeleyDB_FOUND`` + "True" if Berkeley DB found. + +``BerkeleyDB_VERSION`` + The MAJOR.MINOR version of Berkeley DB found. + +#]=======================================================================] + +set(_BerkeleyDB_homebrew_prefix) +if(CMAKE_HOST_APPLE) + find_program(HOMEBREW_EXECUTABLE brew) + if(HOMEBREW_EXECUTABLE) + # The Homebrew package manager installs the berkeley-db* packages as + # "keg-only", which means they are not symlinked into the default prefix. + # To find such a package, the find_path() and find_library() commands + # need additional path hints that are computed by Homebrew itself. + execute_process( + COMMAND ${HOMEBREW_EXECUTABLE} --prefix berkeley-db@4 + OUTPUT_VARIABLE _BerkeleyDB_homebrew_prefix + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + endif() +endif() + +find_path(BerkeleyDB_INCLUDE_DIR + NAMES db_cxx.h + HINTS ${_BerkeleyDB_homebrew_prefix}/include + PATH_SUFFIXES 4.8 48 db4.8 4 db4 5.3 db5.3 5 db5 +) +mark_as_advanced(BerkeleyDB_INCLUDE_DIR) +unset(_BerkeleyDB_homebrew_prefix) + +if(NOT BerkeleyDB_LIBRARY) + if(VCPKG_TARGET_TRIPLET) + # The vcpkg package manager installs the berkeleydb package with the same name + # of release and debug libraries. Therefore, the default search paths set by + # vcpkg's toolchain file cannot be used to search libraries as the debug one + # will always be found. + set(CMAKE_FIND_USE_CMAKE_PATH FALSE) + endif() + + get_filename_component(_BerkeleyDB_lib_hint "${BerkeleyDB_INCLUDE_DIR}" DIRECTORY) + + find_library(BerkeleyDB_LIBRARY_RELEASE + NAMES db_cxx-4.8 db4_cxx db48 db_cxx-5.3 db_cxx-5 db_cxx libdb48 + NAMES_PER_DIR + HINTS ${_BerkeleyDB_lib_hint} + PATH_SUFFIXES lib + ) + mark_as_advanced(BerkeleyDB_LIBRARY_RELEASE) + + find_library(BerkeleyDB_LIBRARY_DEBUG + NAMES db_cxx-4.8 db4_cxx db48 db_cxx-5.3 db_cxx-5 db_cxx libdb48 + NAMES_PER_DIR + HINTS ${_BerkeleyDB_lib_hint} + PATH_SUFFIXES debug/lib + ) + mark_as_advanced(BerkeleyDB_LIBRARY_DEBUG) + + unset(_BerkeleyDB_lib_hint) + unset(CMAKE_FIND_USE_CMAKE_PATH) + + include(SelectLibraryConfigurations) + select_library_configurations(BerkeleyDB) + # The select_library_configurations() command sets BerkeleyDB_FOUND, but we + # want the one from the find_package_handle_standard_args() command below. + unset(BerkeleyDB_FOUND) +endif() + +if(BerkeleyDB_INCLUDE_DIR) + file(STRINGS "${BerkeleyDB_INCLUDE_DIR}/db.h" _BerkeleyDB_version_strings REGEX "^#define[\t ]+DB_VERSION_(MAJOR|MINOR|PATCH)[ \t]+[0-9]+.*") + string(REGEX REPLACE ".*#define[\t ]+DB_VERSION_MAJOR[ \t]+([0-9]+).*" "\\1" _BerkeleyDB_version_major "${_BerkeleyDB_version_strings}") + string(REGEX REPLACE ".*#define[\t ]+DB_VERSION_MINOR[ \t]+([0-9]+).*" "\\1" _BerkeleyDB_version_minor "${_BerkeleyDB_version_strings}") + string(REGEX REPLACE ".*#define[\t ]+DB_VERSION_PATCH[ \t]+([0-9]+).*" "\\1" _BerkeleyDB_version_patch "${_BerkeleyDB_version_strings}") + unset(_BerkeleyDB_version_strings) + # The MAJOR.MINOR.PATCH version will be logged in the following find_package_handle_standard_args() command. + set(_BerkeleyDB_full_version ${_BerkeleyDB_version_major}.${_BerkeleyDB_version_minor}.${_BerkeleyDB_version_patch}) + set(BerkeleyDB_VERSION ${_BerkeleyDB_version_major}.${_BerkeleyDB_version_minor}) + unset(_BerkeleyDB_version_major) + unset(_BerkeleyDB_version_minor) + unset(_BerkeleyDB_version_patch) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(BerkeleyDB + REQUIRED_VARS BerkeleyDB_LIBRARY BerkeleyDB_INCLUDE_DIR + VERSION_VAR _BerkeleyDB_full_version +) +unset(_BerkeleyDB_full_version) + +if(BerkeleyDB_FOUND AND NOT TARGET BerkeleyDB::BerkeleyDB) + add_library(BerkeleyDB::BerkeleyDB UNKNOWN IMPORTED) + set_target_properties(BerkeleyDB::BerkeleyDB PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${BerkeleyDB_INCLUDE_DIR}" + ) + if(BerkeleyDB_LIBRARY_RELEASE) + set_property(TARGET BerkeleyDB::BerkeleyDB APPEND PROPERTY + IMPORTED_CONFIGURATIONS RELEASE + ) + set_target_properties(BerkeleyDB::BerkeleyDB PROPERTIES + IMPORTED_LOCATION_RELEASE "${BerkeleyDB_LIBRARY_RELEASE}" + ) + endif() + if(BerkeleyDB_LIBRARY_DEBUG) + set_property(TARGET BerkeleyDB::BerkeleyDB APPEND PROPERTY + IMPORTED_CONFIGURATIONS DEBUG) + set_target_properties(BerkeleyDB::BerkeleyDB PROPERTIES + IMPORTED_LOCATION_DEBUG "${BerkeleyDB_LIBRARY_DEBUG}" + ) + endif() +endif() diff --git a/cmake/module/FindLibevent.cmake b/cmake/module/FindLibevent.cmake new file mode 100644 index 0000000000..c006b43d60 --- /dev/null +++ b/cmake/module/FindLibevent.cmake @@ -0,0 +1,86 @@ +# Copyright (c) 2024-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +#[=======================================================================[ +FindLibevent +------------ + +Finds the Libevent headers and libraries. + +This is a wrapper around find_package()/pkg_check_modules() commands that: + - facilitates searching in various build environments + - prints a standard log message + +#]=======================================================================] + +# Check whether evhttp_connection_get_peer expects const char**. +# See https://github.com/libevent/libevent/commit/a18301a2bb160ff7c3ffaf5b7653c39ffe27b385 +function(check_evhttp_connection_get_peer target) + include(CMakePushCheckState) + cmake_push_check_state(RESET) + set(CMAKE_REQUIRED_LIBRARIES ${target}) + include(CheckCXXSourceCompiles) + check_cxx_source_compiles(" + #include + #include + + int main() + { + evhttp_connection* conn = (evhttp_connection*)1; + const char* host; + uint16_t port; + evhttp_connection_get_peer(conn, &host, &port); + } + " HAVE_EVHTTP_CONNECTION_GET_PEER_CONST_CHAR + ) + cmake_pop_check_state() + target_compile_definitions(${target} INTERFACE + $<$:HAVE_EVHTTP_CONNECTION_GET_PEER_CONST_CHAR> + ) +endfunction() + +set(_libevent_components core extra) +if(NOT WIN32) + list(APPEND _libevent_components pthreads) +endif() + +find_package(Libevent ${Libevent_FIND_VERSION} QUIET + NO_MODULE +) + +include(FindPackageHandleStandardArgs) +if(Libevent_FOUND) + find_package(Libevent ${Libevent_FIND_VERSION} QUIET + REQUIRED COMPONENTS ${_libevent_components} + NO_MODULE + ) + find_package_handle_standard_args(Libevent + REQUIRED_VARS Libevent_DIR + VERSION_VAR Libevent_VERSION + ) + check_evhttp_connection_get_peer(libevent::extra) +else() + find_package(PkgConfig REQUIRED) + foreach(component IN LISTS _libevent_components) + pkg_check_modules(libevent_${component} + REQUIRED QUIET + IMPORTED_TARGET GLOBAL + libevent_${component}>=${Libevent_FIND_VERSION} + ) + if(TARGET PkgConfig::libevent_${component} AND NOT TARGET libevent::${component}) + add_library(libevent::${component} ALIAS PkgConfig::libevent_${component}) + endif() + endforeach() + find_package_handle_standard_args(Libevent + REQUIRED_VARS libevent_core_LIBRARY_DIRS + VERSION_VAR libevent_core_VERSION + ) + check_evhttp_connection_get_peer(PkgConfig::libevent_extra) +endif() + +unset(_libevent_components) + +mark_as_advanced(Libevent_DIR) +mark_as_advanced(_event_h) +mark_as_advanced(_event_lib) diff --git a/cmake/module/FindQRencode.cmake b/cmake/module/FindQRencode.cmake new file mode 100644 index 0000000000..39e3b8b679 --- /dev/null +++ b/cmake/module/FindQRencode.cmake @@ -0,0 +1,71 @@ +# Copyright (c) 2024-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +#[=======================================================================[ +FindQRencode +------------ + +Finds the QRencode header and library. + +This is a wrapper around find_package()/pkg_check_modules() commands that: + - facilitates searching in various build environments + - prints a standard log message + +#]=======================================================================] + +find_package(PkgConfig QUIET) +if(PKG_CONFIG_FOUND) + pkg_check_modules(PC_QRencode QUIET libqrencode) +endif() + +find_path(QRencode_INCLUDE_DIR + NAMES qrencode.h + PATHS ${PC_QRencode_INCLUDE_DIRS} +) + +find_library(QRencode_LIBRARY_RELEASE + NAMES qrencode + PATHS ${PC_QRencode_LIBRARY_DIRS} +) +find_library(QRencode_LIBRARY_DEBUG + NAMES qrencoded qrencode + PATHS ${PC_QRencode_LIBRARY_DIRS} +) +include(SelectLibraryConfigurations) +select_library_configurations(QRencode) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(QRencode + REQUIRED_VARS QRencode_LIBRARY QRencode_INCLUDE_DIR + VERSION_VAR PC_QRencode_VERSION +) + +if(QRencode_FOUND) + if(NOT TARGET QRencode::QRencode) + add_library(QRencode::QRencode UNKNOWN IMPORTED) + endif() + if(QRencode_LIBRARY_RELEASE) + set_property(TARGET QRencode::QRencode APPEND PROPERTY + IMPORTED_CONFIGURATIONS RELEASE + ) + set_target_properties(QRencode::QRencode PROPERTIES + IMPORTED_LOCATION_RELEASE "${QRencode_LIBRARY_RELEASE}" + ) + endif() + if(QRencode_LIBRARY_DEBUG) + set_property(TARGET QRencode::QRencode APPEND PROPERTY + IMPORTED_CONFIGURATIONS DEBUG + ) + set_target_properties(QRencode::QRencode PROPERTIES + IMPORTED_LOCATION_DEBUG "${QRencode_LIBRARY_DEBUG}" + ) + endif() + set_target_properties(QRencode::QRencode PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${QRencode_INCLUDE_DIR}" + ) +endif() + +mark_as_advanced( + QRencode_INCLUDE_DIR +) diff --git a/cmake/module/FindQt.cmake b/cmake/module/FindQt.cmake new file mode 100644 index 0000000000..2e43294a99 --- /dev/null +++ b/cmake/module/FindQt.cmake @@ -0,0 +1,66 @@ +# Copyright (c) 2024-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +#[=======================================================================[ +FindQt +------ + +Finds the Qt headers and libraries. + +This is a wrapper around find_package() command that: + - facilitates searching in various build environments + - prints a standard log message + +#]=======================================================================] + +set(_qt_homebrew_prefix) +if(CMAKE_HOST_APPLE) + find_program(HOMEBREW_EXECUTABLE brew) + if(HOMEBREW_EXECUTABLE) + execute_process( + COMMAND ${HOMEBREW_EXECUTABLE} --prefix qt@${Qt_FIND_VERSION_MAJOR} + OUTPUT_VARIABLE _qt_homebrew_prefix + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + endif() +endif() + +# Save CMAKE_FIND_ROOT_PATH_MODE_LIBRARY state. +unset(_qt_find_root_path_mode_library_saved) +if(DEFINED CMAKE_FIND_ROOT_PATH_MODE_LIBRARY) + set(_qt_find_root_path_mode_library_saved ${CMAKE_FIND_ROOT_PATH_MODE_LIBRARY}) +endif() + +# The Qt config files internally use find_library() calls for all +# dependencies to ensure their availability. In turn, the find_library() +# inspects the well-known locations on the file system; therefore, it must +# be able to find platform-specific system libraries, for example: +# /usr/x86_64-w64-mingw32/lib/libm.a or /usr/arm-linux-gnueabihf/lib/libm.a. +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY BOTH) + +find_package(Qt${Qt_FIND_VERSION_MAJOR} ${Qt_FIND_VERSION} + COMPONENTS ${Qt_FIND_COMPONENTS} + HINTS ${_qt_homebrew_prefix} + PATH_SUFFIXES Qt${Qt_FIND_VERSION_MAJOR} # Required on OpenBSD systems. +) +unset(_qt_homebrew_prefix) + +# Restore CMAKE_FIND_ROOT_PATH_MODE_LIBRARY state. +if(DEFINED _qt_find_root_path_mode_library_saved) + set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ${_qt_find_root_path_mode_library_saved}) + unset(_qt_find_root_path_mode_library_saved) +else() + unset(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Qt + REQUIRED_VARS Qt${Qt_FIND_VERSION_MAJOR}_DIR + VERSION_VAR Qt${Qt_FIND_VERSION_MAJOR}_VERSION +) + +foreach(component IN LISTS Qt_FIND_COMPONENTS ITEMS "") + mark_as_advanced(Qt${Qt_FIND_VERSION_MAJOR}${component}_DIR) +endforeach() diff --git a/cmake/module/FindUSDT.cmake b/cmake/module/FindUSDT.cmake new file mode 100644 index 0000000000..0be7c28ff5 --- /dev/null +++ b/cmake/module/FindUSDT.cmake @@ -0,0 +1,67 @@ +# Copyright (c) 2024-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +#[=======================================================================[ +FindUSDT +-------- + +Finds the Userspace, Statically Defined Tracing header(s). + +Imported Targets +^^^^^^^^^^^^^^^^ + +This module provides imported target ``USDT::headers``, if +USDT has been found. + +Result Variables +^^^^^^^^^^^^^^^^ + +This module defines the following variables: + +``USDT_FOUND`` + "True" if USDT found. + +#]=======================================================================] + +find_path(USDT_INCLUDE_DIR + NAMES sys/sdt.h +) +mark_as_advanced(USDT_INCLUDE_DIR) + +if(USDT_INCLUDE_DIR) + include(CMakePushCheckState) + cmake_push_check_state(RESET) + + include(CheckCXXSourceCompiles) + set(CMAKE_REQUIRED_INCLUDES ${USDT_INCLUDE_DIR}) + check_cxx_source_compiles(" + // Setting SDT_USE_VARIADIC lets systemtap (sys/sdt.h) know that we want to use + // the optional variadic macros to define tracepoints. + #define SDT_USE_VARIADIC 1 + #include + + int main() + { + STAP_PROBEV(context, event); + int a, b, c, d, e, f, g; + STAP_PROBEV(context, event, a, b, c, d, e, f, g); + } + " HAVE_USDT_H + ) + + cmake_pop_check_state() +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(USDT + REQUIRED_VARS USDT_INCLUDE_DIR HAVE_USDT_H +) + +if(USDT_FOUND AND NOT TARGET USDT::headers) + add_library(USDT::headers INTERFACE IMPORTED) + set_target_properties(USDT::headers PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${USDT_INCLUDE_DIR}" + ) + set(ENABLE_TRACING TRUE) +endif() diff --git a/cmake/module/FindZeroMQ.cmake b/cmake/module/FindZeroMQ.cmake new file mode 100644 index 0000000000..eecd9b2453 --- /dev/null +++ b/cmake/module/FindZeroMQ.cmake @@ -0,0 +1,41 @@ +# Copyright (c) 2024-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +#[=======================================================================[ +FindZeroMQ +---------- + +Finds the ZeroMQ headers and library. + +This is a wrapper around find_package()/pkg_check_modules() commands that: + - facilitates searching in various build environments + - prints a standard log message + +#]=======================================================================] + +include(FindPackageHandleStandardArgs) +find_package(ZeroMQ ${ZeroMQ_FIND_VERSION} NO_MODULE QUIET) +if(ZeroMQ_FOUND) + find_package_handle_standard_args(ZeroMQ + REQUIRED_VARS ZeroMQ_DIR + VERSION_VAR ZeroMQ_VERSION + ) + if(TARGET libzmq) + add_library(zeromq ALIAS libzmq) + elseif(TARGET libzmq-static) + add_library(zeromq ALIAS libzmq-static) + endif() + mark_as_advanced(ZeroMQ_DIR) +else() + find_package(PkgConfig REQUIRED) + pkg_check_modules(libzmq QUIET + IMPORTED_TARGET + libzmq>=${ZeroMQ_FIND_VERSION} + ) + find_package_handle_standard_args(ZeroMQ + REQUIRED_VARS libzmq_LIBRARY_DIRS + VERSION_VAR libzmq_VERSION + ) + add_library(zeromq ALIAS PkgConfig::libzmq) +endif() diff --git a/cmake/module/FlagsSummary.cmake b/cmake/module/FlagsSummary.cmake new file mode 100644 index 0000000000..91d1df90d9 --- /dev/null +++ b/cmake/module/FlagsSummary.cmake @@ -0,0 +1,74 @@ +# Copyright (c) 2024-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +include_guard(GLOBAL) + +function(indent_message header content indent_num) + if(indent_num GREATER 0) + string(REPEAT " " ${indent_num} indentation) + string(REPEAT "." ${indent_num} tail) + string(REGEX REPLACE "${tail}$" "" header "${header}") + endif() + message("${indentation}${header} ${content}") +endfunction() + +# Print tools' flags on best-effort. Include the abstracted +# CMake flags that we touch ourselves. +function(print_flags_per_config config indent_num) + string(TOUPPER "${config}" config_uppercase) + + include(GetTargetInterface) + get_target_interface(definitions "${config}" core_interface COMPILE_DEFINITIONS) + indent_message("Preprocessor defined macros ..........." "${definitions}" ${indent_num}) + + string(STRIP "${CMAKE_CXX_COMPILER_ARG1} ${CMAKE_CXX_FLAGS}" combined_cxx_flags) + string(STRIP "${combined_cxx_flags} ${CMAKE_CXX_FLAGS_${config_uppercase}}" combined_cxx_flags) + string(STRIP "${combined_cxx_flags} ${CMAKE_CXX${CMAKE_CXX_STANDARD}_STANDARD_COMPILE_OPTION}" combined_cxx_flags) + if(CMAKE_POSITION_INDEPENDENT_CODE) + string(JOIN " " combined_cxx_flags ${combined_cxx_flags} ${CMAKE_CXX_COMPILE_OPTIONS_PIC}) + endif() + get_target_interface(core_cxx_flags "${config}" core_interface COMPILE_OPTIONS) + string(STRIP "${combined_cxx_flags} ${core_cxx_flags}" combined_cxx_flags) + string(STRIP "${combined_cxx_flags} ${APPEND_CPPFLAGS}" combined_cxx_flags) + string(STRIP "${combined_cxx_flags} ${APPEND_CXXFLAGS}" combined_cxx_flags) + indent_message("C++ compiler flags ...................." "${combined_cxx_flags}" ${indent_num}) + + string(STRIP "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_${config_uppercase}}" combined_linker_flags) + string(STRIP "${combined_linker_flags} ${CMAKE_EXE_LINKER_FLAGS}" combined_linker_flags) + get_target_interface(common_link_options "${config}" core_interface LINK_OPTIONS) + string(STRIP "${combined_linker_flags} ${common_link_options}" combined_linker_flags) + if(CMAKE_CXX_LINK_PIE_SUPPORTED) + string(JOIN " " combined_linker_flags ${combined_linker_flags} ${CMAKE_CXX_LINK_OPTIONS_PIE}) + endif() + string(STRIP "${combined_linker_flags} ${APPEND_LDFLAGS}" combined_linker_flags) + indent_message("Linker flags .........................." "${combined_linker_flags}" ${indent_num}) +endfunction() + +function(flags_summary) + get_property(is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + list(JOIN CMAKE_CONFIGURATION_TYPES ", " configs) + message("Available build configurations ........ ${configs}") + if(CMAKE_GENERATOR MATCHES "Visual Studio") + set(default_config "Debug") + else() + list(GET CMAKE_CONFIGURATION_TYPES 0 default_config) + endif() + message("Default build configuration ........... ${default_config}") + foreach(config IN LISTS CMAKE_CONFIGURATION_TYPES) + message("") + message("'${config}' build configuration:") + print_flags_per_config("${config}" 2) + endforeach() + else() + message("CMAKE_BUILD_TYPE ...................... ${CMAKE_BUILD_TYPE}") + print_flags_per_config("${CMAKE_BUILD_TYPE}" 0) + endif() + message("") + message([=[ +NOTE: The summary above may not exactly match the final applied build flags + if any additional CMAKE_* or environment variables have been modified. + To see the exact flags applied, build with the --verbose option. +]=]) +endfunction() diff --git a/cmake/module/GenerateHeaders.cmake b/cmake/module/GenerateHeaders.cmake new file mode 100644 index 0000000000..c69007acb6 --- /dev/null +++ b/cmake/module/GenerateHeaders.cmake @@ -0,0 +1,21 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +function(generate_header_from_json json_source_relpath) + add_custom_command( + OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${json_source_relpath}.h + COMMAND ${CMAKE_COMMAND} -DJSON_SOURCE_PATH=${CMAKE_CURRENT_SOURCE_DIR}/${json_source_relpath} -DHEADER_PATH=${CMAKE_CURRENT_BINARY_DIR}/${json_source_relpath}.h -P ${PROJECT_SOURCE_DIR}/cmake/script/GenerateHeaderFromJson.cmake + DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${json_source_relpath} ${PROJECT_SOURCE_DIR}/cmake/script/GenerateHeaderFromJson.cmake + VERBATIM + ) +endfunction() + +function(generate_header_from_raw raw_source_relpath raw_namespace) + add_custom_command( + OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${raw_source_relpath}.h + COMMAND ${CMAKE_COMMAND} -DRAW_SOURCE_PATH=${CMAKE_CURRENT_SOURCE_DIR}/${raw_source_relpath} -DHEADER_PATH=${CMAKE_CURRENT_BINARY_DIR}/${raw_source_relpath}.h -DRAW_NAMESPACE=${raw_namespace} -P ${PROJECT_SOURCE_DIR}/cmake/script/GenerateHeaderFromRaw.cmake + DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${raw_source_relpath} ${PROJECT_SOURCE_DIR}/cmake/script/GenerateHeaderFromRaw.cmake + VERBATIM + ) +endfunction() diff --git a/cmake/module/GenerateSetupNsi.cmake b/cmake/module/GenerateSetupNsi.cmake new file mode 100644 index 0000000000..97a53b071d --- /dev/null +++ b/cmake/module/GenerateSetupNsi.cmake @@ -0,0 +1,18 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +function(generate_setup_nsi) + set(abs_top_srcdir ${PROJECT_SOURCE_DIR}) + set(abs_top_builddir ${PROJECT_BINARY_DIR}) + set(CLIENT_URL ${PROJECT_HOMEPAGE_URL}) + set(CLIENT_TARNAME "bitcoin") + set(BITCOIN_GUI_NAME "bitcoin-qt") + set(BITCOIN_DAEMON_NAME "bitcoind") + set(BITCOIN_CLI_NAME "bitcoin-cli") + set(BITCOIN_TX_NAME "bitcoin-tx") + set(BITCOIN_WALLET_TOOL_NAME "bitcoin-wallet") + set(BITCOIN_TEST_NAME "test_bitcoin") + set(EXEEXT ${CMAKE_EXECUTABLE_SUFFIX}) + configure_file(${PROJECT_SOURCE_DIR}/share/setup.nsi.in ${PROJECT_BINARY_DIR}/bitcoin-win64-setup.nsi USE_SOURCE_PERMISSIONS @ONLY) +endfunction() diff --git a/cmake/module/GetTargetInterface.cmake b/cmake/module/GetTargetInterface.cmake new file mode 100644 index 0000000000..1e455d456b --- /dev/null +++ b/cmake/module/GetTargetInterface.cmake @@ -0,0 +1,53 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +include_guard(GLOBAL) + +# Evaluates config-specific generator expressions in a list. +# Recognizable patterns are: +# - $<$:[value]> +# - $<$>:[value]> +function(evaluate_generator_expressions list config) + set(input ${${list}}) + set(result) + foreach(token IN LISTS input) + if(token MATCHES "\\$<\\$]+)>:([^>]+)>") + if(CMAKE_MATCH_1 STREQUAL config) + list(APPEND result ${CMAKE_MATCH_2}) + endif() + elseif(token MATCHES "\\$<\\$]+)>>:([^>]+)>") + if(NOT CMAKE_MATCH_1 STREQUAL config) + list(APPEND result ${CMAKE_MATCH_2}) + endif() + else() + list(APPEND result ${token}) + endif() + endforeach() + set(${list} ${result} PARENT_SCOPE) +endfunction() + + +# Gets target's interface properties recursively. +function(get_target_interface var config target property) + get_target_property(result ${target} INTERFACE_${property}) + if(result) + evaluate_generator_expressions(result "${config}") + list(JOIN result " " result) + else() + set(result) + endif() + + get_target_property(dependencies ${target} INTERFACE_LINK_LIBRARIES) + if(dependencies) + evaluate_generator_expressions(dependencies "${config}") + foreach(dependency IN LISTS dependencies) + if(TARGET ${dependency}) + get_target_interface(dep_result "${config}" ${dependency} ${property}) + string(STRIP "${result} ${dep_result}" result) + endif() + endforeach() + endif() + + set(${var} "${result}" PARENT_SCOPE) +endfunction() diff --git a/cmake/module/Maintenance.cmake b/cmake/module/Maintenance.cmake new file mode 100644 index 0000000000..61251d2439 --- /dev/null +++ b/cmake/module/Maintenance.cmake @@ -0,0 +1,151 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +include_guard(GLOBAL) + +function(setup_split_debug_script) + if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux") + set(OBJCOPY ${CMAKE_OBJCOPY}) + set(STRIP ${CMAKE_STRIP}) + configure_file( + contrib/devtools/split-debug.sh.in split-debug.sh + FILE_PERMISSIONS OWNER_READ OWNER_EXECUTE + GROUP_READ GROUP_EXECUTE + WORLD_READ + @ONLY + ) + endif() +endfunction() + +function(add_maintenance_targets) + if(NOT PYTHON_COMMAND) + return() + endif() + + if(CMAKE_SYSTEM_NAME STREQUAL "Darwin") + set(exe_format MACHO) + elseif(WIN32) + set(exe_format PE) + else() + set(exe_format ELF) + endif() + + # In CMake, the components of the compiler invocation are separated into distinct variables: + # - CMAKE_CXX_COMPILER: the full path to the compiler binary itself (e.g., /usr/bin/clang++). + # - CMAKE_CXX_COMPILER_ARG1: a string containing initial compiler options (e.g., --target=x86_64-apple-darwin -nostdlibinc). + # By concatenating these variables, we form the complete command line to be passed to a Python script via the CXX environment variable. + string(STRIP "${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1}" cxx_compiler_command) + add_custom_target(test-security-check + COMMAND ${CMAKE_COMMAND} -E env CXX=${cxx_compiler_command} CXXFLAGS=${CMAKE_CXX_FLAGS} LDFLAGS=${CMAKE_EXE_LINKER_FLAGS} ${PYTHON_COMMAND} ${PROJECT_SOURCE_DIR}/contrib/devtools/test-security-check.py TestSecurityChecks.test_${exe_format} + COMMAND ${CMAKE_COMMAND} -E env CXX=${cxx_compiler_command} CXXFLAGS=${CMAKE_CXX_FLAGS} LDFLAGS=${CMAKE_EXE_LINKER_FLAGS} ${PYTHON_COMMAND} ${PROJECT_SOURCE_DIR}/contrib/devtools/test-symbol-check.py TestSymbolChecks.test_${exe_format} + VERBATIM + ) + + foreach(target IN ITEMS bitcoind bitcoin-qt bitcoin-cli bitcoin-tx bitcoin-util bitcoin-wallet test_bitcoin bench_bitcoin) + if(TARGET ${target}) + list(APPEND executables $) + endif() + endforeach() + + add_custom_target(check-symbols + COMMAND ${CMAKE_COMMAND} -E echo "Running symbol and dynamic library checks..." + COMMAND ${PYTHON_COMMAND} ${PROJECT_SOURCE_DIR}/contrib/devtools/symbol-check.py ${executables} + VERBATIM + ) + + if(ENABLE_HARDENING) + add_custom_target(check-security + COMMAND ${CMAKE_COMMAND} -E echo "Checking binary security..." + COMMAND ${PYTHON_COMMAND} ${PROJECT_SOURCE_DIR}/contrib/devtools/security-check.py ${executables} + VERBATIM + ) + else() + add_custom_target(check-security) + endif() +endfunction() + +function(add_windows_deploy_target) + if(MINGW AND TARGET bitcoin-qt AND TARGET bitcoind AND TARGET bitcoin-cli AND TARGET bitcoin-tx AND TARGET bitcoin-wallet AND TARGET bitcoin-util AND TARGET test_bitcoin) + # TODO: Consider replacing this code with the CPack NSIS Generator. + # See https://cmake.org/cmake/help/latest/cpack_gen/nsis.html + include(GenerateSetupNsi) + generate_setup_nsi() + add_custom_command( + OUTPUT ${PROJECT_BINARY_DIR}/bitcoin-win64-setup.exe + COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/release + COMMAND ${CMAKE_STRIP} $ -o ${PROJECT_BINARY_DIR}/release/$ + COMMAND ${CMAKE_STRIP} $ -o ${PROJECT_BINARY_DIR}/release/$ + COMMAND ${CMAKE_STRIP} $ -o ${PROJECT_BINARY_DIR}/release/$ + COMMAND ${CMAKE_STRIP} $ -o ${PROJECT_BINARY_DIR}/release/$ + COMMAND ${CMAKE_STRIP} $ -o ${PROJECT_BINARY_DIR}/release/$ + COMMAND ${CMAKE_STRIP} $ -o ${PROJECT_BINARY_DIR}/release/$ + COMMAND ${CMAKE_STRIP} $ -o ${PROJECT_BINARY_DIR}/release/$ + COMMAND makensis -V2 ${PROJECT_BINARY_DIR}/bitcoin-win64-setup.nsi + VERBATIM + ) + add_custom_target(deploy DEPENDS ${PROJECT_BINARY_DIR}/bitcoin-win64-setup.exe) + endif() +endfunction() + +function(add_macos_deploy_target) + if(CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND TARGET bitcoin-qt) + set(macos_app "Bitcoin-Qt.app") + # Populate Contents subdirectory. + configure_file(${PROJECT_SOURCE_DIR}/share/qt/Info.plist.in ${macos_app}/Contents/Info.plist NO_SOURCE_PERMISSIONS) + file(CONFIGURE OUTPUT ${macos_app}/Contents/PkgInfo CONTENT "APPL????") + # Populate Contents/Resources subdirectory. + file(CONFIGURE OUTPUT ${macos_app}/Contents/Resources/empty.lproj CONTENT "") + configure_file(${PROJECT_SOURCE_DIR}/src/qt/res/icons/bitcoin.icns ${macos_app}/Contents/Resources/bitcoin.icns NO_SOURCE_PERMISSIONS COPYONLY) + file(CONFIGURE OUTPUT ${macos_app}/Contents/Resources/Base.lproj/InfoPlist.strings + CONTENT "{ CFBundleDisplayName = \"@CLIENT_NAME@\"; CFBundleName = \"@CLIENT_NAME@\"; }" + ) + + add_custom_command( + OUTPUT ${PROJECT_BINARY_DIR}/${macos_app}/Contents/MacOS/Bitcoin-Qt + COMMAND ${CMAKE_COMMAND} --install ${PROJECT_BINARY_DIR} --config $ --component GUI --prefix ${macos_app}/Contents/MacOS --strip + COMMAND ${CMAKE_COMMAND} -E rename ${macos_app}/Contents/MacOS/bin/$ ${macos_app}/Contents/MacOS/Bitcoin-Qt + COMMAND ${CMAKE_COMMAND} -E rm -rf ${macos_app}/Contents/MacOS/bin + VERBATIM + ) + + string(REPLACE " " "-" osx_volname ${CLIENT_NAME}) + if(CMAKE_HOST_APPLE) + add_custom_command( + OUTPUT ${PROJECT_BINARY_DIR}/${osx_volname}.zip + COMMAND ${PYTHON_COMMAND} ${PROJECT_SOURCE_DIR}/contrib/macdeploy/macdeployqtplus ${macos_app} ${osx_volname} -translations-dir=${QT_TRANSLATIONS_DIR} -zip + DEPENDS ${PROJECT_BINARY_DIR}/${macos_app}/Contents/MacOS/Bitcoin-Qt + VERBATIM + ) + add_custom_target(deploydir + DEPENDS ${PROJECT_BINARY_DIR}/${osx_volname}.zip + ) + add_custom_target(deploy + DEPENDS ${PROJECT_BINARY_DIR}/${osx_volname}.zip + ) + else() + add_custom_command( + OUTPUT ${PROJECT_BINARY_DIR}/dist/${macos_app}/Contents/MacOS/Bitcoin-Qt + COMMAND OBJDUMP=${CMAKE_OBJDUMP} ${PYTHON_COMMAND} ${PROJECT_SOURCE_DIR}/contrib/macdeploy/macdeployqtplus ${macos_app} ${osx_volname} -translations-dir=${QT_TRANSLATIONS_DIR} + DEPENDS ${PROJECT_BINARY_DIR}/${macos_app}/Contents/MacOS/Bitcoin-Qt + VERBATIM + ) + add_custom_target(deploydir + DEPENDS ${PROJECT_BINARY_DIR}/dist/${macos_app}/Contents/MacOS/Bitcoin-Qt + ) + + find_program(ZIP_COMMAND zip REQUIRED) + add_custom_command( + OUTPUT ${PROJECT_BINARY_DIR}/dist/${osx_volname}.zip + WORKING_DIRECTORY dist + COMMAND ${PROJECT_SOURCE_DIR}/cmake/script/macos_zip.sh ${ZIP_COMMAND} ${osx_volname}.zip + VERBATIM + ) + add_custom_target(deploy + DEPENDS ${PROJECT_BINARY_DIR}/dist/${osx_volname}.zip + ) + endif() + add_dependencies(deploydir bitcoin-qt) + add_dependencies(deploy deploydir) + endif() +endfunction() diff --git a/cmake/module/ProcessConfigurations.cmake b/cmake/module/ProcessConfigurations.cmake new file mode 100644 index 0000000000..7e2fc0080e --- /dev/null +++ b/cmake/module/ProcessConfigurations.cmake @@ -0,0 +1,175 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +include_guard(GLOBAL) + +include(TryAppendCXXFlags) + +macro(normalize_string string) + string(REGEX REPLACE " +" " " ${string} "${${string}}") + string(STRIP "${${string}}" ${string}) +endmacro() + +function(are_flags_overridden flags_var result_var) + normalize_string(${flags_var}) + normalize_string(${flags_var}_INIT) + if(${flags_var} STREQUAL ${flags_var}_INIT) + set(${result_var} FALSE PARENT_SCOPE) + else() + set(${result_var} TRUE PARENT_SCOPE) + endif() +endfunction() + + +# Removes duplicated flags. The relative order of flags is preserved. +# If duplicates are encountered, only the last instance is preserved. +function(deduplicate_flags flags) + separate_arguments(${flags}) + list(REVERSE ${flags}) + list(REMOVE_DUPLICATES ${flags}) + list(REVERSE ${flags}) + list(JOIN ${flags} " " result) + set(${flags} "${result}" PARENT_SCOPE) +endfunction() + + +function(get_all_configs output) + get_property(is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + set(all_configs ${CMAKE_CONFIGURATION_TYPES}) + else() + get_property(all_configs CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS) + if(NOT all_configs) + # See https://cmake.org/cmake/help/latest/manual/cmake-buildsystem.7.html#default-and-custom-configurations + set(all_configs Debug Release RelWithDebInfo MinSizeRel) + endif() + endif() + set(${output} "${all_configs}" PARENT_SCOPE) +endfunction() + + +#[=[ +Set the default build configuration. + +See: https://cmake.org/cmake/help/latest/manual/cmake-buildsystem.7.html#build-configurations. + +On single-configuration generators, this function sets the CMAKE_BUILD_TYPE variable to +the default build configuration, which can be overridden by the user at configure time if needed. + +On multi-configuration generators, this function rearranges the CMAKE_CONFIGURATION_TYPES list, +ensuring that the default build configuration appears first while maintaining the order of the +remaining configurations. The user can choose a build configuration at build time. +]=] +function(set_default_config config) + get_all_configs(all_configs) + if(NOT ${config} IN_LIST all_configs) + message(FATAL_ERROR "The default config is \"${config}\", but must be one of ${all_configs}.") + endif() + + list(REMOVE_ITEM all_configs ${config}) + list(PREPEND all_configs ${config}) + + get_property(is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + get_property(help_string CACHE CMAKE_CONFIGURATION_TYPES PROPERTY HELPSTRING) + set(CMAKE_CONFIGURATION_TYPES "${all_configs}" CACHE STRING "${help_string}" FORCE) + # Also see https://gitlab.kitware.com/cmake/cmake/-/issues/19512. + set(CMAKE_TRY_COMPILE_CONFIGURATION "${config}" PARENT_SCOPE) + else() + set_property(CACHE CMAKE_BUILD_TYPE PROPERTY + STRINGS "${all_configs}" + ) + if(NOT CMAKE_BUILD_TYPE) + message(STATUS "Setting build type to \"${config}\" as none was specified") + get_property(help_string CACHE CMAKE_BUILD_TYPE PROPERTY HELPSTRING) + set(CMAKE_BUILD_TYPE "${config}" CACHE STRING "${help_string}" FORCE) + endif() + set(CMAKE_TRY_COMPILE_CONFIGURATION "${CMAKE_BUILD_TYPE}" PARENT_SCOPE) + endif() +endfunction() + +function(remove_cxx_flag_from_all_configs flag) + get_all_configs(all_configs) + foreach(config IN LISTS all_configs) + string(TOUPPER "${config}" config_uppercase) + set(flags "${CMAKE_CXX_FLAGS_${config_uppercase}}") + separate_arguments(flags) + list(FILTER flags EXCLUDE REGEX "${flag}") + list(JOIN flags " " new_flags) + set(CMAKE_CXX_FLAGS_${config_uppercase} "${new_flags}" PARENT_SCOPE) + set(CMAKE_CXX_FLAGS_${config_uppercase} "${new_flags}" + CACHE STRING + "Flags used by the CXX compiler during ${config_uppercase} builds." + FORCE + ) + endforeach() +endfunction() + +function(replace_cxx_flag_in_config config old_flag new_flag) + string(TOUPPER "${config}" config_uppercase) + string(REGEX REPLACE "(^| )${old_flag}( |$)" "\\1${new_flag}\\2" new_flags "${CMAKE_CXX_FLAGS_${config_uppercase}}") + set(CMAKE_CXX_FLAGS_${config_uppercase} "${new_flags}" PARENT_SCOPE) + set(CMAKE_CXX_FLAGS_${config_uppercase} "${new_flags}" + CACHE STRING + "Flags used by the CXX compiler during ${config_uppercase} builds." + FORCE + ) +endfunction() + +set_default_config(RelWithDebInfo) + +# Redefine/adjust per-configuration flags. +target_compile_definitions(core_interface_debug INTERFACE + DEBUG + DEBUG_LOCKORDER + DEBUG_LOCKCONTENTION + RPC_DOC_CHECK + ABORT_ON_FAILED_ASSUME +) +# We leave assertions on. +if(MSVC) + remove_cxx_flag_from_all_configs(/DNDEBUG) +else() + remove_cxx_flag_from_all_configs(-DNDEBUG) + + # Adjust flags used by the CXX compiler during RELEASE builds. + # Prefer -O2 optimization level. (-O3 is CMake's default for Release for many compilers.) + replace_cxx_flag_in_config(Release -O3 -O2) + + are_flags_overridden(CMAKE_CXX_FLAGS_DEBUG cxx_flags_debug_overridden) + if(NOT cxx_flags_debug_overridden) + # Redefine flags used by the CXX compiler during DEBUG builds. + try_append_cxx_flags("-g3" RESULT_VAR compiler_supports_g3) + if(compiler_supports_g3) + replace_cxx_flag_in_config(Debug -g -g3) + endif() + unset(compiler_supports_g3) + + try_append_cxx_flags("-ftrapv" RESULT_VAR compiler_supports_ftrapv) + if(compiler_supports_ftrapv) + string(PREPEND CMAKE_CXX_FLAGS_DEBUG "-ftrapv ") + endif() + unset(compiler_supports_ftrapv) + + string(PREPEND CMAKE_CXX_FLAGS_DEBUG "-O0 ") + + set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}" + CACHE STRING + "Flags used by the CXX compiler during DEBUG builds." + FORCE + ) + endif() + unset(cxx_flags_debug_overridden) +endif() + +set(CMAKE_CXX_FLAGS_COVERAGE "-g -Og --coverage") +set(CMAKE_OBJCXX_FLAGS_COVERAGE "-g -Og --coverage") +set(CMAKE_EXE_LINKER_FLAGS_COVERAGE "--coverage") +set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE "--coverage") +get_property(is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) +if(is_multi_config) + if(NOT "Coverage" IN_LIST CMAKE_CONFIGURATION_TYPES) + list(APPEND CMAKE_CONFIGURATION_TYPES Coverage) + endif() +endif() diff --git a/cmake/module/TestAppendRequiredLibraries.cmake b/cmake/module/TestAppendRequiredLibraries.cmake new file mode 100644 index 0000000000..5352102c7a --- /dev/null +++ b/cmake/module/TestAppendRequiredLibraries.cmake @@ -0,0 +1,92 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +include_guard(GLOBAL) + +# Illumos/SmartOS requires linking with -lsocket if +# using getifaddrs & freeifaddrs. +# See: +# - https://github.com/bitcoin/bitcoin/pull/21486 +# - https://smartos.org/man/3socket/getifaddrs +function(test_append_socket_library target) + if (NOT TARGET ${target}) + message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION}() called with non-existent target \"${target}\".") + endif() + + set(check_socket_source " + #include + #include + + int main() { + struct ifaddrs* ifaddr; + getifaddrs(&ifaddr); + freeifaddrs(ifaddr); + } + ") + + include(CheckSourceCompilesAndLinks) + check_cxx_source_links("${check_socket_source}" IFADDR_LINKS_WITHOUT_LIBSOCKET) + if(NOT IFADDR_LINKS_WITHOUT_LIBSOCKET) + check_cxx_source_links_with_libs(socket "${check_socket_source}" IFADDR_NEEDS_LINK_TO_LIBSOCKET) + if(IFADDR_NEEDS_LINK_TO_LIBSOCKET) + target_link_libraries(${target} INTERFACE socket) + else() + message(FATAL_ERROR "Cannot figure out how to use getifaddrs/freeifaddrs.") + endif() + endif() + set(HAVE_DECL_GETIFADDRS TRUE PARENT_SCOPE) + set(HAVE_DECL_FREEIFADDRS TRUE PARENT_SCOPE) +endfunction() + +# Clang, when building for 32-bit, +# and linking against libstdc++, requires linking with +# -latomic if using the C++ atomic library. +# Can be tested with: clang++ -std=c++20 test.cpp -m32 +# +# Sourced from http://bugs.debian.org/797228 +function(test_append_atomic_library target) + if (NOT TARGET ${target}) + message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION}() called with non-existent target \"${target}\".") + endif() + + set(check_atomic_source " + #include + #include + #include + + using namespace std::chrono_literals; + + int main() { + std::atomic lock{true}; + lock.exchange(false); + + std::atomic t{0s}; + t.store(2s); + auto t1 = t.load(); + t.compare_exchange_strong(t1, 3s); + + std::atomic d{}; + d.store(3.14); + auto d1 = d.load(); + + std::atomic a{}; + int64_t v = 5; + int64_t r = a.fetch_add(v); + return static_cast(r); + } + ") + + include(CheckSourceCompilesAndLinks) + check_cxx_source_links("${check_atomic_source}" STD_ATOMIC_LINKS_WITHOUT_LIBATOMIC) + if(STD_ATOMIC_LINKS_WITHOUT_LIBATOMIC) + return() + endif() + + check_cxx_source_links_with_libs(atomic "${check_atomic_source}" STD_ATOMIC_NEEDS_LINK_TO_LIBATOMIC) + if(STD_ATOMIC_NEEDS_LINK_TO_LIBATOMIC) + target_link_libraries(${target} INTERFACE atomic) + else() + message(FATAL_ERROR "Cannot figure out how to use std::atomic.") + endif() +endfunction() diff --git a/cmake/module/TryAppendCXXFlags.cmake b/cmake/module/TryAppendCXXFlags.cmake new file mode 100644 index 0000000000..c07455e89e --- /dev/null +++ b/cmake/module/TryAppendCXXFlags.cmake @@ -0,0 +1,125 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +include_guard(GLOBAL) +include(CheckCXXSourceCompiles) + +#[=[ +Add language-wide flags, which will be passed to all invocations of the compiler. +This includes invocations that drive compiling and those that drive linking. + +Usage examples: + + try_append_cxx_flags("-Wformat -Wformat-security" VAR warn_cxx_flags) + + + try_append_cxx_flags("-Wsuggest-override" VAR warn_cxx_flags + SOURCE "struct A { virtual void f(); }; struct B : A { void f() final; };" + ) + + + try_append_cxx_flags("-fsanitize=${SANITIZERS}" TARGET core_interface + RESULT_VAR cxx_supports_sanitizers + ) + if(NOT cxx_supports_sanitizers) + message(FATAL_ERROR "Compiler did not accept requested flags.") + endif() + + + try_append_cxx_flags("-Wunused-parameter" TARGET core_interface + IF_CHECK_PASSED "-Wno-unused-parameter" + ) + + +In configuration output, this function prints a string by the following pattern: + + -- Performing Test CXX_SUPPORTS_[flags] + -- Performing Test CXX_SUPPORTS_[flags] - Success + +]=] +function(try_append_cxx_flags flags) + cmake_parse_arguments(PARSE_ARGV 1 + TACXXF # prefix + "SKIP_LINK" # options + "TARGET;VAR;SOURCE;RESULT_VAR" # one_value_keywords + "IF_CHECK_PASSED" # multi_value_keywords + ) + + set(flags_as_string "${flags}") + separate_arguments(flags) + + string(MAKE_C_IDENTIFIER "${flags_as_string}" id_string) + string(TOUPPER "${id_string}" id_string) + + set(source "int main() { return 0; }") + if(DEFINED TACXXF_SOURCE AND NOT TACXXF_SOURCE STREQUAL source) + set(source "${TACXXF_SOURCE}") + string(SHA256 source_hash "${source}") + string(SUBSTRING ${source_hash} 0 4 source_hash_head) + string(APPEND id_string _${source_hash_head}) + endif() + + # This avoids running a linker. + set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY) + set(CMAKE_REQUIRED_FLAGS "${flags_as_string} ${working_compiler_werror_flag}") + set(compiler_result CXX_SUPPORTS_${id_string}) + check_cxx_source_compiles("${source}" ${compiler_result}) + + if(${compiler_result}) + if(DEFINED TACXXF_IF_CHECK_PASSED) + if(DEFINED TACXXF_TARGET) + target_compile_options(${TACXXF_TARGET} INTERFACE ${TACXXF_IF_CHECK_PASSED}) + endif() + if(DEFINED TACXXF_VAR) + string(STRIP "${${TACXXF_VAR}} ${TACXXF_IF_CHECK_PASSED}" ${TACXXF_VAR}) + endif() + else() + if(DEFINED TACXXF_TARGET) + target_compile_options(${TACXXF_TARGET} INTERFACE ${flags}) + endif() + if(DEFINED TACXXF_VAR) + string(STRIP "${${TACXXF_VAR}} ${flags_as_string}" ${TACXXF_VAR}) + endif() + endif() + endif() + + if(DEFINED TACXXF_VAR) + set(${TACXXF_VAR} "${${TACXXF_VAR}}" PARENT_SCOPE) + endif() + + if(DEFINED TACXXF_RESULT_VAR) + set(${TACXXF_RESULT_VAR} "${${compiler_result}}" PARENT_SCOPE) + endif() + + if(NOT ${compiler_result} OR TACXXF_SKIP_LINK) + return() + endif() + + # This forces running a linker. + set(CMAKE_TRY_COMPILE_TARGET_TYPE EXECUTABLE) + set(CMAKE_REQUIRED_FLAGS "${flags_as_string}") + set(CMAKE_REQUIRED_LINK_OPTIONS ${working_linker_werror_flag}) + set(linker_result LINKER_SUPPORTS_${id_string}) + check_cxx_source_compiles("${source}" ${linker_result}) + + if(${linker_result}) + if(DEFINED TACXXF_IF_CHECK_PASSED) + if(DEFINED TACXXF_TARGET) + target_link_options(${TACXXF_TARGET} INTERFACE ${TACXXF_IF_CHECK_PASSED}) + endif() + else() + if(DEFINED TACXXF_TARGET) + target_link_options(${TACXXF_TARGET} INTERFACE ${flags}) + endif() + endif() + else() + message(WARNING "'${flags_as_string}' fail(s) to link.") + endif() +endfunction() + +if(MSVC) + try_append_cxx_flags("/WX /options:strict" VAR working_compiler_werror_flag SKIP_LINK) +else() + try_append_cxx_flags("-Werror" VAR working_compiler_werror_flag SKIP_LINK) +endif() diff --git a/cmake/module/TryAppendLinkerFlag.cmake b/cmake/module/TryAppendLinkerFlag.cmake new file mode 100644 index 0000000000..8cbd83678d --- /dev/null +++ b/cmake/module/TryAppendLinkerFlag.cmake @@ -0,0 +1,78 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +include_guard(GLOBAL) +include(CheckCXXSourceCompiles) + +#[=[ +Usage example: + + try_append_linker_flag("-Wl,--major-subsystem-version,6" TARGET core_interface) + + +In configuration output, this function prints a string by the following pattern: + + -- Performing Test LINKER_SUPPORTS_[flag] + -- Performing Test LINKER_SUPPORTS_[flag] - Success + +]=] +function(try_append_linker_flag flag) + cmake_parse_arguments(PARSE_ARGV 1 + TALF # prefix + "" # options + "TARGET;VAR;SOURCE;RESULT_VAR" # one_value_keywords + "IF_CHECK_PASSED" # multi_value_keywords + ) + + string(MAKE_C_IDENTIFIER "${flag}" result) + string(TOUPPER "${result}" result) + string(PREPEND result LINKER_SUPPORTS_) + + set(source "int main() { return 0; }") + if(DEFINED TALF_SOURCE AND NOT TALF_SOURCE STREQUAL source) + set(source "${TALF_SOURCE}") + string(SHA256 source_hash "${source}") + string(SUBSTRING ${source_hash} 0 4 source_hash_head) + string(APPEND result _${source_hash_head}) + endif() + + # This forces running a linker. + set(CMAKE_TRY_COMPILE_TARGET_TYPE EXECUTABLE) + set(CMAKE_REQUIRED_LINK_OPTIONS ${flag} ${working_linker_werror_flag}) + check_cxx_source_compiles("${source}" ${result}) + + if(${result}) + if(DEFINED TALF_IF_CHECK_PASSED) + if(DEFINED TALF_TARGET) + target_link_options(${TALF_TARGET} INTERFACE ${TALF_IF_CHECK_PASSED}) + endif() + if(DEFINED TALF_VAR) + string(STRIP "${${TALF_VAR}} ${TALF_IF_CHECK_PASSED}" ${TALF_VAR}) + endif() + else() + if(DEFINED TALF_TARGET) + target_link_options(${TALF_TARGET} INTERFACE ${flag}) + endif() + if(DEFINED TALF_VAR) + string(STRIP "${${TALF_VAR}} ${flag}" ${TALF_VAR}) + endif() + endif() + endif() + + if(DEFINED TALF_VAR) + set(${TALF_VAR} "${${TALF_VAR}}" PARENT_SCOPE) + endif() + + if(DEFINED TALF_RESULT_VAR) + set(${TALF_RESULT_VAR} "${${result}}" PARENT_SCOPE) + endif() +endfunction() + +if(MSVC) + try_append_linker_flag("/WX" VAR working_linker_werror_flag) +elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin") + try_append_linker_flag("-Wl,-fatal_warnings" VAR working_linker_werror_flag) +else() + try_append_linker_flag("-Wl,--fatal-warnings" VAR working_linker_werror_flag) +endif() diff --git a/cmake/module/WarnAboutGlobalProperties.cmake b/cmake/module/WarnAboutGlobalProperties.cmake new file mode 100644 index 0000000000..faa56a2a7f --- /dev/null +++ b/cmake/module/WarnAboutGlobalProperties.cmake @@ -0,0 +1,36 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +include_guard(GLOBAL) + +# Avoid the directory-wide add_definitions() and add_compile_definitions() commands. +# Instead, prefer the target-specific target_compile_definitions() one. +get_directory_property(global_compile_definitions COMPILE_DEFINITIONS) +if(global_compile_definitions) + message(AUTHOR_WARNING "The directory's COMPILE_DEFINITIONS property is not empty: ${global_compile_definitions}") +endif() + +# Avoid the directory-wide add_compile_options() command. +# Instead, prefer the target-specific target_compile_options() one. +get_directory_property(global_compile_options COMPILE_OPTIONS) +if(global_compile_options) + message(AUTHOR_WARNING "The directory's COMPILE_OPTIONS property is not empty: ${global_compile_options}") +endif() + +# Avoid the directory-wide add_link_options() command. +# Instead, prefer the target-specific target_link_options() one. +get_directory_property(global_link_options LINK_OPTIONS) +if(global_link_options) + message(AUTHOR_WARNING "The directory's LINK_OPTIONS property is not empty: ${global_link_options}") +endif() + +# Avoid the directory-wide link_libraries() command. +# Instead, prefer the target-specific target_link_libraries() one. +file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/dummy_cxx_source.cpp "#error") +add_library(check_loose_linked_libraries OBJECT EXCLUDE_FROM_ALL ${CMAKE_CURRENT_BINARY_DIR}/dummy_cxx_source.cpp) +set_target_properties(check_loose_linked_libraries PROPERTIES EXPORT_COMPILE_COMMANDS OFF) +get_target_property(global_linked_libraries check_loose_linked_libraries LINK_LIBRARIES) +if(global_linked_libraries) + message(AUTHOR_WARNING "There are libraries linked with `link_libraries` commands: ${global_linked_libraries}") +endif() diff --git a/cmake/script/Coverage.cmake b/cmake/script/Coverage.cmake new file mode 100644 index 0000000000..72587a5eb6 --- /dev/null +++ b/cmake/script/Coverage.cmake @@ -0,0 +1,89 @@ +# Copyright (c) 2024-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +include(${CMAKE_CURRENT_LIST_DIR}/CoverageInclude.cmake) + +set(functional_test_runner test/functional/test_runner.py) +if(EXTENDED_FUNCTIONAL_TESTS) + list(APPEND functional_test_runner --extended) +endif() +if(DEFINED JOBS) + list(APPEND CMAKE_CTEST_COMMAND -j ${JOBS}) + list(APPEND functional_test_runner -j ${JOBS}) +endif() + +execute_process( + COMMAND ${CMAKE_CTEST_COMMAND} --build-config Coverage + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) +execute_process( + COMMAND ${LCOV_COMMAND} --capture --directory src --test-name test_bitcoin --output-file test_bitcoin.info + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) +execute_process( + COMMAND ${LCOV_COMMAND} --zerocounters --directory src + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) +execute_process( + COMMAND ${LCOV_FILTER_COMMAND} test_bitcoin.info test_bitcoin_filtered.info + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) +execute_process( + COMMAND ${LCOV_COMMAND} --add-tracefile test_bitcoin_filtered.info --output-file test_bitcoin_filtered.info + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) +execute_process( + COMMAND ${LCOV_COMMAND} --add-tracefile baseline_filtered.info --add-tracefile test_bitcoin_filtered.info --output-file test_bitcoin_coverage.info + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) +execute_process( + COMMAND ${GENHTML_COMMAND} test_bitcoin_coverage.info --output-directory test_bitcoin.coverage + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) + +execute_process( + COMMAND ${functional_test_runner} + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) +execute_process( + COMMAND ${LCOV_COMMAND} --capture --directory src --test-name functional-tests --output-file functional_test.info + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) +execute_process( + COMMAND ${LCOV_COMMAND} --zerocounters --directory src + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) +execute_process( + COMMAND ${LCOV_FILTER_COMMAND} functional_test.info functional_test_filtered.info + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) +execute_process( + COMMAND ${LCOV_COMMAND} --add-tracefile functional_test_filtered.info --output-file functional_test_filtered.info + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) +execute_process( + COMMAND ${LCOV_COMMAND} --add-tracefile baseline_filtered.info --add-tracefile test_bitcoin_filtered.info --add-tracefile functional_test_filtered.info --output-file total_coverage.info + COMMAND ${GREP_EXECUTABLE} "%" + COMMAND ${AWK_EXECUTABLE} "{ print substr($3,2,50) \"/\" $5 }" + OUTPUT_FILE coverage_percent.txt + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) +execute_process( + COMMAND ${GENHTML_COMMAND} total_coverage.info --output-directory total.coverage + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) diff --git a/cmake/script/CoverageFuzz.cmake b/cmake/script/CoverageFuzz.cmake new file mode 100644 index 0000000000..0558805394 --- /dev/null +++ b/cmake/script/CoverageFuzz.cmake @@ -0,0 +1,53 @@ +# Copyright (c) 2024-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +include(${CMAKE_CURRENT_LIST_DIR}/CoverageInclude.cmake) + +if(NOT DEFINED FUZZ_CORPORA_DIR) + set(FUZZ_CORPORA_DIR ${CMAKE_CURRENT_SOURCE_DIR}/qa-assets/fuzz_corpora) +endif() + +set(fuzz_test_runner test/fuzz/test_runner.py ${FUZZ_CORPORA_DIR}) +if(DEFINED JOBS) + list(APPEND fuzz_test_runner -j ${JOBS}) +endif() + +execute_process( + COMMAND ${fuzz_test_runner} --loglevel DEBUG + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) +execute_process( + COMMAND ${LCOV_COMMAND} --capture --directory src --test-name fuzz-tests --output-file fuzz.info + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) +execute_process( + COMMAND ${LCOV_COMMAND} --zerocounters --directory src + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) +execute_process( + COMMAND ${LCOV_FILTER_COMMAND} fuzz.info fuzz_filtered.info + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) +execute_process( + COMMAND ${LCOV_COMMAND} --add-tracefile fuzz_filtered.info --output-file fuzz_filtered.info + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) +execute_process( + COMMAND ${LCOV_COMMAND} --add-tracefile baseline_filtered.info --add-tracefile fuzz_filtered.info --output-file fuzz_coverage.info + COMMAND ${GREP_EXECUTABLE} "%" + COMMAND ${AWK_EXECUTABLE} "{ print substr($3,2,50) \"/\" $5 }" + OUTPUT_FILE coverage_percent.txt + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) +execute_process( + COMMAND ${GENHTML_COMMAND} fuzz_coverage.info --output-directory fuzz.coverage + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) diff --git a/cmake/script/CoverageInclude.cmake.in b/cmake/script/CoverageInclude.cmake.in new file mode 100644 index 0000000000..59bf5e3af2 --- /dev/null +++ b/cmake/script/CoverageInclude.cmake.in @@ -0,0 +1,59 @@ +# Copyright (c) 2024-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +if("@CMAKE_CXX_COMPILER_ID@" STREQUAL "Clang") + find_program(LLVM_COV_EXECUTABLE llvm-cov REQUIRED) + set(COV_TOOL "${LLVM_COV_EXECUTABLE} gcov") +else() + find_program(GCOV_EXECUTABLE gcov REQUIRED) + set(COV_TOOL "${GCOV_EXECUTABLE}") +endif() + +# COV_TOOL is used to replace a placeholder. +configure_file( + cmake/cov_tool_wrapper.sh.in ${CMAKE_CURRENT_LIST_DIR}/cov_tool_wrapper.sh + FILE_PERMISSIONS OWNER_READ OWNER_EXECUTE + GROUP_READ GROUP_EXECUTE + WORLD_READ + @ONLY +) + +find_program(LCOV_EXECUTABLE lcov REQUIRED) +separate_arguments(LCOV_OPTS) +set(LCOV_COMMAND ${LCOV_EXECUTABLE} --gcov-tool ${CMAKE_CURRENT_LIST_DIR}/cov_tool_wrapper.sh ${LCOV_OPTS}) + +find_program(GENHTML_EXECUTABLE genhtml REQUIRED) +set(GENHTML_COMMAND ${GENHTML_EXECUTABLE} --show-details ${LCOV_OPTS}) + +find_program(GREP_EXECUTABLE grep REQUIRED) +find_program(AWK_EXECUTABLE awk REQUIRED) + +set(LCOV_FILTER_COMMAND ./filter-lcov.py) +list(APPEND LCOV_FILTER_COMMAND -p "/usr/local/") +list(APPEND LCOV_FILTER_COMMAND -p "/usr/include/") +list(APPEND LCOV_FILTER_COMMAND -p "/usr/lib/") +list(APPEND LCOV_FILTER_COMMAND -p "/usr/lib64/") +list(APPEND LCOV_FILTER_COMMAND -p "src/leveldb/") +list(APPEND LCOV_FILTER_COMMAND -p "src/crc32c/") +list(APPEND LCOV_FILTER_COMMAND -p "src/bench/") +list(APPEND LCOV_FILTER_COMMAND -p "src/crypto/ctaes") +list(APPEND LCOV_FILTER_COMMAND -p "src/minisketch") +list(APPEND LCOV_FILTER_COMMAND -p "src/secp256k1") +list(APPEND LCOV_FILTER_COMMAND -p "depends") + +execute_process( + COMMAND ${LCOV_COMMAND} --capture --initial --directory src --output-file baseline.info + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) +execute_process( + COMMAND ${LCOV_FILTER_COMMAND} baseline.info baseline_filtered.info + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) +execute_process( + COMMAND ${LCOV_COMMAND} --add-tracefile baseline_filtered.info --output-file baseline_filtered.info + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + COMMAND_ERROR_IS_FATAL ANY +) diff --git a/cmake/script/GenerateBuildInfo.cmake b/cmake/script/GenerateBuildInfo.cmake new file mode 100644 index 0000000000..d3ee2eb062 --- /dev/null +++ b/cmake/script/GenerateBuildInfo.cmake @@ -0,0 +1,113 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +macro(fatal_error) + message(FATAL_ERROR "\n" + "Usage:\n" + " cmake -D BUILD_INFO_HEADER_PATH= [-D SOURCE_DIR=] -P ${CMAKE_CURRENT_LIST_FILE}\n" + "All specified paths must be absolute ones.\n" + ) +endmacro() + +if(DEFINED BUILD_INFO_HEADER_PATH AND IS_ABSOLUTE "${BUILD_INFO_HEADER_PATH}") + if(EXISTS "${BUILD_INFO_HEADER_PATH}") + file(STRINGS ${BUILD_INFO_HEADER_PATH} INFO LIMIT_COUNT 1) + endif() +else() + fatal_error() +endif() + +if(DEFINED SOURCE_DIR) + if(IS_ABSOLUTE "${SOURCE_DIR}" AND IS_DIRECTORY "${SOURCE_DIR}") + set(WORKING_DIR ${SOURCE_DIR}) + else() + fatal_error() + endif() +else() + set(WORKING_DIR ${CMAKE_CURRENT_SOURCE_DIR}) +endif() + +set(GIT_TAG) +set(GIT_COMMIT) +if(NOT "$ENV{BITCOIN_GENBUILD_NO_GIT}" STREQUAL "1") + find_package(Git QUIET) + if(Git_FOUND) + execute_process( + COMMAND ${GIT_EXECUTABLE} rev-parse --is-inside-work-tree + WORKING_DIRECTORY ${WORKING_DIR} + OUTPUT_VARIABLE IS_INSIDE_WORK_TREE + OUTPUT_STRIP_TRAILING_WHITESPACE + ERROR_QUIET + ) + if(IS_INSIDE_WORK_TREE) + # Clean 'dirty' status of touched files that haven't been modified. + execute_process( + COMMAND ${GIT_EXECUTABLE} diff + WORKING_DIRECTORY ${WORKING_DIR} + OUTPUT_QUIET + ERROR_QUIET + ) + + execute_process( + COMMAND ${GIT_EXECUTABLE} describe --abbrev=0 + WORKING_DIRECTORY ${WORKING_DIR} + OUTPUT_VARIABLE MOST_RECENT_TAG + OUTPUT_STRIP_TRAILING_WHITESPACE + ERROR_QUIET + ) + + execute_process( + COMMAND ${GIT_EXECUTABLE} rev-list -1 ${MOST_RECENT_TAG} + WORKING_DIRECTORY ${WORKING_DIR} + OUTPUT_VARIABLE MOST_RECENT_TAG_COMMIT + OUTPUT_STRIP_TRAILING_WHITESPACE + ERROR_QUIET + ) + + execute_process( + COMMAND ${GIT_EXECUTABLE} rev-parse HEAD + WORKING_DIRECTORY ${WORKING_DIR} + OUTPUT_VARIABLE HEAD_COMMIT + OUTPUT_STRIP_TRAILING_WHITESPACE + ERROR_QUIET + ) + + execute_process( + COMMAND ${GIT_EXECUTABLE} diff-index --quiet HEAD -- + WORKING_DIRECTORY ${WORKING_DIR} + RESULT_VARIABLE IS_DIRTY + ) + + if(HEAD_COMMIT STREQUAL MOST_RECENT_TAG_COMMIT AND NOT IS_DIRTY) + # If latest commit is tagged and not dirty, then use the tag name. + set(GIT_TAG ${MOST_RECENT_TAG}) + else() + # Otherwise, generate suffix from git, i.e. string like "0e0a5173fae3-dirty". + execute_process( + COMMAND ${GIT_EXECUTABLE} rev-parse --short=12 HEAD + WORKING_DIRECTORY ${WORKING_DIR} + OUTPUT_VARIABLE GIT_COMMIT + OUTPUT_STRIP_TRAILING_WHITESPACE + ERROR_QUIET + ) + if(IS_DIRTY) + string(APPEND GIT_COMMIT "-dirty") + endif() + endif() + endif() + endif() +endif() + +if(GIT_TAG) + set(NEWINFO "#define BUILD_GIT_TAG \"${GIT_TAG}\"") +elseif(GIT_COMMIT) + set(NEWINFO "#define BUILD_GIT_COMMIT \"${GIT_COMMIT}\"") +else() + set(NEWINFO "// No build information available") +endif() + +# Only update the header if necessary. +if(NOT "${INFO}" STREQUAL "${NEWINFO}") + file(WRITE ${BUILD_INFO_HEADER_PATH} "${NEWINFO}\n") +endif() diff --git a/cmake/script/GenerateHeaderFromJson.cmake b/cmake/script/GenerateHeaderFromJson.cmake new file mode 100644 index 0000000000..4a3bddb323 --- /dev/null +++ b/cmake/script/GenerateHeaderFromJson.cmake @@ -0,0 +1,22 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +cmake_path(GET JSON_SOURCE_PATH STEM json_source_basename) + +file(READ ${JSON_SOURCE_PATH} hex_content HEX) +string(REGEX REPLACE "................" "\\0\n" formatted_bytes "${hex_content}") +string(REGEX REPLACE "[^\n][^\n]" "0x\\0, " formatted_bytes "${formatted_bytes}") + +set(header_content +"#include + +namespace json_tests { +inline constexpr char detail_${json_source_basename}_bytes[] { +${formatted_bytes} +}; + +inline constexpr std::string_view ${json_source_basename}{std::begin(detail_${json_source_basename}_bytes), std::end(detail_${json_source_basename}_bytes)}; +} +") +file(WRITE ${HEADER_PATH} "${header_content}") diff --git a/cmake/script/GenerateHeaderFromRaw.cmake b/cmake/script/GenerateHeaderFromRaw.cmake new file mode 100644 index 0000000000..638876ecea --- /dev/null +++ b/cmake/script/GenerateHeaderFromRaw.cmake @@ -0,0 +1,23 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +cmake_path(GET RAW_SOURCE_PATH STEM raw_source_basename) + +file(READ ${RAW_SOURCE_PATH} hex_content HEX) +string(REGEX REPLACE "................" "\\0\n" formatted_bytes "${hex_content}") +string(REGEX REPLACE "[^\n][^\n]" "std::byte{0x\\0}, " formatted_bytes "${formatted_bytes}") + +set(header_content +"#include +#include + +namespace ${RAW_NAMESPACE} { +inline constexpr std::byte detail_${raw_source_basename}_raw[] { +${formatted_bytes} +}; + +inline constexpr std::span ${raw_source_basename}{detail_${raw_source_basename}_raw}; +} +") +file(WRITE ${HEADER_PATH} "${header_content}") diff --git a/cmake/script/macos_zip.sh b/cmake/script/macos_zip.sh new file mode 100755 index 0000000000..cc51699dc9 --- /dev/null +++ b/cmake/script/macos_zip.sh @@ -0,0 +1,12 @@ +#!/bin/sh +# Copyright (c) 2024-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +export LC_ALL=C + +if [ -n "$SOURCE_DATE_EPOCH" ]; then + find . -exec touch -d "@$SOURCE_DATE_EPOCH" {} + +fi + +find . | sort | "$1" -X@ "$2" diff --git a/cmake/tests.cmake b/cmake/tests.cmake new file mode 100644 index 0000000000..2791329800 --- /dev/null +++ b/cmake/tests.cmake @@ -0,0 +1,15 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +if(TARGET bitcoin-util AND TARGET bitcoin-tx AND PYTHON_COMMAND) + add_test(NAME util_test_runner + COMMAND ${CMAKE_COMMAND} -E env BITCOINUTIL=$ BITCOINTX=$ ${PYTHON_COMMAND} ${PROJECT_BINARY_DIR}/test/util/test_runner.py + ) +endif() + +if(PYTHON_COMMAND) + add_test(NAME util_rpcauth_test + COMMAND ${PYTHON_COMMAND} ${PROJECT_BINARY_DIR}/test/util/rpcauth-test.py + ) +endif() From 8284a1ba7ef88a1b56180dbf71b9733f5822707f Mon Sep 17 00:00:00 2001 From: AlefLm Date: Sun, 15 Dec 2024 01:27:19 +0000 Subject: [PATCH 03/19] bench: Add initial cmake support --- src/bench/CMakeLists.txt | 47 ++++++++++++++++++++++++++++++++++++++++ src/bench/bench.h | 1 + 2 files changed, 48 insertions(+) create mode 100644 src/bench/CMakeLists.txt diff --git a/src/bench/CMakeLists.txt b/src/bench/CMakeLists.txt new file mode 100644 index 0000000000..8b058dd8ad --- /dev/null +++ b/src/bench/CMakeLists.txt @@ -0,0 +1,47 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +include(GenerateHeaders) +generate_header_from_raw(data/block413567.raw benchmark::data) + +add_executable(bench_firo + bench_bitcoin.cpp + bench.cpp + ${CMAKE_CURRENT_BINARY_DIR}/data/block413567.raw.h +# Benchmarks: + base58.cpp + ccoins_caching.cpp + checkblock.cpp + checkqueue.cpp + crypto_hash.cpp + Examples.cpp + lockedpool.cpp + mempool_eviction.cpp + perf.cpp + rollingbloom.cpp + verify_script.cpp +) + +target_link_libraries(bench_firo + core_interface + test_util + firo_node + Boost::headers +) + +if(ENABLE_WALLET) + target_sources(bench_firo + PRIVATE + coin_selection.cpp + ) + target_link_libraries(bench_firo firo_wallet) +endif() + +add_test(NAME bench_sanity_check_high_priority + COMMAND bench_firo -sanity-check -priority-level=high +) + +install(TARGETS bench_firo + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} +) diff --git a/src/bench/bench.h b/src/bench/bench.h index 0e7605c726..90a942f6c3 100644 --- a/src/bench/bench.h +++ b/src/bench/bench.h @@ -7,6 +7,7 @@ #include #include +#include #include #include From 6b6c7a3b1e4146d0bdf85e4ceda38eab33c7aed5 Mon Sep 17 00:00:00 2001 From: AlefLm Date: Sun, 15 Dec 2024 01:47:23 +0000 Subject: [PATCH 04/19] Add initial main CMakeLists.txt --- CMakeLists.txt | 613 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 613 insertions(+) create mode 100644 CMakeLists.txt diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000000..897791e93d --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,613 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +# Ubuntu 22.04 LTS Jammy Jellyfish, https://wiki.ubuntu.com/Releases, EOSS in June 2027: +# - CMake 3.22.1, https://packages.ubuntu.com/jammy/cmake +# +# Centos Stream 9, https://www.centos.org/cl-vs-cs/#end-of-life, EOL in May 2027: +# - CMake 3.26.5, https://mirror.stream.centos.org/9-stream/AppStream/x86_64/os/Packages/ +cmake_minimum_required(VERSION 3.22) + +if (${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR}) + message(FATAL_ERROR "In-source builds are not allowed.") +endif() + +#============================= +# Project / Package metadata +#============================= +set(CLIENT_NAME "Firo Core") +set(CLIENT_VERSION_MAJOR 0) +set(CLIENT_VERSION_MINOR 14) +set(CLIENT_VERSION_BUILD 0) +set(CLIENT_VERSION_RC 0) +set(CLIENT_VERSION_IS_RELEASE "false") +set(COPYRIGHT_YEAR "2024") + +# During the enabling of the CXX and CXXOBJ languages, we modify +# CMake's compiler/linker invocation strings by appending the content +# of the user-defined `APPEND_*` variables, which allows overriding +# any flag. We also ensure that the APPEND_* flags are considered +# during CMake's tests, which use the `try_compile()` command. +# +# CMake's docs state that the `CMAKE_TRY_COMPILE_PLATFORM_VARIABLES` +# variable "is meant to be set by CMake's platform information modules +# for the current toolchain, or by a toolchain file." We do our best +# to set it before the `project()` command. +set(CMAKE_TRY_COMPILE_PLATFORM_VARIABLES + CMAKE_CXX_COMPILE_OBJECT + CMAKE_OBJCXX_COMPILE_OBJECT + CMAKE_CXX_LINK_EXECUTABLE +) + +project(FiroCore + VERSION ${CLIENT_VERSION_MAJOR}.${CLIENT_VERSION_MINOR}.${CLIENT_VERSION_BUILD} + DESCRIPTION "Firo client software" + HOMEPAGE_URL "https://firo.org/" + LANGUAGES NONE +) + +set(CLIENT_VERSION_STRING ${PROJECT_VERSION}) +if(CLIENT_VERSION_RC GREATER 0) + string(APPEND CLIENT_VERSION_STRING "rc${CLIENT_VERSION_RC}") +endif() + +set(COPYRIGHT_HOLDERS "The %s developers") +set(COPYRIGHT_HOLDERS_FINAL "The ${CLIENT_NAME} developers") +set(CLIENT_BUGREPORT "https://github.com/firoorg/firo/issues") + +#============================= +# Language setup +#============================= +if(CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND NOT CMAKE_HOST_APPLE) + # We do not use the install_name_tool when cross-compiling for macOS. + # So disable this tool check in further enable_language() commands. + set(CMAKE_PLATFORM_HAS_INSTALLNAME FALSE) +endif() +enable_language(CXX) +set(CMAKE_CXX_STANDARD 20) +set(CMAKE_CXX_STANDARD_REQUIRED ON) +set(CMAKE_CXX_EXTENSIONS OFF) + +list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/module) + +#============================= +# Configurable options +#============================= +include(CMakeDependentOption) +# When adding a new option, end the with a full stop for consistency. +option(BUILD_DAEMON "Build firod executable." ON) +option(BUILD_GUI "Build firo-qt executable." OFF) +option(BUILD_CLI "Build firo-cli executable." ON) + +option(BUILD_TESTS "Build test_firo executable." ON) +option(BUILD_TX "Build firo-tx executable." ${BUILD_TESTS}) +option(BUILD_UTIL "Build firo-util executable." ${BUILD_TESTS}) + +option(BUILD_UTIL_CHAINSTATE "Build experimental firo-chainstate executable." OFF) +option(BUILD_KERNEL_LIB "Build experimental firokernel library." ${BUILD_UTIL_CHAINSTATE}) + +option(ENABLE_WALLET "Enable wallet." ON) +option(WITH_BDB "Enable Berkeley DB (BDB) wallet support." OFF) +cmake_dependent_option(WARN_INCOMPATIBLE_BDB "Warn when using a Berkeley DB (BDB) version other than 4.8." ON "WITH_BDB" OFF) +if(WITH_BDB) + find_package(BerkeleyDB 4.8 MODULE REQUIRED) + set(USE_BDB ON) + if(NOT BerkeleyDB_VERSION VERSION_EQUAL 4.8) + message(WARNING "Found Berkeley DB (BDB) other than 4.8.\n" + "BDB (legacy) wallets opened by this build will not be portable!" + ) + if(WARN_INCOMPATIBLE_BDB) + message(WARNING "If this is intended, pass \"-DWARN_INCOMPATIBLE_BDB=OFF\".\n" + "Passing \"-DWITH_BDB=OFF\" will suppress this warning." + ) + endif() + endif() +endif() +cmake_dependent_option(BUILD_WALLET_TOOL "Build firo-wallet tool." ${BUILD_TESTS} "ENABLE_WALLET" OFF) + +option(ENABLE_HARDENING "Attempt to harden the resulting executables." ON) +option(REDUCE_EXPORTS "Attempt to reduce exported symbols in the resulting executables." OFF) +option(WERROR "Treat compiler warnings as errors." OFF) +option(WITH_CCACHE "Attempt to use ccache for compiling." ON) + +option(WITH_ZMQ "Enable ZMQ notifications." OFF) +if(WITH_ZMQ) + find_package(ZeroMQ 4.0.0 MODULE REQUIRED) +endif() + +option(WITH_USDT "Enable tracepoints for Userspace, Statically Defined Tracing." OFF) +if(WITH_USDT) + find_package(USDT MODULE REQUIRED) +endif() + +cmake_dependent_option(ENABLE_EXTERNAL_SIGNER "Enable external signer support." ON "NOT WIN32" OFF) + +cmake_dependent_option(WITH_QRENCODE "Enable QR code support." ON "BUILD_GUI" OFF) +if(WITH_QRENCODE) + find_package(QRencode MODULE REQUIRED) + set(USE_QRCODE TRUE) +endif() + +cmake_dependent_option(WITH_DBUS "Enable DBus support." ON "CMAKE_SYSTEM_NAME STREQUAL \"Linux\" AND BUILD_GUI" OFF) + + +cmake_dependent_option(BUILD_GUI_TESTS "Build test_firo-qt executable." ON "BUILD_GUI;BUILD_TESTS" OFF) +if(BUILD_GUI) + set(qt_components Core Gui Widgets LinguistTools) + if(ENABLE_WALLET) + list(APPEND qt_components Network) + endif() + if(WITH_DBUS) + list(APPEND qt_components DBus) + set(USE_DBUS TRUE) + endif() + if(BUILD_GUI_TESTS) + list(APPEND qt_components Test) + endif() + find_package(Qt 5.11.3 MODULE REQUIRED + COMPONENTS ${qt_components} + ) + unset(qt_components) +endif() + +option(BUILD_BENCH "Build bench_firo executable." OFF) +option(BUILD_FUZZ_BINARY "Build fuzz binary." OFF) +option(BUILD_FOR_FUZZING "Build for fuzzing. Enabling this will disable all other targets and override BUILD_FUZZ_BINARY." OFF) + +option(INSTALL_MAN "Install man pages." ON) + +set(APPEND_CPPFLAGS "" CACHE STRING "Preprocessor flags that are appended to the command line after all other flags added by the build system. This variable is intended for debugging and special builds.") +set(APPEND_CFLAGS "" CACHE STRING "C compiler flags that are appended to the command line after all other flags added by the build system. This variable is intended for debugging and special builds.") +set(APPEND_CXXFLAGS "" CACHE STRING "(Objective) C++ compiler flags that are appended to the command line after all other flags added by the build system. This variable is intended for debugging and special builds.") +set(APPEND_LDFLAGS "" CACHE STRING "Linker flags that are appended to the command line after all other flags added by the build system. This variable is intended for debugging and special builds.") +# Appending to this low-level rule variables is the only way to +# guarantee that the flags appear at the end of the command line. +string(APPEND CMAKE_CXX_COMPILE_OBJECT " ${APPEND_CPPFLAGS} ${APPEND_CXXFLAGS}") +string(APPEND CMAKE_CXX_CREATE_SHARED_LIBRARY " ${APPEND_LDFLAGS}") +string(APPEND CMAKE_CXX_LINK_EXECUTABLE " ${APPEND_LDFLAGS}") + +set(configure_warnings) + +include(CheckPIESupported) +check_pie_supported(OUTPUT_VARIABLE check_pie_output LANGUAGES CXX) +if(CMAKE_CXX_LINK_PIE_SUPPORTED) + set(CMAKE_POSITION_INDEPENDENT_CODE ON) +elseif(NOT WIN32) + # The warning is superfluous for Windows. + message(WARNING "PIE is not supported at link time: ${check_pie_output}") + list(APPEND configure_warnings "Position independent code disabled.") +endif() +unset(check_pie_output) + +# The core_interface library aims to encapsulate common build flags. +# It is a usage requirement for all targets except for secp256k1, which +# gets its flags by other means. +add_library(core_interface INTERFACE) +add_library(core_interface_relwithdebinfo INTERFACE) +add_library(core_interface_debug INTERFACE) +target_link_libraries(core_interface INTERFACE + $<$:core_interface_relwithdebinfo> + $<$:core_interface_debug> +) + +if(BUILD_FOR_FUZZING) + message(WARNING "BUILD_FOR_FUZZING=ON will disable all other targets and force BUILD_FUZZ_BINARY=ON.") + set(BUILD_DAEMON OFF) + set(BUILD_CLI OFF) + set(BUILD_TX OFF) + set(BUILD_UTIL OFF) + set(BUILD_UTIL_CHAINSTATE OFF) + set(BUILD_KERNEL_LIB OFF) + set(BUILD_WALLET_TOOL OFF) + set(BUILD_GUI OFF) + set(ENABLE_EXTERNAL_SIGNER OFF) + set(WITH_ZMQ OFF) + set(BUILD_TESTS OFF) + set(BUILD_GUI_TESTS OFF) + set(BUILD_BENCH OFF) + set(BUILD_FUZZ_BINARY ON) + + target_compile_definitions(core_interface INTERFACE + FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION + ) +endif() + +include(ProcessConfigurations) + +include(TryAppendCXXFlags) +include(TryAppendLinkerFlag) + +if(WIN32) + #[=[ + This build system supports two ways to build binaries for Windows. + + 1. Building on Windows using MSVC. + Implementation notes: + - /DWIN32 and /D_WINDOWS definitions are included into the CMAKE_CXX_FLAGS_INIT + and CMAKE_CXX_FLAGS_INIT variables by default. + - A run-time library is selected using the CMAKE_MSVC_RUNTIME_LIBRARY variable. + - MSVC-specific options, for example, /Zc:__cplusplus, are additionally required. + + 2. Cross-compiling using MinGW. + Implementation notes: + - WIN32 and _WINDOWS definitions must be provided explicitly. + - A run-time library must be specified explicitly using _MT definition. + ]=] + + target_compile_definitions(core_interface INTERFACE + _WIN32_WINNT=0x0601 + _WIN32_IE=0x0501 + WIN32_LEAN_AND_MEAN + NOMINMAX + ) + + if(MSVC) + if(VCPKG_TARGET_TRIPLET MATCHES "-static") + set(msvc_library_linkage "") + else() + set(msvc_library_linkage "DLL") + endif() + set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>${msvc_library_linkage}") + unset(msvc_library_linkage) + + target_compile_definitions(core_interface INTERFACE + _UNICODE;UNICODE + ) + target_compile_options(core_interface INTERFACE + /utf-8 + /Zc:preprocessor + /Zc:__cplusplus + /sdl + ) + # Improve parallelism in MSBuild. + # See: https://devblogs.microsoft.com/cppblog/improved-parallelism-in-msbuild/. + list(APPEND CMAKE_VS_GLOBALS "UseMultiToolTask=true") + endif() + + if(MINGW) + target_compile_definitions(core_interface INTERFACE + WIN32 + _WINDOWS + _MT + ) + # Avoid the use of aligned vector instructions when building for Windows. + # See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54412. + try_append_cxx_flags("-Wa,-muse-unaligned-vector-move" TARGET core_interface SKIP_LINK) + try_append_linker_flag("-static" TARGET core_interface) + # We require Windows 7 (NT 6.1) or later. + try_append_linker_flag("-Wl,--major-subsystem-version,6" TARGET core_interface) + try_append_linker_flag("-Wl,--minor-subsystem-version,1" TARGET core_interface) + endif() +endif() + +# Use 64-bit off_t on 32-bit Linux. +if (CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SIZEOF_VOID_P EQUAL 4) + # Ensure 64-bit offsets are used for filesystem accesses for 32-bit compilation. + target_compile_definitions(core_interface INTERFACE + _FILE_OFFSET_BITS=64 + ) +endif() + +if(CMAKE_SYSTEM_NAME STREQUAL "Darwin") + target_compile_definitions(core_interface INTERFACE OBJC_OLD_DISPATCH_PROTOTYPES=0) + # These flags are specific to ld64, and may cause issues with other linkers. + # For example: GNU ld will interpret -dead_strip as -de and then try and use + # "ad_strip" as the symbol for the entry point. + try_append_linker_flag("-Wl,-dead_strip" TARGET core_interface) + try_append_linker_flag("-Wl,-dead_strip_dylibs" TARGET core_interface) + if(CMAKE_HOST_APPLE) + try_append_linker_flag("-Wl,-headerpad_max_install_names" TARGET core_interface) + endif() +endif() + +set(THREADS_PREFER_PTHREAD_FLAG ON) +find_package(Threads REQUIRED) +target_link_libraries(core_interface INTERFACE + Threads::Threads +) + +add_library(sanitize_interface INTERFACE) +target_link_libraries(core_interface INTERFACE sanitize_interface) +if(SANITIZERS) + # First check if the compiler accepts flags. If an incompatible pair like + # -fsanitize=address,thread is used here, this check will fail. This will also + # fail if a bad argument is passed, e.g. -fsanitize=undfeined + try_append_cxx_flags("-fsanitize=${SANITIZERS}" TARGET sanitize_interface + RESULT_VAR cxx_supports_sanitizers + SKIP_LINK + ) + if(NOT cxx_supports_sanitizers) + message(FATAL_ERROR "Compiler did not accept requested flags.") + endif() + + # Some compilers (e.g. GCC) require additional libraries like libasan, + # libtsan, libubsan, etc. Make sure linking still works with the sanitize + # flag. This is a separate check so we can give a better error message when + # the sanitize flags are supported by the compiler but the actual sanitizer + # libs are missing. + try_append_linker_flag("-fsanitize=${SANITIZERS}" VAR SANITIZER_LDFLAGS + SOURCE " + #include + #include + extern \"C\" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { return 0; } + __attribute__((weak)) // allow for libFuzzer linking + int main() { return 0; } + " + RESULT_VAR linker_supports_sanitizers + ) + if(NOT linker_supports_sanitizers) + message(FATAL_ERROR "Linker did not accept requested flags, you are missing required libraries.") + endif() +endif() +target_link_options(sanitize_interface INTERFACE ${SANITIZER_LDFLAGS}) + +if(BUILD_FUZZ_BINARY) + include(CheckSourceCompilesAndLinks) + check_cxx_source_links_with_flags("${SANITIZER_LDFLAGS}" " + #include + #include + extern \"C\" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { return 0; } + // No main() function. + " FUZZ_BINARY_LINKS_WITHOUT_MAIN_FUNCTION + ) +endif() + +include(AddBoostIfNeeded) +add_boost_if_needed() + +if(BUILD_DAEMON OR BUILD_GUI OR BUILD_CLI OR BUILD_TESTS OR BUILD_BENCH OR BUILD_FUZZ_BINARY) + find_package(Libevent 2.1.8 MODULE REQUIRED) +endif() + +include(cmake/introspection.cmake) + +include(cmake/ccache.cmake) + +add_library(warn_interface INTERFACE) +target_link_libraries(core_interface INTERFACE warn_interface) +if(MSVC) + try_append_cxx_flags("/W3" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("/wd4018" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("/wd4244" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("/wd4267" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("/wd4715" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("/wd4805" TARGET warn_interface SKIP_LINK) + target_compile_definitions(warn_interface INTERFACE + _CRT_SECURE_NO_WARNINGS + _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING + ) +else() + try_append_cxx_flags("-Wall" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("-Wextra" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("-Wgnu" TARGET warn_interface SKIP_LINK) + # Some compilers will ignore -Wformat-security without -Wformat, so just combine the two here. + try_append_cxx_flags("-Wformat -Wformat-security" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("-Wvla" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("-Wshadow-field" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("-Wthread-safety" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("-Wloop-analysis" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("-Wredundant-decls" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("-Wunused-member-function" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("-Wdate-time" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("-Wconditional-uninitialized" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("-Wduplicated-branches" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("-Wduplicated-cond" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("-Wlogical-op" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("-Woverloaded-virtual" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("-Wsuggest-override" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("-Wimplicit-fallthrough" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("-Wunreachable-code" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("-Wdocumentation" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("-Wself-assign" TARGET warn_interface SKIP_LINK) + try_append_cxx_flags("-Wundef" TARGET warn_interface SKIP_LINK) + + # Some compilers (gcc) ignore unknown -Wno-* options, but warn about all + # unknown options if any other warning is produced. Test the -Wfoo case, and + # set the -Wno-foo case if it works. + try_append_cxx_flags("-Wunused-parameter" TARGET warn_interface SKIP_LINK + IF_CHECK_PASSED "-Wno-unused-parameter" + ) +endif() + +configure_file(cmake/script/Coverage.cmake Coverage.cmake USE_SOURCE_PERMISSIONS COPYONLY) +configure_file(cmake/script/CoverageFuzz.cmake CoverageFuzz.cmake USE_SOURCE_PERMISSIONS COPYONLY) +configure_file(cmake/script/CoverageInclude.cmake.in CoverageInclude.cmake USE_SOURCE_PERMISSIONS @ONLY) + +# Don't allow extended (non-ASCII) symbols in identifiers. This is easier for code review. +try_append_cxx_flags("-fno-extended-identifiers" TARGET core_interface SKIP_LINK) + +try_append_cxx_flags("-ffile-prefix-map=A=B" TARGET core_interface SKIP_LINK + IF_CHECK_PASSED "-ffile-prefix-map=${PROJECT_SOURCE_DIR}/src=." +) + +# Currently all versions of gcc are subject to a class of bugs, see the +# gccbug_90348 test case (only reproduces on GCC 11 and earlier) and +# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111843. To work around that, set +# -fstack-reuse=none for all gcc builds. (Only gcc understands this flag). +try_append_cxx_flags("-fstack-reuse=none" TARGET core_interface) + +if(ENABLE_HARDENING) + add_library(hardening_interface INTERFACE) + target_link_libraries(core_interface INTERFACE hardening_interface) + if(MSVC) + try_append_linker_flag("/DYNAMICBASE" TARGET hardening_interface) + try_append_linker_flag("/HIGHENTROPYVA" TARGET hardening_interface) + try_append_linker_flag("/NXCOMPAT" TARGET hardening_interface) + else() + + # _FORTIFY_SOURCE requires that there is some level of optimization, + # otherwise it does nothing and just creates a compiler warning. + try_append_cxx_flags("-U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=3" + RESULT_VAR cxx_supports_fortify_source + SOURCE "int main() { + # if !defined __OPTIMIZE__ || __OPTIMIZE__ <= 0 + #error + #endif + }" + ) + if(cxx_supports_fortify_source) + target_compile_options(hardening_interface INTERFACE + -U_FORTIFY_SOURCE + -D_FORTIFY_SOURCE=3 + ) + endif() + unset(cxx_supports_fortify_source) + + try_append_cxx_flags("-Wstack-protector" TARGET hardening_interface SKIP_LINK) + try_append_cxx_flags("-fstack-protector-all" TARGET hardening_interface) + try_append_cxx_flags("-fcf-protection=full" TARGET hardening_interface) + + if(MINGW) + # stack-clash-protection doesn't compile with GCC 10 and earlier. + # In any case, it is a no-op for Windows. + # See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90458 for more details. + else() + try_append_cxx_flags("-fstack-clash-protection" TARGET hardening_interface) + endif() + + if(CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64" OR CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64") + if(CMAKE_SYSTEM_NAME STREQUAL "Darwin") + try_append_cxx_flags("-mbranch-protection=bti" TARGET hardening_interface SKIP_LINK) + else() + try_append_cxx_flags("-mbranch-protection=standard" TARGET hardening_interface SKIP_LINK) + endif() + endif() + + try_append_linker_flag("-Wl,--enable-reloc-section" TARGET hardening_interface) + try_append_linker_flag("-Wl,--dynamicbase" TARGET hardening_interface) + try_append_linker_flag("-Wl,--nxcompat" TARGET hardening_interface) + try_append_linker_flag("-Wl,--high-entropy-va" TARGET hardening_interface) + try_append_linker_flag("-Wl,-z,relro" TARGET hardening_interface) + try_append_linker_flag("-Wl,-z,now" TARGET hardening_interface) + try_append_linker_flag("-Wl,-z,separate-code" TARGET hardening_interface) + if(CMAKE_SYSTEM_NAME STREQUAL "Darwin") + try_append_linker_flag("-Wl,-fixup_chains" TARGET hardening_interface) + endif() + endif() +endif() + +if(REDUCE_EXPORTS) + set(CMAKE_CXX_VISIBILITY_PRESET hidden) + try_append_linker_flag("-Wl,--exclude-libs,ALL" TARGET core_interface) + try_append_linker_flag("-Wl,-no_exported_symbols" VAR CMAKE_EXE_LINKER_FLAGS) +endif() + +if(WERROR) + if(MSVC) + set(werror_flag "/WX") + else() + set(werror_flag "-Werror") + endif() + try_append_cxx_flags(${werror_flag} TARGET core_interface SKIP_LINK RESULT_VAR compiler_supports_werror) + if(NOT compiler_supports_werror) + message(FATAL_ERROR "WERROR set but ${werror_flag} is not usable.") + endif() + unset(werror_flag) +endif() + +find_package(Python3 3.10 COMPONENTS Interpreter) +if(Python3_EXECUTABLE) + set(PYTHON_COMMAND ${Python3_EXECUTABLE}) +else() + list(APPEND configure_warnings + "Minimum required Python not found. Utils and rpcauth tests are disabled." + ) +endif() + +target_compile_definitions(core_interface INTERFACE ${DEPENDS_COMPILE_DEFINITIONS}) +target_compile_definitions(core_interface_relwithdebinfo INTERFACE ${DEPENDS_COMPILE_DEFINITIONS_RELWITHDEBINFO}) +target_compile_definitions(core_interface_debug INTERFACE ${DEPENDS_COMPILE_DEFINITIONS_DEBUG}) + +# If the {CXX,LD}FLAGS environment variables are defined during building depends +# and configuring this build system, their content might be duplicated. +if(DEFINED ENV{CXXFLAGS}) + deduplicate_flags(CMAKE_CXX_FLAGS) +endif() +if(DEFINED ENV{LDFLAGS}) + deduplicate_flags(CMAKE_EXE_LINKER_FLAGS) +endif() + +if(BUILD_TESTS) + enable_testing() +endif() + +if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.29) + # have "make test" depend on "make all" + set(CMAKE_SKIP_TEST_ALL_DEPENDENCY FALSE) +endif() + +# TODO: The `CMAKE_SKIP_BUILD_RPATH` variable setting can be deleted +# in the future after reordering Guix script commands to +# perform binary checks after the installation step. +# Relevant discussions: +# - https://github.com/hebasto/firo/pull/236#issuecomment-2183120953 +# - https://github.com/firo/firo/pull/30312#issuecomment-2191235833 +set(CMAKE_SKIP_BUILD_RPATH TRUE) +set(CMAKE_SKIP_INSTALL_RPATH TRUE) +add_subdirectory(doc) + +include(cmake/crc32c.cmake) +include(cmake/leveldb.cmake) +include(cmake/minisketch.cmake) +add_subdirectory(src) + +include(cmake/tests.cmake) + +include(Maintenance) +setup_split_debug_script() +add_maintenance_targets() +add_windows_deploy_target() +add_macos_deploy_target() + +message("\n") +message("Configure summary") +message("=================") +message("Executables:") +message(" firod ............................ ${BUILD_DAEMON}") +message(" firo-qt (GUI) .................... ${BUILD_GUI}") +message(" firo-cli ......................... ${BUILD_CLI}") +message(" firo-tx .......................... ${BUILD_TX}") +message(" firo-util ........................ ${BUILD_UTIL}") +message(" firo-wallet ...................... ${BUILD_WALLET_TOOL}") +message(" firo-chainstate (experimental) ... ${BUILD_UTIL_CHAINSTATE}") +message(" libfirokernel (experimental) ..... ${BUILD_KERNEL_LIB}") +message("Optional features:") +message(" wallet support ...................... ${ENABLE_WALLET}") +if(ENABLE_WALLET) + message(" - legacy wallets (Berkeley DB) ..... ${WITH_BDB}") +endif() +message(" external signer ..................... ${ENABLE_EXTERNAL_SIGNER}") +message(" ZeroMQ .............................. ${WITH_ZMQ}") +message(" USDT tracing ........................ ${WITH_USDT}") +message(" QR code (GUI) ....................... ${WITH_QRENCODE}") +message(" DBus (GUI, Linux only) .............. ${WITH_DBUS}") +message("Tests:") +message(" test_firo ........................ ${BUILD_TESTS}") +message(" test_firo-qt ..................... ${BUILD_GUI_TESTS}") +message(" bench_firo ....................... ${BUILD_BENCH}") +message(" fuzz binary ......................... ${BUILD_FUZZ_BINARY}") +message("") +if(CMAKE_CROSSCOMPILING) + set(cross_status "TRUE, for ${CMAKE_SYSTEM_NAME}, ${CMAKE_SYSTEM_PROCESSOR}") +else() + set(cross_status "FALSE") +endif() +message("Cross compiling ....................... ${cross_status}") +message("C++ compiler .......................... ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}, ${CMAKE_CXX_COMPILER}") +include(FlagsSummary) +flags_summary() +message("Attempt to harden executables ......... ${ENABLE_HARDENING}") +message("Treat compiler warnings as errors ..... ${WERROR}") +message("Use ccache for compiling .............. ${WITH_CCACHE}") +message("\n") +if(configure_warnings) + message(" ******\n") + foreach(warning IN LISTS configure_warnings) + message(WARNING "${warning}") + endforeach() + message(" ******\n") +endif() + +# We want all build properties to be encapsulated properly. +include(WarnAboutGlobalProperties) From 9120d1c7a7c810d5b6735d44518f021ab1529edf Mon Sep 17 00:00:00 2001 From: AlefLm Date: Sun, 15 Dec 2024 01:48:45 +0000 Subject: [PATCH 05/19] doc: add initial cmake support --- doc/CMakeLists.txt | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 doc/CMakeLists.txt diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt new file mode 100644 index 0000000000..310a90612b --- /dev/null +++ b/doc/CMakeLists.txt @@ -0,0 +1,25 @@ +# Copyright (c) 2024-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +find_package(Doxygen COMPONENTS dot) + +if(DOXYGEN_FOUND) + set(doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile) + configure_file(Doxyfile.in ${doxyfile} USE_SOURCE_PERMISSIONS) + + # In CMake 3.27, The FindDoxygen module's doxygen_add_docs() + # command gained a CONFIG_FILE option to specify a custom doxygen + # configuration file. + # TODO: Consider using it. + add_custom_target(docs + COMMAND Doxygen::doxygen ${doxyfile} + WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} + COMMENT "Generating developer documentation" + VERBATIM USES_TERMINAL + ) +else() + add_custom_target(docs + COMMAND ${CMAKE_COMMAND} -E echo "Error: Doxygen not found" + ) +endif() From eb05d6937f46cd69aaa8b3e2bd7eab4e11a34003 Mon Sep 17 00:00:00 2001 From: AlefLm Date: Sun, 15 Dec 2024 01:57:04 +0000 Subject: [PATCH 06/19] univalue: add initial cmake support --- src/univalue/CMakeLists.txt | 41 +++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 src/univalue/CMakeLists.txt diff --git a/src/univalue/CMakeLists.txt b/src/univalue/CMakeLists.txt new file mode 100644 index 0000000000..96733fe077 --- /dev/null +++ b/src/univalue/CMakeLists.txt @@ -0,0 +1,41 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +add_library(univalue STATIC EXCLUDE_FROM_ALL + lib/univalue.cpp + lib/univalue_get.cpp + lib/univalue_read.cpp + lib/univalue_write.cpp +) +target_include_directories(univalue + PUBLIC + $ +) +target_link_libraries(univalue PRIVATE core_interface) + +if(BUILD_TESTS) + add_executable(unitester test/unitester.cpp) + target_compile_definitions(unitester + PRIVATE + JSON_TEST_SRC=\"${CMAKE_CURRENT_SOURCE_DIR}/test\" + ) + target_link_libraries(unitester + PRIVATE + core_interface + univalue + ) + add_test(NAME univalue_test + COMMAND unitester + ) + + add_executable(object test/object.cpp) + target_link_libraries(object + PRIVATE + core_interface + univalue + ) + add_test(NAME univalue_object_test + COMMAND object + ) +endif() From 7e3f9b922f212d362ad368c8c9c9f2842ed56b34 Mon Sep 17 00:00:00 2001 From: AlefLm Date: Sun, 15 Dec 2024 02:02:16 +0000 Subject: [PATCH 07/19] zmq: add initial cmake support --- src/zmq/CMakeLists.txt | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 src/zmq/CMakeLists.txt diff --git a/src/zmq/CMakeLists.txt b/src/zmq/CMakeLists.txt new file mode 100644 index 0000000000..1afbdd1701 --- /dev/null +++ b/src/zmq/CMakeLists.txt @@ -0,0 +1,19 @@ +# Copyright (c) 2023-present The firo Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +add_library(firo_zmq STATIC EXCLUDE_FROM_ALL + zmqabstractnotifier.cpp + zmqnotificationinterface.cpp + zmqpublishnotifier.cpp +) +target_compile_definitions(firo_zmq + INTERFACE + ENABLE_ZMQ=1 +) +target_link_libraries(firo_zmq + PRIVATE + core_interface + univalue + zeromq +) From 0e1059f7d4c0f30dd88f6997bb2cf6d816a09cfe Mon Sep 17 00:00:00 2001 From: AlefLm Date: Sat, 21 Dec 2024 02:40:18 +0000 Subject: [PATCH 08/19] crypto: add initial cmake support --- src/crypto/CMakeLists.txt | 63 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 src/crypto/CMakeLists.txt diff --git a/src/crypto/CMakeLists.txt b/src/crypto/CMakeLists.txt new file mode 100644 index 0000000000..14f37fec7a --- /dev/null +++ b/src/crypto/CMakeLists.txt @@ -0,0 +1,63 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +add_library(bitcoin_crypto STATIC EXCLUDE_FROM_ALL + aes.cpp + chacha20.cpp + chacha20poly1305.cpp + hmac_sha256.cpp + hmac_sha512.cpp + progpow.cpp + ripemd160.cpp + sha1.cpp + sha256.cpp + sha256_sse4.cpp + sha512.cpp + ../support/cleanse.cpp +) + +target_link_libraries(bitcoin_crypto + PRIVATE + core_interface +) + +if(HAVE_SSE41) + add_library(bitcoin_crypto_sse41 STATIC EXCLUDE_FROM_ALL + sha256_sse41.cpp + ) + target_compile_definitions(bitcoin_crypto_sse41 PUBLIC ENABLE_SSE41) + target_compile_options(bitcoin_crypto_sse41 PRIVATE ${SSE41_CXXFLAGS}) + target_link_libraries(bitcoin_crypto_sse41 PRIVATE core_interface) + target_link_libraries(bitcoin_crypto PRIVATE bitcoin_crypto_sse41) +endif() + +if(HAVE_AVX2) + add_library(bitcoin_crypto_avx2 STATIC EXCLUDE_FROM_ALL + sha256_avx2.cpp + ) + target_compile_definitions(bitcoin_crypto_avx2 PUBLIC ENABLE_AVX2) + target_compile_options(bitcoin_crypto_avx2 PRIVATE ${AVX2_CXXFLAGS}) + target_link_libraries(bitcoin_crypto_avx2 PRIVATE core_interface) + target_link_libraries(bitcoin_crypto PRIVATE bitcoin_crypto_avx2) +endif() + +if(HAVE_SSE41 AND HAVE_X86_SHANI) + add_library(bitcoin_crypto_x86_shani STATIC EXCLUDE_FROM_ALL + sha256_x86_shani.cpp + ) + target_compile_definitions(bitcoin_crypto_x86_shani PUBLIC ENABLE_SSE41 ENABLE_X86_SHANI) + target_compile_options(bitcoin_crypto_x86_shani PRIVATE ${X86_SHANI_CXXFLAGS}) + target_link_libraries(bitcoin_crypto_x86_shani PRIVATE core_interface) + target_link_libraries(bitcoin_crypto PRIVATE bitcoin_crypto_x86_shani) +endif() + +if(HAVE_ARM_SHANI) + add_library(bitcoin_crypto_arm_shani STATIC EXCLUDE_FROM_ALL + sha256_arm_shani.cpp + ) + target_compile_definitions(bitcoin_crypto_arm_shani PUBLIC ENABLE_ARM_SHANI) + target_compile_options(bitcoin_crypto_arm_shani PRIVATE ${ARM_SHANI_CXXFLAGS}) + target_link_libraries(bitcoin_crypto_arm_shani PRIVATE core_interface) + target_link_libraries(bitcoin_crypto PRIVATE bitcoin_crypto_arm_shani) +endif() \ No newline at end of file From ce888ef5df021371a485c4506cafc4ce8a9a132b Mon Sep 17 00:00:00 2001 From: AlefLm Date: Sun, 22 Dec 2024 06:12:07 +0000 Subject: [PATCH 09/19] wallet: add initial cmake support --- src/wallet/CMakeLists.txt | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 src/wallet/CMakeLists.txt diff --git a/src/wallet/CMakeLists.txt b/src/wallet/CMakeLists.txt new file mode 100644 index 0000000000..495f85530a --- /dev/null +++ b/src/wallet/CMakeLists.txt @@ -0,0 +1,33 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +# Wallet functionality used by bitcoind and bitcoin-wallet executables. +add_library(bitcoin_wallet STATIC EXCLUDE_FROM_ALL + authhelper.cpp + bip39.cpp + crypter.cpp + db.cpp + lelantusjoinsplitbuilder.cpp + mnemoniccontainer.cpp + rpcdump.cpp + rpcwallet.cpp + sigmaspendbuilder.cpp + txbuilder.cpp + wallet.cpp + walletdb.cpp + walletexcept.cpp +) + +target_link_libraries(bitcoin_wallet + PRIVATE + core_interface + bitcoin_common + univalue + Boost::headers + $ +) + +# Firo only supports BDB for wallet storage. +target_sources(bitcoin_wallet PRIVATE bdb.cpp salvage.cpp) +target_link_libraries(bitcoin_wallet PUBLIC BerkeleyDB::BerkeleyDB) \ No newline at end of file From 1fa52a2f31c01269cafbc4179ca3fb7b0ec8e322 Mon Sep 17 00:00:00 2001 From: AlefLm Date: Mon, 23 Dec 2024 07:46:59 +0000 Subject: [PATCH 10/19] src: initial add of src/CMakeLists.txt --- CMakeLists.txt | 1 - cmake/minisketch.cmake | 91 ------ cmake/script/CoverageInclude.cmake.in | 1 - src/CMakeLists.txt | 389 ++++++++++++++++++++++++++ src/bench/CMakeLists.txt | 1 - src/crypto/CMakeLists.txt | 42 --- src/univalue/CMakeLists.txt | 1 - src/wallet/CMakeLists.txt | 1 - 8 files changed, 389 insertions(+), 138 deletions(-) delete mode 100644 cmake/minisketch.cmake create mode 100644 src/CMakeLists.txt diff --git a/CMakeLists.txt b/CMakeLists.txt index 897791e93d..56beff3d29 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -549,7 +549,6 @@ add_subdirectory(doc) include(cmake/crc32c.cmake) include(cmake/leveldb.cmake) -include(cmake/minisketch.cmake) add_subdirectory(src) include(cmake/tests.cmake) diff --git a/cmake/minisketch.cmake b/cmake/minisketch.cmake deleted file mode 100644 index bb93c80467..0000000000 --- a/cmake/minisketch.cmake +++ /dev/null @@ -1,91 +0,0 @@ -# Copyright (c) 2023-present The Bitcoin Core developers -# Distributed under the MIT software license, see the accompanying -# file COPYING or https://opensource.org/license/mit/. - -# Check for clmul instructions support. -if(MSVC) - set(CLMUL_CXXFLAGS) -else() - set(CLMUL_CXXFLAGS -mpclmul) -endif() -check_cxx_source_compiles_with_flags("${CLMUL_CXXFLAGS}" " - #include - #include - - int main() - { - __m128i a = _mm_cvtsi64_si128((uint64_t)7); - __m128i b = _mm_clmulepi64_si128(a, a, 37); - __m128i c = _mm_srli_epi64(b, 41); - __m128i d = _mm_xor_si128(b, c); - uint64_t e = _mm_cvtsi128_si64(d); - return e == 0; - } - " HAVE_CLMUL -) - -add_library(minisketch_common INTERFACE) -target_compile_definitions(minisketch_common INTERFACE - DISABLE_DEFAULT_FIELDS - ENABLE_FIELD_32 -) -if(MSVC) - target_compile_options(minisketch_common INTERFACE - /wd4060 - /wd4065 - /wd4146 - /wd4244 - /wd4267 - ) -endif() - -if(HAVE_CLMUL) - add_library(minisketch_clmul OBJECT EXCLUDE_FROM_ALL - ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/clmul_1byte.cpp - ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/clmul_2bytes.cpp - ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/clmul_3bytes.cpp - ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/clmul_4bytes.cpp - ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/clmul_5bytes.cpp - ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/clmul_6bytes.cpp - ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/clmul_7bytes.cpp - ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/clmul_8bytes.cpp - ) - target_compile_definitions(minisketch_clmul PUBLIC HAVE_CLMUL) - target_compile_options(minisketch_clmul PRIVATE ${CLMUL_CXXFLAGS}) - target_link_libraries(minisketch_clmul - PRIVATE - core_interface - minisketch_common - ) - set_target_properties(minisketch_clmul PROPERTIES - EXPORT_COMPILE_COMMANDS OFF - ) -endif() - -add_library(minisketch STATIC EXCLUDE_FROM_ALL - ${PROJECT_SOURCE_DIR}/src/minisketch/src/minisketch.cpp - ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/generic_1byte.cpp - ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/generic_2bytes.cpp - ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/generic_3bytes.cpp - ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/generic_4bytes.cpp - ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/generic_5bytes.cpp - ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/generic_6bytes.cpp - ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/generic_7bytes.cpp - ${PROJECT_SOURCE_DIR}/src/minisketch/src/fields/generic_8bytes.cpp -) - -target_include_directories(minisketch - PUBLIC - $ -) - -target_link_libraries(minisketch - PRIVATE - core_interface - minisketch_common - $ -) - -set_target_properties(minisketch PROPERTIES - EXPORT_COMPILE_COMMANDS OFF -) diff --git a/cmake/script/CoverageInclude.cmake.in b/cmake/script/CoverageInclude.cmake.in index 59bf5e3af2..928c19953d 100644 --- a/cmake/script/CoverageInclude.cmake.in +++ b/cmake/script/CoverageInclude.cmake.in @@ -38,7 +38,6 @@ list(APPEND LCOV_FILTER_COMMAND -p "src/leveldb/") list(APPEND LCOV_FILTER_COMMAND -p "src/crc32c/") list(APPEND LCOV_FILTER_COMMAND -p "src/bench/") list(APPEND LCOV_FILTER_COMMAND -p "src/crypto/ctaes") -list(APPEND LCOV_FILTER_COMMAND -p "src/minisketch") list(APPEND LCOV_FILTER_COMMAND -p "src/secp256k1") list(APPEND LCOV_FILTER_COMMAND -p "depends") diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt new file mode 100644 index 0000000000..0afb88110d --- /dev/null +++ b/src/CMakeLists.txt @@ -0,0 +1,389 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +include(GNUInstallDirs) +include(AddWindowsResources) + +configure_file(${PROJECT_SOURCE_DIR}/cmake/bitcoin-build-config.h.in bitcoin-build-config.h USE_SOURCE_PERMISSIONS @ONLY) +include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) + +add_custom_target(generate_build_info + BYPRODUCTS ${PROJECT_BINARY_DIR}/src/bitcoin-build-info.h + COMMAND ${CMAKE_COMMAND} -DBUILD_INFO_HEADER_PATH=${PROJECT_BINARY_DIR}/src/bitcoin-build-info.h -DSOURCE_DIR=${PROJECT_SOURCE_DIR} -P ${PROJECT_SOURCE_DIR}/cmake/script/GenerateBuildInfo.cmake + COMMENT "Generating bitcoin-build-info.h" + VERBATIM +) +add_library(bitcoin_clientversion OBJECT EXCLUDE_FROM_ALL + clientversion.cpp +) +target_link_libraries(bitcoin_clientversion + PRIVATE + core_interface +) +add_dependencies(bitcoin_clientversion generate_build_info) + +#============================= +# util library +# Firo does not have util subdirectory +#============================= + +add_library(bitcoin_util STATIC EXCLUDE_FROM_ALL + fs.cpp + utilmoneystr.cpp + policy/rbf.cpp + utilstrencodings.cpp + mbstring.cpp + threadinterrupt.cpp + utiltime.cpp + random.cpp + sync.cpp + support/lockedpool.cpp +) + +target_link_libraries(bitcoin_util + PRIVATE + core_interface + bitcoin_clientversion + bitcoin_crypto + $<$:ws2_32> + $<$:iphlpapi> +) + +add_subdirectory(crypto) +add_subdirectory(univalue) +if(WITH_MULTIPROCESS) + add_subdirectory(ipc) +endif() + +#============================= +# secp256k1 subtree +#============================= +message("") +message("Configuring secp256k1 subtree...") +set(SECP256K1_DISABLE_SHARED ON CACHE BOOL "" FORCE) +set(SECP256K1_ENABLE_MODULE_ECDH OFF CACHE BOOL "" FORCE) +set(SECP256K1_ENABLE_MODULE_RECOVERY ON CACHE BOOL "" FORCE) +set(SECP256K1_ENABLE_MODULE_MUSIG OFF CACHE BOOL "" FORCE) +set(SECP256K1_BUILD_BENCHMARK OFF CACHE BOOL "" FORCE) +set(SECP256K1_BUILD_TESTS ${BUILD_TESTS} CACHE BOOL "" FORCE) +set(SECP256K1_BUILD_EXHAUSTIVE_TESTS ${BUILD_TESTS} CACHE BOOL "" FORCE) +if(NOT BUILD_TESTS) + # Always skip the ctime tests, if we are building no other tests. + # Otherwise, they are built if Valgrind is available. See SECP256K1_VALGRIND. + set(SECP256K1_BUILD_CTIME_TESTS ${BUILD_TESTS} CACHE BOOL "" FORCE) +endif() +set(SECP256K1_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE) +include(GetTargetInterface) +# -fsanitize and related flags apply to both C++ and C, +# so we can pass them down to libsecp256k1 as CFLAGS and LDFLAGS. +get_target_interface(core_sanitizer_cxx_flags "" sanitize_interface COMPILE_OPTIONS) +set(SECP256K1_APPEND_CFLAGS ${core_sanitizer_cxx_flags} CACHE STRING "" FORCE) +unset(core_sanitizer_cxx_flags) +get_target_interface(core_sanitizer_linker_flags "" sanitize_interface LINK_OPTIONS) +set(SECP256K1_APPEND_LDFLAGS ${core_sanitizer_linker_flags} CACHE STRING "" FORCE) +unset(core_sanitizer_linker_flags) +# We want to build libsecp256k1 with the most tested RelWithDebInfo configuration. +enable_language(C) +foreach(config IN LISTS CMAKE_BUILD_TYPE CMAKE_CONFIGURATION_TYPES) + if(config STREQUAL "") + continue() + endif() + string(TOUPPER "${config}" config) + set(CMAKE_C_FLAGS_${config} "${CMAKE_C_FLAGS_RELWITHDEBINFO}") +endforeach() +# If the CFLAGS environment variable is defined during building depends +# and configuring this build system, its content might be duplicated. +if(DEFINED ENV{CFLAGS}) + deduplicate_flags(CMAKE_C_FLAGS) +endif() +set(CMAKE_EXPORT_COMPILE_COMMANDS OFF) +add_subdirectory(secp256k1) +set_target_properties(secp256k1 PROPERTIES + EXCLUDE_FROM_ALL TRUE +) +set(CMAKE_EXPORT_COMPILE_COMMANDS ON) +string(APPEND CMAKE_C_COMPILE_OBJECT " ${APPEND_CPPFLAGS} ${APPEND_CFLAGS}") + +add_library(bitcoin_consensus STATIC EXCLUDE_FROM_ALL + arith_uint256.cpp + consensus/merkle.cpp + hash.cpp + primitives/block.cpp + primitives/transaction.cpp + pubkey.cpp + script/interpreter.cpp + script/script.cpp + script/script_error.cpp + uint256.cpp +) +target_link_libraries(bitcoin_consensus + PRIVATE + core_interface + bitcoin_crypto + secp256k1 +) + +if(WITH_ZMQ) + add_subdirectory(zmq) +endif() + +# Home for common functionality shared by different executables and libraries. +# Similar to `bitcoin_util` library, but higher-level. +add_library(bitcoin_common STATIC EXCLUDE_FROM_ALL + base58.cpp + libspark/bech32.cpp + chainparams.cpp + chainparamsbase.cpp + coins.cpp + bloom.cpp + init.cpp + compressor.cpp + core_read.cpp + core_write.cpp + chainparams.cpp + key.cpp + merkleblock.cpp + netaddress.cpp + netbase.cpp + policy/policy.cpp + protocol.cpp + rpc/rawtransaction.cpp + scheduler.cpp + script/sign.cpp +) +target_link_libraries(bitcoin_common + PRIVATE + core_interface + bitcoin_consensus + bitcoin_util + univalue + secp256k1 + Boost::headers + $ + $<$:ws2_32> +) + + +set(installable_targets) +if(ENABLE_WALLET) + add_subdirectory(wallet) + + if(BUILD_WALLET_TOOL) + add_executable(bitcoin-wallet + bitcoin-wallet.cpp + init/bitcoin-wallet.cpp + wallet/wallettool.cpp + ) + add_windows_resources(bitcoin-wallet bitcoin-wallet-res.rc) + target_link_libraries(bitcoin-wallet + core_interface + bitcoin_wallet + bitcoin_common + bitcoin_util + Boost::headers + ) + list(APPEND installable_targets bitcoin-wallet) + endif() +endif() + + +# P2P and RPC server functionality used by `bitcoind` and `bitcoin-qt` executables. +add_library(bitcoin_node STATIC EXCLUDE_FROM_ALL + addrdb.cpp + addrman.cpp + blockencodings.cpp + chain.cpp + consensus/tx_verify.cpp + dbwrapper.cpp + httprpc.cpp + httpserver.cpp + init.cpp + chain.cpp + net.cpp + net_processing.cpp + miner.cpp + warnings.cpp + noui.cpp + policy/fees.cpp + policy/rbf.cpp + pow.cpp + rest.cpp + rpc/blockchain.cpp + rpc/mining.cpp + rpc/net.cpp + rpc/server.cpp + script/sigcache.cpp + torcontrol.cpp + txdb.cpp + txmempool.cpp + validation.cpp + validationinterface.cpp + versionbits.cpp +) +target_link_libraries(bitcoin_node + PRIVATE + core_interface + bitcoin_common + bitcoin_util + $ + leveldb + univalue + Boost::headers + $ + $ + $ + $ +) + + +# Bitcoin Core bitcoind. +if(BUILD_DAEMON) + add_executable(bitcoind + bitcoind.cpp + ) + add_windows_resources(bitcoind bitcoind-res.rc) + target_link_libraries(bitcoind + core_interface + bitcoin_node + $ + ) + list(APPEND installable_targets bitcoind) +endif() +if(WITH_MULTIPROCESS) + add_executable(bitcoin-node + bitcoind.cpp + init/bitcoin-node.cpp + ) + target_link_libraries(bitcoin-node + core_interface + bitcoin_node + bitcoin_ipc + $ + ) + list(APPEND installable_targets bitcoin-node) + + if(BUILD_TESTS) + # bitcoin_ipc_test library target is defined here in src/CMakeLists.txt + # instead of src/test/CMakeLists.txt so capnp files in src/test/ are able to + # reference capnp files in src/ipc/capnp/ by relative path. The Cap'n Proto + # compiler only allows importing by relative path when the importing and + # imported files are underneath the same compilation source prefix, so the + # source prefix must be src/, not src/test/ + add_library(bitcoin_ipc_test STATIC EXCLUDE_FROM_ALL + test/ipc_test.cpp + ) + target_capnp_sources(bitcoin_ipc_test ${PROJECT_SOURCE_DIR} + test/ipc_test.capnp + ) + add_dependencies(bitcoin_ipc_test bitcoin_ipc_headers) + endif() +endif() + + +add_library(bitcoin_cli STATIC EXCLUDE_FROM_ALL + rpc/client.cpp +) +target_link_libraries(bitcoin_cli + PUBLIC + core_interface + univalue +) + + +# Bitcoin Core RPC client +if(BUILD_CLI) + add_executable(bitcoin-cli bitcoin-cli.cpp) + add_windows_resources(bitcoin-cli bitcoin-cli-res.rc) + target_link_libraries(bitcoin-cli + core_interface + bitcoin_cli + bitcoin_common + bitcoin_util + libevent::core + libevent::extra + ) + list(APPEND installable_targets bitcoin-cli) +endif() + + +if(BUILD_TX) + add_executable(bitcoin-tx bitcoin-tx.cpp) + add_windows_resources(bitcoin-tx bitcoin-tx-res.rc) + target_link_libraries(bitcoin-tx + core_interface + bitcoin_common + bitcoin_util + univalue + ) + list(APPEND installable_targets bitcoin-tx) +endif() + + +if(BUILD_UTIL) + add_executable(bitcoin-util bitcoin-util.cpp) + add_windows_resources(bitcoin-util bitcoin-util-res.rc) + target_link_libraries(bitcoin-util + core_interface + bitcoin_common + bitcoin_util + ) + list(APPEND installable_targets bitcoin-util) +endif() + + +if(BUILD_GUI) + add_subdirectory(qt) +endif() + + +if(BUILD_KERNEL_LIB) + add_subdirectory(kernel) +endif() + +if(BUILD_UTIL_CHAINSTATE) + add_executable(bitcoin-chainstate + bitcoin-chainstate.cpp + ) + # TODO: The `SKIP_BUILD_RPATH` property setting can be deleted + # in the future after reordering Guix script commands to + # perform binary checks after the installation step. + # Relevant discussions: + # - https://github.com/hebasto/bitcoin/pull/236#issuecomment-2183120953 + # - https://github.com/bitcoin/bitcoin/pull/30312#issuecomment-2191235833 + set_target_properties(bitcoin-chainstate PROPERTIES + SKIP_BUILD_RPATH OFF + ) + target_link_libraries(bitcoin-chainstate + PRIVATE + core_interface + bitcoinkernel + ) +endif() + + +if(BUILD_BENCH) + add_subdirectory(bench) +endif() + +if(BUILD_TESTS) + add_subdirectory(test) +endif() + +if(BUILD_FUZZ_BINARY) + add_subdirectory(test/fuzz) +endif() + + +install(TARGETS ${installable_targets} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} +) +unset(installable_targets) + +if(INSTALL_MAN) + # TODO: these stubs are no longer needed. man pages should be generated at install time. + install(DIRECTORY ../doc/man/ + DESTINATION ${CMAKE_INSTALL_MANDIR}/man1 + FILES_MATCHING PATTERN *.1 + ) +endif() \ No newline at end of file diff --git a/src/bench/CMakeLists.txt b/src/bench/CMakeLists.txt index 8b058dd8ad..63fa9fd313 100644 --- a/src/bench/CMakeLists.txt +++ b/src/bench/CMakeLists.txt @@ -25,7 +25,6 @@ add_executable(bench_firo target_link_libraries(bench_firo core_interface - test_util firo_node Boost::headers ) diff --git a/src/crypto/CMakeLists.txt b/src/crypto/CMakeLists.txt index 14f37fec7a..28c7ca6ae8 100644 --- a/src/crypto/CMakeLists.txt +++ b/src/crypto/CMakeLists.txt @@ -5,14 +5,12 @@ add_library(bitcoin_crypto STATIC EXCLUDE_FROM_ALL aes.cpp chacha20.cpp - chacha20poly1305.cpp hmac_sha256.cpp hmac_sha512.cpp progpow.cpp ripemd160.cpp sha1.cpp sha256.cpp - sha256_sse4.cpp sha512.cpp ../support/cleanse.cpp ) @@ -21,43 +19,3 @@ target_link_libraries(bitcoin_crypto PRIVATE core_interface ) - -if(HAVE_SSE41) - add_library(bitcoin_crypto_sse41 STATIC EXCLUDE_FROM_ALL - sha256_sse41.cpp - ) - target_compile_definitions(bitcoin_crypto_sse41 PUBLIC ENABLE_SSE41) - target_compile_options(bitcoin_crypto_sse41 PRIVATE ${SSE41_CXXFLAGS}) - target_link_libraries(bitcoin_crypto_sse41 PRIVATE core_interface) - target_link_libraries(bitcoin_crypto PRIVATE bitcoin_crypto_sse41) -endif() - -if(HAVE_AVX2) - add_library(bitcoin_crypto_avx2 STATIC EXCLUDE_FROM_ALL - sha256_avx2.cpp - ) - target_compile_definitions(bitcoin_crypto_avx2 PUBLIC ENABLE_AVX2) - target_compile_options(bitcoin_crypto_avx2 PRIVATE ${AVX2_CXXFLAGS}) - target_link_libraries(bitcoin_crypto_avx2 PRIVATE core_interface) - target_link_libraries(bitcoin_crypto PRIVATE bitcoin_crypto_avx2) -endif() - -if(HAVE_SSE41 AND HAVE_X86_SHANI) - add_library(bitcoin_crypto_x86_shani STATIC EXCLUDE_FROM_ALL - sha256_x86_shani.cpp - ) - target_compile_definitions(bitcoin_crypto_x86_shani PUBLIC ENABLE_SSE41 ENABLE_X86_SHANI) - target_compile_options(bitcoin_crypto_x86_shani PRIVATE ${X86_SHANI_CXXFLAGS}) - target_link_libraries(bitcoin_crypto_x86_shani PRIVATE core_interface) - target_link_libraries(bitcoin_crypto PRIVATE bitcoin_crypto_x86_shani) -endif() - -if(HAVE_ARM_SHANI) - add_library(bitcoin_crypto_arm_shani STATIC EXCLUDE_FROM_ALL - sha256_arm_shani.cpp - ) - target_compile_definitions(bitcoin_crypto_arm_shani PUBLIC ENABLE_ARM_SHANI) - target_compile_options(bitcoin_crypto_arm_shani PRIVATE ${ARM_SHANI_CXXFLAGS}) - target_link_libraries(bitcoin_crypto_arm_shani PRIVATE core_interface) - target_link_libraries(bitcoin_crypto PRIVATE bitcoin_crypto_arm_shani) -endif() \ No newline at end of file diff --git a/src/univalue/CMakeLists.txt b/src/univalue/CMakeLists.txt index 96733fe077..ab460286f5 100644 --- a/src/univalue/CMakeLists.txt +++ b/src/univalue/CMakeLists.txt @@ -4,7 +4,6 @@ add_library(univalue STATIC EXCLUDE_FROM_ALL lib/univalue.cpp - lib/univalue_get.cpp lib/univalue_read.cpp lib/univalue_write.cpp ) diff --git a/src/wallet/CMakeLists.txt b/src/wallet/CMakeLists.txt index 495f85530a..6895ace860 100644 --- a/src/wallet/CMakeLists.txt +++ b/src/wallet/CMakeLists.txt @@ -29,5 +29,4 @@ target_link_libraries(bitcoin_wallet ) # Firo only supports BDB for wallet storage. -target_sources(bitcoin_wallet PRIVATE bdb.cpp salvage.cpp) target_link_libraries(bitcoin_wallet PUBLIC BerkeleyDB::BerkeleyDB) \ No newline at end of file From 7a07d23831ed1b7c66687bdfcd1b8be47dd02033 Mon Sep 17 00:00:00 2001 From: AlefLm Date: Fri, 3 Jan 2025 01:51:53 +0000 Subject: [PATCH 11/19] toolchain.cmake.in: Adding toolchain.cmake.in support --- depends/Makefile | 50 +++++++++++- depends/toolchain.cmake.in | 154 +++++++++++++++++++++++++++++++++++++ 2 files changed, 202 insertions(+), 2 deletions(-) create mode 100644 depends/toolchain.cmake.in diff --git a/depends/Makefile b/depends/Makefile index c892ee25ac..74ffec8121 100644 --- a/depends/Makefile +++ b/depends/Makefile @@ -180,7 +180,7 @@ $(host_arch)_$(host_os)_native_toolchain?=$($(host_os)_native_toolchain) include funcs.mk -final_build_id_long+=$(shell $(build_SHA256SUM) config.site.in) +final_build_id_long+=$(shell $(build_SHA256SUM) config.site.in toolchain.cmake.in) final_build_id+=$(shell echo -n "$(final_build_id_long)" | $(build_SHA256SUM) | cut -c-$(HASH_LENGTH)) $(host_prefix)/.stamp_$(final_build_id): $(native_packages) $(packages) $(AT)rm -rf $(@D) @@ -188,6 +188,7 @@ $(host_prefix)/.stamp_$(final_build_id): $(native_packages) $(packages) $(AT)echo copying packages: $^ $(AT)echo to: $(@D) $(AT)cd $(@D); $(foreach package,$^, tar xf $($(package)_cached); ) + $(AT)echo To build Firo with these packages, pass \'--toolchain $(@D)/toolchain.cmake\' to the first CMake invocation. $(AT)touch $@ # $PATH is not preserved between ./configure and make by convention. Its @@ -243,6 +244,50 @@ $(host_prefix)/share/config.site : config.site.in $(host_prefix)/.stamp_$(final_ $< > $@ $(AT)touch $@ +ifeq ($(host),$(build)) + crosscompiling=FALSE +else + crosscompiling=TRUE +endif + +$(host_prefix)/toolchain.cmake : toolchain.cmake.in $(host_prefix)/.stamp_$(final_build_id) + @mkdir -p $(@D) + sed -e 's|@depends_crosscompiling@|$(crosscompiling)|' \ + -e 's|@host_system_name@|$($(host_os)_cmake_system_name)|' \ + -e 's|@host_system_version@|$($(host_os)_cmake_system_version)|' \ + -e 's|@host_arch@|$(host_arch)|' \ + -e 's|@CC@|$(host_CC)|' \ + -e 's|@CXX@|$(host_CXX)|' \ + -e 's|@OSX_SDK@|$(OSX_SDK)|' \ + -e 's|@AR@|$(host_AR)|' \ + -e 's|@RANLIB@|$(host_RANLIB)|' \ + -e 's|@STRIP@|$(host_STRIP)|' \ + -e 's|@OBJCOPY@|$(host_OBJCOPY)|' \ + -e 's|@OBJDUMP@|$(host_OBJDUMP)|' \ + -e 's|@depends_prefix@|$(host_prefix)|' \ + -e 's|@CFLAGS@|$(strip $(host_CFLAGS))|' \ + -e 's|@CFLAGS_RELEASE@|$(strip $(host_release_CFLAGS))|' \ + -e 's|@CFLAGS_DEBUG@|$(strip $(host_debug_CFLAGS))|' \ + -e 's|@CXXFLAGS@|$(strip $(host_CXXFLAGS))|' \ + -e 's|@CXXFLAGS_RELEASE@|$(strip $(host_release_CXXFLAGS))|' \ + -e 's|@CXXFLAGS_DEBUG@|$(strip $(host_debug_CXXFLAGS))|' \ + -e 's|@CPPFLAGS@|$(strip $(host_CPPFLAGS))|' \ + -e 's|@CPPFLAGS_RELEASE@|$(strip $(host_release_CPPFLAGS))|' \ + -e 's|@CPPFLAGS_DEBUG@|$(strip $(host_debug_CPPFLAGS))|' \ + -e 's|@LDFLAGS@|$(strip $(host_LDFLAGS))|' \ + -e 's|@LDFLAGS_RELEASE@|$(strip $(host_release_LDFLAGS))|' \ + -e 's|@LDFLAGS_DEBUG@|$(strip $(host_debug_LDFLAGS))|' \ + -e 's|@qt_packages@|$(qt_packages_)|' \ + -e 's|@qrencode_packages@|$(qrencode_packages_)|' \ + -e 's|@zmq_packages@|$(zmq_packages_)|' \ + -e 's|@wallet_packages@|$(wallet_packages_)|' \ + -e 's|@bdb_packages@|$(bdb_packages_)|' \ + -e 's|@sqlite_packages@|$(sqlite_packages_)|' \ + -e 's|@usdt_packages@|$(usdt_packages_)|' \ + -e 's|@no_harden@|$(NO_HARDEN)|' \ + -e 's|@multiprocess@|$(MULTIPROCESS)|' \ + $< > $@ + touch $@ define check_or_remove_cached mkdir -p $(BASE_CACHE)/$(host)/$(package) && cd $(BASE_CACHE)/$(host)/$(package); \ @@ -266,6 +311,7 @@ check-sources: $(host_prefix)/share/config.site: check-packages check-packages: check-sources +$(host_prefix)/toolchain.cmake: check-packages clean-all: clean @rm -rf $(SOURCES_PATH) x86_64* i686* mips* arm* aarch64* powerpc* riscv32* riscv64* s390x* @@ -273,7 +319,7 @@ clean-all: clean clean: @rm -rf $(WORK_PATH) $(BASE_CACHE) $(BUILD) -install: check-packages $(host_prefix)/share/config.site +install: check-packages $(host_prefix)/share/config.site $(host_prefix)/toolchain.cmake download-one: check-sources $(all_sources) diff --git a/depends/toolchain.cmake.in b/depends/toolchain.cmake.in new file mode 100644 index 0000000000..028d81f2d3 --- /dev/null +++ b/depends/toolchain.cmake.in @@ -0,0 +1,154 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +# This file is expected to be highly volatile and may still change substantially. + +# If CMAKE_SYSTEM_NAME is set within a toolchain file, CMake will also +# set CMAKE_CROSSCOMPILING to TRUE, even if CMAKE_SYSTEM_NAME matches +# CMAKE_HOST_SYSTEM_NAME. To avoid potential misconfiguration of CMake, +# it is best not to touch CMAKE_SYSTEM_NAME unless cross-compiling is +# intended. +if(@depends_crosscompiling@) + set(CMAKE_SYSTEM_NAME @host_system_name@) + set(CMAKE_SYSTEM_VERSION @host_system_version@) + set(CMAKE_SYSTEM_PROCESSOR @host_arch@) +endif() + +if(NOT DEFINED CMAKE_C_FLAGS_INIT) + set(CMAKE_C_FLAGS_INIT "@CFLAGS@") +endif() +if(NOT DEFINED CMAKE_C_FLAGS_RELWITHDEBINFO_INIT) + set(CMAKE_C_FLAGS_RELWITHDEBINFO_INIT "@CFLAGS_RELEASE@") +endif() +if(NOT DEFINED CMAKE_C_FLAGS_DEBUG_INIT) + set(CMAKE_C_FLAGS_DEBUG_INIT "@CFLAGS_DEBUG@") +endif() + +if(NOT DEFINED CMAKE_C_COMPILER) + set(CMAKE_C_COMPILER @CC@) +endif() + +if(NOT DEFINED CMAKE_CXX_FLAGS_INIT) + set(CMAKE_CXX_FLAGS_INIT "@CXXFLAGS@") + set(CMAKE_OBJCXX_FLAGS_INIT "@CXXFLAGS@") +endif() +if(NOT DEFINED CMAKE_CXX_FLAGS_RELWITHDEBINFO_INIT) + set(CMAKE_CXX_FLAGS_RELWITHDEBINFO_INIT "@CXXFLAGS_RELEASE@") + set(CMAKE_OBJCXX_FLAGS_RELWITHDEBINFO_INIT "@CXXFLAGS_RELEASE@") +endif() +if(NOT DEFINED CMAKE_CXX_FLAGS_DEBUG_INIT) + set(CMAKE_CXX_FLAGS_DEBUG_INIT "@CXXFLAGS_DEBUG@") + set(CMAKE_OBJCXX_FLAGS_DEBUG_INIT "@CXXFLAGS_DEBUG@") +endif() + +if(NOT DEFINED CMAKE_CXX_COMPILER) + set(CMAKE_CXX_COMPILER @CXX@) + set(CMAKE_OBJCXX_COMPILER ${CMAKE_CXX_COMPILER}) +endif() + +# The DEPENDS_COMPILE_DEFINITIONS* variables are to be treated as lists. +set(DEPENDS_COMPILE_DEFINITIONS @CPPFLAGS@) +set(DEPENDS_COMPILE_DEFINITIONS_RELWITHDEBINFO @CPPFLAGS_RELEASE@) +set(DEPENDS_COMPILE_DEFINITIONS_DEBUG @CPPFLAGS_DEBUG@) + +if(NOT DEFINED CMAKE_EXE_LINKER_FLAGS_INIT) + set(CMAKE_EXE_LINKER_FLAGS_INIT "@LDFLAGS@") +endif() +if(NOT DEFINED CMAKE_SHARED_LINKER_FLAGS_INIT) + set(CMAKE_SHARED_LINKER_FLAGS_INIT "@LDFLAGS@") +endif() +if(NOT DEFINED CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO_INIT) + set(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO_INIT "@LDFLAGS_RELEASE@") +endif() +if(NOT DEFINED CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO_INIT) + set(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO_INIT "@LDFLAGS_RELEASE@") +endif() +if(NOT DEFINED CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT) + set(CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT "@LDFLAGS_DEBUG@") +endif() +if(NOT DEFINED CMAKE_SHARED_LINKER_FLAGS_DEBUG_INIT) + set(CMAKE_SHARED_LINKER_FLAGS_DEBUG_INIT "@LDFLAGS_DEBUG@") +endif() + +set(CMAKE_AR "@AR@") +set(CMAKE_RANLIB "@RANLIB@") +set(CMAKE_STRIP "@STRIP@") +set(CMAKE_OBJCOPY "@OBJCOPY@") +set(CMAKE_OBJDUMP "@OBJDUMP@") + +# Using our own built dependencies should not be +# affected by a potentially random environment. +set(CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH OFF) + +set(CMAKE_FIND_ROOT_PATH "@depends_prefix@") +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) +set(QT_TRANSLATIONS_DIR "@depends_prefix@/translations") + +if(CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND NOT CMAKE_HOST_APPLE) + # The find_package(Qt ...) function internally uses find_library() + # calls for all dependencies to ensure their availability. + # In turn, the find_library() inspects the well-known locations + # on the file system; therefore, a hint is required. + set(CMAKE_FRAMEWORK_PATH "@OSX_SDK@/System/Library/Frameworks") +endif() + +# Set configuration options for the main build system. +set(qt_packages @qt_packages@) +if("${qt_packages}" STREQUAL "") + set(BUILD_GUI OFF CACHE BOOL "") +else() + set(BUILD_GUI ON CACHE BOOL "") +endif() + +set(qrencode_packages @qrencode_packages@) +if("${qrencode_packages}" STREQUAL "") + set(WITH_QRENCODE OFF CACHE BOOL "") +else() + set(WITH_QRENCODE ON CACHE BOOL "") +endif() + +set(zmq_packages @zmq_packages@) +if("${zmq_packages}" STREQUAL "") + set(WITH_ZMQ OFF CACHE BOOL "") +else() + set(WITH_ZMQ ON CACHE BOOL "") +endif() + +set(wallet_packages @wallet_packages@) +if("${wallet_packages}" STREQUAL "") + set(ENABLE_WALLET OFF CACHE BOOL "") +else() + set(ENABLE_WALLET ON CACHE BOOL "") +endif() + +set(bdb_packages @bdb_packages@) +if("${wallet_packages}" STREQUAL "" OR "${bdb_packages}" STREQUAL "") + set(WITH_BDB OFF CACHE BOOL "") +else() + set(WITH_BDB ON CACHE BOOL "") +endif() + +set(usdt_packages @usdt_packages@) +if("${usdt_packages}" STREQUAL "") + set(WITH_USDT OFF CACHE BOOL "") +else() + set(WITH_USDT ON CACHE BOOL "") +endif() + +if("@no_harden@") + set(ENABLE_HARDENING OFF CACHE BOOL "") +else() + set(ENABLE_HARDENING ON CACHE BOOL "") +endif() + +if("@multiprocess@" STREQUAL "1") + set(WITH_MULTIPROCESS ON CACHE BOOL "") + set(Libmultiprocess_ROOT "${CMAKE_CURRENT_LIST_DIR}" CACHE PATH "") + set(LibmultiprocessNative_ROOT "${CMAKE_CURRENT_LIST_DIR}/native" CACHE PATH "") +else() + set(WITH_MULTIPROCESS OFF CACHE BOOL "") +endif() \ No newline at end of file From d5d1bf038e05925e8a03d9fab7042c34c948fc9f Mon Sep 17 00:00:00 2001 From: AlefLm Date: Wed, 15 Jan 2025 12:10:32 +0000 Subject: [PATCH 12/19] crypto: add support for CMake function check. --- CMakeLists.txt | 1 + cmake/module/TestAppendRequiredLibraries.cmake | 9 +++++++++ src/crypto/CMakeLists.txt | 18 ++++++++++++++++++ src/crypto/common.h | 1 + 4 files changed, 29 insertions(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 56beff3d29..eaa97e6045 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -214,6 +214,7 @@ if(BUILD_FOR_FUZZING) endif() include(ProcessConfigurations) +include(CheckFunctionExists) include(TryAppendCXXFlags) include(TryAppendLinkerFlag) diff --git a/cmake/module/TestAppendRequiredLibraries.cmake b/cmake/module/TestAppendRequiredLibraries.cmake index 5352102c7a..d3e4662d2e 100644 --- a/cmake/module/TestAppendRequiredLibraries.cmake +++ b/cmake/module/TestAppendRequiredLibraries.cmake @@ -90,3 +90,12 @@ function(test_append_atomic_library target) message(FATAL_ERROR "Cannot figure out how to use std::atomic.") endif() endfunction() + +macro(check_function_exists_and_define FUNC_NAME TARGET_NAME SCOPE MACRO_NAME) + check_function_exists(${FUNC_NAME} ${MACRO_NAME}) + if(${MACRO_NAME}) + target_compile_definitions(${TARGET_NAME} ${SCOPE} ${MACRO_NAME}=0) + else() + target_compile_definitions(${TARGET_NAME} ${SCOPE} ${MACRO_NAME}=1) + endif() +endmacro() \ No newline at end of file diff --git a/src/crypto/CMakeLists.txt b/src/crypto/CMakeLists.txt index 28c7ca6ae8..07f3c5dd54 100644 --- a/src/crypto/CMakeLists.txt +++ b/src/crypto/CMakeLists.txt @@ -15,6 +15,24 @@ add_library(bitcoin_crypto STATIC EXCLUDE_FROM_ALL ../support/cleanse.cpp ) +# Check all endian conversion functions for 16-bit +check_function_exists_and_define(htobe16 bitcoin_crypto PRIVATE HAVE_DECL_HTOBE16) +check_function_exists_and_define(htole16 bitcoin_crypto PRIVATE HAVE_DECL_HTOLE16) +check_function_exists_and_define(be16toh bitcoin_crypto PRIVATE HAVE_DECL_BE16TOH) +check_function_exists_and_define(le16toh bitcoin_crypto PRIVATE HAVE_DECL_LE16TOH) + +# Check all endian conversion functions for 32-bit +check_function_exists_and_define(htobe32 bitcoin_crypto PRIVATE HAVE_DECL_HTOBE32) +check_function_exists_and_define(htole32 bitcoin_crypto PRIVATE HAVE_DECL_HTOLE32) +check_function_exists_and_define(be32toh bitcoin_crypto PRIVATE HAVE_DECL_BE32TOH) +check_function_exists_and_define(le32toh bitcoin_crypto PRIVATE HAVE_DECL_LE32TOH) + +# Check all endian conversion functions for 64-bit +check_function_exists_and_define(htobe64 bitcoin_crypto PRIVATE HAVE_DECL_HTOBE64) +check_function_exists_and_define(htole64 bitcoin_crypto PRIVATE HAVE_DECL_HTOLE64) +check_function_exists_and_define(be64toh bitcoin_crypto PRIVATE HAVE_DECL_BE64TOH) +check_function_exists_and_define(le64toh bitcoin_crypto PRIVATE HAVE_DECL_LE64TOH) + target_link_libraries(bitcoin_crypto PRIVATE core_interface diff --git a/src/crypto/common.h b/src/crypto/common.h index bcca3d30ea..45b23960ea 100644 --- a/src/crypto/common.h +++ b/src/crypto/common.h @@ -11,6 +11,7 @@ #include #include +#include #include "compat/endian.h" From aed6efc981a04e0ebf7e4560e53fd846872f797e Mon Sep 17 00:00:00 2001 From: AlefLm Date: Thu, 16 Jan 2025 17:01:37 +0000 Subject: [PATCH 13/19] bitcoin-cli: add CMake compilation. --- CMakeLists.txt | 118 +++++++++++++++++- cmake/module/AddBoostIfNeeded.cmake | 31 ++++- .../module/TestAppendRequiredLibraries.cmake | 19 +-- depends/packages/boost.mk | 2 +- src/CMakeLists.txt | 27 +++- src/bitcoin_bignum/bignum.h | 8 +- src/consensus/tx_verify.cpp | 6 +- src/crypto/CMakeLists.txt | 24 +--- src/crypto/common.h | 3 +- src/dbwrapper.cpp | 2 +- src/sigma/sigma_primitives.hpp | 2 +- src/support/allocators/secure.h | 17 +-- src/support/allocators/zeroafterfree.h | 17 +-- src/wallet/CMakeLists.txt | 2 + 14 files changed, 211 insertions(+), 67 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index eaa97e6045..bb510c9fb9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -47,6 +47,12 @@ project(FiroCore LANGUAGES NONE ) +set(FIRO_DAEMON_NAME firod) +set(FIRO_GUI_NAME firo-qt) +set(FIRO_CLI_NAME firo-cli) +set(FIRO_TX_NAME firo-tx) +set(FIRO_UTIL_NAME firo-util) + set(CLIENT_VERSION_STRING ${PROJECT_VERSION}) if(CLIENT_VERSION_RC GREATER 0) string(APPEND CLIENT_VERSION_STRING "rc${CLIENT_VERSION_RC}") @@ -65,10 +71,15 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND NOT CMAKE_HOST_APPLE) set(CMAKE_PLATFORM_HAS_INSTALLNAME FALSE) endif() enable_language(CXX) -set(CMAKE_CXX_STANDARD 20) +set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) +enable_language(C) +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_STANDARD_REQUIRED ON) +set(CMAKE_C_EXTENSIONS ON) + list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/module) #============================= @@ -76,13 +87,13 @@ list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/module) #============================= include(CMakeDependentOption) # When adding a new option, end the with a full stop for consistency. -option(BUILD_DAEMON "Build firod executable." ON) -option(BUILD_GUI "Build firo-qt executable." OFF) -option(BUILD_CLI "Build firo-cli executable." ON) +option(BUILD_DAEMON "Build ${FIRO_DAEMON_NAME} executable." ON) +option(BUILD_GUI "Build ${FIRO_GUI_NAME} executable." OFF) +option(BUILD_CLI "Build ${FIRO_CLI_NAME} executable." ON) option(BUILD_TESTS "Build test_firo executable." ON) -option(BUILD_TX "Build firo-tx executable." ${BUILD_TESTS}) -option(BUILD_UTIL "Build firo-util executable." ${BUILD_TESTS}) +option(BUILD_TX "Build ${FIRO_TX_NAME} executable." ${BUILD_TESTS}) +option(BUILD_UTIL "Build ${FIRO_UTIL_NAME} executable and library." ${BUILD_TESTS}) option(BUILD_UTIL_CHAINSTATE "Build experimental firo-chainstate executable." OFF) option(BUILD_KERNEL_LIB "Build experimental firokernel library." ${BUILD_UTIL_CHAINSTATE}) @@ -190,6 +201,9 @@ target_link_libraries(core_interface INTERFACE $<$:core_interface_relwithdebinfo> $<$:core_interface_debug> ) +target_compile_definitions(core_interface + INTERFACE + HAVE_CONFIG_H=1) if(BUILD_FOR_FUZZING) message(WARNING "BUILD_FOR_FUZZING=ON will disable all other targets and force BUILD_FUZZ_BINARY=ON.") @@ -362,6 +376,98 @@ if(BUILD_DAEMON OR BUILD_GUI OR BUILD_CLI OR BUILD_TESTS OR BUILD_BENCH OR BUILD endif() include(cmake/introspection.cmake) +#################### +# Check functions and define +include(CheckIncludeFile) +include(CheckSymbolExists) + +# Check for headers +CHECK_INCLUDE_FILE(endian.h HAVE_ENDIAN_H) +CHECK_INCLUDE_FILE(sys/endian.h HAVE_SYS_ENDIAN_H) + +# Setup test code header section +if(HAVE_ENDIAN_H) + set(ENDIAN_HEADER "endian.h") + add_compile_definitions(HAVE_ENDIAN_H=1) +elseif(HAVE_SYS_ENDIAN_H) + set(ENDIAN_HEADER "sys/endian.h") + add_compile_definitions(HAVE_SYS_ENDIAN_H=1) +endif(HAVE_ENDIAN_H) + +# Functions to check +set(ENDIAN_FUNCTIONS + le16toh le32toh le64toh + htole16 htole32 htole64 + be16toh be32toh be64toh + htobe16 htobe32 htobe64 +) + +# Check each function +foreach(func ${ENDIAN_FUNCTIONS}) + string(TOUPPER "HAVE_DECL_${func}" var_name) + check_symbol_exists(${func} "${ENDIAN_HEADER}" ${var_name}) + if(${var_name}) + add_compile_definitions(${var_name}=1) + else() + add_compile_definitions(${var_name}=0) + endif() +endforeach() + +# Check for byteswap.h header +CHECK_INCLUDE_FILE(byteswap.h HAVE_BYTESWAP_H) + +# Setup test code header section +if(HAVE_BYTESWAP_H) + set(BYTESWAP_HEADER "byteswap.h") + add_compile_definitions(HAVE_BYTESWAP_H=1) +endif(HAVE_BYTESWAP_H) + +# Functions to check +set(BSWAP_FUNCTIONS + bswap_16 bswap_32 bswap_64 +) + +# Check each function +foreach(func ${BSWAP_FUNCTIONS}) + string(TOUPPER "HAVE_DECL_${func}" var_name) + check_symbol_exists(${func} "${BYTESWAP_HEADER}" ${var_name}) + if(${var_name}) + add_compile_definitions(${var_name}=1) + else() + add_compile_definitions(${var_name}=0) + endif() +endforeach() + +# strnlen +CHECK_INCLUDE_FILE(string.h HAVE_STRING_H) +if(HAVE_STRING_H) + check_function_exists_and_define(strnlen "string.h" HAVE_DECL_STRNLEN) +endif(HAVE_STRING_H) + +# Functions to check +set(BUILTIN_FUNCTIONS + __builtin_clz + __builtin_clzl + __builtin_clzll +) + +# Check each function +foreach(func ${BUILTIN_FUNCTIONS}) + string(TOUPPER "HAVE_DECL_${func}" var_name) + set(TEST_SOURCE_CODE " + int main() { + int x = 0; + (void)${func}(x); + return 0; + } + ") + check_cxx_source_compiles("${TEST_SOURCE_CODE}" ${var_name}) + if(${var_name}) + add_compile_definitions(${var_name}=1) + else() + add_compile_definitions(${var_name}=0) + endif() +endforeach() include(cmake/ccache.cmake) diff --git a/cmake/module/AddBoostIfNeeded.cmake b/cmake/module/AddBoostIfNeeded.cmake index ecd0d6f2ab..575c59a7f6 100644 --- a/cmake/module/AddBoostIfNeeded.cmake +++ b/cmake/module/AddBoostIfNeeded.cmake @@ -25,8 +25,35 @@ function(add_boost_if_needed) if(POLICY CMP0167) cmake_policy(SET CMP0167 OLD) endif() - set(Boost_NO_BOOST_CMAKE ON) - find_package(Boost 1.73.0 REQUIRED) + set(Boost_NO_BOOST_CMAKE OFF) + find_package(Boost 1.81.0 REQUIRED COMPONENTS atomic chrono filesystem program_options system thread) + + include(CheckCXXSourceCompiles) + set(CMAKE_REQUIRED_INCLUDES ${Boost_INCLUDE_DIRS}) + set(CMAKE_REQUIRED_LIBRARIES ${Boost_LIBRARIES}) + # Test source code + set(SLEEPTEST_SOURCE_CODE " + #include + #include + + int main() { + #if BOOST_VERSION >= 105000 && (!defined(BOOST_HAS_NANOSLEEP) || BOOST_VERSION >= 105200) + boost::this_thread::sleep_for(boost::chrono::milliseconds(0)); + return 0; + #else + choke me + #endif + } + ") + + # Check if the test source code compiles + check_cxx_source_compiles("${SLEEPTEST_SOURCE_CODE}" HAVE_WORKING_BOOST_SLEEP_FOR) + + # Define the macro if the test passed + if(HAVE_WORKING_BOOST_SLEEP_FOR) + add_compile_definitions(HAVE_WORKING_BOOST_SLEEP_FOR=1) + endif() + mark_as_advanced(Boost_INCLUDE_DIR) set_target_properties(Boost::headers PROPERTIES IMPORTED_GLOBAL TRUE) target_compile_definitions(Boost::headers INTERFACE diff --git a/cmake/module/TestAppendRequiredLibraries.cmake b/cmake/module/TestAppendRequiredLibraries.cmake index d3e4662d2e..26981aeeea 100644 --- a/cmake/module/TestAppendRequiredLibraries.cmake +++ b/cmake/module/TestAppendRequiredLibraries.cmake @@ -91,11 +91,16 @@ function(test_append_atomic_library target) endif() endfunction() -macro(check_function_exists_and_define FUNC_NAME TARGET_NAME SCOPE MACRO_NAME) - check_function_exists(${FUNC_NAME} ${MACRO_NAME}) - if(${MACRO_NAME}) - target_compile_definitions(${TARGET_NAME} ${SCOPE} ${MACRO_NAME}=0) - else() - target_compile_definitions(${TARGET_NAME} ${SCOPE} ${MACRO_NAME}=1) - endif() +include(CheckSymbolExists) +include(CheckFunctionExists) +include(CheckIncludeFile) +macro(check_function_exists_and_define FUNC_NAME HEADER_NAME MACRO_NAME) + check_cxx_symbol_exists(${FUNC_NAME} ${HEADER_NAME} ${MACRO_NAME}) + if(${MACRO_NAME}) + message(STATUS "Defined ${MACRO_NAME} = 1") + add_compile_definitions(${MACRO_NAME}=1) + else() + message(STATUS "Defined ${MACRO_NAME} = 0") + add_compile_definitions(${MACRO_NAME}=0) + endif() endmacro() \ No newline at end of file diff --git a/depends/packages/boost.mk b/depends/packages/boost.mk index 859ac1af28..92c05d4334 100644 --- a/depends/packages/boost.mk +++ b/depends/packages/boost.mk @@ -8,7 +8,7 @@ $(package)_dependencies=native_b2 define $(package)_set_vars $(package)_config_opts_release=variant=release $(package)_config_opts_debug=variant=debug -$(package)_config_opts=--layout=tagged --build-type=complete --user-config=user-config.jam +$(package)_config_opts=--layout=system --user-config=user-config.jam $(package)_config_opts+=threading=multi link=static -sNO_COMPRESSION=1 $(package)_config_opts_linux=target-os=linux threadapi=pthread runtime-link=shared $(package)_config_opts_darwin=target-os=darwin runtime-link=shared diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 0afb88110d..5c89fa793c 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -46,6 +46,8 @@ target_link_libraries(bitcoin_util core_interface bitcoin_clientversion bitcoin_crypto + secp256k1 + leveldb $<$:ws2_32> $<$:iphlpapi> ) @@ -120,8 +122,10 @@ add_library(bitcoin_consensus STATIC EXCLUDE_FROM_ALL target_link_libraries(bitcoin_consensus PRIVATE core_interface - bitcoin_crypto secp256k1 + leveldb + PUBLIC + bitcoin_crypto ) if(WITH_ZMQ) @@ -153,18 +157,18 @@ add_library(bitcoin_common STATIC EXCLUDE_FROM_ALL script/sign.cpp ) target_link_libraries(bitcoin_common - PRIVATE + PUBLIC core_interface bitcoin_consensus bitcoin_util univalue secp256k1 Boost::headers + leveldb $ $<$:ws2_32> ) - set(installable_targets) if(ENABLE_WALLET) add_subdirectory(wallet) @@ -226,17 +230,18 @@ target_link_libraries(bitcoin_node core_interface bitcoin_common bitcoin_util + secp256k1 $ leveldb univalue Boost::headers + Boost::thread $ $ $ $ ) - # Bitcoin Core bitcoind. if(BUILD_DAEMON) add_executable(bitcoind @@ -246,6 +251,8 @@ if(BUILD_DAEMON) target_link_libraries(bitcoind core_interface bitcoin_node + univalue + Boost::thread $ ) list(APPEND installable_targets bitcoind) @@ -283,13 +290,20 @@ endif() add_library(bitcoin_cli STATIC EXCLUDE_FROM_ALL rpc/client.cpp + rpc/protocol.cpp + util.cpp ) target_link_libraries(bitcoin_cli PUBLIC core_interface univalue + Boost::filesystem + Boost::thread + Boost::program_options +) +target_include_directories(bitcoin_cli + PUBLIC ) - # Bitcoin Core RPC client if(BUILD_CLI) @@ -300,10 +314,11 @@ if(BUILD_CLI) bitcoin_cli bitcoin_common bitcoin_util - libevent::core libevent::extra + libevent::core ) list(APPEND installable_targets bitcoin-cli) + set_target_properties(bitcoin-cli PROPERTIES OUTPUT_NAME ${FIRO_CLI_NAME}) endif() diff --git a/src/bitcoin_bignum/bignum.h b/src/bitcoin_bignum/bignum.h index b1df2a67fc..19b155e42f 100644 --- a/src/bitcoin_bignum/bignum.h +++ b/src/bitcoin_bignum/bignum.h @@ -9,10 +9,10 @@ #include #include -#include "../../uint256.h" // for uint64 -#include "../../arith_uint256.h" -#include "../../version.h" -#include "../../clientversion.h" +#include "../uint256.h" // for uint64 +#include "../arith_uint256.h" +#include "../version.h" +#include "../clientversion.h" /** Errors thrown by the bignum class */ class bignum_error : public std::runtime_error { diff --git a/src/consensus/tx_verify.cpp b/src/consensus/tx_verify.cpp index bf68f8754b..cf81d2779f 100644 --- a/src/consensus/tx_verify.cpp +++ b/src/consensus/tx_verify.cpp @@ -2,8 +2,6 @@ // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. -#include "tx_verify.h" - #include "consensus.h" #include "primitives/transaction.h" #include "script/interpreter.h" @@ -201,7 +199,8 @@ bool CheckTransaction(const CTransaction& tx, CValidationState &state, bool fChe return true; } -bool Consensus::CheckTxInputs(const CTransaction& tx, CValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight) +namespace Consensus { +bool CheckTxInputs(const CTransaction& tx, CValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight) { // This doesn't trigger the DoS code on purpose; if it did, it would make it easier // for an attacker to attempt to split the network. @@ -244,3 +243,4 @@ bool Consensus::CheckTxInputs(const CTransaction& tx, CValidationState& state, c return state.DoS(100, false, REJECT_INVALID, "bad-txns-fee-outofrange"); return true; } +} // namespace Consensus \ No newline at end of file diff --git a/src/crypto/CMakeLists.txt b/src/crypto/CMakeLists.txt index 07f3c5dd54..0b461e522a 100644 --- a/src/crypto/CMakeLists.txt +++ b/src/crypto/CMakeLists.txt @@ -15,25 +15,13 @@ add_library(bitcoin_crypto STATIC EXCLUDE_FROM_ALL ../support/cleanse.cpp ) -# Check all endian conversion functions for 16-bit -check_function_exists_and_define(htobe16 bitcoin_crypto PRIVATE HAVE_DECL_HTOBE16) -check_function_exists_and_define(htole16 bitcoin_crypto PRIVATE HAVE_DECL_HTOLE16) -check_function_exists_and_define(be16toh bitcoin_crypto PRIVATE HAVE_DECL_BE16TOH) -check_function_exists_and_define(le16toh bitcoin_crypto PRIVATE HAVE_DECL_LE16TOH) - -# Check all endian conversion functions for 32-bit -check_function_exists_and_define(htobe32 bitcoin_crypto PRIVATE HAVE_DECL_HTOBE32) -check_function_exists_and_define(htole32 bitcoin_crypto PRIVATE HAVE_DECL_HTOLE32) -check_function_exists_and_define(be32toh bitcoin_crypto PRIVATE HAVE_DECL_BE32TOH) -check_function_exists_and_define(le32toh bitcoin_crypto PRIVATE HAVE_DECL_LE32TOH) - -# Check all endian conversion functions for 64-bit -check_function_exists_and_define(htobe64 bitcoin_crypto PRIVATE HAVE_DECL_HTOBE64) -check_function_exists_and_define(htole64 bitcoin_crypto PRIVATE HAVE_DECL_HTOLE64) -check_function_exists_and_define(be64toh bitcoin_crypto PRIVATE HAVE_DECL_BE64TOH) -check_function_exists_and_define(le64toh bitcoin_crypto PRIVATE HAVE_DECL_LE64TOH) - target_link_libraries(bitcoin_crypto PRIVATE core_interface + ${Boost_LIBRARIES} ) + +target_include_directories(bitcoin_crypto + PUBLIC + ${Boost_INCLUDE_DIR} +) \ No newline at end of file diff --git a/src/crypto/common.h b/src/crypto/common.h index 45b23960ea..244de556f0 100644 --- a/src/crypto/common.h +++ b/src/crypto/common.h @@ -6,12 +6,11 @@ #define BITCOIN_CRYPTO_COMMON_H #if defined(HAVE_CONFIG_H) -#include "bitcoin-config.h" +#include "../config/bitcoin-config.h" #endif #include #include -#include #include "compat/endian.h" diff --git a/src/dbwrapper.cpp b/src/dbwrapper.cpp index 94ebedeb72..88aa72ef52 100644 --- a/src/dbwrapper.cpp +++ b/src/dbwrapper.cpp @@ -12,7 +12,7 @@ #include #include #include -#include +#include #include static leveldb::Options GetOptions(size_t nCacheSize) diff --git a/src/sigma/sigma_primitives.hpp b/src/sigma/sigma_primitives.hpp index ce3c8ee93a..2db8639ca3 100644 --- a/src/sigma/sigma_primitives.hpp +++ b/src/sigma/sigma_primitives.hpp @@ -1,4 +1,4 @@ -#include "../../crypto/sha256.h" +#include "../crypto/sha256.h" namespace sigma { diff --git a/src/support/allocators/secure.h b/src/support/allocators/secure.h index 7fc0e269f4..3477c2933d 100644 --- a/src/support/allocators/secure.h +++ b/src/support/allocators/secure.h @@ -19,14 +19,15 @@ template struct secure_allocator : public std::allocator { // MSVC8 default copy constructor is broken - typedef std::allocator base; - typedef typename base::size_type size_type; - typedef typename base::difference_type difference_type; - typedef typename base::pointer pointer; - typedef typename base::const_pointer const_pointer; - typedef typename base::reference reference; - typedef typename base::const_reference const_reference; - typedef typename base::value_type value_type; + using base = std::allocator; + using size_type = std::size_t; + using difference_type = std::ptrdiff_t; + using value_type = T; + using pointer = T*; + using const_pointer = const T*; + using reference = T&; + using const_reference = const T&; + secure_allocator() throw() {} secure_allocator(const secure_allocator& a) throw() : base(a) {} template diff --git a/src/support/allocators/zeroafterfree.h b/src/support/allocators/zeroafterfree.h index 8ac7f890ed..5da7ebfd45 100644 --- a/src/support/allocators/zeroafterfree.h +++ b/src/support/allocators/zeroafterfree.h @@ -14,14 +14,15 @@ template struct zero_after_free_allocator : public std::allocator { // MSVC8 default copy constructor is broken - typedef std::allocator base; - typedef typename base::size_type size_type; - typedef typename base::difference_type difference_type; - typedef typename base::pointer pointer; - typedef typename base::const_pointer const_pointer; - typedef typename base::reference reference; - typedef typename base::const_reference const_reference; - typedef typename base::value_type value_type; + using base = std::allocator; + using size_type = std::size_t; + using difference_type = std::ptrdiff_t; + using value_type = T; + using pointer = T*; + using const_pointer = const T*; + using reference = T&; + using const_reference = const T&; + zero_after_free_allocator() throw() {} zero_after_free_allocator(const zero_after_free_allocator& a) throw() : base(a) {} template diff --git a/src/wallet/CMakeLists.txt b/src/wallet/CMakeLists.txt index 6895ace860..7ceb9899bb 100644 --- a/src/wallet/CMakeLists.txt +++ b/src/wallet/CMakeLists.txt @@ -25,6 +25,8 @@ target_link_libraries(bitcoin_wallet bitcoin_common univalue Boost::headers + secp256k1 + leveldb $ ) From 6031191d6fbc5257e18254accbc07b775e9539a9 Mon Sep 17 00:00:00 2001 From: AlefLm Date: Thu, 23 Jan 2025 17:20:01 +0000 Subject: [PATCH 14/19] firo-tx: add CMake compilation. Improve miscellaneous CMake files. --- CMakeLists.txt | 13 +++++++++ depends/toolchain.cmake.in | 2 ++ src/CMakeLists.txt | 39 +++++++++++++++----------- src/crypto/CMakeLists.txt | 10 +++++++ src/crypto/progpow/CMakeLists.txt | 29 +++++++++++++++++++ src/secp256k1/cmake/FindGMP.cmake | 9 ------ src/secp256k1/src/CMakeLists.txt | 30 ++++++++++++++------ src/secp256k1/src/cpp/GroupElement.cpp | 2 ++ src/wallet/CMakeLists.txt | 6 ++-- 9 files changed, 103 insertions(+), 37 deletions(-) create mode 100644 src/crypto/progpow/CMakeLists.txt diff --git a/CMakeLists.txt b/CMakeLists.txt index bb510c9fb9..a3bedb72e0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -62,6 +62,19 @@ set(COPYRIGHT_HOLDERS "The %s developers") set(COPYRIGHT_HOLDERS_FINAL "The ${CLIENT_NAME} developers") set(CLIENT_BUGREPORT "https://github.com/firoorg/firo/issues") +#============================= +# Set Project-wide output folders +#============================= +if(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY) + set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin) +endif() +if(NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY) + set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib) +endif() +if(NOT CMAKE_ARCHIVE_OUTPUT_DIRECTORY) + set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib) +endif() + #============================= # Language setup #============================= diff --git a/depends/toolchain.cmake.in b/depends/toolchain.cmake.in index 028d81f2d3..65e70d8179 100644 --- a/depends/toolchain.cmake.in +++ b/depends/toolchain.cmake.in @@ -82,6 +82,8 @@ set(CMAKE_OBJDUMP "@OBJDUMP@") set(CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH OFF) set(CMAKE_FIND_ROOT_PATH "@depends_prefix@") +list(APPEND CMAKE_PREFIX_PATH "${CMAKE_FIND_ROOT_PATH}/lib/pkgconfig") +set(ENV{PKG_CONFIG_PATH} "${CMAKE_FIND_ROOT_PATH}/lib/pkgconfig:$ENV{PKG_CONFIG_PATH}") set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 5c89fa793c..1e1f4d8b4b 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -182,7 +182,7 @@ if(ENABLE_WALLET) add_windows_resources(bitcoin-wallet bitcoin-wallet-res.rc) target_link_libraries(bitcoin-wallet core_interface - bitcoin_wallet + firo_wallet bitcoin_common bitcoin_util Boost::headers @@ -253,7 +253,7 @@ if(BUILD_DAEMON) bitcoin_node univalue Boost::thread - $ + $ ) list(APPEND installable_targets bitcoind) endif() @@ -266,7 +266,7 @@ if(WITH_MULTIPROCESS) core_interface bitcoin_node bitcoin_ipc - $ + $ ) list(APPEND installable_targets bitcoin-node) @@ -288,12 +288,12 @@ if(WITH_MULTIPROCESS) endif() -add_library(bitcoin_cli STATIC EXCLUDE_FROM_ALL +add_library(firo_cli STATIC EXCLUDE_FROM_ALL rpc/client.cpp rpc/protocol.cpp util.cpp ) -target_link_libraries(bitcoin_cli +target_link_libraries(firo_cli PUBLIC core_interface univalue @@ -301,37 +301,44 @@ target_link_libraries(bitcoin_cli Boost::thread Boost::program_options ) -target_include_directories(bitcoin_cli +target_include_directories(firo_cli PUBLIC ) # Bitcoin Core RPC client if(BUILD_CLI) - add_executable(bitcoin-cli bitcoin-cli.cpp) - add_windows_resources(bitcoin-cli bitcoin-cli-res.rc) - target_link_libraries(bitcoin-cli + add_executable(firo-cli bitcoin-cli.cpp) + add_windows_resources(firo-cli bitcoin-cli-res.rc) + target_link_libraries(firo-cli core_interface - bitcoin_cli + firo_cli bitcoin_common bitcoin_util libevent::extra libevent::core ) - list(APPEND installable_targets bitcoin-cli) - set_target_properties(bitcoin-cli PROPERTIES OUTPUT_NAME ${FIRO_CLI_NAME}) + list(APPEND installable_targets firo-cli) + set_target_properties(firo-cli PROPERTIES OUTPUT_NAME ${FIRO_CLI_NAME}) endif() if(BUILD_TX) - add_executable(bitcoin-tx bitcoin-tx.cpp) - add_windows_resources(bitcoin-tx bitcoin-tx-res.rc) - target_link_libraries(bitcoin-tx + add_executable(firo-tx bitcoin-tx.cpp + keystore.cpp + script/standard.cpp + ) + add_windows_resources(firo-tx bitcoin-tx-res.rc) + target_link_libraries(firo-tx core_interface + bitcoin_crypto + firo_cli bitcoin_common bitcoin_util univalue + secp256k1pp + secp256k1 ) - list(APPEND installable_targets bitcoin-tx) + list(APPEND installable_targets firo-tx) endif() diff --git a/src/crypto/CMakeLists.txt b/src/crypto/CMakeLists.txt index 0b461e522a..d81073afcd 100644 --- a/src/crypto/CMakeLists.txt +++ b/src/crypto/CMakeLists.txt @@ -2,6 +2,8 @@ # Distributed under the MIT software license, see the accompanying # file COPYING or https://opensource.org/license/mit/. +add_subdirectory(progpow) + add_library(bitcoin_crypto STATIC EXCLUDE_FROM_ALL aes.cpp chacha20.cpp @@ -12,6 +14,11 @@ add_library(bitcoin_crypto STATIC EXCLUDE_FROM_ALL sha1.cpp sha256.cpp sha512.cpp + scrypt.cpp + Lyra2Z/Lyra2.c + Lyra2Z/Lyra2Z.c + Lyra2Z/Sponge.c + Lyra2Z/blake.c ../support/cleanse.cpp ) @@ -19,6 +26,9 @@ target_link_libraries(bitcoin_crypto PRIVATE core_interface ${Boost_LIBRARIES} + PUBLIC + ethash + keccak ) target_include_directories(bitcoin_crypto diff --git a/src/crypto/progpow/CMakeLists.txt b/src/crypto/progpow/CMakeLists.txt new file mode 100644 index 0000000000..a056421a6e --- /dev/null +++ b/src/crypto/progpow/CMakeLists.txt @@ -0,0 +1,29 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +add_library(keccak STATIC EXCLUDE_FROM_ALL + lib/keccak/keccak.c + lib/keccak/keccakf800.c + lib/keccak/keccakf1600.c +) + +add_library(ethash STATIC EXCLUDE_FROM_ALL + lib/ethash/ethash.cpp + lib/ethash/managed.cpp + lib/ethash/primes.c + lib/ethash/progpow.cpp +) + +target_link_libraries(ethash + PRIVATE + core_interface + ${Boost_LIBRARIES} + PUBLIC + keccak +) + +target_include_directories(ethash + PUBLIC + ${Boost_INCLUDE_DIR} +) \ No newline at end of file diff --git a/src/secp256k1/cmake/FindGMP.cmake b/src/secp256k1/cmake/FindGMP.cmake index 87a4ec5db7..91790e1987 100644 --- a/src/secp256k1/cmake/FindGMP.cmake +++ b/src/secp256k1/cmake/FindGMP.cmake @@ -24,15 +24,6 @@ find_library(GMP_LIBRARIES /usr/local/lib ) -# Define this symbol if libgmp is installed -add_compile_definitions(HAVE_LIBGMP=1) -# Define this symbol to use the gmp implementation for num -add_compile_definitions(USE_NUM_GMP=1) -# Define this symbol to use the num-based field inverse implementation -add_compile_definitions(USE_FIELD_INV_NUM=1) -# Define this symbol to use the num-based scalar inverse implementation -add_compile_definitions(USE_SCALAR_INV_NUM=1) - if(GMP_INCLUDES) file(STRINGS "${GMP_INCLUDES}/gmp.h" gmp_version_str REGEX "^#define[\t ]+__GNU_MP_VERSION[\t ]+[0-9]+") string(REGEX REPLACE "^#define[\t ]+__GNU_MP_VERSION[\t ]+([0-9]+).*" "\\1" GMP_VERSION_MAJOR "${gmp_version_str}") diff --git a/src/secp256k1/src/CMakeLists.txt b/src/secp256k1/src/CMakeLists.txt index f0d641287c..974bae7678 100644 --- a/src/secp256k1/src/CMakeLists.txt +++ b/src/secp256k1/src/CMakeLists.txt @@ -5,16 +5,8 @@ include(GNUInstallDirs) # from being exported. add_library(secp256k1 OBJECT secp256k1.c) -target_link_libraries(secp256k1 PUBLIC gmp) - set_property(TARGET secp256k1 PROPERTY POSITION_INDEPENDENT_CODE ON) -add_library(secp256k1pp - cpp/GroupElement.cpp - cpp/MultiExponent.cpp - cpp/Scalar.cpp -) - target_link_libraries(secp256k1 PUBLIC gmp @@ -22,8 +14,28 @@ target_link_libraries(secp256k1 OpenSSL::Crypto ) +#============================= +# secp256k1 Configuration +#============================= +# Define this symbol if libgmp is installed +add_compile_definitions(secp256k1 PUBLIC -DHAVE_LIBGMP=1) +# Define this symbol to use the gmp implementation for num +add_compile_definitions(secp256k1 PUBLIC -DUSE_NUM_GMP=1) +# Define this symbol to use the num-based field inverse implementation +add_compile_definitions(secp256k1 PUBLIC -DUSE_FIELD_INV_NUM=1) +# Define this symbol to use the num-based scalar inverse implementation +add_compile_definitions(secp256k1 PUBLIC -DUSE_SCALAR_INV_NUM=1) + +add_library(secp256k1pp + cpp/GroupElement.cpp + cpp/MultiExponent.cpp + cpp/Scalar.cpp +) + +set_property(TARGET secp256k1pp PROPERTY POSITION_INDEPENDENT_CODE ON) + target_link_libraries(secp256k1pp - PUBLIC secp256k1 + PUBLIC secp256k1 gmp ) add_library(secp256k1_asm INTERFACE) diff --git a/src/secp256k1/src/cpp/GroupElement.cpp b/src/secp256k1/src/cpp/GroupElement.cpp index b94499cd8f..beb98a7d40 100644 --- a/src/secp256k1/src/cpp/GroupElement.cpp +++ b/src/secp256k1/src/cpp/GroupElement.cpp @@ -3,6 +3,8 @@ #include "../field.h" #include "../field_impl.h" +#include "../num.h" +#include "../num_impl.h" #include "../group.h" #include "../group_impl.h" #include "../hash.h" diff --git a/src/wallet/CMakeLists.txt b/src/wallet/CMakeLists.txt index 7ceb9899bb..9bd1706207 100644 --- a/src/wallet/CMakeLists.txt +++ b/src/wallet/CMakeLists.txt @@ -3,7 +3,7 @@ # file COPYING or https://opensource.org/license/mit/. # Wallet functionality used by bitcoind and bitcoin-wallet executables. -add_library(bitcoin_wallet STATIC EXCLUDE_FROM_ALL +add_library(firo_wallet STATIC EXCLUDE_FROM_ALL authhelper.cpp bip39.cpp crypter.cpp @@ -19,7 +19,7 @@ add_library(bitcoin_wallet STATIC EXCLUDE_FROM_ALL walletexcept.cpp ) -target_link_libraries(bitcoin_wallet +target_link_libraries(firo_wallet PRIVATE core_interface bitcoin_common @@ -31,4 +31,4 @@ target_link_libraries(bitcoin_wallet ) # Firo only supports BDB for wallet storage. -target_link_libraries(bitcoin_wallet PUBLIC BerkeleyDB::BerkeleyDB) \ No newline at end of file +target_link_libraries(firo_wallet PUBLIC BerkeleyDB::BerkeleyDB) \ No newline at end of file From 48ee339784e0ede29fa8f6b07b52f0bf72af7ae2 Mon Sep 17 00:00:00 2001 From: AlefLm Date: Thu, 23 Jan 2025 21:49:14 +0000 Subject: [PATCH 15/19] firod: add CMake compilation support. * Improved misc CMake compilation support. * Add bitcoin-config.h generation support. --- CMakeLists.txt | 49 +++++- cmake/bitcoin-build-config.h.in | 11 +- depends/packages/packages.mk | 2 + depends/toolchain.cmake.in | 2 +- src/CMakeLists.txt | 282 +++++++++++++++++++++++++++++-- src/crypto/CMakeLists.txt | 9 + src/secp256k1/CMakeLists.txt | 16 +- src/secp256k1/src/CMakeLists.txt | 24 ++- src/zmq/CMakeLists.txt | 2 + 9 files changed, 357 insertions(+), 40 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index a3bedb72e0..3f3963ffc3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -19,6 +19,7 @@ endif() set(CLIENT_NAME "Firo Core") set(CLIENT_VERSION_MAJOR 0) set(CLIENT_VERSION_MINOR 14) +set(CLIENT_VERSION_REVISION 14) set(CLIENT_VERSION_BUILD 0) set(CLIENT_VERSION_RC 0) set(CLIENT_VERSION_IS_RELEASE "false") @@ -41,7 +42,7 @@ set(CMAKE_TRY_COMPILE_PLATFORM_VARIABLES ) project(FiroCore - VERSION ${CLIENT_VERSION_MAJOR}.${CLIENT_VERSION_MINOR}.${CLIENT_VERSION_BUILD} + VERSION ${CLIENT_VERSION_MAJOR}.${CLIENT_VERSION_MINOR}.${CLIENT_VERSION_REVISION} DESCRIPTION "Firo client software" HOMEPAGE_URL "https://firo.org/" LANGUAGES NONE @@ -135,9 +136,14 @@ option(REDUCE_EXPORTS "Attempt to reduce exported symbols in the resulting execu option(WERROR "Treat compiler warnings as errors." OFF) option(WITH_CCACHE "Attempt to use ccache for compiling." ON) -option(WITH_ZMQ "Enable ZMQ notifications." OFF) +option(WITH_ZMQ "Enable ZMQ notifications." ON) if(WITH_ZMQ) + message(STATUS "ZMQ notifications enabled.") + add_compile_definitions(ENABLE_ZMQ=1) find_package(ZeroMQ 4.0.0 MODULE REQUIRED) +else() + message(STATUS "ZMQ notifications disabled.") + add_compile_definitions(ENABLE_ZMQ=0) endif() option(WITH_USDT "Enable tracepoints for Userspace, Statically Defined Tracing." OFF) @@ -388,6 +394,45 @@ if(BUILD_DAEMON OR BUILD_GUI OR BUILD_CLI OR BUILD_TESTS OR BUILD_BENCH OR BUILD find_package(Libevent 2.1.8 MODULE REQUIRED) endif() +# Find bls-dash library +find_library(BLS_DASH_LIBRARY + NAMES bls-dash + REQUIRED +) + +if(${BLS_DASH_LIBRARY} STREQUAL "BLS_DASH_LIBRARY-NOTFOUND") + message(FATAL_ERROR "bls-dash library not found") +else() + message(STATUS "Found bls-dash library: ${BLS_DASH_LIBRARY}") +endif() + +# Find tor library +find_library(TOR_LIBRARY + NAMES tor + REQUIRED +) + +# Find OpenSSL library +find_package(OpenSSL 1.1.1 REQUIRED) + +# Find MiniUPNP library +find_library(MINIUPNP_LIBRARY + NAMES miniupnpc + REQUIRED +) + +# Find zlib library +find_library(ZLIB_LIBRARY + NAMES z + REQUIRED +) + +if(${TOR_LIBRARY} STREQUAL "TOR_LIBRARY-NOTFOUND") + message(FATAL_ERROR "tor library not found") +else() + message(STATUS "Found tor library: ${TOR_LIBRARY}") +endif() + include(cmake/introspection.cmake) #################### # Check functions and define diff --git a/cmake/bitcoin-build-config.h.in b/cmake/bitcoin-build-config.h.in index 56e0519fac..363f3815e7 100644 --- a/cmake/bitcoin-build-config.h.in +++ b/cmake/bitcoin-build-config.h.in @@ -17,6 +17,9 @@ /* Minor version */ #define CLIENT_VERSION_MINOR @CLIENT_VERSION_MINOR@ +/* Revision version */ +#define CLIENT_VERSION_REVISION @CLIENT_VERSION_REVISION@ + /* Copyright holder(s) before %s replacement */ #define COPYRIGHT_HOLDERS "@COPYRIGHT_HOLDERS@" @@ -121,16 +124,16 @@ #cmakedefine HAVE_VM_VM_PARAM_H 1 /* Define to the address where bug reports for this package should be sent. */ -#define CLIENT_BUGREPORT "@CLIENT_BUGREPORT@" +#define PACKAGE_BUGREPORT "@CLIENT_BUGREPORT@" /* Define to the full name of this package. */ -#define CLIENT_NAME "@CLIENT_NAME@" +#define PACKAGE_NAME "@CLIENT_NAME@" /* Define to the home page for this package. */ -#define CLIENT_URL "@PROJECT_HOMEPAGE_URL@" +#define PACKAGE_URL "@PROJECT_HOMEPAGE_URL@" /* Define to the version of this package. */ -#define CLIENT_VERSION_STRING "@CLIENT_VERSION_STRING@" +#define PACKAGE_VERSION "@CLIENT_VERSION_STRING@" /* Define to 1 if strerror_r returns char *. */ #cmakedefine STRERROR_R_CHAR_P 1 diff --git a/depends/packages/packages.mk b/depends/packages/packages.mk index 574bf3b276..813afd4c16 100644 --- a/depends/packages/packages.mk +++ b/depends/packages/packages.mk @@ -11,6 +11,8 @@ qt_mingw32_packages=qt bdb_packages=bdb sqlite_packages=sqlite +zmq_packages=zeromq + upnp_packages=miniupnpc darwin_native_packages = native_ds_store native_mac_alias diff --git a/depends/toolchain.cmake.in b/depends/toolchain.cmake.in index 65e70d8179..1ae9c4ecbd 100644 --- a/depends/toolchain.cmake.in +++ b/depends/toolchain.cmake.in @@ -82,7 +82,7 @@ set(CMAKE_OBJDUMP "@OBJDUMP@") set(CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH OFF) set(CMAKE_FIND_ROOT_PATH "@depends_prefix@") -list(APPEND CMAKE_PREFIX_PATH "${CMAKE_FIND_ROOT_PATH}/lib/pkgconfig") +list(APPEND CMAKE_PREFIX_PATH "${CMAKE_FIND_ROOT_PATH}/lib/;${CMAKE_FIND_ROOT_PATH}/lib/pkgconfig") set(ENV{PKG_CONFIG_PATH} "${CMAKE_FIND_ROOT_PATH}/lib/pkgconfig:$ENV{PKG_CONFIG_PATH}") set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 1e1f4d8b4b..624c2bba1b 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -5,7 +5,7 @@ include(GNUInstallDirs) include(AddWindowsResources) -configure_file(${PROJECT_SOURCE_DIR}/cmake/bitcoin-build-config.h.in bitcoin-build-config.h USE_SOURCE_PERMISSIONS @ONLY) +configure_file(${PROJECT_SOURCE_DIR}/cmake/bitcoin-build-config.h.in ${CMAKE_CURRENT_SOURCE_DIR}/config/bitcoin-config.h USE_SOURCE_PERMISSIONS @ONLY) include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) add_custom_target(generate_build_info @@ -39,6 +39,30 @@ add_library(bitcoin_util STATIC EXCLUDE_FROM_ALL random.cpp sync.cpp support/lockedpool.cpp + bls/bls_batchverifier.h + bls/bls_ies.cpp + bls/bls_ies.h + bls/bls_worker.cpp + bls/bls_worker.h + support/lockedpool.cpp + chainparamsbase.cpp + clientversion.cpp + compat/glibc_sanity.cpp + compat/glibcxx_sanity.cpp + compat/strnlen.cpp + mbstring.cpp + fs.cpp + random.cpp + rpc/protocol.cpp + support/cleanse.cpp + sync.cpp + threadinterrupt.cpp + util.cpp + utilmoneystr.cpp + utilstrencodings.cpp + utiltime.cpp + crypto/scrypt.cpp + primitives/block.cpp ) target_link_libraries(bitcoin_util @@ -48,6 +72,7 @@ target_link_libraries(bitcoin_util bitcoin_crypto secp256k1 leveldb + univalue $<$:ws2_32> $<$:iphlpapi> ) @@ -64,7 +89,7 @@ endif() message("") message("Configuring secp256k1 subtree...") set(SECP256K1_DISABLE_SHARED ON CACHE BOOL "" FORCE) -set(SECP256K1_ENABLE_MODULE_ECDH OFF CACHE BOOL "" FORCE) +set(SECP256K1_ENABLE_MODULE_ECDH ON CACHE BOOL "" FORCE) set(SECP256K1_ENABLE_MODULE_RECOVERY ON CACHE BOOL "" FORCE) set(SECP256K1_ENABLE_MODULE_MUSIG OFF CACHE BOOL "" FORCE) set(SECP256K1_BUILD_BENCHMARK OFF CACHE BOOL "" FORCE) @@ -118,13 +143,49 @@ add_library(bitcoin_consensus STATIC EXCLUDE_FROM_ALL script/script.cpp script/script_error.cpp uint256.cpp + amount.h + arith_uint256.cpp + arith_uint256.h + bls/bls.cpp + bls/bls.h + consensus/merkle.cpp + consensus/merkle.h + consensus/params.h + consensus/validation.h + hash.cpp + flat-database.h + hash.h + prevector.h + crypto/scrypt.h + primitives/block.h + primitives/precomputed_hash.h + primitives/transaction.cpp + primitives/transaction.h + pubkey.cpp + pubkey.h + script/bitcoinconsensus.cpp + script/interpreter.cpp + script/interpreter.h + script/script.cpp + script/script.h + script/script_error.cpp + script/script_error.h + serialize.h + tinyformat.h + uint256.cpp + uint256.h + utilstrencodings.cpp + utilstrencodings.h + version.h ) target_link_libraries(bitcoin_consensus PRIVATE core_interface secp256k1 leveldb + ${BLS_DASH_LIBRARY} PUBLIC + OpenSSL::Crypto bitcoin_crypto ) @@ -155,6 +216,24 @@ add_library(bitcoin_common STATIC EXCLUDE_FROM_ALL rpc/rawtransaction.cpp scheduler.cpp script/sign.cpp + amount.cpp + base58.cpp + chainparams.cpp + coins.cpp + compressor.cpp + core_read.cpp + core_write.cpp + hdmint/hdmint.cpp + key.cpp + keystore.cpp + netaddress.cpp + netbase.cpp + protocol.cpp + saltedhasher.cpp + scheduler.cpp + script/sign.cpp + script/standard.cpp + warnings.cpp ) target_link_libraries(bitcoin_common PUBLIC @@ -165,35 +244,80 @@ target_link_libraries(bitcoin_common secp256k1 Boost::headers leveldb + $<$:firo_zmq> $ $<$:ws2_32> ) +add_library(bitcoin_wallet STATIC EXCLUDE_FROM_ALL + activemasternode.cpp + hdmint/hdmint.cpp + masternode-sync.cpp + hdmint/mintpool.cpp + hdmint/wallet.cpp + sigma.cpp + lelantus.cpp + spark/state.cpp + wallet/crypter.cpp + wallet/bip39.cpp + wallet/mnemoniccontainer.cpp + wallet/db.cpp + wallet/rpcdump.cpp + wallet/rpcwallet.cpp + wallet/sigmaspendbuilder.cpp + wallet/txbuilder.cpp + wallet/lelantusjoinsplitbuilder.cpp + wallet/walletexcept.cpp + wallet/wallet.cpp + spark/sparkwallet.cpp + spark/primitives.cpp + wallet/walletdb.cpp + wallet/authhelper.cpp + hdmint/tracker.cpp + policy/rbf.cpp + bip47/account.cpp + bip47/paymentchannel.cpp + bip47/bip47utils.cpp + bip47/paymentcode.cpp + bip47/secretpoint.cpp + primitives/mint_spend.cpp +) +target_link_libraries(bitcoin_wallet + PUBLIC + core_interface + bitcoin_util + univalue + secp256k1 + Boost::headers + leveldb +) + set(installable_targets) if(ENABLE_WALLET) add_subdirectory(wallet) if(BUILD_WALLET_TOOL) - add_executable(bitcoin-wallet + add_executable(firo-wallet bitcoin-wallet.cpp init/bitcoin-wallet.cpp wallet/wallettool.cpp ) - add_windows_resources(bitcoin-wallet bitcoin-wallet-res.rc) - target_link_libraries(bitcoin-wallet + add_windows_resources(firo-wallet bitcoin-wallet-res.rc) + target_link_libraries(firo-wallet core_interface firo_wallet bitcoin_common bitcoin_util + bitcoin_wallet Boost::headers ) - list(APPEND installable_targets bitcoin-wallet) + list(APPEND installable_targets firo-wallet) endif() endif() # P2P and RPC server functionality used by `bitcoind` and `bitcoin-qt` executables. -add_library(bitcoin_node STATIC EXCLUDE_FROM_ALL +add_library(firo_node STATIC EXCLUDE_FROM_ALL addrdb.cpp addrman.cpp blockencodings.cpp @@ -224,38 +348,164 @@ add_library(bitcoin_node STATIC EXCLUDE_FROM_ALL validation.cpp validationinterface.cpp versionbits.cpp + ui_interface.cpp + compat/glibc_sanity.cpp + compat/glibcxx_sanity.cpp + activemasternode.cpp + addrman.cpp + addrdb.cpp + batchedlogger.cpp + bloom.cpp + blockencodings.cpp + chain.cpp + checkpoints.cpp + dsnotificationinterface.cpp + evo/cbtx.cpp + evo/deterministicmns.cpp + evo/evodb.cpp + evo/mnauth.cpp + evo/providertx.cpp + evo/simplifiedmns.cpp + evo/specialtx.cpp + evo/spork.cpp + llmq/quorums.cpp + llmq/quorums_blockprocessor.cpp + llmq/quorums_commitment.cpp + llmq/quorums_chainlocks.cpp + llmq/quorums_debug.cpp + llmq/quorums_dkgsessionhandler.cpp + llmq/quorums_dkgsessionmgr.cpp + llmq/quorums_dkgsession.cpp + llmq/quorums_init.cpp + llmq/quorums_instantsend.cpp + llmq/quorums_signing.cpp + llmq/quorums_signing_shares.cpp + llmq/quorums_utils.cpp + masternode-payments.cpp + masternode-sync.cpp + masternode-utils.cpp + httprpc.cpp + httpserver.cpp + init.cpp + dbwrapper.cpp + threadinterrupt.cpp + merkleblock.cpp + miner.cpp + messagesigner.cpp + net.cpp + netfulfilledman.cpp + net_processing.cpp + noui.cpp + policy/fees.cpp + policy/policy.cpp + primitives/mint_spend.cpp + pow.cpp + rest.cpp + rpc/blockchain.cpp + rpc/masternode.cpp + rpc/mining.cpp + rpc/misc.cpp + rpc/net.cpp + rpc/rawtransaction.cpp + rpc/server.cpp + rpc/rpcevo.cpp + rpc/rpcquorums.cpp + script/sigcache.cpp + script/ismine.cpp + timedata.cpp + torcontrol.cpp + txdb.cpp + txmempool.cpp + ui_interface.cpp + batchproof_container.cpp + validation.cpp + validationinterface.cpp + versionbits.cpp + sigma.cpp + lelantus.cpp + bip47/paymentcode.cpp + spark/state.cpp + spark/primitives.cpp + coin_containers.cpp + mtpstate.cpp + sigma/coin.cpp + sigma/coinspend.cpp + sigma/spend_metadata.cpp + sigma/params.cpp + liblelantus/lelantus_primitives.cpp + liblelantus/lelantus_prover.cpp + liblelantus/lelantus_verifier.cpp + liblelantus/sigmaextended_prover.cpp + liblelantus/sigmaextended_verifier.cpp + liblelantus/schnorr_prover.cpp + liblelantus/schnorr_verifier.cpp + liblelantus/innerproduct_proof_verifier.cpp + liblelantus/innerproduct_proof_generator.cpp + liblelantus/range_prover.cpp + liblelantus/range_verifier.cpp + liblelantus/coin.cpp + liblelantus/joinsplit.cpp + liblelantus/spend_metadata.cpp + liblelantus/params.cpp + libspark/transcript.cpp + libspark/params.cpp + libspark/schnorr.cpp + libspark/chaum.cpp + libspark/coin.cpp + libspark/bpplus.cpp + libspark/grootle.cpp + libspark/keys.cpp + libspark/util.cpp + libspark/aead.cpp + libspark/kdf.cpp + libspark/hash.cpp + libspark/mint_transaction.cpp + libspark/spend_transaction.cpp + libspark/f4grumble.cpp + libspark/bech32.cpp ) -target_link_libraries(bitcoin_node + +target_link_libraries(firo_node PRIVATE core_interface bitcoin_common bitcoin_util secp256k1 - $ + $<$:firo_zmq> leveldb univalue Boost::headers Boost::thread + OpenSSL::Crypto + ${TOR_LIBRARY} + OpenSSL::SSL + ${MINIUPNP_LIBRARY} + ${ZLIB_LIBRARY} $ $ $ $ ) -# Bitcoin Core bitcoind. +# Bitcoin Core firod. if(BUILD_DAEMON) - add_executable(bitcoind + add_executable(firod bitcoind.cpp ) - add_windows_resources(bitcoind bitcoind-res.rc) - target_link_libraries(bitcoind + add_windows_resources(firod bitcoind-res.rc) + target_link_libraries(firod core_interface - bitcoin_node univalue Boost::thread + firo_node + $<$:firo_zmq> + firo_cli + secp256k1 + secp256k1pp + bitcoin_wallet $ ) - list(APPEND installable_targets bitcoind) + list(APPEND installable_targets firod) endif() if(WITH_MULTIPROCESS) add_executable(bitcoin-node @@ -264,7 +514,7 @@ if(WITH_MULTIPROCESS) ) target_link_libraries(bitcoin-node core_interface - bitcoin_node + firo_node bitcoin_ipc $ ) diff --git a/src/crypto/CMakeLists.txt b/src/crypto/CMakeLists.txt index d81073afcd..39f3541564 100644 --- a/src/crypto/CMakeLists.txt +++ b/src/crypto/CMakeLists.txt @@ -15,6 +15,15 @@ add_library(bitcoin_crypto STATIC EXCLUDE_FROM_ALL sha256.cpp sha512.cpp scrypt.cpp + MerkleTreeProof/arith_uint256.cpp + MerkleTreeProof/blake2 + MerkleTreeProof/core.c + MerkleTreeProof/merkle-tree.cpp + MerkleTreeProof/mtp.cpp + MerkleTreeProof/ref.c + MerkleTreeProof/thread.c + MerkleTreeProof/blake2/blake2b.c + MerkleTreeProof/crypto/sha256.cpp Lyra2Z/Lyra2.c Lyra2Z/Lyra2Z.c Lyra2Z/Sponge.c diff --git a/src/secp256k1/CMakeLists.txt b/src/secp256k1/CMakeLists.txt index 6b4bc2b54e..54ef962cb4 100644 --- a/src/secp256k1/CMakeLists.txt +++ b/src/secp256k1/CMakeLists.txt @@ -75,16 +75,6 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR}/src) option(SECP256K1_ENABLE_MODULE_ECDH "Enable ECDH module." ON) option(SECP256K1_ENABLE_MODULE_RECOVERY "Enable ECDSA pubkey recovery module." ON) -# Processing must be done in a topological sorting of the dependency graph -# (dependent module first). -if(SECP256K1_ENABLE_MODULE_RECOVERY) - add_compile_definitions(ENABLE_MODULE_RECOVERY=1) -endif() - -if(SECP256K1_ENABLE_MODULE_ECDH) - add_compile_definitions(ENABLE_MODULE_ECDH=1) -endif() - set(SECP256K1_ECMULT_WINDOW_SIZE 15 CACHE STRING "Window size for ecmult precomputation for verification, specified as integer in range [2..24]. The default value is a reasonable setting for desktop machines (currently 15). [default=15]") set_property(CACHE SECP256K1_ECMULT_WINDOW_SIZE PROPERTY STRINGS 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24) include(CheckStringOptionValue) @@ -162,9 +152,9 @@ if(SECP256K1_VALGRIND) endif() endif() -option(SECP256K1_BUILD_BENCHMARK "Build benchmarks." ON) -option(SECP256K1_BUILD_TESTS "Build tests." ON) -option(SECP256K1_BUILD_EXHAUSTIVE_TESTS "Build exhaustive tests." ON) +option(SECP256K1_BUILD_BENCHMARK "Build benchmarks." OFF) +option(SECP256K1_BUILD_TESTS "Build tests." OFF) +option(SECP256K1_BUILD_EXHAUSTIVE_TESTS "Build exhaustive tests." OFF) # Redefine configuration flags. # We leave assertions on, because they are only used in the examples, and we want them always on there. diff --git a/src/secp256k1/src/CMakeLists.txt b/src/secp256k1/src/CMakeLists.txt index 974bae7678..6705451b44 100644 --- a/src/secp256k1/src/CMakeLists.txt +++ b/src/secp256k1/src/CMakeLists.txt @@ -18,13 +18,29 @@ target_link_libraries(secp256k1 # secp256k1 Configuration #============================= # Define this symbol if libgmp is installed -add_compile_definitions(secp256k1 PUBLIC -DHAVE_LIBGMP=1) +add_compile_definitions(HAVE_LIBGMP=1) # Define this symbol to use the gmp implementation for num -add_compile_definitions(secp256k1 PUBLIC -DUSE_NUM_GMP=1) +add_compile_definitions(USE_NUM_GMP=1) # Define this symbol to use the num-based field inverse implementation -add_compile_definitions(secp256k1 PUBLIC -DUSE_FIELD_INV_NUM=1) +add_compile_definitions(USE_FIELD_INV_NUM=1) # Define this symbol to use the num-based scalar inverse implementation -add_compile_definitions(secp256k1 PUBLIC -DUSE_SCALAR_INV_NUM=1) +add_compile_definitions(USE_SCALAR_INV_NUM=1) + +# Processing must be done in a topological sorting of the dependency graph +# (dependent module first). +if(SECP256K1_ENABLE_MODULE_RECOVERY) + add_compile_definitions(ENABLE_MODULE_RECOVERY=1) + message(STATUS "secp256k1: Recovery module enabled") +else() + message(STATUS "secp256k1: Recovery module disabled") +endif() + +if(SECP256K1_ENABLE_MODULE_ECDH) + add_compile_definitions(ENABLE_MODULE_ECDH=1) + message(STATUS "secp256k1: ECDH module enabled") +else() + message(STATUS "secp256k1: ECDH module disabled") +endif() add_library(secp256k1pp cpp/GroupElement.cpp diff --git a/src/zmq/CMakeLists.txt b/src/zmq/CMakeLists.txt index 1afbdd1701..f3a02a7bec 100644 --- a/src/zmq/CMakeLists.txt +++ b/src/zmq/CMakeLists.txt @@ -16,4 +16,6 @@ target_link_libraries(firo_zmq core_interface univalue zeromq + secp256k1 + leveldb ) From 5b8f35f728620b233266b129f13e2e03302fc53f Mon Sep 17 00:00:00 2001 From: Alef LM Date: Thu, 6 Feb 2025 02:12:32 +0000 Subject: [PATCH 16/19] gmp: fix gmp link on OS X --- CMakeLists.txt | 5 ++- .../cmake => cmake/module}/FindGMP.cmake | 31 +++++++++++++------ doc/CMakeLists.txt | 1 - src/secp256k1/src/CMakeLists.txt | 16 ++++++---- 4 files changed, 36 insertions(+), 17 deletions(-) rename {src/secp256k1/cmake => cmake/module}/FindGMP.cmake (57%) diff --git a/CMakeLists.txt b/CMakeLists.txt index 3f3963ffc3..6a69c5d2b6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -112,7 +112,7 @@ option(BUILD_UTIL "Build ${FIRO_UTIL_NAME} executable and library." ${BUILD_TEST option(BUILD_UTIL_CHAINSTATE "Build experimental firo-chainstate executable." OFF) option(BUILD_KERNEL_LIB "Build experimental firokernel library." ${BUILD_UTIL_CHAINSTATE}) -option(ENABLE_WALLET "Enable wallet." ON) +option(ENABLE_WALLET "Enable wallet." OFF) option(WITH_BDB "Enable Berkeley DB (BDB) wallet support." OFF) cmake_dependent_option(WARN_INCOMPATIBLE_BDB "Warn when using a Berkeley DB (BDB) version other than 4.8." ON "WITH_BDB" OFF) if(WITH_BDB) @@ -421,6 +421,9 @@ find_library(MINIUPNP_LIBRARY REQUIRED ) +# Find GMP library +find_package(GMP 6.2.1 REQUIRED) + # Find zlib library find_library(ZLIB_LIBRARY NAMES z diff --git a/src/secp256k1/cmake/FindGMP.cmake b/cmake/module/FindGMP.cmake similarity index 57% rename from src/secp256k1/cmake/FindGMP.cmake rename to cmake/module/FindGMP.cmake index 91790e1987..0e658c05dd 100644 --- a/src/secp256k1/cmake/FindGMP.cmake +++ b/cmake/module/FindGMP.cmake @@ -1,7 +1,9 @@ -find_package(PkgConfig QUIET) -if(PKG_CONFIG_FOUND) - pkg_check_modules(PC_GMP QUIET gmp) -endif() +# Try to find the GNU Multiple Precision Arithmetic Library (GMP) +# See http://gmplib.org/ + +if (GMP_INCLUDES AND GMP_LIBRARIES) + set(GMP_FIND_QUIETLY TRUE) +endif (GMP_INCLUDES AND GMP_LIBRARIES) find_path(GMP_INCLUDES NAMES @@ -9,9 +11,10 @@ find_path(GMP_INCLUDES HINTS $ENV{GMPDIR} ${INCLUDE_INSTALL_DIR} - ${PC_GMP_INCLUDE_DIRS} - /usr/include - /usr/local/include + ${LIB_INSTALL_DIR} + ${PC_GMP_LIBRARY_DIRS} + /usr/lib + /usr/local/lib ) find_library(GMP_LIBRARIES @@ -24,7 +27,10 @@ find_library(GMP_LIBRARIES /usr/local/lib ) -if(GMP_INCLUDES) + +if(GMP_LIBRARIES AND GMP_INCLUDES) + message(STATUS "Found GMP: ${GMP_LIBRARIES}") + message(STATUS "GMP includes: ${GMP_INCLUDES}") file(STRINGS "${GMP_INCLUDES}/gmp.h" gmp_version_str REGEX "^#define[\t ]+__GNU_MP_VERSION[\t ]+[0-9]+") string(REGEX REPLACE "^#define[\t ]+__GNU_MP_VERSION[\t ]+([0-9]+).*" "\\1" GMP_VERSION_MAJOR "${gmp_version_str}") @@ -34,4 +40,11 @@ if(GMP_INCLUDES) set(GMP_VERSION "${GMP_VERSION_MAJOR}.${GMP_VERSION_MINOR}") message(STATUS "GMP_VERSION_MAJOR : ${GMP_VERSION_MAJOR}") message(STATUS "GMP_VERSION_MINOR : ${GMP_VERSION_MINOR}") -endif() \ No newline at end of file +else() + message(FATAL_ERROR "Could not find GMP") +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(GMP DEFAULT_MSG + GMP_INCLUDES GMP_LIBRARIES) +mark_as_advanced(GMP_INCLUDES GMP_LIBRARIES) \ No newline at end of file diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt index 310a90612b..60ddd49ec1 100644 --- a/doc/CMakeLists.txt +++ b/doc/CMakeLists.txt @@ -6,7 +6,6 @@ find_package(Doxygen COMPONENTS dot) if(DOXYGEN_FOUND) set(doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile) - configure_file(Doxyfile.in ${doxyfile} USE_SOURCE_PERMISSIONS) # In CMake 3.27, The FindDoxygen module's doxygen_add_docs() # command gained a CONFIG_FILE option to specify a custom doxygen diff --git a/src/secp256k1/src/CMakeLists.txt b/src/secp256k1/src/CMakeLists.txt index 6705451b44..359b5b2746 100644 --- a/src/secp256k1/src/CMakeLists.txt +++ b/src/secp256k1/src/CMakeLists.txt @@ -9,7 +9,7 @@ set_property(TARGET secp256k1 PROPERTY POSITION_INDEPENDENT_CODE ON) target_link_libraries(secp256k1 PUBLIC - gmp + ${GMP_LIBRARIES} PRIVATE OpenSSL::Crypto ) @@ -51,7 +51,11 @@ add_library(secp256k1pp set_property(TARGET secp256k1pp PROPERTY POSITION_INDEPENDENT_CODE ON) target_link_libraries(secp256k1pp - PUBLIC secp256k1 gmp + PUBLIC secp256k1 ${GMP_LIBRARIES} +) + +target_include_directories(secp256k1pp + PUBLIC ${GMP_INCLUDES} ) add_library(secp256k1_asm INTERFACE) @@ -128,18 +132,18 @@ if(SECP256K1_BUILD_BENCHMARK) add_executable(bench_verify bench_verify.c) target_link_libraries(bench_verify PUBLIC secp256k1) add_executable(bench_internal bench_internal.c) - target_link_libraries(bench_internal PUBLIC secp256k1_asm gmp) + target_link_libraries(bench_internal PUBLIC secp256k1_asm ${GMP_LIBRARIES}) endif() if(SECP256K1_BUILD_TESTS) add_executable(noverify_tests tests.c) target_compile_definitions(noverify_tests PRIVATE VERIFY) - target_link_libraries(noverify_tests secp256k1_asm gmp) + target_link_libraries(noverify_tests secp256k1_asm ${GMP_LIBRARIES}) add_test(NAME secp256k1_noverify_tests COMMAND noverify_tests) if(NOT CMAKE_BUILD_TYPE STREQUAL "Coverage") add_executable(tests tests.c) target_compile_definitions(tests PRIVATE VERIFY) - target_link_libraries(tests secp256k1_asm gmp) + target_link_libraries(tests secp256k1_asm ${GMP_LIBRARIES}) add_test(NAME secp256k1_tests COMMAND tests) endif() endif() @@ -147,7 +151,7 @@ endif() if(SECP256K1_BUILD_EXHAUSTIVE_TESTS) # Note: do not include secp256k1_precomputed in exhaustive_tests (it uses runtime-generated tables). add_executable(exhaustive_tests tests_exhaustive.c) - target_link_libraries(exhaustive_tests secp256k1_asm gmp) + target_link_libraries(exhaustive_tests secp256k1_asm ${GMP_LIBRARIES}) target_compile_definitions(exhaustive_tests PRIVATE $<$>:VERIFY>) add_test(NAME secp256k1_exhaustive_tests COMMAND exhaustive_tests) endif() From d62a490d8b42f7b25fa7c741986767a43cbecdf8 Mon Sep 17 00:00:00 2001 From: AlefLm Date: Tue, 11 Feb 2025 21:35:39 +0000 Subject: [PATCH 17/19] build: generate Linux installable package. --- CMakeLists.txt | 6 ++++++ README.md | 9 +++++++++ 2 files changed, 15 insertions(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 6a69c5d2b6..35e929b3a1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -778,3 +778,9 @@ endif() # We want all build properties to be encapsulated properly. include(WarnAboutGlobalProperties) + +# Generate archive files +set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Firo client software") +set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/README.md") +set(CPACK_VERBATIM_VARIABLES YES) +include(CPack) \ No newline at end of file diff --git a/README.md b/README.md index f421ef0201..d1850e0457 100644 --- a/README.md +++ b/README.md @@ -188,6 +188,15 @@ See [doc/build-windows.md](doc/build-windows.md) for instructions on building on Now that you have your self-built or precompiled binaries, it's time to run Firo! Depending by your skill level and/or setup, you might want to use the command line tool or the graphic user interface. If you have problems or need support, [contact the community](https://firo.org/community/social/). +# Install Firo + +After building with `CMake`, generate `.sh` file with `make package`. Once you run `make package` you should have `./FiroCore-VERSION_MAJOR.VERSION_MINOR.VERSION_REVISION-Linux.sh` in your build directory. + +For example, you can install `Firo` on your `/usr/bin` with: +``` +./FiroCore-0.14.14-Linux.sh --prefix=/usr/bin --exclude-subdir +``` + # Contributors ## Code Contributors From 15b408810ee0dc6cc3a7ad9de1b169799b3c8288 Mon Sep 17 00:00:00 2001 From: AlefLm Date: Sun, 16 Feb 2025 22:47:00 +0000 Subject: [PATCH 18/19] CMake: add tests (test_bitcoin) compilation support. --- CMakeLists.txt | 16 +- cmake/script/GenerateHeaderFromJson.cmake | 40 ++-- depends/toolchain.cmake.in | 3 +- src/CMakeLists.txt | 76 ------- src/Makefile.test.include | 2 +- src/secp256k1/src/CMakeLists.txt | 16 +- src/test/CMakeLists.txt | 187 ++++++++++++++++++ src/test/base58_tests.cpp | 6 +- src/univalue/CMakeLists.txt | 9 - src/wallet/CMakeLists.txt | 53 +++-- src/wallet/test/CMakeLists.txt | 20 ++ ...spark_tests.cpp => spark_wallet_tests.cpp} | 2 +- 12 files changed, 290 insertions(+), 140 deletions(-) create mode 100644 src/test/CMakeLists.txt create mode 100644 src/wallet/test/CMakeLists.txt rename src/wallet/test/{spark_tests.cpp => spark_wallet_tests.cpp} (99%) diff --git a/CMakeLists.txt b/CMakeLists.txt index 35e929b3a1..14f1a3fa01 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -52,7 +52,6 @@ set(FIRO_DAEMON_NAME firod) set(FIRO_GUI_NAME firo-qt) set(FIRO_CLI_NAME firo-cli) set(FIRO_TX_NAME firo-tx) -set(FIRO_UTIL_NAME firo-util) set(CLIENT_VERSION_STRING ${PROJECT_VERSION}) if(CLIENT_VERSION_RC GREATER 0) @@ -105,14 +104,13 @@ option(BUILD_DAEMON "Build ${FIRO_DAEMON_NAME} executable." ON) option(BUILD_GUI "Build ${FIRO_GUI_NAME} executable." OFF) option(BUILD_CLI "Build ${FIRO_CLI_NAME} executable." ON) -option(BUILD_TESTS "Build test_firo executable." ON) -option(BUILD_TX "Build ${FIRO_TX_NAME} executable." ${BUILD_TESTS}) -option(BUILD_UTIL "Build ${FIRO_UTIL_NAME} executable and library." ${BUILD_TESTS}) option(BUILD_UTIL_CHAINSTATE "Build experimental firo-chainstate executable." OFF) option(BUILD_KERNEL_LIB "Build experimental firokernel library." ${BUILD_UTIL_CHAINSTATE}) option(ENABLE_WALLET "Enable wallet." OFF) +cmake_dependent_option(BUILD_TESTS "Build tests." OFF "ENABLE_WALLET" OFF) +option(BUILD_TX "Build ${FIRO_TX_NAME} executable." ${BUILD_TESTS}) option(WITH_BDB "Enable Berkeley DB (BDB) wallet support." OFF) cmake_dependent_option(WARN_INCOMPATIBLE_BDB "Warn when using a Berkeley DB (BDB) version other than 4.8." ON "WITH_BDB" OFF) if(WITH_BDB) @@ -129,7 +127,6 @@ if(WITH_BDB) endif() endif() endif() -cmake_dependent_option(BUILD_WALLET_TOOL "Build firo-wallet tool." ${BUILD_TESTS} "ENABLE_WALLET" OFF) option(ENABLE_HARDENING "Attempt to harden the resulting executables." ON) option(REDUCE_EXPORTS "Attempt to reduce exported symbols in the resulting executables." OFF) @@ -162,7 +159,7 @@ endif() cmake_dependent_option(WITH_DBUS "Enable DBus support." ON "CMAKE_SYSTEM_NAME STREQUAL \"Linux\" AND BUILD_GUI" OFF) -cmake_dependent_option(BUILD_GUI_TESTS "Build test_firo-qt executable." ON "BUILD_GUI;BUILD_TESTS" OFF) +cmake_dependent_option(BUILD_GUI_TESTS "Build test_bitcoin-qt executable." ON "BUILD_GUI;BUILD_TESTS" OFF) if(BUILD_GUI) set(qt_components Core Gui Widgets LinguistTools) if(ENABLE_WALLET) @@ -232,7 +229,6 @@ if(BUILD_FOR_FUZZING) set(BUILD_UTIL OFF) set(BUILD_UTIL_CHAINSTATE OFF) set(BUILD_KERNEL_LIB OFF) - set(BUILD_WALLET_TOOL OFF) set(BUILD_GUI OFF) set(ENABLE_EXTERNAL_SIGNER OFF) set(WITH_ZMQ OFF) @@ -735,8 +731,6 @@ message(" firod ............................ ${BUILD_DAEMON}") message(" firo-qt (GUI) .................... ${BUILD_GUI}") message(" firo-cli ......................... ${BUILD_CLI}") message(" firo-tx .......................... ${BUILD_TX}") -message(" firo-util ........................ ${BUILD_UTIL}") -message(" firo-wallet ...................... ${BUILD_WALLET_TOOL}") message(" firo-chainstate (experimental) ... ${BUILD_UTIL_CHAINSTATE}") message(" libfirokernel (experimental) ..... ${BUILD_KERNEL_LIB}") message("Optional features:") @@ -750,8 +744,8 @@ message(" USDT tracing ........................ ${WITH_USDT}") message(" QR code (GUI) ....................... ${WITH_QRENCODE}") message(" DBus (GUI, Linux only) .............. ${WITH_DBUS}") message("Tests:") -message(" test_firo ........................ ${BUILD_TESTS}") -message(" test_firo-qt ..................... ${BUILD_GUI_TESTS}") +message(" test_bitcoin ........................ ${BUILD_TESTS}") +message(" test_bitcoin-qt ..................... ${BUILD_GUI_TESTS}") message(" bench_firo ....................... ${BUILD_BENCH}") message(" fuzz binary ......................... ${BUILD_FUZZ_BINARY}") message("") diff --git a/cmake/script/GenerateHeaderFromJson.cmake b/cmake/script/GenerateHeaderFromJson.cmake index 4a3bddb323..5d3482f5f1 100644 --- a/cmake/script/GenerateHeaderFromJson.cmake +++ b/cmake/script/GenerateHeaderFromJson.cmake @@ -2,21 +2,33 @@ # Distributed under the MIT software license, see the accompanying # file COPYING or https://opensource.org/license/mit/. -cmake_path(GET JSON_SOURCE_PATH STEM json_source_basename) +message(STATUS "Generating header ${HEADER_PATH} from ${JSON_SOURCE_PATH}") -file(READ ${JSON_SOURCE_PATH} hex_content HEX) -string(REGEX REPLACE "................" "\\0\n" formatted_bytes "${hex_content}") -string(REGEX REPLACE "[^\n][^\n]" "0x\\0, " formatted_bytes "${formatted_bytes}") +# Generate a header file from a JSON file containing a hex dump +function(generate_json_header JSON_SOURCE_PATH HEADER_PATH) + # Use get_filename_component instead of cmake_path + get_filename_component(json_source_basename "${JSON_SOURCE_PATH}" NAME_WE) -set(header_content -"#include + # Create directory + get_filename_component(header_dir "${HEADER_PATH}" DIRECTORY) + file(MAKE_DIRECTORY "${header_dir}") + + # Read and convert to hex + file(READ ${JSON_SOURCE_PATH} hex_content HEX) + string(REGEX REPLACE ".." "0x\\0, " formatted_bytes "${hex_content}") -namespace json_tests { -inline constexpr char detail_${json_source_basename}_bytes[] { -${formatted_bytes} -}; + # Generate content + set(header_content + "namespace json_tests{ + static unsigned const char ${json_source_basename}[] = { + ${formatted_bytes} + }; + };" + ) + + # Atomic write using temporary file + file(WRITE "${HEADER_PATH}.new" "${header_content}") + file(RENAME "${HEADER_PATH}.new" "${HEADER_PATH}") +endfunction() -inline constexpr std::string_view ${json_source_basename}{std::begin(detail_${json_source_basename}_bytes), std::end(detail_${json_source_basename}_bytes)}; -} -") -file(WRITE ${HEADER_PATH} "${header_content}") +generate_json_header(${JSON_SOURCE_PATH} ${HEADER_PATH}) diff --git a/depends/toolchain.cmake.in b/depends/toolchain.cmake.in index 1ae9c4ecbd..f50baffe86 100644 --- a/depends/toolchain.cmake.in +++ b/depends/toolchain.cmake.in @@ -82,8 +82,7 @@ set(CMAKE_OBJDUMP "@OBJDUMP@") set(CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH OFF) set(CMAKE_FIND_ROOT_PATH "@depends_prefix@") -list(APPEND CMAKE_PREFIX_PATH "${CMAKE_FIND_ROOT_PATH}/lib/;${CMAKE_FIND_ROOT_PATH}/lib/pkgconfig") -set(ENV{PKG_CONFIG_PATH} "${CMAKE_FIND_ROOT_PATH}/lib/pkgconfig:$ENV{PKG_CONFIG_PATH}") +list(APPEND CMAKE_PREFIX_PATH "${CMAKE_FIND_ROOT_PATH}/lib/") set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 624c2bba1b..b59f55db9a 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -124,12 +124,10 @@ endforeach() if(DEFINED ENV{CFLAGS}) deduplicate_flags(CMAKE_C_FLAGS) endif() -set(CMAKE_EXPORT_COMPILE_COMMANDS OFF) add_subdirectory(secp256k1) set_target_properties(secp256k1 PROPERTIES EXCLUDE_FROM_ALL TRUE ) -set(CMAKE_EXPORT_COMPILE_COMMANDS ON) string(APPEND CMAKE_C_COMPILE_OBJECT " ${APPEND_CPPFLAGS} ${APPEND_CFLAGS}") add_library(bitcoin_consensus STATIC EXCLUDE_FROM_ALL @@ -249,70 +247,9 @@ target_link_libraries(bitcoin_common $<$:ws2_32> ) -add_library(bitcoin_wallet STATIC EXCLUDE_FROM_ALL - activemasternode.cpp - hdmint/hdmint.cpp - masternode-sync.cpp - hdmint/mintpool.cpp - hdmint/wallet.cpp - sigma.cpp - lelantus.cpp - spark/state.cpp - wallet/crypter.cpp - wallet/bip39.cpp - wallet/mnemoniccontainer.cpp - wallet/db.cpp - wallet/rpcdump.cpp - wallet/rpcwallet.cpp - wallet/sigmaspendbuilder.cpp - wallet/txbuilder.cpp - wallet/lelantusjoinsplitbuilder.cpp - wallet/walletexcept.cpp - wallet/wallet.cpp - spark/sparkwallet.cpp - spark/primitives.cpp - wallet/walletdb.cpp - wallet/authhelper.cpp - hdmint/tracker.cpp - policy/rbf.cpp - bip47/account.cpp - bip47/paymentchannel.cpp - bip47/bip47utils.cpp - bip47/paymentcode.cpp - bip47/secretpoint.cpp - primitives/mint_spend.cpp -) -target_link_libraries(bitcoin_wallet - PUBLIC - core_interface - bitcoin_util - univalue - secp256k1 - Boost::headers - leveldb -) - set(installable_targets) if(ENABLE_WALLET) add_subdirectory(wallet) - - if(BUILD_WALLET_TOOL) - add_executable(firo-wallet - bitcoin-wallet.cpp - init/bitcoin-wallet.cpp - wallet/wallettool.cpp - ) - add_windows_resources(firo-wallet bitcoin-wallet-res.rc) - target_link_libraries(firo-wallet - core_interface - firo_wallet - bitcoin_common - bitcoin_util - bitcoin_wallet - Boost::headers - ) - list(APPEND installable_targets firo-wallet) - endif() endif() @@ -322,7 +259,6 @@ add_library(firo_node STATIC EXCLUDE_FROM_ALL addrman.cpp blockencodings.cpp chain.cpp - consensus/tx_verify.cpp dbwrapper.cpp httprpc.cpp httpserver.cpp @@ -502,7 +438,6 @@ if(BUILD_DAEMON) firo_cli secp256k1 secp256k1pp - bitcoin_wallet $ ) list(APPEND installable_targets firod) @@ -592,17 +527,6 @@ if(BUILD_TX) endif() -if(BUILD_UTIL) - add_executable(bitcoin-util bitcoin-util.cpp) - add_windows_resources(bitcoin-util bitcoin-util-res.rc) - target_link_libraries(bitcoin-util - core_interface - bitcoin_common - bitcoin_util - ) - list(APPEND installable_targets bitcoin-util) -endif() - if(BUILD_GUI) add_subdirectory(qt) diff --git a/src/Makefile.test.include b/src/Makefile.test.include index 16819e88d3..99669b8f1c 100644 --- a/src/Makefile.test.include +++ b/src/Makefile.test.include @@ -205,7 +205,7 @@ BITCOIN_TESTS += \ wallet/test/wallet_tests.cpp \ wallet/test/crypto_tests.cpp \ wallet/test/lelantus_tests.cpp \ - wallet/test/spark_tests.cpp \ + wallet/test/spark_wallet_tests.cpp \ wallet/test/sigma_tests.cpp \ wallet/test/mnemonic_tests.cpp \ wallet/test/txbuilder_tests.cpp diff --git a/src/secp256k1/src/CMakeLists.txt b/src/secp256k1/src/CMakeLists.txt index 359b5b2746..dc08c50e34 100644 --- a/src/secp256k1/src/CMakeLists.txt +++ b/src/secp256k1/src/CMakeLists.txt @@ -14,6 +14,11 @@ target_link_libraries(secp256k1 OpenSSL::Crypto ) +target_include_directories(secp256k1 + PUBLIC + ${GMP_INCLUDES} +) + #============================= # secp256k1 Configuration #============================= @@ -54,11 +59,8 @@ target_link_libraries(secp256k1pp PUBLIC secp256k1 ${GMP_LIBRARIES} ) -target_include_directories(secp256k1pp - PUBLIC ${GMP_INCLUDES} -) - add_library(secp256k1_asm INTERFACE) +target_link_libraries(secp256k1_asm INTERFACE ${GMP_LIBRARIES}) if(SECP256K1_ASM STREQUAL "arm32") add_library(secp256k1_asm_arm OBJECT EXCLUDE_FROM_ALL) target_sources(secp256k1_asm_arm PUBLIC @@ -133,17 +135,20 @@ if(SECP256K1_BUILD_BENCHMARK) target_link_libraries(bench_verify PUBLIC secp256k1) add_executable(bench_internal bench_internal.c) target_link_libraries(bench_internal PUBLIC secp256k1_asm ${GMP_LIBRARIES}) + target_include_directories(bench_internal PUBLIC ${GMP_INCLUDES}) endif() if(SECP256K1_BUILD_TESTS) add_executable(noverify_tests tests.c) target_compile_definitions(noverify_tests PRIVATE VERIFY) target_link_libraries(noverify_tests secp256k1_asm ${GMP_LIBRARIES}) + target_include_directories(noverify_tests PUBLIC ${GMP_INCLUDES}) add_test(NAME secp256k1_noverify_tests COMMAND noverify_tests) if(NOT CMAKE_BUILD_TYPE STREQUAL "Coverage") add_executable(tests tests.c) target_compile_definitions(tests PRIVATE VERIFY) target_link_libraries(tests secp256k1_asm ${GMP_LIBRARIES}) + target_include_directories(tests PUBLIC ${GMP_INCLUDES}) add_test(NAME secp256k1_tests COMMAND tests) endif() endif() @@ -151,7 +156,8 @@ endif() if(SECP256K1_BUILD_EXHAUSTIVE_TESTS) # Note: do not include secp256k1_precomputed in exhaustive_tests (it uses runtime-generated tables). add_executable(exhaustive_tests tests_exhaustive.c) - target_link_libraries(exhaustive_tests secp256k1_asm ${GMP_LIBRARIES}) + target_link_libraries(exhaustive_tests PRIVATE secp256k1_asm ${GMP_LIBRARIES}) + target_include_directories(exhaustive_tests PUBLIC ${GMP_INCLUDES}) target_compile_definitions(exhaustive_tests PRIVATE $<$>:VERIFY>) add_test(NAME secp256k1_exhaustive_tests COMMAND exhaustive_tests) endif() diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt new file mode 100644 index 0000000000..79574a5530 --- /dev/null +++ b/src/test/CMakeLists.txt @@ -0,0 +1,187 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +include(GenerateHeaders) +generate_header_from_json(data/base58_encode_decode.json) +generate_header_from_json(data/base58_keys_invalid.json) +generate_header_from_json(data/base58_keys_valid.json) +generate_header_from_json(data/script_tests.json) +generate_header_from_json(data/sighash.json) +generate_header_from_json(data/tx_invalid.json) +generate_header_from_json(data/tx_valid.json) + +# Do not use generator expressions in test sources because the +# SOURCES property is processed to gather test suite macros. +add_executable(test_bitcoin + ${CMAKE_CURRENT_BINARY_DIR}/data/base58_encode_decode.json.h + ${CMAKE_CURRENT_BINARY_DIR}/data/base58_keys_invalid.json.h + ${CMAKE_CURRENT_BINARY_DIR}/data/base58_keys_valid.json.h + ${CMAKE_CURRENT_BINARY_DIR}/data/script_tests.json.h + ${CMAKE_CURRENT_BINARY_DIR}/data/sighash.json.h + ${CMAKE_CURRENT_BINARY_DIR}/data/tx_invalid.json.h + ${CMAKE_CURRENT_BINARY_DIR}/data/tx_valid.json.h + addrman_tests.cpp + allocator_tests.cpp + amount_tests.cpp + arith_uint256_tests.cpp + base32_tests.cpp + base58_tests.cpp + base64_tests.cpp + bip32_tests.cpp + bip47_test_data.h + bip47_tests.cpp + bip47_serialization_tests.cpp + blockencodings_tests.cpp + bloom_tests.cpp + bswap_tests.cpp + checkqueue_tests.cpp + coins_tests.cpp + compress_tests.cpp + crypto_tests.cpp + cuckoocache_tests.cpp + DoS_tests.cpp + fixtures.cpp + fixtures.h + getarg_tests.cpp + hash_tests.cpp + key_tests.cpp + dbwrapper_tests.cpp + lelantus_tests.cpp + lelantus_mintspend_test.cpp + lelantus_state_tests.cpp + sigma_lelantus_transition.cpp + limitedmap_tests.cpp + main_tests.cpp + mbstring_tests.cpp + mempool_tests.cpp + merkle_tests.cpp + miner_tests.cpp + mtp_halving_tests.cpp + mtp_tests.cpp + mtp_trans_tests.cpp + firopow_tests.cpp + multisig_tests.cpp + netbase_tests.cpp + net_tests.cpp + pmt_tests.cpp + prevector_tests.cpp + raii_event_tests.cpp + random_tests.cpp + reverselock_tests.cpp + rpc_tests.cpp + sanity_tests.cpp + scheduler_tests.cpp + scriptnum10.h + scriptnum_tests.cpp + script_P2SH_tests.cpp + script_tests.cpp + serialize_tests.cpp + sighash_tests.cpp + sigma_manymintspend_test.cpp + sigma_mintspend_numinputs.cpp + sigma_mintspend_test.cpp + sigma_partialspend_mempool_tests.cpp + sigma_state_tests.cpp + sigopcount_tests.cpp + skiplist_tests.cpp + streams_tests.cpp + test_bitcoin.cpp + test_bitcoin.h + test_random.h + testutil.cpp + testutil.h + timedata_tests.cpp + transaction_tests.cpp + txdb_tests.cpp + txvalidationcache_tests.cpp + uint256_tests.cpp + univalue_tests.cpp + util_tests.cpp + multiexponentation_test.cpp + firsthalving_tests.cpp + evospork_tests.cpp + evo_deterministicmns_tests.cpp + evo_simplifiedmns_tests.cpp + progpow_tests.cpp + bls_tests.cpp +) + +target_link_libraries(test_bitcoin + core_interface + firo_cli + firo_node + bitcoin_consensus + secp256k1 + Boost::headers + libevent::extra + secp256k1pp + univalue + leveldb + firo_wallet +) + +target_include_directories(test_bitcoin + PUBLIC + ${CMAKE_CURRENT_BINARY_DIR} +) + +if(ENABLE_WALLET) + add_subdirectory(${PROJECT_SOURCE_DIR}/src/wallet/test wallet) +endif() + +if(WITH_MULTIPROCESS) + target_link_libraries(bitcoin_ipc_test + PRIVATE + core_interface + univalue + ) + + target_sources(test_bitcoin + PRIVATE + ipc_tests.cpp + ) + target_link_libraries(test_bitcoin bitcoin_ipc_test bitcoin_ipc) +endif() + +function(add_boost_test source_file) + if(NOT EXISTS ${source_file}) + return() + endif() + + file(READ "${source_file}" source_file_content) + string(REGEX + MATCH "(BOOST_FIXTURE_TEST_SUITE|BOOST_AUTO_TEST_SUITE)\\(([A-Za-z0-9_]+)" + test_suite_macro "${source_file_content}" + ) + string(REGEX + REPLACE "(BOOST_FIXTURE_TEST_SUITE|BOOST_AUTO_TEST_SUITE)\\(" "" + test_suite_name "${test_suite_macro}" + ) + if(test_suite_name) + add_test(NAME ${test_suite_name} + COMMAND test_bitcoin --run_test=${test_suite_name} --catch_system_error=no --log_level=test_suite -- DEBUG_LOG_OUT + ) + set_property(TEST ${test_suite_name} PROPERTY + SKIP_REGULAR_EXPRESSION "no test cases matching filter" + ) + endif() +endfunction() + +function(add_all_test_targets) + get_target_property(test_source_dir test_bitcoin SOURCE_DIR) + get_target_property(test_sources test_bitcoin SOURCES) + foreach(test_source ${test_sources}) + cmake_path(IS_RELATIVE test_source result) + if(result) + cmake_path(APPEND test_source_dir ${test_source} OUTPUT_VARIABLE test_source) + endif() + add_boost_test(${test_source}) + endforeach() +endfunction() + +add_all_test_targets() + +install(TARGETS test_bitcoin + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} +) diff --git a/src/test/base58_tests.cpp b/src/test/base58_tests.cpp index 5d9ddbf81a..1db4a0f925 100644 --- a/src/test/base58_tests.cpp +++ b/src/test/base58_tests.cpp @@ -4,9 +4,9 @@ #include "base58.h" -#include "data/base58_encode_decode.json.h" -#include "data/base58_keys_invalid.json.h" -#include "data/base58_keys_valid.json.h" +#include +#include +#include #include "key.h" #include "script/script.h" diff --git a/src/univalue/CMakeLists.txt b/src/univalue/CMakeLists.txt index ab460286f5..02e1a38958 100644 --- a/src/univalue/CMakeLists.txt +++ b/src/univalue/CMakeLists.txt @@ -28,13 +28,4 @@ if(BUILD_TESTS) COMMAND unitester ) - add_executable(object test/object.cpp) - target_link_libraries(object - PRIVATE - core_interface - univalue - ) - add_test(NAME univalue_object_test - COMMAND object - ) endif() diff --git a/src/wallet/CMakeLists.txt b/src/wallet/CMakeLists.txt index 9bd1706207..c69e7ed2bf 100644 --- a/src/wallet/CMakeLists.txt +++ b/src/wallet/CMakeLists.txt @@ -3,31 +3,48 @@ # file COPYING or https://opensource.org/license/mit/. # Wallet functionality used by bitcoind and bitcoin-wallet executables. + add_library(firo_wallet STATIC EXCLUDE_FROM_ALL - authhelper.cpp - bip39.cpp - crypter.cpp - db.cpp - lelantusjoinsplitbuilder.cpp - mnemoniccontainer.cpp - rpcdump.cpp - rpcwallet.cpp - sigmaspendbuilder.cpp - txbuilder.cpp - wallet.cpp - walletdb.cpp - walletexcept.cpp + ../activemasternode.cpp + ../masternode-sync.cpp + ../sigma.cpp + ../lelantus.cpp + ../hdmint/hdmint.cpp + ../hdmint/mintpool.cpp + ../hdmint/wallet.cpp + ../hdmint/tracker.cpp + ../spark/state.cpp + ../spark/sparkwallet.cpp + ../spark/primitives.cpp + ../policy/rbf.cpp + ../bip47/account.cpp + ../bip47/paymentchannel.cpp + ../bip47/bip47utils.cpp + ../bip47/paymentcode.cpp + ../bip47/secretpoint.cpp + ../primitives/mint_spend.cpp + crypter.cpp + bip39.cpp + mnemoniccontainer.cpp + db.cpp + rpcdump.cpp + rpcwallet.cpp + sigmaspendbuilder.cpp + txbuilder.cpp + lelantusjoinsplitbuilder.cpp + walletexcept.cpp + wallet.cpp + walletdb.cpp + authhelper.cpp ) - target_link_libraries(firo_wallet - PRIVATE + PUBLIC core_interface - bitcoin_common + bitcoin_util univalue - Boost::headers secp256k1 + Boost::headers leveldb - $ ) # Firo only supports BDB for wallet storage. diff --git a/src/wallet/test/CMakeLists.txt b/src/wallet/test/CMakeLists.txt new file mode 100644 index 0000000000..32c0ba9226 --- /dev/null +++ b/src/wallet/test/CMakeLists.txt @@ -0,0 +1,20 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +# Do not use generator expressions in test sources because the +# SOURCES property is processed to gather test suite macros. + +target_sources(test_bitcoin + PRIVATE + accounting_tests.cpp + crypto_tests.cpp + lelantus_tests.cpp + mnemonic_tests.cpp + sigma_tests.cpp + spark_wallet_tests.cpp + txbuilder_tests.cpp + wallet_test_fixture.cpp + wallet_tests.cpp +) +target_link_libraries(test_bitcoin firo_wallet) diff --git a/src/wallet/test/spark_tests.cpp b/src/wallet/test/spark_wallet_tests.cpp similarity index 99% rename from src/wallet/test/spark_tests.cpp rename to src/wallet/test/spark_wallet_tests.cpp index 7ed925fb2d..bd9bd8c297 100644 --- a/src/wallet/test/spark_tests.cpp +++ b/src/wallet/test/spark_wallet_tests.cpp @@ -37,7 +37,7 @@ void ExtractSpend(CTransaction const &tx, } } -BOOST_FIXTURE_TEST_SUITE(spark_tests, SparkTestingSetup) +BOOST_FIXTURE_TEST_SUITE(spark_wallet_tests, SparkTestingSetup) BOOST_AUTO_TEST_CASE(create_mint_recipient) { From 4f5b053aadff35f53b49448d8728c8f245abe811 Mon Sep 17 00:00:00 2001 From: AlefLm Date: Sat, 22 Feb 2025 08:19:28 +0000 Subject: [PATCH 19/19] Qt: CMake GUI compilation support (Ubuntu) --- CMakeLists.txt | 4 +- cmake/module/AddBoostIfNeeded.cmake | 6 +- cmake/module/FindQt.cmake | 119 ++++++++ cmake/module/InstallBinaryComponent.cmake | 26 ++ depends/packages/dbus.mk | 2 +- depends/packages/expat.mk | 2 +- depends/packages/fontconfig.mk | 2 +- depends/packages/freetype.mk | 2 +- depends/packages/libICE.mk | 2 +- depends/packages/libSM.mk | 2 +- depends/packages/libX11.mk | 2 +- depends/packages/libXext.mk | 2 +- depends/packages/libxcb.mk | 2 +- depends/packages/libxcb_util_image.mk | 2 +- depends/packages/libxcb_util_keysyms.mk | 2 +- depends/packages/libxcb_util_render.mk | 2 +- depends/packages/libxcb_util_wm.mk | 2 +- depends/packages/libxkbcommon.mk | 2 +- depends/packages/qt.mk | 5 +- depends/packages/xtrans.mk | 2 +- depends/toolchain.cmake.in | 3 +- src/CMakeLists.txt | 3 +- src/qt/CMakeLists.txt | 329 ++++++++++++++++++++++ src/qt/automintmodel.h | 1 - src/qt/bitcoin.cpp | 1 - src/qt/bitcoingui.cpp | 1 - src/qt/clientmodel.cpp | 2 +- src/qt/paymentserver.cpp | 1 - src/qt/recentrequeststablemodel.cpp | 2 +- src/qt/sendcoinsdialog.cpp | 1 - src/qt/splashscreen.cpp | 1 - src/qt/test/CMakeLists.txt | 54 ++++ src/qt/transactiondesc.cpp | 6 +- src/qt/transactiontablemodel.cpp | 2 +- src/qt/transactionview.cpp | 1 - src/qt/walletmodel.cpp | 1 - src/qt/walletview.cpp | 1 - 37 files changed, 562 insertions(+), 38 deletions(-) create mode 100644 cmake/module/InstallBinaryComponent.cmake create mode 100644 src/qt/CMakeLists.txt create mode 100644 src/qt/test/CMakeLists.txt diff --git a/CMakeLists.txt b/CMakeLists.txt index 14f1a3fa01..ca1170e83a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -159,7 +159,7 @@ endif() cmake_dependent_option(WITH_DBUS "Enable DBus support." ON "CMAKE_SYSTEM_NAME STREQUAL \"Linux\" AND BUILD_GUI" OFF) -cmake_dependent_option(BUILD_GUI_TESTS "Build test_bitcoin-qt executable." ON "BUILD_GUI;BUILD_TESTS" OFF) +cmake_dependent_option(BUILD_GUI_TESTS "Build test_firo-qt executable." ON "BUILD_GUI;BUILD_TESTS" OFF) if(BUILD_GUI) set(qt_components Core Gui Widgets LinguistTools) if(ENABLE_WALLET) @@ -745,7 +745,7 @@ message(" QR code (GUI) ....................... ${WITH_QRENCODE}") message(" DBus (GUI, Linux only) .............. ${WITH_DBUS}") message("Tests:") message(" test_bitcoin ........................ ${BUILD_TESTS}") -message(" test_bitcoin-qt ..................... ${BUILD_GUI_TESTS}") +message(" test_firo-qt ..................... ${BUILD_GUI_TESTS}") message(" bench_firo ....................... ${BUILD_BENCH}") message(" fuzz binary ......................... ${BUILD_FUZZ_BINARY}") message("") diff --git a/cmake/module/AddBoostIfNeeded.cmake b/cmake/module/AddBoostIfNeeded.cmake index 575c59a7f6..370207c0c2 100644 --- a/cmake/module/AddBoostIfNeeded.cmake +++ b/cmake/module/AddBoostIfNeeded.cmake @@ -26,7 +26,11 @@ function(add_boost_if_needed) cmake_policy(SET CMP0167 OLD) endif() set(Boost_NO_BOOST_CMAKE OFF) - find_package(Boost 1.81.0 REQUIRED COMPONENTS atomic chrono filesystem program_options system thread) + set(_boost_components atomic chrono filesystem program_options system thread) + if(BUILD_TESTS) + list(APPEND _boost_components unit_test_framework) + endif() + find_package(Boost 1.81.0 REQUIRED COMPONENTS ${_boost_components}) include(CheckCXXSourceCompiles) set(CMAKE_REQUIRED_INCLUDES ${Boost_INCLUDE_DIRS}) diff --git a/cmake/module/FindQt.cmake b/cmake/module/FindQt.cmake index 2e43294a99..c150b341a0 100644 --- a/cmake/module/FindQt.cmake +++ b/cmake/module/FindQt.cmake @@ -64,3 +64,122 @@ find_package_handle_standard_args(Qt foreach(component IN LISTS Qt_FIND_COMPONENTS ITEMS "") mark_as_advanced(Qt${Qt_FIND_VERSION_MAJOR}${component}_DIR) endforeach() + +if(CMAKE_SYSTEM_NAME STREQUAL "Linux") + # Prioritize finding static libraries + set(_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES}) + set(CMAKE_FIND_LIBRARY_SUFFIXES .a ${_CMAKE_FIND_LIBRARY_SUFFIXES}) + + find_library(LIB_QTLIBPNG NAMES qtlibpng REQUIRED) + message(STATUS "Found Qt5 dependency: qtlibpng : ${LIB_QTLIBPNG}") + + find_library(LIB_FONTCONFIG NAMES fontconfig REQUIRED) + message(STATUS "Found Qt5 dependency: fontconfig : ${LIB_FONTCONFIG}") + + find_library(LIB_EXPAT NAMES expat REQUIRED) + message(STATUS "Found Qt5 dependency: expat : ${LIB_EXPAT}") + + find_library(LIB_FREETYPE NAMES freetype REQUIRED) + message(STATUS "Found Qt5 dependency: freetype : ${LIB_FREETYPE}") + + find_library(LIB_QTHARFBUZZ NAMES qtharfbuzz REQUIRED) + message(STATUS "Found Qt5 dependency: qtharfbuzz : ${LIB_QTHARFBUZZ}") + + find_library(LIB_QTPCR2 NAMES qtpcre2 REQUIRED) + message(STATUS "Found Qt5 dependency: qtpcre2 : ${LIB_QTPCR2}") + + find_library(LIB_XCB_EWMH NAMES xcb-ewmh REQUIRED) + message(STATUS "Found Qt5 dependency: xcb-ewmh : ${LIB_XCB_EWMH}") + + find_library(LIB_XCB_ICCCM NAMES xcb-icccm REQUIRED) + message(STATUS "Found Qt5 dependency: xcb-icccm : ${LIB_XCB_ICCCM}") + + find_library(LIB_XCB_IMAGE NAMES xcb-image REQUIRED) + message(STATUS "Found Qt5 dependency: xcb-image : ${LIB_XCB_IMAGE}") + + find_library(LIB_XCB_KEYSYMS NAMES xcb-keysyms REQUIRED) + message(STATUS "Found Qt5 dependency: xcb-keysyms : ${LIB_XCB_KEYSYMS}") + + find_library(LIB_XCB_RANDR NAMES xcb-randr REQUIRED) + message(STATUS "Found Qt5 dependency: xcb-randr : ${LIB_XCB_RANDR}") + + find_library(LIB_XCB_RENDER_UTIL NAMES xcb-render-util REQUIRED) + message(STATUS "Found Qt5 dependency: xcb-render-util : ${LIB_XCB_RENDER_UTIL}") + + find_library(LIB_XCB_RENDER NAMES xcb-render REQUIRED) + message(STATUS "Found Qt5 dependency: xcb-render : ${LIB_XCB_RENDER}") + + find_library(LIB_XCB_SHAPE NAMES xcb-shape REQUIRED) + message(STATUS "Found Qt5 dependency: xcb-shape : ${LIB_XCB_SHAPE}") + + find_library(LIB_XCB_SHM NAMES xcb-shm REQUIRED) + message(STATUS "Found Qt5 dependency: xcb-shm : ${LIB_XCB_SHM}") + + find_library(LIB_XCB_SYNC NAMES xcb-sync REQUIRED) + message(STATUS "Found Qt5 dependency: xcb-sync : ${LIB_XCB_SYNC}") + + find_library(LIB_XCB_UTIL NAMES xcb-util REQUIRED) + message(STATUS "Found Qt5 dependency: xcb-util : ${LIB_XCB_UTIL}") + + find_library(LIB_XCB_XFIXES NAMES xcb-xfixes REQUIRED) + message(STATUS "Found Qt5 dependency: xcb-xfixes : ${LIB_XCB_XFIXES}") + + find_library(LIB_XCB_XINERAMA NAMES xcb-xinerama REQUIRED) + message(STATUS "Found Qt5 dependency: xcb-xinerama : ${LIB_XCB_XINERAMA}") + + find_library(LIB_XCB_XKB NAMES xcb-xkb REQUIRED) + message(STATUS "Found Qt5 dependency: xcb-xkb : ${LIB_XCB_XKB}") + + find_library(LIB_XCB NAMES xcb REQUIRED) + message(STATUS "Found Qt5 dependency: xcb : ${LIB_XCB}") + + find_library(LIB_XKBCOMMON_X11 NAMES xkbcommon-x11 REQUIRED) + message(STATUS "Found Qt5 dependency: xkbcommon-x11 : ${LIB_XKBCOMMON_X11}") + + find_library(LIB_XKBCOMMON NAMES xkbcommon REQUIRED) + message(STATUS "Found Qt5 dependency: xkbcommon : ${LIB_XKBCOMMON}") + + find_library(LIB_XAU NAMES Xau REQUIRED) + message(STATUS "Found Qt5 dependency: Xau : ${LIB_XAU}") + + find_library(LIB_Z NAMES z REQUIRED) + message(STATUS "Found Qt5 dependency: z : ${LIB_Z}") + + # Qt5 dependencies libraries, order is important, should be last + add_library(Qt5_Dependencies + INTERFACE + ) + target_link_libraries(Qt5_Dependencies + INTERFACE + ${LIB_QTLIBPNG} + ${LIB_FONTCONFIG} + ${LIB_EXPAT} + ${LIB_FREETYPE} + ${LIB_QTHARFBUZZ} + ${LIB_QTPCR2} + ${LIB_XCB_EWMH} + ${LIB_XCB_ICCCM} + ${LIB_XCB_IMAGE} + ${LIB_XCB_KEYSYMS} + ${LIB_XCB_RANDR} + ${LIB_XCB_RENDER_UTIL} + ${LIB_XCB_RENDER} + ${LIB_XCB_SHAPE} + ${LIB_XCB_SHM} + ${LIB_XCB_SYNC} + ${LIB_XCB_UTIL} + ${LIB_XCB_XFIXES} + ${LIB_XCB_XINERAMA} + ${LIB_XCB_XKB} + ${LIB_XCB} + ${LIB_XKBCOMMON_X11} + ${LIB_XKBCOMMON} + ${LIB_XAU} + ${LIB_Z} + ) + + add_library(Qt5::Dependencies ALIAS Qt5_Dependencies) + + # Restore CMAKE_FIND_LIBRARY_SUFFIXES state. + set(CMAKE_FIND_LIBRARY_SUFFIXES ${_CMAKE_FIND_LIBRARY_SUFFIXES}) +endif() \ No newline at end of file diff --git a/cmake/module/InstallBinaryComponent.cmake b/cmake/module/InstallBinaryComponent.cmake new file mode 100644 index 0000000000..c7b2ed9ae6 --- /dev/null +++ b/cmake/module/InstallBinaryComponent.cmake @@ -0,0 +1,26 @@ +# Copyright (c) 2025-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +include_guard(GLOBAL) +include(GNUInstallDirs) + +function(install_binary_component component) + cmake_parse_arguments(PARSE_ARGV 1 + IC # prefix + "HAS_MANPAGE" # options + "" # one_value_keywords + "" # multi_value_keywords + ) + set(target_name ${component}) + install(TARGETS ${target_name} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + COMPONENT ${component} + ) + if(INSTALL_MAN AND IC_HAS_MANPAGE) + install(FILES ${PROJECT_SOURCE_DIR}/doc/man/${target_name}.1 + DESTINATION ${CMAKE_INSTALL_MANDIR}/man1 + COMPONENT ${component} + ) + endif() +endfunction() diff --git a/depends/packages/dbus.mk b/depends/packages/dbus.mk index 90ddcb923f..21483407f5 100644 --- a/depends/packages/dbus.mk +++ b/depends/packages/dbus.mk @@ -6,7 +6,7 @@ $(package)_sha256_hash=23238f70353e38ce5ca183ebc9525c0d97ac00ef640ad29cf794782af $(package)_dependencies=expat define $(package)_set_vars - $(package)_config_opts=--disable-tests --disable-doxygen-docs --disable-xml-docs --disable-static --without-x + $(package)_config_opts=--disable-tests --disable-doxygen-docs --disable-xml-docs --without-x endef define $(package)_config_cmds diff --git a/depends/packages/expat.mk b/depends/packages/expat.mk index 08804dae55..03c3b67d9c 100644 --- a/depends/packages/expat.mk +++ b/depends/packages/expat.mk @@ -5,7 +5,7 @@ $(package)_file_name=$(package)-$($(package)_version).tar.bz2 $(package)_sha256_hash=aff584e5a2f759dcfc6d48671e9529f6afe1e30b0cd6a4cec200cbe3f793de67 define $(package)_set_vars -$(package)_config_opts=--disable-static +$(package)_config_opts= endef define $(package)_config_cmds diff --git a/depends/packages/fontconfig.mk b/depends/packages/fontconfig.mk index 128599ba77..854c13d308 100644 --- a/depends/packages/fontconfig.mk +++ b/depends/packages/fontconfig.mk @@ -6,7 +6,7 @@ $(package)_sha256_hash=b449a3e10c47e1d1c7a6ec6e2016cca73d3bd68fbbd4f0ae5cc6b573f $(package)_dependencies=freetype expat define $(package)_set_vars - $(package)_config_opts=--disable-docs --disable-static --disable-libxml2 --disable-iconv + $(package)_config_opts=--disable-docs --enable-static --disable-libxml2 --disable-iconv $(package)_config_opts += --disable-dependency-tracking --enable-option-checking endef diff --git a/depends/packages/freetype.mk b/depends/packages/freetype.mk index a1584608e1..07d08cb0d3 100644 --- a/depends/packages/freetype.mk +++ b/depends/packages/freetype.mk @@ -5,7 +5,7 @@ $(package)_file_name=$(package)-$($(package)_version).tar.bz2 $(package)_sha256_hash=3a3bb2c4e15ffb433f2032f50a5b5a92558206822e22bfe8cbe339af4aa82f88 define $(package)_set_vars - $(package)_config_opts=--without-zlib --without-png --without-harfbuzz --without-bzip2 --disable-static + $(package)_config_opts=--without-zlib --without-png --without-harfbuzz --without-bzip2 $(package)_config_opts += --enable-option-checking $(package)_config_opts_linux=--with-pic endef diff --git a/depends/packages/libICE.mk b/depends/packages/libICE.mk index fc60323b1c..73c7f79173 100644 --- a/depends/packages/libICE.mk +++ b/depends/packages/libICE.mk @@ -6,7 +6,7 @@ $(package)_sha256_hash=8f7032f2c1c64352b5423f6b48a8ebdc339cc63064af34d66a6c9aa79 $(package)_dependencies=xtrans xproto define $(package)_set_vars - $(package)_config_opts=--disable-static --disable-docs --disable-specs --without-xsltproc + $(package)_config_opts=--disable-docs --disable-specs --without-xsltproc $(package)_config_opts_linux=--with-pic endef diff --git a/depends/packages/libSM.mk b/depends/packages/libSM.mk index 0f9307ca76..014dbb43ca 100644 --- a/depends/packages/libSM.mk +++ b/depends/packages/libSM.mk @@ -6,7 +6,7 @@ $(package)_sha256_hash=0baca8c9f5d934450a70896c4ad38d06475521255ca63b717a6510fdb $(package)_dependencies=xtrans xproto libICE define $(package)_set_vars - $(package)_config_opts=--without-libuuid --without-xsltproc --disable-docs --disable-static + $(package)_config_opts=--without-libuuid --without-xsltproc --disable-docs $(package)_config_opts_linux=--with-pic endef diff --git a/depends/packages/libX11.mk b/depends/packages/libX11.mk index 178d592ee6..0898049f46 100644 --- a/depends/packages/libX11.mk +++ b/depends/packages/libX11.mk @@ -6,7 +6,7 @@ $(package)_sha256_hash=2aa027e837231d2eeea90f3a4afe19948a6eb4c8b2bec0241eba7dbc8 $(package)_dependencies=libxcb xtrans xextproto xproto define $(package)_set_vars -$(package)_config_opts=--disable-xkb --disable-static +$(package)_config_opts=--disable-xkb $(package)_config_opts_linux=--with-pic endef diff --git a/depends/packages/libXext.mk b/depends/packages/libXext.mk index 4db836066f..8157f86406 100644 --- a/depends/packages/libXext.mk +++ b/depends/packages/libXext.mk @@ -6,7 +6,7 @@ $(package)_sha256_hash=f829075bc646cdc085fa25d98d5885d83b1759ceb355933127c257e8e $(package)_dependencies=xproto xextproto libX11 libXau define $(package)_set_vars - $(package)_config_opts=--disable-static + $(package)_config_opts= endef define $(package)_config_cmds diff --git a/depends/packages/libxcb.mk b/depends/packages/libxcb.mk index 036eaf6560..5bbcab8437 100644 --- a/depends/packages/libxcb.mk +++ b/depends/packages/libxcb.mk @@ -7,7 +7,7 @@ $(package)_dependencies=xcb_proto libXau $(package)_patches = remove_pthread_stubs.patch define $(package)_set_vars -$(package)_config_opts=--disable-static --disable-devel-docs --without-doxygen --without-launchd +$(package)_config_opts=--disable-devel-docs --without-doxygen --without-launchd $(package)_config_opts += --disable-dependency-tracking --enable-option-checking # Disable unneeded extensions. # More info is available from: https://doc.qt.io/qt-5.15/linux-requirements.html diff --git a/depends/packages/libxcb_util_image.mk b/depends/packages/libxcb_util_image.mk index d12d67e8e8..70b31a3269 100644 --- a/depends/packages/libxcb_util_image.mk +++ b/depends/packages/libxcb_util_image.mk @@ -6,7 +6,7 @@ $(package)_sha256_hash=2db96a37d78831d643538dd1b595d7d712e04bdccf8896a5e18ce0f39 $(package)_dependencies=libxcb libxcb_util define $(package)_set_vars -$(package)_config_opts=--disable-static --disable-devel-docs --without-doxygen +$(package)_config_opts=--disable-devel-docs --without-doxygen $(package)_config_opts+= --disable-dependency-tracking --enable-option-checking endef diff --git a/depends/packages/libxcb_util_keysyms.mk b/depends/packages/libxcb_util_keysyms.mk index d4f72dedbe..e497b1462c 100644 --- a/depends/packages/libxcb_util_keysyms.mk +++ b/depends/packages/libxcb_util_keysyms.mk @@ -6,7 +6,7 @@ $(package)_sha256_hash=0ef8490ff1dede52b7de533158547f8b454b241aa3e4dcca369507f66 $(package)_dependencies=libxcb xproto define $(package)_set_vars -$(package)_config_opts=--disable-static --disable-devel-docs --without-doxygen +$(package)_config_opts=--disable-devel-docs --without-doxygen $(package)_config_opts += --disable-dependency-tracking --enable-option-checking endef diff --git a/depends/packages/libxcb_util_render.mk b/depends/packages/libxcb_util_render.mk index 28f1fb073c..6d97e3d2d6 100644 --- a/depends/packages/libxcb_util_render.mk +++ b/depends/packages/libxcb_util_render.mk @@ -6,7 +6,7 @@ $(package)_sha256_hash=c6e97e48fb1286d6394dddb1c1732f00227c70bd1bedb7d1acabefdd3 $(package)_dependencies=libxcb define $(package)_set_vars -$(package)_config_opts=--disable-static --disable-devel-docs --without-doxygen +$(package)_config_opts=--disable-devel-docs --without-doxygen $(package)_config_opts += --disable-dependency-tracking --enable-option-checking endef diff --git a/depends/packages/libxcb_util_wm.mk b/depends/packages/libxcb_util_wm.mk index 3b905ba4ec..41426dd655 100644 --- a/depends/packages/libxcb_util_wm.mk +++ b/depends/packages/libxcb_util_wm.mk @@ -6,7 +6,7 @@ $(package)_sha256_hash=28bf8179640eaa89276d2b0f1ce4285103d136be6c98262b6151aaee1 $(package)_dependencies=libxcb define $(package)_set_vars -$(package)_config_opts=--disable-static --disable-devel-docs --without-doxygen +$(package)_config_opts=--disable-devel-docs --without-doxygen $(package)_config_opts += --disable-dependency-tracking --enable-option-checking endef diff --git a/depends/packages/libxkbcommon.mk b/depends/packages/libxkbcommon.mk index bcdcf671f7..b8634e9aa5 100644 --- a/depends/packages/libxkbcommon.mk +++ b/depends/packages/libxkbcommon.mk @@ -11,7 +11,7 @@ $(package)_dependencies=libxcb # a different build system (Meson) define $(package)_set_vars $(package)_config_opts = --enable-option-checking --disable-dependency-tracking -$(package)_config_opts += --disable-static --disable-docs +$(package)_config_opts += --disable-docs $(package)_cflags += -Wno-error=array-bounds endef diff --git a/depends/packages/qt.mk b/depends/packages/qt.mk index 039d15bcb8..fa5ac5ad23 100644 --- a/depends/packages/qt.mk +++ b/depends/packages/qt.mk @@ -276,12 +276,11 @@ define $(package)_build_cmds endef define $(package)_stage_cmds - $(MAKE) -C qtbase/src INSTALL_ROOT=$($(package)_staging_dir) $(addsuffix -install_subtargets,$(addprefix sub-,$($(package)_qt_libs))) && \ - $(MAKE) -C qttools/src/linguist INSTALL_ROOT=$($(package)_staging_dir) $(addsuffix -install_subtargets,$(addprefix sub-,$($(package)_linguist_tools))) && \ + $(MAKE) -C qtbase INSTALL_ROOT=$($(package)_staging_dir) install && \ + $(MAKE) -C qttools INSTALL_ROOT=$($(package)_staging_dir) install && \ $(MAKE) -C qttranslations INSTALL_ROOT=$($(package)_staging_dir) install_subtargets endef define $(package)_postprocess_cmds - rm -rf native/mkspecs/ native/lib/ lib/cmake/ && \ rm -f lib/lib*.la endef diff --git a/depends/packages/xtrans.mk b/depends/packages/xtrans.mk index 99eefa6d5e..174be4cc28 100644 --- a/depends/packages/xtrans.mk +++ b/depends/packages/xtrans.mk @@ -6,7 +6,7 @@ $(package)_sha256_hash=054d4ee3efd52508c753e9f7bc655ef185a29bd2850dd9e2fc2ccc335 $(package)_dependencies= define $(package)_set_vars -$(package)_config_opts_linux=--with-pic --disable-static +$(package)_config_opts_linux=--with-pic endef define $(package)_config_cmds diff --git a/depends/toolchain.cmake.in b/depends/toolchain.cmake.in index f50baffe86..d4bf55ac5a 100644 --- a/depends/toolchain.cmake.in +++ b/depends/toolchain.cmake.in @@ -82,12 +82,13 @@ set(CMAKE_OBJDUMP "@OBJDUMP@") set(CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH OFF) set(CMAKE_FIND_ROOT_PATH "@depends_prefix@") -list(APPEND CMAKE_PREFIX_PATH "${CMAKE_FIND_ROOT_PATH}/lib/") +list(APPEND CMAKE_PREFIX_PATH "${CMAKE_FIND_ROOT_PATH};${CMAKE_FIND_ROOT_PATH}/lib/") set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) set(QT_TRANSLATIONS_DIR "@depends_prefix@/translations") +set(Qt5_DIR "${CMAKE_FIND_ROOT_PATH}/lib/cmake/Qt5" CACHE PATH "Path to Qt5 CMake configuration files" FORCE) if(CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND NOT CMAKE_HOST_APPLE) # The find_package(Qt ...) function internally uses find_library() diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index b59f55db9a..834227a736 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -247,13 +247,14 @@ target_link_libraries(bitcoin_common $<$:ws2_32> ) +include(InstallBinaryComponent) set(installable_targets) if(ENABLE_WALLET) add_subdirectory(wallet) endif() -# P2P and RPC server functionality used by `bitcoind` and `bitcoin-qt` executables. +# P2P and RPC server functionality used by `bitcoind` and `firo-qt` executables. add_library(firo_node STATIC EXCLUDE_FROM_ALL addrdb.cpp addrman.cpp diff --git a/src/qt/CMakeLists.txt b/src/qt/CMakeLists.txt new file mode 100644 index 0000000000..be6724581c --- /dev/null +++ b/src/qt/CMakeLists.txt @@ -0,0 +1,329 @@ +# Copyright (c) 2023-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +if(CMAKE_SYSTEM_NAME STREQUAL "Darwin") + enable_language(OBJCXX) + set(CMAKE_OBJCXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}") + set(CMAKE_OBJCXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}") + set(CMAKE_OBJCXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}") + set(CMAKE_OBJCXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL}") + string(APPEND CMAKE_OBJCXX_COMPILE_OBJECT " ${APPEND_CPPFLAGS} ${APPEND_CXXFLAGS}") +endif() + +get_target_property(qt_lib_type Qt5::Core TYPE) + +function(import_plugins target) + if(qt_lib_type STREQUAL "STATIC_LIBRARY") + set(plugins Qt5::QMinimalIntegrationPlugin) + if(CMAKE_SYSTEM_NAME STREQUAL "Linux") + list(APPEND plugins Qt5::QXcbIntegrationPlugin) + elseif(WIN32) + list(APPEND plugins Qt5::QWindowsIntegrationPlugin Qt5::QWindowsVistaStylePlugin) + elseif(APPLE) + list(APPEND plugins Qt5::QCocoaIntegrationPlugin Qt5::QMacStylePlugin) + endif() + qt5_import_plugins(${target} + INCLUDE ${plugins} + EXCLUDE_BY_TYPE imageformats iconengines + ) + endif() +endfunction() + +# For Qt-specific commands and variables, please consult: +# - https://cmake.org/cmake/help/latest/manual/cmake-qt.7.html +# - https://doc.qt.io/qt-5/cmake-manual.html + +set(CMAKE_AUTOMOC ON) +set(CMAKE_AUTOMOC_MOC_OPTIONS "-p${CMAKE_CURRENT_SOURCE_DIR}") +set(CMAKE_AUTORCC ON) +set(CMAKE_AUTOUIC ON) +set(CMAKE_AUTOUIC_SEARCH_PATHS forms) + +# TODO: The file(GLOB ...) command should be replaced with an explicit +# file list. Such a change must be synced with the corresponding change +# to https://github.com/bitcoin-core/bitcoin-maintainer-tools/blob/main/update-translations.py +file(GLOB ts_files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} locale/*.ts) +set_source_files_properties(${ts_files} PROPERTIES OUTPUT_LOCATION ${CMAKE_CURRENT_BINARY_DIR}/locale) +qt5_add_translation(qm_files ${ts_files}) + +configure_file(bitcoin_locale.qrc bitcoin_locale.qrc USE_SOURCE_PERMISSIONS COPYONLY) + +# The firoqt sources have to include headers in +# order to parse them to collect translatable strings. +add_library(firoqt STATIC EXCLUDE_FROM_ALL + $<$:macdockiconhandler.h> + $<$:macdockiconhandler.mm> + $<$:macnotificationhandler.h> + $<$:macnotificationhandler.mm> + $<$:winshutdownmonitor.cpp> + $<$:winshutdownmonitor.h> + bitcoin.qrc + ${CMAKE_CURRENT_BINARY_DIR}/bitcoin_locale.qrc + addressbookpage.cpp + addresstablemodel.cpp + askpassphrasedialog.cpp + automintdialog.cpp + automintmodel.cpp + automintnotification.cpp + bantablemodel.cpp + bitcoinaddressvalidator.cpp + bitcoinamountfield.cpp + bitcoingui.cpp + bitcoinstrings.cpp + bitcoinunits.cpp + cancelpassworddialog.cpp + clientmodel.cpp + coincontroldialog.cpp + coincontroltreewidget.cpp + csvmodelwriter.cpp + editaddressdialog.cpp + guiutil.cpp + intro.cpp + lelantuscoincontroldialog.cpp + lelantusdialog.cpp + lelantusmodel.cpp + manualmintdialog.cpp + masternodelist.cpp + modaloverlay.cpp + networkstyle.cpp + notificator.cpp + notifymnemonic.cpp + openuridialog.cpp + optionsdialog.cpp + optionsmodel.cpp + overviewpage.cpp + paymentserver.cpp + pcodemodel.cpp + peertablemodel.cpp + platformstyle.cpp + qvalidatedlineedit.cpp + qvaluecombobox.cpp + receivecoinsdialog.cpp + receiverequestdialog.cpp + recentrequeststablemodel.cpp + recover.cpp + rpcconsole.cpp + sendcoinsdialog.cpp + sendcoinsentry.cpp + sendtopcodedialog.cpp + signverifymessagedialog.cpp + sparkmodel.cpp + splashscreen.cpp + trafficgraphwidget.cpp + transactiondesc.cpp + transactiondescdialog.cpp + transactionfilterproxy.cpp + transactionrecord.cpp + transactiontablemodel.cpp + transactionview.cpp + utilitydialog.cpp + walletframe.cpp + walletmodel.cpp + walletmodeltransaction.cpp + walletview.cpp + winshutdownmonitor.cpp +) +target_compile_definitions(firoqt + PUBLIC + QT_NO_KEYWORDS + QT_USE_QSTRINGBUILDER +) +target_include_directories(firoqt + PUBLIC + $ + $ +) +set_property(SOURCE macnotificationhandler.mm + # Ignore warnings "'NSUserNotificationCenter' is deprecated: first deprecated in macOS 11.0". + APPEND PROPERTY COMPILE_OPTIONS -Wno-deprecated-declarations +) +# Add this to skip specific files from UIC processing +set_source_files_properties( + clientmodel.cpp + clientmodel.h + PROPERTIES SKIP_AUTOUIC ON +) +target_link_libraries(firoqt + PUBLIC + leveldb + secp256k1 + univalue + secp256k1pp + Qt5::Widgets + Qt5::Network + PRIVATE + core_interface + firo_cli + Boost::headers + $ + $<$:-framework\ AppKit> + $<$:shlwapi> +) + +if(ENABLE_WALLET) + target_sources(firoqt + PRIVATE + addressbookpage.cpp + automintdialog.cpp + automintnotification.cpp + addresstablemodel.cpp + askpassphrasedialog.cpp + coincontroldialog.cpp + coincontroltreewidget.cpp + editaddressdialog.cpp + manualmintdialog.cpp + openuridialog.cpp + overviewpage.cpp + pcodemodel.cpp + paymentserver.cpp + receivecoinsdialog.cpp + receiverequestdialog.cpp + recentrequeststablemodel.cpp + sendcoinsdialog.cpp + sendcoinsentry.cpp + sendtopcodedialog.cpp + signverifymessagedialog.cpp + transactiondesc.cpp + transactiondescdialog.cpp + transactionfilterproxy.cpp + transactionrecord.cpp + transactiontablemodel.cpp + transactionview.cpp + walletframe.cpp + walletmodel.cpp + walletmodeltransaction.cpp + masternodelist.cpp + walletview.cpp + lelantusmodel.cpp + lelantusdialog.cpp + lelantuscoincontroldialog.cpp + automintmodel.cpp + sparkmodel.cpp + ) + target_link_libraries(firoqt + PRIVATE + firo_wallet + Qt5::Network + ) +endif() + +if(WITH_DBUS) + target_link_libraries(firoqt PRIVATE Qt5::DBus) +endif() + +if(qt_lib_type STREQUAL "STATIC_LIBRARY") + # We want to define static plugins to link ourselves, thus preventing + # automatic linking against a "sane" set of default static plugins. + qt5_import_plugins(firoqt + EXCLUDE_BY_TYPE bearer iconengines imageformats platforms styles + ) +endif() + +add_executable(firo-qt + bitcoin.cpp +) + +add_windows_resources(firo-qt res/bitcoin-qt-res.rc) +target_link_libraries(firo-qt + PUBLIC + core_interface + Qt5::Widgets + firoqt + firo_node + Qt5::Dependencies + ) + +import_plugins(firo-qt) +install_binary_component(firo-qt HAS_MANPAGE) +if(WIN32) + set_target_properties(firo-qt PROPERTIES WIN32_EXECUTABLE TRUE) +endif() + +if(WITH_MULTIPROCESS) + add_executable(bitcoin-gui + main.cpp + ) + target_link_libraries(bitcoin-gui + core_interface + firoqt + firo_node + bitcoin_ipc + ) + import_plugins(bitcoin-gui) + install_binary_component(bitcoin-gui) + if(WIN32) + set_target_properties(bitcoin-gui PROPERTIES WIN32_EXECUTABLE TRUE) + endif() +endif() + +if(BUILD_GUI_TESTS) + add_subdirectory(test) +endif() + + +# Gets sources to be parsed to gather translatable strings. +function(get_translatable_sources var) + set(result) + set(targets) + foreach(dir IN ITEMS ${ARGN}) + get_directory_property(dir_targets DIRECTORY ${PROJECT_SOURCE_DIR}/${dir} BUILDSYSTEM_TARGETS) + list(APPEND targets ${dir_targets}) + endforeach() + foreach(target IN LISTS targets) + get_target_property(target_sources ${target} SOURCES) + if(target_sources) + foreach(source IN LISTS target_sources) + # Get an expression from the generator expression, if any. + if(source MATCHES ":([^>]+)>$") + set(source ${CMAKE_MATCH_1}) + endif() + cmake_path(GET source EXTENSION LAST_ONLY ext) + if(ext STREQUAL ".qrc") + continue() + endif() + if(NOT IS_ABSOLUTE source) + get_target_property(target_source_dir ${target} SOURCE_DIR) + cmake_path(APPEND target_source_dir ${source} OUTPUT_VARIABLE source) + endif() + get_property(is_generated + SOURCE ${source} TARGET_DIRECTORY ${target} + PROPERTY GENERATED + ) + if(NOT is_generated) + list(APPEND result ${source}) + endif() + endforeach() + endif() + endforeach() + set(${var} ${result} PARENT_SCOPE) +endfunction() + +find_program(XGETTEXT_EXECUTABLE xgettext) +find_program(SED_EXECUTABLE sed) +if(NOT XGETTEXT_EXECUTABLE) + add_custom_target(translate + COMMAND ${CMAKE_COMMAND} -E echo "Error: GNU gettext-tools not found" + ) +elseif(NOT SED_EXECUTABLE) + add_custom_target(translate + COMMAND ${CMAKE_COMMAND} -E echo "Error: GNU sed not found" + ) +else() + set(translatable_sources_directories src src/qt src/util) + if(ENABLE_WALLET) + list(APPEND translatable_sources_directories src/wallet) + endif() + get_translatable_sources(translatable_sources ${translatable_sources_directories}) + get_translatable_sources(qt_translatable_sources src/qt) + file(GLOB ui_files ${CMAKE_CURRENT_SOURCE_DIR}/forms/*.ui) + add_custom_target(translate + COMMAND ${CMAKE_COMMAND} -E env XGETTEXT=${XGETTEXT_EXECUTABLE} COPYRIGHT_HOLDERS=${COPYRIGHT_HOLDERS} ${Python3_EXECUTABLE} ${PROJECT_SOURCE_DIR}/share/qt/extract_strings_qt.py ${translatable_sources} + COMMAND Qt5::lupdate -no-obsolete -I ${PROJECT_SOURCE_DIR}/src -locations relative ${CMAKE_CURRENT_SOURCE_DIR}/bitcoinstrings.cpp ${ui_files} ${qt_translatable_sources} -ts ${CMAKE_CURRENT_SOURCE_DIR}/locale/bitcoin_en.ts + COMMAND Qt5::lconvert -drop-translations -o ${CMAKE_CURRENT_SOURCE_DIR}/locale/bitcoin_en.xlf -i ${CMAKE_CURRENT_SOURCE_DIR}/locale/bitcoin_en.ts + COMMAND ${SED_EXECUTABLE} -i.old -e "s|source-language=\"en\" target-language=\"en\"|source-language=\"en\"|" -e "/<\\/target>/d" ${CMAKE_CURRENT_SOURCE_DIR}/locale/bitcoin_en.xlf + COMMAND ${CMAKE_COMMAND} -E rm ${CMAKE_CURRENT_SOURCE_DIR}/locale/bitcoin_en.xlf.old + WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/src + VERBATIM + ) +endif() diff --git a/src/qt/automintmodel.h b/src/qt/automintmodel.h index 5b43de462b..3799d8b0c2 100644 --- a/src/qt/automintmodel.h +++ b/src/qt/automintmodel.h @@ -2,7 +2,6 @@ #define FIRO_QT_AUTOMINTMODEL_H #include "../amount.h" -#include "../ui_interface.h" #include "../uint256.h" #include "../validation.h" diff --git a/src/qt/bitcoin.cpp b/src/qt/bitcoin.cpp index 7d387893e4..199b5b52d9 100644 --- a/src/qt/bitcoin.cpp +++ b/src/qt/bitcoin.cpp @@ -31,7 +31,6 @@ #include "rpc/server.h" #include "scheduler.h" #include "stacktraces.h" -#include "ui_interface.h" #include "util.h" #include "warnings.h" diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp index 47babf2ab7..03dd5a564a 100644 --- a/src/qt/bitcoingui.cpp +++ b/src/qt/bitcoingui.cpp @@ -34,7 +34,6 @@ #include "chainparams.h" #include "init.h" #include "lelantus.h" -#include "ui_interface.h" #include "util.h" #include "evo/deterministicmns.h" diff --git a/src/qt/clientmodel.cpp b/src/qt/clientmodel.cpp index 023c012a36..f143d03302 100644 --- a/src/qt/clientmodel.cpp +++ b/src/qt/clientmodel.cpp @@ -15,7 +15,7 @@ #include "validation.h" #include "net.h" #include "txmempool.h" -#include "ui_interface.h" +#include "../ui_interface.h" #include "util.h" #include diff --git a/src/qt/paymentserver.cpp b/src/qt/paymentserver.cpp index 9bbd3e465b..724ffb0c0c 100644 --- a/src/qt/paymentserver.cpp +++ b/src/qt/paymentserver.cpp @@ -11,7 +11,6 @@ #include "base58.h" #include "chainparams.h" #include "policy/policy.h" -#include "ui_interface.h" #include "util.h" #include "wallet/wallet.h" diff --git a/src/qt/recentrequeststablemodel.cpp b/src/qt/recentrequeststablemodel.cpp index 0a4308f4e3..6e724ad15b 100644 --- a/src/qt/recentrequeststablemodel.cpp +++ b/src/qt/recentrequeststablemodel.cpp @@ -137,7 +137,7 @@ void RecentRequestsTableModel::updateAmountColumnTitle() /** Gets title for amount column including current display unit if optionsModel reference available. */ QString RecentRequestsTableModel::getAmountTitle() { - return (this->walletModel->getOptionsModel() != NULL) ? tr("Requested") + " ("+BitcoinUnits::name(this->walletModel->getOptionsModel()->getDisplayUnit()) + ")" : ""; + return (this->walletModel->getOptionsModel() != NULL) ? tr("Requested") + " ("+BitcoinUnits::name(this->walletModel->getOptionsModel()->getDisplayUnit()) + ")" : QString(""); } QModelIndex RecentRequestsTableModel::index(int row, int column, const QModelIndex &parent) const diff --git a/src/qt/sendcoinsdialog.cpp b/src/qt/sendcoinsdialog.cpp index fd3d658217..9ad781d229 100644 --- a/src/qt/sendcoinsdialog.cpp +++ b/src/qt/sendcoinsdialog.cpp @@ -21,7 +21,6 @@ #include "lelantus.h" #include "wallet/coincontrol.h" #include "validation.h" // mempool and minRelayTxFee -#include "ui_interface.h" #include "txmempool.h" #include "wallet/wallet.h" #include "sendtopcodedialog.h" diff --git a/src/qt/splashscreen.cpp b/src/qt/splashscreen.cpp index 16a6ae820f..e6ab4f4a6d 100644 --- a/src/qt/splashscreen.cpp +++ b/src/qt/splashscreen.cpp @@ -13,7 +13,6 @@ #include "clientversion.h" #include "init.h" #include "util.h" -#include "ui_interface.h" #include "version.h" #ifdef ENABLE_WALLET diff --git a/src/qt/test/CMakeLists.txt b/src/qt/test/CMakeLists.txt new file mode 100644 index 0000000000..949c4c71f8 --- /dev/null +++ b/src/qt/test/CMakeLists.txt @@ -0,0 +1,54 @@ +# Copyright (c) 2024-present The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or https://opensource.org/license/mit/. + +set(CMAKE_AUTOMOC_MOC_OPTIONS "-p${CMAKE_CURRENT_SOURCE_DIR}") + +add_executable(test_firo-qt + compattests.cpp + rpcnestedtests.cpp + test_main.cpp + uritests.cpp + test_sendcoinsentry.cpp + ../../test/test_bitcoin.cpp + ../../test/testutil.cpp +) + +# Add this to skip specific files from UIC processing +set_source_files_properties( + ../../test/test_bitcoin.cpp + PROPERTIES SKIP_AUTOUIC ON +) + +target_link_libraries(test_firo-qt + core_interface + firoqt + firo_node + Boost::headers + Boost::unit_test_framework + Qt5::Test + Qt5::Dependencies +) + +import_plugins(test_firo-qt) + +if(ENABLE_WALLET) + target_sources(test_firo-qt + PRIVATE + ../../wallet/test/wallet_tests.cpp + ../../wallet/test/wallet_test_fixture.cpp + ) +endif() + +add_test(NAME test_firo-qt + COMMAND test_firo-qt +) +if(WIN32 AND VCPKG_TARGET_TRIPLET) + # On Windows, vcpkg configures Qt with `-opengl dynamic`, which makes + # the "minimal" platform plugin unusable due to internal Qt bugs. + set_tests_properties(test_firo-qt PROPERTIES + ENVIRONMENT "QT_QPA_PLATFORM=windows" + ) +endif() + +install_binary_component(test_firo-qt) diff --git a/src/qt/transactiondesc.cpp b/src/qt/transactiondesc.cpp index deaabaf85f..f3b54e4551 100644 --- a/src/qt/transactiondesc.cpp +++ b/src/qt/transactiondesc.cpp @@ -43,13 +43,13 @@ QString TransactionDesc::FormatTxStatus(const CWalletTx& wtx) else if (nDepth == 0) { if (wtx.InMempool()) { strTxStatus = "0/unconfirmed, in memory pool" + - (wtx.isAbandoned() ? ", "+tr("abandoned") : ""); + (wtx.isAbandoned() ? ", "+tr("abandoned") : QString("")); } else if (wtx.InStempool()) { strTxStatus = "0/unconfirmed, in dandelion stem pool"+ - (wtx.isAbandoned() ? ", "+tr("abandoned") : ""); + (wtx.isAbandoned() ? ", "+tr("abandoned") : QString("")); } else { strTxStatus = "0/unconfirmed, not in memory pool" + - (wtx.isAbandoned() ? ", "+tr("abandoned") : ""); + (wtx.isAbandoned() ? ", "+tr("abandoned") : QString("")); } } else if (nDepth < TransactionRecord::RecommendedNumConfirmations) diff --git a/src/qt/transactiontablemodel.cpp b/src/qt/transactiontablemodel.cpp index aa2f661e91..94fbeaedae 100644 --- a/src/qt/transactiontablemodel.cpp +++ b/src/qt/transactiontablemodel.cpp @@ -484,7 +484,7 @@ QString TransactionTableModel::formatTxToAddress(const TransactionRecord *wtx, b QString watchAddress; if (tooltip) { // Mark transactions involving watch-only addresses by adding " (watch-only)" - watchAddress = wtx->involvesWatchAddress ? QString(" (") + tr("watch-only") + QString(")") : ""; + watchAddress = wtx->involvesWatchAddress ? QString(" (") + tr("watch-only") + QString(")") : QString(""); } switch(wtx->type) diff --git a/src/qt/transactionview.cpp b/src/qt/transactionview.cpp index 9161af2a35..4829946d0b 100644 --- a/src/qt/transactionview.cpp +++ b/src/qt/transactionview.cpp @@ -18,7 +18,6 @@ #include "walletmodel.h" #include "pcodemodel.h" -#include "ui_interface.h" #include #include diff --git a/src/qt/walletmodel.cpp b/src/qt/walletmodel.cpp index c625cf4b77..9b947f7d80 100644 --- a/src/qt/walletmodel.cpp +++ b/src/qt/walletmodel.cpp @@ -20,7 +20,6 @@ #include "validation.h" #include "net.h" // for g_connman #include "sync.h" -#include "ui_interface.h" #include "util.h" // for GetBoolArg #include "wallet/wallet.h" #include "wallet/walletdb.h" // for BackupWallet diff --git a/src/qt/walletview.cpp b/src/qt/walletview.cpp index eb65f9fa6b..62047e8d36 100644 --- a/src/qt/walletview.cpp +++ b/src/qt/walletview.cpp @@ -24,7 +24,6 @@ #include "transactionview.h" #include "walletmodel.h" -#include "ui_interface.h" #include #include