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 if test x"$enable_experimental" = x"yes"; then
 439   AC_MSG_NOTICE([******])
 440   AC_MSG_NOTICE([WARNING: experimental build])
 441   AC_MSG_NOTICE([Experimental features do not have stable APIs or properties, and may not be safe for production use.])
 442   AC_MSG_NOTICE([Building ECDH module: $enable_module_ecdh])
 443   AC_MSG_NOTICE([******])
 444 else
 445   if test x"$enable_module_ecdh" = x"yes"; then
 446     AC_MSG_ERROR([ECDH module is experimental. Use --enable-experimental to allow.])
 447   fi
 448   if test x"$set_asm" = x"arm"; then
 449     AC_MSG_ERROR([ARM assembly optimization is experimental. Use --enable-experimental to allow.])
 450   fi
 451 fi
 452
 453 AC_CONFIG_HEADERS([src/libsecp256k1-config.h])
 454 AC_CONFIG_FILES([Makefile libsecp256k1.pc])
 455 AC_SUBST(JNI_INCLUDES)
 456 AC_SUBST(SECP_INCLUDES)
 457 AC_SUBST(SECP_LIBS)
 458 AC_SUBST(SECP_TEST_LIBS)
 459 AC_SUBST(SECP_TEST_INCLUDES)
 460 AM_CONDITIONAL([ENABLE_COVERAGE], [test x"$enable_coverage" = x"yes"])
 461 AM_CONDITIONAL([USE_TESTS], [test x"$use_tests" != x"no"])
 462 AM_CONDITIONAL([USE_EXHAUSTIVE_TESTS], [test x"$use_exhaustive_tests" != x"no"])
 463 AM_CONDITIONAL([USE_BENCHMARK], [test x"$use_benchmark" = x"yes"])
 464 AM_CONDITIONAL([USE_ECMULT_STATIC_PRECOMPUTATION], [test x"$set_precomp" = x"yes"])
 465 AM_CONDITIONAL([ENABLE_MODULE_ECDH], [test x"$enable_module_ecdh" = x"yes"])
 466 AM_CONDITIONAL([ENABLE_MODULE_RECOVERY], [test x"$enable_module_recovery" = x"yes"])
 467 AM_CONDITIONAL([USE_JNI], [test x"$use_jni" = x"yes"])
 468 AM_CONDITIONAL([USE_EXTERNAL_ASM], [test x"$use_external_asm" = x"yes"])
 469 AM_CONDITIONAL([USE_ASM_ARM], [test x"$set_asm" = x"arm"])
 470
 471 dnl make sure nothing new is exported so that we don't break the cache
 472 PKGCONFIG_PATH_TEMP="$PKG_CONFIG_PATH"
 473 unset PKG_CONFIG_PATH
 474 PKG_CONFIG_PATH="$PKGCONFIG_PATH_TEMP"
 475
 476 AC_OUTPUT
 477
 478 echo
 479 echo "Build Options:"
 480 echo "  with endomorphism   = $use_endomorphism"
 481 echo "  with ecmult precomp = $set_precomp"
 482 echo "  with jni            = $use_jni"
 483 echo "  with benchmarks     = $use_benchmark"
 484 echo "  with coverage       = $enable_coverage"
 485 echo "  module ecdh         = $enable_module_ecdh"
 486 echo "  module recovery     = $enable_module_recovery"
 487 echo
 488 echo "  asm                 = $set_asm"
 489 echo "  bignum              = $set_bignum"
 490 echo "  field               = $set_field"
 491 echo "  scalar              = $set_scalar"
 492 echo
 493 echo "  CC                  = $CC"
 494 echo "  CFLAGS              = $CFLAGS"
 495 echo "  CPPFLAGS            = $CPPFLAGS"
 496 echo "  LDFLAGS             = $LDFLAGS"
 497 echo