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