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