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
  33 case $host_os in
  34   *darwin*)
  35      if  test x$cross_compiling != xyes; then
  36        AC_PATH_PROG([BREW],brew,)
  37        if test x$BREW != x; then
  38          dnl These Homebrew packages may be keg-only, meaning that they won't be found
  39          dnl in expected paths because they may conflict with system files. Ask
  40          dnl Homebrew where each one is located, then adjust paths accordingly.
  41
  42          openssl_prefix=`$BREW --prefix openssl 2>/dev/null`
  43          gmp_prefix=`$BREW --prefix gmp 2>/dev/null`
  44          if test x$openssl_prefix != x; then
  45            PKG_CONFIG_PATH="$openssl_prefix/lib/pkgconfig:$PKG_CONFIG_PATH"
  46            export PKG_CONFIG_PATH
  47          fi
  48          if test x$gmp_prefix != x; then
  49            GMP_CPPFLAGS="-I$gmp_prefix/include"
  50            GMP_LIBS="-L$gmp_prefix/lib"
  51          fi
  52        else
  53          AC_PATH_PROG([PORT],port,)
  54          dnl if homebrew isn't installed and macports is, add the macports default paths
  55          dnl as a last resort.
  56          if test x$PORT != x; then
  57            CPPFLAGS="$CPPFLAGS -isystem /opt/local/include"
  58            LDFLAGS="$LDFLAGS -L/opt/local/lib"
  59          fi
  60        fi
  61      fi
  62    ;;
  63 esac
  64
  65 CFLAGS="$CFLAGS -W"
  66
  67 warn_CFLAGS="-std=c89 -pedantic -Wall -Wextra -Wcast-align -Wnested-externs -Wshadow -Wstrict-prototypes -Wno-unused-function -Wno-long-long -Wno-overlength-strings"
  68 saved_CFLAGS="$CFLAGS"
  69 CFLAGS="$CFLAGS $warn_CFLAGS"
  70 AC_MSG_CHECKING([if ${CC} supports ${warn_CFLAGS}])
  71 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
  72     [ AC_MSG_RESULT([yes]) ],
  73     [ AC_MSG_RESULT([no])
  74       CFLAGS="$saved_CFLAGS"
  75     ])
  76
  77 saved_CFLAGS="$CFLAGS"
  78 CFLAGS="$CFLAGS -fvisibility=hidden"
  79 AC_MSG_CHECKING([if ${CC} supports -fvisibility=hidden])
  80 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
  81     [ AC_MSG_RESULT([yes]) ],
  82     [ AC_MSG_RESULT([no])
  83       CFLAGS="$saved_CFLAGS"
  84     ])
  85
  86 AC_ARG_ENABLE(benchmark,
  87     AS_HELP_STRING([--enable-benchmark],[compile benchmark (default is no)]),
  88     [use_benchmark=$enableval],
  89     [use_benchmark=no])
  90
  91 AC_ARG_ENABLE(tests,
  92     AS_HELP_STRING([--enable-tests],[compile tests (default is yes)]),
  93     [use_tests=$enableval],
  94     [use_tests=yes])
  95
  96 AC_ARG_ENABLE(experimental,
  97     AS_HELP_STRING([--enable-experimental],[allow experimental configure options (default is no)]),
  98     [use_experimental=$enableval],
  99     [use_experimental=no])
 100
 101 AC_ARG_ENABLE(endomorphism,
 102     AS_HELP_STRING([--enable-endomorphism],[enable endomorphism (default is no)]),
 103     [use_endomorphism=$enableval],
 104     [use_endomorphism=no])
 105
 106 AC_ARG_ENABLE(ecmult_static_precomputation,
 107     AS_HELP_STRING([--enable-ecmult-static-precomputation],[enable precomputed ecmult table for signing (default is yes)]),
 108     [use_ecmult_static_precomputation=$enableval],
 109     [use_ecmult_static_precomputation=yes])
 110
 111 AC_ARG_ENABLE(module_ecdh,
 112     AS_HELP_STRING([--enable-module-ecdh],[enable ECDH shared secret computation (experimental)]),
 113     [enable_module_ecdh=$enableval],
 114     [enable_module_ecdh=no])
 115
 116 AC_ARG_ENABLE(module_schnorr,
 117     AS_HELP_STRING([--enable-module-schnorr],[enable Schnorr signature module (experimental)]),
 118     [enable_module_schnorr=$enableval],
 119     [enable_module_schnorr=no])
 120
 121 AC_ARG_ENABLE(module_recovery,
 122     AS_HELP_STRING([--enable-module-recovery],[enable ECDSA pubkey recovery module (default is no)]),
 123     [enable_module_recovery=$enableval],
 124     [enable_module_recovery=no])
 125
 126 AC_ARG_ENABLE(jni,
 127     AS_HELP_STRING([--enable-jni],[enable libsecp256k1_jni (default is auto)]),
 128     [use_jni=$enableval],
 129     [use_jni=auto])
 130
 131 AC_ARG_WITH([field], [AS_HELP_STRING([--with-field=64bit|32bit|auto],
 132 [Specify Field Implementation. Default is auto])],[req_field=$withval], [req_field=auto])
 133
 134 AC_ARG_WITH([bignum], [AS_HELP_STRING([--with-bignum=gmp|no|auto],
 135 [Specify Bignum Implementation. Default is auto])],[req_bignum=$withval], [req_bignum=auto])
 136
 137 AC_ARG_WITH([scalar], [AS_HELP_STRING([--with-scalar=64bit|32bit|auto],
 138 [Specify scalar implementation. Default is auto])],[req_scalar=$withval], [req_scalar=auto])
 139
 140 AC_ARG_WITH([asm], [AS_HELP_STRING([--with-asm=x86_64|no|auto]
 141 [Specify assembly optimizations to use. Default is auto])],[req_asm=$withval], [req_asm=auto])
 142
 143 AC_CHECK_TYPES([__int128])
 144
 145 AC_MSG_CHECKING([for __builtin_expect])
 146 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[void myfunc() {__builtin_expect(0,0);}]])],
 147     [ AC_MSG_RESULT([yes]);AC_DEFINE(HAVE_BUILTIN_EXPECT,1,[Define this symbol if __builtin_expect is available]) ],
 148     [ AC_MSG_RESULT([no])
 149     ])
 150
 151 if test x"$req_asm" = x"auto"; then
 152   SECP_64BIT_ASM_CHECK
 153   if test x"$has_64bit_asm" = x"yes"; then
 154     set_asm=x86_64
 155   fi
 156   if test x"$set_asm" = x; then
 157     set_asm=no
 158   fi
 159 else
 160   set_asm=$req_asm
 161   case $set_asm in
 162   x86_64)
 163     SECP_64BIT_ASM_CHECK
 164     if test x"$has_64bit_asm" != x"yes"; then
 165       AC_MSG_ERROR([x86_64 assembly optimization requested but not available])
 166     fi
 167     ;;
 168   no)
 169     ;;
 170   *)
 171     AC_MSG_ERROR([invalid assembly optimization selection])
 172     ;;
 173   esac
 174 fi
 175
 176 if test x"$req_field" = x"auto"; then
 177   if test x"set_asm" = x"x86_64"; then
 178     set_field=64bit
 179   fi
 180   if test x"$set_field" = x; then
 181     SECP_INT128_CHECK
 182     if test x"$has_int128" = x"yes"; then
 183       set_field=64bit
 184     fi
 185   fi
 186   if test x"$set_field" = x; then
 187     set_field=32bit
 188   fi
 189 else
 190   set_field=$req_field
 191   case $set_field in
 192   64bit)
 193     if test x"$set_asm" != x"x86_64"; then
 194       SECP_INT128_CHECK
 195       if test x"$has_int128" != x"yes"; then
 196         AC_MSG_ERROR([64bit field explicitly requested but neither __int128 support or x86_64 assembly available])
 197       fi
 198     fi
 199     ;;
 200   32bit)
 201     ;;
 202   *)
 203     AC_MSG_ERROR([invalid field implementation selection])
 204     ;;
 205   esac
 206 fi
 207
 208 if test x"$req_scalar" = x"auto"; then
 209   SECP_INT128_CHECK
 210   if test x"$has_int128" = x"yes"; then
 211     set_scalar=64bit
 212   fi
 213   if test x"$set_scalar" = x; then
 214     set_scalar=32bit
 215   fi
 216 else
 217   set_scalar=$req_scalar
 218   case $set_scalar in
 219   64bit)
 220     SECP_INT128_CHECK
 221     if test x"$has_int128" != x"yes"; then
 222       AC_MSG_ERROR([64bit scalar explicitly requested but __int128 support not available])
 223     fi
 224     ;;
 225   32bit)
 226     ;;
 227   *)
 228     AC_MSG_ERROR([invalid scalar implementation selected])
 229     ;;
 230   esac
 231 fi
 232
 233 if test x"$req_bignum" = x"auto"; then
 234   SECP_GMP_CHECK
 235   if test x"$has_gmp" = x"yes"; then
 236     set_bignum=gmp
 237   fi
 238
 239   if test x"$set_bignum" = x; then
 240     set_bignum=no
 241   fi
 242 else
 243   set_bignum=$req_bignum
 244   case $set_bignum in
 245   gmp)
 246     SECP_GMP_CHECK
 247     if test x"$has_gmp" != x"yes"; then
 248       AC_MSG_ERROR([gmp bignum explicitly requested but libgmp not available])
 249     fi
 250     ;;
 251   no)
 252     ;;
 253   *)
 254     AC_MSG_ERROR([invalid bignum implementation selection])
 255     ;;
 256   esac
 257 fi
 258
 259 # select assembly optimization
 260 case $set_asm in
 261 x86_64)
 262   AC_DEFINE(USE_ASM_X86_64, 1, [Define this symbol to enable x86_64 assembly optimizations])
 263   ;;
 264 no)
 265   ;;
 266 *)
 267   AC_MSG_ERROR([invalid assembly optimizations])
 268   ;;
 269 esac
 270
 271 # select field implementation
 272 case $set_field in
 273 64bit)
 274   AC_DEFINE(USE_FIELD_5X52, 1, [Define this symbol to use the FIELD_5X52 implementation])
 275   ;;
 276 32bit)
 277   AC_DEFINE(USE_FIELD_10X26, 1, [Define this symbol to use the FIELD_10X26 implementation])
 278   ;;
 279 *)
 280   AC_MSG_ERROR([invalid field implementation])
 281   ;;
 282 esac
 283
 284 # select bignum implementation
 285 case $set_bignum in
 286 gmp)
 287   AC_DEFINE(HAVE_LIBGMP, 1, [Define this symbol if libgmp is installed])
 288   AC_DEFINE(USE_NUM_GMP, 1, [Define this symbol to use the gmp implementation for num])
 289   AC_DEFINE(USE_FIELD_INV_NUM, 1, [Define this symbol to use the num-based field inverse implementation])
 290   AC_DEFINE(USE_SCALAR_INV_NUM, 1, [Define this symbol to use the num-based scalar inverse implementation])
 291   ;;
 292 no)
 293   AC_DEFINE(USE_NUM_NONE, 1, [Define this symbol to use no num implementation])
 294   AC_DEFINE(USE_FIELD_INV_BUILTIN, 1, [Define this symbol to use the native field inverse implementation])
 295   AC_DEFINE(USE_SCALAR_INV_BUILTIN, 1, [Define this symbol to use the native scalar inverse implementation])
 296   ;;
 297 *)
 298   AC_MSG_ERROR([invalid bignum implementation])
 299   ;;
 300 esac
 301
 302 #select scalar implementation
 303 case $set_scalar in
 304 64bit)
 305   AC_DEFINE(USE_SCALAR_4X64, 1, [Define this symbol to use the 4x64 scalar implementation])
 306   ;;
 307 32bit)
 308   AC_DEFINE(USE_SCALAR_8X32, 1, [Define this symbol to use the 8x32 scalar implementation])
 309   ;;
 310 *)
 311   AC_MSG_ERROR([invalid scalar implementation])
 312   ;;
 313 esac
 314
 315 if test x"$use_tests" = x"yes"; then
 316   SECP_OPENSSL_CHECK
 317   if test x"$has_openssl_ec" = x"yes"; then
 318     AC_DEFINE(ENABLE_OPENSSL_TESTS, 1, [Define this symbol if OpenSSL EC functions are available])
 319     SECP_TEST_INCLUDES="$SSL_CFLAGS $CRYPTO_CFLAGS"
 320     SECP_TEST_LIBS="$CRYPTO_LIBS"
 321
 322     case $host in
 323     *mingw*)
 324       SECP_TEST_LIBS="$SECP_TEST_LIBS -lgdi32"
 325       ;;
 326     esac
 327
 328   fi
 329 fi
 330
 331 if test x"$use_jni" != x"no"; then
 332   AX_JNI_INCLUDE_DIR
 333   if test "x$JNI_INCLUDE_DIRS" = "x"; then
 334     if test x"$use_jni" = x"yes"; then
 335       AC_MSG_ERROR([jni support explicitly requested but headers were not found])
 336     fi
 337     AC_MSG_WARN([jni headers not found. jni support disabled])
 338     use_jni=no
 339   else
 340     use_jni=yes
 341     for JNI_INCLUDE_DIR in $JNI_INCLUDE_DIRS; do
 342       JNI_INCLUDES="$JNI_INCLUDES -I$JNI_INCLUDE_DIR"
 343     done
 344   fi
 345 fi
 346
 347 if test x"$set_bignum" = x"gmp"; then
 348   SECP_LIBS="$SECP_LIBS $GMP_LIBS"
 349   SECP_INCLUDES="$SECP_INCLUDES $GMP_CPPFLAGS"
 350 fi
 351
 352 if test x"$use_endomorphism" = x"yes"; then
 353   AC_DEFINE(USE_ENDOMORPHISM, 1, [Define this symbol to use endomorphism optimization])
 354 fi
 355
 356 if test x"$use_ecmult_static_precomputation" = x"yes"; then
 357   AC_DEFINE(USE_ECMULT_STATIC_PRECOMPUTATION, 1, [Define this symbol to use a statically generated ecmult table])
 358 fi
 359
 360 if test x"$enable_module_ecdh" = x"yes"; then
 361   AC_DEFINE(ENABLE_MODULE_ECDH, 1, [Define this symbol to enable the ECDH module])
 362 fi
 363
 364 if test x"$enable_module_schnorr" = x"yes"; then
 365   AC_DEFINE(ENABLE_MODULE_SCHNORR, 1, [Define this symbol to enable the Schnorr signature module])
 366 fi
 367
 368 if test x"$enable_module_recovery" = x"yes"; then
 369   AC_DEFINE(ENABLE_MODULE_RECOVERY, 1, [Define this symbol to enable the ECDSA pubkey recovery module])
 370 fi
 371
 372 AC_C_BIGENDIAN()
 373
 374 AC_MSG_NOTICE([Using assembly optimizations: $set_asm])
 375 AC_MSG_NOTICE([Using field implementation: $set_field])
 376 AC_MSG_NOTICE([Using bignum implementation: $set_bignum])
 377 AC_MSG_NOTICE([Using scalar implementation: $set_scalar])
 378 AC_MSG_NOTICE([Using endomorphism optimizations: $use_endomorphism])
 379 AC_MSG_NOTICE([Building ECDH module: $enable_module_ecdh])
 380 AC_MSG_NOTICE([Building Schnorr signatures module: $enable_module_schnorr])
 381 AC_MSG_NOTICE([Building ECDSA pubkey recovery module: $enable_module_recovery])
 382 AC_MSG_NOTICE([Using jni: $use_jni])
 383
 384 if test x"$enable_experimental" = x"yes"; then
 385   AC_MSG_NOTICE([******])
 386   AC_MSG_NOTICE([WARNING: experimental build])
 387   AC_MSG_NOTICE([Experimental features do not have stable APIs or properties, and may not be safe for production use.])
 388   AC_MSG_NOTICE([Building ECDH module: $enable_module_ecdh])
 389   AC_MSG_NOTICE([Building Schnorr signatures module: $enable_module_schnorr])
 390   AC_MSG_NOTICE([******])
 391 else
 392   if test x"$enable_module_schnorr" = x"yes"; then
 393     AC_MSG_ERROR([Schnorr signature module is experimental. Use --enable-experimental to allow.])
 394   fi
 395   if test x"$enable_module_ecdh" = x"yes"; then
 396     AC_MSG_ERROR([ECDH module is experimental. Use --enable-experimental to allow.])
 397   fi
 398 fi
 399
 400 AC_CONFIG_HEADERS([src/libsecp256k1-config.h])
 401 AC_CONFIG_FILES([Makefile libsecp256k1.pc])
 402 AC_SUBST(JNI_INCLUDES)
 403 AC_SUBST(SECP_INCLUDES)
 404 AC_SUBST(SECP_LIBS)
 405 AC_SUBST(SECP_TEST_LIBS)
 406 AC_SUBST(SECP_TEST_INCLUDES)
 407 AM_CONDITIONAL([USE_TESTS], [test x"$use_tests" != x"no"])
 408 AM_CONDITIONAL([USE_BENCHMARK], [test x"$use_benchmark" = x"yes"])
 409 AM_CONDITIONAL([USE_ECMULT_STATIC_PRECOMPUTATION], [test x"$use_ecmult_static_precomputation" = x"yes"])
 410 AM_CONDITIONAL([ENABLE_MODULE_ECDH], [test x"$enable_module_ecdh" = x"yes"])
 411 AM_CONDITIONAL([ENABLE_MODULE_SCHNORR], [test x"$enable_module_schnorr" = x"yes"])
 412 AM_CONDITIONAL([ENABLE_MODULE_RECOVERY], [test x"$enable_module_recovery" = x"yes"])
 413 AM_CONDITIONAL([USE_JNI], [test x"$use_jni" == x"yes"])
 414
 415 dnl make sure nothing new is exported so that we don't break the cache
 416 PKGCONFIG_PATH_TEMP="$PKG_CONFIG_PATH"
 417 unset PKG_CONFIG_PATH
 418 PKG_CONFIG_PATH="$PKGCONFIG_PATH_TEMP"
 419
 420 AC_OUTPUT