libgcrypt: Add another file missing from tarballs

Quality release ...

2 files changed, 882 insertions, 1 deletions

diff --git a/recipes/libgcrypt/0002-add-other-missing-file.patch b/recipes/libgcrypt/0002-add-other-missing-file.patch
new file mode 100644
index 00000000..fd6fc6a8
--- /dev/null
+++ b/recipes/libgcrypt/0002-add-other-missing-file.patch
@@ -0,0 +1,881 @@
+From f9eed7fcec0b61f5ede54dec30235eb53a538217 Mon Sep 17 00:00:00 2001
+From: Edward Hervey <edward@collabora.com>
+Date:   Wed Jan 8 20:15:44 2014 +0100
+
+    Add other missing file
+
+diff --git a/cipher/serpent-armv7-neon.S b/cipher/serpent-armv7-neon.S
+new file mode 100644
+index 0000000..3559558
+--- /dev/null
++++ b/cipher/serpent-armv7-neon.S
+@@ -0,0 +1,869 @@
++/* serpent-armv7-neon.S  -  ARM/NEON assembly implementation of Serpent cipher
++ *
++ * Copyright (C) 2013 Jussi Kivilinna <jussi.kivilinna@iki.fi>
++ *
++ * 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/>.
++ */
++
++#include <config.h>
++
++#if defined(HAVE_ARM_ARCH_V6) && defined(__ARMEL__) && \
++    defined(HAVE_COMPATIBLE_GCC_ARM_PLATFORM_AS) && \
++    defined(HAVE_GCC_INLINE_ASM_NEON)
++
++.text
++
++.syntax unified
++.fpu neon
++.arm
++
++/* ARM registers */
++#define RROUND r0
++
++/* NEON vector registers */
++#define RA0 q0
++#define RA1 q1
++#define RA2 q2
++#define RA3 q3
++#define RA4 q4
++#define RB0 q5
++#define RB1 q6
++#define RB2 q7
++#define RB3 q8
++#define RB4 q9
++
++#define RT0 q10
++#define RT1 q11
++#define RT2 q12
++#define RT3 q13
++
++#define RA0d0 d0
++#define RA0d1 d1
++#define RA1d0 d2
++#define RA1d1 d3
++#define RA2d0 d4
++#define RA2d1 d5
++#define RA3d0 d6
++#define RA3d1 d7
++#define RA4d0 d8
++#define RA4d1 d9
++#define RB0d0 d10
++#define RB0d1 d11
++#define RB1d0 d12
++#define RB1d1 d13
++#define RB2d0 d14
++#define RB2d1 d15
++#define RB3d0 d16
++#define RB3d1 d17
++#define RB4d0 d18
++#define RB4d1 d19
++#define RT0d0 d20
++#define RT0d1 d21
++#define RT1d0 d22
++#define RT1d1 d23
++#define RT2d0 d24
++#define RT2d1 d25
++
++/**********************************************************************
++  helper macros
++ **********************************************************************/
++
++#define transpose_4x4(_q0, _q1, _q2, _q3) \
++	vtrn.32 _q0, _q1;	\
++	vtrn.32 _q2, _q3;	\
++	vswp _q0##d1, _q2##d0;	\
++	vswp _q1##d1, _q3##d0;
++
++/**********************************************************************
++  8-way serpent
++ **********************************************************************/
++
++/*
++ * These are the S-Boxes of Serpent from following research paper.
++ *
++ *  D. A. Osvik, “Speeding up Serpent,” in Third AES Candidate Conference,
++ *   (New York, New York, USA), p. 317–329, National Institute of Standards and
++ *   Technology, 2000.
++ *
++ * Paper is also available at: http://www.ii.uib.no/~osvik/pub/aes3.pdf
++ *
++ */
++#define SBOX0(a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	veor	a3, a3, a0;	veor	b3, b3, b0;	vmov	a4, a1;		vmov	b4, b1;		\
++	vand	a1, a1, a3;	vand	b1, b1, b3;	veor	a4, a4, a2;	veor	b4, b4, b2;	\
++	veor	a1, a1, a0;	veor	b1, b1, b0;	vorr	a0, a0, a3;	vorr	b0, b0, b3;	\
++	veor	a0, a0, a4;	veor	b0, b0, b4;	veor	a4, a4, a3;	veor	b4, b4, b3;	\
++	veor	a3, a3, a2;	veor	b3, b3, b2;	vorr	a2, a2, a1;	vorr	b2, b2, b1;	\
++	veor	a2, a2, a4;	veor	b2, b2, b4;	vmvn	a4, a4;		vmvn	b4, b4;		\
++	vorr	a4, a4, a1;	vorr	b4, b4, b1;	veor	a1, a1, a3;	veor	b1, b1, b3;	\
++	veor	a1, a1, a4;	veor	b1, b1, b4;	vorr	a3, a3, a0;	vorr	b3, b3, b0;	\
++	veor	a1, a1, a3;	veor	b1, b1, b3;	veor	a4, a3;		veor	b4, b3;
++
++#define SBOX0_INVERSE(a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	vmvn	a2, a2;		vmvn	b2, b2;		vmov	a4, a1;		vmov	b4, b1;		\
++	vorr	a1, a1, a0;	vorr	b1, b1, b0;	vmvn	a4, a4;		vmvn	b4, b4;		\
++	veor	a1, a1, a2;	veor	b1, b1, b2;	vorr	a2, a2, a4;	vorr	b2, b2, b4;	\
++	veor	a1, a1, a3;	veor	b1, b1, b3;	veor	a0, a0, a4;	veor	b0, b0, b4;	\
++	veor	a2, a2, a0;	veor	b2, b2, b0;	vand	a0, a0, a3;	vand	b0, b0, b3;	\
++	veor	a4, a4, a0;	veor	b4, b4, b0;	vorr	a0, a0, a1;	vorr	b0, b0, b1;	\
++	veor	a0, a0, a2;	veor	b0, b0, b2;	veor	a3, a3, a4;	veor	b3, b3, b4;	\
++	veor	a2, a2, a1;	veor	b2, b2, b1;	veor	a3, a3, a0;	veor	b3, b3, b0;	\
++	veor	a3, a3, a1;	veor	b3, b3, b1;\
++	vand	a2, a2, a3;	vand	b2, b2, b3;\
++	veor	a4, a2;	veor	b4, b2;
++
++#define SBOX1(a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	vmvn	a0, a0;		vmvn	b0, b0;		vmvn	a2, a2;		vmvn	b2, b2;		\
++	vmov	a4, a0;		vmov	b4, b0;		vand	a0, a0, a1;	vand	b0, b0, b1;	\
++	veor	a2, a2, a0;	veor	b2, b2, b0;	vorr	a0, a0, a3;	vorr	b0, b0, b3;	\
++	veor	a3, a3, a2;	veor	b3, b3, b2;	veor	a1, a1, a0;	veor	b1, b1, b0;	\
++	veor	a0, a0, a4;	veor	b0, b0, b4;	vorr	a4, a4, a1;	vorr	b4, b4, b1;	\
++	veor	a1, a1, a3;	veor	b1, b1, b3;	vorr	a2, a2, a0;	vorr	b2, b2, b0;	\
++	vand	a2, a2, a4;	vand	b2, b2, b4;	veor	a0, a0, a1;	veor	b0, b0, b1;	\
++	vand	a1, a1, a2;	vand	b1, b1, b2;\
++	veor	a1, a1, a0;	veor	b1, b1, b0;	vand	a0, a0, a2;	vand	b0, b0, b2;	\
++	veor	a0, a4;		veor	b0, b4;
++
++#define SBOX1_INVERSE(a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	vmov	a4, a1;		vmov	b4, b1;		veor	a1, a1, a3;	veor	b1, b1, b3;	\
++	vand	a3, a3, a1;	vand	b3, b3, b1;	veor	a4, a4, a2;	veor	b4, b4, b2;	\
++	veor	a3, a3, a0;	veor	b3, b3, b0;	vorr	a0, a0, a1;	vorr	b0, b0, b1;	\
++	veor	a2, a2, a3;	veor	b2, b2, b3;	veor	a0, a0, a4;	veor	b0, b0, b4;	\
++	vorr	a0, a0, a2;	vorr	b0, b0, b2;	veor	a1, a1, a3;	veor	b1, b1, b3;	\
++	veor	a0, a0, a1;	veor	b0, b0, b1;	vorr	a1, a1, a3;	vorr	b1, b1, b3;	\
++	veor	a1, a1, a0;	veor	b1, b1, b0;	vmvn	a4, a4;		vmvn	b4, b4;		\
++	veor	a4, a4, a1;	veor	b4, b4, b1;	vorr	a1, a1, a0;	vorr	b1, b1, b0;	\
++	veor	a1, a1, a0;	veor	b1, b1, b0;\
++	vorr	a1, a1, a4;	vorr	b1, b1, b4;\
++	veor	a3, a1;		veor	b3, b1;
++
++#define SBOX2(a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	vmov	a4, a0;		vmov	b4, b0;		vand	a0, a0, a2;	vand	b0, b0, b2;	\
++	veor	a0, a0, a3;	veor	b0, b0, b3;	veor	a2, a2, a1;	veor	b2, b2, b1;	\
++	veor	a2, a2, a0;	veor	b2, b2, b0;	vorr	a3, a3, a4;	vorr	b3, b3, b4;	\
++	veor	a3, a3, a1;	veor	b3, b3, b1;	veor	a4, a4, a2;	veor	b4, b4, b2;	\
++	vmov	a1, a3;		vmov	b1, b3;		vorr	a3, a3, a4;	vorr	b3, b3, b4;	\
++	veor	a3, a3, a0;	veor	b3, b3, b0;	vand	a0, a0, a1;	vand	b0, b0, b1;	\
++	veor	a4, a4, a0;	veor	b4, b4, b0;	veor	a1, a1, a3;	veor	b1, b1, b3;	\
++	veor	a1, a1, a4;	veor	b1, b1, b4;	vmvn	a4, a4;		vmvn	b4, b4;
++
++#define SBOX2_INVERSE(a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	veor	a2, a2, a3;	veor	b2, b2, b3;	veor	a3, a3, a0;	veor	b3, b3, b0;	\
++	vmov	a4, a3;		vmov	b4, b3;		vand	a3, a3, a2;	vand	b3, b3, b2;	\
++	veor	a3, a3, a1;	veor	b3, b3, b1;	vorr	a1, a1, a2;	vorr	b1, b1, b2;	\
++	veor	a1, a1, a4;	veor	b1, b1, b4;	vand	a4, a4, a3;	vand	b4, b4, b3;	\
++	veor	a2, a2, a3;	veor	b2, b2, b3;	vand	a4, a4, a0;	vand	b4, b4, b0;	\
++	veor	a4, a4, a2;	veor	b4, b4, b2;	vand	a2, a2, a1;	vand	b2, b2, b1;	\
++	vorr	a2, a2, a0;	vorr	b2, b2, b0;	vmvn	a3, a3;		vmvn	b3, b3;		\
++	veor	a2, a2, a3;	veor	b2, b2, b3;	veor	a0, a0, a3;	veor	b0, b0, b3;	\
++	vand	a0, a0, a1;	vand	b0, b0, b1;	veor	a3, a3, a4;	veor	b3, b3, b4;	\
++	veor	a3, a0;		veor	b3, b0;
++
++#define SBOX3(a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	vmov	a4, a0;		vmov	b4, b0;		vorr	a0, a0, a3;	vorr	b0, b0, b3;	\
++	veor	a3, a3, a1;	veor	b3, b3, b1;	vand	a1, a1, a4;	vand	b1, b1, b4;	\
++	veor	a4, a4, a2;	veor	b4, b4, b2;	veor	a2, a2, a3;	veor	b2, b2, b3;	\
++	vand	a3, a3, a0;	vand	b3, b3, b0;	vorr	a4, a4, a1;	vorr	b4, b4, b1;	\
++	veor	a3, a3, a4;	veor	b3, b3, b4;	veor	a0, a0, a1;	veor	b0, b0, b1;	\
++	vand	a4, a4, a0;	vand	b4, b4, b0;	veor	a1, a1, a3;	veor	b1, b1, b3;	\
++	veor	a4, a4, a2;	veor	b4, b4, b2;	vorr	a1, a1, a0;	vorr	b1, b1, b0;	\
++	veor	a1, a1, a2;	veor	b1, b1, b2;	veor	a0, a0, a3;	veor	b0, b0, b3;	\
++	vmov	a2, a1;		vmov	b2, b1;		vorr	a1, a1, a3;	vorr	b1, b1, b3;	\
++	veor	a1, a0;		veor	b1, b0;
++
++#define SBOX3_INVERSE(a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	vmov	a4, a2;		vmov	b4, b2;		veor	a2, a2, a1;	veor	b2, b2, b1;	\
++	veor	a0, a0, a2;	veor	b0, b0, b2;	vand	a4, a4, a2;	vand	b4, b4, b2;	\
++	veor	a4, a4, a0;	veor	b4, b4, b0;	vand	a0, a0, a1;	vand	b0, b0, b1;	\
++	veor	a1, a1, a3;	veor	b1, b1, b3;	vorr	a3, a3, a4;	vorr	b3, b3, b4;	\
++	veor	a2, a2, a3;	veor	b2, b2, b3;	veor	a0, a0, a3;	veor	b0, b0, b3;	\
++	veor	a1, a1, a4;	veor	b1, b1, b4;	vand	a3, a3, a2;	vand	b3, b3, b2;	\
++	veor	a3, a3, a1;	veor	b3, b3, b1;	veor	a1, a1, a0;	veor	b1, b1, b0;	\
++	vorr	a1, a1, a2;	vorr	b1, b1, b2;	veor	a0, a0, a3;	veor	b0, b0, b3;	\
++	veor	a1, a1, a4;	veor	b1, b1, b4;\
++	veor	a0, a1;		veor	b0, b1;
++
++#define SBOX4(a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	veor	a1, a1, a3;	veor	b1, b1, b3;	vmvn	a3, a3;		vmvn	b3, b3;		\
++	veor	a2, a2, a3;	veor	b2, b2, b3;	veor	a3, a3, a0;	veor	b3, b3, b0;	\
++	vmov	a4, a1;		vmov	b4, b1;		vand	a1, a1, a3;	vand	b1, b1, b3;	\
++	veor	a1, a1, a2;	veor	b1, b1, b2;	veor	a4, a4, a3;	veor	b4, b4, b3;	\
++	veor	a0, a0, a4;	veor	b0, b0, b4;	vand	a2, a2, a4;	vand	b2, b2, b4;	\
++	veor	a2, a2, a0;	veor	b2, b2, b0;	vand	a0, a0, a1;	vand	b0, b0, b1;	\
++	veor	a3, a3, a0;	veor	b3, b3, b0;	vorr	a4, a4, a1;	vorr	b4, b4, b1;	\
++	veor	a4, a4, a0;	veor	b4, b4, b0;	vorr	a0, a0, a3;	vorr	b0, b0, b3;	\
++	veor	a0, a0, a2;	veor	b0, b0, b2;	vand	a2, a2, a3;	vand	b2, b2, b3;	\
++	vmvn	a0, a0;		vmvn	b0, b0;		veor	a4, a2;		veor	b4, b2;
++
++#define SBOX4_INVERSE(a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	vmov	a4, a2;		vmov	b4, b2;		vand	a2, a2, a3;	vand	b2, b2, b3;	\
++	veor	a2, a2, a1;	veor	b2, b2, b1;	vorr	a1, a1, a3;	vorr	b1, b1, b3;	\
++	vand	a1, a1, a0;	vand	b1, b1, b0;	veor	a4, a4, a2;	veor	b4, b4, b2;	\
++	veor	a4, a4, a1;	veor	b4, b4, b1;	vand	a1, a1, a2;	vand	b1, b1, b2;	\
++	vmvn	a0, a0;		vmvn	b0, b0;		veor	a3, a3, a4;	veor	b3, b3, b4;	\
++	veor	a1, a1, a3;	veor	b1, b1, b3;	vand	a3, a3, a0;	vand	b3, b3, b0;	\
++	veor	a3, a3, a2;	veor	b3, b3, b2;	veor	a0, a0, a1;	veor	b0, b0, b1;	\
++	vand	a2, a2, a0;	vand	b2, b2, b0;	veor	a3, a3, a0;	veor	b3, b3, b0;	\
++	veor	a2, a2, a4;	veor	b2, b2, b4;\
++	vorr	a2, a2, a3;	vorr	b2, b2, b3;	veor	a3, a3, a0;	veor	b3, b3, b0;	\
++	veor	a2, a1;		veor	b2, b1;
++
++#define SBOX5(a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	veor	a0, a0, a1;	veor	b0, b0, b1;	veor	a1, a1, a3;	veor	b1, b1, b3;	\
++	vmvn	a3, a3;		vmvn	b3, b3;		vmov	a4, a1;		vmov	b4, b1;		\
++	vand	a1, a1, a0;	vand	b1, b1, b0;	veor	a2, a2, a3;	veor	b2, b2, b3;	\
++	veor	a1, a1, a2;	veor	b1, b1, b2;	vorr	a2, a2, a4;	vorr	b2, b2, b4;	\
++	veor	a4, a4, a3;	veor	b4, b4, b3;	vand	a3, a3, a1;	vand	b3, b3, b1;	\
++	veor	a3, a3, a0;	veor	b3, b3, b0;	veor	a4, a4, a1;	veor	b4, b4, b1;	\
++	veor	a4, a4, a2;	veor	b4, b4, b2;	veor	a2, a2, a0;	veor	b2, b2, b0;	\
++	vand	a0, a0, a3;	vand	b0, b0, b3;	vmvn	a2, a2;		vmvn	b2, b2;		\
++	veor	a0, a0, a4;	veor	b0, b0, b4;	vorr	a4, a4, a3;	vorr	b4, b4, b3;	\
++	veor	a2, a4;		veor	b2, b4;
++
++#define SBOX5_INVERSE(a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	vmvn	a1, a1;		vmvn	b1, b1;		vmov	a4, a3;		vmov	b4, b3;		\
++	veor	a2, a2, a1;	veor	b2, b2, b1;	vorr	a3, a3, a0;	vorr	b3, b3, b0;	\
++	veor	a3, a3, a2;	veor	b3, b3, b2;	vorr	a2, a2, a1;	vorr	b2, b2, b1;	\
++	vand	a2, a2, a0;	vand	b2, b2, b0;	veor	a4, a4, a3;	veor	b4, b4, b3;	\
++	veor	a2, a2, a4;	veor	b2, b2, b4;	vorr	a4, a4, a0;	vorr	b4, b4, b0;	\
++	veor	a4, a4, a1;	veor	b4, b4, b1;	vand	a1, a1, a2;	vand	b1, b1, b2;	\
++	veor	a1, a1, a3;	veor	b1, b1, b3;	veor	a4, a4, a2;	veor	b4, b4, b2;	\
++	vand	a3, a3, a4;	vand	b3, b3, b4;	veor	a4, a4, a1;	veor	b4, b4, b1;	\
++	veor	a3, a3, a4;	veor	b3, b3, b4;	vmvn	a4, a4;		vmvn	b4, b4;		\
++	veor	a3, a0;		veor	b3, b0;
++
++#define SBOX6(a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	vmvn	a2, a2;		vmvn	b2, b2;		vmov	a4, a3;		vmov	b4, b3;		\
++	vand	a3, a3, a0;	vand	b3, b3, b0;	veor	a0, a0, a4;	veor	b0, b0, b4;	\
++	veor	a3, a3, a2;	veor	b3, b3, b2;	vorr	a2, a2, a4;	vorr	b2, b2, b4;	\
++	veor	a1, a1, a3;	veor	b1, b1, b3;	veor	a2, a2, a0;	veor	b2, b2, b0;	\
++	vorr	a0, a0, a1;	vorr	b0, b0, b1;	veor	a2, a2, a1;	veor	b2, b2, b1;	\
++	veor	a4, a4, a0;	veor	b4, b4, b0;	vorr	a0, a0, a3;	vorr	b0, b0, b3;	\
++	veor	a0, a0, a2;	veor	b0, b0, b2;	veor	a4, a4, a3;	veor	b4, b4, b3;	\
++	veor	a4, a4, a0;	veor	b4, b4, b0;	vmvn	a3, a3;		vmvn	b3, b3;		\
++	vand	a2, a2, a4;	vand	b2, b2, b4;\
++	veor	a2, a3;		veor	b2, b3;
++
++#define SBOX6_INVERSE(a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	veor	a0, a0, a2;	veor	b0, b0, b2;	vmov	a4, a2;		vmov	b4, b2;		\
++	vand	a2, a2, a0;	vand	b2, b2, b0;	veor	a4, a4, a3;	veor	b4, b4, b3;	\
++	vmvn	a2, a2;		vmvn	b2, b2;		veor	a3, a3, a1;	veor	b3, b3, b1;	\
++	veor	a2, a2, a3;	veor	b2, b2, b3;	vorr	a4, a4, a0;	vorr	b4, b4, b0;	\
++	veor	a0, a0, a2;	veor	b0, b0, b2;	veor	a3, a3, a4;	veor	b3, b3, b4;	\
++	veor	a4, a4, a1;	veor	b4, b4, b1;	vand	a1, a1, a3;	vand	b1, b1, b3;	\
++	veor	a1, a1, a0;	veor	b1, b1, b0;	veor	a0, a0, a3;	veor	b0, b0, b3;	\
++	vorr	a0, a0, a2;	vorr	b0, b0, b2;	veor	a3, a3, a1;	veor	b3, b3, b1;	\
++	veor	a4, a0;		veor	b4, b0;
++
++#define SBOX7(a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	vmov	a4, a1;		vmov	b4, b1;		vorr	a1, a1, a2;	vorr	b1, b1, b2;	\
++	veor	a1, a1, a3;	veor	b1, b1, b3;	veor	a4, a4, a2;	veor	b4, b4, b2;	\
++	veor	a2, a2, a1;	veor	b2, b2, b1;	vorr	a3, a3, a4;	vorr	b3, b3, b4;	\
++	vand	a3, a3, a0;	vand	b3, b3, b0;	veor	a4, a4, a2;	veor	b4, b4, b2;	\
++	veor	a3, a3, a1;	veor	b3, b3, b1;	vorr	a1, a1, a4;	vorr	b1, b1, b4;	\
++	veor	a1, a1, a0;	veor	b1, b1, b0;	vorr	a0, a0, a4;	vorr	b0, b0, b4;	\
++	veor	a0, a0, a2;	veor	b0, b0, b2;	veor	a1, a1, a4;	veor	b1, b1, b4;	\
++	veor	a2, a2, a1;	veor	b2, b2, b1;	vand	a1, a1, a0;	vand	b1, b1, b0;	\
++	veor	a1, a1, a4;	veor	b1, b1, b4;	vmvn	a2, a2;		vmvn	b2, b2;		\
++	vorr	a2, a2, a0;	vorr	b2, b2, b0;\
++	veor	a4, a2;		veor	b4, b2;
++
++#define SBOX7_INVERSE(a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	vmov	a4, a2;		vmov	b4, b2;		veor	a2, a2, a0;	veor	b2, b2, b0;	\
++	vand	a0, a0, a3;	vand	b0, b0, b3;	vorr	a4, a4, a3;	vorr	b4, b4, b3;	\
++	vmvn	a2, a2;		vmvn	b2, b2;		veor	a3, a3, a1;	veor	b3, b3, b1;	\
++	vorr	a1, a1, a0;	vorr	b1, b1, b0;	veor	a0, a0, a2;	veor	b0, b0, b2;	\
++	vand	a2, a2, a4;	vand	b2, b2, b4;	vand	a3, a3, a4;	vand	b3, b3, b4;	\
++	veor	a1, a1, a2;	veor	b1, b1, b2;	veor	a2, a2, a0;	veor	b2, b2, b0;	\
++	vorr	a0, a0, a2;	vorr	b0, b0, b2;	veor	a4, a4, a1;	veor	b4, b4, b1;	\
++	veor	a0, a0, a3;	veor	b0, b0, b3;	veor	a3, a3, a4;	veor	b3, b3, b4;	\
++	vorr	a4, a4, a0;	vorr	b4, b4, b0;	veor	a3, a3, a2;	veor	b3, b3, b2;	\
++	veor	a4, a2;		veor	b4, b2;
++
++/* Apply SBOX number WHICH to to the block.  */
++#define SBOX(which, a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	SBOX##which (a0, a1, a2, a3, a4, b0, b1, b2, b3, b4)
++
++/* Apply inverse SBOX number WHICH to to the block.  */
++#define SBOX_INVERSE(which, a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	SBOX##which##_INVERSE (a0, a1, a2, a3, a4, b0, b1, b2, b3, b4)
++
++/* XOR round key into block state in a0,a1,a2,a3. a4 used as temporary.  */
++#define BLOCK_XOR_KEY(a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	vdup.32 RT3, RT0d0[0]; \
++	vdup.32 RT1, RT0d0[1]; \
++	vdup.32 RT2, RT0d1[0]; \
++	vdup.32 RT0, RT0d1[1]; \
++	veor a0, a0, RT3;	veor b0, b0, RT3; \
++	veor a1, a1, RT1;	veor b1, b1, RT1; \
++	veor a2, a2, RT2;	veor b2, b2, RT2; \
++	veor a3, a3, RT0;	veor b3, b3, RT0;
++
++#define BLOCK_LOAD_KEY_ENC() \
++	vld1.8 {RT0d0, RT0d1}, [RROUND]!;
++
++#define BLOCK_LOAD_KEY_DEC() \
++	vld1.8 {RT0d0, RT0d1}, [RROUND]; \
++	sub RROUND, RROUND, #16
++
++/* Apply the linear transformation to BLOCK.  */
++#define LINEAR_TRANSFORMATION(a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	vshl.u32	a4, a0, #13;		vshl.u32	b4, b0, #13;		\
++	vshr.u32	a0, a0, #(32-13);	vshr.u32	b0, b0, #(32-13);	\
++	veor		a0, a0, a4;		veor		b0, b0, b4;		\
++	vshl.u32	a4, a2, #3;		vshl.u32	b4, b2, #3;		\
++	vshr.u32	a2, a2, #(32-3);	vshr.u32	b2, b2, #(32-3);	\
++	veor		a2, a2, a4;		veor		b2, b2, b4;		\
++	veor		a1, a0, a1;		veor		b1, b0, b1;		\
++	veor		a1, a2, a1;		veor		b1, b2, b1;		\
++	vshl.u32	a4, a0, #3;		vshl.u32	b4, b0, #3;		\
++	veor		a3, a2, a3;		veor		b3, b2, b3;		\
++	veor		a3, a4, a3;		veor		b3, b4, b3;		\
++	vshl.u32	a4, a1, #1;		vshl.u32	b4, b1, #1;		\
++	vshr.u32	a1, a1, #(32-1);	vshr.u32	b1, b1, #(32-1);	\
++	veor		a1, a1, a4;		veor		b1, b1, b4;		\
++	vshl.u32	a4, a3, #7;		vshl.u32	b4, b3, #7;		\
++	vshr.u32	a3, a3, #(32-7);	vshr.u32	b3, b3, #(32-7);	\
++	veor		a3, a3, a4;		veor		b3, b3, b4;		\
++	veor		a0, a1, a0;		veor		b0, b1, b0;		\
++	veor		a0, a3, a0;		veor		b0, b3, b0;		\
++	vshl.u32	a4, a1, #7;		vshl.u32	b4, b1, #7;		\
++	veor		a2, a3, a2;		veor		b2, b3, b2;		\
++	veor		a2, a4, a2;		veor		b2, b4, b2;		\
++	vshl.u32	a4, a0, #5;		vshl.u32	b4, b0, #5;		\
++	vshr.u32	a0, a0, #(32-5);	vshr.u32	b0, b0, #(32-5);	\
++	veor		a0, a0, a4;		veor		b0, b0, b4;		\
++	vshl.u32	a4, a2, #22;		vshl.u32	b4, b2, #22;		\
++	vshr.u32	a2, a2, #(32-22);	vshr.u32	b2, b2, #(32-22);	\
++	veor		a2, a2, a4;		veor		b2, b2, b4;
++
++/* Apply the inverse linear transformation to BLOCK.  */
++#define LINEAR_TRANSFORMATION_INVERSE(a0, a1, a2, a3, a4, b0, b1, b2, b3, b4) \
++	vshr.u32	a4, a2, #22;		vshr.u32	b4, b2, #22;		\
++	vshl.u32	a2, a2, #(32-22);	vshl.u32	b2, b2, #(32-22);	\
++	veor		a2, a2, a4;		veor		b2, b2, b4;		\
++	vshr.u32	a4, a0, #5;		vshr.u32	b4, b0, #5;		\
++	vshl.u32	a0, a0, #(32-5);	vshl.u32	b0, b0, #(32-5);	\
++	veor		a0, a0, a4;		veor		b0, b0, b4;		\
++	vshl.u32	a4, a1, #7;		vshl.u32	b4, b1, #7;		\
++	veor		a2, a3, a2;		veor		b2, b3, b2;		\
++	veor		a2, a4, a2;		veor		b2, b4, b2;		\
++	veor		a0, a1, a0;		veor		b0, b1, b0;		\
++	veor		a0, a3, a0;		veor		b0, b3, b0;		\
++	vshr.u32	a4, a3, #7;		vshr.u32	b4, b3, #7;		\
++	vshl.u32	a3, a3, #(32-7);	vshl.u32	b3, b3, #(32-7);	\
++	veor		a3, a3, a4;		veor		b3, b3, b4;		\
++	vshr.u32	a4, a1, #1;		vshr.u32	b4, b1, #1;		\
++	vshl.u32	a1, a1, #(32-1);	vshl.u32	b1, b1, #(32-1);	\
++	veor		a1, a1, a4;		veor		b1, b1, b4;		\
++	vshl.u32	a4, a0, #3;		vshl.u32	b4, b0, #3;		\
++	veor		a3, a2, a3;		veor		b3, b2, b3;		\
++	veor		a3, a4, a3;		veor		b3, b4, b3;		\
++	veor		a1, a0, a1;		veor		b1, b0, b1;		\
++	veor		a1, a2, a1;		veor		b1, b2, b1;		\
++	vshr.u32	a4, a2, #3;		vshr.u32	b4, b2, #3;		\
++	vshl.u32	a2, a2, #(32-3);	vshl.u32	b2, b2, #(32-3);	\
++	veor		a2, a2, a4;		veor		b2, b2, b4;		\
++	vshr.u32	a4, a0, #13;		vshr.u32	b4, b0, #13;		\
++	vshl.u32	a0, a0, #(32-13);	vshl.u32	b0, b0, #(32-13);	\
++	veor		a0, a0, a4;		veor		b0, b0, b4;
++
++/* Apply a Serpent round to eight parallel blocks.  This macro increments
++   `round'.  */
++#define ROUND(round, which, a0, a1, a2, a3, a4, na0, na1, na2, na3, na4, \
++			    b0, b1, b2, b3, b4, nb0, nb1, nb2, nb3, nb4) \
++	BLOCK_XOR_KEY (a0, a1, a2, a3, a4, b0, b1, b2, b3, b4);		\
++	BLOCK_LOAD_KEY_ENC ();						\
++	SBOX (which, a0, a1, a2, a3, a4, b0, b1, b2, b3, b4);		\
++	LINEAR_TRANSFORMATION (na0, na1, na2, na3, na4, nb0, nb1, nb2, nb3, nb4);
++
++/* Apply the last Serpent round to eight parallel blocks.  This macro increments
++   `round'.  */
++#define ROUND_LAST(round, which, a0, a1, a2, a3, a4, na0, na1, na2, na3, na4, \
++				 b0, b1, b2, b3, b4, nb0, nb1, nb2, nb3, nb4) \
++	BLOCK_XOR_KEY (a0, a1, a2, a3, a4, b0, b1, b2, b3, b4);		\
++	BLOCK_LOAD_KEY_ENC ();						\
++	SBOX (which, a0, a1, a2, a3, a4, b0, b1, b2, b3, b4);		\
++	BLOCK_XOR_KEY (na0, na1, na2, na3, na4, nb0, nb1, nb2, nb3, nb4);
++
++/* Apply an inverse Serpent round to eight parallel blocks.  This macro
++   increments `round'.  */
++#define ROUND_INVERSE(round, which, a0, a1, a2, a3, a4, \
++				    na0, na1, na2, na3, na4, \
++				    b0, b1, b2, b3, b4, \
++				    nb0, nb1, nb2, nb3, nb4) \
++	LINEAR_TRANSFORMATION_INVERSE (a0, a1, a2, a3, a4, b0, b1, b2, b3, b4);	\
++	SBOX_INVERSE (which, a0, a1, a2, a3, a4, b0, b1, b2, b3, b4);		\
++	BLOCK_XOR_KEY (na0, na1, na2, na3, na4, nb0, nb1, nb2, nb3, nb4);	\
++	BLOCK_LOAD_KEY_DEC ();
++
++/* Apply the first inverse Serpent round to eight parallel blocks.  This macro
++   increments `round'.  */
++#define ROUND_FIRST_INVERSE(round, which, a0, a1, a2, a3, a4, \
++					  na0, na1, na2, na3, na4, \
++					  b0, b1, b2, b3, b4, \
++					  nb0, nb1, nb2, nb3, nb4) \
++	BLOCK_XOR_KEY (a0, a1, a2, a3, a4, b0, b1, b2, b3, b4);			\
++	BLOCK_LOAD_KEY_DEC ();							\
++	SBOX_INVERSE (which, a0, a1, a2, a3, a4, b0, b1, b2, b3, b4); 		\
++	BLOCK_XOR_KEY (na0, na1, na2, na3, na4, nb0, nb1, nb2, nb3, nb4);	\
++	BLOCK_LOAD_KEY_DEC ();
++
++.align 3
++.type __serpent_enc_blk8,%function;
++__serpent_enc_blk8:
++	/* input:
++	 *	r0: round key pointer
++	 *	RA0, RA1, RA2, RA3, RB0, RB1, RB2, RB3: eight parallel plaintext
++	 *						blocks
++	 * output:
++	 *	RA4, RA1, RA2, RA0, RB4, RB1, RB2, RB0: eight parallel
++	 * 						ciphertext blocks
++	 */
++
++	transpose_4x4(RA0, RA1, RA2, RA3);
++	BLOCK_LOAD_KEY_ENC ();
++	transpose_4x4(RB0, RB1, RB2, RB3);
++
++	ROUND (0, 0, RA0, RA1, RA2, RA3, RA4, RA1, RA4, RA2, RA0, RA3,
++		     RB0, RB1, RB2, RB3, RB4, RB1, RB4, RB2, RB0, RB3);
++	ROUND (1, 1, RA1, RA4, RA2, RA0, RA3, RA2, RA1, RA0, RA4, RA3,
++		     RB1, RB4, RB2, RB0, RB3, RB2, RB1, RB0, RB4, RB3);
++	ROUND (2, 2, RA2, RA1, RA0, RA4, RA3, RA0, RA4, RA1, RA3, RA2,
++		     RB2, RB1, RB0, RB4, RB3, RB0, RB4, RB1, RB3, RB2);
++	ROUND (3, 3, RA0, RA4, RA1, RA3, RA2, RA4, RA1, RA3, RA2, RA0,
++		     RB0, RB4, RB1, RB3, RB2, RB4, RB1, RB3, RB2, RB0);
++	ROUND (4, 4, RA4, RA1, RA3, RA2, RA0, RA1, RA0, RA4, RA2, RA3,
++		     RB4, RB1, RB3, RB2, RB0, RB1, RB0, RB4, RB2, RB3);
++	ROUND (5, 5, RA1, RA0, RA4, RA2, RA3, RA0, RA2, RA1, RA4, RA3,
++		     RB1, RB0, RB4, RB2, RB3, RB0, RB2, RB1, RB4, RB3);
++	ROUND (6, 6, RA0, RA2, RA1, RA4, RA3, RA0, RA2, RA3, RA1, RA4,
++		     RB0, RB2, RB1, RB4, RB3, RB0, RB2, RB3, RB1, RB4);
++	ROUND (7, 7, RA0, RA2, RA3, RA1, RA4, RA4, RA1, RA2, RA0, RA3,
++		     RB0, RB2, RB3, RB1, RB4, RB4, RB1, RB2, RB0, RB3);
++	ROUND (8, 0, RA4, RA1, RA2, RA0, RA3, RA1, RA3, RA2, RA4, RA0,
++		     RB4, RB1, RB2, RB0, RB3, RB1, RB3, RB2, RB4, RB0);
++	ROUND (9, 1, RA1, RA3, RA2, RA4, RA0, RA2, RA1, RA4, RA3, RA0,
++		     RB1, RB3, RB2, RB4, RB0, RB2, RB1, RB4, RB3, RB0);
++	ROUND (10, 2, RA2, RA1, RA4, RA3, RA0, RA4, RA3, RA1, RA0, RA2,
++		      RB2, RB1, RB4, RB3, RB0, RB4, RB3, RB1, RB0, RB2);
++	ROUND (11, 3, RA4, RA3, RA1, RA0, RA2, RA3, RA1, RA0, RA2, RA4,
++		      RB4, RB3, RB1, RB0, RB2, RB3, RB1, RB0, RB2, RB4);
++	ROUND (12, 4, RA3, RA1, RA0, RA2, RA4, RA1, RA4, RA3, RA2, RA0,
++		      RB3, RB1, RB0, RB2, RB4, RB1, RB4, RB3, RB2, RB0);
++	ROUND (13, 5, RA1, RA4, RA3, RA2, RA0, RA4, RA2, RA1, RA3, RA0,
++		      RB1, RB4, RB3, RB2, RB0, RB4, RB2, RB1, RB3, RB0);
++	ROUND (14, 6, RA4, RA2, RA1, RA3, RA0, RA4, RA2, RA0, RA1, RA3,
++		      RB4, RB2, RB1, RB3, RB0, RB4, RB2, RB0, RB1, RB3);
++	ROUND (15, 7, RA4, RA2, RA0, RA1, RA3, RA3, RA1, RA2, RA4, RA0,
++		      RB4, RB2, RB0, RB1, RB3, RB3, RB1, RB2, RB4, RB0);
++	ROUND (16, 0, RA3, RA1, RA2, RA4, RA0, RA1, RA0, RA2, RA3, RA4,
++		      RB3, RB1, RB2, RB4, RB0, RB1, RB0, RB2, RB3, RB4);
++	ROUND (17, 1, RA1, RA0, RA2, RA3, RA4, RA2, RA1, RA3, RA0, RA4,
++		      RB1, RB0, RB2, RB3, RB4, RB2, RB1, RB3, RB0, RB4);
++	ROUND (18, 2, RA2, RA1, RA3, RA0, RA4, RA3, RA0, RA1, RA4, RA2,
++		      RB2, RB1, RB3, RB0, RB4, RB3, RB0, RB1, RB4, RB2);
++	ROUND (19, 3, RA3, RA0, RA1, RA4, RA2, RA0, RA1, RA4, RA2, RA3,
++		      RB3, RB0, RB1, RB4, RB2, RB0, RB1, RB4, RB2, RB3);
++	ROUND (20, 4, RA0, RA1, RA4, RA2, RA3, RA1, RA3, RA0, RA2, RA4,
++		      RB0, RB1, RB4, RB2, RB3, RB1, RB3, RB0, RB2, RB4);
++	ROUND (21, 5, RA1, RA3, RA0, RA2, RA4, RA3, RA2, RA1, RA0, RA4,
++		      RB1, RB3, RB0, RB2, RB4, RB3, RB2, RB1, RB0, RB4);
++	ROUND (22, 6, RA3, RA2, RA1, RA0, RA4, RA3, RA2, RA4, RA1, RA0,
++		      RB3, RB2, RB1, RB0, RB4, RB3, RB2, RB4, RB1, RB0);
++	ROUND (23, 7, RA3, RA2, RA4, RA1, RA0, RA0, RA1, RA2, RA3, RA4,
++		      RB3, RB2, RB4, RB1, RB0, RB0, RB1, RB2, RB3, RB4);
++	ROUND (24, 0, RA0, RA1, RA2, RA3, RA4, RA1, RA4, RA2, RA0, RA3,
++		      RB0, RB1, RB2, RB3, RB4, RB1, RB4, RB2, RB0, RB3);
++	ROUND (25, 1, RA1, RA4, RA2, RA0, RA3, RA2, RA1, RA0, RA4, RA3,
++		      RB1, RB4, RB2, RB0, RB3, RB2, RB1, RB0, RB4, RB3);
++	ROUND (26, 2, RA2, RA1, RA0, RA4, RA3, RA0, RA4, RA1, RA3, RA2,
++		      RB2, RB1, RB0, RB4, RB3, RB0, RB4, RB1, RB3, RB2);
++	ROUND (27, 3, RA0, RA4, RA1, RA3, RA2, RA4, RA1, RA3, RA2, RA0,
++		      RB0, RB4, RB1, RB3, RB2, RB4, RB1, RB3, RB2, RB0);
++	ROUND (28, 4, RA4, RA1, RA3, RA2, RA0, RA1, RA0, RA4, RA2, RA3,
++		      RB4, RB1, RB3, RB2, RB0, RB1, RB0, RB4, RB2, RB3);
++	ROUND (29, 5, RA1, RA0, RA4, RA2, RA3, RA0, RA2, RA1, RA4, RA3,
++		      RB1, RB0, RB4, RB2, RB3, RB0, RB2, RB1, RB4, RB3);
++	ROUND (30, 6, RA0, RA2, RA1, RA4, RA3, RA0, RA2, RA3, RA1, RA4,
++		      RB0, RB2, RB1, RB4, RB3, RB0, RB2, RB3, RB1, RB4);
++	ROUND_LAST (31, 7, RA0, RA2, RA3, RA1, RA4, RA4, RA1, RA2, RA0, RA3,
++		           RB0, RB2, RB3, RB1, RB4, RB4, RB1, RB2, RB0, RB3);
++
++	transpose_4x4(RA4, RA1, RA2, RA0);
++	transpose_4x4(RB4, RB1, RB2, RB0);
++
++	bx lr;
++.size __serpent_enc_blk8,.-__serpent_enc_blk8;
++
++.align 3
++.type   __serpent_dec_blk8,%function;
++__serpent_dec_blk8:
++	/* input:
++	 *	r0: round key pointer
++	 *	RA0, RA1, RA2, RA3, RB0, RB1, RB2, RB3: eight parallel
++	 * 						ciphertext blocks
++	 * output:
++	 *	RA0, RA1, RA2, RA3, RB0, RB1, RB2, RB3: eight parallel plaintext
++	 *						blocks
++	 */
++
++	add RROUND, RROUND, #(32*16);
++
++	transpose_4x4(RA0, RA1, RA2, RA3);
++	BLOCK_LOAD_KEY_DEC ();
++	transpose_4x4(RB0, RB1, RB2, RB3);
++
++	ROUND_FIRST_INVERSE (31, 7, RA0, RA1, RA2, RA3, RA4,
++				    RA3, RA0, RA1, RA4, RA2,
++				    RB0, RB1, RB2, RB3, RB4,
++				    RB3, RB0, RB1, RB4, RB2);
++	ROUND_INVERSE (30, 6, RA3, RA0, RA1, RA4, RA2, RA0, RA1, RA2, RA4, RA3,
++		              RB3, RB0, RB1, RB4, RB2, RB0, RB1, RB2, RB4, RB3);
++	ROUND_INVERSE (29, 5, RA0, RA1, RA2, RA4, RA3, RA1, RA3, RA4, RA2, RA0,
++		              RB0, RB1, RB2, RB4, RB3, RB1, RB3, RB4, RB2, RB0);
++	ROUND_INVERSE (28, 4, RA1, RA3, RA4, RA2, RA0, RA1, RA2, RA4, RA0, RA3,
++		              RB1, RB3, RB4, RB2, RB0, RB1, RB2, RB4, RB0, RB3);
++	ROUND_INVERSE (27, 3, RA1, RA2, RA4, RA0, RA3, RA4, RA2, RA0, RA1, RA3,
++		              RB1, RB2, RB4, RB0, RB3, RB4, RB2, RB0, RB1, RB3);
++	ROUND_INVERSE (26, 2, RA4, RA2, RA0, RA1, RA3, RA2, RA3, RA0, RA1, RA4,
++		              RB4, RB2, RB0, RB1, RB3, RB2, RB3, RB0, RB1, RB4);
++	ROUND_INVERSE (25, 1, RA2, RA3, RA0, RA1, RA4, RA4, RA2, RA1, RA0, RA3,
++		              RB2, RB3, RB0, RB1, RB4, RB4, RB2, RB1, RB0, RB3);
++	ROUND_INVERSE (24, 0, RA4, RA2, RA1, RA0, RA3, RA4, RA3, RA2, RA0, RA1,
++		              RB4, RB2, RB1, RB0, RB3, RB4, RB3, RB2, RB0, RB1);
++	ROUND_INVERSE (23, 7, RA4, RA3, RA2, RA0, RA1, RA0, RA4, RA3, RA1, RA2,
++		              RB4, RB3, RB2, RB0, RB1, RB0, RB4, RB3, RB1, RB2);
++	ROUND_INVERSE (22, 6, RA0, RA4, RA3, RA1, RA2, RA4, RA3, RA2, RA1, RA0,
++		              RB0, RB4, RB3, RB1, RB2, RB4, RB3, RB2, RB1, RB0);
++	ROUND_INVERSE (21, 5, RA4, RA3, RA2, RA1, RA0, RA3, RA0, RA1, RA2, RA4,
++		              RB4, RB3, RB2, RB1, RB0, RB3, RB0, RB1, RB2, RB4);
++	ROUND_INVERSE (20, 4, RA3, RA0, RA1, RA2, RA4, RA3, RA2, RA1, RA4, RA0,
++		              RB3, RB0, RB1, RB2, RB4, RB3, RB2, RB1, RB4, RB0);
++	ROUND_INVERSE (19, 3, RA3, RA2, RA1, RA4, RA0, RA1, RA2, RA4, RA3, RA0,
++		              RB3, RB2, RB1, RB4, RB0, RB1, RB2, RB4, RB3, RB0);
++	ROUND_INVERSE (18, 2, RA1, RA2, RA4, RA3, RA0, RA2, RA0, RA4, RA3, RA1,
++		              RB1, RB2, RB4, RB3, RB0, RB2, RB0, RB4, RB3, RB1);
++	ROUND_INVERSE (17, 1, RA2, RA0, RA4, RA3, RA1, RA1, RA2, RA3, RA4, RA0,
++		              RB2, RB0, RB4, RB3, RB1, RB1, RB2, RB3, RB4, RB0);
++	ROUND_INVERSE (16, 0, RA1, RA2, RA3, RA4, RA0, RA1, RA0, RA2, RA4, RA3,
++		              RB1, RB2, RB3, RB4, RB0, RB1, RB0, RB2, RB4, RB3);
++	ROUND_INVERSE (15, 7, RA1, RA0, RA2, RA4, RA3, RA4, RA1, RA0, RA3, RA2,
++		              RB1, RB0, RB2, RB4, RB3, RB4, RB1, RB0, RB3, RB2);
++	ROUND_INVERSE (14, 6, RA4, RA1, RA0, RA3, RA2, RA1, RA0, RA2, RA3, RA4,
++		              RB4, RB1, RB0, RB3, RB2, RB1, RB0, RB2, RB3, RB4);
++	ROUND_INVERSE (13, 5, RA1, RA0, RA2, RA3, RA4, RA0, RA4, RA3, RA2, RA1,
++		              RB1, RB0, RB2, RB3, RB4, RB0, RB4, RB3, RB2, RB1);
++	ROUND_INVERSE (12, 4, RA0, RA4, RA3, RA2, RA1, RA0, RA2, RA3, RA1, RA4,
++		              RB0, RB4, RB3, RB2, RB1, RB0, RB2, RB3, RB1, RB4);
++	ROUND_INVERSE (11, 3, RA0, RA2, RA3, RA1, RA4, RA3, RA2, RA1, RA0, RA4,
++		              RB0, RB2, RB3, RB1, RB4, RB3, RB2, RB1, RB0, RB4);
++	ROUND_INVERSE (10, 2, RA3, RA2, RA1, RA0, RA4, RA2, RA4, RA1, RA0, RA3,
++		              RB3, RB2, RB1, RB0, RB4, RB2, RB4, RB1, RB0, RB3);
++	ROUND_INVERSE (9, 1, RA2, RA4, RA1, RA0, RA3, RA3, RA2, RA0, RA1, RA4,
++		             RB2, RB4, RB1, RB0, RB3, RB3, RB2, RB0, RB1, RB4);
++	ROUND_INVERSE (8, 0, RA3, RA2, RA0, RA1, RA4, RA3, RA4, RA2, RA1, RA0,
++		             RB3, RB2, RB0, RB1, RB4, RB3, RB4, RB2, RB1, RB0);
++	ROUND_INVERSE (7, 7, RA3, RA4, RA2, RA1, RA0, RA1, RA3, RA4, RA0, RA2,
++		             RB3, RB4, RB2, RB1, RB0, RB1, RB3, RB4, RB0, RB2);
++	ROUND_INVERSE (6, 6, RA1, RA3, RA4, RA0, RA2, RA3, RA4, RA2, RA0, RA1,
++		             RB1, RB3, RB4, RB0, RB2, RB3, RB4, RB2, RB0, RB1);
++	ROUND_INVERSE (5, 5, RA3, RA4, RA2, RA0, RA1, RA4, RA1, RA0, RA2, RA3,
++		             RB3, RB4, RB2, RB0, RB1, RB4, RB1, RB0, RB2, RB3);
++	ROUND_INVERSE (4, 4, RA4, RA1, RA0, RA2, RA3, RA4, RA2, RA0, RA3, RA1,
++		             RB4, RB1, RB0, RB2, RB3, RB4, RB2, RB0, RB3, RB1);
++	ROUND_INVERSE (3, 3, RA4, RA2, RA0, RA3, RA1, RA0, RA2, RA3, RA4, RA1,
++		             RB4, RB2, RB0, RB3, RB1, RB0, RB2, RB3, RB4, RB1);
++	ROUND_INVERSE (2, 2, RA0, RA2, RA3, RA4, RA1, RA2, RA1, RA3, RA4, RA0,
++		             RB0, RB2, RB3, RB4, RB1, RB2, RB1, RB3, RB4, RB0);
++	ROUND_INVERSE (1, 1, RA2, RA1, RA3, RA4, RA0, RA0, RA2, RA4, RA3, RA1,
++		             RB2, RB1, RB3, RB4, RB0, RB0, RB2, RB4, RB3, RB1);
++	ROUND_INVERSE (0, 0, RA0, RA2, RA4, RA3, RA1, RA0, RA1, RA2, RA3, RA4,
++		             RB0, RB2, RB4, RB3, RB1, RB0, RB1, RB2, RB3, RB4);
++
++	transpose_4x4(RA0, RA1, RA2, RA3);
++	transpose_4x4(RB0, RB1, RB2, RB3);
++
++	bx lr;
++.size __serpent_dec_blk8,.-__serpent_dec_blk8;
++
++.align 3
++.globl _gcry_serpent_neon_ctr_enc
++.type _gcry_serpent_neon_ctr_enc,%function;
++_gcry_serpent_neon_ctr_enc:
++	/* input:
++	 *	r0: ctx, CTX
++	 *	r1: dst (8 blocks)
++	 *	r2: src (8 blocks)
++	 *	r3: iv
++	 */
++
++	vmov.u8 RT1d0, #0xff; /* u64: -1 */
++	push {r4,lr};
++	vadd.u64 RT2d0, RT1d0, RT1d0; /* u64: -2 */
++	vpush {RA4-RB2};
++
++	/* load IV and byteswap */
++	vld1.8 {RA0}, [r3];
++	vrev64.u8 RT0, RA0; /* be => le */
++	ldr r4, [r3, #8];
++
++	/* construct IVs */
++	vsub.u64 RA2d1, RT0d1, RT2d0; /* +2 */
++	vsub.u64 RA1d1, RT0d1, RT1d0; /* +1 */
++	cmp r4, #-1;
++
++	vsub.u64 RB0d1, RA2d1, RT2d0; /* +4 */
++	vsub.u64 RA3d1, RA2d1, RT1d0; /* +3 */
++	ldr r4, [r3, #12];
++
++	vsub.u64 RB2d1, RB0d1, RT2d0; /* +6 */
++	vsub.u64 RB1d1, RB0d1, RT1d0; /* +5 */
++
++	vsub.u64 RT2d1, RB2d1, RT2d0; /* +8 */
++	vsub.u64 RB3d1, RB2d1, RT1d0; /* +7 */
++
++	vmov RA1d0, RT0d0;
++	vmov RA2d0, RT0d0;
++	vmov RA3d0, RT0d0;
++	vmov RB0d0, RT0d0;
++	rev r4, r4;
++	vmov RB1d0, RT0d0;
++	vmov RB2d0, RT0d0;
++	vmov RB3d0, RT0d0;
++	vmov RT2d0, RT0d0;
++
++	/* check need for handling 64-bit overflow and carry */
++	beq .Ldo_ctr_carry;
++
++.Lctr_carry_done:
++	/* le => be */
++	vrev64.u8 RA1, RA1;
++	vrev64.u8 RA2, RA2;
++	vrev64.u8 RA3, RA3;
++	vrev64.u8 RB0, RB0;
++	vrev64.u8 RT2, RT2;
++	vrev64.u8 RB1, RB1;
++	vrev64.u8 RB2, RB2;
++	vrev64.u8 RB3, RB3;
++	/* store new IV */
++	vst1.8 {RT2}, [r3];
++
++	bl __serpent_enc_blk8;
++
++	vld1.8 {RT0, RT1}, [r2]!;
++	vld1.8 {RT2, RT3}, [r2]!;
++	veor RA4, RA4, RT0;
++	veor RA1, RA1, RT1;
++	vld1.8 {RT0, RT1}, [r2]!;
++	veor RA2, RA2, RT2;
++	veor RA0, RA0, RT3;
++	vld1.8 {RT2, RT3}, [r2]!;
++	veor RB4, RB4, RT0;
++	veor RT0, RT0;
++	veor RB1, RB1, RT1;
++	veor RT1, RT1;
++	veor RB2, RB2, RT2;
++	veor RT2, RT2;
++	veor RB0, RB0, RT3;
++	veor RT3, RT3;
++
++	vst1.8 {RA4}, [r1]!;
++	vst1.8 {RA1}, [r1]!;
++	veor RA1, RA1;
++	vst1.8 {RA2}, [r1]!;
++	veor RA2, RA2;
++	vst1.8 {RA0}, [r1]!;
++	veor RA0, RA0;
++	vst1.8 {RB4}, [r1]!;
++	veor RB4, RB4;
++	vst1.8 {RB1}, [r1]!;
++	vst1.8 {RB2}, [r1]!;
++	vst1.8 {RB0}, [r1]!;
++
++	vpop {RA4-RB2};
++
++	/* clear the used registers */
++	veor RA3, RA3;
++	veor RB3, RB3;
++
++	pop {r4,pc};
++
++.Ldo_ctr_carry:
++	cmp r4, #-8;
++	blo .Lctr_carry_done;
++	beq .Lcarry_RT2;
++
++	cmp r4, #-6;
++	blo .Lcarry_RB3;
++	beq .Lcarry_RB2;
++
++	cmp r4, #-4;
++	blo .Lcarry_RB1;
++	beq .Lcarry_RB0;
++
++	cmp r4, #-2;
++	blo .Lcarry_RA3;
++	beq .Lcarry_RA2;
++
++	vsub.u64 RA1d0, RT1d0;
++.Lcarry_RA2:
++	vsub.u64 RA2d0, RT1d0;
++.Lcarry_RA3:
++	vsub.u64 RA3d0, RT1d0;
++.Lcarry_RB0:
++	vsub.u64 RB0d0, RT1d0;
++.Lcarry_RB1:
++	vsub.u64 RB1d0, RT1d0;
++.Lcarry_RB2:
++	vsub.u64 RB2d0, RT1d0;
++.Lcarry_RB3:
++	vsub.u64 RB3d0, RT1d0;
++.Lcarry_RT2:
++	vsub.u64 RT2d0, RT1d0;
++
++	b .Lctr_carry_done;
++.size _gcry_serpent_neon_ctr_enc,.-_gcry_serpent_neon_ctr_enc;
++
++.align 3
++.globl _gcry_serpent_neon_cfb_dec
++.type _gcry_serpent_neon_cfb_dec,%function;
++_gcry_serpent_neon_cfb_dec:
++	/* input:
++	 *	r0: ctx, CTX
++	 *	r1: dst (8 blocks)
++	 *	r2: src (8 blocks)
++	 *	r3: iv
++	 */
++
++	push {lr};
++	vpush {RA4-RB2};
++
++	/* Load input */
++	vld1.8 {RA0}, [r3];
++	vld1.8 {RA1, RA2}, [r2]!;
++	vld1.8 {RA3}, [r2]!;
++	vld1.8 {RB0}, [r2]!;
++	vld1.8 {RB1, RB2}, [r2]!;
++	vld1.8 {RB3}, [r2]!;
++
++	/* Update IV */
++	vld1.8 {RT0}, [r2]!;
++	vst1.8 {RT0}, [r3];
++	mov r3, lr;
++	sub r2, r2, #(8*16);
++
++	bl __serpent_enc_blk8;
++
++	vld1.8 {RT0, RT1}, [r2]!;
++	vld1.8 {RT2, RT3}, [r2]!;
++	veor RA4, RA4, RT0;
++	veor RA1, RA1, RT1;
++	vld1.8 {RT0, RT1}, [r2]!;
++	veor RA2, RA2, RT2;
++	veor RA0, RA0, RT3;
++	vld1.8 {RT2, RT3}, [r2]!;
++	veor RB4, RB4, RT0;
++	veor RT0, RT0;
++	veor RB1, RB1, RT1;
++	veor RT1, RT1;
++	veor RB2, RB2, RT2;
++	veor RT2, RT2;
++	veor RB0, RB0, RT3;
++	veor RT3, RT3;
++
++	vst1.8 {RA4}, [r1]!;
++	vst1.8 {RA1}, [r1]!;
++	veor RA1, RA1;
++	vst1.8 {RA2}, [r1]!;
++	veor RA2, RA2;
++	vst1.8 {RA0}, [r1]!;
++	veor RA0, RA0;
++	vst1.8 {RB4}, [r1]!;
++	veor RB4, RB4;
++	vst1.8 {RB1}, [r1]!;
++	vst1.8 {RB2}, [r1]!;
++	vst1.8 {RB0}, [r1]!;
++
++	vpop {RA4-RB2};
++
++	/* clear the used registers */
++	veor RA3, RA3;
++	veor RB3, RB3;
++
++	pop {pc};
++.size _gcry_serpent_neon_cfb_dec,.-_gcry_serpent_neon_cfb_dec;
++
++.align 3
++.globl _gcry_serpent_neon_cbc_dec
++.type _gcry_serpent_neon_cbc_dec,%function;
++_gcry_serpent_neon_cbc_dec:
++	/* input:
++	 *	r0: ctx, CTX
++	 *	r1: dst (8 blocks)
++	 *	r2: src (8 blocks)
++	 *	r3: iv
++	 */
++
++	push {lr};
++	vpush {RA4-RB2};
++
++	vld1.8 {RA0, RA1}, [r2]!;
++	vld1.8 {RA2, RA3}, [r2]!;
++	vld1.8 {RB0, RB1}, [r2]!;
++	vld1.8 {RB2, RB3}, [r2]!;
++	sub r2, r2, #(8*16);
++
++	bl __serpent_dec_blk8;
++
++	vld1.8 {RB4}, [r3];
++	vld1.8 {RT0, RT1}, [r2]!;
++	vld1.8 {RT2, RT3}, [r2]!;
++	veor RA0, RA0, RB4;
++	veor RA1, RA1, RT0;
++	veor RA2, RA2, RT1;
++	vld1.8 {RT0, RT1}, [r2]!;
++	veor RA3, RA3, RT2;
++	veor RB0, RB0, RT3;
++	vld1.8 {RT2, RT3}, [r2]!;
++	veor RB1, RB1, RT0;
++	veor RT0, RT0;
++	veor RB2, RB2, RT1;
++	veor RT1, RT1;
++	veor RB3, RB3, RT2;
++	veor RT2, RT2;
++	vst1.8 {RT3}, [r3]; /* store new IV */
++	veor RT3, RT3;
++
++	vst1.8 {RA0, RA1}, [r1]!;
++	veor RA0, RA0;
++	veor RA1, RA1;
++	vst1.8 {RA2, RA3}, [r1]!;
++	veor RA2, RA2;
++	vst1.8 {RB0, RB1}, [r1]!;
++	veor RA3, RA3;
++	vst1.8 {RB2, RB3}, [r1]!;
++	veor RB3, RB3;
++
++	vpop {RA4-RB2};
++
++	/* clear the used registers */
++	veor RB4, RB4;
++
++	pop {pc};
++.size _gcry_serpent_neon_cbc_dec,.-_gcry_serpent_neon_cbc_dec;
++
++#endif
diff --git a/recipes/libgcrypt/libgcrypt.recipe b/recipes/libgcrypt/libgcrypt.recipe
index 0b6bc1aa..58a4f3bd 100644
--- a/recipes/libgcrypt/libgcrypt.recipe
+++ b/recipes/libgcrypt/libgcrypt.recipe
@@ -11,7 +11,7 @@ class Recipe(recipe.Recipe):
     url = 'ftp://ftp.gnupg.org/gcrypt/libgcrypt/libgcrypt-%(version)s.tar.bz2'
     autoreconf = True
     configure_options = ' --with-gpg-error-prefix=$CERBERO_PREFIX'
-    patches = ['0001-Add-missing-file-in-distribution-tarball.patch']
+    patches = ['0001-Add-missing-file-in-distribution-tarball.patch', '0002-add-other-missing-file.patch']
     deps = ['libgpg-error']
 
     files_libs = ['libgcrypt']