grpc 1.71.0 → 1.73.0

data/third_party/abseil-cpp/absl/flags/flag.h

@@ -204,12 +204,14 @@ ABSL_NAMESPACE_END
 
 #if ABSL_FLAGS_STRIP_NAMES
 #define ABSL_FLAG_IMPL_FLAGNAME(txt) ""
+#define ABSL_FLAG_IMPL_TYPENAME(txt) ""
 #define ABSL_FLAG_IMPL_FILENAME() ""
 #define ABSL_FLAG_IMPL_REGISTRAR(T, flag)                                      \
   absl::flags_internal::FlagRegistrar<T, false>(ABSL_FLAG_IMPL_FLAG_PTR(flag), \
                                                 nullptr)
 #else
 #define ABSL_FLAG_IMPL_FLAGNAME(txt) txt
+#define ABSL_FLAG_IMPL_TYPENAME(txt) txt
 #define ABSL_FLAG_IMPL_FILENAME() __FILE__
 #define ABSL_FLAG_IMPL_REGISTRAR(T, flag)                                     \
   absl::flags_internal::FlagRegistrar<T, true>(ABSL_FLAG_IMPL_FLAG_PTR(flag), \
@@ -261,16 +263,17 @@ ABSL_NAMESPACE_END
 // Note: Name of registrar object is not arbitrary. It is used to "grab"
 // global name for FLAGS_no<flag_name> symbol, thus preventing the possibility
 // of defining two flags with names foo and nofoo.
-#define ABSL_FLAG_IMPL(Type, name, default_value, help)                       \
-  extern ::absl::Flag<Type> FLAGS_##name;                                     \
-  namespace absl /* block flags in namespaces */ {}                           \
-  ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value)           \
-  ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, help)                             \
-  ABSL_CONST_INIT absl::Flag<Type> FLAGS_##name{                              \
-      ABSL_FLAG_IMPL_FLAGNAME(#name), ABSL_FLAG_IMPL_FILENAME(),              \
-      ABSL_FLAG_IMPL_HELP_ARG(name), ABSL_FLAG_IMPL_DEFAULT_ARG(Type, name)}; \
-  extern absl::flags_internal::FlagRegistrarEmpty FLAGS_no##name;             \
-  absl::flags_internal::FlagRegistrarEmpty FLAGS_no##name =                   \
+#define ABSL_FLAG_IMPL(Type, name, default_value, help)               \
+  extern ::absl::Flag<Type> FLAGS_##name;                             \
+  namespace absl /* block flags in namespaces */ {}                   \
+  ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value)   \
+  ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, help)                     \
+  ABSL_CONST_INIT absl::Flag<Type> FLAGS_##name{                      \
+      ABSL_FLAG_IMPL_FLAGNAME(#name), ABSL_FLAG_IMPL_TYPENAME(#Type), \
+      ABSL_FLAG_IMPL_FILENAME(), ABSL_FLAG_IMPL_HELP_ARG(name),       \
+      ABSL_FLAG_IMPL_DEFAULT_ARG(Type, name)};                        \
+  extern absl::flags_internal::FlagRegistrarEmpty FLAGS_no##name;     \
+  absl::flags_internal::FlagRegistrarEmpty FLAGS_no##name =           \
       ABSL_FLAG_IMPL_REGISTRAR(Type, FLAGS_##name)
 
 // ABSL_RETIRED_FLAG
@@ -290,8 +293,7 @@ ABSL_NAMESPACE_END
 // arguments unchanged (unless of course you actually want to retire the flag
 // type at this time as well).
 //
-// `default_value` is only used as a double check on the type. `explanation` is
-// unused.
+// `default_value` and `explanation` are unused.
 // TODO(rogeeff): replace RETIRED_FLAGS with FLAGS once forward declarations of
 // retired flags are cleaned up.
 #define ABSL_RETIRED_FLAG(type, name, default_value, explanation)      \

data/third_party/abseil-cpp/absl/flags/internal/flag.cc

@@ -34,7 +34,9 @@
 #include "absl/base/config.h"
 #include "absl/base/const_init.h"
 #include "absl/base/dynamic_annotations.h"
+#include "absl/base/no_destructor.h"
 #include "absl/base/optimization.h"
+#include "absl/base/thread_annotations.h"
 #include "absl/flags/config.h"
 #include "absl/flags/internal/commandlineflag.h"
 #include "absl/flags/usage_config.h"
@@ -85,11 +87,15 @@ class MutexRelock {
 // we move the memory to the freelist where it lives indefinitely, so it can
 // still be safely accessed. This also prevents leak checkers from complaining
 // about the leaked memory that can no longer be accessed through any pointer.
-ABSL_CONST_INIT absl::Mutex s_freelist_guard(absl::kConstInit);
-ABSL_CONST_INIT std::vector<void*>* s_freelist = nullptr;
+absl::Mutex* FreelistMutex() {
+  static absl::NoDestructor<absl::Mutex> mutex;
+  return mutex.get();
+}
+ABSL_CONST_INIT std::vector<void*>* s_freelist ABSL_GUARDED_BY(FreelistMutex())
+    ABSL_PT_GUARDED_BY(FreelistMutex()) = nullptr;
 
 void AddToFreelist(void* p) {
-  absl::MutexLock l(&s_freelist_guard);
+  absl::MutexLock l(FreelistMutex());
   if (!s_freelist) {
     s_freelist = new std::vector<void*>;
   }
@@ -101,7 +107,7 @@ void AddToFreelist(void* p) {
 ///////////////////////////////////////////////////////////////////////////////
 
 uint64_t NumLeakedFlagValues() {
-  absl::MutexLock l(&s_freelist_guard);
+  absl::MutexLock l(FreelistMutex());
   return s_freelist == nullptr ? 0u : s_freelist->size();
 }
 
@@ -336,6 +342,8 @@ void FlagImpl::StoreValue(const void* src, ValueSource source) {
 
 absl::string_view FlagImpl::Name() const { return name_; }
 
+absl::string_view FlagImpl::TypeName() const { return type_name_; }
+
 std::string FlagImpl::Filename() const {
   return flags_internal::GetUsageConfig().normalize_filename(filename_);
 }

data/third_party/abseil-cpp/absl/flags/internal/flag.h

@@ -373,9 +373,13 @@ class MaskedPointer {
 
   static constexpr int RequiredAlignment() { return 4; }
 
+  constexpr MaskedPointer() : ptr_(nullptr) {}
   constexpr explicit MaskedPointer(ptr_t rhs) : ptr_(rhs) {}
   MaskedPointer(ptr_t rhs, bool is_candidate);
 
+  MaskedPointer(const MaskedPointer& rhs) = default;
+  MaskedPointer& operator=(const MaskedPointer& rhs) = default;
+
   void* Ptr() const {
     return reinterpret_cast<void*>(reinterpret_cast<mask_t>(ptr_) &
                                    kPtrValueMask);
@@ -578,10 +582,12 @@ class FlagState;
 #endif
 class FlagImpl final : public CommandLineFlag {
  public:
-  constexpr FlagImpl(const char* name, const char* filename, FlagOpFn op,
-                     FlagHelpArg help, FlagValueStorageKind value_kind,
+  constexpr FlagImpl(const char* name, const char* type_name,
+                     const char* filename, FlagOpFn op, FlagHelpArg help,
+                     FlagValueStorageKind value_kind,
                      FlagDefaultArg default_arg)
       : name_(name),
+        type_name_(type_name),
         filename_(filename),
         op_(op),
         help_(help.source),
@@ -694,6 +700,7 @@ class FlagImpl final : public CommandLineFlag {
 
   // CommandLineFlag interface implementation
   absl::string_view Name() const override;
+  absl::string_view TypeName() const override;
   std::string Filename() const override;
   std::string Help() const override;
   FlagFastTypeId TypeId() const override;
@@ -727,6 +734,10 @@ class FlagImpl final : public CommandLineFlag {
 
   // Flags name passed to ABSL_FLAG as second arg.
   const char* const name_;
+
+  // Flags type passed to ABSL_FLAG as first arg.
+  const char* const type_name_;
+
   // The file name where ABSL_FLAG resides.
   const char* const filename_;
   // Type-specific operations vtable.
@@ -785,9 +796,9 @@ class FlagImpl final : public CommandLineFlag {
 template <typename T>
 class Flag {
  public:
-  constexpr Flag(const char* name, const char* filename, FlagHelpArg help,
-                 const FlagDefaultArg default_arg)
-      : impl_(name, filename, &FlagOps<T>, help,
+  constexpr Flag(const char* name, const char* type_name, const char* filename,
+                 FlagHelpArg help, const FlagDefaultArg default_arg)
+      : impl_(name, type_name, filename, &FlagOps<T>, help,
               flags_internal::StorageKind<T>(), default_arg),
         value_() {}
 

data/third_party/abseil-cpp/absl/flags/internal/private_handle_accessor.cc

@@ -59,6 +59,10 @@ bool PrivateHandleAccessor::ParseFrom(CommandLineFlag& flag,
   return flag.ParseFrom(value, set_mode, source, error);
 }
 
+absl::string_view PrivateHandleAccessor::TypeName(const CommandLineFlag& flag) {
+  return flag.TypeName();
+}
+
 }  // namespace flags_internal
 ABSL_NAMESPACE_END
 }  // namespace absl

data/third_party/abseil-cpp/absl/flags/internal/private_handle_accessor.h

@@ -52,6 +52,9 @@ class PrivateHandleAccessor {
   static bool ParseFrom(CommandLineFlag& flag, absl::string_view value,
                         flags_internal::FlagSettingMode set_mode,
                         flags_internal::ValueSource source, std::string& error);
+
+  // Access to CommandLineFlag::TypeName.
+  static absl::string_view TypeName(const CommandLineFlag& flag);
 };
 
 }  // namespace flags_internal

data/third_party/abseil-cpp/absl/flags/internal/program_name.cc

@@ -19,7 +19,7 @@
 
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
-#include "absl/base/const_init.h"
+#include "absl/base/no_destructor.h"
 #include "absl/base/thread_annotations.h"
 #include "absl/flags/internal/path_util.h"
 #include "absl/strings/string_view.h"
@@ -29,30 +29,31 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace flags_internal {
 
-ABSL_CONST_INIT static absl::Mutex program_name_guard(absl::kConstInit);
-ABSL_CONST_INIT static std::string* program_name
-    ABSL_GUARDED_BY(program_name_guard) = nullptr;
+static absl::Mutex* ProgramNameMutex() {
+  static absl::NoDestructor<absl::Mutex> mutex;
+  return mutex.get();
+}
+ABSL_CONST_INIT static std::string* program_name ABSL_GUARDED_BY(
+    ProgramNameMutex()) ABSL_PT_GUARDED_BY(ProgramNameMutex()) = nullptr;
 
 std::string ProgramInvocationName() {
-  absl::MutexLock l(&program_name_guard);
-
+  absl::MutexLock l(ProgramNameMutex());
   return program_name ? *program_name : "UNKNOWN";
 }
 
 std::string ShortProgramInvocationName() {
-  absl::MutexLock l(&program_name_guard);
-
+  absl::MutexLock l(ProgramNameMutex());
   return program_name ? std::string(flags_internal::Basename(*program_name))
                       : "UNKNOWN";
 }
 
 void SetProgramInvocationName(absl::string_view prog_name_str) {
-  absl::MutexLock l(&program_name_guard);
-
-  if (!program_name)
+  absl::MutexLock l(ProgramNameMutex());
+  if (!program_name) {
     program_name = new std::string(prog_name_str);
-  else
+  } else {
     program_name->assign(prog_name_str.data(), prog_name_str.size());
+  }
 }
 
 }  // namespace flags_internal

data/third_party/abseil-cpp/absl/flags/usage_config.cc

@@ -22,6 +22,7 @@
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
 #include "absl/base/const_init.h"
+#include "absl/base/no_destructor.h"
 #include "absl/base/thread_annotations.h"
 #include "absl/flags/internal/path_util.h"
 #include "absl/flags/internal/program_name.h"
@@ -104,14 +105,18 @@ std::string NormalizeFilename(absl::string_view filename) {
 
 // --------------------------------------------------------------------
 
-ABSL_CONST_INIT absl::Mutex custom_usage_config_guard(absl::kConstInit);
+absl::Mutex* CustomUsageConfigMutex() {
+  static absl::NoDestructor<absl::Mutex> mutex;
+  return mutex.get();
+}
 ABSL_CONST_INIT FlagsUsageConfig* custom_usage_config
-    ABSL_GUARDED_BY(custom_usage_config_guard) = nullptr;
+    ABSL_GUARDED_BY(CustomUsageConfigMutex())
+        ABSL_PT_GUARDED_BY(CustomUsageConfigMutex()) = nullptr;
 
 }  // namespace
 
 FlagsUsageConfig GetUsageConfig() {
-  absl::MutexLock l(&custom_usage_config_guard);
+  absl::MutexLock l(CustomUsageConfigMutex());
 
   if (custom_usage_config) return *custom_usage_config;
 
@@ -136,7 +141,7 @@ void ReportUsageError(absl::string_view msg, bool is_fatal) {
 }  // namespace flags_internal
 
 void SetFlagsUsageConfig(FlagsUsageConfig usage_config) {
-  absl::MutexLock l(&flags_internal::custom_usage_config_guard);
+  absl::MutexLock l(flags_internal::CustomUsageConfigMutex());
 
   if (!usage_config.contains_helpshort_flags)
     usage_config.contains_helpshort_flags =

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

@@ -78,11 +78,16 @@
 #ifndef ABSL_HASH_HASH_H_
 #define ABSL_HASH_HASH_H_
 
+#include <cstddef>
+#include <cstdint>
 #include <tuple>
+#include <type_traits>
 #include <utility>
 
+#include "absl/base/config.h"
 #include "absl/functional/function_ref.h"
 #include "absl/hash/internal/hash.h"
+#include "absl/meta/type_traits.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -319,8 +324,12 @@ class HashState : public hash_internal::HashStateBase<HashState> {
   // Create a new `HashState` instance that wraps `state`. All calls to
   // `combine()` and `combine_contiguous()` on the new instance will be
   // redirected to the original `state` object. The `state` object must outlive
-  // the `HashState` instance.
-  template <typename T>
+  // the `HashState` instance. `T` must be a subclass of `HashStateBase<T>` -
+  // users should not define their own HashState types.
+  template <
+      typename T,
+      absl::enable_if_t<
+          std::is_base_of<hash_internal::HashStateBase<T>, T>::value, int> = 0>
   static HashState Create(T* state) {
     HashState s;
     s.Init(state);
@@ -353,6 +362,7 @@ class HashState : public hash_internal::HashStateBase<HashState> {
   HashState() = default;
 
   friend class HashState::HashStateBase;
+  friend struct hash_internal::CombineRaw;
 
   template <typename T>
   static void CombineContiguousImpl(void* p, const unsigned char* first,
@@ -361,10 +371,22 @@ class HashState : public hash_internal::HashStateBase<HashState> {
     state = T::combine_contiguous(std::move(state), first, size);
   }
 
+  static HashState combine_raw(HashState hash_state, uint64_t value) {
+    hash_state.combine_raw_(hash_state.state_, value);
+    return hash_state;
+  }
+
+  template <typename T>
+  static void CombineRawImpl(void* p, uint64_t value) {
+    T& state = *static_cast<T*>(p);
+    state = hash_internal::CombineRaw()(std::move(state), value);
+  }
+
   template <typename T>
   void Init(T* state) {
     state_ = state;
     combine_contiguous_ = &CombineContiguousImpl<T>;
+    combine_raw_ = &CombineRawImpl<T>;
     run_combine_unordered_ = &RunCombineUnorderedImpl<T>;
   }
 
@@ -403,6 +425,7 @@ class HashState : public hash_internal::HashStateBase<HashState> {
   void Init(HashState* state) {
     state_ = state->state_;
     combine_contiguous_ = state->combine_contiguous_;
+    combine_raw_ = state->combine_raw_;
     run_combine_unordered_ = state->run_combine_unordered_;
   }
 
@@ -413,6 +436,7 @@ class HashState : public hash_internal::HashStateBase<HashState> {
 
   void* state_;
   void (*combine_contiguous_)(void*, const unsigned char*, size_t);
+  void (*combine_raw_)(void*, uint64_t);
   HashState (*run_combine_unordered_)(
       HashState state,
       absl::FunctionRef<void(HashState, absl::FunctionRef<void(HashState&)>)>);

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

@@ -14,6 +14,14 @@
 
 #include "absl/hash/internal/hash.h"
 
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/hash/internal/low_level_hash.h"
+
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace hash_internal {
@@ -21,9 +29,10 @@ namespace hash_internal {
 uint64_t MixingHashState::CombineLargeContiguousImpl32(
     uint64_t state, const unsigned char* first, size_t len) {
   while (len >= PiecewiseChunkSize()) {
-    state = Mix(state,
-                hash_internal::CityHash32(reinterpret_cast<const char*>(first),
-                                          PiecewiseChunkSize()));
+    state = Mix(
+        state ^ hash_internal::CityHash32(reinterpret_cast<const char*>(first),
+                                          PiecewiseChunkSize()),
+        kMul);
     len -= PiecewiseChunkSize();
     first += PiecewiseChunkSize();
   }
@@ -35,7 +44,7 @@ uint64_t MixingHashState::CombineLargeContiguousImpl32(
 uint64_t MixingHashState::CombineLargeContiguousImpl64(
     uint64_t state, const unsigned char* first, size_t len) {
   while (len >= PiecewiseChunkSize()) {
-    state = Mix(state, Hash64(first, PiecewiseChunkSize()));
+    state = Mix(state ^ Hash64(first, PiecewiseChunkSize()), kMul);
     len -= PiecewiseChunkSize();
     first += PiecewiseChunkSize();
   }
@@ -46,22 +55,13 @@ uint64_t MixingHashState::CombineLargeContiguousImpl64(
 
 ABSL_CONST_INIT const void* const MixingHashState::kSeed = &kSeed;
 
-// The salt array used by LowLevelHash. This array is NOT the mechanism used to
-// make absl::Hash non-deterministic between program invocations.  See `Seed()`
-// for that mechanism.
-//
-// Any random values are fine. These values are just digits from the decimal
-// part of pi.
-// https://en.wikipedia.org/wiki/Nothing-up-my-sleeve_number
-constexpr uint64_t kHashSalt[5] = {
-    uint64_t{0x243F6A8885A308D3}, uint64_t{0x13198A2E03707344},
-    uint64_t{0xA4093822299F31D0}, uint64_t{0x082EFA98EC4E6C89},
-    uint64_t{0x452821E638D01377},
-};
+#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
+constexpr uint64_t MixingHashState::kStaticRandomData[];
+#endif
 
 uint64_t MixingHashState::LowLevelHashImpl(const unsigned char* data,
                                            size_t len) {
-  return LowLevelHashLenGt16(data, len, Seed(), kHashSalt);
+  return LowLevelHashLenGt16(data, len, Seed(), &kStaticRandomData[0]);
 }
 
 }  // namespace hash_internal