configure.ac

   1 AC_PREREQ([2.60])
   2 AC_INIT([libsecp256k1],[0.1])
   3 AC_CONFIG_AUX_DIR([build-aux])
   4 AC_CONFIG_MACRO_DIR([build-aux/m4])
   5 AC_CANONICAL_HOST
   6 AH_TOP([#ifndef LIBSECP256K1_CONFIG_H])
   7 AH_TOP([#define LIBSECP256K1_CONFIG_H])
   8 AH_BOTTOM([#endif /*LIBSECP256K1_CONFIG_H*/])
   9 AM_INIT_AUTOMAKE([foreign subdir-objects])
  10
  11 # Set -g if CFLAGS are not already set, which matches the default autoconf
  12 # behavior (see PROG_CC in the Autoconf manual) with the exception that we don't
  13 # set -O2 here because we set it in any case (see further down).
  14 : ${CFLAGS="-g"}
  15 LT_INIT
  16
  17 dnl make the compilation flags quiet unless V=1 is used
  18 m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
  19
  20 PKG_PROG_PKG_CONFIG
  21
  22 AC_PATH_TOOL(AR, ar)
  23 AC_PATH_TOOL(RANLIB, ranlib)
  24 AC_PATH_TOOL(STRIP, strip)
  25 AX_PROG_CC_FOR_BUILD
  26
  27 AM_PROG_CC_C_O
  28
  29 AC_PROG_CC_C89
  30 if test x"$ac_cv_prog_cc_c89" = x"no"; then
  31   AC_MSG_ERROR([c89 compiler support required])
  32 fi
  33 AM_PROG_AS
  34
  35 case $host_os in
  36   *darwin*)
  37      if  test x$cross_compiling != xyes; then
  38        AC_PATH_PROG([BREW],brew,)
  39        if test x$BREW != x; then
  40          dnl These Homebrew packages may be keg-only, meaning that they won't be found
  41          dnl in expected paths because they may conflict with system files. Ask
  42          dnl Homebrew where each one is located, then adjust paths accordingly.
  43          openssl_prefix=`$BREW --prefix openssl 2>/dev/null`
  44          gmp_prefix=`$BREW --prefix gmp 2>/dev/null`
  45          valgrind_prefix=`$BREW --prefix valgrind 2>/dev/null`
  46          if test x$openssl_prefix != x; then
  47            PKG_CONFIG_PATH="$openssl_prefix/lib/pkgconfig:$PKG_CONFIG_PATH"
  48            export PKG_CONFIG_PATH
  49            CRYPTO_CPPFLAGS="-I$openssl_prefix/include"
  50          fi
  51          if test x$gmp_prefix != x; then
  52            GMP_CPPFLAGS="-I$gmp_prefix/include"
  53            GMP_LIBS="-L$gmp_prefix/lib"
  54          fi
  55          if test x$valgrind_prefix != x; then
  56            VALGRIND_CPPFLAGS="-I$valgrind_prefix/include"
  57          fi
  58        else
  59          AC_PATH_PROG([PORT],port,)
  60          dnl if homebrew isn't installed and macports is, add the macports default paths
  61          dnl as a last resort.
  62          if test x$PORT != x; then
  63            CPPFLAGS="$CPPFLAGS -isystem /opt/local/include"
  64            LDFLAGS="$LDFLAGS -L/opt/local/lib"
  65          fi
  66        fi
  67      fi
  68    ;;
  69 esac
  70
  71 CFLAGS="-W $CFLAGS"
  72
  73 warn_CFLAGS="-std=c89 -pedantic -Wall -Wextra -Wcast-align -Wnested-externs -Wshadow -Wstrict-prototypes -Wundef -Wno-unused-function -Wno-long-long -Wno-overlength-strings"
  74 saved_CFLAGS="$CFLAGS"
  75 CFLAGS="$warn_CFLAGS $CFLAGS"
  76 AC_MSG_CHECKING([if ${CC} supports ${warn_CFLAGS}])
  77 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
  78     [ AC_MSG_RESULT([yes]) ],
  79     [ AC_MSG_RESULT([no])
  80       CFLAGS="$saved_CFLAGS"
  81     ])
  82
  83 saved_CFLAGS="$CFLAGS"
  84 CFLAGS="-fvisibility=hidden $CFLAGS"
  85 AC_MSG_CHECKING([if ${CC} supports -fvisibility=hidden])
  86 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
  87     [ AC_MSG_RESULT([yes]) ],
  88     [ AC_MSG_RESULT([no])
  89       CFLAGS="$saved_CFLAGS"
  90     ])
  91
  92 AC_ARG_ENABLE(benchmark,
  93     AS_HELP_STRING([--enable-benchmark],[compile benchmark [default=yes]]),
  94     [use_benchmark=$enableval],
  95     [use_benchmark=yes])
  96
  97 AC_ARG_ENABLE(coverage,
  98     AS_HELP_STRING([--enable-coverage],[enable compiler flags to support kcov coverage analysis [default=no]]),
  99     [enable_coverage=$enableval],
 100     [enable_coverage=no])
 101
 102 AC_ARG_ENABLE(tests,
 103     AS_HELP_STRING([--enable-tests],[compile tests [default=yes]]),
 104     [use_tests=$enableval],
 105     [use_tests=yes])
 106
 107 AC_ARG_ENABLE(openssl_tests,
 108     AS_HELP_STRING([--enable-openssl-tests],[enable OpenSSL tests [default=auto]]),
 109     [enable_openssl_tests=$enableval],
 110     [enable_openssl_tests=auto])
 111
 112 AC_ARG_ENABLE(experimental,
 113     AS_HELP_STRING([--enable-experimental],[allow experimental configure options [default=no]]),
 114     [use_experimental=$enableval],
 115     [use_experimental=no])
 116
 117 AC_ARG_ENABLE(exhaustive_tests,
 118     AS_HELP_STRING([--enable-exhaustive-tests],[compile exhaustive tests [default=yes]]),
 119     [use_exhaustive_tests=$enableval],
 120     [use_exhaustive_tests=yes])
 121
 122 AC_ARG_ENABLE(ecmult_static_precomputation,
 123     AS_HELP_STRING([--enable-ecmult-static-precomputation],[enable precomputed ecmult table for signing [default=auto]]),
 124     [use_ecmult_static_precomputation=$enableval],
 125     [use_ecmult_static_precomputation=auto])
 126
 127 AC_ARG_ENABLE(module_ecdh,
 128     AS_HELP_STRING([--enable-module-ecdh],[enable ECDH shared secret computation]),
 129     [enable_module_ecdh=$enableval],
 130     [enable_module_ecdh=no])
 131
 132 AC_ARG_ENABLE(module_recovery,
 133     AS_HELP_STRING([--enable-module-recovery],[enable ECDSA pubkey recovery module [default=no]]),
 134     [enable_module_recovery=$enableval],
 135     [enable_module_recovery=no])
 136
 137 AC_ARG_ENABLE(module_extrakeys,
 138     AS_HELP_STRING([--enable-module-extrakeys],[enable extrakeys module (experimental)]),
 139     [enable_module_extrakeys=$enableval],
 140     [enable_module_extrakeys=no])
 141
 142 AC_ARG_ENABLE(module_schnorrsig,
 143     AS_HELP_STRING([--enable-module-schnorrsig],[enable schnorrsig module (experimental)]),
 144     [enable_module_schnorrsig=$enableval],
 145     [enable_module_schnorrsig=no])
 146
 147 AC_ARG_ENABLE(external_default_callbacks,
 148     AS_HELP_STRING([--enable-external-default-callbacks],[enable external default callback functions [default=no]]),
 149     [use_external_default_callbacks=$enableval],
 150     [use_external_default_callbacks=no])
 151
 152 dnl Test-only override of the (autodetected by the C code) "widemul" setting.
 153 dnl Legal values are int64 (for [u]int64_t), int128 (for [unsigned] __int128), and auto (the default).
 154 AC_ARG_WITH([test-override-wide-multiply], [] ,[set_widemul=$withval], [set_widemul=auto])
 155
 156 AC_ARG_WITH([bignum], [AS_HELP_STRING([--with-bignum=gmp|no|auto],
 157 [bignum implementation to use [default=auto]])],[req_bignum=$withval], [req_bignum=auto])
 158
 159 AC_ARG_WITH([asm], [AS_HELP_STRING([--with-asm=x86_64|arm|no|auto],
 160 [assembly optimizations to use (experimental: arm) [default=auto]])],[req_asm=$withval], [req_asm=auto])
 161
 162 AC_ARG_WITH([ecmult-window], [AS_HELP_STRING([--with-ecmult-window=SIZE|auto],
 163 [window size for ecmult precomputation for verification, specified as integer in range [2..24].]
 164 [Larger values result in possibly better performance at the cost of an exponentially larger precomputed table.]
 165 [The table will store 2^(SIZE-1) * 64 bytes of data but can be larger in memory due to platform-specific padding and alignment.]
 166 ["auto" is a reasonable setting for desktop machines (currently 15). [default=auto]]
 167 )],
 168 [req_ecmult_window=$withval], [req_ecmult_window=auto])
 169
 170 AC_ARG_WITH([ecmult-gen-precision], [AS_HELP_STRING([--with-ecmult-gen-precision=2|4|8|auto],
 171 [Precision bits to tune the precomputed table size for signing.]
 172 [The size of the table is 32kB for 2 bits, 64kB for 4 bits, 512kB for 8 bits of precision.]
 173 [A larger table size usually results in possible faster signing.]
 174 ["auto" is a reasonable setting for desktop machines (currently 4). [default=auto]]
 175 )],
 176 [req_ecmult_gen_precision=$withval], [req_ecmult_gen_precision=auto])
 177
 178 AC_ARG_WITH([valgrind], [AS_HELP_STRING([--with-valgrind=yes|no|auto],
 179 [Build with extra checks for running inside Valgrind [default=auto]]
 180 )],
 181 [req_valgrind=$withval], [req_valgrind=auto])
 182
 183 if test x"$req_valgrind" = x"no"; then
 184   enable_valgrind=no
 185 else
 186   SECP_VALGRIND_CHECK
 187   if test x"$has_valgrind" != x"yes"; then
 188     if test x"$req_valgrind" = x"yes"; then
 189       AC_MSG_ERROR([Valgrind support explicitly requested but valgrind/memcheck.h header not available])
 190     fi
 191     enable_valgrind=no
 192   else
 193     enable_valgrind=yes
 194   fi
 195 fi
 196 AM_CONDITIONAL([VALGRIND_ENABLED],[test "$enable_valgrind" = "yes"])
 197
 198 if test x"$enable_coverage" = x"yes"; then
 199     AC_DEFINE(COVERAGE, 1, [Define this symbol to compile out all VERIFY code])
 200     CFLAGS="-O0 --coverage $CFLAGS"
 201     LDFLAGS="--coverage $LDFLAGS"
 202 else
 203     CFLAGS="-O2 $CFLAGS"
 204 fi
 205
 206 if test x"$use_ecmult_static_precomputation" != x"no"; then
 207   # Temporarily switch to an environment for the native compiler
 208   save_cross_compiling=$cross_compiling
 209   cross_compiling=no
 210   SAVE_CC="$CC"
 211   CC="$CC_FOR_BUILD"
 212   SAVE_CFLAGS="$CFLAGS"
 213   CFLAGS="$CFLAGS_FOR_BUILD"
 214   SAVE_CPPFLAGS="$CPPFLAGS"
 215   CPPFLAGS="$CPPFLAGS_FOR_BUILD"
 216   SAVE_LDFLAGS="$LDFLAGS"
 217   LDFLAGS="$LDFLAGS_FOR_BUILD"
 218
 219   warn_CFLAGS_FOR_BUILD="-Wall -Wextra -Wno-unused-function"
 220   saved_CFLAGS="$CFLAGS"
 221   CFLAGS="$warn_CFLAGS_FOR_BUILD $CFLAGS"
 222   AC_MSG_CHECKING([if native ${CC_FOR_BUILD} supports ${warn_CFLAGS_FOR_BUILD}])
 223   AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
 224       [ AC_MSG_RESULT([yes]) ],
 225       [ AC_MSG_RESULT([no])
 226         CFLAGS="$saved_CFLAGS"
 227       ])
 228
 229   AC_MSG_CHECKING([for working native compiler: ${CC_FOR_BUILD}])
 230   AC_RUN_IFELSE(
 231     [AC_LANG_PROGRAM([], [])],
 232     [working_native_cc=yes],
 233     [working_native_cc=no],[:])
 234
 235   CFLAGS_FOR_BUILD="$CFLAGS"
 236
 237   # Restore the environment
 238   cross_compiling=$save_cross_compiling
 239   CC="$SAVE_CC"
 240   CFLAGS="$SAVE_CFLAGS"
 241   CPPFLAGS="$SAVE_CPPFLAGS"
 242   LDFLAGS="$SAVE_LDFLAGS"
 243
 244   if test x"$working_native_cc" = x"no"; then
 245     AC_MSG_RESULT([no])
 246     set_precomp=no
 247     m4_define([please_set_for_build], [Please set CC_FOR_BUILD, CFLAGS_FOR_BUILD, CPPFLAGS_FOR_BUILD, and/or LDFLAGS_FOR_BUILD.])
 248     if test x"$use_ecmult_static_precomputation" = x"yes";  then
 249       AC_MSG_ERROR([native compiler ${CC_FOR_BUILD} does not produce working binaries. please_set_for_build])
 250     else
 251       AC_MSG_WARN([Disabling statically generated ecmult table because the native compiler ${CC_FOR_BUILD} does not produce working binaries. please_set_for_build])
 252     fi
 253   else
 254     AC_MSG_RESULT([yes])
 255     set_precomp=yes
 256   fi
 257 else
 258   set_precomp=no
 259 fi
 260
 261 if test x"$req_asm" = x"auto"; then
 262   SECP_64BIT_ASM_CHECK
 263   if test x"$has_64bit_asm" = x"yes"; then
 264     set_asm=x86_64
 265   fi
 266   if test x"$set_asm" = x; then
 267     set_asm=no
 268   fi
 269 else
 270   set_asm=$req_asm
 271   case $set_asm in
 272   x86_64)
 273     SECP_64BIT_ASM_CHECK
 274     if test x"$has_64bit_asm" != x"yes"; then
 275       AC_MSG_ERROR([x86_64 assembly optimization requested but not available])
 276     fi
 277     ;;
 278   arm)
 279     ;;
 280   no)
 281     ;;
 282   *)
 283     AC_MSG_ERROR([invalid assembly optimization selection])
 284     ;;
 285   esac
 286 fi
 287
 288 if test x"$req_bignum" = x"auto"; then
 289   SECP_GMP_CHECK
 290   if test x"$has_gmp" = x"yes"; then
 291     set_bignum=gmp
 292   fi
 293
 294   if test x"$set_bignum" = x; then
 295     set_bignum=no
 296   fi
 297 else
 298   set_bignum=$req_bignum
 299   case $set_bignum in
 300   gmp)
 301     SECP_GMP_CHECK
 302     if test x"$has_gmp" != x"yes"; then
 303       AC_MSG_ERROR([gmp bignum explicitly requested but libgmp not available])
 304     fi
 305     ;;
 306   no)
 307     ;;
 308   *)
 309     AC_MSG_ERROR([invalid bignum implementation selection])
 310     ;;
 311   esac
 312 fi
 313
 314 # select assembly optimization
 315 use_external_asm=no
 316
 317 case $set_asm in
 318 x86_64)
 319   AC_DEFINE(USE_ASM_X86_64, 1, [Define this symbol to enable x86_64 assembly optimizations])
 320   ;;
 321 arm)
 322   use_external_asm=yes
 323   ;;
 324 no)
 325   ;;
 326 *)
 327   AC_MSG_ERROR([invalid assembly optimizations])
 328   ;;
 329 esac
 330
 331 # select wide multiplication implementation
 332 case $set_widemul in
 333 int128)
 334   AC_DEFINE(USE_FORCE_WIDEMUL_INT128, 1, [Define this symbol to force the use of the (unsigned) __int128 based wide multiplication implementation])
 335   ;;
 336 int64)
 337   AC_DEFINE(USE_FORCE_WIDEMUL_INT64, 1, [Define this symbol to force the use of the (u)int64_t based wide multiplication implementation])
 338   ;;
 339 auto)
 340   ;;
 341 *)
 342   AC_MSG_ERROR([invalid wide multiplication implementation])
 343   ;;
 344 esac
 345
 346 # select bignum implementation
 347 case $set_bignum in
 348 gmp)
 349   AC_DEFINE(HAVE_LIBGMP, 1, [Define this symbol if libgmp is installed])
 350   AC_DEFINE(USE_NUM_GMP, 1, [Define this symbol to use the gmp implementation for num])
 351   AC_DEFINE(USE_FIELD_INV_NUM, 1, [Define this symbol to use the num-based field inverse implementation])
 352   AC_DEFINE(USE_SCALAR_INV_NUM, 1, [Define this symbol to use the num-based scalar inverse implementation])
 353   ;;
 354 no)
 355   AC_DEFINE(USE_NUM_NONE, 1, [Define this symbol to use no num implementation])
 356   AC_DEFINE(USE_FIELD_INV_BUILTIN, 1, [Define this symbol to use the native field inverse implementation])
 357   AC_DEFINE(USE_SCALAR_INV_BUILTIN, 1, [Define this symbol to use the native scalar inverse implementation])
 358   ;;
 359 *)
 360   AC_MSG_ERROR([invalid bignum implementation])
 361   ;;
 362 esac
 363
 364 #set ecmult window size
 365 if test x"$req_ecmult_window" = x"auto"; then
 366   set_ecmult_window=15
 367 else
 368   set_ecmult_window=$req_ecmult_window
 369 fi
 370
 371 error_window_size=['window size for ecmult precomputation not an integer in range [2..24] or "auto"']
 372 case $set_ecmult_window in
 373 ''|*[[!0-9]]*)
 374   # no valid integer
 375   AC_MSG_ERROR($error_window_size)
 376   ;;
 377 *)
 378   if test "$set_ecmult_window" -lt 2 -o "$set_ecmult_window" -gt 24 ; then
 379     # not in range
 380     AC_MSG_ERROR($error_window_size)
 381   fi
 382   AC_DEFINE_UNQUOTED(ECMULT_WINDOW_SIZE, $set_ecmult_window, [Set window size for ecmult precomputation])
 383   ;;
 384 esac
 385
 386 #set ecmult gen precision
 387 if test x"$req_ecmult_gen_precision" = x"auto"; then
 388   set_ecmult_gen_precision=4
 389 else
 390   set_ecmult_gen_precision=$req_ecmult_gen_precision
 391 fi
 392
 393 case $set_ecmult_gen_precision in
 394 2|4|8)
 395   AC_DEFINE_UNQUOTED(ECMULT_GEN_PREC_BITS, $set_ecmult_gen_precision, [Set ecmult gen precision bits])
 396   ;;
 397 *)
 398   AC_MSG_ERROR(['ecmult gen precision not 2, 4, 8 or "auto"'])
 399   ;;
 400 esac
 401
 402 if test x"$use_tests" = x"yes"; then
 403   SECP_OPENSSL_CHECK
 404   if test x"$enable_openssl_tests" != x"no" && test x"$has_openssl_ec" = x"yes"; then
 405       enable_openssl_tests=yes
 406       AC_DEFINE(ENABLE_OPENSSL_TESTS, 1, [Define this symbol if OpenSSL EC functions are available])
 407       SECP_TEST_INCLUDES="$SSL_CFLAGS $CRYPTO_CFLAGS $CRYPTO_CPPFLAGS"
 408       SECP_TEST_LIBS="$CRYPTO_LIBS"
 409
 410       case $host in
 411       *mingw*)
 412         SECP_TEST_LIBS="$SECP_TEST_LIBS -lgdi32"
 413         ;;
 414       esac
 415   else
 416     if test x"$enable_openssl_tests" = x"yes"; then
 417       AC_MSG_ERROR([OpenSSL tests requested but OpenSSL with EC support is not available])
 418     fi
 419     enable_openssl_tests=no
 420   fi
 421 else
 422   if test x"$enable_openssl_tests" = x"yes"; then
 423     AC_MSG_ERROR([OpenSSL tests requested but tests are not enabled])
 424   fi
 425   enable_openssl_tests=no
 426 fi
 427
 428 if test x"$set_bignum" = x"gmp"; then
 429   SECP_LIBS="$SECP_LIBS $GMP_LIBS"
 430   SECP_INCLUDES="$SECP_INCLUDES $GMP_CPPFLAGS"
 431 fi
 432
 433 if test x"$enable_valgrind" = x"yes"; then
 434   SECP_INCLUDES="$SECP_INCLUDES $VALGRIND_CPPFLAGS"
 435 fi
 436
 437 if test x"$set_precomp" = x"yes"; then
 438   AC_DEFINE(USE_ECMULT_STATIC_PRECOMPUTATION, 1, [Define this symbol to use a statically generated ecmult table])
 439 fi
 440
 441 if test x"$enable_module_ecdh" = x"yes"; then
 442   AC_DEFINE(ENABLE_MODULE_ECDH, 1, [Define this symbol to enable the ECDH module])
 443 fi
 444
 445 if test x"$enable_module_recovery" = x"yes"; then
 446   AC_DEFINE(ENABLE_MODULE_RECOVERY, 1, [Define this symbol to enable the ECDSA pubkey recovery module])
 447 fi
 448
 449 if test x"$enable_module_schnorrsig" = x"yes"; then
 450   AC_DEFINE(ENABLE_MODULE_SCHNORRSIG, 1, [Define this symbol to enable the schnorrsig module])
 451   enable_module_extrakeys=yes
 452 fi
 453
 454 # Test if extrakeys is set after the schnorrsig module to allow the schnorrsig
 455 # module to set enable_module_extrakeys=yes
 456 if test x"$enable_module_extrakeys" = x"yes"; then
 457   AC_DEFINE(ENABLE_MODULE_EXTRAKEYS, 1, [Define this symbol to enable the extrakeys module])
 458 fi
 459
 460 if test x"$use_external_asm" = x"yes"; then
 461   AC_DEFINE(USE_EXTERNAL_ASM, 1, [Define this symbol if an external (non-inline) assembly implementation is used])
 462 fi
 463
 464 if test x"$use_external_default_callbacks" = x"yes"; then
 465   AC_DEFINE(USE_EXTERNAL_DEFAULT_CALLBACKS, 1, [Define this symbol if an external implementation of the default callbacks is used])
 466 fi
 467
 468 if test x"$enable_experimental" = x"yes"; then
 469   AC_MSG_NOTICE([******])
 470   AC_MSG_NOTICE([WARNING: experimental build])
 471   AC_MSG_NOTICE([Experimental features do not have stable APIs or properties, and may not be safe for production use.])
 472   AC_MSG_NOTICE([Building extrakeys module: $enable_module_extrakeys])
 473   AC_MSG_NOTICE([Building schnorrsig module: $enable_module_schnorrsig])
 474   AC_MSG_NOTICE([******])
 475 else
 476   if test x"$enable_module_extrakeys" = x"yes"; then
 477     AC_MSG_ERROR([extrakeys module is experimental. Use --enable-experimental to allow.])
 478   fi
 479   if test x"$enable_module_schnorrsig" = x"yes"; then
 480     AC_MSG_ERROR([schnorrsig module is experimental. Use --enable-experimental to allow.])
 481   fi
 482   if test x"$set_asm" = x"arm"; then
 483     AC_MSG_ERROR([ARM assembly optimization is experimental. Use --enable-experimental to allow.])
 484   fi
 485 fi
 486
 487 AC_CONFIG_HEADERS([src/libsecp256k1-config.h])
 488 AC_CONFIG_FILES([Makefile libsecp256k1.pc])
 489 AC_SUBST(SECP_INCLUDES)
 490 AC_SUBST(SECP_LIBS)
 491 AC_SUBST(SECP_TEST_LIBS)
 492 AC_SUBST(SECP_TEST_INCLUDES)
 493 AM_CONDITIONAL([ENABLE_COVERAGE], [test x"$enable_coverage" = x"yes"])
 494 AM_CONDITIONAL([USE_TESTS], [test x"$use_tests" != x"no"])
 495 AM_CONDITIONAL([USE_EXHAUSTIVE_TESTS], [test x"$use_exhaustive_tests" != x"no"])
 496 AM_CONDITIONAL([USE_BENCHMARK], [test x"$use_benchmark" = x"yes"])
 497 AM_CONDITIONAL([USE_ECMULT_STATIC_PRECOMPUTATION], [test x"$set_precomp" = x"yes"])
 498 AM_CONDITIONAL([ENABLE_MODULE_ECDH], [test x"$enable_module_ecdh" = x"yes"])
 499 AM_CONDITIONAL([ENABLE_MODULE_RECOVERY], [test x"$enable_module_recovery" = x"yes"])
 500 AM_CONDITIONAL([ENABLE_MODULE_EXTRAKEYS], [test x"$enable_module_extrakeys" = x"yes"])
 501 AM_CONDITIONAL([ENABLE_MODULE_SCHNORRSIG], [test x"$enable_module_schnorrsig" = x"yes"])
 502 AM_CONDITIONAL([USE_EXTERNAL_ASM], [test x"$use_external_asm" = x"yes"])
 503 AM_CONDITIONAL([USE_ASM_ARM], [test x"$set_asm" = x"arm"])
 504
 505 dnl make sure nothing new is exported so that we don't break the cache
 506 PKGCONFIG_PATH_TEMP="$PKG_CONFIG_PATH"
 507 unset PKG_CONFIG_PATH
 508 PKG_CONFIG_PATH="$PKGCONFIG_PATH_TEMP"
 509
 510 AC_OUTPUT
 511
 512 echo
 513 echo "Build Options:"
 514 echo "  with ecmult precomp     = $set_precomp"
 515 echo "  with external callbacks = $use_external_default_callbacks"
 516 echo "  with benchmarks         = $use_benchmark"
 517 echo "  with tests              = $use_tests"
 518 echo "  with openssl tests      = $enable_openssl_tests"
 519 echo "  with coverage           = $enable_coverage"
 520 echo "  module ecdh             = $enable_module_ecdh"
 521 echo "  module recovery         = $enable_module_recovery"
 522 echo "  module extrakeys        = $enable_module_extrakeys"
 523 echo "  module schnorrsig       = $enable_module_schnorrsig"
 524 echo
 525 echo "  asm                     = $set_asm"
 526 echo "  bignum                  = $set_bignum"
 527 echo "  ecmult window size      = $set_ecmult_window"
 528 echo "  ecmult gen prec. bits   = $set_ecmult_gen_precision"
 529 dnl Hide test-only options unless they're used.
 530 if test x"$set_widemul" != xauto; then
 531 echo "  wide multiplication     = $set_widemul"
 532 fi
 533 echo
 534 echo "  valgrind                = $enable_valgrind"
 535 echo "  CC                      = $CC"
 536 echo "  CFLAGS                  = $CFLAGS"
 537 echo "  CPPFLAGS                = $CPPFLAGS"
 538 echo "  LDFLAGS                 = $LDFLAGS"
 539 echo