Export of internal Abseil changes

--
dab5caab05d89d03066ef92584660688595a3aaf by Mark Barolak <mbar@google.com>:

Add absl::Status and absl::StatusOr to absl/README.md

Import of https://github.com/abseil/abseil-cpp/pull/863

PiperOrigin-RevId: 347857368

--
1ca3c7a96417cd6e6d62f4dc36fd5ddaa61cfa20 by Chris Kennelly <ckennelly@google.com>:

Leverage integer power-of-2 functions and bit counting library in Abseil.

PiperOrigin-RevId: 347816486

--
e5cbe05879fd65dce7875e2e0105331a1615d89b by Chris Kennelly <ckennelly@google.com>:

Mitigate narrowing warning on MSVC.

If sizeof(x) <= sizeof(uint32_t), no truncation occurs when casting to
uint32_t, but the compiler cannot always determine this.

PiperOrigin-RevId: 347696526

--
079dff64cb175d282d9e22dfb4a522199ffdae2e by Benjamin Barenblat <bbaren@google.com>:

Avoid libgcc -NaN narrowing bug

When testing -NaN parsing, avoid narrowing -NaN from double to float.
This avoids a bug in libgcc
(https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98251).

PiperOrigin-RevId: 347654751

--
2e78a7634865aeef6765e1f447e96cf8d9985059 by Chris Kennelly <ckennelly@google.com>:

Mark popcount helpers as inline.

These are conditionally constexpr, so we need to add inline to cover the
non-constexpr builds to avoid ODR violations.

PiperOrigin-RevId: 347620138

--
437fbb363aea1654179f102dcdd607ec33c1af1e by Chris Kennelly <ckennelly@google.com>:

Use explicit narrowing cast.

This is never invoked in practice, but compilers with -Wimplicit-int-conversion
may trigger when sizeof(T) > sizeof(uint16_t) prior to determining this never
runs.

PiperOrigin-RevId: 347609857
GitOrigin-RevId: dab5caab05d89d03066ef92584660688595a3aaf
Change-Id: I6296ddffe7ec646f8ce121138f21e1e85a2cff4b

1 files changed, 8 insertions, 21 deletions

diff --git a/absl/container/internal/raw_hash_set.h b/absl/container/internal/raw_hash_set.h
index a958daaf..4477f7dc 100644
--- a/absl/container/internal/raw_hash_set.h
+++ b/absl/container/internal/raw_hash_set.h
@@ -102,7 +102,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/base/internal/bits.h"
 #include "absl/base/internal/endian.h"
 #include "absl/base/optimization.h"
 #include "absl/base/port.h"
@@ -116,6 +115,7 @@
 #include "absl/container/internal/layout.h"
 #include "absl/memory/memory.h"
 #include "absl/meta/type_traits.h"
+#include "absl/numeric/bits.h"
 #include "absl/utility/utility.h"
 
 namespace absl {
@@ -190,17 +190,8 @@ constexpr bool IsNoThrowSwappable(std::false_type /* is_swappable */) {
 
 template <typename T>
 int TrailingZeros(T x) {
-  return sizeof(T) == 8 ? base_internal::CountTrailingZerosNonZero64(
-                              static_cast<uint64_t>(x))
-                        : base_internal::CountTrailingZerosNonZero32(
-                              static_cast<uint32_t>(x));
-}
-
-template <typename T>
-int LeadingZeros(T x) {
-  return sizeof(T) == 8
-             ? base_internal::CountLeadingZeros64(static_cast<uint64_t>(x))
-             : base_internal::CountLeadingZeros32(static_cast<uint32_t>(x));
+  ABSL_INTERNAL_ASSUME(x != 0);
+  return countr_zero(x);
 }
 
 // An abstraction over a bitmask. It provides an easy way to iterate through the
@@ -233,11 +224,7 @@ class BitMask {
   int LowestBitSet() const {
     return container_internal::TrailingZeros(mask_) >> Shift;
   }
-  int HighestBitSet() const {
-    return (sizeof(T) * CHAR_BIT - container_internal::LeadingZeros(mask_) -
-            1) >>
-           Shift;
-  }
+  int HighestBitSet() const { return (bit_width(mask_) - 1) >> Shift; }
 
   BitMask begin() const { return *this; }
   BitMask end() const { return BitMask(0); }
@@ -249,7 +236,7 @@ class BitMask {
   int LeadingZeros() const {
     constexpr int total_significant_bits = SignificantBits << Shift;
     constexpr int extra_bits = sizeof(T) * 8 - total_significant_bits;
-    return container_internal::LeadingZeros(mask_ << extra_bits) >> Shift;
+    return countl_zero(mask_ << extra_bits) >> Shift;
   }
 
  private:
@@ -380,8 +367,8 @@ struct GroupSse2Impl {
   // Returns the number of trailing empty or deleted elements in the group.
   uint32_t CountLeadingEmptyOrDeleted() const {
     auto special = _mm_set1_epi8(kSentinel);
-    return TrailingZeros(
-        _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl)) + 1);
+    return TrailingZeros(static_cast<uint32_t>(
+        _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl)) + 1));
   }
 
   void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const {
@@ -476,7 +463,7 @@ void ConvertDeletedToEmptyAndFullToDeleted(ctrl_t* ctrl, size_t capacity);
 
 // Rounds up the capacity to the next power of 2 minus 1, with a minimum of 1.
 inline size_t NormalizeCapacity(size_t n) {
-  return n ? ~size_t{} >> LeadingZeros(n) : 1;
+  return n ? ~size_t{} >> countl_zero(n) : 1;
 }
 
 // We use 7/8th as maximum load factor.