grpc 1.80.0 → 1.81.0

data/third_party/upb/upb/port/sanitizers.h

@@ -0,0 +1,179 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2025 Google LLC.  All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file or at
+// https://developers.google.com/open-source/licenses/bsd
+
+#ifndef UPB_PORT_SANITIZERS_H_
+#define UPB_PORT_SANITIZERS_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+
+// Must be last.
+#include "upb/port/def.inc"
+
+// Must be inside def.inc/undef.inc
+#if UPB_HWASAN
+#include <sanitizer/hwasan_interface.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// UPB_ARENA_SIZE_HACK depends on this struct having size 1.
+typedef struct {
+  uint8_t state;
+} upb_Xsan;
+
+UPB_INLINE uint8_t _upb_Xsan_NextTag(upb_Xsan *xsan) {
+#if UPB_HWASAN
+  xsan->state++;
+  if (xsan->state <= UPB_HWASAN_POISON_TAG) {
+    xsan->state = UPB_HWASAN_POISON_TAG + 1;
+  }
+  return xsan->state;
+#else
+  UPB_UNUSED(xsan);
+  return 0;
+#endif
+}
+
+enum {
+#if UPB_ASAN
+  UPB_PRIVATE(kUpb_Asan_GuardSize) = 32,
+#else
+  UPB_PRIVATE(kUpb_Asan_GuardSize) = 0,
+#endif
+};
+
+UPB_INLINE uint8_t UPB_PRIVATE(_upb_Xsan_GetTag)(const void *addr) {
+#if UPB_HWASAN
+  return __hwasan_get_tag_from_pointer(addr);
+#else
+  UPB_UNUSED(addr);
+  return 0;
+#endif
+}
+
+UPB_INLINE void UPB_PRIVATE(upb_Xsan_Init)(upb_Xsan *xsan) {
+#if UPB_HWASAN || UPB_TSAN
+  xsan->state = 0;
+#else
+  UPB_UNUSED(xsan);
+#endif
+}
+
+// Marks the given region as poisoned, meaning that it is not accessible until
+// it is unpoisoned.
+UPB_INLINE void UPB_PRIVATE(upb_Xsan_PoisonRegion)(const void *addr,
+                                                   size_t size) {
+#if UPB_ASAN
+  void __asan_poison_memory_region(void const volatile *addr, size_t size);
+  __asan_poison_memory_region(addr, size);
+#elif UPB_HWASAN
+  __hwasan_tag_memory(addr, UPB_HWASAN_POISON_TAG, UPB_ALIGN_MALLOC(size));
+#else
+  UPB_UNUSED(addr);
+  UPB_UNUSED(size);
+#endif
+}
+
+UPB_INLINE void *UPB_PRIVATE(_upb_Xsan_UnpoisonRegion)(void *addr, size_t size,
+                                                       uint8_t tag) {
+#if UPB_ASAN
+  UPB_UNUSED(tag);
+  void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
+  __asan_unpoison_memory_region(addr, size);
+  return addr;
+#elif UPB_HWASAN
+  __hwasan_tag_memory(addr, tag, UPB_ALIGN_MALLOC(size));
+  return __hwasan_tag_pointer(addr, tag);
+#else
+  UPB_UNUSED(size);
+  UPB_UNUSED(tag);
+
+  // `addr` is the pointer that will be returned from arena alloc/realloc
+  // functions.  In this code-path we know it must be non-NULL, but the compiler
+  // doesn't know this unless we add a UPB_ASSUME() annotation.
+  //
+  // This will let the optimizer optimize away NULL-checks if it can see that
+  // this path was taken.
+  UPB_ASSUME(addr);
+  return addr;
+#endif
+}
+
+// Allows users to read and write to the given region, which will be considered
+// distinct from other regions and may only be accessed through the returned
+// pointer.
+//
+// `addr` must be aligned to the malloc alignment.  Size may be unaligned,
+// and with ASAN we can respect `size` precisely, but with HWASAN we must
+// round `size` up to the next multiple of the malloc alignment, so the caller
+// must guarantee that rounding up `size` will not cause overlap with other
+// regions.
+UPB_INLINE void *UPB_PRIVATE(upb_Xsan_NewUnpoisonedRegion)(upb_Xsan *xsan,
+                                                           void *addr,
+                                                           size_t size) {
+  return UPB_PRIVATE(_upb_Xsan_UnpoisonRegion)(addr, size,
+                                               _upb_Xsan_NextTag(xsan));
+}
+
+// Resizes the given region to a new size, *without* invalidating any existing
+// pointers to the region.
+//
+// `tagged_addr` must be a pointer that was previously returned from
+// `upb_Xsan_NewUnpoisonedRegion`.  `old_size` must be the size that was
+// originally passed to `upb_Xsan_NewUnpoisonedRegion`.
+UPB_INLINE void *UPB_PRIVATE(upb_Xsan_ResizeUnpoisonedRegion)(void *tagged_addr,
+                                                              size_t old_size,
+                                                              size_t new_size) {
+  UPB_PRIVATE(upb_Xsan_PoisonRegion)(tagged_addr, old_size);
+  return UPB_PRIVATE(_upb_Xsan_UnpoisonRegion)(
+      tagged_addr, new_size, UPB_PRIVATE(_upb_Xsan_GetTag)(tagged_addr));
+}
+
+// Compares two pointers and returns true if they are equal. This returns the
+// correct result even if one or both of the pointers are tagged.
+UPB_INLINE bool UPB_PRIVATE(upb_Xsan_PtrEq)(const void *a, const void *b) {
+#if UPB_HWASAN
+  return __hwasan_tag_pointer(a, 0) == __hwasan_tag_pointer(b, 0);
+#else
+  return a == b;
+#endif
+}
+
+// These annotations improve TSAN's ability to detect data races.  By
+// proactively accessing a non-atomic variable at the point where it is
+// "logically" accessed, we can trigger TSAN diagnostics that might have
+// otherwise been masked by subsequent atomic operations.
+
+UPB_INLINE void UPB_PRIVATE(upb_Xsan_AccessReadOnly)(upb_Xsan *xsan) {
+#if UPB_TSAN
+  // For performance we avoid using a volatile variable.
+  __asm__ volatile("" ::"r"(xsan->state));
+#else
+  UPB_UNUSED(xsan);
+#endif
+}
+
+UPB_INLINE void UPB_PRIVATE(upb_Xsan_AccessReadWrite)(upb_Xsan *xsan) {
+#if UPB_TSAN
+  // For performance we avoid using a volatile variable.
+  __asm__ volatile("" : "+r"(xsan->state));
+#else
+  UPB_UNUSED(xsan);
+#endif
+}
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#include "upb/port/undef.inc"
+
+#endif  // UPB_PORT_SANITIZERS_H_

data/third_party/upb/upb/port/undef.inc

@@ -23,7 +23,9 @@
 #undef UPB_ALIGN_MALLOC
 #undef UPB_ALIGN_OF
 #undef UPB_ALIGN_AS
-#undef UPB_MALLOC_ALIGN
+#undef UPB_STATIC_ASSERT
+#undef UPB_STATIC_ASSERT_CONCAT
+#undef UPB_STATIC_ASSERT_CONCAT_IMPL
 #undef UPB_LIKELY
 #undef UPB_UNLIKELY
 #undef UPB_UNPREDICTABLE
@@ -31,6 +33,7 @@
 #undef UPB_NOINLINE
 #undef UPB_NORETURN
 #undef UPB_PRINTF
+#undef UPB_NODEREF
 #undef UPB_MAX
 #undef UPB_MIN
 #undef UPB_UNUSED
@@ -42,6 +45,7 @@
 #undef UPB_LONGJMP
 #undef UPB_PTRADD
 #undef UPB_MUSTTAIL
+#undef UPB_PRESERVE_NONE
 #undef UPB_FASTTABLE_SUPPORTED
 #undef UPB_FASTTABLE_MASK
 #undef UPB_FASTTABLE
@@ -49,14 +53,10 @@
 #undef UPB_POISON_MEMORY_REGION
 #undef UPB_UNPOISON_MEMORY_REGION
 #undef UPB_ASAN
-#undef UPB_ASAN_GUARD_SIZE
-#undef UPB_CLANG_ASAN
-#undef UPB_TSAN_PUBLISHED_MEMBER
-#undef UPB_TSAN_INIT_PUBLISHED
-#undef UPB_TSAN_CHECK_PUBLISHED
-#undef UPB_TSAN_PUBLISH
-#undef UPB_TSAN_CHECK_READ
-#undef UPB_TSAN_CHECK_WRITE
+#undef UPB_HWASAN
+#undef UPB_HWASAN_POISON_TAG
+#undef UPB_MALLOC_ALIGN
+#undef UPB_TSAN
 #undef UPB_TREAT_CLOSED_ENUMS_LIKE_OPEN
 #undef UPB_DEPRECATED
 #undef UPB_GNUC_MIN
@@ -74,3 +74,13 @@
 #undef UPB_LINKARR_START
 #undef UPB_LINKARR_STOP
 #undef UPB_FUTURE_BREAKING_CHANGES
+#undef UPB_HAS_ATTRIBUTE
+#undef UPB_HAS_BUILTIN
+#undef UPB_HAS_EXTENSION
+#undef UPB_HAS_FEATURE
+#undef UPB_XSAN_MEMBER
+#undef UPB_XSAN
+#undef UPB_XSAN_STRUCT_SIZE
+#undef UPB_ENABLE_REF_CYCLE_CHECKS
+#undef UPB_ARM64_ASM
+#undef UPB_ARM64_BTI_DEFAULT

data/third_party/upb/upb/reflection/enum_def.c

@@ -49,10 +49,8 @@ struct upb_EnumDef {
   int res_range_count;
   int res_name_count;
   int32_t defaultval;
+  UPB_DESC(SymbolVisibility) visibility;
   bool is_sorted;  // Whether all of the values are defined in ascending order.
-#if UINTPTR_MAX == 0xffffffff
-  uint32_t padding;  // Increase size to a multiple of 8.
-#endif
 };
 
 upb_EnumDef* _upb_EnumDef_At(const upb_EnumDef* e, int i) {
@@ -90,6 +88,10 @@ const UPB_DESC(FeatureSet) *
   return e->resolved_features;
 }
 
+UPB_DESC(SymbolVisibility) upb_EnumDef_Visibility(const upb_EnumDef* e) {
+  return e->visibility;
+}
+
 const char* upb_EnumDef_FullName(const upb_EnumDef* e) { return e->full_name; }
 
 const char* upb_EnumDef_Name(const upb_EnumDef* e) {
@@ -285,6 +287,8 @@ static void create_enumdef(upb_DefBuilder* ctx, const char* prefix,
   e->res_name_count = n_res_name;
   e->res_names = _upb_EnumReservedNames_New(ctx, n_res_name, res_names);
 
+  e->visibility = UPB_DESC(EnumDescriptorProto_visibility)(enum_proto);
+
   if (!upb_inttable_compact(&e->iton, ctx->arena)) _upb_DefBuilder_OomErr(ctx);
 
   if (upb_EnumDef_IsClosed(e)) {

data/third_party/upb/upb/reflection/enum_def.h

@@ -42,6 +42,7 @@ bool upb_EnumDef_MiniDescriptorEncode(const upb_EnumDef* e, upb_Arena* a,
 const char* upb_EnumDef_Name(const upb_EnumDef* e);
 const UPB_DESC(EnumOptions) * upb_EnumDef_Options(const upb_EnumDef* e);
 const UPB_DESC(FeatureSet) * upb_EnumDef_ResolvedFeatures(const upb_EnumDef* e);
+UPB_DESC(SymbolVisibility) upb_EnumDef_Visibility(const upb_EnumDef* e);
 
 upb_StringView upb_EnumDef_ReservedName(const upb_EnumDef* e, int i);
 int upb_EnumDef_ReservedNameCount(const upb_EnumDef* e);

data/third_party/upb/upb/reflection/field_def.h

@@ -49,6 +49,7 @@ UPB_API bool upb_FieldDef_IsEnum(const upb_FieldDef* f);
 bool upb_FieldDef_IsExtension(const upb_FieldDef* f);
 UPB_API bool upb_FieldDef_IsMap(const upb_FieldDef* f);
 bool upb_FieldDef_IsOptional(const upb_FieldDef* f);
+bool _upb_FieldDef_IsPackable(const upb_FieldDef* f);
 UPB_API bool upb_FieldDef_IsPacked(const upb_FieldDef* f);
 bool upb_FieldDef_IsPrimitive(const upb_FieldDef* f);
 UPB_API bool upb_FieldDef_IsRepeated(const upb_FieldDef* f);

data/third_party/upb/upb/reflection/file_def.c

@@ -220,7 +220,7 @@ const UPB_DESC(FeatureSet*)
                          upb_FileDef_EditionName(min));
     return NULL;
   }
-  if (edition > max) {
+  if (edition > max && edition != UPB_DESC(EDITION_UNSTABLE)) {
     _upb_DefBuilder_Errf(ctx,
                          "Edition %s is later than the maximum edition %s "
                          "given in the defaults",

data/third_party/upb/upb/reflection/internal/upb_edition_defaults.h

@@ -13,7 +13,7 @@
 // features. This is used for feature resolution under Editions.
 // NOLINTBEGIN
 // clang-format off
-#define UPB_INTERNAL_UPB_EDITION_DEFAULTS "\n\027\030\204\007\"\000*\020\010\001\020\002\030\002 \003(\0010\0028\002@\001\n\027\030\347\007\"\000*\020\010\002\020\001\030\001 \002(\0010\0018\002@\001\n\027\030\350\007\"\014\010\001\020\001\030\001 \002(\0010\001*\0048\002@\001 \346\007(\350\007"
+#define UPB_INTERNAL_UPB_EDITION_DEFAULTS "\n\027\030\204\007\"\000*\020\010\001\020\002\030\002 \003(\0010\0028\002@\001\n\027\030\347\007\"\000*\020\010\002\020\001\030\001 \002(\0010\0018\002@\001\n\027\030\350\007\"\014\010\001\020\001\030\001 \002(\0010\001*\0048\002@\001\n\027\030\351\007\"\020\010\001\020\001\030\001 \002(\0010\0018\001@\002*\000 \346\007(\351\007"
 // clang-format on
 // NOLINTEND
 

data/third_party/upb/upb/reflection/message_def.c

@@ -76,6 +76,7 @@ struct upb_MessageDef {
   bool in_message_set;
   bool is_sorted;
   upb_WellKnown well_known_type;
+  UPB_DESC(SymbolVisibility) visibility;
 };
 
 static void assign_msg_wellknowntype(upb_MessageDef* m) {
@@ -323,6 +324,11 @@ upb_WellKnown upb_MessageDef_WellKnownType(const upb_MessageDef* m) {
   return m->well_known_type;
 }
 
+UPB_API UPB_DESC(SymbolVisibility)
+    upb_MessageDef_Visibility(const upb_MessageDef* m) {
+  return m->visibility;
+}
+
 bool _upb_MessageDef_InMessageSet(const upb_MessageDef* m) {
   return m->in_message_set;
 }
@@ -517,6 +523,26 @@ void _upb_MessageDef_LinkMiniTable(upb_DefBuilder* ctx,
 #endif
 }
 
+// Returns whether packable repeated fields in the message should be considered
+// packed by default. This is used only for the purpose of encoding
+// MiniDescriptors, so we just return true if there are more packed fields than
+// unpacked. This optimizes for smaller MiniDescriptors.
+static bool _upb_MessageDef_DefaultIsPacked(const upb_MessageDef* m) {
+  int packed = 0;
+  int unpacked = 0;
+  for (int i = 0; i < m->field_count; i++) {
+    const upb_FieldDef* f = upb_MessageDef_Field(m, i);
+    if (_upb_FieldDef_IsPackable(f)) {
+      if (upb_FieldDef_IsPacked(f)) {
+        ++packed;
+      } else {
+        ++unpacked;
+      }
+    }
+  }
+  return packed > unpacked;
+}
+
 static bool _upb_MessageDef_ValidateUtf8(const upb_MessageDef* m) {
   bool has_string = false;
   for (int i = 0; i < m->field_count; i++) {
@@ -536,8 +562,7 @@ static bool _upb_MessageDef_ValidateUtf8(const upb_MessageDef* m) {
 static uint64_t _upb_MessageDef_Modifiers(const upb_MessageDef* m) {
   uint64_t out = 0;
 
-  if (UPB_DESC(FeatureSet_repeated_field_encoding(m->resolved_features)) ==
-      UPB_DESC(FeatureSet_PACKED)) {
+  if (_upb_MessageDef_DefaultIsPacked(m)) {
     out |= kUpb_MessageModifier_DefaultIsPacked;
   }
 
@@ -744,6 +769,8 @@ static void create_msgdef(upb_DefBuilder* ctx, const char* prefix,
   m->nested_msg_count = n_msg;
   m->nested_msgs =
       _upb_MessageDefs_New(ctx, n_msg, msgs, m->resolved_features, m);
+
+  m->visibility = UPB_DESC(DescriptorProto_visibility)(msg_proto);
 }
 
 // Allocate and initialize an array of |n| message defs.

data/third_party/upb/upb/reflection/message_def.h

@@ -148,6 +148,8 @@ int upb_MessageDef_ReservedRangeCount(const upb_MessageDef* m);
 
 UPB_API upb_Syntax upb_MessageDef_Syntax(const upb_MessageDef* m);
 UPB_API upb_WellKnown upb_MessageDef_WellKnownType(const upb_MessageDef* m);
+UPB_API UPB_DESC(SymbolVisibility)
+    upb_MessageDef_Visibility(const upb_MessageDef* m);
 
 #ifdef __cplusplus
 } /* extern "C" */

data/third_party/upb/upb/text/internal/encode.c

@@ -53,7 +53,7 @@ const char* UPB_PRIVATE(_upb_TextEncode_Unknown)(txtenc* e, const char* ptr,
 
   while (!upb_EpsCopyInputStream_IsDone(stream, &ptr)) {
     uint32_t tag;
-    CHK(ptr = upb_WireReader_ReadTag(ptr, &tag));
+    CHK(ptr = upb_WireReader_ReadTag(ptr, &tag, stream));
     if (tag == end_group) return ptr;
 
     UPB_PRIVATE(_upb_TextEncode_Indent)(e);
@@ -63,19 +63,19 @@ const char* UPB_PRIVATE(_upb_TextEncode_Unknown)(txtenc* e, const char* ptr,
     switch (upb_WireReader_GetWireType(tag)) {
       case kUpb_WireType_Varint: {
         uint64_t val;
-        CHK(ptr = upb_WireReader_ReadVarint(ptr, &val));
+        CHK(ptr = upb_WireReader_ReadVarint(ptr, &val, stream));
         UPB_PRIVATE(_upb_TextEncode_Printf)(e, "%" PRIu64, val);
         break;
       }
       case kUpb_WireType_32Bit: {
         uint32_t val;
-        ptr = upb_WireReader_ReadFixed32(ptr, &val);
+        ptr = upb_WireReader_ReadFixed32(ptr, &val, stream);
         UPB_PRIVATE(_upb_TextEncode_Printf)(e, "0x%08" PRIu32, val);
         break;
       }
       case kUpb_WireType_64Bit: {
         uint64_t val;
-        ptr = upb_WireReader_ReadFixed64(ptr, &val);
+        ptr = upb_WireReader_ReadFixed64(ptr, &val, stream);
         UPB_PRIVATE(_upb_TextEncode_Printf)(e, "0x%016" PRIu64, val);
         break;
       }
@@ -83,7 +83,7 @@ const char* UPB_PRIVATE(_upb_TextEncode_Unknown)(txtenc* e, const char* ptr,
         int size;
         char* start = e->ptr;
         size_t start_overflow = e->overflow;
-        CHK(ptr = upb_WireReader_ReadSize(ptr, &size));
+        CHK(ptr = upb_WireReader_ReadSize(ptr, &size, stream));
         CHK(upb_EpsCopyInputStream_CheckDataSizeAvailable(stream, ptr, size));
 
         // Speculatively try to parse as message.