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