@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/abseil-cpp/absl/crc/crc32c_test.cc

@@ -1,257 +0,0 @@
-// Copyright 2022 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "absl/crc/crc32c.h"
-
-#include <algorithm>
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <limits>
-#include <sstream>
-#include <string>
-#include <tuple>
-
-#include "gtest/gtest.h"
-#include "absl/crc/internal/crc32c.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/string_view.h"
-
-namespace {
-
-TEST(CRC32C, RFC3720) {
-  // Test the results of the vectors from
-  // https://www.rfc-editor.org/rfc/rfc3720#appendix-B.4
-  char data[32];
-
-  // 32 bytes of ones.
-  memset(data, 0, sizeof(data));
-  EXPECT_EQ(absl::ComputeCrc32c(absl::string_view(data, sizeof(data))),
-            absl::crc32c_t{0x8a9136aa});
-
-  // 32 bytes of ones.
-  memset(data, 0xff, sizeof(data));
-  EXPECT_EQ(absl::ComputeCrc32c(absl::string_view(data, sizeof(data))),
-            absl::crc32c_t{0x62a8ab43});
-
-  // 32 incrementing bytes.
-  for (int i = 0; i < 32; ++i) data[i] = static_cast<char>(i);
-  EXPECT_EQ(absl::ComputeCrc32c(absl::string_view(data, sizeof(data))),
-            absl::crc32c_t{0x46dd794e});
-
-  // 32 decrementing bytes.
-  for (int i = 0; i < 32; ++i) data[i] = static_cast<char>(31 - i);
-  EXPECT_EQ(absl::ComputeCrc32c(absl::string_view(data, sizeof(data))),
-            absl::crc32c_t{0x113fdb5c});
-
-  // An iSCSI - SCSI Read (10) Command PDU.
-  constexpr uint8_t cmd[48] = {
-      0x01, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
-      0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x18, 0x28, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  };
-  EXPECT_EQ(absl::ComputeCrc32c(absl::string_view(
-                reinterpret_cast<const char*>(cmd), sizeof(cmd))),
-            absl::crc32c_t{0xd9963a56});
-}
-
-std::string TestString(size_t len) {
-  std::string result;
-  result.reserve(len);
-  for (size_t i = 0; i < len; ++i) {
-    result.push_back(static_cast<char>(i % 256));
-  }
-  return result;
-}
-
-TEST(CRC32C, Compute) {
-  EXPECT_EQ(absl::ComputeCrc32c(""), absl::crc32c_t{0});
-  EXPECT_EQ(absl::ComputeCrc32c("hello world"), absl::crc32c_t{0xc99465aa});
-}
-
-TEST(CRC32C, Extend) {
-  uint32_t base = 0xC99465AA;  // CRC32C of "Hello World"
-  std::string extension = "Extension String";
-
-  EXPECT_EQ(
-      absl::ExtendCrc32c(absl::crc32c_t{base}, extension),
-      absl::crc32c_t{0xD2F65090});  // CRC32C of "Hello WorldExtension String"
-}
-
-TEST(CRC32C, ExtendByZeroes) {
-  std::string base = "hello world";
-  absl::crc32c_t base_crc = absl::crc32c_t{0xc99465aa};
-
-  constexpr size_t kExtendByValues[] = {100, 10000, 100000};
-  for (const size_t extend_by : kExtendByValues) {
-    SCOPED_TRACE(extend_by);
-    absl::crc32c_t crc2 = absl::ExtendCrc32cByZeroes(base_crc, extend_by);
-    EXPECT_EQ(crc2, absl::ComputeCrc32c(base + std::string(extend_by, '\0')));
-  }
-}
-
-// Test ExtendCrc32cByZeroes() for the full range of the size_t length,
-// including every bit. This is important because ExtendCrc32cByZeroes() is
-// implemented using an array of constants, where each entry in the array is
-// used only when a particular bit in the size_t length is set. This test
-// verifies that every entry in that array is correct.
-TEST(CRC32C, ExtendByZeroesAllLengthBits) {
-  absl::crc32c_t base_crc = absl::crc32c_t{0xc99465aa};
-  const std::array<std::tuple<uint64_t, absl::crc32c_t>, 5> kTestCases = {{
-      {0, absl::crc32c_t(0xc99465aa)},
-      {std::numeric_limits<uint32_t>::max(), absl::crc32c_t(0x9b1d5aaa)},
-      {0x12345678, absl::crc32c_t(0xcf0e9553)},
-      {std::numeric_limits<uint64_t>::max(), absl::crc32c_t(0xf5bff489)},
-      {0x12345678abcdefff, absl::crc32c_t(0xaa1ffb0b)},
-  }};
-  for (const auto &test_case : kTestCases) {
-    uint64_t length = std::get<0>(test_case);
-    absl::crc32c_t expected_value = std::get<1>(test_case);
-    SCOPED_TRACE(length);
-    if (length > std::numeric_limits<size_t>::max()) {
-      // On 32-bit platforms, 64-bit lengths cannot be used or tested.
-      continue;
-    }
-    EXPECT_EQ(absl::ExtendCrc32cByZeroes(base_crc, static_cast<size_t>(length)),
-              expected_value);
-  }
-}
-
-TEST(CRC32C, UnextendByZeroes) {
-  constexpr size_t kExtendByValues[] = {2, 200, 20000, 200000, 20000000};
-  constexpr size_t kUnextendByValues[] = {0, 100, 10000, 100000, 10000000};
-
-  for (auto seed_crc : {absl::crc32c_t{0}, absl::crc32c_t{0xc99465aa}}) {
-    SCOPED_TRACE(seed_crc);
-    for (const size_t size_1 : kExtendByValues) {
-      for (const size_t size_2 : kUnextendByValues) {
-        size_t extend_size = std::max(size_1, size_2);
-        size_t unextend_size = std::min(size_1, size_2);
-        SCOPED_TRACE(extend_size);
-        SCOPED_TRACE(unextend_size);
-
-        // Extending by A zeroes an unextending by B<A zeros should be identical
-        // to extending by A-B zeroes.
-        absl::crc32c_t crc1 = seed_crc;
-        crc1 = absl::ExtendCrc32cByZeroes(crc1, extend_size);
-        crc1 = absl::crc_internal::UnextendCrc32cByZeroes(crc1, unextend_size);
-
-        absl::crc32c_t crc2 = seed_crc;
-        crc2 = absl::ExtendCrc32cByZeroes(crc2, extend_size - unextend_size);
-
-        EXPECT_EQ(crc1, crc2);
-      }
-    }
-  }
-
-  constexpr size_t kSizes[] = {0, 1, 100, 10000};
-  for (const size_t size : kSizes) {
-    SCOPED_TRACE(size);
-    std::string string_before = TestString(size);
-    std::string string_after = string_before + std::string(size, '\0');
-
-    absl::crc32c_t crc_before = absl::ComputeCrc32c(string_before);
-    absl::crc32c_t crc_after = absl::ComputeCrc32c(string_after);
-
-    EXPECT_EQ(crc_before,
-              absl::crc_internal::UnextendCrc32cByZeroes(crc_after, size));
-  }
-}
-
-TEST(CRC32C, Concat) {
-  std::string hello = "Hello, ";
-  std::string world = "world!";
-  std::string hello_world = absl::StrCat(hello, world);
-
-  absl::crc32c_t crc_a = absl::ComputeCrc32c(hello);
-  absl::crc32c_t crc_b = absl::ComputeCrc32c(world);
-  absl::crc32c_t crc_ab = absl::ComputeCrc32c(hello_world);
-
-  EXPECT_EQ(absl::ConcatCrc32c(crc_a, crc_b, world.size()), crc_ab);
-}
-
-TEST(CRC32C, Memcpy) {
-  constexpr size_t kBytesSize[] = {0, 1, 20, 500, 100000};
-  for (size_t bytes : kBytesSize) {
-    SCOPED_TRACE(bytes);
-    std::string sample_string = TestString(bytes);
-    std::string target_buffer = std::string(bytes, '\0');
-
-    absl::crc32c_t memcpy_crc =
-        absl::MemcpyCrc32c(&(target_buffer[0]), sample_string.data(), bytes);
-    absl::crc32c_t compute_crc = absl::ComputeCrc32c(sample_string);
-
-    EXPECT_EQ(memcpy_crc, compute_crc);
-    EXPECT_EQ(sample_string, target_buffer);
-  }
-}
-
-TEST(CRC32C, RemovePrefix) {
-  std::string hello = "Hello, ";
-  std::string world = "world!";
-  std::string hello_world = absl::StrCat(hello, world);
-
-  absl::crc32c_t crc_a = absl::ComputeCrc32c(hello);
-  absl::crc32c_t crc_b = absl::ComputeCrc32c(world);
-  absl::crc32c_t crc_ab = absl::ComputeCrc32c(hello_world);
-
-  EXPECT_EQ(absl::RemoveCrc32cPrefix(crc_a, crc_ab, world.size()), crc_b);
-}
-
-TEST(CRC32C, RemoveSuffix) {
-  std::string hello = "Hello, ";
-  std::string world = "world!";
-  std::string hello_world = absl::StrCat(hello, world);
-
-  absl::crc32c_t crc_a = absl::ComputeCrc32c(hello);
-  absl::crc32c_t crc_b = absl::ComputeCrc32c(world);
-  absl::crc32c_t crc_ab = absl::ComputeCrc32c(hello_world);
-
-  EXPECT_EQ(absl::RemoveCrc32cSuffix(crc_ab, crc_b, world.size()), crc_a);
-}
-
-TEST(CRC32C, InsertionOperator) {
-  {
-    std::ostringstream buf;
-    buf << absl::crc32c_t{0xc99465aa};
-    EXPECT_EQ(buf.str(), "c99465aa");
-  }
-  {
-    std::ostringstream buf;
-    buf << absl::crc32c_t{0};
-    EXPECT_EQ(buf.str(), "00000000");
-  }
-  {
-    std::ostringstream buf;
-    buf << absl::crc32c_t{17};
-    EXPECT_EQ(buf.str(), "00000011");
-  }
-}
-
-TEST(CRC32C, AbslStringify) {
-  // StrFormat
-  EXPECT_EQ(absl::StrFormat("%v", absl::crc32c_t{0xc99465aa}), "c99465aa");
-  EXPECT_EQ(absl::StrFormat("%v", absl::crc32c_t{0}), "00000000");
-  EXPECT_EQ(absl::StrFormat("%v", absl::crc32c_t{17}), "00000011");
-
-  // StrCat
-  EXPECT_EQ(absl::StrCat(absl::crc32c_t{0xc99465aa}), "c99465aa");
-  EXPECT_EQ(absl::StrCat(absl::crc32c_t{0}), "00000000");
-  EXPECT_EQ(absl::StrCat(absl::crc32c_t{17}), "00000011");
-}
-
-}  // namespace

package/deps/abseil-cpp/absl/crc/internal/cpu_detect.cc

@@ -1,359 +0,0 @@
-// Copyright 2022 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "absl/crc/internal/cpu_detect.h"
-
-#include <cstdint>
-#include <string>
-
-#include "absl/base/config.h"
-#include "absl/types/optional.h"  // IWYU pragma: keep
-
-#if defined(__aarch64__) && defined(__linux__)
-#include <asm/hwcap.h>
-#include <sys/auxv.h>
-#endif
-
-#if defined(__aarch64__) && defined(__APPLE__)
-#if defined(__has_include) && __has_include(<arm/cpu_capabilities_public.h>)
-#include <arm/cpu_capabilities_public.h>
-#endif
-#include <sys/sysctl.h>
-#include <sys/types.h>
-#endif
-
-#if defined(_WIN32) || defined(_WIN64)
-#include <intrin.h>
-#endif
-
-#if defined(__x86_64__) || defined(_M_X64)
-#if ABSL_HAVE_BUILTIN(__cpuid)
-// MSVC-equivalent __cpuid intrinsic declaration for clang-like compilers
-// for non-Windows build environments.
-extern void __cpuid(int[4], int);
-#elif !defined(_WIN32) && !defined(_WIN64)
-// MSVC defines this function for us.
-// https://learn.microsoft.com/en-us/cpp/intrinsics/cpuid-cpuidex
-static void __cpuid(int cpu_info[4], int info_type) {
-  __asm__ volatile("cpuid \n\t"
-                   : "=a"(cpu_info[0]), "=b"(cpu_info[1]), "=c"(cpu_info[2]),
-                     "=d"(cpu_info[3])
-                   : "a"(info_type), "c"(0));
-}
-#endif  // !defined(_WIN32) && !defined(_WIN64)
-#endif  // defined(__x86_64__) || defined(_M_X64)
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace crc_internal {
-
-#if defined(__x86_64__) || defined(_M_X64)
-
-namespace {
-
-enum class Vendor {
-  kUnknown,
-  kIntel,
-  kAmd,
-};
-
-Vendor GetVendor() {
-  // Get the vendor string (issue CPUID with eax = 0).
-  int cpu_info[4];
-  __cpuid(cpu_info, 0);
-
-  std::string vendor;
-  vendor.append(reinterpret_cast<char*>(&cpu_info[1]), 4);
-  vendor.append(reinterpret_cast<char*>(&cpu_info[3]), 4);
-  vendor.append(reinterpret_cast<char*>(&cpu_info[2]), 4);
-  if (vendor == "GenuineIntel") {
-    return Vendor::kIntel;
-  } else if (vendor == "AuthenticAMD") {
-    return Vendor::kAmd;
-  } else {
-    return Vendor::kUnknown;
-  }
-}
-
-CpuType GetIntelCpuType() {
-  // To get general information and extended features we send eax = 1 and
-  // ecx = 0 to cpuid.  The response is returned in eax, ebx, ecx and edx.
-  // (See Intel 64 and IA-32 Architectures Software Developer's Manual
-  // Volume 2A: Instruction Set Reference, A-M CPUID).
-  // https://www.intel.com/content/www/us/en/architecture-and-technology/64-ia-32-architectures-software-developer-vol-2a-manual.html
-  // https://learn.microsoft.com/en-us/cpp/intrinsics/cpuid-cpuidex
-  int cpu_info[4];
-  __cpuid(cpu_info, 1);
-
-  // Response in eax bits as follows:
-  // 0-3 (stepping id)
-  // 4-7 (model number),
-  // 8-11 (family code),
-  // 12-13 (processor type),
-  // 16-19 (extended model)
-  // 20-27 (extended family)
-
-  int family = (cpu_info[0] >> 8) & 0x0f;
-  int model_num = (cpu_info[0] >> 4) & 0x0f;
-  int ext_family = (cpu_info[0] >> 20) & 0xff;
-  int ext_model_num = (cpu_info[0] >> 16) & 0x0f;
-
-  int brand_id = cpu_info[1] & 0xff;
-
-  // Process the extended family and model info if necessary
-  if (family == 0x0f) {
-    family += ext_family;
-  }
-
-  if (family == 0x0f || family == 0x6) {
-    model_num += (ext_model_num << 4);
-  }
-
-  switch (brand_id) {
-    case 0:  // no brand ID, so parse CPU family/model
-      switch (family) {
-        case 6:  // Most PentiumIII processors are in this category
-          switch (model_num) {
-            case 0x2c:  // Westmere: Gulftown
-              return CpuType::kIntelWestmere;
-            case 0x2d:  // Sandybridge
-              return CpuType::kIntelSandybridge;
-            case 0x3e:  // Ivybridge
-              return CpuType::kIntelIvybridge;
-            case 0x3c:  // Haswell (client)
-            case 0x3f:  // Haswell
-              return CpuType::kIntelHaswell;
-            case 0x4f:  // Broadwell
-            case 0x56:  // BroadwellDE
-              return CpuType::kIntelBroadwell;
-            case 0x55:                 // Skylake Xeon
-              if ((cpu_info[0] & 0x0f) < 5) {  // stepping < 5 is skylake
-                return CpuType::kIntelSkylakeXeon;
-              } else {  // stepping >= 5 is cascadelake
-                return CpuType::kIntelCascadelakeXeon;
-              }
-            case 0x5e:  // Skylake (client)
-              return CpuType::kIntelSkylake;
-            case 0x6a:  // Ice Lake
-              return CpuType::kIntelIcelake;
-            case 0x8f:  // Sapphire Rapids
-              return CpuType::kIntelSapphirerapids;
-            case 0xcf:  // Emerald Rapids
-              return CpuType::kIntelEmeraldrapids;
-            case 0xad:  // Granite Rapids
-              return CpuType::kIntelGraniterapidsap;
-            default:
-              return CpuType::kUnknown;
-          }
-        default:
-          return CpuType::kUnknown;
-      }
-    default:
-      return CpuType::kUnknown;
-  }
-}
-
-CpuType GetAmdCpuType() {
-  // To get general information and extended features we send eax = 1 and
-  // ecx = 0 to cpuid.  The response is returned in eax, ebx, ecx and edx.
-  // (See Intel 64 and IA-32 Architectures Software Developer's Manual
-  // Volume 2A: Instruction Set Reference, A-M CPUID).
-  // https://learn.microsoft.com/en-us/cpp/intrinsics/cpuid-cpuidex
-  int cpu_info[4];
-  __cpuid(cpu_info, 1);
-
-  // Response in eax bits as follows:
-  // 0-3 (stepping id)
-  // 4-7 (model number),
-  // 8-11 (family code),
-  // 12-13 (processor type),
-  // 16-19 (extended model)
-  // 20-27 (extended family)
-
-  int family = (cpu_info[0] >> 8) & 0x0f;
-  int model_num = (cpu_info[0] >> 4) & 0x0f;
-  int ext_family = (cpu_info[0] >> 20) & 0xff;
-  int ext_model_num = (cpu_info[0] >> 16) & 0x0f;
-
-  if (family == 0x0f) {
-    family += ext_family;
-    model_num += (ext_model_num << 4);
-  }
-
-  switch (family) {
-    case 0x17:
-      switch (model_num) {
-        case 0x0:  // Stepping Ax
-        case 0x1:  // Stepping Bx
-          return CpuType::kAmdNaples;
-        case 0x30:  // Stepping Ax
-        case 0x31:  // Stepping Bx
-          return CpuType::kAmdRome;
-        default:
-          return CpuType::kUnknown;
-      }
-      break;
-    case 0x19:
-      switch (model_num) {
-        case 0x0:  // Stepping Ax
-        case 0x1:  // Stepping B0
-          return CpuType::kAmdMilan;
-        case 0x10:  // Stepping A0
-        case 0x11:  // Stepping B0
-          return CpuType::kAmdGenoa;
-        case 0x44:  // Stepping A0
-          return CpuType::kAmdRyzenV3000;
-        default:
-          return CpuType::kUnknown;
-      }
-      break;
-    case 0x1A:
-      switch (model_num) {
-        case 0x2:
-          return CpuType::kAmdTurin;
-        default:
-          return CpuType::kUnknown;
-      }
-      break;
-    default:
-      return CpuType::kUnknown;
-  }
-}
-
-}  // namespace
-
-CpuType GetCpuType() {
-  switch (GetVendor()) {
-    case Vendor::kIntel:
-      return GetIntelCpuType();
-    case Vendor::kAmd:
-      return GetAmdCpuType();
-    default:
-      return CpuType::kUnknown;
-  }
-}
-
-bool SupportsArmCRC32PMULL() { return false; }
-
-#elif defined(__aarch64__) && defined(__linux__)
-
-#ifndef HWCAP_CPUID
-#define HWCAP_CPUID (1 << 11)
-#endif
-
-#define ABSL_INTERNAL_AARCH64_ID_REG_READ(id, val) \
-  asm("mrs %0, " #id : "=r"(val))
-
-CpuType GetCpuType() {
-  // MIDR_EL1 is not visible to EL0, however the access will be emulated by
-  // linux if AT_HWCAP has HWCAP_CPUID set.
-  //
-  // This method will be unreliable on heterogeneous computing systems (ex:
-  // big.LITTLE) since the value of MIDR_EL1 will change based on the calling
-  // thread.
-  uint64_t hwcaps = getauxval(AT_HWCAP);
-  if (hwcaps & HWCAP_CPUID) {
-    uint64_t midr = 0;
-    ABSL_INTERNAL_AARCH64_ID_REG_READ(MIDR_EL1, midr);
-    uint32_t implementer = (midr >> 24) & 0xff;
-    uint32_t part_number = (midr >> 4) & 0xfff;
-    switch (implementer) {
-      case 0x41:
-        switch (part_number) {
-          case 0xd0c: return CpuType::kArmNeoverseN1;
-          case 0xd40: return CpuType::kArmNeoverseV1;
-          case 0xd49: return CpuType::kArmNeoverseN2;
-          case 0xd4f: return CpuType::kArmNeoverseV2;
-          case 0xd8e: return CpuType::kArmNeoverseN3;
-          default:
-            return CpuType::kUnknown;
-        }
-        break;
-      case 0xc0:
-        switch (part_number) {
-          case 0xac3: return CpuType::kAmpereSiryn;
-          default:
-            return CpuType::kUnknown;
-        }
-        break;
-      default:
-        return CpuType::kUnknown;
-    }
-  }
-  return CpuType::kUnknown;
-}
-
-bool SupportsArmCRC32PMULL() {
-#if defined(HWCAP_CRC32) && defined(HWCAP_PMULL)
-  uint64_t hwcaps = getauxval(AT_HWCAP);
-  return (hwcaps & HWCAP_CRC32) && (hwcaps & HWCAP_PMULL);
-#else
-  return false;
-#endif
-}
-
-#elif defined(__aarch64__) && defined(__APPLE__)
-
-CpuType GetCpuType() { return CpuType::kUnknown; }
-
-template <typename T>
-static absl::optional<T> ReadSysctlByName(const char* name) {
-  T val;
-  size_t val_size = sizeof(T);
-  int ret = sysctlbyname(name, &val, &val_size, nullptr, 0);
-  if (ret == -1) {
-    return absl::nullopt;
-  }
-  return val;
-}
-
-bool SupportsArmCRC32PMULL() {
-  // Newer XNU kernels support querying all capabilities in a single
-  // sysctlbyname.
-#if defined(CAP_BIT_CRC32) && defined(CAP_BIT_FEAT_PMULL)
-  static const absl::optional<uint64_t> caps =
-      ReadSysctlByName<uint64_t>("hw.optional.arm.caps");
-  if (caps.has_value()) {
-    constexpr uint64_t kCrc32AndPmullCaps =
-        (uint64_t{1} << CAP_BIT_CRC32) | (uint64_t{1} << CAP_BIT_FEAT_PMULL);
-    return (*caps & kCrc32AndPmullCaps) == kCrc32AndPmullCaps;
-  }
-#endif
-
-  // https://developer.apple.com/documentation/kernel/1387446-sysctlbyname/determining_instruction_set_characteristics#3915619
-  static const absl::optional<int> armv8_crc32 =
-      ReadSysctlByName<int>("hw.optional.armv8_crc32");
-  if (armv8_crc32.value_or(0) == 0) {
-    return false;
-  }
-  // https://developer.apple.com/documentation/kernel/1387446-sysctlbyname/determining_instruction_set_characteristics#3918855
-  static const absl::optional<int> feat_pmull =
-      ReadSysctlByName<int>("hw.optional.arm.FEAT_PMULL");
-  if (feat_pmull.value_or(0) == 0) {
-    return false;
-  }
-  return true;
-}
-
-#else
-
-CpuType GetCpuType() { return CpuType::kUnknown; }
-
-bool SupportsArmCRC32PMULL() { return false; }
-
-#endif
-
-}  // namespace crc_internal
-ABSL_NAMESPACE_END
-}  // namespace absl

package/deps/abseil-cpp/absl/crc/internal/cpu_detect.h

@@ -1,69 +0,0 @@
-// Copyright 2022 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_CRC_INTERNAL_CPU_DETECT_H_
-#define ABSL_CRC_INTERNAL_CPU_DETECT_H_
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace crc_internal {
-
-// Enumeration of architectures that we have special-case tuning parameters for.
-// This set may change over time.
-enum class CpuType {
-  kUnknown,
-  kIntelHaswell,
-  kAmdRome,
-  kAmdNaples,
-  kAmdMilan,
-  kAmdGenoa,
-  kAmdTurin,
-  kAmdRyzenV3000,
-  kIntelCascadelakeXeon,
-  kIntelSkylakeXeon,
-  kIntelBroadwell,
-  kIntelIcelake,
-  kIntelSapphirerapids,
-  kIntelEmeraldrapids,
-  kIntelGraniterapidsap,
-  kIntelSkylake,
-  kIntelIvybridge,
-  kIntelSandybridge,
-  kIntelWestmere,
-  kArmNeoverseN1,
-  kArmNeoverseV1,
-  kAmpereSiryn,
-  kArmNeoverseN2,
-  kArmNeoverseV2,
-  kArmNeoverseN3,
-};
-
-// Returns the type of host CPU this code is running on.  Returns kUnknown if
-// the host CPU is of unknown type, or if detection otherwise fails.
-CpuType GetCpuType();
-
-// Returns whether the host CPU supports the CPU features needed for our
-// accelerated implementations. The CpuTypes enumerated above apart from
-// kUnknown support the required features. On unknown CPUs, we can use
-// this to see if it's safe to use hardware acceleration, though without any
-// tuning.
-bool SupportsArmCRC32PMULL();
-
-}  // namespace crc_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CRC_INTERNAL_CPU_DETECT_H_