@nxtedition/rocksdb 15.2.3 → 15.2.4

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

@@ -1,278 +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_CRC32_X86_ARM_COMBINED_SIMD_H_
-#define ABSL_CRC_INTERNAL_CRC32_X86_ARM_COMBINED_SIMD_H_
-
-#include <cstdint>
-
-#include "absl/base/config.h"
-
-// -------------------------------------------------------------------------
-// Many x86 and ARM machines have CRC acceleration hardware.
-// We can do a faster version of Extend() on such machines.
-// We define a translation layer for both x86 and ARM for the ease of use and
-// most performance gains.
-
-// This implementation requires 64-bit CRC instructions (part of SSE 4.2) and
-// PCLMULQDQ instructions. 32-bit builds with SSE 4.2 do exist, so the
-// __x86_64__ condition is necessary.
-#if defined(__x86_64__) && defined(__SSE4_2__) && defined(__PCLMUL__)
-
-#include <x86intrin.h>
-#define ABSL_CRC_INTERNAL_HAVE_X86_SIMD
-
-#elif defined(_MSC_VER) && !defined(__clang__) && defined(__AVX__) && \
-    defined(_M_AMD64)
-
-// MSVC AVX (/arch:AVX) implies SSE 4.2 and PCLMULQDQ.
-#include <intrin.h>
-#define ABSL_CRC_INTERNAL_HAVE_X86_SIMD
-
-#elif defined(__aarch64__) && defined(__LITTLE_ENDIAN__) &&                 \
-    defined(__ARM_FEATURE_CRC32) && defined(ABSL_INTERNAL_HAVE_ARM_NEON) && \
-    defined(__ARM_FEATURE_CRYPTO)
-
-#include <arm_acle.h>
-#include <arm_neon.h>
-#define ABSL_CRC_INTERNAL_HAVE_ARM_SIMD
-
-#endif
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace crc_internal {
-
-#if defined(ABSL_CRC_INTERNAL_HAVE_ARM_SIMD) || \
-    defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD)
-
-#if defined(ABSL_CRC_INTERNAL_HAVE_ARM_SIMD)
-using V128 = uint64x2_t;
-#else
-// Note: Do not use __m128i_u, it is not portable.
-// Use V128_LoadU() perform an unaligned load from __m128i*.
-using V128 = __m128i;
-#endif
-
-// Starting with the initial value in |crc|, accumulates a CRC32 value for
-// unsigned integers of different sizes.
-uint32_t CRC32_u8(uint32_t crc, uint8_t v);
-
-uint32_t CRC32_u16(uint32_t crc, uint16_t v);
-
-uint32_t CRC32_u32(uint32_t crc, uint32_t v);
-
-uint32_t CRC32_u64(uint32_t crc, uint64_t v);
-
-// Loads 128 bits of integer data. |src| must be 16-byte aligned.
-V128 V128_Load(const V128* src);
-
-// Load 128 bits of integer data. |src| does not need to be aligned.
-V128 V128_LoadU(const V128* src);
-
-// Store 128 bits of integer data. |src| must be 16-byte aligned.
-void V128_Store(V128* dst, V128 data);
-
-// Polynomially multiplies the high 64 bits of |l| and |r|.
-V128 V128_PMulHi(const V128 l, const V128 r);
-
-// Polynomially multiplies the low 64 bits of |l| and |r|.
-V128 V128_PMulLow(const V128 l, const V128 r);
-
-// Polynomially multiplies the low 64 bits of |r| and high 64 bits of |l|.
-V128 V128_PMul01(const V128 l, const V128 r);
-
-// Polynomially multiplies the low 64 bits of |l| and high 64 bits of |r|.
-V128 V128_PMul10(const V128 l, const V128 r);
-
-// Produces a XOR operation of |l| and |r|.
-V128 V128_Xor(const V128 l, const V128 r);
-
-// Sets the lower half of a 128 bit register to the given 64-bit value and
-// zeroes the upper half.
-// dst[63:0] := |r|
-// dst[127:64] := |0|
-V128 V128_From64WithZeroFill(const uint64_t r);
-
-// Extracts a 32-bit integer from |l|, selected with |imm|.
-template <int imm>
-int V128_Extract32(const V128 l);
-
-// Extracts a 64-bit integer from |l|, selected with |imm|.
-template <int imm>
-uint64_t V128_Extract64(const V128 l);
-
-// Extracts the low 64 bits from V128.
-int64_t V128_Low64(const V128 l);
-
-// Add packed 64-bit integers in |l| and |r|.
-V128 V128_Add64(const V128 l, const V128 r);
-
-#endif
-
-#if defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD)
-
-inline uint32_t CRC32_u8(uint32_t crc, uint8_t v) {
-  return _mm_crc32_u8(crc, v);
-}
-
-inline uint32_t CRC32_u16(uint32_t crc, uint16_t v) {
-  return _mm_crc32_u16(crc, v);
-}
-
-inline uint32_t CRC32_u32(uint32_t crc, uint32_t v) {
-  return _mm_crc32_u32(crc, v);
-}
-
-inline uint32_t CRC32_u64(uint32_t crc, uint64_t v) {
-  return static_cast<uint32_t>(_mm_crc32_u64(crc, v));
-}
-
-inline V128 V128_Load(const V128* src) { return _mm_load_si128(src); }
-
-inline V128 V128_LoadU(const V128* src) { return _mm_loadu_si128(src); }
-
-inline void V128_Store(V128* dst, V128 data) { _mm_store_si128(dst, data); }
-
-inline V128 V128_PMulHi(const V128 l, const V128 r) {
-  return _mm_clmulepi64_si128(l, r, 0x11);
-}
-
-inline V128 V128_PMulLow(const V128 l, const V128 r) {
-  return _mm_clmulepi64_si128(l, r, 0x00);
-}
-
-inline V128 V128_PMul01(const V128 l, const V128 r) {
-  return _mm_clmulepi64_si128(l, r, 0x01);
-}
-
-inline V128 V128_PMul10(const V128 l, const V128 r) {
-  return _mm_clmulepi64_si128(l, r, 0x10);
-}
-
-inline V128 V128_Xor(const V128 l, const V128 r) { return _mm_xor_si128(l, r); }
-
-inline V128 V128_From64WithZeroFill(const uint64_t r) {
-  return _mm_set_epi64x(static_cast<int64_t>(0), static_cast<int64_t>(r));
-}
-
-template <int imm>
-inline int V128_Extract32(const V128 l) {
-  return _mm_extract_epi32(l, imm);
-}
-
-template <int imm>
-inline uint64_t V128_Extract64(const V128 l) {
-  return static_cast<uint64_t>(_mm_extract_epi64(l, imm));
-}
-
-inline int64_t V128_Low64(const V128 l) { return _mm_cvtsi128_si64(l); }
-
-inline V128 V128_Add64(const V128 l, const V128 r) {
-  return _mm_add_epi64(l, r);
-}
-
-#elif defined(ABSL_CRC_INTERNAL_HAVE_ARM_SIMD)
-
-inline uint32_t CRC32_u8(uint32_t crc, uint8_t v) { return __crc32cb(crc, v); }
-
-inline uint32_t CRC32_u16(uint32_t crc, uint16_t v) {
-  return __crc32ch(crc, v);
-}
-
-inline uint32_t CRC32_u32(uint32_t crc, uint32_t v) {
-  return __crc32cw(crc, v);
-}
-
-inline uint32_t CRC32_u64(uint32_t crc, uint64_t v) {
-  return __crc32cd(crc, v);
-}
-
-inline V128 V128_Load(const V128* src) {
-  return vld1q_u64(reinterpret_cast<const uint64_t*>(src));
-}
-
-inline V128 V128_LoadU(const V128* src) {
-  return vld1q_u64(reinterpret_cast<const uint64_t*>(src));
-}
-
-inline void V128_Store(V128* dst, V128 data) {
-  vst1q_u64(reinterpret_cast<uint64_t*>(dst), data);
-}
-
-// Using inline assembly as clang does not generate the pmull2 instruction and
-// performance drops by 15-20%.
-// TODO(b/193678732): Investigate why there is a slight performance hit when
-// using intrinsics instead of inline assembly.
-inline V128 V128_PMulHi(const V128 l, const V128 r) {
-  uint64x2_t res;
-  __asm__ __volatile__("pmull2 %0.1q, %1.2d, %2.2d \n\t"
-                       : "=w"(res)
-                       : "w"(l), "w"(r));
-  return res;
-}
-
-// TODO(b/193678732): Investigate why the compiler decides to move the constant
-// loop multiplicands from GPR to Neon registers every loop iteration.
-inline V128 V128_PMulLow(const V128 l, const V128 r) {
-  uint64x2_t res;
-  __asm__ __volatile__("pmull %0.1q, %1.1d, %2.1d \n\t"
-                       : "=w"(res)
-                       : "w"(l), "w"(r));
-  return res;
-}
-
-inline V128 V128_PMul01(const V128 l, const V128 r) {
-  return reinterpret_cast<V128>(vmull_p64(
-      reinterpret_cast<poly64_t>(vget_high_p64(vreinterpretq_p64_u64(l))),
-      reinterpret_cast<poly64_t>(vget_low_p64(vreinterpretq_p64_u64(r)))));
-}
-
-inline V128 V128_PMul10(const V128 l, const V128 r) {
-  return reinterpret_cast<V128>(vmull_p64(
-      reinterpret_cast<poly64_t>(vget_low_p64(vreinterpretq_p64_u64(l))),
-      reinterpret_cast<poly64_t>(vget_high_p64(vreinterpretq_p64_u64(r)))));
-}
-
-inline V128 V128_Xor(const V128 l, const V128 r) { return veorq_u64(l, r); }
-
-inline V128 V128_From64WithZeroFill(const uint64_t r){
-  constexpr uint64x2_t kZero = {0, 0};
-  return vsetq_lane_u64(r, kZero, 0);
-}
-
-
-template <int imm>
-inline int V128_Extract32(const V128 l) {
-  return vgetq_lane_s32(vreinterpretq_s32_u64(l), imm);
-}
-
-template <int imm>
-inline uint64_t V128_Extract64(const V128 l) {
-  return vgetq_lane_u64(l, imm);
-}
-
-inline int64_t V128_Low64(const V128 l) {
-  return vgetq_lane_s64(vreinterpretq_s64_u64(l), 0);
-}
-
-inline V128 V128_Add64(const V128 l, const V128 r) { return vaddq_u64(l, r); }
-
-#endif
-
-}  // namespace crc_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CRC_INTERNAL_CRC32_X86_ARM_COMBINED_SIMD_H_

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

@@ -1,39 +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_CRC32C_H_
-#define ABSL_CRC_INTERNAL_CRC32C_H_
-
-#include "absl/base/config.h"
-#include "absl/crc/crc32c.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace crc_internal {
-
-// Modifies a CRC32 value by removing `length` bytes with a value of 0 from
-// the end of the string.
-//
-// This is the inverse operation of ExtendCrc32cByZeroes().
-//
-// This operation has a runtime cost of O(log(`length`))
-//
-// Internal implementation detail, exposed for testing only.
-crc32c_t UnextendCrc32cByZeroes(crc32c_t initial_crc, size_t length);
-
-}  // namespace crc_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CRC_INTERNAL_CRC32C_H_

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

@@ -1,72 +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_CRC32C_INLINE_H_
-#define ABSL_CRC_INTERNAL_CRC32C_INLINE_H_
-
-#include <cstdint>
-
-#include "absl/base/config.h"
-#include "absl/base/internal/endian.h"
-#include "absl/crc/internal/crc32_x86_arm_combined_simd.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace crc_internal {
-
-// CRC32C implementation optimized for small inputs.
-// Either computes crc and return true, or if there is
-// no hardware support does nothing and returns false.
-inline bool ExtendCrc32cInline(uint32_t* crc, const char* p, size_t n) {
-#if defined(ABSL_CRC_INTERNAL_HAVE_ARM_SIMD) || \
-    defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD)
-  constexpr uint32_t kCrc32Xor = 0xffffffffU;
-  *crc ^= kCrc32Xor;
-  if (n & 1) {
-    *crc = CRC32_u8(*crc, static_cast<uint8_t>(*p));
-    n--;
-    p++;
-  }
-  if (n & 2) {
-    *crc = CRC32_u16(*crc, absl::little_endian::Load16(p));
-    n -= 2;
-    p += 2;
-  }
-  if (n & 4) {
-    *crc = CRC32_u32(*crc, absl::little_endian::Load32(p));
-    n -= 4;
-    p += 4;
-  }
-  while (n) {
-    *crc = CRC32_u64(*crc, absl::little_endian::Load64(p));
-    n -= 8;
-    p += 8;
-  }
-  *crc ^= kCrc32Xor;
-  return true;
-#else
-  // No hardware support, signal the need to fallback.
-  static_cast<void>(crc);
-  static_cast<void>(p);
-  static_cast<void>(n);
-  return false;
-#endif  // defined(ABSL_CRC_INTERNAL_HAVE_ARM_SIMD) ||
-        // defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD)
-}
-
-}  // namespace crc_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CRC_INTERNAL_CRC32C_INLINE_H_

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

@@ -1,131 +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/crc_cord_state.h"
-
-#include <cassert>
-
-#include "absl/base/config.h"
-#include "absl/base/no_destructor.h"
-#include "absl/numeric/bits.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace crc_internal {
-
-CrcCordState::RefcountedRep* CrcCordState::RefSharedEmptyRep() {
-  static absl::NoDestructor<CrcCordState::RefcountedRep> empty;
-
-  assert(empty->count.load(std::memory_order_relaxed) >= 1);
-  assert(empty->rep.removed_prefix.length == 0);
-  assert(empty->rep.prefix_crc.empty());
-
-  Ref(empty.get());
-  return empty.get();
-}
-
-CrcCordState::CrcCordState() : refcounted_rep_(new RefcountedRep) {}
-
-CrcCordState::CrcCordState(const CrcCordState& other)
-    : refcounted_rep_(other.refcounted_rep_) {
-  Ref(refcounted_rep_);
-}
-
-CrcCordState::CrcCordState(CrcCordState&& other)
-    : refcounted_rep_(other.refcounted_rep_) {
-  // Make `other` valid for use after move.
-  other.refcounted_rep_ = RefSharedEmptyRep();
-}
-
-CrcCordState& CrcCordState::operator=(const CrcCordState& other) {
-  if (this != &other) {
-    Unref(refcounted_rep_);
-    refcounted_rep_ = other.refcounted_rep_;
-    Ref(refcounted_rep_);
-  }
-  return *this;
-}
-
-CrcCordState& CrcCordState::operator=(CrcCordState&& other) {
-  if (this != &other) {
-    Unref(refcounted_rep_);
-    refcounted_rep_ = other.refcounted_rep_;
-    // Make `other` valid for use after move.
-    other.refcounted_rep_ = RefSharedEmptyRep();
-  }
-  return *this;
-}
-
-CrcCordState::~CrcCordState() {
-  Unref(refcounted_rep_);
-}
-
-crc32c_t CrcCordState::Checksum() const {
-  if (rep().prefix_crc.empty()) {
-    return absl::crc32c_t{0};
-  }
-  if (IsNormalized()) {
-    return rep().prefix_crc.back().crc;
-  }
-  return absl::RemoveCrc32cPrefix(
-      rep().removed_prefix.crc, rep().prefix_crc.back().crc,
-      rep().prefix_crc.back().length - rep().removed_prefix.length);
-}
-
-CrcCordState::PrefixCrc CrcCordState::NormalizedPrefixCrcAtNthChunk(
-    size_t n) const {
-  assert(n < NumChunks());
-  if (IsNormalized()) {
-    return rep().prefix_crc[n];
-  }
-  size_t length = rep().prefix_crc[n].length - rep().removed_prefix.length;
-  return PrefixCrc(length,
-                   absl::RemoveCrc32cPrefix(rep().removed_prefix.crc,
-                                            rep().prefix_crc[n].crc, length));
-}
-
-void CrcCordState::Normalize() {
-  if (IsNormalized() || rep().prefix_crc.empty()) {
-    return;
-  }
-
-  Rep* r = mutable_rep();
-  for (auto& prefix_crc : r->prefix_crc) {
-    size_t remaining = prefix_crc.length - r->removed_prefix.length;
-    prefix_crc.crc = absl::RemoveCrc32cPrefix(r->removed_prefix.crc,
-                                              prefix_crc.crc, remaining);
-    prefix_crc.length = remaining;
-  }
-  r->removed_prefix = PrefixCrc();
-}
-
-void CrcCordState::Poison() {
-  Rep* rep = mutable_rep();
-  if (NumChunks() > 0) {
-    for (auto& prefix_crc : rep->prefix_crc) {
-      // This is basically CRC32::Scramble().
-      uint32_t crc = static_cast<uint32_t>(prefix_crc.crc);
-      crc += 0x2e76e41b;
-      crc = absl::rotr(crc, 17);
-      prefix_crc.crc = crc32c_t{crc};
-    }
-  } else {
-    // Add a fake corrupt chunk.
-    rep->prefix_crc.emplace_back(0, crc32c_t{1});
-  }
-}
-
-}  // namespace crc_internal
-ABSL_NAMESPACE_END
-}  // namespace absl

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

@@ -1,159 +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_CRC_CORD_STATE_H_
-#define ABSL_CRC_INTERNAL_CRC_CORD_STATE_H_
-
-#include <atomic>
-#include <cstddef>
-#include <deque>
-
-#include "absl/base/config.h"
-#include "absl/crc/crc32c.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace crc_internal {
-
-// CrcCordState is a copy-on-write class that holds the chunked CRC32C data
-// that allows CrcCord to perform efficient substring operations. CrcCordState
-// is used as a member variable in CrcCord. When a CrcCord is converted to a
-// Cord, the CrcCordState is shallow-copied into the root node of the Cord. If
-// the converted Cord is modified outside of CrcCord, the CrcCordState is
-// discarded from the Cord. If the Cord is converted back to a CrcCord, and the
-// Cord is still carrying the CrcCordState in its root node, the CrcCord can
-// re-use the CrcCordState, making the construction of the CrcCord cheap.
-//
-// CrcCordState does not try to encapsulate the CRC32C state (CrcCord requires
-// knowledge of how CrcCordState represents the CRC32C state). It does
-// encapsulate the copy-on-write nature of the state.
-class CrcCordState {
- public:
-  // Constructors.
-  CrcCordState();
-  CrcCordState(const CrcCordState&);
-  CrcCordState(CrcCordState&&);
-
-  // Destructor. Atomically unreferences the data.
-  ~CrcCordState();
-
-  // Copy and move operators.
-  CrcCordState& operator=(const CrcCordState&);
-  CrcCordState& operator=(CrcCordState&&);
-
-  // A (length, crc) pair.
-  struct PrefixCrc {
-    PrefixCrc() = default;
-    PrefixCrc(size_t length_arg, absl::crc32c_t crc_arg)
-        : length(length_arg), crc(crc_arg) {}
-
-    size_t length = 0;
-
-    // TODO(absl-team): Memory stomping often zeros out memory. If this struct
-    // gets overwritten, we could end up with {0, 0}, which is the correct CRC
-    // for a string of length 0. Consider storing a scrambled value and
-    // unscrambling it before verifying it.
-    absl::crc32c_t crc = absl::crc32c_t{0};
-  };
-
-  // The representation of the chunked CRC32C data.
-  struct Rep {
-    // `removed_prefix` is the crc and length of any prefix that has been
-    // removed from the Cord (for example, by calling
-    // `CrcCord::RemovePrefix()`). To get the checksum of any prefix of the
-    // cord, this value must be subtracted from `prefix_crc`. See `Checksum()`
-    // for an example.
-    //
-    // CrcCordState is said to be "normalized" if removed_prefix.length == 0.
-    PrefixCrc removed_prefix;
-
-    // A deque of (length, crc) pairs, representing length and crc of a prefix
-    // of the Cord, before removed_prefix has been subtracted. The lengths of
-    // the prefixes are stored in increasing order. If the Cord is not empty,
-    // the last value in deque is the contains the CRC32C of the entire Cord
-    // when removed_prefix is subtracted from it.
-    std::deque<PrefixCrc> prefix_crc;
-  };
-
-  // Returns a reference to the representation of the chunked CRC32C data.
-  const Rep& rep() const { return refcounted_rep_->rep; }
-
-  // Returns a mutable reference to the representation of the chunked CRC32C
-  // data. Calling this function will copy the data if another instance also
-  // holds a reference to the data, so it is important to call rep() instead if
-  // the data may not be mutated.
-  Rep* mutable_rep() {
-    if (refcounted_rep_->count.load(std::memory_order_acquire) != 1) {
-      RefcountedRep* copy = new RefcountedRep;
-      copy->rep = refcounted_rep_->rep;
-      Unref(refcounted_rep_);
-      refcounted_rep_ = copy;
-    }
-    return &refcounted_rep_->rep;
-  }
-
-  // Returns the CRC32C of the entire Cord.
-  absl::crc32c_t Checksum() const;
-
-  // Returns true if the chunked CRC32C cached is normalized.
-  bool IsNormalized() const { return rep().removed_prefix.length == 0; }
-
-  // Normalizes the chunked CRC32C checksum cache by subtracting any removed
-  // prefix from the chunks.
-  void Normalize();
-
-  // Returns the number of cached chunks.
-  size_t NumChunks() const { return rep().prefix_crc.size(); }
-
-  // Helper that returns the (length, crc) of the `n`-th cached chunked.
-  PrefixCrc NormalizedPrefixCrcAtNthChunk(size_t n) const;
-
-  // Poisons all chunks to so that Checksum() will likely be incorrect with high
-  // probability.
-  void Poison();
-
- private:
-  struct RefcountedRep {
-    std::atomic<int32_t> count{1};
-    Rep rep;
-  };
-
-  // Adds a reference to the shared global empty `RefcountedRep`, and returns a
-  // pointer to the `RefcountedRep`. This is an optimization to avoid unneeded
-  // allocations when the allocation is unlikely to ever be used. The returned
-  // pointer can be `Unref()`ed when it is no longer needed.  Since the returned
-  // instance will always have a reference counter greater than 1, attempts to
-  // modify it (by calling `mutable_rep()`) will create a new unshared copy.
-  static RefcountedRep* RefSharedEmptyRep();
-
-  static void Ref(RefcountedRep* r) {
-    assert(r != nullptr);
-    r->count.fetch_add(1, std::memory_order_relaxed);
-  }
-
-  static void Unref(RefcountedRep* r) {
-    assert(r != nullptr);
-    if (r->count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
-      delete r;
-    }
-  }
-
-  RefcountedRep* refcounted_rep_;
-};
-
-}  // namespace crc_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CRC_INTERNAL_CRC_CORD_STATE_H_