grpc 1.50.0.pre1-x86_64-linux → 1.52.0.pre2-x86_64-linux

data/third_party/abseil-cpp/absl/random/internal/salted_seed_seq.h

@@ -1,165 +0,0 @@
-// Copyright 2017 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_RANDOM_INTERNAL_SALTED_SEED_SEQ_H_
-#define ABSL_RANDOM_INTERNAL_SALTED_SEED_SEQ_H_
-
-#include <cstdint>
-#include <cstdlib>
-#include <initializer_list>
-#include <iterator>
-#include <memory>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-#include "absl/container/inlined_vector.h"
-#include "absl/meta/type_traits.h"
-#include "absl/random/internal/seed_material.h"
-#include "absl/types/optional.h"
-#include "absl/types/span.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// This class conforms to the C++ Standard "Seed Sequence" concept
-// [rand.req.seedseq].
-//
-// A `SaltedSeedSeq` is meant to wrap an existing seed sequence and modify
-// generated sequence by mixing with extra entropy. This entropy may be
-// build-dependent or process-dependent. The implementation may change to be
-// have either or both kinds of entropy. If salt is not available sequence is
-// not modified.
-template <typename SSeq>
-class SaltedSeedSeq {
- public:
-  using inner_sequence_type = SSeq;
-  using result_type = typename SSeq::result_type;
-
-  SaltedSeedSeq() : seq_(absl::make_unique<SSeq>()) {}
-
-  template <typename Iterator>
-  SaltedSeedSeq(Iterator begin, Iterator end)
-      : seq_(absl::make_unique<SSeq>(begin, end)) {}
-
-  template <typename T>
-  SaltedSeedSeq(std::initializer_list<T> il)
-      : SaltedSeedSeq(il.begin(), il.end()) {}
-
-  SaltedSeedSeq(const SaltedSeedSeq&) = delete;
-  SaltedSeedSeq& operator=(const SaltedSeedSeq&) = delete;
-
-  SaltedSeedSeq(SaltedSeedSeq&&) = default;
-  SaltedSeedSeq& operator=(SaltedSeedSeq&&) = default;
-
-  template <typename RandomAccessIterator>
-  void generate(RandomAccessIterator begin, RandomAccessIterator end) {
-    using U = typename std::iterator_traits<RandomAccessIterator>::value_type;
-
-    // The common case is that generate is called with ContiguousIterators
-    // to uint arrays. Such contiguous memory regions may be optimized,
-    // which we detect here.
-    using TagType = absl::conditional_t<
-        (std::is_same<U, uint32_t>::value &&
-         (std::is_pointer<RandomAccessIterator>::value ||
-          std::is_same<RandomAccessIterator,
-                       typename std::vector<U>::iterator>::value)),
-        ContiguousAndUint32Tag, DefaultTag>;
-    if (begin != end) {
-      generate_impl(TagType{}, begin, end, std::distance(begin, end));
-    }
-  }
-
-  template <typename OutIterator>
-  void param(OutIterator out) const {
-    seq_->param(out);
-  }
-
-  size_t size() const { return seq_->size(); }
-
- private:
-  struct ContiguousAndUint32Tag {};
-  struct DefaultTag {};
-
-  // Generate which requires the iterators are contiguous pointers to uint32_t.
-  // Fills the initial seed buffer the underlying SSeq::generate() call,
-  // then mixes in the salt material.
-  template <typename Contiguous>
-  void generate_impl(ContiguousAndUint32Tag, Contiguous begin, Contiguous end,
-                     size_t n) {
-    seq_->generate(begin, end);
-    const uint32_t salt = absl::random_internal::GetSaltMaterial().value_or(0);
-    auto span = absl::Span<uint32_t>(&*begin, n);
-    MixIntoSeedMaterial(absl::MakeConstSpan(&salt, 1), span);
-  }
-
-  // The uncommon case for generate is that it is called with iterators over
-  // some other buffer type which is assignable from a 32-bit value. In this
-  // case we allocate a temporary 32-bit buffer and then copy-assign back
-  // to the initial inputs.
-  template <typename RandomAccessIterator>
-  void generate_impl(DefaultTag, RandomAccessIterator begin,
-                     RandomAccessIterator, size_t n) {
-    // Allocates a seed buffer of `n` elements, generates the seed, then
-    // copies the result into the `out` iterator.
-    absl::InlinedVector<uint32_t, 8> data(n, 0);
-    generate_impl(ContiguousAndUint32Tag{}, data.begin(), data.end(), n);
-    std::copy(data.begin(), data.end(), begin);
-  }
-
-  // Because [rand.req.seedseq] is not required to be copy-constructible,
-  // copy-assignable nor movable, we wrap it with unique pointer to be able
-  // to move SaltedSeedSeq.
-  std::unique_ptr<SSeq> seq_;
-};
-
-// is_salted_seed_seq indicates whether the type is a SaltedSeedSeq.
-template <typename T, typename = void>
-struct is_salted_seed_seq : public std::false_type {};
-
-template <typename T>
-struct is_salted_seed_seq<
-    T, typename std::enable_if<std::is_same<
-           T, SaltedSeedSeq<typename T::inner_sequence_type>>::value>::type>
-    : public std::true_type {};
-
-// MakeSaltedSeedSeq returns a salted variant of the seed sequence.
-// When provided with an existing SaltedSeedSeq, returns the input parameter,
-// otherwise constructs a new SaltedSeedSeq which embodies the original
-// non-salted seed parameters.
-template <
-    typename SSeq,  //
-    typename EnableIf = absl::enable_if_t<is_salted_seed_seq<SSeq>::value>>
-SSeq MakeSaltedSeedSeq(SSeq&& seq) {
-  return SSeq(std::forward<SSeq>(seq));
-}
-
-template <
-    typename SSeq,  //
-    typename EnableIf = absl::enable_if_t<!is_salted_seed_seq<SSeq>::value>>
-SaltedSeedSeq<typename std::decay<SSeq>::type> MakeSaltedSeedSeq(SSeq&& seq) {
-  using sseq_type = typename std::decay<SSeq>::type;
-  using result_type = typename sseq_type::result_type;
-
-  absl::InlinedVector<result_type, 8> data;
-  seq.param(std::back_inserter(data));
-  return SaltedSeedSeq<sseq_type>(data.begin(), data.end());
-}
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_RANDOM_INTERNAL_SALTED_SEED_SEQ_H_

data/third_party/abseil-cpp/absl/random/internal/seed_material.cc

@@ -1,267 +0,0 @@
-// Copyright 2017 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/random/internal/seed_material.h"
-
-#include <fcntl.h>
-
-#ifndef _WIN32
-#include <unistd.h>
-#else
-#include <io.h>
-#endif
-
-#include <algorithm>
-#include <cerrno>
-#include <cstdint>
-#include <cstdlib>
-#include <cstring>
-
-#include "absl/base/dynamic_annotations.h"
-#include "absl/base/internal/raw_logging.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/string_view.h"
-#include "absl/strings/strip.h"
-
-#if defined(__native_client__)
-
-#include <nacl/nacl_random.h>
-#define ABSL_RANDOM_USE_NACL_SECURE_RANDOM 1
-
-#elif defined(_WIN32)
-
-#include <windows.h>
-#define ABSL_RANDOM_USE_BCRYPT 1
-#pragma comment(lib, "bcrypt.lib")
-
-#elif defined(__Fuchsia__)
-#include <zircon/syscalls.h>
-
-#endif
-
-#if defined(__GLIBC__) && \
-    (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 25))
-// glibc >= 2.25 has getentropy()
-#define ABSL_RANDOM_USE_GET_ENTROPY 1
-#endif
-
-#if defined(__EMSCRIPTEN__)
-#include <sys/random.h>
-// Emscripten has getentropy, but it resides in a different header.
-#define ABSL_RANDOM_USE_GET_ENTROPY 1
-#endif
-
-#if defined(ABSL_RANDOM_USE_BCRYPT)
-#include <bcrypt.h>
-
-#ifndef BCRYPT_SUCCESS
-#define BCRYPT_SUCCESS(Status) (((NTSTATUS)(Status)) >= 0)
-#endif
-// Also link bcrypt; this can be done via linker options or:
-// #pragma comment(lib, "bcrypt.lib")
-#endif
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-namespace {
-
-// Read OS Entropy for random number seeds.
-// TODO(absl-team): Possibly place a cap on how much entropy may be read at a
-// time.
-
-#if defined(ABSL_RANDOM_USE_BCRYPT)
-
-// On Windows potentially use the BCRYPT CNG API to read available entropy.
-bool ReadSeedMaterialFromOSEntropyImpl(absl::Span<uint32_t> values) {
-  BCRYPT_ALG_HANDLE hProvider;
-  NTSTATUS ret;
-  ret = BCryptOpenAlgorithmProvider(&hProvider, BCRYPT_RNG_ALGORITHM,
-                                    MS_PRIMITIVE_PROVIDER, 0);
-  if (!(BCRYPT_SUCCESS(ret))) {
-    ABSL_RAW_LOG(ERROR, "Failed to open crypto provider.");
-    return false;
-  }
-  ret = BCryptGenRandom(
-      hProvider,                                             // provider
-      reinterpret_cast<UCHAR*>(values.data()),               // buffer
-      static_cast<ULONG>(sizeof(uint32_t) * values.size()),  // bytes
-      0);                                                    // flags
-  BCryptCloseAlgorithmProvider(hProvider, 0);
-  return BCRYPT_SUCCESS(ret);
-}
-
-#elif defined(ABSL_RANDOM_USE_NACL_SECURE_RANDOM)
-
-// On NaCL use nacl_secure_random to acquire bytes.
-bool ReadSeedMaterialFromOSEntropyImpl(absl::Span<uint32_t> values) {
-  auto buffer = reinterpret_cast<uint8_t*>(values.data());
-  size_t buffer_size = sizeof(uint32_t) * values.size();
-
-  uint8_t* output_ptr = buffer;
-  while (buffer_size > 0) {
-    size_t nread = 0;
-    const int error = nacl_secure_random(output_ptr, buffer_size, &nread);
-    if (error != 0 || nread > buffer_size) {
-      ABSL_RAW_LOG(ERROR, "Failed to read secure_random seed data: %d", error);
-      return false;
-    }
-    output_ptr += nread;
-    buffer_size -= nread;
-  }
-  return true;
-}
-
-#elif defined(__Fuchsia__)
-
-bool ReadSeedMaterialFromOSEntropyImpl(absl::Span<uint32_t> values) {
-  auto buffer = reinterpret_cast<uint8_t*>(values.data());
-  size_t buffer_size = sizeof(uint32_t) * values.size();
-  zx_cprng_draw(buffer, buffer_size);
-  return true;
-}
-
-#else
-
-#if defined(ABSL_RANDOM_USE_GET_ENTROPY)
-// On *nix, use getentropy() if supported. Note that libc may support
-// getentropy(), but the kernel may not, in which case this function will return
-// false.
-bool ReadSeedMaterialFromGetEntropy(absl::Span<uint32_t> values) {
-  auto buffer = reinterpret_cast<uint8_t*>(values.data());
-  size_t buffer_size = sizeof(uint32_t) * values.size();
-  while (buffer_size > 0) {
-    // getentropy() has a maximum permitted length of 256.
-    size_t to_read = std::min<size_t>(buffer_size, 256);
-    int result = getentropy(buffer, to_read);
-    if (result < 0) {
-      return false;
-    }
-    // https://github.com/google/sanitizers/issues/1173
-    // MemorySanitizer can't see through getentropy().
-    ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(buffer, to_read);
-    buffer += to_read;
-    buffer_size -= to_read;
-  }
-  return true;
-}
-#endif  // defined(ABSL_RANDOM_GETENTROPY)
-
-// On *nix, read entropy from /dev/urandom.
-bool ReadSeedMaterialFromDevURandom(absl::Span<uint32_t> values) {
-  const char kEntropyFile[] = "/dev/urandom";
-
-  auto buffer = reinterpret_cast<uint8_t*>(values.data());
-  size_t buffer_size = sizeof(uint32_t) * values.size();
-
-  int dev_urandom = open(kEntropyFile, O_RDONLY);
-  bool success = (-1 != dev_urandom);
-  if (!success) {
-    return false;
-  }
-
-  while (success && buffer_size > 0) {
-    int bytes_read = read(dev_urandom, buffer, buffer_size);
-    int read_error = errno;
-    success = (bytes_read > 0);
-    if (success) {
-      buffer += bytes_read;
-      buffer_size -= bytes_read;
-    } else if (bytes_read == -1 && read_error == EINTR) {
-      success = true;  // Need to try again.
-    }
-  }
-  close(dev_urandom);
-  return success;
-}
-
-bool ReadSeedMaterialFromOSEntropyImpl(absl::Span<uint32_t> values) {
-#if defined(ABSL_RANDOM_USE_GET_ENTROPY)
-  if (ReadSeedMaterialFromGetEntropy(values)) {
-    return true;
-  }
-#endif
-  // Libc may support getentropy, but the kernel may not, so we still have
-  // to fallback to ReadSeedMaterialFromDevURandom().
-  return ReadSeedMaterialFromDevURandom(values);
-}
-
-#endif
-
-}  // namespace
-
-bool ReadSeedMaterialFromOSEntropy(absl::Span<uint32_t> values) {
-  assert(values.data() != nullptr);
-  if (values.data() == nullptr) {
-    return false;
-  }
-  if (values.empty()) {
-    return true;
-  }
-  return ReadSeedMaterialFromOSEntropyImpl(values);
-}
-
-void MixIntoSeedMaterial(absl::Span<const uint32_t> sequence,
-                         absl::Span<uint32_t> seed_material) {
-  // Algorithm is based on code available at
-  // https://gist.github.com/imneme/540829265469e673d045
-  constexpr uint32_t kInitVal = 0x43b0d7e5;
-  constexpr uint32_t kHashMul = 0x931e8875;
-  constexpr uint32_t kMixMulL = 0xca01f9dd;
-  constexpr uint32_t kMixMulR = 0x4973f715;
-  constexpr uint32_t kShiftSize = sizeof(uint32_t) * 8 / 2;
-
-  uint32_t hash_const = kInitVal;
-  auto hash = [&](uint32_t value) {
-    value ^= hash_const;
-    hash_const *= kHashMul;
-    value *= hash_const;
-    value ^= value >> kShiftSize;
-    return value;
-  };
-
-  auto mix = [&](uint32_t x, uint32_t y) {
-    uint32_t result = kMixMulL * x - kMixMulR * y;
-    result ^= result >> kShiftSize;
-    return result;
-  };
-
-  for (const auto& seq_val : sequence) {
-    for (auto& elem : seed_material) {
-      elem = mix(elem, hash(seq_val));
-    }
-  }
-}
-
-absl::optional<uint32_t> GetSaltMaterial() {
-  // Salt must be common for all generators within the same process so read it
-  // only once and store in static variable.
-  static const auto salt_material = []() -> absl::optional<uint32_t> {
-    uint32_t salt_value = 0;
-
-    if (random_internal::ReadSeedMaterialFromOSEntropy(
-            MakeSpan(&salt_value, 1))) {
-      return salt_value;
-    }
-
-    return absl::nullopt;
-  }();
-
-  return salt_material;
-}
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
-}  // namespace absl

data/third_party/abseil-cpp/absl/random/internal/seed_material.h

@@ -1,104 +0,0 @@
-// Copyright 2017 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_RANDOM_INTERNAL_SEED_MATERIAL_H_
-#define ABSL_RANDOM_INTERNAL_SEED_MATERIAL_H_
-
-#include <cassert>
-#include <cstdint>
-#include <cstdlib>
-#include <string>
-#include <vector>
-
-#include "absl/base/attributes.h"
-#include "absl/random/internal/fast_uniform_bits.h"
-#include "absl/types/optional.h"
-#include "absl/types/span.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// Returns the number of 32-bit blocks needed to contain the given number of
-// bits.
-constexpr size_t SeedBitsToBlocks(size_t seed_size) {
-  return (seed_size + 31) / 32;
-}
-
-// Amount of entropy (measured in bits) used to instantiate a Seed Sequence,
-// with which to create a URBG.
-constexpr size_t kEntropyBitsNeeded = 256;
-
-// Amount of entropy (measured in 32-bit blocks) used to instantiate a Seed
-// Sequence, with which to create a URBG.
-constexpr size_t kEntropyBlocksNeeded =
-    random_internal::SeedBitsToBlocks(kEntropyBitsNeeded);
-
-static_assert(kEntropyBlocksNeeded > 0,
-              "Entropy used to seed URBGs must be nonzero.");
-
-// Attempts to fill a span of uint32_t-values using an OS-provided source of
-// true entropy (eg. /dev/urandom) into an array of uint32_t blocks of data. The
-// resulting array may be used to initialize an instance of a class conforming
-// to the C++ Standard "Seed Sequence" concept [rand.req.seedseq].
-//
-// If values.data() == nullptr, the behavior is undefined.
-ABSL_MUST_USE_RESULT
-bool ReadSeedMaterialFromOSEntropy(absl::Span<uint32_t> values);
-
-// Attempts to fill a span of uint32_t-values using variates generated by an
-// existing instance of a class conforming to the C++ Standard "Uniform Random
-// Bit Generator" concept [rand.req.urng]. The resulting data may be used to
-// initialize an instance of a class conforming to the C++ Standard
-// "Seed Sequence" concept [rand.req.seedseq].
-//
-// If urbg == nullptr or values.data() == nullptr, the behavior is undefined.
-template <typename URBG>
-ABSL_MUST_USE_RESULT bool ReadSeedMaterialFromURBG(
-    URBG* urbg, absl::Span<uint32_t> values) {
-  random_internal::FastUniformBits<uint32_t> distr;
-
-  assert(urbg != nullptr && values.data() != nullptr);
-  if (urbg == nullptr || values.data() == nullptr) {
-    return false;
-  }
-
-  for (uint32_t& seed_value : values) {
-    seed_value = distr(*urbg);
-  }
-  return true;
-}
-
-// Mixes given sequence of values with into given sequence of seed material.
-// Time complexity of this function is O(sequence.size() *
-// seed_material.size()).
-//
-// Algorithm is based on code available at
-// https://gist.github.com/imneme/540829265469e673d045
-// by Melissa O'Neill.
-void MixIntoSeedMaterial(absl::Span<const uint32_t> sequence,
-                         absl::Span<uint32_t> seed_material);
-
-// Returns salt value.
-//
-// Salt is obtained only once and stored in static variable.
-//
-// May return empty value if optaining the salt was not possible.
-absl::optional<uint32_t> GetSaltMaterial();
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_RANDOM_INTERNAL_SEED_MATERIAL_H_

data/third_party/abseil-cpp/absl/random/internal/traits.h

@@ -1,149 +0,0 @@
-// Copyright 2017 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_RANDOM_INTERNAL_TRAITS_H_
-#define ABSL_RANDOM_INTERNAL_TRAITS_H_
-
-#include <cstdint>
-#include <limits>
-#include <type_traits>
-
-#include "absl/base/config.h"
-#include "absl/numeric/bits.h"
-#include "absl/numeric/int128.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// random_internal::is_widening_convertible<A, B>
-//
-// Returns whether a type A is widening-convertible to a type B.
-//
-// A is widening-convertible to B means:
-//   A a = <any number>;
-//   B b = a;
-//   A c = b;
-//   EXPECT_EQ(a, c);
-template <typename A, typename B>
-class is_widening_convertible {
-  // As long as there are enough bits in the exact part of a number:
-  // - unsigned can fit in float, signed, unsigned
-  // - signed can fit in float, signed
-  // - float can fit in float
-  // So we define rank to be:
-  // - rank(float) -> 2
-  // - rank(signed) -> 1
-  // - rank(unsigned) -> 0
-  template <class T>
-  static constexpr int rank() {
-    return !std::numeric_limits<T>::is_integer +
-           std::numeric_limits<T>::is_signed;
-  }
-
- public:
-  // If an arithmetic-type B can represent at least as many digits as a type A,
-  // and B belongs to a rank no lower than A, then A can be safely represented
-  // by B through a widening-conversion.
-  static constexpr bool value =
-      std::numeric_limits<A>::digits <= std::numeric_limits<B>::digits &&
-      rank<A>() <= rank<B>();
-};
-
-template <typename T>
-struct IsIntegral : std::is_integral<T> {};
-template <>
-struct IsIntegral<absl::int128> : std::true_type {};
-template <>
-struct IsIntegral<absl::uint128> : std::true_type {};
-
-template <typename T>
-struct MakeUnsigned : std::make_unsigned<T> {};
-template <>
-struct MakeUnsigned<absl::int128> {
-  using type = absl::uint128;
-};
-template <>
-struct MakeUnsigned<absl::uint128> {
-  using type = absl::uint128;
-};
-
-template <typename T>
-struct IsUnsigned : std::is_unsigned<T> {};
-template <>
-struct IsUnsigned<absl::int128> : std::false_type {};
-template <>
-struct IsUnsigned<absl::uint128> : std::true_type {};
-
-// unsigned_bits<N>::type returns the unsigned int type with the indicated
-// number of bits.
-template <size_t N>
-struct unsigned_bits;
-
-template <>
-struct unsigned_bits<8> {
-  using type = uint8_t;
-};
-template <>
-struct unsigned_bits<16> {
-  using type = uint16_t;
-};
-template <>
-struct unsigned_bits<32> {
-  using type = uint32_t;
-};
-template <>
-struct unsigned_bits<64> {
-  using type = uint64_t;
-};
-
-template <>
-struct unsigned_bits<128> {
-  using type = absl::uint128;
-};
-
-// 256-bit wrapper for wide multiplications.
-struct U256 {
-  uint128 hi;
-  uint128 lo;
-};
-template <>
-struct unsigned_bits<256> {
-  using type = U256;
-};
-
-template <typename IntType>
-struct make_unsigned_bits {
-  using type = typename unsigned_bits<
-      std::numeric_limits<typename MakeUnsigned<IntType>::type>::digits>::type;
-};
-
-template <typename T>
-int BitWidth(T v) {
-  // Workaround for bit_width not supporting int128.
-  // Don't hardcode `64` to make sure this code does not trigger compiler
-  // warnings in smaller types.
-  constexpr int half_bits = sizeof(T) * 8 / 2;
-  if (sizeof(T) == 16 && (v >> half_bits) != 0) {
-    return bit_width(static_cast<uint64_t>(v >> half_bits)) + half_bits;
-  } else {
-    return bit_width(static_cast<uint64_t>(v));
-  }
-}
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_RANDOM_INTERNAL_TRAITS_H_