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