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_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_TYPES([__int128])
 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="$CFLAGS -O0 --coverage"
 181     LDFLAGS="$LDFLAGS --coverage"
 182 else
 183     CFLAGS="$CFLAGS -O3"
 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="$CFLAGS $warn_CFLAGS_FOR_BUILD"
 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"
 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"$use_jni" != x"no"; then
 476   AX_JNI_INCLUDE_DIR
 477   have_jni_dependencies=yes
 478   if test x"$enable_module_ecdh" = x"no"; then
 479     have_jni_dependencies=no
 480   fi
 481   if test "x$JNI_INCLUDE_DIRS" = "x"; then
 482     have_jni_dependencies=no
 483   fi
 484   if test "x$have_jni_dependencies" = "xno"; then
 485     if test x"$use_jni" = x"yes"; then
 486       AC_MSG_ERROR([jni support explicitly requested but headers/dependencies were not found. Enable ECDH and try again.])
 487     fi
 488     AC_MSG_WARN([jni headers/dependencies not found. jni support disabled])
 489     use_jni=no
 490   else
 491     use_jni=yes
 492     for JNI_INCLUDE_DIR in $JNI_INCLUDE_DIRS; do
 493       JNI_INCLUDES="$JNI_INCLUDES -I$JNI_INCLUDE_DIR"
 494     done
 495   fi
 496 fi
 497
 498 if test x"$set_bignum" = x"gmp"; then
 499   SECP_LIBS="$SECP_LIBS $GMP_LIBS"
 500   SECP_INCLUDES="$SECP_INCLUDES $GMP_CPPFLAGS"
 501 fi
 502
 503 if test x"$use_endomorphism" = x"yes"; then
 504   AC_DEFINE(USE_ENDOMORPHISM, 1, [Define this symbol to use endomorphism optimization])
 505 fi
 506
 507 if test x"$set_precomp" = x"yes"; then
 508   AC_DEFINE(USE_ECMULT_STATIC_PRECOMPUTATION, 1, [Define this symbol to use a statically generated ecmult table])
 509 fi
 510
 511 if test x"$enable_module_ecdh" = x"yes"; then
 512   AC_DEFINE(ENABLE_MODULE_ECDH, 1, [Define this symbol to enable the ECDH module])
 513 fi
 514
 515 if test x"$enable_module_recovery" = x"yes"; then
 516   AC_DEFINE(ENABLE_MODULE_RECOVERY, 1, [Define this symbol to enable the ECDSA pubkey recovery module])
 517 fi
 518
 519 AC_C_BIGENDIAN()
 520
 521 if test x"$use_external_asm" = x"yes"; then
 522   AC_DEFINE(USE_EXTERNAL_ASM, 1, [Define this symbol if an external (non-inline) assembly implementation is used])
 523 fi
 524
 525 if test x"$use_external_default_callbacks" = x"yes"; then
 526   AC_DEFINE(USE_EXTERNAL_DEFAULT_CALLBACKS, 1, [Define this symbol if an external implementation of the default callbacks is used])
 527 fi
 528
 529 if test x"$enable_experimental" = x"yes"; then
 530   AC_MSG_NOTICE([******])
 531   AC_MSG_NOTICE([WARNING: experimental build])
 532   AC_MSG_NOTICE([Experimental features do not have stable APIs or properties, and may not be safe for production use.])
 533   AC_MSG_NOTICE([Building ECDH module: $enable_module_ecdh])
 534   AC_MSG_NOTICE([******])
 535 else
 536   if test x"$enable_module_ecdh" = x"yes"; then
 537     AC_MSG_ERROR([ECDH module is experimental. Use --enable-experimental to allow.])
 538   fi
 539   if test x"$set_asm" = x"arm"; then
 540     AC_MSG_ERROR([ARM assembly optimization is experimental. Use --enable-experimental to allow.])
 541   fi
 542 fi
 543
 544 AC_CONFIG_HEADERS([src/libsecp256k1-config.h])
 545 AC_CONFIG_FILES([Makefile libsecp256k1.pc])
 546 AC_SUBST(JNI_INCLUDES)
 547 AC_SUBST(SECP_INCLUDES)
 548 AC_SUBST(SECP_LIBS)
 549 AC_SUBST(SECP_TEST_LIBS)
 550 AC_SUBST(SECP_TEST_INCLUDES)
 551 AM_CONDITIONAL([ENABLE_COVERAGE], [test x"$enable_coverage" = x"yes"])
 552 AM_CONDITIONAL([USE_TESTS], [test x"$use_tests" != x"no"])
 553 AM_CONDITIONAL([USE_EXHAUSTIVE_TESTS], [test x"$use_exhaustive_tests" != x"no"])
 554 AM_CONDITIONAL([USE_BENCHMARK], [test x"$use_benchmark" = x"yes"])
 555 AM_CONDITIONAL([USE_ECMULT_STATIC_PRECOMPUTATION], [test x"$set_precomp" = x"yes"])
 556 AM_CONDITIONAL([ENABLE_MODULE_ECDH], [test x"$enable_module_ecdh" = x"yes"])
 557 AM_CONDITIONAL([ENABLE_MODULE_RECOVERY], [test x"$enable_module_recovery" = x"yes"])
 558 AM_CONDITIONAL([USE_JNI], [test x"$use_jni" = x"yes"])
 559 AM_CONDITIONAL([USE_EXTERNAL_ASM], [test x"$use_external_asm" = x"yes"])
 560 AM_CONDITIONAL([USE_ASM_ARM], [test x"$set_asm" = x"arm"])
 561
 562 dnl make sure nothing new is exported so that we don't break the cache
 563 PKGCONFIG_PATH_TEMP="$PKG_CONFIG_PATH"
 564 unset PKG_CONFIG_PATH
 565 PKG_CONFIG_PATH="$PKGCONFIG_PATH_TEMP"
 566
 567 AC_OUTPUT
 568
 569 echo
 570 echo "Build Options:"
 571 echo "  with endomorphism       = $use_endomorphism"
 572 echo "  with ecmult precomp     = $set_precomp"
 573 echo "  with external callbacks = $use_external_default_callbacks"
 574 echo "  with jni                = $use_jni"
 575 echo "  with benchmarks         = $use_benchmark"
 576 echo "  with coverage           = $enable_coverage"
 577 echo "  module ecdh             = $enable_module_ecdh"
 578 echo "  module recovery         = $enable_module_recovery"
 579 echo
 580 echo "  asm                     = $set_asm"
 581 echo "  bignum                  = $set_bignum"
 582 echo "  field                   = $set_field"
 583 echo "  scalar                  = $set_scalar"
 584 echo "  ecmult window size      = $set_ecmult_window"
 585 echo "  ecmult gen prec. bits   = $set_ecmult_gen_precision"
 586 echo
 587 echo "  CC                      = $CC"
 588 echo "  CFLAGS                  = $CFLAGS"
 589 echo "  CPPFLAGS                = $CPPFLAGS"
 590 echo "  LDFLAGS                 = $LDFLAGS"
 591 echo