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(jni,
 138     AS_HELP_STRING([--enable-jni],[enable libsecp256k1_jni [default=no]]),
 139     [use_jni=$enableval],
 140     [use_jni=no])
 141
 142 AC_ARG_WITH([field], [AS_HELP_STRING([--with-field=64bit|32bit|auto],
 143 [finite field implementation to use [default=auto]])],[req_field=$withval], [req_field=auto])
 144
 145 AC_ARG_WITH([bignum], [AS_HELP_STRING([--with-bignum=gmp|no|auto],
 146 [bignum implementation to use [default=auto]])],[req_bignum=$withval], [req_bignum=auto])
 147
 148 AC_ARG_WITH([scalar], [AS_HELP_STRING([--with-scalar=64bit|32bit|auto],
 149 [scalar implementation to use [default=auto]])],[req_scalar=$withval], [req_scalar=auto])
 150
 151 AC_ARG_WITH([asm], [AS_HELP_STRING([--with-asm=x86_64|arm|no|auto],
 152 [assembly optimizations to use (experimental: arm) [default=auto]])],[req_asm=$withval], [req_asm=auto])
 153
 154 AC_ARG_WITH([ecmult-window], [AS_HELP_STRING([--with-ecmult-window=SIZE|auto],
 155 [window size for ecmult precomputation for verification, specified as integer in range [2..24].]
 156 [Larger values result in possibly better performance at the cost of an exponentially larger precomputed table.]
 157 [The table will store 2^(SIZE-2) * 64 bytes of data but can be larger in memory due to platform-specific padding and alignment.]
 158 [If the endomorphism optimization is enabled, two tables of this size are used instead of only one.]
 159 ["auto" is a reasonable setting for desktop machines (currently 15). [default=auto]]
 160 )],
 161 [req_ecmult_window=$withval], [req_ecmult_window=auto])
 162
 163 AC_CHECK_TYPES([__int128])
 164
 165 if test x"$enable_coverage" = x"yes"; then
 166     AC_DEFINE(COVERAGE, 1, [Define this symbol to compile out all VERIFY code])
 167     CFLAGS="$CFLAGS -O0 --coverage"
 168     LDFLAGS="$LDFLAGS --coverage"
 169 else
 170     CFLAGS="$CFLAGS -O3"
 171 fi
 172
 173 if test x"$use_ecmult_static_precomputation" != x"no"; then
 174   # Temporarily switch to an environment for the native compiler
 175   save_cross_compiling=$cross_compiling
 176   cross_compiling=no
 177   SAVE_CC="$CC"
 178   CC="$CC_FOR_BUILD"
 179   SAVE_CFLAGS="$CFLAGS"
 180   CFLAGS="$CFLAGS_FOR_BUILD"
 181   SAVE_CPPFLAGS="$CPPFLAGS"
 182   CPPFLAGS="$CPPFLAGS_FOR_BUILD"
 183   SAVE_LDFLAGS="$LDFLAGS"
 184   LDFLAGS="$LDFLAGS_FOR_BUILD"
 185
 186   warn_CFLAGS_FOR_BUILD="-Wall -Wextra -Wno-unused-function"
 187   saved_CFLAGS="$CFLAGS"
 188   CFLAGS="$CFLAGS $warn_CFLAGS_FOR_BUILD"
 189   AC_MSG_CHECKING([if native ${CC_FOR_BUILD} supports ${warn_CFLAGS_FOR_BUILD}])
 190   AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
 191       [ AC_MSG_RESULT([yes]) ],
 192       [ AC_MSG_RESULT([no])
 193         CFLAGS="$saved_CFLAGS"
 194       ])
 195
 196   AC_MSG_CHECKING([for working native compiler: ${CC_FOR_BUILD}])
 197   AC_RUN_IFELSE(
 198     [AC_LANG_PROGRAM([], [])],
 199     [working_native_cc=yes],
 200     [working_native_cc=no],[dnl])
 201
 202   CFLAGS_FOR_BUILD="$CFLAGS"
 203
 204   # Restore the environment
 205   cross_compiling=$save_cross_compiling
 206   CC="$SAVE_CC"
 207   CFLAGS="$SAVE_CFLAGS"
 208   CPPFLAGS="$SAVE_CPPFLAGS"
 209   LDFLAGS="$SAVE_LDFLAGS"
 210
 211   if test x"$working_native_cc" = x"no"; then
 212     AC_MSG_RESULT([no])
 213     set_precomp=no
 214     m4_define([please_set_for_build], [Please set CC_FOR_BUILD, CFLAGS_FOR_BUILD, CPPFLAGS_FOR_BUILD, and/or LDFLAGS_FOR_BUILD.])
 215     if test x"$use_ecmult_static_precomputation" = x"yes";  then
 216       AC_MSG_ERROR([native compiler ${CC_FOR_BUILD} does not produce working binaries. please_set_for_build])
 217     else
 218       AC_MSG_WARN([Disabling statically generated ecmult table because the native compiler ${CC_FOR_BUILD} does not produce working binaries. please_set_for_build])
 219     fi
 220   else
 221     AC_MSG_RESULT([yes])
 222     set_precomp=yes
 223   fi
 224 else
 225   set_precomp=no
 226 fi
 227
 228 if test x"$req_asm" = x"auto"; then
 229   SECP_64BIT_ASM_CHECK
 230   if test x"$has_64bit_asm" = x"yes"; then
 231     set_asm=x86_64
 232   fi
 233   if test x"$set_asm" = x; then
 234     set_asm=no
 235   fi
 236 else
 237   set_asm=$req_asm
 238   case $set_asm in
 239   x86_64)
 240     SECP_64BIT_ASM_CHECK
 241     if test x"$has_64bit_asm" != x"yes"; then
 242       AC_MSG_ERROR([x86_64 assembly optimization requested but not available])
 243     fi
 244     ;;
 245   arm)
 246     ;;
 247   no)
 248     ;;
 249   *)
 250     AC_MSG_ERROR([invalid assembly optimization selection])
 251     ;;
 252   esac
 253 fi
 254
 255 if test x"$req_field" = x"auto"; then
 256   if test x"set_asm" = x"x86_64"; then
 257     set_field=64bit
 258   fi
 259   if test x"$set_field" = x; then
 260     SECP_INT128_CHECK
 261     if test x"$has_int128" = x"yes"; then
 262       set_field=64bit
 263     fi
 264   fi
 265   if test x"$set_field" = x; then
 266     set_field=32bit
 267   fi
 268 else
 269   set_field=$req_field
 270   case $set_field in
 271   64bit)
 272     if test x"$set_asm" != x"x86_64"; then
 273       SECP_INT128_CHECK
 274       if test x"$has_int128" != x"yes"; then
 275         AC_MSG_ERROR([64bit field explicitly requested but neither __int128 support or x86_64 assembly available])
 276       fi
 277     fi
 278     ;;
 279   32bit)
 280     ;;
 281   *)
 282     AC_MSG_ERROR([invalid field implementation selection])
 283     ;;
 284   esac
 285 fi
 286
 287 if test x"$req_scalar" = x"auto"; then
 288   SECP_INT128_CHECK
 289   if test x"$has_int128" = x"yes"; then
 290     set_scalar=64bit
 291   fi
 292   if test x"$set_scalar" = x; then
 293     set_scalar=32bit
 294   fi
 295 else
 296   set_scalar=$req_scalar
 297   case $set_scalar in
 298   64bit)
 299     SECP_INT128_CHECK
 300     if test x"$has_int128" != x"yes"; then
 301       AC_MSG_ERROR([64bit scalar explicitly requested but __int128 support not available])
 302     fi
 303     ;;
 304   32bit)
 305     ;;
 306   *)
 307     AC_MSG_ERROR([invalid scalar implementation selected])
 308     ;;
 309   esac
 310 fi
 311
 312 if test x"$req_bignum" = x"auto"; then
 313   SECP_GMP_CHECK
 314   if test x"$has_gmp" = x"yes"; then
 315     set_bignum=gmp
 316   fi
 317
 318   if test x"$set_bignum" = x; then
 319     set_bignum=no
 320   fi
 321 else
 322   set_bignum=$req_bignum
 323   case $set_bignum in
 324   gmp)
 325     SECP_GMP_CHECK
 326     if test x"$has_gmp" != x"yes"; then
 327       AC_MSG_ERROR([gmp bignum explicitly requested but libgmp not available])
 328     fi
 329     ;;
 330   no)
 331     ;;
 332   *)
 333     AC_MSG_ERROR([invalid bignum implementation selection])
 334     ;;
 335   esac
 336 fi
 337
 338 # select assembly optimization
 339 use_external_asm=no
 340
 341 case $set_asm in
 342 x86_64)
 343   AC_DEFINE(USE_ASM_X86_64, 1, [Define this symbol to enable x86_64 assembly optimizations])
 344   ;;
 345 arm)
 346   use_external_asm=yes
 347   ;;
 348 no)
 349   ;;
 350 *)
 351   AC_MSG_ERROR([invalid assembly optimizations])
 352   ;;
 353 esac
 354
 355 # select field implementation
 356 case $set_field in
 357 64bit)
 358   AC_DEFINE(USE_FIELD_5X52, 1, [Define this symbol to use the FIELD_5X52 implementation])
 359   ;;
 360 32bit)
 361   AC_DEFINE(USE_FIELD_10X26, 1, [Define this symbol to use the FIELD_10X26 implementation])
 362   ;;
 363 *)
 364   AC_MSG_ERROR([invalid field implementation])
 365   ;;
 366 esac
 367
 368 # select bignum implementation
 369 case $set_bignum in
 370 gmp)
 371   AC_DEFINE(HAVE_LIBGMP, 1, [Define this symbol if libgmp is installed])
 372   AC_DEFINE(USE_NUM_GMP, 1, [Define this symbol to use the gmp implementation for num])
 373   AC_DEFINE(USE_FIELD_INV_NUM, 1, [Define this symbol to use the num-based field inverse implementation])
 374   AC_DEFINE(USE_SCALAR_INV_NUM, 1, [Define this symbol to use the num-based scalar inverse implementation])
 375   ;;
 376 no)
 377   AC_DEFINE(USE_NUM_NONE, 1, [Define this symbol to use no num implementation])
 378   AC_DEFINE(USE_FIELD_INV_BUILTIN, 1, [Define this symbol to use the native field inverse implementation])
 379   AC_DEFINE(USE_SCALAR_INV_BUILTIN, 1, [Define this symbol to use the native scalar inverse implementation])
 380   ;;
 381 *)
 382   AC_MSG_ERROR([invalid bignum implementation])
 383   ;;
 384 esac
 385
 386 #select scalar implementation
 387 case $set_scalar in
 388 64bit)
 389   AC_DEFINE(USE_SCALAR_4X64, 1, [Define this symbol to use the 4x64 scalar implementation])
 390   ;;
 391 32bit)
 392   AC_DEFINE(USE_SCALAR_8X32, 1, [Define this symbol to use the 8x32 scalar implementation])
 393   ;;
 394 *)
 395   AC_MSG_ERROR([invalid scalar implementation])
 396   ;;
 397 esac
 398
 399 #set ecmult window size
 400 if test x"$req_ecmult_window" = x"auto"; then
 401   set_ecmult_window=15
 402 else
 403   set_ecmult_window=$req_ecmult_window
 404 fi
 405
 406 error_window_size=['window size for ecmult precomputation not an integer in range [2..24] or "auto"']
 407 case $set_ecmult_window in
 408 ''|*[[!0-9]]*)
 409   # no valid integer
 410   AC_MSG_ERROR($error_window_size)
 411   ;;
 412 *)
 413   if test "$set_ecmult_window" -lt 2 -o "$set_ecmult_window" -gt 24 ; then
 414     # not in range
 415     AC_MSG_ERROR($error_window_size)
 416   fi
 417   AC_DEFINE_UNQUOTED(ECMULT_WINDOW_SIZE, $set_ecmult_window, [Set window size for ecmult precomputation])
 418   ;;
 419 esac
 420
 421 if test x"$use_tests" = x"yes"; then
 422   SECP_OPENSSL_CHECK
 423   if test x"$has_openssl_ec" = x"yes"; then
 424     if test x"$enable_openssl_tests" != x"no"; then
 425       AC_DEFINE(ENABLE_OPENSSL_TESTS, 1, [Define this symbol if OpenSSL EC functions are available])
 426       SECP_TEST_INCLUDES="$SSL_CFLAGS $CRYPTO_CFLAGS"
 427       SECP_TEST_LIBS="$CRYPTO_LIBS"
 428
 429       case $host in
 430       *mingw*)
 431         SECP_TEST_LIBS="$SECP_TEST_LIBS -lgdi32"
 432         ;;
 433       esac
 434     fi
 435   else
 436     if test x"$enable_openssl_tests" = x"yes"; then
 437       AC_MSG_ERROR([OpenSSL tests requested but OpenSSL with EC support is not available])
 438     fi
 439   fi
 440 else
 441   if test x"$enable_openssl_tests" = x"yes"; then
 442     AC_MSG_ERROR([OpenSSL tests requested but tests are not enabled])
 443   fi
 444 fi
 445
 446 if test x"$use_jni" != x"no"; then
 447   AX_JNI_INCLUDE_DIR
 448   have_jni_dependencies=yes
 449   if test x"$enable_module_ecdh" = x"no"; then
 450     have_jni_dependencies=no
 451   fi
 452   if test "x$JNI_INCLUDE_DIRS" = "x"; then
 453     have_jni_dependencies=no
 454   fi
 455   if test "x$have_jni_dependencies" = "xno"; then
 456     if test x"$use_jni" = x"yes"; then
 457       AC_MSG_ERROR([jni support explicitly requested but headers/dependencies were not found. Enable ECDH and try again.])
 458     fi
 459     AC_MSG_WARN([jni headers/dependencies not found. jni support disabled])
 460     use_jni=no
 461   else
 462     use_jni=yes
 463     for JNI_INCLUDE_DIR in $JNI_INCLUDE_DIRS; do
 464       JNI_INCLUDES="$JNI_INCLUDES -I$JNI_INCLUDE_DIR"
 465     done
 466   fi
 467 fi
 468
 469 if test x"$set_bignum" = x"gmp"; then
 470   SECP_LIBS="$SECP_LIBS $GMP_LIBS"
 471   SECP_INCLUDES="$SECP_INCLUDES $GMP_CPPFLAGS"
 472 fi
 473
 474 if test x"$use_endomorphism" = x"yes"; then
 475   AC_DEFINE(USE_ENDOMORPHISM, 1, [Define this symbol to use endomorphism optimization])
 476 fi
 477
 478 if test x"$set_precomp" = x"yes"; then
 479   AC_DEFINE(USE_ECMULT_STATIC_PRECOMPUTATION, 1, [Define this symbol to use a statically generated ecmult table])
 480 fi
 481
 482 if test x"$enable_module_ecdh" = x"yes"; then
 483   AC_DEFINE(ENABLE_MODULE_ECDH, 1, [Define this symbol to enable the ECDH module])
 484 fi
 485
 486 if test x"$enable_module_recovery" = x"yes"; then
 487   AC_DEFINE(ENABLE_MODULE_RECOVERY, 1, [Define this symbol to enable the ECDSA pubkey recovery module])
 488 fi
 489
 490 AC_C_BIGENDIAN()
 491
 492 if test x"$use_external_asm" = x"yes"; then
 493   AC_DEFINE(USE_EXTERNAL_ASM, 1, [Define this symbol if an external (non-inline) assembly implementation is used])
 494 fi
 495
 496 if test x"$enable_experimental" = x"yes"; then
 497   AC_MSG_NOTICE([******])
 498   AC_MSG_NOTICE([WARNING: experimental build])
 499   AC_MSG_NOTICE([Experimental features do not have stable APIs or properties, and may not be safe for production use.])
 500   AC_MSG_NOTICE([Building ECDH module: $enable_module_ecdh])
 501   AC_MSG_NOTICE([******])
 502 else
 503   if test x"$enable_module_ecdh" = x"yes"; then
 504     AC_MSG_ERROR([ECDH module is experimental. Use --enable-experimental to allow.])
 505   fi
 506   if test x"$set_asm" = x"arm"; then
 507     AC_MSG_ERROR([ARM assembly optimization is experimental. Use --enable-experimental to allow.])
 508   fi
 509 fi
 510
 511 AC_CONFIG_HEADERS([src/libsecp256k1-config.h])
 512 AC_CONFIG_FILES([Makefile libsecp256k1.pc])
 513 AC_SUBST(JNI_INCLUDES)
 514 AC_SUBST(SECP_INCLUDES)
 515 AC_SUBST(SECP_LIBS)
 516 AC_SUBST(SECP_TEST_LIBS)
 517 AC_SUBST(SECP_TEST_INCLUDES)
 518 AM_CONDITIONAL([ENABLE_COVERAGE], [test x"$enable_coverage" = x"yes"])
 519 AM_CONDITIONAL([USE_TESTS], [test x"$use_tests" != x"no"])
 520 AM_CONDITIONAL([USE_EXHAUSTIVE_TESTS], [test x"$use_exhaustive_tests" != x"no"])
 521 AM_CONDITIONAL([USE_BENCHMARK], [test x"$use_benchmark" = x"yes"])
 522 AM_CONDITIONAL([USE_ECMULT_STATIC_PRECOMPUTATION], [test x"$set_precomp" = x"yes"])
 523 AM_CONDITIONAL([ENABLE_MODULE_ECDH], [test x"$enable_module_ecdh" = x"yes"])
 524 AM_CONDITIONAL([ENABLE_MODULE_RECOVERY], [test x"$enable_module_recovery" = x"yes"])
 525 AM_CONDITIONAL([USE_JNI], [test x"$use_jni" = x"yes"])
 526 AM_CONDITIONAL([USE_EXTERNAL_ASM], [test x"$use_external_asm" = x"yes"])
 527 AM_CONDITIONAL([USE_ASM_ARM], [test x"$set_asm" = x"arm"])
 528
 529 dnl make sure nothing new is exported so that we don't break the cache
 530 PKGCONFIG_PATH_TEMP="$PKG_CONFIG_PATH"
 531 unset PKG_CONFIG_PATH
 532 PKG_CONFIG_PATH="$PKGCONFIG_PATH_TEMP"
 533
 534 AC_OUTPUT
 535
 536 echo
 537 echo "Build Options:"
 538 echo "  with endomorphism   = $use_endomorphism"
 539 echo "  with ecmult precomp = $set_precomp"
 540 echo "  with jni            = $use_jni"
 541 echo "  with benchmarks     = $use_benchmark"
 542 echo "  with coverage       = $enable_coverage"
 543 echo "  module ecdh         = $enable_module_ecdh"
 544 echo "  module recovery     = $enable_module_recovery"
 545 echo
 546 echo "  asm                 = $set_asm"
 547 echo "  bignum              = $set_bignum"
 548 echo "  field               = $set_field"
 549 echo "  scalar              = $set_scalar"
 550 echo "  ecmult window size  = $set_ecmult_window"
 551 echo
 552 echo "  CC                  = $CC"
 553 echo "  CFLAGS              = $CFLAGS"
 554 echo "  CPPFLAGS            = $CPPFLAGS"
 555 echo "  LDFLAGS             = $LDFLAGS"
 556 echo