rbnacl-libsodium 1.0.11 → 1.0.13

data/vendor/libsodium/src/libsodium/crypto_generichash/blake2b/ref/blake2b-compress-ssse3.c

@@ -0,0 +1,90 @@
+
+#include <stdint.h>
+#include <string.h>
+
+#include "blake2.h"
+#include "private/common.h"
+#include "private/sse2_64_32.h"
+
+#if defined(HAVE_EMMINTRIN_H) && defined(HAVE_TMMINTRIN_H)
+
+# ifdef __GNUC__
+#  pragma GCC target("sse2")
+#  pragma GCC target("ssse3")
+# endif
+
+# include <emmintrin.h>
+# include <tmmintrin.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  = ((uint64_t *) block)[0];
+    const uint64_t m1  = ((uint64_t *) block)[1];
+    const uint64_t m2  = ((uint64_t *) block)[2];
+    const uint64_t m3  = ((uint64_t *) block)[3];
+    const uint64_t m4  = ((uint64_t *) block)[4];
+    const uint64_t m5  = ((uint64_t *) block)[5];
+    const uint64_t m6  = ((uint64_t *) block)[6];
+    const uint64_t m7  = ((uint64_t *) block)[7];
+    const uint64_t m8  = ((uint64_t *) block)[8];
+    const uint64_t m9  = ((uint64_t *) block)[9];
+    const uint64_t m10 = ((uint64_t *) block)[10];
+    const uint64_t m11 = ((uint64_t *) block)[11];
+    const uint64_t m12 = ((uint64_t *) block)[12];
+    const uint64_t m13 = ((uint64_t *) block)[13];
+    const uint64_t m14 = ((uint64_t *) block)[14];
+    const uint64_t m15 = ((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;
+}
+
+#endif

data/vendor/libsodium/src/libsodium/crypto_generichash/blake2b/ref/blake2b-compress-ssse3.h

@@ -0,0 +1,103 @@
+
+#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)
+
+#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))))
+
+#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

data/vendor/libsodium/src/libsodium/crypto_generichash/blake2b/ref/blake2b-load-avx2.h

@@ -0,0 +1,340 @@
+#ifndef blake2b_load_avx2_H
+#define blake2b_load_avx2_H
+
+#define BLAKE2B_LOAD_MSG_0_1(b0)               \
+    do {                                       \
+        t0 = _mm256_unpacklo_epi64(m0, m1);    \
+        t1 = _mm256_unpacklo_epi64(m2, m3);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_0_2(b0)               \
+    do {                                       \
+        t0 = _mm256_unpackhi_epi64(m0, m1);    \
+        t1 = _mm256_unpackhi_epi64(m2, m3);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_0_3(b0)               \
+    do {                                       \
+        t0 = _mm256_unpacklo_epi64(m4, m5);    \
+        t1 = _mm256_unpacklo_epi64(m6, m7);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_0_4(b0)               \
+    do {                                       \
+        t0 = _mm256_unpackhi_epi64(m4, m5);    \
+        t1 = _mm256_unpackhi_epi64(m6, m7);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_1_1(b0)               \
+    do {                                       \
+        t0 = _mm256_unpacklo_epi64(m7, m2);    \
+        t1 = _mm256_unpackhi_epi64(m4, m6);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_1_2(b0)               \
+    do {                                       \
+        t0 = _mm256_unpacklo_epi64(m5, m4);    \
+        t1 = _mm256_alignr_epi8(m3, m7, 8);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_1_3(b0)                                \
+    do {                                                        \
+        t0 = _mm256_shuffle_epi32(m0, _MM_SHUFFLE(1, 0, 3, 2)); \
+        t1 = _mm256_unpackhi_epi64(m5, m2);                     \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0);                  \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_1_4(b0)               \
+    do {                                       \
+        t0 = _mm256_unpacklo_epi64(m6, m1);    \
+        t1 = _mm256_unpackhi_epi64(m3, m1);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_2_1(b0)               \
+    do {                                       \
+        t0 = _mm256_alignr_epi8(m6, m5, 8);    \
+        t1 = _mm256_unpackhi_epi64(m2, m7);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_2_2(b0)               \
+    do {                                       \
+        t0 = _mm256_unpacklo_epi64(m4, m0);    \
+        t1 = _mm256_blend_epi32(m6, m1, 0x33); \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_2_3(b0)               \
+    do {                                       \
+        t0 = _mm256_blend_epi32(m1, m5, 0x33); \
+        t1 = _mm256_unpackhi_epi64(m3, m4);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_2_4(b0)               \
+    do {                                       \
+        t0 = _mm256_unpacklo_epi64(m7, m3);    \
+        t1 = _mm256_alignr_epi8(m2, m0, 8);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_3_1(b0)               \
+    do {                                       \
+        t0 = _mm256_unpackhi_epi64(m3, m1);    \
+        t1 = _mm256_unpackhi_epi64(m6, m5);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_3_2(b0)               \
+    do {                                       \
+        t0 = _mm256_unpackhi_epi64(m4, m0);    \
+        t1 = _mm256_unpacklo_epi64(m6, m7);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_3_3(b0)               \
+    do {                                       \
+        t0 = _mm256_blend_epi32(m2, m1, 0x33); \
+        t1 = _mm256_blend_epi32(m7, m2, 0x33); \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_3_4(b0)               \
+    do {                                       \
+        t0 = _mm256_unpacklo_epi64(m3, m5);    \
+        t1 = _mm256_unpacklo_epi64(m0, m4);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_4_1(b0)               \
+    do {                                       \
+        t0 = _mm256_unpackhi_epi64(m4, m2);    \
+        t1 = _mm256_unpacklo_epi64(m1, m5);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_4_2(b0)               \
+    do {                                       \
+        t0 = _mm256_blend_epi32(m3, m0, 0x33); \
+        t1 = _mm256_blend_epi32(m7, m2, 0x33); \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_4_3(b0)               \
+    do {                                       \
+        t0 = _mm256_blend_epi32(m5, m7, 0x33); \
+        t1 = _mm256_blend_epi32(m1, m3, 0x33); \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_4_4(b0)               \
+    do {                                       \
+        t0 = _mm256_alignr_epi8(m6, m0, 8);    \
+        t1 = _mm256_blend_epi32(m6, m4, 0x33); \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_5_1(b0)               \
+    do {                                       \
+        t0 = _mm256_unpacklo_epi64(m1, m3);    \
+        t1 = _mm256_unpacklo_epi64(m0, m4);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_5_2(b0)               \
+    do {                                       \
+        t0 = _mm256_unpacklo_epi64(m6, m5);    \
+        t1 = _mm256_unpackhi_epi64(m5, m1);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_5_3(b0)               \
+    do {                                       \
+        t0 = _mm256_blend_epi32(m3, m2, 0x33); \
+        t1 = _mm256_unpackhi_epi64(m7, m0);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_5_4(b0)               \
+    do {                                       \
+        t0 = _mm256_unpackhi_epi64(m6, m2);    \
+        t1 = _mm256_blend_epi32(m4, m7, 0x33); \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_6_1(b0)               \
+    do {                                       \
+        t0 = _mm256_blend_epi32(m0, m6, 0x33); \
+        t1 = _mm256_unpacklo_epi64(m7, m2);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_6_2(b0)               \
+    do {                                       \
+        t0 = _mm256_unpackhi_epi64(m2, m7);    \
+        t1 = _mm256_alignr_epi8(m5, m6, 8);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_6_3(b0)                                \
+    do {                                                        \
+        t0 = _mm256_unpacklo_epi64(m0, m3);                     \
+        t1 = _mm256_shuffle_epi32(m4, _MM_SHUFFLE(1, 0, 3, 2)); \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0);                  \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_6_4(b0)               \
+    do {                                       \
+        t0 = _mm256_unpackhi_epi64(m3, m1);    \
+        t1 = _mm256_blend_epi32(m5, m1, 0x33); \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_7_1(b0)               \
+    do {                                       \
+        t0 = _mm256_unpackhi_epi64(m6, m3);    \
+        t1 = _mm256_blend_epi32(m1, m6, 0x33); \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_7_2(b0)               \
+    do {                                       \
+        t0 = _mm256_alignr_epi8(m7, m5, 8);    \
+        t1 = _mm256_unpackhi_epi64(m0, m4);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_7_3(b0)               \
+    do {                                       \
+        t0 = _mm256_unpackhi_epi64(m2, m7);    \
+        t1 = _mm256_unpacklo_epi64(m4, m1);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_7_4(b0)               \
+    do {                                       \
+        t0 = _mm256_unpacklo_epi64(m0, m2);    \
+        t1 = _mm256_unpacklo_epi64(m3, m5);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_8_1(b0)               \
+    do {                                       \
+        t0 = _mm256_unpacklo_epi64(m3, m7);    \
+        t1 = _mm256_alignr_epi8(m0, m5, 8);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_8_2(b0)               \
+    do {                                       \
+        t0 = _mm256_unpackhi_epi64(m7, m4);    \
+        t1 = _mm256_alignr_epi8(m4, m1, 8);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_8_3(b0)               \
+    do {                                       \
+        t0 = m6;                               \
+        t1 = _mm256_alignr_epi8(m5, m0, 8);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_8_4(b0)               \
+    do {                                       \
+        t0 = _mm256_blend_epi32(m3, m1, 0x33); \
+        t1 = m2;                               \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_9_1(b0)               \
+    do {                                       \
+        t0 = _mm256_unpacklo_epi64(m5, m4);    \
+        t1 = _mm256_unpackhi_epi64(m3, m0);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_9_2(b0)               \
+    do {                                       \
+        t0 = _mm256_unpacklo_epi64(m1, m2);    \
+        t1 = _mm256_blend_epi32(m2, m3, 0x33); \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_9_3(b0)               \
+    do {                                       \
+        t0 = _mm256_unpackhi_epi64(m7, m4);    \
+        t1 = _mm256_unpackhi_epi64(m1, m6);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_9_4(b0)               \
+    do {                                       \
+        t0 = _mm256_alignr_epi8(m7, m5, 8);    \
+        t1 = _mm256_unpacklo_epi64(m6, m0);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_10_1(b0)              \
+    do {                                       \
+        t0 = _mm256_unpacklo_epi64(m0, m1);    \
+        t1 = _mm256_unpacklo_epi64(m2, m3);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_10_2(b0)              \
+    do {                                       \
+        t0 = _mm256_unpackhi_epi64(m0, m1);    \
+        t1 = _mm256_unpackhi_epi64(m2, m3);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_10_3(b0)              \
+    do {                                       \
+        t0 = _mm256_unpacklo_epi64(m4, m5);    \
+        t1 = _mm256_unpacklo_epi64(m6, m7);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_10_4(b0)              \
+    do {                                       \
+        t0 = _mm256_unpackhi_epi64(m4, m5);    \
+        t1 = _mm256_unpackhi_epi64(m6, m7);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_11_1(b0)              \
+    do {                                       \
+        t0 = _mm256_unpacklo_epi64(m7, m2);    \
+        t1 = _mm256_unpackhi_epi64(m4, m6);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_11_2(b0)              \
+    do {                                       \
+        t0 = _mm256_unpacklo_epi64(m5, m4);    \
+        t1 = _mm256_alignr_epi8(m3, m7, 8);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_11_3(b0)                               \
+    do {                                                        \
+        t0 = _mm256_shuffle_epi32(m0, _MM_SHUFFLE(1, 0, 3, 2)); \
+        t1 = _mm256_unpackhi_epi64(m5, m2);                     \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0);                  \
+    } while (0)
+
+#define BLAKE2B_LOAD_MSG_11_4(b0)              \
+    do {                                       \
+        t0 = _mm256_unpacklo_epi64(m6, m1);    \
+        t1 = _mm256_unpackhi_epi64(m3, m1);    \
+        b0 = _mm256_blend_epi32(t0, t1, 0xF0); \
+    } while (0)
+
+#endif