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