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