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