grpc 1.71.0 → 1.73.0

data/third_party/abseil-cpp/absl/log/internal/log_message.h

@@ -27,17 +27,21 @@
 #ifndef ABSL_LOG_INTERNAL_LOG_MESSAGE_H_
 #define ABSL_LOG_INTERNAL_LOG_MESSAGE_H_
 
+#include <cstddef>
 #include <ios>
 #include <memory>
 #include <ostream>
 #include <streambuf>
 #include <string>
+#include <type_traits>
 
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
 #include "absl/base/internal/errno_saver.h"
 #include "absl/base/log_severity.h"
+#include "absl/base/nullability.h"
 #include "absl/log/internal/nullguard.h"
+#include "absl/log/internal/structured_proto.h"
 #include "absl/log/log_entry.h"
 #include "absl/log/log_sink.h"
 #include "absl/strings/has_absl_stringify.h"
@@ -49,6 +53,8 @@ ABSL_NAMESPACE_BEGIN
 namespace log_internal {
 constexpr int kLogMessageBufferSize = 15000;
 
+enum class StructuredStringType;
+
 class LogMessage {
  public:
   struct InfoTag {};
@@ -56,15 +62,15 @@ class LogMessage {
   struct ErrorTag {};
 
   // Used for `LOG`.
-  LogMessage(const char* file, int line,
+  LogMessage(absl::Nonnull<const char*> file, int line,
              absl::LogSeverity severity) ABSL_ATTRIBUTE_COLD;
   // These constructors are slightly smaller/faster to call; the severity is
   // curried into the function pointer.
-  LogMessage(const char* file, int line,
+  LogMessage(absl::Nonnull<const char*> file, int line,
              InfoTag) ABSL_ATTRIBUTE_COLD ABSL_ATTRIBUTE_NOINLINE;
-  LogMessage(const char* file, int line,
+  LogMessage(absl::Nonnull<const char*> file, int line,
              WarningTag) ABSL_ATTRIBUTE_COLD ABSL_ATTRIBUTE_NOINLINE;
-  LogMessage(const char* file, int line,
+  LogMessage(absl::Nonnull<const char*> file, int line,
              ErrorTag) ABSL_ATTRIBUTE_COLD ABSL_ATTRIBUTE_NOINLINE;
   LogMessage(const LogMessage&) = delete;
   LogMessage& operator=(const LogMessage&) = delete;
@@ -95,59 +101,67 @@ class LogMessage {
   // of `errno`.
   LogMessage& WithPerror();
   // Sends this message to `*sink` in addition to whatever other sinks it would
-  // otherwise have been sent to.  `sink` must not be null.
-  LogMessage& ToSinkAlso(absl::LogSink* sink);
-  // Sends this message to `*sink` and no others.  `sink` must not be null.
-  LogMessage& ToSinkOnly(absl::LogSink* sink);
+  // otherwise have been sent to.
+  LogMessage& ToSinkAlso(absl::Nonnull<absl::LogSink*> sink);
+  // Sends this message to `*sink` and no others.
+  LogMessage& ToSinkOnly(absl::Nonnull<absl::LogSink*> sink);
 
   // Don't call this method from outside this library.
   LogMessage& InternalStream() { return *this; }
 
   // By-value overloads for small, common types let us overlook common failures
   // to define globals and static data members (i.e. in a .cc file).
-  // clang-format off
-  // The CUDA toolchain cannot handle these <<<'s:
+  // NOLINTBEGIN(runtime/int)
+  // NOLINTBEGIN(google-runtime-int)
+  // clang-format off:  The CUDA toolchain cannot handle these <<<'s
   LogMessage& operator<<(char v) { return operator<< <char>(v); }
   LogMessage& operator<<(signed char v) { return operator<< <signed char>(v); }
   LogMessage& operator<<(unsigned char v) {
     return operator<< <unsigned char>(v);
   }
-  LogMessage& operator<<(signed short v) {  // NOLINT
-    return operator<< <signed short>(v);  // NOLINT
+  LogMessage& operator<<(signed short v) {
+    return operator<< <signed short>(v);
   }
   LogMessage& operator<<(signed int v) { return operator<< <signed int>(v); }
-  LogMessage& operator<<(signed long v) {  // NOLINT
-    return operator<< <signed long>(v);  // NOLINT
+  LogMessage& operator<<(signed long v) {
+    return operator<< <signed long>(v);
   }
-  LogMessage& operator<<(signed long long v) {  // NOLINT
-    return operator<< <signed long long>(v);  // NOLINT
+  LogMessage& operator<<(signed long long v) {
+    return operator<< <signed long long>(v);
   }
-  LogMessage& operator<<(unsigned short v) {  // NOLINT
-    return operator<< <unsigned short>(v);  // NOLINT
+  LogMessage& operator<<(unsigned short v) {
+    return operator<< <unsigned short>(v);
   }
   LogMessage& operator<<(unsigned int v) {
     return operator<< <unsigned int>(v);
   }
-  LogMessage& operator<<(unsigned long v) {  // NOLINT
-    return operator<< <unsigned long>(v);  // NOLINT
+  LogMessage& operator<<(unsigned long v) {
+    return operator<< <unsigned long>(v);
+  }
+  LogMessage& operator<<(unsigned long long v) {
+    return operator<< <unsigned long long>(v);
   }
-  LogMessage& operator<<(unsigned long long v) {  // NOLINT
-    return operator<< <unsigned long long>(v);  // NOLINT
+  LogMessage& operator<<(absl::Nullable<void*> v) {
+    return operator<< <void*>(v);
+  }
+  LogMessage& operator<<(absl::Nullable<const void*> v) {
+    return operator<< <const void*>(v);
   }
-  LogMessage& operator<<(void* v) { return operator<< <void*>(v); }
-  LogMessage& operator<<(const void* v) { return operator<< <const void*>(v); }
   LogMessage& operator<<(float v) { return operator<< <float>(v); }
   LogMessage& operator<<(double v) { return operator<< <double>(v); }
   LogMessage& operator<<(bool v) { return operator<< <bool>(v); }
   // clang-format on
+  // NOLINTEND(google-runtime-int)
+  // NOLINTEND(runtime/int)
 
   // These overloads are more efficient since no `ostream` is involved.
   LogMessage& operator<<(const std::string& v);
   LogMessage& operator<<(absl::string_view v);
 
   // Handle stream manipulators e.g. std::endl.
-  LogMessage& operator<<(std::ostream& (*m)(std::ostream& os));
-  LogMessage& operator<<(std::ios_base& (*m)(std::ios_base& os));
+  LogMessage& operator<<(absl::Nonnull<std::ostream& (*)(std::ostream & os)> m);
+  LogMessage& operator<<(
+      absl::Nonnull<std::ios_base& (*)(std::ios_base & os)> m);
 
   // Literal strings.  This allows us to record C string literals as literals in
   // the logging.proto.Value.
@@ -206,6 +220,10 @@ class LogMessage {
   struct LogMessageData;  // Opaque type containing message state
   friend class AsLiteralImpl;
   friend class StringifySink;
+  template <StructuredStringType str_type>
+  friend class AsStructuredStringTypeImpl;
+  template <typename T>
+  friend class AsStructuredValueImpl;
 
   // This streambuf writes directly into the structured logging buffer so that
   // arbitrary types can be encoded as string data (using
@@ -236,6 +254,13 @@ class LogMessage {
   template <StringType str_type>
   void CopyToEncodedBuffer(char ch, size_t num) ABSL_ATTRIBUTE_NOINLINE;
 
+  // Copies `field` to the encoded buffer, then appends `str` after it
+  // (truncating `str` if necessary to fit).
+  template <StringType str_type>
+  void CopyToEncodedBufferWithStructuredProtoField(StructuredProtoField field,
+                                                   absl::string_view str)
+      ABSL_ATTRIBUTE_NOINLINE;
+
   // Returns `true` if the message is fatal or enabled debug-fatal.
   bool IsFatal() const;
 
@@ -255,7 +280,7 @@ class LogMessage {
 
   // We keep the data in a separate struct so that each instance of `LogMessage`
   // uses less stack space.
-  std::unique_ptr<LogMessageData> data_;
+  absl::Nonnull<std::unique_ptr<LogMessageData>> data_;
 };
 
 // Helper class so that `AbslStringify()` can modify the LogMessage.
@@ -273,7 +298,8 @@ class StringifySink final {
   }
 
   // For types that implement `AbslStringify` using `absl::Format()`.
-  friend void AbslFormatFlush(StringifySink* sink, absl::string_view v) {
+  friend void AbslFormatFlush(absl::Nonnull<StringifySink*> sink,
+                              absl::string_view v) {
     sink->Append(v);
   }
 
@@ -315,27 +341,28 @@ LogMessage& LogMessage::operator<<(char (&buf)[SIZE]) {
 // We instantiate these specializations in the library's TU to save space in
 // other TUs.  Since the template is marked `ABSL_ATTRIBUTE_NOINLINE` we will be
 // emitting a function call either way.
+// NOLINTBEGIN(runtime/int)
+// NOLINTBEGIN(google-runtime-int)
 extern template LogMessage& LogMessage::operator<<(const char& v);
 extern template LogMessage& LogMessage::operator<<(const signed char& v);
 extern template LogMessage& LogMessage::operator<<(const unsigned char& v);
-extern template LogMessage& LogMessage::operator<<(const short& v);  // NOLINT
-extern template LogMessage& LogMessage::operator<<(
-    const unsigned short& v);  // NOLINT
+extern template LogMessage& LogMessage::operator<<(const short& v);
+extern template LogMessage& LogMessage::operator<<(const unsigned short& v);
 extern template LogMessage& LogMessage::operator<<(const int& v);
+extern template LogMessage& LogMessage::operator<<(const unsigned int& v);
+extern template LogMessage& LogMessage::operator<<(const long& v);
+extern template LogMessage& LogMessage::operator<<(const unsigned long& v);
+extern template LogMessage& LogMessage::operator<<(const long long& v);
+extern template LogMessage& LogMessage::operator<<(const unsigned long long& v);
 extern template LogMessage& LogMessage::operator<<(
-    const unsigned int& v);                                         // NOLINT
-extern template LogMessage& LogMessage::operator<<(const long& v);  // NOLINT
-extern template LogMessage& LogMessage::operator<<(
-    const unsigned long& v);  // NOLINT
-extern template LogMessage& LogMessage::operator<<(
-    const long long& v);  // NOLINT
+    absl::Nullable<void*> const& v);
 extern template LogMessage& LogMessage::operator<<(
-    const unsigned long long& v);  // NOLINT
-extern template LogMessage& LogMessage::operator<<(void* const& v);
-extern template LogMessage& LogMessage::operator<<(const void* const& v);
+    absl::Nullable<const void*> const& v);
 extern template LogMessage& LogMessage::operator<<(const float& v);
 extern template LogMessage& LogMessage::operator<<(const double& v);
 extern template LogMessage& LogMessage::operator<<(const bool& v);
+// NOLINTEND(google-runtime-int)
+// NOLINTEND(runtime/int)
 
 extern template void LogMessage::CopyToEncodedBuffer<
     LogMessage::StringType::kLiteral>(absl::string_view str);
@@ -351,9 +378,10 @@ extern template void LogMessage::CopyToEncodedBuffer<
 // message.
 class LogMessageFatal final : public LogMessage {
  public:
-  LogMessageFatal(const char* file, int line) ABSL_ATTRIBUTE_COLD;
-  LogMessageFatal(const char* file, int line,
-                  absl::string_view failure_msg) ABSL_ATTRIBUTE_COLD;
+  LogMessageFatal(absl::Nonnull<const char*> file,
+                  int line) ABSL_ATTRIBUTE_COLD;
+  LogMessageFatal(absl::Nonnull<const char*> file, int line,
+                  absl::Nonnull<const char*> failure_msg) ABSL_ATTRIBUTE_COLD;
   [[noreturn]] ~LogMessageFatal();
 };
 
@@ -362,7 +390,8 @@ class LogMessageFatal final : public LogMessage {
 // for DLOG(FATAL) variants.
 class LogMessageDebugFatal final : public LogMessage {
  public:
-  LogMessageDebugFatal(const char* file, int line) ABSL_ATTRIBUTE_COLD;
+  LogMessageDebugFatal(absl::Nonnull<const char*> file,
+                       int line) ABSL_ATTRIBUTE_COLD;
   ~LogMessageDebugFatal();
 };
 
@@ -371,16 +400,19 @@ class LogMessageQuietlyDebugFatal final : public LogMessage {
   // DLOG(QFATAL) calls this instead of LogMessageQuietlyFatal to make sure the
   // destructor is not [[noreturn]] even if this is always FATAL as this is only
   // invoked when DLOG() is enabled.
-  LogMessageQuietlyDebugFatal(const char* file, int line) ABSL_ATTRIBUTE_COLD;
+  LogMessageQuietlyDebugFatal(absl::Nonnull<const char*> file,
+                              int line) ABSL_ATTRIBUTE_COLD;
   ~LogMessageQuietlyDebugFatal();
 };
 
 // Used for LOG(QFATAL) to make sure it's properly understood as [[noreturn]].
 class LogMessageQuietlyFatal final : public LogMessage {
  public:
-  LogMessageQuietlyFatal(const char* file, int line) ABSL_ATTRIBUTE_COLD;
-  LogMessageQuietlyFatal(const char* file, int line,
-                         absl::string_view failure_msg) ABSL_ATTRIBUTE_COLD;
+  LogMessageQuietlyFatal(absl::Nonnull<const char*> file,
+                         int line) ABSL_ATTRIBUTE_COLD;
+  LogMessageQuietlyFatal(absl::Nonnull<const char*> file, int line,
+                         absl::Nonnull<const char*> failure_msg)
+      ABSL_ATTRIBUTE_COLD;
   [[noreturn]] ~LogMessageQuietlyFatal();
 };
 

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

@@ -35,9 +35,6 @@ void EncodeRawVarint(uint64_t value, size_t size, absl::Span<char> *buf) {
   }
   buf->remove_prefix(size);
 }
-constexpr uint64_t MakeTagType(uint64_t tag, WireType type) {
-  return tag << 3 | static_cast<uint64_t>(type);
-}
 }  // namespace
 
 bool EncodeVarint(uint64_t tag, uint64_t value, absl::Span<char> *buf) {

data/third_party/abseil-cpp/absl/log/internal/proto.h

@@ -199,23 +199,33 @@ constexpr uint64_t MaxVarintForSize(size_t size) {
   return size >= 10 ? (std::numeric_limits<uint64_t>::max)()
                     : (static_cast<uint64_t>(1) << size * 7) - 1;
 }
+constexpr uint64_t MakeTagType(uint64_t tag, WireType type) {
+  return tag << 3 | static_cast<uint64_t>(type);
+}
 
 // `BufferSizeFor` returns a number of bytes guaranteed to be sufficient to
-// store encoded fields of the specified WireTypes regardless of tag numbers and
-// data values.  This only makes sense for `WireType::kLengthDelimited` if you
-// add in the length of the contents yourself, e.g. for string and bytes fields
-// by adding the lengths of any encoded strings to the return value or for
-// submessage fields by enumerating the fields you may encode into their
-// contents.
-constexpr size_t BufferSizeFor() { return 0; }
-template <typename... T>
-constexpr size_t BufferSizeFor(WireType type, T... tail) {
-  // tag_type + data + ...
-  return MaxVarintSize() +
-         (type == WireType::kVarint ? MaxVarintSize() :              //
-              type == WireType::k64Bit ? 8 :                         //
-                  type == WireType::k32Bit ? 4 : MaxVarintSize()) +  //
-         BufferSizeFor(tail...);
+// store encoded fields as `(tag, WireType)`, regardless of data values.  This
+// only makes sense for `WireType::kLengthDelimited` if you add in the length of
+// the contents yourself, e.g. for string and bytes fields by adding the lengths
+// of any encoded strings to the return value or for submessage fields by
+// enumerating the fields you may encode into their contents.
+constexpr size_t BufferSizeFor(uint64_t tag, WireType type) {
+  size_t buffer_size = VarintSize(MakeTagType(tag, type));
+  switch (type) {
+    case WireType::kVarint:
+      buffer_size += MaxVarintSize();
+      break;
+    case WireType::k64Bit:
+      buffer_size += size_t{8};
+      break;
+    case WireType::kLengthDelimited:
+      buffer_size += MaxVarintSize();
+      break;
+    case WireType::k32Bit:
+      buffer_size += size_t{4};
+      break;
+  }
+  return buffer_size;
 }
 
 // absl::Span<const char> represents a view into the un-processed space in a

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

@@ -0,0 +1,115 @@
+//
+// Copyright 2024 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/log/internal/structured_proto.h"
+
+#include <cstdint>
+
+#include "absl/base/config.h"
+#include "absl/log/internal/proto.h"
+#include "absl/types/span.h"
+#include "absl/types/variant.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace log_internal {
+
+namespace {
+
+// Handles protobuf-encoding a type contained inside
+// `StructuredProtoField::Varint`.
+struct VarintEncoderVisitor final {
+  template <typename T>
+  bool operator()(T value) const {
+    return EncodeVarint(field_number, value, &buf);
+  }
+
+  uint64_t field_number;
+  absl::Span<char>& buf;
+};
+
+// Handles protobuf-encoding a type contained inside
+// `StructuredProtoField::I64`.
+struct I64EncoderVisitor final {
+  bool operator()(uint64_t value) const {
+    return Encode64Bit(field_number, value, &buf);
+  }
+
+  bool operator()(int64_t value) const {
+    return Encode64Bit(field_number, value, &buf);
+  }
+
+  bool operator()(double value) const {
+    return EncodeDouble(field_number, value, &buf);
+  }
+
+  uint64_t field_number;
+  absl::Span<char>& buf;
+};
+
+// Handles protobuf-encoding a type contained inside
+// `StructuredProtoField::I32`.
+struct I32EncoderVisitor final {
+  bool operator()(uint32_t value) const {
+    return Encode32Bit(field_number, value, &buf);
+  }
+
+  bool operator()(int32_t value) const {
+    return Encode32Bit(field_number, value, &buf);
+  }
+
+  bool operator()(float value) const {
+    return EncodeFloat(field_number, value, &buf);
+  }
+
+  uint64_t field_number;
+  absl::Span<char>& buf;
+};
+
+// Handles protobuf-encoding a type contained inside `StructuredProtoField`.
+struct EncoderVisitor final {
+  bool operator()(StructuredProtoField::Varint varint) {
+    return absl::visit(VarintEncoderVisitor{field_number, buf}, varint);
+  }
+
+  bool operator()(StructuredProtoField::I64 i64) {
+    return absl::visit(I64EncoderVisitor{field_number, buf}, i64);
+  }
+
+  bool operator()(StructuredProtoField::LengthDelimited length_delimited) {
+    // No need for a visitor, since `StructuredProtoField::LengthDelimited` is
+    // just `absl::Span<const char>`.
+    return EncodeBytes(field_number, length_delimited, &buf);
+  }
+
+  bool operator()(StructuredProtoField::I32 i32) {
+    return absl::visit(I32EncoderVisitor{field_number, buf}, i32);
+  }
+
+  uint64_t field_number;
+  absl::Span<char>& buf;
+};
+
+}  // namespace
+
+bool EncodeStructuredProtoField(StructuredProtoField field,
+                                absl::Span<char>& buf) {
+  return absl::visit(EncoderVisitor{field.field_number, buf}, field.value);
+}
+
+}  // namespace log_internal
+
+ABSL_NAMESPACE_END
+}  // namespace absl

data/third_party/abseil-cpp/absl/log/internal/structured_proto.h

@@ -0,0 +1,107 @@
+// Copyright 2024 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.
+//
+// -----------------------------------------------------------------------------
+// File: log/internal/structured_proto.h
+// -----------------------------------------------------------------------------
+
+#ifndef ABSL_LOG_INTERNAL_STRUCTURED_PROTO_H_
+#define ABSL_LOG_INTERNAL_STRUCTURED_PROTO_H_
+
+#include <cstddef>
+#include <cstdint>
+
+#include "absl/base/config.h"
+#include "absl/log/internal/proto.h"
+#include "absl/types/span.h"
+#include "absl/types/variant.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace log_internal {
+
+// Sum type holding a single valid protobuf field suitable for encoding.
+struct StructuredProtoField final {
+  // Numeric type encoded with varint encoding:
+  // https://protobuf.dev/programming-guides/encoding/#varints
+  using Varint = absl::variant<uint64_t, int64_t, uint32_t, int32_t, bool>;
+
+  // Fixed-length 64-bit integer encoding:
+  // https://protobuf.dev/programming-guides/encoding/#non-varints
+  using I64 = absl::variant<uint64_t, int64_t, double>;
+
+  // Length-delimited record type (string, sub-message):
+  // https://protobuf.dev/programming-guides/encoding/#length-types
+  using LengthDelimited = absl::Span<const char>;
+
+  // Fixed-length 32-bit integer encoding:
+  // https://protobuf.dev/programming-guides/encoding/#non-varints
+  using I32 = absl::variant<uint32_t, int32_t, float>;
+
+  // Valid record type:
+  // https://protobuf.dev/programming-guides/encoding/#structure
+  using Value = absl::variant<Varint, I64, LengthDelimited, I32>;
+
+  // Field number for the protobuf value.
+  uint64_t field_number;
+
+  // Value to encode.
+  Value value;
+};
+
+// Estimates the number of bytes needed to encode `field` using
+// protobuf encoding.
+//
+// The returned value might be larger than the actual number of bytes needed.
+inline size_t BufferSizeForStructuredProtoField(StructuredProtoField field) {
+  // Visitor to estimate the number of bytes of one of the types contained
+  // inside `StructuredProtoField`.
+  struct BufferSizeVisitor final {
+    size_t operator()(StructuredProtoField::Varint /*unused*/) {
+      return BufferSizeFor(field_number, WireType::kVarint);
+    }
+
+    size_t operator()(StructuredProtoField::I64 /*unused*/) {
+      return BufferSizeFor(field_number, WireType::k64Bit);
+    }
+
+    size_t operator()(StructuredProtoField::LengthDelimited length_delimited) {
+      return BufferSizeFor(field_number, WireType::kLengthDelimited) +
+             length_delimited.size();
+    }
+
+    size_t operator()(StructuredProtoField::I32 /*unused*/) {
+      return BufferSizeFor(field_number, WireType::k32Bit);
+    }
+
+    uint64_t field_number;
+  };
+
+  return absl::visit(BufferSizeVisitor{field.field_number}, field.value);
+}
+
+// Encodes `field` into `buf` using protobuf encoding.
+//
+// On success, returns `true` and advances `buf` to the end of
+// the bytes consumed.
+//
+// On failure (if `buf` was too small), returns `false`.
+bool EncodeStructuredProtoField(StructuredProtoField field,
+                                absl::Span<char>& buf);
+
+}  // namespace log_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_LOG_INTERNAL_STRUCTURED_PROTO_H_

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

@@ -207,7 +207,14 @@ int PrependVModuleLocked(absl::string_view module_pattern, int log_level)
   get_vmodule_info().erase(
       std::remove_if(++iter, get_vmodule_info().end(),
                      [module_pattern](const VModuleInfo& info) {
-                       return FNMatch(info.module_pattern, module_pattern);
+                       // Remove the previous pattern if it is less generic than
+                       // the new one. For example, if the new pattern
+                       // `module_pattern` is "foo*" and the previous pattern
+                       // `info.module_pattern` is "foo", we should remove the
+                       // previous pattern. Because the new pattern "foo*" will
+                       // match all the files that the previous pattern "foo"
+                       // matches.
+                       return FNMatch(module_pattern, info.module_pattern);
                      }),
       get_vmodule_info().cend());
   return old_log_level.value_or(global_v);

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

@@ -22,6 +22,7 @@
 #define ABSL_LOG_LOG_SINK_REGISTRY_H_
 
 #include "absl/base/config.h"
+#include "absl/base/nullability.h"
 #include "absl/log/internal/log_sink_set.h"
 #include "absl/log/log_sink.h"
 
@@ -43,8 +44,10 @@ ABSL_NAMESPACE_BEGIN
 // sink instead which writes them to `stderr`.
 //
 // Do not call these inside `absl::LogSink::Send`.
-inline void AddLogSink(absl::LogSink* sink) { log_internal::AddLogSink(sink); }
-inline void RemoveLogSink(absl::LogSink* sink) {
+inline void AddLogSink(absl::Nonnull<absl::LogSink*> sink) {
+  log_internal::AddLogSink(sink);
+}
+inline void RemoveLogSink(absl::Nonnull<absl::LogSink*> sink) {
   log_internal::RemoveLogSink(sink);
 }
 

data/third_party/abseil-cpp/absl/log/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/meta/type_traits.h

@@ -503,10 +503,11 @@ using swap_internal::Swap;
 // remove the condition.
 //
 // Clang on all platforms fails to detect that a type with a user-provided
-// move-assignment operator is not trivially relocatable. So in fact we
-// opt out of Clang altogether, for now.
+// move-assignment operator is not trivially relocatable so we also check for
+// is_trivially_move_assignable for Clang.
 //
-// TODO(b/325479096): Remove the opt-out once Clang's behavior is fixed.
+// TODO(b/325479096): Remove the Clang is_trivially_move_assignable version once
+// Clang's behavior is fixed.
 //
 // According to https://github.com/abseil/abseil-cpp/issues/1479, this does not
 // work with NVCC either.
@@ -516,6 +517,15 @@ using swap_internal::Swap;
 template <class T>
 struct is_trivially_relocatable
     : std::integral_constant<bool, __is_trivially_relocatable(T)> {};
+#elif ABSL_HAVE_BUILTIN(__is_trivially_relocatable) && defined(__clang__) && \
+    !(defined(_WIN32) || defined(_WIN64)) && !defined(__APPLE__) &&          \
+    !defined(__NVCC__)
+template <class T>
+struct is_trivially_relocatable
+    : std::integral_constant<
+          bool, std::is_trivially_copyable<T>::value ||
+                    (__is_trivially_relocatable(T) &&
+                     std::is_trivially_move_assignable<T>::value)> {};
 #else
 // Otherwise we use a fallback that detects only those types we can feasibly
 // detect. Any type that is trivially copyable is by definition trivially
@@ -648,9 +658,9 @@ struct IsView<std::span<T>> : std::true_type {};
 // Until then, we consider an assignment from an "owner" (such as std::string)
 // to a "view" (such as std::string_view) to be a lifetime-bound assignment.
 template <typename T, typename U>
-using IsLifetimeBoundAssignment =
-    std::integral_constant<bool, IsView<absl::remove_cvref_t<T>>::value &&
-                                     IsOwner<absl::remove_cvref_t<U>>::value>;
+using IsLifetimeBoundAssignment = absl::conjunction<
+    std::integral_constant<bool, !std::is_lvalue_reference<U>::value>,
+    IsOwner<absl::remove_cvref_t<U>>, IsView<absl::remove_cvref_t<T>>>;
 
 }  // namespace type_traits_internal