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