No OneTemporary
Actions

Size

80 KB

Subscribers

None

View Options

	diff --git a/cipher/Makefile.am b/cipher/Makefile.am
	index 98c62549..15400e56 100644
	--- a/cipher/Makefile.am
	+++ b/cipher/Makefile.am
	@@ -1,105 +1,105 @@
	# Makefile for cipher modules
	# Copyright (C) 1998, 1999, 2000, 2001, 2002,
	# 2003, 2009 Free Software Foundation, Inc.
	#
	# This file is part of Libgcrypt.
	#
	# Libgcrypt is free software; you can redistribute it and/or modify
	# it under the terms of the GNU Lesser General Public License as
	# published by the Free Software Foundation; either version 2.1 of
	# the License, or (at your option) any later version.
	#
	# Libgcrypt is distributed in the hope that it will be useful,
	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	# GNU Lesser General Public License for more details.
	#
	# You should have received a copy of the GNU Lesser General Public
	# License along with this program; if not, see <http://www.gnu.org/licenses/>.

	# Process this file with automake to produce Makefile.in

	EXTRA_DIST = Manifest

	# Need to include ../src in addition to top_srcdir because gcrypt.h is
	# a built header.
	AM_CPPFLAGS = -I../src -I$(top_srcdir)/src
	AM_CFLAGS = $(GPG_ERROR_CFLAGS)

	AM_CCASFLAGS = $(NOEXECSTACK_FLAGS)


	noinst_LTLIBRARIES = libcipher.la

	GCRYPT_MODULES = @GCRYPT_CIPHERS@ @GCRYPT_PUBKEY_CIPHERS@ \
	@GCRYPT_DIGESTS@ @GCRYPT_KDFS@

	libcipher_la_DEPENDENCIES = $(GCRYPT_MODULES)
	libcipher_la_LIBADD = $(GCRYPT_MODULES)

	libcipher_la_SOURCES = \
	cipher.c cipher-internal.h \
	cipher-cbc.c cipher-cfb.c cipher-ofb.c cipher-ctr.c cipher-aeswrap.c \
	cipher-ccm.c cipher-cmac.c cipher-gcm.c \
	cipher-selftest.c cipher-selftest.h \
	pubkey.c pubkey-internal.h pubkey-util.c \
	md.c \
	mac.c mac-internal.h \
	mac-hmac.c mac-cmac.c mac-gmac.c \
	kdf.c kdf-internal.h \
	hmac-tests.c \
	bithelp.h \
	bufhelp.h \
	primegen.c \
	hash-common.c hash-common.h \
	dsa-common.c rsa-common.c \
	rmd.h

	EXTRA_libcipher_la_SOURCES = \
	-arcfour.c \
	+arcfour.c arcfour-amd64.S \
	blowfish.c blowfish-amd64.S \
	cast5.c cast5-amd64.S cast5-arm.S \
	crc.c \
	des.c \
	dsa.c \
	elgamal.c \
	ecc.c ecc-curves.c ecc-misc.c ecc-common.h \
	ecc-ecdsa.c ecc-eddsa.c ecc-gost.c \
	idea.c \
	gost28147.c gost.h \
	gostr3411-94.c \
	md4.c \
	md5.c \
	rijndael.c rijndael-tables.h rijndael-amd64.S rijndael-arm.S \
	rmd160.c \
	rsa.c \
	salsa20.c salsa20-amd64.S salsa20-armv7-neon.S \
	scrypt.c \
	seed.c \
	serpent.c serpent-sse2-amd64.S serpent-avx2-amd64.S \
	sha1.c sha1-ssse3-amd64.S sha1-avx-amd64.S sha1-avx-bmi2-amd64.S \
	sha1-armv7-neon.S \
	sha256.c sha256-ssse3-amd64.S sha256-avx-amd64.S sha256-avx2-bmi2-amd64.S \
	sha512.c sha512-ssse3-amd64.S sha512-avx-amd64.S sha512-avx2-bmi2-amd64.S \
	sha512-armv7-neon.S \
	stribog.c \
	tiger.c \
	whirlpool.c \
	twofish.c twofish-amd64.S twofish-arm.S \
	rfc2268.c \
	camellia.c camellia.h camellia-glue.c camellia-aesni-avx-amd64.S \
	camellia-aesni-avx2-amd64.S camellia-arm.S

	if ENABLE_O_FLAG_MUNGING
	o_flag_munging = sed -e 's/-O$[2-9s][2-9s]*$/-O1/' -e 's/-Ofast/-O1/g'
	else
	o_flag_munging = cat
	endif


	# We need to lower the optimization for this module.
	tiger.o: $(srcdir)/tiger.c
	`echo $(COMPILE) -c $(srcdir)/tiger.c \| $(o_flag_munging) `

	tiger.lo: $(srcdir)/tiger.c
	`echo $(LTCOMPILE) -c $(srcdir)/tiger.c \| $(o_flag_munging) `
	diff --git a/cipher/arcfour-amd64.S b/cipher/arcfour-amd64.S
	new file mode 100644
	index 00000000..c32cd6f1
	--- /dev/null
	+++ b/cipher/arcfour-amd64.S
	@@ -0,0 +1,97 @@
	+/*
	+** RC4 implementation optimized for AMD64.
	+**
	+** Author: Marc Bevand <bevand_m (at) epita.fr>
	+** Licence: I hereby disclaim the copyright on this code and place it
	+** in the public domain.
	+**
	+** The throughput achieved by this code is about 320 MBytes/sec, on
	+** a 1.8 GHz AMD Opteron (rev C0) processor.
	+**
	+** 2013/12/20 <jussi.kivilinna@iki.fi>:
	+** - Integrated to libgcrypt
	+** - 4.18 cycles/byte on Intel i5-4570
	+*/
	+
	+#ifdef __x86_64__
	+#include <config.h>
	+#if defined(USE_ARCFOUR) && defined(HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS)
	+
	+.text
	+.align 16
	+.globl _gcry_arcfour_amd64
	+.type _gcry_arcfour_amd64,@function
	+_gcry_arcfour_amd64:
	+ push %rbp
	+ push %rbx
	+ mov %rdi, %rbp # key = ARG(key)
	+ mov %rsi, %rbx # rbx = ARG(len)
	+ mov %rdx, %rsi # in = ARG(in)
	+ mov %rcx, %rdi # out = ARG(out)
	+ mov (4*256)(%rbp), %ecx # x = key->x
	+ mov (4*256+4)(%rbp),%edx # y = key->y
	+ inc %rcx # x++
	+ and $255, %rcx # x &= 0xff
	+ lea -8(%rbx,%rsi), %rbx # rbx = in+len-8
	+ mov %rbx, %r9 # tmp = in+len-8
	+ mov (%rbp,%rcx,4), %eax # tx = d[x]
	+ cmp %rsi, %rbx # cmp in with in+len-8
	+ jl .Lend # jump if (in+len-8 < in)
	+
	+.Lstart:
	+ add $8, %rsi # increment in
	+ add $8, %rdi # increment out
	+
	+ # generate the next 8 bytes of the rc4 stream into %r8
	+ mov $8, %r11 # byte counter
	+1: add %al, %dl # y += tx
	+ mov (%rbp,%rdx,4), %ebx # ty = d[y]
	+ mov %ebx, (%rbp,%rcx,4) # d[x] = ty
	+ add %al, %bl # val = ty + tx
	+ mov %eax, (%rbp,%rdx,4) # d[y] = tx
	+ inc %cl # x++ (NEXT ROUND)
	+ mov (%rbp,%rcx,4), %eax # tx = d[x] (NEXT ROUND)
	+ shl $8, %r8
	+ movb (%rbp,%rbx,4), %r8b # val = d[val]
	+ dec %r11b
	+ jnz 1b
	+
	+ # xor 8 bytes
	+ bswap %r8
	+ xor -8(%rsi), %r8
	+ cmp %r9, %rsi # cmp in+len-8 with in
	+ mov %r8, -8(%rdi)
	+ jle .Lstart # jump if (in <= in+len-8)
	+
	+.Lend:
	+ add $8, %r9 # tmp = in+len
	+
	+ # handle the last bytes, one by one
	+1: cmp %rsi, %r9 # cmp in with in+len
	+ jle .Lfinished # jump if (in+len <= in)
	+ add %al, %dl # y += tx
	+ mov (%rbp,%rdx,4), %ebx # ty = d[y]
	+ mov %ebx, (%rbp,%rcx,4) # d[x] = ty
	+ add %al, %bl # val = ty + tx
	+ mov %eax, (%rbp,%rdx,4) # d[y] = tx
	+ inc %cl # x++ (NEXT ROUND)
	+ mov (%rbp,%rcx,4), %eax # tx = d[x] (NEXT ROUND)
	+ movb (%rbp,%rbx,4), %r8b # val = d[val]
	+ xor (%rsi), %r8b # xor 1 byte
	+ movb %r8b, (%rdi)
	+ inc %rsi # in++
	+ inc %rdi # out++
	+ jmp 1b
	+
	+.Lfinished:
	+ dec %rcx # x--
	+ movb %dl, (4*256)(%rbp) # key->y = y
	+ movb %cl, (4*256+4)(%rbp) # key->x = x
	+ pop %rbx
	+ pop %rbp
	+ ret
	+.L__gcry_arcfour_amd64_end:
	+.size _gcry_arcfour_amd64,.L__gcry_arcfour_amd64_end-_gcry_arcfour_amd64
	+
	+#endif
	+#endif
	diff --git a/cipher/arcfour.c b/cipher/arcfour.c
	index d692c84a..27537bfd 100644
	--- a/cipher/arcfour.c
	+++ b/cipher/arcfour.c
	@@ -1,185 +1,212 @@
	/* arcfour.c - The arcfour stream cipher
	* Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
	*
	* This file is part of Libgcrypt.
	*
	* Libgcrypt is free software; you can redistribute it and/or modify
	* it under the terms of the GNU Lesser general Public License as
	* published by the Free Software Foundation; either version 2.1 of
	* the License, or (at your option) any later version.
	*
	* Libgcrypt is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this program; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
	*
	* For a description of the algorithm, see:
	* Bruce Schneier: Applied Cryptography. John Wiley & Sons, 1996.
	* ISBN 0-471-11709-9. Pages 397 ff.
	*/


	#include <config.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include "types.h"
	#include "g10lib.h"
	#include "cipher.h"

	+/* USE_AMD64_ASM indicates whether to use AMD64 assembly code. */
	+#undef USE_AMD64_ASM
	+#if defined(__x86_64__) && defined(HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS)
	+# define USE_AMD64_ASM 1
	+#endif
	+
	static const char *selftest(void);

	+#ifdef USE_AMD64_ASM
	+
	+typedef struct {
	+ u32 sbox[256];
	+ u32 idx_i, idx_j;
	+} ARCFOUR_context;
	+
	+void _gcry_arcfour_amd64(void key, size_t len, const byte indata,
	+ byte *outdata);
	+
	+static void
	+encrypt_stream (void *context,
	+ byte outbuf, const byte inbuf, size_t length)
	+{
	+ _gcry_arcfour_amd64 (context, length, inbuf, outbuf );
	+}
	+
	+#else /!USE_AMD64_ASM/
	+
	typedef struct {
	byte sbox[256];
	int idx_i, idx_j;
	} ARCFOUR_context;

	static void
	do_encrypt_stream( ARCFOUR_context *ctx,
	byte outbuf, const byte inbuf, size_t length )
	{
	#ifndef __i386__
	register unsigned int i = ctx->idx_i;
	register byte j = ctx->idx_j;
	register byte *sbox = ctx->sbox;
	register byte t, u;

	while ( length-- )
	{
	i++;
	t = sbox[(byte)i];
	j += t;
	u = sbox[j];
	sbox[(byte)i] = u;
	u += t;
	sbox[j] = t;
	outbuf++ = sbox[u] ^ inbuf++;
	}

	ctx->idx_i = (byte)i;
	ctx->idx_j = (byte)j;
	#else /__i386__/
	/* Old implementation of arcfour is faster on i386 than the version above.
	* This is because version above increases register pressure which on i386
	* would push some of the variables to memory/stack. Therefore keep this
	* version for i386 to avoid regressing performance. */
	register int i = ctx->idx_i;
	register int j = ctx->idx_j;
	register byte *sbox = ctx->sbox;
	register int t;

	while ( length-- )
	{
	i++;
	i = i & 255; /* The and-op seems to be faster than the mod-op. */
	j += sbox[i];
	j &= 255;
	t = sbox[i]; sbox[i] = sbox[j]; sbox[j] = t;
	outbuf++ = inbuf++ ^ sbox[(sbox[i] + sbox[j]) & 255];
	}

	ctx->idx_i = i;
	ctx->idx_j = j;
	#endif
	}

	static void
	encrypt_stream (void *context,
	byte outbuf, const byte inbuf, size_t length)
	{
	ARCFOUR_context ctx = (ARCFOUR_context ) context;
	do_encrypt_stream (ctx, outbuf, inbuf, length );
	_gcry_burn_stack (64);
	}

	+#endif /!USE_AMD64_ASM/
	+

	static gcry_err_code_t
	do_arcfour_setkey (void context, const byte key, unsigned int keylen)
	{
	static int initialized;
	static const char* selftest_failed;
	int i, j;
	byte karr[256];
	ARCFOUR_context ctx = (ARCFOUR_context ) context;

	if (!initialized )
	{
	initialized = 1;
	selftest_failed = selftest();
	if( selftest_failed )
	log_error ("ARCFOUR selftest failed (%s)\n", selftest_failed );
	}
	if( selftest_failed )
	return GPG_ERR_SELFTEST_FAILED;

	if( keylen < 40/8 ) /* we want at least 40 bits */
	return GPG_ERR_INV_KEYLEN;

	ctx->idx_i = ctx->idx_j = 0;
	for (i=0; i < 256; i++ )
	ctx->sbox[i] = i;
	for (i=j=0; i < 256; i++,j++ )
	{
	if (j >= keylen)
	j = 0;
	karr[i] = key[j];
	}
	for (i=j=0; i < 256; i++ )
	{
	int t;
	j = (j + ctx->sbox[i] + karr[i]) & 255;
	t = ctx->sbox[i];
	ctx->sbox[i] = ctx->sbox[j];
	ctx->sbox[j] = t;
	}
	wipememory( karr, sizeof(karr) );

	return GPG_ERR_NO_ERROR;
	}

	static gcry_err_code_t
	arcfour_setkey ( void context, const byte key, unsigned int keylen )
	{
	ARCFOUR_context ctx = (ARCFOUR_context ) context;
	gcry_err_code_t rc = do_arcfour_setkey (ctx, key, keylen );
	return rc;
	}


	static const char*
	selftest(void)
	{
	ARCFOUR_context ctx;
	byte scratch[16];

	/* Test vector from Cryptlib labeled there: "from the
	State/Commerce Department". */
	static const byte key_1[] =
	{ 0x61, 0x8A, 0x63, 0xD2, 0xFB };
	static const byte plaintext_1[] =
	{ 0xDC, 0xEE, 0x4C, 0xF9, 0x2C };
	static const byte ciphertext_1[] =
	{ 0xF1, 0x38, 0x29, 0xC9, 0xDE };

	arcfour_setkey( &ctx, key_1, sizeof(key_1));
	encrypt_stream( &ctx, scratch, plaintext_1, sizeof(plaintext_1));
	if ( memcmp (scratch, ciphertext_1, sizeof (ciphertext_1)))
	return "Arcfour encryption test 1 failed.";
	arcfour_setkey( &ctx, key_1, sizeof(key_1));
	encrypt_stream(&ctx, scratch, scratch, sizeof(plaintext_1)); /* decrypt */
	if ( memcmp (scratch, plaintext_1, sizeof (plaintext_1)))
	return "Arcfour decryption test 1 failed.";
	return NULL;
	}


	gcry_cipher_spec_t _gcry_cipher_spec_arcfour =
	{
	GCRY_CIPHER_ARCFOUR, {0, 0},
	"ARCFOUR", NULL, NULL, 1, 128, sizeof (ARCFOUR_context),
	arcfour_setkey, NULL, NULL, encrypt_stream, encrypt_stream,
	};
	diff --git a/configure.ac b/configure.ac
	index 8b43d9a8..1715161b 100644
	--- a/configure.ac
	+++ b/configure.ac
	@@ -1,1997 +1,2004 @@
	# Configure.ac script for Libgcrypt
	# Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006,
	# 2007, 2008, 2009, 2011 Free Software Foundation, Inc.
	# Copyright (C) 2012, 2013 g10 Code GmbH
	#
	# This file is part of Libgcrypt.
	#
	# Libgcrypt is free software; you can redistribute it and/or modify
	# it under the terms of the GNU Lesser General Public License as
	# published by the Free Software Foundation; either version 2.1 of
	# the License, or (at your option) any later version.
	#
	# Libgcrypt is distributed in the hope that it will be useful,
	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	# GNU Lesser General Public License for more details.
	#
	# You should have received a copy of the GNU Lesser General Public
	# License along with this program; if not, see <http://www.gnu.org/licenses/>.

	# (Process this file with autoconf to produce a configure script.)
	AC_REVISION($Revision$)
	AC_PREREQ(2.60)
	min_automake_version="1.10"

	# To build a release you need to create a tag with the version number
	# (git tag -s libgcrypt-n.m.k) and run "./autogen.sh --force". Please
	# bump the version number immediately after the release and do another
	# commit and push so that the git magic is able to work. See below
	# for the LT versions.
	m4_define(mym4_version_major, [1])
	m4_define(mym4_version_minor, [7])
	m4_define(mym4_version_micro, [0])

	# Below is m4 magic to extract and compute the revision number, the
	# decimalized short revision number, a beta version string, and a flag
	# indicating a development version (mym4_isgit). Note that the m4
	# processing is done by autoconf and not during the configure run.
	m4_define(mym4_version,
	[mym4_version_major.mym4_version_minor.mym4_version_micro])
	m4_define([mym4_revision],
	m4_esyscmd([git rev-parse --short HEAD \| tr -d '\n\r']))
	m4_define([mym4_revision_dec],
	m4_esyscmd_s([echo $((0x$(echo ]mym4_revision[\|head -c 4)))]))
	m4_define([mym4_betastring],
	m4_esyscmd_s([git describe --match 'libgcrypt-[0-9].*[0-9]' --long\|\
	awk -F- '$3!=0{print"-beta"$3}']))
	m4_define([mym4_isgit],m4_if(mym4_betastring,[],[no],[yes]))
	m4_define([mym4_full_version],[mym4_version[]mym4_betastring])

	AC_INIT([libgcrypt],[mym4_full_version],[http://bugs.gnupg.org])

	# LT Version numbers, remember to change them just before a release.
	# (Interfaces removed: CURRENT++, AGE=0, REVISION=0)
	# (Interfaces added: CURRENT++, AGE++, REVISION=0)
	# (No interfaces changed: REVISION++)
	LIBGCRYPT_LT_CURRENT=20
	LIBGCRYPT_LT_AGE=0
	LIBGCRYPT_LT_REVISION=0


	# If the API is changed in an incompatible way: increment the next counter.
	#
	# 1.6: ABI and API change but the change is to most users irrelevant
	# and thus the API version number has not been incremented.
	LIBGCRYPT_CONFIG_API_VERSION=1

	# If you change the required gpg-error version, please remove
	# unnecessary error code defines in src/gcrypt-int.h.
	NEED_GPG_ERROR_VERSION=1.11

	PACKAGE=$PACKAGE_NAME
	VERSION=$PACKAGE_VERSION

	AC_CONFIG_SRCDIR([src/libgcrypt.vers])
	AM_INIT_AUTOMAKE
	AC_CONFIG_HEADER(config.h)
	AC_CONFIG_MACRO_DIR([m4])
	AC_CONFIG_LIBOBJ_DIR([compat])
	AC_CANONICAL_HOST
	AM_MAINTAINER_MODE

	AH_TOP([
	#ifndef _GCRYPT_CONFIG_H_INCLUDED
	#define _GCRYPT_CONFIG_H_INCLUDED

	/* Enable gpg-error's strerror macro for W32CE. */
	#define GPG_ERR_ENABLE_ERRNO_MACROS 1
	])

	AH_BOTTOM([
	#define _GCRYPT_IN_LIBGCRYPT 1

	/* If the configure check for endianness has been disabled, get it from
	OS macros. This is intended for making fat binary builds on OS X. */
	#ifdef DISABLED_ENDIAN_CHECK
	# if defined(__BIG_ENDIAN__)
	# define WORDS_BIGENDIAN 1
	# elif defined(__LITTLE_ENDIAN__)
	# undef WORDS_BIGENDIAN
	# else
	# error "No endianness found"
	# endif
	#endif /DISABLED_ENDIAN_CHECK/

	/* We basically use the original Camellia source. Make sure the symbols
	properly prefixed. */
	#define CAMELLIA_EXT_SYM_PREFIX _gcry_

	#endif /_GCRYPT_CONFIG_H_INCLUDED/
	])

	AH_VERBATIM([_REENTRANT],
	[/* To allow the use of Libgcrypt in multithreaded programs we have to use
	special features from the library. */
	#ifndef _REENTRANT
	# define _REENTRANT 1
	#endif
	])


	AC_SUBST(LIBGCRYPT_LT_CURRENT)
	AC_SUBST(LIBGCRYPT_LT_AGE)
	AC_SUBST(LIBGCRYPT_LT_REVISION)
	AC_SUBST(PACKAGE)
	AC_SUBST(VERSION)
	AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of this package])
	AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version of this package])
	VERSION_NUMBER=m4_esyscmd(printf "0x%02x%02x%02x" mym4_version_major \
	mym4_version_minor mym4_version_micro)
	AC_SUBST(VERSION_NUMBER)


	######################
	## Basic checks. ### (we need some results later on (e.g. $GCC)
	######################

	AC_PROG_MAKE_SET
	missing_dir=`cd $ac_aux_dir && pwd`
	AM_MISSING_PROG(ACLOCAL, aclocal, $missing_dir)
	AM_MISSING_PROG(AUTOCONF, autoconf, $missing_dir)
	AM_MISSING_PROG(AUTOMAKE, automake, $missing_dir)
	AM_MISSING_PROG(AUTOHEADER, autoheader, $missing_dir)
	# AM_MISSING_PROG(MAKEINFO, makeinfo, $missing_dir)
	AC_PROG_CC
	AC_PROG_CPP
	AM_PROG_CC_C_O
	AM_PROG_AS
	AC_ISC_POSIX
	AC_PROG_INSTALL
	AC_PROG_AWK

	AC_GNU_SOURCE

	# We need to compile and run a program on the build machine. A
	# comment in libgpg-error says that the AC_PROG_CC_FOR_BUILD macro in
	# the AC archive is broken for autoconf 2.57. Given that there is no
	# newer version of that macro, we assume that it is also broken for
	# autoconf 2.61 and thus we use a simple but usually sufficient
	# approach.
	AC_MSG_CHECKING(for cc for build)
	if test "$cross_compiling" = "yes"; then
	CC_FOR_BUILD="${CC_FOR_BUILD-cc}"
	else
	CC_FOR_BUILD="${CC_FOR_BUILD-$CC}"
	fi
	AC_MSG_RESULT($CC_FOR_BUILD)
	AC_ARG_VAR(CC_FOR_BUILD,[build system C compiler])


	LT_PREREQ([2.2.6])
	LT_INIT([win32-dll disable-static])
	LT_LANG([Windows Resource])


	##########################
	## General definitions. ##
	##########################

	# Used by libgcrypt-config
	LIBGCRYPT_CONFIG_LIBS="-lgcrypt"
	LIBGCRYPT_CONFIG_CFLAGS=""
	LIBGCRYPT_CONFIG_HOST="$host"

	# Definitions for symmetric ciphers.
	available_ciphers="arcfour blowfish cast5 des aes twofish serpent rfc2268 seed"
	available_ciphers="$available_ciphers camellia idea salsa20 gost28147"
	enabled_ciphers=""

	# Definitions for public-key ciphers.
	available_pubkey_ciphers="dsa elgamal rsa ecc"
	enabled_pubkey_ciphers=""

	# Definitions for message digests.
	available_digests="crc gostr3411-94 md4 md5 rmd160 sha1 sha256"
	available_digests_64="sha512 tiger whirlpool stribog"
	enabled_digests=""

	# Definitions for kdfs (optional ones)
	available_kdfs="s2k pkdf2"
	available_kdfs_64="scrypt"
	enabled_kdfs=""

	# Definitions for random modules.
	available_random_modules="linux egd unix"
	auto_random_modules="$available_random_modules"

	# Supported thread backends.
	LIBGCRYPT_THREAD_MODULES=""

	# Other definitions.
	print_egd_notice=no
	have_w32_system=no
	have_w32ce_system=no
	have_pthread=no


	# Setup some stuff depending on host.
	case "${host}" in
	--mingw32*)
	ac_cv_have_dev_random=no
	have_w32_system=yes
	case "${host}" in
	-mingw32ce)
	have_w32ce_system=yes
	available_random_modules="w32ce"
	;;
	*)
	available_random_modules="w32"
	;;
	esac
	AC_DEFINE(USE_ONLY_8DOT3,1,
	[set this to limit filenames to the 8.3 format])
	AC_DEFINE(HAVE_DRIVE_LETTERS,1,
	[defined if we must run on a stupid file system])
	AC_DEFINE(HAVE_DOSISH_SYSTEM,1,
	[defined if we run on some of the PCDOS like systems
	(DOS, Windoze. OS/2) with special properties like
	no file modes])
	;;

	i?86-emx-os2 \| i?86--os2emx)
	# OS/2 with the EMX environment
	ac_cv_have_dev_random=no
	AC_DEFINE(HAVE_DRIVE_LETTERS)
	AC_DEFINE(HAVE_DOSISH_SYSTEM)
	;;

	i?86--msdosdjgpp)
	# DOS with the DJGPP environment
	ac_cv_have_dev_random=no
	AC_DEFINE(HAVE_DRIVE_LETTERS)
	AC_DEFINE(HAVE_DOSISH_SYSTEM)
	;;

	--hpux*)
	if test -z "$GCC" ; then
	CFLAGS="$CFLAGS -Ae -D_HPUX_SOURCE"
	fi
	;;
	-dec-osf4)
	if test -z "$GCC" ; then
	# Suppress all warnings
	# to get rid of the unsigned/signed char mismatch warnings.
	CFLAGS="$CFLAGS -w"
	fi
	;;
	m68k-atari-mint)
	;;
	*)
	;;
	esac

	if test "$have_w32_system" = yes; then
	AC_DEFINE(HAVE_W32_SYSTEM,1, [Defined if we run on a W32 API based system])
	if test "$have_w32ce_system" = yes; then
	AC_DEFINE(HAVE_W32CE_SYSTEM,1,[Defined if we run on WindowsCE])
	fi
	fi
	AM_CONDITIONAL(HAVE_W32_SYSTEM, test "$have_w32_system" = yes)
	AM_CONDITIONAL(HAVE_W32CE_SYSTEM, test "$have_w32ce_system" = yes)



	# A printable OS Name is sometimes useful.
	case "${host}" in
	--mingw32ce*)
	PRINTABLE_OS_NAME="W32CE"
	;;

	--mingw32*)
	PRINTABLE_OS_NAME="W32"
	;;

	i?86-emx-os2 \| i?86--os2emx )
	PRINTABLE_OS_NAME="OS/2"
	;;

	i?86--msdosdjgpp)
	PRINTABLE_OS_NAME="MSDOS/DJGPP"
	;;

	-linux)
	PRINTABLE_OS_NAME="GNU/Linux"
	;;

	*)
	PRINTABLE_OS_NAME=`uname -s \|\| echo "Unknown"`
	;;
	esac

	#
	# Figure out the name of the random device
	#
	case "${host}" in
	-openbsd)
	NAME_OF_DEV_RANDOM="/dev/srandom"
	NAME_OF_DEV_URANDOM="/dev/urandom"
	;;

	*)
	NAME_OF_DEV_RANDOM="/dev/random"
	NAME_OF_DEV_URANDOM="/dev/urandom"
	;;
	esac


	AC_ARG_ENABLE(endian-check,
	AC_HELP_STRING([--disable-endian-check],
	[disable the endian check and trust the OS provided macros]),
	endiancheck=$enableval,endiancheck=yes)
	if test x"$endiancheck" = xyes ; then
	AC_C_BIGENDIAN
	else
	AC_DEFINE(DISABLED_ENDIAN_CHECK,1,[configure did not test for endianess])
	fi

	AC_CHECK_SIZEOF(unsigned short, 2)
	AC_CHECK_SIZEOF(unsigned int, 4)
	AC_CHECK_SIZEOF(unsigned long, 4)
	AC_CHECK_SIZEOF(unsigned long long, 0)

	AC_TYPE_UINTPTR_T

	if test "$ac_cv_sizeof_unsigned_short" = "0" \
	\|\| test "$ac_cv_sizeof_unsigned_int" = "0" \
	\|\| test "$ac_cv_sizeof_unsigned_long" = "0"; then
	AC_MSG_WARN([Hmmm, something is wrong with the sizes - using defaults]);
	fi

	# Do we have any 64-bit data types?
	if test "$ac_cv_sizeof_unsigned_int" != "8" \
	&& test "$ac_cv_sizeof_unsigned_long" != "8" \
	&& test "$ac_cv_sizeof_unsigned_long_long" != "8" \
	&& test "$ac_cv_sizeof_uint64_t" != "8"; then
	AC_MSG_WARN([No 64-bit types. Disabling TIGER/192, SCRYPT, SHA-384, \
	SHA-512 and GOST R 34.11-12])
	else
	available_digests="$available_digests $available_digests_64"
	available_kdfs="$available_kdfs $available_kdfs_64"
	fi

	# If not specified otherwise, all available algorithms will be
	# included.
	default_ciphers="$available_ciphers"
	default_pubkey_ciphers="$available_pubkey_ciphers"
	default_digests="$available_digests"
	default_kdfs="$available_kdfs"

	# Substitutions to set generated files in a Emacs buffer to read-only.
	AC_SUBST(emacs_local_vars_begin, ['Local Variables:'])
	AC_SUBST(emacs_local_vars_read_only, ['buffer-read-only: t'])
	AC_SUBST(emacs_local_vars_end, ['End:'])

	############################
	## Command line switches. ##
	############################

	# Implementation of the --enable-ciphers switch.
	AC_ARG_ENABLE(ciphers,
	AC_HELP_STRING([--enable-ciphers=ciphers],
	[select the symmetric ciphers to include]),
	[enabled_ciphers=`echo $enableval \| tr ',:' ' ' \| tr '[A-Z]' '[a-z]'`],
	[enabled_ciphers=""])
	if test "x$enabled_ciphers" = "x" \
	-o "$enabled_ciphers" = "yes" \
	-o "$enabled_ciphers" = "no"; then
	enabled_ciphers=$default_ciphers
	fi
	AC_MSG_CHECKING([which symmetric ciphers to include])
	for cipher in $enabled_ciphers; do
	LIST_MEMBER($cipher, $available_ciphers)
	if test "$found" = "0"; then
	AC_MSG_ERROR([unsupported cipher "$cipher" specified])
	fi
	done
	AC_MSG_RESULT([$enabled_ciphers])

	# Implementation of the --enable-pubkey-ciphers switch.
	AC_ARG_ENABLE(pubkey-ciphers,
	AC_HELP_STRING([--enable-pubkey-ciphers=ciphers],
	[select the public-key ciphers to include]),
	[enabled_pubkey_ciphers=`echo $enableval \| tr ',:' ' ' \| tr '[A-Z]' '[a-z]'`],
	[enabled_pubkey_ciphers=""])
	if test "x$enabled_pubkey_ciphers" = "x" \
	-o "$enabled_pubkey_ciphers" = "yes" \
	-o "$enabled_pubkey_ciphers" = "no"; then
	enabled_pubkey_ciphers=$default_pubkey_ciphers
	fi
	AC_MSG_CHECKING([which public-key ciphers to include])
	for cipher in $enabled_pubkey_ciphers; do
	LIST_MEMBER($cipher, $available_pubkey_ciphers)
	if test "$found" = "0"; then
	AC_MSG_ERROR([unsupported public-key cipher specified])
	fi
	done
	AC_MSG_RESULT([$enabled_pubkey_ciphers])

	# Implementation of the --enable-digests switch.
	AC_ARG_ENABLE(digests,
	AC_HELP_STRING([--enable-digests=digests],
	[select the message digests to include]),
	[enabled_digests=`echo $enableval \| tr ',:' ' ' \| tr '[A-Z]' '[a-z]'`],
	[enabled_digests=""])
	if test "x$enabled_digests" = "x" \
	-o "$enabled_digests" = "yes" \
	-o "$enabled_digests" = "no"; then
	enabled_digests=$default_digests
	fi
	AC_MSG_CHECKING([which message digests to include])
	for digest in $enabled_digests; do
	LIST_MEMBER($digest, $available_digests)
	if test "$found" = "0"; then
	AC_MSG_ERROR([unsupported message digest specified])
	fi
	done
	AC_MSG_RESULT([$enabled_digests])

	# Implementation of the --enable-kdfs switch.
	AC_ARG_ENABLE(kdfs,
	AC_HELP_STRING([--enable-kfds=kdfs],
	[select the KDFs to include]),
	[enabled_kdfs=`echo $enableval \| tr ',:' ' ' \| tr '[A-Z]' '[a-z]'`],
	[enabled_kdfs=""])
	if test "x$enabled_kdfs" = "x" \
	-o "$enabled_kdfs" = "yes" \
	-o "$enabled_kdfs" = "no"; then
	enabled_kdfs=$default_kdfs
	fi
	AC_MSG_CHECKING([which key derivation functions to include])
	for kdf in $enabled_kdfs; do
	LIST_MEMBER($kdf, $available_kdfs)
	if test "$found" = "0"; then
	AC_MSG_ERROR([unsupported key derivation function specified])
	fi
	done
	AC_MSG_RESULT([$enabled_kdfs])

	# Implementation of the --enable-random switch.
	AC_ARG_ENABLE(random,
	AC_HELP_STRING([--enable-random=name],
	[select which random number generator to use]),
	[random=`echo $enableval \| tr '[A-Z]' '[a-z]'`],
	[])
	if test "x$random" = "x" -o "$random" = "yes" -o "$random" = "no"; then
	random=default
	fi
	AC_MSG_CHECKING([which random module to use])
	if test "$random" != "default" -a "$random" != "auto"; then
	LIST_MEMBER($random, $available_random_modules)
	if test "$found" = "0"; then
	AC_MSG_ERROR([unsupported random module specified])
	fi
	fi
	AC_MSG_RESULT($random)

	# Implementation of the --disable-dev-random switch.
	AC_MSG_CHECKING([whether use of /dev/random is requested])
	AC_ARG_ENABLE(dev-random,
	[ --disable-dev-random disable the use of dev random],
	try_dev_random=$enableval, try_dev_random=yes)
	AC_MSG_RESULT($try_dev_random)

	# Implementation of the --with-egd-socket switch.
	AC_ARG_WITH(egd-socket,
	[ --with-egd-socket=NAME Use NAME for the EGD socket)],
	egd_socket_name="$withval", egd_socket_name="" )
	AC_DEFINE_UNQUOTED(EGD_SOCKET_NAME, "$egd_socket_name",
	[Define if you don't want the default EGD socket name.
	For details see cipher/rndegd.c])

	# Implementation of the --enable-random-daemon
	AC_MSG_CHECKING([whether the experimental random daemon is requested])
	AC_ARG_ENABLE([random-daemon],
	AC_HELP_STRING([--enable-random-daemon],
	[Build and support the experimental gcryptrnd]),
	[use_random_daemon=$enableval],
	[use_random_daemon=no])
	AC_MSG_RESULT($use_random_daemon)
	if test x$use_random_daemon = xyes ; then
	AC_DEFINE(USE_RANDOM_DAEMON,1,
	[Define to support the experimental random daemon])
	fi
	AM_CONDITIONAL(USE_RANDOM_DAEMON, test x$use_random_daemon = xyes)


	# Implementation of --disable-asm.
	AC_MSG_CHECKING([whether MPI assembler modules are requested])
	AC_ARG_ENABLE([asm],
	AC_HELP_STRING([--disable-asm],
	[Disable MPI assembler modules]),
	[try_asm_modules=$enableval],
	[try_asm_modules=yes])
	AC_MSG_RESULT($try_asm_modules)

	# Implementation of the --enable-m-guard switch.
	AC_MSG_CHECKING([whether memory guard is requested])
	AC_ARG_ENABLE(m-guard,
	AC_HELP_STRING([--enable-m-guard],
	[Enable memory guard facility]),
	[use_m_guard=$enableval], [use_m_guard=no])
	AC_MSG_RESULT($use_m_guard)
	if test "$use_m_guard" = yes ; then
	AC_DEFINE(M_GUARD,1,[Define to use the (obsolete) malloc guarding feature])
	fi

	# Implementation of the --enable-large-data-tests switch.
	AC_MSG_CHECKING([whether to run large data tests])
	AC_ARG_ENABLE(large-data-tests,
	AC_HELP_STRING([--enable-large-data-tests],
	[Enable the real long ruinning large data tests]),
	large_data_tests=$enableval,large_data_tests=no)
	AC_MSG_RESULT($large_data_tests)
	AC_SUBST(RUN_LARGE_DATA_TESTS, $large_data_tests)


	# Implementation of the --with-capabilities switch.
	# Check whether we want to use Linux capabilities
	AC_MSG_CHECKING([whether use of capabilities is requested])
	AC_ARG_WITH(capabilities,
	AC_HELP_STRING([--with-capabilities],
	[Use linux capabilities [default=no]]),
	[use_capabilities="$withval"],[use_capabilities=no])
	AC_MSG_RESULT($use_capabilities)

	# Implementation of the --enable-hmac-binary-check.
	AC_MSG_CHECKING([whether a HMAC binary check is requested])
	AC_ARG_ENABLE(hmac-binary-check,
	AC_HELP_STRING([--enable-hmac-binary-check],
	[Enable library integrity check]),
	[use_hmac_binary_check=$enableval],
	[use_hmac_binary_check=no])
	AC_MSG_RESULT($use_hmac_binary_check)
	if test "$use_hmac_binary_check" = yes ; then
	AC_DEFINE(ENABLE_HMAC_BINARY_CHECK,1,
	[Define to support an HMAC based integrity check])
	fi


	# Implementation of the --disable-padlock-support switch.
	AC_MSG_CHECKING([whether padlock support is requested])
	AC_ARG_ENABLE(padlock-support,
	AC_HELP_STRING([--disable-padlock-support],
	[Disable support for the PadLock Engine of VIA processors]),
	padlocksupport=$enableval,padlocksupport=yes)
	AC_MSG_RESULT($padlocksupport)
	if test x"$padlocksupport" = xyes ; then
	AC_DEFINE(ENABLE_PADLOCK_SUPPORT, 1,
	[Enable support for the PadLock engine.])
	fi

	# Implementation of the --disable-aesni-support switch.
	AC_MSG_CHECKING([whether AESNI support is requested])
	AC_ARG_ENABLE(aesni-support,
	AC_HELP_STRING([--disable-aesni-support],
	[Disable support for the Intel AES-NI instructions]),
	aesnisupport=$enableval,aesnisupport=yes)
	AC_MSG_RESULT($aesnisupport)

	# Implementation of the --disable-pclmul-support switch.
	AC_MSG_CHECKING([whether PCLMUL support is requested])
	AC_ARG_ENABLE(pclmul-support,
	AC_HELP_STRING([--disable-pclmul-support],
	[Disable support for the Intel PCLMUL instructions]),
	pclmulsupport=$enableval,pclmulsupport=yes)
	AC_MSG_RESULT($pclmulsupport)

	# Implementation of the --disable-drng-support switch.
	AC_MSG_CHECKING([whether DRNG support is requested])
	AC_ARG_ENABLE(drng-support,
	AC_HELP_STRING([--disable-drng-support],
	[Disable support for the Intel DRNG (RDRAND instruction)]),
	drngsupport=$enableval,drngsupport=yes)
	AC_MSG_RESULT($drngsupport)
	if test x"$drngsupport" = xyes ; then
	AC_DEFINE(ENABLE_DRNG_SUPPORT, 1,
	[Enable support for Intel DRNG (RDRAND instruction).])
	fi

	# Implementation of the --disable-avx-support switch.
	AC_MSG_CHECKING([whether AVX support is requested])
	AC_ARG_ENABLE(avx-support,
	AC_HELP_STRING([--disable-avx-support],
	[Disable support for the Intel AVX instructions]),
	avxsupport=$enableval,avxsupport=yes)
	AC_MSG_RESULT($avxsupport)

	# Implementation of the --disable-avx2-support switch.
	AC_MSG_CHECKING([whether AVX2 support is requested])
	AC_ARG_ENABLE(avx2-support,
	AC_HELP_STRING([--disable-avx2-support],
	[Disable support for the Intel AVX2 instructions]),
	avx2support=$enableval,avx2support=yes)
	AC_MSG_RESULT($avx2support)

	# Implementation of the --disable-neon-support switch.
	AC_MSG_CHECKING([whether NEON support is requested])
	AC_ARG_ENABLE(neon-support,
	AC_HELP_STRING([--disable-neon-support],
	[Disable support for the ARM NEON instructions]),
	neonsupport=$enableval,neonsupport=yes)
	AC_MSG_RESULT($neonsupport)

	# Implementation of the --disable-O-flag-munging switch.
	AC_MSG_CHECKING([whether a -O flag munging is requested])
	AC_ARG_ENABLE([O-flag-munging],
	AC_HELP_STRING([--disable-O-flag-munging],
	[Disable modification of the cc -O flag]),
	[enable_o_flag_munging=$enableval],
	[enable_o_flag_munging=yes])
	AC_MSG_RESULT($enable_o_flag_munging)
	AM_CONDITIONAL(ENABLE_O_FLAG_MUNGING, test "$enable_o_flag_munging" = "yes")

	# Implementation of the --disable-amd64-as-feature-detection switch.
	AC_MSG_CHECKING([whether to enable AMD64 as(1) feature detection])
	AC_ARG_ENABLE(amd64-as-feature-detection,
	AC_HELP_STRING([--disable-amd64-as-feature-detection],
	[Disable the auto-detection of AMD64 as(1) features]),
	amd64_as_feature_detection=$enableval,
	amd64_as_feature_detection=yes)
	AC_MSG_RESULT($amd64_as_feature_detection)


	AC_DEFINE_UNQUOTED(PRINTABLE_OS_NAME, "$PRINTABLE_OS_NAME",
	[A human readable text with the name of the OS])

	# For some systems we know that we have ld_version scripts.
	# Use it then as default.
	have_ld_version_script=no
	case "${host}" in
	--linux*)
	have_ld_version_script=yes
	;;
	--gnu*)
	have_ld_version_script=yes
	;;
	esac
	AC_ARG_ENABLE([ld-version-script],
	AC_HELP_STRING([--enable-ld-version-script],
	[enable/disable use of linker version script.
	(default is system dependent)]),
	[have_ld_version_script=$enableval],
	[ : ] )
	AM_CONDITIONAL(HAVE_LD_VERSION_SCRIPT, test "$have_ld_version_script" = "yes")

	AC_DEFINE_UNQUOTED(NAME_OF_DEV_RANDOM, "$NAME_OF_DEV_RANDOM",
	[defined to the name of the strong random device])
	AC_DEFINE_UNQUOTED(NAME_OF_DEV_URANDOM, "$NAME_OF_DEV_URANDOM",
	[defined to the name of the weaker random device])


	###############################
	#### Checks for libraries. ####
	###############################

	#
	# gpg-error is required.
	#
	AM_PATH_GPG_ERROR("$NEED_GPG_ERROR_VERSION")
	if test "x$GPG_ERROR_LIBS" = "x"; then
	AC_MSG_ERROR([libgpg-error is needed.
	See ftp://ftp.gnupg.org/gcrypt/libgpg-error/ .])
	fi

	AC_DEFINE(GPG_ERR_SOURCE_DEFAULT, GPG_ERR_SOURCE_GCRYPT,
	[The default error source for libgcrypt.])

	#
	# Check whether the GNU Pth library is available. We require this
	# to build the optional gcryptrnd program.
	#
	AC_ARG_WITH(pth-prefix,
	AC_HELP_STRING([--with-pth-prefix=PFX],
	[prefix where GNU Pth is installed (optional)]),
	pth_config_prefix="$withval", pth_config_prefix="")
	if test x$pth_config_prefix != x ; then
	PTH_CONFIG="$pth_config_prefix/bin/pth-config"
	fi
	if test "$use_random_daemon" = "yes"; then
	AC_PATH_PROG(PTH_CONFIG, pth-config, no)
	if test "$PTH_CONFIG" = "no"; then
	AC_MSG_WARN([[
	***
	*** To build the Libgcrypt's random number daemon
	*** we need the support of the GNU Portable Threads Library.
	*** Download it from ftp://ftp.gnu.org/gnu/pth/
	*** On a Debian GNU/Linux system you might want to try
	*** apt-get install libpth-dev
	***]])
	else
	GNUPG_PTH_VERSION_CHECK([1.3.7])
	if test $have_pth = yes; then
	PTH_CFLAGS=`$PTH_CONFIG --cflags`
	PTH_LIBS=`$PTH_CONFIG --ldflags`
	PTH_LIBS="$PTH_LIBS `$PTH_CONFIG --libs --all`"
	AC_DEFINE(USE_GNU_PTH, 1,
	[Defined if the GNU Portable Thread Library should be used])
	AC_DEFINE(HAVE_PTH, 1,
	[Defined if the GNU Pth is available])
	fi
	fi
	fi
	AC_SUBST(PTH_CFLAGS)
	AC_SUBST(PTH_LIBS)

	#
	# Check whether pthreads is available
	#
	AC_CHECK_LIB(pthread,pthread_create,have_pthread=yes)
	if test "$have_pthread" = yes; then
	AC_DEFINE(HAVE_PTHREAD, ,[Define if we have pthread.])
	fi

	#
	# See which thread system we have
	# FIXME: Thus duplicates the above check.
	#
	gl_LOCK

	# Solaris needs -lsocket and -lnsl. Unisys system includes
	# gethostbyname in libsocket but needs libnsl for socket.
	AC_SEARCH_LIBS(setsockopt, [socket], ,
	[AC_SEARCH_LIBS(setsockopt, [socket], , , [-lnsl])])
	AC_SEARCH_LIBS(setsockopt, [nsl])

	##################################
	#### Checks for header files. ####
	##################################

	AC_HEADER_STDC
	AC_CHECK_HEADERS(unistd.h sys/select.h sys/msg.h)
	INSERT_SYS_SELECT_H=
	if test x"$ac_cv_header_sys_select_h" = xyes; then
	INSERT_SYS_SELECT_H=" include <sys/select.h>"
	fi
	AC_SUBST(INSERT_SYS_SELECT_H)


	##########################################
	#### Checks for typedefs, structures, ####
	#### and compiler characteristics. ####
	##########################################

	AC_C_CONST
	AC_C_INLINE
	AC_TYPE_SIZE_T
	AC_TYPE_SIGNAL
	AC_DECL_SYS_SIGLIST
	AC_TYPE_PID_T

	GNUPG_CHECK_TYPEDEF(byte, HAVE_BYTE_TYPEDEF)
	GNUPG_CHECK_TYPEDEF(ushort, HAVE_USHORT_TYPEDEF)
	GNUPG_CHECK_TYPEDEF(ulong, HAVE_ULONG_TYPEDEF)
	GNUPG_CHECK_TYPEDEF(u16, HAVE_U16_TYPEDEF)
	GNUPG_CHECK_TYPEDEF(u32, HAVE_U32_TYPEDEF)

	gl_TYPE_SOCKLEN_T
	case "${host}" in
	--mingw32*)
	# socklen_t may or may not be defined depending on what headers
	# are included. To be safe we use int as this is the actual type.
	FALLBACK_SOCKLEN_T="typedef int gcry_socklen_t;"
	;;
	*)
	if test ".$gl_cv_socklen_t_equiv" = "."; then
	FALLBACK_SOCKLEN_T="typedef socklen_t gcry_socklen_t;"
	else
	FALLBACK_SOCKLEN_T="typedef ${gl_cv_socklen_t_equiv} gcry_socklen_t;"
	fi
	esac
	AC_SUBST(FALLBACK_SOCKLEN_T)


	#
	# Check for __builtin_bswap32 intrinsic.
	#
	AC_CACHE_CHECK(for __builtin_bswap32,
	[gcry_cv_have_builtin_bswap32],
	[gcry_cv_have_builtin_bswap32=no
	AC_LINK_IFELSE([AC_LANG_PROGRAM([],
	[int x = 0; int y = __builtin_bswap32(x); return y;])],
	[gcry_cv_have_builtin_bswap32=yes])])
	if test "$gcry_cv_have_builtin_bswap32" = "yes" ; then
	AC_DEFINE(HAVE_BUILTIN_BSWAP32,1,
	[Defined if compiler has '__builtin_bswap32' intrinsic])
	fi


	#
	# Check for __builtin_bswap64 intrinsic.
	#
	AC_CACHE_CHECK(for __builtin_bswap64,
	[gcry_cv_have_builtin_bswap64],
	[gcry_cv_have_builtin_bswap64=no
	AC_LINK_IFELSE([AC_LANG_PROGRAM([],
	[long long x = 0; long long y = __builtin_bswap64(x); return y;])],
	[gcry_cv_have_builtin_bswap64=yes])])
	if test "$gcry_cv_have_builtin_bswap64" = "yes" ; then
	AC_DEFINE(HAVE_BUILTIN_BSWAP64,1,
	[Defined if compiler has '__builtin_bswap64' intrinsic])
	fi


	#
	# Check for VLA support (variable length arrays).
	#
	AC_CACHE_CHECK(whether the variable length arrays are supported,
	[gcry_cv_have_vla],
	[gcry_cv_have_vla=no
	AC_COMPILE_IFELSE([AC_LANG_SOURCE(
	[[void f1(char *, int);
	char foo(int i) {
	char b[(i < 0 ? 0 : i) + 1];
	f1(b, sizeof b); return b[0];}]])],
	[gcry_cv_have_vla=yes])])
	if test "$gcry_cv_have_vla" = "yes" ; then
	AC_DEFINE(HAVE_VLA,1, [Defined if variable length arrays are supported])
	fi


	#
	# Check for ELF visibility support.
	#
	AC_CACHE_CHECK(whether the visibility attribute is supported,
	gcry_cv_visibility_attribute,
	[gcry_cv_visibility_attribute=no
	AC_LANG_CONFTEST([AC_LANG_SOURCE(
	[[int foo __attribute__ ((visibility ("hidden"))) = 1;
	int bar __attribute__ ((visibility ("protected"))) = 1;
	]])])

	if ${CC-cc} -Werror -S conftest.c -o conftest.s \
	1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD ; then
	if grep '\.hidden.*foo' conftest.s >/dev/null 2>&1 ; then
	if grep '\.protected.*bar' conftest.s >/dev/null 2>&1; then
	gcry_cv_visibility_attribute=yes
	fi
	fi
	fi
	])
	if test "$gcry_cv_visibility_attribute" = "yes"; then
	AC_CACHE_CHECK(for broken visibility attribute,
	gcry_cv_broken_visibility_attribute,
	[gcry_cv_broken_visibility_attribute=yes
	AC_LANG_CONFTEST([AC_LANG_SOURCE(
	[[int foo (int x);
	int bar (int x) __asm__ ("foo")
	__attribute__ ((visibility ("hidden")));
	int bar (int x) { return x; }
	]])])

	if ${CC-cc} -Werror -S conftest.c -o conftest.s \
	1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD ; then
	if grep '\.hidden@<:@ _@:>@foo' conftest.s >/dev/null 2>&1;
	then
	gcry_cv_broken_visibility_attribute=no
	fi
	fi
	])
	fi
	if test "$gcry_cv_visibility_attribute" = "yes"; then
	AC_CACHE_CHECK(for broken alias attribute,
	gcry_cv_broken_alias_attribute,
	[gcry_cv_broken_alias_attribute=yes
	AC_LANG_CONFTEST([AC_LANG_SOURCE(
	[[extern int foo (int x) __asm ("xyzzy");
	int bar (int x) { return x; }
	extern __typeof (bar) foo __attribute ((weak, alias ("bar")));
	extern int dfoo;
	extern __typeof (dfoo) dfoo __asm ("abccb");
	int dfoo = 1;
	]])])

	if ${CC-cc} -Werror -S conftest.c -o conftest.s \
	1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD ; then
	if grep 'xyzzy' conftest.s >/dev/null 2>&1 && \
	grep 'abccb' conftest.s >/dev/null 2>&1; then
	gcry_cv_broken_alias_attribute=no
	fi
	fi
	])
	fi
	if test "$gcry_cv_visibility_attribute" = "yes"; then
	AC_CACHE_CHECK(if gcc supports -fvisibility=hidden,
	gcry_cv_gcc_has_f_visibility,
	[gcry_cv_gcc_has_f_visibility=no
	_gcc_cflags_save=$CFLAGS
	CFLAGS="-fvisibility=hidden"
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[])],
	gcry_cv_gcc_has_f_visibility=yes)
	CFLAGS=$_gcc_cflags_save;
	])
	fi
	if test "$gcry_cv_visibility_attribute" = "yes" \
	&& test "$gcry_cv_broken_visibility_attribute" != "yes" \
	&& test "$gcry_cv_broken_alias_attribute" != "yes" \
	&& test "$gcry_cv_gcc_has_f_visibility" = "yes"
	then
	AC_DEFINE(GCRY_USE_VISIBILITY, 1,
	[Define to use the GNU C visibility attribute.])
	CFLAGS="$CFLAGS -fvisibility=hidden"
	fi


	#
	# Check whether the compiler supports the GCC style aligned attribute
	#
	AC_CACHE_CHECK([whether the GCC style aligned attribute is supported],
	[gcry_cv_gcc_attribute_aligned],
	[gcry_cv_gcc_attribute_aligned=no
	AC_COMPILE_IFELSE([AC_LANG_SOURCE(
	[[struct { int a; } foo __attribute__ ((aligned (16)));]])],
	[gcry_cv_gcc_attribute_aligned=yes])])
	if test "$gcry_cv_gcc_attribute_aligned" = "yes" ; then
	AC_DEFINE(HAVE_GCC_ATTRIBUTE_ALIGNED,1,
	[Defined if a GCC style "__attribute__ ((aligned (n))" is supported])
	fi


	#
	# Check whether the compiler supports 'asm' or '__asm__' keyword for
	# assembler blocks.
	#
	AC_CACHE_CHECK([whether 'asm' assembler keyword is supported],
	[gcry_cv_have_asm],
	[gcry_cv_have_asm=no
	AC_COMPILE_IFELSE([AC_LANG_SOURCE(
	[[void a(void) { asm("":::"memory"); }]])],
	[gcry_cv_have_asm=yes])])
	AC_CACHE_CHECK([whether '__asm__' assembler keyword is supported],
	[gcry_cv_have___asm__],
	[gcry_cv_have___asm__=no
	AC_COMPILE_IFELSE([AC_LANG_SOURCE(
	[[void a(void) { __asm__("":::"memory"); }]])],
	[gcry_cv_have___asm__=yes])])
	if test "$gcry_cv_have_asm" = "no" ; then
	if test "$gcry_cv_have___asm__" = "yes" ; then
	AC_DEFINE(asm,__asm__,
	[Define to supported assembler block keyword, if plain 'asm' was not
	supported])
	fi
	fi


	#
	# Check whether the compiler supports inline assembly memory barrier.
	#
	if test "$gcry_cv_have_asm" = "no" ; then
	if test "$gcry_cv_have___asm__" = "yes" ; then
	AC_CACHE_CHECK([whether inline assembly memory barrier is supported],
	[gcry_cv_have_asm_volatile_memory],
	[gcry_cv_have_asm_volatile_memory=no
	AC_COMPILE_IFELSE([AC_LANG_SOURCE(
	[[void a(void) { __asm__ volatile("":::"memory"); }]])],
	[gcry_cv_have_asm_volatile_memory=yes])])
	fi
	else
	AC_CACHE_CHECK([whether inline assembly memory barrier is supported],
	[gcry_cv_have_asm_volatile_memory],
	[gcry_cv_have_asm_volatile_memory=no
	AC_COMPILE_IFELSE([AC_LANG_SOURCE(
	[[void a(void) { asm volatile("":::"memory"); }]])],
	[gcry_cv_have_asm_volatile_memory=yes])])
	fi
	if test "$gcry_cv_have_asm_volatile_memory" = "yes" ; then
	AC_DEFINE(HAVE_GCC_ASM_VOLATILE_MEMORY,1,
	[Define if inline asm memory barrier is supported])
	fi


	#
	# Check whether GCC inline assembler supports SSSE3 instructions
	# This is required for the AES-NI instructions.
	#
	AC_CACHE_CHECK([whether GCC inline assembler supports SSSE3 instructions],
	[gcry_cv_gcc_inline_asm_ssse3],
	[gcry_cv_gcc_inline_asm_ssse3=no
	AC_COMPILE_IFELSE([AC_LANG_SOURCE(
	[[static unsigned char be_mask[16] __attribute__ ((aligned (16))) =
	{ 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
	void a(void) {
	__asm__("pshufb %[mask], %%xmm2\n\t"::[mask]"m"(*be_mask):);
	}]])],
	[gcry_cv_gcc_inline_asm_ssse3=yes])])
	if test "$gcry_cv_gcc_inline_asm_ssse3" = "yes" ; then
	AC_DEFINE(HAVE_GCC_INLINE_ASM_SSSE3,1,
	[Defined if inline assembler supports SSSE3 instructions])
	fi


	#
	# Check whether GCC inline assembler supports PCLMUL instructions.
	#
	AC_CACHE_CHECK([whether GCC inline assembler supports PCLMUL instructions],
	[gcry_cv_gcc_inline_asm_pclmul],
	[gcry_cv_gcc_inline_asm_pclmul=no
	AC_COMPILE_IFELSE([AC_LANG_SOURCE(
	[[void a(void) {
	__asm__("pclmulqdq \$0, %%xmm1, %%xmm3\n\t":::"cc");
	}]])],
	[gcry_cv_gcc_inline_asm_pclmul=yes])])
	if test "$gcry_cv_gcc_inline_asm_pclmul" = "yes" ; then
	AC_DEFINE(HAVE_GCC_INLINE_ASM_PCLMUL,1,
	[Defined if inline assembler supports PCLMUL instructions])
	fi


	#
	# Check whether GCC inline assembler supports AVX instructions
	#
	AC_CACHE_CHECK([whether GCC inline assembler supports AVX instructions],
	[gcry_cv_gcc_inline_asm_avx],
	[gcry_cv_gcc_inline_asm_avx=no
	AC_COMPILE_IFELSE([AC_LANG_SOURCE(
	[[void a(void) {
	__asm__("xgetbv; vaesdeclast (%[mem]),%%xmm0,%%xmm7\n\t"::[mem]"r"(0):);
	}]])],
	[gcry_cv_gcc_inline_asm_avx=yes])])
	if test "$gcry_cv_gcc_inline_asm_avx" = "yes" ; then
	AC_DEFINE(HAVE_GCC_INLINE_ASM_AVX,1,
	[Defined if inline assembler supports AVX instructions])
	fi


	#
	# Check whether GCC inline assembler supports AVX2 instructions
	#
	AC_CACHE_CHECK([whether GCC inline assembler supports AVX2 instructions],
	[gcry_cv_gcc_inline_asm_avx2],
	[gcry_cv_gcc_inline_asm_avx2=no
	AC_COMPILE_IFELSE([AC_LANG_SOURCE(
	[[void a(void) {
	__asm__("xgetbv; vpbroadcastb %%xmm7,%%ymm1\n\t":::"cc");
	}]])],
	[gcry_cv_gcc_inline_asm_avx2=yes])])
	if test "$gcry_cv_gcc_inline_asm_avx2" = "yes" ; then
	AC_DEFINE(HAVE_GCC_INLINE_ASM_AVX2,1,
	[Defined if inline assembler supports AVX2 instructions])
	fi


	#
	# Check whether GCC inline assembler supports BMI2 instructions
	#
	AC_CACHE_CHECK([whether GCC inline assembler supports BMI2 instructions],
	[gcry_cv_gcc_inline_asm_bmi2],
	[gcry_cv_gcc_inline_asm_bmi2=no
	AC_COMPILE_IFELSE([AC_LANG_SOURCE(
	[[void a(void) {
	__asm__("rorxl \$23, %%eax, %%edx\\n\\t":::"memory");
	}]])],
	[gcry_cv_gcc_inline_asm_bmi2=yes])])
	if test "$gcry_cv_gcc_inline_asm_bmi2" = "yes" ; then
	AC_DEFINE(HAVE_GCC_INLINE_ASM_BMI2,1,
	[Defined if inline assembler supports BMI2 instructions])
	fi


	#
	# Check whether GCC assembler supports features needed for our amd64
	# implementations
	#
	if test $amd64_as_feature_detection = yes; then
	AC_CACHE_CHECK([whether GCC assembler is compatible for amd64 assembly implementations],
	[gcry_cv_gcc_amd64_platform_as_ok],
	[gcry_cv_gcc_amd64_platform_as_ok=no
	AC_COMPILE_IFELSE([AC_LANG_SOURCE(
	[[__asm__(
	/* Test if '.type' and '.size' are supported. */
	/* These work only on ELF targets. */
	/* TODO: add COFF (mingw64, cygwin64) support to assembly
	* implementations. Mingw64/cygwin64 also require additional
	* work because they use different calling convention. */
	"asmfunc:\n\t"
	".size asmfunc,.-asmfunc;\n\t"
	".type asmfunc,@function;\n\t"
	);]])],
	[gcry_cv_gcc_amd64_platform_as_ok=yes])])
	if test "$gcry_cv_gcc_amd64_platform_as_ok" = "yes" ; then
	AC_DEFINE(HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS,1,
	[Defined if underlying assembler is compatible with amd64 assembly implementations])
	fi
	fi


	#
	# Check whether GCC assembler supports features needed for assembly
	# implementations that use Intel syntax
	#
	AC_CACHE_CHECK([whether GCC assembler is compatible for Intel syntax assembly implementations],
	[gcry_cv_gcc_platform_as_ok_for_intel_syntax],
	[gcry_cv_gcc_platform_as_ok_for_intel_syntax=no
	AC_COMPILE_IFELSE([AC_LANG_SOURCE(
	[[__asm__(
	".intel_syntax noprefix\n\t"
	"pxor xmm1, xmm7;\n\t"
	/* Intel syntax implementation also use GAS macros, so check
	* for them here. */
	"VAL_A = xmm4\n\t"
	"VAL_B = xmm2\n\t"
	".macro SET_VAL_A p1\n\t"
	" VAL_A = \\\\p1 \n\t"
	".endm\n\t"
	".macro SET_VAL_B p1\n\t"
	" VAL_B = \\\\p1 \n\t"
	".endm\n\t"
	"vmovdqa VAL_A, VAL_B;\n\t"
	"SET_VAL_A eax\n\t"
	"SET_VAL_B ebp\n\t"
	"add VAL_A, VAL_B;\n\t"
	"add VAL_B, 0b10101;\n\t"
	);]])],
	[gcry_cv_gcc_platform_as_ok_for_intel_syntax=yes])])
	if test "$gcry_cv_gcc_platform_as_ok_for_intel_syntax" = "yes" ; then
	AC_DEFINE(HAVE_INTEL_SYNTAX_PLATFORM_AS,1,
	[Defined if underlying assembler is compatible with Intel syntax assembly implementations])
	fi


	#
	# Check whether compiler is configured for ARMv6 or newer architecture
	#
	AC_CACHE_CHECK([whether compiler is configured for ARMv6 or newer architecture],
	[gcry_cv_cc_arm_arch_is_v6],
	[AC_EGREP_CPP(yes,
	[#if defined(__arm__) && \
	((defined(__ARM_ARCH) && __ARM_ARCH >= 6) \
	\|\| defined(__ARM_ARCH_6__) \|\| defined(__ARM_ARCH_6J__) \
	\|\| defined(__ARM_ARCH_6Z__) \|\| defined(__ARM_ARCH_6ZK__) \
	\|\| defined(__ARM_ARCH_6K__) \|\| defined(__ARM_ARCH_6T2__) \
	\|\| defined(__ARM_ARCH_7__) \|\| defined(__ARM_ARCH_7A__) \
	\|\| defined(__ARM_ARCH_7R__) \|\| defined(__ARM_ARCH_7M__) \
	\|\| defined(__ARM_ARCH_7EM__))
	yes
	#endif
	], gcry_cv_cc_arm_arch_is_v6=yes, gcry_cv_cc_arm_arch_is_v6=no)])
	if test "$gcry_cv_cc_arm_arch_is_v6" = "yes" ; then
	AC_DEFINE(HAVE_ARM_ARCH_V6,1,
	[Defined if ARM architecture is v6 or newer])
	fi


	#
	# Check whether GCC inline assembler supports NEON instructions
	#
	AC_CACHE_CHECK([whether GCC inline assembler supports NEON instructions],
	[gcry_cv_gcc_inline_asm_neon],
	[gcry_cv_gcc_inline_asm_neon=no
	AC_COMPILE_IFELSE([AC_LANG_SOURCE(
	[[__asm__(
	".syntax unified\n\t"
	".thumb\n\t"
	".fpu neon\n\t"
	"vld1.64 {%q0-%q1}, [%r0]!;\n\t"
	"vrev64.8 %q0, %q3;\n\t"
	"vadd.u64 %q0, %q1;\n\t"
	"vadd.s64 %d3, %d2, %d3;\n\t"
	);
	]])],
	[gcry_cv_gcc_inline_asm_neon=yes])])
	if test "$gcry_cv_gcc_inline_asm_neon" = "yes" ; then
	AC_DEFINE(HAVE_GCC_INLINE_ASM_NEON,1,
	[Defined if inline assembler supports NEON instructions])
	fi


	#
	# Check whether GCC assembler supports features needed for our ARM
	# implementations
	#
	AC_CACHE_CHECK([whether GCC assembler is compatible for ARM assembly implementations],
	[gcry_cv_gcc_arm_platform_as_ok],
	[gcry_cv_gcc_arm_platform_as_ok=no
	AC_COMPILE_IFELSE([AC_LANG_SOURCE(
	[[__asm__(
	/* Test if assembler supports UAL syntax. */
	".syntax unified\n\t"
	".arm\n\t" /* our assembly code is in ARM mode */
	/* Following causes error if assembler ignored '.syntax unified'. */
	"asmfunc:\n\t"
	"add %r0, %r0, %r4, ror #12;\n\t"

	/* Test if '.type' and '.size' are supported. */
	".size asmfunc,.-asmfunc;\n\t"
	".type asmfunc,%function;\n\t"
	);]])],
	[gcry_cv_gcc_arm_platform_as_ok=yes])])
	if test "$gcry_cv_gcc_arm_platform_as_ok" = "yes" ; then
	AC_DEFINE(HAVE_COMPATIBLE_GCC_ARM_PLATFORM_AS,1,
	[Defined if underlying assembler is compatible with ARM assembly implementations])
	fi


	#######################################
	#### Checks for library functions. ####
	#######################################

	AC_FUNC_VPRINTF
	# We have replacements for these in src/missing-string.c
	AC_CHECK_FUNCS(stpcpy strcasecmp)
	# We have replacements for these in src/g10lib.h
	AC_CHECK_FUNCS(strtoul memmove stricmp atexit raise)
	# Other checks
	AC_CHECK_FUNCS(strerror rand mmap getpagesize sysconf waitpid wait4)
	AC_CHECK_FUNCS(gettimeofday getrusage gethrtime clock_gettime syslog)
	AC_CHECK_FUNCS(fcntl ftruncate)

	GNUPG_CHECK_MLOCK

	#
	# Replacement functions.
	#
	AC_REPLACE_FUNCS([getpid clock])


	#
	# Check wether it is necessary to link against libdl.
	#
	DL_LIBS=""
	if test "$use_hmac_binary_check" = yes ; then
	_gcry_save_libs="$LIBS"
	LIBS=""
	AC_SEARCH_LIBS(dlopen, c dl,,,)
	DL_LIBS=$LIBS
	LIBS="$_gcry_save_libs"
	LIBGCRYPT_CONFIG_LIBS="${LIBGCRYPT_CONFIG_LIBS} ${DL_LIBS}"
	fi
	AC_SUBST(DL_LIBS)


	#
	# Check whether we can use Linux capabilities as requested.
	#
	if test "$use_capabilities" = "yes" ; then
	use_capabilities=no
	AC_CHECK_HEADERS(sys/capability.h)
	if test "$ac_cv_header_sys_capability_h" = "yes" ; then
	AC_CHECK_LIB(cap, cap_init, ac_need_libcap=1)
	if test "$ac_cv_lib_cap_cap_init" = "yes"; then
	AC_DEFINE(USE_CAPABILITIES,1,
	[define if capabilities should be used])
	LIBS="$LIBS -lcap"
	use_capabilities=yes
	fi
	fi
	if test "$use_capabilities" = "no" ; then
	AC_MSG_WARN([[
	***
	*** The use of capabilities on this system is not possible.
	*** You need a recent Linux kernel and some patches:
	*** fcaps-2.2.9-990610.patch (kernel patch for 2.2.9)
	*** fcap-module-990613.tar.gz (kernel module)
	*** libcap-1.92.tar.gz (user mode library and utilities)
	*** And you have to configure the kernel with CONFIG_VFS_CAP_PLUGIN
	*** set (filesystems menu). Be warned: This code is really ALPHA.
	***]])
	fi
	fi

	# Check whether a random device is available.
	if test "$try_dev_random" = yes ; then
	AC_CACHE_CHECK(for random device, ac_cv_have_dev_random,
	[if test -r "$NAME_OF_DEV_RANDOM" && test -r "$NAME_OF_DEV_URANDOM" ; then
	ac_cv_have_dev_random=yes; else ac_cv_have_dev_random=no; fi])
	if test "$ac_cv_have_dev_random" = yes; then
	AC_DEFINE(HAVE_DEV_RANDOM,1,
	[defined if the system supports a random device] )
	fi
	else
	AC_MSG_CHECKING(for random device)
	ac_cv_have_dev_random=no
	AC_MSG_RESULT(has been disabled)
	fi

	# Figure out the random modules for this configuration.
	if test "$random" = "default"; then

	# Select default value.
	if test "$ac_cv_have_dev_random" = yes; then
	# Try Linuxish random device.
	random_modules="linux"
	else
	case "${host}" in
	--mingw32ce*)
	# WindowsCE random device.
	random_modules="w32ce"
	;;
	--mingw32\|--cygwin)
	# Windows random device.
	random_modules="w32"
	;;
	*)
	# Build everything, allow to select at runtime.
	random_modules="$auto_random_modules"
	;;
	esac
	fi
	else
	if test "$random" = "auto"; then
	# Build everything, allow to select at runtime.
	random_modules="$auto_random_modules"
	else
	random_modules="$random"
	fi
	fi


	#
	# Setup assembler stuff.
	#
	# Note that config.links also defines mpi_cpu_arch, which is required
	# later on.
	#
	GNUPG_SYS_SYMBOL_UNDERSCORE()
	AC_ARG_ENABLE(mpi-path,
	AC_HELP_STRING([--enable-mpi-path=EXTRA_PATH],
	[prepend EXTRA_PATH to list of CPU specific optimizations]),
	mpi_extra_path="$enableval",mpi_extra_path="")
	AC_MSG_CHECKING(for mpi assembler functions)
	if test -f $srcdir/mpi/config.links ; then
	. $srcdir/mpi/config.links
	AC_CONFIG_LINKS("$mpi_ln_list")
	ac_cv_mpi_sflags="$mpi_sflags"
	AC_MSG_RESULT(done)
	else
	AC_MSG_RESULT(failed)
	AC_MSG_ERROR([mpi/config.links missing!])
	fi
	MPI_SFLAGS="$ac_cv_mpi_sflags"
	AC_SUBST(MPI_SFLAGS)

	AM_CONDITIONAL(MPI_MOD_ASM_MPIH_ADD1, test "$mpi_mod_asm_mpih_add1" = yes)
	AM_CONDITIONAL(MPI_MOD_ASM_MPIH_SUB1, test "$mpi_mod_asm_mpih_sub1" = yes)
	AM_CONDITIONAL(MPI_MOD_ASM_MPIH_MUL1, test "$mpi_mod_asm_mpih_mul1" = yes)
	AM_CONDITIONAL(MPI_MOD_ASM_MPIH_MUL2, test "$mpi_mod_asm_mpih_mul2" = yes)
	AM_CONDITIONAL(MPI_MOD_ASM_MPIH_MUL3, test "$mpi_mod_asm_mpih_mul3" = yes)
	AM_CONDITIONAL(MPI_MOD_ASM_MPIH_LSHIFT, test "$mpi_mod_asm_mpih_lshift" = yes)
	AM_CONDITIONAL(MPI_MOD_ASM_MPIH_RSHIFT, test "$mpi_mod_asm_mpih_rshift" = yes)
	AM_CONDITIONAL(MPI_MOD_ASM_UDIV, test "$mpi_mod_asm_udiv" = yes)
	AM_CONDITIONAL(MPI_MOD_ASM_UDIV_QRNND, test "$mpi_mod_asm_udiv_qrnnd" = yes)
	AM_CONDITIONAL(MPI_MOD_C_MPIH_ADD1, test "$mpi_mod_c_mpih_add1" = yes)
	AM_CONDITIONAL(MPI_MOD_C_MPIH_SUB1, test "$mpi_mod_c_mpih_sub1" = yes)
	AM_CONDITIONAL(MPI_MOD_C_MPIH_MUL1, test "$mpi_mod_c_mpih_mul1" = yes)
	AM_CONDITIONAL(MPI_MOD_C_MPIH_MUL2, test "$mpi_mod_c_mpih_mul2" = yes)
	AM_CONDITIONAL(MPI_MOD_C_MPIH_MUL3, test "$mpi_mod_c_mpih_mul3" = yes)
	AM_CONDITIONAL(MPI_MOD_C_MPIH_LSHIFT, test "$mpi_mod_c_mpih_lshift" = yes)
	AM_CONDITIONAL(MPI_MOD_C_MPIH_RSHIFT, test "$mpi_mod_c_mpih_rshift" = yes)
	AM_CONDITIONAL(MPI_MOD_C_UDIV, test "$mpi_mod_c_udiv" = yes)
	AM_CONDITIONAL(MPI_MOD_C_UDIV_QRNND, test "$mpi_mod_c_udiv_qrnnd" = yes)

	if test mym4_isgit = "yes"; then
	AC_DEFINE(IS_DEVELOPMENT_VERSION,1,
	[Defined if this is not a regular release])
	fi


	AM_CONDITIONAL(CROSS_COMPILING, test x$cross_compiling = xyes)


	# This is handy for debugging so the compiler doesn't rearrange
	# things and eliminate variables.
	AC_ARG_ENABLE(optimization,
	AC_HELP_STRING([--disable-optimization],
	[disable compiler optimization]),
	[if test $enableval = no ; then
	CFLAGS=`echo $CFLAGS \| sed 's/-O[[0-9]]//'`
	fi])

	# CFLAGS mangling when using gcc.
	if test "$GCC" = yes; then
	CFLAGS="$CFLAGS -Wall"
	if test "$USE_MAINTAINER_MODE" = "yes"; then
	CFLAGS="$CFLAGS -Wcast-align -Wshadow -Wstrict-prototypes"
	CFLAGS="$CFLAGS -Wformat -Wno-format-y2k -Wformat-security"

	# If -Wno-missing-field-initializers is supported we can enable a
	# a bunch of really useful warnings.
	AC_MSG_CHECKING([if gcc supports -Wno-missing-field-initializers])
	_gcc_cflags_save=$CFLAGS
	CFLAGS="-Wno-missing-field-initializers"
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[])],_gcc_wopt=yes,_gcc_wopt=no)
	AC_MSG_RESULT($_gcc_wopt)
	CFLAGS=$_gcc_cflags_save;
	if test x"$_gcc_wopt" = xyes ; then
	CFLAGS="$CFLAGS -W -Wextra -Wbad-function-cast"
	CFLAGS="$CFLAGS -Wwrite-strings"
	CFLAGS="$CFLAGS -Wdeclaration-after-statement"
	CFLAGS="$CFLAGS -Wno-missing-field-initializers"
	CFLAGS="$CFLAGS -Wno-sign-compare"
	fi

	AC_MSG_CHECKING([if gcc supports -Wpointer-arith])
	_gcc_cflags_save=$CFLAGS
	CFLAGS="-Wpointer-arith"
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[])],_gcc_wopt=yes,_gcc_wopt=no)
	AC_MSG_RESULT($_gcc_wopt)
	CFLAGS=$_gcc_cflags_save;
	if test x"$_gcc_wopt" = xyes ; then
	CFLAGS="$CFLAGS -Wpointer-arith"
	fi
	fi

	fi

	# Check whether as(1) supports a noeexecstack feature. This test
	# includes an override option.
	CL_AS_NOEXECSTACK


	AC_SUBST(LIBGCRYPT_CONFIG_API_VERSION)
	AC_SUBST(LIBGCRYPT_CONFIG_LIBS)
	AC_SUBST(LIBGCRYPT_CONFIG_CFLAGS)
	AC_SUBST(LIBGCRYPT_CONFIG_HOST)
	AC_SUBST(LIBGCRYPT_THREAD_MODULES)

	AC_CONFIG_COMMANDS([gcrypt-conf],[[
	chmod +x src/libgcrypt-config
	]],[[
	prefix=$prefix
	exec_prefix=$exec_prefix
	libdir=$libdir
	datadir=$datadir
	DATADIRNAME=$DATADIRNAME
	]])

	#####################
	#### Conclusion. ####
	#####################

	# Check that requested feature can actually be used and define
	# ENABLE_foo_SUPPORT macros.

	if test x"$aesnisupport" = xyes ; then
	if test "$gcry_cv_gcc_inline_asm_ssse3" != "yes" ; then
	aesnisupport="no (unsupported by compiler)"
	fi
	fi
	if test x"$pclmulsupport" = xyes ; then
	if test "$gcry_cv_gcc_inline_asm_pclmul" != "yes" ; then
	pclmulsupport="no (unsupported by compiler)"
	fi
	fi
	if test x"$avxsupport" = xyes ; then
	if test "$gcry_cv_gcc_inline_asm_avx" != "yes" ; then
	avxsupport="no (unsupported by compiler)"
	fi
	fi
	if test x"$avx2support" = xyes ; then
	if test "$gcry_cv_gcc_inline_asm_avx2" != "yes" ; then
	avx2support="no (unsupported by compiler)"
	fi
	fi
	if test x"$neonsupport" = xyes ; then
	if test "$gcry_cv_gcc_inline_asm_neon" != "yes" ; then
	neonsupport="no (unsupported by compiler)"
	fi
	fi

	if test x"$aesnisupport" = xyes ; then
	AC_DEFINE(ENABLE_AESNI_SUPPORT, 1,
	[Enable support for Intel AES-NI instructions.])
	fi
	if test x"$pclmulsupport" = xyes ; then
	AC_DEFINE(ENABLE_PCLMUL_SUPPORT, 1,
	[Enable support for Intel PCLMUL instructions.])
	fi
	if test x"$avxsupport" = xyes ; then
	AC_DEFINE(ENABLE_AVX_SUPPORT,1,
	[Enable support for Intel AVX instructions.])
	fi
	if test x"$avx2support" = xyes ; then
	AC_DEFINE(ENABLE_AVX2_SUPPORT,1,
	[Enable support for Intel AVX2 instructions.])
	fi
	if test x"$neonsupport" = xyes ; then
	AC_DEFINE(ENABLE_NEON_SUPPORT,1,
	[Enable support for ARM NEON instructions.])
	fi


	# Define conditional sources and config.h symbols depending on the
	# selected ciphers, pubkey-ciphers, digests, kdfs, and random modules.

	LIST_MEMBER(arcfour, $enabled_ciphers)
	if test "$found" = "1"; then
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS arcfour.lo"
	AC_DEFINE(USE_ARCFOUR, 1, [Defined if this module should be included])
	+
	+ case "${host}" in
	+ x86_64--)
	+ # Build with the assembly implementation
	+ GCRYPT_CIPHERS="$GCRYPT_CIPHERS arcfour-amd64.lo"
	+ ;;
	+ esac
	fi

	LIST_MEMBER(blowfish, $enabled_ciphers)
	if test "$found" = "1" ; then
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS blowfish.lo"
	AC_DEFINE(USE_BLOWFISH, 1, [Defined if this module should be included])

	case "${host}" in
	x86_64--)
	# Build with the assembly implementation
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS blowfish-amd64.lo"
	;;
	arm--*)
	# Build with the assembly implementation
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS blowfish-arm.lo"
	;;
	esac
	fi

	LIST_MEMBER(cast5, $enabled_ciphers)
	if test "$found" = "1" ; then
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS cast5.lo"
	AC_DEFINE(USE_CAST5, 1, [Defined if this module should be included])

	case "${host}" in
	x86_64--)
	# Build with the assembly implementation
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS cast5-amd64.lo"
	;;
	arm--*)
	# Build with the assembly implementation
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS cast5-arm.lo"
	;;
	esac
	fi

	LIST_MEMBER(des, $enabled_ciphers)
	if test "$found" = "1" ; then
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS des.lo"
	AC_DEFINE(USE_DES, 1, [Defined if this module should be included])
	fi

	LIST_MEMBER(aes, $enabled_ciphers)
	if test "$found" = "1" ; then
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael.lo"
	AC_DEFINE(USE_AES, 1, [Defined if this module should be included])

	case "${host}" in
	x86_64--)
	# Build with the assembly implementation
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael-amd64.lo"
	;;
	arm--*)
	# Build with the assembly implementation
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael-arm.lo"
	;;
	esac
	fi

	LIST_MEMBER(twofish, $enabled_ciphers)
	if test "$found" = "1" ; then
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS twofish.lo"
	AC_DEFINE(USE_TWOFISH, 1, [Defined if this module should be included])

	case "${host}" in
	x86_64--)
	# Build with the assembly implementation
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS twofish-amd64.lo"
	;;
	arm--*)
	# Build with the assembly implementation
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS twofish-arm.lo"
	;;
	esac
	fi

	LIST_MEMBER(serpent, $enabled_ciphers)
	if test "$found" = "1" ; then
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS serpent.lo"
	AC_DEFINE(USE_SERPENT, 1, [Defined if this module should be included])

	case "${host}" in
	x86_64--)
	# Build with the SSE2 implementation
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS serpent-sse2-amd64.lo"
	;;
	esac

	if test x"$avx2support" = xyes ; then
	# Build with the AVX2 implementation
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS serpent-avx2-amd64.lo"
	fi

	if test x"$neonsupport" = xyes ; then
	# Build with the NEON implementation
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS serpent-armv7-neon.lo"
	fi
	fi

	LIST_MEMBER(rfc2268, $enabled_ciphers)
	if test "$found" = "1" ; then
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS rfc2268.lo"
	AC_DEFINE(USE_RFC2268, 1, [Defined if this module should be included])
	fi

	LIST_MEMBER(seed, $enabled_ciphers)
	if test "$found" = "1" ; then
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS seed.lo"
	AC_DEFINE(USE_SEED, 1, [Defined if this module should be included])
	fi

	LIST_MEMBER(camellia, $enabled_ciphers)
	if test "$found" = "1" ; then
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS camellia.lo camellia-glue.lo"
	AC_DEFINE(USE_CAMELLIA, 1, [Defined if this module should be included])

	case "${host}" in
	arm--*)
	# Build with the assembly implementation
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS camellia-arm.lo"
	;;
	esac

	if test x"$avxsupport" = xyes ; then
	if test x"$aesnisupport" = xyes ; then
	# Build with the AES-NI/AVX implementation
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS camellia-aesni-avx-amd64.lo"
	fi
	fi

	if test x"$avx2support" = xyes ; then
	if test x"$aesnisupport" = xyes ; then
	# Build with the AES-NI/AVX2 implementation
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS camellia-aesni-avx2-amd64.lo"
	fi
	fi
	fi

	LIST_MEMBER(idea, $enabled_ciphers)
	if test "$found" = "1" ; then
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS idea.lo"
	AC_DEFINE(USE_IDEA, 1, [Defined if this module should be included])
	fi

	LIST_MEMBER(salsa20, $enabled_ciphers)
	if test "$found" = "1" ; then
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS salsa20.lo"
	AC_DEFINE(USE_SALSA20, 1, [Defined if this module should be included])

	case "${host}" in
	x86_64--)
	# Build with the assembly implementation
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS salsa20-amd64.lo"
	;;
	esac

	if test x"$neonsupport" = xyes ; then
	# Build with the NEON implementation
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS salsa20-armv7-neon.lo"
	fi
	fi

	LIST_MEMBER(gost28147, $enabled_ciphers)
	if test "$found" = "1" ; then
	GCRYPT_CIPHERS="$GCRYPT_CIPHERS gost28147.lo"
	AC_DEFINE(USE_GOST28147, 1, [Defined if this module should be included])
	fi

	LIST_MEMBER(dsa, $enabled_pubkey_ciphers)
	if test "$found" = "1" ; then
	GCRYPT_PUBKEY_CIPHERS="$GCRYPT_PUBKEY_CIPHERS dsa.lo"
	AC_DEFINE(USE_DSA, 1, [Defined if this module should be included])
	fi

	LIST_MEMBER(rsa, $enabled_pubkey_ciphers)
	if test "$found" = "1" ; then
	GCRYPT_PUBKEY_CIPHERS="$GCRYPT_PUBKEY_CIPHERS rsa.lo"
	AC_DEFINE(USE_RSA, 1, [Defined if this module should be included])
	fi

	LIST_MEMBER(elgamal, $enabled_pubkey_ciphers)
	if test "$found" = "1" ; then
	GCRYPT_PUBKEY_CIPHERS="$GCRYPT_PUBKEY_CIPHERS elgamal.lo"
	AC_DEFINE(USE_ELGAMAL, 1, [Defined if this module should be included])
	fi

	LIST_MEMBER(ecc, $enabled_pubkey_ciphers)
	if test "$found" = "1" ; then
	GCRYPT_PUBKEY_CIPHERS="$GCRYPT_PUBKEY_CIPHERS \
	ecc.lo ecc-curves.lo ecc-misc.lo \
	ecc-ecdsa.lo ecc-eddsa.lo ecc-gost.lo"
	AC_DEFINE(USE_ECC, 1, [Defined if this module should be included])
	fi

	LIST_MEMBER(crc, $enabled_digests)
	if test "$found" = "1" ; then
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS crc.lo"
	AC_DEFINE(USE_CRC, 1, [Defined if this module should be included])
	fi

	LIST_MEMBER(gostr3411-94, $enabled_digests)
	if test "$found" = "1" ; then
	# GOST R 34.11-94 internally uses GOST 28147-89
	LIST_MEMBER(gost28147, $enabled_ciphers)
	if test "$found" = "1" ; then
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS gostr3411-94.lo"
	AC_DEFINE(USE_GOST_R_3411_94, 1, [Defined if this module should be included])
	fi
	fi

	LIST_MEMBER(stribog, $enabled_digests)
	if test "$found" = "1" ; then
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS stribog.lo"
	AC_DEFINE(USE_GOST_R_3411_12, 1, [Defined if this module should be included])
	fi

	LIST_MEMBER(md4, $enabled_digests)
	if test "$found" = "1" ; then
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS md4.lo"
	AC_DEFINE(USE_MD4, 1, [Defined if this module should be included])
	fi

	LIST_MEMBER(md5, $enabled_digests)
	if test "$found" = "1" ; then
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS md5.lo"
	AC_DEFINE(USE_MD5, 1, [Defined if this module should be included])
	fi

	LIST_MEMBER(sha256, $enabled_digests)
	if test "$found" = "1" ; then
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha256.lo"
	AC_DEFINE(USE_SHA256, 1, [Defined if this module should be included])

	case "${host}" in
	x86_64--)
	# Build with the assembly implementation
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha256-ssse3-amd64.lo"
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha256-avx-amd64.lo"
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha256-avx2-bmi2-amd64.lo"
	;;
	esac
	fi

	LIST_MEMBER(sha512, $enabled_digests)
	if test "$found" = "1" ; then
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha512.lo"
	AC_DEFINE(USE_SHA512, 1, [Defined if this module should be included])

	case "${host}" in
	x86_64--)
	# Build with the assembly implementation
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha512-ssse3-amd64.lo"
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha512-avx-amd64.lo"
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha512-avx2-bmi2-amd64.lo"
	;;
	esac

	if test x"$neonsupport" = xyes ; then
	# Build with the NEON implementation
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha512-armv7-neon.lo"
	fi
	fi

	LIST_MEMBER(tiger, $enabled_digests)
	if test "$found" = "1" ; then
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS tiger.lo"
	AC_DEFINE(USE_TIGER, 1, [Defined if this module should be included])
	fi

	LIST_MEMBER(whirlpool, $enabled_digests)
	if test "$found" = "1" ; then
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS whirlpool.lo"
	AC_DEFINE(USE_WHIRLPOOL, 1, [Defined if this module should be included])
	fi

	# rmd160 and sha1 should be included always.
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS rmd160.lo sha1.lo"
	AC_DEFINE(USE_RMD160, 1, [Defined if this module should be included])
	AC_DEFINE(USE_SHA1, 1, [Defined if this module should be included])

	case "${host}" in
	x86_64--)
	# Build with the assembly implementation
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha1-ssse3-amd64.lo"
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha1-avx-amd64.lo"
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha1-avx-bmi2-amd64.lo"
	;;
	arm--*)
	# Build with the assembly implementation
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha1-armv7-neon.lo"
	;;
	esac

	LIST_MEMBER(scrypt, $enabled_kdfs)
	if test "$found" = "1" ; then
	GCRYPT_KDFS="$GCRYPT_KDFS scrypt.lo"
	AC_DEFINE(USE_SCRYPT, 1, [Defined if this module should be included])
	fi

	LIST_MEMBER(linux, $random_modules)
	if test "$found" = "1" ; then
	GCRYPT_RANDOM="$GCRYPT_RANDOM rndlinux.lo"
	AC_DEFINE(USE_RNDLINUX, 1, [Defined if the /dev/random RNG should be used.])
	fi

	LIST_MEMBER(unix, $random_modules)
	if test "$found" = "1" ; then
	GCRYPT_RANDOM="$GCRYPT_RANDOM rndunix.lo"
	AC_DEFINE(USE_RNDUNIX, 1, [Defined if the default Unix RNG should be used.])
	print_egd_notice=yes
	fi

	LIST_MEMBER(egd, $random_modules)
	if test "$found" = "1" ; then
	GCRYPT_RANDOM="$GCRYPT_RANDOM rndegd.lo"
	AC_DEFINE(USE_RNDEGD, 1, [Defined if the EGD based RNG should be used.])
	fi

	LIST_MEMBER(w32, $random_modules)
	if test "$found" = "1" ; then
	GCRYPT_RANDOM="$GCRYPT_RANDOM rndw32.lo"
	AC_DEFINE(USE_RNDW32, 1,
	[Defined if the Windows specific RNG should be used.])
	fi

	LIST_MEMBER(w32ce, $random_modules)
	if test "$found" = "1" ; then
	GCRYPT_RANDOM="$GCRYPT_RANDOM rndw32ce.lo"
	AC_DEFINE(USE_RNDW32CE, 1,
	[Defined if the WindowsCE specific RNG should be used.])
	fi

	AC_SUBST([GCRYPT_CIPHERS])
	AC_SUBST([GCRYPT_PUBKEY_CIPHERS])
	AC_SUBST([GCRYPT_DIGESTS])
	AC_SUBST([GCRYPT_KDFS])
	AC_SUBST([GCRYPT_RANDOM])

	AC_SUBST(LIBGCRYPT_CIPHERS, $enabled_ciphers)
	AC_SUBST(LIBGCRYPT_PUBKEY_CIPHERS, $enabled_pubkey_ciphers)
	AC_SUBST(LIBGCRYPT_DIGESTS, $enabled_digests)

	# For printing the configuration we need a colon separated list of
	# algorithm names.
	tmp=`echo "$enabled_ciphers" \| tr ' ' : `
	AC_DEFINE_UNQUOTED(LIBGCRYPT_CIPHERS, "$tmp",
	[List of available cipher algorithms])
	tmp=`echo "$enabled_pubkey_ciphers" \| tr ' ' : `
	AC_DEFINE_UNQUOTED(LIBGCRYPT_PUBKEY_CIPHERS, "$tmp",
	[List of available public key cipher algorithms])
	tmp=`echo "$enabled_digests" \| tr ' ' : `
	AC_DEFINE_UNQUOTED(LIBGCRYPT_DIGESTS, "$tmp",
	[List of available digest algorithms])
	tmp=`echo "$enabled_kdfs" \| tr ' ' : `
	AC_DEFINE_UNQUOTED(LIBGCRYPT_KDFS, "$tmp",
	[List of available KDF algorithms])


	#
	# Define conditional sources depending on the used hardware platform.
	# Note that all possible modules must also be listed in
	# src/Makefile.am (EXTRA_libgcrypt_la_SOURCES).
	#
	GCRYPT_HWF_MODULES=
	case "$mpi_cpu_arch" in
	x86)
	AC_DEFINE(HAVE_CPU_ARCH_X86, 1, [Defined for the x86 platforms])
	GCRYPT_HWF_MODULES="hwf-x86.lo"
	;;
	alpha)
	AC_DEFINE(HAVE_CPU_ARCH_ALPHA, 1, [Defined for Alpha platforms])
	;;
	sparc)
	AC_DEFINE(HAVE_CPU_ARCH_SPARC, 1, [Defined for SPARC platforms])
	;;
	mips)
	AC_DEFINE(HAVE_CPU_ARCH_MIPS, 1, [Defined for MIPS platforms])
	;;
	m68k)
	AC_DEFINE(HAVE_CPU_ARCH_M68K, 1, [Defined for M68k platforms])
	;;
	ppc)
	AC_DEFINE(HAVE_CPU_ARCH_PPC, 1, [Defined for PPC platforms])
	;;
	arm)
	AC_DEFINE(HAVE_CPU_ARCH_ARM, 1, [Defined for ARM platforms])
	GCRYPT_HWF_MODULES="hwf-arm.lo"
	;;
	esac
	AC_SUBST([GCRYPT_HWF_MODULES])


	#
	# Provide information about the build.
	#
	BUILD_REVISION="mym4_revision"
	AC_SUBST(BUILD_REVISION)
	AC_DEFINE_UNQUOTED(BUILD_REVISION, "$BUILD_REVISION",
	[GIT commit id revision used to build this package])

	changequote(,)dnl
	BUILD_FILEVERSION=`echo "$VERSION" \| sed 's/$[0-9.]$./\1./;s/\./,/g'`
	changequote([,])dnl
	BUILD_FILEVERSION="${BUILD_FILEVERSION}mym4_revision_dec"
	AC_SUBST(BUILD_FILEVERSION)

	BUILD_TIMESTAMP=`date -u +%Y-%m-%dT%H:%M+0000 2>/dev/null \|\| date`
	AC_SUBST(BUILD_TIMESTAMP)
	AC_DEFINE_UNQUOTED(BUILD_TIMESTAMP, "$BUILD_TIMESTAMP",
	[The time this package was configured for a build])


	# And create the files.
	AC_CONFIG_FILES([
	Makefile
	m4/Makefile
	compat/Makefile
	mpi/Makefile
	cipher/Makefile
	random/Makefile
	doc/Makefile
	src/Makefile
	src/gcrypt.h
	src/libgcrypt-config
	src/versioninfo.rc
	tests/Makefile
	])
	AC_CONFIG_FILES([tests/hashtest-256g], [chmod +x tests/hashtest-256g])
	AC_OUTPUT


	detection_module="${GCRYPT_HWF_MODULES%.lo}"
	test -n "$detection_module" \|\| detection_module="none"

	# Give some feedback
	GCRY_MSG_SHOW([],[])
	GCRY_MSG_SHOW([Libgcrypt],[v${VERSION} has been configured as follows:])
	GCRY_MSG_SHOW([],[])
	GCRY_MSG_SHOW([Platform: ],[$PRINTABLE_OS_NAME ($host)])
	GCRY_MSG_SHOW([Hardware detection module:],[$detection_module])
	GCRY_MSG_WRAP([Enabled cipher algorithms:],[$enabled_ciphers])
	GCRY_MSG_WRAP([Enabled digest algorithms:],[$enabled_digests])
	GCRY_MSG_WRAP([Enabled kdf algorithms: ],[$enabled_kdfs])
	GCRY_MSG_WRAP([Enabled pubkey algorithms:],[$enabled_pubkey_ciphers])
	GCRY_MSG_SHOW([Random number generator: ],[$random])
	GCRY_MSG_SHOW([Using linux capabilities: ],[$use_capabilities])
	GCRY_MSG_SHOW([Try using Padlock crypto: ],[$padlocksupport])
	GCRY_MSG_SHOW([Try using AES-NI crypto: ],[$aesnisupport])
	GCRY_MSG_SHOW([Try using Intel PCLMUL: ],[$pclmulsupport])
	GCRY_MSG_SHOW([Try using DRNG (RDRAND): ],[$drngsupport])
	GCRY_MSG_SHOW([Try using Intel AVX: ],[$avxsupport])
	GCRY_MSG_SHOW([Try using Intel AVX2: ],[$avx2support])
	GCRY_MSG_SHOW([Try using ARM NEON: ],[$neonsupport])
	GCRY_MSG_SHOW([],[])

	if test "$print_egd_notice" = "yes"; then
	cat <<G10EOF

	The performance of the Unix random gatherer module (rndunix) is not
	very good and it does not keep the entropy pool over multiple
	invocations of Libgcrypt base applications. The suggested way to
	overcome this problem is to use the

	Entropy Gathering Daemon (EGD)

	which provides a entropy source for the whole system. It is written
	in Perl and available at the GnuPG FTP servers. To enable EGD you
	should rerun configure with the option "--enable-static-rnd=egd".
	For more information consult the GnuPG webpages:

	http://www.gnupg.org/download.html#egd

	G10EOF
	fi

	if test "$gcry_cv_gcc_attribute_aligned" != "yes" ; then
	cat <<G10EOF

	Please not that your compiler does not support the GCC style
	aligned attribute. Using this software may evoke bus errors.

	G10EOF
	fi

	if test -n "$gpl"; then
	echo "Please note that you are building a version of Libgcrypt with"
	echo " $gpl"
	echo "included. These parts are licensed under the GPL and thus the"
	echo "use of this library has to comply with the conditions of the GPL."
	fi

File Metadata

Mime Type: text/x-diff
Expires: Mon, Dec 23, 1:58 PM (1 d, 19 h)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 54/ee/a28531a46de05274525584889dd2

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions