[llvm-branch-commits] [llvm] [Support] Integrate SipHash.cpp into libSupport. (PR #94394)

Ahmed Bougacha via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Fri Jun 14 16:53:09 PDT 2024 

https://github.com/ahmedbougacha updated https://github.com/llvm/llvm-project/pull/94394

>From 1e9a3fde97d907c3cd6be33db91d1c18c7236ffb Mon Sep 17 00:00:00 2001
From: Ahmed Bougacha <ahmed at bougacha.org>
Date: Tue, 4 Jun 2024 12:41:47 -0700
Subject: [PATCH 1/8] [Support] Reformat SipHash.cpp to match libSupport.

While there, give it our usual file header and an acknowledgement,
and remove the imported README.md.SipHash.
---
 llvm/lib/Support/README.md.SipHash | 126 --------------
 llvm/lib/Support/SipHash.cpp       | 264 ++++++++++++++---------------
 2 files changed, 129 insertions(+), 261 deletions(-)
 delete mode 100644 llvm/lib/Support/README.md.SipHash

diff --git a/llvm/lib/Support/README.md.SipHash b/llvm/lib/Support/README.md.SipHash
deleted file mode 100644
index 4de3cd1854681..0000000000000
--- a/llvm/lib/Support/README.md.SipHash
+++ /dev/null
@@ -1,126 +0,0 @@
-# SipHash
-
-[![License:
-CC0-1.0](https://licensebuttons.net/l/zero/1.0/80x15.png)](http://creativecommons.org/publicdomain/zero/1.0/)
-
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
-
-SipHash is a family of pseudorandom functions (PRFs) optimized for speed on short messages.
-This is the reference C code of SipHash: portable, simple, optimized for clarity and debugging.
-
-SipHash was designed in 2012 by [Jean-Philippe Aumasson](https://aumasson.jp)
-and [Daniel J. Bernstein](https://cr.yp.to) as a defense against [hash-flooding
-DoS attacks](https://aumasson.jp/siphash/siphashdos_29c3_slides.pdf).
-
-SipHash is:
-
-* *Simpler and faster* on short messages than previous cryptographic
-algorithms, such as MACs based on universal hashing.
-
-* *Competitive in performance* with insecure non-cryptographic algorithms, such as [fhhash](https://github.com/cbreeden/fxhash).
-
-* *Cryptographically secure*, with no sign of weakness despite multiple [cryptanalysis](https://eprint.iacr.org/2019/865) [projects](https://eprint.iacr.org/2019/865) by leading cryptographers.
-
-* *Battle-tested*, with successful integration in OSs (Linux kernel, OpenBSD,
-FreeBSD, FreeRTOS), languages (Perl, Python, Ruby, etc.), libraries (OpenSSL libcrypto,
-Sodium, etc.) and applications (Wireguard, Redis, etc.).
-
-As a secure pseudorandom function (a.k.a. keyed hash function), SipHash can also be used as a secure message authentication code (MAC).
-But SipHash is *not a hash* in the sense of general-purpose key-less hash function such as BLAKE3 or SHA-3.
-SipHash should therefore always be used with a secret key in order to be secure.
-
-
-## Variants
-
-The default SipHash is *SipHash-2-4*: it takes a 128-bit key, does 2 compression
-rounds, 4 finalization rounds, and returns a 64-bit tag.
-
-Variants can use a different number of rounds. For example, we proposed *SipHash-4-8* as a conservative version.
-
-The following versions are not described in the paper but were designed and analyzed to fulfill applications' needs:
-
-* *SipHash-128* returns a 128-bit tag instead of 64-bit. Versions with specified number of rounds are SipHash-2-4-128, SipHash4-8-128, and so on.
-
-* *HalfSipHash* works with 32-bit words instead of 64-bit, takes a 64-bit key,
-and returns 32-bit or 64-bit tags. For example, HalfSipHash-2-4-32 has 2
-compression rounds, 4 finalization rounds, and returns a 32-bit tag.
-
-
-## Security
-
-(Half)SipHash-*c*-*d* with *c* ≥ 2 and *d* ≥ 4 is expected to provide the maximum PRF
-security for any function with the same key and output size.
-
-The standard PRF security goal allow the attacker access to the output of SipHash on messages chosen adaptively by the attacker.
-
-Security is limited by the key size (128 bits for SipHash), such that
-attackers searching 2<sup>*s*</sup> keys have chance 2<sup>*s*−128</sup> of finding
-the SipHash key. 
-Security is also limited by the output size. In particular, when
-SipHash is used as a MAC, an attacker who blindly tries 2<sup>*s*</sup> tags will
-succeed with probability 2<sup>*s*-*t*</sup>, if *t* is that tag's bit size.
-
-
-## Research
-
-* [Research paper](https://www.aumasson.jp/siphash/siphash.pdf) "SipHash: a fast short-input PRF" (accepted at INDOCRYPT 2012)
-* [Slides](https://cr.yp.to/talks/2012.12.12/slides.pdf) of the presentation of SipHash at INDOCRYPT 2012 (Bernstein)
-* [Slides](https://www.aumasson.jp/siphash/siphash_slides.pdf) of the presentation of SipHash at the DIAC workshop (Aumasson)
-
-
-## Usage
-
-Running
-
-```sh
-  make
-```
-
-will build tests for 
-
-* SipHash-2-4-64
-* SipHash-2-4-128
-* HalfSipHash-2-4-32
-* HalfSipHash-2-4-64
-
-
-```C
-  ./test
-```
-
-verifies 64 test vectors, and
-
-```C
-  ./debug
-```
-
-does the same and prints intermediate values.
-
-The code can be adapted to implement SipHash-*c*-*d*, the version of SipHash
-with *c* compression rounds and *d* finalization rounds, by defining `cROUNDS`
-or `dROUNDS` when compiling.  This can be done with `-D` command line arguments
-to many compilers such as below.
-
-```sh
-gcc -Wall --std=c99 -DcROUNDS=2 -DdROUNDS=4 siphash.c halfsiphash.c test.c -o test
-```
-
-The `makefile` also takes *c* and *d* rounds values as parameters.
-
-```sh
-make cROUNDS=2 dROUNDS=4
-``` 
-
-Obviously, if the number of rounds is modified then the test vectors
-won't verify.
-
-## Intellectual property
-
-This code is copyright (c) 2014-2023 Jean-Philippe Aumasson, Daniel J.
-Bernstein. It is multi-licensed under
-
-* [CC0](./LICENCE_CC0)
-* [MIT](./LICENSE_MIT).
-* [Apache 2.0 with LLVM exceptions](./LICENSE_A2LLVM).
-
diff --git a/llvm/lib/Support/SipHash.cpp b/llvm/lib/Support/SipHash.cpp
index c6d16e205521d..f31023740011f 100644
--- a/llvm/lib/Support/SipHash.cpp
+++ b/llvm/lib/Support/SipHash.cpp
@@ -1,25 +1,19 @@
-/*
-   SipHash reference C implementation
-
-   Copyright (c) 2012-2022 Jean-Philippe Aumasson
-   <jeanphilippe.aumasson at gmail.com>
-   Copyright (c) 2012-2014 Daniel J. Bernstein <djb at cr.yp.to>
-
-   To the extent possible under law, the author(s) have dedicated all copyright
-   and related and neighboring rights to this software to the public domain
-   worldwide. This software is distributed without any warranty.
-
-   You should have received a copy of the CC0 Public Domain Dedication along
-   with
-   this software. If not, see
-   <http://creativecommons.org/publicdomain/zero/1.0/>.
- */
+//===--- SipHash.cpp - An ABI-stable string hash --------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
 
 #include "siphash.h"
 #include <assert.h>
 #include <stddef.h>
 #include <stdint.h>
 
+// Lightly adapted from the SipHash reference C implementation by
+// Jean-Philippe Aumasson and Daniel J. Bernstein.
+
 /* default: SipHash-2-4 */
 #ifndef cROUNDS
 #define cROUNDS 2
@@ -31,49 +25,49 @@
 #define ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b))))
 
 #define U32TO8_LE(p, v)                                                        \
-    (p)[0] = (uint8_t)((v));                                                   \
-    (p)[1] = (uint8_t)((v) >> 8);                                              \
-    (p)[2] = (uint8_t)((v) >> 16);                                             \
-    (p)[3] = (uint8_t)((v) >> 24);
+  (p)[0] = (uint8_t)((v));                                                     \
+  (p)[1] = (uint8_t)((v) >> 8);                                                \
+  (p)[2] = (uint8_t)((v) >> 16);                                               \
+  (p)[3] = (uint8_t)((v) >> 24);
 
 #define U64TO8_LE(p, v)                                                        \
-    U32TO8_LE((p), (uint32_t)((v)));                                           \
-    U32TO8_LE((p) + 4, (uint32_t)((v) >> 32));
+  U32TO8_LE((p), (uint32_t)((v)));                                             \
+  U32TO8_LE((p) + 4, (uint32_t)((v) >> 32));
 
 #define U8TO64_LE(p)                                                           \
-    (((uint64_t)((p)[0])) | ((uint64_t)((p)[1]) << 8) |                        \
-     ((uint64_t)((p)[2]) << 16) | ((uint64_t)((p)[3]) << 24) |                 \
-     ((uint64_t)((p)[4]) << 32) | ((uint64_t)((p)[5]) << 40) |                 \
-     ((uint64_t)((p)[6]) << 48) | ((uint64_t)((p)[7]) << 56))
+  (((uint64_t)((p)[0])) | ((uint64_t)((p)[1]) << 8) |                          \
+   ((uint64_t)((p)[2]) << 16) | ((uint64_t)((p)[3]) << 24) |                   \
+   ((uint64_t)((p)[4]) << 32) | ((uint64_t)((p)[5]) << 40) |                   \
+   ((uint64_t)((p)[6]) << 48) | ((uint64_t)((p)[7]) << 56))
 
 #define SIPROUND                                                               \
-    do {                                                                       \
-        v0 += v1;                                                              \
-        v1 = ROTL(v1, 13);                                                     \
-        v1 ^= v0;                                                              \
-        v0 = ROTL(v0, 32);                                                     \
-        v2 += v3;                                                              \
-        v3 = ROTL(v3, 16);                                                     \
-        v3 ^= v2;                                                              \
-        v0 += v3;                                                              \
-        v3 = ROTL(v3, 21);                                                     \
-        v3 ^= v0;                                                              \
-        v2 += v1;                                                              \
-        v1 = ROTL(v1, 17);                                                     \
-        v1 ^= v2;                                                              \
-        v2 = ROTL(v2, 32);                                                     \
-    } while (0)
+  do {                                                                         \
+    v0 += v1;                                                                  \
+    v1 = ROTL(v1, 13);                                                         \
+    v1 ^= v0;                                                                  \
+    v0 = ROTL(v0, 32);                                                         \
+    v2 += v3;                                                                  \
+    v3 = ROTL(v3, 16);                                                         \
+    v3 ^= v2;                                                                  \
+    v0 += v3;                                                                  \
+    v3 = ROTL(v3, 21);                                                         \
+    v3 ^= v0;                                                                  \
+    v2 += v1;                                                                  \
+    v1 = ROTL(v1, 17);                                                         \
+    v1 ^= v2;                                                                  \
+    v2 = ROTL(v2, 32);                                                         \
+  } while (0)
 
 #ifdef DEBUG_SIPHASH
 #include <stdio.h>
 
 #define TRACE                                                                  \
-    do {                                                                       \
-        printf("(%3zu) v0 %016" PRIx64 "\n", inlen, v0);                       \
-        printf("(%3zu) v1 %016" PRIx64 "\n", inlen, v1);                       \
-        printf("(%3zu) v2 %016" PRIx64 "\n", inlen, v2);                       \
-        printf("(%3zu) v3 %016" PRIx64 "\n", inlen, v3);                       \
-    } while (0)
+  do {                                                                         \
+    printf("(%3zu) v0 %016" PRIx64 "\n", inlen, v0);                           \
+    printf("(%3zu) v1 %016" PRIx64 "\n", inlen, v1);                           \
+    printf("(%3zu) v2 %016" PRIx64 "\n", inlen, v2);                           \
+    printf("(%3zu) v3 %016" PRIx64 "\n", inlen, v3);                           \
+  } while (0)
 #else
 #define TRACE
 #endif
@@ -82,104 +76,104 @@
     Computes a SipHash value
     *in: pointer to input data (read-only)
     inlen: input data length in bytes (any size_t value)
-    *k: pointer to the key data (read-only), must be 16 bytes 
+    *k: pointer to the key data (read-only), must be 16 bytes
     *out: pointer to output data (write-only), outlen bytes must be allocated
     outlen: length of the output in bytes, must be 8 or 16
 */
 int siphash(const void *in, const size_t inlen, const void *k, uint8_t *out,
             const size_t outlen) {
 
-    const unsigned char *ni = (const unsigned char *)in;
-    const unsigned char *kk = (const unsigned char *)k;
-
-    assert((outlen == 8) || (outlen == 16));
-    uint64_t v0 = UINT64_C(0x736f6d6570736575);
-    uint64_t v1 = UINT64_C(0x646f72616e646f6d);
-    uint64_t v2 = UINT64_C(0x6c7967656e657261);
-    uint64_t v3 = UINT64_C(0x7465646279746573);
-    uint64_t k0 = U8TO64_LE(kk);
-    uint64_t k1 = U8TO64_LE(kk + 8);
-    uint64_t m;
-    int i;
-    const unsigned char *end = ni + inlen - (inlen % sizeof(uint64_t));
-    const int left = inlen & 7;
-    uint64_t b = ((uint64_t)inlen) << 56;
-    v3 ^= k1;
-    v2 ^= k0;
-    v1 ^= k1;
-    v0 ^= k0;
-
-    if (outlen == 16)
-        v1 ^= 0xee;
-
-    for (; ni != end; ni += 8) {
-        m = U8TO64_LE(ni);
-        v3 ^= m;
-
-        TRACE;
-        for (i = 0; i < cROUNDS; ++i)
-            SIPROUND;
-
-        v0 ^= m;
-    }
-
-    switch (left) {
-    case 7:
-        b |= ((uint64_t)ni[6]) << 48;
-        /* FALLTHRU */
-    case 6:
-        b |= ((uint64_t)ni[5]) << 40;
-        /* FALLTHRU */
-    case 5:
-        b |= ((uint64_t)ni[4]) << 32;
-        /* FALLTHRU */
-    case 4:
-        b |= ((uint64_t)ni[3]) << 24;
-        /* FALLTHRU */
-    case 3:
-        b |= ((uint64_t)ni[2]) << 16;
-        /* FALLTHRU */
-    case 2:
-        b |= ((uint64_t)ni[1]) << 8;
-        /* FALLTHRU */
-    case 1:
-        b |= ((uint64_t)ni[0]);
-        break;
-    case 0:
-        break;
-    }
-
-    v3 ^= b;
+  const unsigned char *ni = (const unsigned char *)in;
+  const unsigned char *kk = (const unsigned char *)k;
+
+  assert((outlen == 8) || (outlen == 16));
+  uint64_t v0 = UINT64_C(0x736f6d6570736575);
+  uint64_t v1 = UINT64_C(0x646f72616e646f6d);
+  uint64_t v2 = UINT64_C(0x6c7967656e657261);
+  uint64_t v3 = UINT64_C(0x7465646279746573);
+  uint64_t k0 = U8TO64_LE(kk);
+  uint64_t k1 = U8TO64_LE(kk + 8);
+  uint64_t m;
+  int i;
+  const unsigned char *end = ni + inlen - (inlen % sizeof(uint64_t));
+  const int left = inlen & 7;
+  uint64_t b = ((uint64_t)inlen) << 56;
+  v3 ^= k1;
+  v2 ^= k0;
+  v1 ^= k1;
+  v0 ^= k0;
+
+  if (outlen == 16)
+    v1 ^= 0xee;
+
+  for (; ni != end; ni += 8) {
+    m = U8TO64_LE(ni);
+    v3 ^= m;
 
     TRACE;
     for (i = 0; i < cROUNDS; ++i)
-        SIPROUND;
-
-    v0 ^= b;
-
-    if (outlen == 16)
-        v2 ^= 0xee;
-    else
-        v2 ^= 0xff;
-
-    TRACE;
-    for (i = 0; i < dROUNDS; ++i)
-        SIPROUND;
-
-    b = v0 ^ v1 ^ v2 ^ v3;
-    U64TO8_LE(out, b);
-
-    if (outlen == 8)
-        return 0;
+      SIPROUND;
+
+    v0 ^= m;
+  }
+
+  switch (left) {
+  case 7:
+    b |= ((uint64_t)ni[6]) << 48;
+    /* FALLTHRU */
+  case 6:
+    b |= ((uint64_t)ni[5]) << 40;
+    /* FALLTHRU */
+  case 5:
+    b |= ((uint64_t)ni[4]) << 32;
+    /* FALLTHRU */
+  case 4:
+    b |= ((uint64_t)ni[3]) << 24;
+    /* FALLTHRU */
+  case 3:
+    b |= ((uint64_t)ni[2]) << 16;
+    /* FALLTHRU */
+  case 2:
+    b |= ((uint64_t)ni[1]) << 8;
+    /* FALLTHRU */
+  case 1:
+    b |= ((uint64_t)ni[0]);
+    break;
+  case 0:
+    break;
+  }
+
+  v3 ^= b;
+
+  TRACE;
+  for (i = 0; i < cROUNDS; ++i)
+    SIPROUND;
+
+  v0 ^= b;
+
+  if (outlen == 16)
+    v2 ^= 0xee;
+  else
+    v2 ^= 0xff;
+
+  TRACE;
+  for (i = 0; i < dROUNDS; ++i)
+    SIPROUND;
+
+  b = v0 ^ v1 ^ v2 ^ v3;
+  U64TO8_LE(out, b);
+
+  if (outlen == 8)
+    return 0;
 
-    v1 ^= 0xdd;
+  v1 ^= 0xdd;
 
-    TRACE;
-    for (i = 0; i < dROUNDS; ++i)
-        SIPROUND;
+  TRACE;
+  for (i = 0; i < dROUNDS; ++i)
+    SIPROUND;
 
-    b = v0 ^ v1 ^ v2 ^ v3;
-    U64TO8_LE(out + 8, b);
+  b = v0 ^ v1 ^ v2 ^ v3;
+  U64TO8_LE(out + 8, b);
 
-    return 0;
+  return 0;
 }

>From 3d4f7dcaf8e9c4ad666f84b4ba7c8c742c336896 Mon Sep 17 00:00:00 2001
From: Ahmed Bougacha <ahmed at bougacha.org>
Date: Tue, 4 Jun 2024 12:45:37 -0700
Subject: [PATCH 2/8] [Support] Remove SipHash tracing support.

---
 llvm/lib/Support/SipHash.cpp | 18 ------------------
 1 file changed, 18 deletions(-)

diff --git a/llvm/lib/Support/SipHash.cpp b/llvm/lib/Support/SipHash.cpp
index f31023740011f..b7cc692b7d6b4 100644
--- a/llvm/lib/Support/SipHash.cpp
+++ b/llvm/lib/Support/SipHash.cpp
@@ -58,20 +58,6 @@
     v2 = ROTL(v2, 32);                                                         \
   } while (0)
 
-#ifdef DEBUG_SIPHASH
-#include <stdio.h>
-
-#define TRACE                                                                  \
-  do {                                                                         \
-    printf("(%3zu) v0 %016" PRIx64 "\n", inlen, v0);                           \
-    printf("(%3zu) v1 %016" PRIx64 "\n", inlen, v1);                           \
-    printf("(%3zu) v2 %016" PRIx64 "\n", inlen, v2);                           \
-    printf("(%3zu) v3 %016" PRIx64 "\n", inlen, v3);                           \
-  } while (0)
-#else
-#define TRACE
-#endif
-
 /*
     Computes a SipHash value
     *in: pointer to input data (read-only)
@@ -110,7 +96,6 @@ int siphash(const void *in, const size_t inlen, const void *k, uint8_t *out,
     m = U8TO64_LE(ni);
     v3 ^= m;
 
-    TRACE;
     for (i = 0; i < cROUNDS; ++i)
       SIPROUND;
 
@@ -145,7 +130,6 @@ int siphash(const void *in, const size_t inlen, const void *k, uint8_t *out,
 
   v3 ^= b;
 
-  TRACE;
   for (i = 0; i < cROUNDS; ++i)
     SIPROUND;
 
@@ -156,7 +140,6 @@ int siphash(const void *in, const size_t inlen, const void *k, uint8_t *out,
   else
     v2 ^= 0xff;
 
-  TRACE;
   for (i = 0; i < dROUNDS; ++i)
     SIPROUND;
 
@@ -168,7 +151,6 @@ int siphash(const void *in, const size_t inlen, const void *k, uint8_t *out,
 
   v1 ^= 0xdd;
 
-  TRACE;
   for (i = 0; i < dROUNDS; ++i)
     SIPROUND;
 

>From 6679d54b2d1b037c849aea3cf04507e5390adc49 Mon Sep 17 00:00:00 2001
From: Ahmed Bougacha <ahmed at bougacha.org>
Date: Tue, 4 Jun 2024 12:48:11 -0700
Subject: [PATCH 3/8] [Support] Integrate SipHash.cpp into libSupport.

Start building it as part of the library, with some minor
tweaks compared to the reference implementation:
- templatize cROUNDS/dROUNDS, as well as 8B/16B result type
- replace assert with static_assert
- return the result directly, as uint64_t/uint128_t
- remove big-endian support
- use LLVM_FALLTHROUGH

The siphash function itself isn't used yet, and will be in a follow-up
commit.
---
 llvm/lib/Support/CMakeLists.txt |  4 +-
 llvm/lib/Support/SipHash.cpp    | 66 ++++++++++-----------------------
 2 files changed, 21 insertions(+), 49 deletions(-)

diff --git a/llvm/lib/Support/CMakeLists.txt b/llvm/lib/Support/CMakeLists.txt
index 7cc01a5399911..f5f8447d48d01 100644
--- a/llvm/lib/Support/CMakeLists.txt
+++ b/llvm/lib/Support/CMakeLists.txt
@@ -127,9 +127,6 @@ endif()
 
 add_subdirectory(BLAKE3)
 
-# Temporarily ignore SipHash.cpp before we fully integrate it into LLVMSupport.
-set(LLVM_OPTIONAL_SOURCES SipHash.cpp)
-
 add_llvm_component_library(LLVMSupport
   ABIBreak.cpp
   AMDGPUMetadata.cpp
@@ -226,6 +223,7 @@ add_llvm_component_library(LLVMSupport
   SHA1.cpp
   SHA256.cpp
   Signposts.cpp
+  SipHash.cpp
   SmallPtrSet.cpp
   SmallVector.cpp
   SourceMgr.cpp
diff --git a/llvm/lib/Support/SipHash.cpp b/llvm/lib/Support/SipHash.cpp
index b7cc692b7d6b4..ef882ae4d8745 100644
--- a/llvm/lib/Support/SipHash.cpp
+++ b/llvm/lib/Support/SipHash.cpp
@@ -6,34 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "siphash.h"
-#include <assert.h>
-#include <stddef.h>
-#include <stdint.h>
+#include "llvm/Support/Compiler.h"
+#include <cstdint>
 
 // Lightly adapted from the SipHash reference C implementation by
 // Jean-Philippe Aumasson and Daniel J. Bernstein.
 
-/* default: SipHash-2-4 */
-#ifndef cROUNDS
-#define cROUNDS 2
-#endif
-#ifndef dROUNDS
-#define dROUNDS 4
-#endif
-
 #define ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b))))
 
-#define U32TO8_LE(p, v)                                                        \
-  (p)[0] = (uint8_t)((v));                                                     \
-  (p)[1] = (uint8_t)((v) >> 8);                                                \
-  (p)[2] = (uint8_t)((v) >> 16);                                               \
-  (p)[3] = (uint8_t)((v) >> 24);
-
-#define U64TO8_LE(p, v)                                                        \
-  U32TO8_LE((p), (uint32_t)((v)));                                             \
-  U32TO8_LE((p) + 4, (uint32_t)((v) >> 32));
-
 #define U8TO64_LE(p)                                                           \
   (((uint64_t)((p)[0])) | ((uint64_t)((p)[1]) << 8) |                          \
    ((uint64_t)((p)[2]) << 16) | ((uint64_t)((p)[3]) << 24) |                   \
@@ -58,21 +38,15 @@
     v2 = ROTL(v2, 32);                                                         \
   } while (0)
 
-/*
-    Computes a SipHash value
-    *in: pointer to input data (read-only)
-    inlen: input data length in bytes (any size_t value)
-    *k: pointer to the key data (read-only), must be 16 bytes
-    *out: pointer to output data (write-only), outlen bytes must be allocated
-    outlen: length of the output in bytes, must be 8 or 16
-*/
-int siphash(const void *in, const size_t inlen, const void *k, uint8_t *out,
-            const size_t outlen) {
+template <int cROUNDS, int dROUNDS, class ResultTy>
+static inline ResultTy siphash(const unsigned char *in, uint64_t inlen,
+                               const unsigned char (&k)[16]) {
 
   const unsigned char *ni = (const unsigned char *)in;
   const unsigned char *kk = (const unsigned char *)k;
 
-  assert((outlen == 8) || (outlen == 16));
+  static_assert(sizeof(ResultTy) == 8 || sizeof(ResultTy) == 16,
+                "result type should be uint64_t or uint128_t");
   uint64_t v0 = UINT64_C(0x736f6d6570736575);
   uint64_t v1 = UINT64_C(0x646f72616e646f6d);
   uint64_t v2 = UINT64_C(0x6c7967656e657261);
@@ -89,7 +63,7 @@ int siphash(const void *in, const size_t inlen, const void *k, uint8_t *out,
   v1 ^= k1;
   v0 ^= k0;
 
-  if (outlen == 16)
+  if (sizeof(ResultTy) == 16)
     v1 ^= 0xee;
 
   for (; ni != end; ni += 8) {
@@ -105,22 +79,22 @@ int siphash(const void *in, const size_t inlen, const void *k, uint8_t *out,
   switch (left) {
   case 7:
     b |= ((uint64_t)ni[6]) << 48;
-    /* FALLTHRU */
+    LLVM_FALLTHROUGH;
   case 6:
     b |= ((uint64_t)ni[5]) << 40;
-    /* FALLTHRU */
+    LLVM_FALLTHROUGH;
   case 5:
     b |= ((uint64_t)ni[4]) << 32;
-    /* FALLTHRU */
+    LLVM_FALLTHROUGH;
   case 4:
     b |= ((uint64_t)ni[3]) << 24;
-    /* FALLTHRU */
+    LLVM_FALLTHROUGH;
   case 3:
     b |= ((uint64_t)ni[2]) << 16;
-    /* FALLTHRU */
+    LLVM_FALLTHROUGH;
   case 2:
     b |= ((uint64_t)ni[1]) << 8;
-    /* FALLTHRU */
+    LLVM_FALLTHROUGH;
   case 1:
     b |= ((uint64_t)ni[0]);
     break;
@@ -135,7 +109,7 @@ int siphash(const void *in, const size_t inlen, const void *k, uint8_t *out,
 
   v0 ^= b;
 
-  if (outlen == 16)
+  if (sizeof(ResultTy) == 16)
     v2 ^= 0xee;
   else
     v2 ^= 0xff;
@@ -144,10 +118,10 @@ int siphash(const void *in, const size_t inlen, const void *k, uint8_t *out,
     SIPROUND;
 
   b = v0 ^ v1 ^ v2 ^ v3;
-  U64TO8_LE(out, b);
 
-  if (outlen == 8)
-    return 0;
+  uint64_t firstHalf = b;
+  if (sizeof(ResultTy) == 8)
+    return firstHalf;
 
   v1 ^= 0xdd;
 
@@ -155,7 +129,7 @@ int siphash(const void *in, const size_t inlen, const void *k, uint8_t *out,
     SIPROUND;
 
   b = v0 ^ v1 ^ v2 ^ v3;
-  U64TO8_LE(out + 8, b);
+  uint64_t secondHalf = b;
 
-  return 0;
+  return firstHalf | (ResultTy(secondHalf) << (sizeof(ResultTy) == 8 ? 0 : 64));
 }

>From acb8f3c319165bac2315cabe735cd8beccac046e Mon Sep 17 00:00:00 2001
From: Ahmed Bougacha <ahmed at bougacha.org>
Date: Wed, 5 Jun 2024 10:12:28 -0700
Subject: [PATCH 4/8] Address review feedback.

- add back github link to ref. impl.
- add back function doc comment
- use anon. namespace
- use constexpr outlen, avoid or workaround
---
 llvm/lib/Support/SipHash.cpp | 34 ++++++++++++++++++++++++----------
 1 file changed, 24 insertions(+), 10 deletions(-)

diff --git a/llvm/lib/Support/SipHash.cpp b/llvm/lib/Support/SipHash.cpp
index ef882ae4d8745..fe6c28de2f591 100644
--- a/llvm/lib/Support/SipHash.cpp
+++ b/llvm/lib/Support/SipHash.cpp
@@ -9,8 +9,9 @@
 #include "llvm/Support/Compiler.h"
 #include <cstdint>
 
-// Lightly adapted from the SipHash reference C implementation by
-// Jean-Philippe Aumasson and Daniel J. Bernstein.
+// Lightly adapted from the SipHash reference C implementation:
+//   https://github.com/veorq/SipHash
+// by Jean-Philippe Aumasson and Daniel J. Bernstein
 
 #define ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b))))
 
@@ -38,15 +39,26 @@
     v2 = ROTL(v2, 32);                                                         \
   } while (0)
 
+namespace {
+
+/// Computes a SipHash value
+///
+/// \param in: pointer to input data (read-only)
+/// \param inlen: input data length in bytes (any size_t value)
+/// \param k: reference to the key data 16-byte array (read-only)
+/// \returns output data, must be 8 or 16 bytes
+///
 template <int cROUNDS, int dROUNDS, class ResultTy>
-static inline ResultTy siphash(const unsigned char *in, uint64_t inlen,
-                               const unsigned char (&k)[16]) {
+ResultTy siphash(const unsigned char *in, uint64_t inlen,
+                 const unsigned char (&k)[16]) {
 
   const unsigned char *ni = (const unsigned char *)in;
   const unsigned char *kk = (const unsigned char *)k;
 
-  static_assert(sizeof(ResultTy) == 8 || sizeof(ResultTy) == 16,
+  constexpr size_t outlen = sizeof(ResultTy);
+  static_assert(outlen == 8 || outlen == 16,
                 "result type should be uint64_t or uint128_t");
+
   uint64_t v0 = UINT64_C(0x736f6d6570736575);
   uint64_t v1 = UINT64_C(0x646f72616e646f6d);
   uint64_t v2 = UINT64_C(0x6c7967656e657261);
@@ -63,7 +75,7 @@ static inline ResultTy siphash(const unsigned char *in, uint64_t inlen,
   v1 ^= k1;
   v0 ^= k0;
 
-  if (sizeof(ResultTy) == 16)
+  if (outlen == 16)
     v1 ^= 0xee;
 
   for (; ni != end; ni += 8) {
@@ -109,7 +121,7 @@ static inline ResultTy siphash(const unsigned char *in, uint64_t inlen,
 
   v0 ^= b;
 
-  if (sizeof(ResultTy) == 16)
+  if (outlen == 16)
     v2 ^= 0xee;
   else
     v2 ^= 0xff;
@@ -118,9 +130,9 @@ static inline ResultTy siphash(const unsigned char *in, uint64_t inlen,
     SIPROUND;
 
   b = v0 ^ v1 ^ v2 ^ v3;
-
   uint64_t firstHalf = b;
-  if (sizeof(ResultTy) == 8)
+
+  if (outlen == 8)
     return firstHalf;
 
   v1 ^= 0xdd;
@@ -131,5 +143,7 @@ static inline ResultTy siphash(const unsigned char *in, uint64_t inlen,
   b = v0 ^ v1 ^ v2 ^ v3;
   uint64_t secondHalf = b;
 
-  return firstHalf | (ResultTy(secondHalf) << (sizeof(ResultTy) == 8 ? 0 : 64));
+  return firstHalf | (ResultTy(secondHalf) << 64);
 }
+
+} // end anonymous namespace

>From 644b473fa7d0382b035d4dfd2ea4ed88fcd97233 Mon Sep 17 00:00:00 2001
From: Ahmed Bougacha <ahmed at bougacha.org>
Date: Tue, 11 Jun 2024 15:36:33 -0700
Subject: [PATCH 5/8] Return result indirectly to bring back big-endian host
 support.

Use endian::support to do the appropriate swaps.

Returning the result as a value was convenient but int128 types and
big-endian hosts don't mix well.  We don't have 128-bit byteswap, and
it's not something that would even be usable, because int128 can be
returned with the 64-bit halves in little-endian order.  I don't know
that we can confidently rely on this being always true, so just define
away this whole problem; we don't need the doubled/16-byte result here
anyway.
---
 llvm/lib/Support/SipHash.cpp | 34 ++++++++++++++--------------------
 1 file changed, 14 insertions(+), 20 deletions(-)

diff --git a/llvm/lib/Support/SipHash.cpp b/llvm/lib/Support/SipHash.cpp
index fe6c28de2f591..44cde6b5b9594 100644
--- a/llvm/lib/Support/SipHash.cpp
+++ b/llvm/lib/Support/SipHash.cpp
@@ -7,20 +7,18 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Compiler.h"
+#include "llvm/Support/Endian.h"
 #include <cstdint>
 
+using namespace llvm;
+using namespace support;
+
 // Lightly adapted from the SipHash reference C implementation:
 //   https://github.com/veorq/SipHash
 // by Jean-Philippe Aumasson and Daniel J. Bernstein
 
 #define ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b))))
 
-#define U8TO64_LE(p)                                                           \
-  (((uint64_t)((p)[0])) | ((uint64_t)((p)[1]) << 8) |                          \
-   ((uint64_t)((p)[2]) << 16) | ((uint64_t)((p)[3]) << 24) |                   \
-   ((uint64_t)((p)[4]) << 32) | ((uint64_t)((p)[5]) << 40) |                   \
-   ((uint64_t)((p)[6]) << 48) | ((uint64_t)((p)[7]) << 56))
-
 #define SIPROUND                                                               \
   do {                                                                         \
     v0 += v1;                                                                  \
@@ -48,23 +46,21 @@ namespace {
 /// \param k: reference to the key data 16-byte array (read-only)
 /// \returns output data, must be 8 or 16 bytes
 ///
-template <int cROUNDS, int dROUNDS, class ResultTy>
-ResultTy siphash(const unsigned char *in, uint64_t inlen,
-                 const unsigned char (&k)[16]) {
+template <int cROUNDS, int dROUNDS, size_t outlen>
+void siphash(const unsigned char *in, uint64_t inlen,
+             const unsigned char (&k)[16], unsigned char (&out)[outlen]) {
 
   const unsigned char *ni = (const unsigned char *)in;
   const unsigned char *kk = (const unsigned char *)k;
 
-  constexpr size_t outlen = sizeof(ResultTy);
-  static_assert(outlen == 8 || outlen == 16,
-                "result type should be uint64_t or uint128_t");
+  static_assert(outlen == 8 || outlen == 16, "result should be 8 or 16 bytes");
 
   uint64_t v0 = UINT64_C(0x736f6d6570736575);
   uint64_t v1 = UINT64_C(0x646f72616e646f6d);
   uint64_t v2 = UINT64_C(0x6c7967656e657261);
   uint64_t v3 = UINT64_C(0x7465646279746573);
-  uint64_t k0 = U8TO64_LE(kk);
-  uint64_t k1 = U8TO64_LE(kk + 8);
+  uint64_t k0 = endian::read64le(kk);
+  uint64_t k1 = endian::read64le(kk + 8);
   uint64_t m;
   int i;
   const unsigned char *end = ni + inlen - (inlen % sizeof(uint64_t));
@@ -79,7 +75,7 @@ ResultTy siphash(const unsigned char *in, uint64_t inlen,
     v1 ^= 0xee;
 
   for (; ni != end; ni += 8) {
-    m = U8TO64_LE(ni);
+    m = endian::read64le(ni);
     v3 ^= m;
 
     for (i = 0; i < cROUNDS; ++i)
@@ -130,10 +126,10 @@ ResultTy siphash(const unsigned char *in, uint64_t inlen,
     SIPROUND;
 
   b = v0 ^ v1 ^ v2 ^ v3;
-  uint64_t firstHalf = b;
+  endian::write64le(out, b);
 
   if (outlen == 8)
-    return firstHalf;
+    return;
 
   v1 ^= 0xdd;
 
@@ -141,9 +137,7 @@ ResultTy siphash(const unsigned char *in, uint64_t inlen,
     SIPROUND;
 
   b = v0 ^ v1 ^ v2 ^ v3;
-  uint64_t secondHalf = b;
-
-  return firstHalf | (ResultTy(secondHalf) << 64);
+  endian::write64le(out + 8, b);
 }
 
 } // end anonymous namespace

>From 37c84b9dce70f40db8a7c27b7de8232c4d10f78f Mon Sep 17 00:00:00 2001
From: Ahmed Bougacha <ahmed at bougacha.org>
Date: Thu, 13 Jun 2024 15:03:03 -0700
Subject: [PATCH 6/8] Export interfaces for SipHash-2-4-64/-128, and test using
 ref. vectors.

---
 llvm/include/llvm/Support/SipHash.h    |  31 ++++
 llvm/lib/Support/SipHash.cpp           |  14 ++
 llvm/unittests/Support/CMakeLists.txt  |   1 +
 llvm/unittests/Support/SipHashTest.cpp | 247 +++++++++++++++++++++++++
 4 files changed, 293 insertions(+)
 create mode 100644 llvm/include/llvm/Support/SipHash.h
 create mode 100644 llvm/unittests/Support/SipHashTest.cpp

diff --git a/llvm/include/llvm/Support/SipHash.h b/llvm/include/llvm/Support/SipHash.h
new file mode 100644
index 0000000000000..c501d7ae70956
--- /dev/null
+++ b/llvm/include/llvm/Support/SipHash.h
@@ -0,0 +1,31 @@
+//===--- SipHash.h - An ABI-stable string SipHash ---------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// An implementation of SipHash, a hash function optimized for speed on
+// short inputs. Based on the SipHash reference implementation.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_SIPHASH_H
+#define LLVM_SUPPORT_SIPHASH_H
+
+#include <cstdint>
+
+namespace llvm {
+
+/// Computes a SipHash-2-4 64-bit result.
+void getSipHash_2_4_64(const uint8_t *In, uint64_t InLen,
+                       const uint8_t (&K)[16], uint8_t (&Out)[8]);
+
+/// Computes a SipHash-2-4 128-bit result.
+void getSipHash_2_4_128(const uint8_t *In, uint64_t InLen,
+                        const uint8_t (&K)[16], uint8_t (&Out)[16]);
+
+} // end namespace llvm
+
+#endif
diff --git a/llvm/lib/Support/SipHash.cpp b/llvm/lib/Support/SipHash.cpp
index 44cde6b5b9594..b4d52cda41861 100644
--- a/llvm/lib/Support/SipHash.cpp
+++ b/llvm/lib/Support/SipHash.cpp
@@ -141,3 +141,17 @@ void siphash(const unsigned char *in, uint64_t inlen,
 }
 
 } // end anonymous namespace
+
+namespace llvm {
+
+void getSipHash_2_4_64(const uint8_t *In, uint64_t InLen,
+                       const uint8_t (&K)[16], uint8_t (&Out)[8]) {
+  siphash<2, 4>(In, InLen, K, Out);
+}
+
+void getSipHash_2_4_128(const uint8_t *In, uint64_t InLen,
+                        const uint8_t (&K)[16], uint8_t (&Out)[16]) {
+  siphash<2, 4>(In, InLen, K, Out);
+}
+
+} // end namespace llvm
diff --git a/llvm/unittests/Support/CMakeLists.txt b/llvm/unittests/Support/CMakeLists.txt
index 2718be8450f80..631f2e6bf00df 100644
--- a/llvm/unittests/Support/CMakeLists.txt
+++ b/llvm/unittests/Support/CMakeLists.txt
@@ -75,6 +75,7 @@ add_llvm_unittest(SupportTests
   ScopedPrinterTest.cpp
   SHA256.cpp
   SignalsTest.cpp
+  SipHashTest.cpp
   SourceMgrTest.cpp
   SpecialCaseListTest.cpp
   SuffixTreeTest.cpp
diff --git a/llvm/unittests/Support/SipHashTest.cpp b/llvm/unittests/Support/SipHashTest.cpp
new file mode 100644
index 0000000000000..4d9d5da15956c
--- /dev/null
+++ b/llvm/unittests/Support/SipHashTest.cpp
@@ -0,0 +1,247 @@
+//===- llvm/unittest/Support/SipHashTest.cpp ------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/SipHash.h"
+#include "gtest/gtest.h"
+#include <string.h>
+
+using namespace llvm;
+
+namespace {
+
+// Test vectors and harness from the SipHash reference implementation:
+//   https://github.com/veorq/SipHash
+// The below is lightly adapted from test.c/vectors.h.
+
+const uint8_t ExpectedSipHash64[64][8] = {
+    { 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, },
+    { 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, },
+    { 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d, },
+    { 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85, },
+    { 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf, },
+    { 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18, },
+    { 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb, },
+    { 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab, },
+    { 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93, },
+    { 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e, },
+    { 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a, },
+    { 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4, },
+    { 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75, },
+    { 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14, },
+    { 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7, },
+    { 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1, },
+    { 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f, },
+    { 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69, },
+    { 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b, },
+    { 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb, },
+    { 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe, },
+    { 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0, },
+    { 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93, },
+    { 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8, },
+    { 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8, },
+    { 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc, },
+    { 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17, },
+    { 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f, },
+    { 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde, },
+    { 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6, },
+    { 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad, },
+    { 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32, },
+    { 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71, },
+    { 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7, },
+    { 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12, },
+    { 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15, },
+    { 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31, },
+    { 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02, },
+    { 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca, },
+    { 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a, },
+    { 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e, },
+    { 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad, },
+    { 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18, },
+    { 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4, },
+    { 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9, },
+    { 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9, },
+    { 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb, },
+    { 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0, },
+    { 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6, },
+    { 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7, },
+    { 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee, },
+    { 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1, },
+    { 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a, },
+    { 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81, },
+    { 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f, },
+    { 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24, },
+    { 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7, },
+    { 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea, },
+    { 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60, },
+    { 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66, },
+    { 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c, },
+    { 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f, },
+    { 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5, },
+    { 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, },
+};
+
+TEST(SipHashTest, SipHash_2_4_64) {
+  uint8_t K[16];
+  for (size_t KI = 0; KI < sizeof(K); ++KI)
+    K[KI] = KI;
+
+  uint8_t In[64], Out[8];
+  for (size_t InLen = 0; InLen < sizeof(In); ++InLen) {
+    In[InLen] = InLen;
+    getSipHash_2_4_64(In, InLen, K, Out);
+    for (size_t I = 0; I < sizeof(Out); ++I)
+      EXPECT_EQ(ExpectedSipHash64[InLen][I], Out[I]);
+  }
+}
+
+const uint8_t ExpectedSipHash128[64][16] = {
+    { 0xa3, 0x81, 0x7f, 0x04, 0xba, 0x25, 0xa8, 0xe6,
+      0x6d, 0xf6, 0x72, 0x14, 0xc7, 0x55, 0x02, 0x93, },
+    { 0xda, 0x87, 0xc1, 0xd8, 0x6b, 0x99, 0xaf, 0x44,
+      0x34, 0x76, 0x59, 0x11, 0x9b, 0x22, 0xfc, 0x45, },
+    { 0x81, 0x77, 0x22, 0x8d, 0xa4, 0xa4, 0x5d, 0xc7,
+      0xfc, 0xa3, 0x8b, 0xde, 0xf6, 0x0a, 0xff, 0xe4, },
+    { 0x9c, 0x70, 0xb6, 0x0c, 0x52, 0x67, 0xa9, 0x4e,
+      0x5f, 0x33, 0xb6, 0xb0, 0x29, 0x85, 0xed, 0x51, },
+    { 0xf8, 0x81, 0x64, 0xc1, 0x2d, 0x9c, 0x8f, 0xaf,
+      0x7d, 0x0f, 0x6e, 0x7c, 0x7b, 0xcd, 0x55, 0x79, },
+    { 0x13, 0x68, 0x87, 0x59, 0x80, 0x77, 0x6f, 0x88,
+      0x54, 0x52, 0x7a, 0x07, 0x69, 0x0e, 0x96, 0x27, },
+    { 0x14, 0xee, 0xca, 0x33, 0x8b, 0x20, 0x86, 0x13,
+      0x48, 0x5e, 0xa0, 0x30, 0x8f, 0xd7, 0xa1, 0x5e, },
+    { 0xa1, 0xf1, 0xeb, 0xbe, 0xd8, 0xdb, 0xc1, 0x53,
+      0xc0, 0xb8, 0x4a, 0xa6, 0x1f, 0xf0, 0x82, 0x39, },
+    { 0x3b, 0x62, 0xa9, 0xba, 0x62, 0x58, 0xf5, 0x61,
+      0x0f, 0x83, 0xe2, 0x64, 0xf3, 0x14, 0x97, 0xb4, },
+    { 0x26, 0x44, 0x99, 0x06, 0x0a, 0xd9, 0xba, 0xab,
+      0xc4, 0x7f, 0x8b, 0x02, 0xbb, 0x6d, 0x71, 0xed, },
+    { 0x00, 0x11, 0x0d, 0xc3, 0x78, 0x14, 0x69, 0x56,
+      0xc9, 0x54, 0x47, 0xd3, 0xf3, 0xd0, 0xfb, 0xba, },
+    { 0x01, 0x51, 0xc5, 0x68, 0x38, 0x6b, 0x66, 0x77,
+      0xa2, 0xb4, 0xdc, 0x6f, 0x81, 0xe5, 0xdc, 0x18, },
+    { 0xd6, 0x26, 0xb2, 0x66, 0x90, 0x5e, 0xf3, 0x58,
+      0x82, 0x63, 0x4d, 0xf6, 0x85, 0x32, 0xc1, 0x25, },
+    { 0x98, 0x69, 0xe2, 0x47, 0xe9, 0xc0, 0x8b, 0x10,
+      0xd0, 0x29, 0x93, 0x4f, 0xc4, 0xb9, 0x52, 0xf7, },
+    { 0x31, 0xfc, 0xef, 0xac, 0x66, 0xd7, 0xde, 0x9c,
+      0x7e, 0xc7, 0x48, 0x5f, 0xe4, 0x49, 0x49, 0x02, },
+    { 0x54, 0x93, 0xe9, 0x99, 0x33, 0xb0, 0xa8, 0x11,
+      0x7e, 0x08, 0xec, 0x0f, 0x97, 0xcf, 0xc3, 0xd9, },
+    { 0x6e, 0xe2, 0xa4, 0xca, 0x67, 0xb0, 0x54, 0xbb,
+      0xfd, 0x33, 0x15, 0xbf, 0x85, 0x23, 0x05, 0x77, },
+    { 0x47, 0x3d, 0x06, 0xe8, 0x73, 0x8d, 0xb8, 0x98,
+      0x54, 0xc0, 0x66, 0xc4, 0x7a, 0xe4, 0x77, 0x40, },
+    { 0xa4, 0x26, 0xe5, 0xe4, 0x23, 0xbf, 0x48, 0x85,
+      0x29, 0x4d, 0xa4, 0x81, 0xfe, 0xae, 0xf7, 0x23, },
+    { 0x78, 0x01, 0x77, 0x31, 0xcf, 0x65, 0xfa, 0xb0,
+      0x74, 0xd5, 0x20, 0x89, 0x52, 0x51, 0x2e, 0xb1, },
+    { 0x9e, 0x25, 0xfc, 0x83, 0x3f, 0x22, 0x90, 0x73,
+      0x3e, 0x93, 0x44, 0xa5, 0xe8, 0x38, 0x39, 0xeb, },
+    { 0x56, 0x8e, 0x49, 0x5a, 0xbe, 0x52, 0x5a, 0x21,
+      0x8a, 0x22, 0x14, 0xcd, 0x3e, 0x07, 0x1d, 0x12, },
+    { 0x4a, 0x29, 0xb5, 0x45, 0x52, 0xd1, 0x6b, 0x9a,
+      0x46, 0x9c, 0x10, 0x52, 0x8e, 0xff, 0x0a, 0xae, },
+    { 0xc9, 0xd1, 0x84, 0xdd, 0xd5, 0xa9, 0xf5, 0xe0,
+      0xcf, 0x8c, 0xe2, 0x9a, 0x9a, 0xbf, 0x69, 0x1c, },
+    { 0x2d, 0xb4, 0x79, 0xae, 0x78, 0xbd, 0x50, 0xd8,
+      0x88, 0x2a, 0x8a, 0x17, 0x8a, 0x61, 0x32, 0xad, },
+    { 0x8e, 0xce, 0x5f, 0x04, 0x2d, 0x5e, 0x44, 0x7b,
+      0x50, 0x51, 0xb9, 0xea, 0xcb, 0x8d, 0x8f, 0x6f, },
+    { 0x9c, 0x0b, 0x53, 0xb4, 0xb3, 0xc3, 0x07, 0xe8,
+      0x7e, 0xae, 0xe0, 0x86, 0x78, 0x14, 0x1f, 0x66, },
+    { 0xab, 0xf2, 0x48, 0xaf, 0x69, 0xa6, 0xea, 0xe4,
+      0xbf, 0xd3, 0xeb, 0x2f, 0x12, 0x9e, 0xeb, 0x94, },
+    { 0x06, 0x64, 0xda, 0x16, 0x68, 0x57, 0x4b, 0x88,
+      0xb9, 0x35, 0xf3, 0x02, 0x73, 0x58, 0xae, 0xf4, },
+    { 0xaa, 0x4b, 0x9d, 0xc4, 0xbf, 0x33, 0x7d, 0xe9,
+      0x0c, 0xd4, 0xfd, 0x3c, 0x46, 0x7c, 0x6a, 0xb7, },
+    { 0xea, 0x5c, 0x7f, 0x47, 0x1f, 0xaf, 0x6b, 0xde,
+      0x2b, 0x1a, 0xd7, 0xd4, 0x68, 0x6d, 0x22, 0x87, },
+    { 0x29, 0x39, 0xb0, 0x18, 0x32, 0x23, 0xfa, 0xfc,
+      0x17, 0x23, 0xde, 0x4f, 0x52, 0xc4, 0x3d, 0x35, },
+    { 0x7c, 0x39, 0x56, 0xca, 0x5e, 0xea, 0xfc, 0x3e,
+      0x36, 0x3e, 0x9d, 0x55, 0x65, 0x46, 0xeb, 0x68, },
+    { 0x77, 0xc6, 0x07, 0x71, 0x46, 0xf0, 0x1c, 0x32,
+      0xb6, 0xb6, 0x9d, 0x5f, 0x4e, 0xa9, 0xff, 0xcf, },
+    { 0x37, 0xa6, 0x98, 0x6c, 0xb8, 0x84, 0x7e, 0xdf,
+      0x09, 0x25, 0xf0, 0xf1, 0x30, 0x9b, 0x54, 0xde, },
+    { 0xa7, 0x05, 0xf0, 0xe6, 0x9d, 0xa9, 0xa8, 0xf9,
+      0x07, 0x24, 0x1a, 0x2e, 0x92, 0x3c, 0x8c, 0xc8, },
+    { 0x3d, 0xc4, 0x7d, 0x1f, 0x29, 0xc4, 0x48, 0x46,
+      0x1e, 0x9e, 0x76, 0xed, 0x90, 0x4f, 0x67, 0x11, },
+    { 0x0d, 0x62, 0xbf, 0x01, 0xe6, 0xfc, 0x0e, 0x1a,
+      0x0d, 0x3c, 0x47, 0x51, 0xc5, 0xd3, 0x69, 0x2b, },
+    { 0x8c, 0x03, 0x46, 0x8b, 0xca, 0x7c, 0x66, 0x9e,
+      0xe4, 0xfd, 0x5e, 0x08, 0x4b, 0xbe, 0xe7, 0xb5, },
+    { 0x52, 0x8a, 0x5b, 0xb9, 0x3b, 0xaf, 0x2c, 0x9c,
+      0x44, 0x73, 0xcc, 0xe5, 0xd0, 0xd2, 0x2b, 0xd9, },
+    { 0xdf, 0x6a, 0x30, 0x1e, 0x95, 0xc9, 0x5d, 0xad,
+      0x97, 0xae, 0x0c, 0xc8, 0xc6, 0x91, 0x3b, 0xd8, },
+    { 0x80, 0x11, 0x89, 0x90, 0x2c, 0x85, 0x7f, 0x39,
+      0xe7, 0x35, 0x91, 0x28, 0x5e, 0x70, 0xb6, 0xdb, },
+    { 0xe6, 0x17, 0x34, 0x6a, 0xc9, 0xc2, 0x31, 0xbb,
+      0x36, 0x50, 0xae, 0x34, 0xcc, 0xca, 0x0c, 0x5b, },
+    { 0x27, 0xd9, 0x34, 0x37, 0xef, 0xb7, 0x21, 0xaa,
+      0x40, 0x18, 0x21, 0xdc, 0xec, 0x5a, 0xdf, 0x89, },
+    { 0x89, 0x23, 0x7d, 0x9d, 0xed, 0x9c, 0x5e, 0x78,
+      0xd8, 0xb1, 0xc9, 0xb1, 0x66, 0xcc, 0x73, 0x42, },
+    { 0x4a, 0x6d, 0x80, 0x91, 0xbf, 0x5e, 0x7d, 0x65,
+      0x11, 0x89, 0xfa, 0x94, 0xa2, 0x50, 0xb1, 0x4c, },
+    { 0x0e, 0x33, 0xf9, 0x60, 0x55, 0xe7, 0xae, 0x89,
+      0x3f, 0xfc, 0x0e, 0x3d, 0xcf, 0x49, 0x29, 0x02, },
+    { 0xe6, 0x1c, 0x43, 0x2b, 0x72, 0x0b, 0x19, 0xd1,
+      0x8e, 0xc8, 0xd8, 0x4b, 0xdc, 0x63, 0x15, 0x1b, },
+    { 0xf7, 0xe5, 0xae, 0xf5, 0x49, 0xf7, 0x82, 0xcf,
+      0x37, 0x90, 0x55, 0xa6, 0x08, 0x26, 0x9b, 0x16, },
+    { 0x43, 0x8d, 0x03, 0x0f, 0xd0, 0xb7, 0xa5, 0x4f,
+      0xa8, 0x37, 0xf2, 0xad, 0x20, 0x1a, 0x64, 0x03, },
+    { 0xa5, 0x90, 0xd3, 0xee, 0x4f, 0xbf, 0x04, 0xe3,
+      0x24, 0x7e, 0x0d, 0x27, 0xf2, 0x86, 0x42, 0x3f, },
+    { 0x5f, 0xe2, 0xc1, 0xa1, 0x72, 0xfe, 0x93, 0xc4,
+      0xb1, 0x5c, 0xd3, 0x7c, 0xae, 0xf9, 0xf5, 0x38, },
+    { 0x2c, 0x97, 0x32, 0x5c, 0xbd, 0x06, 0xb3, 0x6e,
+      0xb2, 0x13, 0x3d, 0xd0, 0x8b, 0x3a, 0x01, 0x7c, },
+    { 0x92, 0xc8, 0x14, 0x22, 0x7a, 0x6b, 0xca, 0x94,
+      0x9f, 0xf0, 0x65, 0x9f, 0x00, 0x2a, 0xd3, 0x9e, },
+    { 0xdc, 0xe8, 0x50, 0x11, 0x0b, 0xd8, 0x32, 0x8c,
+      0xfb, 0xd5, 0x08, 0x41, 0xd6, 0x91, 0x1d, 0x87, },
+    { 0x67, 0xf1, 0x49, 0x84, 0xc7, 0xda, 0x79, 0x12,
+      0x48, 0xe3, 0x2b, 0xb5, 0x92, 0x25, 0x83, 0xda, },
+    { 0x19, 0x38, 0xf2, 0xcf, 0x72, 0xd5, 0x4e, 0xe9,
+      0x7e, 0x94, 0x16, 0x6f, 0xa9, 0x1d, 0x2a, 0x36, },
+    { 0x74, 0x48, 0x1e, 0x96, 0x46, 0xed, 0x49, 0xfe,
+      0x0f, 0x62, 0x24, 0x30, 0x16, 0x04, 0x69, 0x8e, },
+    { 0x57, 0xfc, 0xa5, 0xde, 0x98, 0xa9, 0xd6, 0xd8,
+      0x00, 0x64, 0x38, 0xd0, 0x58, 0x3d, 0x8a, 0x1d, },
+    { 0x9f, 0xec, 0xde, 0x1c, 0xef, 0xdc, 0x1c, 0xbe,
+      0xd4, 0x76, 0x36, 0x74, 0xd9, 0x57, 0x53, 0x59, },
+    { 0xe3, 0x04, 0x0c, 0x00, 0xeb, 0x28, 0xf1, 0x53,
+      0x66, 0xca, 0x73, 0xcb, 0xd8, 0x72, 0xe7, 0x40, },
+    { 0x76, 0x97, 0x00, 0x9a, 0x6a, 0x83, 0x1d, 0xfe,
+      0xcc, 0xa9, 0x1c, 0x59, 0x93, 0x67, 0x0f, 0x7a, },
+    { 0x58, 0x53, 0x54, 0x23, 0x21, 0xf5, 0x67, 0xa0,
+      0x05, 0xd5, 0x47, 0xa4, 0xf0, 0x47, 0x59, 0xbd, },
+    { 0x51, 0x50, 0xd1, 0x77, 0x2f, 0x50, 0x83, 0x4a,
+      0x50, 0x3e, 0x06, 0x9a, 0x97, 0x3f, 0xbd, 0x7c, },
+};
+
+TEST(SipHashTest, SipHash_2_4_128) {
+  uint8_t K[16];
+  for (size_t KI = 0; KI < sizeof(K); ++KI)
+    K[KI] = KI;
+
+  uint8_t In[64], Out[16];
+  for (size_t InLen = 0; InLen < sizeof(In); ++InLen) {
+    In[InLen] = InLen;
+    getSipHash_2_4_128(In, InLen, K, Out);
+    for (size_t I = 0; I < sizeof(Out); ++I)
+      EXPECT_EQ(ExpectedSipHash128[InLen][I], Out[I]);
+  }
+}
+
+} // end anonymous namespace

>From 780778e49d7f4080420b2f1a1042f5a6ba216e5d Mon Sep 17 00:00:00 2001
From: Ahmed Bougacha <ahmed at bougacha.org>
Date: Thu, 13 Jun 2024 16:00:23 -0700
Subject: [PATCH 7/8] Pass input as ArrayRef<uint8_t>

Leave output/keys as fixed-size arrays.
---
 llvm/include/llvm/Support/SipHash.h    | 10 ++++++----
 llvm/lib/Support/SipHash.cpp           | 10 ++++++----
 llvm/unittests/Support/SipHashTest.cpp |  5 +++--
 3 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/llvm/include/llvm/Support/SipHash.h b/llvm/include/llvm/Support/SipHash.h
index c501d7ae70956..c9709c4479028 100644
--- a/llvm/include/llvm/Support/SipHash.h
+++ b/llvm/include/llvm/Support/SipHash.h
@@ -18,13 +18,15 @@
 
 namespace llvm {
 
+template<typename T> class ArrayRef;
+
 /// Computes a SipHash-2-4 64-bit result.
-void getSipHash_2_4_64(const uint8_t *In, uint64_t InLen,
-                       const uint8_t (&K)[16], uint8_t (&Out)[8]);
+void getSipHash_2_4_64(ArrayRef<uint8_t> In, const uint8_t (&K)[16],
+                       uint8_t (&Out)[8]);
 
 /// Computes a SipHash-2-4 128-bit result.
-void getSipHash_2_4_128(const uint8_t *In, uint64_t InLen,
-                        const uint8_t (&K)[16], uint8_t (&Out)[16]);
+void getSipHash_2_4_128(ArrayRef<uint8_t> In, const uint8_t (&K)[16],
+                        uint8_t (&Out)[16]);
 
 } // end namespace llvm
 
diff --git a/llvm/lib/Support/SipHash.cpp b/llvm/lib/Support/SipHash.cpp
index b4d52cda41861..35a7236df1a17 100644
--- a/llvm/lib/Support/SipHash.cpp
+++ b/llvm/lib/Support/SipHash.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Support/SipHash.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Endian.h"
 #include <cstdint>
@@ -144,14 +146,14 @@ void siphash(const unsigned char *in, uint64_t inlen,
 
 namespace llvm {
 
-void getSipHash_2_4_64(const uint8_t *In, uint64_t InLen,
+void getSipHash_2_4_64(ArrayRef<uint8_t> In,
                        const uint8_t (&K)[16], uint8_t (&Out)[8]) {
-  siphash<2, 4>(In, InLen, K, Out);
+  siphash<2, 4>(In.data(), In.size(), K, Out);
 }
 
-void getSipHash_2_4_128(const uint8_t *In, uint64_t InLen,
+void getSipHash_2_4_128(ArrayRef<uint8_t> In,
                         const uint8_t (&K)[16], uint8_t (&Out)[16]) {
-  siphash<2, 4>(In, InLen, K, Out);
+  siphash<2, 4>(In.data(), In.size(), K, Out);
 }
 
 } // end namespace llvm
diff --git a/llvm/unittests/Support/SipHashTest.cpp b/llvm/unittests/Support/SipHashTest.cpp
index 4d9d5da15956c..8a1cfb6652652 100644
--- a/llvm/unittests/Support/SipHashTest.cpp
+++ b/llvm/unittests/Support/SipHashTest.cpp
@@ -6,6 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/SipHash.h"
 #include "gtest/gtest.h"
 #include <string.h>
@@ -93,7 +94,7 @@ TEST(SipHashTest, SipHash_2_4_64) {
   uint8_t In[64], Out[8];
   for (size_t InLen = 0; InLen < sizeof(In); ++InLen) {
     In[InLen] = InLen;
-    getSipHash_2_4_64(In, InLen, K, Out);
+    getSipHash_2_4_64(ArrayRef(In, InLen), K, Out);
     for (size_t I = 0; I < sizeof(Out); ++I)
       EXPECT_EQ(ExpectedSipHash64[InLen][I], Out[I]);
   }
@@ -238,7 +239,7 @@ TEST(SipHashTest, SipHash_2_4_128) {
   uint8_t In[64], Out[16];
   for (size_t InLen = 0; InLen < sizeof(In); ++InLen) {
     In[InLen] = InLen;
-    getSipHash_2_4_128(In, InLen, K, Out);
+    getSipHash_2_4_128(ArrayRef(In, InLen), K, Out);
     for (size_t I = 0; I < sizeof(Out); ++I)
       EXPECT_EQ(ExpectedSipHash128[InLen][I], Out[I]);
   }

>From 52ed57f69cf164d66831b9e398bccac1baf0211b Mon Sep 17 00:00:00 2001
From: Ahmed Bougacha <ahmed at bougacha.org>
Date: Fri, 14 Jun 2024 16:30:45 -0700
Subject: [PATCH 8/8] Reformat; try to preserve original vectors.h.

And don't namespace llvm
---
 llvm/include/llvm/Support/SipHash.h    |    2 +-
 llvm/lib/Support/SipHash.cpp           |   12 +-
 llvm/unittests/Support/SipHashTest.cpp | 2007 +++++++++++++++++++++---
 3 files changed, 1811 insertions(+), 210 deletions(-)

diff --git a/llvm/include/llvm/Support/SipHash.h b/llvm/include/llvm/Support/SipHash.h
index c9709c4479028..56dea80ef2e6b 100644
--- a/llvm/include/llvm/Support/SipHash.h
+++ b/llvm/include/llvm/Support/SipHash.h
@@ -18,7 +18,7 @@
 
 namespace llvm {
 
-template<typename T> class ArrayRef;
+template <typename T> class ArrayRef;
 
 /// Computes a SipHash-2-4 64-bit result.
 void getSipHash_2_4_64(ArrayRef<uint8_t> In, const uint8_t (&K)[16],
diff --git a/llvm/lib/Support/SipHash.cpp b/llvm/lib/Support/SipHash.cpp
index 35a7236df1a17..ed1a305f0443f 100644
--- a/llvm/lib/Support/SipHash.cpp
+++ b/llvm/lib/Support/SipHash.cpp
@@ -144,16 +144,12 @@ void siphash(const unsigned char *in, uint64_t inlen,
 
 } // end anonymous namespace
 
-namespace llvm {
-
-void getSipHash_2_4_64(ArrayRef<uint8_t> In,
-                       const uint8_t (&K)[16], uint8_t (&Out)[8]) {
+void llvm::getSipHash_2_4_64(ArrayRef<uint8_t> In, const uint8_t (&K)[16],
+                             uint8_t (&Out)[8]) {
   siphash<2, 4>(In.data(), In.size(), K, Out);
 }
 
-void getSipHash_2_4_128(ArrayRef<uint8_t> In,
-                        const uint8_t (&K)[16], uint8_t (&Out)[16]) {
+void llvm::getSipHash_2_4_128(ArrayRef<uint8_t> In, const uint8_t (&K)[16],
+                              uint8_t (&Out)[16]) {
   siphash<2, 4>(In.data(), In.size(), K, Out);
 }
-
-} // end namespace llvm
diff --git a/llvm/unittests/Support/SipHashTest.cpp b/llvm/unittests/Support/SipHashTest.cpp
index 8a1cfb6652652..bd05c278fc7a2 100644
--- a/llvm/unittests/Support/SipHashTest.cpp
+++ b/llvm/unittests/Support/SipHashTest.cpp
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/SipHash.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "gtest/gtest.h"
 #include <string.h>
 
@@ -15,76 +15,12 @@ using namespace llvm;
 
 namespace {
 
-// Test vectors and harness from the SipHash reference implementation:
+// Tests from the SipHash reference implementation:
 //   https://github.com/veorq/SipHash
-// The below is lightly adapted from test.c/vectors.h.
-
-const uint8_t ExpectedSipHash64[64][8] = {
-    { 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, },
-    { 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, },
-    { 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d, },
-    { 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85, },
-    { 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf, },
-    { 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18, },
-    { 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb, },
-    { 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab, },
-    { 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93, },
-    { 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e, },
-    { 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a, },
-    { 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4, },
-    { 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75, },
-    { 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14, },
-    { 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7, },
-    { 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1, },
-    { 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f, },
-    { 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69, },
-    { 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b, },
-    { 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb, },
-    { 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe, },
-    { 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0, },
-    { 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93, },
-    { 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8, },
-    { 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8, },
-    { 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc, },
-    { 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17, },
-    { 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f, },
-    { 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde, },
-    { 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6, },
-    { 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad, },
-    { 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32, },
-    { 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71, },
-    { 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7, },
-    { 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12, },
-    { 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15, },
-    { 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31, },
-    { 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02, },
-    { 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca, },
-    { 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a, },
-    { 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e, },
-    { 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad, },
-    { 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18, },
-    { 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4, },
-    { 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9, },
-    { 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9, },
-    { 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb, },
-    { 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0, },
-    { 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6, },
-    { 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7, },
-    { 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee, },
-    { 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1, },
-    { 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a, },
-    { 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81, },
-    { 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f, },
-    { 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24, },
-    { 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7, },
-    { 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea, },
-    { 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60, },
-    { 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66, },
-    { 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c, },
-    { 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f, },
-    { 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5, },
-    { 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, },
-};
+// from test.c and vectors.h, with the latter vectors at the end of the file,
+// forward-declared here.
+extern const uint8_t ExpectedSipHash64[64][8];
+extern const uint8_t ExpectedSipHash128[64][16];
 
 TEST(SipHashTest, SipHash_2_4_64) {
   uint8_t K[16];
@@ -100,137 +36,6 @@ TEST(SipHashTest, SipHash_2_4_64) {
   }
 }
 
-const uint8_t ExpectedSipHash128[64][16] = {
-    { 0xa3, 0x81, 0x7f, 0x04, 0xba, 0x25, 0xa8, 0xe6,
-      0x6d, 0xf6, 0x72, 0x14, 0xc7, 0x55, 0x02, 0x93, },
-    { 0xda, 0x87, 0xc1, 0xd8, 0x6b, 0x99, 0xaf, 0x44,
-      0x34, 0x76, 0x59, 0x11, 0x9b, 0x22, 0xfc, 0x45, },
-    { 0x81, 0x77, 0x22, 0x8d, 0xa4, 0xa4, 0x5d, 0xc7,
-      0xfc, 0xa3, 0x8b, 0xde, 0xf6, 0x0a, 0xff, 0xe4, },
-    { 0x9c, 0x70, 0xb6, 0x0c, 0x52, 0x67, 0xa9, 0x4e,
-      0x5f, 0x33, 0xb6, 0xb0, 0x29, 0x85, 0xed, 0x51, },
-    { 0xf8, 0x81, 0x64, 0xc1, 0x2d, 0x9c, 0x8f, 0xaf,
-      0x7d, 0x0f, 0x6e, 0x7c, 0x7b, 0xcd, 0x55, 0x79, },
-    { 0x13, 0x68, 0x87, 0x59, 0x80, 0x77, 0x6f, 0x88,
-      0x54, 0x52, 0x7a, 0x07, 0x69, 0x0e, 0x96, 0x27, },
-    { 0x14, 0xee, 0xca, 0x33, 0x8b, 0x20, 0x86, 0x13,
-      0x48, 0x5e, 0xa0, 0x30, 0x8f, 0xd7, 0xa1, 0x5e, },
-    { 0xa1, 0xf1, 0xeb, 0xbe, 0xd8, 0xdb, 0xc1, 0x53,
-      0xc0, 0xb8, 0x4a, 0xa6, 0x1f, 0xf0, 0x82, 0x39, },
-    { 0x3b, 0x62, 0xa9, 0xba, 0x62, 0x58, 0xf5, 0x61,
-      0x0f, 0x83, 0xe2, 0x64, 0xf3, 0x14, 0x97, 0xb4, },
-    { 0x26, 0x44, 0x99, 0x06, 0x0a, 0xd9, 0xba, 0xab,
-      0xc4, 0x7f, 0x8b, 0x02, 0xbb, 0x6d, 0x71, 0xed, },
-    { 0x00, 0x11, 0x0d, 0xc3, 0x78, 0x14, 0x69, 0x56,
-      0xc9, 0x54, 0x47, 0xd3, 0xf3, 0xd0, 0xfb, 0xba, },
-    { 0x01, 0x51, 0xc5, 0x68, 0x38, 0x6b, 0x66, 0x77,
-      0xa2, 0xb4, 0xdc, 0x6f, 0x81, 0xe5, 0xdc, 0x18, },
-    { 0xd6, 0x26, 0xb2, 0x66, 0x90, 0x5e, 0xf3, 0x58,
-      0x82, 0x63, 0x4d, 0xf6, 0x85, 0x32, 0xc1, 0x25, },
-    { 0x98, 0x69, 0xe2, 0x47, 0xe9, 0xc0, 0x8b, 0x10,
-      0xd0, 0x29, 0x93, 0x4f, 0xc4, 0xb9, 0x52, 0xf7, },
-    { 0x31, 0xfc, 0xef, 0xac, 0x66, 0xd7, 0xde, 0x9c,
-      0x7e, 0xc7, 0x48, 0x5f, 0xe4, 0x49, 0x49, 0x02, },
-    { 0x54, 0x93, 0xe9, 0x99, 0x33, 0xb0, 0xa8, 0x11,
-      0x7e, 0x08, 0xec, 0x0f, 0x97, 0xcf, 0xc3, 0xd9, },
-    { 0x6e, 0xe2, 0xa4, 0xca, 0x67, 0xb0, 0x54, 0xbb,
-      0xfd, 0x33, 0x15, 0xbf, 0x85, 0x23, 0x05, 0x77, },
-    { 0x47, 0x3d, 0x06, 0xe8, 0x73, 0x8d, 0xb8, 0x98,
-      0x54, 0xc0, 0x66, 0xc4, 0x7a, 0xe4, 0x77, 0x40, },
-    { 0xa4, 0x26, 0xe5, 0xe4, 0x23, 0xbf, 0x48, 0x85,
-      0x29, 0x4d, 0xa4, 0x81, 0xfe, 0xae, 0xf7, 0x23, },
-    { 0x78, 0x01, 0x77, 0x31, 0xcf, 0x65, 0xfa, 0xb0,
-      0x74, 0xd5, 0x20, 0x89, 0x52, 0x51, 0x2e, 0xb1, },
-    { 0x9e, 0x25, 0xfc, 0x83, 0x3f, 0x22, 0x90, 0x73,
-      0x3e, 0x93, 0x44, 0xa5, 0xe8, 0x38, 0x39, 0xeb, },
-    { 0x56, 0x8e, 0x49, 0x5a, 0xbe, 0x52, 0x5a, 0x21,
-      0x8a, 0x22, 0x14, 0xcd, 0x3e, 0x07, 0x1d, 0x12, },
-    { 0x4a, 0x29, 0xb5, 0x45, 0x52, 0xd1, 0x6b, 0x9a,
-      0x46, 0x9c, 0x10, 0x52, 0x8e, 0xff, 0x0a, 0xae, },
-    { 0xc9, 0xd1, 0x84, 0xdd, 0xd5, 0xa9, 0xf5, 0xe0,
-      0xcf, 0x8c, 0xe2, 0x9a, 0x9a, 0xbf, 0x69, 0x1c, },
-    { 0x2d, 0xb4, 0x79, 0xae, 0x78, 0xbd, 0x50, 0xd8,
-      0x88, 0x2a, 0x8a, 0x17, 0x8a, 0x61, 0x32, 0xad, },
-    { 0x8e, 0xce, 0x5f, 0x04, 0x2d, 0x5e, 0x44, 0x7b,
-      0x50, 0x51, 0xb9, 0xea, 0xcb, 0x8d, 0x8f, 0x6f, },
-    { 0x9c, 0x0b, 0x53, 0xb4, 0xb3, 0xc3, 0x07, 0xe8,
-      0x7e, 0xae, 0xe0, 0x86, 0x78, 0x14, 0x1f, 0x66, },
-    { 0xab, 0xf2, 0x48, 0xaf, 0x69, 0xa6, 0xea, 0xe4,
-      0xbf, 0xd3, 0xeb, 0x2f, 0x12, 0x9e, 0xeb, 0x94, },
-    { 0x06, 0x64, 0xda, 0x16, 0x68, 0x57, 0x4b, 0x88,
-      0xb9, 0x35, 0xf3, 0x02, 0x73, 0x58, 0xae, 0xf4, },
-    { 0xaa, 0x4b, 0x9d, 0xc4, 0xbf, 0x33, 0x7d, 0xe9,
-      0x0c, 0xd4, 0xfd, 0x3c, 0x46, 0x7c, 0x6a, 0xb7, },
-    { 0xea, 0x5c, 0x7f, 0x47, 0x1f, 0xaf, 0x6b, 0xde,
-      0x2b, 0x1a, 0xd7, 0xd4, 0x68, 0x6d, 0x22, 0x87, },
-    { 0x29, 0x39, 0xb0, 0x18, 0x32, 0x23, 0xfa, 0xfc,
-      0x17, 0x23, 0xde, 0x4f, 0x52, 0xc4, 0x3d, 0x35, },
-    { 0x7c, 0x39, 0x56, 0xca, 0x5e, 0xea, 0xfc, 0x3e,
-      0x36, 0x3e, 0x9d, 0x55, 0x65, 0x46, 0xeb, 0x68, },
-    { 0x77, 0xc6, 0x07, 0x71, 0x46, 0xf0, 0x1c, 0x32,
-      0xb6, 0xb6, 0x9d, 0x5f, 0x4e, 0xa9, 0xff, 0xcf, },
-    { 0x37, 0xa6, 0x98, 0x6c, 0xb8, 0x84, 0x7e, 0xdf,
-      0x09, 0x25, 0xf0, 0xf1, 0x30, 0x9b, 0x54, 0xde, },
-    { 0xa7, 0x05, 0xf0, 0xe6, 0x9d, 0xa9, 0xa8, 0xf9,
-      0x07, 0x24, 0x1a, 0x2e, 0x92, 0x3c, 0x8c, 0xc8, },
-    { 0x3d, 0xc4, 0x7d, 0x1f, 0x29, 0xc4, 0x48, 0x46,
-      0x1e, 0x9e, 0x76, 0xed, 0x90, 0x4f, 0x67, 0x11, },
-    { 0x0d, 0x62, 0xbf, 0x01, 0xe6, 0xfc, 0x0e, 0x1a,
-      0x0d, 0x3c, 0x47, 0x51, 0xc5, 0xd3, 0x69, 0x2b, },
-    { 0x8c, 0x03, 0x46, 0x8b, 0xca, 0x7c, 0x66, 0x9e,
-      0xe4, 0xfd, 0x5e, 0x08, 0x4b, 0xbe, 0xe7, 0xb5, },
-    { 0x52, 0x8a, 0x5b, 0xb9, 0x3b, 0xaf, 0x2c, 0x9c,
-      0x44, 0x73, 0xcc, 0xe5, 0xd0, 0xd2, 0x2b, 0xd9, },
-    { 0xdf, 0x6a, 0x30, 0x1e, 0x95, 0xc9, 0x5d, 0xad,
-      0x97, 0xae, 0x0c, 0xc8, 0xc6, 0x91, 0x3b, 0xd8, },
-    { 0x80, 0x11, 0x89, 0x90, 0x2c, 0x85, 0x7f, 0x39,
-      0xe7, 0x35, 0x91, 0x28, 0x5e, 0x70, 0xb6, 0xdb, },
-    { 0xe6, 0x17, 0x34, 0x6a, 0xc9, 0xc2, 0x31, 0xbb,
-      0x36, 0x50, 0xae, 0x34, 0xcc, 0xca, 0x0c, 0x5b, },
-    { 0x27, 0xd9, 0x34, 0x37, 0xef, 0xb7, 0x21, 0xaa,
-      0x40, 0x18, 0x21, 0xdc, 0xec, 0x5a, 0xdf, 0x89, },
-    { 0x89, 0x23, 0x7d, 0x9d, 0xed, 0x9c, 0x5e, 0x78,
-      0xd8, 0xb1, 0xc9, 0xb1, 0x66, 0xcc, 0x73, 0x42, },
-    { 0x4a, 0x6d, 0x80, 0x91, 0xbf, 0x5e, 0x7d, 0x65,
-      0x11, 0x89, 0xfa, 0x94, 0xa2, 0x50, 0xb1, 0x4c, },
-    { 0x0e, 0x33, 0xf9, 0x60, 0x55, 0xe7, 0xae, 0x89,
-      0x3f, 0xfc, 0x0e, 0x3d, 0xcf, 0x49, 0x29, 0x02, },
-    { 0xe6, 0x1c, 0x43, 0x2b, 0x72, 0x0b, 0x19, 0xd1,
-      0x8e, 0xc8, 0xd8, 0x4b, 0xdc, 0x63, 0x15, 0x1b, },
-    { 0xf7, 0xe5, 0xae, 0xf5, 0x49, 0xf7, 0x82, 0xcf,
-      0x37, 0x90, 0x55, 0xa6, 0x08, 0x26, 0x9b, 0x16, },
-    { 0x43, 0x8d, 0x03, 0x0f, 0xd0, 0xb7, 0xa5, 0x4f,
-      0xa8, 0x37, 0xf2, 0xad, 0x20, 0x1a, 0x64, 0x03, },
-    { 0xa5, 0x90, 0xd3, 0xee, 0x4f, 0xbf, 0x04, 0xe3,
-      0x24, 0x7e, 0x0d, 0x27, 0xf2, 0x86, 0x42, 0x3f, },
-    { 0x5f, 0xe2, 0xc1, 0xa1, 0x72, 0xfe, 0x93, 0xc4,
-      0xb1, 0x5c, 0xd3, 0x7c, 0xae, 0xf9, 0xf5, 0x38, },
-    { 0x2c, 0x97, 0x32, 0x5c, 0xbd, 0x06, 0xb3, 0x6e,
-      0xb2, 0x13, 0x3d, 0xd0, 0x8b, 0x3a, 0x01, 0x7c, },
-    { 0x92, 0xc8, 0x14, 0x22, 0x7a, 0x6b, 0xca, 0x94,
-      0x9f, 0xf0, 0x65, 0x9f, 0x00, 0x2a, 0xd3, 0x9e, },
-    { 0xdc, 0xe8, 0x50, 0x11, 0x0b, 0xd8, 0x32, 0x8c,
-      0xfb, 0xd5, 0x08, 0x41, 0xd6, 0x91, 0x1d, 0x87, },
-    { 0x67, 0xf1, 0x49, 0x84, 0xc7, 0xda, 0x79, 0x12,
-      0x48, 0xe3, 0x2b, 0xb5, 0x92, 0x25, 0x83, 0xda, },
-    { 0x19, 0x38, 0xf2, 0xcf, 0x72, 0xd5, 0x4e, 0xe9,
-      0x7e, 0x94, 0x16, 0x6f, 0xa9, 0x1d, 0x2a, 0x36, },
-    { 0x74, 0x48, 0x1e, 0x96, 0x46, 0xed, 0x49, 0xfe,
-      0x0f, 0x62, 0x24, 0x30, 0x16, 0x04, 0x69, 0x8e, },
-    { 0x57, 0xfc, 0xa5, 0xde, 0x98, 0xa9, 0xd6, 0xd8,
-      0x00, 0x64, 0x38, 0xd0, 0x58, 0x3d, 0x8a, 0x1d, },
-    { 0x9f, 0xec, 0xde, 0x1c, 0xef, 0xdc, 0x1c, 0xbe,
-      0xd4, 0x76, 0x36, 0x74, 0xd9, 0x57, 0x53, 0x59, },
-    { 0xe3, 0x04, 0x0c, 0x00, 0xeb, 0x28, 0xf1, 0x53,
-      0x66, 0xca, 0x73, 0xcb, 0xd8, 0x72, 0xe7, 0x40, },
-    { 0x76, 0x97, 0x00, 0x9a, 0x6a, 0x83, 0x1d, 0xfe,
-      0xcc, 0xa9, 0x1c, 0x59, 0x93, 0x67, 0x0f, 0x7a, },
-    { 0x58, 0x53, 0x54, 0x23, 0x21, 0xf5, 0x67, 0xa0,
-      0x05, 0xd5, 0x47, 0xa4, 0xf0, 0x47, 0x59, 0xbd, },
-    { 0x51, 0x50, 0xd1, 0x77, 0x2f, 0x50, 0x83, 0x4a,
-      0x50, 0x3e, 0x06, 0x9a, 0x97, 0x3f, 0xbd, 0x7c, },
-};
-
 TEST(SipHashTest, SipHash_2_4_128) {
   uint8_t K[16];
   for (size_t KI = 0; KI < sizeof(K); ++KI)
@@ -245,4 +50,1804 @@ TEST(SipHashTest, SipHash_2_4_128) {
   }
 }
 
+// Below are the unmodified expected outputs from vectors.h
+
+const uint8_t ExpectedSipHash64[64][8] = {
+    {
+        0x31,
+        0x0e,
+        0x0e,
+        0xdd,
+        0x47,
+        0xdb,
+        0x6f,
+        0x72,
+    },
+    {
+        0xfd,
+        0x67,
+        0xdc,
+        0x93,
+        0xc5,
+        0x39,
+        0xf8,
+        0x74,
+    },
+    {
+        0x5a,
+        0x4f,
+        0xa9,
+        0xd9,
+        0x09,
+        0x80,
+        0x6c,
+        0x0d,
+    },
+    {
+        0x2d,
+        0x7e,
+        0xfb,
+        0xd7,
+        0x96,
+        0x66,
+        0x67,
+        0x85,
+    },
+    {
+        0xb7,
+        0x87,
+        0x71,
+        0x27,
+        0xe0,
+        0x94,
+        0x27,
+        0xcf,
+    },
+    {
+        0x8d,
+        0xa6,
+        0x99,
+        0xcd,
+        0x64,
+        0x55,
+        0x76,
+        0x18,
+    },
+    {
+        0xce,
+        0xe3,
+        0xfe,
+        0x58,
+        0x6e,
+        0x46,
+        0xc9,
+        0xcb,
+    },
+    {
+        0x37,
+        0xd1,
+        0x01,
+        0x8b,
+        0xf5,
+        0x00,
+        0x02,
+        0xab,
+    },
+    {
+        0x62,
+        0x24,
+        0x93,
+        0x9a,
+        0x79,
+        0xf5,
+        0xf5,
+        0x93,
+    },
+    {
+        0xb0,
+        0xe4,
+        0xa9,
+        0x0b,
+        0xdf,
+        0x82,
+        0x00,
+        0x9e,
+    },
+    {
+        0xf3,
+        0xb9,
+        0xdd,
+        0x94,
+        0xc5,
+        0xbb,
+        0x5d,
+        0x7a,
+    },
+    {
+        0xa7,
+        0xad,
+        0x6b,
+        0x22,
+        0x46,
+        0x2f,
+        0xb3,
+        0xf4,
+    },
+    {
+        0xfb,
+        0xe5,
+        0x0e,
+        0x86,
+        0xbc,
+        0x8f,
+        0x1e,
+        0x75,
+    },
+    {
+        0x90,
+        0x3d,
+        0x84,
+        0xc0,
+        0x27,
+        0x56,
+        0xea,
+        0x14,
+    },
+    {
+        0xee,
+        0xf2,
+        0x7a,
+        0x8e,
+        0x90,
+        0xca,
+        0x23,
+        0xf7,
+    },
+    {
+        0xe5,
+        0x45,
+        0xbe,
+        0x49,
+        0x61,
+        0xca,
+        0x29,
+        0xa1,
+    },
+    {
+        0xdb,
+        0x9b,
+        0xc2,
+        0x57,
+        0x7f,
+        0xcc,
+        0x2a,
+        0x3f,
+    },
+    {
+        0x94,
+        0x47,
+        0xbe,
+        0x2c,
+        0xf5,
+        0xe9,
+        0x9a,
+        0x69,
+    },
+    {
+        0x9c,
+        0xd3,
+        0x8d,
+        0x96,
+        0xf0,
+        0xb3,
+        0xc1,
+        0x4b,
+    },
+    {
+        0xbd,
+        0x61,
+        0x79,
+        0xa7,
+        0x1d,
+        0xc9,
+        0x6d,
+        0xbb,
+    },
+    {
+        0x98,
+        0xee,
+        0xa2,
+        0x1a,
+        0xf2,
+        0x5c,
+        0xd6,
+        0xbe,
+    },
+    {
+        0xc7,
+        0x67,
+        0x3b,
+        0x2e,
+        0xb0,
+        0xcb,
+        0xf2,
+        0xd0,
+    },
+    {
+        0x88,
+        0x3e,
+        0xa3,
+        0xe3,
+        0x95,
+        0x67,
+        0x53,
+        0x93,
+    },
+    {
+        0xc8,
+        0xce,
+        0x5c,
+        0xcd,
+        0x8c,
+        0x03,
+        0x0c,
+        0xa8,
+    },
+    {
+        0x94,
+        0xaf,
+        0x49,
+        0xf6,
+        0xc6,
+        0x50,
+        0xad,
+        0xb8,
+    },
+    {
+        0xea,
+        0xb8,
+        0x85,
+        0x8a,
+        0xde,
+        0x92,
+        0xe1,
+        0xbc,
+    },
+    {
+        0xf3,
+        0x15,
+        0xbb,
+        0x5b,
+        0xb8,
+        0x35,
+        0xd8,
+        0x17,
+    },
+    {
+        0xad,
+        0xcf,
+        0x6b,
+        0x07,
+        0x63,
+        0x61,
+        0x2e,
+        0x2f,
+    },
+    {
+        0xa5,
+        0xc9,
+        0x1d,
+        0xa7,
+        0xac,
+        0xaa,
+        0x4d,
+        0xde,
+    },
+    {
+        0x71,
+        0x65,
+        0x95,
+        0x87,
+        0x66,
+        0x50,
+        0xa2,
+        0xa6,
+    },
+    {
+        0x28,
+        0xef,
+        0x49,
+        0x5c,
+        0x53,
+        0xa3,
+        0x87,
+        0xad,
+    },
+    {
+        0x42,
+        0xc3,
+        0x41,
+        0xd8,
+        0xfa,
+        0x92,
+        0xd8,
+        0x32,
+    },
+    {
+        0xce,
+        0x7c,
+        0xf2,
+        0x72,
+        0x2f,
+        0x51,
+        0x27,
+        0x71,
+    },
+    {
+        0xe3,
+        0x78,
+        0x59,
+        0xf9,
+        0x46,
+        0x23,
+        0xf3,
+        0xa7,
+    },
+    {
+        0x38,
+        0x12,
+        0x05,
+        0xbb,
+        0x1a,
+        0xb0,
+        0xe0,
+        0x12,
+    },
+    {
+        0xae,
+        0x97,
+        0xa1,
+        0x0f,
+        0xd4,
+        0x34,
+        0xe0,
+        0x15,
+    },
+    {
+        0xb4,
+        0xa3,
+        0x15,
+        0x08,
+        0xbe,
+        0xff,
+        0x4d,
+        0x31,
+    },
+    {
+        0x81,
+        0x39,
+        0x62,
+        0x29,
+        0xf0,
+        0x90,
+        0x79,
+        0x02,
+    },
+    {
+        0x4d,
+        0x0c,
+        0xf4,
+        0x9e,
+        0xe5,
+        0xd4,
+        0xdc,
+        0xca,
+    },
+    {
+        0x5c,
+        0x73,
+        0x33,
+        0x6a,
+        0x76,
+        0xd8,
+        0xbf,
+        0x9a,
+    },
+    {
+        0xd0,
+        0xa7,
+        0x04,
+        0x53,
+        0x6b,
+        0xa9,
+        0x3e,
+        0x0e,
+    },
+    {
+        0x92,
+        0x59,
+        0x58,
+        0xfc,
+        0xd6,
+        0x42,
+        0x0c,
+        0xad,
+    },
+    {
+        0xa9,
+        0x15,
+        0xc2,
+        0x9b,
+        0xc8,
+        0x06,
+        0x73,
+        0x18,
+    },
+    {
+        0x95,
+        0x2b,
+        0x79,
+        0xf3,
+        0xbc,
+        0x0a,
+        0xa6,
+        0xd4,
+    },
+    {
+        0xf2,
+        0x1d,
+        0xf2,
+        0xe4,
+        0x1d,
+        0x45,
+        0x35,
+        0xf9,
+    },
+    {
+        0x87,
+        0x57,
+        0x75,
+        0x19,
+        0x04,
+        0x8f,
+        0x53,
+        0xa9,
+    },
+    {
+        0x10,
+        0xa5,
+        0x6c,
+        0xf5,
+        0xdf,
+        0xcd,
+        0x9a,
+        0xdb,
+    },
+    {
+        0xeb,
+        0x75,
+        0x09,
+        0x5c,
+        0xcd,
+        0x98,
+        0x6c,
+        0xd0,
+    },
+    {
+        0x51,
+        0xa9,
+        0xcb,
+        0x9e,
+        0xcb,
+        0xa3,
+        0x12,
+        0xe6,
+    },
+    {
+        0x96,
+        0xaf,
+        0xad,
+        0xfc,
+        0x2c,
+        0xe6,
+        0x66,
+        0xc7,
+    },
+    {
+        0x72,
+        0xfe,
+        0x52,
+        0x97,
+        0x5a,
+        0x43,
+        0x64,
+        0xee,
+    },
+    {
+        0x5a,
+        0x16,
+        0x45,
+        0xb2,
+        0x76,
+        0xd5,
+        0x92,
+        0xa1,
+    },
+    {
+        0xb2,
+        0x74,
+        0xcb,
+        0x8e,
+        0xbf,
+        0x87,
+        0x87,
+        0x0a,
+    },
+    {
+        0x6f,
+        0x9b,
+        0xb4,
+        0x20,
+        0x3d,
+        0xe7,
+        0xb3,
+        0x81,
+    },
+    {
+        0xea,
+        0xec,
+        0xb2,
+        0xa3,
+        0x0b,
+        0x22,
+        0xa8,
+        0x7f,
+    },
+    {
+        0x99,
+        0x24,
+        0xa4,
+        0x3c,
+        0xc1,
+        0x31,
+        0x57,
+        0x24,
+    },
+    {
+        0xbd,
+        0x83,
+        0x8d,
+        0x3a,
+        0xaf,
+        0xbf,
+        0x8d,
+        0xb7,
+    },
+    {
+        0x0b,
+        0x1a,
+        0x2a,
+        0x32,
+        0x65,
+        0xd5,
+        0x1a,
+        0xea,
+    },
+    {
+        0x13,
+        0x50,
+        0x79,
+        0xa3,
+        0x23,
+        0x1c,
+        0xe6,
+        0x60,
+    },
+    {
+        0x93,
+        0x2b,
+        0x28,
+        0x46,
+        0xe4,
+        0xd7,
+        0x06,
+        0x66,
+    },
+    {
+        0xe1,
+        0x91,
+        0x5f,
+        0x5c,
+        0xb1,
+        0xec,
+        0xa4,
+        0x6c,
+    },
+    {
+        0xf3,
+        0x25,
+        0x96,
+        0x5c,
+        0xa1,
+        0x6d,
+        0x62,
+        0x9f,
+    },
+    {
+        0x57,
+        0x5f,
+        0xf2,
+        0x8e,
+        0x60,
+        0x38,
+        0x1b,
+        0xe5,
+    },
+    {
+        0x72,
+        0x45,
+        0x06,
+        0xeb,
+        0x4c,
+        0x32,
+        0x8a,
+        0x95,
+    },
+};
+
+const uint8_t ExpectedSipHash128[64][16] = {
+    {
+        0xa3,
+        0x81,
+        0x7f,
+        0x04,
+        0xba,
+        0x25,
+        0xa8,
+        0xe6,
+        0x6d,
+        0xf6,
+        0x72,
+        0x14,
+        0xc7,
+        0x55,
+        0x02,
+        0x93,
+    },
+    {
+        0xda,
+        0x87,
+        0xc1,
+        0xd8,
+        0x6b,
+        0x99,
+        0xaf,
+        0x44,
+        0x34,
+        0x76,
+        0x59,
+        0x11,
+        0x9b,
+        0x22,
+        0xfc,
+        0x45,
+    },
+    {
+        0x81,
+        0x77,
+        0x22,
+        0x8d,
+        0xa4,
+        0xa4,
+        0x5d,
+        0xc7,
+        0xfc,
+        0xa3,
+        0x8b,
+        0xde,
+        0xf6,
+        0x0a,
+        0xff,
+        0xe4,
+    },
+    {
+        0x9c,
+        0x70,
+        0xb6,
+        0x0c,
+        0x52,
+        0x67,
+        0xa9,
+        0x4e,
+        0x5f,
+        0x33,
+        0xb6,
+        0xb0,
+        0x29,
+        0x85,
+        0xed,
+        0x51,
+    },
+    {
+        0xf8,
+        0x81,
+        0x64,
+        0xc1,
+        0x2d,
+        0x9c,
+        0x8f,
+        0xaf,
+        0x7d,
+        0x0f,
+        0x6e,
+        0x7c,
+        0x7b,
+        0xcd,
+        0x55,
+        0x79,
+    },
+    {
+        0x13,
+        0x68,
+        0x87,
+        0x59,
+        0x80,
+        0x77,
+        0x6f,
+        0x88,
+        0x54,
+        0x52,
+        0x7a,
+        0x07,
+        0x69,
+        0x0e,
+        0x96,
+        0x27,
+    },
+    {
+        0x14,
+        0xee,
+        0xca,
+        0x33,
+        0x8b,
+        0x20,
+        0x86,
+        0x13,
+        0x48,
+        0x5e,
+        0xa0,
+        0x30,
+        0x8f,
+        0xd7,
+        0xa1,
+        0x5e,
+    },
+    {
+        0xa1,
+        0xf1,
+        0xeb,
+        0xbe,
+        0xd8,
+        0xdb,
+        0xc1,
+        0x53,
+        0xc0,
+        0xb8,
+        0x4a,
+        0xa6,
+        0x1f,
+        0xf0,
+        0x82,
+        0x39,
+    },
+    {
+        0x3b,
+        0x62,
+        0xa9,
+        0xba,
+        0x62,
+        0x58,
+        0xf5,
+        0x61,
+        0x0f,
+        0x83,
+        0xe2,
+        0x64,
+        0xf3,
+        0x14,
+        0x97,
+        0xb4,
+    },
+    {
+        0x26,
+        0x44,
+        0x99,
+        0x06,
+        0x0a,
+        0xd9,
+        0xba,
+        0xab,
+        0xc4,
+        0x7f,
+        0x8b,
+        0x02,
+        0xbb,
+        0x6d,
+        0x71,
+        0xed,
+    },
+    {
+        0x00,
+        0x11,
+        0x0d,
+        0xc3,
+        0x78,
+        0x14,
+        0x69,
+        0x56,
+        0xc9,
+        0x54,
+        0x47,
+        0xd3,
+        0xf3,
+        0xd0,
+        0xfb,
+        0xba,
+    },
+    {
+        0x01,
+        0x51,
+        0xc5,
+        0x68,
+        0x38,
+        0x6b,
+        0x66,
+        0x77,
+        0xa2,
+        0xb4,
+        0xdc,
+        0x6f,
+        0x81,
+        0xe5,
+        0xdc,
+        0x18,
+    },
+    {
+        0xd6,
+        0x26,
+        0xb2,
+        0x66,
+        0x90,
+        0x5e,
+        0xf3,
+        0x58,
+        0x82,
+        0x63,
+        0x4d,
+        0xf6,
+        0x85,
+        0x32,
+        0xc1,
+        0x25,
+    },
+    {
+        0x98,
+        0x69,
+        0xe2,
+        0x47,
+        0xe9,
+        0xc0,
+        0x8b,
+        0x10,
+        0xd0,
+        0x29,
+        0x93,
+        0x4f,
+        0xc4,
+        0xb9,
+        0x52,
+        0xf7,
+    },
+    {
+        0x31,
+        0xfc,
+        0xef,
+        0xac,
+        0x66,
+        0xd7,
+        0xde,
+        0x9c,
+        0x7e,
+        0xc7,
+        0x48,
+        0x5f,
+        0xe4,
+        0x49,
+        0x49,
+        0x02,
+    },
+    {
+        0x54,
+        0x93,
+        0xe9,
+        0x99,
+        0x33,
+        0xb0,
+        0xa8,
+        0x11,
+        0x7e,
+        0x08,
+        0xec,
+        0x0f,
+        0x97,
+        0xcf,
+        0xc3,
+        0xd9,
+    },
+    {
+        0x6e,
+        0xe2,
+        0xa4,
+        0xca,
+        0x67,
+        0xb0,
+        0x54,
+        0xbb,
+        0xfd,
+        0x33,
+        0x15,
+        0xbf,
+        0x85,
+        0x23,
+        0x05,
+        0x77,
+    },
+    {
+        0x47,
+        0x3d,
+        0x06,
+        0xe8,
+        0x73,
+        0x8d,
+        0xb8,
+        0x98,
+        0x54,
+        0xc0,
+        0x66,
+        0xc4,
+        0x7a,
+        0xe4,
+        0x77,
+        0x40,
+    },
+    {
+        0xa4,
+        0x26,
+        0xe5,
+        0xe4,
+        0x23,
+        0xbf,
+        0x48,
+        0x85,
+        0x29,
+        0x4d,
+        0xa4,
+        0x81,
+        0xfe,
+        0xae,
+        0xf7,
+        0x23,
+    },
+    {
+        0x78,
+        0x01,
+        0x77,
+        0x31,
+        0xcf,
+        0x65,
+        0xfa,
+        0xb0,
+        0x74,
+        0xd5,
+        0x20,
+        0x89,
+        0x52,
+        0x51,
+        0x2e,
+        0xb1,
+    },
+    {
+        0x9e,
+        0x25,
+        0xfc,
+        0x83,
+        0x3f,
+        0x22,
+        0x90,
+        0x73,
+        0x3e,
+        0x93,
+        0x44,
+        0xa5,
+        0xe8,
+        0x38,
+        0x39,
+        0xeb,
+    },
+    {
+        0x56,
+        0x8e,
+        0x49,
+        0x5a,
+        0xbe,
+        0x52,
+        0x5a,
+        0x21,
+        0x8a,
+        0x22,
+        0x14,
+        0xcd,
+        0x3e,
+        0x07,
+        0x1d,
+        0x12,
+    },
+    {
+        0x4a,
+        0x29,
+        0xb5,
+        0x45,
+        0x52,
+        0xd1,
+        0x6b,
+        0x9a,
+        0x46,
+        0x9c,
+        0x10,
+        0x52,
+        0x8e,
+        0xff,
+        0x0a,
+        0xae,
+    },
+    {
+        0xc9,
+        0xd1,
+        0x84,
+        0xdd,
+        0xd5,
+        0xa9,
+        0xf5,
+        0xe0,
+        0xcf,
+        0x8c,
+        0xe2,
+        0x9a,
+        0x9a,
+        0xbf,
+        0x69,
+        0x1c,
+    },
+    {
+        0x2d,
+        0xb4,
+        0x79,
+        0xae,
+        0x78,
+        0xbd,
+        0x50,
+        0xd8,
+        0x88,
+        0x2a,
+        0x8a,
+        0x17,
+        0x8a,
+        0x61,
+        0x32,
+        0xad,
+    },
+    {
+        0x8e,
+        0xce,
+        0x5f,
+        0x04,
+        0x2d,
+        0x5e,
+        0x44,
+        0x7b,
+        0x50,
+        0x51,
+        0xb9,
+        0xea,
+        0xcb,
+        0x8d,
+        0x8f,
+        0x6f,
+    },
+    {
+        0x9c,
+        0x0b,
+        0x53,
+        0xb4,
+        0xb3,
+        0xc3,
+        0x07,
+        0xe8,
+        0x7e,
+        0xae,
+        0xe0,
+        0x86,
+        0x78,
+        0x14,
+        0x1f,
+        0x66,
+    },
+    {
+        0xab,
+        0xf2,
+        0x48,
+        0xaf,
+        0x69,
+        0xa6,
+        0xea,
+        0xe4,
+        0xbf,
+        0xd3,
+        0xeb,
+        0x2f,
+        0x12,
+        0x9e,
+        0xeb,
+        0x94,
+    },
+    {
+        0x06,
+        0x64,
+        0xda,
+        0x16,
+        0x68,
+        0x57,
+        0x4b,
+        0x88,
+        0xb9,
+        0x35,
+        0xf3,
+        0x02,
+        0x73,
+        0x58,
+        0xae,
+        0xf4,
+    },
+    {
+        0xaa,
+        0x4b,
+        0x9d,
+        0xc4,
+        0xbf,
+        0x33,
+        0x7d,
+        0xe9,
+        0x0c,
+        0xd4,
+        0xfd,
+        0x3c,
+        0x46,
+        0x7c,
+        0x6a,
+        0xb7,
+    },
+    {
+        0xea,
+        0x5c,
+        0x7f,
+        0x47,
+        0x1f,
+        0xaf,
+        0x6b,
+        0xde,
+        0x2b,
+        0x1a,
+        0xd7,
+        0xd4,
+        0x68,
+        0x6d,
+        0x22,
+        0x87,
+    },
+    {
+        0x29,
+        0x39,
+        0xb0,
+        0x18,
+        0x32,
+        0x23,
+        0xfa,
+        0xfc,
+        0x17,
+        0x23,
+        0xde,
+        0x4f,
+        0x52,
+        0xc4,
+        0x3d,
+        0x35,
+    },
+    {
+        0x7c,
+        0x39,
+        0x56,
+        0xca,
+        0x5e,
+        0xea,
+        0xfc,
+        0x3e,
+        0x36,
+        0x3e,
+        0x9d,
+        0x55,
+        0x65,
+        0x46,
+        0xeb,
+        0x68,
+    },
+    {
+        0x77,
+        0xc6,
+        0x07,
+        0x71,
+        0x46,
+        0xf0,
+        0x1c,
+        0x32,
+        0xb6,
+        0xb6,
+        0x9d,
+        0x5f,
+        0x4e,
+        0xa9,
+        0xff,
+        0xcf,
+    },
+    {
+        0x37,
+        0xa6,
+        0x98,
+        0x6c,
+        0xb8,
+        0x84,
+        0x7e,
+        0xdf,
+        0x09,
+        0x25,
+        0xf0,
+        0xf1,
+        0x30,
+        0x9b,
+        0x54,
+        0xde,
+    },
+    {
+        0xa7,
+        0x05,
+        0xf0,
+        0xe6,
+        0x9d,
+        0xa9,
+        0xa8,
+        0xf9,
+        0x07,
+        0x24,
+        0x1a,
+        0x2e,
+        0x92,
+        0x3c,
+        0x8c,
+        0xc8,
+    },
+    {
+        0x3d,
+        0xc4,
+        0x7d,
+        0x1f,
+        0x29,
+        0xc4,
+        0x48,
+        0x46,
+        0x1e,
+        0x9e,
+        0x76,
+        0xed,
+        0x90,
+        0x4f,
+        0x67,
+        0x11,
+    },
+    {
+        0x0d,
+        0x62,
+        0xbf,
+        0x01,
+        0xe6,
+        0xfc,
+        0x0e,
+        0x1a,
+        0x0d,
+        0x3c,
+        0x47,
+        0x51,
+        0xc5,
+        0xd3,
+        0x69,
+        0x2b,
+    },
+    {
+        0x8c,
+        0x03,
+        0x46,
+        0x8b,
+        0xca,
+        0x7c,
+        0x66,
+        0x9e,
+        0xe4,
+        0xfd,
+        0x5e,
+        0x08,
+        0x4b,
+        0xbe,
+        0xe7,
+        0xb5,
+    },
+    {
+        0x52,
+        0x8a,
+        0x5b,
+        0xb9,
+        0x3b,
+        0xaf,
+        0x2c,
+        0x9c,
+        0x44,
+        0x73,
+        0xcc,
+        0xe5,
+        0xd0,
+        0xd2,
+        0x2b,
+        0xd9,
+    },
+    {
+        0xdf,
+        0x6a,
+        0x30,
+        0x1e,
+        0x95,
+        0xc9,
+        0x5d,
+        0xad,
+        0x97,
+        0xae,
+        0x0c,
+        0xc8,
+        0xc6,
+        0x91,
+        0x3b,
+        0xd8,
+    },
+    {
+        0x80,
+        0x11,
+        0x89,
+        0x90,
+        0x2c,
+        0x85,
+        0x7f,
+        0x39,
+        0xe7,
+        0x35,
+        0x91,
+        0x28,
+        0x5e,
+        0x70,
+        0xb6,
+        0xdb,
+    },
+    {
+        0xe6,
+        0x17,
+        0x34,
+        0x6a,
+        0xc9,
+        0xc2,
+        0x31,
+        0xbb,
+        0x36,
+        0x50,
+        0xae,
+        0x34,
+        0xcc,
+        0xca,
+        0x0c,
+        0x5b,
+    },
+    {
+        0x27,
+        0xd9,
+        0x34,
+        0x37,
+        0xef,
+        0xb7,
+        0x21,
+        0xaa,
+        0x40,
+        0x18,
+        0x21,
+        0xdc,
+        0xec,
+        0x5a,
+        0xdf,
+        0x89,
+    },
+    {
+        0x89,
+        0x23,
+        0x7d,
+        0x9d,
+        0xed,
+        0x9c,
+        0x5e,
+        0x78,
+        0xd8,
+        0xb1,
+        0xc9,
+        0xb1,
+        0x66,
+        0xcc,
+        0x73,
+        0x42,
+    },
+    {
+        0x4a,
+        0x6d,
+        0x80,
+        0x91,
+        0xbf,
+        0x5e,
+        0x7d,
+        0x65,
+        0x11,
+        0x89,
+        0xfa,
+        0x94,
+        0xa2,
+        0x50,
+        0xb1,
+        0x4c,
+    },
+    {
+        0x0e,
+        0x33,
+        0xf9,
+        0x60,
+        0x55,
+        0xe7,
+        0xae,
+        0x89,
+        0x3f,
+        0xfc,
+        0x0e,
+        0x3d,
+        0xcf,
+        0x49,
+        0x29,
+        0x02,
+    },
+    {
+        0xe6,
+        0x1c,
+        0x43,
+        0x2b,
+        0x72,
+        0x0b,
+        0x19,
+        0xd1,
+        0x8e,
+        0xc8,
+        0xd8,
+        0x4b,
+        0xdc,
+        0x63,
+        0x15,
+        0x1b,
+    },
+    {
+        0xf7,
+        0xe5,
+        0xae,
+        0xf5,
+        0x49,
+        0xf7,
+        0x82,
+        0xcf,
+        0x37,
+        0x90,
+        0x55,
+        0xa6,
+        0x08,
+        0x26,
+        0x9b,
+        0x16,
+    },
+    {
+        0x43,
+        0x8d,
+        0x03,
+        0x0f,
+        0xd0,
+        0xb7,
+        0xa5,
+        0x4f,
+        0xa8,
+        0x37,
+        0xf2,
+        0xad,
+        0x20,
+        0x1a,
+        0x64,
+        0x03,
+    },
+    {
+        0xa5,
+        0x90,
+        0xd3,
+        0xee,
+        0x4f,
+        0xbf,
+        0x04,
+        0xe3,
+        0x24,
+        0x7e,
+        0x0d,
+        0x27,
+        0xf2,
+        0x86,
+        0x42,
+        0x3f,
+    },
+    {
+        0x5f,
+        0xe2,
+        0xc1,
+        0xa1,
+        0x72,
+        0xfe,
+        0x93,
+        0xc4,
+        0xb1,
+        0x5c,
+        0xd3,
+        0x7c,
+        0xae,
+        0xf9,
+        0xf5,
+        0x38,
+    },
+    {
+        0x2c,
+        0x97,
+        0x32,
+        0x5c,
+        0xbd,
+        0x06,
+        0xb3,
+        0x6e,
+        0xb2,
+        0x13,
+        0x3d,
+        0xd0,
+        0x8b,
+        0x3a,
+        0x01,
+        0x7c,
+    },
+    {
+        0x92,
+        0xc8,
+        0x14,
+        0x22,
+        0x7a,
+        0x6b,
+        0xca,
+        0x94,
+        0x9f,
+        0xf0,
+        0x65,
+        0x9f,
+        0x00,
+        0x2a,
+        0xd3,
+        0x9e,
+    },
+    {
+        0xdc,
+        0xe8,
+        0x50,
+        0x11,
+        0x0b,
+        0xd8,
+        0x32,
+        0x8c,
+        0xfb,
+        0xd5,
+        0x08,
+        0x41,
+        0xd6,
+        0x91,
+        0x1d,
+        0x87,
+    },
+    {
+        0x67,
+        0xf1,
+        0x49,
+        0x84,
+        0xc7,
+        0xda,
+        0x79,
+        0x12,
+        0x48,
+        0xe3,
+        0x2b,
+        0xb5,
+        0x92,
+        0x25,
+        0x83,
+        0xda,
+    },
+    {
+        0x19,
+        0x38,
+        0xf2,
+        0xcf,
+        0x72,
+        0xd5,
+        0x4e,
+        0xe9,
+        0x7e,
+        0x94,
+        0x16,
+        0x6f,
+        0xa9,
+        0x1d,
+        0x2a,
+        0x36,
+    },
+    {
+        0x74,
+        0x48,
+        0x1e,
+        0x96,
+        0x46,
+        0xed,
+        0x49,
+        0xfe,
+        0x0f,
+        0x62,
+        0x24,
+        0x30,
+        0x16,
+        0x04,
+        0x69,
+        0x8e,
+    },
+    {
+        0x57,
+        0xfc,
+        0xa5,
+        0xde,
+        0x98,
+        0xa9,
+        0xd6,
+        0xd8,
+        0x00,
+        0x64,
+        0x38,
+        0xd0,
+        0x58,
+        0x3d,
+        0x8a,
+        0x1d,
+    },
+    {
+        0x9f,
+        0xec,
+        0xde,
+        0x1c,
+        0xef,
+        0xdc,
+        0x1c,
+        0xbe,
+        0xd4,
+        0x76,
+        0x36,
+        0x74,
+        0xd9,
+        0x57,
+        0x53,
+        0x59,
+    },
+    {
+        0xe3,
+        0x04,
+        0x0c,
+        0x00,
+        0xeb,
+        0x28,
+        0xf1,
+        0x53,
+        0x66,
+        0xca,
+        0x73,
+        0xcb,
+        0xd8,
+        0x72,
+        0xe7,
+        0x40,
+    },
+    {
+        0x76,
+        0x97,
+        0x00,
+        0x9a,
+        0x6a,
+        0x83,
+        0x1d,
+        0xfe,
+        0xcc,
+        0xa9,
+        0x1c,
+        0x59,
+        0x93,
+        0x67,
+        0x0f,
+        0x7a,
+    },
+    {
+        0x58,
+        0x53,
+        0x54,
+        0x23,
+        0x21,
+        0xf5,
+        0x67,
+        0xa0,
+        0x05,
+        0xd5,
+        0x47,
+        0xa4,
+        0xf0,
+        0x47,
+        0x59,
+        0xbd,
+    },
+    {
+        0x51,
+        0x50,
+        0xd1,
+        0x77,
+        0x2f,
+        0x50,
+        0x83,
+        0x4a,
+        0x50,
+        0x3e,
+        0x06,
+        0x9a,
+        0x97,
+        0x3f,
+        0xbd,
+        0x7c,
+    },
+};
+
 } // end anonymous namespace

More information about the llvm-branch-commits mailing list