AC_PREREQ([2.63]) AUTOMAKE_OPTIONS = 1.11 AC_INIT([Construct],[1]) AC_GNU_SOURCE AC_USE_SYSTEM_EXTENSIONS AC_CANONICAL_HOST AC_CANONICAL_BUILD AC_CANONICAL_TARGET AC_PREFIX_DEFAULT([/]) AC_CONFIG_MACRO_DIR([tools/m4]) AC_CONFIG_HEADER(include/ircd/config.h) AC_PATH_PROG(AUTOMAKE, automake) AC_PATH_PROG(ACLOCAL, aclocal) AC_PATH_PROG(AUTOHEADER, autoheader) AC_PATH_PROG(AS, as) AC_PATH_PROG(RM, rm) AC_PATH_PROG(CP, cp) AC_PATH_PROG(MV, mv) AC_PATH_PROG(LN, ln) AC_PATH_PROG(LDGOLD, ld.gold) AC_PATH_PROG(LDLLD, ld.lld) AC_PATH_PROG(LD, ld.gold) AC_PATH_PROG(XXD, xxd) AC_PATH_PROG(TOUCH, touch) AC_SUBST(CFLAGS, "-pipe $CFLAGS") AC_SUBST(CXXFLAGS, "-pipe $CXXFLAGS") AC_SUBST(CCASFLAGS, "$CCASFLAGS") LT_INIT([dlopen shared disable-static]) LT_LANG([C++]) AM_PROG_AS AC_PROG_CXX AC_PROG_CXX_C_O AC_PROG_LIBTOOL AC_PROG_MAKE_SET AC_LANG(C++) AX_CXX_COMPILE_STDCXX([20], [gnu], [optional], 202002) AX_CXX_COMPILE_STDCXX([2a], [gnu], [mandatory], 201709) dnl *************************************************************************** dnl dnl Makefile tree dnl dnl These (and Makefile.in) are generated from a Makefile.am in the same dir. dnl AC_CONFIG_FILES(\ Makefile \ include/ircd/Makefile \ construct/Makefile \ ircd/Makefile \ matrix/Makefile \ modules/Makefile \ share/Makefile \ ) AM_INIT_AUTOMAKE([subdir-objects]) dnl If this is not (un)set, paths are added such as -I../include/ircd to every dnl build command and that isn't nice because it makes our headers conflict dnl with standard library/path headers which we don't want or need. AC_SUBST(DEFAULT_INCLUDES, []) dnl dnl Recursive local targets (clean-local is implied) dnl #AM_EXTRA_RECURSIVE_TARGETS([ # mrproper #]) dnl *************************************************************************** dnl dnl Platform dnl dnl dnl Compiler brand dnl AM_CONDITIONAL([GCC], [[[[ $CXX = g\+\+* ]]]]) AM_CONDITIONAL([CLANG], [[[[ $CXX = clang* ]]]]) RB_DEFINE_UNQUOTED([CXX], ["$CXX"], [CXX Compiler]) dnl dnl Compiler version dnl AX_CXX_VERSION RB_DEFINE_UNQUOTED([CXX_VERSION], ["$CXX_VERSION"], [CXX Compiler Version]) AX_CXX_EPOCH RB_DEFINE_UNQUOTED([CXX_EPOCH], [$CXX_EPOCH], [CXX Compiler Version (major nr)]) AM_CONDITIONAL([GCC8], [[[[ $CXX = g\+\+* ]] && [[ $CXX_EPOCH -ge 8 ]]]]) AM_CONDITIONAL([GCC9], [[[[ $CXX = g\+\+* ]] && [[ $CXX_EPOCH -ge 9 ]]]]) AM_CONDITIONAL([GCC10], [[[[ $CXX = g\+\+* ]] && [[ $CXX_EPOCH -ge 10 ]]]]) AM_CONDITIONAL([GCC11], [[[[ $CXX = g\+\+* ]] && [[ $CXX_EPOCH -ge 11 ]]]]) AM_CONDITIONAL([GCC12], [[[[ $CXX = g\+\+* ]] && [[ $CXX_EPOCH -ge 12 ]]]]) AM_CONDITIONAL([CLANG8], [[[[ $CXX = clang* ]] && [[ $CXX_EPOCH -ge 8 ]]]]) AM_CONDITIONAL([CLANG9], [[[[ $CXX = clang* ]] && [[ $CXX_EPOCH -ge 9 ]]]]) AM_CONDITIONAL([CLANG10], [[[[ $CXX = clang* ]] && [[ $CXX_EPOCH -ge 10 ]]]]) AM_CONDITIONAL([CLANG11], [[[[ $CXX = clang* ]] && [[ $CXX_EPOCH -ge 11 ]]]]) AM_CONDITIONAL([CLANG12], [[[[ $CXX = clang* ]] && [[ $CXX_EPOCH -ge 12 ]]]]) AM_CONDITIONAL([CLANG13], [[[[ $CXX = clang* ]] && [[ $CXX_EPOCH -ge 13 ]]]]) AM_CONDITIONAL([CLANG14], [[[[ $CXX = clang* ]] && [[ $CXX_EPOCH -ge 14 ]]]]) AM_CONDITIONAL([CLANG15], [[[[ $CXX = clang* ]] && [[ $CXX_EPOCH -ge 15 ]]]]) AM_CONDITIONAL([CLANG16], [[[[ $CXX = clang* ]] && [[ $CXX_EPOCH -ge 16 ]]]]) dnl dnl Coarse operating system test macros dnl AM_CONDITIONAL([LINUX], [[[[ $host_os = *linux* ]]]]) AM_CONDITIONAL([NETBSD], [[[[ $host_os = *netbsd* ]]]]) AM_CONDITIONAL([FREEBSD], [[[[ $host_os = *freebsd* ]]]]) AM_CONDITIONAL([MINGW], [[[[ $host_os = *mingw* ]] || [[ $host_os = *msys* ]]]]) AM_CONDITIONAL([CYGWIN], [[[[ $host_os = *cygwin* ]]]]) AM_CONDITIONAL([INTERIX], [[[[ $host_os = *interix* ]]]]) AM_CONDITIONAL([SOLARIS], [[[[ $host_os = *solaris* ]]]]) RB_DEFINE_UNQUOTED([OS], ["$host_os"], [Host operating system]) dnl dnl Standard libraries dnl AC_SEARCH_LIBS([__dynamic_cast], [c++], [], [ AC_MSG_ERROR([Please install libstdc++ on this system.]) ]) dnl *************************************************************************** dnl dnl Developer options dnl dnl dnl Debugging mode dnl AC_MSG_CHECKING(whether to enable debugging) AC_ARG_ENABLE(debug, RB_HELP_STRING([--enable-debug=[[no]]], [Enable debugging suite for development]), [ debug=$enableval ], [ debug="no" ]) AC_MSG_RESULT([$debug]) AM_CONDITIONAL([DEBUG], [[[[ "$debug" = "yes" ]]]]) AM_COND_IF([DEBUG], [ AC_SUBST(DEBUG, 1) RB_DEFINE_UNQUOTED([DEBUG], [1], [Not configured for release when lit.]) RB_DEFINE_UNQUOTED([DEBUG_LEVEL], [1], [Defined to 0 for release; or > 0 otherwise]) ], [ RB_DEFINE_UNQUOTED([DEBUG_LEVEL], [0], [Defined to 0 for release; or > 0 otherwise]) ]) dnl dnl Compactness dnl AC_MSG_CHECKING(Optimize for size; strip symbols; force no debugging) AC_ARG_ENABLE(compact, RB_HELP_STRING([--enable-compact], [Optimize for size and compactness]), [ compact=$enableval ], [ compact="no" ]) AC_MSG_RESULT([$compact]) AM_CONDITIONAL([COMPACT], [[[[ "$compact" = "yes" ]]]]) AM_COND_IF([COMPACT], [ AC_SUBST(COMPACT, 1) RB_DEFINE_UNQUOTED([COMPACT], [1], [Not configured for compactness when lit.]) ]) dnl dnl Explicit assert switch for still using assert() without --enable-debug dnl AC_MSG_CHECKING(whether to explicitly enable assertions) AC_ARG_ENABLE(assert, RB_HELP_STRING([--enable-assert], [Enable assertions without --enable-debug]), [ assert=$enableval AC_MSG_RESULT([$assert]) ], [ AM_COND_IF(DEBUG, [ assert="yes" AC_MSG_RESULT([$assert, enabled by default with --enable-debug]) ], [ assert="no" AC_MSG_RESULT([$assert]) ]) ]) AM_CONDITIONAL([ASSERT], [[[[ "$assert" = "yes" ]]]]) AM_COND_IF(ASSERT, [ assert_type="abort" AC_SUBST(ASSERT, 1) ], [ CPPDEFINE([NDEBUG]) ]) dnl dnl Switch to control the action of assert() dnl AC_MSG_CHECKING(what the result of a failed assertion implies) AC_ARG_WITH(assert, RB_HELP_STRING([--with-assert[[[=abort]]]], [Change assertion behavior]), [ assert_type=$withval ]) AM_COND_IF(ASSERT, [ AC_MSG_RESULT([$assert_type]) AC_SUBST(ASSERT_TYPE, $assert_type) if [[ ! -z "$assert_type" ]]; then if [[ "$assert_type" != "abort" ]]; then RB_DEFINE_UNQUOTED([ASSERT], ["$assert_type"], [Assertion behavior]) fi if [[ "$assert_type" == "trap" ]]; then RB_DEFINE([ASSERT_INTRINSIC], [1], [Intrinsic assertion behavior]) fi if [[ "$assert_type" == "opt" ]]; then RB_DEFINE([ASSERT_OPTIMISTIC], [1], [Optimistic assertion behavior]) fi fi ], [ AC_MSG_RESULT([nothing without assertions enabled]) assert_type="" ]) dnl dnl Explicit optimize switch for enabling optimization when using --enable-debug dnl AC_MSG_CHECKING(whether to explicitly enable optimized build) AC_ARG_ENABLE(optimize, RB_HELP_STRING([--enable-optimize], [Enable optimization even with --enable-debug]), [ optimize=$enableval AC_MSG_RESULT([$optimize]) ], [ AM_COND_IF(DEBUG, [ optimize="no" AC_MSG_RESULT([$optimize, disabled by default with --enable-debug]) ], [ optimize="yes" AC_MSG_RESULT([$optimize]) ]) ]) AM_CONDITIONAL([OPTIMIZE], [[[[ "$optimize" = "yes" ]]]]) AM_COND_IF([OPTIMIZE], [ AC_SUBST(OPTIMIZE, 1) ]) dnl dnl Enable target clones code generation dnl AC_MSG_CHECKING(whether to generate code for target clones) AC_ARG_ENABLE(clones, RB_HELP_STRING([--enable-clones], [Enable target clones generation]), [ clones="yes" ], [ clones="no" ]) AC_MSG_RESULT([$clones]) AM_CONDITIONAL([CLONES], [[[[ "$clones" = "yes" ]]]]) AM_COND_IF([CLONES], [ AC_SUBST(CLONES, 1) RB_DEFINE([CLONES], [1], [Function multi-versioning for different architectures]) ]) dnl dnl Explicit link-time-optimization switch dnl AC_MSG_CHECKING(whether to enable link-time optimization) AC_ARG_ENABLE(lto, RB_HELP_STRING([--enable-lto], [Enable link-time optimization]), [ lto=$enableval ], [ lto="yes" ]) if test "$lto" = "yes"; then AM_COND_IF(OPTIMIZE, [ AM_COND_IF(CLANG, [ AS_CASE([$host_cpu], [aarch64], [ lto="no" AC_MSG_RESULT([no, doesn't work on aarch64]) ], [ lto="yes" AC_MSG_RESULT([yes]) ]) ], [ lto="no" AC_MSG_RESULT([no, only available with clang]) ]) ], [ lto="no" AC_MSG_RESULT([no, optimizations disabled]) ]) else AC_MSG_RESULT([no]) fi AM_CONDITIONAL([LTO], [[[[ "$lto" = "yes" ]]]]) AM_COND_IF([LTO], [ AC_SUBST(LTO, 1) ]) dnl dnl Explicit optimization level switch dnl AC_MSG_CHECKING(whether to explicitly set the optimization level) AC_ARG_WITH(optimize-level, RB_HELP_STRING([--with-optimize-level[[[=3]]]], [Explicitly set the optimize level]), [ optimize_level=$withval AC_MSG_RESULT([yes, enabling optimization level -O$optimize_level]) AC_SUBST(OPTMIZE_LEVEL, $optimize_level) RB_DEFINE_UNQUOTED([OPTIMIZE_LEVEL], [$optimize_level], [User configured optimization level]) ], [ AM_COND_IF(OPTIMIZE, [ AM_COND_IF(COMPACT, [ optimize_level="s" AC_MSG_RESULT([no, but --enable-optimize and --enable-compact means -O$optimize_level]) AC_SUBST(OPTIMIZE_LEVEL, $optimize_level) RB_DEFINE_UNQUOTED([OPTIMIZE_LEVEL], [$optimize_level], [Implicitly set release mode optimization]) ], [ optimize_level="3" AC_MSG_RESULT([no, but --enable-optimize has implied level -O$optimize_level]) AC_SUBST(OPTIMIZE_LEVEL, $optimize_level) RB_DEFINE_UNQUOTED([OPTIMIZE_LEVEL], [$optimize_level], [Explicitly set release mode optimization]) ]) ], [ AM_COND_IF(DEBUG, [ optimize_level="g" AC_MSG_RESULT([no, but --enable-debug has implied level -O$optimize_level]) AC_SUBST(OPTIMIZE_LEVEL, $optimize_level) RB_DEFINE_UNQUOTED([OPTIMIZE_LEVEL], ['$optimize_level'], [Debug mode optimization level]) ], [ optimize_level="3" AC_MSG_RESULT([no, but release mode has implied level -O$optimize_level]) AC_SUBST(OPTIMIZE_LEVEL, $optimize_level) RB_DEFINE_UNQUOTED([OPTIMIZE_LEVEL], [$optimize_level], [Release mode optimization]) ]) ]) ]) dnl dnl Explicit log level dnl dnl NOTE: Log levels here must be manually sync'ed with ircd/logger.h dnl AC_MSG_CHECKING(whether to explicitly set the logging level ceiling) AC_ARG_WITH(log-level, RB_HELP_STRING([--with-log-level[[[=INFO]]]], [Explicitly set the log level ceiling]), [ AC_MSG_RESULT([yes, enabling log level $withval and below]) level=4 if [[ $withval = "DEBUG" ]]; then level=7 elif [[ $withval = "DWARNING" ]]; then level=6 elif [[ $withval = "DERROR" ]]; then level=5 elif [[ $withval = "INFO" ]]; then level=4 elif [[ $withval = "NOTICE" ]]; then level=3 elif [[ $withval = "WARNING" ]]; then level=2 elif [[ $withval = "ERROR" ]]; then level=1 elif [[ $withval = "CRITICAL" ]]; then level=0 elif [[ $withval = "-1" ]]; then level=-1 fi AC_SUBST(LOG_LEVEL, $level) RB_DEFINE_UNQUOTED([LOG_LEVEL], [$level], [Log messages for user configured level and below.]) ], [ AM_COND_IF(DEBUG, [ AC_MSG_RESULT([no, but debug mode enables all log levels through DEBUG]) AC_SUBST(LOG_LEVEL, 7) RB_DEFINE_UNQUOTED([LOG_LEVEL], [7], [Log message level default for DEBUG mode]) ], [ AC_MSG_RESULT([no]) AC_SUBST(LOG_LEVEL, 4) RB_DEFINE_UNQUOTED([LOG_LEVEL], [4], [Log message level default for release mode]) ]) ]) dnl dnl Precompiled headers dnl AC_MSG_CHECKING(whether to enable precompiled headers) AC_ARG_ENABLE(pch, RB_HELP_STRING([--enable-pch], [Enable precompiled header generation]), [ build_pch=$enableval ], [ build_pch="yes" ]) AC_MSG_RESULT([$build_pch]) AM_CONDITIONAL([BUILD_PCH], [[[[ "$build_pch" = "yes" ]]]]) AM_CONDITIONAL([CLANG_PCH], [[[[ "$build_pch" = "yes" ]] && [[ $CXX = clang* ]]]]) AM_COND_IF([BUILD_PCH], [ CPPDEFINE([PCH]) ]) dnl dnl Generic Mode compilation dnl AC_MSG_CHECKING(whether to enable generic mode or emit for this host) AC_ARG_ENABLE(generic, RB_HELP_STRING([--enable-generic], [Emit more generic code for pkg binaries]), [ enable_generic="yes" ], [ enable_generic="no" ]) AC_MSG_RESULT([$enable_generic]) AM_CONDITIONAL([GENERIC], [[[[ "$enable_generic" = "yes" ]]]]) AM_COND_IF([GENERIC], [ RB_DEFINE([GENERIC], [1], [Building binary tuned for generic architectures]) ]) dnl dnl Tuned compilation dnl machine="" AC_MSG_CHECKING(whether to emit specific architecture features) AC_ARG_WITH(machine, RB_HELP_STRING([--with-machine], [Emit special feature instructions]), [ if [[ "$withval" != "yes" ]]; then machine=$withval fi ]) if [[ ! -z "$machine" ]]; then AC_MSG_RESULT([yes]) else AC_MSG_RESULT([no]) fi dnl dnl Disable third-party allocators dnl AC_MSG_CHECKING(whether to allow available third-party allocator libraries from being used) AC_ARG_ENABLE(malloc-libs, RB_HELP_STRING([--enable-malloc-libs], [Enable third-party dynamic memory libraries (jemalloc/tcmalloc/etc)]), [ use_malloc_libs=$enableval ], [ use_malloc_libs="yes" ]) AC_MSG_RESULT([$use_malloc_libs]) AM_CONDITIONAL([MALLOC_LIBS], [[[[ "$use_malloc_libs" = "yes" ]]]]) dnl dnl Low memory compilation mode dnl AC_ARG_ENABLE(lowmem-compile, RB_HELP_STRING([--enable-lowmem-compile], [Enable low-memory compilation options]), [ lowmem_compile="yes" ], [ lowmem_compile="no" ]) AC_MSG_RESULT([$lowmem_compile]) AM_CONDITIONAL([LOWMEM_COMPILE], [[[[ $lowmem_compile = "yes" ]]]]) dnl dnl GCC toolchain selection (for clang) dnl AC_MSG_CHECKING(whether to use a specific GCC toolchain) AC_ARG_WITH(gcc-toolchain, RB_HELP_STRING([--with-gcc-toolchain], [Path to GCC toolchain]), [ with_gcc_toolchain=$withval AC_MSG_RESULT([yes, "$with_gcc_toolchain"]) AC_SUBST(GCC_TOOLCHAIN, $with_gcc_toolchain) AM_COND_IF(CLANG, [ RB_VAR_PREPEND([CXXFLAGS], ["--gcc-toolchain=$with_gcc_toolchain"]) RB_VAR_PREPEND([LDFLAGS], ["--gcc-toolchain=$with_gcc_toolchain"]) ], [ AC_MSG_WARN([--with-gcc-toolchain only applies to clang builds.]) ]) ], [ AC_MSG_RESULT([no]) ]) dnl *************************************************************************** dnl dnl Compiler flags dnl dnl dnl Reserved for user dnl dnl ex. `make EXTRA_CXXFLAGS="-Weverything" ircd` to append CXXFLAGS dnl AC_SUBST(EXTRA_CPPFLAGS, "$EXTRA_CPPFLAGS") dnl AC_SUBST(EXTRA_CFLAGS, "$EXTRA_CFLAGS") dnl AC_SUBST(EXTRA_CXXFLAGS, "$EXTRA_CXXFLAGS") dnl AC_SUBST(EXTRA_LDFLAGS, "$EXTRA_LDFLAGS") dnl AC_SUBST(EXTRA_LIBS, "$EXTRA_LIBS") dnl dnl Features dnl AM_COND_IF([GCC], [ dnl RB_VAR_PREPEND([CXXFLAGS], ["-fmodules-ts"]) ]) AM_COND_IF([CLANG], [ dnl RB_VAR_PREPEND([CXXFLAGS], ["-fmodules"]) ]) AM_COND_IF([CLANG], [ RB_VAR_PREPEND([CXXFLAGS], ["-fblocks"]) RB_VAR_PREPEND([CXXFLAGS], ["-fasm-blocks"]) ]) AM_COND_IF([CLANG11], [ RB_VAR_PREPEND([CXXFLAGS], ["-fenable-matrix"]) ]) dnl dnl Misc dnl dnl This disables thread-safety for static variable initialization dnl (specifically local static variables inside functions) which reduces dnl generated code size and complexity. This is alright since construct is dnl primarily single threaded. Even if other threads are spawned for special dnl tasks we consider the likelyhood of a static initialization race to either dnl be sufficiently low or simply immaterial for our uses of them. dnl RB_VAR_PREPEND([CXXFLAGS], ["-fno-threadsafe-statics"]) dnl Exception safety at instruction boundary rather than function boundary dnl This option is needed to enable noexcept(false) i.e to throw from a dnl destructor; without this noexcept(false) still terminates. RB_VAR_PREPEND([CXXFLAGS], ["-fasynchronous-unwind-tables"]) dnl -fvisibility-inlines-hidden - for optimization; note the address of inline dnl functions won't be the same between translation units RB_VAR_PREPEND([CXXFLAGS], ["-fvisibility-inlines-hidden"]) dnl see gcc(1) AM_COND_IF([GCC], [ RB_VAR_PREPEND([CXXFLAGS], ["-fnothrow-opt"]) ]) AM_COND_IF([GCC], [ RB_VAR_PREPEND([CXXFLAGS], ["-flax-vector-conversions"]) ]) dnl dnl Optimization dnl RB_VAR_PREPEND([CXXFLAGS], ["-O$optimize_level"]) AM_COND_IF([OPTIMIZE], [ optimize="yes" AM_COND_IF([GCC], [ RB_VAR_PREPEND([CXXFLAGS], ["-fgcse-sm"]) RB_VAR_PREPEND([CXXFLAGS], ["-fgcse-las"]) RB_VAR_PREPEND([CXXFLAGS], ["-fsched-stalled-insns=0"]) RB_VAR_PREPEND([CXXFLAGS], ["-fsched-pressure"]) RB_VAR_PREPEND([CXXFLAGS], ["-fsched-spec-load"]) dnl RB_VAR_PREPEND([CXXFLAGS], ["-fsched2-use-superblocks"]) dnl RB_VAR_PREPEND([CXXFLAGS], ["-fsched2-use-superblocks"]) RB_VAR_PREPEND([CXXFLAGS], ["-fira-hoist-pressure"]) RB_VAR_PREPEND([CXXFLAGS], ["-fbranch-target-load-optimize"]) RB_VAR_PREPEND([CXXFLAGS], ["-frerun-loop-opt"]) RB_VAR_PREPEND([CXXFLAGS], ["-fdevirtualize-at-ltrans"]) dnl RB_VAR_PREPEND([CXXFLAGS], ["-fbtr-bb-exclusive"]) RB_VAR_PREPEND([CXXFLAGS], ["-fipa-pta"]) RB_VAR_PREPEND([CXXFLAGS], ["-fmodulo-sched"]) RB_VAR_PREPEND([CXXFLAGS], ["-fmodulo-sched-allow-regmoves"]) RB_VAR_PREPEND([CXXFLAGS], ["-ftracer"]) RB_VAR_PREPEND([CXXFLAGS], ["-ftree-loop-im"]) RB_VAR_PREPEND([CXXFLAGS], ["-ftree-switch-conversion"]) ]) ], [ optimize="no" dnl Optimization options we enable in non-optimized mode. These will be enabled dnl in non-optimized mode as well as optimized mode so they are as similar as dnl possible without impacting debuggability. RB_VAR_PREPEND([CXXFLAGS], ["-falign-functions"]) dnl RB_VAR_PREPEND([CXXFLAGS], ["-fdata-sections"]) dnl RB_VAR_PREPEND([CXXFLAGS], ["-ffunction-sections"]) RB_VAR_PREPEND([CXXFLAGS], ["-ftree-vectorize"]) AM_COND_IF([GCC], [ RB_VAR_PREPEND([CXXFLAGS], ["-falign-labels"]) RB_VAR_PREPEND([CXXFLAGS], ["-falign-loops"]) RB_VAR_PREPEND([CXXFLAGS], ["-falign-jumps"]) RB_VAR_PREPEND([CXXFLAGS], ["-ftree-vrp"]) RB_VAR_PREPEND([CXXFLAGS], ["-ftree-dce"]) RB_VAR_PREPEND([CXXFLAGS], ["-ftree-dse"]) RB_VAR_PREPEND([CXXFLAGS], ["-ftree-loop-im"]) RB_VAR_PREPEND([CXXFLAGS], ["-ftree-switch-conversion"]) ]) ]) AM_COND_IF([CLANG], [ RB_VAR_PREPEND([CXXFLAGS], ["-fno-data-sections"]) RB_VAR_PREPEND([CXXFLAGS], ["-fno-function-sections"]) ]) dnl dnl Compiler intrumentation dnl dnl XXX workaround for valgrind; remove once valgrind is updated AM_COND_IF([DEBUG], [ AM_COND_IF([CLANG14], [ RB_VAR_PREPEND([CXXFLAGS], ["-gdwarf-4"]) ]) ]) dnl Enable debugging symbols. AM_COND_IF([DEBUG], [ RB_VAR_PREPEND([CXXFLAGS], ["-ggdb"]) RB_VAR_PREPEND([CXXFLAGS], ["-g"]) ]) AM_COND_IF([DEBUG], [ AM_COND_IF([GCC], [ RB_VAR_PREPEND([CXXFLAGS], ["-fvar-tracking-assignments"]) RB_VAR_PREPEND([CXXFLAGS], ["-fvar-tracking"]) ]) ]) RB_VAR_PREPEND([CXXFLAGS], ["-fverbose-asm"]) dnl Creates an ELF section in the output which contains a list of dnl the command line arguments used for compilation. AM_COND_IF([GCC], [ RB_VAR_PREPEND([CXXFLAGS], ["-frecord-gcc-switches"]) ]) AM_COND_IF([CLANG], [ RB_VAR_PREPEND([CXXFLAGS], ["-grecord-gcc-switches"]) RB_VAR_PREPEND([CXXFLAGS], ["-fno-discard-value-names"]) RB_VAR_PREPEND([CXXFLAGS], ["-fident"]) ]) AM_COND_IF([DEBUG], [ AM_COND_IF([GCC], [ RB_VAR_PREPEND([CXXFLAGS], ["-fmax-errors=2"]) ]) AM_COND_IF([CLANG], [ RB_VAR_PREPEND([CXXFLAGS], ["-ferror-limit=2"]) ]) ]) AM_COND_IF([BUILD_PCH], [ AM_COND_IF([GCC], [ RB_VAR_PREPEND([CXXFLAGS], ["-fpch-deps"]) ]) AM_COND_IF([CLANG], [ RB_VAR_PREPEND([CPPFLAGS], ["-fpch-preprocess"]) ]) AM_COND_IF([CLANG10], [ RB_VAR_PREPEND([CXXFLAGS], ["-fpch-validate-input-files-content"]) ]) ]) dnl dnl Runtime intrumentation dnl AM_COND_IF([GCC], [ RB_VAR_PREPEND([CXXFLAGS], ["-fstack-protector-explicit"]) AS_CASE([$host_cpu], [x86_64], [ dnl These flags should not be used on Intel-CET capable platforms dnl TODO: XXX AS_IF([test "$CXX_EPOCH" -ge "9"], [ AM_COND_IF([GENERIC], [ RB_VAR_PREPEND([CXXFLAGS], ["-fcf-protection=return"]) ], [ RB_VAR_PREPEND([CXXFLAGS], ["-fcf-protection=none"]) RB_VAR_PREPEND([CXXFLAGS], ["-mmanual-endbr"]) ]) ]) ]) ]) AM_COND_IF([GCC], [ RB_VAR_PREPEND([CXXFLAGS], ["-fvtable-verify=none"]) ]) dnl dnl Machine Tuning dnl MACHINE_FLAGS="" dnl Initial machine machine_arch="native" machine_tune="native" AM_COND_IF([CLANG], [ AS_IF([test "$CXX_EPOCH" -lt "15"], [ AS_IF([test "$host_cpu" = "aarch64"], [ machine_arch="" ]) ]) ]) AM_COND_IF([GENERIC], [ machine_tune="generic" AS_CASE([$host_cpu], [x86_64], [ machine_arch="x86-64" ]) ]) dnl Specific extension specification machine_feat="" for feature in $machine; do if [[ $(echo $feature | cut -d"=" -f1) == "arch" ]]; then machine_arch=$(echo $feature | cut -d"=" -f2) elif [[ $(echo $feature | cut -d"=" -f1) == "tune" ]]; then machine_tune=$(echo $feature | cut -d"=" -f2) else machine_feat="$feature $machine_feat" RB_VAR_PREPEND([MACHINE_FLAGS], [-m${feature}]) fi done dnl Ensures mtune=generic accompanies one of the generic march= options dnl even if --enable-generic wasn't given, otherwise gcc will reject. AM_COND_IF_NOT([GENERIC], [ AS_CASE([$machine_arch], [x86-64*], [ machine_tune="generic" ], [ machine_tune=$machine_arch ]) ]) dnl Specific extension underrides AS_CASE([$host_cpu], [x86_64], [ dnl AMD K10's SSE4a doesn't work with valgrind RB_VAR_PREPEND([MACHINE_FLAGS], [-mno-sse4a]) ]) if [[ ! -z "$machine_tune" ]]; then RB_VAR_PREPEND([MACHINE_FLAGS], [-mtune=$machine_tune]) fi if [[ ! -z "$machine_arch" ]]; then RB_VAR_PREPEND([MACHINE_FLAGS], [-march=$machine_arch]) fi machine_tuning="${host_cpu} arch=$machine_arch tune=$machine_tune :$machine_feat" RB_VAR_PREPEND([CXXFLAGS], [$MACHINE_FLAGS]) dnl Get the target features for this build from gcc into a readable string AM_COND_IF([GCC], [ _cxx=$(echo "${CXX}" | cut -d' ' -f1) _cmd="${_cxx} -Q --help=target ${MACHINE_FLAGS}" machine_features=$(${_cmd} | grep enabled | grep -v 'mno-') machine_features=$(printf "\n${machine_features}") ]) dnl Get the target features for this build from clang into a readable string AM_COND_IF([CLANG], [ _flag=0 _cxx=$(echo "${CXX}" | cut -d' ' -f1) _str=$(${_cxx} -E ${MACHINE_FLAGS} - -### 2>&1) machine_features="" for i in $_str; do if [[ $i == '"-target-feature"' ]]; then _flag=1 elif [[ $_flag == 1 ]]; then _flag=0 attr=$(echo $i | sed -e 's/^"//' -e 's/"$//') if [[ ${attr:0:1} == '+' ]]; then machine_features="${machine_features}${attr} " fi fi done ]) dnl dnl Compiler warnings dnl AC_MSG_CHECKING(whether to enable warnings) AC_ARG_ENABLE(warnings, RB_HELP_STRING([--enable-warnings], [Disable all sorts of warnings like a rockstar]), [ warnings=$enableval ], [ warnings="yes" ]) AC_MSG_RESULT([$warnings]) AM_CONDITIONAL([WARNINGS], [[[[ "$warnings" = "yes" ]]]]) AC_DEFUN([RB_MAYBE_CWARN], [ AM_COND_IF([WARNINGS], [ RB_MAYBE_CXXFLAG([$1], [$2]) ]) ]) STACK_USAGE_WARNING=16384 FRAME_SIZE_WARNING=8192 CWARNS="" dnl Compatible warnings RB_MAYBE_CWARN([-Wall], charybdis_cv_c_gcc_w_all) RB_MAYBE_CWARN([-Wextra], charybdis_cv_c_gcc_w_extra) RB_MAYBE_CWARN([-Wpointer-arith], charybdis_cv_c_gcc_w_pointer_arith) RB_MAYBE_CWARN([-Wcast-align], charybdis_cv_c_gcc_w_cast_align) RB_MAYBE_CWARN([-Wcast-qual], charybdis_cv_c_gcc_w_cast_qual) RB_MAYBE_CWARN([-Wfloat-equal], charybdis_cv_c_gcc_w_float_equal) RB_MAYBE_CWARN([-Wwrite-strings], charybdis_cv_c_gcc_w_write_strings) RB_MAYBE_CWARN([-Wparentheses], charybdis_cv_c_gcc_parentheses) RB_MAYBE_CWARN([-Wundef], charybdis_cv_c_gcc_w_undef) RB_MAYBE_CWARN([-Wpacked], charybdis_cv_c_gcc_w_packed) RB_MAYBE_CWARN([-Wformat -Wformat-y2k -Wformat-nonliteral], charybdis_cv_c_gcc_w_format) RB_MAYBE_CWARN([-Wstrict-aliasing=2 -Wstrict-overflow=5], charybdis_cv_c_gcc_w_strict) RB_MAYBE_CWARN([-Wdisabled-optimization], charybdis_cv_c_gcc_w_disabled_optimization) RB_MAYBE_CWARN([-Winvalid-pch], charybdis_cv_c_gcc_w_invalid_pch) RB_MAYBE_CWARN([-Winit-self], charybdis_cv_c_gcc_w_init_self) RB_MAYBE_CWARN([-Wunreachable-code], charybdis_cv_c_gcc_w_unreachable_code) RB_MAYBE_CWARN([-Wno-overloaded-virtual], charybdis_cv_c_gcc_w_overloaded_virtual) RB_MAYBE_CWARN([-Wnon-virtual-dtor], charybdis_cv_c_gcc_w_non_virtual_dtor) RB_MAYBE_CWARN([-Wsized-deallocation], charybdis_cv_c_gcc_w_sized_deallocation) RB_MAYBE_CWARN([-Wctor-dtor-privacy], charybdis_cv_c_gcc_w_ctor_dtor_privacy) RB_MAYBE_CWARN([-Wsign-promo], charybdis_cv_c_gcc_w_sign_promo) RB_MAYBE_CWARN([-Wtrampolines], charybdis_cv_c_gcc_w_trampolines) RB_MAYBE_CWARN([-Wduplicated-cond], charybdis_cv_c_gcc_w_duplicated_cond) RB_MAYBE_CWARN([-Wduplicate-branches], charybdis_cv_c_gcc_w_duplicate_branches) RB_MAYBE_CWARN([-Wrestrict], charybdis_cv_c_gcc_w_restrict) RB_MAYBE_CWARN([-Wnull-dereference], charybdis_cv_c_gcc_w_null_dereference) RB_MAYBE_CWARN([-Wplacement-new=2], charybdis_cv_c_gcc_w_placement_new) RB_MAYBE_CWARN([-Wundef], charybdis_cv_c_gcc_w_undef) RB_MAYBE_CWARN([-Wodr], charybdis_cv_c_gcc_w_odr) RB_MAYBE_CWARN([-Wimplicit-fallthrough], charybdis_cv_c_gcc_w_implicit_fallthrough) RB_MAYBE_CWARN([-Werror=return-type], charybdis_cv_c_gcc_w_error_return_type) RB_MAYBE_CWARN([-Werror=reorder], charybdis_cv_c_gcc_w_error_reorder) dnl Compiler specific AM_COND_IF([GCC], [ RB_MAYBE_CWARN([-Werror=return-local-addr], charybdis_cv_c_gcc_w_error_return_local_addr) RB_MAYBE_CWARN([-Wlogical-op], charybdis_cv_c_gcc_w_logical_op) RB_MAYBE_CWARN([-Wformat-security], charybdis_cv_c_gcc_w_format_security) RB_MAYBE_CWARN([-Wstack-usage=$STACK_USAGE_WARNING], charybdis_cv_c_gcc_w_stack_usage) RB_MAYBE_CWARN([-Wframe-larger-than=$FRAME_SIZE_WARNING], charybdis_cv_c_gcc_w_frame_larger_than) RB_MAYBE_CWARN([-Walloca], charybdis_cv_c_gcc_w_alloca) RB_MAYBE_CWARN([-Wvector-operation-performance], charybdis_cv_c_gcc_w_vector_operation_performance) RB_MAYBE_CWARN([-Wstringop-overflow=4], charybdis_cv_c_gcc_w_stringop_overflow) ]) dnl Compiler specific AM_COND_IF([CLANG], [ RB_MAYBE_CWARN([-Werror=return-stack-address], charybdis_cv_c_gcc_w_error_return_stack_address) RB_MAYBE_CWARN([-Wundefined-reinterpret-cast], charybdis_cv_c_gcc_w_undefined_reinterpret_cast) RB_MAYBE_CWARN([-Wconditional-uninitialized], charybdis_cv_c_gcc_w_conditional_uninitialized) RB_MAYBE_CWARN([-Wno-mismatched-tags], charybdis_cv_c_gcc_w_mismatched_tags) RB_MAYBE_CWARN([-Wno-format-security], charybdis_cv_c_gcc_w_format_security) RB_MAYBE_CWARN([-Wno-unknown-warning-option], charybdis_cv_c_gcc_w_unknown_warning_option) RB_MAYBE_CWARN([-Wno-profile-instr-unprofiled], charybdis_cv_c_gcc_w_profile_instr_unprofiled) ]) dnl dnl Warnings we suppress: dnl dnl Missing field initializers should have default init or some zero-extension as per std, this dnl warning is only useful if you want to gauge where that's happening for a specific reason RB_MAYBE_CWARN([-Wno-missing-field-initializers], charybdis_cv_c_gcc_w_missing_field_initializers) dnl Unused variables, functions, labels, etc are just fine as long as they get optimized dnl away. These warnings can be re-enabled during a code cleanup, otherwise shut up. RB_MAYBE_CWARN([-Wno-unused], charybdis_cv_c_gcc_w_unused) RB_MAYBE_CWARN([-Wno-unused-function], charybdis_cv_c_gcc_w_unused_function) RB_MAYBE_CWARN([-Wno-unused-label], charybdis_cv_c_gcc_w_unused_label) RB_MAYBE_CWARN([-Wno-unused-value], charybdis_cv_c_gcc_w_unused_value) RB_MAYBE_CWARN([-Wno-unused-variable], charybdis_cv_c_gcc_w_unused_variable) RB_MAYBE_CWARN([-Wno-unused-parameter], charybdis_cv_c_gcc_w_unused_parameter) dnl Re-enable -Wunused-result so explicit annotations will still warn. RB_MAYBE_CWARN([-Wunused-result], charybdis_cv_c_gcc_w_unused_result) dnl This warning is disabled to allow preprocessor statements like #endif to dnl contain text on the same line. This is used for example to write the dnl identifier in the matching prior #ifdef, which has no actual effect except dnl clarity. RB_MAYBE_CWARN([-Wno-endif-labels], charybdis_cv_c_gcc_w_endif_labels) dnl dnl Suppressed unless in debug mode dnl AM_COND_IF([DEBUG], [ RB_MAYBE_CWARN([-Wsuggest-final-types], charybdis_cv_c_gcc_w_suggest_final_types) RB_MAYBE_CWARN([-Wsuggest-final-methods], charybdis_cv_c_gcc_w_suggest_final_methods) RB_MAYBE_CWARN([-Wsuggest-override], charybdis_cv_c_gcc_w_suggest_override) RB_MAYBE_CWARN([-Wmissing-noreturn], charybdis_cv_c_gcc_w_missing_noreturn) RB_MAYBE_CWARN([-Wuninitialized], charybdis_cv_c_gcc_w_uninitialized) AM_COND_IF([GCC], [ RB_MAYBE_CWARN([-Wnoexcept], charybdis_cv_c_gcc_w_noexcept) RB_MAYBE_CWARN([-Wsuggest-attribute=format], charybdis_cv_c_gcc_w_suggest_attribute_format) RB_MAYBE_CWARN([-Wsuggest-attribute=noreturn], charybdis_cv_c_gcc_w_suggest_attribute_noreturn) RB_MAYBE_CWARN([-Wsuggest-attribute=malloc], charybdis_cv_c_gcc_w_suggest_attribute_malloc) RB_MAYBE_CWARN([-Wsuggest-attribute=cold], charybdis_cv_c_gcc_w_suggest_attribute_cold) dnl RB_MAYBE_CWARN([-Wsuggest-attribute=pure], charybdis_cv_c_gcc_w_suggest_attribute_pure) dnl RB_MAYBE_CWARN([-Wsuggest-attribute=const], charybdis_cv_c_gcc_w_suggest_attribute_const) ]) ], [ RB_MAYBE_CWARN([-Wno-unknown-pragmas], charybdis_cv_c_gcc_w_no_unknown_pragmas) RB_MAYBE_CWARN([-Wno-deprecated-declarations], charybdis_cv_c_gcc_w_no_deprecated_declarations) RB_MAYBE_CWARN([-Wno-deprecated], charybdis_cv_c_gcc_w_no_deprecated) AM_COND_IF([CLANG], [ RB_MAYBE_CWARN([-Wno-unknown-attributes], charybdis_cv_c_gcc_w_no_unknown_attributes) RB_MAYBE_CWARN([-Wno-uninitialized], charybdis_cv_c_gcc_w_no_uninitialized) ]) AM_COND_IF([GCC], [ RB_MAYBE_CWARN([-Wno-ignored-attributes], charybdis_cv_c_gcc_w_no_ignored_attributes) RB_MAYBE_CWARN([-Wno-attributes], charybdis_cv_c_gcc_w_no_attributes) RB_MAYBE_CWARN([-Wno-pragmas], charybdis_cv_c_gcc_w_no_pragmas) RB_MAYBE_CWARN([-Wno-empty-body], charybdis_cv_c_gcc_w_no_empty_body) ]) ]) dnl dnl List of compiler-specific / incompatible warning options dnl dnl Warning discovery section AC_MSG_CHECKING(whether to enable warning discovery) AC_ARG_ENABLE(every-warning, RB_HELP_STRING([--enable-every-warning], [Enable warning discovery (-Weverything)]), [ AC_MSG_RESULT([yes]) RB_MAYBE_CWARN([-Weverything], charybdis_cv_c_gcc_w_everything) dnl Ignored a priori RB_MAYBE_CWARN([-Wno-c++98-compat], charybdis_cv_c_gcc_w_no_cxx98_compat) RB_MAYBE_CWARN([-Wno-c++98-compat-pedantic], charybdis_cv_c_gcc_w_no_cxx98_compat_pedantic) RB_MAYBE_CWARN([-Wno-c++98-compat-extra-semi], charybdis_cv_c_gcc_w_no_cxx98_compat_extra_semi) RB_MAYBE_CWARN([-Wno-pre-c++14-compat], charybdis_cv_c_gcc_w_no_pre_cxx14_compat) RB_MAYBE_CWARN([-Wno-pre-c++17-compat], charybdis_cv_c_gcc_w_no_pre_cxx17_compat) dnl Ignored by design RB_MAYBE_CWARN([-Wno-comma], charybdis_cv_c_gcc_w_no_comma) RB_MAYBE_CWARN([-Wno-shadow], charybdis_cv_c_gcc_w_no_shadow) RB_MAYBE_CWARN([-Wno-shadow-field], charybdis_cv_c_gcc_w_no_shadow_field) RB_MAYBE_CWARN([-Wno-shadow-field-in-constructor], charybdis_cv_c_gcc_w_no_shadow_field_in_constructor) RB_MAYBE_CWARN([-Wno-shadow-uncaptured-local], charybdis_cv_c_gcc_w_no_shadow_uncaptured_local) RB_MAYBE_CWARN([-Wno-gnu-conditional-omitted-operand], charybdis_cv_c_gcc_w_no_gnu_conditional_omitted_operand) RB_MAYBE_CWARN([-Wno-ctad-maybe-unsupported], charybdis_cv_c_gcc_w_no_ctad_maybe_unsupported) RB_MAYBE_CWARN([-Wno-disabled-macro-expansion], charybdis_cv_c_gcc_w_no_disabled_macro_expansion) dnl Ignored for now RB_MAYBE_CWARN([-Wno-padded], charybdis_cv_c_gcc_w_no_padded) RB_MAYBE_CWARN([-Wno-sign-conversion], charybdis_cv_c_gcc_w_no_sign_conversion) RB_MAYBE_CWARN([-Wno-unused-exception-parameter], charybdis_cv_c_gcc_w_no_unused_exception_parameter) RB_MAYBE_CWARN([-Wno-extra-semi], charybdis_cv_c_gcc_w_no_extra_semi) RB_MAYBE_CWARN([-Wno-extra-semi-stmt], charybdis_cv_c_gcc_w_no_extra_semi_stmt) RB_MAYBE_CWARN([-Wno-weak-vtables], charybdis_cv_c_gcc_w_no_weak_vtables) RB_MAYBE_CWARN([-Wno-global-constructors], charybdis_cv_c_gcc_w_no_global_constructors) RB_MAYBE_CWARN([-Wno-dtor-name], charybdis_cv_c_gcc_w_no_dtor_name) dnl Ignored with issue low priority RB_MAYBE_CWARN([-Wno-old-style-cast], charybdis_cv_c_gcc_w_no_old_style_cast) RB_MAYBE_CWARN([-Wno-float-conversion], charybdis_cv_c_gcc_w_no_implicit_int_conversion) RB_MAYBE_CWARN([-Wno-implicit-int-conversion], charybdis_cv_c_gcc_w_no_implicit_int_conversion) dnl Ignored with issue high priority RB_MAYBE_CWARN([-Wno-reserved-identifier], charybdis_cv_c_gcc_w_no_reserved_identifier) RB_MAYBE_CWARN([-Wno-reserved-macro-identifier], charybdis_cv_c_gcc_w_no_reserved_macro_identifier) ], [ AC_MSG_RESULT([no]) ]) AM_COND_IF_NOT([GENERIC], [ dnl When tuning for a specific target ignore the ABI compat warnings RB_MAYBE_CWARN([-Wno-psabi], charybdis_cv_c_gcc_w_psabi) ]) dnl assume the warning flags RB_VAR_PREPEND([CPPFLAGS], ["$CWARNS"]) dnl mirror the base CFLAGS and CXXFLAGS up to this point CFLAGS="$CXXFLAGS" dnl *************************************************************************** dnl dnl Linker flags dnl AM_COND_IF([CLANG], [ AM_CONDITIONAL([LLD], [test "" != ""]) dnl AM_CONDITIONAL([LLD], [test "$LDLLD" != ""]) AM_CONDITIONAL([GOLD], [test "$LDGOLD" != ""]) ], [ AM_CONDITIONAL([LLD], [test "" != ""]) AM_CONDITIONAL([GOLD], [test "$LDGOLD" != ""]) ]) AM_COND_IF_NAND([LLD], [GOLD], [ AC_MSG_ERROR([Sorry, ld.gold required at this time.]) ]) AM_COND_IF([LLD], [ AC_SUBST(LD, "$LDLLD") ]) AM_COND_IF([LLD], [ RB_VAR_PREPEND([LDFLAGS], ["-fuse-ld=lld"]) RB_VAR_PREPEND([LDFLAGS], ["-Wc,-fuse-ld=lld"]) ]) AM_COND_IF([GOLD], [ AM_COND_IF([GCC], [ RB_VAR_PREPEND([LDFLAGS], ["-Wl,-fuse-ld=gold"]) RB_VAR_PREPEND([LDFLAGS], ["-Wl,--gdb-index"]) ]) AM_COND_IF([CLANG], [ RB_VAR_PREPEND([LDFLAGS], ["-fuse-ld=gold"]) RB_VAR_PREPEND([LDFLAGS], ["-Wc,-fuse-ld=gold"]) ]) RB_VAR_PREPEND([LDFLAGS], ["-Wl,--warn-common"]) RB_VAR_PREPEND([LDFLAGS], ["-Wl,--warn-execstack"]) RB_VAR_PREPEND([LDFLAGS], ["-Wl,--detect-odr-violations"]) RB_VAR_PREPEND([LDFLAGS], ["-Wl,--rosegment"]) dnl RB_VAR_PREPEND([LDFLAGS], ["-Wl,--icf=all"]) RB_VAR_PREPEND([LDFLAGS], ["-Wl,-z,noexecstack"]) RB_VAR_PREPEND([LDFLAGS], ["-Wl,-z,combreloc"]) RB_VAR_PREPEND([LDFLAGS], ["-Wl,-z,text-unlikely-segment"]) RB_VAR_PREPEND([LDFLAGS], ["-Wl,-z,keep-text-section-prefix"]) ]) dnl Note compact mode options available in both GOLD and LLD AM_COND_IF([COMPACT], [ RB_VAR_PREPEND([LDFLAGS], ["-Wl,--strip-all"]) RB_VAR_PREPEND([LDFLAGS], ["-Wl,--gc-sections"]) ]) dnl *************************************************************************** dnl dnl Philology checks dnl AC_ISC_POSIX AC_C_CONST AC_C_INLINE if test "$ac_cv_header_machine_endian_h" = "no" ; then AC_C_BIGENDIAN fi AC_TYPE_PID_T AC_TYPE_UID_T AC_TYPE_OFF_T AC_TYPE_SIZE_T AC_TYPE_SSIZE_T AC_TYPE_INTPTR_T AC_TYPE_UINTPTR_T dnl C standard type sizes on this platform RB_CHECK_SIZEOF([char], 1) AC_CHECK_SIZEOF([short]) AC_CHECK_SIZEOF([int]) AC_CHECK_SIZEOF([float]) AC_CHECK_SIZEOF([long]) AC_CHECK_SIZEOF([double]) AC_CHECK_SIZEOF([long long]) AC_CHECK_SIZEOF([long double]) dnl Check for the C++11/C++20 unicode character types and sizes AC_CHECK_TYPES([char8_t]) AC_CHECK_SIZEOF([char8_t]) AC_CHECK_TYPES([char16_t]) AC_CHECK_SIZEOF([char16_t]) AC_CHECK_TYPES([char32_t]) AC_CHECK_SIZEOF([char32_t]) dnl Probe the details of 128-bit arithmetic support on this platform. dnl see: include/ircd/portable.h AC_CHECK_TYPES([int128_t]) AC_CHECK_SIZEOF([int128_t]) AC_CHECK_TYPES([uint128_t]) AC_CHECK_SIZEOF([uint128_t]) AC_CHECK_TYPES([__int128]) AC_CHECK_SIZEOF([__int128]) AC_CHECK_TYPES([__int128_t]) AC_CHECK_SIZEOF([__int128_t]) AC_CHECK_TYPES([__uint128_t]) AC_CHECK_SIZEOF([__uint128_t]) dnl Gauge the support of experimental compact floating point formats AC_CHECK_TYPES([_Float16]) AC_CHECK_SIZEOF([_Float16]) AC_CHECK_TYPES([__fp16]) AC_CHECK_SIZEOF([__fp16]) AC_CHECK_TYPES([__bf16]) AC_CHECK_SIZEOF([__bf16]) dnl -fsigned-char ensures 'char' is signed on all platforms RB_VAR_PREPEND([CFLAGS], ["-fsigned-char"]) RB_VAR_PREPEND([CXXFLAGS], ["-fsigned-char"]) dnl *************************************************************************** dnl dnl Header files dnl AC_HEADER_STDBOOL dnl AC_HEADER_STDC dnl libc RB_CHK_SYSHEADER(assert.h, [ASSERT_H]) RB_CHK_SYSHEADER(stdarg.h, [STDARG_H]) dnl libc++ RB_CHK_SYSHEADER(cstddef, [CSTDDEF]) RB_CHK_SYSHEADER(cstdint, [CSTDINT]) RB_CHK_SYSHEADER(cstdlib, [CSTDLIB]) RB_CHK_SYSHEADER(cstdarg, [CSTDARG]) RB_CHK_SYSHEADER(cassert, [CASSERT]) RB_CHK_SYSHEADER(limits, [LIMITS]) RB_CHK_SYSHEADER(type_traits, [TYPE_TRAITS]) RB_CHK_SYSHEADER(typeindex, [TYPEINDEX]) RB_CHK_SYSHEADER(variant, [VARIANT]) RB_CHK_SYSHEADER(utility, [UTILITY]) RB_CHK_SYSHEADER(execution, [EXECUTION]) RB_CHK_SYSHEADER(functional, [FUNCTIONAL]) RB_CHK_SYSHEADER(algorithm, [ALGORITHM]) RB_CHK_SYSHEADER(numeric, [NUMERIC]) RB_CHK_SYSHEADER(cmath, [CMATH]) RB_CHK_SYSHEADER(cfloat, [CFLOAT]) RB_CHK_SYSHEADER(cfenv, [CFENV]) RB_CHK_SYSHEADER(memory, [MEMORY]) RB_CHK_SYSHEADER(exception, [EXCEPTION]) RB_CHK_SYSHEADER(cerrno, [CERRNO]) RB_CHK_SYSHEADER(system_error, [SYSTEM_ERROR]) RB_CHK_SYSHEADER(map, [MAP]) RB_CHK_SYSHEADER(set, [SET]) RB_CHK_SYSHEADER(list, [LIST]) RB_CHK_SYSHEADER(stack, [STACK]) RB_CHK_SYSHEADER(queue, [QUEUE]) RB_CHK_SYSHEADER(deque, [DEQUE]) RB_CHK_SYSHEADER(tuple, [TUPLE]) RB_CHK_SYSHEADER(array, [ARRAY]) RB_CHK_SYSHEADER(vector, [VECTOR]) RB_CHK_SYSHEADER(forward_list, [FORWARD_LIST]) RB_CHK_SYSHEADER(unordered_map, [UNORDERED_MAP]) RB_CHK_SYSHEADER(string, [STRING]) RB_CHK_SYSHEADER(cstring, [CSTRING]) RB_CHK_SYSHEADER(locale, [LOCALE]) RB_CHK_SYSHEADER(cuchar, [CUCHAR]) RB_CHK_SYSHEADER(codecvt, [CODECVT]) RB_CHK_SYSHEADER(sstream, [SSTREAM]) RB_CHK_SYSHEADER(fstream, [FSTREAM]) RB_CHK_SYSHEADER(iostream, [IOSTREAM]) RB_CHK_SYSHEADER(iosfwd, [IOSFWD]) RB_CHK_SYSHEADER(iomanip, [IOMANIP]) RB_CHK_SYSHEADER(cstdio, [CSTDIO]) RB_CHK_SYSHEADER(chrono, [CHRONO]) RB_CHK_SYSHEADER(ctime, [CTIME]) RB_CHK_SYSHEADER(atomic, [ATOMIC]) RB_CHK_SYSHEADER(thread, [THREAD]) RB_CHK_SYSHEADER(mutex, [MUTEX]) RB_CHK_SYSHEADER(shared_mutex, [SHARED_MUTEX]) RB_CHK_SYSHEADER(condition_variable, [CONDITION_VARIABLE]) RB_CHK_SYSHEADER(random, [RANDOM]) RB_CHK_SYSHEADER(bitset, [BITSET]) RB_CHK_SYSHEADER(string_view, [STRING_VIEW]) RB_CHK_SYSHEADER(optional, [OPTIONAL]) RB_CHK_SYSHEADER(new, [NEW]) RB_CHK_SYSHEADER(regex, [REGEX]) RB_CHK_SYSHEADER(memory_resource, [MEMORY_RESOURCE]) RB_CHK_SYSHEADER(filesystem, [FILESYSTEM]) RB_CHK_SYSHEADER(concepts, [CONCEPTS]) RB_CHK_SYSHEADER(cxxabi.h, [CXXABI_H]) dnl unix platform RB_CHK_SYSHEADER(unistd.h, [UNISTD_H]) RB_CHK_SYSHEADER(signal.h, [SIGNAL_H]) RB_CHK_SYSHEADER(ifaddrs.h, [IFADDRS_H]) RB_CHK_SYSHEADER(netdb.h, [NETDB_H]) RB_CHK_SYSHEADER(fcntl.h, [FCNTL_H]) RB_CHK_SYSHEADER(elf.h, [ELF_H]) RB_CHK_SYSHEADER(link.h, [LINK_H]) RB_CHK_SYSHEADER(dlfcn.h, [DLFCN_H]) RB_CHK_SYSHEADER(execinfo.h, [EXECINFO_H]) RB_CHK_SYSHEADER(sys/types.h, [SYS_TYPES_H]) RB_CHK_SYSHEADER(sys/time.h, [SYS_TIME_H]) RB_CHK_SYSHEADER(sys/stat.h, [SYS_STAT_H]) RB_CHK_SYSHEADER(sys/statfs.h, [SYS_STATFS_H]) RB_CHK_SYSHEADER(sys/statvfs.h, [SYS_STATVFS_H]) RB_CHK_SYSHEADER(sys/resource.h, [SYS_RESOURCE_H]) RB_CHK_SYSHEADER(sys/syscall.h, [SYS_SYSCALL_H]) RB_CHK_SYSHEADER(sys/utsname.h, [SYS_UTSNAME_H]) RB_CHK_SYSHEADER(sys/ioctl.h, [SYS_IOCTL_H]) RB_CHK_SYSHEADER(sys/mman.h, [SYS_MMAN_H]) RB_CHK_SYSHEADER(sys/event.h, [SYS_EVENT_H]) RB_CHK_SYSHEADER(gnu/libc-version.h, [GNU_LIBC_VERSION_H]) RB_CHK_SYSHEADER(gnu/lib-names.h, [GNU_LIB_NAMES_H]) dnl linux platform RB_CHK_SYSHEADER(asm/prctl.h, [ASM_PRCTL_H]) RB_CHK_SYSHEADER(sys/auxv.h, [SYS_AUXV_H]) RB_CHK_SYSHEADER(sys/sysinfo.h, [SYS_SYSINFO_H]) RB_CHK_SYSHEADER(sys/eventfd.h, [SYS_EVENTFD_H]) RB_CHK_SYSHEADER(sys/inotify.h, [SYS_INOTIFY_H]) RB_CHK_SYSHEADER(sys/sysmacros.h, [SYS_SYSMACROS_H]) RB_CHK_SYSHEADER(sys/prctl.h, [SYS_PRCTL_H]) RB_CHK_SYSHEADER(sys/epoll.h, [SYS_EPOLL_H]) RB_CHK_SYSHEADER(sys/timerfd.h, [SYS_TIMERFD_H]) RB_CHK_SYSHEADER(linux/aio_abi.h, [LINUX_AIO_ABI_H]) RB_CHK_SYSHEADER(linux/magic.h, [LINUX_MAGIC_H]) RB_CHK_SYSHEADER(linux/perf_event.h, [LINUX_PERF_EVENT_H]) RB_CHK_SYSHEADER(linux/hw_breakpoint.h, [LINUX_HW_BREAKPOINT_H]) RB_CHK_SYSHEADER(linux/io_uring.h, [LINUX_IO_URING_H]) RB_CHK_SYSHEADER(linux/icmp.h, [LINUX_ICMP_H]) RB_CHK_SYSHEADER(linux/input-event-codes.h, [LINUX_INPUT_EVENT_CODES_H]) RB_CHK_SYSHEADER(linux/bpf.h, [LINUX_BPF_H]) dnl windows platform RB_CHK_SYSHEADER(windows.h, [WINDOWS_H]) RB_CHK_SYSHEADER(winsock2.h, [WINSOCK2_H]) RB_CHK_SYSHEADER(ws2tcpip.h, [WS2TCPIP_H]) RB_CHK_SYSHEADER(iphlpapi.h, [IPHLPAPI_H]) dnl x86 platform RB_CHK_SYSHEADER(x86intrin.h, [X86INTRIN_H]) RB_CHK_SYSHEADER(cpuid.h, [CPUID_H]) dnl arm platform RB_CHK_SYSHEADER(arm_acle.h, [ARM_ACLE_H]) RB_CHK_SYSHEADER(arm_cmse.h, [ARM_ACLE_H]) RB_CHK_SYSHEADER(arm_neon.h, [ARM_NEON_H]) RB_CHK_SYSHEADER(arm_sve.h, [ARM_SVE_H]) dnl instrumentation RB_CHK_SYSHEADER(malloc.h, [MALLOC_H]) RB_CHK_SYSHEADER(valgrind/valgrind.h, [VALGRIND_VALGRIND_H]) RB_CHK_SYSHEADER(valgrind/memcheck.h, [VALGRIND_MEMCHECK_H]) RB_CHK_SYSHEADER(valgrind/callgrind.h, [VALGRIND_CALLGRIND_H]) dnl experimental RB_CHK_SYSHEADER(experimental/string_view, [EXPERIMENTAL_STRING_VIEW]) RB_CHK_SYSHEADER(experimental/optional, [EXPERIMENTAL_OPTIONAL]) RB_CHK_SYSHEADER(experimental/memory_resource, [EXPERIMENTAL_MEMORY_RESOURCE]) dnl *************************************************************************** dnl dnl Specific function checks dnl AC_CHECK_FUNCS([ \ backtrace \ fadvise \ madvise \ mallinfo \ mallinfo2 \ mlock \ mlock2 \ mmap \ mprotect \ mremap \ msync \ posix_fadvise \ posix_madvise \ preadv2 \ pwritev2 \ strlcat \ strlcpy \ sync \ syncfs \ ]) AC_SEARCH_LIBS(dlinfo, dl, AC_DEFINE(HAVE_DLINFO, 1, [Define if you have dlinfo])) AC_SEARCH_LIBS(nanosleep, rt posix4, AC_DEFINE(HAVE_NANOSLEEP, 1, [Define if you have nanosleep])) dnl dnl Networking Functions dnl dnl dnl ip6 dnl AC_ARG_ENABLE(ipv6, RB_HELP_STRING([--enable-ipv6], [Enable IPv6 support]), [ ipv6=$enableval ], [ ipv6="yes" ]) AM_CONDITIONAL([IPV6], [[[[ "$ipv6" = "yes" ]]]]) AM_COND_IF(IPV6, [ AC_DEFINE([HAVE_IPV6], [1], [IPv6 is supported]) AC_SUBST(IPV6, 1) ]) dnl dnl netdb / libnss_db dnl AC_CHECK_FUNCS([ \ endprotoent \ getprotobyname \ getprotobyname_r \ setprotoent \ ]) dnl Even if getprotobyname(3) is found linux tries to open nss_db at runtime and dnl that surprises our user with trouble. The check catches it here FWIW. AM_COND_IF(LINUX, [ AC_CHECK_LIB([nss_db], [_nss_db_getprotobyname_r], [ AC_DEFINE(HAVE_LIBNSS_DB, 1, [Define if you have libnss_db]) ], [ AC_MSG_WARN([Missing libnss_db.so for getprotobyname(3) impl. Try apt-get install libnss-db]) ]) ]) dnl *************************************************************************** dnl dnl Miscellaneous operating system specific dnl AM_COND_IF(MINGW, [ AC_DEFINE(HAVE_WIN32, [1], [Define to 1 if you are on windows]) RB_VAR_PREPEND([LIBS], ["-lws2_32 -liphlpapi"]) ], [ RB_VAR_PREPEND([LIBS], ["-latomic"]) RB_VAR_PREPEND([LIBS], ["-lpthread"]) AM_COND_IF([GCC], [ RB_VAR_PREPEND([CXXFLAGS], ["-pthread"]) ]) ]) AM_COND_IF(INTERIX, [ CPPDEFINE([_ALL_SOURCE]) CPPDEFINE([_XOPEN_SOURCE], [500]) CPPDEFINE([_POSIX_PTHREAD_SEMANTICS]) CPPDEFINE([_XPG4_2]) ],[]) dnl dnl Linux AIO support dnl AM_COND_IF(LINUX, [ AC_ARG_ENABLE(aio, RB_HELP_STRING([--enable-aio], [Enable kernel AIO support]), [ aio=$enableval ], [ aio="yes" ]) AC_MSG_RESULT([$aio]) ]) AM_CONDITIONAL([AIO], [test "x$aio" = "xyes" ]) AM_COND_IF([AIO], [ IRCD_DEFINE(USE_AIO, [1], [Linux AIO is enabled and may be used]) ], [ IRCD_DEFINE(USE_AIO, [0], [Linux AIO is disabled and will not be used]) ]) dnl dnl Linux io_uring support dnl AM_COND_IF(LINUX, [ AC_ARG_ENABLE(iou, RB_HELP_STRING([--enable-iou], [Enable kernel io_uring support]), [ iou=$enableval ], [ iou="yes" ]) AC_MSG_RESULT([$iou]) ]) AM_CONDITIONAL([IOU], [test "x$iou" = "xyes" ]) AM_COND_IF([IOU], [ IRCD_DEFINE(USE_IOU, [1], [Linux io_uring is enabled for use if available]) ], [ IRCD_DEFINE(USE_IOU, [0], [Linux io_uring is disabled and will not be used]) ]) dnl *************************************************************************** dnl dnl Installation dnl AC_PATH_PROGS_FEATURE_CHECK([INSTALL], [install], [ $ac_path_INSTALL -C --version > /dev/null 2>&1 \ && ac_cv_path_INSTALL="$ac_path_INSTALL -C" ]) AC_MSG_CHECKING([if any install supports the -C flag]) if test -n "$ac_cv_path_INSTALL"; then AC_MSG_RESULT([yes]) INSTALL=$ac_cv_path_INSTALL else AC_MSG_RESULT([no]) AC_MSG_WARN([Application should not be running during make install.]) AC_PATH_PROG(INSTALL, install) fi dnl dnl Installation Layout dnl AC_PREFIX_DEFAULT([/usr]) AC_PREFIX_PROGRAM([/usr]) PKG_PROG_PKG_CONFIG AC_SUBST_DIR([prefix]) if test "$prefix" = "NONE"; then prefix="$ac_default_prefix" else dnl Don't get bitten by Cygwin's stupidity if the user specified dnl a custom prefix with a trailing slash prefix=`echo $prefix | sed 's/\/$//'` fi RB_DEFINE_UNQUOTED(PREFIX, ["$prefix"], [Prefix of IRCd install]) dnl dnl bindir dnl AC_SUBST_DIR([bindir]) RB_DEFINE_UNQUOTED([BIN_DIR], ["$bindir"], [Directory where binary executables are to be found.]) dnl dnl Check for --with-confdir [deprecated, use --sysconfdir instead] dnl AC_SUBST_DIR([sysconfdir]) RB_DEFINE_UNQUOTED([CONF_DIR], ["$sysconfdir"], [Prefix where config files are installed.]) dnl dnl includedir dnl AC_SUBST_DIR([includedir]) RB_DEFINE_UNQUOTED([INCLUDE_DIR], ["$includedir"], [Prefix where headers are installed.]) dnl dnl libdir dnl AC_SUBST_DIR([libdir]) RB_DEFINE_UNQUOTED([LIB_DIR], ["$libdir"], [Prefix where libs are installed.]) dnl dnl Check for --with-moduledir dnl AC_SUBST_DIR([moduledir]) AC_MSG_CHECKING([whether to modify moduledir]) AC_ARG_WITH(moduledir, RB_HELP_STRING([--with-moduledir=DIR], [Directory to install modules]), [ AC_MSG_RESULT(yes) moduledir=`echo $withval | sed 's/\/$//'` ], [ AC_MSG_RESULT(no) moduledir="${libdir}/modules/${PACKAGE_TARNAME}" ]) RB_DEFINE_UNQUOTED([MODULE_DIR], ["$moduledir"], [Prefix where modules are installed.]) dnl dnl datarootdir dnl AC_SUBST_DIR([datarootdir]) RB_DEFINE_UNQUOTED([DATAROOT_DIR], ["$datarootdir"], [Directory where read-only assets go.]) dnl dnl datadir dnl AC_SUBST_DIR([datadir]) if test "x$datarootdir" = "x$datadir"; then datadir="$datarootdir/${PACKAGE_TARNAME}" fi RB_DEFINE_UNQUOTED([DATA_DIR], ["$datadir"], [Directory where read-only assets go.]) dnl dnl Check for --with-webappdir dnl AC_MSG_CHECKING([whether to modify webappdir]) AC_ARG_WITH(webappdir, RB_HELP_STRING([--with-webappdir=DIR], [Directory to install served assets]), [ AC_MSG_RESULT(yes) webappdir=`echo $withval | sed 's/\/$//'` ], [ AC_MSG_RESULT(no) webappdir="${datadir}/webapp" ]) RB_DEFINE_UNQUOTED([WEBAPP_DIR], ["$webappdir"], [Prefix where website assets are served from.]) AC_SUBST_DIR([webappdir]) dnl dnl localstatedir dnl dnl Avoid name collisions. AC_SUBST_DIR([localstatedir]) RB_DEFINE_UNQUOTED([LOCALSTATE_DIR], ["$localstatedir"], [Prefix where db and logs go.]) dnl dnl Check for --with-dbdir dnl AC_MSG_CHECKING([whether to modify database directory]) AC_ARG_WITH(dbdir, RB_HELP_STRING([--with-dbdir=DIR], [Directory where databases are located]), [ AC_MSG_RESULT(yes) dbdir=`echo $withval | sed 's/\/$//'` ], [ AC_MSG_RESULT(no) dbdir="${localstatedir}/db/${PACKAGE_TARNAME}" ]) RB_DEFINE_UNQUOTED([DB_DIR], ["$dbdir"], [Directory where databases are located]) AC_SUBST_DIR([dbdir]) dnl dnl Check for --with-logdir dnl AC_MSG_CHECKING([whether to modify logdir]) AC_ARG_WITH(logdir, RB_HELP_STRING([--with-logdir=DIR], [Directory where to write logfiles]), [ AC_MSG_RESULT(yes) logdir=`echo $withval | sed 's/\/$//'` ], [ AC_MSG_RESULT(no) logdir="${localstatedir}/log/${PACKAGE_TARNAME}" ]) RB_DEFINE_UNQUOTED([LOG_DIR], ["$logdir"], [Prefix where to write logfiles.]) AC_SUBST_DIR([logdir]) dnl dnl runstatedir dnl AC_SUBST_DIR([runstatedir]) runstatedir="$runstatedir/${PACKAGE_TARNAME}" RB_DEFINE_UNQUOTED([RUN_DIR], ["$runstatedir"], [Prefix where runtime ephemeral files go.]) dnl *************************************************************************** dnl dnl Third party dnl dnl dnl dnl unicode / icu dnl dnl AC_SUBST(ICU_CPPFLAGS, []) AC_SUBST(ICU_LDFLAGS, []) AC_SUBST(ICU_LIBS, []) AC_ARG_WITH(icu-includes, RB_HELP_STRING([--with-icu-includes=[[[DIR]]]], [Path to unicode include directory]), [ RB_VAR_APPEND([ICU_CPPFLAGS], ["-isystem $withval"]) ]) AC_ARG_WITH(icu-libs, RB_HELP_STRING([--with-icu-libs=[[[DIR]]]], [Path to unicode libraries directory]), [ RB_VAR_APPEND([ICU_LDFLAGS], ["-L$withval"]) ]) dnl RB_CHK_SYSHEADER(unicode/utypes.h, [UNICODE_UTYPES_H]) dnl RB_CHK_SYSHEADER(unicode/ustring.h, [UNICODE_USTRING_H]) dnl RB_CHK_SYSHEADER(unicode/utext.h, [UNICODE_UTEXT_H]) dnl RB_CHK_SYSHEADER(unicode/unistr.h, [UNICODE_UNISTR_H]) dnl RB_CHK_SYSHEADER(unicode/chariter.h, [UNICODE_CHARITER_H]) dnl RB_CHK_SYSHEADER(unicode/stringpiece.h, [UNICODE_STRINGPIECE_H]) dnl RB_CHK_SYSHEADER(unicode/utf.h, [UNICODE_UTF_H]) dnl RB_CHK_SYSHEADER(unicode/uchar.h, [UNICODE_UCHAR_H]) dnl RB_CHK_SYSHEADER(unicode/uscript.h, [UNICODE_USCRIPT_H]) dnl RB_CHK_SYSHEADER(unicode/uset.h, [UNICODE_USET_H]) dnl RB_CHK_SYSHEADER(unicode/uniset.h, [UNICODE_UNISET_H]) dnl RB_CHK_SYSHEADER(unicode/uloc.h, [UNICODE_ULOC_H]) dnl RB_CHK_SYSHEADER(unicode/locid.h, [UNICODE_LOCID_H]) dnl RB_CHK_SYSHEADER(unicode/usearch.h, [UNICODE_USEARCH_H]) dnl RB_CHK_SYSHEADER(unicode/stsearch.h, [UNICODE_STSEARCH_H]) dnl RB_CHK_SYSHEADER(unicode/ubrk.h, [UNICODE_UBRK_H]) dnl RB_CHK_SYSHEADER(unicode/brkiter.h, [UNICODE_BRKITER_H]) dnl RB_CHK_SYSHEADER(unicode/uidna.h, [UNICODE_UIDNA_H] ) dnl RB_CHK_SYSHEADER(unicode/idna.h, [UNICODE_IDNA_H]) dnl RB_CHK_SYSHEADER(unicode/utmscale.h, [UNICODE_UTMSCALE_H]) have_icu="no" PKG_CHECK_MODULES(icuuc, [icuuc], [ have_icu="yes" have_icuuc="yes" RB_VAR_APPEND([ICU_LIBS], ["-licuuc"]) ], [ AC_CHECK_LIB([icuuc], [_init], [ have_icu="yes" have_icuuc="yes" RB_VAR_APPEND([ICU_LIBS], ["-licuuc"]) ], [ have_icuuc="no" ]) ]) AM_CONDITIONAL([ICUUC], [test "x$have_icuuc" = "xyes" ]) AM_CONDITIONAL([ICU], [test "x$have_icu" = "xyes" ]) AM_COND_IF(ICU, [ IRCD_DEFINE(USE_ICU, [1], [International Components for Unicode is available]) ], [ IRCD_DEFINE(USE_ICU, [0], [International Components for Unicode is not available]) ]) dnl dnl dnl libsodium (NaCl) crypto support dnl dnl AC_SUBST(SODIUM_CPPFLAGS, []) AC_SUBST(SODIUM_LDFLAGS, []) AC_SUBST(SODIUM_LIBS, []) AC_ARG_WITH(sodium-includes, RB_HELP_STRING([--with-sodium-includes=[[[DIR]]]], [Path to sodium include directory]), [ RB_VAR_APPEND([SODIUM_CPPFLAGS], ["-I$withval"]) ], []) AC_ARG_WITH(sodium-libs, RB_HELP_STRING([--with-sodium-libs=[[[DIR]]]], [Path to sodium library directory]), [ RB_VAR_APPEND([SODIUM_LDFLAGS], ["-L$withval"]) ], []) PKG_CHECK_MODULES(sodium, libsodium, [ have_sodium="yes" ], [ dnl NOTE that PKG_CHECK_MODULES is preferred, but on some systems it gives dnl a false negative and we end up here with an AC_CHECK_LIB fallback. AC_CHECK_LIB([sodium], sodium_init, [ have_sodium="yes" ], [ have_sodium="no" ]) ]) AM_CONDITIONAL([SODIUM], [test "x$have_sodium" = "xyes"]) AM_COND_IF([SODIUM], [ RB_CHK_SYSHEADER(sodium.h, [SODIUM_H]) AC_DEFINE([HAVE_SODIUM], [1], [Have libsodium]) RB_VAR_APPEND([SODIUM_LIBS], ["-lsodium"]) ], [ AC_MSG_ERROR([libsodium is required but not found. Try apt-get install libsodium-dev]) ]) dnl dnl dnl OpenSSL support dnl dnl AC_SUBST(SSL_CPPFLAGS, []) AC_SUBST(SSL_LDFLAGS, []) AC_SUBST(SSL_LIBS, []) AC_ARG_WITH(ssl, RB_HELP_STRING([--with-ssl=[[[DIR]]]], [Path to SSL source directory]), [ SSL_CPPFLAGS="-I$withval/include" SSL_LDFLAGS="-L$withval" ], []) AC_ARG_WITH(ssl-includes, RB_HELP_STRING([--with-ssl-includes=[[[DIR]]]], [Path to SSL include directory]), [ SSL_CPPFLAGS="-I$withval" ], []) AC_ARG_WITH(ssl-libs, RB_HELP_STRING([--with-ssl-libs=[[[DIR]]]], [Path to SSL library directory]), [ SSL_LDFLAGS="-L$withval" ], []) RB_CHK_SYSHEADER(openssl/err.h, [OPENSSL_ERR_H]) RB_CHK_SYSHEADER(openssl/asn1.h, [OPENSSL_ASN1_H]) RB_CHK_SYSHEADER(openssl/sha.h, [OPENSSL_SHA_H]) RB_CHK_SYSHEADER(openssl/hmac.h, [OPENSSL_HMAC_H]) RB_CHK_SYSHEADER(openssl/ssl.h, [OPENSSL_SSL_H]) RB_CHK_SYSHEADER(openssl/ec.h, [OPENSSL_EC_H]) RB_CHK_SYSHEADER(openssl/rsa.h, [OPENSSL_RSA_H]) RB_CHK_SYSHEADER(openssl/x509.h, [OPENSSL_X509_H]) RB_CHK_SYSHEADER(openssl/evp.h, [OPENSSL_EVP_H]) RB_CHK_SYSHEADER(openssl/ripemd.h, [OPENSSL_RIPEMD_H]) RB_CHK_SYSHEADER(openssl/dh.h, [OPENSSL_DH_H]) RB_CHK_SYSHEADER(openssl/tls1.h, [OPENSSL_TLS1_H]) PKG_CHECK_MODULES(ssl, [ssl], [ have_ssl="yes" ], [ AC_CHECK_LIB(ssl, SSL_version, [ have_ssl="yes" ], [ have_ssl="no" AC_MSG_ERROR([libssl is required but not found. Try apt-get install libssl-dev]) ]) ]) AM_CONDITIONAL([SSL], [test "x$have_ssl" = "xyes"]) AM_COND_IF([SSL], [ SSL_LIBS="-lssl" ]) AC_SUBST(CRYPTO_CPPFLAGS, []) AC_SUBST(CRYPTO_LDFLAGS, []) AC_SUBST(CRYPTO_LIBS, []) PKG_CHECK_MODULES(crypto, [crypto], [ have_crypto="yes" ], [ AC_CHECK_LIB(crypto, OPENSSL_init, [ have_crypto="yes" CRYPTO_LIBS="-lcrypto" ], [ have_crypto="no" AC_MSG_ERROR([libcrypto is required but not found.]) ]) ]) AM_CONDITIONAL([CRYPTO], [test "x$have_crypto" = "xyes"]) AM_COND_IF([CRYPTO], [ AC_DEFINE(HAVE_CRYPTO, 1, [Define to 1 if libcrypto (-lcrypto) is available.]) CRYPTO_LIBS="-lcrypto" ]) dnl dnl dnl libmagic support dnl dnl AC_SUBST(MAGIC_CPPFLAGS, []) AC_SUBST(MAGIC_LDFLAGS, []) AC_SUBST(MAGIC_LIBS, []) AC_ARG_WITH(magic-includes, RB_HELP_STRING([--with-magic-includes=[[[DIR]]]], [Path to magic include directory]), [ MAGIC_CPPFLAGS="-I$withval" ], []) AC_ARG_WITH(magic-libs, RB_HELP_STRING([--with-magic-libs=[[[DIR]]]], [Path to magic library directory]), [ MAGIC_LDFLAGS="-L$withval" ], []) AC_ARG_WITH(magic-file, RB_HELP_STRING([--with-magic-file=[[[FILE]]]], [Path to magic database file]), [ MAGIC_FILE="$withval" RB_DEFINE_UNQUOTED([MAGIC_FILE], ["$MAGIC_FILE"], [Magic file path]) ], [ RB_DEFINE_UNQUOTED([MAGIC_FILE], [""], [Magic file path]) ]) RB_CHK_SYSHEADER(magic.h, [MAGIC_H]) PKG_CHECK_MODULES(magic, [magic], [ have_magic="yes" ], [ AC_CHECK_LIB(magic, magic_version, [ have_magic="yes" ], [ have_magic="no" AC_MSG_ERROR([libmagic is required but not found. Try apt-get install libmagic-dev]) ]) ]) AM_CONDITIONAL([MAGIC], [test "x$have_magic" = "xyes"]) AM_COND_IF([MAGIC], [ MAGIC_LIBS="-lmagic" ]) dnl dnl dnl zstd dnl dnl AC_SUBST(ZSTD_CPPFLAGS) AC_SUBST(ZSTD_LDFLAGS) AC_SUBST(ZSTD_LIBS) AC_ARG_WITH(zstd-includes, RB_HELP_STRING([--with-zstd-includes=[[[DIR]]]], [Path to zstd include directory]), [ ZSTD_CPPFLAGS="-I$withval" ], []) AC_ARG_WITH(zstd-libs, RB_HELP_STRING([--with-zstd-libs=[[[DIR]]]], [Path to zstd library directory]), [ ZSTD_LDFLAGS="-L$withval" ], []) RB_CHK_SYSHEADER(zstd.h, [ZSTD_H]) PKG_CHECK_MODULES(zstd, [zstd], [ have_zstd="yes" ], [ AC_CHECK_LIB(zstd, ZSTD_versionNumber, [ have_zstd="yes" ], [ have_zstd="no" ]) ]) AM_CONDITIONAL([ZSTD], [test "x$have_zstd" = "xyes"]) AM_COND_IF([ZSTD], [ ZSTD_LIBS="-lzstd" ]) dnl dnl dnl zlib support dnl dnl AC_SUBST(Z_CPPFLAGS) AC_SUBST(Z_LDFLAGS) AC_SUBST(Z_LIBS) AC_ARG_WITH(z-includes, RB_HELP_STRING([--with-z-includes=[[[DIR]]]], [Path to zlib include directory]), [ Z_CPPFLAGS="-I$withval" ], []) AC_ARG_WITH(z-libs, RB_HELP_STRING([--with-z-libs=[[[DIR]]]], [Path to zlib library directory]), [ Z_LDFLAGS="-L$withval" ], []) RB_CHK_SYSHEADER(zlib.h, [ZLIB_H]) PKG_CHECK_MODULES(zlib, [zlib], [ have_zlib="yes" ], [ AC_CHECK_LIB(z, zlibVersion, [ have_zlib="yes" ], [ have_zlib="no" ]) ]) AM_CONDITIONAL([ZLIB], [test "x$have_zlib" = "xyes"]) AM_COND_IF([ZLIB], [ ZLIB_LIBS="-lz" ]) dnl dnl dnl lz4 support dnl dnl AC_SUBST(LZ4_CPPFLAGS) AC_SUBST(LZ4_LDFLAGS) AC_SUBST(LZ4_LIBS) AC_ARG_WITH(lz4-includes, RB_HELP_STRING([--with-lz4-includes=[[[DIR]]]], [Path to LZ4 include directory]), [ LZ4_CPPFLAGS="-I$withval" ], []) AC_ARG_WITH(lz4-libs, RB_HELP_STRING([--with-lz4-libs=[[[DIR]]]], [Path to LZ4 library directory]), [ LZ4_LDFLAGS="-L$withval" ], []) RB_CHK_SYSHEADER(lz4.h, [LZ4_H]) PKG_CHECK_MODULES(lz4, [lz4], [ have_lz4="yes" ], [ AC_CHECK_LIB(lz4, LZ4_versionNumber, [ have_lz4="yes" ], [ have_lz4="no" ]) ]) AM_CONDITIONAL([LZ4], [test "x$have_lz4" = "xyes"]) AM_COND_IF([LZ4], [ LZ4_LIBS="-llz4" ]) dnl dnl dnl snappy support dnl dnl AC_SUBST(SNAPPY_CPPFLAGS) AC_SUBST(SNAPPY_LDFLAGS) AC_SUBST(SNAPPY_LIBS) AC_ARG_WITH(snappy-includes, RB_HELP_STRING([--with-snappy-includes=[[[DIR]]]], [Path to snappy include directory]), [ SNAPPY_CPPFLAGS="-I$withval" ], []) AC_ARG_WITH(snappy-libs, RB_HELP_STRING([--with-snappy-libs=[[[DIR]]]], [Path to snappy library directory]), [ SNAPPY_LDFLAGS="-L$withval" ], []) RB_CHK_SYSHEADER(snappy.h, [SNAPPY_H]) PKG_CHECK_MODULES(snappy, [snappy], [ have_snappy="yes" ], [ AC_CHECK_LIB(snappy, snappy_compress, [ have_snappy="yes" ], [ have_snappy="no" ]) ]) AM_CONDITIONAL([SNAPPY], [test "x$have_snappy" = "xyes"]) AM_COND_IF([SNAPPY], [ SNAPPY_LIBS="-lsnappy" ]) dnl dnl dnl libgmp support dnl dnl AC_SUBST(GMP_CPPFLAGS, []) AC_SUBST(GMP_LDFLAGS, []) AC_SUBST(GMP_LIBS, []) AC_ARG_WITH(gmp-includes, RB_HELP_STRING([--with-gmp-includes=[[[DIR]]]], [Path to libgmp include directory]), [ GMP_CPPFLAGS="-isystem $withval" ], []) AC_ARG_WITH(gmp-libs, RB_HELP_STRING([--with-gmp-libs=[[[DIR]]]], [Path to libgmp library directory]), [ GMP_LDFLAGS="-L$withval" ], []) PKG_CHECK_MODULES(gmp, [gmp], [ have_gmp="yes" ], [ AC_CHECK_LIB([gmp], [__gmp_version], [ have_gmp="yes" ], [ have_gmp="no" ]) ]) AM_CONDITIONAL([GMP], [test "x$have_gmp" = "xyes" ]) AM_COND_IF([GMP], [ GMP_LIBS="-lgmp" ], [ AC_MSG_WARN([Unable to find GNU Multi-Precision library (libgmp) on this system.]) ]) dnl dnl dnl libpbc support dnl dnl AC_SUBST(PBC_CPPFLAGS, []) AC_SUBST(PBC_LDFLAGS, []) AC_SUBST(PBC_LIBS, []) AC_ARG_WITH(pbc-includes, RB_HELP_STRING([--with-pbc-includes=[[[DIR]]]], [Path to libpbc include directory]), [ PBC_CPPFLAGS="-isystem $withval" ], []) AC_ARG_WITH(pbc-libs, RB_HELP_STRING([--with-pbc-libs=[[[DIR]]]], [Path to libpbc library directory]), [ PBC_LDFLAGS="-L$withval" ], []) AC_MSG_CHECKING([whether you asked to use the Pairing-Based Cryptography library included here]) AC_ARG_WITH(included-pbc, RB_HELP_STRING([--with-included-pbc], [Use the libpbc sources from included submodule]), [ AC_MSG_RESULT([yes]) have_pbc="yes" with_included_pbc="yes" AC_DEFINE(HAVE_PBC, 1, [Define to 1 if libpbc is available.]) PBC_CPPFLAGS="-isystem $PWD/deps/pbc/include" PBC_LDFLAGS="-L$PWD/deps/pbc/" PBC_LIBS="$PWD/deps/pbc/libpbc.a" bash tools/buildpbc.sh AS_IF([ test $? != 0 ], [ AC_MSG_ERROR([Failed to build Pairing-Based Cryptography library included submodule]) ]) ], [ AC_MSG_RESULT([no]) with_included_pbc="no" PKG_CHECK_MODULES(pbc, [pbc], [ have_pbc="yes" AC_DEFINE(HAVE_PBC, 1, [Define to 1 if libpbc is available.]) PBC_LIBS="-lpbc" ], [ AC_CHECK_LIB([pbc], [pbc_set_memory_functions], [ have_pbc="yes" AC_DEFINE(HAVE_PBC, 1, [Define to 1 if libpbc is available.]) PBC_LIBS="-lpbc" ], [ have_pbc="no" AC_MSG_WARN([Unable to find Pairing-Based Cryptography (libpbc) on this system.]) ]) ]) ]) AM_CONDITIONAL([PBC], [test "x$have_pbc" = "xyes" ]) dnl dnl dnl Portable Network Graphics (PNG) support dnl dnl AC_SUBST(PNG_CPPFLAGS, []) AC_SUBST(PNG_LDFLAGS, []) AC_SUBST(PNG_LIBS, []) AC_ARG_WITH(png-includes, RB_HELP_STRING([--with-png-includes=[[[DIR]]]], [Path to PNG include directory]), [ RB_VAR_APPEND([PNG_CPPFLAGS], ["-I$withval"]) ]) AC_ARG_WITH(png-libs, RB_HELP_STRING([--with-png-libs=[[[DIR]]]], [Path to PNG library directory]), [ RB_VAR_APPEND([PNG_LDFLAGS], ["-L$withval"]) ], []) RB_CHK_SYSHEADER([png.h], [PNG_H]) PKG_CHECK_MODULES(PNG, [png], [ dnl May not be DT_NEEDED in actual library since Magick loads it dynamically. RB_VAR_APPEND([PNG_LIBS], ["-lpng"]) have_png="yes" ], [ AC_CHECK_LIB([png], [png_access_version_number], [ have_png="yes" RB_VAR_APPEND([PNG_LIBS], ["-lpng"]) ], [ have_png="no" AC_MSG_WARN([Unable to find libpng for portable network graphics on this system.]) ]) ]) AM_CONDITIONAL([PNG], [test "x$have_png" = "xyes"]) dnl IRCD_ENABLE_MAGICK is always defined for use in a constexpr if AM_COND_IF([PNG], [ IRCD_DEFINE(USE_PNG, [1], [Portable Network Graphics (PNG) support is available and enabled]) ], [ IRCD_DEFINE(USE_PNG, [0], [Portable Network Graphics (PNG) support is unavailable or disabled]) ]) dnl dnl dnl ImageMagick support dnl dnl AC_SUBST(IMAGEMAGICK_CPPFLAGS) AC_SUBST(IMAGEMAGICK_LDFLAGS) AC_SUBST(IMAGEMAGICK_LIBS) AC_ARG_WITH(imagemagick-includes, RB_HELP_STRING([--with-imagemagick-includes=[[[DIR]]]], [Path to imagemagick include directory]), [ RB_VAR_APPEND([IMAGEMAGICK_CPPFLAGS], ["-I$withval"]) ], [ RB_VAR_APPEND([IMAGEMAGICK_CPPFLAGS], [-isystem /usr/include/GraphicsMagick/]) ]) AC_ARG_WITH(imagemagick-libs, RB_HELP_STRING([--with-imagemagick-libs=[[[DIR]]]], [Path to imagemagick library directory]), [ RB_VAR_APPEND([IMAGEMAGICK_LDFLAGS], ["-L$withval"]) ], []) dnl push restore_cppflags=$CPPFLAGS restore_ldflags=$LDFLAGS RB_VAR_PREPEND([CPPFLAGS], [$IMAGEMAGICK_CPPFLAGS]) RB_VAR_PREPEND([LDFLAGS], [$IMAGEMAGICK_LDFLAGS]) RB_CHK_SYSHEADER([Magick++.h], [MAGICKPP_H]) PKG_CHECK_MODULES(GraphicsMagickPP, [GraphicsMagick++], [ RB_VAR_APPEND([IMAGEMAGICK_LIBS], ["-lGraphicsMagick++"]) have_imagemagickpp="yes" ], [ have_imagemagickpp="no" ]) RB_CHK_SYSHEADER([wand/wand_api.h], [MAGICK_WAND_API_H]) PKG_CHECK_MODULES(GraphicsMagickWand, [GraphicsMagickWand], [ RB_VAR_APPEND([IMAGEMAGICK_LIBS], ["-lGraphicsMagickWand"]) have_imagemagickwand="yes" ], [ have_imagemagickwand="no" ]) RB_CHK_SYSHEADER([magick/api.h], [MAGICK_API_H]) PKG_CHECK_MODULES(GraphicsMagick, [GraphicsMagick], [ RB_VAR_APPEND([IMAGEMAGICK_LIBS], ["-lGraphicsMagick"]) have_imagemagick="yes" ], [ have_imagemagick="no" ]) dnl pop CPPFLAGS=$restore_cppflags LDFLAGS=$restore_ldflags AM_CONDITIONAL([IMAGEMAGICK], [test "x$have_imagemagick" = "xyes"]) dnl IRCD_ENABLE_MAGICK is always defined for use in a constexpr if AM_COND_IF([IMAGEMAGICK], [ IRCD_DEFINE(USE_MAGICK, [1], [Magick support is available and enabled]) ], [ IRCD_DEFINE(USE_MAGICK, [0], [Magick support is not available]) ]) dnl dnl dnl jemalloc dnl dnl RB_CHK_SYSHEADER(jemalloc/jemalloc.h, [JEMALLOC_H]) PKG_CHECK_MODULES(jemalloc, [jemalloc], [ have_jemalloc="yes" ], [ AC_CHECK_LIB(jemalloc, malloc, [ have_jemalloc="yes" ], [ have_jemalloc="no" ]) ]) AC_MSG_CHECKING(whether to enable use of any found jemalloc) AC_ARG_ENABLE(jemalloc, RB_HELP_STRING([--enable-jemalloc], [Enable jemalloc as dynamic memory manager]), [ enable_jemalloc=$enableval ], [ enable_jemalloc="yes" ]) AC_MSG_RESULT([$enable_jemalloc]) AM_CONDITIONAL([JEMALLOC], [test "x$have_jemalloc" = "xyes" && test "x$enable_jemalloc" = "xyes" ]) dnl dnl dnl Select a third-party allocator dnl dnl AC_SUBST(MALLOC_CPPFLAGS) AC_SUBST(MALLOC_CXXFLAGS) AC_SUBST(MALLOC_LDFLAGS) alloc_lib="standard" dnl ALLOC_LIBS true unless --disable-alloc-libs configured AM_COND_IF([MALLOC_LIBS], [ AM_COND_IF([JEMALLOC], [ alloc_lib="jemalloc" RB_VAR_PREPEND([LIBS], ["-ljemalloc"]) AC_DEFINE(IRCD_ALLOCATOR_USE_JEMALLOC, 1, [Use jemalloc as the allocator]) ], [ AC_DEFINE(IRCD_ALLOCATOR_USE_DEFAULT, 1, [Use the default allocator]) ]) ], [ AC_DEFINE(IRCD_ALLOCATOR_USE_DEFAULT, 1, [Use the default allocator]) ]) dnl dnl dnl libLLVM dnl dnl AC_SUBST(LLVM_CPPFLAGS, []) AC_SUBST(LLVM_LDFLAGS, []) AC_SUBST(LLVM_LIBS, []) AC_ARG_WITH(llvm-includes, RB_HELP_STRING([--with-llvm-includes=[[[DIR]]]], [Path to libllvm include directory]), [ LLVM_CPPFLAGS="-isystem $withval" ], [ LLVM_CPPFLAGS="-isystem /usr/lib/llvm-${CXX_EPOCH}/include" ]) AC_ARG_WITH(llvm-libs, RB_HELP_STRING([--with-llvm-libs=[[[DIR]]]], [Path to libllvm library directory]), [ LLVM_LDFLAGS="-L$withval" ], [ LLVM_LDFLAGS="-L/usr/lib/llvm-${CXX_EPOCH}/lib" ]) PKG_CHECK_MODULES(LLVM, [LLVM], [ have_libllvm="yes" LLVM_LIBS="-lLLVM" ], [ AC_CHECK_LIB([LLVM], [LLVMBuildAnd], [ have_libllvm="yes" LLVM_LIBS="-lLLVM" ], [ have_libllvm="no" AC_MSG_WARN([Unable to find LLVM compiler infrastructure library on this system.]) ]) ]) AM_CONDITIONAL([LLVM], [test "x$have_libllvm" = "xyes" ]) AM_COND_IF(LLVM, [ IRCD_DEFINE(USE_LLVM, [1], [libllvm is available and enabled]) ], [ IRCD_DEFINE(USE_LLVM, [0], [libllvm is not available]) ]) dnl dnl dnl LibDRM dnl dnl AC_SUBST(DRM_CPPFLAGS, []) AC_SUBST(DRM_LDFLAGS, []) AC_SUBST(DRM_LIBS, []) AC_ARG_WITH(drm-includes, RB_HELP_STRING([--with-drm-includes=[[[DIR]]]], [Path to DRM include directory]), [ drm_incdir="$withval" DRM_CPPFLAGS="-isystem $withval" ], []) AC_ARG_WITH(drm-libs, RB_HELP_STRING([--with-drm-libs=[[[DIR]]]], [Path to DRM library directory]), [ drm_libdir="$withval" DRM_LDFLAGS="-L$withval" ], []) RB_CHK_SYSHEADER([xf86drm.h], [XF86DRM_H]) RB_CHK_SYSHEADER([drm/drm.h], [DRM_DRM_H]) PKG_CHECK_MODULES(libdrm, [DRM], [ have_drm="yes" ], [ AC_CHECK_LIB(drm, drmOpen, [ have_drm="yes" ], [ have_drm="no" ]) ]) AC_MSG_CHECKING(whether to enable use of any found DRM) AM_CONDITIONAL([DRM], [test "x$have_drm" = "xyes"]) AM_COND_IF([DRM], [ AC_MSG_RESULT([yes]) IRCD_DEFINE(USE_DRM, [1], [DRM support is available and enabled]) RB_VAR_APPEND([DRM_LIBS], ["-ldrm"]) ], [ IRCD_DEFINE(USE_DRM, [0], [DRM support is not available]) ]) dnl dnl dnl AMD ROCm dnl dnl AC_SUBST(ROCM_CPPFLAGS, []) AC_SUBST(ROCM_LDFLAGS, []) AC_SUBST(ROCM_LIBS, []) AC_ARG_WITH(rocm-includes, RB_HELP_STRING([--with-rocm-includes=[[[DIR]]]], [Path to ROCm include directory]), [ rocm_incdir="$withval" ROCM_CPPFLAGS="-isystem $withval -isystem ${withval}/hsa" ], []) AC_ARG_WITH(rocm-libs, RB_HELP_STRING([--with-rocm-libs=[[[DIR]]]], [Path to ROCm library directory]), [ rocm_libdir="$withval" ROCM_LDFLAGS="-L$withval" ], []) dnl push restore_cppflags=$CPPFLAGS restore_ldflags=$LDFLAGS RB_VAR_PREPEND([CPPFLAGS], [$ROCM_CPPFLAGS]) RB_VAR_PREPEND([LDFLAGS], [$ROCM_LDFLAGS]) RB_CHK_SYSHEADER(rocm_version.h, [ROCM_VERSION_H]) PKG_CHECK_MODULES(rocm, [rocm-core], [ have_rocm="yes" ], [ AC_CHECK_LIB(rocm-core, getROCmVersion, [ have_rocm="yes" ], [ have_rocm="no" ]) ]) dnl pop CPPFLAGS=$restore_cppflags LDFLAGS=$restore_ldflags AC_MSG_CHECKING(whether to enable use of any found ROCm) AC_ARG_ENABLE(rocm, RB_HELP_STRING([--enable-rocm], [Enable ROCm support]), [ enable_rocm=$enableval ], [ enable_rocm="yes" ]) AC_MSG_RESULT([$enable_rocm]) AM_CONDITIONAL([ROCM], [test "x$have_rocm" = "xyes" && test "x$enable_rocm" = "xyes" ]) AM_COND_IF([ROCM], [ IRCD_DEFINE(USE_ROCM, [1], [ROCm support is available and enabled]) ], [ IRCD_DEFINE(USE_ROCM, [0], [ROCm support is not available]) ]) dnl dnl dnl GPU Perf API (GPA) dnl dnl AC_SUBST(GPA_CPPFLAGS, []) AC_SUBST(GPA_LDFLAGS, []) AC_SUBST(GPA_LIBS, []) AC_ARG_WITH(gpa-includes, RB_HELP_STRING([--with-gpa-includes=[[[DIR]]]], [Path to GPA include directory]), [ gpa_incdir="$withval" GPA_CPPFLAGS="-isystem $withval" ], []) AC_ARG_WITH(gpa-libs, RB_HELP_STRING([--with-gpa-libs=[[[DIR]]]], [Path to GPA library directory]), [ gpa_libdir="$withval" GPA_LDFLAGS="-L$withval" ], []) dnl push restore_cppflags=$CPPFLAGS restore_ldflags=$LDFLAGS RB_VAR_PREPEND([CPPFLAGS], [$GPA_CPPFLAGS]) RB_VAR_PREPEND([LDFLAGS], [$GPA_LDFLAGS]) RB_CHK_SYSHEADER(gpu_performance_api/gpu_perf_api.h, [GPU_PERF_API_H]) PKG_CHECK_MODULES(gpa, [GPUPerfAPIVK], [ have_gpa="yes" ], [ AC_CHECK_LIB(GPUPerfAPIVK, GpaGetVersion, [ have_gpa="yes" ], [ have_gpa="no" ]) ]) dnl pop CPPFLAGS=$restore_cppflags LDFLAGS=$restore_ldflags AC_MSG_CHECKING(whether to enable use of any found GPA) AC_ARG_ENABLE(gpa, RB_HELP_STRING([--enable-gpa], [Enable GPA support]), [ enable_gpa=$enableval ], [ enable_gpa="yes" ]) AC_MSG_RESULT([$enable_gpa]) AM_CONDITIONAL([GPA], [test "x$have_gpa" = "xyes" && test "x$enable_gpa" = "xyes" ]) AM_COND_IF([GPA], [ IRCD_DEFINE(USE_GPA, [1], [GPA support is available and enabled]) ], [ IRCD_DEFINE(USE_GPA, [0], [GPA support is not available]) ]) dnl dnl dnl OpenCL dnl dnl AC_SUBST(OPENCL_CPPFLAGS, []) AC_SUBST(OPENCL_LDFLAGS, []) AC_SUBST(OPENCL_LIBS, []) AC_ARG_WITH(opencl-includes, RB_HELP_STRING([--with-opencl-includes=[[[DIR]]]], [Path to OpenCL include directory]), [ opencl_incdir="$withval" OPENCL_CPPFLAGS="-isystem $withval" ], []) AC_ARG_WITH(opencl-libs, RB_HELP_STRING([--with-opencl-libs=[[[DIR]]]], [Path to OpenCL library directory]), [ opencl_libdir="$withval" OPENCL_LDFLAGS="-L$withval" ], []) RB_CHK_SYSHEADER(CL/cl.h, [CL_CL_H]) RB_CHK_SYSHEADER(CL/opencl.h, [CL_OPENCL_H]) PKG_CHECK_MODULES(OpenCL, [OpenCL], [ have_opencl="yes" ], [ AC_CHECK_LIB(OpenCL, clGetPlatformInfo, [ have_opencl="yes" ], [ have_opencl="no" ]) ]) AC_MSG_CHECKING(whether to enable use of any found OpenCL) AC_ARG_ENABLE(opencl, RB_HELP_STRING([--enable-opencl], [Enable OpenCL support]), [ enable_opencl=$enableval ], [ enable_opencl="yes" ]) AC_MSG_RESULT([$enable_opencl]) AM_CONDITIONAL([OPENCL], [test "x$have_opencl" = "xyes" && test "x$enable_opencl" = "xyes" ]) AM_COND_IF([OPENCL], [ IRCD_DEFINE(USE_OPENCL, [1], [OpenCL support is available and enabled]) RB_VAR_APPEND([OPENCL_LIBS], ["-lOpenCL"]) ], [ IRCD_DEFINE(USE_OPENCL, [0], [OpenCL support is not available]) ]) dnl dnl dnl Arm NN dnl dnl AC_SUBST(ARMNN_CPPFLAGS, []) AC_SUBST(ARMNN_LDFLAGS, []) AC_SUBST(ARMNN_LIBS, []) AC_ARG_WITH(armnn-includes, RB_HELP_STRING([--with-armnn-includes=[[[DIR]]]], [Path to Arm NN include directory]), [ armnn_incdir="$withval" ARMNN_CPPFLAGS="-isystem $withval" ], []) AC_ARG_WITH(armnn-libs, RB_HELP_STRING([--with-armnn-libs=[[[DIR]]]], [Path to Arm NN library directory]), [ armnn_libdir="$withval" ARMNN_LDFLAGS="-L$withval" ], []) RB_CHK_SYSHEADER(armnn/ArmNN.hpp, [ARMNN_ARMNN_HPP]) PKG_CHECK_MODULES(armnn, [armnn], [ have_armnn="yes" ], [ AC_CHECK_LIB(armnn, _ZN5armnn7RuntimeD1Ev, [ have_armnn="yes" ], [ have_armnn="no" ]) ]) AC_MSG_CHECKING(whether to enable use of any found ArmNN) AC_ARG_ENABLE(armnn, RB_HELP_STRING([--enable-armnn], [Enable Arm NN support]), [ enable_armnn=$enableval ], [ enable_armnn="yes" ]) AC_MSG_RESULT([$enable_armnn]) AM_CONDITIONAL([ARMNN], [test "x$have_armnn" = "xyes" && test "x$enable_armnn" = "xyes" ]) AM_COND_IF([ARMNN], [ IRCD_DEFINE(USE_ARMNN, [1], [Arm NN support is available and enabled]) RB_VAR_APPEND([ARMNN_LIBS], ["-larmnn"]) ], [ IRCD_DEFINE(USE_ARMNN, [0], [Arm NN support is not available]) ]) dnl dnl dnl liburing dnl dnl AC_SUBST(URING_CPPFLAGS, []) AC_SUBST(URING_LDFLAGS, []) AC_SUBST(URING_LIBS, []) AC_ARG_WITH(uring-includes, RB_HELP_STRING([--with-uring-includes=[[[DIR]]]], [Path to uring include directory]), [ RB_VAR_APPEND([URING_CPPFLAGS], ["-isystem $withval"]) ]) AC_ARG_WITH(uring-libs, RB_HELP_STRING([--with-uring-libs=[[[DIR]]]], [Path to uring libraries directory]), [ RB_VAR_APPEND([URING_LDFLAGS], ["-L$withval"]) ]) dnl push restore_cppflags=$CPPFLAGS restore_ldflags=$LDFLAGS RB_VAR_PREPEND([CPPFLAGS], [$URING_CPPFLAGS]) RB_VAR_PREPEND([LDFLAGS], [$URING_LDFLAGS]) RB_CHK_SYSHEADER(liburing.h, [LIBURING_H]) have_uring="no" PKG_CHECK_MODULES(uring, [uring], [ have_uring="$iou" ], [ AC_CHECK_LIB([uring], [io_uring_queue_init], [ have_uring="$iou" ], [ have_uring="no" ]) ]) dnl pop CPPFLAGS=$restore_cppflags LDFLAGS=$restore_ldflags AM_CONDITIONAL([URING], [test "x$have_uring" = "xyes"]) AM_COND_IF([URING], [ RB_VAR_APPEND([LIBS], ["-luring"]) IRCD_DEFINE(USE_URING, [1], [liburing's availability for use.]) ], [ IRCD_DEFINE(USE_URING, [0], [liburing's availability for use.]) ]) dnl dnl dnl boost support dnl dnl BOOST_VERSION_MIN="1.66" BOOST_VERSION_MIN_PATCH="0" BOOST_BUILT_LIBS="coroutine,context,thread,chrono,system" AC_SUBST(BOOST_CPPFLAGS, []) AC_SUBST(BOOST_LDFLAGS, []) AC_SUBST(BOOST_LIBS, []) AC_ARG_WITH(boost-includes, RB_HELP_STRING([--with-boost-includes=[[[DIR]]]], [Path to boost include directory]), [ boost_incdir="$withval" BOOST_CPPFLAGS="-isystem $withval" ], []) AC_ARG_WITH(boost-libs, RB_HELP_STRING([--with-boost-libs=[[[DIR]]]], [Path to boost library directory]), [ boost_libdir="$withval" BOOST_LDFLAGS="-L$withval" ], []) AC_MSG_CHECKING([whether you asked to use boost sources included here]) AC_ARG_WITH(included-boost, RB_HELP_STRING([--with-included-boost[[[=built]]]], [Use the boost sources from included submodule]), [ AC_MSG_RESULT([yes]) AC_MSG_NOTICE([Bootstrapping boost]) AM_COND_IF([DEBUG], [ dnl boost_variant="debug" boost_variant="release" ], [ boost_variant="release" ]) AM_COND_IF([MINGW], [ BTOOLSET="mingw" boost_libdir="$PWD/deps/boost/stage/lib" ], [ dnl the CXX may have a space and then arguments so we must chop them BTOOLSET=`echo $CXX | cut -d' ' -f1` boost_libdir="$PWD/deps/boost/lib" ]) BOOST_LDFLAGS="-L$boost_libdir" BOOST_CPPFLAGS="-isystem $PWD/deps/boost/include" boost_version="$withval" if test x"$boost_version" == x"yes"; then boost_version="${BOOST_VERSION_MIN}.${BOOST_VERSION_MIN_PATCH}" fi boost_linkage="shared" boost_version="boost-${boost_version}" boost_cxxflags="-std=gnu++20" if [[ $boost_version != "boost-built" ]]; then bash tools/boostrap.sh $BTOOLSET $BOOST_BUILT_LIBS $boost_variant $boost_linkage multi $boost_version $boost_cxxflags AS_IF([ test $? != 0 ], [ AC_MSG_ERROR([Failed to build included boost.]) ]) AC_DEFINE(RB_INCLUDED_BOOST, 1, [Defined if configured with included boost]) AC_MSG_NOTICE([Bootstrapping boost: done]) fi ],[ AC_MSG_RESULT([no]) AX_BOOST_BASE([$BOOST_VERSION_MIN], [ with_included_boost="no" ], [ with_included_boost="yes" AC_MSG_ERROR([Failed to find boost_system library. (try --with-included-boost)]) ]) AX_BOOST_ASIO AX_BOOST_SYSTEM AX_BOOST_COROUTINE AX_BOOST_CONTEXT AX_BOOST_CHRONO boost_linkage="shared" ]) if [[ "$boost_linkage" = "shared" ]]; then AM_COND_IF([MINGW], [ AC_SUBST(BOOST_LIBS, ["-lboost_coroutine-mgw53-1_61.dll -lboost_context-mgw53-1_61.dll -lboost_thread-mgw53-1_61.dll -lboost_system-mgw53-1_61.dll"]) ], [ AC_SUBST(BOOST_LIBS, ["-lboost_coroutine -lboost_context -lboost_thread -lboost_chrono -lboost_system"]) ]) else AM_COND_IF([MINGW], [ AC_SUBST(BOOST_LIBS, ["$boost_libdir/libboost_coroutine-mgw53-1_61.dll.a $boost_libdir/libboost_context-mgw53-1_61.dll.a $boost_libdir/libboost_thread-mgw53-1_61.dll.a $boost_libdir/libboost_system-mgw53-1_61.dll.a"]) ], [ AC_SUBST(BOOST_LIBS, ["$boost_libdir/libboost_coroutine.a $boost_libdir/libboost_context.a $boost_libdir/libboost_thread.a $boost_libdir/libboost_system.a"]) ]) fi dnl Units which require boost::asio use these flags. This includes the dnl ircd/asio.h PCH, which includes ircd.h upstream in the precompile. AC_SUBST(ASIO_UNIT_CPPFLAGS) RB_VAR_APPEND([ASIO_UNIT_CPPFLAGS], ["$BOOST_CPPFLAGS"]) RB_VAR_APPEND([ASIO_UNIT_CPPFLAGS], ["$SSL_CPPFLAGS"]) RB_VAR_APPEND([ASIO_UNIT_CPPFLAGS], ["$CRYPTO_CPPFLAGS"]) RB_VAR_APPEND([ASIO_UNIT_CPPFLAGS], ["$URING_CPPFLAGS"]) dnl Units defining spirit grammars may benefit from special compiler flags due dnl to their various complexities. The ./configure may have generated flags dnl in $GRAMMAR_UNIT_CXXFLAGS to improve compile time and reduce debug symbol. AC_SUBST(SPIRIT_UNIT_CPPFLAGS) RB_VAR_APPEND([SPIRIT_UNIT_CPPFLAGS], ["$ICU_CPPFLAGS"]) RB_VAR_APPEND([SPIRIT_UNIT_CPPFLAGS], ["$BOOST_CPPFLAGS"]) AC_SUBST(SPIRIT_UNIT_CXXFLAGS) AM_COND_IF([GCC], [ RB_VAR_APPEND([SPIRIT_UNIT_CXXFLAGS], ["-fno-var-tracking"]) RB_VAR_APPEND([SPIRIT_UNIT_CXXFLAGS], ["-fno-var-tracking-assignments"]) RB_VAR_APPEND([SPIRIT_UNIT_CXXFLAGS], ["-femit-struct-debug-baseonly"]) AM_COND_IF([LOWMEM_COMPILE], [ RB_VAR_APPEND([SPIRIT_UNIT_CXXFLAGS], ["--param ggc-min-expand=1"]) RB_VAR_APPEND([SPIRIT_UNIT_CXXFLAGS], ["-fno-ipa-pta"]) ]) ]) dnl dnl dnl RocksDB support dnl dnl ROCKSDB_VERSION_DEFAULT="v7.4.5" AC_SUBST(ROCKSDB_CPPFLAGS, []) AC_SUBST(ROCKSDB_LDFLAGS, []) AC_SUBST(ROCKSDB_LIBS, []) AC_ARG_WITH(rocksdb-includes, RB_HELP_STRING([--with-rocksdb-includes=[[[DIR]]]], [Path to RocksDB include directory]), [ ROCKSDB_CPPFLAGS="-isystem $withval" ], []) AC_ARG_WITH(rocksdb-libs, RB_HELP_STRING([--with-rocksdb-libs=[[[DIR]]]], [Path to RocksDB library directory]), [ ROCKSDB_LDFLAGS="-L$withval" ], []) AC_MSG_CHECKING([whether you asked to use the RocksDB included here]) AC_ARG_WITH(included-rocksdb, RB_HELP_STRING([--with-included-rocksdb[[[=version]]]], [Use the RocksDB sources from included submodule]), [ AC_MSG_RESULT([yes]) with_included_rocksdb="yes" AC_MSG_NOTICE([Shared RocksDB linkage requires running charybdis with an intact build directory]) ROCKSDB_CPPFLAGS="-isystem $PWD/deps/rocksdb/include" ROCKSDB_LDFLAGS="-L$PWD/deps/rocksdb/" RB_VAR_APPEND([ROCKSDB_LDFLAGS], ["-Wl,-rpath=$PWD/deps/rocksdb"]) ROCKSDB_LIBS="-lrocksdb" rocksdb_linkage="shared_lib" rocksdb_version="$withval" if test x"$rocksdb_version" == x"yes"; then rocksdb_version="$ROCKSDB_VERSION_DEFAULT" fi if [[ $rocksdb_version != "built" ]]; then bash tools/buildrocks.sh $rocksdb_linkage $rocksdb_version fi AS_IF([ test $? != 0 ], [ AC_MSG_ERROR([Failed to build RocksDB]) ]) ],[ AC_MSG_RESULT([no]) with_included_rocksdb="no" PKG_CHECK_MODULES(rocksdb, [rocksdb], [ ROCKSDB_LIBS="-lrocksdb" ], [ AC_CHECK_LIB(rocksdb, rocksdb_open, [ ROCKSDB_LIBS="-lrocksdb" ], [ AC_MSG_ERROR([Unable to find required RocksDB package. Try apt-get install librocksdb-dev]) ]) ]) ]) dnl Units which include rocksdb headers use these flags. AC_SUBST(ROCKSDB_UNIT_CPPFLAGS) RB_VAR_APPEND([ROCKSDB_UNIT_CPPFLAGS], ["$ROCKSDB_CPPFLAGS"]) RB_VAR_APPEND([ROCKSDB_UNIT_CPPFLAGS], ["$ZSTD_CPPFLAGS"]) RB_VAR_APPEND([ROCKSDB_UNIT_CPPFLAGS], ["$SNAPPY_CPPFLAGS"]) RB_VAR_APPEND([ROCKSDB_UNIT_CPPFLAGS], ["$LZ4_CPPFLAGS"]) RB_VAR_APPEND([ROCKSDB_UNIT_CPPFLAGS], ["$Z_CPPFLAGS"]) dnl dnl dnl SpiderMonkey support dnl dnl AC_MSG_CHECKING([whether you asked to use the JS engine included here]) AC_ARG_WITH(included-js, RB_HELP_STRING([--with-included-js[[[=shared]]]], [Use the JS engine (SpiderMonkey) sources we include here]), [ AC_MSG_RESULT([yes]) with_included_js="yes" AC_SUBST(JS_CPPFLAGS) RB_VAR_APPEND([JS_CPPFLAGS], ["-isystem $PWD/deps/gecko-dev/js/src/build_OPT.OBJ/dist/include"]) #JS_CPPFLAGS+=" -I$PWD/deps/gecko-dev/js/src/build_OPT.OBJ/dist/include" AC_SUBST(JS_LDFLAGS) RB_VAR_APPEND([JS_LDFLAGS], ["-L$PWD/deps/gecko-dev/js/src/build_OPT.OBJ/dist/sdk/lib"]) RB_VAR_APPEND([JS_LDFLAGS], ["-L$PWD/deps/gecko-dev/js/src/build_OPT.OBJ/intl/icu/target/lib"]) RB_VAR_APPEND([JS_LDFLAGS], ["-L$PWD/deps/gecko-dev/js/src/build_OPT.OBJ/js/src"]) AC_SUBST(JS_LIBS) RB_VAR_APPEND([JS_LIBS], ["-lmozjs-68"]) RB_VAR_APPEND([JS_LIBS], ["-lmozglue"]) dnl !!!! dnl HACK BUG-WORKAROUND - Mozilla forgot to include this in their lib? dnl Runtime segfault (unresolved dynamic function address) if this is not specified #JS_LIBS+=" $PWD/deps/gecko-dev/js/src/build_OPT.OBJ/mfbt/Unified_cpp_mfbt0.o" #JS_LIBS+=" $PWD/deps/gecko-dev/js/src/build_OPT.OBJ/mfbt/Unified_cpp_mfbt1.o" RB_VAR_APPEND([JS_LIBS], ["$PWD/deps/gecko-dev/js/src/build_OPT.OBJ/mozglue/misc/TimeStamp.o"]) AC_MSG_CHECKING([whether to use shared JS engine]) if [[ $withval = "shared" ]]; then AC_MSG_RESULT([yes]) AC_MSG_NOTICE([Shared SpiderMonkey linkage requires running charybdis with an intact build directory]) js_linkage="shared" RB_VAR_APPEND([JS_LDFLAGS], ["-Wl,-rpath=$PWD/deps/gecko-dev/js/src/build_OPT.OBJ/dist/sdk/lib"]) RB_VAR_APPEND([JS_LDFLAGS], ["-Wl,-rpath=$PWD/deps/gecko-dev/js/src/build_OPT.OBJ/intl/icu/target/lib"]) else AC_MSG_RESULT([no]) js_linkage="static" RB_VAR_APPEND([JS_LIBS], ["-ljs_static"]) fi js_branch="esr68" if [[ $DEBUG ]]; then js_options="--disable-optimize --enable-debug --disable-js-shell" else js_options="--enable-optimize --disable-js-shell" fi bash tools/buildjs.sh "$js_branch" "$js_options" RB_DEFINE_UNQUOTED([ENABLE_JS], [1], [ Enable JavaScript support. ]) RB_DEFINE_UNQUOTED([INC_JSAPI_H], [jsapi.h>], [ SpiderMonkey JavaScript API. ]) RB_DEFINE_UNQUOTED([INC_JSFRIENDAPI_H], [jsfriendapi.h>], [ SpiderMonkey JavaScript Extended API. ]) RB_DEFINE_UNQUOTED([INC_JS_CONVERSIONS_H], [js/Conversions.h>], [ SpiderMonkey JavaScript Conversions. ]) ],[ AC_MSG_RESULT([no]) with_included_js="no" dnl TODO mumble mumble AC_CHECK_LIB(mozjs-68, _Z11JS_ShutDownv, [ ], [ AC_MSG_WARN([Unable to find JS engine (SpiderMonkey 68) package. Try apt-get install libmozjs-dev]) ]) dnl TODO dnl AC_SUBST(JS_CPPFLAGS, ["-I/usr/include/mozjs-68"]) dnl AC_SUBST(JS_LDFLAGS, []) dnl AC_SUBST(JS_LIBS, ["-lmozjs-68"]) ]) dnl TODO use an $enable_js var AM_CONDITIONAL([JS], [[[[ $with_included_js = yes ]]]]) dnl *************************************************************************** dnl dnl Application settings dnl dnl dnl --with-mxid-maxlen dnl AC_ARG_WITH(mxid-maxlen, RB_HELP_STRING([--with-mxid-maxlen=LENGTH],[Set the upper-bound mxid length to LENGTH (default 255, max 511)]), [ if ! expr "$withval" + 0 >/dev/null 2>&1; then AC_MSG_ERROR(MXID_MAXLEN must be a numeric value) fi if test $withval -gt 511; then MXID_MAXLEN=511 AC_MSG_WARN([MXID_MAXLEN has a hard limit of 511. Setting MXID_MAXLEN=511]) elif test $withval -lt 4; then MXID_MAXLEN=4 AC_MSG_WARN([MXID_MAXLEN has a lower limit of 4. Setting MXID_MAXLEN=4]) else MXID_MAXLEN="$withval" fi ], [ MXID_MAXLEN=255 ]) RB_DEFINE_UNQUOTED([MXID_MAXLEN], [$MXID_MAXLEN], [Maximum string length of an MXID (not including null)]) dnl *************************************************************************** dnl dnl Branding defined in the compilation dnl VERSION_COMMIT_CMD="git rev-parse --short HEAD" RB_VERSION_COMMIT=`$VERSION_COMMIT_CMD` RB_DEFINE_UNQUOTED([VERSION_COMMIT], ["$RB_VERSION_COMMIT"], [Git commit at configuration time.]) #CPPDEFINE([RB_VERSION_COMMIT], [`$VERSION_COMMIT_CMD`]) VERSION_BRANCH_CMD="git rev-parse --abbrev-ref HEAD" RB_VERSION_BRANCH=`$VERSION_BRANCH_CMD` RB_DEFINE_UNQUOTED([VERSION_BRANCH], ["$RB_VERSION_BRANCH"], [Git branch at configuration time.]) #CPPDEFINE([RB_VERSION_BRANCH], [`$VERSION_BRANCH_CMD`]) VERSION_TAG_CMD="git describe --tags --abbrev=0 --dirty --always --broken" RB_VERSION_TAG=`$VERSION_TAG_CMD` RB_DEFINE_UNQUOTED([VERSION_TAG], ["$RB_VERSION_TAG"], [Git tag at configuration time.]) #CPPDEFINE([RB_VERSION_TAG], [`$VERSION_TAG_CMD`]) VERSION_CMD="git describe --tags --always --broken" RB_VERSION=`$VERSION_CMD` RB_DEFINE_UNQUOTED([VERSION], ["$RB_VERSION"], [Version generated at configuration time.]) DATESTR_CMD="date" RB_DATESTR=`$DATESTR_CMD` RB_DEFINE_UNQUOTED([DATESTR], ["$RB_DATESTR"], [Readable date string of configuration time.]) DATECODE_CMD="date +%s" RB_DATECODE=`$DATECODE_CMD` RB_DEFINE_UNQUOTED([TIME_CONFIGURED], [$RB_DATECODE], [UNIX epoch time at configuration time.]) RB_DEFINE_UNQUOTED([DATE_CONFIGURED], ["$RB_DATESTR"], [Convenience string of RB_TIME_CONFIGURED]) dnl dnl --with-custom-branding dnl AC_MSG_CHECKING([whether custom branding is requested]) AC_ARG_WITH(custom-branding, RB_HELP_STRING([--with-custom-branding=NAME], [Custom branding name]), [ BRANDING_NAME="$withval" AC_DEFINE_UNQUOTED(BRANDING_NAME, ["$BRANDING_NAME"], [Custom branding name.]) AC_DEFINE(CUSTOM_BRANDING, 1, [Define if custom branding is enabled.]) AC_MSG_RESULT([yes]) ],[ BRANDING_NAME="$PACKAGE_NAME" AC_DEFINE_UNQUOTED(BRANDING_NAME, ["$BRANDING_NAME"], [Current package]) AC_MSG_RESULT([no]) ]) dnl dnl --with-custom-version dnl AC_MSG_CHECKING([whether a custom version is requested]) AC_ARG_WITH(custom-version, RB_HELP_STRING([--with-custom-version=NAME], [Custom version branding]), [ BRANDING_VERSION="$withval" AC_DEFINE_UNQUOTED(BRANDING_VERSION, ["$BRANDING_VERSION"], [Custom branding version.]) AC_MSG_RESULT([yes]) ], [ BRANDING_VERSION="$RB_VERSION" AC_DEFINE_UNQUOTED(BRANDING_VERSION, ["$BRANDING_VERSION"], [Current version]) AC_MSG_RESULT([no]) ]) dnl *************************************************************************** dnl dnl Output dnl AC_OUTPUT dnl Make it look sexay! echo echo "Configured ........................ $PACKAGE_NAME $PACKAGE_VERSION" echo "Configured time ................... $RB_DATESTR" echo echo "C++ Compiler ...................... $CXX" echo "C++ Compiler flags (CXXFLAGS) ..... $CXXFLAGS" echo echo "Linker ............................ $LD" echo "Linker flags (LDFLAGS) ............ $LDFLAGS" echo echo "Developer platform (build) ........ $build_cpu $build_vendor $build_os" echo "Target platform (host) ............ $host_cpu $host_vendor $host_os" echo "Target clones ..................... $clones" echo "Target features ................... $machine_tuning $machine_features" echo echo "Precompile headers ................ $build_pch" echo "Developer warnings ................ $warnings" echo "Developer debugging ............... $debug" echo "Developer assertions .............. $assert ($assert_type)" echo "Optimized compile ................. $optimize (-O$optimize_level)" echo "Optimized linking ................. $lto" echo echo "Magic support ..................... $have_magic" echo "ImageMagick support ............... $have_imagemagick" echo "PNG support ....................... $have_png" echo "Unicode (icuuc) support ........... $have_icuuc" echo "Ziplinks (libz) support ........... $have_zlib" echo "Zstandard (zstd) support .......... $have_zstd" echo "Snappy support .................... $have_snappy" echo "LZ4 support ....................... $have_lz4" echo "SSL support ....................... $have_ssl" echo "Crypto support .................... $have_crypto" echo "Sodium support .................... $have_sodium" echo "GNU MP support .................... $have_gmp" echo "PBC support ....................... $have_pbc" echo "LLVM library support .............. $have_libllvm" echo "DRM support ....................... $have_drm" echo "ARM NN support .................... $have_armnn" echo "AMD ROCm support .................. $have_rocm" echo "AMD GPA support ................... $have_gpa" echo "OpenCL support .................... $have_opencl" echo "Liburing support .................. $have_uring" echo "Memory allocator .................. $alloc_lib" echo echo "Using bundled Boost ............... $with_included_boost" echo "Using bundled RocksDB ............. $with_included_rocksdb" echo echo "Install prefix .................... $prefix" echo "Binary prefix .................... $bindir" echo "Config prefix ..................... $sysconfdir" echo "Include prefix .................... $includedir" echo "Library prefix .................... $libdir" echo "Shared prefix ..................... $datarootdir" echo echo "Runstate directory ................ $runstatedir" echo "Database directory ................ $dbdir" echo "Logging directory ................. $logdir" echo "Modules directory ................. $moduledir" echo "Shared directory .................. $datadir" echo "Webapp directory .................. $webappdir" echo echo "Matrix ID (mxid) length ........... $MXID_MAXLEN" echo "Logging level ..................... $LOG_LEVEL" echo "Branding .......................... $BRANDING_NAME $BRANDING_VERSION" echo echo "* Ready to build $PACKAGE_NAME" echo "* Now run 'make'"