78508ecf87f4060d5624e6a709ae8c1bdeca7e14
[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 sha512"
200 available_digests="$available_digests sha3 tiger whirlpool stribog blake2"
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 # Following attribute tests depend on warnings to cause compile to fail,
962 # so set -Werror temporarily.
963 _gcc_cflags_save=$CFLAGS
964 CFLAGS="$CFLAGS -Werror"
965
966
967 #
968 # Check whether the compiler supports the GCC style aligned attribute
969 #
970 AC_CACHE_CHECK([whether the GCC style aligned attribute is supported],
971        [gcry_cv_gcc_attribute_aligned],
972        [gcry_cv_gcc_attribute_aligned=no
973         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
974           [[struct { int a; } foo __attribute__ ((aligned (16)));]])],
975           [gcry_cv_gcc_attribute_aligned=yes])])
976 if test "$gcry_cv_gcc_attribute_aligned" = "yes" ; then
977    AC_DEFINE(HAVE_GCC_ATTRIBUTE_ALIGNED,1,
978      [Defined if a GCC style "__attribute__ ((aligned (n))" is supported])
979 fi
980
981
982 #
983 # Check whether the compiler supports the GCC style packed attribute
984 #
985 AC_CACHE_CHECK([whether the GCC style packed attribute is supported],
986        [gcry_cv_gcc_attribute_packed],
987        [gcry_cv_gcc_attribute_packed=no
988         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
989           [[struct foolong_s { long b; } __attribute__ ((packed));
990             struct foo_s { char a; struct foolong_s b; }
991               __attribute__ ((packed));
992             enum bar {
993               FOO = 1 / (sizeof(struct foo_s) == (sizeof(char) + sizeof(long))),
994             };]])],
995           [gcry_cv_gcc_attribute_packed=yes])])
996 if test "$gcry_cv_gcc_attribute_packed" = "yes" ; then
997    AC_DEFINE(HAVE_GCC_ATTRIBUTE_PACKED,1,
998      [Defined if a GCC style "__attribute__ ((packed))" is supported])
999 fi
1000
1001
1002 #
1003 # Check whether the compiler supports the GCC style may_alias attribute
1004 #
1005 AC_CACHE_CHECK([whether the GCC style may_alias attribute is supported],
1006        [gcry_cv_gcc_attribute_may_alias],
1007        [gcry_cv_gcc_attribute_may_alias=no
1008         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1009           [[typedef struct foo_s { int a; }
1010             __attribute__ ((may_alias)) foo_t;]])],
1011           [gcry_cv_gcc_attribute_may_alias=yes])])
1012 if test "$gcry_cv_gcc_attribute_may_alias" = "yes" ; then
1013    AC_DEFINE(HAVE_GCC_ATTRIBUTE_MAY_ALIAS,1,
1014      [Defined if a GCC style "__attribute__ ((may_alias))" is supported])
1015 fi
1016
1017
1018 # Restore flags.
1019 CFLAGS=$_gcc_cflags_save;
1020
1021
1022 #
1023 # Check whether the compiler supports 'asm' or '__asm__' keyword for
1024 # assembler blocks.
1025 #
1026 AC_CACHE_CHECK([whether 'asm' assembler keyword is supported],
1027        [gcry_cv_have_asm],
1028        [gcry_cv_have_asm=no
1029         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1030           [[void a(void) { asm("":::"memory"); }]])],
1031           [gcry_cv_have_asm=yes])])
1032 AC_CACHE_CHECK([whether '__asm__' assembler keyword is supported],
1033        [gcry_cv_have___asm__],
1034        [gcry_cv_have___asm__=no
1035         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1036           [[void a(void) { __asm__("":::"memory"); }]])],
1037           [gcry_cv_have___asm__=yes])])
1038 if test "$gcry_cv_have_asm" = "no" ; then
1039    if test "$gcry_cv_have___asm__" = "yes" ; then
1040       AC_DEFINE(asm,__asm__,
1041         [Define to supported assembler block keyword, if plain 'asm' was not
1042          supported])
1043    fi
1044 fi
1045
1046
1047 #
1048 # Check whether the compiler supports inline assembly memory barrier.
1049 #
1050 if test "$gcry_cv_have_asm" = "no" ; then
1051    if test "$gcry_cv_have___asm__" = "yes" ; then
1052       AC_CACHE_CHECK([whether inline assembly memory barrier is supported],
1053           [gcry_cv_have_asm_volatile_memory],
1054           [gcry_cv_have_asm_volatile_memory=no
1055            AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1056              [[void a(void) { __asm__ volatile("":::"memory"); }]])],
1057              [gcry_cv_have_asm_volatile_memory=yes])])
1058    fi
1059 else
1060    AC_CACHE_CHECK([whether inline assembly memory barrier is supported],
1061        [gcry_cv_have_asm_volatile_memory],
1062        [gcry_cv_have_asm_volatile_memory=no
1063         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1064           [[void a(void) { asm volatile("":::"memory"); }]])],
1065           [gcry_cv_have_asm_volatile_memory=yes])])
1066 fi
1067 if test "$gcry_cv_have_asm_volatile_memory" = "yes" ; then
1068    AC_DEFINE(HAVE_GCC_ASM_VOLATILE_MEMORY,1,
1069      [Define if inline asm memory barrier is supported])
1070 fi
1071
1072
1073 #
1074 # Check whether GCC assembler supports features needed for our ARM
1075 # implementations.  This needs to be done before setting up the
1076 # assembler stuff.
1077 #
1078 AC_CACHE_CHECK([whether GCC assembler is compatible for ARM assembly implementations],
1079        [gcry_cv_gcc_arm_platform_as_ok],
1080        [gcry_cv_gcc_arm_platform_as_ok=no
1081         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1082           [[__asm__(
1083                 /* Test if assembler supports UAL syntax.  */
1084                 ".syntax unified\n\t"
1085                 ".arm\n\t" /* our assembly code is in ARM mode  */
1086                 /* Following causes error if assembler ignored '.syntax unified'.  */
1087                 "asmfunc:\n\t"
1088                 "add %r0, %r0, %r4, ror #12;\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_arm_platform_as_ok=yes])])
1095 if test "$gcry_cv_gcc_arm_platform_as_ok" = "yes" ; then
1096    AC_DEFINE(HAVE_COMPATIBLE_GCC_ARM_PLATFORM_AS,1,
1097      [Defined if underlying assembler is compatible with ARM assembly implementations])
1098 fi
1099
1100
1101 #
1102 # Check whether GCC assembler supports features needed for our ARMv8/Aarch64
1103 # implementations.  This needs to be done before setting up the
1104 # assembler stuff.
1105 #
1106 AC_CACHE_CHECK([whether GCC assembler is compatible for ARMv8/Aarch64 assembly implementations],
1107        [gcry_cv_gcc_aarch64_platform_as_ok],
1108        [gcry_cv_gcc_aarch64_platform_as_ok=no
1109         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1110           [[__asm__(
1111                 "asmfunc:\n\t"
1112                 "eor x0, x0, x30, ror #12;\n\t"
1113                 "add x0, x0, x30, asr #12;\n\t"
1114                 "eor v0.16b, v0.16b, v31.16b;\n\t"
1115
1116                 /* Test if '.type' and '.size' are supported.  */
1117                 ".size asmfunc,.-asmfunc;\n\t"
1118                 ".type asmfunc,@function;\n\t"
1119             );]])],
1120           [gcry_cv_gcc_aarch64_platform_as_ok=yes])])
1121 if test "$gcry_cv_gcc_aarch64_platform_as_ok" = "yes" ; then
1122    AC_DEFINE(HAVE_COMPATIBLE_GCC_AARCH64_PLATFORM_AS,1,
1123      [Defined if underlying assembler is compatible with ARMv8/Aarch64 assembly implementations])
1124 fi
1125
1126
1127 #
1128 # Check whether underscores in symbols are required.  This needs to be
1129 # done before setting up the assembler stuff.
1130 #
1131 GNUPG_SYS_SYMBOL_UNDERSCORE()
1132
1133
1134 #################################
1135 ####                         ####
1136 #### Setup assembler stuff.  ####
1137 #### Define mpi_cpu_arch.    ####
1138 ####                         ####
1139 #################################
1140 AC_ARG_ENABLE(mpi-path,
1141               AC_HELP_STRING([--enable-mpi-path=EXTRA_PATH],
1142               [prepend EXTRA_PATH to list of CPU specific optimizations]),
1143               mpi_extra_path="$enableval",mpi_extra_path="")
1144 AC_MSG_CHECKING(architecture and mpi assembler functions)
1145 if test -f $srcdir/mpi/config.links ; then
1146     . $srcdir/mpi/config.links
1147     AC_CONFIG_LINKS("$mpi_ln_list")
1148     ac_cv_mpi_sflags="$mpi_sflags"
1149     AC_MSG_RESULT($mpi_cpu_arch)
1150 else
1151     AC_MSG_RESULT(failed)
1152     AC_MSG_ERROR([mpi/config.links missing!])
1153 fi
1154 MPI_SFLAGS="$ac_cv_mpi_sflags"
1155 AC_SUBST(MPI_SFLAGS)
1156
1157 AM_CONDITIONAL(MPI_MOD_ASM_MPIH_ADD1, test "$mpi_mod_asm_mpih_add1" = yes)
1158 AM_CONDITIONAL(MPI_MOD_ASM_MPIH_SUB1, test "$mpi_mod_asm_mpih_sub1" = yes)
1159 AM_CONDITIONAL(MPI_MOD_ASM_MPIH_MUL1, test "$mpi_mod_asm_mpih_mul1" = yes)
1160 AM_CONDITIONAL(MPI_MOD_ASM_MPIH_MUL2, test "$mpi_mod_asm_mpih_mul2" = yes)
1161 AM_CONDITIONAL(MPI_MOD_ASM_MPIH_MUL3, test "$mpi_mod_asm_mpih_mul3" = yes)
1162 AM_CONDITIONAL(MPI_MOD_ASM_MPIH_LSHIFT, test "$mpi_mod_asm_mpih_lshift" = yes)
1163 AM_CONDITIONAL(MPI_MOD_ASM_MPIH_RSHIFT, test "$mpi_mod_asm_mpih_rshift" = yes)
1164 AM_CONDITIONAL(MPI_MOD_ASM_UDIV, test "$mpi_mod_asm_udiv" = yes)
1165 AM_CONDITIONAL(MPI_MOD_ASM_UDIV_QRNND, test "$mpi_mod_asm_udiv_qrnnd" = yes)
1166 AM_CONDITIONAL(MPI_MOD_C_MPIH_ADD1, test "$mpi_mod_c_mpih_add1" = yes)
1167 AM_CONDITIONAL(MPI_MOD_C_MPIH_SUB1, test "$mpi_mod_c_mpih_sub1" = yes)
1168 AM_CONDITIONAL(MPI_MOD_C_MPIH_MUL1, test "$mpi_mod_c_mpih_mul1" = yes)
1169 AM_CONDITIONAL(MPI_MOD_C_MPIH_MUL2, test "$mpi_mod_c_mpih_mul2" = yes)
1170 AM_CONDITIONAL(MPI_MOD_C_MPIH_MUL3, test "$mpi_mod_c_mpih_mul3" = yes)
1171 AM_CONDITIONAL(MPI_MOD_C_MPIH_LSHIFT, test "$mpi_mod_c_mpih_lshift" = yes)
1172 AM_CONDITIONAL(MPI_MOD_C_MPIH_RSHIFT, test "$mpi_mod_c_mpih_rshift" = yes)
1173 AM_CONDITIONAL(MPI_MOD_C_UDIV, test "$mpi_mod_c_udiv" = yes)
1174 AM_CONDITIONAL(MPI_MOD_C_UDIV_QRNND, test "$mpi_mod_c_udiv_qrnnd" = yes)
1175
1176 # Reset non applicable feature flags.
1177 if test "$mpi_cpu_arch" != "x86" ; then
1178    aesnisupport="n/a"
1179    pclmulsupport="n/a"
1180    sse41support="n/a"
1181    avxsupport="n/a"
1182    avx2support="n/a"
1183    padlocksupport="n/a"
1184    drngsupport="n/a"
1185 fi
1186
1187 if test "$mpi_cpu_arch" != "arm" ; then
1188    if test "$mpi_cpu_arch" != "aarch64" ; then
1189      neonsupport="n/a"
1190      armcryptosupport="n/a"
1191    fi
1192 fi
1193
1194
1195 #############################################
1196 ####                                     ####
1197 #### Platform specific compiler checks.  ####
1198 ####                                     ####
1199 #############################################
1200
1201
1202 # Following tests depend on warnings to cause compile to fail, so set -Werror
1203 # temporarily.
1204 _gcc_cflags_save=$CFLAGS
1205 CFLAGS="$CFLAGS -Werror"
1206
1207
1208 #
1209 # Check whether compiler supports 'ms_abi' function attribute.
1210 #
1211 AC_CACHE_CHECK([whether compiler supports 'ms_abi' function attribute],
1212        [gcry_cv_gcc_attribute_ms_abi],
1213        [gcry_cv_gcc_attribute_ms_abi=no
1214         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1215           [[int __attribute__ ((ms_abi)) proto(int);]])],
1216           [gcry_cv_gcc_attribute_ms_abi=yes])])
1217 if test "$gcry_cv_gcc_attribute_ms_abi" = "yes" ; then
1218    AC_DEFINE(HAVE_GCC_ATTRIBUTE_MS_ABI,1,
1219      [Defined if compiler supports "__attribute__ ((ms_abi))" function attribute])
1220 fi
1221
1222
1223 #
1224 # Check whether compiler supports 'sysv_abi' function attribute.
1225 #
1226 AC_CACHE_CHECK([whether compiler supports 'sysv_abi' function attribute],
1227        [gcry_cv_gcc_attribute_sysv_abi],
1228        [gcry_cv_gcc_attribute_sysv_abi=no
1229         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1230           [[int __attribute__ ((sysv_abi)) proto(int);]])],
1231           [gcry_cv_gcc_attribute_sysv_abi=yes])])
1232 if test "$gcry_cv_gcc_attribute_sysv_abi" = "yes" ; then
1233    AC_DEFINE(HAVE_GCC_ATTRIBUTE_SYSV_ABI,1,
1234      [Defined if compiler supports "__attribute__ ((sysv_abi))" function attribute])
1235 fi
1236
1237
1238 #
1239 # Check whether default calling convention is 'ms_abi'.
1240 #
1241 if test "$gcry_cv_gcc_attribute_ms_abi" = "yes" ; then
1242    AC_CACHE_CHECK([whether default calling convention is 'ms_abi'],
1243           [gcry_cv_gcc_default_abi_is_ms_abi],
1244           [gcry_cv_gcc_default_abi_is_ms_abi=no
1245            AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1246              [[void *test(void) {
1247                  void *(*def_func)(void) = test;
1248                  void *__attribute__((ms_abi))(*msabi_func)(void);
1249                  /* warning on SysV abi targets, passes on Windows based targets */
1250                  msabi_func = def_func;
1251                  return msabi_func;
1252              }]])],
1253              [gcry_cv_gcc_default_abi_is_ms_abi=yes])])
1254    if test "$gcry_cv_gcc_default_abi_is_ms_abi" = "yes" ; then
1255       AC_DEFINE(HAVE_GCC_DEFAULT_ABI_IS_MS_ABI,1,
1256         [Defined if default calling convention is 'ms_abi'])
1257    fi
1258 fi
1259
1260
1261 #
1262 # Check whether default calling convention is 'sysv_abi'.
1263 #
1264 if test "$gcry_cv_gcc_attribute_sysv_abi" = "yes" ; then
1265    AC_CACHE_CHECK([whether default calling convention is 'sysv_abi'],
1266           [gcry_cv_gcc_default_abi_is_sysv_abi],
1267           [gcry_cv_gcc_default_abi_is_sysv_abi=no
1268            AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1269              [[void *test(void) {
1270                  void *(*def_func)(void) = test;
1271                  void *__attribute__((sysv_abi))(*sysvabi_func)(void);
1272                  /* warning on MS ABI targets, passes on SysV ABI targets */
1273                  sysvabi_func = def_func;
1274                  return sysvabi_func;
1275              }]])],
1276              [gcry_cv_gcc_default_abi_is_sysv_abi=yes])])
1277    if test "$gcry_cv_gcc_default_abi_is_sysv_abi" = "yes" ; then
1278       AC_DEFINE(HAVE_GCC_DEFAULT_ABI_IS_SYSV_ABI,1,
1279         [Defined if default calling convention is 'sysv_abi'])
1280    fi
1281 fi
1282
1283
1284 # Restore flags.
1285 CFLAGS=$_gcc_cflags_save;
1286
1287
1288 #
1289 # Check whether GCC inline assembler supports SSSE3 instructions
1290 # This is required for the AES-NI instructions.
1291 #
1292 AC_CACHE_CHECK([whether GCC inline assembler supports SSSE3 instructions],
1293        [gcry_cv_gcc_inline_asm_ssse3],
1294        [if test "$mpi_cpu_arch" != "x86" ; then
1295           gcry_cv_gcc_inline_asm_ssse3="n/a"
1296         else
1297           gcry_cv_gcc_inline_asm_ssse3=no
1298           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1299           [[static unsigned char be_mask[16] __attribute__ ((aligned (16))) =
1300               { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
1301             void a(void) {
1302               __asm__("pshufb %[mask], %%xmm2\n\t"::[mask]"m"(*be_mask):);
1303             }]])],
1304           [gcry_cv_gcc_inline_asm_ssse3=yes])
1305         fi])
1306 if test "$gcry_cv_gcc_inline_asm_ssse3" = "yes" ; then
1307    AC_DEFINE(HAVE_GCC_INLINE_ASM_SSSE3,1,
1308      [Defined if inline assembler supports SSSE3 instructions])
1309 fi
1310
1311
1312 #
1313 # Check whether GCC inline assembler supports PCLMUL instructions.
1314 #
1315 AC_CACHE_CHECK([whether GCC inline assembler supports PCLMUL instructions],
1316        [gcry_cv_gcc_inline_asm_pclmul],
1317        [if test "$mpi_cpu_arch" != "x86" ; then
1318           gcry_cv_gcc_inline_asm_pclmul="n/a"
1319         else
1320           gcry_cv_gcc_inline_asm_pclmul=no
1321           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1322           [[void a(void) {
1323               __asm__("pclmulqdq \$0, %%xmm1, %%xmm3\n\t":::"cc");
1324             }]])],
1325           [gcry_cv_gcc_inline_asm_pclmul=yes])
1326         fi])
1327 if test "$gcry_cv_gcc_inline_asm_pclmul" = "yes" ; then
1328    AC_DEFINE(HAVE_GCC_INLINE_ASM_PCLMUL,1,
1329      [Defined if inline assembler supports PCLMUL instructions])
1330 fi
1331
1332 #
1333 # Check whether GCC inline assembler supports SSE4.1 instructions.
1334 #
1335 AC_CACHE_CHECK([whether GCC inline assembler supports SSE4.1 instructions],
1336        [gcry_cv_gcc_inline_asm_sse41],
1337        [if test "$mpi_cpu_arch" != "x86" ; then
1338           gcry_cv_gcc_inline_asm_sse41="n/a"
1339         else
1340           gcry_cv_gcc_inline_asm_sse41=no
1341           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1342           [[void a(void) {
1343               int i;
1344               __asm__("pextrd \$2, %%xmm0, %[out]\n\t" : [out] "=m" (i));
1345             }]])],
1346           [gcry_cv_gcc_inline_asm_sse41=yes])
1347         fi])
1348 if test "$gcry_cv_gcc_inline_asm_sse41" = "yes" ; then
1349    AC_DEFINE(HAVE_GCC_INLINE_ASM_SSE41,1,
1350      [Defined if inline assembler supports SSE4.1 instructions])
1351 fi
1352
1353
1354 #
1355 # Check whether GCC inline assembler supports AVX instructions
1356 #
1357 AC_CACHE_CHECK([whether GCC inline assembler supports AVX instructions],
1358        [gcry_cv_gcc_inline_asm_avx],
1359        [if test "$mpi_cpu_arch" != "x86" ; then
1360           gcry_cv_gcc_inline_asm_avx="n/a"
1361         else
1362           gcry_cv_gcc_inline_asm_avx=no
1363           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1364           [[void a(void) {
1365               __asm__("xgetbv; vaesdeclast (%[mem]),%%xmm0,%%xmm7\n\t"::[mem]"r"(0):);
1366             }]])],
1367           [gcry_cv_gcc_inline_asm_avx=yes])
1368         fi])
1369 if test "$gcry_cv_gcc_inline_asm_avx" = "yes" ; then
1370    AC_DEFINE(HAVE_GCC_INLINE_ASM_AVX,1,
1371      [Defined if inline assembler supports AVX instructions])
1372 fi
1373
1374
1375 #
1376 # Check whether GCC inline assembler supports AVX2 instructions
1377 #
1378 AC_CACHE_CHECK([whether GCC inline assembler supports AVX2 instructions],
1379        [gcry_cv_gcc_inline_asm_avx2],
1380        [if test "$mpi_cpu_arch" != "x86" ; then
1381           gcry_cv_gcc_inline_asm_avx2="n/a"
1382         else
1383           gcry_cv_gcc_inline_asm_avx2=no
1384           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1385           [[void a(void) {
1386               __asm__("xgetbv; vpbroadcastb %%xmm7,%%ymm1\n\t":::"cc");
1387             }]])],
1388           [gcry_cv_gcc_inline_asm_avx2=yes])
1389         fi])
1390 if test "$gcry_cv_gcc_inline_asm_avx2" = "yes" ; then
1391    AC_DEFINE(HAVE_GCC_INLINE_ASM_AVX2,1,
1392      [Defined if inline assembler supports AVX2 instructions])
1393 fi
1394
1395
1396 #
1397 # Check whether GCC inline assembler supports BMI2 instructions
1398 #
1399 AC_CACHE_CHECK([whether GCC inline assembler supports BMI2 instructions],
1400        [gcry_cv_gcc_inline_asm_bmi2],
1401        [if test "$mpi_cpu_arch" != "x86" ; then
1402           gcry_cv_gcc_inline_asm_bmi2="n/a"
1403         else
1404           gcry_cv_gcc_inline_asm_bmi2=no
1405           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1406           [[void a(void) {
1407               __asm__("rorxl \$23, %%eax, %%edx\\n\\t":::"memory");
1408             }]])],
1409           [gcry_cv_gcc_inline_asm_bmi2=yes])
1410         fi])
1411 if test "$gcry_cv_gcc_inline_asm_bmi2" = "yes" ; then
1412    AC_DEFINE(HAVE_GCC_INLINE_ASM_BMI2,1,
1413      [Defined if inline assembler supports BMI2 instructions])
1414 fi
1415
1416
1417 #
1418 # Check whether GCC assembler needs "-Wa,--divide" to correctly handle
1419 # constant division
1420 #
1421 if test $amd64_as_feature_detection = yes; then
1422   AC_CACHE_CHECK([whether GCC assembler handles division correctly],
1423        [gcry_cv_gcc_as_const_division_ok],
1424        [gcry_cv_gcc_as_const_division_ok=no
1425         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1426           [[__asm__("xorl \$(123456789/12345678), %ebp;\n\t");]])],
1427           [gcry_cv_gcc_as_const_division_ok=yes])])
1428   if test "$gcry_cv_gcc_as_const_division_ok" = "no" ; then
1429     #
1430     # Add '-Wa,--divide' to CPPFLAGS and try check again.
1431     #
1432     _gcc_cppflags_save="$CPPFLAGS"
1433     CPPFLAGS="$CPPFLAGS -Wa,--divide"
1434     AC_CACHE_CHECK([whether GCC assembler handles division correctly with "-Wa,--divide"],
1435          [gcry_cv_gcc_as_const_division_with_wadivide_ok],
1436          [gcry_cv_gcc_as_const_division_with_wadivide_ok=no
1437           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1438             [[__asm__("xorl \$(123456789/12345678), %ebp;\n\t");]])],
1439             [gcry_cv_gcc_as_const_division_with_wadivide_ok=yes])])
1440     if test "$gcry_cv_gcc_as_const_division_with_wadivide_ok" = "no" ; then
1441       # '-Wa,--divide' did not work, restore old flags.
1442       CPPFLAGS="$_gcc_cppflags_save"
1443     fi
1444   fi
1445 fi
1446
1447
1448 #
1449 # Check whether GCC assembler supports features needed for our amd64
1450 # implementations
1451 #
1452 if test $amd64_as_feature_detection = yes; then
1453   AC_CACHE_CHECK([whether GCC assembler is compatible for amd64 assembly implementations],
1454        [gcry_cv_gcc_amd64_platform_as_ok],
1455        [if test "$mpi_cpu_arch" != "x86" ; then
1456           gcry_cv_gcc_amd64_platform_as_ok="n/a"
1457         else
1458           gcry_cv_gcc_amd64_platform_as_ok=no
1459           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1460           [[__asm__(
1461                 /* Test if '.type' and '.size' are supported.  */
1462                 /* These work only on ELF targets. */
1463                 "asmfunc:\n\t"
1464                 ".size asmfunc,.-asmfunc;\n\t"
1465                 ".type asmfunc,@function;\n\t"
1466                 /* Test if assembler allows use of '/' for constant division
1467                  * (Solaris/x86 issue). If previous constant division check
1468                  * and "-Wa,--divide" workaround failed, this causes assembly
1469                  * to be disable on this machine. */
1470                 "xorl \$(123456789/12345678), %ebp;\n\t"
1471             );]])],
1472           [gcry_cv_gcc_amd64_platform_as_ok=yes])
1473         fi])
1474   if test "$gcry_cv_gcc_amd64_platform_as_ok" = "yes" ; then
1475      AC_DEFINE(HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS,1,
1476               [Defined if underlying assembler is compatible with amd64 assembly implementations])
1477   fi
1478   if test "$gcry_cv_gcc_amd64_platform_as_ok" = "no" &&
1479      test "$gcry_cv_gcc_attribute_sysv_abi" = "yes" &&
1480      test "$gcry_cv_gcc_default_abi_is_ms_abi" = "yes"; then
1481     AC_CACHE_CHECK([whether GCC assembler is compatible for WIN64 assembly implementations],
1482       [gcry_cv_gcc_win64_platform_as_ok],
1483       [gcry_cv_gcc_win64_platform_as_ok=no
1484       AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1485         [[__asm__(
1486               ".globl asmfunc\n\t"
1487               "asmfunc:\n\t"
1488               "xorq \$(1234), %rbp;\n\t"
1489           );]])],
1490         [gcry_cv_gcc_win64_platform_as_ok=yes])])
1491     if test "$gcry_cv_gcc_win64_platform_as_ok" = "yes" ; then
1492       AC_DEFINE(HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS,1,
1493                 [Defined if underlying assembler is compatible with WIN64 assembly implementations])
1494     fi
1495   fi
1496 fi
1497
1498
1499 #
1500 # Check whether GCC assembler supports features needed for assembly
1501 # implementations that use Intel syntax
1502 #
1503 AC_CACHE_CHECK([whether GCC assembler is compatible for Intel syntax assembly implementations],
1504        [gcry_cv_gcc_platform_as_ok_for_intel_syntax],
1505        [if test "$mpi_cpu_arch" != "x86" ; then
1506           gcry_cv_gcc_platform_as_ok_for_intel_syntax="n/a"
1507         else
1508           gcry_cv_gcc_platform_as_ok_for_intel_syntax=no
1509           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1510           [[__asm__(
1511                 ".intel_syntax noprefix\n\t"
1512                 "pxor xmm1, xmm7;\n\t"
1513                 /* Intel syntax implementation also use GAS macros, so check
1514                  * for them here. */
1515                 "VAL_A = xmm4\n\t"
1516                 "VAL_B = xmm2\n\t"
1517                 ".macro SET_VAL_A p1\n\t"
1518                 "  VAL_A = \\\\p1 \n\t"
1519                 ".endm\n\t"
1520                 ".macro SET_VAL_B p1\n\t"
1521                 "  VAL_B = \\\\p1 \n\t"
1522                 ".endm\n\t"
1523                 "vmovdqa VAL_A, VAL_B;\n\t"
1524                 "SET_VAL_A eax\n\t"
1525                 "SET_VAL_B ebp\n\t"
1526                 "add VAL_A, VAL_B;\n\t"
1527                 "add VAL_B, 0b10101;\n\t"
1528             );]])],
1529           [gcry_cv_gcc_platform_as_ok_for_intel_syntax=yes])
1530         fi])
1531 if test "$gcry_cv_gcc_platform_as_ok_for_intel_syntax" = "yes" ; then
1532   AC_DEFINE(HAVE_INTEL_SYNTAX_PLATFORM_AS,1,
1533             [Defined if underlying assembler is compatible with Intel syntax assembly implementations])
1534 fi
1535
1536
1537 #
1538 # Check whether compiler is configured for ARMv6 or newer architecture
1539 #
1540 AC_CACHE_CHECK([whether compiler is configured for ARMv6 or newer architecture],
1541        [gcry_cv_cc_arm_arch_is_v6],
1542        [if test "$mpi_cpu_arch" != "arm" ; then
1543           gcry_cv_cc_arm_arch_is_v6="n/a"
1544         else
1545           gcry_cv_cc_arm_arch_is_v6=no
1546           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1547           [[
1548            #if defined(__arm__) && \
1549              ((defined(__ARM_ARCH) && __ARM_ARCH >= 6) \
1550              || defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) \
1551              || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) \
1552              || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6T2__) \
1553              || defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) \
1554              || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) \
1555              || defined(__ARM_ARCH_7EM__))
1556              /* empty */
1557            #else
1558              /* fail compile if not ARMv6. */
1559              not_armv6 not_armv6 = (not_armv6)not_armv6;
1560            #endif
1561           ]])],
1562           [gcry_cv_cc_arm_arch_is_v6=yes])
1563         fi])
1564 if test "$gcry_cv_cc_arm_arch_is_v6" = "yes" ; then
1565    AC_DEFINE(HAVE_ARM_ARCH_V6,1,
1566      [Defined if ARM architecture is v6 or newer])
1567 fi
1568
1569
1570 #
1571 # Check whether GCC inline assembler supports NEON instructions
1572 #
1573 AC_CACHE_CHECK([whether GCC inline assembler supports NEON instructions],
1574        [gcry_cv_gcc_inline_asm_neon],
1575        [if test "$mpi_cpu_arch" != "arm" ; then
1576           gcry_cv_gcc_inline_asm_neon="n/a"
1577         else
1578           gcry_cv_gcc_inline_asm_neon=no
1579           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1580           [[__asm__(
1581                 ".syntax unified\n\t"
1582                 ".arm\n\t"
1583                 ".fpu neon\n\t"
1584                 "vld1.64 {%q0-%q1}, [%r0]!;\n\t"
1585                 "vrev64.8 %q0, %q3;\n\t"
1586                 "vadd.u64 %q0, %q1;\n\t"
1587                 "vadd.s64 %d3, %d2, %d3;\n\t"
1588                 );
1589             ]])],
1590           [gcry_cv_gcc_inline_asm_neon=yes])
1591         fi])
1592 if test "$gcry_cv_gcc_inline_asm_neon" = "yes" ; then
1593    AC_DEFINE(HAVE_GCC_INLINE_ASM_NEON,1,
1594      [Defined if inline assembler supports NEON instructions])
1595 fi
1596
1597
1598 #
1599 # Check whether GCC inline assembler supports AArch32 Crypto Extension instructions
1600 #
1601 AC_CACHE_CHECK([whether GCC inline assembler supports AArch32 Crypto Extension instructions],
1602        [gcry_cv_gcc_inline_asm_aarch32_crypto],
1603        [if test "$mpi_cpu_arch" != "arm" ; then
1604           gcry_cv_gcc_inline_asm_aarch32_crypto="n/a"
1605         else
1606           gcry_cv_gcc_inline_asm_aarch32_crypto=no
1607           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1608           [[__asm__(
1609                 ".syntax unified\n\t"
1610                 ".arm\n\t"
1611                 ".fpu crypto-neon-fp-armv8\n\t"
1612
1613                 "sha1h.32 q0, q0;\n\t"
1614                 "sha1c.32 q0, q0, q0;\n\t"
1615                 "sha1p.32 q0, q0, q0;\n\t"
1616                 "sha1su0.32 q0, q0, q0;\n\t"
1617                 "sha1su1.32 q0, q0;\n\t"
1618
1619                 "sha256h.32 q0, q0, q0;\n\t"
1620                 "sha256h2.32 q0, q0, q0;\n\t"
1621                 "sha1p.32 q0, q0, q0;\n\t"
1622                 "sha256su0.32 q0, q0;\n\t"
1623                 "sha256su1.32 q0, q0, q15;\n\t"
1624
1625                 "aese.8 q0, q0;\n\t"
1626                 "aesd.8 q0, q0;\n\t"
1627                 "aesmc.8 q0, q0;\n\t"
1628                 "aesimc.8 q0, q0;\n\t"
1629
1630                 "vmull.p64 q0, d0, d0;\n\t"
1631                 );
1632             ]])],
1633           [gcry_cv_gcc_inline_asm_aarch32_crypto=yes])
1634         fi])
1635 if test "$gcry_cv_gcc_inline_asm_aarch32_crypto" = "yes" ; then
1636    AC_DEFINE(HAVE_GCC_INLINE_ASM_AARCH32_CRYPTO,1,
1637      [Defined if inline assembler supports AArch32 Crypto Extension instructions])
1638 fi
1639
1640
1641 #
1642 # Check whether GCC inline assembler supports AArch64 NEON instructions
1643 #
1644 AC_CACHE_CHECK([whether GCC inline assembler supports AArch64 NEON instructions],
1645        [gcry_cv_gcc_inline_asm_aarch64_neon],
1646        [if test "$mpi_cpu_arch" != "aarch64" ; then
1647           gcry_cv_gcc_inline_asm_aarch64_neon="n/a"
1648         else
1649           gcry_cv_gcc_inline_asm_aarch64_neon=no
1650           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1651           [[__asm__(
1652                 ".cpu generic+simd\n\t"
1653                 "mov w0, \#42;\n\t"
1654                 "dup v0.8b, w0;\n\t"
1655                 "ld4 {v0.8b,v1.8b,v2.8b,v3.8b},[x0],\#32;\n\t"
1656                 );
1657             ]])],
1658           [gcry_cv_gcc_inline_asm_aarch64_neon=yes])
1659         fi])
1660 if test "$gcry_cv_gcc_inline_asm_aarch64_neon" = "yes" ; then
1661    AC_DEFINE(HAVE_GCC_INLINE_ASM_AARCH64_NEON,1,
1662      [Defined if inline assembler supports AArch64 NEON instructions])
1663 fi
1664
1665
1666 #
1667 # Check whether GCC inline assembler supports AArch64 Crypto Extension instructions
1668 #
1669 AC_CACHE_CHECK([whether GCC inline assembler supports AArch64 Crypto Extension instructions],
1670        [gcry_cv_gcc_inline_asm_aarch64_crypto],
1671        [if test "$mpi_cpu_arch" != "aarch64" ; then
1672           gcry_cv_gcc_inline_asm_aarch64_crypto="n/a"
1673         else
1674           gcry_cv_gcc_inline_asm_aarch64_crypto=no
1675           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1676           [[__asm__(
1677                 ".cpu generic+simd+crypto\n\t"
1678
1679                 "mov w0, \#42;\n\t"
1680                 "dup v0.8b, w0;\n\t"
1681                 "ld4 {v0.8b,v1.8b,v2.8b,v3.8b},[x0],\#32;\n\t"
1682
1683                 "sha1h s0, s0;\n\t"
1684                 "sha1c q0, s0, v0.4s;\n\t"
1685                 "sha1p q0, s0, v0.4s;\n\t"
1686                 "sha1su0 v0.4s, v0.4s, v0.4s;\n\t"
1687                 "sha1su1 v0.4s, v0.4s;\n\t"
1688
1689                 "sha256h q0, q0, v0.4s;\n\t"
1690                 "sha256h2 q0, q0, v0.4s;\n\t"
1691                 "sha1p q0, s0, v0.4s;\n\t"
1692                 "sha256su0 v0.4s, v0.4s;\n\t"
1693                 "sha256su1 v0.4s, v0.4s, v31.4s;\n\t"
1694
1695                 "aese v0.16b, v0.16b;\n\t"
1696                 "aesd v0.16b, v0.16b;\n\t"
1697                 "aesmc v0.16b, v0.16b;\n\t"
1698                 "aesimc v0.16b, v0.16b;\n\t"
1699
1700                 "pmull v0.1q, v0.1d, v31.1d;\n\t"
1701                 "pmull2 v0.1q, v0.2d, v31.2d;\n\t"
1702                 );
1703             ]])],
1704           [gcry_cv_gcc_inline_asm_aarch64_crypto=yes])
1705         fi])
1706 if test "$gcry_cv_gcc_inline_asm_aarch64_crypto" = "yes" ; then
1707    AC_DEFINE(HAVE_GCC_INLINE_ASM_AARCH64_CRYPTO,1,
1708      [Defined if inline assembler supports AArch64 Crypto Extension instructions])
1709 fi
1710
1711
1712 #######################################
1713 #### Checks for library functions. ####
1714 #######################################
1715
1716 AC_FUNC_VPRINTF
1717 # We have replacements for these in src/missing-string.c
1718 AC_CHECK_FUNCS(stpcpy strcasecmp)
1719 # We have replacements for these in src/g10lib.h
1720 AC_CHECK_FUNCS(strtoul memmove stricmp atexit raise)
1721 # Other checks
1722 AC_CHECK_FUNCS(strerror rand mmap getpagesize sysconf waitpid wait4)
1723 AC_CHECK_FUNCS(gettimeofday getrusage gethrtime clock_gettime syslog)
1724 AC_CHECK_FUNCS(syscall fcntl ftruncate flockfile)
1725
1726 GNUPG_CHECK_MLOCK
1727
1728 #
1729 # Replacement functions.
1730 #
1731 AC_REPLACE_FUNCS([getpid clock])
1732
1733
1734 #
1735 # Check wether it is necessary to link against libdl.
1736 #
1737 DL_LIBS=""
1738 if test "$use_hmac_binary_check" = yes ; then
1739   _gcry_save_libs="$LIBS"
1740   LIBS=""
1741   AC_SEARCH_LIBS(dlopen, c dl,,,)
1742   DL_LIBS=$LIBS
1743   LIBS="$_gcry_save_libs"
1744   LIBGCRYPT_CONFIG_LIBS="${LIBGCRYPT_CONFIG_LIBS} ${DL_LIBS}"
1745 fi
1746 AC_SUBST(DL_LIBS)
1747
1748
1749 #
1750 # Check whether we can use Linux capabilities as requested.
1751 #
1752 if test "$use_capabilities" = "yes" ; then
1753 use_capabilities=no
1754 AC_CHECK_HEADERS(sys/capability.h)
1755 if test "$ac_cv_header_sys_capability_h" = "yes" ; then
1756   AC_CHECK_LIB(cap, cap_init, ac_need_libcap=1)
1757   if test "$ac_cv_lib_cap_cap_init" = "yes"; then
1758      AC_DEFINE(USE_CAPABILITIES,1,
1759                [define if capabilities should be used])
1760      LIBS="$LIBS -lcap"
1761      use_capabilities=yes
1762   fi
1763 fi
1764 if test "$use_capabilities" = "no" ; then
1765     AC_MSG_WARN([[
1766 ***
1767 *** The use of capabilities on this system is not possible.
1768 *** You need a recent Linux kernel and some patches:
1769 ***   fcaps-2.2.9-990610.patch      (kernel patch for 2.2.9)
1770 ***   fcap-module-990613.tar.gz     (kernel module)
1771 ***   libcap-1.92.tar.gz            (user mode library and utilities)
1772 *** And you have to configure the kernel with CONFIG_VFS_CAP_PLUGIN
1773 *** set (filesystems menu). Be warned: This code is *really* ALPHA.
1774 ***]])
1775 fi
1776 fi
1777
1778 # Check whether a random device is available.
1779 if test "$try_dev_random" = yes ; then
1780     AC_CACHE_CHECK(for random device, ac_cv_have_dev_random,
1781     [if test -r "$NAME_OF_DEV_RANDOM" && test -r "$NAME_OF_DEV_URANDOM" ; then
1782       ac_cv_have_dev_random=yes; else ac_cv_have_dev_random=no; fi])
1783     if test "$ac_cv_have_dev_random" = yes; then
1784         AC_DEFINE(HAVE_DEV_RANDOM,1,
1785                  [defined if the system supports a random device] )
1786     fi
1787 else
1788     AC_MSG_CHECKING(for random device)
1789     ac_cv_have_dev_random=no
1790     AC_MSG_RESULT(has been disabled)
1791 fi
1792
1793 # Figure out the random modules for this configuration.
1794 if test "$random" = "default"; then
1795
1796     # Select default value.
1797     if test "$ac_cv_have_dev_random" = yes; then
1798         # Try Linuxish random device.
1799         random_modules="linux"
1800     else
1801         case "${host}" in
1802         *-*-mingw32ce*)
1803           # WindowsCE random device.
1804           random_modules="w32ce"
1805           ;;
1806         *-*-mingw32*|*-*-cygwin*)
1807           # Windows random device.
1808           random_modules="w32"
1809           ;;
1810         *)
1811           # Build everything, allow to select at runtime.
1812           random_modules="$auto_random_modules"
1813           ;;
1814         esac
1815     fi
1816 else
1817     if test "$random" = "auto"; then
1818         # Build everything, allow to select at runtime.
1819         random_modules="$auto_random_modules"
1820     else
1821         random_modules="$random"
1822     fi
1823 fi
1824
1825
1826 #
1827 # Other defines
1828 #
1829 if test mym4_isgit = "yes"; then
1830     AC_DEFINE(IS_DEVELOPMENT_VERSION,1,
1831               [Defined if this is not a regular release])
1832 fi
1833
1834
1835 AM_CONDITIONAL(CROSS_COMPILING, test x$cross_compiling = xyes)
1836
1837
1838 # This is handy for debugging so the compiler doesn't rearrange
1839 # things and eliminate variables.
1840 AC_ARG_ENABLE(optimization,
1841        AC_HELP_STRING([--disable-optimization],
1842                       [disable compiler optimization]),
1843                       [if test $enableval = no ; then
1844                          CFLAGS=`echo $CFLAGS | sed 's/-O[[0-9]]//'`
1845                        fi])
1846
1847 # CFLAGS mangling when using gcc.
1848 if test "$GCC" = yes; then
1849     CFLAGS="$CFLAGS -Wall"
1850     if test "$USE_MAINTAINER_MODE" = "yes"; then
1851         CFLAGS="$CFLAGS -Wcast-align -Wshadow -Wstrict-prototypes"
1852         CFLAGS="$CFLAGS -Wformat -Wno-format-y2k -Wformat-security"
1853
1854         # If -Wno-missing-field-initializers is supported we can enable a
1855         # a bunch of really useful warnings.
1856         AC_MSG_CHECKING([if gcc supports -Wno-missing-field-initializers])
1857         _gcc_cflags_save=$CFLAGS
1858         CFLAGS="-Wno-missing-field-initializers"
1859         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[])],_gcc_wopt=yes,_gcc_wopt=no)
1860         AC_MSG_RESULT($_gcc_wopt)
1861         CFLAGS=$_gcc_cflags_save;
1862         if test x"$_gcc_wopt" = xyes ; then
1863           CFLAGS="$CFLAGS -W -Wextra -Wbad-function-cast"
1864           CFLAGS="$CFLAGS -Wwrite-strings"
1865           CFLAGS="$CFLAGS -Wdeclaration-after-statement"
1866           CFLAGS="$CFLAGS -Wno-missing-field-initializers"
1867           CFLAGS="$CFLAGS -Wno-sign-compare"
1868         fi
1869
1870         AC_MSG_CHECKING([if gcc supports -Wpointer-arith])
1871         _gcc_cflags_save=$CFLAGS
1872         CFLAGS="-Wpointer-arith"
1873         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[])],_gcc_wopt=yes,_gcc_wopt=no)
1874         AC_MSG_RESULT($_gcc_wopt)
1875         CFLAGS=$_gcc_cflags_save;
1876         if test x"$_gcc_wopt" = xyes ; then
1877           CFLAGS="$CFLAGS -Wpointer-arith"
1878         fi
1879     fi
1880
1881 fi
1882
1883 # Check whether as(1) supports a noeexecstack feature.  This test
1884 # includes an override option.
1885 CL_AS_NOEXECSTACK
1886
1887
1888 AC_SUBST(LIBGCRYPT_CONFIG_API_VERSION)
1889 AC_SUBST(LIBGCRYPT_CONFIG_LIBS)
1890 AC_SUBST(LIBGCRYPT_CONFIG_CFLAGS)
1891 AC_SUBST(LIBGCRYPT_CONFIG_HOST)
1892 AC_SUBST(LIBGCRYPT_THREAD_MODULES)
1893
1894 AC_CONFIG_COMMANDS([gcrypt-conf],[[
1895 chmod +x src/libgcrypt-config
1896 ]],[[
1897 prefix=$prefix
1898 exec_prefix=$exec_prefix
1899 libdir=$libdir
1900 datadir=$datadir
1901 DATADIRNAME=$DATADIRNAME
1902 ]])
1903
1904 #####################
1905 #### Conclusion. ####
1906 #####################
1907
1908 # Check that requested feature can actually be used and define
1909 # ENABLE_foo_SUPPORT macros.
1910
1911 if test x"$aesnisupport" = xyes ; then
1912   if test "$gcry_cv_gcc_inline_asm_ssse3" != "yes" ; then
1913     aesnisupport="no (unsupported by compiler)"
1914   fi
1915 fi
1916 if test x"$pclmulsupport" = xyes ; then
1917   if test "$gcry_cv_gcc_inline_asm_pclmul" != "yes" ; then
1918     pclmulsupport="no (unsupported by compiler)"
1919   fi
1920 fi
1921 if test x"$sse41support" = xyes ; then
1922   if test "$gcry_cv_gcc_inline_asm_sse41" != "yes" ; then
1923     sse41support="no (unsupported by compiler)"
1924   fi
1925 fi
1926 if test x"$avxsupport" = xyes ; then
1927   if test "$gcry_cv_gcc_inline_asm_avx" != "yes" ; then
1928     avxsupport="no (unsupported by compiler)"
1929   fi
1930 fi
1931 if test x"$avx2support" = xyes ; then
1932   if test "$gcry_cv_gcc_inline_asm_avx2" != "yes" ; then
1933     avx2support="no (unsupported by compiler)"
1934   fi
1935 fi
1936 if test x"$neonsupport" = xyes ; then
1937   if test "$gcry_cv_gcc_inline_asm_neon" != "yes" ; then
1938     if test "$gcry_cv_gcc_inline_asm_aarch64_neon" != "yes" ; then
1939       neonsupport="no (unsupported by compiler)"
1940     fi
1941   fi
1942 fi
1943 if test x"$armcryptosupport" = xyes ; then
1944   if test "$gcry_cv_gcc_inline_asm_aarch32_crypto" != "yes" ; then
1945     if test "$gcry_cv_gcc_inline_asm_aarch64_crypto" != "yes" ; then
1946       neonsupport="no (unsupported by compiler)"
1947     fi
1948   fi
1949 fi
1950
1951 if test x"$aesnisupport" = xyes ; then
1952   AC_DEFINE(ENABLE_AESNI_SUPPORT, 1,
1953             [Enable support for Intel AES-NI instructions.])
1954 fi
1955 if test x"$pclmulsupport" = xyes ; then
1956   AC_DEFINE(ENABLE_PCLMUL_SUPPORT, 1,
1957             [Enable support for Intel PCLMUL instructions.])
1958 fi
1959 if test x"$sse41support" = xyes ; then
1960   AC_DEFINE(ENABLE_SSE41_SUPPORT, 1,
1961             [Enable support for Intel SSE4.1 instructions.])
1962 fi
1963 if test x"$avxsupport" = xyes ; then
1964   AC_DEFINE(ENABLE_AVX_SUPPORT,1,
1965             [Enable support for Intel AVX instructions.])
1966 fi
1967 if test x"$avx2support" = xyes ; then
1968   AC_DEFINE(ENABLE_AVX2_SUPPORT,1,
1969             [Enable support for Intel AVX2 instructions.])
1970 fi
1971 if test x"$neonsupport" = xyes ; then
1972   AC_DEFINE(ENABLE_NEON_SUPPORT,1,
1973             [Enable support for ARM NEON instructions.])
1974 fi
1975 if test x"$armcryptosupport" = xyes ; then
1976   AC_DEFINE(ENABLE_ARM_CRYPTO_SUPPORT,1,
1977             [Enable support for ARMv8 Crypto Extension instructions.])
1978 fi
1979 if test x"$padlocksupport" = xyes ; then
1980   AC_DEFINE(ENABLE_PADLOCK_SUPPORT, 1,
1981             [Enable support for the PadLock engine.])
1982 fi
1983 if test x"$drngsupport" = xyes ; then
1984   AC_DEFINE(ENABLE_DRNG_SUPPORT, 1,
1985             [Enable support for Intel DRNG (RDRAND instruction).])
1986 fi
1987
1988
1989 # Define conditional sources and config.h symbols depending on the
1990 # selected ciphers, pubkey-ciphers, digests, kdfs, and random modules.
1991
1992 LIST_MEMBER(arcfour, $enabled_ciphers)
1993 if test "$found" = "1"; then
1994    GCRYPT_CIPHERS="$GCRYPT_CIPHERS arcfour.lo"
1995    AC_DEFINE(USE_ARCFOUR, 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 arcfour-amd64.lo"
2001       ;;
2002    esac
2003 fi
2004
2005 LIST_MEMBER(blowfish, $enabled_ciphers)
2006 if test "$found" = "1" ; then
2007    GCRYPT_CIPHERS="$GCRYPT_CIPHERS blowfish.lo"
2008    AC_DEFINE(USE_BLOWFISH, 1, [Defined if this module should be included])
2009
2010    case "${host}" in
2011       x86_64-*-*)
2012          # Build with the assembly implementation
2013          GCRYPT_CIPHERS="$GCRYPT_CIPHERS blowfish-amd64.lo"
2014       ;;
2015       arm*-*-*)
2016          # Build with the assembly implementation
2017          GCRYPT_CIPHERS="$GCRYPT_CIPHERS blowfish-arm.lo"
2018       ;;
2019    esac
2020 fi
2021
2022 LIST_MEMBER(cast5, $enabled_ciphers)
2023 if test "$found" = "1" ; then
2024    GCRYPT_CIPHERS="$GCRYPT_CIPHERS cast5.lo"
2025    AC_DEFINE(USE_CAST5, 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 cast5-amd64.lo"
2031       ;;
2032       arm*-*-*)
2033          # Build with the assembly implementation
2034          GCRYPT_CIPHERS="$GCRYPT_CIPHERS cast5-arm.lo"
2035       ;;
2036    esac
2037 fi
2038
2039 LIST_MEMBER(des, $enabled_ciphers)
2040 if test "$found" = "1" ; then
2041    GCRYPT_CIPHERS="$GCRYPT_CIPHERS des.lo"
2042    AC_DEFINE(USE_DES, 1, [Defined if this module should be included])
2043
2044    case "${host}" in
2045       x86_64-*-*)
2046          # Build with the assembly implementation
2047          GCRYPT_CIPHERS="$GCRYPT_CIPHERS des-amd64.lo"
2048       ;;
2049    esac
2050 fi
2051
2052 LIST_MEMBER(aes, $enabled_ciphers)
2053 if test "$found" = "1" ; then
2054    GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael.lo"
2055    AC_DEFINE(USE_AES, 1, [Defined if this module should be included])
2056
2057    case "${host}" in
2058       x86_64-*-*)
2059          # Build with the assembly implementation
2060          GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael-amd64.lo"
2061
2062          # Build with the SSSE3 implementation
2063          GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael-ssse3-amd64.lo"
2064          GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael-ssse3-amd64-asm.lo"
2065       ;;
2066       arm*-*-*)
2067          # Build with the assembly implementation
2068          GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael-arm.lo"
2069
2070          # Build with the ARMv8/AArch32 CE implementation
2071          GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael-armv8-ce.lo"
2072          GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael-armv8-aarch32-ce.lo"
2073       ;;
2074       aarch64-*-*)
2075          # Build with the assembly implementation
2076          GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael-aarch64.lo"
2077
2078          # Build with the ARMv8/AArch64 CE implementation
2079          GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael-armv8-ce.lo"
2080          GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael-armv8-aarch64-ce.lo"
2081       ;;
2082    esac
2083
2084    case "$mpi_cpu_arch" in
2085      x86)
2086          # Build with the AES-NI implementation
2087          GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael-aesni.lo"
2088
2089          # Build with the Padlock implementation
2090          GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael-padlock.lo"
2091       ;;
2092    esac
2093 fi
2094
2095 LIST_MEMBER(twofish, $enabled_ciphers)
2096 if test "$found" = "1" ; then
2097    GCRYPT_CIPHERS="$GCRYPT_CIPHERS twofish.lo"
2098    AC_DEFINE(USE_TWOFISH, 1, [Defined if this module should be included])
2099
2100    case "${host}" in
2101       x86_64-*-*)
2102          # Build with the assembly implementation
2103          GCRYPT_CIPHERS="$GCRYPT_CIPHERS twofish-amd64.lo"
2104
2105          if test x"$avx2support" = xyes ; then
2106             # Build with the AVX2 implementation
2107             GCRYPT_CIPHERS="$GCRYPT_CIPHERS twofish-avx2-amd64.lo"
2108          fi
2109       ;;
2110       arm*-*-*)
2111          # Build with the assembly implementation
2112          GCRYPT_CIPHERS="$GCRYPT_CIPHERS twofish-arm.lo"
2113       ;;
2114       aarch64-*-*)
2115          # Build with the assembly implementation
2116          GCRYPT_CIPHERS="$GCRYPT_CIPHERS twofish-aarch64.lo"
2117       ;;
2118    esac
2119 fi
2120
2121 LIST_MEMBER(serpent, $enabled_ciphers)
2122 if test "$found" = "1" ; then
2123    GCRYPT_CIPHERS="$GCRYPT_CIPHERS serpent.lo"
2124    AC_DEFINE(USE_SERPENT, 1, [Defined if this module should be included])
2125
2126    case "${host}" in
2127       x86_64-*-*)
2128          # Build with the SSE2 implementation
2129          GCRYPT_CIPHERS="$GCRYPT_CIPHERS serpent-sse2-amd64.lo"
2130       ;;
2131    esac
2132
2133    if test x"$avx2support" = xyes ; then
2134       # Build with the AVX2 implementation
2135       GCRYPT_CIPHERS="$GCRYPT_CIPHERS serpent-avx2-amd64.lo"
2136    fi
2137
2138    if test x"$neonsupport" = xyes ; then
2139       # Build with the NEON implementation
2140       GCRYPT_CIPHERS="$GCRYPT_CIPHERS serpent-armv7-neon.lo"
2141    fi
2142 fi
2143
2144 LIST_MEMBER(rfc2268, $enabled_ciphers)
2145 if test "$found" = "1" ; then
2146    GCRYPT_CIPHERS="$GCRYPT_CIPHERS rfc2268.lo"
2147    AC_DEFINE(USE_RFC2268, 1, [Defined if this module should be included])
2148 fi
2149
2150 LIST_MEMBER(seed, $enabled_ciphers)
2151 if test "$found" = "1" ; then
2152    GCRYPT_CIPHERS="$GCRYPT_CIPHERS seed.lo"
2153    AC_DEFINE(USE_SEED, 1, [Defined if this module should be included])
2154 fi
2155
2156 LIST_MEMBER(camellia, $enabled_ciphers)
2157 if test "$found" = "1" ; then
2158    GCRYPT_CIPHERS="$GCRYPT_CIPHERS camellia.lo camellia-glue.lo"
2159    AC_DEFINE(USE_CAMELLIA, 1, [Defined if this module should be included])
2160
2161    case "${host}" in
2162       arm*-*-*)
2163          # Build with the assembly implementation
2164          GCRYPT_CIPHERS="$GCRYPT_CIPHERS camellia-arm.lo"
2165       ;;
2166       aarch64-*-*)
2167          # Build with the assembly implementation
2168          GCRYPT_CIPHERS="$GCRYPT_CIPHERS camellia-aarch64.lo"
2169       ;;
2170    esac
2171
2172    if test x"$avxsupport" = xyes ; then
2173       if test x"$aesnisupport" = xyes ; then
2174         # Build with the AES-NI/AVX implementation
2175         GCRYPT_CIPHERS="$GCRYPT_CIPHERS camellia-aesni-avx-amd64.lo"
2176       fi
2177    fi
2178
2179    if test x"$avx2support" = xyes ; then
2180       if test x"$aesnisupport" = xyes ; then
2181         # Build with the AES-NI/AVX2 implementation
2182         GCRYPT_CIPHERS="$GCRYPT_CIPHERS camellia-aesni-avx2-amd64.lo"
2183       fi
2184    fi
2185 fi
2186
2187 LIST_MEMBER(idea, $enabled_ciphers)
2188 if test "$found" = "1" ; then
2189    GCRYPT_CIPHERS="$GCRYPT_CIPHERS idea.lo"
2190    AC_DEFINE(USE_IDEA, 1, [Defined if this module should be included])
2191 fi
2192
2193 LIST_MEMBER(salsa20, $enabled_ciphers)
2194 if test "$found" = "1" ; then
2195    GCRYPT_CIPHERS="$GCRYPT_CIPHERS salsa20.lo"
2196    AC_DEFINE(USE_SALSA20, 1, [Defined if this module should be included])
2197
2198    case "${host}" in
2199       x86_64-*-*)
2200          # Build with the assembly implementation
2201          GCRYPT_CIPHERS="$GCRYPT_CIPHERS salsa20-amd64.lo"
2202       ;;
2203    esac
2204
2205    if test x"$neonsupport" = xyes ; then
2206      # Build with the NEON implementation
2207      GCRYPT_CIPHERS="$GCRYPT_CIPHERS salsa20-armv7-neon.lo"
2208    fi
2209 fi
2210
2211 LIST_MEMBER(gost28147, $enabled_ciphers)
2212 if test "$found" = "1" ; then
2213    GCRYPT_CIPHERS="$GCRYPT_CIPHERS gost28147.lo"
2214    AC_DEFINE(USE_GOST28147, 1, [Defined if this module should be included])
2215 fi
2216
2217 LIST_MEMBER(chacha20, $enabled_ciphers)
2218 if test "$found" = "1" ; then
2219    GCRYPT_CIPHERS="$GCRYPT_CIPHERS chacha20.lo"
2220    AC_DEFINE(USE_CHACHA20, 1, [Defined if this module should be included])
2221
2222    case "${host}" in
2223       x86_64-*-*)
2224          # Build with the assembly implementation
2225          GCRYPT_CIPHERS="$GCRYPT_CIPHERS chacha20-sse2-amd64.lo"
2226          GCRYPT_CIPHERS="$GCRYPT_CIPHERS chacha20-ssse3-amd64.lo"
2227          GCRYPT_CIPHERS="$GCRYPT_CIPHERS chacha20-avx2-amd64.lo"
2228       ;;
2229    esac
2230
2231    if test x"$neonsupport" = xyes ; then
2232      # Build with the NEON implementation
2233      GCRYPT_CIPHERS="$GCRYPT_CIPHERS chacha20-armv7-neon.lo"
2234    fi
2235 fi
2236
2237 case "${host}" in
2238    x86_64-*-*)
2239       # Build with the assembly implementation
2240       GCRYPT_CIPHERS="$GCRYPT_CIPHERS poly1305-sse2-amd64.lo"
2241       GCRYPT_CIPHERS="$GCRYPT_CIPHERS poly1305-avx2-amd64.lo"
2242    ;;
2243 esac
2244
2245 if test x"$neonsupport" = xyes ; then
2246    # Build with the NEON implementation
2247    GCRYPT_CIPHERS="$GCRYPT_CIPHERS poly1305-armv7-neon.lo"
2248 fi
2249
2250 LIST_MEMBER(dsa, $enabled_pubkey_ciphers)
2251 if test "$found" = "1" ; then
2252    GCRYPT_PUBKEY_CIPHERS="$GCRYPT_PUBKEY_CIPHERS dsa.lo"
2253    AC_DEFINE(USE_DSA, 1, [Defined if this module should be included])
2254 fi
2255
2256 LIST_MEMBER(rsa, $enabled_pubkey_ciphers)
2257 if test "$found" = "1" ; then
2258    GCRYPT_PUBKEY_CIPHERS="$GCRYPT_PUBKEY_CIPHERS rsa.lo"
2259    AC_DEFINE(USE_RSA, 1, [Defined if this module should be included])
2260 fi
2261
2262 LIST_MEMBER(elgamal, $enabled_pubkey_ciphers)
2263 if test "$found" = "1" ; then
2264    GCRYPT_PUBKEY_CIPHERS="$GCRYPT_PUBKEY_CIPHERS elgamal.lo"
2265    AC_DEFINE(USE_ELGAMAL, 1, [Defined if this module should be included])
2266 fi
2267
2268 LIST_MEMBER(ecc, $enabled_pubkey_ciphers)
2269 if test "$found" = "1" ; then
2270    GCRYPT_PUBKEY_CIPHERS="$GCRYPT_PUBKEY_CIPHERS \
2271                           ecc.lo ecc-curves.lo ecc-misc.lo \
2272                           ecc-ecdsa.lo ecc-eddsa.lo ecc-gost.lo"
2273    AC_DEFINE(USE_ECC, 1, [Defined if this module should be included])
2274 fi
2275
2276 LIST_MEMBER(crc, $enabled_digests)
2277 if test "$found" = "1" ; then
2278    GCRYPT_DIGESTS="$GCRYPT_DIGESTS crc.lo"
2279    AC_DEFINE(USE_CRC, 1, [Defined if this module should be included])
2280
2281    case "${host}" in
2282       i?86-*-* | x86_64-*-*)
2283          # Build with the assembly implementation
2284          GCRYPT_DIGESTS="$GCRYPT_DIGESTS crc-intel-pclmul.lo"
2285       ;;
2286    esac
2287 fi
2288
2289 LIST_MEMBER(gostr3411-94, $enabled_digests)
2290 if test "$found" = "1" ; then
2291    # GOST R 34.11-94 internally uses GOST 28147-89
2292    LIST_MEMBER(gost28147, $enabled_ciphers)
2293    if test "$found" = "1" ; then
2294       GCRYPT_DIGESTS="$GCRYPT_DIGESTS gostr3411-94.lo"
2295       AC_DEFINE(USE_GOST_R_3411_94, 1, [Defined if this module should be included])
2296    fi
2297 fi
2298
2299 LIST_MEMBER(stribog, $enabled_digests)
2300 if test "$found" = "1" ; then
2301    GCRYPT_DIGESTS="$GCRYPT_DIGESTS stribog.lo"
2302    AC_DEFINE(USE_GOST_R_3411_12, 1, [Defined if this module should be included])
2303 fi
2304
2305 LIST_MEMBER(md2, $enabled_digests)
2306 if test "$found" = "1" ; then
2307    GCRYPT_DIGESTS="$GCRYPT_DIGESTS md2.lo"
2308    AC_DEFINE(USE_MD2, 1, [Defined if this module should be included])
2309 fi
2310
2311 LIST_MEMBER(md4, $enabled_digests)
2312 if test "$found" = "1" ; then
2313    GCRYPT_DIGESTS="$GCRYPT_DIGESTS md4.lo"
2314    AC_DEFINE(USE_MD4, 1, [Defined if this module should be included])
2315 fi
2316
2317 LIST_MEMBER(md5, $enabled_digests)
2318 if test "$found" = "1" ; then
2319    GCRYPT_DIGESTS="$GCRYPT_DIGESTS md5.lo"
2320    AC_DEFINE(USE_MD5, 1, [Defined if this module should be included])
2321 fi
2322
2323 LIST_MEMBER(rmd160, $enabled_digests)
2324 if test "$found" = "1" ; then
2325    GCRYPT_DIGESTS="$GCRYPT_DIGESTS rmd160.lo"
2326    AC_DEFINE(USE_RMD160, 1, [Defined if this module should be included])
2327 fi
2328
2329 LIST_MEMBER(sha256, $enabled_digests)
2330 if test "$found" = "1" ; then
2331    GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha256.lo"
2332    AC_DEFINE(USE_SHA256, 1, [Defined if this module should be included])
2333
2334    case "${host}" in
2335       x86_64-*-*)
2336          # Build with the assembly implementation
2337          GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha256-ssse3-amd64.lo"
2338          GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha256-avx-amd64.lo"
2339          GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha256-avx2-bmi2-amd64.lo"
2340       ;;
2341       arm*-*-*)
2342          # Build with the assembly implementation
2343          GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha256-armv8-aarch32-ce.lo"
2344       ;;
2345       aarch64-*-*)
2346          # Build with the assembly implementation
2347          GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha256-armv8-aarch64-ce.lo"
2348       ;;
2349    esac
2350 fi
2351
2352 LIST_MEMBER(sha512, $enabled_digests)
2353 if test "$found" = "1" ; then
2354    GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha512.lo"
2355    AC_DEFINE(USE_SHA512, 1, [Defined if this module should be included])
2356
2357    case "${host}" in
2358       x86_64-*-*)
2359          # Build with the assembly implementation
2360          GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha512-ssse3-amd64.lo"
2361          GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha512-avx-amd64.lo"
2362          GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha512-avx2-bmi2-amd64.lo"
2363       ;;
2364       arm*-*-*)
2365          # Build with the assembly implementation
2366          GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha512-arm.lo"
2367       ;;
2368    esac
2369
2370    if test x"$neonsupport" = xyes ; then
2371      # Build with the NEON implementation
2372      GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha512-armv7-neon.lo"
2373    fi
2374 fi
2375
2376 LIST_MEMBER(sha3, $enabled_digests)
2377 if test "$found" = "1" ; then
2378    GCRYPT_DIGESTS="$GCRYPT_DIGESTS keccak.lo"
2379    AC_DEFINE(USE_SHA3, 1, [Defined if this module should be included])
2380
2381    case "${host}" in
2382       x86_64-*-*)
2383          # Build with the assembly implementation
2384          :
2385       ;;
2386    esac
2387
2388    if test x"$neonsupport" = xyes ; then
2389      # Build with the NEON implementation
2390      GCRYPT_DIGESTS="$GCRYPT_DIGESTS keccak-armv7-neon.lo"
2391    fi
2392 fi
2393
2394 LIST_MEMBER(tiger, $enabled_digests)
2395 if test "$found" = "1" ; then
2396    GCRYPT_DIGESTS="$GCRYPT_DIGESTS tiger.lo"
2397    AC_DEFINE(USE_TIGER, 1, [Defined if this module should be included])
2398 fi
2399
2400 LIST_MEMBER(whirlpool, $enabled_digests)
2401 if test "$found" = "1" ; then
2402    GCRYPT_DIGESTS="$GCRYPT_DIGESTS whirlpool.lo"
2403    AC_DEFINE(USE_WHIRLPOOL, 1, [Defined if this module should be included])
2404
2405    case "${host}" in
2406       x86_64-*-*)
2407          # Build with the assembly implementation
2408          GCRYPT_DIGESTS="$GCRYPT_DIGESTS whirlpool-sse2-amd64.lo"
2409       ;;
2410    esac
2411 fi
2412
2413 LIST_MEMBER(blake2, $enabled_digests)
2414 if test "$found" = "1" ; then
2415    GCRYPT_DIGESTS="$GCRYPT_DIGESTS blake2.lo"
2416    AC_DEFINE(USE_BLAKE2, 1, [Defined if this module should be included])
2417 fi
2418
2419 # SHA-1 needs to be included always for example because it is used by
2420 # random-csprng.c.
2421 GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha1.lo"
2422 AC_DEFINE(USE_SHA1, 1,   [Defined if this module should be included])
2423
2424 case "${host}" in
2425   x86_64-*-*)
2426     # Build with the assembly implementation
2427     GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha1-ssse3-amd64.lo"
2428     GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha1-avx-amd64.lo"
2429     GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha1-avx-bmi2-amd64.lo"
2430   ;;
2431   arm*-*-*)
2432     # Build with the assembly implementation
2433     GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha1-armv7-neon.lo"
2434     GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha1-armv8-aarch32-ce.lo"
2435   ;;
2436   aarch64-*-*)
2437     # Build with the assembly implementation
2438     GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha1-armv8-aarch64-ce.lo"
2439   ;;
2440 esac
2441
2442 LIST_MEMBER(scrypt, $enabled_kdfs)
2443 if test "$found" = "1" ; then
2444    GCRYPT_KDFS="$GCRYPT_KDFS scrypt.lo"
2445    AC_DEFINE(USE_SCRYPT, 1, [Defined if this module should be included])
2446 fi
2447
2448 LIST_MEMBER(linux, $random_modules)
2449 if test "$found" = "1" ; then
2450    GCRYPT_RANDOM="$GCRYPT_RANDOM rndlinux.lo"
2451    AC_DEFINE(USE_RNDLINUX, 1, [Defined if the /dev/random RNG should be used.])
2452 fi
2453
2454 LIST_MEMBER(unix, $random_modules)
2455 if test "$found" = "1" ; then
2456    GCRYPT_RANDOM="$GCRYPT_RANDOM rndunix.lo"
2457    AC_DEFINE(USE_RNDUNIX, 1, [Defined if the default Unix RNG should be used.])
2458    print_egd_notice=yes
2459 fi
2460
2461 LIST_MEMBER(egd, $random_modules)
2462 if test "$found" = "1" ; then
2463    GCRYPT_RANDOM="$GCRYPT_RANDOM rndegd.lo"
2464    AC_DEFINE(USE_RNDEGD, 1, [Defined if the EGD based RNG should be used.])
2465 fi
2466
2467 LIST_MEMBER(w32, $random_modules)
2468 if test "$found" = "1" ; then
2469    GCRYPT_RANDOM="$GCRYPT_RANDOM rndw32.lo"
2470    AC_DEFINE(USE_RNDW32, 1,
2471              [Defined if the Windows specific RNG should be used.])
2472 fi
2473
2474 LIST_MEMBER(w32ce, $random_modules)
2475 if test "$found" = "1" ; then
2476    GCRYPT_RANDOM="$GCRYPT_RANDOM rndw32ce.lo"
2477    AC_DEFINE(USE_RNDW32CE, 1,
2478              [Defined if the WindowsCE specific RNG should be used.])
2479 fi
2480
2481 AC_SUBST([GCRYPT_CIPHERS])
2482 AC_SUBST([GCRYPT_PUBKEY_CIPHERS])
2483 AC_SUBST([GCRYPT_DIGESTS])
2484 AC_SUBST([GCRYPT_KDFS])
2485 AC_SUBST([GCRYPT_RANDOM])
2486
2487 AC_SUBST(LIBGCRYPT_CIPHERS, $enabled_ciphers)
2488 AC_SUBST(LIBGCRYPT_PUBKEY_CIPHERS, $enabled_pubkey_ciphers)
2489 AC_SUBST(LIBGCRYPT_DIGESTS, $enabled_digests)
2490
2491 # For printing the configuration we need a colon separated list of
2492 # algorithm names.
2493 tmp=`echo "$enabled_ciphers" | tr ' ' : `
2494 AC_DEFINE_UNQUOTED(LIBGCRYPT_CIPHERS, "$tmp",
2495                    [List of available cipher algorithms])
2496 tmp=`echo "$enabled_pubkey_ciphers" | tr ' ' : `
2497 AC_DEFINE_UNQUOTED(LIBGCRYPT_PUBKEY_CIPHERS, "$tmp",
2498                    [List of available public key cipher algorithms])
2499 tmp=`echo "$enabled_digests" | tr ' ' : `
2500 AC_DEFINE_UNQUOTED(LIBGCRYPT_DIGESTS, "$tmp",
2501                    [List of available digest algorithms])
2502 tmp=`echo "$enabled_kdfs" | tr ' ' : `
2503 AC_DEFINE_UNQUOTED(LIBGCRYPT_KDFS, "$tmp",
2504                    [List of available KDF algorithms])
2505
2506
2507 #
2508 # Define conditional sources depending on the used hardware platform.
2509 # Note that all possible modules must also be listed in
2510 # src/Makefile.am (EXTRA_libgcrypt_la_SOURCES).
2511 #
2512 GCRYPT_HWF_MODULES=
2513 case "$mpi_cpu_arch" in
2514      x86)
2515         AC_DEFINE(HAVE_CPU_ARCH_X86, 1,   [Defined for the x86 platforms])
2516         GCRYPT_HWF_MODULES="hwf-x86.lo"
2517         ;;
2518      alpha)
2519         AC_DEFINE(HAVE_CPU_ARCH_ALPHA, 1, [Defined for Alpha platforms])
2520         ;;
2521      sparc)
2522         AC_DEFINE(HAVE_CPU_ARCH_SPARC, 1, [Defined for SPARC platforms])
2523         ;;
2524      mips)
2525         AC_DEFINE(HAVE_CPU_ARCH_MIPS, 1,  [Defined for MIPS platforms])
2526         ;;
2527      m68k)
2528         AC_DEFINE(HAVE_CPU_ARCH_M68K, 1,  [Defined for M68k platforms])
2529         ;;
2530      ppc)
2531         AC_DEFINE(HAVE_CPU_ARCH_PPC, 1,   [Defined for PPC platforms])
2532         ;;
2533      arm)
2534         AC_DEFINE(HAVE_CPU_ARCH_ARM, 1,   [Defined for ARM platforms])
2535         GCRYPT_HWF_MODULES="hwf-arm.lo"
2536         ;;
2537      aarch64)
2538         AC_DEFINE(HAVE_CPU_ARCH_ARM, 1,   [Defined for ARM AArch64 platforms])
2539         GCRYPT_HWF_MODULES="hwf-arm.lo"
2540         ;;
2541 esac
2542 AC_SUBST([GCRYPT_HWF_MODULES])
2543
2544
2545 #
2546 # Option to disable building of doc file
2547 #
2548 build_doc=yes
2549 AC_ARG_ENABLE([doc], AC_HELP_STRING([--disable-doc],
2550                                     [do not build the documentation]),
2551                      build_doc=$enableval, build_doc=yes)
2552 AM_CONDITIONAL([BUILD_DOC], [test "x$build_doc" != xno])
2553
2554
2555 #
2556 # Provide information about the build.
2557 #
2558 BUILD_REVISION="mym4_revision"
2559 AC_SUBST(BUILD_REVISION)
2560 AC_DEFINE_UNQUOTED(BUILD_REVISION, "$BUILD_REVISION",
2561                    [GIT commit id revision used to build this package])
2562
2563 changequote(,)dnl
2564 BUILD_FILEVERSION=`echo "$VERSION" | sed 's/\([0-9.]*\).*/\1./;s/\./,/g'`
2565 changequote([,])dnl
2566 BUILD_FILEVERSION="${BUILD_FILEVERSION}mym4_revision_dec"
2567 AC_SUBST(BUILD_FILEVERSION)
2568
2569 AC_ARG_ENABLE([build-timestamp],
2570   AC_HELP_STRING([--enable-build-timestamp],
2571                  [set an explicit build timestamp for reproducibility.
2572                   (default is the current time in ISO-8601 format)]),
2573      [if test "$enableval" = "yes"; then
2574         BUILD_TIMESTAMP=`date -u +%Y-%m-%dT%H:%M+0000 2>/dev/null || date`
2575       else
2576         BUILD_TIMESTAMP="$enableval"
2577       fi],
2578      [BUILD_TIMESTAMP="<none>"])
2579 AC_SUBST(BUILD_TIMESTAMP)
2580 AC_DEFINE_UNQUOTED(BUILD_TIMESTAMP, "$BUILD_TIMESTAMP",
2581                    [The time this package was configured for a build])
2582
2583
2584 # And create the files.
2585 AC_CONFIG_FILES([
2586 Makefile
2587 m4/Makefile
2588 compat/Makefile
2589 mpi/Makefile
2590 cipher/Makefile
2591 random/Makefile
2592 doc/Makefile
2593 src/Makefile
2594 src/gcrypt.h
2595 src/libgcrypt-config
2596 src/versioninfo.rc
2597 tests/Makefile
2598 ])
2599 AC_CONFIG_FILES([tests/hashtest-256g], [chmod +x tests/hashtest-256g])
2600 AC_CONFIG_FILES([tests/basic-disable-all-hwf], [chmod +x tests/basic-disable-all-hwf])
2601 AC_OUTPUT
2602
2603
2604 detection_module="${GCRYPT_HWF_MODULES%.lo}"
2605 test -n "$detection_module" || detection_module="none"
2606
2607 # Give some feedback
2608 GCRY_MSG_SHOW([],[])
2609 GCRY_MSG_SHOW([Libgcrypt],[v${VERSION} has been configured as follows:])
2610 GCRY_MSG_SHOW([],[])
2611 GCRY_MSG_SHOW([Platform:                 ],[$PRINTABLE_OS_NAME ($host)])
2612 GCRY_MSG_SHOW([Hardware detection module:],[$detection_module])
2613 GCRY_MSG_WRAP([Enabled cipher algorithms:],[$enabled_ciphers])
2614 GCRY_MSG_WRAP([Enabled digest algorithms:],[$enabled_digests])
2615 GCRY_MSG_WRAP([Enabled kdf algorithms:   ],[$enabled_kdfs])
2616 GCRY_MSG_WRAP([Enabled pubkey algorithms:],[$enabled_pubkey_ciphers])
2617 GCRY_MSG_SHOW([Random number generator:  ],[$random])
2618 GCRY_MSG_SHOW([Using linux capabilities: ],[$use_capabilities])
2619 GCRY_MSG_SHOW([Try using Padlock crypto: ],[$padlocksupport])
2620 GCRY_MSG_SHOW([Try using AES-NI crypto:  ],[$aesnisupport])
2621 GCRY_MSG_SHOW([Try using Intel PCLMUL:   ],[$pclmulsupport])
2622 GCRY_MSG_SHOW([Try using Intel SSE4.1:   ],[$sse41support])
2623 GCRY_MSG_SHOW([Try using DRNG (RDRAND):  ],[$drngsupport])
2624 GCRY_MSG_SHOW([Try using Intel AVX:      ],[$avxsupport])
2625 GCRY_MSG_SHOW([Try using Intel AVX2:     ],[$avx2support])
2626 GCRY_MSG_SHOW([Try using ARM NEON:       ],[$neonsupport])
2627 GCRY_MSG_SHOW([Try using ARMv8 crypto:   ],[$armcryptosupport])
2628 GCRY_MSG_SHOW([],[])
2629
2630 if test "x${gpg_config_script_warn}" != x; then
2631 cat <<G10EOF
2632         Mismatches between the target platform and the to
2633         be used libraries have been been detected for:
2634          ${gpg_config_script_warn}
2635         Please check above for warning messages.
2636
2637 G10EOF
2638 fi
2639 if test "$print_egd_notice" = "yes"; then
2640 cat <<G10EOF
2641    The performance of the Unix random gatherer module (rndunix) is not
2642    very good and it does not keep the entropy pool over multiple
2643    invocations of Libgcrypt base applications.  The suggested way to
2644    overcome this problem is to use the
2645
2646                  Entropy Gathering Daemon (EGD)
2647
2648    which provides a entropy source for the whole system.  It is written
2649    in Perl and available at the GnuPG FTP servers.  For more information
2650    consult the GnuPG site:
2651
2652           https://gnupg.org/related_software/swlist.html#egd
2653
2654 G10EOF
2655 fi
2656
2657 if test "$gcry_cv_gcc_attribute_aligned" != "yes" ; then
2658 cat <<G10EOF
2659    Please not that your compiler does not support the GCC style
2660    aligned attribute. Using this software may evoke bus errors.
2661
2662 G10EOF
2663 fi
2664
2665 if test -n "$gpl"; then
2666   echo "Please note that you are building a version of Libgcrypt with"
2667   echo "  $gpl"
2668   echo "included.  These parts are licensed under the GPL and thus the"
2669   echo "use of this library has to comply with the conditions of the GPL."
2670   echo ""
2671 fi