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
  44          openssl_prefix=`$BREW --prefix openssl 2>/dev/null`
  45          gmp_prefix=`$BREW --prefix gmp 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        else
  56          AC_PATH_PROG([PORT],port,)
  57          dnl if homebrew isn't installed and macports is, add the macports default paths
  58          dnl as a last resort.
  59          if test x$PORT != x; then
  60            CPPFLAGS="$CPPFLAGS -isystem /opt/local/include"
  61            LDFLAGS="$LDFLAGS -L/opt/local/lib"
  62          fi
  63        fi
  64      fi
  65    ;;
  66 esac
  67
  68 CFLAGS="-W $CFLAGS"
  69
  70 warn_CFLAGS="-std=c89 -pedantic -Wall -Wextra -Wcast-align -Wnested-externs -Wshadow -Wstrict-prototypes -Wundef -Wno-unused-function -Wno-long-long -Wno-overlength-strings"
  71 saved_CFLAGS="$CFLAGS"
  72 CFLAGS="$warn_CFLAGS $CFLAGS"
  73 AC_MSG_CHECKING([if ${CC} supports ${warn_CFLAGS}])
  74 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
  75     [ AC_MSG_RESULT([yes]) ],
  76     [ AC_MSG_RESULT([no])
  77       CFLAGS="$saved_CFLAGS"
  78     ])
  79
  80 saved_CFLAGS="$CFLAGS"
  81 CFLAGS="-fvisibility=hidden $CFLAGS"
  82 AC_MSG_CHECKING([if ${CC} supports -fvisibility=hidden])
  83 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
  84     [ AC_MSG_RESULT([yes]) ],
  85     [ AC_MSG_RESULT([no])
  86       CFLAGS="$saved_CFLAGS"
  87     ])
  88
  89 AC_ARG_ENABLE(benchmark,
  90     AS_HELP_STRING([--enable-benchmark],[compile benchmark [default=yes]]),
  91     [use_benchmark=$enableval],
  92     [use_benchmark=yes])
  93
  94 AC_ARG_ENABLE(coverage,
  95     AS_HELP_STRING([--enable-coverage],[enable compiler flags to support kcov coverage analysis [default=no]]),
  96     [enable_coverage=$enableval],
  97     [enable_coverage=no])
  98
  99 AC_ARG_ENABLE(tests,
 100     AS_HELP_STRING([--enable-tests],[compile tests [default=yes]]),
 101     [use_tests=$enableval],
 102     [use_tests=yes])
 103
 104 AC_ARG_ENABLE(openssl_tests,
 105     AS_HELP_STRING([--enable-openssl-tests],[enable OpenSSL tests [default=auto]]),
 106     [enable_openssl_tests=$enableval],
 107     [enable_openssl_tests=auto])
 108
 109 AC_ARG_ENABLE(experimental,
 110     AS_HELP_STRING([--enable-experimental],[allow experimental configure options [default=no]]),
 111     [use_experimental=$enableval],
 112     [use_experimental=no])
 113
 114 AC_ARG_ENABLE(exhaustive_tests,
 115     AS_HELP_STRING([--enable-exhaustive-tests],[compile exhaustive tests [default=yes]]),
 116     [use_exhaustive_tests=$enableval],
 117     [use_exhaustive_tests=yes])
 118
 119 AC_ARG_ENABLE(endomorphism,
 120     AS_HELP_STRING([--enable-endomorphism],[enable endomorphism [default=no]]),
 121     [use_endomorphism=$enableval],
 122     [use_endomorphism=no])
 123
 124 AC_ARG_ENABLE(ecmult_static_precomputation,
 125     AS_HELP_STRING([--enable-ecmult-static-precomputation],[enable precomputed ecmult table for signing [default=auto]]),
 126     [use_ecmult_static_precomputation=$enableval],
 127     [use_ecmult_static_precomputation=auto])
 128
 129 AC_ARG_ENABLE(module_ecdh,
 130     AS_HELP_STRING([--enable-module-ecdh],[enable ECDH shared secret computation (experimental)]),
 131     [enable_module_ecdh=$enableval],
 132     [enable_module_ecdh=no])
 133
 134 AC_ARG_ENABLE(module_recovery,
 135     AS_HELP_STRING([--enable-module-recovery],[enable ECDSA pubkey recovery module [default=no]]),
 136     [enable_module_recovery=$enableval],
 137     [enable_module_recovery=no])
 138
 139 AC_ARG_ENABLE(module_extrakeys,
 140     AS_HELP_STRING([--enable-module-extrakeys],[enable extrakeys module (experimental)]),
 141     [enable_module_extrakeys=$enableval],
 142     [enable_module_extrakeys=no])
 143
 144 AC_ARG_ENABLE(module_schnorrsig,
 145     AS_HELP_STRING([--enable-module-schnorrsig],[enable schnorrsig module (experimental)]),
 146     [enable_module_schnorrsig=$enableval],
 147     [enable_module_schnorrsig=no])
 148
 149 AC_ARG_ENABLE(external_default_callbacks,
 150     AS_HELP_STRING([--enable-external-default-callbacks],[enable external default callback functions [default=no]]),
 151     [use_external_default_callbacks=$enableval],
 152     [use_external_default_callbacks=no])
 153
 154 dnl Test-only override of the (autodetected by the C code) "widemul" setting.
 155 dnl Legal values are int64 (for [u]int64_t), int128 (for [unsigned] __int128), and auto (the default).
 156 AC_ARG_WITH([test-override-wide-multiply], [] ,[set_widemul=$withval], [set_widemul=auto])
 157
 158 AC_ARG_WITH([bignum], [AS_HELP_STRING([--with-bignum=gmp|no|auto],
 159 [bignum implementation to use [default=auto]])],[req_bignum=$withval], [req_bignum=auto])
 160
 161 AC_ARG_WITH([asm], [AS_HELP_STRING([--with-asm=x86_64|arm|no|auto],
 162 [assembly optimizations to use (experimental: arm) [default=auto]])],[req_asm=$withval], [req_asm=auto])
 163
 164 AC_ARG_WITH([ecmult-window], [AS_HELP_STRING([--with-ecmult-window=SIZE|auto],
 165 [window size for ecmult precomputation for verification, specified as integer in range [2..24].]
 166 [Larger values result in possibly better performance at the cost of an exponentially larger precomputed table.]
 167 [The table will store 2^(SIZE-2) * 64 bytes of data but can be larger in memory due to platform-specific padding and alignment.]
 168 [If the endomorphism optimization is enabled, two tables of this size are used instead of only one.]
 169 ["auto" is a reasonable setting for desktop machines (currently 15). [default=auto]]
 170 )],
 171 [req_ecmult_window=$withval], [req_ecmult_window=auto])
 172
 173 AC_ARG_WITH([ecmult-gen-precision], [AS_HELP_STRING([--with-ecmult-gen-precision=2|4|8|auto],
 174 [Precision bits to tune the precomputed table size for signing.]
 175 [The size of the table is 32kB for 2 bits, 64kB for 4 bits, 512kB for 8 bits of precision.]
 176 [A larger table size usually results in possible faster signing.]
 177 ["auto" is a reasonable setting for desktop machines (currently 4). [default=auto]]
 178 )],
 179 [req_ecmult_gen_precision=$withval], [req_ecmult_gen_precision=auto])
 180
 181 AC_ARG_WITH([valgrind], [AS_HELP_STRING([--with-valgrind=yes|no|auto],
 182 [Build with extra checks for running inside Valgrind [default=auto]]
 183 )],
 184 [req_valgrind=$withval], [req_valgrind=auto])
 185
 186 if test x"$req_valgrind" = x"no"; then
 187   enable_valgrind=no
 188 else
 189   AC_CHECK_HEADER([valgrind/memcheck.h], [enable_valgrind=yes], [
 190     if test x"$req_valgrind" = x"yes"; then
 191       AC_MSG_ERROR([Valgrind support explicitly requested but valgrind/memcheck.h header not available])
 192     fi
 193     enable_valgrind=no
 194   ], [])
 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"$has_openssl_ec" = x"yes"; then
 405     if test x"$enable_openssl_tests" != x"no"; then
 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     fi
 416   else
 417     if test x"$enable_openssl_tests" = x"yes"; then
 418       AC_MSG_ERROR([OpenSSL tests requested but OpenSSL with EC support is not available])
 419     fi
 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 fi
 426
 427 if test x"$set_bignum" = x"gmp"; then
 428   SECP_LIBS="$SECP_LIBS $GMP_LIBS"
 429   SECP_INCLUDES="$SECP_INCLUDES $GMP_CPPFLAGS"
 430 fi
 431
 432 if test x"$use_endomorphism" = x"yes"; then
 433   AC_DEFINE(USE_ENDOMORPHISM, 1, [Define this symbol to use endomorphism optimization])
 434 fi
 435
 436 if test x"$set_precomp" = x"yes"; then
 437   AC_DEFINE(USE_ECMULT_STATIC_PRECOMPUTATION, 1, [Define this symbol to use a statically generated ecmult table])
 438 fi
 439
 440 if test x"$enable_module_ecdh" = x"yes"; then
 441   AC_DEFINE(ENABLE_MODULE_ECDH, 1, [Define this symbol to enable the ECDH module])
 442 fi
 443
 444 if test x"$enable_module_recovery" = x"yes"; then
 445   AC_DEFINE(ENABLE_MODULE_RECOVERY, 1, [Define this symbol to enable the ECDSA pubkey recovery module])
 446 fi
 447
 448 if test x"$enable_module_schnorrsig" = x"yes"; then
 449   AC_DEFINE(ENABLE_MODULE_SCHNORRSIG, 1, [Define this symbol to enable the schnorrsig module])
 450   enable_module_extrakeys=yes
 451 fi
 452
 453 # Test if extrakeys is set after the schnorrsig module to allow the schnorrsig
 454 # module to set enable_module_extrakeys=yes
 455 if test x"$enable_module_extrakeys" = x"yes"; then
 456   AC_DEFINE(ENABLE_MODULE_EXTRAKEYS, 1, [Define this symbol to enable the extrakeys module])
 457 fi
 458
 459 if test x"$use_external_asm" = x"yes"; then
 460   AC_DEFINE(USE_EXTERNAL_ASM, 1, [Define this symbol if an external (non-inline) assembly implementation is used])
 461 fi
 462
 463 if test x"$use_external_default_callbacks" = x"yes"; then
 464   AC_DEFINE(USE_EXTERNAL_DEFAULT_CALLBACKS, 1, [Define this symbol if an external implementation of the default callbacks is used])
 465 fi
 466
 467 if test x"$enable_experimental" = x"yes"; then
 468   AC_MSG_NOTICE([******])
 469   AC_MSG_NOTICE([WARNING: experimental build])
 470   AC_MSG_NOTICE([Experimental features do not have stable APIs or properties, and may not be safe for production use.])
 471   AC_MSG_NOTICE([Building ECDH module: $enable_module_ecdh])
 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_ecdh" = x"yes"; then
 477     AC_MSG_ERROR([ECDH module is experimental. Use --enable-experimental to allow.])
 478   fi
 479   if test x"$enable_module_extrakeys" = x"yes"; then
 480     AC_MSG_ERROR([extrakeys module is experimental. Use --enable-experimental to allow.])
 481   fi
 482   if test x"$enable_module_schnorrsig" = x"yes"; then
 483     AC_MSG_ERROR([schnorrsig module is experimental. Use --enable-experimental to allow.])
 484   fi
 485   if test x"$set_asm" = x"arm"; then
 486     AC_MSG_ERROR([ARM assembly optimization is experimental. Use --enable-experimental to allow.])
 487   fi
 488 fi
 489
 490 AC_CONFIG_HEADERS([src/libsecp256k1-config.h])
 491 AC_CONFIG_FILES([Makefile libsecp256k1.pc])
 492 AC_SUBST(SECP_INCLUDES)
 493 AC_SUBST(SECP_LIBS)
 494 AC_SUBST(SECP_TEST_LIBS)
 495 AC_SUBST(SECP_TEST_INCLUDES)
 496 AM_CONDITIONAL([ENABLE_COVERAGE], [test x"$enable_coverage" = x"yes"])
 497 AM_CONDITIONAL([USE_TESTS], [test x"$use_tests" != x"no"])
 498 AM_CONDITIONAL([USE_EXHAUSTIVE_TESTS], [test x"$use_exhaustive_tests" != x"no"])
 499 AM_CONDITIONAL([USE_BENCHMARK], [test x"$use_benchmark" = x"yes"])
 500 AM_CONDITIONAL([USE_ECMULT_STATIC_PRECOMPUTATION], [test x"$set_precomp" = x"yes"])
 501 AM_CONDITIONAL([ENABLE_MODULE_ECDH], [test x"$enable_module_ecdh" = x"yes"])
 502 AM_CONDITIONAL([ENABLE_MODULE_RECOVERY], [test x"$enable_module_recovery" = x"yes"])
 503 AM_CONDITIONAL([ENABLE_MODULE_EXTRAKEYS], [test x"$enable_module_extrakeys" = x"yes"])
 504 AM_CONDITIONAL([ENABLE_MODULE_SCHNORRSIG], [test x"$enable_module_schnorrsig" = x"yes"])
 505 AM_CONDITIONAL([USE_EXTERNAL_ASM], [test x"$use_external_asm" = x"yes"])
 506 AM_CONDITIONAL([USE_ASM_ARM], [test x"$set_asm" = x"arm"])
 507
 508 dnl make sure nothing new is exported so that we don't break the cache
 509 PKGCONFIG_PATH_TEMP="$PKG_CONFIG_PATH"
 510 unset PKG_CONFIG_PATH
 511 PKG_CONFIG_PATH="$PKGCONFIG_PATH_TEMP"
 512
 513 AC_OUTPUT
 514
 515 echo
 516 echo "Build Options:"
 517 echo "  with endomorphism       = $use_endomorphism"
 518 echo "  with ecmult precomp     = $set_precomp"
 519 echo "  with external callbacks = $use_external_default_callbacks"
 520 echo "  with benchmarks         = $use_benchmark"
 521 echo "  with coverage           = $enable_coverage"
 522 echo "  module ecdh             = $enable_module_ecdh"
 523 echo "  module recovery         = $enable_module_recovery"
 524 echo "  module extrakeys        = $enable_module_extrakeys"
 525 echo "  module schnorrsig       = $enable_module_schnorrsig"
 526 echo
 527 echo "  asm                     = $set_asm"
 528 echo "  bignum                  = $set_bignum"
 529 echo "  ecmult window size      = $set_ecmult_window"
 530 echo "  ecmult gen prec. bits   = $set_ecmult_gen_precision"
 531 dnl Hide test-only options unless they're used.
 532 if test x"$set_widemul" != xauto; then
 533 echo "  wide multiplication     = $set_widemul"
 534 fi
 535 echo
 536 echo "  valgrind                = $enable_valgrind"
 537 echo "  CC                      = $CC"
 538 echo "  CFLAGS                  = $CFLAGS"
 539 echo "  CPPFLAGS                = $CPPFLAGS"
 540 echo "  LDFLAGS                 = $LDFLAGS"
 541 echo