]> Git Repo - secp256k1.git/blob - configure.ac
configure: Allow specifying --with[out]-valgrind explicitly
[secp256k1.git] / 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_ARG_WITH([valgrind], [AS_HELP_STRING([--with-valgrind=yes|no|auto],
172 [Build with extra checks for running inside Valgrind [default=auto]]
173 )],
174 [req_valgrind=$withval], [req_valgrind=auto])
175
176 if test x"$req_valgrind" = x"no"; then
177   enable_valgrind=no
178 else
179   AC_CHECK_HEADER([valgrind/memcheck.h], [enable_valgrind=yes], [
180     if test x"$req_valgrind" = x"yes"; then
181       AC_MSG_ERROR([Valgrind support explicitly requested but valgrind/memcheck.h header not available])
182     fi
183     enable_valgrind=no
184   ], [])
185 fi
186 AM_CONDITIONAL([VALGRIND_ENABLED],[test "$enable_valgrind" = "yes"])
187
188 if test x"$enable_coverage" = x"yes"; then
189     AC_DEFINE(COVERAGE, 1, [Define this symbol to compile out all VERIFY code])
190     CFLAGS="-O0 --coverage $CFLAGS"
191     LDFLAGS="--coverage $LDFLAGS"
192 else
193     CFLAGS="-O2 $CFLAGS"
194 fi
195
196 if test x"$use_ecmult_static_precomputation" != x"no"; then
197   # Temporarily switch to an environment for the native compiler
198   save_cross_compiling=$cross_compiling
199   cross_compiling=no
200   SAVE_CC="$CC"
201   CC="$CC_FOR_BUILD"
202   SAVE_CFLAGS="$CFLAGS"
203   CFLAGS="$CFLAGS_FOR_BUILD"
204   SAVE_CPPFLAGS="$CPPFLAGS"
205   CPPFLAGS="$CPPFLAGS_FOR_BUILD"
206   SAVE_LDFLAGS="$LDFLAGS"
207   LDFLAGS="$LDFLAGS_FOR_BUILD"
208
209   warn_CFLAGS_FOR_BUILD="-Wall -Wextra -Wno-unused-function"
210   saved_CFLAGS="$CFLAGS"
211   CFLAGS="$warn_CFLAGS_FOR_BUILD $CFLAGS"
212   AC_MSG_CHECKING([if native ${CC_FOR_BUILD} supports ${warn_CFLAGS_FOR_BUILD}])
213   AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
214       [ AC_MSG_RESULT([yes]) ],
215       [ AC_MSG_RESULT([no])
216         CFLAGS="$saved_CFLAGS"
217       ])
218
219   AC_MSG_CHECKING([for working native compiler: ${CC_FOR_BUILD}])
220   AC_RUN_IFELSE(
221     [AC_LANG_PROGRAM([], [])],
222     [working_native_cc=yes],
223     [working_native_cc=no],[:])
224
225   CFLAGS_FOR_BUILD="$CFLAGS"
226
227   # Restore the environment
228   cross_compiling=$save_cross_compiling
229   CC="$SAVE_CC"
230   CFLAGS="$SAVE_CFLAGS"
231   CPPFLAGS="$SAVE_CPPFLAGS"
232   LDFLAGS="$SAVE_LDFLAGS"
233
234   if test x"$working_native_cc" = x"no"; then
235     AC_MSG_RESULT([no])
236     set_precomp=no
237     m4_define([please_set_for_build], [Please set CC_FOR_BUILD, CFLAGS_FOR_BUILD, CPPFLAGS_FOR_BUILD, and/or LDFLAGS_FOR_BUILD.])
238     if test x"$use_ecmult_static_precomputation" = x"yes";  then
239       AC_MSG_ERROR([native compiler ${CC_FOR_BUILD} does not produce working binaries. please_set_for_build])
240     else
241       AC_MSG_WARN([Disabling statically generated ecmult table because the native compiler ${CC_FOR_BUILD} does not produce working binaries. please_set_for_build])
242     fi
243   else
244     AC_MSG_RESULT([yes])
245     set_precomp=yes
246   fi
247 else
248   set_precomp=no
249 fi
250
251 if test x"$req_asm" = x"auto"; then
252   SECP_64BIT_ASM_CHECK
253   if test x"$has_64bit_asm" = x"yes"; then
254     set_asm=x86_64
255   fi
256   if test x"$set_asm" = x; then
257     set_asm=no
258   fi
259 else
260   set_asm=$req_asm
261   case $set_asm in
262   x86_64)
263     SECP_64BIT_ASM_CHECK
264     if test x"$has_64bit_asm" != x"yes"; then
265       AC_MSG_ERROR([x86_64 assembly optimization requested but not available])
266     fi
267     ;;
268   arm)
269     ;;
270   no)
271     ;;
272   *)
273     AC_MSG_ERROR([invalid assembly optimization selection])
274     ;;
275   esac
276 fi
277
278 if test x"$req_bignum" = x"auto"; then
279   SECP_GMP_CHECK
280   if test x"$has_gmp" = x"yes"; then
281     set_bignum=gmp
282   fi
283
284   if test x"$set_bignum" = x; then
285     set_bignum=no
286   fi
287 else
288   set_bignum=$req_bignum
289   case $set_bignum in
290   gmp)
291     SECP_GMP_CHECK
292     if test x"$has_gmp" != x"yes"; then
293       AC_MSG_ERROR([gmp bignum explicitly requested but libgmp not available])
294     fi
295     ;;
296   no)
297     ;;
298   *)
299     AC_MSG_ERROR([invalid bignum implementation selection])
300     ;;
301   esac
302 fi
303
304 # select assembly optimization
305 use_external_asm=no
306
307 case $set_asm in
308 x86_64)
309   AC_DEFINE(USE_ASM_X86_64, 1, [Define this symbol to enable x86_64 assembly optimizations])
310   ;;
311 arm)
312   use_external_asm=yes
313   ;;
314 no)
315   ;;
316 *)
317   AC_MSG_ERROR([invalid assembly optimizations])
318   ;;
319 esac
320
321 # select wide multiplication implementation
322 case $set_widemul in
323 int128)
324   AC_DEFINE(USE_FORCE_WIDEMUL_INT128, 1, [Define this symbol to force the use of the (unsigned) __int128 based wide multiplication implementation])
325   ;;
326 int64)
327   AC_DEFINE(USE_FORCE_WIDEMUL_INT64, 1, [Define this symbol to force the use of the (u)int64_t based wide multiplication implementation])
328   ;;
329 auto)
330   ;;
331 *)
332   AC_MSG_ERROR([invalid wide multiplication implementation])
333   ;;
334 esac
335
336 # select bignum implementation
337 case $set_bignum in
338 gmp)
339   AC_DEFINE(HAVE_LIBGMP, 1, [Define this symbol if libgmp is installed])
340   AC_DEFINE(USE_NUM_GMP, 1, [Define this symbol to use the gmp implementation for num])
341   AC_DEFINE(USE_FIELD_INV_NUM, 1, [Define this symbol to use the num-based field inverse implementation])
342   AC_DEFINE(USE_SCALAR_INV_NUM, 1, [Define this symbol to use the num-based scalar inverse implementation])
343   ;;
344 no)
345   AC_DEFINE(USE_NUM_NONE, 1, [Define this symbol to use no num implementation])
346   AC_DEFINE(USE_FIELD_INV_BUILTIN, 1, [Define this symbol to use the native field inverse implementation])
347   AC_DEFINE(USE_SCALAR_INV_BUILTIN, 1, [Define this symbol to use the native scalar inverse implementation])
348   ;;
349 *)
350   AC_MSG_ERROR([invalid bignum implementation])
351   ;;
352 esac
353
354 #set ecmult window size
355 if test x"$req_ecmult_window" = x"auto"; then
356   set_ecmult_window=15
357 else
358   set_ecmult_window=$req_ecmult_window
359 fi
360
361 error_window_size=['window size for ecmult precomputation not an integer in range [2..24] or "auto"']
362 case $set_ecmult_window in
363 ''|*[[!0-9]]*)
364   # no valid integer
365   AC_MSG_ERROR($error_window_size)
366   ;;
367 *)
368   if test "$set_ecmult_window" -lt 2 -o "$set_ecmult_window" -gt 24 ; then
369     # not in range
370     AC_MSG_ERROR($error_window_size)
371   fi
372   AC_DEFINE_UNQUOTED(ECMULT_WINDOW_SIZE, $set_ecmult_window, [Set window size for ecmult precomputation])
373   ;;
374 esac
375
376 #set ecmult gen precision
377 if test x"$req_ecmult_gen_precision" = x"auto"; then
378   set_ecmult_gen_precision=4
379 else
380   set_ecmult_gen_precision=$req_ecmult_gen_precision
381 fi
382
383 case $set_ecmult_gen_precision in
384 2|4|8)
385   AC_DEFINE_UNQUOTED(ECMULT_GEN_PREC_BITS, $set_ecmult_gen_precision, [Set ecmult gen precision bits])
386   ;;
387 *)
388   AC_MSG_ERROR(['ecmult gen precision not 2, 4, 8 or "auto"'])
389   ;;
390 esac
391
392 if test x"$use_tests" = x"yes"; then
393   SECP_OPENSSL_CHECK
394   if test x"$has_openssl_ec" = x"yes"; then
395     if test x"$enable_openssl_tests" != x"no"; then
396       AC_DEFINE(ENABLE_OPENSSL_TESTS, 1, [Define this symbol if OpenSSL EC functions are available])
397       SECP_TEST_INCLUDES="$SSL_CFLAGS $CRYPTO_CFLAGS $CRYPTO_CPPFLAGS"
398       SECP_TEST_LIBS="$CRYPTO_LIBS"
399
400       case $host in
401       *mingw*)
402         SECP_TEST_LIBS="$SECP_TEST_LIBS -lgdi32"
403         ;;
404       esac
405     fi
406   else
407     if test x"$enable_openssl_tests" = x"yes"; then
408       AC_MSG_ERROR([OpenSSL tests requested but OpenSSL with EC support is not available])
409     fi
410   fi
411 else
412   if test x"$enable_openssl_tests" = x"yes"; then
413     AC_MSG_ERROR([OpenSSL tests requested but tests are not enabled])
414   fi
415 fi
416
417 if test x"$set_bignum" = x"gmp"; then
418   SECP_LIBS="$SECP_LIBS $GMP_LIBS"
419   SECP_INCLUDES="$SECP_INCLUDES $GMP_CPPFLAGS"
420 fi
421
422 if test x"$use_endomorphism" = x"yes"; then
423   AC_DEFINE(USE_ENDOMORPHISM, 1, [Define this symbol to use endomorphism optimization])
424 fi
425
426 if test x"$set_precomp" = x"yes"; then
427   AC_DEFINE(USE_ECMULT_STATIC_PRECOMPUTATION, 1, [Define this symbol to use a statically generated ecmult table])
428 fi
429
430 if test x"$enable_module_ecdh" = x"yes"; then
431   AC_DEFINE(ENABLE_MODULE_ECDH, 1, [Define this symbol to enable the ECDH module])
432 fi
433
434 if test x"$enable_module_recovery" = x"yes"; then
435   AC_DEFINE(ENABLE_MODULE_RECOVERY, 1, [Define this symbol to enable the ECDSA pubkey recovery module])
436 fi
437
438 AC_C_BIGENDIAN()
439
440 if test x"$use_external_asm" = x"yes"; then
441   AC_DEFINE(USE_EXTERNAL_ASM, 1, [Define this symbol if an external (non-inline) assembly implementation is used])
442 fi
443
444 if test x"$use_external_default_callbacks" = x"yes"; then
445   AC_DEFINE(USE_EXTERNAL_DEFAULT_CALLBACKS, 1, [Define this symbol if an external implementation of the default callbacks is used])
446 fi
447
448 if test x"$enable_experimental" = x"yes"; then
449   AC_MSG_NOTICE([******])
450   AC_MSG_NOTICE([WARNING: experimental build])
451   AC_MSG_NOTICE([Experimental features do not have stable APIs or properties, and may not be safe for production use.])
452   AC_MSG_NOTICE([Building ECDH module: $enable_module_ecdh])
453   AC_MSG_NOTICE([******])
454 else
455   if test x"$enable_module_ecdh" = x"yes"; then
456     AC_MSG_ERROR([ECDH module is experimental. Use --enable-experimental to allow.])
457   fi
458   if test x"$set_asm" = x"arm"; then
459     AC_MSG_ERROR([ARM assembly optimization is experimental. Use --enable-experimental to allow.])
460   fi
461 fi
462
463 AC_CONFIG_HEADERS([src/libsecp256k1-config.h])
464 AC_CONFIG_FILES([Makefile libsecp256k1.pc])
465 AC_SUBST(SECP_INCLUDES)
466 AC_SUBST(SECP_LIBS)
467 AC_SUBST(SECP_TEST_LIBS)
468 AC_SUBST(SECP_TEST_INCLUDES)
469 AM_CONDITIONAL([ENABLE_COVERAGE], [test x"$enable_coverage" = x"yes"])
470 AM_CONDITIONAL([USE_TESTS], [test x"$use_tests" != x"no"])
471 AM_CONDITIONAL([USE_EXHAUSTIVE_TESTS], [test x"$use_exhaustive_tests" != x"no"])
472 AM_CONDITIONAL([USE_BENCHMARK], [test x"$use_benchmark" = x"yes"])
473 AM_CONDITIONAL([USE_ECMULT_STATIC_PRECOMPUTATION], [test x"$set_precomp" = x"yes"])
474 AM_CONDITIONAL([ENABLE_MODULE_ECDH], [test x"$enable_module_ecdh" = x"yes"])
475 AM_CONDITIONAL([ENABLE_MODULE_RECOVERY], [test x"$enable_module_recovery" = x"yes"])
476 AM_CONDITIONAL([USE_EXTERNAL_ASM], [test x"$use_external_asm" = x"yes"])
477 AM_CONDITIONAL([USE_ASM_ARM], [test x"$set_asm" = x"arm"])
478
479 dnl make sure nothing new is exported so that we don't break the cache
480 PKGCONFIG_PATH_TEMP="$PKG_CONFIG_PATH"
481 unset PKG_CONFIG_PATH
482 PKG_CONFIG_PATH="$PKGCONFIG_PATH_TEMP"
483
484 AC_OUTPUT
485
486 echo
487 echo "Build Options:"
488 echo "  with endomorphism       = $use_endomorphism"
489 echo "  with ecmult precomp     = $set_precomp"
490 echo "  with external callbacks = $use_external_default_callbacks"
491 echo "  with benchmarks         = $use_benchmark"
492 echo "  with coverage           = $enable_coverage"
493 echo "  module ecdh             = $enable_module_ecdh"
494 echo "  module recovery         = $enable_module_recovery"
495 echo
496 echo "  asm                     = $set_asm"
497 echo "  bignum                  = $set_bignum"
498 echo "  ecmult window size      = $set_ecmult_window"
499 echo "  ecmult gen prec. bits   = $set_ecmult_gen_precision"
500 dnl Hide test-only options unless they're used.
501 if test x"$set_widemul" != xauto; then
502 echo "  wide multiplication     = $set_widemul"
503 fi
504 echo
505 echo "  valgrind                = $enable_valgrind"
506 echo "  CC                      = $CC"
507 echo "  CFLAGS                  = $CFLAGS"
508 echo "  CPPFLAGS                = $CPPFLAGS"
509 echo "  LDFLAGS                 = $LDFLAGS"
510 echo
This page took 0.051549 seconds and 4 git commands to generate.