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