react-native-quick-crypto 1.0.0-beta.20 → 1.0.0-beta.21

package/ios/libsodium-stable/src/libsodium/crypto_generichash/blake2b/ref/blake2b-compress-avx2.h

@@ -1,142 +0,0 @@
-
-#ifndef blake2b_compress_avx2_H
-#define blake2b_compress_avx2_H
-
-#define LOADU128(p) _mm_loadu_si128((const __m128i *) (p))
-#define STOREU128(p, r) _mm_storeu_si128((__m128i *) (p), r)
-
-#define LOADU(p) _mm256_loadu_si256((const __m256i *) (p))
-#define STOREU(p, r) _mm256_storeu_si256((__m256i *) (p), r)
-
-#if defined(__INTEL_COMPILER) || defined(_MSC_VER) || defined(__GNUC__)
-# define LOAD(p) _mm256_load_si256((const __m256i *) (p))
-# define STORE(p, r) _mm256_store_si256((__m256i *) (p), r)
-#else
-# define LOAD(p) LOADU(p)
-# define STORE(p, r) STOREU(p, r)
-#endif
-
-static inline uint64_t
-LOADU64(const void *p)
-{
-    uint64_t v;
-    memcpy(&v, p, sizeof v);
-    return v;
-}
-
-#define ROTATE16                                                              \
-    _mm256_setr_epi8(2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9, 2, \
-                     3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9)
-
-#define ROTATE24                                                              \
-    _mm256_setr_epi8(3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10, 3, \
-                     4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10)
-
-#define ADD(a, b) _mm256_add_epi64(a, b)
-#define SUB(a, b) _mm256_sub_epi64(a, b)
-
-#define XOR(a, b) _mm256_xor_si256(a, b)
-#define AND(a, b) _mm256_and_si256(a, b)
-#define OR(a, b) _mm256_or_si256(a, b)
-
-#define ROT32(x) _mm256_shuffle_epi32((x), _MM_SHUFFLE(2, 3, 0, 1))
-#define ROT24(x) _mm256_shuffle_epi8((x), ROTATE24)
-#define ROT16(x) _mm256_shuffle_epi8((x), ROTATE16)
-#define ROT63(x) _mm256_or_si256(_mm256_srli_epi64((x), 63), ADD((x), (x)))
-
-#define BLAKE2B_G1_V1(a, b, c, d, m) \
-    do {                             \
-        a = ADD(a, m);               \
-        a = ADD(a, b);               \
-        d = XOR(d, a);               \
-        d = ROT32(d);                \
-        c = ADD(c, d);               \
-        b = XOR(b, c);               \
-        b = ROT24(b);                \
-    } while (0)
-
-#define BLAKE2B_G2_V1(a, b, c, d, m) \
-    do {                             \
-        a = ADD(a, m);               \
-        a = ADD(a, b);               \
-        d = XOR(d, a);               \
-        d = ROT16(d);                \
-        c = ADD(c, d);               \
-        b = XOR(b, c);               \
-        b = ROT63(b);                \
-    } while (0)
-
-#define BLAKE2B_DIAG_V1(a, b, c, d)                               \
-    do {                                                          \
-        a = _mm256_permute4x64_epi64(a, _MM_SHUFFLE(2, 1, 0, 3)); \
-        d = _mm256_permute4x64_epi64(d, _MM_SHUFFLE(1, 0, 3, 2)); \
-        c = _mm256_permute4x64_epi64(c, _MM_SHUFFLE(0, 3, 2, 1)); \
-    } while(0)
-
-#define BLAKE2B_UNDIAG_V1(a, b, c, d)                             \
-    do {                                                          \
-        a = _mm256_permute4x64_epi64(a, _MM_SHUFFLE(0, 3, 2, 1)); \
-        d = _mm256_permute4x64_epi64(d, _MM_SHUFFLE(1, 0, 3, 2)); \
-        c = _mm256_permute4x64_epi64(c, _MM_SHUFFLE(2, 1, 0, 3)); \
-    } while(0)
-
-#include "blake2b-load-avx2.h"
-
-#define BLAKE2B_ROUND_V1(a, b, c, d, r, m) \
-    do {                                   \
-        __m256i b0;                        \
-        BLAKE2B_LOAD_MSG_##r##_1(b0);      \
-        BLAKE2B_G1_V1(a, b, c, d, b0);     \
-        BLAKE2B_LOAD_MSG_##r##_2(b0);      \
-        BLAKE2B_G2_V1(a, b, c, d, b0);     \
-        BLAKE2B_DIAG_V1(a, b, c, d);       \
-        BLAKE2B_LOAD_MSG_##r##_3(b0);      \
-        BLAKE2B_G1_V1(a, b, c, d, b0);     \
-        BLAKE2B_LOAD_MSG_##r##_4(b0);      \
-        BLAKE2B_G2_V1(a, b, c, d, b0);     \
-        BLAKE2B_UNDIAG_V1(a, b, c, d);     \
-    } while (0)
-
-#define BLAKE2B_ROUNDS_V1(a, b, c, d, m)       \
-    do {                                       \
-        BLAKE2B_ROUND_V1(a, b, c, d, 0, (m));  \
-        BLAKE2B_ROUND_V1(a, b, c, d, 1, (m));  \
-        BLAKE2B_ROUND_V1(a, b, c, d, 2, (m));  \
-        BLAKE2B_ROUND_V1(a, b, c, d, 3, (m));  \
-        BLAKE2B_ROUND_V1(a, b, c, d, 4, (m));  \
-        BLAKE2B_ROUND_V1(a, b, c, d, 5, (m));  \
-        BLAKE2B_ROUND_V1(a, b, c, d, 6, (m));  \
-        BLAKE2B_ROUND_V1(a, b, c, d, 7, (m));  \
-        BLAKE2B_ROUND_V1(a, b, c, d, 8, (m));  \
-        BLAKE2B_ROUND_V1(a, b, c, d, 9, (m));  \
-        BLAKE2B_ROUND_V1(a, b, c, d, 10, (m)); \
-        BLAKE2B_ROUND_V1(a, b, c, d, 11, (m)); \
-    } while (0)
-
-#define DECLARE_MESSAGE_WORDS(m)                                         \
-    const __m256i m0 = _mm256_broadcastsi128_si256(LOADU128((m) + 0));   \
-    const __m256i m1 = _mm256_broadcastsi128_si256(LOADU128((m) + 16));  \
-    const __m256i m2 = _mm256_broadcastsi128_si256(LOADU128((m) + 32));  \
-    const __m256i m3 = _mm256_broadcastsi128_si256(LOADU128((m) + 48));  \
-    const __m256i m4 = _mm256_broadcastsi128_si256(LOADU128((m) + 64));  \
-    const __m256i m5 = _mm256_broadcastsi128_si256(LOADU128((m) + 80));  \
-    const __m256i m6 = _mm256_broadcastsi128_si256(LOADU128((m) + 96));  \
-    const __m256i m7 = _mm256_broadcastsi128_si256(LOADU128((m) + 112)); \
-    __m256i       t0, t1;
-
-#define BLAKE2B_COMPRESS_V1(a, b, m, t0, t1, f0, f1)                      \
-    do {                                                                  \
-        DECLARE_MESSAGE_WORDS(m)                                          \
-        const __m256i iv0 = a;                                            \
-        const __m256i iv1 = b;                                            \
-        __m256i       c   = LOAD(&blake2b_IV[0]);                         \
-        __m256i       d =                                                 \
-            XOR(LOAD(&blake2b_IV[4]), _mm256_set_epi64x(f1, f0, t1, t0)); \
-        BLAKE2B_ROUNDS_V1(a, b, c, d, m);                                 \
-        a = XOR(a, c);                                                    \
-        b = XOR(b, d);                                                    \
-        a = XOR(a, iv0);                                                  \
-        b = XOR(b, iv1);                                                  \
-    } while (0)
-
-#endif

package/ios/libsodium-stable/src/libsodium/crypto_generichash/blake2b/ref/blake2b-compress-ref.c

@@ -1,93 +0,0 @@
-
-#include <stdint.h>
-#include <string.h>
-
-#include "blake2.h"
-#include "private/common.h"
-
-CRYPTO_ALIGN(64)
-static const uint64_t blake2b_IV[8] = {
-    0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL, 0x3c6ef372fe94f82bULL,
-    0xa54ff53a5f1d36f1ULL, 0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL,
-    0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL
-};
-
-static const uint8_t blake2b_sigma[12][16] = {
-    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
-    { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
-    { 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
-    { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
-    { 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
-    { 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
-    { 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
-    { 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
-    { 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
-    { 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0 },
-    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
-    { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 }
-};
-
-int
-blake2b_compress_ref(blake2b_state *S, const uint8_t block[BLAKE2B_BLOCKBYTES])
-{
-    uint64_t m[16];
-    uint64_t v[16];
-    int      i;
-
-    for (i = 0; i < 16; ++i) {
-        m[i] = LOAD64_LE(block + i * sizeof m[i]);
-    }
-    for (i = 0; i < 8; ++i) {
-        v[i] = S->h[i];
-    }
-    v[8]  = blake2b_IV[0];
-    v[9]  = blake2b_IV[1];
-    v[10] = blake2b_IV[2];
-    v[11] = blake2b_IV[3];
-    v[12] = S->t[0] ^ blake2b_IV[4];
-    v[13] = S->t[1] ^ blake2b_IV[5];
-    v[14] = S->f[0] ^ blake2b_IV[6];
-    v[15] = S->f[1] ^ blake2b_IV[7];
-#define G(r, i, a, b, c, d)                      \
-    do {                                         \
-        a += b + m[blake2b_sigma[r][2 * i + 0]]; \
-        d = ROTR64(d ^ a, 32);                   \
-        c += d;                                  \
-        b = ROTR64(b ^ c, 24);                   \
-        a += b + m[blake2b_sigma[r][2 * i + 1]]; \
-        d = ROTR64(d ^ a, 16);                   \
-        c += d;                                  \
-        b = ROTR64(b ^ c, 63);                   \
-    } while (0)
-#define ROUND(r)                           \
-    do {                                   \
-        G(r, 0, v[0], v[4], v[8], v[12]);  \
-        G(r, 1, v[1], v[5], v[9], v[13]);  \
-        G(r, 2, v[2], v[6], v[10], v[14]); \
-        G(r, 3, v[3], v[7], v[11], v[15]); \
-        G(r, 4, v[0], v[5], v[10], v[15]); \
-        G(r, 5, v[1], v[6], v[11], v[12]); \
-        G(r, 6, v[2], v[7], v[8], v[13]);  \
-        G(r, 7, v[3], v[4], v[9], v[14]);  \
-    } while (0)
-    ROUND(0);
-    ROUND(1);
-    ROUND(2);
-    ROUND(3);
-    ROUND(4);
-    ROUND(5);
-    ROUND(6);
-    ROUND(7);
-    ROUND(8);
-    ROUND(9);
-    ROUND(10);
-    ROUND(11);
-
-    for (i = 0; i < 8; ++i) {
-        S->h[i] = S->h[i] ^ v[i] ^ v[i + 8];
-    }
-
-#undef G
-#undef ROUND
-    return 0;
-}

package/ios/libsodium-stable/src/libsodium/crypto_generichash/blake2b/ref/blake2b-compress-sse41.c

@@ -1,91 +0,0 @@
-
-#define BLAKE2_USE_SSSE3
-#define BLAKE2_USE_SSE41
-
-#include <stdint.h>
-#include <string.h>
-
-#include "blake2.h"
-#include "private/common.h"
-
-#if defined(HAVE_EMMINTRIN_H) && defined(HAVE_TMMINTRIN_H) && \
-    defined(HAVE_SMMINTRIN_H)
-
-# ifdef __clang__
-#  pragma clang attribute push(__attribute__((target("sse2,ssse3,sse4.1"))), apply_to = function)
-# elif defined(__GNUC__)
-#  pragma GCC target("sse2,ssse3,sse4.1")
-# endif
-
-# include <emmintrin.h>
-# include <smmintrin.h>
-# include <tmmintrin.h>
-# include "private/sse2_64_32.h"
-
-# include "blake2b-compress-sse41.h"
-
-CRYPTO_ALIGN(64)
-static const uint64_t blake2b_IV[8] = {
-    0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL, 0x3c6ef372fe94f82bULL,
-    0xa54ff53a5f1d36f1ULL, 0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL,
-    0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL
-};
-
-int
-blake2b_compress_sse41(blake2b_state *S,
-                       const uint8_t  block[BLAKE2B_BLOCKBYTES])
-{
-    __m128i       row1l, row1h;
-    __m128i       row2l, row2h;
-    __m128i       row3l, row3h;
-    __m128i       row4l, row4h;
-    __m128i       b0, b1;
-    __m128i       t0, t1;
-    const __m128i r16 =
-        _mm_setr_epi8(2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9);
-    const __m128i r24 =
-        _mm_setr_epi8(3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10);
-    const __m128i m0 = LOADU(block + 00);
-    const __m128i m1 = LOADU(block + 16);
-    const __m128i m2 = LOADU(block + 32);
-    const __m128i m3 = LOADU(block + 48);
-    const __m128i m4 = LOADU(block + 64);
-    const __m128i m5 = LOADU(block + 80);
-    const __m128i m6 = LOADU(block + 96);
-    const __m128i m7 = LOADU(block + 112);
-    row1l            = LOADU(&S->h[0]);
-    row1h            = LOADU(&S->h[2]);
-    row2l            = LOADU(&S->h[4]);
-    row2h            = LOADU(&S->h[6]);
-    row3l            = LOADU(&blake2b_IV[0]);
-    row3h            = LOADU(&blake2b_IV[2]);
-    row4l            = _mm_xor_si128(LOADU(&blake2b_IV[4]), LOADU(&S->t[0]));
-    row4h            = _mm_xor_si128(LOADU(&blake2b_IV[6]), LOADU(&S->f[0]));
-    ROUND(0);
-    ROUND(1);
-    ROUND(2);
-    ROUND(3);
-    ROUND(4);
-    ROUND(5);
-    ROUND(6);
-    ROUND(7);
-    ROUND(8);
-    ROUND(9);
-    ROUND(10);
-    ROUND(11);
-    row1l = _mm_xor_si128(row3l, row1l);
-    row1h = _mm_xor_si128(row3h, row1h);
-    STOREU(&S->h[0], _mm_xor_si128(LOADU(&S->h[0]), row1l));
-    STOREU(&S->h[2], _mm_xor_si128(LOADU(&S->h[2]), row1h));
-    row2l = _mm_xor_si128(row4l, row2l);
-    row2h = _mm_xor_si128(row4h, row2h);
-    STOREU(&S->h[4], _mm_xor_si128(LOADU(&S->h[4]), row2l));
-    STOREU(&S->h[6], _mm_xor_si128(LOADU(&S->h[6]), row2h));
-    return 0;
-}
-
-# ifdef __clang__
-#  pragma clang attribute pop
-# endif
-
-#endif

package/ios/libsodium-stable/src/libsodium/crypto_generichash/blake2b/ref/blake2b-compress-sse41.h

@@ -1,106 +0,0 @@
-
-#ifndef blake2b_compress_sse41_H
-#define blake2b_compress_sse41_H
-
-#define LOADU(p) _mm_loadu_si128((const __m128i *) (const void *) (p))
-#define STOREU(p, r) _mm_storeu_si128((__m128i *) (void *) (p), r)
-
-#if !(defined(_mm_roti_epi64) && defined(__XOP__))
-#undef  _mm_roti_epi64
-#define _mm_roti_epi64(x, c)                                         \
-    (-(c) == 32)                                                     \
-        ? _mm_shuffle_epi32((x), _MM_SHUFFLE(2, 3, 0, 1))            \
-        : (-(c) == 24)                                               \
-              ? _mm_shuffle_epi8((x), r24)                           \
-              : (-(c) == 16)                                         \
-                    ? _mm_shuffle_epi8((x), r16)                     \
-                    : (-(c) == 63)                                   \
-                          ? _mm_xor_si128(_mm_srli_epi64((x), -(c)), \
-                                          _mm_add_epi64((x), (x)))   \
-                          : _mm_xor_si128(_mm_srli_epi64((x), -(c)), \
-                                          _mm_slli_epi64((x), 64 - (-(c))))
-#endif
-
-#define G1(row1l, row2l, row3l, row4l, row1h, row2h, row3h, row4h, b0, b1) \
-    row1l = _mm_add_epi64(_mm_add_epi64(row1l, b0), row2l);                \
-    row1h = _mm_add_epi64(_mm_add_epi64(row1h, b1), row2h);                \
-                                                                           \
-    row4l = _mm_xor_si128(row4l, row1l);                                   \
-    row4h = _mm_xor_si128(row4h, row1h);                                   \
-                                                                           \
-    row4l = _mm_roti_epi64(row4l, -32);                                    \
-    row4h = _mm_roti_epi64(row4h, -32);                                    \
-                                                                           \
-    row3l = _mm_add_epi64(row3l, row4l);                                   \
-    row3h = _mm_add_epi64(row3h, row4h);                                   \
-                                                                           \
-    row2l = _mm_xor_si128(row2l, row3l);                                   \
-    row2h = _mm_xor_si128(row2h, row3h);                                   \
-                                                                           \
-    row2l = _mm_roti_epi64(row2l, -24);                                    \
-    row2h = _mm_roti_epi64(row2h, -24);
-
-#define G2(row1l, row2l, row3l, row4l, row1h, row2h, row3h, row4h, b0, b1) \
-    row1l = _mm_add_epi64(_mm_add_epi64(row1l, b0), row2l);                \
-    row1h = _mm_add_epi64(_mm_add_epi64(row1h, b1), row2h);                \
-                                                                           \
-    row4l = _mm_xor_si128(row4l, row1l);                                   \
-    row4h = _mm_xor_si128(row4h, row1h);                                   \
-                                                                           \
-    row4l = _mm_roti_epi64(row4l, -16);                                    \
-    row4h = _mm_roti_epi64(row4h, -16);                                    \
-                                                                           \
-    row3l = _mm_add_epi64(row3l, row4l);                                   \
-    row3h = _mm_add_epi64(row3h, row4h);                                   \
-                                                                           \
-    row2l = _mm_xor_si128(row2l, row3l);                                   \
-    row2h = _mm_xor_si128(row2h, row3h);                                   \
-                                                                           \
-    row2l = _mm_roti_epi64(row2l, -63);                                    \
-    row2h = _mm_roti_epi64(row2h, -63);
-
-#define DIAGONALIZE(row1l, row2l, row3l, row4l, row1h, row2h, row3h, row4h) \
-    t0    = _mm_alignr_epi8(row2h, row2l, 8);                               \
-    t1    = _mm_alignr_epi8(row2l, row2h, 8);                               \
-    row2l = t0;                                                             \
-    row2h = t1;                                                             \
-                                                                            \
-    t0    = row3l;                                                          \
-    row3l = row3h;                                                          \
-    row3h = t0;                                                             \
-                                                                            \
-    t0    = _mm_alignr_epi8(row4h, row4l, 8);                               \
-    t1    = _mm_alignr_epi8(row4l, row4h, 8);                               \
-    row4l = t1;                                                             \
-    row4h = t0;
-
-#define UNDIAGONALIZE(row1l, row2l, row3l, row4l, row1h, row2h, row3h, row4h) \
-    t0    = _mm_alignr_epi8(row2l, row2h, 8);                                 \
-    t1    = _mm_alignr_epi8(row2h, row2l, 8);                                 \
-    row2l = t0;                                                               \
-    row2h = t1;                                                               \
-                                                                              \
-    t0    = row3l;                                                            \
-    row3l = row3h;                                                            \
-    row3h = t0;                                                               \
-                                                                              \
-    t0    = _mm_alignr_epi8(row4l, row4h, 8);                                 \
-    t1    = _mm_alignr_epi8(row4h, row4l, 8);                                 \
-    row4l = t1;                                                               \
-    row4h = t0;
-
-#include "blake2b-load-sse41.h"
-
-#define ROUND(r)                                                         \
-    LOAD_MSG_##r##_1(b0, b1);                                            \
-    G1(row1l, row2l, row3l, row4l, row1h, row2h, row3h, row4h, b0, b1);  \
-    LOAD_MSG_##r##_2(b0, b1);                                            \
-    G2(row1l, row2l, row3l, row4l, row1h, row2h, row3h, row4h, b0, b1);  \
-    DIAGONALIZE(row1l, row2l, row3l, row4l, row1h, row2h, row3h, row4h); \
-    LOAD_MSG_##r##_3(b0, b1);                                            \
-    G1(row1l, row2l, row3l, row4l, row1h, row2h, row3h, row4h, b0, b1);  \
-    LOAD_MSG_##r##_4(b0, b1);                                            \
-    G2(row1l, row2l, row3l, row4l, row1h, row2h, row3h, row4h, b0, b1);  \
-    UNDIAGONALIZE(row1l, row2l, row3l, row4l, row1h, row2h, row3h, row4h);
-
-#endif

package/ios/libsodium-stable/src/libsodium/crypto_generichash/blake2b/ref/blake2b-compress-ssse3.c

@@ -1,95 +0,0 @@
-
-#include <stdint.h>
-#include <string.h>
-
-#include "blake2.h"
-#include "private/common.h"
-
-#if defined(HAVE_EMMINTRIN_H) && defined(HAVE_TMMINTRIN_H)
-
-# ifdef __clang__
-#  pragma clang attribute push(__attribute__((target("sse2,ssse3"))), apply_to = function)
-# elif defined(__GNUC__)
-#  pragma GCC target("sse2,ssse3")
-# endif
-
-# include <emmintrin.h>
-# include <tmmintrin.h>
-# include "private/sse2_64_32.h"
-
-# include "blake2b-compress-ssse3.h"
-
-CRYPTO_ALIGN(64)
-static const uint64_t blake2b_IV[8] = {
-    0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL, 0x3c6ef372fe94f82bULL,
-    0xa54ff53a5f1d36f1ULL, 0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL,
-    0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL
-};
-
-int
-blake2b_compress_ssse3(blake2b_state *S,
-                       const uint8_t  block[BLAKE2B_BLOCKBYTES])
-{
-    __m128i       row1l, row1h;
-    __m128i       row2l, row2h;
-    __m128i       row3l, row3h;
-    __m128i       row4l, row4h;
-    __m128i       b0, b1;
-    __m128i       t0, t1;
-    const __m128i r16 =
-        _mm_setr_epi8(2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9);
-    const __m128i r24 =
-        _mm_setr_epi8(3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10);
-    const uint64_t m0  = ((const uint64_t *) block)[0];
-    const uint64_t m1  = ((const uint64_t *) block)[1];
-    const uint64_t m2  = ((const uint64_t *) block)[2];
-    const uint64_t m3  = ((const uint64_t *) block)[3];
-    const uint64_t m4  = ((const uint64_t *) block)[4];
-    const uint64_t m5  = ((const uint64_t *) block)[5];
-    const uint64_t m6  = ((const uint64_t *) block)[6];
-    const uint64_t m7  = ((const uint64_t *) block)[7];
-    const uint64_t m8  = ((const uint64_t *) block)[8];
-    const uint64_t m9  = ((const uint64_t *) block)[9];
-    const uint64_t m10 = ((const uint64_t *) block)[10];
-    const uint64_t m11 = ((const uint64_t *) block)[11];
-    const uint64_t m12 = ((const uint64_t *) block)[12];
-    const uint64_t m13 = ((const uint64_t *) block)[13];
-    const uint64_t m14 = ((const uint64_t *) block)[14];
-    const uint64_t m15 = ((const uint64_t *) block)[15];
-
-    row1l = LOADU(&S->h[0]);
-    row1h = LOADU(&S->h[2]);
-    row2l = LOADU(&S->h[4]);
-    row2h = LOADU(&S->h[6]);
-    row3l = LOADU(&blake2b_IV[0]);
-    row3h = LOADU(&blake2b_IV[2]);
-    row4l = _mm_xor_si128(LOADU(&blake2b_IV[4]), LOADU(&S->t[0]));
-    row4h = _mm_xor_si128(LOADU(&blake2b_IV[6]), LOADU(&S->f[0]));
-    ROUND(0);
-    ROUND(1);
-    ROUND(2);
-    ROUND(3);
-    ROUND(4);
-    ROUND(5);
-    ROUND(6);
-    ROUND(7);
-    ROUND(8);
-    ROUND(9);
-    ROUND(10);
-    ROUND(11);
-    row1l = _mm_xor_si128(row3l, row1l);
-    row1h = _mm_xor_si128(row3h, row1h);
-    STOREU(&S->h[0], _mm_xor_si128(LOADU(&S->h[0]), row1l));
-    STOREU(&S->h[2], _mm_xor_si128(LOADU(&S->h[2]), row1h));
-    row2l = _mm_xor_si128(row4l, row2l);
-    row2h = _mm_xor_si128(row4h, row2h);
-    STOREU(&S->h[4], _mm_xor_si128(LOADU(&S->h[4]), row2l));
-    STOREU(&S->h[6], _mm_xor_si128(LOADU(&S->h[6]), row2h));
-    return 0;
-}
-
-# ifdef __clang__
-#  pragma clang attribute pop
-# endif
-
-#endif

package/ios/libsodium-stable/src/libsodium/crypto_generichash/blake2b/ref/blake2b-compress-ssse3.h

@@ -1,106 +0,0 @@
-
-#ifndef blake2b_compress_ssse3_H
-#define blake2b_compress_ssse3_H
-
-#define LOADU(p) _mm_loadu_si128((const __m128i *) (const void *) (p))
-#define STOREU(p, r) _mm_storeu_si128((__m128i *) (void *) (p), r)
-
-#if !(defined(_mm_roti_epi64) && defined(__XOP__))
-#undef  _mm_roti_epi64
-#define _mm_roti_epi64(x, c)                                         \
-    (-(c) == 32)                                                     \
-        ? _mm_shuffle_epi32((x), _MM_SHUFFLE(2, 3, 0, 1))            \
-        : (-(c) == 24)                                               \
-              ? _mm_shuffle_epi8((x), r24)                           \
-              : (-(c) == 16)                                         \
-                    ? _mm_shuffle_epi8((x), r16)                     \
-                    : (-(c) == 63)                                   \
-                          ? _mm_xor_si128(_mm_srli_epi64((x), -(c)), \
-                                          _mm_add_epi64((x), (x)))   \
-                          : _mm_xor_si128(_mm_srli_epi64((x), -(c)), \
-                                          _mm_slli_epi64((x), 64 - (-(c))))
-#endif
-
-#define G1(row1l, row2l, row3l, row4l, row1h, row2h, row3h, row4h, b0, b1) \
-    row1l = _mm_add_epi64(_mm_add_epi64(row1l, b0), row2l);                \
-    row1h = _mm_add_epi64(_mm_add_epi64(row1h, b1), row2h);                \
-                                                                           \
-    row4l = _mm_xor_si128(row4l, row1l);                                   \
-    row4h = _mm_xor_si128(row4h, row1h);                                   \
-                                                                           \
-    row4l = _mm_roti_epi64(row4l, -32);                                    \
-    row4h = _mm_roti_epi64(row4h, -32);                                    \
-                                                                           \
-    row3l = _mm_add_epi64(row3l, row4l);                                   \
-    row3h = _mm_add_epi64(row3h, row4h);                                   \
-                                                                           \
-    row2l = _mm_xor_si128(row2l, row3l);                                   \
-    row2h = _mm_xor_si128(row2h, row3h);                                   \
-                                                                           \
-    row2l = _mm_roti_epi64(row2l, -24);                                    \
-    row2h = _mm_roti_epi64(row2h, -24);
-
-#define G2(row1l, row2l, row3l, row4l, row1h, row2h, row3h, row4h, b0, b1) \
-    row1l = _mm_add_epi64(_mm_add_epi64(row1l, b0), row2l);                \
-    row1h = _mm_add_epi64(_mm_add_epi64(row1h, b1), row2h);                \
-                                                                           \
-    row4l = _mm_xor_si128(row4l, row1l);                                   \
-    row4h = _mm_xor_si128(row4h, row1h);                                   \
-                                                                           \
-    row4l = _mm_roti_epi64(row4l, -16);                                    \
-    row4h = _mm_roti_epi64(row4h, -16);                                    \
-                                                                           \
-    row3l = _mm_add_epi64(row3l, row4l);                                   \
-    row3h = _mm_add_epi64(row3h, row4h);                                   \
-                                                                           \
-    row2l = _mm_xor_si128(row2l, row3l);                                   \
-    row2h = _mm_xor_si128(row2h, row3h);                                   \
-                                                                           \
-    row2l = _mm_roti_epi64(row2l, -63);                                    \
-    row2h = _mm_roti_epi64(row2h, -63);
-
-#define DIAGONALIZE(row1l, row2l, row3l, row4l, row1h, row2h, row3h, row4h) \
-    t0    = _mm_alignr_epi8(row2h, row2l, 8);                               \
-    t1    = _mm_alignr_epi8(row2l, row2h, 8);                               \
-    row2l = t0;                                                             \
-    row2h = t1;                                                             \
-                                                                            \
-    t0    = row3l;                                                          \
-    row3l = row3h;                                                          \
-    row3h = t0;                                                             \
-                                                                            \
-    t0    = _mm_alignr_epi8(row4h, row4l, 8);                               \
-    t1    = _mm_alignr_epi8(row4l, row4h, 8);                               \
-    row4l = t1;                                                             \
-    row4h = t0;
-
-#define UNDIAGONALIZE(row1l, row2l, row3l, row4l, row1h, row2h, row3h, row4h) \
-    t0    = _mm_alignr_epi8(row2l, row2h, 8);                                 \
-    t1    = _mm_alignr_epi8(row2h, row2l, 8);                                 \
-    row2l = t0;                                                               \
-    row2h = t1;                                                               \
-                                                                              \
-    t0    = row3l;                                                            \
-    row3l = row3h;                                                            \
-    row3h = t0;                                                               \
-                                                                              \
-    t0    = _mm_alignr_epi8(row4l, row4h, 8);                                 \
-    t1    = _mm_alignr_epi8(row4h, row4l, 8);                                 \
-    row4l = t1;                                                               \
-    row4h = t0;
-
-#include "blake2b-load-sse2.h"
-
-#define ROUND(r)                                                         \
-    LOAD_MSG_##r##_1(b0, b1);                                            \
-    G1(row1l, row2l, row3l, row4l, row1h, row2h, row3h, row4h, b0, b1);  \
-    LOAD_MSG_##r##_2(b0, b1);                                            \
-    G2(row1l, row2l, row3l, row4l, row1h, row2h, row3h, row4h, b0, b1);  \
-    DIAGONALIZE(row1l, row2l, row3l, row4l, row1h, row2h, row3h, row4h); \
-    LOAD_MSG_##r##_3(b0, b1);                                            \
-    G1(row1l, row2l, row3l, row4l, row1h, row2h, row3h, row4h, b0, b1);  \
-    LOAD_MSG_##r##_4(b0, b1);                                            \
-    G2(row1l, row2l, row3l, row4l, row1h, row2h, row3h, row4h, b0, b1);  \
-    UNDIAGONALIZE(row1l, row2l, row3l, row4l, row1h, row2h, row3h, row4h);
-
-#endif