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="-O3 -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 no)]),
  89     [use_benchmark=$enableval],
  90     [use_benchmark=no])
  91
  92 AC_ARG_ENABLE(tests,
  93     AS_HELP_STRING([--enable-tests],[compile tests (default is yes)]),
  94     [use_tests=$enableval],
  95     [use_tests=yes])
  96
  97 AC_ARG_ENABLE(experimental,
  98     AS_HELP_STRING([--enable-experimental],[allow experimental configure options (default is no)]),
  99     [use_experimental=$enableval],
 100     [use_experimental=no])
 101
 102 AC_ARG_ENABLE(endomorphism,
 103     AS_HELP_STRING([--enable-endomorphism],[enable endomorphism (default is no)]),
 104     [use_endomorphism=$enableval],
 105     [use_endomorphism=no])
 106
 107 AC_ARG_ENABLE(ecmult_static_precomputation,
 108     AS_HELP_STRING([--enable-ecmult-static-precomputation],[enable precomputed ecmult table for signing (default is yes)]),
 109     [use_ecmult_static_precomputation=$enableval],
 110     [use_ecmult_static_precomputation=yes])
 111
 112 AC_ARG_ENABLE(module_ecdh,
 113     AS_HELP_STRING([--enable-module-ecdh],[enable ECDH shared secret computation (experimental)]),
 114     [enable_module_ecdh=$enableval],
 115     [enable_module_ecdh=no])
 116
 117 AC_ARG_ENABLE(module_schnorr,
 118     AS_HELP_STRING([--enable-module-schnorr],[enable Schnorr signature module (experimental)]),
 119     [enable_module_schnorr=$enableval],
 120     [enable_module_schnorr=no])
 121
 122 AC_ARG_ENABLE(module_recovery,
 123     AS_HELP_STRING([--enable-module-recovery],[enable ECDSA pubkey recovery module (default is no)]),
 124     [enable_module_recovery=$enableval],
 125     [enable_module_recovery=no])
 126
 127 AC_ARG_ENABLE(jni,
 128     AS_HELP_STRING([--enable-jni],[enable libsecp256k1_jni (default is auto)]),
 129     [use_jni=$enableval],
 130     [use_jni=auto])
 131
 132 AC_ARG_WITH([field], [AS_HELP_STRING([--with-field=64bit|32bit|auto],
 133 [Specify Field Implementation. Default is auto])],[req_field=$withval], [req_field=auto])
 134
 135 AC_ARG_WITH([bignum], [AS_HELP_STRING([--with-bignum=gmp|no|auto],
 136 [Specify Bignum Implementation. Default is auto])],[req_bignum=$withval], [req_bignum=auto])
 137
 138 AC_ARG_WITH([scalar], [AS_HELP_STRING([--with-scalar=64bit|32bit|auto],
 139 [Specify scalar implementation. Default is auto])],[req_scalar=$withval], [req_scalar=auto])
 140
 141 AC_ARG_WITH([asm], [AS_HELP_STRING([--with-asm=x86_64|arm|no|auto]
 142 [Specify assembly optimizations to use. Default is auto (experimental: arm)])],[req_asm=$withval], [req_asm=auto])
 143
 144 AC_CHECK_TYPES([__int128])
 145
 146 AC_MSG_CHECKING([for __builtin_expect])
 147 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[void myfunc() {__builtin_expect(0,0);}]])],
 148     [ AC_MSG_RESULT([yes]);AC_DEFINE(HAVE_BUILTIN_EXPECT,1,[Define this symbol if __builtin_expect is available]) ],
 149     [ AC_MSG_RESULT([no])
 150     ])
 151
 152 if test x"$req_asm" = x"auto"; then
 153   SECP_64BIT_ASM_CHECK
 154   if test x"$has_64bit_asm" = x"yes"; then
 155     set_asm=x86_64
 156   fi
 157   if test x"$set_asm" = x; then
 158     set_asm=no
 159   fi
 160 else
 161   set_asm=$req_asm
 162   case $set_asm in
 163   x86_64)
 164     SECP_64BIT_ASM_CHECK
 165     if test x"$has_64bit_asm" != x"yes"; then
 166       AC_MSG_ERROR([x86_64 assembly optimization requested but not available])
 167     fi
 168     ;;
 169   arm)
 170     ;;
 171   no)
 172     ;;
 173   *)
 174     AC_MSG_ERROR([invalid assembly optimization selection])
 175     ;;
 176   esac
 177 fi
 178
 179 if test x"$req_field" = x"auto"; then
 180   if test x"set_asm" = x"x86_64"; then
 181     set_field=64bit
 182   fi
 183   if test x"$set_field" = x; then
 184     SECP_INT128_CHECK
 185     if test x"$has_int128" = x"yes"; then
 186       set_field=64bit
 187     fi
 188   fi
 189   if test x"$set_field" = x; then
 190     set_field=32bit
 191   fi
 192 else
 193   set_field=$req_field
 194   case $set_field in
 195   64bit)
 196     if test x"$set_asm" != x"x86_64"; then
 197       SECP_INT128_CHECK
 198       if test x"$has_int128" != x"yes"; then
 199         AC_MSG_ERROR([64bit field explicitly requested but neither __int128 support or x86_64 assembly available])
 200       fi
 201     fi
 202     ;;
 203   32bit)
 204     ;;
 205   *)
 206     AC_MSG_ERROR([invalid field implementation selection])
 207     ;;
 208   esac
 209 fi
 210
 211 if test x"$req_scalar" = x"auto"; then
 212   SECP_INT128_CHECK
 213   if test x"$has_int128" = x"yes"; then
 214     set_scalar=64bit
 215   fi
 216   if test x"$set_scalar" = x; then
 217     set_scalar=32bit
 218   fi
 219 else
 220   set_scalar=$req_scalar
 221   case $set_scalar in
 222   64bit)
 223     SECP_INT128_CHECK
 224     if test x"$has_int128" != x"yes"; then
 225       AC_MSG_ERROR([64bit scalar explicitly requested but __int128 support not available])
 226     fi
 227     ;;
 228   32bit)
 229     ;;
 230   *)
 231     AC_MSG_ERROR([invalid scalar implementation selected])
 232     ;;
 233   esac
 234 fi
 235
 236 if test x"$req_bignum" = x"auto"; then
 237   SECP_GMP_CHECK
 238   if test x"$has_gmp" = x"yes"; then
 239     set_bignum=gmp
 240   fi
 241
 242   if test x"$set_bignum" = x; then
 243     set_bignum=no
 244   fi
 245 else
 246   set_bignum=$req_bignum
 247   case $set_bignum in
 248   gmp)
 249     SECP_GMP_CHECK
 250     if test x"$has_gmp" != x"yes"; then
 251       AC_MSG_ERROR([gmp bignum explicitly requested but libgmp not available])
 252     fi
 253     ;;
 254   no)
 255     ;;
 256   *)
 257     AC_MSG_ERROR([invalid bignum implementation selection])
 258     ;;
 259   esac
 260 fi
 261
 262 # select assembly optimization
 263 use_external_asm=no
 264
 265 case $set_asm in
 266 x86_64)
 267   AC_DEFINE(USE_ASM_X86_64, 1, [Define this symbol to enable x86_64 assembly optimizations])
 268   ;;
 269 arm)
 270   use_external_asm=yes
 271   ;;
 272 no)
 273   ;;
 274 *)
 275   AC_MSG_ERROR([invalid assembly optimizations])
 276   ;;
 277 esac
 278
 279 # select field implementation
 280 case $set_field in
 281 64bit)
 282   AC_DEFINE(USE_FIELD_5X52, 1, [Define this symbol to use the FIELD_5X52 implementation])
 283   ;;
 284 32bit)
 285   AC_DEFINE(USE_FIELD_10X26, 1, [Define this symbol to use the FIELD_10X26 implementation])
 286   ;;
 287 *)
 288   AC_MSG_ERROR([invalid field implementation])
 289   ;;
 290 esac
 291
 292 # select bignum implementation
 293 case $set_bignum in
 294 gmp)
 295   AC_DEFINE(HAVE_LIBGMP, 1, [Define this symbol if libgmp is installed])
 296   AC_DEFINE(USE_NUM_GMP, 1, [Define this symbol to use the gmp implementation for num])
 297   AC_DEFINE(USE_FIELD_INV_NUM, 1, [Define this symbol to use the num-based field inverse implementation])
 298   AC_DEFINE(USE_SCALAR_INV_NUM, 1, [Define this symbol to use the num-based scalar inverse implementation])
 299   ;;
 300 no)
 301   AC_DEFINE(USE_NUM_NONE, 1, [Define this symbol to use no num implementation])
 302   AC_DEFINE(USE_FIELD_INV_BUILTIN, 1, [Define this symbol to use the native field inverse implementation])
 303   AC_DEFINE(USE_SCALAR_INV_BUILTIN, 1, [Define this symbol to use the native scalar inverse implementation])
 304   ;;
 305 *)
 306   AC_MSG_ERROR([invalid bignum implementation])
 307   ;;
 308 esac
 309
 310 #select scalar implementation
 311 case $set_scalar in
 312 64bit)
 313   AC_DEFINE(USE_SCALAR_4X64, 1, [Define this symbol to use the 4x64 scalar implementation])
 314   ;;
 315 32bit)
 316   AC_DEFINE(USE_SCALAR_8X32, 1, [Define this symbol to use the 8x32 scalar implementation])
 317   ;;
 318 *)
 319   AC_MSG_ERROR([invalid scalar implementation])
 320   ;;
 321 esac
 322
 323 if test x"$use_tests" = x"yes"; then
 324   SECP_OPENSSL_CHECK
 325   if test x"$has_openssl_ec" = x"yes"; then
 326     AC_DEFINE(ENABLE_OPENSSL_TESTS, 1, [Define this symbol if OpenSSL EC functions are available])
 327     SECP_TEST_INCLUDES="$SSL_CFLAGS $CRYPTO_CFLAGS"
 328     SECP_TEST_LIBS="$CRYPTO_LIBS"
 329
 330     case $host in
 331     *mingw*)
 332       SECP_TEST_LIBS="$SECP_TEST_LIBS -lgdi32"
 333       ;;
 334     esac
 335
 336   fi
 337 fi
 338
 339 if test x"$use_jni" != x"no"; then
 340   AX_JNI_INCLUDE_DIR
 341   have_jni_dependencies=yes
 342   if test x"$enable_module_schnorr" = x"no"; then
 343     have_jni_dependencies=no
 344   fi
 345   if test x"$enable_module_ecdh" = x"no"; then
 346     have_jni_dependencies=no
 347   fi
 348   if test "x$JNI_INCLUDE_DIRS" = "x"; then
 349     have_jni_dependencies=no
 350   fi
 351   if test "x$have_jni_dependencies" = "xno"; then
 352     if test x"$use_jni" = x"yes"; then
 353       AC_MSG_ERROR([jni support explicitly requested but headers/dependencies were not found. Enable ECDH and Schnorr and try again.])
 354     fi
 355     AC_MSG_WARN([jni headers/dependencies not found. jni support disabled])
 356     use_jni=no
 357   else
 358     use_jni=yes
 359     for JNI_INCLUDE_DIR in $JNI_INCLUDE_DIRS; do
 360       JNI_INCLUDES="$JNI_INCLUDES -I$JNI_INCLUDE_DIR"
 361     done
 362   fi
 363 fi
 364
 365 if test x"$set_bignum" = x"gmp"; then
 366   SECP_LIBS="$SECP_LIBS $GMP_LIBS"
 367   SECP_INCLUDES="$SECP_INCLUDES $GMP_CPPFLAGS"
 368 fi
 369
 370 if test x"$use_endomorphism" = x"yes"; then
 371   AC_DEFINE(USE_ENDOMORPHISM, 1, [Define this symbol to use endomorphism optimization])
 372 fi
 373
 374 if test x"$use_ecmult_static_precomputation" = x"yes"; then
 375   AC_DEFINE(USE_ECMULT_STATIC_PRECOMPUTATION, 1, [Define this symbol to use a statically generated ecmult table])
 376 fi
 377
 378 if test x"$enable_module_ecdh" = x"yes"; then
 379   AC_DEFINE(ENABLE_MODULE_ECDH, 1, [Define this symbol to enable the ECDH module])
 380 fi
 381
 382 if test x"$enable_module_schnorr" = x"yes"; then
 383   AC_DEFINE(ENABLE_MODULE_SCHNORR, 1, [Define this symbol to enable the Schnorr signature module])
 384 fi
 385
 386 if test x"$enable_module_recovery" = x"yes"; then
 387   AC_DEFINE(ENABLE_MODULE_RECOVERY, 1, [Define this symbol to enable the ECDSA pubkey recovery module])
 388 fi
 389
 390 AC_C_BIGENDIAN()
 391
 392 if test x"$use_external_asm" = x"yes"; then
 393   AC_DEFINE(USE_EXTERNAL_ASM, 1, [Define this symbol if an external (non-inline) assembly implementation is used])
 394 fi
 395
 396 AC_MSG_NOTICE([Using assembly optimizations: $set_asm])
 397 AC_MSG_NOTICE([Using field implementation: $set_field])
 398 AC_MSG_NOTICE([Using bignum implementation: $set_bignum])
 399 AC_MSG_NOTICE([Using scalar implementation: $set_scalar])
 400 AC_MSG_NOTICE([Using endomorphism optimizations: $use_endomorphism])
 401 AC_MSG_NOTICE([Building ECDH module: $enable_module_ecdh])
 402 AC_MSG_NOTICE([Building Schnorr signatures module: $enable_module_schnorr])
 403 AC_MSG_NOTICE([Building ECDSA pubkey recovery module: $enable_module_recovery])
 404 AC_MSG_NOTICE([Using jni: $use_jni])
 405
 406 if test x"$enable_experimental" = x"yes"; then
 407   AC_MSG_NOTICE([******])
 408   AC_MSG_NOTICE([WARNING: experimental build])
 409   AC_MSG_NOTICE([Experimental features do not have stable APIs or properties, and may not be safe for production use.])
 410   AC_MSG_NOTICE([Building ECDH module: $enable_module_ecdh])
 411   AC_MSG_NOTICE([Building Schnorr signatures module: $enable_module_schnorr])
 412   AC_MSG_NOTICE([******])
 413 else
 414   if test x"$enable_module_schnorr" = x"yes"; then
 415     AC_MSG_ERROR([Schnorr signature module is experimental. Use --enable-experimental to allow.])
 416   fi
 417   if test x"$enable_module_ecdh" = x"yes"; then
 418     AC_MSG_ERROR([ECDH module is experimental. Use --enable-experimental to allow.])
 419   fi
 420   if test x"$set_asm" = x"arm"; then
 421     AC_MSG_ERROR([ARM assembly optimization is experimental. Use --enable-experimental to allow.])
 422   fi
 423 fi
 424
 425 AC_CONFIG_HEADERS([src/libsecp256k1-config.h])
 426 AC_CONFIG_FILES([Makefile libsecp256k1.pc])
 427 AC_SUBST(JNI_INCLUDES)
 428 AC_SUBST(SECP_INCLUDES)
 429 AC_SUBST(SECP_LIBS)
 430 AC_SUBST(SECP_TEST_LIBS)
 431 AC_SUBST(SECP_TEST_INCLUDES)
 432 AM_CONDITIONAL([USE_TESTS], [test x"$use_tests" != x"no"])
 433 AM_CONDITIONAL([USE_BENCHMARK], [test x"$use_benchmark" = x"yes"])
 434 AM_CONDITIONAL([USE_ECMULT_STATIC_PRECOMPUTATION], [test x"$use_ecmult_static_precomputation" = x"yes"])
 435 AM_CONDITIONAL([ENABLE_MODULE_ECDH], [test x"$enable_module_ecdh" = x"yes"])
 436 AM_CONDITIONAL([ENABLE_MODULE_SCHNORR], [test x"$enable_module_schnorr" = x"yes"])
 437 AM_CONDITIONAL([ENABLE_MODULE_RECOVERY], [test x"$enable_module_recovery" = x"yes"])
 438 AM_CONDITIONAL([USE_JNI], [test x"$use_jni" == x"yes"])
 439 AM_CONDITIONAL([USE_EXTERNAL_ASM], [test x"$use_external_asm" = x"yes"])
 440 AM_CONDITIONAL([USE_ASM_ARM], [test x"$set_asm" = x"arm"])
 441
 442 dnl make sure nothing new is exported so that we don't break the cache
 443 PKGCONFIG_PATH_TEMP="$PKG_CONFIG_PATH"
 444 unset PKG_CONFIG_PATH
 445 PKG_CONFIG_PATH="$PKGCONFIG_PATH_TEMP"
 446
 447 AC_OUTPUT