2019-12-19 16:32:29 +01:00
AC_PREREQ([2.69])
2023-04-15 00:01:04 +02:00
define(_CLIENT_VERSION_MAJOR, 20)
2023-11-14 16:23:00 +01:00
define(_CLIENT_VERSION_MINOR, 1)
2022-04-15 21:00:14 +02:00
define(_CLIENT_VERSION_BUILD, 0)
2023-11-14 16:23:00 +01:00
define(_CLIENT_VERSION_RC, 0)
2018-07-12 11:01:10 +02:00
define(_CLIENT_VERSION_IS_RELEASE, false)
2023-01-12 22:13:43 +01:00
define(_COPYRIGHT_YEAR, 2023)
2016-02-04 13:41:58 +01:00
define(_COPYRIGHT_HOLDERS,[The %s developers])
2016-03-31 14:28:41 +02:00
define(_COPYRIGHT_HOLDERS_SUBSTITUTION,[[Dash Core]])
2020-11-20 15:42:01 +01:00
AC_INIT([Dash Core],m4_join([.], _CLIENT_VERSION_MAJOR, _CLIENT_VERSION_MINOR, _CLIENT_VERSION_BUILD)m4_if(_CLIENT_VERSION_RC, [0], [], [rc]_CLIENT_VERSION_RC),[https://github.com/dashpay/dash/issues],[dashcore],[https://dash.org/])
2017-08-09 02:19:06 +02:00
AC_CONFIG_SRCDIR([src/validation.cpp])
2022-08-02 18:34:58 +02:00
AC_CONFIG_HEADERS([src/config/bitcoin-config.h])
2014-09-14 01:09:25 +02:00
AC_CONFIG_AUX_DIR([build-aux])
AC_CONFIG_MACRO_DIR([build-aux/m4])
2014-10-14 03:59:59 +02:00
2020-03-09 16:33:08 +01:00
m4_ifndef([PKG_PROG_PKG_CONFIG], [AC_MSG_ERROR([PKG_PROG_PKG_CONFIG macro not found. Please install pkg-config and re-run autogen.sh])])
PKG_PROG_PKG_CONFIG
if test "x$PKG_CONFIG" = x; then
AC_MSG_ERROR([pkg-config not found])
fi
2017-09-15 13:54:36 +02:00
BITCOIN_DAEMON_NAME=dashd
BITCOIN_GUI_NAME=dash-qt
BITCOIN_CLI_NAME=dash-cli
BITCOIN_TX_NAME=dash-tx
2019-01-31 17:07:45 +01:00
BITCOIN_WALLET_TOOL_NAME=dash-wallet
2016-04-15 16:43:38 +02:00
2017-07-16 20:55:57 +02:00
dnl Unless the user specified ARFLAGS, force it to be cr
2022-06-16 12:14:04 +02:00
dnl This is also the default as-of libtool 2.4.7
2017-07-16 20:55:57 +02:00
AC_ARG_VAR(ARFLAGS, [Flags for the archiver, defaults to <cr> if not set])
if test "x${ARFLAGS+set}" != "xset"; then
ARFLAGS="cr"
fi
2013-05-28 01:55:01 +02:00
AC_CANONICAL_HOST
2014-10-14 03:59:59 +02:00
2015-03-19 15:15:08 +01:00
AH_TOP([#ifndef DASH_CONFIG_H])
AH_TOP([#define DASH_CONFIG_H])
AH_BOTTOM([#endif //DASH_CONFIG_H])
2013-05-28 01:55:01 +02:00
2014-11-06 02:30:59 +01:00
dnl Automake init set-up and checks
2020-03-11 16:31:13 +01:00
AM_INIT_AUTOMAKE([1.13 no-define subdir-objects foreign])
2013-05-28 01:55:01 +02:00
AM_MAINTAINER_MODE([enable])
dnl make the compilation flags quiet unless V=1 is used
2020-03-11 16:31:13 +01:00
AM_SILENT_RULES([yes])
2013-05-28 01:55:01 +02:00
2014-11-06 02:30:59 +01:00
dnl Compiler checks (here before libtool).
2013-09-08 22:30:24 +02:00
if test "x${CXXFLAGS+set}" = "xset"; then
CXXFLAGS_overridden=yes
else
CXXFLAGS_overridden=no
fi
2014-09-14 01:09:25 +02:00
AC_PROG_CXX
2013-09-08 22:30:24 +02:00
2014-11-06 02:30:59 +01:00
dnl By default, libtool for mingw refuses to link static libs into a dll for
dnl fear of mixing pic/non-pic objects, and import/export complications. Since
dnl we have those under control, re-enable that functionality.
case $host in
*mingw*)
lt_cv_deplibs_check_method="pass_all"
;;
esac
2020-04-11 07:17:04 +02:00
2021-12-11 23:14:17 +01:00
AC_ARG_ENABLE([c++20],
[AS_HELP_STRING([--enable-c++20],
[enable compilation in c++20 mode (disabled by default)])],
[use_cxx20=$enableval],
[use_cxx20=no])
dnl Require C++17 or C++20 compiler (no GNU extensions)
if test "x$use_cxx20" = xyes; then
AX_CXX_COMPILE_STDCXX([20], [noext], [mandatory])
else
AX_CXX_COMPILE_STDCXX([17], [noext], [mandatory])
fi
2020-04-11 07:17:04 +02:00
2016-09-09 08:57:08 +02:00
dnl Check if -latomic is required for <std::atomic>
CHECK_ATOMIC
2017-05-12 00:01:03 +02:00
dnl Unless the user specified OBJCXX, force it to be the same as CXX. This ensures
dnl that we get the same -std flags for both.
m4_ifdef([AC_PROG_OBJCXX],[
if test "x${OBJCXX+set}" = "x"; then
OBJCXX="${CXX}"
fi
AC_PROG_OBJCXX
])
2022-03-24 11:56:13 +01:00
dnl OpenBSD ships with 2.4.2
LT_PREREQ([2.4.2])
2014-11-06 02:30:59 +01:00
dnl Libtool init checks.
2022-02-23 15:17:09 +01:00
LT_INIT([pic-only win32-dll])
2013-05-28 01:55:01 +02:00
2014-11-06 02:30:59 +01:00
dnl Check/return PATH for base programs.
2014-09-14 01:09:25 +02:00
AC_PATH_TOOL(AR, ar)
AC_PATH_TOOL(RANLIB, ranlib)
AC_PATH_TOOL(STRIP, strip)
AC_PATH_TOOL(GCOV, gcov)
2020-08-08 14:36:45 +02:00
AC_PATH_TOOL(LLVM_COV, llvm-cov)
2014-09-14 01:09:25 +02:00
AC_PATH_PROG(LCOV, lcov)
2023-05-10 10:29:23 +02:00
dnl Python 3.8 is specified in .python-version and should be used if available, see doc/dependencies.md
AC_PATH_PROGS([PYTHON], [python3.8 python3.9 python3.10 python3.11 python3.12 python3 python])
2014-09-14 01:09:25 +02:00
AC_PATH_PROG(GENHTML, genhtml)
AC_PATH_PROG([GIT], [git])
AC_PATH_PROG(CCACHE,ccache)
AC_PATH_PROG(XGETTEXT,xgettext)
AC_PATH_PROG(HEXDUMP,hexdump)
2016-06-13 07:57:21 +02:00
AC_PATH_TOOL(OBJCOPY, objcopy)
2019-07-02 06:16:11 +02:00
AC_PATH_TOOL(DSYMUTIL, dsymutil)
2018-02-17 08:49:18 +01:00
AC_PATH_PROG(DOXYGEN, doxygen)
AM_CONDITIONAL([HAVE_DOXYGEN], [test -n "$DOXYGEN"])
2013-05-28 01:55:01 +02:00
2016-02-04 13:41:58 +01:00
AC_ARG_VAR(PYTHONPATH, Augments the default search path for python module files)
2013-11-29 16:50:11 +01:00
AC_ARG_ENABLE([wallet],
2015-10-02 07:44:36 +02:00
[AS_HELP_STRING([--disable-wallet],
[disable wallet (enabled by default)])],
2013-11-29 16:50:11 +01:00
[enable_wallet=$enableval],
2023-02-04 19:28:21 +01:00
[enable_wallet=auto])
2013-11-29 16:50:11 +01:00
2023-02-03 15:46:16 +01:00
AC_ARG_WITH([sqlite],
[AS_HELP_STRING([--with-sqlite=yes|no|auto],
[enable sqlite wallet support (default: auto, i.e., enabled if wallet is enabled and sqlite is found)])],
[use_sqlite=$withval],
[use_sqlite=auto])
2023-02-04 19:28:21 +01:00
AC_ARG_WITH([bdb],
[AS_HELP_STRING([--without-bdb],
[disable bdb wallet support (default is enabled if wallet is enabled)])],
[use_bdb=$withval],
[use_bdb=auto])
2020-09-05 16:36:47 +02:00
AC_ARG_ENABLE([ebpf],
[AS_HELP_STRING([--enable-ebpf],
[enable eBPF tracing (default is yes if sys/sdt.h is found)])],
[use_ebpf=$enableval],
[use_ebpf=yes])
2013-05-28 01:55:01 +02:00
AC_ARG_WITH([miniupnpc],
[AS_HELP_STRING([--with-miniupnpc],
[enable UPNP (default is yes if libminiupnpc is found)])],
[use_upnp=$withval],
[use_upnp=auto])
2022-02-26 13:19:13 +01:00
AC_ARG_WITH([natpmp],
[AS_HELP_STRING([--with-natpmp],
[enable NAT-PMP (default is yes if libnatpmp is found)])],
[use_natpmp=$withval],
[use_natpmp=auto])
2013-05-28 01:55:01 +02:00
AC_ARG_ENABLE(tests,
2015-10-02 07:44:36 +02:00
AS_HELP_STRING([--disable-tests],[do not compile tests (default is to compile)]),
2013-05-28 01:55:01 +02:00
[use_tests=$enableval],
[use_tests=yes])
2016-03-31 14:50:10 +02:00
AC_ARG_ENABLE(gui-tests,
AS_HELP_STRING([--disable-gui-tests],[do not compile GUI tests (default is to compile if GUI and tests enabled)]),
[use_gui_tests=$enableval],
[use_gui_tests=$use_tests])
Simple benchmarking framework
Benchmarking framework, loosely based on google's micro-benchmarking
library (https://github.com/google/benchmark)
Wny not use the Google Benchmark framework? Because adding Even More Dependencies
isn't worth it. If we get a dozen or three benchmarks and need nanosecond-accurate
timings of threaded code then switching to the full-blown Google Benchmark library
should be considered.
The benchmark framework is hard-coded to run each benchmark for one wall-clock second,
and then spits out .csv-format timing information to stdout. It is left as an
exercise for later (or maybe never) to add command-line arguments to specify which
benchmark(s) to run, how long to run them for, how to format results, etc etc etc.
Again, see the Google Benchmark framework for where that might end up.
See src/bench/MilliSleep.cpp for a sanity-test benchmark that just benchmarks
'sleep 100 milliseconds.'
To compile and run benchmarks:
cd src; make bench
Sample output:
Benchmark,count,min,max,average
Sleep100ms,10,0.101854,0.105059,0.103881
2015-09-24 19:13:38 +02:00
AC_ARG_ENABLE(bench,
2015-10-11 12:47:59 +02:00
AS_HELP_STRING([--disable-bench],[do not compile benchmarks (default is to compile)]),
Simple benchmarking framework
Benchmarking framework, loosely based on google's micro-benchmarking
library (https://github.com/google/benchmark)
Wny not use the Google Benchmark framework? Because adding Even More Dependencies
isn't worth it. If we get a dozen or three benchmarks and need nanosecond-accurate
timings of threaded code then switching to the full-blown Google Benchmark library
should be considered.
The benchmark framework is hard-coded to run each benchmark for one wall-clock second,
and then spits out .csv-format timing information to stdout. It is left as an
exercise for later (or maybe never) to add command-line arguments to specify which
benchmark(s) to run, how long to run them for, how to format results, etc etc etc.
Again, see the Google Benchmark framework for where that might end up.
See src/bench/MilliSleep.cpp for a sanity-test benchmark that just benchmarks
'sleep 100 milliseconds.'
To compile and run benchmarks:
cd src; make bench
Sample output:
Benchmark,count,min,max,average
Sleep100ms,10,0.101854,0.105059,0.103881
2015-09-24 19:13:38 +02:00
[use_bench=$enableval],
[use_bench=yes])
2019-05-19 22:20:34 +02:00
AC_ARG_ENABLE([extended-functional-tests],
AS_HELP_STRING([--enable-extended-functional-tests],[enable expensive functional tests when using lcov (default no)]),
[use_extended_functional_tests=$enableval],
[use_extended_functional_tests=no])
2015-10-12 14:37:57 +02:00
2021-08-11 05:20:43 +02:00
AC_ARG_ENABLE([fuzz],
2019-07-10 12:21:26 +02:00
AS_HELP_STRING([--enable-fuzz],
2023-08-23 13:28:58 +02:00
[build for fuzzing (default no). enabling this will disable all other targets and override --{enable,disable}-fuzz-binary]),
2021-08-11 05:20:43 +02:00
[enable_fuzz=$enableval],
[enable_fuzz=no])
2023-08-23 13:28:58 +02:00
AC_ARG_ENABLE([fuzz-binary],
AS_HELP_STRING([--enable-fuzz-binary],
[enable building of fuzz binary (default yes).]),
[enable_fuzz_binary=$enableval],
[enable_fuzz_binary=yes])
2022-09-19 09:03:12 +02:00
AC_ARG_ENABLE([danger_fuzz_link_all],
AS_HELP_STRING([--enable-danger-fuzz-link-all],
[Danger! Modifies source code. Needs git and gnu sed installed. Link each fuzz target (default no).]),
[enable_danger_fuzz_link_all=$enableval],
[enable_danger_fuzz_link_all=no])
2013-05-28 01:55:01 +02:00
AC_ARG_WITH([qrencode],
[AS_HELP_STRING([--with-qrencode],
[enable QR code support (default is yes if qt is enabled and libqrencode is found)])],
[use_qr=$withval],
[use_qr=auto])
AC_ARG_ENABLE([hardening],
2015-10-02 07:44:36 +02:00
[AS_HELP_STRING([--disable-hardening],
2018-03-06 20:20:00 +01:00
[do not attempt to harden the resulting executables (default is to harden when possible)])],
2013-05-28 01:55:01 +02:00
[use_hardening=$enableval],
2018-03-06 20:20:00 +01:00
[use_hardening=auto])
2013-05-28 01:55:01 +02:00
2014-08-18 21:55:54 +02:00
AC_ARG_ENABLE([reduce-exports],
[AS_HELP_STRING([--enable-reduce-exports],
2015-02-23 23:48:57 +01:00
[attempt to reduce exported symbols in the resulting executables (default is no)])],
2014-08-18 21:55:54 +02:00
[use_reduce_exports=$enableval],
2015-02-23 23:48:57 +01:00
[use_reduce_exports=no])
2014-08-18 21:55:54 +02:00
2013-05-28 01:55:01 +02:00
AC_ARG_ENABLE([ccache],
2015-10-02 07:44:36 +02:00
[AS_HELP_STRING([--disable-ccache],
[do not use ccache for building (default is to use if found)])],
2013-05-28 01:55:01 +02:00
[use_ccache=$enableval],
[use_ccache=auto])
2021-10-11 23:56:11 +02:00
dnl Suppress warnings from external headers (e.g. Boost, Qt).
dnl May be useful if warnings from external headers clutter the build output
dnl too much, so that it becomes difficult to spot Bitcoin Core warnings
dnl or if they cause a build failure with --enable-werror.
AC_ARG_ENABLE([suppress-external-warnings],
[AS_HELP_STRING([--enable-suppress-external-warnings],
[Suppress warnings from external headers (default is no)])],
[suppress_external_warnings=$enableval],
[suppress_external_warnings=no])
2013-05-28 01:55:01 +02:00
AC_ARG_ENABLE([lcov],
[AS_HELP_STRING([--enable-lcov],
[enable lcov testing (default is no)])],
2017-11-06 11:29:43 +01:00
[use_lcov=$enableval],
2013-05-28 01:55:01 +02:00
[use_lcov=no])
2018-06-24 15:56:00 +02:00
2017-06-22 20:49:54 +02:00
AC_ARG_ENABLE([lcov-branch-coverage],
[AS_HELP_STRING([--enable-lcov-branch-coverage],
[enable lcov testing branch coverage (default is no)])],
[use_lcov_branch=yes],
[use_lcov_branch=no])
2013-05-28 01:55:01 +02:00
2019-05-25 16:39:36 +02:00
AC_ARG_ENABLE([threadlocal],
[AS_HELP_STRING([--enable-threadlocal],
2023-07-09 18:03:44 +02:00
[enable features that depend on the c++ thread_local keyword (currently just thread names in debug logs). (default is to enable if there is platform support)])],
2019-05-25 16:39:36 +02:00
[use_thread_local=$enableval],
[use_thread_local=auto])
2017-09-05 22:12:42 +02:00
AC_ARG_ENABLE([asm],
2019-04-26 18:44:36 +02:00
[AS_HELP_STRING([--disable-asm],
[disable assembly routines (enabled by default)])],
2017-09-05 22:12:42 +02:00
[use_asm=$enableval],
[use_asm=yes])
if test "x$use_asm" = xyes; then
AC_DEFINE(USE_ASM, 1, [Define this symbol to build in assembly routines])
2017-07-20 20:16:28 +02:00
fi
2014-11-18 18:06:32 +01:00
AC_ARG_ENABLE([zmq],
2015-09-16 16:25:51 +02:00
[AS_HELP_STRING([--disable-zmq],
2015-09-30 08:40:20 +02:00
[disable ZMQ notifications])],
2014-11-18 18:06:32 +01:00
[use_zmq=$enableval],
[use_zmq=yes])
2013-05-28 01:55:01 +02:00
2016-09-13 10:25:41 +02:00
AC_ARG_ENABLE(man,
[AS_HELP_STRING([--disable-man],
[do not install man pages (default is to install)])],,
enable_man=yes)
AM_CONDITIONAL(ENABLE_MAN, test "$enable_man" != no)
2019-12-10 19:16:11 +01:00
dnl Enable debug
2014-03-04 06:52:42 +01:00
AC_ARG_ENABLE([debug],
[AS_HELP_STRING([--enable-debug],
2019-08-14 22:06:40 +02:00
[use compiler flags and macros suited for debugging (default is no)])],
2014-03-04 06:52:42 +01:00
[enable_debug=$enableval],
[enable_debug=no])
2019-12-10 19:16:11 +01:00
dnl Enable exception stacktraces
2020-12-01 05:18:46 +01:00
AC_ARG_ENABLE([stacktraces],
[AS_HELP_STRING([--enable-stacktraces],
[gather and print exception stack traces (default is yes)])],
[enable_stacktraces=$enableval],
[enable_stacktraces=yes])
2019-12-10 19:16:11 +01:00
dnl Enable crash hooks
2019-07-02 06:16:11 +02:00
AC_ARG_ENABLE([crash-hooks],
[AS_HELP_STRING([--enable-crash-hooks],
[hook into exception/signal/assert handling to gather stack traces (default is no)])],
[enable_crashhooks=$enableval],
[enable_crashhooks=no])
2019-02-21 19:37:16 +01:00
2019-12-10 19:16:11 +01:00
dnl Enable in-wallet miner
2019-03-19 08:43:37 +01:00
AC_ARG_ENABLE([miner],
[AS_HELP_STRING([--enable-miner],
[enable in-wallet miner (default is yes)])],
[enable_miner=$enableval],
[enable_miner=yes])
AM_CONDITIONAL([ENABLE_MINER], [test x$enable_miner = xyes])
if test "x$enable_miner" = xyes; then
AC_DEFINE(ENABLE_MINER, 1, [Define this symbol if in-wallet miner should be enabled])
fi
2019-12-10 19:16:11 +01:00
dnl Enable different -fsanitize options
2018-03-29 22:57:09 +02:00
AC_ARG_WITH([sanitizers],
[AS_HELP_STRING([--with-sanitizers],
[comma separated list of extra sanitizers to build with (default is none enabled)])],
[use_sanitizers=$withval])
2019-12-10 19:16:11 +01:00
dnl Enable gprof profiling
2018-03-06 20:20:00 +01:00
AC_ARG_ENABLE([gprof],
[AS_HELP_STRING([--enable-gprof],
[use gprof profiling compiler flags (default is no)])],
[enable_gprof=$enableval],
[enable_gprof=no])
2019-12-10 19:16:11 +01:00
dnl Turn warnings into errors
2017-02-23 10:48:11 +01:00
AC_ARG_ENABLE([werror],
[AS_HELP_STRING([--enable-werror],
[Treat certain compiler warnings as errors (default is no)])],
[enable_werror=$enableval],
[enable_werror=no])
build: quiet annoying warnings without adding new ones
Disabling warnings can be tricky, because doing so can cause a different
compiler to create new warnings about unsupported disable flags. Also, some
warnings don't surface until they're paired with another warning (gcc). For
example, adding "-Wno-foo" won't cause any trouble, but if there's a legitimate
warning emitted, the "unknown option -Wno-foo" will show up as well.
Work around this in 2 ways:
1. When checking to see if -Wno-foo is supported, check for "-Wfoo" instead.
2. Enable -Werror while checking 1.
If "-Werror -Wfoo" compiles, "-Wno-foo" is almost guaranteed to be supported.
-Werror itself is also checked. If that fails to compile by itself, it likely
means that the user added a flag that adds a warning. In that case, -Werror
won't be used while checking, and the build may be extra noisy. The user would
need to fix the bad input flag.
Also, silence 2 more additional warnings that can show up post-c++11.
(cherry picked from commit 63b3111f84daa421abc2889a550e86c17bf9609d)
2016-03-09 22:45:58 +01:00
AC_LANG_PUSH([C++])
2019-12-02 21:35:27 +01:00
dnl Check for a flag to turn compiler warnings into errors. This is helpful for checks which may
dnl appear to succeed because by default they merely emit warnings when they fail.
dnl
dnl Note that this is not necessarily a check to see if -Werror is supported, but rather to see if
dnl a compile with -Werror can succeed. This is important because the compiler may already be
dnl warning about something unrelated, for example about some path issue. If that is the case,
dnl -Werror cannot be used because all of those warnings would be turned into errors.
build: quiet annoying warnings without adding new ones
Disabling warnings can be tricky, because doing so can cause a different
compiler to create new warnings about unsupported disable flags. Also, some
warnings don't surface until they're paired with another warning (gcc). For
example, adding "-Wno-foo" won't cause any trouble, but if there's a legitimate
warning emitted, the "unknown option -Wno-foo" will show up as well.
Work around this in 2 ways:
1. When checking to see if -Wno-foo is supported, check for "-Wfoo" instead.
2. Enable -Werror while checking 1.
If "-Werror -Wfoo" compiles, "-Wno-foo" is almost guaranteed to be supported.
-Werror itself is also checked. If that fails to compile by itself, it likely
means that the user added a flag that adds a warning. In that case, -Werror
won't be used while checking, and the build may be extra noisy. The user would
need to fix the bad input flag.
Also, silence 2 more additional warnings that can show up post-c++11.
(cherry picked from commit 63b3111f84daa421abc2889a550e86c17bf9609d)
2016-03-09 22:45:58 +01:00
AX_CHECK_COMPILE_FLAG([-Werror],[CXXFLAG_WERROR="-Werror"],[CXXFLAG_WERROR=""])
2019-12-02 21:35:27 +01:00
dnl Check for a flag to turn linker warnings into errors. When flags are passed to linkers via the
dnl compiler driver using a -Wl,-foo flag, linker warnings may be swallowed rather than bubbling up.
dnl See note above, the same applies here as well.
dnl
dnl LDFLAG_WERROR Should only be used when testing -Wl,*
case $host in
*darwin*)
AX_CHECK_LINK_FLAG([-Wl,-fatal_warnings],[LDFLAG_WERROR="-Wl,-fatal_warnings"],[LDFLAG_WERROR=""])
;;
*)
AX_CHECK_LINK_FLAG([-Wl,--fatal-warnings],[LDFLAG_WERROR="-Wl,--fatal-warnings"],[LDFLAG_WERROR=""])
;;
esac
2014-03-04 06:52:42 +01:00
if test "x$enable_debug" = xyes; then
2019-12-10 19:16:11 +01:00
dnl Clear default -g -O2 flags
2018-06-13 15:46:46 +02:00
if test "x$CXXFLAGS_overridden" = xno; then
CXXFLAGS=""
fi
2019-08-14 22:06:40 +02:00
2019-12-10 19:16:11 +01:00
dnl Disable all optimizations
2019-08-14 22:06:40 +02:00
AX_CHECK_COMPILE_FLAG([-O0], [[DEBUG_CXXFLAGS="$DEBUG_CXXFLAGS -O0"]],,[[$CXXFLAG_WERROR]])
2014-11-29 12:29:14 +01:00
2019-12-10 19:16:11 +01:00
dnl Prefer -g3, fall back to -g if that is unavailable.
2018-05-14 15:27:46 +02:00
AX_CHECK_COMPILE_FLAG(
[-g3],
[[DEBUG_CXXFLAGS="$DEBUG_CXXFLAGS -g3"]],
[AX_CHECK_COMPILE_FLAG([-g],[[DEBUG_CXXFLAGS="$DEBUG_CXXFLAGS -g"]],,[[$CXXFLAG_WERROR]])],
[[$CXXFLAG_WERROR]])
2022-03-14 22:40:40 +01:00
AX_CHECK_PREPROC_FLAG([-DDEBUG_CORE],[[DEBUG_CPPFLAGS="$DEBUG_CPPFLAGS -DDEBUG_CORE"]],,[[$CXXFLAG_WERROR]])
2018-05-14 15:27:46 +02:00
AX_CHECK_PREPROC_FLAG([-DDEBUG_LOCKORDER],[[DEBUG_CPPFLAGS="$DEBUG_CPPFLAGS -DDEBUG_LOCKORDER"]],,[[$CXXFLAG_WERROR]])
2022-04-13 20:20:59 +02:00
AX_CHECK_PREPROC_FLAG([-DABORT_ON_FAILED_ASSUME],[[DEBUG_CPPFLAGS="$DEBUG_CPPFLAGS -DABORT_ON_FAILED_ASSUME"]],,[[$CXXFLAG_WERROR]])
2018-06-27 02:54:27 +02:00
AX_CHECK_COMPILE_FLAG([-ftrapv],[DEBUG_CXXFLAGS="$DEBUG_CXXFLAGS -ftrapv"],,[[$CXXFLAG_WERROR]])
2019-07-02 06:16:11 +02:00
else
# We always enable at at least -g1 debug info to support proper stacktraces in crash infos
# Stacktraces will be suboptimal due to optimization, but better than nothing. Also, -fno-omit-frame-pointer
# mitigates this a little bit
2019-02-21 19:37:16 +01:00
if test "x$GCC" = xyes; then
CFLAGS="$CFLAGS -g1 -fno-omit-frame-pointer"
fi
if test "x$GXX" = xyes; then
CXXFLAGS="$CXXFLAGS -g1 -fno-omit-frame-pointer"
fi
2014-11-29 12:29:14 +01:00
fi
2014-03-04 06:52:42 +01:00
2020-12-01 05:18:46 +01:00
if test "x$enable_stacktraces" != xno; then
AC_CHECK_HEADERS([execinfo.h], [], [enable_stacktraces=no])
fi
AM_CONDITIONAL([ENABLE_STACKTRACES], [test x$enable_stacktraces = xyes])
if test "x$enable_stacktraces" = xyes; then
AC_DEFINE(ENABLE_STACKTRACES, 1, [Define this symbol if stacktraces should be enabled])
else
enable_crashhooks=no
fi
2019-07-02 06:16:11 +02:00
AM_CONDITIONAL([ENABLE_CRASH_HOOKS], [test x$enable_crashhooks = xyes])
if test "x$enable_crashhooks" = xyes; then
AC_DEFINE(ENABLE_CRASH_HOOKS, 1, [Define this symbol if crash hooks should be enabled])
2019-02-21 19:37:16 +01:00
fi
2020-12-01 05:18:46 +01:00
2019-02-21 19:37:16 +01:00
AX_CHECK_LINK_FLAG([-Wl,-wrap=__cxa_allocate_exception], [LINK_WRAP_SUPPORTED=yes],,,)
2019-07-02 06:16:11 +02:00
AM_CONDITIONAL([CRASH_HOOKS_WRAPPED_CXX_ABI],[test x$LINK_WRAP_SUPPORTED = xyes])
2019-02-21 19:37:16 +01:00
if test x$LINK_WRAP_SUPPORTED = "xyes"; then
2019-07-02 06:16:11 +02:00
AC_DEFINE(CRASH_HOOKS_WRAPPED_CXX_ABI, 1, [Define this symbol to use wrapped CXX ABIs for exception stacktraces])
2019-02-21 19:37:16 +01:00
fi
# Needed for MinGW targets when debug symbols are enabled as compiled objects get very large
AX_CHECK_COMPILE_FLAG([-Wa,-mbig-obj], [CXXFLAGS="$CXXFLAGS -Wa,-mbig-obj"],,,)
2018-03-29 22:57:09 +02:00
if test x$use_sanitizers != x; then
2019-12-10 19:16:11 +01:00
dnl First check if the compiler accepts flags. If an incompatible pair like
dnl -fsanitize=address,thread is used here, this check will fail. This will also
dnl fail if a bad argument is passed, e.g. -fsanitize=undfeined
2018-03-29 22:57:09 +02:00
AX_CHECK_COMPILE_FLAG(
[[-fsanitize=$use_sanitizers]],
[[SANITIZER_CXXFLAGS=-fsanitize=$use_sanitizers]],
[AC_MSG_ERROR([compiler did not accept requested flags])])
2019-12-10 19:16:11 +01:00
dnl Some compilers (e.g. GCC) require additional libraries like libasan,
dnl libtsan, libubsan, etc. Make sure linking still works with the sanitize
dnl flag. This is a separate check so we can give a better error message when
dnl the sanitize flags are supported by the compiler but the actual sanitizer
dnl libs are missing.
2018-03-29 22:57:09 +02:00
AX_CHECK_LINK_FLAG(
[[-fsanitize=$use_sanitizers]],
[[SANITIZER_LDFLAGS=-fsanitize=$use_sanitizers]],
2019-01-10 18:59:56 +01:00
[AC_MSG_ERROR([linker did not accept requested flags, you are missing required libraries])],
[],
[AC_LANG_PROGRAM([[
#include <cstdint>
#include <cstddef>
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { return 0; }
__attribute__((weak)) // allow for libFuzzer linking
]],[[]])])
2018-03-29 22:57:09 +02:00
fi
2017-02-23 10:48:11 +01:00
ERROR_CXXFLAGS=
if test "x$enable_werror" = "xyes"; then
if test "x$CXXFLAG_WERROR" = "x"; then
AC_MSG_ERROR("enable-werror set but -Werror is not usable")
fi
2023-08-22 22:19:48 +02:00
AX_CHECK_COMPILE_FLAG([-Werror=reorder],[ERROR_CXXFLAGS="$ERROR_CXXFLAGS -Werror=reorder"],,[[$CXXFLAG_WERROR]])
2020-05-13 22:20:05 +02:00
AX_CHECK_COMPILE_FLAG([-Werror=gnu],[ERROR_CXXFLAGS="$ERROR_CXXFLAGS -Werror=gnu"],,[[$CXXFLAG_WERROR]])
2017-02-23 10:48:11 +01:00
AX_CHECK_COMPILE_FLAG([-Werror=vla],[ERROR_CXXFLAGS="$ERROR_CXXFLAGS -Werror=vla"],,[[$CXXFLAG_WERROR]])
2020-06-06 14:13:31 +02:00
AX_CHECK_COMPILE_FLAG([-Werror=shadow-field],[ERROR_CXXFLAGS="$ERROR_CXXFLAGS -Werror=shadow-field"],,[[$CXXFLAG_WERROR]])
2021-06-17 16:22:12 +02:00
AX_CHECK_COMPILE_FLAG([-Werror=switch],[ERROR_CXXFLAGS="$ERROR_CXXFLAGS -Werror=switch"],,[[$CXXFLAG_WERROR]])
2021-06-09 14:02:42 +02:00
AX_CHECK_COMPILE_FLAG([-Werror=thread-safety],[ERROR_CXXFLAGS="$ERROR_CXXFLAGS -Werror=thread-safety"],,[[$CXXFLAG_WERROR]])
2020-08-18 05:07:00 +02:00
AX_CHECK_COMPILE_FLAG([-Werror=range-loop-analysis],[ERROR_CXXFLAGS="$ERROR_CXXFLAGS -Werror=range-loop-analysis"],,[[$CXXFLAG_WERROR]])
2019-11-15 10:23:48 +01:00
AX_CHECK_COMPILE_FLAG([-Werror=unused-variable],[ERROR_CXXFLAGS="$ERROR_CXXFLAGS -Werror=unused-variable"],,[[$CXXFLAG_WERROR]])
2021-06-17 07:45:50 +02:00
AX_CHECK_COMPILE_FLAG([-Werror=date-time],[ERROR_CXXFLAGS="$ERROR_CXXFLAGS -Werror=date-time"],,[[$CXXFLAG_WERROR]])
2020-02-14 10:19:04 +01:00
AX_CHECK_COMPILE_FLAG([-Werror=return-type],[ERROR_CXXFLAGS="$ERROR_CXXFLAGS -Werror=return-type"],,[[$CXXFLAG_WERROR]])
2020-05-01 14:05:48 +02:00
AX_CHECK_COMPILE_FLAG([-Werror=conditional-uninitialized],[ERROR_CXXFLAGS="$ERROR_CXXFLAGS -Werror=conditional-uninitialized"],,[[$CXXFLAG_WERROR]])
2020-05-11 05:33:42 +02:00
AX_CHECK_COMPILE_FLAG([-Werror=sign-compare],[ERROR_CXXFLAGS="$ERROR_CXXFLAGS -Werror=sign-compare"],,[[$CXXFLAG_WERROR]])
2020-03-14 07:51:27 +01:00
dnl -Wsuggest-override is broken with GCC before 9.2
dnl https://gcc.gnu.org/bugzilla/show_bug.cgi?id=78010
AX_CHECK_COMPILE_FLAG([-Werror=suggest-override],[ERROR_CXXFLAGS="$ERROR_CXXFLAGS -Werror=suggest-override"],,[[$CXXFLAG_WERROR]],
[AC_LANG_SOURCE([[struct A { virtual void f(); }; struct B : A { void f() final; };]])])
2020-06-01 10:05:15 +02:00
AX_CHECK_COMPILE_FLAG([-Werror=unreachable-code-loop-increment],[ERROR_CXXFLAGS="$ERROR_CXXFLAGS -Werror=unreachable-code-loop-increment"],,[[$CXXFLAG_WERROR]])
2021-02-02 01:56:31 +01:00
AX_CHECK_COMPILE_FLAG([-Werror=mismatched-tags], [ERROR_CXXFLAGS="$ERROR_CXXFLAGS -Werror=mismatched-tags"], [], [$CXXFLAG_WERROR])
2017-02-23 10:48:11 +01:00
fi
2013-09-08 22:30:24 +02:00
if test "x$CXXFLAGS_overridden" = "xno"; then
2021-06-17 16:20:41 +02:00
AX_CHECK_COMPILE_FLAG([-Wall],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wall"],,[[$CXXFLAG_WERROR]])
AX_CHECK_COMPILE_FLAG([-Wextra],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wextra"],,[[$CXXFLAG_WERROR]])
Merge #18088: build: ensure we aren't using GNU extensions
0ae8f18dfe143051fec6ae10ea7df10142e3ff2f build: add -Wgnu to compile flags (fanquake)
3a0fd7726b8b916de6cce33bb67f48990575f923 Remove use of non-standard zero variadic macros (Ben Woosley)
49f6178c3e5e3ad54a419da9d8523207da17fc64 Drop unused LOG_TIME_MICROS helper (Ben Woosley)
5d4999951ee32e333b511245862628e80f83b703 prevector: Avoid unnamed struct, which is a GNU extension (DesWurstes)
Pull request description:
Since we [started using](https://github.com/bitcoin/bitcoin/pull/7165) the `ax_cxx_compile_stdcxx.m4` macro we've been passing `[noext]` to indicate that we don't want to use an extended mode, i.e GNU extensions. Speaking to Cory he clarified that the intention was to "require only vanilla c++11 and turn _off_ extension support so they would fail to compile".
However in the codebase we are currently making use of some GNU extensions. We should either remove there usage, or at least amend our CXX compiler checks. I'd prefer the former.
#### anonymous structs
```bash
./prevector.h:153:9: warning: anonymous structs are a GNU extension [-Wgnu-anonymous-struct]
struct {
```
This is fixed in https://github.com/bitcoin/bitcoin/commit/b849212c1ec01cc8633b8cdcd390da9b1051be0d.
#### variadic macros
```bash
./undo.h:57:50: warning: must specify at least one argument for '...' parameter of variadic macro [-Wgnu-zero-variadic-macro-arguments]
::Unserialize(s, VARINT(nVersionDummy));
```
This is taken care of in #18087.
The `LOG_TIME_*` macros introduced in #16805 make use of a [GNU extension](https://gcc.gnu.org/onlinedocs/cpp/Variadic-Macros.html).
```bash
In file included from validation.cpp:22:
./logging/timer.h:99:99: warning: token pasting of ',' and __VA_ARGS__ is a GNU extension [-Wgnu-zero-variadic-macro-arguments]
BCLog::Timer<std::chrono::milliseconds> PASTE2(logging_timer, __COUNTER__)(__func__, end_msg, ## __VA_ARGS__)
^
./logging/timer.h:99:99: warning: token pasting of ',' and __VA_ARGS__ is a GNU extension [-Wgnu-zero-variadic-macro-arguments]
./logging/timer.h:99:99: warning: token pasting of ',' and __VA_ARGS__ is a GNU extension [-Wgnu-zero-variadic-macro-arguments]
./logging/timer.h:99:99: warning: token pasting of ',' and __VA_ARGS__ is a GNU extension [-Wgnu-zero-variadic-macro-arguments]
./logging/timer.h:99:99: warning: token pasting of ',' and __VA_ARGS__ is a GNU extension [-Wgnu-zero-variadic-macro-arguments]
./logging/timer.h:101:92: warning: token pasting of ',' and __VA_ARGS__ is a GNU extension [-Wgnu-zero-variadic-macro-arguments]
BCLog::Timer<std::chrono::seconds> PASTE2(logging_timer, __COUNTER__)(__func__, end_msg, ## __VA_ARGS__)
^
6 warnings generated.
```
This is fixed in 081a0ab64eb442bc85c4d4a4d3bc2c8e97ac2a6d and 612e8e138b97fc5ad2f38847300132a8fc423c3f.
#### prevention
To ensure that usage doesn't creep back in we can add [`-Wgnu`](https://clang.llvm.org/docs/DiagnosticsReference.html#wgnu) to our compile time flags, which will make Clang warn whenever it encounters GNU extensions.
This would close #14130.
Also related to #17230, where it's suggested we use a GNU extension, the `gnu::pure` attribute.
ACKs for top commit:
practicalswift:
ACK 0ae8f18dfe143051fec6ae10ea7df10142e3ff2f -- diff looks correct
MarcoFalke:
ACK 0ae8f18dfe143051fec6ae10ea7df10142e3ff2f
vasild:
utACK 0ae8f18df
dongcarl:
ACK 0ae8f18dfe143051fec6ae10ea7df10142e3ff2f
Tree-SHA512: c517404681ef8edf04c785731d26105bac9f3c9c958605aa24cbe399c649e7c5ee0c4aa8e714fd2b2d335e2fbea4d571e09b0dec36678ef871f0a6683ba6bb7f
2020-05-05 01:19:44 +02:00
AX_CHECK_COMPILE_FLAG([-Wgnu],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wgnu"],,[[$CXXFLAG_WERROR]])
2020-07-15 13:51:02 +02:00
dnl some compilers will ignore -Wformat-security without -Wformat, so just combine the two here.
AX_CHECK_COMPILE_FLAG([-Wformat -Wformat-security],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wformat -Wformat-security"],,[[$CXXFLAG_WERROR]])
2021-06-17 16:20:41 +02:00
AX_CHECK_COMPILE_FLAG([-Wvla],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wvla"],,[[$CXXFLAG_WERROR]])
2020-06-06 14:13:31 +02:00
AX_CHECK_COMPILE_FLAG([-Wshadow-field],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wshadow-field"],,[[$CXXFLAG_WERROR]])
2021-06-17 16:22:12 +02:00
AX_CHECK_COMPILE_FLAG([-Wswitch],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wswitch"],,[[$CXXFLAG_WERROR]])
2021-06-17 16:20:41 +02:00
AX_CHECK_COMPILE_FLAG([-Wthread-safety],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wthread-safety"],,[[$CXXFLAG_WERROR]])
2018-06-24 16:34:56 +02:00
AX_CHECK_COMPILE_FLAG([-Wrange-loop-analysis],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wrange-loop-analysis"],,[[$CXXFLAG_WERROR]])
2021-06-17 16:24:51 +02:00
AX_CHECK_COMPILE_FLAG([-Wredundant-decls],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wredundant-decls"],,[[$CXXFLAG_WERROR]])
2019-11-15 10:23:48 +01:00
AX_CHECK_COMPILE_FLAG([-Wunused-variable],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wunused-variable"],,[[$CXXFLAG_WERROR]])
2021-01-05 12:05:39 +01:00
AX_CHECK_COMPILE_FLAG([-Wunused-member-function],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wunused-member-function"],,[[$CXXFLAG_WERROR]])
2021-06-17 07:45:50 +02:00
AX_CHECK_COMPILE_FLAG([-Wdate-time],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wdate-time"],,[[$CXXFLAG_WERROR]])
2020-05-01 14:05:48 +02:00
AX_CHECK_COMPILE_FLAG([-Wconditional-uninitialized],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wconditional-uninitialized"],,[[$CXXFLAG_WERROR]])
2020-05-11 05:33:42 +02:00
AX_CHECK_COMPILE_FLAG([-Wsign-compare],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wsign-compare"],,[[$CXXFLAG_WERROR]])
2020-05-19 14:34:24 +02:00
AX_CHECK_COMPILE_FLAG([-Wduplicated-branches],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wduplicated-branches"],,[[$CXXFLAG_WERROR]])
AX_CHECK_COMPILE_FLAG([-Wduplicated-cond],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wduplicated-cond"],,[[$CXXFLAG_WERROR]])
AX_CHECK_COMPILE_FLAG([-Wlogical-op],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wlogical-op"],,[[$CXXFLAG_WERROR]])
AX_CHECK_COMPILE_FLAG([-Woverloaded-virtual],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Woverloaded-virtual"],,[[$CXXFLAG_WERROR]])
2020-03-14 07:51:27 +01:00
AX_CHECK_COMPILE_FLAG([-Wsuggest-override],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wsuggest-override"],,[[$CXXFLAG_WERROR]],
[AC_LANG_SOURCE([[struct A { virtual void f(); }; struct B : A { void f() final; };]])])
2020-06-01 10:05:15 +02:00
AX_CHECK_COMPILE_FLAG([-Wunreachable-code-loop-increment],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wunreachable-code-loop-increment"],,[[$CXXFLAG_WERROR]])
build: quiet annoying warnings without adding new ones
Disabling warnings can be tricky, because doing so can cause a different
compiler to create new warnings about unsupported disable flags. Also, some
warnings don't surface until they're paired with another warning (gcc). For
example, adding "-Wno-foo" won't cause any trouble, but if there's a legitimate
warning emitted, the "unknown option -Wno-foo" will show up as well.
Work around this in 2 ways:
1. When checking to see if -Wno-foo is supported, check for "-Wfoo" instead.
2. Enable -Werror while checking 1.
If "-Werror -Wfoo" compiles, "-Wno-foo" is almost guaranteed to be supported.
-Werror itself is also checked. If that fails to compile by itself, it likely
means that the user added a flag that adds a warning. In that case, -Werror
won't be used while checking, and the build may be extra noisy. The user would
need to fix the bad input flag.
Also, silence 2 more additional warnings that can show up post-c++11.
(cherry picked from commit 63b3111f84daa421abc2889a550e86c17bf9609d)
2016-03-09 22:45:58 +01:00
2019-12-10 19:16:11 +01:00
dnl Some compilers (gcc) ignore unknown -Wno-* options, but warn about all
dnl unknown options if any other warning is produced. Test the -Wfoo case, and
dnl set the -Wno-foo case if it works.
2021-06-17 16:20:41 +02:00
AX_CHECK_COMPILE_FLAG([-Wunused-parameter],[NOWARN_CXXFLAGS="$NOWARN_CXXFLAGS -Wno-unused-parameter"],,[[$CXXFLAG_WERROR]])
AX_CHECK_COMPILE_FLAG([-Wself-assign],[NOWARN_CXXFLAGS="$NOWARN_CXXFLAGS -Wno-self-assign"],,[[$CXXFLAG_WERROR]])
AX_CHECK_COMPILE_FLAG([-Wunused-local-typedef],[NOWARN_CXXFLAGS="$NOWARN_CXXFLAGS -Wno-unused-local-typedef"],,[[$CXXFLAG_WERROR]])
AX_CHECK_COMPILE_FLAG([-Wimplicit-fallthrough],[NOWARN_CXXFLAGS="$NOWARN_CXXFLAGS -Wno-implicit-fallthrough"],,[[$CXXFLAG_WERROR]])
2021-06-17 05:44:06 +02:00
if test x$suppress_external_warnings != xyes ; then
AX_CHECK_COMPILE_FLAG([-Wdeprecated-copy],[NOWARN_CXXFLAGS="$NOWARN_CXXFLAGS -Wno-deprecated-copy"],,[[$CXXFLAG_WERROR]])
fi
2013-09-08 22:30:24 +02:00
fi
2017-07-14 09:23:56 +02:00
2020-05-29 02:04:16 +02:00
dnl Don't allow extended (non-ASCII) symbols in identifiers. This is easier for code review.
AX_CHECK_COMPILE_FLAG([-fno-extended-identifiers],[[CXXFLAGS="$CXXFLAGS -fno-extended-identifiers"]],,[[$CXXFLAG_WERROR]])
2021-07-15 22:42:55 +02:00
enable_sse42=no
2019-04-26 18:44:36 +02:00
enable_sse41=no
enable_avx2=no
2022-02-14 20:47:24 +01:00
enable_x86_shani=no
2019-04-26 18:44:36 +02:00
if test "x$use_asm" = "xyes"; then
2021-07-15 22:42:55 +02:00
dnl Check for optional instruction set support. Enabling these does _not_ imply that all code will
dnl be compiled with them, rather that specific objects/libs may use them after checking for runtime
dnl compatibility.
dnl x86
2022-03-30 20:49:51 +02:00
AX_CHECK_COMPILE_FLAG([-msse4.2],[[SSE42_CXXFLAGS="-msse4.2"]],,[[$CXXFLAG_WERROR]])
AX_CHECK_COMPILE_FLAG([-msse4.1],[[SSE41_CXXFLAGS="-msse4.1"]],,[[$CXXFLAG_WERROR]])
AX_CHECK_COMPILE_FLAG([-mavx -mavx2],[[AVX2_CXXFLAGS="-mavx -mavx2"]],,[[$CXXFLAG_WERROR]])
AX_CHECK_COMPILE_FLAG([-msse4 -msha],[[X86_SHANI_CXXFLAGS="-msse4 -msha"]],,[[$CXXFLAG_WERROR]])
2017-08-05 13:18:01 +02:00
2017-07-14 09:23:56 +02:00
TEMP_CXXFLAGS="$CXXFLAGS"
CXXFLAGS="$CXXFLAGS $SSE42_CXXFLAGS"
2021-07-15 22:42:55 +02:00
AC_MSG_CHECKING(for SSE4.2 intrinsics)
2017-07-14 09:23:56 +02:00
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <stdint.h>
#if defined(_MSC_VER)
#include <intrin.h>
#elif defined(__GNUC__) && defined(__SSE4_2__)
#include <nmmintrin.h>
#endif
]],[[
uint64_t l = 0;
l = _mm_crc32_u8(l, 0);
l = _mm_crc32_u32(l, 0);
l = _mm_crc32_u64(l, 0);
return l;
]])],
2021-07-15 22:42:55 +02:00
[ AC_MSG_RESULT(yes); enable_sse42=yes],
2017-07-14 09:23:56 +02:00
[ AC_MSG_RESULT(no)]
)
CXXFLAGS="$TEMP_CXXFLAGS"
2018-06-04 09:11:18 +02:00
TEMP_CXXFLAGS="$CXXFLAGS"
CXXFLAGS="$CXXFLAGS $SSE41_CXXFLAGS"
AC_MSG_CHECKING(for SSE4.1 intrinsics)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <stdint.h>
#include <immintrin.h>
]],[[
__m128i l = _mm_set1_epi32(0);
return _mm_extract_epi32(l, 3);
]])],
[ AC_MSG_RESULT(yes); enable_sse41=yes; AC_DEFINE(ENABLE_SSE41, 1, [Define this symbol to build code that uses SSE4.1 intrinsics]) ],
[ AC_MSG_RESULT(no)]
)
CXXFLAGS="$TEMP_CXXFLAGS"
TEMP_CXXFLAGS="$CXXFLAGS"
CXXFLAGS="$CXXFLAGS $AVX2_CXXFLAGS"
AC_MSG_CHECKING(for AVX2 intrinsics)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <stdint.h>
#include <immintrin.h>
]],[[
__m256i l = _mm256_set1_epi32(0);
return _mm256_extract_epi32(l, 7);
]])],
[ AC_MSG_RESULT(yes); enable_avx2=yes; AC_DEFINE(ENABLE_AVX2, 1, [Define this symbol to build code that uses AVX2 intrinsics]) ],
[ AC_MSG_RESULT(no)]
)
CXXFLAGS="$TEMP_CXXFLAGS"
2018-07-09 20:33:41 +02:00
TEMP_CXXFLAGS="$CXXFLAGS"
2022-02-14 20:47:24 +01:00
CXXFLAGS="$CXXFLAGS $X86_SHANI_CXXFLAGS"
AC_MSG_CHECKING(for x86 SHA-NI intrinsics)
2018-07-09 20:33:41 +02:00
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <stdint.h>
#include <immintrin.h>
]],[[
__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, i, k), 0);
]])],
2022-02-14 20:47:24 +01:00
[ AC_MSG_RESULT(yes); enable_x86_shani=yes; AC_DEFINE(ENABLE_X86_SHANI, 1, [Define this symbol to build code that uses x86 SHA-NI intrinsics]) ],
2018-07-09 20:33:41 +02:00
[ AC_MSG_RESULT(no)]
)
CXXFLAGS="$TEMP_CXXFLAGS"
2021-07-15 22:42:55 +02:00
# ARM
AX_CHECK_COMPILE_FLAG([-march=armv8-a+crc+crypto],[[ARM_CRC_CXXFLAGS="-march=armv8-a+crc+crypto"]],,[[$CXXFLAG_WERROR]])
2022-02-14 20:47:24 +01:00
AX_CHECK_COMPILE_FLAG([-march=armv8-a+crc+crypto], [ARM_SHANI_CXXFLAGS="-march=armv8-a+crc+crypto"], [], [$CXXFLAG_WERROR])
2021-07-15 22:42:55 +02:00
TEMP_CXXFLAGS="$CXXFLAGS"
CXXFLAGS="$CXXFLAGS $ARM_CRC_CXXFLAGS"
2022-02-14 20:47:24 +01:00
AC_MSG_CHECKING(for ARMv8 CRC32 intrinsics)
2021-07-15 22:42:55 +02:00
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <arm_acle.h>
#include <arm_neon.h>
]],[[
2021-09-23 13:19:05 +02:00
#ifdef __aarch64__
2021-07-15 22:42:55 +02:00
__crc32cb(0, 0); __crc32ch(0, 0); __crc32cw(0, 0); __crc32cd(0, 0);
vmull_p64(0, 0);
2021-09-23 13:19:05 +02:00
#else
#error "crc32c library does not support hardware acceleration on 32-bit ARM"
#endif
2021-07-15 22:42:55 +02:00
]])],
[ AC_MSG_RESULT(yes); enable_arm_crc=yes; ],
[ AC_MSG_RESULT(no)]
)
CXXFLAGS="$TEMP_CXXFLAGS"
2022-02-14 20:47:24 +01:00
TEMP_CXXFLAGS="$CXXFLAGS"
CXXFLAGS="$CXXFLAGS $ARM_SHANI_CXXFLAGS"
AC_MSG_CHECKING([for ARMv8 SHA-NI intrinsics])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <arm_acle.h>
#include <arm_neon.h>
]],[[
uint32x4_t a, b, c;
vsha256h2q_u32(a, b, c);
vsha256hq_u32(a, b, c);
vsha256su0q_u32(a, b);
vsha256su1q_u32(a, b, c);
]])],
[ AC_MSG_RESULT([yes]); enable_arm_shani=yes; AC_DEFINE([ENABLE_ARM_SHANI], [1], [Define this symbol to build code that uses ARMv8 SHA-NI intrinsics]) ],
[ AC_MSG_RESULT([no])]
)
CXXFLAGS="$TEMP_CXXFLAGS"
2019-04-26 18:44:36 +02:00
fi
2021-11-10 09:23:07 +01:00
CPPFLAGS="$CPPFLAGS -DHAVE_BUILD_INFO"
2013-05-28 01:55:01 +02:00
2015-01-06 14:12:39 +01:00
AC_ARG_WITH([utils],
[AS_HELP_STRING([--with-utils],
2019-01-31 17:07:45 +01:00
[build dash-cli dash-tx dash-wallet (default=yes)])],
2015-01-06 14:12:39 +01:00
[build_bitcoin_utils=$withval],
[build_bitcoin_utils=yes])
2018-09-27 17:12:28 +02:00
AC_ARG_ENABLE([util-cli],
[AS_HELP_STRING([--enable-util-cli],
[build dash-cli])],
[build_bitcoin_cli=$enableval],
[build_bitcoin_cli=$build_bitcoin_utils])
AC_ARG_ENABLE([util-tx],
[AS_HELP_STRING([--enable-util-tx],
[build dash-tx])],
[build_bitcoin_tx=$enableval],
[build_bitcoin_tx=$build_bitcoin_utils])
2019-01-31 17:07:45 +01:00
AC_ARG_ENABLE([util-wallet],
[AS_HELP_STRING([--enable-util-wallet],
[build dash-wallet])],
[build_bitcoin_wallet=$enableval],
[build_bitcoin_wallet=$build_bitcoin_utils])
2015-01-06 14:12:39 +01:00
AC_ARG_WITH([libs],
[AS_HELP_STRING([--with-libs],
[build libraries (default=yes)])],
[build_bitcoin_libs=$withval],
[build_bitcoin_libs=yes])
AC_ARG_WITH([daemon],
[AS_HELP_STRING([--with-daemon],
2015-04-03 00:51:08 +02:00
[build dashd daemon (default=yes)])],
2015-01-06 14:12:39 +01:00
[build_bitcoind=$withval],
[build_bitcoind=yes])
2013-05-28 01:55:01 +02:00
case $host in
*mingw*)
TARGET_OS=windows
2020-01-24 07:17:48 +01:00
AC_CHECK_LIB([kernel32], [GetModuleFileNameA],, AC_MSG_ERROR(libkernel32 missing))
AC_CHECK_LIB([user32], [main],, AC_MSG_ERROR(libuser32 missing))
AC_CHECK_LIB([gdi32], [main],, AC_MSG_ERROR(libgdi32 missing))
AC_CHECK_LIB([comdlg32], [main],, AC_MSG_ERROR(libcomdlg32 missing))
AC_CHECK_LIB([winmm], [main],, AC_MSG_ERROR(libwinmm missing))
AC_CHECK_LIB([shell32], [SHGetSpecialFolderPathW],, AC_MSG_ERROR(libshell32 missing))
AC_CHECK_LIB([comctl32], [main],, AC_MSG_ERROR(libcomctl32 missing))
AC_CHECK_LIB([ole32], [CoCreateInstance],, AC_MSG_ERROR(libole32 missing))
AC_CHECK_LIB([oleaut32], [main],, AC_MSG_ERROR(liboleaut32 missing))
AC_CHECK_LIB([uuid], [main],, AC_MSG_ERROR(libuuid missing))
AC_CHECK_LIB([advapi32], [CryptAcquireContextW],, AC_MSG_ERROR(libadvapi32 missing))
AC_CHECK_LIB([ws2_32], [WSAStartup],, AC_MSG_ERROR(libws2_32 missing))
AC_CHECK_LIB([shlwapi], [PathRemoveFileSpecW],, AC_MSG_ERROR(libshlwapi missing))
AC_CHECK_LIB([iphlpapi], [GetAdaptersAddresses],, AC_MSG_ERROR(libiphlpapi missing))
2023-01-02 08:13:49 +01:00
AC_CHECK_LIB([psapi], [GetProcessMemoryInfo],, [AC_MSG_ERROR([libpsapi missing])])
AC_CHECK_LIB([bcrypt], [main],, [AC_MSG_ERROR([libbcrypt missing])])
2013-09-25 23:58:18 +02:00
2019-12-10 19:16:11 +01:00
dnl -static is interpreted by libtool, where it has a different meaning.
dnl In libtool-speak, it's -all-static.
2014-10-15 00:03:52 +02:00
AX_CHECK_LINK_FLAG([[-static]],[LIBTOOL_APP_LDFLAGS="$LIBTOOL_APP_LDFLAGS -all-static"])
2013-05-28 01:55:01 +02:00
AC_PATH_PROG([MAKENSIS], [makensis], none)
if test x$MAKENSIS = xnone; then
AC_MSG_WARN("makensis not found. Cannot create installer.")
fi
2013-09-18 23:39:18 +02:00
AC_PATH_TOOL(WINDRES, windres, none)
if test x$WINDRES = xnone; then
AC_MSG_ERROR("windres not found")
fi
2019-02-05 18:13:01 +01:00
CPPFLAGS="$CPPFLAGS -D_MT -DWIN32 -D_WINDOWS -DBOOST_THREAD_USE_LIB -D_WIN32_WINNT=0x0601"
2014-11-18 21:49:56 +01:00
dnl libtool insists upon adding -nostdlib and a list of objects/libs to link against.
dnl That breaks our ability to build dll's with static libgcc/libstdc++/libssp. Override
dnl its command here, with the predeps/postdeps removed, and -static inserted. Postdeps are
dnl also overridden to prevent their insertion later.
dnl This should only affect dll's.
archive_cmds_CXX="\$CC -shared \$libobjs \$deplibs \$compiler_flags -static -o \$output_objdir/\$soname \${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker \$lib"
postdeps_CXX=
2020-05-20 03:49:25 +02:00
dnl We require Windows 7 (NT 6.1) or later
AX_CHECK_LINK_FLAG([[-Wl,--major-subsystem-version -Wl,6 -Wl,--minor-subsystem-version -Wl,1]],[LDFLAGS="$LDFLAGS -Wl,--major-subsystem-version -Wl,6 -Wl,--minor-subsystem-version -Wl,1"],,[[$LDFLAG_WERROR]])
2013-05-28 01:55:01 +02:00
;;
*darwin*)
TARGET_OS=darwin
if test x$cross_compiling != xyes; then
2013-12-07 00:11:03 +01:00
BUILD_OS=darwin
2013-05-28 01:55:01 +02:00
AC_CHECK_PROG([BREW],brew, brew)
if test x$BREW = xbrew; then
2014-10-06 22:36:24 +02:00
dnl These Homebrew packages may be keg-only, meaning that they won't be found
2014-09-29 21:26:31 +02:00
dnl in expected paths because they may conflict with system files. Ask
dnl Homebrew where each one is located, then adjust paths accordingly.
dnl It's safe to add these paths even if the functionality is disabled by
dnl the user (--without-wallet or --without-gui for example).
2024-01-10 19:09:02 +01:00
if test "x$use_bdb" != xno && $BREW list --versions berkeley-db4 >/dev/null && test "x$BDB_CFLAGS" = "x" && test "x$BDB_LIBS" = "x"; then
2020-12-04 10:08:12 +01:00
bdb_prefix=$($BREW --prefix berkeley-db4 2>/dev/null)
Merge #19356: build: Fix search for brew-installed BDB 4 on OS X
8578c6fccd11404412d2c60f9bede311b79ca0d0 build: Fix search for brew-installed BDB 4 on OS X (Glenn Willen)
Pull request description:
~~NOTE: This PR contains one important fix that I need (to make Bitcoin Core build cleanly on my system without shenanigans), plus some related general cleanup that is not really necessary, and could be annoying. (I am prepared to defend my argument that BDB_CFLAGS is wrong here, and BDB_CPPFLAGS is right, but this could bite anybody who has gotten in the habit of -- or scripted -- setting the former.)~~
Ok, I have been convinced that I was too clever with the refactor and I have removed it. Now it's just the tiny change to fix the build on my local machine.
---
On OS X, when searching Homebrew keg-only packages for BDB 4.8, if we find it,
use BDB_CPPFLAGS and BDB_LIBS instead of CFLAGS and LIBS for the result. This
is (1) more correct, and (2) necessary in order to give this location
priority over other directories in the include search path, which may include
system include directories with other versions of BDB.
ACKs for top commit:
theuni:
ACK 8578c6fccd11404412d2c60f9bede311b79ca0d0.
Tree-SHA512: a28f48fc81a25736f7e77c663f21cd9a6ae1cd115682031c5aa695c94cb5afa11920330a60cd6a54832822a2aec1eb23123ac2e2dcd4f0b3835aef9c9339ac97
2020-06-29 06:44:12 +02:00
dnl This must precede the call to BITCOIN_FIND_BDB48 below.
BDB_CFLAGS="-I$bdb_prefix/include"
BDB_LIBS="-L$bdb_prefix/lib -ldb_cxx-4.8"
2014-09-29 21:26:31 +02:00
fi
2024-01-10 19:09:02 +01:00
if test "x$use_sqlite" != xno && $BREW list --versions sqlite3 >/dev/null; then
export PKG_CONFIG_PATH="$($BREW --prefix sqlite3 2>/dev/null)/lib/pkgconfig:$PKG_CONFIG_PATH"
fi
if $BREW list --versions qt5 >/dev/null; then
export PKG_CONFIG_PATH="$($BREW --prefix qt5 2>/dev/null)/lib/pkgconfig:$PKG_CONFIG_PATH"
2014-09-29 21:26:31 +02:00
fi
2021-07-03 14:29:11 +02:00
2023-05-26 20:41:15 +02:00
gmp_prefix=$($BREW --prefix gmp 2>/dev/null)
if test x$gmp_prefix != x; then
CPPFLAGS="$CPPFLAGS -I$gmp_prefix/include"
LDFLAGS="$LDFLAGS -L$gmp_prefix/lib"
fi
2021-07-03 14:29:11 +02:00
case $host in
*aarch64*)
dnl The preferred Homebrew prefix for Apple Silicon is /opt/homebrew.
dnl Therefore, as we do not use pkg-config to detect miniupnpc and libnatpmp
dnl packages, we should set the CPPFLAGS and LDFLAGS variables for them
dnl explicitly.
if test "x$use_upnp" != xno && $BREW list --versions miniupnpc >/dev/null; then
miniupnpc_prefix=$($BREW --prefix miniupnpc 2>/dev/null)
if test "x$suppress_external_warnings" != xno; then
CPPFLAGS="$CPPFLAGS -isystem $miniupnpc_prefix/include"
else
CPPFLAGS="$CPPFLAGS -I$miniupnpc_prefix/include"
fi
LDFLAGS="$LDFLAGS -L$miniupnpc_prefix/lib"
fi
if test "x$use_natpmp" != xno && $BREW list --versions libnatpmp >/dev/null; then
libnatpmp_prefix=$($BREW --prefix libnatpmp 2>/dev/null)
if test "x$suppress_external_warnings" != xno; then
CPPFLAGS="$CPPFLAGS -isystem $libnatpmp_prefix/include"
else
CPPFLAGS="$CPPFLAGS -I$libnatpmp_prefix/include"
fi
LDFLAGS="$LDFLAGS -L$libnatpmp_prefix/lib"
fi
;;
esac
2013-05-28 01:55:01 +02:00
fi
2013-12-07 00:11:03 +01:00
else
case $build_os in
*darwin*)
BUILD_OS=darwin
;;
*)
2020-07-24 02:15:42 +02:00
AC_PATH_TOOL([DSYMUTIL], [dsymutil], dsymutil)
2013-12-07 00:11:03 +01:00
AC_PATH_TOOL([INSTALLNAMETOOL], [install_name_tool], install_name_tool)
AC_PATH_TOOL([OTOOL], [otool], otool)
2020-09-26 03:18:01 +02:00
AC_PATH_PROGS([XORRISOFS], [xorrisofs], xorrisofs)
AC_PATH_PROGS([DMG], [dmg], dmg)
2014-11-22 03:21:54 +01:00
dnl libtool will try to strip the static lib, which is a problem for
dnl cross-builds because strip attempts to call a hard-coded ld,
dnl which may not exist in the path. Stripping the .a is not
dnl necessary, so just disable it.
old_striplib=
2013-12-07 00:11:03 +01:00
;;
esac
2013-05-28 01:55:01 +02:00
fi
2019-12-02 21:35:27 +01:00
AX_CHECK_LINK_FLAG([[-Wl,-headerpad_max_install_names]], [LDFLAGS="$LDFLAGS -Wl,-headerpad_max_install_names"],, [[$LDFLAG_WERROR]])
2020-04-30 12:28:44 +02:00
CPPFLAGS="$CPPFLAGS -DMAC_OSX -DOBJC_OLD_DISPATCH_PROTOTYPES=0"
2015-11-10 02:50:25 +01:00
OBJCXXFLAGS="$CXXFLAGS"
2013-05-28 01:55:01 +02:00
;;
2018-07-14 04:34:17 +02:00
*android*)
dnl make sure android stays above linux for hosts like *linux-android*
2021-11-24 05:32:59 +01:00
TARGET_OS=android
2020-08-28 11:09:58 +02:00
case $host in
*x86_64*)
ANDROID_ARCH=x86_64
;;
*aarch64*)
ANDROID_ARCH=arm64-v8a
;;
*armv7a*)
ANDROID_ARCH=armeabi-v7a
;;
*) AC_MSG_ERROR("Could not determine Android arch") ;;
esac
2018-07-14 04:34:17 +02:00
;;
2014-06-04 05:42:53 +02:00
*linux*)
TARGET_OS=linux
2013-05-28 01:55:01 +02:00
;;
esac
2019-05-19 22:20:34 +02:00
if test x$use_extended_functional_tests != xno; then
AC_SUBST(EXTENDED_FUNCTIONAL_TESTS, --extended)
2015-10-12 14:37:57 +02:00
fi
2014-10-03 20:58:59 +02:00
if test x$use_lcov = xyes; then
if test x$LCOV = x; then
2013-05-28 01:55:01 +02:00
AC_MSG_ERROR("lcov testing requested but lcov not found")
fi
2015-10-11 22:05:20 +02:00
if test x$PYTHON = x; then
AC_MSG_ERROR("lcov testing requested but python not found")
fi
2014-10-03 20:58:59 +02:00
if test x$GENHTML = x; then
2013-05-28 01:55:01 +02:00
AC_MSG_ERROR("lcov testing requested but genhtml not found")
fi
2020-08-08 14:36:45 +02:00
AC_MSG_CHECKING([whether compiler is Clang])
AC_PREPROC_IFELSE([AC_LANG_SOURCE([[
#if defined(__clang__) && defined(__llvm__)
// Compiler is Clang
#else
# error Compiler is not Clang
#endif
]])],[
AC_MSG_RESULT([yes])
if test x$LLVM_COV = x; then
AC_MSG_ERROR([lcov testing requested but llvm-cov not found])
fi
COV_TOOL="$LLVM_COV gcov"
],[
AC_MSG_RESULT([no])
if test x$GCOV = x; then
AC_MSG_ERROR([lcov testing requested but gcov not found])
fi
COV_TOOL="$GCOV"
])
AC_SUBST(COV_TOOL)
AC_SUBST(COV_TOOL_WRAPPER, "cov_tool_wrapper.sh")
LCOV="$LCOV --gcov-tool $(pwd)/$COV_TOOL_WRAPPER"
2016-12-30 08:42:55 +01:00
AX_CHECK_LINK_FLAG([[--coverage]], [LDFLAGS="$LDFLAGS --coverage"],
[AC_MSG_ERROR("lcov testing requested but --coverage linker flag does not work")])
2013-05-28 01:55:01 +02:00
AX_CHECK_COMPILE_FLAG([--coverage],[CXXFLAGS="$CXXFLAGS --coverage"],
[AC_MSG_ERROR("lcov testing requested but --coverage flag does not work")])
2017-06-22 20:49:54 +02:00
CXXFLAGS="$CXXFLAGS -Og"
fi
if test x$use_lcov_branch != xno; then
AC_SUBST(LCOV_OPTS, "$LCOV_OPTS --rc lcov_branch_coverage=1")
2013-05-28 01:55:01 +02:00
fi
2014-12-19 09:53:43 +01:00
dnl Check for endianness
AC_C_BIGENDIAN
2013-05-28 01:55:01 +02:00
dnl Check for pthread compile/link requirements
AX_PTHREAD
2022-08-02 18:34:58 +02:00
dnl The following macro will add the necessary defines to bitcoin-config.h, but
2019-12-10 19:16:11 +01:00
dnl they also need to be passed down to any subprojects. Pull the results out of
dnl the cache and add them to CPPFLAGS.
2013-05-28 01:55:01 +02:00
AC_SYS_LARGEFILE
2019-12-10 19:16:11 +01:00
dnl detect POSIX or GNU variant of strerror_r
2014-05-08 14:15:19 +02:00
AC_FUNC_STRERROR_R
2013-05-28 01:55:01 +02:00
if test x$ac_cv_sys_file_offset_bits != x &&
test x$ac_cv_sys_file_offset_bits != xno &&
test x$ac_cv_sys_file_offset_bits != xunknown; then
CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits"
fi
if test x$ac_cv_sys_large_files != x &&
test x$ac_cv_sys_large_files != xno &&
test x$ac_cv_sys_large_files != xunknown; then
CPPFLAGS="$CPPFLAGS -D_LARGE_FILES=$ac_cv_sys_large_files"
fi
2014-10-14 23:31:16 +02:00
AX_GCC_FUNC_ATTRIBUTE([visibility])
AX_GCC_FUNC_ATTRIBUTE([dllexport])
AX_GCC_FUNC_ATTRIBUTE([dllimport])
2023-07-09 18:03:44 +02:00
AC_SEARCH_LIBS([clock_gettime],[rt])
2014-03-28 00:58:41 +01:00
2018-03-06 20:20:00 +01:00
if test "x$enable_gprof" = xyes; then
dnl -pg is incompatible with -pie. Since hardening and profiling together doesn't make sense,
dnl we simply make them mutually exclusive here. Additionally, hardened toolchains may force
dnl -pie by default, in which case it needs to be turned off with -no-pie.
if test x$use_hardening = xyes; then
AC_MSG_ERROR(gprof profiling is not compatible with hardening. Reconfigure with --disable-hardening or --disable-gprof)
fi
use_hardening=no
AX_CHECK_COMPILE_FLAG([-pg],[GPROF_CXXFLAGS="-pg"],
[AC_MSG_ERROR(gprof profiling requested but not available)], [[$CXXFLAG_WERROR]])
AX_CHECK_LINK_FLAG([[-no-pie]], [GPROF_LDFLAGS="-no-pie"])
AX_CHECK_LINK_FLAG([[-pg]],[GPROF_LDFLAGS="$GPROF_LDFLAGS -pg"],
[AC_MSG_ERROR(gprof profiling requested but not available)], [[$GPROF_LDFLAGS]])
fi
2015-11-10 02:50:25 +01:00
if test x$TARGET_OS != xwindows; then
2019-12-10 19:16:11 +01:00
dnl All windows code is PIC, forcing it on just adds useless compile warnings
2015-11-10 02:50:25 +01:00
AX_CHECK_COMPILE_FLAG([-fPIC],[PIC_FLAGS="-fPIC"])
2014-03-28 00:58:41 +01:00
fi
2019-12-10 19:16:11 +01:00
dnl All versions of gcc that we commonly use for building are subject to bug
dnl https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90348. To work around that, set
dnl -fstack-reuse=none for all gcc builds. (Only gcc understands this flag)
2019-05-16 13:43:55 +02:00
AX_CHECK_COMPILE_FLAG([-fstack-reuse=none],[HARDENED_CXXFLAGS="$HARDENED_CXXFLAGS -fstack-reuse=none"])
2013-05-28 01:55:01 +02:00
if test x$use_hardening != xno; then
2018-03-06 20:20:00 +01:00
use_hardening=yes
2013-05-28 01:55:01 +02:00
AX_CHECK_COMPILE_FLAG([-Wstack-protector],[HARDENED_CXXFLAGS="$HARDENED_CXXFLAGS -Wstack-protector"])
2013-10-05 13:02:47 +02:00
AX_CHECK_COMPILE_FLAG([-fstack-protector-all],[HARDENED_CXXFLAGS="$HARDENED_CXXFLAGS -fstack-protector-all"])
2014-11-29 12:29:14 +01:00
Merge #20720: build: more robustly check for fcf-protection support
e9189a750b237eba1befc6b16c12c2cee3e0176c build: more robustly check for fcf-protection support (fanquake)
Pull request description:
When using Clang 7, we may end up trying to use the flag when it won't
work properly, which can lead to confusing errors. i.e:
```bash
/usr/bin/ld: error: ... <corrupt x86 feature size: 0x8>
```
Use `AX_CHECK_LINK_FLAG` & `--fatal-warnings` to ensure we wont use the flag in this case.
We do this as even when the error is emitted, compilation succeeds, and the binaries produced will run. This means we can't just check if the compiler accepts the flag, or if compilation succeeds (without or without `-Werror`, and/or passing `-Wl,--fatal-warnings`, which may not be passed through to the linker).
This was reported by someone configuring for fuzzing, on Debian 10, where Clang 7 is the default.
See here for a minimal example of the problematic behaviour:
https://gist.github.com/fanquake/9b33555fcfebef8eb8c0795a71732bc6
ACKs for top commit:
pstratem:
tested ACK e9189a750b237eba1befc6b16c12c2cee3e0176c
MarcoFalke:
not an ACK e9189a750b237eba1befc6b16c12c2cee3e0176c , I only tested configure on my system (gcc-10, clang-11):
hebasto:
ACK e9189a750b237eba1befc6b16c12c2cee3e0176c, tested with clang-7, clang-10 and gcc: the `-fcf-protection=full` is not applied for clang-7, but applied for others compilers.
Tree-SHA512: ec24b0cc5523b90139c96cbb33bb98d1e6a24d858c466aa7dfb3c474caf8c50aca53e570fdbc0ff88378406b0ac5d687542452637b1b5fa062e829291b886fc1
2021-02-08 06:33:59 +01:00
dnl -fcf-protection used with Clang 7 causes ld to emit warnings:
dnl ld: error: ... <corrupt x86 feature size: 0x8>
dnl Use CHECK_LINK_FLAG & --fatal-warnings to ensure we wont use the flag in this case.
AX_CHECK_LINK_FLAG([-fcf-protection=full],[HARDENED_CXXFLAGS="$HARDENED_CXXFLAGS -fcf-protection=full"],, [[$LDFLAG_WERROR]])
Merge #18921: build: add stack-clash and control-flow protection options to hardening flags
b536813cefc13f5c54a28a7c2fce8c69e89d6624 build: add -fstack-clash-protection to hardening flags (fanquake)
076183b36b76a11438463883ff916f17aef9e001 build: add -fcf-protection=full to hardening options (fanquake)
Pull request description:
Beginning with Ubuntu `19.10`, it's packaged GCC now has some additional hardening options enabled by default (in addition to existing defaults like `-fstack-protector-strong` and reducing the minimum ssp buffer size). The new additions are`-fcf-protection=full` and `-fstack-clash-protection`.
> -fcf-protection=[full|branch|return|none]
> Enable code instrumentation of control-flow transfers to increase program security by checking that target addresses of control-flow transfer instructions (such as indirect function call, function return, indirect jump) are valid. This prevents diverting the flow of control to an unexpected target. This is intended to protect against such threats as Return-oriented Programming (ROP), and similarly call/jmp-oriented programming (COP/JOP).
> -fstack-clash-protection
> Generate code to prevent stack clash style attacks. When this option is enabled, the compiler will only allocate one page of stack space at a time and each page is accessed immediately after allocation. Thus, it prevents allocations from jumping over any stack guard page provided by the operating system.
If your interested you can grab `gcc-9_9.3.0-10ubuntu2.debian.tar.xz` from https://packages.ubuntu.com/focal/g++-9. The relevant changes are part of the `gcc-distro-specs` patches, along with the relevant additions to the gcc manages:
> NOTE: In Ubuntu 19.10 and later versions, -fcf-protection is enabled by default for C, C++, ObjC, ObjC++, if none of -fno-cf-protection nor -fcf-protection=* are found.
> NOTE: In Ubuntu 19.10 and later versions, -fstack-clash-protection is enabled by default for C, C++, ObjC, ObjC++, unless -fno-stack-clash-protection is found.
So, if you're C++ using GCC on Ubuntu 19.10 or later, these options will be active unless you explicitly opt out. This can be observed with a small test:
```c++
int main() { return 0; }
```
```bash
g++ --version
g++ (Ubuntu 9.3.0-10ubuntu2) 9.3.0
g++ test.cpp
objdump -dC a.out
..
0000000000001129 <main>:
1129: f3 0f 1e fa endbr64
112d: 55 push %rbp
112e: 48 89 e5 mov %rsp,%rbp
1131: b8 00 00 00 00 mov $0x0,%eax
1136: 5d pop %rbp
1137: c3 retq
1138: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1)
113f: 00
# recompile opting out of control flow protection
g++ test.cpp -fcf-protection=none
objdump -dC a.out
...
0000000000001129 <main>:
1129: 55 push %rbp
112a: 48 89 e5 mov %rsp,%rbp
112d: b8 00 00 00 00 mov $0x0,%eax
1132: 5d pop %rbp
1133: c3 retq
1134: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
113b: 00 00 00
113e: 66 90 xchg %ax,%ax
```
Note the insertion of an `endbr64` instruction when compiling and _not_ opting out. This instruction is part of the Intel Control-flow Enforcement Technology [spec](https://software.intel.com/sites/default/files/managed/4d/2a/control-flow-enforcement-technology-preview.pdf), which the GCC control flow implementation is based on.
If we're still doing gitian builds for the `0.21.0` and `0.22.0` releases, we'd likely update the gitian image to Ubuntu Focal, which would mean that the GCC used for gitian builds would also be using these options by default. So we should decide whether we want to explicitly turn these options on as part of our hardening options (although not just for this reason), or, we should be opting-out.
GCC has supported both options since 8.0.0. Clang has supported `-fcf-protection` from 7.0.0 and will support `-fstack-clash-protection` in it's upcoming [11.0.0 release](https://clang.llvm.org/docs/ReleaseNotes.html#id6).
ACKs for top commit:
jamesob:
ACK b536813cefc13f5c54a28a7c2fce8c69e89d6624 ([`jamesob/ackr/18921.1.fanquake.build_add_stack_clash_an`](https://github.com/jamesob/bitcoin/tree/ackr/18921.1.fanquake.build_add_stack_clash_an))
laanwj:
Code review ACK b536813cefc13f5c54a28a7c2fce8c69e89d6624
Tree-SHA512: abc9adf23cdf1be384f5fb9aa5bfffdda86b9ecd671064298d4cda0440828b509f070f9b19c88c7ce50ead9ff32afff9f14c5e78d75f01241568fbfa077be0b7
2020-08-29 13:40:38 +02:00
2021-03-23 04:48:26 +01:00
case $host in
*mingw*)
dnl stack-clash-protection doesn't currently work, and likely should just be skipped for Windows.
dnl See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90458 for more details.
;;
*)
2021-05-25 10:02:57 +02:00
AX_CHECK_COMPILE_FLAG([-fstack-clash-protection], [HARDENED_CXXFLAGS="$HARDENED_CXXFLAGS -fstack-clash-protection"], [], [$CXXFLAG_WERROR])
2021-03-23 04:48:26 +01:00
;;
esac
Merge #18921: build: add stack-clash and control-flow protection options to hardening flags
b536813cefc13f5c54a28a7c2fce8c69e89d6624 build: add -fstack-clash-protection to hardening flags (fanquake)
076183b36b76a11438463883ff916f17aef9e001 build: add -fcf-protection=full to hardening options (fanquake)
Pull request description:
Beginning with Ubuntu `19.10`, it's packaged GCC now has some additional hardening options enabled by default (in addition to existing defaults like `-fstack-protector-strong` and reducing the minimum ssp buffer size). The new additions are`-fcf-protection=full` and `-fstack-clash-protection`.
> -fcf-protection=[full|branch|return|none]
> Enable code instrumentation of control-flow transfers to increase program security by checking that target addresses of control-flow transfer instructions (such as indirect function call, function return, indirect jump) are valid. This prevents diverting the flow of control to an unexpected target. This is intended to protect against such threats as Return-oriented Programming (ROP), and similarly call/jmp-oriented programming (COP/JOP).
> -fstack-clash-protection
> Generate code to prevent stack clash style attacks. When this option is enabled, the compiler will only allocate one page of stack space at a time and each page is accessed immediately after allocation. Thus, it prevents allocations from jumping over any stack guard page provided by the operating system.
If your interested you can grab `gcc-9_9.3.0-10ubuntu2.debian.tar.xz` from https://packages.ubuntu.com/focal/g++-9. The relevant changes are part of the `gcc-distro-specs` patches, along with the relevant additions to the gcc manages:
> NOTE: In Ubuntu 19.10 and later versions, -fcf-protection is enabled by default for C, C++, ObjC, ObjC++, if none of -fno-cf-protection nor -fcf-protection=* are found.
> NOTE: In Ubuntu 19.10 and later versions, -fstack-clash-protection is enabled by default for C, C++, ObjC, ObjC++, unless -fno-stack-clash-protection is found.
So, if you're C++ using GCC on Ubuntu 19.10 or later, these options will be active unless you explicitly opt out. This can be observed with a small test:
```c++
int main() { return 0; }
```
```bash
g++ --version
g++ (Ubuntu 9.3.0-10ubuntu2) 9.3.0
g++ test.cpp
objdump -dC a.out
..
0000000000001129 <main>:
1129: f3 0f 1e fa endbr64
112d: 55 push %rbp
112e: 48 89 e5 mov %rsp,%rbp
1131: b8 00 00 00 00 mov $0x0,%eax
1136: 5d pop %rbp
1137: c3 retq
1138: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1)
113f: 00
# recompile opting out of control flow protection
g++ test.cpp -fcf-protection=none
objdump -dC a.out
...
0000000000001129 <main>:
1129: 55 push %rbp
112a: 48 89 e5 mov %rsp,%rbp
112d: b8 00 00 00 00 mov $0x0,%eax
1132: 5d pop %rbp
1133: c3 retq
1134: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
113b: 00 00 00
113e: 66 90 xchg %ax,%ax
```
Note the insertion of an `endbr64` instruction when compiling and _not_ opting out. This instruction is part of the Intel Control-flow Enforcement Technology [spec](https://software.intel.com/sites/default/files/managed/4d/2a/control-flow-enforcement-technology-preview.pdf), which the GCC control flow implementation is based on.
If we're still doing gitian builds for the `0.21.0` and `0.22.0` releases, we'd likely update the gitian image to Ubuntu Focal, which would mean that the GCC used for gitian builds would also be using these options by default. So we should decide whether we want to explicitly turn these options on as part of our hardening options (although not just for this reason), or, we should be opting-out.
GCC has supported both options since 8.0.0. Clang has supported `-fcf-protection` from 7.0.0 and will support `-fstack-clash-protection` in it's upcoming [11.0.0 release](https://clang.llvm.org/docs/ReleaseNotes.html#id6).
ACKs for top commit:
jamesob:
ACK b536813cefc13f5c54a28a7c2fce8c69e89d6624 ([`jamesob/ackr/18921.1.fanquake.build_add_stack_clash_an`](https://github.com/jamesob/bitcoin/tree/ackr/18921.1.fanquake.build_add_stack_clash_an))
laanwj:
Code review ACK b536813cefc13f5c54a28a7c2fce8c69e89d6624
Tree-SHA512: abc9adf23cdf1be384f5fb9aa5bfffdda86b9ecd671064298d4cda0440828b509f070f9b19c88c7ce50ead9ff32afff9f14c5e78d75f01241568fbfa077be0b7
2020-08-29 13:40:38 +02:00
2019-12-10 19:16:11 +01:00
dnl When enable_debug is yes, all optimizations are disabled.
dnl However, FORTIFY_SOURCE requires that there is some level of optimization, otherwise it does nothing and just creates a compiler warning.
dnl Since FORTIFY_SOURCE is a no-op without optimizations, do not enable it when enable_debug is yes.
2019-10-15 14:00:26 +02:00
if test x$enable_debug != xyes; then
AX_CHECK_PREPROC_FLAG([-D_FORTIFY_SOURCE=2],[
AX_CHECK_PREPROC_FLAG([-U_FORTIFY_SOURCE],[
HARDENED_CPPFLAGS="$HARDENED_CPPFLAGS -U_FORTIFY_SOURCE"
])
HARDENED_CPPFLAGS="$HARDENED_CPPFLAGS -D_FORTIFY_SOURCE=2"
2013-11-12 22:01:36 +01:00
])
2019-10-15 14:00:26 +02:00
fi
2013-05-28 01:55:01 +02:00
2023-06-04 19:34:54 +02:00
AX_CHECK_LINK_FLAG([[-Wl,--enable-reloc-section]], [HARDENED_LDFLAGS="$HARDENED_LDFLAGS -Wl,--enable-reloc-section"],, [[$LDFLAG_WERROR]])
2019-12-02 21:35:27 +01:00
AX_CHECK_LINK_FLAG([[-Wl,--dynamicbase]], [HARDENED_LDFLAGS="$HARDENED_LDFLAGS -Wl,--dynamicbase"],, [[$LDFLAG_WERROR]])
AX_CHECK_LINK_FLAG([[-Wl,--nxcompat]], [HARDENED_LDFLAGS="$HARDENED_LDFLAGS -Wl,--nxcompat"],, [[$LDFLAG_WERROR]])
AX_CHECK_LINK_FLAG([[-Wl,--high-entropy-va]], [HARDENED_LDFLAGS="$HARDENED_LDFLAGS -Wl,--high-entropy-va"],, [[$LDFLAG_WERROR]])
AX_CHECK_LINK_FLAG([[-Wl,-z,relro]], [HARDENED_LDFLAGS="$HARDENED_LDFLAGS -Wl,-z,relro"],, [[$LDFLAG_WERROR]])
AX_CHECK_LINK_FLAG([[-Wl,-z,now]], [HARDENED_LDFLAGS="$HARDENED_LDFLAGS -Wl,-z,now"],, [[$LDFLAG_WERROR]])
AX_CHECK_LINK_FLAG([[-Wl,-z,separate-code]], [HARDENED_LDFLAGS="$HARDENED_LDFLAGS -Wl,-z,separate-code"],, [[$LDFLAG_WERROR]])
2018-04-17 10:58:22 +02:00
AX_CHECK_LINK_FLAG([[-fPIE -pie]], [PIE_FLAGS="-fPIE"; HARDENED_LDFLAGS="$HARDENED_LDFLAGS -pie"],, [[$CXXFLAG_WERROR]])
2013-05-28 01:55:01 +02:00
2014-10-15 00:24:25 +02:00
case $host in
*mingw*)
2018-06-13 15:44:53 +02:00
AC_CHECK_LIB([ssp], [main],, AC_MSG_ERROR(libssp missing))
2014-10-15 00:24:25 +02:00
;;
esac
2013-05-28 01:55:01 +02:00
fi
2020-04-28 11:19:00 +02:00
dnl These flags are specific to ld64, and may cause issues with other linkers.
2021-12-28 22:45:54 +01:00
dnl For example: GNU ld will interpret -dead_strip as -de and then try and use
2020-04-28 11:19:00 +02:00
dnl "ad_strip" as the symbol for the entry point.
2013-05-28 01:55:01 +02:00
if test x$TARGET_OS = xdarwin; then
2019-12-02 21:35:27 +01:00
AX_CHECK_LINK_FLAG([[-Wl,-dead_strip]], [LDFLAGS="$LDFLAGS -Wl,-dead_strip"],, [[$LDFLAG_WERROR]])
AX_CHECK_LINK_FLAG([[-Wl,-dead_strip_dylibs]], [LDFLAGS="$LDFLAGS -Wl,-dead_strip_dylibs"],, [[$LDFLAG_WERROR]])
AX_CHECK_LINK_FLAG([[-Wl,-bind_at_load]], [HARDENED_LDFLAGS="$HARDENED_LDFLAGS -Wl,-bind_at_load"],, [[$LDFLAG_WERROR]])
2013-05-28 01:55:01 +02:00
fi
2022-04-25 11:59:51 +02:00
AC_CHECK_HEADERS([endian.h sys/endian.h byteswap.h stdio.h stdlib.h unistd.h strings.h sys/types.h sys/stat.h sys/select.h sys/prctl.h sys/sysctl.h vm/vm_param.h sys/vmmeter.h sys/resources.h])
2014-06-09 21:05:28 +02:00
2021-03-31 08:37:06 +02:00
AC_CHECK_DECLS([getifaddrs, freeifaddrs],[CHECK_SOCKET],,
2018-09-10 18:07:53 +02:00
[#include <sys/types.h>
#include <ifaddrs.h>]
)
2014-11-21 10:38:27 +01:00
AC_CHECK_DECLS([strnlen])
2019-12-10 19:16:11 +01:00
dnl Check for daemon(3), unrelated to --with-daemon (although used by it)
2016-09-30 18:02:53 +02:00
AC_CHECK_DECLS([daemon])
2021-02-23 18:51:13 +01:00
AC_CHECK_DECLS([pipe2])
2014-12-19 09:53:43 +01:00
AC_CHECK_DECLS([le16toh, le32toh, le64toh, htole16, htole32, htole64, be16toh, be32toh, be64toh, htobe16, htobe32, htobe64],,,
2014-06-09 21:05:28 +02:00
[#if HAVE_ENDIAN_H
#include <endian.h>
2015-06-07 03:38:31 +02:00
#elif HAVE_SYS_ENDIAN_H
#include <sys/endian.h>
2014-06-09 21:05:28 +02:00
#endif])
2013-05-28 01:55:01 +02:00
2014-12-19 09:53:43 +01:00
AC_CHECK_DECLS([bswap_16, bswap_32, bswap_64],,,
[#if HAVE_BYTESWAP_H
#include <byteswap.h>
2014-06-09 21:05:28 +02:00
#endif])
2013-05-28 01:55:01 +02:00
2017-04-24 14:02:12 +02:00
AC_CHECK_DECLS([__builtin_clz, __builtin_clzl, __builtin_clzll])
2017-03-31 10:36:18 +02:00
dnl Check for mallopt(M_ARENA_MAX) (to set glibc arenas)
AC_MSG_CHECKING(for mallopt M_ARENA_MAX)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <malloc.h>]],
[[ mallopt(M_ARENA_MAX, 1); ]])],
[ AC_MSG_RESULT(yes); AC_DEFINE(HAVE_MALLOPT_ARENA_MAX, 1,[Define this symbol if you have mallopt with M_ARENA_MAX]) ],
[ AC_MSG_RESULT(no)]
)
2017-03-20 15:04:59 +01:00
dnl Check for malloc_info (for memory statistics information in getmemoryinfo)
AC_MSG_CHECKING(for getmemoryinfo)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <malloc.h>]],
[[ int f = malloc_info(0, NULL); ]])],
[ AC_MSG_RESULT(yes); AC_DEFINE(HAVE_MALLOC_INFO, 1,[Define this symbol if you have malloc_info]) ],
[ AC_MSG_RESULT(no)]
)
2020-04-30 10:44:20 +02:00
dnl Check for posix_fallocate
AC_MSG_CHECKING(for posix_fallocate)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
// same as in src/util/system.cpp
#ifdef __linux__
#ifdef _POSIX_C_SOURCE
#undef _POSIX_C_SOURCE
#endif
#define _POSIX_C_SOURCE 200112L
#endif // __linux__
#include <fcntl.h>]],
[[ int f = posix_fallocate(0, 0, 0); ]])],
[ AC_MSG_RESULT(yes); AC_DEFINE(HAVE_POSIX_FALLOCATE, 1,[Define this symbol if you have posix_fallocate]) ],
[ AC_MSG_RESULT(no)]
)
2014-08-18 21:55:54 +02:00
AC_MSG_CHECKING([for visibility attribute])
AC_LINK_IFELSE([AC_LANG_SOURCE([
int foo_def( void ) __attribute__((visibility("default")));
int main(){}
])],
[
AC_DEFINE(HAVE_VISIBILITY_ATTRIBUTE,1,[Define if the visibility attribute is supported.])
AC_MSG_RESULT(yes)
],
[
AC_MSG_RESULT(no)
if test x$use_reduce_exports = xyes; then
2015-02-24 02:18:54 +01:00
AC_MSG_ERROR([Cannot find a working visibility attribute. Use --disable-reduce-exports.])
2014-08-18 21:55:54 +02:00
fi
]
)
2023-07-09 18:03:44 +02:00
if test "x$use_thread_local" = xyes || test "x$use_thread_local" = xauto; then
2019-05-25 16:39:36 +02:00
TEMP_LDFLAGS="$LDFLAGS"
LDFLAGS="$TEMP_LDFLAGS $PTHREAD_CFLAGS"
AC_MSG_CHECKING([for thread_local support])
AC_LINK_IFELSE([AC_LANG_SOURCE([
#include <thread>
static thread_local int foo = 0;
static void run_thread() { foo++;}
int main(){
for(int i = 0; i < 10; i++) { std::thread(run_thread).detach();}
return foo;
}
])],
[
case $host in
*mingw*)
2019-12-10 19:16:11 +01:00
dnl mingw32's implementation of thread_local has also been shown to behave
dnl erroneously under concurrent usage; see:
dnl https://gist.github.com/jamesob/fe9a872051a88b2025b1aa37bfa98605
2019-05-25 16:39:36 +02:00
AC_MSG_RESULT(no)
;;
*freebsd*)
2019-12-10 19:16:11 +01:00
dnl FreeBSD's implementation of thread_local is also buggy (per
dnl https://groups.google.com/d/msg/bsdmailinglist/22ncTZAbDp4/Dii_pII5AwAJ)
2019-05-25 16:39:36 +02:00
AC_MSG_RESULT(no)
;;
*)
AC_DEFINE(HAVE_THREAD_LOCAL,1,[Define if thread_local is supported.])
AC_MSG_RESULT(yes)
;;
esac
],
[
AC_MSG_RESULT(no)
]
)
LDFLAGS="$TEMP_LDFLAGS"
fi
2017-11-28 08:37:50 +01:00
2020-03-18 23:23:25 +01:00
dnl check for gmtime_r(), fallback to gmtime_s() if that is unavailable
dnl fail if neither are available.
AC_MSG_CHECKING(for gmtime_r)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <ctime>]],
[[ gmtime_r((const time_t *) nullptr, (struct tm *) nullptr); ]])],
[ AC_MSG_RESULT(yes); AC_DEFINE(HAVE_GMTIME_R, 1, [Define this symbol if gmtime_r is available]) ],
[ AC_MSG_RESULT(no);
AC_MSG_CHECKING(for gmtime_s);
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <ctime>]],
[[ gmtime_s((struct tm *) nullptr, (const time_t *) nullptr); ]])],
[ AC_MSG_RESULT(yes)],
[ AC_MSG_RESULT(no); AC_MSG_ERROR(Both gmtime_r and gmtime_s are unavailable) ]
)
]
)
2019-12-10 19:16:11 +01:00
dnl Check for different ways of gathering OS randomness
2017-03-01 12:40:06 +01:00
AC_MSG_CHECKING(for Linux getrandom syscall)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>
#include <sys/syscall.h>
#include <linux/random.h>]],
[[ syscall(SYS_getrandom, nullptr, 32, 0); ]])],
[ AC_MSG_RESULT(yes); AC_DEFINE(HAVE_SYS_GETRANDOM, 1,[Define this symbol if the Linux getrandom system call is available]) ],
[ AC_MSG_RESULT(no)]
)
AC_MSG_CHECKING(for getentropy)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]],
[[ getentropy(nullptr, 32) ]])],
[ AC_MSG_RESULT(yes); AC_DEFINE(HAVE_GETENTROPY, 1,[Define this symbol if the BSD getentropy system call is available]) ],
[ AC_MSG_RESULT(no)]
)
2017-08-07 17:13:49 +02:00
AC_MSG_CHECKING(for getentropy via random.h)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>
#include <sys/random.h>]],
[[ getentropy(nullptr, 32) ]])],
[ AC_MSG_RESULT(yes); AC_DEFINE(HAVE_GETENTROPY_RAND, 1,[Define this symbol if the BSD getentropy system call is available with sys/random.h]) ],
[ AC_MSG_RESULT(no)]
)
2022-04-25 11:59:51 +02:00
AC_MSG_CHECKING(for sysctl)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/types.h>
#include <sys/sysctl.h>]],
2020-03-19 15:23:12 +01:00
[[ #ifdef __linux__
2022-04-25 11:59:51 +02:00
#error "Don't use sysctl on Linux, it's deprecated even when it works"
#endif
2020-03-19 15:23:12 +01:00
sysctl(nullptr, 2, nullptr, nullptr, nullptr, 0); ]])],
2022-04-25 11:59:51 +02:00
[ AC_MSG_RESULT(yes); AC_DEFINE(HAVE_SYSCTL, 1,[Define this symbol if the BSD sysctl() is available]) ],
[ AC_MSG_RESULT(no)]
)
2017-03-01 12:40:06 +01:00
AC_MSG_CHECKING(for sysctl KERN_ARND)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/types.h>
#include <sys/sysctl.h>]],
2020-03-19 15:23:12 +01:00
[[ #ifdef __linux__
#error "Don't use sysctl on Linux, it's deprecated even when it works"
#endif
static int name[2] = {CTL_KERN, KERN_ARND};
2017-03-01 12:40:06 +01:00
sysctl(name, 2, nullptr, nullptr, nullptr, 0); ]])],
[ AC_MSG_RESULT(yes); AC_DEFINE(HAVE_SYSCTL_ARND, 1,[Define this symbol if the BSD sysctl(KERN_ARND) is available]) ],
[ AC_MSG_RESULT(no)]
)
2018-07-05 13:21:37 +02:00
AC_MSG_CHECKING(for if type char equals int8_t)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <stdint.h>
#include <type_traits>]],
[[ static_assert(std::is_same<int8_t, char>::value, ""); ]])],
[ AC_MSG_RESULT(yes); AC_DEFINE(CHAR_EQUALS_INT8, 1,[Define this symbol if type char equals int8_t]) ],
[ AC_MSG_RESULT(no)]
)
2019-12-10 19:16:11 +01:00
dnl ensure backtrace() is found, check -lexecinfo if necessary
2019-09-22 22:46:45 +02:00
if test x$TARGET_OS != xwindows; then
2020-12-01 05:18:46 +01:00
if test "x$enable_stacktraces" != xno; then
AC_SEARCH_LIBS([backtrace], [execinfo], [], [
AC_MSG_ERROR([Unable to find backtrace()])
])
fi
2019-09-22 22:46:45 +02:00
fi
2021-07-15 22:42:55 +02:00
AC_MSG_CHECKING(for fdatasync)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]],
[[ fdatasync(0); ]])],
[ AC_MSG_RESULT(yes); HAVE_FDATASYNC=1 ],
[ AC_MSG_RESULT(no); HAVE_FDATASYNC=0 ]
)
2021-01-07 21:56:42 +01:00
AC_DEFINE_UNQUOTED([HAVE_FDATASYNC], [$HAVE_FDATASYNC], [Define to 1 if fdatasync is available.])
2021-07-15 22:42:55 +02:00
AC_MSG_CHECKING(for F_FULLFSYNC)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <fcntl.h>]],
[[ fcntl(0, F_FULLFSYNC, 0); ]])],
[ AC_MSG_RESULT(yes); HAVE_FULLFSYNC=1 ],
[ AC_MSG_RESULT(no); HAVE_FULLFSYNC=0 ]
)
AC_MSG_CHECKING(for O_CLOEXEC)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <fcntl.h>]],
[[ open("", O_CLOEXEC); ]])],
[ AC_MSG_RESULT(yes); HAVE_O_CLOEXEC=1 ],
[ AC_MSG_RESULT(no); HAVE_O_CLOEXEC=0 ]
)
2021-02-23 18:51:13 +01:00
AC_DEFINE_UNQUOTED([HAVE_O_CLOEXEC], [$HAVE_O_CLOEXEC], [Define to 1 if O_CLOEXEC flag is available.])
2021-07-15 22:42:55 +02:00
dnl crc32c platform checks
AC_MSG_CHECKING(for __builtin_prefetch)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[
char data = 0;
const char* address = &data;
__builtin_prefetch(address, 0, 0);
]])],
[ AC_MSG_RESULT(yes); HAVE_BUILTIN_PREFETCH=1 ],
[ AC_MSG_RESULT(no); HAVE_BUILTIN_PREFETCH=0 ]
)
AC_MSG_CHECKING(for _mm_prefetch)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <xmmintrin.h>]], [[
char data = 0;
const char* address = &data;
_mm_prefetch(address, _MM_HINT_NTA);
]])],
[ AC_MSG_RESULT(yes); HAVE_MM_PREFETCH=1 ],
[ AC_MSG_RESULT(no); HAVE_MM_PREFETCH=0 ]
)
AC_MSG_CHECKING(for strong getauxval support in the system headers)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <sys/auxv.h>
]], [[
getauxval(AT_HWCAP);
]])],
2020-12-14 21:00:49 +01:00
[ AC_MSG_RESULT(yes); HAVE_STRONG_GETAUXVAL=1; AC_DEFINE(HAVE_STRONG_GETAUXVAL, 1, [Define this symbol to build code that uses getauxval)]) ],
2021-07-15 22:42:55 +02:00
[ AC_MSG_RESULT(no); HAVE_STRONG_GETAUXVAL=0 ]
)
dnl Check for reduced exports
2015-02-23 23:48:57 +01:00
if test x$use_reduce_exports = xyes; then
2014-08-18 21:55:54 +02:00
AX_CHECK_COMPILE_FLAG([-fvisibility=hidden],[RE_CXXFLAGS="-fvisibility=hidden"],
2015-02-24 02:18:54 +01:00
[AC_MSG_ERROR([Cannot set default symbol visibility. Use --disable-reduce-exports.])])
2014-08-18 21:55:54 +02:00
fi
2022-05-21 09:33:04 +02:00
AC_MSG_CHECKING([for std::system])
AC_LINK_IFELSE(
[ AC_LANG_PROGRAM(
[[ #include <cstdlib> ]],
[[ int nErr = std::system(""); ]]
)],
[ AC_MSG_RESULT(yes); AC_DEFINE(HAVE_STD__SYSTEM, 1, Define to 1 if you have the `std::system' function.)],
[ AC_MSG_RESULT(no) ]
)
AC_MSG_CHECKING([for ::_wsystem])
AC_LINK_IFELSE(
[ AC_LANG_PROGRAM(
[[ ]],
[[ int nErr = ::_wsystem(""); ]]
)],
[ AC_MSG_RESULT(yes); AC_DEFINE(HAVE_WSYSTEM, 1, Define to 1 if you have the `::wsystem' function.)],
[ AC_MSG_RESULT(no) ]
)
# Define to 1 if std::system or ::wsystem (Windows) is available
AC_DEFINE([HAVE_SYSTEM], [HAVE_STD__SYSTEM || HAVE_WSYSTEM], [std::system or ::wsystem])
2021-10-11 23:56:11 +02:00
dnl SUPPRESSED_CPPFLAGS=SUPPRESS_WARNINGS([$SOME_CPPFLAGS])
dnl Replace -I with -isystem in $SOME_CPPFLAGS to suppress warnings from
dnl headers from its include directories and return the result.
dnl See -isystem documentation:
dnl https://gcc.gnu.org/onlinedocs/gcc/Directory-Options.html
dnl https://clang.llvm.org/docs/ClangCommandLineReference.html#cmdoption-clang-isystem-directory
dnl Do not change "-I/usr/include" to "-isystem /usr/include" because that
dnl is not necessary (/usr/include is already a system directory) and because
dnl it would break GCC's #include_next.
AC_DEFUN([SUPPRESS_WARNINGS],
2022-03-29 10:58:03 +02:00
[[$(echo $1 |${SED} -E -e 's/(^| )-I/\1-isystem /g' -e 's;-isystem /usr/include/*( |$);-I/usr/include\1;g')]])
2021-10-11 23:56:11 +02:00
2019-07-10 12:21:26 +02:00
dnl enable-fuzz should disable all other targets
if test "x$enable_fuzz" = "xyes"; then
2023-08-23 13:28:58 +02:00
AC_MSG_WARN(enable-fuzz will disable all other targets and force --enable-fuzz-binary=yes)
2019-07-10 12:21:26 +02:00
build_bitcoin_utils=no
build_bitcoin_cli=no
build_bitcoin_tx=no
build_bitcoin_wallet=no
build_bitcoind=no
build_bitcoin_libs=no
bitcoin_enable_qt=no
bitcoin_enable_qt_test=no
bitcoin_enable_qt_dbus=no
enable_wallet=no
use_bench=no
use_upnp=no
2022-02-26 13:19:13 +01:00
use_natpmp=no
2019-07-10 12:21:26 +02:00
use_zmq=no
2023-08-23 13:28:58 +02:00
enable_fuzz_binary=yes
2020-10-08 13:17:25 +02:00
2022-04-13 20:20:59 +02:00
AX_CHECK_PREPROC_FLAG([-DABORT_ON_FAILED_ASSUME],[[DEBUG_CPPFLAGS="$DEBUG_CPPFLAGS -DABORT_ON_FAILED_ASSUME"]],,[[$CXXFLAG_WERROR]])
2023-08-23 13:28:58 +02:00
AC_MSG_CHECKING([whether main function is needed for fuzz binary])
2020-10-08 13:17:25 +02:00
AX_CHECK_LINK_FLAG(
[[-fsanitize=$use_sanitizers]],
[AC_MSG_RESULT([no])],
[AC_MSG_RESULT([yes])
2023-08-23 12:53:09 +02:00
CPPFLAGS="$CPPFLAGS -DPROVIDE_FUZZ_MAIN_FUNCTION"],
2020-10-08 13:17:25 +02:00
[],
[AC_LANG_PROGRAM([[
#include <cstdint>
#include <cstddef>
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { return 0; }
2021-02-05 10:04:50 +01:00
/* comment to remove the main function ...
]],[[
*/ int not_main() {
]])])
2019-07-10 12:21:26 +02:00
else
BITCOIN_QT_INIT
dnl sets $bitcoin_enable_qt, $bitcoin_enable_qt_test, $bitcoin_enable_qt_dbus
2022-02-05 22:53:46 +01:00
BITCOIN_QT_CONFIGURE([5.11.3])
2019-07-10 12:21:26 +02:00
dnl Keep a copy of the original $QT_INCLUDES and use it when invoking qt's moc
QT_INCLUDES_UNSUPPRESSED=$QT_INCLUDES
if test x$suppress_external_warnings != xno ; then
QT_INCLUDES=SUPPRESS_WARNINGS($QT_INCLUDES)
QT_DBUS_INCLUDES=SUPPRESS_WARNINGS($QT_DBUS_INCLUDES)
QT_TEST_INCLUDES=SUPPRESS_WARNINGS($QT_TEST_INCLUDES)
fi
2023-08-23 13:28:58 +02:00
2023-08-23 12:53:09 +02:00
CPPFLAGS="$CPPFLAGS -DPROVIDE_FUZZ_MAIN_FUNCTION"
2019-07-10 12:21:26 +02:00
fi
2013-11-29 16:50:11 +01:00
if test x$enable_wallet != xno; then
dnl Check for libdb_cxx only if wallet enabled
2021-04-07 09:22:49 +02:00
if test "x$use_bdb" != "xno"; then
BITCOIN_FIND_BDB48
if test x$suppress_external_warnings != xno ; then
2021-10-11 23:56:11 +02:00
BDB_CPPFLAGS=SUPPRESS_WARNINGS($BDB_CPPFLAGS)
2021-04-07 09:22:49 +02:00
fi
2021-10-11 23:56:11 +02:00
fi
2023-02-04 19:26:20 +01:00
dnl Check for sqlite3
2023-02-03 15:46:16 +01:00
if test "x$use_sqlite" != "xno"; then
PKG_CHECK_MODULES([SQLITE], [sqlite3 >= 3.7.17], [have_sqlite=yes], [have_sqlite=no])
fi
AC_MSG_CHECKING([whether to build wallet with support for sqlite])
if test "x$use_sqlite" = "xno"; then
use_sqlite=no
elif test "x$have_sqlite" = "xno"; then
if test "x$use_sqlite" = "xyes"; then
AC_MSG_ERROR([sqlite support requested but cannot be built. Use --without-sqlite])
fi
use_sqlite=no
else
if test x$use_sqlite != xno; then
AC_DEFINE([USE_SQLITE],[1],[Define if sqlite support should be compiled in])
use_sqlite=yes
fi
fi
AC_MSG_RESULT([$use_sqlite])
2023-02-04 19:28:21 +01:00
dnl Disable wallet if both --without-bdb and --without-sqlite
if test "x$use_bdb$use_sqlite" = "xnono"; then
if test "x$enable_wallet" = "xyes"; then
AC_MSG_ERROR([wallet functionality requested but no BDB or SQLite support available.])
fi
enable_wallet=no
fi
2013-11-29 16:50:11 +01:00
fi
2013-05-28 01:55:01 +02:00
2020-09-05 16:36:47 +02:00
if test x$use_ebpf != xno; then
2021-06-18 09:15:33 +02:00
AC_MSG_CHECKING([whether eBPF tracepoints are supported])
AC_COMPILE_IFELSE([
AC_LANG_PROGRAM(
[#include <sys/sdt.h>],
[DTRACE_PROBE("context", "event");]
)],
[AC_MSG_RESULT(yes); have_sdt=yes; AC_DEFINE([ENABLE_TRACING], [1], [Define to 1 to enable eBPF user static defined tracepoints])],
[AC_MSG_RESULT(no); have_sdt=no;]
)
2020-09-05 16:36:47 +02:00
fi
2013-05-28 01:55:01 +02:00
dnl Check for libminiupnpc (optional)
if test x$use_upnp != xno; then
2013-11-28 03:16:16 +01:00
AC_CHECK_HEADERS(
2024-01-10 03:01:32 +01:00
[miniupnpc/miniupnpc.h miniupnpc/upnpcommands.h miniupnpc/upnperrors.h],
2018-03-19 16:04:36 +01:00
[AC_CHECK_LIB([miniupnpc], [upnpDiscover], [MINIUPNPC_LIBS=-lminiupnpc], [have_miniupnpc=no])],
2013-11-28 03:16:16 +01:00
[have_miniupnpc=no]
)
2019-07-29 16:41:54 +02:00
dnl The minimum supported miniUPnPc API version is set to 10. This keeps compatibility
dnl with Ubuntu 16.04 LTS and Debian 8 libminiupnpc-dev packages.
if test x$have_miniupnpc != xno; then
AC_MSG_CHECKING([whether miniUPnPc API version is supported])
AC_PREPROC_IFELSE([AC_LANG_PROGRAM([[
@%:@include <miniupnpc/miniupnpc.h>
]], [[
#if MINIUPNPC_API_VERSION >= 10
// Everything is okay
#else
# error miniUPnPc API version is too old
#endif
]])],[
AC_MSG_RESULT(yes)
],[
AC_MSG_RESULT(no)
AC_MSG_WARN([miniUPnPc API version < 10 is unsupported, disabling UPnP support.])
have_miniupnpc=no
])
fi
2013-05-28 01:55:01 +02:00
fi
2022-02-26 13:19:13 +01:00
dnl Check for libnatpmp (optional).
if test "x$use_natpmp" != xno; then
AC_CHECK_HEADERS([natpmp.h],
[AC_CHECK_LIB([natpmp], [initnatpmp], [NATPMP_LIBS=-lnatpmp], [have_natpmp=no])],
[have_natpmp=no])
fi
2019-01-31 17:07:45 +01:00
if test x$build_bitcoin_wallet$build_bitcoin_cli$build_bitcoin_tx$build_bitcoind$bitcoin_enable_qt$use_tests$use_bench = xnonononononono; then
2015-01-06 14:12:39 +01:00
use_boost=no
else
use_boost=yes
fi
if test x$use_boost = xyes; then
2021-02-17 02:12:16 +01:00
dnl Check for Boost headers
AX_BOOST_BASE([1.64.0],[],[AC_MSG_ERROR([Boost is not available!])])
2017-12-19 09:14:41 +01:00
if test x$want_boost = xno; then
2022-08-02 18:35:18 +02:00
AC_MSG_ERROR([[only libdashconsensus can be built without boost]])
2017-12-19 09:14:41 +01:00
fi
2013-05-28 01:55:01 +02:00
AX_BOOST_FILESYSTEM
AX_BOOST_THREAD
2021-10-11 23:56:11 +02:00
if test x$suppress_external_warnings != xno; then
Merge bitcoin/bitcoin#25436: build: GCC-12 build improvements
880d4aaf81f3d5d7fbb915905c2e61b816a6a747 build: use BOOST_NO_CXX98_FUNCTION_BASE to suppress warnings (fanquake)
1bdbbbdc46c4e50bf07bc362e7e391ea1a53ea2f build: suppress array-bounds errors in libxkbcommon (fanquake)
Pull request description:
2 changes to better support building with GCC 12, which out of the box, is currently broken if you want to build using depends.
Prevent `-Warray-bounds` errors when building libxkbcommon. i.e:
```bash
src/xkbcomp/ast-build.c:82:27: error: array subscript 'ExprDef[0]' is partly outside array bounds of 'unsigned char[32]' [-Werror=array-bounds]
82 | expr->expr.value_type = type;
| ~~~~~~~~~~~~~~~~~~~~~~^~~~~~
src/xkbcomp/ast-build.c:75:21: note: object of size 32 allocated by 'malloc'
75 | ExprDef *expr = malloc(size);
| ^~~~~~~~~~~~
```
It might be the case that these would be fixed by updating the
package, but that would also require installing new build tools (meson),
as well as potentially more dependencies (wayland), and it'd need
testing with Qt. For now, just turn the errors into wanrings.
Define `BOOST_NO_CXX98_FUNCTION_BASE` to prevent GCC warning about the use of `std::unary_function`. i.e:
```bash
/bitcoin/depends/aarch64-unknown-linux-gnu/include/boost/container_hash/hash.hpp:131:33:
warning: 'template<class _Arg, class _Result> struct std::unary_function' is deprecated [-Wdeprecated-declarations]
131 | struct hash_base : std::unary_function<T, std::size_t> {};
| ^~~~~~~~~~~~~~
In file included from /usr/include/c++/12/bits/unique_ptr.h:37,
from /usr/include/c++/12/memory:76,
from ./init.h:10,
from init.cpp:10:
/usr/include/c++/12/bits/stl_function.h:117:12: note: declared here
117 | struct unary_function
```
Boost `container_hash` (included via functional -> multi_index) uses
[`std::unary_function`, which was deprecated in C++11](https://en.cppreference.com/w/cpp/utility/functional/unary_function), and "removed" in
C++17. It's use causes warnings with newer compilers, i.e GCC 12.1.
Use the MACRO outlined in https://github.com/boostorg/container_hash/issues/22, and added to Boost Config for GCC 12 in https://github.com/boostorg/config/pull/430, to prevent it's use.
[BOOST_NO_CXX98_FUNCTION_BASE](https://www.boost.org/doc/libs/master/libs/config/doc/html/boost_config/boost_macro_reference.html):
> The standard library no longer supports std::unary_function and std::binary_function.
> They were deprecated in C++11 and is removed from C++14.
Guix Build (x86_64):
```bash
```
Guix Build (arm64):
```bash
```
ACKs for top commit:
laanwj:
Code review ACK 880d4aaf81f3d5d7fbb915905c2e61b816a6a747
Tree-SHA512: 10c4679c3eb788e9279acc4960731c55ae1568bd3df525d3c46f97d8b0319e7d8450b1638b6777d98111b5991dba5c787e95d80b1ac932e0b4779d4b8e74875e
2022-06-27 11:12:57 +02:00
dnl Prevent use of std::unary_function, which was removed in C++17,
dnl and will generate warnings with newer compilers.
dnl See: https://github.com/boostorg/container_hash/issues/22.
BOOST_CPPFLAGS="$BOOST_CPPFLAGS -DBOOST_NO_CXX98_FUNCTION_BASE"
2021-10-11 23:56:11 +02:00
BOOST_CPPFLAGS=SUPPRESS_WARNINGS($BOOST_CPPFLAGS)
fi
2020-08-05 07:10:11 +02:00
BOOST_LIBS="$BOOST_LDFLAGS $BOOST_SYSTEM_LIB $BOOST_FILESYSTEM_LIB $BOOST_THREAD_LIB"
2015-01-06 14:12:39 +01:00
fi
2015-02-23 23:48:57 +01:00
if test x$use_reduce_exports = xyes; then
2014-08-18 21:55:54 +02:00
CXXFLAGS="$CXXFLAGS $RE_CXXFLAGS"
2019-12-02 21:35:27 +01:00
AX_CHECK_LINK_FLAG([[-Wl,--exclude-libs,ALL]], [RELDFLAGS="-Wl,--exclude-libs,ALL"],, [[$LDFLAG_WERROR]])
2014-08-18 21:55:54 +02:00
fi
2013-05-28 01:55:01 +02:00
if test x$use_tests = xyes; then
2013-09-10 21:18:09 +02:00
if test x$HEXDUMP = x; then
AC_MSG_ERROR(hexdump is required for tests)
fi
2015-01-06 14:12:39 +01:00
if test x$use_boost = xyes; then
2013-05-28 01:55:01 +02:00
AX_BOOST_UNIT_TEST_FRAMEWORK
2014-01-16 11:55:54 +01:00
dnl Determine if -DBOOST_TEST_DYN_LINK is needed
AC_MSG_CHECKING([for dynamic linked boost test])
TEMP_LIBS="$LIBS"
2014-10-10 19:00:50 +02:00
LIBS="$LIBS $BOOST_LDFLAGS $BOOST_UNIT_TEST_FRAMEWORK_LIB"
2014-01-16 11:55:54 +01:00
TEMP_CPPFLAGS="$CPPFLAGS"
CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
AC_LINK_IFELSE([AC_LANG_SOURCE([
#define BOOST_TEST_DYN_LINK
#define BOOST_TEST_MAIN
#include <boost/test/unit_test.hpp>
])],
[AC_MSG_RESULT(yes)]
[TESTDEFS="$TESTDEFS -DBOOST_TEST_DYN_LINK"],
[AC_MSG_RESULT(no)])
LIBS="$TEMP_LIBS"
CPPFLAGS="$TEMP_CPPFLAGS"
2015-01-06 14:12:39 +01:00
fi
2013-05-28 01:55:01 +02:00
fi
2020-03-09 16:33:08 +01:00
dnl libevent check
2013-05-28 01:55:01 +02:00
2020-03-09 16:33:08 +01:00
if test x$build_bitcoin_cli$build_bitcoind$bitcoin_enable_qt$use_tests$use_bench != xnonononono; then
PKG_CHECK_MODULES([EVENT], [libevent >= 2.0.21], [use_libevent=yes], [AC_MSG_ERROR([libevent version 2.0.21 or greater not found.])])
if test x$TARGET_OS != xwindows; then
PKG_CHECK_MODULES([EVENT_PTHREADS], [libevent_pthreads >= 2.0.21],, [AC_MSG_ERROR([libevent_pthreads version 2.0.21 or greater not found.])])
2015-01-20 06:04:59 +01:00
fi
2020-03-09 16:33:08 +01:00
fi
2015-01-20 06:04:59 +01:00
2020-03-09 16:33:08 +01:00
dnl QR Code encoding library check
2015-10-03 21:21:55 +02:00
2020-03-09 16:33:08 +01:00
if test "x$use_qr" != xno; then
BITCOIN_QT_CHECK([PKG_CHECK_MODULES([QR], [libqrencode], [have_qrencode=yes], [have_qrencode=no])])
fi
2016-07-30 11:40:13 +02:00
2020-03-09 16:33:08 +01:00
dnl ZMQ check
if test "x$use_zmq" = xyes; then
PKG_CHECK_MODULES([ZMQ], [libzmq >= 4],
AC_DEFINE([ENABLE_ZMQ], [1], [Define to 1 to enable ZMQ functions]),
[AC_DEFINE([ENABLE_ZMQ], [0], [Define to 1 to enable ZMQ functions])
AC_MSG_WARN([libzmq version 4.x or greater not found, disabling])
use_zmq=no])
else
AC_DEFINE_UNQUOTED([ENABLE_ZMQ], [0], [Define to 1 to enable ZMQ functions])
fi
if test "x$use_zmq" = xyes; then
dnl Assume libzmq was built for static linking
case $host in
*mingw*)
ZMQ_CFLAGS="$ZMQ_CFLAGS -DZMQ_STATIC"
;;
esac
2013-12-13 21:19:02 +01:00
fi
2013-05-28 01:55:01 +02:00
2021-08-10 21:35:55 +02:00
dnl check if libgmp is present
AC_CHECK_HEADER([gmp.h],, AC_MSG_ERROR(libgmp headers missing))
AC_CHECK_LIB([gmp], [__gmpz_init],GMP_LIBS=-lgmp, AC_MSG_ERROR(libgmp missing))
2015-03-19 15:15:08 +01:00
AC_MSG_CHECKING([whether to build dashd])
2013-09-08 04:44:12 +02:00
AM_CONDITIONAL([BUILD_BITCOIND], [test x$build_bitcoind = xyes])
AC_MSG_RESULT($build_bitcoind)
2018-09-27 17:12:28 +02:00
AC_MSG_CHECKING([whether to build dash-cli])
AM_CONDITIONAL([BUILD_BITCOIN_CLI], [test x$build_bitcoin_cli = xyes])
AC_MSG_RESULT($build_bitcoin_cli)
AC_MSG_CHECKING([whether to build dash-tx])
AM_CONDITIONAL([BUILD_BITCOIN_TX], [test x$build_bitcoin_tx = xyes])
AC_MSG_RESULT($build_bitcoin_tx)
2013-09-08 04:44:12 +02:00
2019-01-31 17:07:45 +01:00
AC_MSG_CHECKING([whether to build dash-wallet])
AM_CONDITIONAL([BUILD_BITCOIN_WALLET], [test x$build_bitcoin_wallet = xyes])
AC_MSG_RESULT($build_bitcoin_wallet)
2014-11-07 04:43:19 +01:00
AC_MSG_CHECKING([whether to build libraries])
AM_CONDITIONAL([BUILD_BITCOIN_LIBS], [test x$build_bitcoin_libs = xyes])
if test x$build_bitcoin_libs = xyes; then
AC_DEFINE(HAVE_CONSENSUS_LIB, 1, [Define this symbol if the consensus lib has been built])
2022-08-02 18:35:18 +02:00
AC_CONFIG_FILES([libdashconsensus.pc:libdashconsensus.pc.in])
2014-11-07 04:43:19 +01:00
fi
AC_MSG_RESULT($build_bitcoin_libs)
2013-05-28 01:55:01 +02:00
AC_LANG_POP
if test "x$use_ccache" != "xno"; then
2013-09-08 05:18:47 +02:00
AC_MSG_CHECKING(if ccache should be used)
2013-05-28 01:55:01 +02:00
if test x$CCACHE = x; then
if test "x$use_ccache" = "xyes"; then
AC_MSG_ERROR([ccache not found.]);
else
use_ccache=no
fi
else
use_ccache=yes
CC="$ac_cv_path_CCACHE $CC"
CXX="$ac_cv_path_CCACHE $CXX"
fi
AC_MSG_RESULT($use_ccache)
2021-04-21 07:26:12 +02:00
if test "x$use_ccache" = "xyes"; then
2021-10-11 03:55:05 +02:00
AX_CHECK_COMPILE_FLAG([-fdebug-prefix-map=A=B],[DEBUG_CXXFLAGS="$DEBUG_CXXFLAGS -fdebug-prefix-map=\$(abs_top_srcdir)=."],,[[$CXXFLAG_WERROR]])
AX_CHECK_PREPROC_FLAG([-fmacro-prefix-map=A=B],[DEBUG_CPPFLAGS="$DEBUG_CPPFLAGS -fmacro-prefix-map=\$(abs_top_srcdir)=."],,[[$CXXFLAG_WERROR]])
2021-04-21 07:26:12 +02:00
fi
2013-05-28 01:55:01 +02:00
fi
2013-11-29 16:50:11 +01:00
dnl enable wallet
AC_MSG_CHECKING([if wallet should be enabled])
if test x$enable_wallet != xno; then
AC_MSG_RESULT(yes)
AC_DEFINE_UNQUOTED([ENABLE_WALLET],[1],[Define to 1 to enable wallet functions])
2023-02-04 19:28:21 +01:00
enable_wallet=yes
2013-11-29 16:50:11 +01:00
else
AC_MSG_RESULT(no)
fi
2013-05-28 01:55:01 +02:00
dnl enable upnp support
2013-09-08 05:18:47 +02:00
AC_MSG_CHECKING([whether to build with support for UPnP])
2013-05-28 01:55:01 +02:00
if test x$have_miniupnpc = xno; then
if test x$use_upnp = xyes; then
2019-07-29 16:41:54 +02:00
AC_MSG_ERROR("UPnP requested but cannot be built. Use --without-miniupnpc.")
2013-05-28 01:55:01 +02:00
fi
AC_MSG_RESULT(no)
2019-07-29 16:41:54 +02:00
use_upnp=no
2013-05-28 01:55:01 +02:00
else
if test x$use_upnp != xno; then
AC_MSG_RESULT(yes)
use_upnp=yes
2023-01-30 11:45:00 +01:00
AC_DEFINE([USE_UPNP], [1], [Define to 1 if UPnP support should be compiled in.]) if test x$TARGET_OS = xwindows; then
2014-08-26 21:17:18 +02:00
MINIUPNPC_CPPFLAGS="-DSTATICLIB -DMINIUPNP_STATICLIB"
2013-05-28 01:55:01 +02:00
fi
else
AC_MSG_RESULT(no)
fi
fi
2022-02-26 13:19:13 +01:00
dnl Enable NAT-PMP support.
AC_MSG_CHECKING([whether to build with support for NAT-PMP])
if test "x$have_natpmp" = xno; then
if test "x$use_natpmp" = xyes; then
AC_MSG_ERROR([NAT-PMP requested but cannot be built. Use --without-natpmp])
fi
AC_MSG_RESULT([no])
use_natpmp=no
else
if test "x$use_natpmp" != xno; then
AC_MSG_RESULT([yes])
use_natpmp=yes
2023-01-30 11:45:00 +01:00
AC_DEFINE([USE_NATPMP], [1], [Define to 1 if UPnP support should be compiled in.])
2021-02-17 08:06:30 +01:00
if test x$TARGET_OS = xwindows; then
NATPMP_CPPFLAGS="-DSTATICLIB -DNATPMP_STATICLIB"
fi
2022-02-26 13:19:13 +01:00
else
AC_MSG_RESULT([no])
fi
fi
2013-05-28 01:55:01 +02:00
dnl these are only used when qt is enabled
2016-03-31 14:50:10 +02:00
BUILD_TEST_QT=""
2013-12-13 21:19:02 +01:00
if test x$bitcoin_enable_qt != xno; then
2013-05-28 01:55:01 +02:00
dnl enable dbus support
2013-09-08 05:18:47 +02:00
AC_MSG_CHECKING([whether to build GUI with support for D-Bus])
2013-12-13 21:19:02 +01:00
if test x$bitcoin_enable_qt_dbus != xno; then
2013-05-28 01:55:01 +02:00
AC_DEFINE([USE_DBUS],[1],[Define if dbus support should be compiled in])
fi
2013-12-13 21:19:02 +01:00
AC_MSG_RESULT($bitcoin_enable_qt_dbus)
2013-05-28 01:55:01 +02:00
dnl enable qr support
2013-09-08 05:18:47 +02:00
AC_MSG_CHECKING([whether to build GUI with support for QR codes])
2013-05-28 01:55:01 +02:00
if test x$have_qrencode = xno; then
2014-10-03 20:58:59 +02:00
if test x$use_qr = xyes; then
2019-12-03 22:15:14 +01:00
AC_MSG_ERROR([QR support requested but cannot be built. Use --without-qrencode])
2013-05-28 01:55:01 +02:00
fi
2019-12-03 22:15:14 +01:00
use_qr=no
2013-05-28 01:55:01 +02:00
else
if test x$use_qr != xno; then
AC_DEFINE([USE_QRCODE],[1],[Define if QR support should be compiled in])
use_qr=yes
fi
fi
2019-12-03 22:15:14 +01:00
AC_MSG_RESULT([$use_qr])
2013-05-28 01:55:01 +02:00
2014-10-03 20:58:59 +02:00
if test x$XGETTEXT = x; then
2013-12-13 21:19:02 +01:00
AC_MSG_WARN("xgettext is required to update qt translations")
fi
2015-03-19 15:15:08 +01:00
AC_MSG_CHECKING([whether to build test_dash-qt])
2016-03-31 14:50:10 +02:00
if test x$use_gui_tests$bitcoin_enable_qt_test = xyesyes; then
2013-09-08 05:18:47 +02:00
AC_MSG_RESULT([yes])
2016-03-31 14:50:10 +02:00
BUILD_TEST_QT="yes"
2013-09-08 05:18:47 +02:00
else
AC_MSG_RESULT([no])
2013-12-13 21:19:02 +01:00
fi
2013-05-28 01:55:01 +02:00
fi
2014-11-18 18:06:32 +01:00
AM_CONDITIONAL([ENABLE_ZMQ], [test "x$use_zmq" = "xyes"])
2015-03-19 15:15:08 +01:00
AC_MSG_CHECKING([whether to build test_dash])
2013-05-28 01:55:01 +02:00
if test x$use_tests = xyes; then
2020-12-10 09:10:58 +01:00
if test "x$enable_fuzz" = "xyes"; then
AC_MSG_RESULT([no, because fuzzing is enabled])
else
AC_MSG_RESULT([yes])
fi
2016-03-31 14:50:10 +02:00
BUILD_TEST="yes"
2013-09-08 05:18:47 +02:00
else
AC_MSG_RESULT([no])
2016-03-31 14:50:10 +02:00
BUILD_TEST=""
2013-05-28 01:55:01 +02:00
fi
2014-08-18 21:55:54 +02:00
AC_MSG_CHECKING([whether to reduce exports])
2015-02-23 23:48:57 +01:00
if test x$use_reduce_exports = xyes; then
2014-08-18 21:55:54 +02:00
AC_MSG_RESULT([yes])
else
AC_MSG_RESULT([no])
fi
2019-07-02 06:16:11 +02:00
# When compiled natively on MacOS, we need to specify -flat to avoid producing a dSYM bundle
# When cross-compiled on linux, we're using a different version of the tool that only supports flat symbol files
AC_MSG_CHECKING([whether dsymutil needs -flat])
if test x$DSYMUTIL != x && ($DSYMUTIL --help | grep -q \\-flat); then
AC_MSG_RESULT([yes])
DSYMUTIL_FLAT="$DSYMUTIL -flat"
else
AC_MSG_RESULT([no])
DSYMUTIL_FLAT="$DSYMUTIL"
fi
AC_MSG_RESULT($dsymutil_needs_flat)
2019-01-31 17:07:45 +01:00
if test x$build_bitcoin_wallet$build_bitcoin_cli$build_bitcoin_tx$build_bitcoind$bitcoin_enable_qt$use_tests$use_bench = xnonononononono; then
2016-08-13 15:11:01 +02:00
AC_MSG_ERROR([No targets! Please specify at least one of: --with-utils --with-libs --with-daemon --with-gui --enable-bench or --enable-tests])
2014-01-18 21:11:05 +01:00
fi
2022-10-15 21:36:10 +02:00
if test x$enable_fuzz_binary = xyes; then
CHECK_RUNTIME_LIB
fi
2013-05-28 01:55:01 +02:00
AM_CONDITIONAL([TARGET_DARWIN], [test x$TARGET_OS = xdarwin])
2013-12-07 00:11:03 +01:00
AM_CONDITIONAL([BUILD_DARWIN], [test x$BUILD_OS = xdarwin])
2022-12-28 12:22:14 +01:00
AM_CONDITIONAL([TARGET_LINUX], [test x$TARGET_OS = xlinux])
2013-05-28 01:55:01 +02:00
AM_CONDITIONAL([TARGET_WINDOWS], [test x$TARGET_OS = xwindows])
2014-10-03 20:58:59 +02:00
AM_CONDITIONAL([ENABLE_WALLET],[test x$enable_wallet = xyes])
2023-02-03 15:46:16 +01:00
AM_CONDITIONAL([USE_SQLITE], [test "x$use_sqlite" = "xyes"])
2023-02-04 19:28:21 +01:00
AM_CONDITIONAL([USE_BDB], [test "x$use_bdb" = "xyes"])
2020-09-05 16:36:47 +02:00
AM_CONDITIONAL([ENABLE_TRACING],[test x$have_sdt = xyes])
2016-03-31 14:50:10 +02:00
AM_CONDITIONAL([ENABLE_TESTS],[test x$BUILD_TEST = xyes])
2021-08-11 05:20:43 +02:00
AM_CONDITIONAL([ENABLE_FUZZ],[test x$enable_fuzz = xyes])
2023-08-23 13:28:58 +02:00
AM_CONDITIONAL([ENABLE_FUZZ_BINARY],[test x$enable_fuzz_binary = xyes])
2022-09-19 09:03:12 +02:00
AM_CONDITIONAL([ENABLE_FUZZ_LINK_ALL],[test x$enable_danger_fuzz_link_all = xyes])
2014-10-03 20:58:59 +02:00
AM_CONDITIONAL([ENABLE_QT],[test x$bitcoin_enable_qt = xyes])
2016-03-31 14:50:10 +02:00
AM_CONDITIONAL([ENABLE_QT_TESTS],[test x$BUILD_TEST_QT = xyes])
Simple benchmarking framework
Benchmarking framework, loosely based on google's micro-benchmarking
library (https://github.com/google/benchmark)
Wny not use the Google Benchmark framework? Because adding Even More Dependencies
isn't worth it. If we get a dozen or three benchmarks and need nanosecond-accurate
timings of threaded code then switching to the full-blown Google Benchmark library
should be considered.
The benchmark framework is hard-coded to run each benchmark for one wall-clock second,
and then spits out .csv-format timing information to stdout. It is left as an
exercise for later (or maybe never) to add command-line arguments to specify which
benchmark(s) to run, how long to run them for, how to format results, etc etc etc.
Again, see the Google Benchmark framework for where that might end up.
See src/bench/MilliSleep.cpp for a sanity-test benchmark that just benchmarks
'sleep 100 milliseconds.'
To compile and run benchmarks:
cd src; make bench
Sample output:
Benchmark,count,min,max,average
Sleep100ms,10,0.101854,0.105059,0.103881
2015-09-24 19:13:38 +02:00
AM_CONDITIONAL([ENABLE_BENCH],[test x$use_bench = xyes])
2013-05-28 01:55:01 +02:00
AM_CONDITIONAL([USE_QRCODE], [test x$use_qr = xyes])
2014-10-03 20:58:59 +02:00
AM_CONDITIONAL([USE_LCOV],[test x$use_lcov = xyes])
2020-04-10 18:52:32 +02:00
AM_CONDITIONAL([USE_LIBEVENT],[test x$use_libevent = xyes])
2016-01-26 20:50:50 +01:00
AM_CONDITIONAL([HARDEN],[test x$use_hardening = xyes])
2021-07-15 22:42:55 +02:00
AM_CONDITIONAL([ENABLE_SSE42],[test x$enable_sse42 = xyes])
2018-06-04 09:11:18 +02:00
AM_CONDITIONAL([ENABLE_SSE41],[test x$enable_sse41 = xyes])
AM_CONDITIONAL([ENABLE_AVX2],[test x$enable_avx2 = xyes])
2022-03-30 20:49:51 +02:00
AM_CONDITIONAL([ENABLE_X86_SHANI],[test x$enable_x86_shani = xyes])
2021-07-15 22:42:55 +02:00
AM_CONDITIONAL([ENABLE_ARM_CRC],[test x$enable_arm_crc = xyes])
2022-02-14 20:47:24 +01:00
AM_CONDITIONAL([ENABLE_ARM_SHANI], [test "$enable_arm_shani" = "yes"])
2017-09-05 22:12:42 +02:00
AM_CONDITIONAL([USE_ASM],[test x$use_asm = xyes])
2021-07-15 22:42:55 +02:00
AM_CONDITIONAL([WORDS_BIGENDIAN],[test x$ac_cv_c_bigendian = xyes])
2023-08-23 13:28:58 +02:00
AM_CONDITIONAL([USE_NATPMP],[test x$use_natpmp = xyes])
AM_CONDITIONAL([USE_UPNP],[test x$use_upnp = xyes])
2013-05-28 01:55:01 +02:00
AC_DEFINE(CLIENT_VERSION_MAJOR, _CLIENT_VERSION_MAJOR, [Major version])
AC_DEFINE(CLIENT_VERSION_MINOR, _CLIENT_VERSION_MINOR, [Minor version])
AC_DEFINE(CLIENT_VERSION_BUILD, _CLIENT_VERSION_BUILD, [Version Build])
AC_DEFINE(CLIENT_VERSION_IS_RELEASE, _CLIENT_VERSION_IS_RELEASE, [Version is release])
2016-03-31 14:28:41 +02:00
AC_DEFINE(COPYRIGHT_YEAR, _COPYRIGHT_YEAR, [Copyright year])
2016-02-04 13:41:58 +01:00
AC_DEFINE(COPYRIGHT_HOLDERS, "_COPYRIGHT_HOLDERS", [Copyright holder(s) before %s replacement])
AC_DEFINE(COPYRIGHT_HOLDERS_SUBSTITUTION, "_COPYRIGHT_HOLDERS_SUBSTITUTION", [Replacement for %s in copyright holders string])
2016-03-31 14:28:41 +02:00
define(_COPYRIGHT_HOLDERS_FINAL, [patsubst(_COPYRIGHT_HOLDERS, [%s], [_COPYRIGHT_HOLDERS_SUBSTITUTION])])
2016-02-04 13:41:58 +01:00
AC_DEFINE(COPYRIGHT_HOLDERS_FINAL, "_COPYRIGHT_HOLDERS_FINAL", [Copyright holder(s)])
2013-05-28 01:55:01 +02:00
AC_SUBST(CLIENT_VERSION_MAJOR, _CLIENT_VERSION_MAJOR)
AC_SUBST(CLIENT_VERSION_MINOR, _CLIENT_VERSION_MINOR)
AC_SUBST(CLIENT_VERSION_BUILD, _CLIENT_VERSION_BUILD)
AC_SUBST(CLIENT_VERSION_IS_RELEASE, _CLIENT_VERSION_IS_RELEASE)
AC_SUBST(COPYRIGHT_YEAR, _COPYRIGHT_YEAR)
2016-02-04 13:41:58 +01:00
AC_SUBST(COPYRIGHT_HOLDERS, "_COPYRIGHT_HOLDERS")
AC_SUBST(COPYRIGHT_HOLDERS_SUBSTITUTION, "_COPYRIGHT_HOLDERS_SUBSTITUTION")
AC_SUBST(COPYRIGHT_HOLDERS_FINAL, "_COPYRIGHT_HOLDERS_FINAL")
2016-04-15 16:43:38 +02:00
AC_SUBST(BITCOIN_DAEMON_NAME)
AC_SUBST(BITCOIN_GUI_NAME)
AC_SUBST(BITCOIN_CLI_NAME)
AC_SUBST(BITCOIN_TX_NAME)
2019-01-31 17:07:45 +01:00
AC_SUBST(BITCOIN_WALLET_TOOL_NAME)
2013-05-28 01:55:01 +02:00
2014-08-18 21:55:54 +02:00
AC_SUBST(RELDFLAGS)
2018-05-14 15:27:46 +02:00
AC_SUBST(DEBUG_CPPFLAGS)
2021-06-17 16:20:41 +02:00
AC_SUBST(WARN_CXXFLAGS)
AC_SUBST(NOWARN_CXXFLAGS)
2018-05-14 15:27:46 +02:00
AC_SUBST(DEBUG_CXXFLAGS)
2017-02-23 10:48:11 +01:00
AC_SUBST(ERROR_CXXFLAGS)
2018-03-06 20:20:00 +01:00
AC_SUBST(GPROF_CXXFLAGS)
AC_SUBST(GPROF_LDFLAGS)
2015-11-10 02:50:25 +01:00
AC_SUBST(HARDENED_CXXFLAGS)
AC_SUBST(HARDENED_CPPFLAGS)
AC_SUBST(HARDENED_LDFLAGS)
AC_SUBST(PIC_FLAGS)
AC_SUBST(PIE_FLAGS)
2018-03-29 22:57:09 +02:00
AC_SUBST(SANITIZER_CXXFLAGS)
AC_SUBST(SANITIZER_LDFLAGS)
2017-06-13 19:38:37 +02:00
AC_SUBST(SSE42_CXXFLAGS)
2018-06-04 09:11:18 +02:00
AC_SUBST(SSE41_CXXFLAGS)
AC_SUBST(AVX2_CXXFLAGS)
2022-02-14 20:47:24 +01:00
AC_SUBST(X86_SHANI_CXXFLAGS)
2021-07-15 22:42:55 +02:00
AC_SUBST(ARM_CRC_CXXFLAGS)
2022-02-14 20:47:24 +01:00
AC_SUBST(ARM_SHANI_CXXFLAGS)
2014-10-15 00:03:52 +02:00
AC_SUBST(LIBTOOL_APP_LDFLAGS)
2023-02-03 15:46:16 +01:00
AC_SUBST(USE_SQLITE)
2023-02-04 19:28:21 +01:00
AC_SUBST(USE_BDB)
2013-05-28 01:55:01 +02:00
AC_SUBST(USE_UPNP)
AC_SUBST(USE_QRCODE)
AC_SUBST(BOOST_LIBS)
2023-02-04 19:26:20 +01:00
AC_SUBST(SQLITE_LIBS)
2013-05-28 01:55:01 +02:00
AC_SUBST(TESTDEFS)
2014-08-26 21:17:18 +02:00
AC_SUBST(MINIUPNPC_CPPFLAGS)
2014-10-13 05:28:58 +02:00
AC_SUBST(MINIUPNPC_LIBS)
2021-08-10 21:35:55 +02:00
AC_SUBST(GMP_LIBS)
2021-02-17 08:06:30 +01:00
AC_SUBST(NATPMP_CPPFLAGS)
2022-02-26 13:19:13 +01:00
AC_SUBST(NATPMP_LIBS)
2016-07-08 15:08:21 +02:00
AC_SUBST(EVENT_LIBS)
AC_SUBST(EVENT_PTHREADS_LIBS)
AC_SUBST(ZMQ_LIBS)
AC_SUBST(QR_LIBS)
2019-07-02 06:16:11 +02:00
AC_SUBST(DSYMUTIL_FLAT)
2021-07-15 22:42:55 +02:00
AC_SUBST(HAVE_FDATASYNC)
AC_SUBST(HAVE_FULLFSYNC)
AC_SUBST(HAVE_O_CLOEXEC)
AC_SUBST(HAVE_BUILTIN_PREFETCH)
AC_SUBST(HAVE_MM_PREFETCH)
AC_SUBST(HAVE_STRONG_GETAUXVAL)
2020-03-18 23:23:25 +01:00
AC_SUBST(HAVE_GMTIME_R)
2020-08-28 11:09:58 +02:00
AC_SUBST(ANDROID_ARCH)
2017-06-06 23:54:23 +02:00
AC_CONFIG_FILES([Makefile src/Makefile doc/man/Makefile share/setup.nsi share/qt/Info.plist test/config.ini])
2016-06-13 07:57:21 +02:00
AC_CONFIG_FILES([contrib/devtools/split-debug.sh],[chmod +x contrib/devtools/split-debug.sh])
2018-02-17 08:49:18 +01:00
AM_COND_IF([HAVE_DOXYGEN], [AC_CONFIG_FILES([doc/Doxyfile])])
2023-06-04 19:52:35 +02:00
AC_CONFIG_LINKS([contrib/devtools/security-check.py:contrib/devtools/security-check.py])
AC_CONFIG_LINKS([contrib/devtools/test-security-check.py:contrib/devtools/test-security-check.py])
2022-12-28 12:22:14 +01:00
AC_CONFIG_LINKS([contrib/devtools/symbol-check.py:contrib/devtools/symbol-check.py])
AC_CONFIG_LINKS([contrib/devtools/test-symbol-check.py:contrib/devtools/test-symbol-check.py])
2017-10-02 13:35:08 +02:00
AC_CONFIG_LINKS([contrib/filter-lcov.py:contrib/filter-lcov.py])
2023-06-11 08:59:47 +02:00
AC_CONFIG_LINKS([contrib/macdeploy/background.tiff:contrib/macdeploy/background.tiff])
2019-05-19 22:20:34 +02:00
AC_CONFIG_LINKS([test/functional/test_runner.py:test/functional/test_runner.py])
2020-03-27 14:02:48 +01:00
AC_CONFIG_LINKS([test/fuzz/test_runner.py:test/fuzz/test_runner.py])
2019-05-19 22:20:34 +02:00
AC_CONFIG_LINKS([test/util/bitcoin-util-test.py:test/util/bitcoin-util-test.py])
2018-04-25 16:52:34 +02:00
AC_CONFIG_LINKS([test/util/rpcauth-test.py:test/util/rpcauth-test.py])
2014-11-05 16:58:37 +01:00
dnl boost's m4 checks do something really nasty: they export these vars. As a
dnl result, they leak into secp256k1's configure and crazy things happen.
dnl Until this is fixed upstream and we've synced, we'll just un-export them.
2014-11-06 02:01:42 +01:00
CPPFLAGS_TEMP="$CPPFLAGS"
2014-11-05 20:48:11 +01:00
unset CPPFLAGS
2014-11-06 02:01:42 +01:00
CPPFLAGS="$CPPFLAGS_TEMP"
LDFLAGS_TEMP="$LDFLAGS"
2014-11-05 20:48:11 +01:00
unset LDFLAGS
2014-11-06 02:01:42 +01:00
LDFLAGS="$LDFLAGS_TEMP"
LIBS_TEMP="$LIBS"
unset LIBS
LIBS="$LIBS_TEMP"
2023-09-08 09:57:53 +02:00
ac_configure_args="${ac_configure_args} --disable-shared --with-pic --enable-benchmark=no --enable-module-recovery --disable-module-ecdh"
2022-11-22 18:34:46 +01:00
AC_CONFIG_SUBDIRS([src/dashbls src/secp256k1])
2014-11-05 16:58:37 +01:00
2013-05-28 01:55:01 +02:00
AC_OUTPUT
2014-07-23 07:00:55 +02:00
2015-08-26 12:05:36 +02:00
dnl Replace the BUILDDIR path with the correct Windows path if compiling on Native Windows
case ${OS} in
*Windows*)
2017-06-06 23:54:23 +02:00
sed 's/BUILDDIR="\/\([[a-z]]\)/BUILDDIR="\1:/' test/config.ini > test/config-2.ini
mv test/config-2.ini test/config.ini
2015-08-26 12:05:36 +02:00
;;
esac
2016-11-17 16:05:53 +01:00
2018-06-24 15:56:00 +02:00
echo
2016-11-17 16:05:53 +01:00
echo "Options used to compile and link:"
2019-03-25 07:15:46 +01:00
echo " with wallet = $enable_wallet"
echo " with gui / qt = $bitcoin_enable_qt"
2023-02-03 15:46:16 +01:00
if test "x$enable_wallet" != "xno"; then
echo " with sqlite = $use_sqlite"
2023-02-04 19:28:21 +01:00
echo " with bdb = $use_bdb"
2023-02-03 15:46:16 +01:00
fi
2016-11-17 16:05:53 +01:00
if test x$bitcoin_enable_qt != xno; then
2019-03-25 07:15:46 +01:00
echo " with qr = $use_qr"
2016-11-17 16:05:53 +01:00
fi
2019-03-25 07:15:46 +01:00
echo " with zmq = $use_zmq"
2020-12-10 09:10:58 +01:00
if test x$enable_fuzz == xno; then
echo " with test = $use_tests"
else
echo " with test = not building test_dash because fuzzing is enabled"
echo " with fuzz = $enable_fuzz"
2021-08-11 05:20:43 +02:00
fi
2020-12-10 09:10:58 +01:00
echo " with bench = $use_bench"
2019-03-25 07:15:46 +01:00
echo " with upnp = $use_upnp"
2022-02-26 13:19:13 +01:00
echo " with natpmp = $use_natpmp"
2017-09-05 22:12:42 +02:00
echo " use asm = $use_asm"
2020-09-05 16:36:47 +02:00
echo " ebpf tracing = $have_sdt"
2020-11-07 23:20:40 +01:00
echo " sanitizers = $use_sanitizers"
2019-03-25 07:15:46 +01:00
echo " debug enabled = $enable_debug"
2020-12-01 05:18:46 +01:00
echo " stacktraces enabled = $enable_stacktraces"
2019-07-02 06:16:11 +02:00
echo " crash hooks enabled = $enable_crashhooks"
2019-03-25 07:15:46 +01:00
echo " miner enabled = $enable_miner"
2018-03-06 20:20:00 +01:00
echo " gprof enabled = $enable_gprof"
2019-03-25 07:15:46 +01:00
echo " werror = $enable_werror"
2018-06-24 15:56:00 +02:00
echo
2019-03-25 07:15:46 +01:00
echo " target os = $TARGET_OS"
2020-06-04 04:27:07 +02:00
echo " build os = $build_os"
2016-11-17 16:05:53 +01:00
echo
2019-03-25 07:15:46 +01:00
echo " CC = $CC"
2022-08-23 18:03:33 +02:00
echo " CFLAGS = $PTHREAD_CFLAGS $CFLAGS"
2018-05-14 15:27:46 +02:00
echo " CPPFLAGS = $DEBUG_CPPFLAGS $HARDENED_CPPFLAGS $CPPFLAGS"
2019-03-25 07:15:46 +01:00
echo " CXX = $CXX"
2021-06-17 16:20:41 +02:00
echo " CXXFLAGS = $DEBUG_CXXFLAGS $HARDENED_CXXFLAGS $WARN_CXXFLAGS $NOWARN_CXXFLAGS $ERROR_CXXFLAGS $GPROF_CXXFLAGS $CXXFLAGS"
2022-08-23 18:03:33 +02:00
echo " LDFLAGS = $PTHREAD_LIBS $HARDENED_LDFLAGS $GPROF_LDFLAGS $LDFLAGS"
2019-07-18 02:04:57 +02:00
echo " ARFLAGS = $ARFLAGS"
2018-06-24 15:56:00 +02:00
echo
