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          fi
  50          if test x$gmp_prefix != x; then
  51            GMP_CPPFLAGS="-I$gmp_prefix/include"
  52            GMP_LIBS="-L$gmp_prefix/lib"
  53          fi
  54        else
  55          AC_PATH_PROG([PORT],port,)
  56          dnl if homebrew isn't installed and macports is, add the macports default paths
  57          dnl as a last resort.
  58          if test x$PORT != x; then
  59            CPPFLAGS="$CPPFLAGS -isystem /opt/local/include"
  60            LDFLAGS="$LDFLAGS -L/opt/local/lib"
  61          fi
  62        fi
  63      fi
  64    ;;
  65 esac
  66
  67 CFLAGS="-W $CFLAGS"
  68
  69 warn_CFLAGS="-std=c89 -pedantic -Wall -Wextra -Wcast-align -Wnested-externs -Wshadow -Wstrict-prototypes -Wno-unused-function -Wno-long-long -Wno-overlength-strings"
  70 saved_CFLAGS="$CFLAGS"
  71 CFLAGS="$warn_CFLAGS $CFLAGS"
  72 AC_MSG_CHECKING([if ${CC} supports ${warn_CFLAGS}])
  73 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
  74     [ AC_MSG_RESULT([yes]) ],
  75     [ AC_MSG_RESULT([no])
  76       CFLAGS="$saved_CFLAGS"
  77     ])
  78
  79 saved_CFLAGS="$CFLAGS"
  80 CFLAGS="-fvisibility=hidden $CFLAGS"
  81 AC_MSG_CHECKING([if ${CC} supports -fvisibility=hidden])
  82 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
  83     [ AC_MSG_RESULT([yes]) ],
  84     [ AC_MSG_RESULT([no])
  85       CFLAGS="$saved_CFLAGS"
  86     ])
  87
  88 AC_ARG_ENABLE(benchmark,
  89     AS_HELP_STRING([--enable-benchmark],[compile benchmark [default=yes]]),
  90     [use_benchmark=$enableval],
  91     [use_benchmark=yes])
  92
  93 AC_ARG_ENABLE(coverage,
  94     AS_HELP_STRING([--enable-coverage],[enable compiler flags to support kcov coverage analysis [default=no]]),
  95     [enable_coverage=$enableval],
  96     [enable_coverage=no])
  97
  98 AC_ARG_ENABLE(tests,
  99     AS_HELP_STRING([--enable-tests],[compile tests [default=yes]]),
 100     [use_tests=$enableval],
 101     [use_tests=yes])
 102
 103 AC_ARG_ENABLE(openssl_tests,
 104     AS_HELP_STRING([--enable-openssl-tests],[enable OpenSSL tests [default=auto]]),
 105     [enable_openssl_tests=$enableval],
 106     [enable_openssl_tests=auto])
 107
 108 AC_ARG_ENABLE(experimental,
 109     AS_HELP_STRING([--enable-experimental],[allow experimental configure options [default=no]]),
 110     [use_experimental=$enableval],
 111     [use_experimental=no])
 112
 113 AC_ARG_ENABLE(exhaustive_tests,
 114     AS_HELP_STRING([--enable-exhaustive-tests],[compile exhaustive tests [default=yes]]),
 115     [use_exhaustive_tests=$enableval],
 116     [use_exhaustive_tests=yes])
 117
 118 AC_ARG_ENABLE(endomorphism,
 119     AS_HELP_STRING([--enable-endomorphism],[enable endomorphism [default=no]]),
 120     [use_endomorphism=$enableval],
 121     [use_endomorphism=no])
 122
 123 AC_ARG_ENABLE(ecmult_static_precomputation,
 124     AS_HELP_STRING([--enable-ecmult-static-precomputation],[enable precomputed ecmult table for signing [default=auto]]),
 125     [use_ecmult_static_precomputation=$enableval],
 126     [use_ecmult_static_precomputation=auto])
 127
 128 AC_ARG_ENABLE(module_ecdh,
 129     AS_HELP_STRING([--enable-module-ecdh],[enable ECDH shared secret computation (experimental)]),
 130     [enable_module_ecdh=$enableval],
 131     [enable_module_ecdh=no])
 132
 133 AC_ARG_ENABLE(module_recovery,
 134     AS_HELP_STRING([--enable-module-recovery],[enable ECDSA pubkey recovery module [default=no]]),
 135     [enable_module_recovery=$enableval],
 136     [enable_module_recovery=no])
 137
 138 AC_ARG_ENABLE(external_default_callbacks,
 139     AS_HELP_STRING([--enable-external-default-callbacks],[enable external default callback functions [default=no]]),
 140     [use_external_default_callbacks=$enableval],
 141     [use_external_default_callbacks=no])
 142
 143 AC_ARG_ENABLE(jni,
 144     AS_HELP_STRING([--enable-jni],[enable libsecp256k1_jni [default=no]]),
 145     [use_jni=$enableval],
 146     [use_jni=no])
 147
 148 AC_ARG_WITH([field], [AS_HELP_STRING([--with-field=64bit|32bit|auto],
 149 [finite field implementation to use [default=auto]])],[req_field=$withval], [req_field=auto])
 150
 151 AC_ARG_WITH([bignum], [AS_HELP_STRING([--with-bignum=gmp|no|auto],
 152 [bignum implementation to use [default=auto]])],[req_bignum=$withval], [req_bignum=auto])
 153
 154 AC_ARG_WITH([scalar], [AS_HELP_STRING([--with-scalar=64bit|32bit|auto],
 155 [scalar implementation to use [default=auto]])],[req_scalar=$withval], [req_scalar=auto])
 156
 157 AC_ARG_WITH([asm], [AS_HELP_STRING([--with-asm=x86_64|arm|no|auto],
 158 [assembly optimizations to use (experimental: arm) [default=auto]])],[req_asm=$withval], [req_asm=auto])
 159
 160 AC_ARG_WITH([ecmult-window], [AS_HELP_STRING([--with-ecmult-window=SIZE|auto],
 161 [window size for ecmult precomputation for verification, specified as integer in range [2..24].]
 162 [Larger values result in possibly better performance at the cost of an exponentially larger precomputed table.]
 163 [The table will store 2^(SIZE-2) * 64 bytes of data but can be larger in memory due to platform-specific padding and alignment.]
 164 [If the endomorphism optimization is enabled, two tables of this size are used instead of only one.]
 165 ["auto" is a reasonable setting for desktop machines (currently 15). [default=auto]]
 166 )],
 167 [req_ecmult_window=$withval], [req_ecmult_window=auto])
 168
 169 AC_ARG_WITH([ecmult-gen-precision], [AS_HELP_STRING([--with-ecmult-gen-precision=2|4|8|auto],
 170 [Precision bits to tune the precomputed table size for signing.]
 171 [The size of the table is 32kB for 2 bits, 64kB for 4 bits, 512kB for 8 bits of precision.]
 172 [A larger table size usually results in possible faster signing.]
 173 ["auto" is a reasonable setting for desktop machines (currently 4). [default=auto]]
 174 )],
 175 [req_ecmult_gen_precision=$withval], [req_ecmult_gen_precision=auto])
 176
 177 AC_CHECK_TYPES([__int128])
 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],[dnl])
 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_field" = x"auto"; then
 270   if test x"set_asm" = x"x86_64"; then
 271     set_field=64bit
 272   fi
 273   if test x"$set_field" = x; then
 274     SECP_INT128_CHECK
 275     if test x"$has_int128" = x"yes"; then
 276       set_field=64bit
 277     fi
 278   fi
 279   if test x"$set_field" = x; then
 280     set_field=32bit
 281   fi
 282 else
 283   set_field=$req_field
 284   case $set_field in
 285   64bit)
 286     if test x"$set_asm" != x"x86_64"; then
 287       SECP_INT128_CHECK
 288       if test x"$has_int128" != x"yes"; then
 289         AC_MSG_ERROR([64bit field explicitly requested but neither __int128 support or x86_64 assembly available])
 290       fi
 291     fi
 292     ;;
 293   32bit)
 294     ;;
 295   *)
 296     AC_MSG_ERROR([invalid field implementation selection])
 297     ;;
 298   esac
 299 fi
 300
 301 if test x"$req_scalar" = x"auto"; then
 302   SECP_INT128_CHECK
 303   if test x"$has_int128" = x"yes"; then
 304     set_scalar=64bit
 305   fi
 306   if test x"$set_scalar" = x; then
 307     set_scalar=32bit
 308   fi
 309 else
 310   set_scalar=$req_scalar
 311   case $set_scalar in
 312   64bit)
 313     SECP_INT128_CHECK
 314     if test x"$has_int128" != x"yes"; then
 315       AC_MSG_ERROR([64bit scalar explicitly requested but __int128 support not available])
 316     fi
 317     ;;
 318   32bit)
 319     ;;
 320   *)
 321     AC_MSG_ERROR([invalid scalar implementation selected])
 322     ;;
 323   esac
 324 fi
 325
 326 if test x"$req_bignum" = x"auto"; then
 327   SECP_GMP_CHECK
 328   if test x"$has_gmp" = x"yes"; then
 329     set_bignum=gmp
 330   fi
 331
 332   if test x"$set_bignum" = x; then
 333     set_bignum=no
 334   fi
 335 else
 336   set_bignum=$req_bignum
 337   case $set_bignum in
 338   gmp)
 339     SECP_GMP_CHECK
 340     if test x"$has_gmp" != x"yes"; then
 341       AC_MSG_ERROR([gmp bignum explicitly requested but libgmp not available])
 342     fi
 343     ;;
 344   no)
 345     ;;
 346   *)
 347     AC_MSG_ERROR([invalid bignum implementation selection])
 348     ;;
 349   esac
 350 fi
 351
 352 # select assembly optimization
 353 use_external_asm=no
 354
 355 case $set_asm in
 356 x86_64)
 357   AC_DEFINE(USE_ASM_X86_64, 1, [Define this symbol to enable x86_64 assembly optimizations])
 358   ;;
 359 arm)
 360   use_external_asm=yes
 361   ;;
 362 no)
 363   ;;
 364 *)
 365   AC_MSG_ERROR([invalid assembly optimizations])
 366   ;;
 367 esac
 368
 369 # select field implementation
 370 case $set_field in
 371 64bit)
 372   AC_DEFINE(USE_FIELD_5X52, 1, [Define this symbol to use the FIELD_5X52 implementation])
 373   ;;
 374 32bit)
 375   AC_DEFINE(USE_FIELD_10X26, 1, [Define this symbol to use the FIELD_10X26 implementation])
 376   ;;
 377 *)
 378   AC_MSG_ERROR([invalid field implementation])
 379   ;;
 380 esac
 381
 382 # select bignum implementation
 383 case $set_bignum in
 384 gmp)
 385   AC_DEFINE(HAVE_LIBGMP, 1, [Define this symbol if libgmp is installed])
 386   AC_DEFINE(USE_NUM_GMP, 1, [Define this symbol to use the gmp implementation for num])
 387   AC_DEFINE(USE_FIELD_INV_NUM, 1, [Define this symbol to use the num-based field inverse implementation])
 388   AC_DEFINE(USE_SCALAR_INV_NUM, 1, [Define this symbol to use the num-based scalar inverse implementation])
 389   ;;
 390 no)
 391   AC_DEFINE(USE_NUM_NONE, 1, [Define this symbol to use no num implementation])
 392   AC_DEFINE(USE_FIELD_INV_BUILTIN, 1, [Define this symbol to use the native field inverse implementation])
 393   AC_DEFINE(USE_SCALAR_INV_BUILTIN, 1, [Define this symbol to use the native scalar inverse implementation])
 394   ;;
 395 *)
 396   AC_MSG_ERROR([invalid bignum implementation])
 397   ;;
 398 esac
 399
 400 #select scalar implementation
 401 case $set_scalar in
 402 64bit)
 403   AC_DEFINE(USE_SCALAR_4X64, 1, [Define this symbol to use the 4x64 scalar implementation])
 404   ;;
 405 32bit)
 406   AC_DEFINE(USE_SCALAR_8X32, 1, [Define this symbol to use the 8x32 scalar implementation])
 407   ;;
 408 *)
 409   AC_MSG_ERROR([invalid scalar implementation])
 410   ;;
 411 esac
 412
 413 #set ecmult window size
 414 if test x"$req_ecmult_window" = x"auto"; then
 415   set_ecmult_window=15
 416 else
 417   set_ecmult_window=$req_ecmult_window
 418 fi
 419
 420 error_window_size=['window size for ecmult precomputation not an integer in range [2..24] or "auto"']
 421 case $set_ecmult_window in
 422 ''|*[[!0-9]]*)
 423   # no valid integer
 424   AC_MSG_ERROR($error_window_size)
 425   ;;
 426 *)
 427   if test "$set_ecmult_window" -lt 2 -o "$set_ecmult_window" -gt 24 ; then
 428     # not in range
 429     AC_MSG_ERROR($error_window_size)
 430   fi
 431   AC_DEFINE_UNQUOTED(ECMULT_WINDOW_SIZE, $set_ecmult_window, [Set window size for ecmult precomputation])
 432   ;;
 433 esac
 434
 435 #set ecmult gen precision
 436 if test x"$req_ecmult_gen_precision" = x"auto"; then
 437   set_ecmult_gen_precision=4
 438 else
 439   set_ecmult_gen_precision=$req_ecmult_gen_precision
 440 fi
 441
 442 case $set_ecmult_gen_precision in
 443 2|4|8)
 444   AC_DEFINE_UNQUOTED(ECMULT_GEN_PREC_BITS, $set_ecmult_gen_precision, [Set ecmult gen precision bits])
 445   ;;
 446 *)
 447   AC_MSG_ERROR(['ecmult gen precision not 2, 4, 8 or "auto"'])
 448   ;;
 449 esac
 450
 451 if test x"$use_tests" = x"yes"; then
 452   SECP_OPENSSL_CHECK
 453   if test x"$has_openssl_ec" = x"yes"; then
 454     if test x"$enable_openssl_tests" != x"no"; then
 455       AC_DEFINE(ENABLE_OPENSSL_TESTS, 1, [Define this symbol if OpenSSL EC functions are available])
 456       SECP_TEST_INCLUDES="$SSL_CFLAGS $CRYPTO_CFLAGS"
 457       SECP_TEST_LIBS="$CRYPTO_LIBS"
 458
 459       case $host in
 460       *mingw*)
 461         SECP_TEST_LIBS="$SECP_TEST_LIBS -lgdi32"
 462         ;;
 463       esac
 464     fi
 465   else
 466     if test x"$enable_openssl_tests" = x"yes"; then
 467       AC_MSG_ERROR([OpenSSL tests requested but OpenSSL with EC support is not available])
 468     fi
 469   fi
 470 else
 471   if test x"$enable_openssl_tests" = x"yes"; then
 472     AC_MSG_ERROR([OpenSSL tests requested but tests are not enabled])
 473   fi
 474 fi
 475
 476 if test x"$use_jni" != x"no"; then
 477   AX_JNI_INCLUDE_DIR
 478   have_jni_dependencies=yes
 479   if test x"$enable_module_ecdh" = x"no"; then
 480     have_jni_dependencies=no
 481   fi
 482   if test "x$JNI_INCLUDE_DIRS" = "x"; then
 483     have_jni_dependencies=no
 484   fi
 485   if test "x$have_jni_dependencies" = "xno"; then
 486     if test x"$use_jni" = x"yes"; then
 487       AC_MSG_ERROR([jni support explicitly requested but headers/dependencies were not found. Enable ECDH and try again.])
 488     fi
 489     AC_MSG_WARN([jni headers/dependencies not found. jni support disabled])
 490     use_jni=no
 491   else
 492     use_jni=yes
 493     for JNI_INCLUDE_DIR in $JNI_INCLUDE_DIRS; do
 494       JNI_INCLUDES="$JNI_INCLUDES -I$JNI_INCLUDE_DIR"
 495     done
 496   fi
 497 fi
 498
 499 if test x"$set_bignum" = x"gmp"; then
 500   SECP_LIBS="$SECP_LIBS $GMP_LIBS"
 501   SECP_INCLUDES="$SECP_INCLUDES $GMP_CPPFLAGS"
 502 fi
 503
 504 if test x"$use_endomorphism" = x"yes"; then
 505   AC_DEFINE(USE_ENDOMORPHISM, 1, [Define this symbol to use endomorphism optimization])
 506 fi
 507
 508 if test x"$set_precomp" = x"yes"; then
 509   AC_DEFINE(USE_ECMULT_STATIC_PRECOMPUTATION, 1, [Define this symbol to use a statically generated ecmult table])
 510 fi
 511
 512 if test x"$enable_module_ecdh" = x"yes"; then
 513   AC_DEFINE(ENABLE_MODULE_ECDH, 1, [Define this symbol to enable the ECDH module])
 514 fi
 515
 516 if test x"$enable_module_recovery" = x"yes"; then
 517   AC_DEFINE(ENABLE_MODULE_RECOVERY, 1, [Define this symbol to enable the ECDSA pubkey recovery module])
 518 fi
 519
 520 AC_C_BIGENDIAN()
 521
 522 if test x"$use_external_asm" = x"yes"; then
 523   AC_DEFINE(USE_EXTERNAL_ASM, 1, [Define this symbol if an external (non-inline) assembly implementation is used])
 524 fi
 525
 526 if test x"$use_external_default_callbacks" = x"yes"; then
 527   AC_DEFINE(USE_EXTERNAL_DEFAULT_CALLBACKS, 1, [Define this symbol if an external implementation of the default callbacks is used])
 528 fi
 529
 530 if test x"$enable_experimental" = x"yes"; then
 531   AC_MSG_NOTICE([******])
 532   AC_MSG_NOTICE([WARNING: experimental build])
 533   AC_MSG_NOTICE([Experimental features do not have stable APIs or properties, and may not be safe for production use.])
 534   AC_MSG_NOTICE([Building ECDH module: $enable_module_ecdh])
 535   AC_MSG_NOTICE([******])
 536 else
 537   if test x"$enable_module_ecdh" = x"yes"; then
 538     AC_MSG_ERROR([ECDH module is experimental. Use --enable-experimental to allow.])
 539   fi
 540   if test x"$set_asm" = x"arm"; then
 541     AC_MSG_ERROR([ARM assembly optimization is experimental. Use --enable-experimental to allow.])
 542   fi
 543 fi
 544
 545 AC_CONFIG_HEADERS([src/libsecp256k1-config.h])
 546 AC_CONFIG_FILES([Makefile libsecp256k1.pc])
 547 AC_SUBST(JNI_INCLUDES)
 548 AC_SUBST(SECP_INCLUDES)
 549 AC_SUBST(SECP_LIBS)
 550 AC_SUBST(SECP_TEST_LIBS)
 551 AC_SUBST(SECP_TEST_INCLUDES)
 552 AM_CONDITIONAL([ENABLE_COVERAGE], [test x"$enable_coverage" = x"yes"])
 553 AM_CONDITIONAL([USE_TESTS], [test x"$use_tests" != x"no"])
 554 AM_CONDITIONAL([USE_EXHAUSTIVE_TESTS], [test x"$use_exhaustive_tests" != x"no"])
 555 AM_CONDITIONAL([USE_BENCHMARK], [test x"$use_benchmark" = x"yes"])
 556 AM_CONDITIONAL([USE_ECMULT_STATIC_PRECOMPUTATION], [test x"$set_precomp" = x"yes"])
 557 AM_CONDITIONAL([ENABLE_MODULE_ECDH], [test x"$enable_module_ecdh" = x"yes"])
 558 AM_CONDITIONAL([ENABLE_MODULE_RECOVERY], [test x"$enable_module_recovery" = x"yes"])
 559 AM_CONDITIONAL([USE_JNI], [test x"$use_jni" = x"yes"])
 560 AM_CONDITIONAL([USE_EXTERNAL_ASM], [test x"$use_external_asm" = x"yes"])
 561 AM_CONDITIONAL([USE_ASM_ARM], [test x"$set_asm" = x"arm"])
 562
 563 dnl make sure nothing new is exported so that we don't break the cache
 564 PKGCONFIG_PATH_TEMP="$PKG_CONFIG_PATH"
 565 unset PKG_CONFIG_PATH
 566 PKG_CONFIG_PATH="$PKGCONFIG_PATH_TEMP"
 567
 568 AC_OUTPUT
 569
 570 echo
 571 echo "Build Options:"
 572 echo "  with endomorphism       = $use_endomorphism"
 573 echo "  with ecmult precomp     = $set_precomp"
 574 echo "  with external callbacks = $use_external_default_callbacks"
 575 echo "  with jni                = $use_jni"
 576 echo "  with benchmarks         = $use_benchmark"
 577 echo "  with coverage           = $enable_coverage"
 578 echo "  module ecdh             = $enable_module_ecdh"
 579 echo "  module recovery         = $enable_module_recovery"
 580 echo
 581 echo "  asm                     = $set_asm"
 582 echo "  bignum                  = $set_bignum"
 583 echo "  field                   = $set_field"
 584 echo "  scalar                  = $set_scalar"
 585 echo "  ecmult window size      = $set_ecmult_window"
 586 echo "  ecmult gen prec. bits   = $set_ecmult_gen_precision"
 587 echo
 588 echo "  CC                      = $CC"
 589 echo "  CFLAGS                  = $CFLAGS"
 590 echo "  CPPFLAGS                = $CPPFLAGS"
 591 echo "  LDFLAGS                 = $LDFLAGS"
 592 echo