grpc 1.72.0 → 1.73.0

data/third_party/abseil-cpp/absl/hash/internal/hash.h

@@ -36,8 +36,10 @@
 #include <algorithm>
 #include <array>
 #include <bitset>
+#include <cassert>
 #include <cmath>
 #include <cstddef>
+#include <cstdint>
 #include <cstring>
 #include <deque>
 #include <forward_list>
@@ -56,7 +58,10 @@
 #include <utility>
 #include <vector>
 
+#include "absl/base/attributes.h"
+#include "absl/base/internal/endian.h"
 #include "absl/base/internal/unaligned_access.h"
+#include "absl/base/optimization.h"
 #include "absl/base/port.h"
 #include "absl/container/fixed_array.h"
 #include "absl/hash/internal/city.h"
@@ -69,8 +74,7 @@
 #include "absl/types/variant.h"
 #include "absl/utility/utility.h"
 
-#if defined(__cpp_lib_filesystem) && __cpp_lib_filesystem >= 201703L && \
-    !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
+#if defined(__cpp_lib_filesystem) && __cpp_lib_filesystem >= 201703L
 #include <filesystem>  // NOLINT
 #endif
 
@@ -78,6 +82,10 @@
 #include <string_view>
 #endif
 
+#ifdef __ARM_ACLE
+#include <arm_acle.h>
+#endif
+
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
@@ -340,11 +348,47 @@ struct is_uniquely_represented<
 template <>
 struct is_uniquely_represented<bool> : std::false_type {};
 
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+// Specialize the trait for GNU extension types.
+template <>
+struct is_uniquely_represented<__int128> : std::true_type {};
+template <>
+struct is_uniquely_represented<unsigned __int128> : std::true_type {};
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+
+template <typename T>
+struct FitsIn64Bits : std::integral_constant<bool, sizeof(T) <= 8> {};
+
+struct CombineRaw {
+  template <typename H>
+  H operator()(H state, uint64_t value) const {
+    return H::combine_raw(std::move(state), value);
+  }
+};
+
 // hash_bytes()
 //
 // Convenience function that combines `hash_state` with the byte representation
 // of `value`.
-template <typename H, typename T>
+template <typename H, typename T,
+          absl::enable_if_t<FitsIn64Bits<T>::value, int> = 0>
+H hash_bytes(H hash_state, const T& value) {
+  const unsigned char* start = reinterpret_cast<const unsigned char*>(&value);
+  uint64_t v;
+  if (sizeof(T) == 1) {
+    v = *start;
+  } else if (sizeof(T) == 2) {
+    v = absl::base_internal::UnalignedLoad16(start);
+  } else if (sizeof(T) == 4) {
+    v = absl::base_internal::UnalignedLoad32(start);
+  } else {
+    assert(sizeof(T) == 8);
+    v = absl::base_internal::UnalignedLoad64(start);
+  }
+  return CombineRaw()(std::move(hash_state), v);
+}
+template <typename H, typename T,
+          absl::enable_if_t<!FitsIn64Bits<T>::value, int> = 0>
 H hash_bytes(H hash_state, const T& value) {
   const unsigned char* start = reinterpret_cast<const unsigned char*>(&value);
   return H::combine_contiguous(std::move(hash_state), start, sizeof(value));
@@ -446,9 +490,9 @@ std::enable_if_t<std::is_pointer<T>::value, H> AbslHashValue(H hash_state,
                                                              T ptr) {
   auto v = reinterpret_cast<uintptr_t>(ptr);
   // Due to alignment, pointers tend to have low bits as zero, and the next few
-  // bits follow a pattern since they are also multiples of some base value.
-  // Mixing the pointer twice helps prevent stuck low bits for certain alignment
-  // values.
+  // bits follow a pattern since they are also multiples of some base value. The
+  // byte swap in WeakMix helps ensure we still have good entropy in low bits.
+  // Mix pointers twice to ensure we have good entropy in low bits.
   return H::combine(std::move(hash_state), v, v);
 }
 
@@ -597,7 +641,6 @@ H AbslHashValue(H hash_state, std::basic_string_view<Char> str) {
 #endif  // ABSL_HAVE_STD_STRING_VIEW
 
 #if defined(__cpp_lib_filesystem) && __cpp_lib_filesystem >= 201703L && \
-    !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) && \
     (!defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) ||        \
      __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 130000) &&       \
     (!defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) ||         \
@@ -929,6 +972,7 @@ struct HashSelect {
     static State combine_contiguous(State hash_state, const unsigned char*,
                                     size_t);
     using State::HashStateBase::combine_contiguous;
+    static State combine_raw(State state, uint64_t value);
   };
 
   struct UniquelyRepresentedProbe {
@@ -1011,13 +1055,21 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   using uint128 = absl::uint128;
 #endif  // ABSL_HAVE_INTRINSIC_INT128
 
+  // Random data taken from the hexadecimal digits of Pi's fractional component.
+  // https://en.wikipedia.org/wiki/Nothing-up-my-sleeve_number
+  ABSL_CACHELINE_ALIGNED static constexpr uint64_t kStaticRandomData[] = {
+      0x243f'6a88'85a3'08d3, 0x1319'8a2e'0370'7344, 0xa409'3822'299f'31d0,
+      0x082e'fa98'ec4e'6c89, 0x4528'21e6'38d0'1377,
+  };
+
   static constexpr uint64_t kMul =
   sizeof(size_t) == 4 ? uint64_t{0xcc9e2d51}
-                      : uint64_t{0x9ddfea08eb382d69};
+                      : uint64_t{0xdcb22ca68cb134ed};
 
   template <typename T>
   using IntegralFastPath =
-      conjunction<std::is_integral<T>, is_uniquely_represented<T>>;
+      conjunction<std::is_integral<T>, is_uniquely_represented<T>,
+                  FitsIn64Bits<T>>;
 
  public:
   // Move only
@@ -1047,7 +1099,7 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   template <typename T, absl::enable_if_t<IntegralFastPath<T>::value, int> = 0>
   static size_t hash(T value) {
     return static_cast<size_t>(
-        Mix(Seed(), static_cast<std::make_unsigned_t<T>>(value)));
+        WeakMix(Seed() ^ static_cast<std::make_unsigned_t<T>>(value)));
   }
 
   // Overload of MixingHashState::hash()
@@ -1085,6 +1137,7 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   // Allow the HashState type-erasure implementation to invoke
   // RunCombinedUnordered() directly.
   friend class absl::HashState;
+  friend struct CombineRaw;
 
   // Workaround for MSVC bug.
   // We make the type copyable to fix the calling convention, even though we
@@ -1094,6 +1147,14 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
 
   explicit MixingHashState(uint64_t state) : state_(state) {}
 
+  // Combines a raw value from e.g. integrals/floats/pointers/etc. This allows
+  // us to be consistent with IntegralFastPath when combining raw types, but
+  // optimize Read1To3 and Read4To8 differently for the string case.
+  static MixingHashState combine_raw(MixingHashState hash_state,
+                                     uint64_t value) {
+    return MixingHashState(WeakMix(hash_state.state_ ^ value));
+  }
+
   // Implementation of the base case for combine_contiguous where we actually
   // mix the bytes into the state.
   // Dispatch to different implementations of the combine_contiguous depending
@@ -1107,6 +1168,49 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
                                         std::integral_constant<int, 8>
                                         /* sizeof_size_t */);
 
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t CombineSmallContiguousImpl(
+      uint64_t state, const unsigned char* first, size_t len) {
+    ABSL_ASSUME(len <= 8);
+    uint64_t v;
+    if (len >= 4) {
+      v = Read4To8(first, len);
+    } else if (len > 0) {
+      v = Read1To3(first, len);
+    } else {
+      // Empty ranges have no effect.
+      return state;
+    }
+    return WeakMix(state ^ v);
+  }
+
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t CombineContiguousImpl9to16(
+      uint64_t state, const unsigned char* first, size_t len) {
+    ABSL_ASSUME(len >= 9);
+    ABSL_ASSUME(len <= 16);
+    // Note: any time one half of the mix function becomes zero it will fail to
+    // incorporate any bits from the other half. However, there is exactly 1 in
+    // 2^64 values for each side that achieve this, and only when the size is
+    // exactly 16 -- for smaller sizes there is an overlapping byte that makes
+    // this impossible unless the seed is *also* incredibly unlucky.
+    auto p = Read9To16(first, len);
+    return Mix(state ^ p.first, kMul ^ p.second);
+  }
+
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t CombineContiguousImpl17to32(
+      uint64_t state, const unsigned char* first, size_t len) {
+    ABSL_ASSUME(len >= 17);
+    ABSL_ASSUME(len <= 32);
+    // Do two mixes of overlapping 16-byte ranges in parallel to minimize
+    // latency.
+    const uint64_t m0 =
+        Mix(Read8(first) ^ kStaticRandomData[1], Read8(first + 8) ^ state);
+
+    const unsigned char* tail_16b_ptr = first + (len - 16);
+    const uint64_t m1 = Mix(Read8(tail_16b_ptr) ^ kStaticRandomData[3],
+                            Read8(tail_16b_ptr + 8) ^ state);
+    return m0 ^ m1;
+  }
+
   // Slow dispatch path for calls to CombineContiguousImpl with a size argument
   // larger than PiecewiseChunkSize().  Has the same effect as calling
   // CombineContiguousImpl() repeatedly with the chunk stride size.
@@ -1122,8 +1226,8 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   // are in .second.
   static std::pair<uint64_t, uint64_t> Read9To16(const unsigned char* p,
                                                  size_t len) {
-    uint64_t low_mem = absl::base_internal::UnalignedLoad64(p);
-    uint64_t high_mem = absl::base_internal::UnalignedLoad64(p + len - 8);
+    uint64_t low_mem = Read8(p);
+    uint64_t high_mem = Read8(p + len - 8);
 #ifdef ABSL_IS_LITTLE_ENDIAN
     uint64_t most_significant = high_mem;
     uint64_t least_significant = low_mem;
@@ -1134,55 +1238,81 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
     return {least_significant, most_significant};
   }
 
+  // Reads 8 bytes from p.
+  static uint64_t Read8(const unsigned char* p) {
+    // Suppress erroneous array bounds errors on GCC.
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
+#endif
+    return absl::base_internal::UnalignedLoad64(p);
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+  }
+
   // Reads 4 to 8 bytes from p. Zero pads to fill uint64_t.
+  // TODO(b/384509507): consider optimizing this by not requiring the output to
+  // be equivalent to an integer load for 4/8 bytes. Currently, we rely on this
+  // behavior for the HashConsistentAcrossIntTypes test case. Ditto for
+  // Read1To3.
   static uint64_t Read4To8(const unsigned char* p, size_t len) {
-    uint32_t low_mem = absl::base_internal::UnalignedLoad32(p);
-    uint32_t high_mem = absl::base_internal::UnalignedLoad32(p + len - 4);
-#ifdef ABSL_IS_LITTLE_ENDIAN
-    uint32_t most_significant = high_mem;
-    uint32_t least_significant = low_mem;
-#else
-    uint32_t most_significant = low_mem;
-    uint32_t least_significant = high_mem;
-#endif
-    return (static_cast<uint64_t>(most_significant) << (len - 4) * 8) |
-           least_significant;
+    // If `len < 8`, we duplicate bytes in the middle.
+    // E.g.:
+    // `ABCD` will be read as `ABCDABCD`.
+    // `ABCDE` will be read as `ABCDBCDE`.
+    // `ABCDEF` will be read as `ABCDCDEF`.
+    // `ABCDEFG` will be read as `ABCDDEFG`.
+    // We also do not care about endianness. On big-endian platforms, bytes will
+    // be shuffled (it's fine). We always shift low memory by 32, because that
+    // can be pipelined earlier. Reading high memory requires computing
+    // `p + len - 4`.
+    uint64_t most_significant =
+        static_cast<uint64_t>(absl::base_internal::UnalignedLoad32(p)) << 32;
+    uint64_t least_significant =
+        absl::base_internal::UnalignedLoad32(p + len - 4);
+    return most_significant | least_significant;
   }
 
   // Reads 1 to 3 bytes from p. Zero pads to fill uint32_t.
   static uint32_t Read1To3(const unsigned char* p, size_t len) {
-    // The trick used by this implementation is to avoid branches if possible.
-    unsigned char mem0 = p[0];
-    unsigned char mem1 = p[len / 2];
-    unsigned char mem2 = p[len - 1];
-#ifdef ABSL_IS_LITTLE_ENDIAN
-    unsigned char significant2 = mem2;
-    unsigned char significant1 = mem1;
-    unsigned char significant0 = mem0;
-#else
-    unsigned char significant2 = mem0;
-    unsigned char significant1 = len == 2 ? mem0 : mem1;
-    unsigned char significant0 = mem2;
-#endif
-    return static_cast<uint32_t>(significant0 |                     //
-                                 (significant1 << (len / 2 * 8)) |  //
-                                 (significant2 << ((len - 1) * 8)));
+    // The trick used by this implementation is to avoid branches.
+    // We always read three bytes by duplicating.
+    // E.g.,
+    // `A` is read as `AAA`.
+    // `AB` is read as `ABB`.
+    // `ABC` is read as `ABC`.
+    // We always shift `p[0]` so that it can be pipelined better.
+    // Other bytes require extra computation to find indices.
+    uint32_t mem0 = (static_cast<uint32_t>(p[0]) << 16) | p[len - 1];
+    uint32_t mem1 = static_cast<uint32_t>(p[len / 2]) << 8;
+    return mem0 | mem1;
   }
 
-  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Mix(uint64_t state, uint64_t v) {
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Mix(uint64_t lhs, uint64_t rhs) {
     // Though the 128-bit product on AArch64 needs two instructions, it is
     // still a good balance between speed and hash quality.
     using MultType =
         absl::conditional_t<sizeof(size_t) == 4, uint64_t, uint128>;
-    // We do the addition in 64-bit space to make sure the 128-bit
-    // multiplication is fast. If we were to do it as MultType the compiler has
-    // to assume that the high word is non-zero and needs to perform 2
-    // multiplications instead of one.
-    MultType m = state + v;
-    m *= kMul;
+    MultType m = lhs;
+    m *= rhs;
     return static_cast<uint64_t>(m ^ (m >> (sizeof(m) * 8 / 2)));
   }
 
+  // Slightly lower latency than Mix, but with lower quality. The byte swap
+  // helps ensure that low bits still have high quality.
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t WeakMix(uint64_t n) {
+    // WeakMix doesn't work well on 32-bit platforms so just use Mix.
+    if (sizeof(size_t) < 8) return Mix(n, kMul);
+#ifdef __ARM_ACLE
+    // gbswap_64 compiles to `rev` on ARM, but `rbit` is better because it
+    // reverses bits rather than reversing bytes.
+    return __rbitll(n * kMul);
+#else
+    return absl::gbswap_64(n * kMul);
+#endif
+  }
+
   // An extern to avoid bloat on a direct call to LowLevelHash() with fixed
   // values for both the seed and salt parameters.
   static uint64_t LowLevelHashImpl(const unsigned char* data, size_t len);
@@ -1234,21 +1364,15 @@ inline uint64_t MixingHashState::CombineContiguousImpl(
     std::integral_constant<int, 4> /* sizeof_size_t */) {
   // For large values we use CityHash, for small ones we just use a
   // multiplicative hash.
-  uint64_t v;
-  if (len > 8) {
-    if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
-      return CombineLargeContiguousImpl32(state, first, len);
-    }
-    v = hash_internal::CityHash32(reinterpret_cast<const char*>(first), len);
-  } else if (len >= 4) {
-    v = Read4To8(first, len);
-  } else if (len > 0) {
-    v = Read1To3(first, len);
-  } else {
-    // Empty ranges have no effect.
-    return state;
+  if (len <= 8) {
+    return CombineSmallContiguousImpl(state, first, len);
   }
-  return Mix(state, v);
+  if (ABSL_PREDICT_TRUE(len <= PiecewiseChunkSize())) {
+    return Mix(state ^ hash_internal::CityHash32(
+                           reinterpret_cast<const char*>(first), len),
+               kMul);
+  }
+  return CombineLargeContiguousImpl32(state, first, len);
 }
 
 // Overload of MixingHashState::CombineContiguousImpl()
@@ -1257,38 +1381,19 @@ inline uint64_t MixingHashState::CombineContiguousImpl(
     std::integral_constant<int, 8> /* sizeof_size_t */) {
   // For large values we use LowLevelHash or CityHash depending on the platform,
   // for small ones we just use a multiplicative hash.
-  uint64_t v;
-  if (len > 16) {
-    if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
-      return CombineLargeContiguousImpl64(state, first, len);
-    }
-    v = Hash64(first, len);
-  } else if (len > 8) {
-    // This hash function was constructed by the ML-driven algorithm discovery
-    // using reinforcement learning. We fed the agent lots of inputs from
-    // microbenchmarks, SMHasher, low hamming distance from generated inputs and
-    // picked up the one that was good on micro and macrobenchmarks.
-    auto p = Read9To16(first, len);
-    uint64_t lo = p.first;
-    uint64_t hi = p.second;
-    // Rotation by 53 was found to be most often useful when discovering these
-    // hashing algorithms with ML techniques.
-    lo = absl::rotr(lo, 53);
-    state += kMul;
-    lo += state;
-    state ^= hi;
-    uint128 m = state;
-    m *= lo;
-    return static_cast<uint64_t>(m ^ (m >> 64));
-  } else if (len >= 4) {
-    v = Read4To8(first, len);
-  } else if (len > 0) {
-    v = Read1To3(first, len);
-  } else {
-    // Empty ranges have no effect.
-    return state;
+  if (len <= 8) {
+    return CombineSmallContiguousImpl(state, first, len);
+  }
+  if (len <= 16) {
+    return CombineContiguousImpl9to16(state, first, len);
+  }
+  if (len <= 32) {
+    return CombineContiguousImpl17to32(state, first, len);
+  }
+  if (ABSL_PREDICT_TRUE(len <= PiecewiseChunkSize())) {
+    return Mix(state ^ Hash64(first, len), kMul);
   }
-  return Mix(state, v);
+  return CombineLargeContiguousImpl64(state, first, len);
 }
 
 struct AggregateBarrier {};

data/third_party/abseil-cpp/absl/hash/internal/low_level_hash.cc

@@ -33,8 +33,6 @@ static uint64_t Mix(uint64_t v0, uint64_t v1) {
 
 uint64_t LowLevelHashLenGt16(const void* data, size_t len, uint64_t seed,
                              const uint64_t salt[5]) {
-  // Prefetch the cacheline that data resides in.
-  PrefetchToLocalCache(data);
   const uint8_t* ptr = static_cast<const uint8_t*>(data);
   uint64_t starting_length = static_cast<uint64_t>(len);
   const uint8_t* last_16_ptr = ptr + starting_length - 16;
@@ -42,8 +40,8 @@ uint64_t LowLevelHashLenGt16(const void* data, size_t len, uint64_t seed,
 
   if (len > 64) {
     // If we have more than 64 bytes, we're going to handle chunks of 64
-    // bytes at a time. We're going to build up two separate hash states
-    // which we will then hash together.
+    // bytes at a time. We're going to build up four separate hash states
+    // which we will then hash together. This avoids short dependency chains.
     uint64_t duplicated_state0 = current_state;
     uint64_t duplicated_state1 = current_state;
     uint64_t duplicated_state2 = current_state;

data/third_party/abseil-cpp/absl/log/absl_vlog_is_on.h

@@ -40,6 +40,8 @@
 // last . and everything after it) is stripped from each filename prior to
 // matching, as is the special suffix "-inl".
 //
+// Example: --vmodule=module_a=1,module_b=2
+//
 // Files are matched against globs in `--vmodule` in order, and the first match
 // determines the verbosity level.
 //

data/third_party/abseil-cpp/absl/log/internal/check_op.cc

@@ -14,10 +14,15 @@
 
 #include "absl/log/internal/check_op.h"
 
-#include <string.h>
-
+#include <cstring>
 #include <ostream>
+#include <string>
+#include <utility>
 
+#include "absl/base/config.h"
+#include "absl/base/nullability.h"
+#include "absl/debugging/leak_check.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
 #ifdef _MSC_VER
@@ -26,18 +31,13 @@
 #include <strings.h>  // for strcasecmp, but msvc does not have this header
 #endif
 
-#include <sstream>
-#include <string>
-
-#include "absl/base/config.h"
-#include "absl/strings/str_cat.h"
-
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace log_internal {
 
 #define ABSL_LOGGING_INTERNAL_DEFINE_MAKE_CHECK_OP_STRING(x) \
-  template std::string* MakeCheckOpString(x, x, const char*)
+  template absl::Nonnull<const char*> MakeCheckOpString(     \
+      x, x, absl::Nonnull<const char*>)
 ABSL_LOGGING_INTERNAL_DEFINE_MAKE_CHECK_OP_STRING(bool);
 ABSL_LOGGING_INTERNAL_DEFINE_MAKE_CHECK_OP_STRING(int64_t);
 ABSL_LOGGING_INTERNAL_DEFINE_MAKE_CHECK_OP_STRING(uint64_t);
@@ -53,7 +53,8 @@ ABSL_LOGGING_INTERNAL_DEFINE_MAKE_CHECK_OP_STRING(const unsigned char*);
 ABSL_LOGGING_INTERNAL_DEFINE_MAKE_CHECK_OP_STRING(const void*);
 #undef ABSL_LOGGING_INTERNAL_DEFINE_MAKE_CHECK_OP_STRING
 
-CheckOpMessageBuilder::CheckOpMessageBuilder(const char* exprtext) {
+CheckOpMessageBuilder::CheckOpMessageBuilder(
+    absl::Nonnull<const char*> exprtext) {
   stream_ << exprtext << " (";
 }
 
@@ -62,9 +63,10 @@ std::ostream& CheckOpMessageBuilder::ForVar2() {
   return stream_;
 }
 
-std::string* CheckOpMessageBuilder::NewString() {
+absl::Nonnull<const char*> CheckOpMessageBuilder::NewString() {
   stream_ << ")";
-  return new std::string(stream_.str());
+  // There's no need to free this string since the process is crashing.
+  return absl::IgnoreLeak(new std::string(std::move(stream_).str()))->c_str();
 }
 
 void MakeCheckOpValueString(std::ostream& os, const char v) {
@@ -100,16 +102,19 @@ void MakeCheckOpValueString(std::ostream& os, const void* p) {
 }
 
 // Helper functions for string comparisons.
-#define DEFINE_CHECK_STROP_IMPL(name, func, expected)                      \
-  std::string* Check##func##expected##Impl(const char* s1, const char* s2, \
-                                           const char* exprtext) {         \
-    bool equal = s1 == s2 || (s1 && s2 && !func(s1, s2));                  \
-    if (equal == expected) {                                               \
-      return nullptr;                                                      \
-    } else {                                                               \
-      return new std::string(                                              \
-          absl::StrCat(exprtext, " (", s1, " vs. ", s2, ")"));             \
-    }                                                                      \
+#define DEFINE_CHECK_STROP_IMPL(name, func, expected)                          \
+  absl::Nullable<const char*> Check##func##expected##Impl(                     \
+      absl::Nullable<const char*> s1, absl::Nullable<const char*> s2,          \
+      absl::Nonnull<const char*> exprtext) {                                   \
+    bool equal = s1 == s2 || (s1 && s2 && !func(s1, s2));                      \
+    if (equal == expected) {                                                   \
+      return nullptr;                                                          \
+    } else {                                                                   \
+      /* There's no need to free this string since the process is crashing. */ \
+      return absl::IgnoreLeak(new std::string(absl::StrCat(exprtext, " (", s1, \
+                                                           " vs. ", s2, ")"))) \
+          ->c_str();                                                           \
+    }                                                                          \
   }
 DEFINE_CHECK_STROP_IMPL(CHECK_STREQ, strcmp, true)
 DEFINE_CHECK_STROP_IMPL(CHECK_STRNE, strcmp, false)