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_ENABLE(jni,
 143     AS_HELP_STRING([--enable-jni],[enable libsecp256k1_jni [default=no]]),
 144     [use_jni=$enableval],
 145     [use_jni=no])
 146
 147 AC_ARG_WITH([field], [AS_HELP_STRING([--with-field=64bit|32bit|auto],
 148 [finite field implementation to use [default=auto]])],[req_field=$withval], [req_field=auto])
 149
 150 AC_ARG_WITH([bignum], [AS_HELP_STRING([--with-bignum=gmp|no|auto],
 151 [bignum implementation to use [default=auto]])],[req_bignum=$withval], [req_bignum=auto])
 152
 153 AC_ARG_WITH([scalar], [AS_HELP_STRING([--with-scalar=64bit|32bit|auto],
 154 [scalar implementation to use [default=auto]])],[req_scalar=$withval], [req_scalar=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_CHECK_TYPES([__int128])
 169
 170 if test x"$enable_coverage" = x"yes"; then
 171     AC_DEFINE(COVERAGE, 1, [Define this symbol to compile out all VERIFY code])
 172     CFLAGS="$CFLAGS -O0 --coverage"
 173     LDFLAGS="$LDFLAGS --coverage"
 174 else
 175     CFLAGS="$CFLAGS -O3"
 176 fi
 177
 178 if test x"$use_ecmult_static_precomputation" != x"no"; then
 179   # Temporarily switch to an environment for the native compiler
 180   save_cross_compiling=$cross_compiling
 181   cross_compiling=no
 182   SAVE_CC="$CC"
 183   CC="$CC_FOR_BUILD"
 184   SAVE_CFLAGS="$CFLAGS"
 185   CFLAGS="$CFLAGS_FOR_BUILD"
 186   SAVE_CPPFLAGS="$CPPFLAGS"
 187   CPPFLAGS="$CPPFLAGS_FOR_BUILD"
 188   SAVE_LDFLAGS="$LDFLAGS"
 189   LDFLAGS="$LDFLAGS_FOR_BUILD"
 190
 191   warn_CFLAGS_FOR_BUILD="-Wall -Wextra -Wno-unused-function"
 192   saved_CFLAGS="$CFLAGS"
 193   CFLAGS="$CFLAGS $warn_CFLAGS_FOR_BUILD"
 194   AC_MSG_CHECKING([if native ${CC_FOR_BUILD} supports ${warn_CFLAGS_FOR_BUILD}])
 195   AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
 196       [ AC_MSG_RESULT([yes]) ],
 197       [ AC_MSG_RESULT([no])
 198         CFLAGS="$saved_CFLAGS"
 199       ])
 200
 201   AC_MSG_CHECKING([for working native compiler: ${CC_FOR_BUILD}])
 202   AC_RUN_IFELSE(
 203     [AC_LANG_PROGRAM([], [])],
 204     [working_native_cc=yes],
 205     [working_native_cc=no],[dnl])
 206
 207   CFLAGS_FOR_BUILD="$CFLAGS"
 208
 209   # Restore the environment
 210   cross_compiling=$save_cross_compiling
 211   CC="$SAVE_CC"
 212   CFLAGS="$SAVE_CFLAGS"
 213   CPPFLAGS="$SAVE_CPPFLAGS"
 214   LDFLAGS="$SAVE_LDFLAGS"
 215
 216   if test x"$working_native_cc" = x"no"; then
 217     AC_MSG_RESULT([no])
 218     set_precomp=no
 219     m4_define([please_set_for_build], [Please set CC_FOR_BUILD, CFLAGS_FOR_BUILD, CPPFLAGS_FOR_BUILD, and/or LDFLAGS_FOR_BUILD.])
 220     if test x"$use_ecmult_static_precomputation" = x"yes";  then
 221       AC_MSG_ERROR([native compiler ${CC_FOR_BUILD} does not produce working binaries. please_set_for_build])
 222     else
 223       AC_MSG_WARN([Disabling statically generated ecmult table because the native compiler ${CC_FOR_BUILD} does not produce working binaries. please_set_for_build])
 224     fi
 225   else
 226     AC_MSG_RESULT([yes])
 227     set_precomp=yes
 228   fi
 229 else
 230   set_precomp=no
 231 fi
 232
 233 if test x"$req_asm" = x"auto"; then
 234   SECP_64BIT_ASM_CHECK
 235   if test x"$has_64bit_asm" = x"yes"; then
 236     set_asm=x86_64
 237   fi
 238   if test x"$set_asm" = x; then
 239     set_asm=no
 240   fi
 241 else
 242   set_asm=$req_asm
 243   case $set_asm in
 244   x86_64)
 245     SECP_64BIT_ASM_CHECK
 246     if test x"$has_64bit_asm" != x"yes"; then
 247       AC_MSG_ERROR([x86_64 assembly optimization requested but not available])
 248     fi
 249     ;;
 250   arm)
 251     ;;
 252   no)
 253     ;;
 254   *)
 255     AC_MSG_ERROR([invalid assembly optimization selection])
 256     ;;
 257   esac
 258 fi
 259
 260 if test x"$req_field" = x"auto"; then
 261   if test x"set_asm" = x"x86_64"; then
 262     set_field=64bit
 263   fi
 264   if test x"$set_field" = x; then
 265     SECP_INT128_CHECK
 266     if test x"$has_int128" = x"yes"; then
 267       set_field=64bit
 268     fi
 269   fi
 270   if test x"$set_field" = x; then
 271     set_field=32bit
 272   fi
 273 else
 274   set_field=$req_field
 275   case $set_field in
 276   64bit)
 277     if test x"$set_asm" != x"x86_64"; then
 278       SECP_INT128_CHECK
 279       if test x"$has_int128" != x"yes"; then
 280         AC_MSG_ERROR([64bit field explicitly requested but neither __int128 support or x86_64 assembly available])
 281       fi
 282     fi
 283     ;;
 284   32bit)
 285     ;;
 286   *)
 287     AC_MSG_ERROR([invalid field implementation selection])
 288     ;;
 289   esac
 290 fi
 291
 292 if test x"$req_scalar" = x"auto"; then
 293   SECP_INT128_CHECK
 294   if test x"$has_int128" = x"yes"; then
 295     set_scalar=64bit
 296   fi
 297   if test x"$set_scalar" = x; then
 298     set_scalar=32bit
 299   fi
 300 else
 301   set_scalar=$req_scalar
 302   case $set_scalar in
 303   64bit)
 304     SECP_INT128_CHECK
 305     if test x"$has_int128" != x"yes"; then
 306       AC_MSG_ERROR([64bit scalar explicitly requested but __int128 support not available])
 307     fi
 308     ;;
 309   32bit)
 310     ;;
 311   *)
 312     AC_MSG_ERROR([invalid scalar implementation selected])
 313     ;;
 314   esac
 315 fi
 316
 317 if test x"$req_bignum" = x"auto"; then
 318   SECP_GMP_CHECK
 319   if test x"$has_gmp" = x"yes"; then
 320     set_bignum=gmp
 321   fi
 322
 323   if test x"$set_bignum" = x; then
 324     set_bignum=no
 325   fi
 326 else
 327   set_bignum=$req_bignum
 328   case $set_bignum in
 329   gmp)
 330     SECP_GMP_CHECK
 331     if test x"$has_gmp" != x"yes"; then
 332       AC_MSG_ERROR([gmp bignum explicitly requested but libgmp not available])
 333     fi
 334     ;;
 335   no)
 336     ;;
 337   *)
 338     AC_MSG_ERROR([invalid bignum implementation selection])
 339     ;;
 340   esac
 341 fi
 342
 343 # select assembly optimization
 344 use_external_asm=no
 345
 346 case $set_asm in
 347 x86_64)
 348   AC_DEFINE(USE_ASM_X86_64, 1, [Define this symbol to enable x86_64 assembly optimizations])
 349   ;;
 350 arm)
 351   use_external_asm=yes
 352   ;;
 353 no)
 354   ;;
 355 *)
 356   AC_MSG_ERROR([invalid assembly optimizations])
 357   ;;
 358 esac
 359
 360 # select field implementation
 361 case $set_field in
 362 64bit)
 363   AC_DEFINE(USE_FIELD_5X52, 1, [Define this symbol to use the FIELD_5X52 implementation])
 364   ;;
 365 32bit)
 366   AC_DEFINE(USE_FIELD_10X26, 1, [Define this symbol to use the FIELD_10X26 implementation])
 367   ;;
 368 *)
 369   AC_MSG_ERROR([invalid field implementation])
 370   ;;
 371 esac
 372
 373 # select bignum implementation
 374 case $set_bignum in
 375 gmp)
 376   AC_DEFINE(HAVE_LIBGMP, 1, [Define this symbol if libgmp is installed])
 377   AC_DEFINE(USE_NUM_GMP, 1, [Define this symbol to use the gmp implementation for num])
 378   AC_DEFINE(USE_FIELD_INV_NUM, 1, [Define this symbol to use the num-based field inverse implementation])
 379   AC_DEFINE(USE_SCALAR_INV_NUM, 1, [Define this symbol to use the num-based scalar inverse implementation])
 380   ;;
 381 no)
 382   AC_DEFINE(USE_NUM_NONE, 1, [Define this symbol to use no num implementation])
 383   AC_DEFINE(USE_FIELD_INV_BUILTIN, 1, [Define this symbol to use the native field inverse implementation])
 384   AC_DEFINE(USE_SCALAR_INV_BUILTIN, 1, [Define this symbol to use the native scalar inverse implementation])
 385   ;;
 386 *)
 387   AC_MSG_ERROR([invalid bignum implementation])
 388   ;;
 389 esac
 390
 391 #select scalar implementation
 392 case $set_scalar in
 393 64bit)
 394   AC_DEFINE(USE_SCALAR_4X64, 1, [Define this symbol to use the 4x64 scalar implementation])
 395   ;;
 396 32bit)
 397   AC_DEFINE(USE_SCALAR_8X32, 1, [Define this symbol to use the 8x32 scalar implementation])
 398   ;;
 399 *)
 400   AC_MSG_ERROR([invalid scalar implementation])
 401   ;;
 402 esac
 403
 404 #set ecmult window size
 405 if test x"$req_ecmult_window" = x"auto"; then
 406   set_ecmult_window=15
 407 else
 408   set_ecmult_window=$req_ecmult_window
 409 fi
 410
 411 error_window_size=['window size for ecmult precomputation not an integer in range [2..24] or "auto"']
 412 case $set_ecmult_window in
 413 ''|*[[!0-9]]*)
 414   # no valid integer
 415   AC_MSG_ERROR($error_window_size)
 416   ;;
 417 *)
 418   if test "$set_ecmult_window" -lt 2 -o "$set_ecmult_window" -gt 24 ; then
 419     # not in range
 420     AC_MSG_ERROR($error_window_size)
 421   fi
 422   AC_DEFINE_UNQUOTED(ECMULT_WINDOW_SIZE, $set_ecmult_window, [Set window size for ecmult precomputation])
 423   ;;
 424 esac
 425
 426 if test x"$use_tests" = x"yes"; then
 427   SECP_OPENSSL_CHECK
 428   if test x"$has_openssl_ec" = x"yes"; then
 429     if test x"$enable_openssl_tests" != x"no"; then
 430       AC_DEFINE(ENABLE_OPENSSL_TESTS, 1, [Define this symbol if OpenSSL EC functions are available])
 431       SECP_TEST_INCLUDES="$SSL_CFLAGS $CRYPTO_CFLAGS"
 432       SECP_TEST_LIBS="$CRYPTO_LIBS"
 433
 434       case $host in
 435       *mingw*)
 436         SECP_TEST_LIBS="$SECP_TEST_LIBS -lgdi32"
 437         ;;
 438       esac
 439     fi
 440   else
 441     if test x"$enable_openssl_tests" = x"yes"; then
 442       AC_MSG_ERROR([OpenSSL tests requested but OpenSSL with EC support is not available])
 443     fi
 444   fi
 445 else
 446   if test x"$enable_openssl_tests" = x"yes"; then
 447     AC_MSG_ERROR([OpenSSL tests requested but tests are not enabled])
 448   fi
 449 fi
 450
 451 if test x"$use_jni" != x"no"; then
 452   AX_JNI_INCLUDE_DIR
 453   have_jni_dependencies=yes
 454   if test x"$enable_module_ecdh" = x"no"; then
 455     have_jni_dependencies=no
 456   fi
 457   if test "x$JNI_INCLUDE_DIRS" = "x"; then
 458     have_jni_dependencies=no
 459   fi
 460   if test "x$have_jni_dependencies" = "xno"; then
 461     if test x"$use_jni" = x"yes"; then
 462       AC_MSG_ERROR([jni support explicitly requested but headers/dependencies were not found. Enable ECDH and try again.])
 463     fi
 464     AC_MSG_WARN([jni headers/dependencies not found. jni support disabled])
 465     use_jni=no
 466   else
 467     use_jni=yes
 468     for JNI_INCLUDE_DIR in $JNI_INCLUDE_DIRS; do
 469       JNI_INCLUDES="$JNI_INCLUDES -I$JNI_INCLUDE_DIR"
 470     done
 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(JNI_INCLUDES)
 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_JNI], [test x"$use_jni" = x"yes"])
 535 AM_CONDITIONAL([USE_EXTERNAL_ASM], [test x"$use_external_asm" = x"yes"])
 536 AM_CONDITIONAL([USE_ASM_ARM], [test x"$set_asm" = x"arm"])
 537
 538 dnl make sure nothing new is exported so that we don't break the cache
 539 PKGCONFIG_PATH_TEMP="$PKG_CONFIG_PATH"
 540 unset PKG_CONFIG_PATH
 541 PKG_CONFIG_PATH="$PKGCONFIG_PATH_TEMP"
 542
 543 AC_OUTPUT
 544
 545 echo
 546 echo "Build Options:"
 547 echo "  with endomorphism       = $use_endomorphism"
 548 echo "  with ecmult precomp     = $set_precomp"
 549 echo "  with external callbacks = $use_external_default_callbacks"
 550 echo "  with jni                = $use_jni"
 551 echo "  with benchmarks         = $use_benchmark"
 552 echo "  with coverage           = $enable_coverage"
 553 echo "  module ecdh             = $enable_module_ecdh"
 554 echo "  module recovery         = $enable_module_recovery"
 555 echo
 556 echo "  asm                     = $set_asm"
 557 echo "  bignum                  = $set_bignum"
 558 echo "  field                   = $set_field"
 559 echo "  scalar                  = $set_scalar"
 560 echo "  ecmult window size      = $set_ecmult_window"
 561 echo
 562 echo "  CC                      = $CC"
 563 echo "  CFLAGS                  = $CFLAGS"
 564 echo "  CPPFLAGS                = $CPPFLAGS"
 565 echo "  LDFLAGS                 = $LDFLAGS"
 566 echo