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_CHECK_HEADER([valgrind/memcheck.h], [enable_valgrind=yes], [enable_valgrind=no], [])
 182 AM_CONDITIONAL([VALGRIND_ENABLED],[test "$enable_valgrind" = "yes"])
 183
 184 if test x"$enable_coverage" = x"yes"; then
 185     AC_DEFINE(COVERAGE, 1, [Define this symbol to compile out all VERIFY code])
 186     CFLAGS="-O0 --coverage $CFLAGS"
 187     LDFLAGS="--coverage $LDFLAGS"
 188 else
 189     CFLAGS="-O2 $CFLAGS"
 190 fi
 191
 192 if test x"$use_ecmult_static_precomputation" != x"no"; then
 193   # Temporarily switch to an environment for the native compiler
 194   save_cross_compiling=$cross_compiling
 195   cross_compiling=no
 196   SAVE_CC="$CC"
 197   CC="$CC_FOR_BUILD"
 198   SAVE_CFLAGS="$CFLAGS"
 199   CFLAGS="$CFLAGS_FOR_BUILD"
 200   SAVE_CPPFLAGS="$CPPFLAGS"
 201   CPPFLAGS="$CPPFLAGS_FOR_BUILD"
 202   SAVE_LDFLAGS="$LDFLAGS"
 203   LDFLAGS="$LDFLAGS_FOR_BUILD"
 204
 205   warn_CFLAGS_FOR_BUILD="-Wall -Wextra -Wno-unused-function"
 206   saved_CFLAGS="$CFLAGS"
 207   CFLAGS="$warn_CFLAGS_FOR_BUILD $CFLAGS"
 208   AC_MSG_CHECKING([if native ${CC_FOR_BUILD} supports ${warn_CFLAGS_FOR_BUILD}])
 209   AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
 210       [ AC_MSG_RESULT([yes]) ],
 211       [ AC_MSG_RESULT([no])
 212         CFLAGS="$saved_CFLAGS"
 213       ])
 214
 215   AC_MSG_CHECKING([for working native compiler: ${CC_FOR_BUILD}])
 216   AC_RUN_IFELSE(
 217     [AC_LANG_PROGRAM([], [])],
 218     [working_native_cc=yes],
 219     [working_native_cc=no],[:])
 220
 221   CFLAGS_FOR_BUILD="$CFLAGS"
 222
 223   # Restore the environment
 224   cross_compiling=$save_cross_compiling
 225   CC="$SAVE_CC"
 226   CFLAGS="$SAVE_CFLAGS"
 227   CPPFLAGS="$SAVE_CPPFLAGS"
 228   LDFLAGS="$SAVE_LDFLAGS"
 229
 230   if test x"$working_native_cc" = x"no"; then
 231     AC_MSG_RESULT([no])
 232     set_precomp=no
 233     m4_define([please_set_for_build], [Please set CC_FOR_BUILD, CFLAGS_FOR_BUILD, CPPFLAGS_FOR_BUILD, and/or LDFLAGS_FOR_BUILD.])
 234     if test x"$use_ecmult_static_precomputation" = x"yes";  then
 235       AC_MSG_ERROR([native compiler ${CC_FOR_BUILD} does not produce working binaries. please_set_for_build])
 236     else
 237       AC_MSG_WARN([Disabling statically generated ecmult table because the native compiler ${CC_FOR_BUILD} does not produce working binaries. please_set_for_build])
 238     fi
 239   else
 240     AC_MSG_RESULT([yes])
 241     set_precomp=yes
 242   fi
 243 else
 244   set_precomp=no
 245 fi
 246
 247 if test x"$req_asm" = x"auto"; then
 248   SECP_64BIT_ASM_CHECK
 249   if test x"$has_64bit_asm" = x"yes"; then
 250     set_asm=x86_64
 251   fi
 252   if test x"$set_asm" = x; then
 253     set_asm=no
 254   fi
 255 else
 256   set_asm=$req_asm
 257   case $set_asm in
 258   x86_64)
 259     SECP_64BIT_ASM_CHECK
 260     if test x"$has_64bit_asm" != x"yes"; then
 261       AC_MSG_ERROR([x86_64 assembly optimization requested but not available])
 262     fi
 263     ;;
 264   arm)
 265     ;;
 266   no)
 267     ;;
 268   *)
 269     AC_MSG_ERROR([invalid assembly optimization selection])
 270     ;;
 271   esac
 272 fi
 273
 274 if test x"$req_bignum" = x"auto"; then
 275   SECP_GMP_CHECK
 276   if test x"$has_gmp" = x"yes"; then
 277     set_bignum=gmp
 278   fi
 279
 280   if test x"$set_bignum" = x; then
 281     set_bignum=no
 282   fi
 283 else
 284   set_bignum=$req_bignum
 285   case $set_bignum in
 286   gmp)
 287     SECP_GMP_CHECK
 288     if test x"$has_gmp" != x"yes"; then
 289       AC_MSG_ERROR([gmp bignum explicitly requested but libgmp not available])
 290     fi
 291     ;;
 292   no)
 293     ;;
 294   *)
 295     AC_MSG_ERROR([invalid bignum implementation selection])
 296     ;;
 297   esac
 298 fi
 299
 300 # select assembly optimization
 301 use_external_asm=no
 302
 303 case $set_asm in
 304 x86_64)
 305   AC_DEFINE(USE_ASM_X86_64, 1, [Define this symbol to enable x86_64 assembly optimizations])
 306   ;;
 307 arm)
 308   use_external_asm=yes
 309   ;;
 310 no)
 311   ;;
 312 *)
 313   AC_MSG_ERROR([invalid assembly optimizations])
 314   ;;
 315 esac
 316
 317 # select wide multiplication implementation
 318 case $set_widemul in
 319 int128)
 320   AC_DEFINE(USE_FORCE_WIDEMUL_INT128, 1, [Define this symbol to force the use of the (unsigned) __int128 based wide multiplication implementation])
 321   ;;
 322 int64)
 323   AC_DEFINE(USE_FORCE_WIDEMUL_INT64, 1, [Define this symbol to force the use of the (u)int64_t based wide multiplication implementation])
 324   ;;
 325 auto)
 326   ;;
 327 *)
 328   AC_MSG_ERROR([invalid wide multiplication implementation])
 329   ;;
 330 esac
 331
 332 # select bignum implementation
 333 case $set_bignum in
 334 gmp)
 335   AC_DEFINE(HAVE_LIBGMP, 1, [Define this symbol if libgmp is installed])
 336   AC_DEFINE(USE_NUM_GMP, 1, [Define this symbol to use the gmp implementation for num])
 337   AC_DEFINE(USE_FIELD_INV_NUM, 1, [Define this symbol to use the num-based field inverse implementation])
 338   AC_DEFINE(USE_SCALAR_INV_NUM, 1, [Define this symbol to use the num-based scalar inverse implementation])
 339   ;;
 340 no)
 341   AC_DEFINE(USE_NUM_NONE, 1, [Define this symbol to use no num implementation])
 342   AC_DEFINE(USE_FIELD_INV_BUILTIN, 1, [Define this symbol to use the native field inverse implementation])
 343   AC_DEFINE(USE_SCALAR_INV_BUILTIN, 1, [Define this symbol to use the native scalar inverse implementation])
 344   ;;
 345 *)
 346   AC_MSG_ERROR([invalid bignum implementation])
 347   ;;
 348 esac
 349
 350 #set ecmult window size
 351 if test x"$req_ecmult_window" = x"auto"; then
 352   set_ecmult_window=15
 353 else
 354   set_ecmult_window=$req_ecmult_window
 355 fi
 356
 357 error_window_size=['window size for ecmult precomputation not an integer in range [2..24] or "auto"']
 358 case $set_ecmult_window in
 359 ''|*[[!0-9]]*)
 360   # no valid integer
 361   AC_MSG_ERROR($error_window_size)
 362   ;;
 363 *)
 364   if test "$set_ecmult_window" -lt 2 -o "$set_ecmult_window" -gt 24 ; then
 365     # not in range
 366     AC_MSG_ERROR($error_window_size)
 367   fi
 368   AC_DEFINE_UNQUOTED(ECMULT_WINDOW_SIZE, $set_ecmult_window, [Set window size for ecmult precomputation])
 369   ;;
 370 esac
 371
 372 #set ecmult gen precision
 373 if test x"$req_ecmult_gen_precision" = x"auto"; then
 374   set_ecmult_gen_precision=4
 375 else
 376   set_ecmult_gen_precision=$req_ecmult_gen_precision
 377 fi
 378
 379 case $set_ecmult_gen_precision in
 380 2|4|8)
 381   AC_DEFINE_UNQUOTED(ECMULT_GEN_PREC_BITS, $set_ecmult_gen_precision, [Set ecmult gen precision bits])
 382   ;;
 383 *)
 384   AC_MSG_ERROR(['ecmult gen precision not 2, 4, 8 or "auto"'])
 385   ;;
 386 esac
 387
 388 if test x"$use_tests" = x"yes"; then
 389   SECP_OPENSSL_CHECK
 390   if test x"$has_openssl_ec" = x"yes"; then
 391     if test x"$enable_openssl_tests" != x"no"; then
 392       AC_DEFINE(ENABLE_OPENSSL_TESTS, 1, [Define this symbol if OpenSSL EC functions are available])
 393       SECP_TEST_INCLUDES="$SSL_CFLAGS $CRYPTO_CFLAGS $CRYPTO_CPPFLAGS"
 394       SECP_TEST_LIBS="$CRYPTO_LIBS"
 395
 396       case $host in
 397       *mingw*)
 398         SECP_TEST_LIBS="$SECP_TEST_LIBS -lgdi32"
 399         ;;
 400       esac
 401     fi
 402   else
 403     if test x"$enable_openssl_tests" = x"yes"; then
 404       AC_MSG_ERROR([OpenSSL tests requested but OpenSSL with EC support is not available])
 405     fi
 406   fi
 407 else
 408   if test x"$enable_openssl_tests" = x"yes"; then
 409     AC_MSG_ERROR([OpenSSL tests requested but tests are not enabled])
 410   fi
 411 fi
 412
 413 if test x"$set_bignum" = x"gmp"; then
 414   SECP_LIBS="$SECP_LIBS $GMP_LIBS"
 415   SECP_INCLUDES="$SECP_INCLUDES $GMP_CPPFLAGS"
 416 fi
 417
 418 if test x"$use_endomorphism" = x"yes"; then
 419   AC_DEFINE(USE_ENDOMORPHISM, 1, [Define this symbol to use endomorphism optimization])
 420 fi
 421
 422 if test x"$set_precomp" = x"yes"; then
 423   AC_DEFINE(USE_ECMULT_STATIC_PRECOMPUTATION, 1, [Define this symbol to use a statically generated ecmult table])
 424 fi
 425
 426 if test x"$enable_module_ecdh" = x"yes"; then
 427   AC_DEFINE(ENABLE_MODULE_ECDH, 1, [Define this symbol to enable the ECDH module])
 428 fi
 429
 430 if test x"$enable_module_recovery" = x"yes"; then
 431   AC_DEFINE(ENABLE_MODULE_RECOVERY, 1, [Define this symbol to enable the ECDSA pubkey recovery module])
 432 fi
 433
 434 if test x"$enable_module_schnorrsig" = x"yes"; then
 435   AC_DEFINE(ENABLE_MODULE_SCHNORRSIG, 1, [Define this symbol to enable the schnorrsig module])
 436   enable_module_extrakeys=yes
 437 fi
 438
 439 # Test if extrakeys is set after the schnorrsig module to allow the schnorrsig
 440 # module to set enable_module_extrakeys=yes
 441 if test x"$enable_module_extrakeys" = x"yes"; then
 442   AC_DEFINE(ENABLE_MODULE_EXTRAKEYS, 1, [Define this symbol to enable the extrakeys module])
 443 fi
 444
 445 if test x"$use_external_asm" = x"yes"; then
 446   AC_DEFINE(USE_EXTERNAL_ASM, 1, [Define this symbol if an external (non-inline) assembly implementation is used])
 447 fi
 448
 449 if test x"$use_external_default_callbacks" = x"yes"; then
 450   AC_DEFINE(USE_EXTERNAL_DEFAULT_CALLBACKS, 1, [Define this symbol if an external implementation of the default callbacks is used])
 451 fi
 452
 453 if test x"$enable_experimental" = x"yes"; then
 454   AC_MSG_NOTICE([******])
 455   AC_MSG_NOTICE([WARNING: experimental build])
 456   AC_MSG_NOTICE([Experimental features do not have stable APIs or properties, and may not be safe for production use.])
 457   AC_MSG_NOTICE([Building ECDH module: $enable_module_ecdh])
 458   AC_MSG_NOTICE([Building extrakeys module: $enable_module_extrakeys])
 459   AC_MSG_NOTICE([Building schnorrsig module: $enable_module_schnorrsig])
 460   AC_MSG_NOTICE([******])
 461 else
 462   if test x"$enable_module_ecdh" = x"yes"; then
 463     AC_MSG_ERROR([ECDH module is experimental. Use --enable-experimental to allow.])
 464   fi
 465   if test x"$enable_module_extrakeys" = x"yes"; then
 466     AC_MSG_ERROR([extrakeys module is experimental. Use --enable-experimental to allow.])
 467   fi
 468   if test x"$enable_module_schnorrsig" = x"yes"; then
 469     AC_MSG_ERROR([schnorrsig module is experimental. Use --enable-experimental to allow.])
 470   fi
 471   if test x"$set_asm" = x"arm"; then
 472     AC_MSG_ERROR([ARM assembly optimization is experimental. Use --enable-experimental to allow.])
 473   fi
 474 fi
 475
 476 AC_CONFIG_HEADERS([src/libsecp256k1-config.h])
 477 AC_CONFIG_FILES([Makefile libsecp256k1.pc])
 478 AC_SUBST(SECP_INCLUDES)
 479 AC_SUBST(SECP_LIBS)
 480 AC_SUBST(SECP_TEST_LIBS)
 481 AC_SUBST(SECP_TEST_INCLUDES)
 482 AM_CONDITIONAL([ENABLE_COVERAGE], [test x"$enable_coverage" = x"yes"])
 483 AM_CONDITIONAL([USE_TESTS], [test x"$use_tests" != x"no"])
 484 AM_CONDITIONAL([USE_EXHAUSTIVE_TESTS], [test x"$use_exhaustive_tests" != x"no"])
 485 AM_CONDITIONAL([USE_BENCHMARK], [test x"$use_benchmark" = x"yes"])
 486 AM_CONDITIONAL([USE_ECMULT_STATIC_PRECOMPUTATION], [test x"$set_precomp" = x"yes"])
 487 AM_CONDITIONAL([ENABLE_MODULE_ECDH], [test x"$enable_module_ecdh" = x"yes"])
 488 AM_CONDITIONAL([ENABLE_MODULE_RECOVERY], [test x"$enable_module_recovery" = x"yes"])
 489 AM_CONDITIONAL([ENABLE_MODULE_EXTRAKEYS], [test x"$enable_module_extrakeys" = x"yes"])
 490 AM_CONDITIONAL([ENABLE_MODULE_SCHNORRSIG], [test x"$enable_module_schnorrsig" = x"yes"])
 491 AM_CONDITIONAL([USE_EXTERNAL_ASM], [test x"$use_external_asm" = x"yes"])
 492 AM_CONDITIONAL([USE_ASM_ARM], [test x"$set_asm" = x"arm"])
 493
 494 dnl make sure nothing new is exported so that we don't break the cache
 495 PKGCONFIG_PATH_TEMP="$PKG_CONFIG_PATH"
 496 unset PKG_CONFIG_PATH
 497 PKG_CONFIG_PATH="$PKGCONFIG_PATH_TEMP"
 498
 499 AC_OUTPUT
 500
 501 echo
 502 echo "Build Options:"
 503 echo "  with endomorphism       = $use_endomorphism"
 504 echo "  with ecmult precomp     = $set_precomp"
 505 echo "  with external callbacks = $use_external_default_callbacks"
 506 echo "  with benchmarks         = $use_benchmark"
 507 echo "  with coverage           = $enable_coverage"
 508 echo "  module ecdh             = $enable_module_ecdh"
 509 echo "  module recovery         = $enable_module_recovery"
 510 echo "  module extrakeys        = $enable_module_extrakeys"
 511 echo "  module schnorrsig       = $enable_module_schnorrsig"
 512 echo
 513 echo "  asm                     = $set_asm"
 514 echo "  bignum                  = $set_bignum"
 515 echo "  ecmult window size      = $set_ecmult_window"
 516 echo "  ecmult gen prec. bits   = $set_ecmult_gen_precision"
 517 dnl Hide test-only options unless they're used.
 518 if test x"$set_widemul" != xauto; then
 519 echo "  wide multiplication     = $set_widemul"
 520 fi
 521 echo
 522 echo "  valgrind                = $enable_valgrind"
 523 echo "  CC                      = $CC"
 524 echo "  CFLAGS                  = $CFLAGS"
 525 echo "  CPPFLAGS                = $CPPFLAGS"
 526 echo "  LDFLAGS                 = $LDFLAGS"
 527 echo