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