Check for compiler SSE4.1 support in PCLMUL CRC code.
[libgcrypt.git] / configure.ac
1 # Configure.ac script for Libgcrypt
2 # Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006,
3 #               2007, 2008, 2009, 2011 Free Software Foundation, Inc.
4 # Copyright (C) 2012, 2013, 2014, 2015, 2016  g10 Code GmbH
5 #
6 # This file is part of Libgcrypt.
7 #
8 # Libgcrypt is free software; you can redistribute it and/or modify
9 # it under the terms of the GNU Lesser General Public License as
10 # published by the Free Software Foundation; either version 2.1 of
11 # the License, or (at your option) any later version.
12 #
13 # Libgcrypt is distributed in the hope that it will be useful,
14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 # GNU Lesser General Public License for more details.
17 #
18 # You should have received a copy of the GNU Lesser General Public
19 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
20
21 # (Process this file with autoconf to produce a configure script.)
22 AC_REVISION($Revision$)
23 AC_PREREQ(2.60)
24 min_automake_version="1.14"
25
26 # To build a release you need to create a tag with the version number
27 # (git tag -s libgcrypt-n.m.k) and run "./autogen.sh --force".  Please
28 # bump the version number immediately after the release and do another
29 # commit and push so that the git magic is able to work.  See below
30 # for the LT versions.
31 m4_define(mym4_version_major, [1])
32 m4_define(mym4_version_minor, [7])
33 m4_define(mym4_version_micro, [1])
34
35 # Below is m4 magic to extract and compute the revision number, the
36 # decimalized short revision number, a beta version string, and a flag
37 # indicating a development version (mym4_isgit). Note that the m4
38 # processing is done by autoconf and not during the configure run.
39 m4_define(mym4_version,
40           [mym4_version_major.mym4_version_minor.mym4_version_micro])
41 m4_define([mym4_revision],
42           m4_esyscmd([git rev-parse --short HEAD | tr -d '\n\r']))
43 m4_define([mym4_revision_dec],
44           m4_esyscmd_s([echo $((0x$(echo ]mym4_revision[|head -c 4)))]))
45 m4_define([mym4_betastring],
46           m4_esyscmd_s([git describe --match 'libgcrypt-[0-9].*[0-9]' --long|\
47                         awk -F- '$3!=0{print"-beta"$3}']))
48 m4_define([mym4_isgit],m4_if(mym4_betastring,[],[no],[yes]))
49 m4_define([mym4_full_version],[mym4_version[]mym4_betastring])
50
51 AC_INIT([libgcrypt],[mym4_full_version],[http://bugs.gnupg.org])
52
53 # LT Version numbers, remember to change them just *before* a release.
54 #   (Interfaces removed:    CURRENT++, AGE=0, REVISION=0)
55 #   (Interfaces added:      CURRENT++, AGE++, REVISION=0)
56 #   (No interfaces changed:                   REVISION++)
57 LIBGCRYPT_LT_CURRENT=21
58 LIBGCRYPT_LT_AGE=1
59 LIBGCRYPT_LT_REVISION=0
60
61
62 # If the API is changed in an incompatible way: increment the next counter.
63 #
64 # 1.6: ABI and API change but the change is to most users irrelevant
65 #      and thus the API version number has not been incremented.
66 LIBGCRYPT_CONFIG_API_VERSION=1
67
68 # If you change the required gpg-error version, please remove
69 # unnecessary error code defines in src/gcrypt-int.h.
70 NEED_GPG_ERROR_VERSION=1.13
71
72 PACKAGE=$PACKAGE_NAME
73 VERSION=$PACKAGE_VERSION
74
75 AC_CONFIG_AUX_DIR([build-aux])
76 AC_CONFIG_SRCDIR([src/libgcrypt.vers])
77 AM_INIT_AUTOMAKE([serial-tests dist-bzip2])
78 AC_CONFIG_HEADER(config.h)
79 AC_CONFIG_MACRO_DIR([m4])
80 AC_CONFIG_LIBOBJ_DIR([compat])
81 AC_CANONICAL_HOST
82 AM_MAINTAINER_MODE
83 AM_SILENT_RULES
84
85 AC_ARG_VAR(SYSROOT,[locate config scripts also below that directory])
86
87 AH_TOP([
88 #ifndef _GCRYPT_CONFIG_H_INCLUDED
89 #define _GCRYPT_CONFIG_H_INCLUDED
90
91 /* Enable gpg-error's strerror macro for W32CE.  */
92 #define GPG_ERR_ENABLE_ERRNO_MACROS 1
93 ])
94
95 AH_BOTTOM([
96 #define _GCRYPT_IN_LIBGCRYPT 1
97
98 /* If the configure check for endianness has been disabled, get it from
99    OS macros.  This is intended for making fat binary builds on OS X.  */
100 #ifdef DISABLED_ENDIAN_CHECK
101 # if defined(__BIG_ENDIAN__)
102 #  define WORDS_BIGENDIAN 1
103 # elif defined(__LITTLE_ENDIAN__)
104 #  undef WORDS_BIGENDIAN
105 # else
106 #  error "No endianness found"
107 # endif
108 #endif /*DISABLED_ENDIAN_CHECK*/
109
110 /* We basically use the original Camellia source.  Make sure the symbols
111    properly prefixed.  */
112 #define CAMELLIA_EXT_SYM_PREFIX _gcry_
113
114 #endif /*_GCRYPT_CONFIG_H_INCLUDED*/
115 ])
116
117 AH_VERBATIM([_REENTRANT],
118 [/* To allow the use of Libgcrypt in multithreaded programs we have to use
119     special features from the library. */
120 #ifndef _REENTRANT
121 # define _REENTRANT 1
122 #endif
123 ])
124
125
126 AC_SUBST(LIBGCRYPT_LT_CURRENT)
127 AC_SUBST(LIBGCRYPT_LT_AGE)
128 AC_SUBST(LIBGCRYPT_LT_REVISION)
129 AC_SUBST(PACKAGE)
130 AC_SUBST(VERSION)
131 AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of this package])
132 AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version of this package])
133 VERSION_NUMBER=m4_esyscmd(printf "0x%02x%02x%02x" mym4_version_major \
134                           mym4_version_minor mym4_version_micro)
135 AC_SUBST(VERSION_NUMBER)
136
137
138 ######################
139 ##  Basic checks.  ### (we need some results later on (e.g. $GCC)
140 ######################
141
142 AC_PROG_MAKE_SET
143 missing_dir=`cd $ac_aux_dir && pwd`
144 AM_MISSING_PROG(ACLOCAL, aclocal, $missing_dir)
145 AM_MISSING_PROG(AUTOCONF, autoconf, $missing_dir)
146 AM_MISSING_PROG(AUTOMAKE, automake, $missing_dir)
147 AM_MISSING_PROG(AUTOHEADER, autoheader, $missing_dir)
148 # AM_MISSING_PROG(MAKEINFO, makeinfo, $missing_dir)
149 AC_PROG_CC
150 AC_PROG_CPP
151 AM_PROG_CC_C_O
152 AM_PROG_AS
153 AC_ISC_POSIX
154 AC_PROG_INSTALL
155 AC_PROG_AWK
156
157 AC_GNU_SOURCE
158
159 # We need to compile and run a program on the build machine.  A
160 # comment in libgpg-error says that the AC_PROG_CC_FOR_BUILD macro in
161 # the AC archive is broken for autoconf 2.57.  Given that there is no
162 # newer version of that macro, we assume that it is also broken for
163 # autoconf 2.61 and thus we use a simple but usually sufficient
164 # approach.
165 AC_MSG_CHECKING(for cc for build)
166 if test "$cross_compiling" = "yes"; then
167   CC_FOR_BUILD="${CC_FOR_BUILD-cc}"
168 else
169   CC_FOR_BUILD="${CC_FOR_BUILD-$CC}"
170 fi
171 AC_MSG_RESULT($CC_FOR_BUILD)
172 AC_ARG_VAR(CC_FOR_BUILD,[build system C compiler])
173
174
175 LT_PREREQ([2.2.6])
176 LT_INIT([win32-dll disable-static])
177 LT_LANG([Windows Resource])
178
179
180 ##########################
181 ## General definitions. ##
182 ##########################
183
184 # Used by libgcrypt-config
185 LIBGCRYPT_CONFIG_LIBS="-lgcrypt"
186 LIBGCRYPT_CONFIG_CFLAGS=""
187 LIBGCRYPT_CONFIG_HOST="$host"
188
189 # Definitions for symmetric ciphers.
190 available_ciphers="arcfour blowfish cast5 des aes twofish serpent rfc2268 seed"
191 available_ciphers="$available_ciphers camellia idea salsa20 gost28147 chacha20"
192 enabled_ciphers=""
193
194 # Definitions for public-key ciphers.
195 available_pubkey_ciphers="dsa elgamal rsa ecc"
196 enabled_pubkey_ciphers=""
197
198 # Definitions for message digests.
199 available_digests="crc gostr3411-94 md2 md4 md5 rmd160 sha1 sha256"
200 available_digests="$available_digests sha512 sha3 tiger whirlpool stribog"
201 enabled_digests=""
202
203 # Definitions for kdfs (optional ones)
204 available_kdfs="s2k pkdf2 scrypt"
205 enabled_kdfs=""
206
207 # Definitions for random modules.
208 available_random_modules="linux egd unix"
209 auto_random_modules="$available_random_modules"
210
211 # Supported thread backends.
212 LIBGCRYPT_THREAD_MODULES=""
213
214 # Other definitions.
215 print_egd_notice=no
216 have_w32_system=no
217 have_w32ce_system=no
218 have_pthread=no
219
220
221 # Setup some stuff depending on host.
222 case "${host}" in
223     *-*-mingw32*)
224       ac_cv_have_dev_random=no
225       have_w32_system=yes
226       case "${host}" in
227         *-mingw32ce*)
228             have_w32ce_system=yes
229             available_random_modules="w32ce"
230             ;;
231         *)
232             available_random_modules="w32"
233             ;;
234       esac
235       AC_DEFINE(USE_ONLY_8DOT3,1,
236                 [set this to limit filenames to the 8.3 format])
237       AC_DEFINE(HAVE_DRIVE_LETTERS,1,
238                 [defined if we must run on a stupid file system])
239       AC_DEFINE(HAVE_DOSISH_SYSTEM,1,
240                 [defined if we run on some of the PCDOS like systems
241                  (DOS, Windoze. OS/2) with special properties like
242                   no file modes])
243       ;;
244
245     i?86-emx-os2 | i?86-*-os2*emx)
246         # OS/2 with the EMX environment
247         ac_cv_have_dev_random=no
248         AC_DEFINE(HAVE_DRIVE_LETTERS)
249         AC_DEFINE(HAVE_DOSISH_SYSTEM)
250         ;;
251
252     i?86-*-msdosdjgpp*)
253         # DOS with the DJGPP environment
254         ac_cv_have_dev_random=no
255         AC_DEFINE(HAVE_DRIVE_LETTERS)
256         AC_DEFINE(HAVE_DOSISH_SYSTEM)
257         ;;
258
259     *-*-hpux*)
260         if test -z "$GCC" ; then
261             CFLAGS="$CFLAGS -Ae -D_HPUX_SOURCE"
262         fi
263         ;;
264     *-dec-osf4*)
265         if test -z "$GCC" ; then
266             # Suppress all warnings
267             # to get rid of the unsigned/signed char mismatch warnings.
268             CFLAGS="$CFLAGS -w"
269         fi
270         ;;
271     m68k-atari-mint)
272         ;;
273     *)
274       ;;
275 esac
276
277 if test "$have_w32_system" = yes; then
278    AC_DEFINE(HAVE_W32_SYSTEM,1, [Defined if we run on a W32 API based system])
279    if test "$have_w32ce_system" = yes; then
280      AC_DEFINE(HAVE_W32CE_SYSTEM,1,[Defined if we run on WindowsCE])
281    fi
282 fi
283 AM_CONDITIONAL(HAVE_W32_SYSTEM, test "$have_w32_system" = yes)
284 AM_CONDITIONAL(HAVE_W32CE_SYSTEM, test "$have_w32ce_system" = yes)
285
286
287
288 # A printable OS Name is sometimes useful.
289 case "${host}" in
290     *-*-mingw32ce*)
291         PRINTABLE_OS_NAME="W32CE"
292         ;;
293
294     *-*-mingw32*)
295         PRINTABLE_OS_NAME="W32"
296         ;;
297
298     i?86-emx-os2 | i?86-*-os2*emx )
299         PRINTABLE_OS_NAME="OS/2"
300         ;;
301
302     i?86-*-msdosdjgpp*)
303         PRINTABLE_OS_NAME="MSDOS/DJGPP"
304         ;;
305
306     *-linux*)
307         PRINTABLE_OS_NAME="GNU/Linux"
308         ;;
309
310     *)
311         PRINTABLE_OS_NAME=`uname -s || echo "Unknown"`
312         ;;
313 esac
314
315 #
316 # Figure out the name of the random device
317 #
318 case "${host}" in
319     *-openbsd*)
320         NAME_OF_DEV_RANDOM="/dev/srandom"
321         NAME_OF_DEV_URANDOM="/dev/urandom"
322         ;;
323
324     *)
325         NAME_OF_DEV_RANDOM="/dev/random"
326         NAME_OF_DEV_URANDOM="/dev/urandom"
327         ;;
328 esac
329
330
331 AC_ARG_ENABLE(endian-check,
332               AC_HELP_STRING([--disable-endian-check],
333               [disable the endian check and trust the OS provided macros]),
334               endiancheck=$enableval,endiancheck=yes)
335 if test x"$endiancheck" = xyes ; then
336   AC_C_BIGENDIAN
337 else
338   AC_DEFINE(DISABLED_ENDIAN_CHECK,1,[configure did not test for endianess])
339 fi
340
341 AC_CHECK_SIZEOF(unsigned short, 2)
342 AC_CHECK_SIZEOF(unsigned int, 4)
343 AC_CHECK_SIZEOF(unsigned long, 4)
344 AC_CHECK_SIZEOF(unsigned long long, 0)
345 AC_CHECK_SIZEOF(void *, 0)
346
347 AC_TYPE_UINTPTR_T
348
349 if test "$ac_cv_sizeof_unsigned_short" = "0" \
350    || test "$ac_cv_sizeof_unsigned_int" = "0" \
351    || test "$ac_cv_sizeof_unsigned_long" = "0"; then
352     AC_MSG_WARN([Hmmm, something is wrong with the sizes - using defaults]);
353 fi
354
355 # Ensure that we have UINT64_C before we bother to check for uint64_t
356 AC_CACHE_CHECK([for UINT64_C],[gnupg_cv_uint64_c_works],
357    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <inttypes.h>]],
358        [[uint64_t foo=UINT64_C(42);]])],
359      gnupg_cv_uint64_c_works=yes,gnupg_cv_uint64_c_works=no))
360 if test "$gnupg_cv_uint64_c_works" = "yes" ; then
361    AC_CHECK_SIZEOF(uint64_t)
362 fi
363
364 # Do we have any 64-bit data types?
365 if test "$ac_cv_sizeof_unsigned_int" != "8" \
366    && test "$ac_cv_sizeof_unsigned_long" != "8" \
367    && test "$ac_cv_sizeof_unsigned_long_long" != "8" \
368    && test "$ac_cv_sizeof_uint64_t" != "8"; then
369     AC_MSG_ERROR([[
370 ***
371 *** No 64-bit integer type available.
372 *** It is not possible to build Libgcrypt on this platform.
373 ***]])
374 fi
375
376
377 # If not specified otherwise, all available algorithms will be
378 # included.
379 default_ciphers="$available_ciphers"
380 default_pubkey_ciphers="$available_pubkey_ciphers"
381 default_digests="$available_digests"
382 default_kdfs="$available_kdfs"
383 # Blacklist MD2 by default
384 default_digests=`echo $default_digests | sed -e 's/md2//g'`
385
386 # Substitutions to set generated files in a Emacs buffer to read-only.
387 AC_SUBST(emacs_local_vars_begin, ['Local Variables:'])
388 AC_SUBST(emacs_local_vars_read_only, ['buffer-read-only: t'])
389 AC_SUBST(emacs_local_vars_end, ['End:'])
390
391 ############################
392 ## Command line switches. ##
393 ############################
394
395 # Implementation of the --enable-ciphers switch.
396 AC_ARG_ENABLE(ciphers,
397               AC_HELP_STRING([--enable-ciphers=ciphers],
398                              [select the symmetric ciphers to include]),
399               [enabled_ciphers=`echo $enableval | tr ',:' '  ' | tr '[A-Z]' '[a-z]'`],
400               [enabled_ciphers=""])
401 if test "x$enabled_ciphers" = "x" \
402    -o "$enabled_ciphers" = "yes"  \
403    -o "$enabled_ciphers" = "no"; then
404    enabled_ciphers=$default_ciphers
405 fi
406 AC_MSG_CHECKING([which symmetric ciphers to include])
407 for cipher in $enabled_ciphers; do
408     LIST_MEMBER($cipher, $available_ciphers)
409     if test "$found" = "0"; then
410        AC_MSG_ERROR([unsupported cipher "$cipher" specified])
411     fi
412 done
413 AC_MSG_RESULT([$enabled_ciphers])
414
415 # Implementation of the --enable-pubkey-ciphers switch.
416 AC_ARG_ENABLE(pubkey-ciphers,
417               AC_HELP_STRING([--enable-pubkey-ciphers=ciphers],
418                              [select the public-key ciphers to include]),
419               [enabled_pubkey_ciphers=`echo $enableval | tr ',:' '  ' | tr '[A-Z]' '[a-z]'`],
420               [enabled_pubkey_ciphers=""])
421 if test "x$enabled_pubkey_ciphers" = "x" \
422    -o "$enabled_pubkey_ciphers" = "yes"  \
423    -o "$enabled_pubkey_ciphers" = "no"; then
424    enabled_pubkey_ciphers=$default_pubkey_ciphers
425 fi
426 AC_MSG_CHECKING([which public-key ciphers to include])
427 for cipher in $enabled_pubkey_ciphers; do
428     LIST_MEMBER($cipher, $available_pubkey_ciphers)
429     if test "$found" = "0"; then
430        AC_MSG_ERROR([unsupported public-key cipher specified])
431     fi
432 done
433 AC_MSG_RESULT([$enabled_pubkey_ciphers])
434
435 # Implementation of the --enable-digests switch.
436 AC_ARG_ENABLE(digests,
437               AC_HELP_STRING([--enable-digests=digests],
438                              [select the message digests to include]),
439               [enabled_digests=`echo $enableval | tr ',:' '  ' | tr '[A-Z]' '[a-z]'`],
440               [enabled_digests=""])
441 if test "x$enabled_digests" = "x" \
442    -o "$enabled_digests" = "yes"  \
443    -o "$enabled_digests" = "no"; then
444    enabled_digests=$default_digests
445 fi
446 AC_MSG_CHECKING([which message digests to include])
447 for digest in $enabled_digests; do
448     LIST_MEMBER($digest, $available_digests)
449     if test "$found" = "0"; then
450        AC_MSG_ERROR([unsupported message digest specified])
451     fi
452 done
453 AC_MSG_RESULT([$enabled_digests])
454
455 # Implementation of the --enable-kdfs switch.
456 AC_ARG_ENABLE(kdfs,
457       AC_HELP_STRING([--enable-kfds=kdfs],
458                      [select the KDFs to include]),
459       [enabled_kdfs=`echo $enableval | tr ',:' '  ' | tr '[A-Z]' '[a-z]'`],
460       [enabled_kdfs=""])
461 if test "x$enabled_kdfs" = "x" \
462    -o "$enabled_kdfs" = "yes"  \
463    -o "$enabled_kdfs" = "no"; then
464    enabled_kdfs=$default_kdfs
465 fi
466 AC_MSG_CHECKING([which key derivation functions to include])
467 for kdf in $enabled_kdfs; do
468     LIST_MEMBER($kdf, $available_kdfs)
469     if test "$found" = "0"; then
470        AC_MSG_ERROR([unsupported key derivation function specified])
471     fi
472 done
473 AC_MSG_RESULT([$enabled_kdfs])
474
475 # Implementation of the --enable-random switch.
476 AC_ARG_ENABLE(random,
477               AC_HELP_STRING([--enable-random=name],
478                              [select which random number generator to use]),
479               [random=`echo $enableval | tr '[A-Z]' '[a-z]'`],
480               [])
481 if test "x$random" = "x" -o "$random" = "yes" -o "$random" = "no"; then
482     random=default
483 fi
484 AC_MSG_CHECKING([which random module to use])
485 if test "$random" != "default" -a "$random" != "auto"; then
486     LIST_MEMBER($random, $available_random_modules)
487     if test "$found" = "0"; then
488        AC_MSG_ERROR([unsupported random module specified])
489     fi
490 fi
491 AC_MSG_RESULT($random)
492
493 # Implementation of the --disable-dev-random switch.
494 AC_MSG_CHECKING([whether use of /dev/random is requested])
495 AC_ARG_ENABLE(dev-random,
496 [  --disable-dev-random    disable the use of dev random],
497     try_dev_random=$enableval, try_dev_random=yes)
498 AC_MSG_RESULT($try_dev_random)
499
500 # Implementation of the --with-egd-socket switch.
501 AC_ARG_WITH(egd-socket,
502     [  --with-egd-socket=NAME  Use NAME for the EGD socket)],
503             egd_socket_name="$withval", egd_socket_name="" )
504 AC_DEFINE_UNQUOTED(EGD_SOCKET_NAME, "$egd_socket_name",
505                    [Define if you don't want the default EGD socket name.
506                     For details see cipher/rndegd.c])
507
508 # Implementation of the --enable-random-daemon
509 AC_MSG_CHECKING([whether the experimental random daemon is requested])
510 AC_ARG_ENABLE([random-daemon],
511               AC_HELP_STRING([--enable-random-daemon],
512                              [Build and support the experimental gcryptrnd]),
513               [use_random_daemon=$enableval],
514               [use_random_daemon=no])
515 AC_MSG_RESULT($use_random_daemon)
516 if test x$use_random_daemon = xyes ; then
517     AC_DEFINE(USE_RANDOM_DAEMON,1,
518               [Define to support the experimental random daemon])
519 fi
520 AM_CONDITIONAL(USE_RANDOM_DAEMON, test x$use_random_daemon = xyes)
521
522
523 # Implementation of --disable-asm.
524 AC_MSG_CHECKING([whether MPI assembler modules are requested])
525 AC_ARG_ENABLE([asm],
526               AC_HELP_STRING([--disable-asm],
527                              [Disable MPI assembler modules]),
528               [try_asm_modules=$enableval],
529               [try_asm_modules=yes])
530 AC_MSG_RESULT($try_asm_modules)
531
532 # Implementation of the --enable-m-guard switch.
533 AC_MSG_CHECKING([whether memory guard is requested])
534 AC_ARG_ENABLE(m-guard,
535               AC_HELP_STRING([--enable-m-guard],
536                              [Enable memory guard facility]),
537               [use_m_guard=$enableval], [use_m_guard=no])
538 AC_MSG_RESULT($use_m_guard)
539 if test "$use_m_guard" = yes ; then
540     AC_DEFINE(M_GUARD,1,[Define to use the (obsolete) malloc guarding feature])
541 fi
542
543 # Implementation of the --enable-large-data-tests switch.
544 AC_MSG_CHECKING([whether to run large data tests])
545 AC_ARG_ENABLE(large-data-tests,
546               AC_HELP_STRING([--enable-large-data-tests],
547                  [Enable the real long ruinning large data tests]),
548               large_data_tests=$enableval,large_data_tests=no)
549 AC_MSG_RESULT($large_data_tests)
550 AC_SUBST(RUN_LARGE_DATA_TESTS, $large_data_tests)
551
552
553 # Implementation of the --with-capabilities switch.
554 # Check whether we want to use Linux capabilities
555 AC_MSG_CHECKING([whether use of capabilities is requested])
556 AC_ARG_WITH(capabilities,
557             AC_HELP_STRING([--with-capabilities],
558                            [Use linux capabilities [default=no]]),
559             [use_capabilities="$withval"],[use_capabilities=no])
560 AC_MSG_RESULT($use_capabilities)
561
562 # Implementation of the --enable-hmac-binary-check.
563 AC_MSG_CHECKING([whether a HMAC binary check is requested])
564 AC_ARG_ENABLE(hmac-binary-check,
565               AC_HELP_STRING([--enable-hmac-binary-check],
566                              [Enable library integrity check]),
567               [use_hmac_binary_check=$enableval],
568               [use_hmac_binary_check=no])
569 AC_MSG_RESULT($use_hmac_binary_check)
570 if test "$use_hmac_binary_check" = yes ; then
571     AC_DEFINE(ENABLE_HMAC_BINARY_CHECK,1,
572               [Define to support an HMAC based integrity check])
573 fi
574
575
576 # Implementation of the --disable-padlock-support switch.
577 AC_MSG_CHECKING([whether padlock support is requested])
578 AC_ARG_ENABLE(padlock-support,
579               AC_HELP_STRING([--disable-padlock-support],
580                  [Disable support for the PadLock Engine of VIA processors]),
581               padlocksupport=$enableval,padlocksupport=yes)
582 AC_MSG_RESULT($padlocksupport)
583
584 # Implementation of the --disable-aesni-support switch.
585 AC_MSG_CHECKING([whether AESNI support is requested])
586 AC_ARG_ENABLE(aesni-support,
587               AC_HELP_STRING([--disable-aesni-support],
588                  [Disable support for the Intel AES-NI instructions]),
589               aesnisupport=$enableval,aesnisupport=yes)
590 AC_MSG_RESULT($aesnisupport)
591
592 # Implementation of the --disable-pclmul-support switch.
593 AC_MSG_CHECKING([whether PCLMUL support is requested])
594 AC_ARG_ENABLE(pclmul-support,
595               AC_HELP_STRING([--disable-pclmul-support],
596                  [Disable support for the Intel PCLMUL instructions]),
597               pclmulsupport=$enableval,pclmulsupport=yes)
598 AC_MSG_RESULT($pclmulsupport)
599
600 # Implementation of the --disable-sse41-support switch.
601 AC_MSG_CHECKING([whether SSE4.1 support is requested])
602 AC_ARG_ENABLE(sse41-support,
603               AC_HELP_STRING([--disable-sse41-support],
604                  [Disable support for the Intel SSE4.1 instructions]),
605               sse41support=$enableval,sse41support=yes)
606 AC_MSG_RESULT($sse41support)
607
608 # Implementation of the --disable-drng-support switch.
609 AC_MSG_CHECKING([whether DRNG support is requested])
610 AC_ARG_ENABLE(drng-support,
611               AC_HELP_STRING([--disable-drng-support],
612                  [Disable support for the Intel DRNG (RDRAND instruction)]),
613               drngsupport=$enableval,drngsupport=yes)
614 AC_MSG_RESULT($drngsupport)
615
616 # Implementation of the --disable-avx-support switch.
617 AC_MSG_CHECKING([whether AVX support is requested])
618 AC_ARG_ENABLE(avx-support,
619               AC_HELP_STRING([--disable-avx-support],
620                  [Disable support for the Intel AVX instructions]),
621               avxsupport=$enableval,avxsupport=yes)
622 AC_MSG_RESULT($avxsupport)
623
624 # Implementation of the --disable-avx2-support switch.
625 AC_MSG_CHECKING([whether AVX2 support is requested])
626 AC_ARG_ENABLE(avx2-support,
627               AC_HELP_STRING([--disable-avx2-support],
628                  [Disable support for the Intel AVX2 instructions]),
629               avx2support=$enableval,avx2support=yes)
630 AC_MSG_RESULT($avx2support)
631
632 # Implementation of the --disable-neon-support switch.
633 AC_MSG_CHECKING([whether NEON support is requested])
634 AC_ARG_ENABLE(neon-support,
635               AC_HELP_STRING([--disable-neon-support],
636                  [Disable support for the ARM NEON instructions]),
637               neonsupport=$enableval,neonsupport=yes)
638 AC_MSG_RESULT($neonsupport)
639
640 # Implementation of the --disable-O-flag-munging switch.
641 AC_MSG_CHECKING([whether a -O flag munging is requested])
642 AC_ARG_ENABLE([O-flag-munging],
643               AC_HELP_STRING([--disable-O-flag-munging],
644                  [Disable modification of the cc -O flag]),
645               [enable_o_flag_munging=$enableval],
646               [enable_o_flag_munging=yes])
647 AC_MSG_RESULT($enable_o_flag_munging)
648 AM_CONDITIONAL(ENABLE_O_FLAG_MUNGING, test "$enable_o_flag_munging" = "yes")
649
650 # Implementation of the --disable-amd64-as-feature-detection switch.
651 AC_MSG_CHECKING([whether to enable AMD64 as(1) feature detection])
652 AC_ARG_ENABLE(amd64-as-feature-detection,
653               AC_HELP_STRING([--disable-amd64-as-feature-detection],
654                  [Disable the auto-detection of AMD64 as(1) features]),
655               amd64_as_feature_detection=$enableval,
656               amd64_as_feature_detection=yes)
657 AC_MSG_RESULT($amd64_as_feature_detection)
658
659
660 AC_DEFINE_UNQUOTED(PRINTABLE_OS_NAME, "$PRINTABLE_OS_NAME",
661                    [A human readable text with the name of the OS])
662
663 # For some systems we know that we have ld_version scripts.
664 # Use it then as default.
665 have_ld_version_script=no
666 case "${host}" in
667     *-*-linux*)
668         have_ld_version_script=yes
669         ;;
670     *-*-gnu*)
671         have_ld_version_script=yes
672         ;;
673 esac
674 AC_ARG_ENABLE([ld-version-script],
675               AC_HELP_STRING([--enable-ld-version-script],
676                              [enable/disable use of linker version script.
677                               (default is system dependent)]),
678               [have_ld_version_script=$enableval],
679               [ : ] )
680 AM_CONDITIONAL(HAVE_LD_VERSION_SCRIPT, test "$have_ld_version_script" = "yes")
681
682 AC_DEFINE_UNQUOTED(NAME_OF_DEV_RANDOM, "$NAME_OF_DEV_RANDOM",
683                    [defined to the name of the strong random device])
684 AC_DEFINE_UNQUOTED(NAME_OF_DEV_URANDOM, "$NAME_OF_DEV_URANDOM",
685                    [defined to the name of the weaker random device])
686
687
688 ###############################
689 #### Checks for libraries. ####
690 ###############################
691
692 #
693 # gpg-error is required.
694 #
695 AM_PATH_GPG_ERROR("$NEED_GPG_ERROR_VERSION")
696 if test "x$GPG_ERROR_LIBS" = "x"; then
697   AC_MSG_ERROR([libgpg-error is needed.
698                 See ftp://ftp.gnupg.org/gcrypt/libgpg-error/ .])
699 fi
700
701 AC_DEFINE(GPG_ERR_SOURCE_DEFAULT, GPG_ERR_SOURCE_GCRYPT,
702           [The default error source for libgcrypt.])
703
704 #
705 # Check whether the GNU Pth library is available.  We require this
706 # to build the optional gcryptrnd program.
707 #
708 AC_ARG_WITH(pth-prefix,
709             AC_HELP_STRING([--with-pth-prefix=PFX],
710                            [prefix where GNU Pth is installed (optional)]),
711      pth_config_prefix="$withval", pth_config_prefix="")
712 if test x$pth_config_prefix != x ; then
713    PTH_CONFIG="$pth_config_prefix/bin/pth-config"
714 fi
715 if test "$use_random_daemon" = "yes"; then
716   AC_PATH_PROG(PTH_CONFIG, pth-config, no)
717   if test "$PTH_CONFIG" = "no"; then
718     AC_MSG_WARN([[
719 ***
720 *** To build the Libgcrypt's random number daemon
721 *** we need the support of the GNU Portable Threads Library.
722 *** Download it from ftp://ftp.gnu.org/gnu/pth/
723 *** On a Debian GNU/Linux system you might want to try
724 ***   apt-get install libpth-dev
725 ***]])
726   else
727     GNUPG_PTH_VERSION_CHECK([1.3.7])
728     if test $have_pth = yes; then
729        PTH_CFLAGS=`$PTH_CONFIG --cflags`
730        PTH_LIBS=`$PTH_CONFIG --ldflags`
731        PTH_LIBS="$PTH_LIBS `$PTH_CONFIG --libs --all`"
732        AC_DEFINE(USE_GNU_PTH, 1,
733                 [Defined if the GNU Portable Thread Library should be used])
734        AC_DEFINE(HAVE_PTH, 1,
735                 [Defined if the GNU Pth is available])
736     fi
737   fi
738 fi
739 AC_SUBST(PTH_CFLAGS)
740 AC_SUBST(PTH_LIBS)
741
742 #
743 # Check whether pthreads is available
744 #
745 if test "$have_w32_system" != yes; then
746   AC_CHECK_LIB(pthread,pthread_create,have_pthread=yes)
747   if test "$have_pthread" = yes; then
748     AC_DEFINE(HAVE_PTHREAD, 1 ,[Define if we have pthread.])
749   fi
750 fi
751
752
753 # Solaris needs -lsocket and -lnsl. Unisys system includes
754 # gethostbyname in libsocket but needs libnsl for socket.
755 AC_SEARCH_LIBS(setsockopt, [socket], ,
756         [AC_SEARCH_LIBS(setsockopt, [socket], , , [-lnsl])])
757 AC_SEARCH_LIBS(setsockopt, [nsl])
758
759 ##################################
760 #### Checks for header files. ####
761 ##################################
762
763 AC_HEADER_STDC
764 AC_CHECK_HEADERS(unistd.h sys/select.h sys/msg.h)
765 INSERT_SYS_SELECT_H=
766 if test x"$ac_cv_header_sys_select_h" = xyes; then
767   INSERT_SYS_SELECT_H=" include <sys/select.h>"
768 fi
769 AC_SUBST(INSERT_SYS_SELECT_H)
770
771
772 ##########################################
773 #### Checks for typedefs, structures, ####
774 ####  and compiler characteristics.   ####
775 ##########################################
776
777 AC_C_CONST
778 AC_C_INLINE
779 AC_TYPE_SIZE_T
780 AC_TYPE_SIGNAL
781 AC_DECL_SYS_SIGLIST
782 AC_TYPE_PID_T
783
784 GNUPG_CHECK_TYPEDEF(byte, HAVE_BYTE_TYPEDEF)
785 GNUPG_CHECK_TYPEDEF(ushort, HAVE_USHORT_TYPEDEF)
786 GNUPG_CHECK_TYPEDEF(ulong, HAVE_ULONG_TYPEDEF)
787 GNUPG_CHECK_TYPEDEF(u16, HAVE_U16_TYPEDEF)
788 GNUPG_CHECK_TYPEDEF(u32, HAVE_U32_TYPEDEF)
789
790 gl_TYPE_SOCKLEN_T
791 case "${host}" in
792   *-*-mingw32*)
793     # socklen_t may or may not be defined depending on what headers
794     # are included.  To be safe we use int as this is the actual type.
795     FALLBACK_SOCKLEN_T="typedef int gcry_socklen_t;"
796     ;;
797   *)
798     if test ".$gl_cv_socklen_t_equiv" = "."; then
799       FALLBACK_SOCKLEN_T="typedef socklen_t gcry_socklen_t;"
800     else
801       FALLBACK_SOCKLEN_T="typedef ${gl_cv_socklen_t_equiv} gcry_socklen_t;"
802     fi
803 esac
804 AC_SUBST(FALLBACK_SOCKLEN_T)
805
806
807 #
808 # Check for __builtin_bswap32 intrinsic.
809 #
810 AC_CACHE_CHECK(for __builtin_bswap32,
811        [gcry_cv_have_builtin_bswap32],
812        [gcry_cv_have_builtin_bswap32=no
813         AC_LINK_IFELSE([AC_LANG_PROGRAM([],
814           [int x = 0; int y = __builtin_bswap32(x); return y;])],
815           [gcry_cv_have_builtin_bswap32=yes])])
816 if test "$gcry_cv_have_builtin_bswap32" = "yes" ; then
817    AC_DEFINE(HAVE_BUILTIN_BSWAP32,1,
818              [Defined if compiler has '__builtin_bswap32' intrinsic])
819 fi
820
821
822 #
823 # Check for __builtin_bswap64 intrinsic.
824 #
825 AC_CACHE_CHECK(for __builtin_bswap64,
826        [gcry_cv_have_builtin_bswap64],
827        [gcry_cv_have_builtin_bswap64=no
828         AC_LINK_IFELSE([AC_LANG_PROGRAM([],
829           [long long x = 0; long long y = __builtin_bswap64(x); return y;])],
830           [gcry_cv_have_builtin_bswap64=yes])])
831 if test "$gcry_cv_have_builtin_bswap64" = "yes" ; then
832    AC_DEFINE(HAVE_BUILTIN_BSWAP64,1,
833              [Defined if compiler has '__builtin_bswap64' intrinsic])
834 fi
835
836
837 #
838 # Check for __builtin_ctz intrinsic.
839 #
840 AC_CACHE_CHECK(for __builtin_ctz,
841        [gcry_cv_have_builtin_ctz],
842        [gcry_cv_have_builtin_ctz=no
843         AC_LINK_IFELSE([AC_LANG_PROGRAM([],
844           [unsigned int x = 0; int y = __builtin_ctz(x); return y;])],
845           [gcry_cv_have_builtin_ctz=yes])])
846 if test "$gcry_cv_have_builtin_ctz" = "yes" ; then
847    AC_DEFINE(HAVE_BUILTIN_CTZ, 1,
848              [Defined if compiler has '__builtin_ctz' intrinsic])
849 fi
850
851
852 #
853 # Check for VLA support (variable length arrays).
854 #
855 AC_CACHE_CHECK(whether the variable length arrays are supported,
856        [gcry_cv_have_vla],
857        [gcry_cv_have_vla=no
858         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
859           [[void f1(char *, int);
860             char foo(int i) {
861               char b[(i < 0 ? 0 : i) + 1];
862               f1(b, sizeof b); return b[0];}]])],
863           [gcry_cv_have_vla=yes])])
864 if test "$gcry_cv_have_vla" = "yes" ; then
865    AC_DEFINE(HAVE_VLA,1, [Defined if variable length arrays are supported])
866 fi
867
868
869 #
870 # Check for ELF visibility support.
871 #
872 AC_CACHE_CHECK(whether the visibility attribute is supported,
873        gcry_cv_visibility_attribute,
874        [gcry_cv_visibility_attribute=no
875         AC_LANG_CONFTEST([AC_LANG_SOURCE(
876           [[int foo __attribute__ ((visibility ("hidden"))) = 1;
877             int bar __attribute__ ((visibility ("protected"))) = 1;
878           ]])])
879
880         if ${CC-cc} -Werror -S conftest.c -o conftest.s \
881                   1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD ; then
882             if grep '\.hidden.*foo' conftest.s >/dev/null 2>&1 ; then
883                 if grep '\.protected.*bar' conftest.s >/dev/null 2>&1; then
884                     gcry_cv_visibility_attribute=yes
885                 fi
886             fi
887         fi
888        ])
889 if test "$gcry_cv_visibility_attribute" = "yes"; then
890     AC_CACHE_CHECK(for broken visibility attribute,
891        gcry_cv_broken_visibility_attribute,
892        [gcry_cv_broken_visibility_attribute=yes
893         AC_LANG_CONFTEST([AC_LANG_SOURCE(
894           [[int foo (int x);
895             int bar (int x) __asm__ ("foo")
896                             __attribute__ ((visibility ("hidden")));
897             int bar (int x) { return x; }
898           ]])])
899
900         if ${CC-cc} -Werror -S conftest.c -o conftest.s \
901                   1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD ; then
902            if grep '\.hidden@<:@        _@:>@foo' conftest.s >/dev/null 2>&1;
903             then
904                gcry_cv_broken_visibility_attribute=no
905            fi
906         fi
907        ])
908 fi
909 if test "$gcry_cv_visibility_attribute" = "yes"; then
910     AC_CACHE_CHECK(for broken alias attribute,
911        gcry_cv_broken_alias_attribute,
912        [gcry_cv_broken_alias_attribute=yes
913         AC_LANG_CONFTEST([AC_LANG_SOURCE(
914           [[extern int foo (int x) __asm ("xyzzy");
915             int bar (int x) { return x; }
916             extern __typeof (bar) foo __attribute ((weak, alias ("bar")));
917             extern int dfoo;
918             extern __typeof (dfoo) dfoo __asm ("abccb");
919             int dfoo = 1;
920           ]])])
921
922         if ${CC-cc} -Werror -S conftest.c -o conftest.s \
923                   1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD ; then
924            if grep 'xyzzy' conftest.s >/dev/null 2>&1 && \
925               grep 'abccb' conftest.s >/dev/null 2>&1; then
926               gcry_cv_broken_alias_attribute=no
927            fi
928         fi
929         ])
930 fi
931 if test "$gcry_cv_visibility_attribute" = "yes"; then
932     AC_CACHE_CHECK(if gcc supports -fvisibility=hidden,
933        gcry_cv_gcc_has_f_visibility,
934        [gcry_cv_gcc_has_f_visibility=no
935         _gcc_cflags_save=$CFLAGS
936         CFLAGS="-fvisibility=hidden"
937         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[])],
938                           gcry_cv_gcc_has_f_visibility=yes)
939         CFLAGS=$_gcc_cflags_save;
940        ])
941 fi
942 if test "$gcry_cv_visibility_attribute" = "yes" \
943    && test "$gcry_cv_broken_visibility_attribute" != "yes" \
944    && test "$gcry_cv_broken_alias_attribute" != "yes" \
945    && test "$gcry_cv_gcc_has_f_visibility" = "yes"
946  then
947    AC_DEFINE(GCRY_USE_VISIBILITY, 1,
948                [Define to use the GNU C visibility attribute.])
949    CFLAGS="$CFLAGS -fvisibility=hidden"
950 fi
951
952
953 #
954 # Check whether the compiler supports the GCC style aligned attribute
955 #
956 AC_CACHE_CHECK([whether the GCC style aligned attribute is supported],
957        [gcry_cv_gcc_attribute_aligned],
958        [gcry_cv_gcc_attribute_aligned=no
959         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
960           [[struct { int a; } foo __attribute__ ((aligned (16)));]])],
961           [gcry_cv_gcc_attribute_aligned=yes])])
962 if test "$gcry_cv_gcc_attribute_aligned" = "yes" ; then
963    AC_DEFINE(HAVE_GCC_ATTRIBUTE_ALIGNED,1,
964      [Defined if a GCC style "__attribute__ ((aligned (n))" is supported])
965 fi
966
967
968 #
969 # Check whether the compiler supports the GCC style packed attribute
970 #
971 AC_CACHE_CHECK([whether the GCC style packed attribute is supported],
972        [gcry_cv_gcc_attribute_packed],
973        [gcry_cv_gcc_attribute_packed=no
974         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
975           [[struct foolong_s { long b; } __attribute__ ((packed));
976             struct foo_s { char a; struct foolong_s b; }
977               __attribute__ ((packed));
978             enum bar {
979               FOO = 1 / (sizeof(struct foo_s) == (sizeof(char) + sizeof(long))),
980             };]])],
981           [gcry_cv_gcc_attribute_packed=yes])])
982 if test "$gcry_cv_gcc_attribute_packed" = "yes" ; then
983    AC_DEFINE(HAVE_GCC_ATTRIBUTE_PACKED,1,
984      [Defined if a GCC style "__attribute__ ((packed))" is supported])
985 fi
986
987
988 #
989 # Check whether the compiler supports 'asm' or '__asm__' keyword for
990 # assembler blocks.
991 #
992 AC_CACHE_CHECK([whether 'asm' assembler keyword is supported],
993        [gcry_cv_have_asm],
994        [gcry_cv_have_asm=no
995         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
996           [[void a(void) { asm("":::"memory"); }]])],
997           [gcry_cv_have_asm=yes])])
998 AC_CACHE_CHECK([whether '__asm__' assembler keyword is supported],
999        [gcry_cv_have___asm__],
1000        [gcry_cv_have___asm__=no
1001         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1002           [[void a(void) { __asm__("":::"memory"); }]])],
1003           [gcry_cv_have___asm__=yes])])
1004 if test "$gcry_cv_have_asm" = "no" ; then
1005    if test "$gcry_cv_have___asm__" = "yes" ; then
1006       AC_DEFINE(asm,__asm__,
1007         [Define to supported assembler block keyword, if plain 'asm' was not
1008          supported])
1009    fi
1010 fi
1011
1012
1013 #
1014 # Check whether the compiler supports inline assembly memory barrier.
1015 #
1016 if test "$gcry_cv_have_asm" = "no" ; then
1017    if test "$gcry_cv_have___asm__" = "yes" ; then
1018       AC_CACHE_CHECK([whether inline assembly memory barrier is supported],
1019           [gcry_cv_have_asm_volatile_memory],
1020           [gcry_cv_have_asm_volatile_memory=no
1021            AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1022              [[void a(void) { __asm__ volatile("":::"memory"); }]])],
1023              [gcry_cv_have_asm_volatile_memory=yes])])
1024    fi
1025 else
1026    AC_CACHE_CHECK([whether inline assembly memory barrier is supported],
1027        [gcry_cv_have_asm_volatile_memory],
1028        [gcry_cv_have_asm_volatile_memory=no
1029         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1030           [[void a(void) { asm volatile("":::"memory"); }]])],
1031           [gcry_cv_have_asm_volatile_memory=yes])])
1032 fi
1033 if test "$gcry_cv_have_asm_volatile_memory" = "yes" ; then
1034    AC_DEFINE(HAVE_GCC_ASM_VOLATILE_MEMORY,1,
1035      [Define if inline asm memory barrier is supported])
1036 fi
1037
1038
1039 #
1040 # Check whether GCC assembler supports features needed for our ARM
1041 # implementations.  This needs to be done before setting up the
1042 # assembler stuff.
1043 #
1044 AC_CACHE_CHECK([whether GCC assembler is compatible for ARM assembly implementations],
1045        [gcry_cv_gcc_arm_platform_as_ok],
1046        [gcry_cv_gcc_arm_platform_as_ok=no
1047         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1048           [[__asm__(
1049                 /* Test if assembler supports UAL syntax.  */
1050                 ".syntax unified\n\t"
1051                 ".arm\n\t" /* our assembly code is in ARM mode  */
1052                 /* Following causes error if assembler ignored '.syntax unified'.  */
1053                 "asmfunc:\n\t"
1054                 "add %r0, %r0, %r4, ror #12;\n\t"
1055
1056                 /* Test if '.type' and '.size' are supported.  */
1057                 ".size asmfunc,.-asmfunc;\n\t"
1058                 ".type asmfunc,%function;\n\t"
1059             );]])],
1060           [gcry_cv_gcc_arm_platform_as_ok=yes])])
1061 if test "$gcry_cv_gcc_arm_platform_as_ok" = "yes" ; then
1062    AC_DEFINE(HAVE_COMPATIBLE_GCC_ARM_PLATFORM_AS,1,
1063      [Defined if underlying assembler is compatible with ARM assembly implementations])
1064 fi
1065
1066
1067 #
1068 # Check whether underscores in symbols are required.  This needs to be
1069 # done before setting up the assembler stuff.
1070 #
1071 GNUPG_SYS_SYMBOL_UNDERSCORE()
1072
1073
1074 #################################
1075 ####                         ####
1076 #### Setup assembler stuff.  ####
1077 #### Define mpi_cpu_arch.    ####
1078 ####                         ####
1079 #################################
1080 AC_ARG_ENABLE(mpi-path,
1081               AC_HELP_STRING([--enable-mpi-path=EXTRA_PATH],
1082               [prepend EXTRA_PATH to list of CPU specific optimizations]),
1083               mpi_extra_path="$enableval",mpi_extra_path="")
1084 AC_MSG_CHECKING(architecture and mpi assembler functions)
1085 if test -f $srcdir/mpi/config.links ; then
1086     . $srcdir/mpi/config.links
1087     AC_CONFIG_LINKS("$mpi_ln_list")
1088     ac_cv_mpi_sflags="$mpi_sflags"
1089     AC_MSG_RESULT($mpi_cpu_arch)
1090 else
1091     AC_MSG_RESULT(failed)
1092     AC_MSG_ERROR([mpi/config.links missing!])
1093 fi
1094 MPI_SFLAGS="$ac_cv_mpi_sflags"
1095 AC_SUBST(MPI_SFLAGS)
1096
1097 AM_CONDITIONAL(MPI_MOD_ASM_MPIH_ADD1, test "$mpi_mod_asm_mpih_add1" = yes)
1098 AM_CONDITIONAL(MPI_MOD_ASM_MPIH_SUB1, test "$mpi_mod_asm_mpih_sub1" = yes)
1099 AM_CONDITIONAL(MPI_MOD_ASM_MPIH_MUL1, test "$mpi_mod_asm_mpih_mul1" = yes)
1100 AM_CONDITIONAL(MPI_MOD_ASM_MPIH_MUL2, test "$mpi_mod_asm_mpih_mul2" = yes)
1101 AM_CONDITIONAL(MPI_MOD_ASM_MPIH_MUL3, test "$mpi_mod_asm_mpih_mul3" = yes)
1102 AM_CONDITIONAL(MPI_MOD_ASM_MPIH_LSHIFT, test "$mpi_mod_asm_mpih_lshift" = yes)
1103 AM_CONDITIONAL(MPI_MOD_ASM_MPIH_RSHIFT, test "$mpi_mod_asm_mpih_rshift" = yes)
1104 AM_CONDITIONAL(MPI_MOD_ASM_UDIV, test "$mpi_mod_asm_udiv" = yes)
1105 AM_CONDITIONAL(MPI_MOD_ASM_UDIV_QRNND, test "$mpi_mod_asm_udiv_qrnnd" = yes)
1106 AM_CONDITIONAL(MPI_MOD_C_MPIH_ADD1, test "$mpi_mod_c_mpih_add1" = yes)
1107 AM_CONDITIONAL(MPI_MOD_C_MPIH_SUB1, test "$mpi_mod_c_mpih_sub1" = yes)
1108 AM_CONDITIONAL(MPI_MOD_C_MPIH_MUL1, test "$mpi_mod_c_mpih_mul1" = yes)
1109 AM_CONDITIONAL(MPI_MOD_C_MPIH_MUL2, test "$mpi_mod_c_mpih_mul2" = yes)
1110 AM_CONDITIONAL(MPI_MOD_C_MPIH_MUL3, test "$mpi_mod_c_mpih_mul3" = yes)
1111 AM_CONDITIONAL(MPI_MOD_C_MPIH_LSHIFT, test "$mpi_mod_c_mpih_lshift" = yes)
1112 AM_CONDITIONAL(MPI_MOD_C_MPIH_RSHIFT, test "$mpi_mod_c_mpih_rshift" = yes)
1113 AM_CONDITIONAL(MPI_MOD_C_UDIV, test "$mpi_mod_c_udiv" = yes)
1114 AM_CONDITIONAL(MPI_MOD_C_UDIV_QRNND, test "$mpi_mod_c_udiv_qrnnd" = yes)
1115
1116 # Reset non applicable feature flags.
1117 if test "$mpi_cpu_arch" != "x86" ; then
1118    aesnisupport="n/a"
1119    pclmulsupport="n/a"
1120    sse41support="n/a"
1121    avxsupport="n/a"
1122    avx2support="n/a"
1123    padlocksupport="n/a"
1124    drngsupport="n/a"
1125 fi
1126
1127 if test "$mpi_cpu_arch" != "arm" ; then
1128    neonsupport="n/a"
1129 fi
1130
1131
1132 #############################################
1133 ####                                     ####
1134 #### Platform specific compiler checks.  ####
1135 ####                                     ####
1136 #############################################
1137
1138
1139 # Following tests depend on warnings to cause compile to fail, so set -Werror
1140 # temporarily.
1141 _gcc_cflags_save=$CFLAGS
1142 CFLAGS="$CFLAGS -Werror"
1143
1144
1145 #
1146 # Check whether compiler supports 'ms_abi' function attribute.
1147 #
1148 AC_CACHE_CHECK([whether compiler supports 'ms_abi' function attribute],
1149        [gcry_cv_gcc_attribute_ms_abi],
1150        [gcry_cv_gcc_attribute_ms_abi=no
1151         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1152           [[int __attribute__ ((ms_abi)) proto(int);]])],
1153           [gcry_cv_gcc_attribute_ms_abi=yes])])
1154 if test "$gcry_cv_gcc_attribute_ms_abi" = "yes" ; then
1155    AC_DEFINE(HAVE_GCC_ATTRIBUTE_MS_ABI,1,
1156      [Defined if compiler supports "__attribute__ ((ms_abi))" function attribute])
1157 fi
1158
1159
1160 #
1161 # Check whether compiler supports 'sysv_abi' function attribute.
1162 #
1163 AC_CACHE_CHECK([whether compiler supports 'sysv_abi' function attribute],
1164        [gcry_cv_gcc_attribute_sysv_abi],
1165        [gcry_cv_gcc_attribute_sysv_abi=no
1166         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1167           [[int __attribute__ ((sysv_abi)) proto(int);]])],
1168           [gcry_cv_gcc_attribute_sysv_abi=yes])])
1169 if test "$gcry_cv_gcc_attribute_sysv_abi" = "yes" ; then
1170    AC_DEFINE(HAVE_GCC_ATTRIBUTE_SYSV_ABI,1,
1171      [Defined if compiler supports "__attribute__ ((sysv_abi))" function attribute])
1172 fi
1173
1174
1175 #
1176 # Check whether default calling convention is 'ms_abi'.
1177 #
1178 if test "$gcry_cv_gcc_attribute_ms_abi" = "yes" ; then
1179    AC_CACHE_CHECK([whether default calling convention is 'ms_abi'],
1180           [gcry_cv_gcc_default_abi_is_ms_abi],
1181           [gcry_cv_gcc_default_abi_is_ms_abi=no
1182            AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1183              [[void *test(void) {
1184                  void *(*def_func)(void) = test;
1185                  void *__attribute__((ms_abi))(*msabi_func)(void);
1186                  /* warning on SysV abi targets, passes on Windows based targets */
1187                  msabi_func = def_func;
1188                  return msabi_func;
1189              }]])],
1190              [gcry_cv_gcc_default_abi_is_ms_abi=yes])])
1191    if test "$gcry_cv_gcc_default_abi_is_ms_abi" = "yes" ; then
1192       AC_DEFINE(HAVE_GCC_DEFAULT_ABI_IS_MS_ABI,1,
1193         [Defined if default calling convention is 'ms_abi'])
1194    fi
1195 fi
1196
1197
1198 #
1199 # Check whether default calling convention is 'sysv_abi'.
1200 #
1201 if test "$gcry_cv_gcc_attribute_sysv_abi" = "yes" ; then
1202    AC_CACHE_CHECK([whether default calling convention is 'sysv_abi'],
1203           [gcry_cv_gcc_default_abi_is_sysv_abi],
1204           [gcry_cv_gcc_default_abi_is_sysv_abi=no
1205            AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1206              [[void *test(void) {
1207                  void *(*def_func)(void) = test;
1208                  void *__attribute__((sysv_abi))(*sysvabi_func)(void);
1209                  /* warning on MS ABI targets, passes on SysV ABI targets */
1210                  sysvabi_func = def_func;
1211                  return sysvabi_func;
1212              }]])],
1213              [gcry_cv_gcc_default_abi_is_sysv_abi=yes])])
1214    if test "$gcry_cv_gcc_default_abi_is_sysv_abi" = "yes" ; then
1215       AC_DEFINE(HAVE_GCC_DEFAULT_ABI_IS_SYSV_ABI,1,
1216         [Defined if default calling convention is 'sysv_abi'])
1217    fi
1218 fi
1219
1220
1221 # Restore flags.
1222 CFLAGS=$_gcc_cflags_save;
1223
1224
1225 #
1226 # Check whether GCC inline assembler supports SSSE3 instructions
1227 # This is required for the AES-NI instructions.
1228 #
1229 AC_CACHE_CHECK([whether GCC inline assembler supports SSSE3 instructions],
1230        [gcry_cv_gcc_inline_asm_ssse3],
1231        [if test "$mpi_cpu_arch" != "x86" ; then
1232           gcry_cv_gcc_inline_asm_ssse3="n/a"
1233         else
1234           gcry_cv_gcc_inline_asm_ssse3=no
1235           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1236           [[static unsigned char be_mask[16] __attribute__ ((aligned (16))) =
1237               { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
1238             void a(void) {
1239               __asm__("pshufb %[mask], %%xmm2\n\t"::[mask]"m"(*be_mask):);
1240             }]])],
1241           [gcry_cv_gcc_inline_asm_ssse3=yes])
1242         fi])
1243 if test "$gcry_cv_gcc_inline_asm_ssse3" = "yes" ; then
1244    AC_DEFINE(HAVE_GCC_INLINE_ASM_SSSE3,1,
1245      [Defined if inline assembler supports SSSE3 instructions])
1246 fi
1247
1248
1249 #
1250 # Check whether GCC inline assembler supports PCLMUL instructions.
1251 #
1252 AC_CACHE_CHECK([whether GCC inline assembler supports PCLMUL instructions],
1253        [gcry_cv_gcc_inline_asm_pclmul],
1254        [if test "$mpi_cpu_arch" != "x86" ; then
1255           gcry_cv_gcc_inline_asm_pclmul="n/a"
1256         else
1257           gcry_cv_gcc_inline_asm_pclmul=no
1258           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1259           [[void a(void) {
1260               __asm__("pclmulqdq \$0, %%xmm1, %%xmm3\n\t":::"cc");
1261             }]])],
1262           [gcry_cv_gcc_inline_asm_pclmul=yes])
1263         fi])
1264 if test "$gcry_cv_gcc_inline_asm_pclmul" = "yes" ; then
1265    AC_DEFINE(HAVE_GCC_INLINE_ASM_PCLMUL,1,
1266      [Defined if inline assembler supports PCLMUL instructions])
1267 fi
1268
1269 #
1270 # Check whether GCC inline assembler supports SSE4.1 instructions.
1271 #
1272 AC_CACHE_CHECK([whether GCC inline assembler supports SSE4.1 instructions],
1273        [gcry_cv_gcc_inline_asm_sse41],
1274        [if test "$mpi_cpu_arch" != "x86" ; then
1275           gcry_cv_gcc_inline_asm_sse41="n/a"
1276         else
1277           gcry_cv_gcc_inline_asm_sse41=no
1278           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1279           [[void a(void) {
1280               int i;
1281               __asm__("pextrd \$2, %%xmm0, %[out]\n\t" : [out] "=m" (i));
1282             }]])],
1283           [gcry_cv_gcc_inline_asm_sse41=yes])
1284         fi])
1285 if test "$gcry_cv_gcc_inline_asm_sse41" = "yes" ; then
1286    AC_DEFINE(HAVE_GCC_INLINE_ASM_SSE41,1,
1287      [Defined if inline assembler supports SSE4.1 instructions])
1288 fi
1289
1290
1291 #
1292 # Check whether GCC inline assembler supports AVX instructions
1293 #
1294 AC_CACHE_CHECK([whether GCC inline assembler supports AVX instructions],
1295        [gcry_cv_gcc_inline_asm_avx],
1296        [if test "$mpi_cpu_arch" != "x86" ; then
1297           gcry_cv_gcc_inline_asm_avx="n/a"
1298         else
1299           gcry_cv_gcc_inline_asm_avx=no
1300           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1301           [[void a(void) {
1302               __asm__("xgetbv; vaesdeclast (%[mem]),%%xmm0,%%xmm7\n\t"::[mem]"r"(0):);
1303             }]])],
1304           [gcry_cv_gcc_inline_asm_avx=yes])
1305         fi])
1306 if test "$gcry_cv_gcc_inline_asm_avx" = "yes" ; then
1307    AC_DEFINE(HAVE_GCC_INLINE_ASM_AVX,1,
1308      [Defined if inline assembler supports AVX instructions])
1309 fi
1310
1311
1312 #
1313 # Check whether GCC inline assembler supports AVX2 instructions
1314 #
1315 AC_CACHE_CHECK([whether GCC inline assembler supports AVX2 instructions],
1316        [gcry_cv_gcc_inline_asm_avx2],
1317        [if test "$mpi_cpu_arch" != "x86" ; then
1318           gcry_cv_gcc_inline_asm_avx2="n/a"
1319         else
1320           gcry_cv_gcc_inline_asm_avx2=no
1321           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1322           [[void a(void) {
1323               __asm__("xgetbv; vpbroadcastb %%xmm7,%%ymm1\n\t":::"cc");
1324             }]])],
1325           [gcry_cv_gcc_inline_asm_avx2=yes])
1326         fi])
1327 if test "$gcry_cv_gcc_inline_asm_avx2" = "yes" ; then
1328    AC_DEFINE(HAVE_GCC_INLINE_ASM_AVX2,1,
1329      [Defined if inline assembler supports AVX2 instructions])
1330 fi
1331
1332
1333 #
1334 # Check whether GCC inline assembler supports BMI2 instructions
1335 #
1336 AC_CACHE_CHECK([whether GCC inline assembler supports BMI2 instructions],
1337        [gcry_cv_gcc_inline_asm_bmi2],
1338        [if test "$mpi_cpu_arch" != "x86" ; then
1339           gcry_cv_gcc_inline_asm_bmi2="n/a"
1340         else
1341           gcry_cv_gcc_inline_asm_bmi2=no
1342           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1343           [[void a(void) {
1344               __asm__("rorxl \$23, %%eax, %%edx\\n\\t":::"memory");
1345             }]])],
1346           [gcry_cv_gcc_inline_asm_bmi2=yes])
1347         fi])
1348 if test "$gcry_cv_gcc_inline_asm_bmi2" = "yes" ; then
1349    AC_DEFINE(HAVE_GCC_INLINE_ASM_BMI2,1,
1350      [Defined if inline assembler supports BMI2 instructions])
1351 fi
1352
1353
1354 #
1355 # Check whether GCC assembler needs "-Wa,--divide" to correctly handle
1356 # constant division
1357 #
1358 if test $amd64_as_feature_detection = yes; then
1359   AC_CACHE_CHECK([whether GCC assembler handles division correctly],
1360        [gcry_cv_gcc_as_const_division_ok],
1361        [gcry_cv_gcc_as_const_division_ok=no
1362         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1363           [[__asm__("xorl \$(123456789/12345678), %ebp;\n\t");]])],
1364           [gcry_cv_gcc_as_const_division_ok=yes])])
1365   if test "$gcry_cv_gcc_as_const_division_ok" = "no" ; then
1366     #
1367     # Add '-Wa,--divide' to CPPFLAGS and try check again.
1368     #
1369     _gcc_cppflags_save="$CPPFLAGS"
1370     CPPFLAGS="$CPPFLAGS -Wa,--divide"
1371     AC_CACHE_CHECK([whether GCC assembler handles division correctly with "-Wa,--divide"],
1372          [gcry_cv_gcc_as_const_division_with_wadivide_ok],
1373          [gcry_cv_gcc_as_const_division_with_wadivide_ok=no
1374           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1375             [[__asm__("xorl \$(123456789/12345678), %ebp;\n\t");]])],
1376             [gcry_cv_gcc_as_const_division_with_wadivide_ok=yes])])
1377     if test "$gcry_cv_gcc_as_const_division_with_wadivide_ok" = "no" ; then
1378       # '-Wa,--divide' did not work, restore old flags.
1379       CPPFLAGS="$_gcc_cppflags_save"
1380     fi
1381   fi
1382 fi
1383
1384
1385 #
1386 # Check whether GCC assembler supports features needed for our amd64
1387 # implementations
1388 #
1389 if test $amd64_as_feature_detection = yes; then
1390   AC_CACHE_CHECK([whether GCC assembler is compatible for amd64 assembly implementations],
1391        [gcry_cv_gcc_amd64_platform_as_ok],
1392        [if test "$mpi_cpu_arch" != "x86" ; then
1393           gcry_cv_gcc_amd64_platform_as_ok="n/a"
1394         else
1395           gcry_cv_gcc_amd64_platform_as_ok=no
1396           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1397           [[__asm__(
1398                 /* Test if '.type' and '.size' are supported.  */
1399                 /* These work only on ELF targets. */
1400                 "asmfunc:\n\t"
1401                 ".size asmfunc,.-asmfunc;\n\t"
1402                 ".type asmfunc,@function;\n\t"
1403                 /* Test if assembler allows use of '/' for constant division
1404                  * (Solaris/x86 issue). If previous constant division check
1405                  * and "-Wa,--divide" workaround failed, this causes assembly
1406                  * to be disable on this machine. */
1407                 "xorl \$(123456789/12345678), %ebp;\n\t"
1408             );]])],
1409           [gcry_cv_gcc_amd64_platform_as_ok=yes])
1410         fi])
1411   if test "$gcry_cv_gcc_amd64_platform_as_ok" = "yes" ; then
1412      AC_DEFINE(HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS,1,
1413               [Defined if underlying assembler is compatible with amd64 assembly implementations])
1414   fi
1415   if test "$gcry_cv_gcc_amd64_platform_as_ok" = "no" &&
1416      test "$gcry_cv_gcc_attribute_sysv_abi" = "yes" &&
1417      test "$gcry_cv_gcc_default_abi_is_ms_abi" = "yes"; then
1418     AC_CACHE_CHECK([whether GCC assembler is compatible for WIN64 assembly implementations],
1419       [gcry_cv_gcc_win64_platform_as_ok],
1420       [gcry_cv_gcc_win64_platform_as_ok=no
1421       AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1422         [[__asm__(
1423               ".globl asmfunc\n\t"
1424               "asmfunc:\n\t"
1425               "xorq \$(1234), %rbp;\n\t"
1426           );]])],
1427         [gcry_cv_gcc_win64_platform_as_ok=yes])])
1428     if test "$gcry_cv_gcc_win64_platform_as_ok" = "yes" ; then
1429       AC_DEFINE(HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS,1,
1430                 [Defined if underlying assembler is compatible with WIN64 assembly implementations])
1431     fi
1432   fi
1433 fi
1434
1435
1436 #
1437 # Check whether GCC assembler supports features needed for assembly
1438 # implementations that use Intel syntax
1439 #
1440 AC_CACHE_CHECK([whether GCC assembler is compatible for Intel syntax assembly implementations],
1441        [gcry_cv_gcc_platform_as_ok_for_intel_syntax],
1442        [if test "$mpi_cpu_arch" != "x86" ; then
1443           gcry_cv_gcc_platform_as_ok_for_intel_syntax="n/a"
1444         else
1445           gcry_cv_gcc_platform_as_ok_for_intel_syntax=no
1446           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1447           [[__asm__(
1448                 ".intel_syntax noprefix\n\t"
1449                 "pxor xmm1, xmm7;\n\t"
1450                 /* Intel syntax implementation also use GAS macros, so check
1451                  * for them here. */
1452                 "VAL_A = xmm4\n\t"
1453                 "VAL_B = xmm2\n\t"
1454                 ".macro SET_VAL_A p1\n\t"
1455                 "  VAL_A = \\\\p1 \n\t"
1456                 ".endm\n\t"
1457                 ".macro SET_VAL_B p1\n\t"
1458                 "  VAL_B = \\\\p1 \n\t"
1459                 ".endm\n\t"
1460                 "vmovdqa VAL_A, VAL_B;\n\t"
1461                 "SET_VAL_A eax\n\t"
1462                 "SET_VAL_B ebp\n\t"
1463                 "add VAL_A, VAL_B;\n\t"
1464                 "add VAL_B, 0b10101;\n\t"
1465             );]])],
1466           [gcry_cv_gcc_platform_as_ok_for_intel_syntax=yes])
1467         fi])
1468 if test "$gcry_cv_gcc_platform_as_ok_for_intel_syntax" = "yes" ; then
1469   AC_DEFINE(HAVE_INTEL_SYNTAX_PLATFORM_AS,1,
1470             [Defined if underlying assembler is compatible with Intel syntax assembly implementations])
1471 fi
1472
1473
1474 #
1475 # Check whether compiler is configured for ARMv6 or newer architecture
1476 #
1477 AC_CACHE_CHECK([whether compiler is configured for ARMv6 or newer architecture],
1478        [gcry_cv_cc_arm_arch_is_v6],
1479        [if test "$mpi_cpu_arch" != "arm" ; then
1480           gcry_cv_cc_arm_arch_is_v6="n/a"
1481         else
1482           gcry_cv_cc_arm_arch_is_v6=no
1483           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1484           [[
1485            #if defined(__arm__) && \
1486              ((defined(__ARM_ARCH) && __ARM_ARCH >= 6) \
1487              || defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) \
1488              || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) \
1489              || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6T2__) \
1490              || defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) \
1491              || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) \
1492              || defined(__ARM_ARCH_7EM__))
1493              /* empty */
1494            #else
1495              /* fail compile if not ARMv6. */
1496              not_armv6 not_armv6 = (not_armv6)not_armv6;
1497            #endif
1498           ]])],
1499           [gcry_cv_cc_arm_arch_is_v6=yes])
1500         fi])
1501 if test "$gcry_cv_cc_arm_arch_is_v6" = "yes" ; then
1502    AC_DEFINE(HAVE_ARM_ARCH_V6,1,
1503      [Defined if ARM architecture is v6 or newer])
1504 fi
1505
1506
1507 #
1508 # Check whether GCC inline assembler supports NEON instructions
1509 #
1510 AC_CACHE_CHECK([whether GCC inline assembler supports NEON instructions],
1511        [gcry_cv_gcc_inline_asm_neon],
1512        [if test "$mpi_cpu_arch" != "arm" ; then
1513           gcry_cv_gcc_inline_asm_neon="n/a"
1514         else
1515           gcry_cv_gcc_inline_asm_neon=no
1516           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1517           [[__asm__(
1518                 ".syntax unified\n\t"
1519                 ".arm\n\t"
1520                 ".fpu neon\n\t"
1521                 "vld1.64 {%q0-%q1}, [%r0]!;\n\t"
1522                 "vrev64.8 %q0, %q3;\n\t"
1523                 "vadd.u64 %q0, %q1;\n\t"
1524                 "vadd.s64 %d3, %d2, %d3;\n\t"
1525                 );
1526             ]])],
1527           [gcry_cv_gcc_inline_asm_neon=yes])
1528         fi])
1529 if test "$gcry_cv_gcc_inline_asm_neon" = "yes" ; then
1530    AC_DEFINE(HAVE_GCC_INLINE_ASM_NEON,1,
1531      [Defined if inline assembler supports NEON instructions])
1532 fi
1533
1534
1535 #######################################
1536 #### Checks for library functions. ####
1537 #######################################
1538
1539 AC_FUNC_VPRINTF
1540 # We have replacements for these in src/missing-string.c
1541 AC_CHECK_FUNCS(stpcpy strcasecmp)
1542 # We have replacements for these in src/g10lib.h
1543 AC_CHECK_FUNCS(strtoul memmove stricmp atexit raise)
1544 # Other checks
1545 AC_CHECK_FUNCS(strerror rand mmap getpagesize sysconf waitpid wait4)
1546 AC_CHECK_FUNCS(gettimeofday getrusage gethrtime clock_gettime syslog)
1547 AC_CHECK_FUNCS(syscall fcntl ftruncate flockfile)
1548
1549 GNUPG_CHECK_MLOCK
1550
1551 #
1552 # Replacement functions.
1553 #
1554 AC_REPLACE_FUNCS([getpid clock])
1555
1556
1557 #
1558 # Check wether it is necessary to link against libdl.
1559 #
1560 DL_LIBS=""
1561 if test "$use_hmac_binary_check" = yes ; then
1562   _gcry_save_libs="$LIBS"
1563   LIBS=""
1564   AC_SEARCH_LIBS(dlopen, c dl,,,)
1565   DL_LIBS=$LIBS
1566   LIBS="$_gcry_save_libs"
1567   LIBGCRYPT_CONFIG_LIBS="${LIBGCRYPT_CONFIG_LIBS} ${DL_LIBS}"
1568 fi
1569 AC_SUBST(DL_LIBS)
1570
1571
1572 #
1573 # Check whether we can use Linux capabilities as requested.
1574 #
1575 if test "$use_capabilities" = "yes" ; then
1576 use_capabilities=no
1577 AC_CHECK_HEADERS(sys/capability.h)
1578 if test "$ac_cv_header_sys_capability_h" = "yes" ; then
1579   AC_CHECK_LIB(cap, cap_init, ac_need_libcap=1)
1580   if test "$ac_cv_lib_cap_cap_init" = "yes"; then
1581      AC_DEFINE(USE_CAPABILITIES,1,
1582                [define if capabilities should be used])
1583      LIBS="$LIBS -lcap"
1584      use_capabilities=yes
1585   fi
1586 fi
1587 if test "$use_capabilities" = "no" ; then
1588     AC_MSG_WARN([[
1589 ***
1590 *** The use of capabilities on this system is not possible.
1591 *** You need a recent Linux kernel and some patches:
1592 ***   fcaps-2.2.9-990610.patch      (kernel patch for 2.2.9)
1593 ***   fcap-module-990613.tar.gz     (kernel module)
1594 ***   libcap-1.92.tar.gz            (user mode library and utilities)
1595 *** And you have to configure the kernel with CONFIG_VFS_CAP_PLUGIN
1596 *** set (filesystems menu). Be warned: This code is *really* ALPHA.
1597 ***]])
1598 fi
1599 fi
1600
1601 # Check whether a random device is available.
1602 if test "$try_dev_random" = yes ; then
1603     AC_CACHE_CHECK(for random device, ac_cv_have_dev_random,
1604     [if test -r "$NAME_OF_DEV_RANDOM" && test -r "$NAME_OF_DEV_URANDOM" ; then
1605       ac_cv_have_dev_random=yes; else ac_cv_have_dev_random=no; fi])
1606     if test "$ac_cv_have_dev_random" = yes; then
1607         AC_DEFINE(HAVE_DEV_RANDOM,1,
1608                  [defined if the system supports a random device] )
1609     fi
1610 else
1611     AC_MSG_CHECKING(for random device)
1612     ac_cv_have_dev_random=no
1613     AC_MSG_RESULT(has been disabled)
1614 fi
1615
1616 # Figure out the random modules for this configuration.
1617 if test "$random" = "default"; then
1618
1619     # Select default value.
1620     if test "$ac_cv_have_dev_random" = yes; then
1621         # Try Linuxish random device.
1622         random_modules="linux"
1623     else
1624         case "${host}" in
1625         *-*-mingw32ce*)
1626           # WindowsCE random device.
1627           random_modules="w32ce"
1628           ;;
1629         *-*-mingw32*|*-*-cygwin*)
1630           # Windows random device.
1631           random_modules="w32"
1632           ;;
1633         *)
1634           # Build everything, allow to select at runtime.
1635           random_modules="$auto_random_modules"
1636           ;;
1637         esac
1638     fi
1639 else
1640     if test "$random" = "auto"; then
1641         # Build everything, allow to select at runtime.
1642         random_modules="$auto_random_modules"
1643     else
1644         random_modules="$random"
1645     fi
1646 fi
1647
1648
1649 #
1650 # Other defines
1651 #
1652 if test mym4_isgit = "yes"; then
1653     AC_DEFINE(IS_DEVELOPMENT_VERSION,1,
1654               [Defined if this is not a regular release])
1655 fi
1656
1657
1658 AM_CONDITIONAL(CROSS_COMPILING, test x$cross_compiling = xyes)
1659
1660
1661 # This is handy for debugging so the compiler doesn't rearrange
1662 # things and eliminate variables.
1663 AC_ARG_ENABLE(optimization,
1664        AC_HELP_STRING([--disable-optimization],
1665                       [disable compiler optimization]),
1666                       [if test $enableval = no ; then
1667                          CFLAGS=`echo $CFLAGS | sed 's/-O[[0-9]]//'`
1668                        fi])
1669
1670 # CFLAGS mangling when using gcc.
1671 if test "$GCC" = yes; then
1672     CFLAGS="$CFLAGS -Wall"
1673     if test "$USE_MAINTAINER_MODE" = "yes"; then
1674         CFLAGS="$CFLAGS -Wcast-align -Wshadow -Wstrict-prototypes"
1675         CFLAGS="$CFLAGS -Wformat -Wno-format-y2k -Wformat-security"
1676
1677         # If -Wno-missing-field-initializers is supported we can enable a
1678         # a bunch of really useful warnings.
1679         AC_MSG_CHECKING([if gcc supports -Wno-missing-field-initializers])
1680         _gcc_cflags_save=$CFLAGS
1681         CFLAGS="-Wno-missing-field-initializers"
1682         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[])],_gcc_wopt=yes,_gcc_wopt=no)
1683         AC_MSG_RESULT($_gcc_wopt)
1684         CFLAGS=$_gcc_cflags_save;
1685         if test x"$_gcc_wopt" = xyes ; then
1686           CFLAGS="$CFLAGS -W -Wextra -Wbad-function-cast"
1687           CFLAGS="$CFLAGS -Wwrite-strings"
1688           CFLAGS="$CFLAGS -Wdeclaration-after-statement"
1689           CFLAGS="$CFLAGS -Wno-missing-field-initializers"
1690           CFLAGS="$CFLAGS -Wno-sign-compare"
1691         fi
1692
1693         AC_MSG_CHECKING([if gcc supports -Wpointer-arith])
1694         _gcc_cflags_save=$CFLAGS
1695         CFLAGS="-Wpointer-arith"
1696         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[])],_gcc_wopt=yes,_gcc_wopt=no)
1697         AC_MSG_RESULT($_gcc_wopt)
1698         CFLAGS=$_gcc_cflags_save;
1699         if test x"$_gcc_wopt" = xyes ; then
1700           CFLAGS="$CFLAGS -Wpointer-arith"
1701         fi
1702     fi
1703
1704 fi
1705
1706 # Check whether as(1) supports a noeexecstack feature.  This test
1707 # includes an override option.
1708 CL_AS_NOEXECSTACK
1709
1710
1711 AC_SUBST(LIBGCRYPT_CONFIG_API_VERSION)
1712 AC_SUBST(LIBGCRYPT_CONFIG_LIBS)
1713 AC_SUBST(LIBGCRYPT_CONFIG_CFLAGS)
1714 AC_SUBST(LIBGCRYPT_CONFIG_HOST)
1715 AC_SUBST(LIBGCRYPT_THREAD_MODULES)
1716
1717 AC_CONFIG_COMMANDS([gcrypt-conf],[[
1718 chmod +x src/libgcrypt-config
1719 ]],[[
1720 prefix=$prefix
1721 exec_prefix=$exec_prefix
1722 libdir=$libdir
1723 datadir=$datadir
1724 DATADIRNAME=$DATADIRNAME
1725 ]])
1726
1727 #####################
1728 #### Conclusion. ####
1729 #####################
1730
1731 # Check that requested feature can actually be used and define
1732 # ENABLE_foo_SUPPORT macros.
1733
1734 if test x"$aesnisupport" = xyes ; then
1735   if test "$gcry_cv_gcc_inline_asm_ssse3" != "yes" ; then
1736     aesnisupport="no (unsupported by compiler)"
1737   fi
1738 fi
1739 if test x"$pclmulsupport" = xyes ; then
1740   if test "$gcry_cv_gcc_inline_asm_pclmul" != "yes" ; then
1741     pclmulsupport="no (unsupported by compiler)"
1742   fi
1743 fi
1744 if test x"$sse41support" = xyes ; then
1745   if test "$gcry_cv_gcc_inline_asm_sse41" != "yes" ; then
1746     sse41support="no (unsupported by compiler)"
1747   fi
1748 fi
1749 if test x"$avxsupport" = xyes ; then
1750   if test "$gcry_cv_gcc_inline_asm_avx" != "yes" ; then
1751     avxsupport="no (unsupported by compiler)"
1752   fi
1753 fi
1754 if test x"$avx2support" = xyes ; then
1755   if test "$gcry_cv_gcc_inline_asm_avx2" != "yes" ; then
1756     avx2support="no (unsupported by compiler)"
1757   fi
1758 fi
1759 if test x"$neonsupport" = xyes ; then
1760   if test "$gcry_cv_gcc_inline_asm_neon" != "yes" ; then
1761     neonsupport="no (unsupported by compiler)"
1762   fi
1763 fi
1764
1765 if test x"$aesnisupport" = xyes ; then
1766   AC_DEFINE(ENABLE_AESNI_SUPPORT, 1,
1767             [Enable support for Intel AES-NI instructions.])
1768 fi
1769 if test x"$pclmulsupport" = xyes ; then
1770   AC_DEFINE(ENABLE_PCLMUL_SUPPORT, 1,
1771             [Enable support for Intel PCLMUL instructions.])
1772 fi
1773 if test x"$sse41support" = xyes ; then
1774   AC_DEFINE(ENABLE_SSE41_SUPPORT, 1,
1775             [Enable support for Intel SSE4.1 instructions.])
1776 fi
1777 if test x"$avxsupport" = xyes ; then
1778   AC_DEFINE(ENABLE_AVX_SUPPORT,1,
1779             [Enable support for Intel AVX instructions.])
1780 fi
1781 if test x"$avx2support" = xyes ; then
1782   AC_DEFINE(ENABLE_AVX2_SUPPORT,1,
1783             [Enable support for Intel AVX2 instructions.])
1784 fi
1785 if test x"$neonsupport" = xyes ; then
1786   AC_DEFINE(ENABLE_NEON_SUPPORT,1,
1787             [Enable support for ARM NEON instructions.])
1788 fi
1789 if test x"$padlocksupport" = xyes ; then
1790   AC_DEFINE(ENABLE_PADLOCK_SUPPORT, 1,
1791             [Enable support for the PadLock engine.])
1792 fi
1793 if test x"$drngsupport" = xyes ; then
1794   AC_DEFINE(ENABLE_DRNG_SUPPORT, 1,
1795             [Enable support for Intel DRNG (RDRAND instruction).])
1796 fi
1797
1798
1799 # Define conditional sources and config.h symbols depending on the
1800 # selected ciphers, pubkey-ciphers, digests, kdfs, and random modules.
1801
1802 LIST_MEMBER(arcfour, $enabled_ciphers)
1803 if test "$found" = "1"; then
1804    GCRYPT_CIPHERS="$GCRYPT_CIPHERS arcfour.lo"
1805    AC_DEFINE(USE_ARCFOUR, 1, [Defined if this module should be included])
1806
1807    case "${host}" in
1808       x86_64-*-*)
1809          # Build with the assembly implementation
1810          GCRYPT_CIPHERS="$GCRYPT_CIPHERS arcfour-amd64.lo"
1811       ;;
1812    esac
1813 fi
1814
1815 LIST_MEMBER(blowfish, $enabled_ciphers)
1816 if test "$found" = "1" ; then
1817    GCRYPT_CIPHERS="$GCRYPT_CIPHERS blowfish.lo"
1818    AC_DEFINE(USE_BLOWFISH, 1, [Defined if this module should be included])
1819
1820    case "${host}" in
1821       x86_64-*-*)
1822          # Build with the assembly implementation
1823          GCRYPT_CIPHERS="$GCRYPT_CIPHERS blowfish-amd64.lo"
1824       ;;
1825       arm*-*-*)
1826          # Build with the assembly implementation
1827          GCRYPT_CIPHERS="$GCRYPT_CIPHERS blowfish-arm.lo"
1828       ;;
1829    esac
1830 fi
1831
1832 LIST_MEMBER(cast5, $enabled_ciphers)
1833 if test "$found" = "1" ; then
1834    GCRYPT_CIPHERS="$GCRYPT_CIPHERS cast5.lo"
1835    AC_DEFINE(USE_CAST5, 1, [Defined if this module should be included])
1836
1837    case "${host}" in
1838       x86_64-*-*)
1839          # Build with the assembly implementation
1840          GCRYPT_CIPHERS="$GCRYPT_CIPHERS cast5-amd64.lo"
1841       ;;
1842       arm*-*-*)
1843          # Build with the assembly implementation
1844          GCRYPT_CIPHERS="$GCRYPT_CIPHERS cast5-arm.lo"
1845       ;;
1846    esac
1847 fi
1848
1849 LIST_MEMBER(des, $enabled_ciphers)
1850 if test "$found" = "1" ; then
1851    GCRYPT_CIPHERS="$GCRYPT_CIPHERS des.lo"
1852    AC_DEFINE(USE_DES, 1, [Defined if this module should be included])
1853
1854    case "${host}" in
1855       x86_64-*-*)
1856          # Build with the assembly implementation
1857          GCRYPT_CIPHERS="$GCRYPT_CIPHERS des-amd64.lo"
1858       ;;
1859    esac
1860 fi
1861
1862 LIST_MEMBER(aes, $enabled_ciphers)
1863 if test "$found" = "1" ; then
1864    GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael.lo"
1865    AC_DEFINE(USE_AES, 1, [Defined if this module should be included])
1866
1867    case "${host}" in
1868       x86_64-*-*)
1869          # Build with the assembly implementation
1870          GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael-amd64.lo"
1871
1872          # Build with the SSSE3 implementation
1873          GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael-ssse3-amd64.lo"
1874       ;;
1875       arm*-*-*)
1876          # Build with the assembly implementation
1877          GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael-arm.lo"
1878       ;;
1879    esac
1880
1881    case "$mpi_cpu_arch" in
1882      x86)
1883          # Build with the AES-NI implementation
1884          GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael-aesni.lo"
1885
1886          # Build with the Padlock implementation
1887          GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael-padlock.lo"
1888       ;;
1889    esac
1890 fi
1891
1892 LIST_MEMBER(twofish, $enabled_ciphers)
1893 if test "$found" = "1" ; then
1894    GCRYPT_CIPHERS="$GCRYPT_CIPHERS twofish.lo"
1895    AC_DEFINE(USE_TWOFISH, 1, [Defined if this module should be included])
1896
1897    case "${host}" in
1898       x86_64-*-*)
1899          # Build with the assembly implementation
1900          GCRYPT_CIPHERS="$GCRYPT_CIPHERS twofish-amd64.lo"
1901       ;;
1902       arm*-*-*)
1903          # Build with the assembly implementation
1904          GCRYPT_CIPHERS="$GCRYPT_CIPHERS twofish-arm.lo"
1905       ;;
1906    esac
1907 fi
1908
1909 LIST_MEMBER(serpent, $enabled_ciphers)
1910 if test "$found" = "1" ; then
1911    GCRYPT_CIPHERS="$GCRYPT_CIPHERS serpent.lo"
1912    AC_DEFINE(USE_SERPENT, 1, [Defined if this module should be included])
1913
1914    case "${host}" in
1915       x86_64-*-*)
1916          # Build with the SSE2 implementation
1917          GCRYPT_CIPHERS="$GCRYPT_CIPHERS serpent-sse2-amd64.lo"
1918       ;;
1919    esac
1920
1921    if test x"$avx2support" = xyes ; then
1922       # Build with the AVX2 implementation
1923       GCRYPT_CIPHERS="$GCRYPT_CIPHERS serpent-avx2-amd64.lo"
1924    fi
1925
1926    if test x"$neonsupport" = xyes ; then
1927       # Build with the NEON implementation
1928       GCRYPT_CIPHERS="$GCRYPT_CIPHERS serpent-armv7-neon.lo"
1929    fi
1930 fi
1931
1932 LIST_MEMBER(rfc2268, $enabled_ciphers)
1933 if test "$found" = "1" ; then
1934    GCRYPT_CIPHERS="$GCRYPT_CIPHERS rfc2268.lo"
1935    AC_DEFINE(USE_RFC2268, 1, [Defined if this module should be included])
1936 fi
1937
1938 LIST_MEMBER(seed, $enabled_ciphers)
1939 if test "$found" = "1" ; then
1940    GCRYPT_CIPHERS="$GCRYPT_CIPHERS seed.lo"
1941    AC_DEFINE(USE_SEED, 1, [Defined if this module should be included])
1942 fi
1943
1944 LIST_MEMBER(camellia, $enabled_ciphers)
1945 if test "$found" = "1" ; then
1946    GCRYPT_CIPHERS="$GCRYPT_CIPHERS camellia.lo camellia-glue.lo"
1947    AC_DEFINE(USE_CAMELLIA, 1, [Defined if this module should be included])
1948
1949    case "${host}" in
1950       arm*-*-*)
1951          # Build with the assembly implementation
1952          GCRYPT_CIPHERS="$GCRYPT_CIPHERS camellia-arm.lo"
1953       ;;
1954    esac
1955
1956    if test x"$avxsupport" = xyes ; then
1957       if test x"$aesnisupport" = xyes ; then
1958         # Build with the AES-NI/AVX implementation
1959         GCRYPT_CIPHERS="$GCRYPT_CIPHERS camellia-aesni-avx-amd64.lo"
1960       fi
1961    fi
1962
1963    if test x"$avx2support" = xyes ; then
1964       if test x"$aesnisupport" = xyes ; then
1965         # Build with the AES-NI/AVX2 implementation
1966         GCRYPT_CIPHERS="$GCRYPT_CIPHERS camellia-aesni-avx2-amd64.lo"
1967       fi
1968    fi
1969 fi
1970
1971 LIST_MEMBER(idea, $enabled_ciphers)
1972 if test "$found" = "1" ; then
1973    GCRYPT_CIPHERS="$GCRYPT_CIPHERS idea.lo"
1974    AC_DEFINE(USE_IDEA, 1, [Defined if this module should be included])
1975 fi
1976
1977 LIST_MEMBER(salsa20, $enabled_ciphers)
1978 if test "$found" = "1" ; then
1979    GCRYPT_CIPHERS="$GCRYPT_CIPHERS salsa20.lo"
1980    AC_DEFINE(USE_SALSA20, 1, [Defined if this module should be included])
1981
1982    case "${host}" in
1983       x86_64-*-*)
1984          # Build with the assembly implementation
1985          GCRYPT_CIPHERS="$GCRYPT_CIPHERS salsa20-amd64.lo"
1986       ;;
1987    esac
1988
1989    if test x"$neonsupport" = xyes ; then
1990      # Build with the NEON implementation
1991      GCRYPT_CIPHERS="$GCRYPT_CIPHERS salsa20-armv7-neon.lo"
1992    fi
1993 fi
1994
1995 LIST_MEMBER(gost28147, $enabled_ciphers)
1996 if test "$found" = "1" ; then
1997    GCRYPT_CIPHERS="$GCRYPT_CIPHERS gost28147.lo"
1998    AC_DEFINE(USE_GOST28147, 1, [Defined if this module should be included])
1999 fi
2000
2001 LIST_MEMBER(chacha20, $enabled_ciphers)
2002 if test "$found" = "1" ; then
2003    GCRYPT_CIPHERS="$GCRYPT_CIPHERS chacha20.lo"
2004    AC_DEFINE(USE_CHACHA20, 1, [Defined if this module should be included])
2005
2006    case "${host}" in
2007       x86_64-*-*)
2008          # Build with the assembly implementation
2009          GCRYPT_CIPHERS="$GCRYPT_CIPHERS chacha20-sse2-amd64.lo"
2010          GCRYPT_CIPHERS="$GCRYPT_CIPHERS chacha20-ssse3-amd64.lo"
2011          GCRYPT_CIPHERS="$GCRYPT_CIPHERS chacha20-avx2-amd64.lo"
2012       ;;
2013    esac
2014
2015    if test x"$neonsupport" = xyes ; then
2016      # Build with the NEON implementation
2017      GCRYPT_CIPHERS="$GCRYPT_CIPHERS chacha20-armv7-neon.lo"
2018    fi
2019 fi
2020
2021 case "${host}" in
2022    x86_64-*-*)
2023       # Build with the assembly implementation
2024       GCRYPT_CIPHERS="$GCRYPT_CIPHERS poly1305-sse2-amd64.lo"
2025       GCRYPT_CIPHERS="$GCRYPT_CIPHERS poly1305-avx2-amd64.lo"
2026    ;;
2027 esac
2028
2029 if test x"$neonsupport" = xyes ; then
2030    # Build with the NEON implementation
2031    GCRYPT_CIPHERS="$GCRYPT_CIPHERS poly1305-armv7-neon.lo"
2032 fi
2033
2034 LIST_MEMBER(dsa, $enabled_pubkey_ciphers)
2035 if test "$found" = "1" ; then
2036    GCRYPT_PUBKEY_CIPHERS="$GCRYPT_PUBKEY_CIPHERS dsa.lo"
2037    AC_DEFINE(USE_DSA, 1, [Defined if this module should be included])
2038 fi
2039
2040 LIST_MEMBER(rsa, $enabled_pubkey_ciphers)
2041 if test "$found" = "1" ; then
2042    GCRYPT_PUBKEY_CIPHERS="$GCRYPT_PUBKEY_CIPHERS rsa.lo"
2043    AC_DEFINE(USE_RSA, 1, [Defined if this module should be included])
2044 fi
2045
2046 LIST_MEMBER(elgamal, $enabled_pubkey_ciphers)
2047 if test "$found" = "1" ; then
2048    GCRYPT_PUBKEY_CIPHERS="$GCRYPT_PUBKEY_CIPHERS elgamal.lo"
2049    AC_DEFINE(USE_ELGAMAL, 1, [Defined if this module should be included])
2050 fi
2051
2052 LIST_MEMBER(ecc, $enabled_pubkey_ciphers)
2053 if test "$found" = "1" ; then
2054    GCRYPT_PUBKEY_CIPHERS="$GCRYPT_PUBKEY_CIPHERS \
2055                           ecc.lo ecc-curves.lo ecc-misc.lo \
2056                           ecc-ecdsa.lo ecc-eddsa.lo ecc-gost.lo"
2057    AC_DEFINE(USE_ECC, 1, [Defined if this module should be included])
2058 fi
2059
2060 LIST_MEMBER(crc, $enabled_digests)
2061 if test "$found" = "1" ; then
2062    GCRYPT_DIGESTS="$GCRYPT_DIGESTS crc.lo"
2063    AC_DEFINE(USE_CRC, 1, [Defined if this module should be included])
2064
2065    case "${host}" in
2066       i?86-*-* | x86_64-*-*)
2067          # Build with the assembly implementation
2068          GCRYPT_DIGESTS="$GCRYPT_DIGESTS crc-intel-pclmul.lo"
2069       ;;
2070    esac
2071 fi
2072
2073 LIST_MEMBER(gostr3411-94, $enabled_digests)
2074 if test "$found" = "1" ; then
2075    # GOST R 34.11-94 internally uses GOST 28147-89
2076    LIST_MEMBER(gost28147, $enabled_ciphers)
2077    if test "$found" = "1" ; then
2078       GCRYPT_DIGESTS="$GCRYPT_DIGESTS gostr3411-94.lo"
2079       AC_DEFINE(USE_GOST_R_3411_94, 1, [Defined if this module should be included])
2080    fi
2081 fi
2082
2083 LIST_MEMBER(stribog, $enabled_digests)
2084 if test "$found" = "1" ; then
2085    GCRYPT_DIGESTS="$GCRYPT_DIGESTS stribog.lo"
2086    AC_DEFINE(USE_GOST_R_3411_12, 1, [Defined if this module should be included])
2087 fi
2088
2089 LIST_MEMBER(md2, $enabled_digests)
2090 if test "$found" = "1" ; then
2091    GCRYPT_DIGESTS="$GCRYPT_DIGESTS md2.lo"
2092    AC_DEFINE(USE_MD2, 1, [Defined if this module should be included])
2093 fi
2094
2095 LIST_MEMBER(md4, $enabled_digests)
2096 if test "$found" = "1" ; then
2097    GCRYPT_DIGESTS="$GCRYPT_DIGESTS md4.lo"
2098    AC_DEFINE(USE_MD4, 1, [Defined if this module should be included])
2099 fi
2100
2101 LIST_MEMBER(md5, $enabled_digests)
2102 if test "$found" = "1" ; then
2103    GCRYPT_DIGESTS="$GCRYPT_DIGESTS md5.lo"
2104    AC_DEFINE(USE_MD5, 1, [Defined if this module should be included])
2105 fi
2106
2107 LIST_MEMBER(rmd160, $enabled_digests)
2108 if test "$found" = "1" ; then
2109    GCRYPT_DIGESTS="$GCRYPT_DIGESTS rmd160.lo"
2110    AC_DEFINE(USE_RMD160, 1, [Defined if this module should be included])
2111 fi
2112
2113 LIST_MEMBER(sha256, $enabled_digests)
2114 if test "$found" = "1" ; then
2115    GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha256.lo"
2116    AC_DEFINE(USE_SHA256, 1, [Defined if this module should be included])
2117
2118    case "${host}" in
2119       x86_64-*-*)
2120          # Build with the assembly implementation
2121          GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha256-ssse3-amd64.lo"
2122          GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha256-avx-amd64.lo"
2123          GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha256-avx2-bmi2-amd64.lo"
2124       ;;
2125    esac
2126 fi
2127
2128 LIST_MEMBER(sha512, $enabled_digests)
2129 if test "$found" = "1" ; then
2130    GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha512.lo"
2131    AC_DEFINE(USE_SHA512, 1, [Defined if this module should be included])
2132
2133    case "${host}" in
2134       x86_64-*-*)
2135          # Build with the assembly implementation
2136          GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha512-ssse3-amd64.lo"
2137          GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha512-avx-amd64.lo"
2138          GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha512-avx2-bmi2-amd64.lo"
2139       ;;
2140       arm*-*-*)
2141          # Build with the assembly implementation
2142          GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha512-arm.lo"
2143       ;;
2144    esac
2145
2146    if test x"$neonsupport" = xyes ; then
2147      # Build with the NEON implementation
2148      GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha512-armv7-neon.lo"
2149    fi
2150 fi
2151
2152 LIST_MEMBER(sha3, $enabled_digests)
2153 if test "$found" = "1" ; then
2154    GCRYPT_DIGESTS="$GCRYPT_DIGESTS keccak.lo"
2155    AC_DEFINE(USE_SHA3, 1, [Defined if this module should be included])
2156
2157    case "${host}" in
2158       x86_64-*-*)
2159          # Build with the assembly implementation
2160          :
2161       ;;
2162    esac
2163
2164    if test x"$neonsupport" = xyes ; then
2165      # Build with the NEON implementation
2166      GCRYPT_DIGESTS="$GCRYPT_DIGESTS keccak-armv7-neon.lo"
2167    fi
2168 fi
2169
2170 LIST_MEMBER(tiger, $enabled_digests)
2171 if test "$found" = "1" ; then
2172    GCRYPT_DIGESTS="$GCRYPT_DIGESTS tiger.lo"
2173    AC_DEFINE(USE_TIGER, 1, [Defined if this module should be included])
2174 fi
2175
2176 LIST_MEMBER(whirlpool, $enabled_digests)
2177 if test "$found" = "1" ; then
2178    GCRYPT_DIGESTS="$GCRYPT_DIGESTS whirlpool.lo"
2179    AC_DEFINE(USE_WHIRLPOOL, 1, [Defined if this module should be included])
2180
2181    case "${host}" in
2182       x86_64-*-*)
2183          # Build with the assembly implementation
2184          GCRYPT_DIGESTS="$GCRYPT_DIGESTS whirlpool-sse2-amd64.lo"
2185       ;;
2186    esac
2187 fi
2188
2189 # SHA-1 needs to be included always for example because it is used by
2190 # random-csprng.c.
2191 GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha1.lo"
2192 AC_DEFINE(USE_SHA1, 1,   [Defined if this module should be included])
2193
2194 case "${host}" in
2195   x86_64-*-*)
2196     # Build with the assembly implementation
2197     GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha1-ssse3-amd64.lo"
2198     GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha1-avx-amd64.lo"
2199     GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha1-avx-bmi2-amd64.lo"
2200   ;;
2201   arm*-*-*)
2202     # Build with the assembly implementation
2203     GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha1-armv7-neon.lo"
2204   ;;
2205 esac
2206
2207 LIST_MEMBER(scrypt, $enabled_kdfs)
2208 if test "$found" = "1" ; then
2209    GCRYPT_KDFS="$GCRYPT_KDFS scrypt.lo"
2210    AC_DEFINE(USE_SCRYPT, 1, [Defined if this module should be included])
2211 fi
2212
2213 LIST_MEMBER(linux, $random_modules)
2214 if test "$found" = "1" ; then
2215    GCRYPT_RANDOM="$GCRYPT_RANDOM rndlinux.lo"
2216    AC_DEFINE(USE_RNDLINUX, 1, [Defined if the /dev/random RNG should be used.])
2217 fi
2218
2219 LIST_MEMBER(unix, $random_modules)
2220 if test "$found" = "1" ; then
2221    GCRYPT_RANDOM="$GCRYPT_RANDOM rndunix.lo"
2222    AC_DEFINE(USE_RNDUNIX, 1, [Defined if the default Unix RNG should be used.])
2223    print_egd_notice=yes
2224 fi
2225
2226 LIST_MEMBER(egd, $random_modules)
2227 if test "$found" = "1" ; then
2228    GCRYPT_RANDOM="$GCRYPT_RANDOM rndegd.lo"
2229    AC_DEFINE(USE_RNDEGD, 1, [Defined if the EGD based RNG should be used.])
2230 fi
2231
2232 LIST_MEMBER(w32, $random_modules)
2233 if test "$found" = "1" ; then
2234    GCRYPT_RANDOM="$GCRYPT_RANDOM rndw32.lo"
2235    AC_DEFINE(USE_RNDW32, 1,
2236              [Defined if the Windows specific RNG should be used.])
2237 fi
2238
2239 LIST_MEMBER(w32ce, $random_modules)
2240 if test "$found" = "1" ; then
2241    GCRYPT_RANDOM="$GCRYPT_RANDOM rndw32ce.lo"
2242    AC_DEFINE(USE_RNDW32CE, 1,
2243              [Defined if the WindowsCE specific RNG should be used.])
2244 fi
2245
2246 AC_SUBST([GCRYPT_CIPHERS])
2247 AC_SUBST([GCRYPT_PUBKEY_CIPHERS])
2248 AC_SUBST([GCRYPT_DIGESTS])
2249 AC_SUBST([GCRYPT_KDFS])
2250 AC_SUBST([GCRYPT_RANDOM])
2251
2252 AC_SUBST(LIBGCRYPT_CIPHERS, $enabled_ciphers)
2253 AC_SUBST(LIBGCRYPT_PUBKEY_CIPHERS, $enabled_pubkey_ciphers)
2254 AC_SUBST(LIBGCRYPT_DIGESTS, $enabled_digests)
2255
2256 # For printing the configuration we need a colon separated list of
2257 # algorithm names.
2258 tmp=`echo "$enabled_ciphers" | tr ' ' : `
2259 AC_DEFINE_UNQUOTED(LIBGCRYPT_CIPHERS, "$tmp",
2260                    [List of available cipher algorithms])
2261 tmp=`echo "$enabled_pubkey_ciphers" | tr ' ' : `
2262 AC_DEFINE_UNQUOTED(LIBGCRYPT_PUBKEY_CIPHERS, "$tmp",
2263                    [List of available public key cipher algorithms])
2264 tmp=`echo "$enabled_digests" | tr ' ' : `
2265 AC_DEFINE_UNQUOTED(LIBGCRYPT_DIGESTS, "$tmp",
2266                    [List of available digest algorithms])
2267 tmp=`echo "$enabled_kdfs" | tr ' ' : `
2268 AC_DEFINE_UNQUOTED(LIBGCRYPT_KDFS, "$tmp",
2269                    [List of available KDF algorithms])
2270
2271
2272 #
2273 # Define conditional sources depending on the used hardware platform.
2274 # Note that all possible modules must also be listed in
2275 # src/Makefile.am (EXTRA_libgcrypt_la_SOURCES).
2276 #
2277 GCRYPT_HWF_MODULES=
2278 case "$mpi_cpu_arch" in
2279      x86)
2280         AC_DEFINE(HAVE_CPU_ARCH_X86, 1,   [Defined for the x86 platforms])
2281         GCRYPT_HWF_MODULES="hwf-x86.lo"
2282         ;;
2283      alpha)
2284         AC_DEFINE(HAVE_CPU_ARCH_ALPHA, 1, [Defined for Alpha platforms])
2285         ;;
2286      sparc)
2287         AC_DEFINE(HAVE_CPU_ARCH_SPARC, 1, [Defined for SPARC platforms])
2288         ;;
2289      mips)
2290         AC_DEFINE(HAVE_CPU_ARCH_MIPS, 1,  [Defined for MIPS platforms])
2291         ;;
2292      m68k)
2293         AC_DEFINE(HAVE_CPU_ARCH_M68K, 1,  [Defined for M68k platforms])
2294         ;;
2295      ppc)
2296         AC_DEFINE(HAVE_CPU_ARCH_PPC, 1,   [Defined for PPC platforms])
2297         ;;
2298      arm)
2299         AC_DEFINE(HAVE_CPU_ARCH_ARM, 1,   [Defined for ARM platforms])
2300         GCRYPT_HWF_MODULES="hwf-arm.lo"
2301         ;;
2302 esac
2303 AC_SUBST([GCRYPT_HWF_MODULES])
2304
2305
2306 #
2307 # Option to disable building of doc file
2308 #
2309 build_doc=yes
2310 AC_ARG_ENABLE([doc], AC_HELP_STRING([--disable-doc],
2311                                     [do not build the documentation]),
2312                      build_doc=$enableval, build_doc=yes)
2313 AM_CONDITIONAL([BUILD_DOC], [test "x$build_doc" != xno])
2314
2315
2316 #
2317 # Provide information about the build.
2318 #
2319 BUILD_REVISION="mym4_revision"
2320 AC_SUBST(BUILD_REVISION)
2321 AC_DEFINE_UNQUOTED(BUILD_REVISION, "$BUILD_REVISION",
2322                    [GIT commit id revision used to build this package])
2323
2324 changequote(,)dnl
2325 BUILD_FILEVERSION=`echo "$VERSION" | sed 's/\([0-9.]*\).*/\1./;s/\./,/g'`
2326 changequote([,])dnl
2327 BUILD_FILEVERSION="${BUILD_FILEVERSION}mym4_revision_dec"
2328 AC_SUBST(BUILD_FILEVERSION)
2329
2330 AC_ARG_ENABLE([build-timestamp],
2331   AC_HELP_STRING([--enable-build-timestamp],
2332                  [set an explicit build timestamp for reproducibility.
2333                   (default is the current time in ISO-8601 format)]),
2334      [if test "$enableval" = "yes"; then
2335         BUILD_TIMESTAMP=`date -u +%Y-%m-%dT%H:%M+0000 2>/dev/null || date`
2336       else
2337         BUILD_TIMESTAMP="$enableval"
2338       fi],
2339      [BUILD_TIMESTAMP="<none>"])
2340 AC_SUBST(BUILD_TIMESTAMP)
2341 AC_DEFINE_UNQUOTED(BUILD_TIMESTAMP, "$BUILD_TIMESTAMP",
2342                    [The time this package was configured for a build])
2343
2344
2345 # And create the files.
2346 AC_CONFIG_FILES([
2347 Makefile
2348 m4/Makefile
2349 compat/Makefile
2350 mpi/Makefile
2351 cipher/Makefile
2352 random/Makefile
2353 doc/Makefile
2354 src/Makefile
2355 src/gcrypt.h
2356 src/libgcrypt-config
2357 src/versioninfo.rc
2358 tests/Makefile
2359 ])
2360 AC_CONFIG_FILES([tests/hashtest-256g], [chmod +x tests/hashtest-256g])
2361 AC_OUTPUT
2362
2363
2364 detection_module="${GCRYPT_HWF_MODULES%.lo}"
2365 test -n "$detection_module" || detection_module="none"
2366
2367 # Give some feedback
2368 GCRY_MSG_SHOW([],[])
2369 GCRY_MSG_SHOW([Libgcrypt],[v${VERSION} has been configured as follows:])
2370 GCRY_MSG_SHOW([],[])
2371 GCRY_MSG_SHOW([Platform:                 ],[$PRINTABLE_OS_NAME ($host)])
2372 GCRY_MSG_SHOW([Hardware detection module:],[$detection_module])
2373 GCRY_MSG_WRAP([Enabled cipher algorithms:],[$enabled_ciphers])
2374 GCRY_MSG_WRAP([Enabled digest algorithms:],[$enabled_digests])
2375 GCRY_MSG_WRAP([Enabled kdf algorithms:   ],[$enabled_kdfs])
2376 GCRY_MSG_WRAP([Enabled pubkey algorithms:],[$enabled_pubkey_ciphers])
2377 GCRY_MSG_SHOW([Random number generator:  ],[$random])
2378 GCRY_MSG_SHOW([Using linux capabilities: ],[$use_capabilities])
2379 GCRY_MSG_SHOW([Try using Padlock crypto: ],[$padlocksupport])
2380 GCRY_MSG_SHOW([Try using AES-NI crypto:  ],[$aesnisupport])
2381 GCRY_MSG_SHOW([Try using Intel PCLMUL:   ],[$pclmulsupport])
2382 GCRY_MSG_SHOW([Try using Intel SSE4.1:   ],[$sse41support])
2383 GCRY_MSG_SHOW([Try using DRNG (RDRAND):  ],[$drngsupport])
2384 GCRY_MSG_SHOW([Try using Intel AVX:      ],[$avxsupport])
2385 GCRY_MSG_SHOW([Try using Intel AVX2:     ],[$avx2support])
2386 GCRY_MSG_SHOW([Try using ARM NEON:       ],[$neonsupport])
2387 GCRY_MSG_SHOW([],[])
2388
2389 if test "x${gpg_config_script_warn}" != x; then
2390 cat <<G10EOF
2391         Mismatches between the target platform and the to
2392         be used libraries have been been detected for:
2393          ${gpg_config_script_warn}
2394         Please check above for warning messages.
2395
2396 G10EOF
2397 fi
2398 if test "$print_egd_notice" = "yes"; then
2399 cat <<G10EOF
2400    The performance of the Unix random gatherer module (rndunix) is not
2401    very good and it does not keep the entropy pool over multiple
2402    invocations of Libgcrypt base applications.  The suggested way to
2403    overcome this problem is to use the
2404
2405                  Entropy Gathering Daemon (EGD)
2406
2407    which provides a entropy source for the whole system.  It is written
2408    in Perl and available at the GnuPG FTP servers.  For more information
2409    consult the GnuPG site:
2410
2411           https://gnupg.org/related_software/swlist.html#egd
2412
2413 G10EOF
2414 fi
2415
2416 if test "$gcry_cv_gcc_attribute_aligned" != "yes" ; then
2417 cat <<G10EOF
2418    Please not that your compiler does not support the GCC style
2419    aligned attribute. Using this software may evoke bus errors.
2420
2421 G10EOF
2422 fi
2423
2424 if test -n "$gpl"; then
2425   echo "Please note that you are building a version of Libgcrypt with"
2426   echo "  $gpl"
2427   echo "included.  These parts are licensed under the GPL and thus the"
2428   echo "use of this library has to comply with the conditions of the GPL."
2429   echo ""
2430 fi