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