[llvm] 577c3f1 - [Support] Integrate SipHash.cpp into libSupport. (#94394)

via llvm-commits llvm-commits at lists.llvm.org
Fri Jun 14 17:07:44 PDT 2024


Author: Ahmed Bougacha
Date: 2024-06-14T17:07:41-07:00
New Revision: 577c3f114b7c342ea6d8b69d3c4f22ce26d96b13

URL: https://github.com/llvm/llvm-project/commit/577c3f114b7c342ea6d8b69d3c4f22ce26d96b13
DIFF: https://github.com/llvm/llvm-project/commit/577c3f114b7c342ea6d8b69d3c4f22ce26d96b13.diff

LOG: [Support] Integrate SipHash.cpp into libSupport.  (#94394)

Start building it as part of the library, with some minor
tweaks compared to the reference implementation:
- clang-format to match libSupport
- remove tracing support
- add file header
- templatize cROUNDS/dROUNDS, as well as 8B/16B result length
- replace assert with static_assert
- use LLVM_FALLTHROUGH

This also exports interfaces for SipHash-2-4-64/-128, and
tests them using the reference test vectors.

Added: 
    llvm/include/llvm/Support/SipHash.h

Modified: 
    llvm/lib/Support/CMakeLists.txt
    llvm/lib/Support/SipHash.cpp
    llvm/unittests/Support/CMakeLists.txt
    llvm/unittests/Support/SipHashTest.cpp

Removed: 
    


################################################################################
diff  --git a/llvm/include/llvm/Support/SipHash.h b/llvm/include/llvm/Support/SipHash.h
new file mode 100644
index 0000000000000..56dea80ef2e6b
--- /dev/null
+++ b/llvm/include/llvm/Support/SipHash.h
@@ -0,0 +1,33 @@
+//===--- 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 {
+
+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],
+                       uint8_t (&Out)[8]);
+
+/// Computes a SipHash-2-4 128-bit result.
+void getSipHash_2_4_128(ArrayRef<uint8_t> In, const uint8_t (&K)[16],
+                        uint8_t (&Out)[16]);
+
+} // end namespace llvm
+
+#endif

diff  --git a/llvm/lib/Support/CMakeLists.txt b/llvm/lib/Support/CMakeLists.txt
index 7632f33afce7d..2af6b20dddae3 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
@@ -227,6 +224,7 @@ add_llvm_component_library(LLVMSupport
   SHA1.cpp
   SHA256.cpp
   Signposts.cpp
+  SipHash.cpp
   SlowDynamicAPInt.cpp
   SmallPtrSet.cpp
   SmallVector.cpp

diff  --git a/llvm/lib/Support/SipHash.cpp b/llvm/lib/Support/SipHash.cpp
index c6d16e205521d..ed1a305f0443f 100644
--- a/llvm/lib/Support/SipHash.cpp
+++ b/llvm/lib/Support/SipHash.cpp
@@ -1,185 +1,155 @@
-/*
-   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/>.
- */
-
-#include "siphash.h"
-#include <assert.h>
-#include <stddef.h>
-#include <stdint.h>
-
-/* default: SipHash-2-4 */
-#ifndef cROUNDS
-#define cROUNDS 2
-#endif
-#ifndef dROUNDS
-#define dROUNDS 4
-#endif
+//===--- 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 "llvm/Support/SipHash.h"
+#include "llvm/ADT/ArrayRef.h"
+#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 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) |                 \
-     ((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)
-
-#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)
-    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) {
-
-    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;
-
-    TRACE;
-    for (i = 0; i < cROUNDS; ++i)
-        SIPROUND;
-
-    v0 ^= b;
-
-    if (outlen == 16)
-        v2 ^= 0xee;
-    else
-        v2 ^= 0xff;
+  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)
+
+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, 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;
+
+  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 = 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));
+  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 = endian::read64le(ni);
+    v3 ^= m;
 
-    TRACE;
-    for (i = 0; i < dROUNDS; ++i)
-        SIPROUND;
-
-    b = v0 ^ v1 ^ v2 ^ v3;
-    U64TO8_LE(out, b);
-
-    if (outlen == 8)
-        return 0;
-
-    v1 ^= 0xdd;
+    for (i = 0; i < cROUNDS; ++i)
+      SIPROUND;
+
+    v0 ^= m;
+  }
+
+  switch (left) {
+  case 7:
+    b |= ((uint64_t)ni[6]) << 48;
+    LLVM_FALLTHROUGH;
+  case 6:
+    b |= ((uint64_t)ni[5]) << 40;
+    LLVM_FALLTHROUGH;
+  case 5:
+    b |= ((uint64_t)ni[4]) << 32;
+    LLVM_FALLTHROUGH;
+  case 4:
+    b |= ((uint64_t)ni[3]) << 24;
+    LLVM_FALLTHROUGH;
+  case 3:
+    b |= ((uint64_t)ni[2]) << 16;
+    LLVM_FALLTHROUGH;
+  case 2:
+    b |= ((uint64_t)ni[1]) << 8;
+    LLVM_FALLTHROUGH;
+  case 1:
+    b |= ((uint64_t)ni[0]);
+    break;
+  case 0:
+    break;
+  }
+
+  v3 ^= b;
+
+  for (i = 0; i < cROUNDS; ++i)
+    SIPROUND;
+
+  v0 ^= b;
+
+  if (outlen == 16)
+    v2 ^= 0xee;
+  else
+    v2 ^= 0xff;
+
+  for (i = 0; i < dROUNDS; ++i)
+    SIPROUND;
+
+  b = v0 ^ v1 ^ v2 ^ v3;
+  endian::write64le(out, b);
+
+  if (outlen == 8)
+    return;
+
+  v1 ^= 0xdd;
+
+  for (i = 0; i < dROUNDS; ++i)
+    SIPROUND;
+
+  b = v0 ^ v1 ^ v2 ^ v3;
+  endian::write64le(out + 8, b);
+}
 
-    TRACE;
-    for (i = 0; i < dROUNDS; ++i)
-        SIPROUND;
+} // end anonymous namespace
 
-    b = v0 ^ v1 ^ v2 ^ v3;
-    U64TO8_LE(out + 8, b);
+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);
+}
 
-    return 0;
+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);
 }

diff  --git a/llvm/unittests/Support/CMakeLists.txt b/llvm/unittests/Support/CMakeLists.txt
index 548bdf96c6aca..631f2e6bf00df 100644
--- a/llvm/unittests/Support/CMakeLists.txt
+++ b/llvm/unittests/Support/CMakeLists.txt
@@ -3,9 +3,6 @@ set(LLVM_LINK_COMPONENTS
   TargetParser
   )
 
-# Temporarily ignore SipHashTest.cpp before we fully integrate it.
-set(LLVM_OPTIONAL_SOURCES SipHashTest.cpp)
-
 add_llvm_unittest(SupportTests
   AddressRangeTest.cpp
   AlignmentTest.cpp
@@ -78,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
index 1a0ca045f8d9d..bd05c278fc7a2 100644
--- a/llvm/unittests/Support/SipHashTest.cpp
+++ b/llvm/unittests/Support/SipHashTest.cpp
@@ -1,6 +1,58 @@
-#include <stdint.h>
+//===- 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
+//
+//===----------------------------------------------------------------------===//
 
-const uint8_t vectors_sip64[64][8] = {
+#include "llvm/Support/SipHash.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "gtest/gtest.h"
+#include <string.h>
+
+using namespace llvm;
+
+namespace {
+
+// Tests from the SipHash reference implementation:
+//   https://github.com/veorq/SipHash
+// 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];
+  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(ArrayRef(In, InLen), K, Out);
+    for (size_t I = 0; I < sizeof(Out); ++I)
+      EXPECT_EQ(ExpectedSipHash64[InLen][I], Out[I]);
+  }
+}
+
+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(ArrayRef(In, InLen), K, Out);
+    for (size_t I = 0; I < sizeof(Out); ++I)
+      EXPECT_EQ(ExpectedSipHash128[InLen][I], Out[I]);
+  }
+}
+
+// Below are the unmodified expected outputs from vectors.h
+
+const uint8_t ExpectedSipHash64[64][8] = {
     {
         0x31,
         0x0e,
@@ -642,7 +694,8 @@ const uint8_t vectors_sip64[64][8] = {
         0x95,
     },
 };
-const uint8_t vectors_sip128[64][16] = {
+
+const uint8_t ExpectedSipHash128[64][16] = {
     {
         0xa3,
         0x81,
@@ -1796,1031 +1849,5 @@ const uint8_t vectors_sip128[64][16] = {
         0x7c,
     },
 };
-const uint8_t vectors_hsip32[64][4] = {
-    {
-        0xa9,
-        0x35,
-        0x9f,
-        0x5b,
-    },
-    {
-        0x27,
-        0x47,
-        0x5a,
-        0xb8,
-    },
-    {
-        0xfa,
-        0x62,
-        0xa6,
-        0x03,
-    },
-    {
-        0x8a,
-        0xfe,
-        0xe7,
-        0x04,
-    },
-    {
-        0x2a,
-        0x6e,
-        0x46,
-        0x89,
-    },
-    {
-        0xc5,
-        0xfa,
-        0xb6,
-        0x69,
-    },
-    {
-        0x58,
-        0x63,
-        0xfc,
-        0x23,
-    },
-    {
-        0x8b,
-        0xcf,
-        0x63,
-        0xc5,
-    },
-    {
-        0xd0,
-        0xb8,
-        0x84,
-        0x8f,
-    },
-    {
-        0xf8,
-        0x06,
-        0xe7,
-        0x79,
-    },
-    {
-        0x94,
-        0xb0,
-        0x79,
-        0x34,
-    },
-    {
-        0x08,
-        0x08,
-        0x30,
-        0x50,
-    },
-    {
-        0x57,
-        0xf0,
-        0x87,
-        0x2f,
-    },
-    {
-        0x77,
-        0xe6,
-        0x63,
-        0xff,
-    },
-    {
-        0xd6,
-        0xff,
-        0xf8,
-        0x7c,
-    },
-    {
-        0x74,
-        0xfe,
-        0x2b,
-        0x97,
-    },
-    {
-        0xd9,
-        0xb5,
-        0xac,
-        0x84,
-    },
-    {
-        0xc4,
-        0x74,
-        0x64,
-        0x5b,
-    },
-    {
-        0x46,
-        0x5b,
-        0x8d,
-        0x9b,
-    },
-    {
-        0x7b,
-        0xef,
-        0xe3,
-        0x87,
-    },
-    {
-        0xe3,
-        0x4d,
-        0x10,
-        0x45,
-    },
-    {
-        0x61,
-        0x3f,
-        0x62,
-        0xb3,
-    },
-    {
-        0x70,
-        0xf3,
-        0x67,
-        0xfe,
-    },
-    {
-        0xe6,
-        0xad,
-        0xb8,
-        0xbd,
-    },
-    {
-        0x27,
-        0x40,
-        0x0c,
-        0x63,
-    },
-    {
-        0x26,
-        0x78,
-        0x78,
-        0x75,
-    },
-    {
-        0x4f,
-        0x56,
-        0x7b,
-        0x5f,
-    },
-    {
-        0x3a,
-        0xb0,
-        0xe6,
-        0x69,
-    },
-    {
-        0xb0,
-        0x64,
-        0x40,
-        0x00,
-    },
-    {
-        0xff,
-        0x67,
-        0x0f,
-        0xb4,
-    },
-    {
-        0x50,
-        0x9e,
-        0x33,
-        0x8b,
-    },
-    {
-        0x5d,
-        0x58,
-        0x9f,
-        0x1a,
-    },
-    {
-        0xfe,
-        0xe7,
-        0x21,
-        0x12,
-    },
-    {
-        0x33,
-        0x75,
-        0x32,
-        0x59,
-    },
-    {
-        0x6a,
-        0x43,
-        0x4f,
-        0x8c,
-    },
-    {
-        0xfe,
-        0x28,
-        0xb7,
-        0x29,
-    },
-    {
-        0xe7,
-        0x5c,
-        0xc6,
-        0xec,
-    },
-    {
-        0x69,
-        0x7e,
-        0x8d,
-        0x54,
-    },
-    {
-        0x63,
-        0x68,
-        0x8b,
-        0x0f,
-    },
-    {
-        0x65,
-        0x0b,
-        0x62,
-        0xb4,
-    },
-    {
-        0xb6,
-        0xbc,
-        0x18,
-        0x40,
-    },
-    {
-        0x5d,
-        0x07,
-        0x45,
-        0x05,
-    },
-    {
-        0x24,
-        0x42,
-        0xfd,
-        0x2e,
-    },
-    {
-        0x7b,
-        0xb7,
-        0x86,
-        0x3a,
-    },
-    {
-        0x77,
-        0x05,
-        0xd5,
-        0x48,
-    },
-    {
-        0xd7,
-        0x52,
-        0x08,
-        0xb1,
-    },
-    {
-        0xb6,
-        0xd4,
-        0x99,
-        0xc8,
-    },
-    {
-        0x08,
-        0x92,
-        0x20,
-        0x2e,
-    },
-    {
-        0x69,
-        0xe1,
-        0x2c,
-        0xe3,
-    },
-    {
-        0x8d,
-        0xb5,
-        0x80,
-        0xe5,
-    },
-    {
-        0x36,
-        0x97,
-        0x64,
-        0xc6,
-    },
-    {
-        0x01,
-        0x6e,
-        0x02,
-        0x04,
-    },
-    {
-        0x3b,
-        0x85,
-        0xf3,
-        0xd4,
-    },
-    {
-        0xfe,
-        0xdb,
-        0x66,
-        0xbe,
-    },
-    {
-        0x1e,
-        0x69,
-        0x2a,
-        0x3a,
-    },
-    {
-        0xc6,
-        0x89,
-        0x84,
-        0xc0,
-    },
-    {
-        0xa5,
-        0xc5,
-        0xb9,
-        0x40,
-    },
-    {
-        0x9b,
-        0xe9,
-        0xe8,
-        0x8c,
-    },
-    {
-        0x7d,
-        0xbc,
-        0x81,
-        0x40,
-    },
-    {
-        0x7c,
-        0x07,
-        0x8e,
-        0xc5,
-    },
-    {
-        0xd4,
-        0xe7,
-        0x6c,
-        0x73,
-    },
-    {
-        0x42,
-        0x8f,
-        0xcb,
-        0xb9,
-    },
-    {
-        0xbd,
-        0x83,
-        0x99,
-        0x7a,
-    },
-    {
-        0x59,
-        0xea,
-        0x4a,
-        0x74,
-    },
-};
-const uint8_t vectors_hsip64[64][8] = {
-    {
-        0x21,
-        0x8d,
-        0x1f,
-        0x59,
-        0xb9,
-        0xb8,
-        0x3c,
-        0xc8,
-    },
-    {
-        0xbe,
-        0x55,
-        0x24,
-        0x12,
-        0xf8,
-        0x38,
-        0x73,
-        0x15,
-    },
-    {
-        0x06,
-        0x4f,
-        0x39,
-        0xef,
-        0x7c,
-        0x50,
-        0xeb,
-        0x57,
-    },
-    {
-        0xce,
-        0x0f,
-        0x1a,
-        0x45,
-        0xf7,
-        0x06,
-        0x06,
-        0x79,
-    },
-    {
-        0xd5,
-        0xe7,
-        0x8a,
-        0x17,
-        0x5b,
-        0xe5,
-        0x2e,
-        0xa1,
-    },
-    {
-        0xcb,
-        0x9d,
-        0x7c,
-        0x3f,
-        0x2f,
-        0x3d,
-        0xb5,
-        0x80,
-    },
-    {
-        0xce,
-        0x3e,
-        0x91,
-        0x35,
-        0x8a,
-        0xa2,
-        0xbc,
-        0x25,
-    },
-    {
-        0xff,
-        0x20,
-        0x27,
-        0x28,
-        0xb0,
-        0x7b,
-        0xc6,
-        0x84,
-    },
-    {
-        0xed,
-        0xfe,
-        0xe8,
-        0x20,
-        0xbc,
-        0xe4,
-        0x85,
-        0x8c,
-    },
-    {
-        0x5b,
-        0x51,
-        0xcc,
-        0xcc,
-        0x13,
-        0x88,
-        0x83,
-        0x07,
-    },
-    {
-        0x95,
-        0xb0,
-        0x46,
-        0x9f,
-        0x06,
-        0xa6,
-        0xf2,
-        0xee,
-    },
-    {
-        0xae,
-        0x26,
-        0x33,
-        0x39,
-        0x94,
-        0xdd,
-        0xcd,
-        0x48,
-    },
-    {
-        0x7b,
-        0xc7,
-        0x1f,
-        0x9f,
-        0xae,
-        0xf5,
-        0xc7,
-        0x99,
-    },
-    {
-        0x5a,
-        0x23,
-        0x52,
-        0xd7,
-        0x5a,
-        0x0c,
-        0x37,
-        0x44,
-    },
-    {
-        0x3b,
-        0xb1,
-        0xa8,
-        0x70,
-        0xea,
-        0xe8,
-        0xe6,
-        0x58,
-    },
-    {
-        0x21,
-        0x7d,
-        0x0b,
-        0xcb,
-        0x4e,
-        0x81,
-        0xc9,
-        0x02,
-    },
-    {
-        0x73,
-        0x36,
-        0xaa,
-        0xd2,
-        0x5f,
-        0x7b,
-        0xf3,
-        0xb5,
-    },
-    {
-        0x37,
-        0xad,
-        0xc0,
-        0x64,
-        0x1c,
-        0x4c,
-        0x4f,
-        0x6a,
-    },
-    {
-        0xc9,
-        0xb2,
-        0xdb,
-        0x2b,
-        0x9a,
-        0x3e,
-        0x42,
-        0xf9,
-    },
-    {
-        0xf9,
-        0x10,
-        0xe4,
-        0x80,
-        0x20,
-        0xab,
-        0x36,
-        0x3c,
-    },
-    {
-        0x1b,
-        0xf5,
-        0x2b,
-        0x0a,
-        0x6f,
-        0xee,
-        0xa7,
-        0xdb,
-    },
-    {
-        0x00,
-        0x74,
-        0x1d,
-        0xc2,
-        0x69,
-        0xe8,
-        0xb3,
-        0xef,
-    },
-    {
-        0xe2,
-        0x01,
-        0x03,
-        0xfa,
-        0x1b,
-        0xa7,
-        0x76,
-        0xef,
-    },
-    {
-        0x4c,
-        0x22,
-        0x10,
-        0xe5,
-        0x4b,
-        0x68,
-        0x1d,
-        0x73,
-    },
-    {
-        0x70,
-        0x74,
-        0x10,
-        0x45,
-        0xae,
-        0x3f,
-        0xa6,
-        0xf1,
-    },
-    {
-        0x0c,
-        0x86,
-        0x40,
-        0x37,
-        0x39,
-        0x71,
-        0x40,
-        0x38,
-    },
-    {
-        0x0d,
-        0x89,
-        0x9e,
-        0xd8,
-        0x11,
-        0x29,
-        0x23,
-        0xf0,
-    },
-    {
-        0x22,
-        0x6b,
-        0xf5,
-        0xfa,
-        0xb8,
-        0x1e,
-        0xe1,
-        0xb8,
-    },
-    {
-        0x2d,
-        0x92,
-        0x5f,
-        0xfb,
-        0x1e,
-        0x00,
-        0x16,
-        0xb5,
-    },
-    {
-        0x36,
-        0x19,
-        0x58,
-        0xd5,
-        0x2c,
-        0xee,
-        0x10,
-        0xf1,
-    },
-    {
-        0x29,
-        0x1a,
-        0xaf,
-        0x86,
-        0x48,
-        0x98,
-        0x17,
-        0x9d,
-    },
-    {
-        0x86,
-        0x3c,
-        0x7f,
-        0x15,
-        0x5c,
-        0x34,
-        0x11,
-        0x7c,
-    },
-    {
-        0x28,
-        0x70,
-        0x9d,
-        0x46,
-        0xd8,
-        0x11,
-        0x62,
-        0x6c,
-    },
-    {
-        0x24,
-        0x84,
-        0x77,
-        0x68,
-        0x1d,
-        0x28,
-        0xf8,
-        0x9c,
-    },
-    {
-        0x83,
-        0x24,
-        0xe4,
-        0xd7,
-        0x52,
-        0x8f,
-        0x98,
-        0x30,
-    },
-    {
-        0xf9,
-        0xef,
-        0xd4,
-        0xe1,
-        0x3a,
-        0xea,
-        0x6b,
-        0xd8,
-    },
-    {
-        0x86,
-        0xd6,
-        0x7a,
-        0x40,
-        0xec,
-        0x42,
-        0x76,
-        0xdc,
-    },
-    {
-        0x3f,
-        0x62,
-        0x92,
-        0xec,
-        0xcc,
-        0xa9,
-        0x7e,
-        0x35,
-    },
-    {
-        0xcb,
-        0xd9,
-        0x2e,
-        0xe7,
-        0x24,
-        0xd4,
-        0x21,
-        0x09,
-    },
-    {
-        0x36,
-        0x8d,
-        0xf6,
-        0x80,
-        0x8d,
-        0x40,
-        0x3d,
-        0x79,
-    },
-    {
-        0x5b,
-        0x38,
-        0xc8,
-        0x1c,
-        0x67,
-        0xc8,
-        0xae,
-        0x4c,
-    },
-    {
-        0x95,
-        0xab,
-        0x71,
-        0x89,
-        0xd4,
-        0x39,
-        0xac,
-        0xb3,
-    },
-    {
-        0xa9,
-        0x1a,
-        0x52,
-        0xc0,
-        0x25,
-        0x32,
-        0x70,
-        0x24,
-    },
-    {
-        0x5b,
-        0x00,
-        0x87,
-        0xc6,
-        0x95,
-        0x28,
-        0xac,
-        0xea,
-    },
-    {
-        0x1e,
-        0x30,
-        0xf3,
-        0xad,
-        0x27,
-        0xdc,
-        0xb1,
-        0x5a,
-    },
-    {
-        0x69,
-        0x7f,
-        0x5c,
-        0x9a,
-        0x90,
-        0x32,
-        0x4e,
-        0xd4,
-    },
-    {
-        0x49,
-        0x5c,
-        0x0f,
-        0x99,
-        0x55,
-        0x57,
-        0xdc,
-        0x38,
-    },
-    {
-        0x94,
-        0x27,
-        0x20,
-        0x2a,
-        0x3c,
-        0x29,
-        0xf9,
-        0x4d,
-    },
-    {
-        0xa9,
-        0xea,
-        0xa8,
-        0xc0,
-        0x4b,
-        0xa9,
-        0x3e,
-        0x3e,
-    },
-    {
-        0xee,
-        0xa4,
-        0xc1,
-        0x73,
-        0x7d,
-        0x01,
-        0x12,
-        0x18,
-    },
-    {
-        0x91,
-        0x2d,
-        0x56,
-        0x8f,
-        0xd8,
-        0xf6,
-        0x5a,
-        0x49,
-    },
-    {
-        0x56,
-        0x91,
-        0x95,
-        0x96,
-        0xb0,
-        0xff,
-        0x5c,
-        0x97,
-    },
-    {
-        0x02,
-        0x44,
-        0x5a,
-        0x79,
-        0x98,
-        0xf5,
-        0x50,
-        0xe1,
-    },
-    {
-        0x86,
-        0xec,
-        0x46,
-        0x6c,
-        0xe7,
-        0x1d,
-        0x1f,
-        0xb2,
-    },
-    {
-        0x35,
-        0x95,
-        0x69,
-        0xe7,
-        0xd2,
-        0x89,
-        0xe3,
-        0xbc,
-    },
-    {
-        0x87,
-        0x1b,
-        0x05,
-        0xca,
-        0x62,
-        0xbb,
-        0x7c,
-        0x96,
-    },
-    {
-        0xa1,
-        0xa4,
-        0x92,
-        0xf9,
-        0x42,
-        0xf1,
-        0x5f,
-        0x1d,
-    },
-    {
-        0x12,
-        0xec,
-        0x26,
-        0x7f,
-        0xf6,
-        0x09,
-        0x5b,
-        0x6e,
-    },
-    {
-        0x5d,
-        0x1b,
-        0x5e,
-        0xa1,
-        0xb2,
-        0x31,
-        0xd8,
-        0x9d,
-    },
-    {
-        0xd8,
-        0xcf,
-        0xb4,
-        0x45,
-        0x3f,
-        0x92,
-        0xee,
-        0x54,
-    },
-    {
-        0xd6,
-        0x76,
-        0x28,
-        0x90,
-        0xbf,
-        0x26,
-        0xe4,
-        0x60,
-    },
-    {
-        0x31,
-        0x35,
-        0x63,
-        0xa4,
-        0xb7,
-        0xed,
-        0x5c,
-        0xf3,
-    },
-    {
-        0xf9,
-        0x0b,
-        0x3a,
-        0xb5,
-        0x72,
-        0xd4,
-        0x66,
-        0x93,
-    },
-    {
-        0x2e,
-        0xa6,
-        0x3c,
-        0x71,
-        0xbf,
-        0x32,
-        0x60,
-        0x87,
-    },
-};
+
+} // end anonymous namespace


        


More information about the llvm-commits mailing list