4 files changed, 360 insertions, 0 deletions
diff --git a/src/utils/simd_32/info.txt b/src/utils/simd_32/info.txt
new file mode 100644
index 000000000..c72f2a6ed
--- /dev/null
+++ b/src/utils/simd_32/info.txt
@@ -0,0 +1,18 @@
+realname "SIMD"
+
+define SIMD_32
+
+load_on always
+
+<arch>
+pentium-m
+pentium4
+prescott
+amd64
+</arch>
+
+<cc>
+gcc
+icc
+msvc
+</cc>
diff --git a/src/utils/simd_32/simd_32.h b/src/utils/simd_32/simd_32.h
new file mode 100644
index 000000000..d9fac0d3d
--- /dev/null
+++ b/src/utils/simd_32/simd_32.h
@@ -0,0 +1,29 @@
+/**
+* Lightweight wrappers for SIMD operations
+*/
+
+#ifndef BOTAN_SIMD_32_H__
+#define BOTAN_SIMD_32_H__
+
+#include <botan/types.h>
+
+//#define BOTAN_TARGET_CPU_HAS_SSE2
+
+#if defined(BOTAN_TARGET_CPU_HAS_SSE2)
+
+  #include <botan/simd_sse.h>
+  namespace Botan { typedef SIMD_SSE2 SIMD_32; }
+
+#elif defined(BOTAN_TARGET_CPU_HAS_ALTIVEC)
+
+  #include <botan/simd_altivec.h>
+  namespace Botan { typedef SIMD_Altivec SIMD_32; }
+
+#else
+
+  #include <botan/simd_scalar.h>
+  namespace Botan { typedef SIMD_Scalar SIMD_32; }
+
+#endif
+
+#endif
diff --git a/src/utils/simd_32/simd_scalar.h b/src/utils/simd_32/simd_scalar.h
new file mode 100644
index 000000000..a6067f115
--- /dev/null
+++ b/src/utils/simd_32/simd_scalar.h
@@ -0,0 +1,172 @@
+/**
+* Scalar emulation of SIMD operations
+*/
+
+#ifndef BOTAN_SIMD_SCALAR_H__
+#define BOTAN_SIMD_SCALAR_H__
+
+#include <botan/loadstor.h>
+
+namespace Botan {
+
+class SIMD_Scalar
+   {
+   public:
+      SIMD_Scalar(const u32bit B[4])
+         {
+         R0 = B[0];
+         R1 = B[1];
+         R2 = B[2];
+         R3 = B[3];
+         }
+
+      SIMD_Scalar(u32bit B0, u32bit B1, u32bit B2, u32bit B3)
+         {
+         R0 = B0;
+         R1 = B1;
+         R2 = B2;
+         R3 = B3;
+         }
+
+      SIMD_Scalar(u32bit B)
+         {
+         R0 = B;
+         R1 = B;
+         R2 = B;
+         R3 = B;
+         }
+
+      static SIMD_Scalar load_le(const void* in)
+         {
+         const byte* in_b = static_cast<const byte*>(in);
+         return SIMD_Scalar(Botan::load_le<u32bit>(in_b, 0),
+                            Botan::load_le<u32bit>(in_b, 1),
+                            Botan::load_le<u32bit>(in_b, 2),
+                            Botan::load_le<u32bit>(in_b, 3));
+         }
+
+      static SIMD_Scalar load_be(const void* in)
+         {
+         const byte* in_b = static_cast<const byte*>(in);
+         return SIMD_Scalar(Botan::load_be<u32bit>(in_b, 0),
+                            Botan::load_be<u32bit>(in_b, 1),
+                            Botan::load_be<u32bit>(in_b, 2),
+                            Botan::load_be<u32bit>(in_b, 3));
+         }
+
+      void store_le(byte out[]) const
+         {
+         Botan::store_le(out, R0, R1, R2, R3);
+         }
+
+      void store_be(byte out[]) const
+         {
+         Botan::store_be(out, R0, R1, R2, R3);
+         }
+
+      void rotate_left(u32bit rot)
+         {
+         R0 = Botan::rotate_left(R0, rot);
+         R1 = Botan::rotate_left(R1, rot);
+         R2 = Botan::rotate_left(R2, rot);
+         R3 = Botan::rotate_left(R3, rot);
+         }
+
+      void rotate_right(u32bit rot)
+         {
+         R0 = Botan::rotate_right(R0, rot);
+         R1 = Botan::rotate_right(R1, rot);
+         R2 = Botan::rotate_right(R2, rot);
+         R3 = Botan::rotate_right(R3, rot);
+         }
+
+      void operator+=(const SIMD_Scalar& other)
+         {
+         R0 += other.R0;
+         R1 += other.R1;
+         R2 += other.R2;
+         R3 += other.R3;
+         }
+
+      SIMD_Scalar operator+(const SIMD_Scalar& other) const
+         {
+         return SIMD_Scalar(R0 + other.R0,
+                            R1 + other.R1,
+                            R2 + other.R2,
+                            R3 + other.R3);
+         }
+
+      void operator^=(const SIMD_Scalar& other)
+         {
+         R0 ^= other.R0;
+         R1 ^= other.R1;
+         R2 ^= other.R2;
+         R3 ^= other.R3;
+         }
+
+      SIMD_Scalar operator^(const SIMD_Scalar& other) const
+         {
+         return SIMD_Scalar(R0 ^ other.R0,
+                            R1 ^ other.R1,
+                            R2 ^ other.R2,
+                            R3 ^ other.R3);
+         }
+
+      void operator|=(const SIMD_Scalar& other)
+         {
+         R0 |= other.R0;
+         R1 |= other.R1;
+         R2 |= other.R2;
+         R3 |= other.R3;
+         }
+
+      void operator&=(const SIMD_Scalar& other)
+         {
+         R0 &= other.R0;
+         R1 &= other.R1;
+         R2 &= other.R2;
+         R3 &= other.R3;
+         }
+
+      SIMD_Scalar operator<<(u32bit shift) const
+         {
+         return SIMD_Scalar(R0 << shift,
+                            R1 << shift,
+                            R2 << shift,
+                            R3 << shift);
+         }
+
+      SIMD_Scalar operator>>(u32bit shift) const
+         {
+         return SIMD_Scalar(R0 >> shift,
+                            R1 >> shift,
+                            R2 >> shift,
+                            R3 >> shift);
+         }
+
+      SIMD_Scalar operator~() const
+         {
+         return SIMD_Scalar(~R0, ~R1, ~R2, ~R3);
+         }
+
+      static void transpose(SIMD_Scalar& B0, SIMD_Scalar& B1,
+                            SIMD_Scalar& B2, SIMD_Scalar& B3)
+         {
+         SIMD_Scalar T0(B0.R0, B1.R0, B2.R0, B3.R0);
+         SIMD_Scalar T1(B0.R1, B1.R1, B2.R1, B3.R1);
+         SIMD_Scalar T2(B0.R2, B1.R2, B2.R2, B3.R2);
+         SIMD_Scalar T3(B0.R3, B1.R3, B2.R3, B3.R3);
+
+         B0 = T0;
+         B1 = T1;
+         B2 = T2;
+         B3 = T3;
+         }
+
+   private:
+      u32bit R0, R1, R2, R3;
+   };
+
+}
+
+#endif
diff --git a/src/utils/simd_32/simd_sse.h b/src/utils/simd_32/simd_sse.h
new file mode 100644
index 000000000..d9135f1c7
--- /dev/null
+++ b/src/utils/simd_32/simd_sse.h
@@ -0,0 +1,141 @@
+/**
+* Lightweight wrappers for SSE2 intrinsics for 32-bit operations
+*/
+
+#ifndef BOTAN_SIMD_SSE_H__
+#define BOTAN_SIMD_SSE_H__
+
+#include <botan/types.h>
+#include <emmintrin.h>
+
+namespace Botan {
+
+class SIMD_SSE2
+   {
+   public:
+      SIMD_SSE2(const u32bit B[4])
+         {
+         reg = _mm_loadu_si128((const __m128i*)B);
+         }
+
+      SIMD_SSE2(u32bit B0, u32bit B1, u32bit B2, u32bit B3)
+         {
+         reg = _mm_set_epi32(B0, B1, B2, B3);
+         }
+
+      SIMD_SSE2(u32bit B)
+         {
+         reg = _mm_set1_epi32(B);
+         }
+
+      static SIMD_SSE2 load_le(const void* in)
+         {
+         return _mm_loadu_si128((const __m128i*)in);
+         }
+
+      static SIMD_SSE2 load_be(const void* in)
+         {
+         return SIMD_SSE2(_mm_loadu_si128((const __m128i*)in)).bswap();
+         }
+
+      void store_le(byte out[]) const
+         {
+         _mm_storeu_si128((__m128i*)out, reg);
+         }
+
+      void store_be(byte out[]) const
+         {
+         bswap().store_le(out);
+         }
+
+      void rotate_left(u32bit rot)
+         {
+         reg = _mm_or_si128(_mm_slli_epi32(reg, rot),
+                            _mm_srli_epi32(reg, 32-rot));
+         }
+
+      void rotate_right(u32bit rot)
+         {
+         reg = _mm_or_si128(_mm_srli_epi32(reg, rot),
+                            _mm_slli_epi32(reg, 32-rot));
+         }
+
+      void operator+=(const SIMD_SSE2& other)
+         {
+         reg = _mm_add_epi32(reg, other.reg);
+         }
+
+      SIMD_SSE2 operator+(const SIMD_SSE2& other) const
+         {
+         return _mm_add_epi32(reg, other.reg);
+         }
+
+      void operator^=(const SIMD_SSE2& other)
+         {
+         reg = _mm_xor_si128(reg, other.reg);
+         }
+
+      SIMD_SSE2 operator^(const SIMD_SSE2& other) const
+         {
+         return _mm_xor_si128(reg, other.reg);
+         }
+
+      void operator|=(const SIMD_SSE2& other)
+         {
+         reg = _mm_or_si128(reg, other.reg);
+         }
+
+      void operator&=(const SIMD_SSE2& other)
+         {
+         reg = _mm_and_si128(reg, other.reg);
+         }
+
+      SIMD_SSE2 operator<<(u32bit shift) const
+         {
+         return _mm_slli_epi32(reg, shift);
+         }
+
+      SIMD_SSE2 operator>>(u32bit shift) const
+         {
+         return _mm_srli_epi32(reg, shift);
+         }
+
+      SIMD_SSE2 operator~() const
+         {
+         static const __m128i all_ones = _mm_set1_epi32(0xFFFFFFFF);
+         return _mm_xor_si128(reg, all_ones);
+         }
+
+      static void transpose(SIMD_SSE2& B0, SIMD_SSE2& B1,
+                            SIMD_SSE2& B2, SIMD_SSE2& B3)
+         {
+         __m128i T0 = _mm_unpacklo_epi32(B0.reg, B1.reg);
+         __m128i T1 = _mm_unpacklo_epi32(B2.reg, B3.reg);
+         __m128i T2 = _mm_unpackhi_epi32(B0.reg, B1.reg);
+         __m128i T3 = _mm_unpackhi_epi32(B2.reg, B3.reg);
+         B0.reg = _mm_unpacklo_epi64(T0, T1);
+         B1.reg = _mm_unpackhi_epi64(T0, T1);
+         B2.reg = _mm_unpacklo_epi64(T2, T3);
+         B3.reg = _mm_unpackhi_epi64(T2, T3);
+         }
+
+   private:
+      SIMD_SSE2(__m128i in) { reg = in; }
+
+      SIMD_SSE2 bswap() const
+         {
+         __m128i T = reg;
+
+         T = _mm_shufflehi_epi16(T, _MM_SHUFFLE(2, 3, 0, 1));
+         T = _mm_shufflelo_epi16(T, _MM_SHUFFLE(2, 3, 0, 1));
+
+         return _mm_or_si128(_mm_srli_epi16(T, 8),
+                             _mm_slli_epi16(T, 8));
+         }
+
+      __m128i reg;
+   };
+
+}
+
+#endif