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