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