re2 1.22.2 → 1.23.0

package/vendor/abseil-cpp/absl/random/internal/{pool_urbg.cc → entropy_pool.cc}

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "absl/random/internal/pool_urbg.h"
+#include "absl/random/internal/entropy_pool.h"
 
 #include <algorithm>
 #include <atomic>
@@ -23,15 +23,14 @@
 #include "absl/base/attributes.h"
 #include "absl/base/call_once.h"
 #include "absl/base/config.h"
-#include "absl/base/internal/endian.h"
-#include "absl/base/internal/raw_logging.h"
 #include "absl/base/internal/spinlock.h"
-#include "absl/base/internal/sysinfo.h"
-#include "absl/base/internal/unaligned_access.h"
 #include "absl/base/optimization.h"
+#include "absl/base/thread_annotations.h"
 #include "absl/random/internal/randen.h"
+#include "absl/random/internal/randen_traits.h"
 #include "absl/random/internal/seed_material.h"
 #include "absl/random/seed_gen_exception.h"
+#include "absl/types/span.h"
 
 using absl::base_internal::SpinLock;
 using absl::base_internal::SpinLockHolder;
@@ -45,16 +44,18 @@ namespace {
 // single generator within a RandenPool<T>. It is an internal implementation
 // detail, and does not aim to conform to [rand.req.urng].
 //
-// NOTE: There are alignment issues when used on ARM, for instance.
-// See the allocation code in PoolAlignedAlloc().
-class RandenPoolEntry {
+// At least 32-byte alignment is required for the state_ array on some ARM
+// platforms.  We also want this aligned to a cacheline to eliminate false
+// sharing.
+class alignas(std::max(size_t{ABSL_CACHELINE_SIZE}, size_t{32}))
+    RandenPoolEntry {
  public:
   static constexpr size_t kState = RandenTraits::kStateBytes / sizeof(uint32_t);
   static constexpr size_t kCapacity =
       RandenTraits::kCapacityBytes / sizeof(uint32_t);
 
   void Init(absl::Span<const uint32_t> data) {
-    SpinLockHolder l(&mu_);  // Always uncontested.
+    SpinLockHolder l(mu_);  // Always uncontested.
     std::copy(data.begin(), data.end(), std::begin(state_));
     next_ = kState;
   }
@@ -62,10 +63,6 @@ class RandenPoolEntry {
   // Copy bytes into out.
   void Fill(uint8_t* out, size_t bytes) ABSL_LOCKS_EXCLUDED(mu_);
 
-  // Returns random bits from the buffer in units of T.
-  template <typename T>
-  inline T Generate() ABSL_LOCKS_EXCLUDED(mu_);
-
   inline void MaybeRefill() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
     if (next_ >= kState) {
       next_ = kCapacity;
@@ -73,55 +70,24 @@ class RandenPoolEntry {
     }
   }
 
+  inline size_t available() const ABSL_SHARED_LOCKS_REQUIRED(mu_) {
+    return kState - next_;
+  }
+
  private:
   // Randen URBG state.
-  uint32_t state_[kState] ABSL_GUARDED_BY(mu_);  // First to satisfy alignment.
+  // At least 32-byte alignment is required by ARM platform code.
+  alignas(32) uint32_t state_[kState] ABSL_GUARDED_BY(mu_);
   SpinLock mu_;
   const Randen impl_;
   size_t next_ ABSL_GUARDED_BY(mu_);
 };
 
-template <>
-inline uint8_t RandenPoolEntry::Generate<uint8_t>() {
-  SpinLockHolder l(&mu_);
-  MaybeRefill();
-  return static_cast<uint8_t>(state_[next_++]);
-}
-
-template <>
-inline uint16_t RandenPoolEntry::Generate<uint16_t>() {
-  SpinLockHolder l(&mu_);
-  MaybeRefill();
-  return static_cast<uint16_t>(state_[next_++]);
-}
-
-template <>
-inline uint32_t RandenPoolEntry::Generate<uint32_t>() {
-  SpinLockHolder l(&mu_);
-  MaybeRefill();
-  return state_[next_++];
-}
-
-template <>
-inline uint64_t RandenPoolEntry::Generate<uint64_t>() {
-  SpinLockHolder l(&mu_);
-  if (next_ >= kState - 1) {
-    next_ = kCapacity;
-    impl_.Generate(state_);
-  }
-  auto p = state_ + next_;
-  next_ += 2;
-
-  uint64_t result;
-  std::memcpy(&result, p, sizeof(result));
-  return result;
-}
-
 void RandenPoolEntry::Fill(uint8_t* out, size_t bytes) {
-  SpinLockHolder l(&mu_);
+  SpinLockHolder l(mu_);
   while (bytes > 0) {
     MaybeRefill();
-    size_t remaining = (kState - next_) * sizeof(state_[0]);
+    size_t remaining = available() * sizeof(state_[0]);
     size_t to_copy = std::min(bytes, remaining);
     std::memcpy(out, &state_[next_], to_copy);
     out += to_copy;
@@ -185,38 +151,17 @@ size_t GetPoolID() {
 #endif
 }
 
-// Allocate a RandenPoolEntry with at least 32-byte alignment, which is required
-// by ARM platform code.
-RandenPoolEntry* PoolAlignedAlloc() {
-  constexpr size_t kAlignment =
-      ABSL_CACHELINE_SIZE > 32 ? ABSL_CACHELINE_SIZE : 32;
-
-  // Not all the platforms that we build for have std::aligned_alloc, however
-  // since we never free these objects, we can over allocate and munge the
-  // pointers to the correct alignment.
-  uintptr_t x = reinterpret_cast<uintptr_t>(
-      new char[sizeof(RandenPoolEntry) + kAlignment]);
-  auto y = x % kAlignment;
-  void* aligned = reinterpret_cast<void*>(y == 0 ? x : (x + kAlignment - y));
-  return new (aligned) RandenPoolEntry();
-}
-
 // Allocate and initialize kPoolSize objects of type RandenPoolEntry.
-//
-// The initialization strategy is to initialize one object directly from
-// OS entropy, then to use that object to seed all of the individual
-// pool instances.
 void InitPoolURBG() {
   static constexpr size_t kSeedSize =
       RandenTraits::kStateBytes / sizeof(uint32_t);
-  // Read the seed data from OS entropy once.
+  // Read OS entropy once, and use it to initialize each pool entry.
   uint32_t seed_material[kPoolSize * kSeedSize];
-  if (!random_internal::ReadSeedMaterialFromOSEntropy(
-          absl::MakeSpan(seed_material))) {
-    random_internal::ThrowSeedGenException();
+  if (!ReadSeedMaterialFromOSEntropy(absl::MakeSpan(seed_material))) {
+    ThrowSeedGenException();
   }
   for (size_t i = 0; i < kPoolSize; i++) {
-    shared_pools[i] = PoolAlignedAlloc();
+    shared_pools[i] = new RandenPoolEntry();
     shared_pools[i]->Init(
         absl::MakeSpan(&seed_material[i * kSeedSize], kSeedSize));
   }
@@ -230,24 +175,11 @@ RandenPoolEntry* GetPoolForCurrentThread() {
 
 }  // namespace
 
-template <typename T>
-typename RandenPool<T>::result_type RandenPool<T>::Generate() {
+void GetEntropyFromRandenPool(void* dest, size_t bytes) {
   auto* pool = GetPoolForCurrentThread();
-  return pool->Generate<T>();
+  pool->Fill(reinterpret_cast<uint8_t*>(dest), bytes);
 }
 
-template <typename T>
-void RandenPool<T>::Fill(absl::Span<result_type> data) {
-  auto* pool = GetPoolForCurrentThread();
-  pool->Fill(reinterpret_cast<uint8_t*>(data.data()),
-             data.size() * sizeof(result_type));
-}
-
-template class RandenPool<uint8_t>;
-template class RandenPool<uint16_t>;
-template class RandenPool<uint32_t>;
-template class RandenPool<uint64_t>;
-
 }  // namespace random_internal
 ABSL_NAMESPACE_END
 }  // namespace absl

package/vendor/abseil-cpp/absl/{base/inline_variable_test_b.cc → random/internal/entropy_pool.h}

@@ -12,16 +12,24 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "absl/base/internal/inline_variable_testing.h"
+#ifndef ABSL_RANDOM_INTERNAL_ENTROPY_POOL_H_
+#define ABSL_RANDOM_INTERNAL_ENTROPY_POOL_H_
+
+#include <cstddef>
+
+#include "absl/base/config.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
-namespace inline_variable_testing_internal {
+namespace random_internal {
 
-const Foo& get_foo_b() { return inline_variable_foo; }
+// GetEntropyFromRandenPool() is a helper function that fills a memory region
+// with random bytes from the RandenPool.  This is used by the absl::BitGen
+// implementation to fill the internal buffer.
+void GetEntropyFromRandenPool(void* dest, size_t bytes);
 
-const int& get_int_b() { return inline_variable_int; }
-
-}  // namespace inline_variable_testing_internal
+}  // namespace random_internal
 ABSL_NAMESPACE_END
 }  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_ENTROPY_POOL_H_

package/vendor/abseil-cpp/absl/random/internal/entropy_pool_test.cc

@@ -0,0 +1,119 @@
+// 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/entropy_pool.h"
+
+#include <bitset>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <thread>  // NOLINT
+#include <utility>
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/synchronization/mutex.h"
+
+namespace {
+
+using ::absl::random_internal::GetEntropyFromRandenPool;
+
+TEST(EntropyPoolTest, DistinctSequencesPerThread) {
+  using result_type = uint32_t;
+  constexpr int kNumThreads = 12;
+  constexpr size_t kValuesPerThread = 32;
+
+  // Acquire entropy from multiple threads.
+  std::vector<std::vector<result_type>> data;
+  {
+    absl::Mutex mu;
+    std::vector<std::thread> threads;
+    for (int i = 0; i < kNumThreads; i++) {
+      threads.emplace_back([&]() {
+        std::vector<result_type> v(kValuesPerThread);
+        GetEntropyFromRandenPool(v.data(), sizeof(result_type) * v.size());
+        absl::MutexLock l(mu);
+        data.push_back(std::move(v));
+      });
+    }
+    for (auto& t : threads) t.join();
+  }
+
+  EXPECT_EQ(data.size(), kNumThreads);
+
+  // There should be essentially no duplicates in the sequences.
+  size_t expected_size = 0;
+  absl::flat_hash_set<result_type> seen;
+  for (const auto& v : data) {
+    expected_size += v.size();
+    for (result_type x : v) seen.insert(x);
+  }
+  EXPECT_GE(seen.size(), expected_size - 1);
+}
+
+// This validates that sequences are independent.
+TEST(EntropyPoolTest, ValidateDistribution) {
+  using result_type = uint32_t;
+  constexpr int kNumOutputs = 16;
+  std::vector<result_type> a(kNumOutputs);
+  std::vector<result_type> b(kNumOutputs);
+
+  GetEntropyFromRandenPool(a.data(), sizeof(a[0]) * a.size());
+  GetEntropyFromRandenPool(b.data(), sizeof(b[0]) * b.size());
+
+  // Compare the two sequences, counting the number of bits that are different,
+  // then verify using a normal-approximation of the binomial distribution.
+  size_t changed_bits = 0;
+  size_t total_set = 0;
+  size_t equal_count = 0;
+  size_t zero_count = 0;
+  for (size_t i = 0; i < a.size(); ++i) {
+    std::bitset<sizeof(result_type) * 8> changed_set(a[i] ^ b[i]);
+    changed_bits += changed_set.count();
+
+    std::bitset<sizeof(result_type) * 8> a_set(a[i]);
+    std::bitset<sizeof(result_type) * 8> b_set(b[i]);
+    total_set += a_set.count() + b_set.count();
+
+    equal_count += (a[i] == b[i]) ? 1 : 0;
+
+    zero_count += (a[i] == 0) ? 1 : 0;
+    zero_count += (b[i] == 0) ? 1 : 0;
+  }
+
+  constexpr size_t kNBits = kNumOutputs * sizeof(result_type) * 8;
+
+  // This should be a binomial distribution with:
+  //    p = 0.5
+  //    n = kNBits
+  //    sigma =~ 11.3 (sqrt(n * 0.5 * 0.5))
+  // So we expect the number of changed bits to be within 5 standard deviations
+  // of the mean; this should fail less than one in 3 million times.
+  EXPECT_NEAR(changed_bits, kNBits * 0.5, 5 * std::sqrt(kNBits))
+      << "@" << changed_bits / static_cast<double>(kNBits);
+
+  // Verify that the number of set bits is also within the expected range;
+  // Note that this is summed over the two sequences, so the number of trials
+  // is twice the number of bits.
+  EXPECT_NEAR(total_set, kNBits, 5 * std::sqrt(2 * kNBits))
+      << "@" << total_set / static_cast<double>(2 * kNBits);
+
+  // A[i] == B[i] with probability ~= 16 * 1/2^32; certainly less than 1.
+  EXPECT_LE(equal_count, 1);
+
+  // Zeros values must be rare; 32 / 2^32 is certainly less than 1.
+  EXPECT_LE(zero_count, 1);
+}
+}  // namespace

package/vendor/abseil-cpp/absl/random/internal/mock_helpers.h

@@ -19,7 +19,7 @@
 #include <utility>
 
 #include "absl/base/config.h"
-#include "absl/base/internal/fast_type_id.h"
+#include "absl/base/fast_type_id.h"
 #include "absl/types/optional.h"
 
 namespace absl {
@@ -48,7 +48,7 @@ struct NoOpValidator {
 //   result_type(args...)
 //
 class MockHelpers {
-  using IdType = ::absl::base_internal::FastTypeIdType;
+  using IdType = ::absl::FastTypeIdType;
 
   // Given a key signature type used to index the mock, extract the components.
   // KeyT is expected to have the form:
@@ -82,8 +82,7 @@ class MockHelpers {
                                                 Args&&... args) {
     ArgTupleT arg_tuple(std::forward<Args>(args)...);
     ReturnT result;
-    if (urbg->InvokeMock(::absl::base_internal::FastTypeId<KeyT>(), &arg_tuple,
-                         &result)) {
+    if (urbg->InvokeMock(FastTypeId<KeyT>(), &arg_tuple, &result)) {
       return result;
     }
     return absl::nullopt;
@@ -92,9 +91,9 @@ class MockHelpers {
  public:
   // InvokeMock is private; this provides access for some specialized use cases.
   template <typename URBG>
-  static inline bool PrivateInvokeMock(URBG* urbg, IdType type,
+  static inline bool PrivateInvokeMock(URBG* urbg, IdType key_id,
                                        void* args_tuple, void* result) {
-    return urbg->InvokeMock(type, args_tuple, result);
+    return urbg->InvokeMock(key_id, args_tuple, result);
   }
 
   // Invoke a mock for the KeyT (may or may not be a signature).
@@ -138,7 +137,7 @@ class MockHelpers {
           m, std::declval<IdType>(), ValidatorT())) {
     return m.template RegisterMock<typename KeySignature<KeyT>::result_type,
                                    typename KeySignature<KeyT>::arg_tuple_type>(
-        m, ::absl::base_internal::FastTypeId<KeyT>(), ValidatorT());
+        m, ::absl::FastTypeId<KeyT>(), ValidatorT());
   }
 
   // Acquire a mock for the KeyT (may or may not be a signature).

package/vendor/abseil-cpp/absl/random/internal/nonsecure_base.h

@@ -16,19 +16,19 @@
 #define ABSL_RANDOM_INTERNAL_NONSECURE_BASE_H_
 
 #include <algorithm>
+#include <cstddef>
 #include <cstdint>
 #include <iterator>
 #include <type_traits>
 #include <utility>
 #include <vector>
 
-#include "absl/base/macros.h"
+#include "absl/base/config.h"
 #include "absl/container/inlined_vector.h"
 #include "absl/meta/type_traits.h"
-#include "absl/random/internal/pool_urbg.h"
+#include "absl/random/internal/entropy_pool.h"
 #include "absl/random/internal/salted_seed_seq.h"
 #include "absl/random/internal/seed_material.h"
-#include "absl/types/span.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -46,8 +46,7 @@ class RandenPoolSeedSeq {
   void generate_impl(ContiguousTag, Contiguous begin, Contiguous end) {
     const size_t n = static_cast<size_t>(std::distance(begin, end));
     auto* a = &(*begin);
-    RandenPool<uint8_t>::Fill(
-        absl::MakeSpan(reinterpret_cast<uint8_t*>(a), sizeof(*a) * n));
+    GetEntropyFromRandenPool(a, sizeof(*a) * n);
   }
 
   // Construct a buffer of size n and fill it with values, then copy
@@ -57,7 +56,7 @@ class RandenPoolSeedSeq {
                      RandomAccessIterator end) {
     const size_t n = std::distance(begin, end);
     absl::InlinedVector<uint32_t, 8> data(n, 0);
-    RandenPool<uint32_t>::Fill(absl::MakeSpan(data.begin(), data.end()));
+    GetEntropyFromRandenPool(data.begin(), sizeof(data[0]) * n);
     std::copy(std::begin(data), std::end(data), begin);
   }
 

package/vendor/abseil-cpp/absl/random/internal/nonsecure_base_test.cc

@@ -14,18 +14,22 @@
 
 #include "absl/random/internal/nonsecure_base.h"
 
+#include <algorithm>
 #include <cstddef>
 #include <cstdint>
 #include <iterator>
 #include <random>
+#include <thread>  // NOLINT
 #include <type_traits>
 #include <utility>
 #include <vector>
 
 #include "gtest/gtest.h"
+#include "absl/container/flat_hash_set.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/distributions.h"
 #include "absl/random/random.h"
+#include "absl/synchronization/mutex.h"
 
 namespace {
 
@@ -194,6 +198,41 @@ TEST(NonsecureURBGBase, EqualSeedSequencesYieldEqualVariates) {
   }
 }
 
+TEST(NonsecureURBGBase, DistinctSequencesPerThread) {
+  constexpr int kNumThreads = 12;
+  constexpr size_t kValuesPerThread = 32;
+  using result_type = absl::BitGen::result_type;
+
+  // Acquire initial sequences from multiple threads.
+  std::vector<std::vector<result_type>> data;
+  {
+    absl::Mutex mu;
+    std::vector<std::thread> threads;
+    for (int i = 0; i < kNumThreads; i++) {
+      threads.emplace_back([&]() {
+        absl::BitGen gen;
+
+        std::vector<result_type> v(kValuesPerThread);
+        std::generate(v.begin(), v.end(), [&]() { return gen(); });
+        absl::MutexLock l(mu);
+        data.push_back(std::move(v));
+      });
+    }
+    for (auto& t : threads) t.join();
+  }
+
+  EXPECT_EQ(data.size(), kNumThreads);
+
+  // There should be essentially no duplicates in the sequences.
+  size_t expected_size = 0;
+  absl::flat_hash_set<result_type> seen;
+  for (const auto& v : data) {
+    expected_size += v.size();
+    for (result_type x : v) seen.insert(x);
+  }
+  EXPECT_GE(seen.size(), expected_size - 1);
+}
+
 TEST(RandenPoolSeedSeqTest, SeederWorksForU32) {
   absl::random_internal::RandenPoolSeedSeq seeder;
 

package/vendor/abseil-cpp/absl/random/internal/randen_benchmarks.cc

@@ -20,6 +20,7 @@
 #include "absl/random/internal/nanobenchmark.h"
 #include "absl/random/internal/platform.h"
 #include "absl/random/internal/randen.h"
+#include "absl/random/internal/randen_detect.h"
 #include "absl/random/internal/randen_engine.h"
 #include "absl/random/internal/randen_hwaes.h"
 #include "absl/random/internal/randen_slow.h"
@@ -27,6 +28,7 @@
 
 namespace {
 
+using absl::random_internal::CPUSupportsRandenHwAes;
 using absl::random_internal::Randen;
 using absl::random_internal::RandenHwAes;
 using absl::random_internal::RandenSlow;
@@ -150,14 +152,14 @@ void RunAll(const int argc, char* argv[]) {
   const FuncInput unpredictable = (argc != 999);
   static const FuncInput inputs[] = {unpredictable * 100, unpredictable * 1000};
 
-#if !defined(ABSL_INTERNAL_DISABLE_AES) && ABSL_HAVE_ACCELERATED_AES
-  Measure<AbsorbFn<RandenHwAes>>("Absorb (HwAes)", inputs);
-#endif
+  if (CPUSupportsRandenHwAes()) {
+    Measure<AbsorbFn<RandenHwAes>>("Absorb (HwAes)", inputs);
+  }
   Measure<AbsorbFn<RandenSlow>>("Absorb (Slow)", inputs);
 
-#if !defined(ABSL_INTERNAL_DISABLE_AES) && ABSL_HAVE_ACCELERATED_AES
-  Measure<GenerateFn<RandenHwAes>>("Generate (HwAes)", inputs);
-#endif
+  if (CPUSupportsRandenHwAes()) {
+    Measure<GenerateFn<RandenHwAes>>("Generate (HwAes)", inputs);
+  }
   Measure<GenerateFn<RandenSlow>>("Generate (Slow)", inputs);
 
   // Measure the production engine.

package/vendor/abseil-cpp/absl/random/internal/randen_detect.cc

@@ -74,7 +74,7 @@ static void __cpuid(int cpu_info[4], int info_type) {
 // On linux, just use the c-library getauxval call.
 #if defined(ABSL_INTERNAL_USE_LINUX_GETAUXVAL)
 
-extern "C" unsigned long getauxval(unsigned long type);  // NOLINT(runtime/int)
+#include <sys/auxv.h>
 
 static uint32_t GetAuxval(uint32_t hwcap_type) {
   return static_cast<uint32_t>(getauxval(hwcap_type));

package/vendor/abseil-cpp/absl/random/internal/seed_material.cc

@@ -23,17 +23,23 @@
 #endif
 
 #include <algorithm>
+#include <cassert>
 #include <cerrno>
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
+#include <string>
+#include <vector>
 
+#include "absl/base/config.h"
 #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"
+#include "absl/types/optional.h"
+#include "absl/types/span.h"
 
 #if defined(__native_client__)
 
@@ -167,24 +173,27 @@ bool ReadSeedMaterialFromDevURandom(absl::Span<uint32_t> values) {
   size_t buffer_size = sizeof(uint32_t) * values.size();
 
   int dev_urandom = open(kEntropyFile, O_RDONLY);
-  bool success = (-1 != dev_urandom);
-  if (!success) {
+  if (dev_urandom < 0) {
+    ABSL_RAW_LOG(ERROR, "Failed to open /dev/urandom.");
     return false;
   }
 
-  while (success && buffer_size > 0) {
+  while (buffer_size > 0) {
     ssize_t bytes_read = read(dev_urandom, buffer, buffer_size);
     int read_error = errno;
-    success = (bytes_read > 0);
-    if (success) {
-      buffer += bytes_read;
-      buffer_size -= static_cast<size_t>(bytes_read);
-    } else if (bytes_read == -1 && read_error == EINTR) {
-      success = true;  // Need to try again.
+    if (bytes_read == -1 && read_error == EINTR) {
+      // Interrupted, try again.
+      continue;
+    } else if (bytes_read <= 0) {
+      // EOF, or error.
+      break;
     }
+    buffer += bytes_read;
+    buffer_size -= static_cast<size_t>(bytes_read);
   }
+
   close(dev_urandom);
-  return success;
+  return buffer_size == 0;
 }
 
 bool ReadSeedMaterialFromOSEntropyImpl(absl::Span<uint32_t> values) {
@@ -251,8 +260,7 @@ absl::optional<uint32_t> GetSaltMaterial() {
   static const auto salt_material = []() -> absl::optional<uint32_t> {
     uint32_t salt_value = 0;
 
-    if (random_internal::ReadSeedMaterialFromOSEntropy(
-            MakeSpan(&salt_value, 1))) {
+    if (ReadSeedMaterialFromOSEntropy(absl::MakeSpan(&salt_value, 1))) {
       return salt_value;
     }
 

package/vendor/abseil-cpp/absl/random/internal/seed_material.h

@@ -21,7 +21,7 @@
 #include <string>
 #include <vector>
 
-#include "absl/base/attributes.h"
+#include "absl/base/config.h"
 #include "absl/random/internal/fast_uniform_bits.h"
 #include "absl/types/optional.h"
 #include "absl/types/span.h"
@@ -54,7 +54,7 @@ static_assert(kEntropyBlocksNeeded > 0,
 // to the C++ Standard "Seed Sequence" concept [rand.req.seedseq].
 //
 // If values.data() == nullptr, the behavior is undefined.
-ABSL_MUST_USE_RESULT
+[[nodiscard]]
 bool ReadSeedMaterialFromOSEntropy(absl::Span<uint32_t> values);
 
 // Attempts to fill a span of uint32_t-values using variates generated by an
@@ -65,8 +65,8 @@ bool ReadSeedMaterialFromOSEntropy(absl::Span<uint32_t> values);
 //
 // 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) {
+[[nodiscard]] bool ReadSeedMaterialFromURBG(URBG* urbg,
+                                            absl::Span<uint32_t> values) {
   random_internal::FastUniformBits<uint32_t> distr;
 
   assert(urbg != nullptr && values.data() != nullptr);
@@ -94,7 +94,7 @@ void MixIntoSeedMaterial(absl::Span<const uint32_t> sequence,
 //
 // Salt is obtained only once and stored in static variable.
 //
-// May return empty value if optaining the salt was not possible.
+// May return empty value if obtaining the salt was not possible.
 absl::optional<uint32_t> GetSaltMaterial();
 
 }  // namespace random_internal

package/vendor/abseil-cpp/absl/random/internal/seed_material_test.cc

@@ -15,12 +15,15 @@
 #include "absl/random/internal/seed_material.h"
 
 #include <bitset>
+#include <cstdint>
 #include <cstdlib>
 #include <cstring>
 #include <random>
+#include <vector>
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
+#include "absl/types/span.h"
 
 #ifdef __ANDROID__
 // Android assert messages only go to system log, so death tests cannot inspect