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            CRYPTO_CPPFLAGS="-I$openssl_prefix/include"
  50          fi
  51          if test x$gmp_prefix != x; then
  52            GMP_CPPFLAGS="-I$gmp_prefix/include"
  53            GMP_LIBS="-L$gmp_prefix/lib"
  54          fi
  55        else
  56          AC_PATH_PROG([PORT],port,)
  57          dnl if homebrew isn't installed and macports is, add the macports default paths
  58          dnl as a last resort.
  59          if test x$PORT != x; then
  60            CPPFLAGS="$CPPFLAGS -isystem /opt/local/include"
  61            LDFLAGS="$LDFLAGS -L/opt/local/lib"
  62          fi
  63        fi
  64      fi
  65    ;;
  66 esac
  67
  68 CFLAGS="-W $CFLAGS"
  69
  70 warn_CFLAGS="-std=c89 -pedantic -Wall -Wextra -Wcast-align -Wnested-externs -Wshadow -Wstrict-prototypes -Wno-unused-function -Wno-long-long -Wno-overlength-strings"
  71 saved_CFLAGS="$CFLAGS"
  72 CFLAGS="$warn_CFLAGS $CFLAGS"
  73 AC_MSG_CHECKING([if ${CC} supports ${warn_CFLAGS}])
  74 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
  75     [ AC_MSG_RESULT([yes]) ],
  76     [ AC_MSG_RESULT([no])
  77       CFLAGS="$saved_CFLAGS"
  78     ])
  79
  80 saved_CFLAGS="$CFLAGS"
  81 CFLAGS="-fvisibility=hidden $CFLAGS"
  82 AC_MSG_CHECKING([if ${CC} supports -fvisibility=hidden])
  83 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
  84     [ AC_MSG_RESULT([yes]) ],
  85     [ AC_MSG_RESULT([no])
  86       CFLAGS="$saved_CFLAGS"
  87     ])
  88
  89 AC_ARG_ENABLE(benchmark,
  90     AS_HELP_STRING([--enable-benchmark],[compile benchmark [default=yes]]),
  91     [use_benchmark=$enableval],
  92     [use_benchmark=yes])
  93
  94 AC_ARG_ENABLE(coverage,
  95     AS_HELP_STRING([--enable-coverage],[enable compiler flags to support kcov coverage analysis [default=no]]),
  96     [enable_coverage=$enableval],
  97     [enable_coverage=no])
  98
  99 AC_ARG_ENABLE(tests,
 100     AS_HELP_STRING([--enable-tests],[compile tests [default=yes]]),
 101     [use_tests=$enableval],
 102     [use_tests=yes])
 103
 104 AC_ARG_ENABLE(openssl_tests,
 105     AS_HELP_STRING([--enable-openssl-tests],[enable OpenSSL tests [default=auto]]),
 106     [enable_openssl_tests=$enableval],
 107     [enable_openssl_tests=auto])
 108
 109 AC_ARG_ENABLE(experimental,
 110     AS_HELP_STRING([--enable-experimental],[allow experimental configure options [default=no]]),
 111     [use_experimental=$enableval],
 112     [use_experimental=no])
 113
 114 AC_ARG_ENABLE(exhaustive_tests,
 115     AS_HELP_STRING([--enable-exhaustive-tests],[compile exhaustive tests [default=yes]]),
 116     [use_exhaustive_tests=$enableval],
 117     [use_exhaustive_tests=yes])
 118
 119 AC_ARG_ENABLE(endomorphism,
 120     AS_HELP_STRING([--enable-endomorphism],[enable endomorphism [default=no]]),
 121     [use_endomorphism=$enableval],
 122     [use_endomorphism=no])
 123
 124 AC_ARG_ENABLE(ecmult_static_precomputation,
 125     AS_HELP_STRING([--enable-ecmult-static-precomputation],[enable precomputed ecmult table for signing [default=auto]]),
 126     [use_ecmult_static_precomputation=$enableval],
 127     [use_ecmult_static_precomputation=auto])
 128
 129 AC_ARG_ENABLE(module_ecdh,
 130     AS_HELP_STRING([--enable-module-ecdh],[enable ECDH shared secret computation (experimental)]),
 131     [enable_module_ecdh=$enableval],
 132     [enable_module_ecdh=no])
 133
 134 AC_ARG_ENABLE(module_recovery,
 135     AS_HELP_STRING([--enable-module-recovery],[enable ECDSA pubkey recovery module [default=no]]),
 136     [enable_module_recovery=$enableval],
 137     [enable_module_recovery=no])
 138
 139 AC_ARG_ENABLE(external_default_callbacks,
 140     AS_HELP_STRING([--enable-external-default-callbacks],[enable external default callback functions [default=no]]),
 141     [use_external_default_callbacks=$enableval],
 142     [use_external_default_callbacks=no])
 143
 144 dnl Test-only override of the (autodetected by the C code) "widemul" setting.
 145 dnl Legal values are int64 (for [u]int64_t), int128 (for [unsigned] __int128), and auto (the default).
 146 AC_ARG_WITH([test-override-wide-multiply], [] ,[set_widemul=$withval], [set_widemul=auto])
 147
 148 AC_ARG_WITH([bignum], [AS_HELP_STRING([--with-bignum=gmp|no|auto],
 149 [bignum implementation to use [default=auto]])],[req_bignum=$withval], [req_bignum=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_ARG_WITH([ecmult-gen-precision], [AS_HELP_STRING([--with-ecmult-gen-precision=2|4|8|auto],
 164 [Precision bits to tune the precomputed table size for signing.]
 165 [The size of the table is 32kB for 2 bits, 64kB for 4 bits, 512kB for 8 bits of precision.]
 166 [A larger table size usually results in possible faster signing.]
 167 ["auto" is a reasonable setting for desktop machines (currently 4). [default=auto]]
 168 )],
 169 [req_ecmult_gen_precision=$withval], [req_ecmult_gen_precision=auto])
 170
 171 AC_CHECK_HEADER([valgrind/memcheck.h], [enable_valgrind=yes], [enable_valgrind=no], [])
 172 AM_CONDITIONAL([VALGRIND_ENABLED],[test "$enable_valgrind" = "yes"])
 173
 174 if test x"$enable_coverage" = x"yes"; then
 175     AC_DEFINE(COVERAGE, 1, [Define this symbol to compile out all VERIFY code])
 176     CFLAGS="-O0 --coverage $CFLAGS"
 177     LDFLAGS="--coverage $LDFLAGS"
 178 else
 179     CFLAGS="-O2 $CFLAGS"
 180 fi
 181
 182 if test x"$use_ecmult_static_precomputation" != x"no"; then
 183   # Temporarily switch to an environment for the native compiler
 184   save_cross_compiling=$cross_compiling
 185   cross_compiling=no
 186   SAVE_CC="$CC"
 187   CC="$CC_FOR_BUILD"
 188   SAVE_CFLAGS="$CFLAGS"
 189   CFLAGS="$CFLAGS_FOR_BUILD"
 190   SAVE_CPPFLAGS="$CPPFLAGS"
 191   CPPFLAGS="$CPPFLAGS_FOR_BUILD"
 192   SAVE_LDFLAGS="$LDFLAGS"
 193   LDFLAGS="$LDFLAGS_FOR_BUILD"
 194
 195   warn_CFLAGS_FOR_BUILD="-Wall -Wextra -Wno-unused-function"
 196   saved_CFLAGS="$CFLAGS"
 197   CFLAGS="$warn_CFLAGS_FOR_BUILD $CFLAGS"
 198   AC_MSG_CHECKING([if native ${CC_FOR_BUILD} supports ${warn_CFLAGS_FOR_BUILD}])
 199   AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
 200       [ AC_MSG_RESULT([yes]) ],
 201       [ AC_MSG_RESULT([no])
 202         CFLAGS="$saved_CFLAGS"
 203       ])
 204
 205   AC_MSG_CHECKING([for working native compiler: ${CC_FOR_BUILD}])
 206   AC_RUN_IFELSE(
 207     [AC_LANG_PROGRAM([], [])],
 208     [working_native_cc=yes],
 209     [working_native_cc=no],[:])
 210
 211   CFLAGS_FOR_BUILD="$CFLAGS"
 212
 213   # Restore the environment
 214   cross_compiling=$save_cross_compiling
 215   CC="$SAVE_CC"
 216   CFLAGS="$SAVE_CFLAGS"
 217   CPPFLAGS="$SAVE_CPPFLAGS"
 218   LDFLAGS="$SAVE_LDFLAGS"
 219
 220   if test x"$working_native_cc" = x"no"; then
 221     AC_MSG_RESULT([no])
 222     set_precomp=no
 223     m4_define([please_set_for_build], [Please set CC_FOR_BUILD, CFLAGS_FOR_BUILD, CPPFLAGS_FOR_BUILD, and/or LDFLAGS_FOR_BUILD.])
 224     if test x"$use_ecmult_static_precomputation" = x"yes";  then
 225       AC_MSG_ERROR([native compiler ${CC_FOR_BUILD} does not produce working binaries. please_set_for_build])
 226     else
 227       AC_MSG_WARN([Disabling statically generated ecmult table because the native compiler ${CC_FOR_BUILD} does not produce working binaries. please_set_for_build])
 228     fi
 229   else
 230     AC_MSG_RESULT([yes])
 231     set_precomp=yes
 232   fi
 233 else
 234   set_precomp=no
 235 fi
 236
 237 if test x"$req_asm" = x"auto"; then
 238   SECP_64BIT_ASM_CHECK
 239   if test x"$has_64bit_asm" = x"yes"; then
 240     set_asm=x86_64
 241   fi
 242   if test x"$set_asm" = x; then
 243     set_asm=no
 244   fi
 245 else
 246   set_asm=$req_asm
 247   case $set_asm in
 248   x86_64)
 249     SECP_64BIT_ASM_CHECK
 250     if test x"$has_64bit_asm" != x"yes"; then
 251       AC_MSG_ERROR([x86_64 assembly optimization requested but not available])
 252     fi
 253     ;;
 254   arm)
 255     ;;
 256   no)
 257     ;;
 258   *)
 259     AC_MSG_ERROR([invalid assembly optimization selection])
 260     ;;
 261   esac
 262 fi
 263
 264 if test x"$req_bignum" = x"auto"; then
 265   SECP_GMP_CHECK
 266   if test x"$has_gmp" = x"yes"; then
 267     set_bignum=gmp
 268   fi
 269
 270   if test x"$set_bignum" = x; then
 271     set_bignum=no
 272   fi
 273 else
 274   set_bignum=$req_bignum
 275   case $set_bignum in
 276   gmp)
 277     SECP_GMP_CHECK
 278     if test x"$has_gmp" != x"yes"; then
 279       AC_MSG_ERROR([gmp bignum explicitly requested but libgmp not available])
 280     fi
 281     ;;
 282   no)
 283     ;;
 284   *)
 285     AC_MSG_ERROR([invalid bignum implementation selection])
 286     ;;
 287   esac
 288 fi
 289
 290 # select assembly optimization
 291 use_external_asm=no
 292
 293 case $set_asm in
 294 x86_64)
 295   AC_DEFINE(USE_ASM_X86_64, 1, [Define this symbol to enable x86_64 assembly optimizations])
 296   ;;
 297 arm)
 298   use_external_asm=yes
 299   ;;
 300 no)
 301   ;;
 302 *)
 303   AC_MSG_ERROR([invalid assembly optimizations])
 304   ;;
 305 esac
 306
 307 # select wide multiplication implementation
 308 case $set_widemul in
 309 int128)
 310   AC_DEFINE(USE_FORCE_WIDEMUL_INT128, 1, [Define this symbol to force the use of the (unsigned) __int128 based wide multiplication implementation])
 311   ;;
 312 int64)
 313   AC_DEFINE(USE_FORCE_WIDEMUL_INT64, 1, [Define this symbol to force the use of the (u)int64_t based wide multiplication implementation])
 314   ;;
 315 auto)
 316   ;;
 317 *)
 318   AC_MSG_ERROR([invalid wide multiplication implementation])
 319   ;;
 320 esac
 321
 322 # select bignum implementation
 323 case $set_bignum in
 324 gmp)
 325   AC_DEFINE(HAVE_LIBGMP, 1, [Define this symbol if libgmp is installed])
 326   AC_DEFINE(USE_NUM_GMP, 1, [Define this symbol to use the gmp implementation for num])
 327   AC_DEFINE(USE_FIELD_INV_NUM, 1, [Define this symbol to use the num-based field inverse implementation])
 328   AC_DEFINE(USE_SCALAR_INV_NUM, 1, [Define this symbol to use the num-based scalar inverse implementation])
 329   ;;
 330 no)
 331   AC_DEFINE(USE_NUM_NONE, 1, [Define this symbol to use no num implementation])
 332   AC_DEFINE(USE_FIELD_INV_BUILTIN, 1, [Define this symbol to use the native field inverse implementation])
 333   AC_DEFINE(USE_SCALAR_INV_BUILTIN, 1, [Define this symbol to use the native scalar inverse implementation])
 334   ;;
 335 *)
 336   AC_MSG_ERROR([invalid bignum implementation])
 337   ;;
 338 esac
 339
 340 #set ecmult window size
 341 if test x"$req_ecmult_window" = x"auto"; then
 342   set_ecmult_window=15
 343 else
 344   set_ecmult_window=$req_ecmult_window
 345 fi
 346
 347 error_window_size=['window size for ecmult precomputation not an integer in range [2..24] or "auto"']
 348 case $set_ecmult_window in
 349 ''|*[[!0-9]]*)
 350   # no valid integer
 351   AC_MSG_ERROR($error_window_size)
 352   ;;
 353 *)
 354   if test "$set_ecmult_window" -lt 2 -o "$set_ecmult_window" -gt 24 ; then
 355     # not in range
 356     AC_MSG_ERROR($error_window_size)
 357   fi
 358   AC_DEFINE_UNQUOTED(ECMULT_WINDOW_SIZE, $set_ecmult_window, [Set window size for ecmult precomputation])
 359   ;;
 360 esac
 361
 362 #set ecmult gen precision
 363 if test x"$req_ecmult_gen_precision" = x"auto"; then
 364   set_ecmult_gen_precision=4
 365 else
 366   set_ecmult_gen_precision=$req_ecmult_gen_precision
 367 fi
 368
 369 case $set_ecmult_gen_precision in
 370 2|4|8)
 371   AC_DEFINE_UNQUOTED(ECMULT_GEN_PREC_BITS, $set_ecmult_gen_precision, [Set ecmult gen precision bits])
 372   ;;
 373 *)
 374   AC_MSG_ERROR(['ecmult gen precision not 2, 4, 8 or "auto"'])
 375   ;;
 376 esac
 377
 378 if test x"$use_tests" = x"yes"; then
 379   SECP_OPENSSL_CHECK
 380   if test x"$has_openssl_ec" = x"yes"; then
 381     if test x"$enable_openssl_tests" != x"no"; then
 382       AC_DEFINE(ENABLE_OPENSSL_TESTS, 1, [Define this symbol if OpenSSL EC functions are available])
 383       SECP_TEST_INCLUDES="$SSL_CFLAGS $CRYPTO_CFLAGS $CRYPTO_CPPFLAGS"
 384       SECP_TEST_LIBS="$CRYPTO_LIBS"
 385
 386       case $host in
 387       *mingw*)
 388         SECP_TEST_LIBS="$SECP_TEST_LIBS -lgdi32"
 389         ;;
 390       esac
 391     fi
 392   else
 393     if test x"$enable_openssl_tests" = x"yes"; then
 394       AC_MSG_ERROR([OpenSSL tests requested but OpenSSL with EC support is not available])
 395     fi
 396   fi
 397 else
 398   if test x"$enable_openssl_tests" = x"yes"; then
 399     AC_MSG_ERROR([OpenSSL tests requested but tests are not enabled])
 400   fi
 401 fi
 402
 403 if test x"$set_bignum" = x"gmp"; then
 404   SECP_LIBS="$SECP_LIBS $GMP_LIBS"
 405   SECP_INCLUDES="$SECP_INCLUDES $GMP_CPPFLAGS"
 406 fi
 407
 408 if test x"$use_endomorphism" = x"yes"; then
 409   AC_DEFINE(USE_ENDOMORPHISM, 1, [Define this symbol to use endomorphism optimization])
 410 fi
 411
 412 if test x"$set_precomp" = x"yes"; then
 413   AC_DEFINE(USE_ECMULT_STATIC_PRECOMPUTATION, 1, [Define this symbol to use a statically generated ecmult table])
 414 fi
 415
 416 if test x"$enable_module_ecdh" = x"yes"; then
 417   AC_DEFINE(ENABLE_MODULE_ECDH, 1, [Define this symbol to enable the ECDH module])
 418 fi
 419
 420 if test x"$enable_module_recovery" = x"yes"; then
 421   AC_DEFINE(ENABLE_MODULE_RECOVERY, 1, [Define this symbol to enable the ECDSA pubkey recovery module])
 422 fi
 423
 424 if test x"$use_external_asm" = x"yes"; then
 425   AC_DEFINE(USE_EXTERNAL_ASM, 1, [Define this symbol if an external (non-inline) assembly implementation is used])
 426 fi
 427
 428 if test x"$use_external_default_callbacks" = x"yes"; then
 429   AC_DEFINE(USE_EXTERNAL_DEFAULT_CALLBACKS, 1, [Define this symbol if an external implementation of the default callbacks is used])
 430 fi
 431
 432 if test x"$enable_experimental" = x"yes"; then
 433   AC_MSG_NOTICE([******])
 434   AC_MSG_NOTICE([WARNING: experimental build])
 435   AC_MSG_NOTICE([Experimental features do not have stable APIs or properties, and may not be safe for production use.])
 436   AC_MSG_NOTICE([Building ECDH module: $enable_module_ecdh])
 437   AC_MSG_NOTICE([******])
 438 else
 439   if test x"$enable_module_ecdh" = x"yes"; then
 440     AC_MSG_ERROR([ECDH module is experimental. Use --enable-experimental to allow.])
 441   fi
 442   if test x"$set_asm" = x"arm"; then
 443     AC_MSG_ERROR([ARM assembly optimization is experimental. Use --enable-experimental to allow.])
 444   fi
 445 fi
 446
 447 AC_CONFIG_HEADERS([src/libsecp256k1-config.h])
 448 AC_CONFIG_FILES([Makefile libsecp256k1.pc])
 449 AC_SUBST(SECP_INCLUDES)
 450 AC_SUBST(SECP_LIBS)
 451 AC_SUBST(SECP_TEST_LIBS)
 452 AC_SUBST(SECP_TEST_INCLUDES)
 453 AM_CONDITIONAL([ENABLE_COVERAGE], [test x"$enable_coverage" = x"yes"])
 454 AM_CONDITIONAL([USE_TESTS], [test x"$use_tests" != x"no"])
 455 AM_CONDITIONAL([USE_EXHAUSTIVE_TESTS], [test x"$use_exhaustive_tests" != x"no"])
 456 AM_CONDITIONAL([USE_BENCHMARK], [test x"$use_benchmark" = x"yes"])
 457 AM_CONDITIONAL([USE_ECMULT_STATIC_PRECOMPUTATION], [test x"$set_precomp" = x"yes"])
 458 AM_CONDITIONAL([ENABLE_MODULE_ECDH], [test x"$enable_module_ecdh" = x"yes"])
 459 AM_CONDITIONAL([ENABLE_MODULE_RECOVERY], [test x"$enable_module_recovery" = x"yes"])
 460 AM_CONDITIONAL([USE_EXTERNAL_ASM], [test x"$use_external_asm" = x"yes"])
 461 AM_CONDITIONAL([USE_ASM_ARM], [test x"$set_asm" = x"arm"])
 462
 463 dnl make sure nothing new is exported so that we don't break the cache
 464 PKGCONFIG_PATH_TEMP="$PKG_CONFIG_PATH"
 465 unset PKG_CONFIG_PATH
 466 PKG_CONFIG_PATH="$PKGCONFIG_PATH_TEMP"
 467
 468 AC_OUTPUT
 469
 470 echo
 471 echo "Build Options:"
 472 echo "  with endomorphism       = $use_endomorphism"
 473 echo "  with ecmult precomp     = $set_precomp"
 474 echo "  with external callbacks = $use_external_default_callbacks"
 475 echo "  with benchmarks         = $use_benchmark"
 476 echo "  with coverage           = $enable_coverage"
 477 echo "  module ecdh             = $enable_module_ecdh"
 478 echo "  module recovery         = $enable_module_recovery"
 479 echo
 480 echo "  asm                     = $set_asm"
 481 echo "  bignum                  = $set_bignum"
 482 echo "  ecmult window size      = $set_ecmult_window"
 483 echo "  ecmult gen prec. bits   = $set_ecmult_gen_precision"
 484 dnl Hide test-only options unless they're used.
 485 if test x"$set_widemul" != xauto; then
 486 echo "  wide multiplication     = $set_widemul"
 487 fi
 488 echo
 489 echo "  valgrind                = $enable_valgrind"
 490 echo "  CC                      = $CC"
 491 echo "  CFLAGS                  = $CFLAGS"
 492 echo "  CPPFLAGS                = $CPPFLAGS"
 493 echo "  LDFLAGS                 = $LDFLAGS"
 494 echo