grpc 1.81.1 → 1.83.1

data/third_party/upb/upb/mini_table/internal/size_log2.h

@@ -42,7 +42,8 @@ UPB_INLINE int UPB_PRIVATE(_upb_CType_SizeLg2)(upb_CType c_type) {
 }
 
 // Return the log2 of the storage size in bytes for a upb_FieldType
-UPB_INLINE int UPB_PRIVATE(_upb_FieldType_SizeLg2)(upb_FieldType field_type) {
+UPB_INLINE size_t
+UPB_PRIVATE(_upb_FieldType_SizeLg2)(upb_FieldType field_type) {
   static const int8_t size[] = {
       3,               // kUpb_FieldType_Double
       2,               // kUpb_FieldType_Float

data/third_party/upb/upb/mini_table/internal/sub.h

@@ -11,16 +11,13 @@
 // Must be last.
 #include "upb/port/def.inc"
 
-typedef union {
-  const struct upb_MiniTable* const* UPB_PRIVATE(submsg);
-  const struct upb_MiniTableEnum* UPB_PRIVATE(subenum);
-} upb_MiniTableSubInternal;
-
 union upb_MiniTableSub {
   const struct upb_MiniTable* UPB_PRIVATE(submsg);
   const struct upb_MiniTableEnum* UPB_PRIVATE(subenum);
 };
 
+typedef union upb_MiniTableSub upb_MiniTableSubInternal;
+
 #ifdef __cplusplus
 extern "C" {
 #endif

data/third_party/upb/upb/mini_table/message.h

@@ -36,25 +36,20 @@ UPB_API_INLINE bool upb_MiniTable_IsMessageSet(const upb_MiniTable* m);
 // DEPRECATED: use upb_MiniTable_SubMessage() instead
 // Returns the MiniTable for a message field, NULL if the field is unlinked.
 UPB_API_INLINE const upb_MiniTable* upb_MiniTable_GetSubMessageTable(
-    const upb_MiniTable* m, const upb_MiniTableField* f);
+    const upb_MiniTableField* f);
 
-// Returns the MiniTable for a message field if it is a submessage, otherwise
-// returns NULL.
-//
-// WARNING: if dynamic tree shaking is in use, the return value may be the
-// "empty", zero-field placeholder message instead of the real message type.
-// If the message is later linked, this function will begin returning the real
-// message type.
+// Returns the MiniTable for a message field if it is a submessage and the field
+// is linked, otherwise returns NULL.
 UPB_API_INLINE const upb_MiniTable* upb_MiniTable_SubMessage(
-    const upb_MiniTable* m, const upb_MiniTableField* f);
+    const upb_MiniTableField* f);
 
 // Returns the MiniTable for a map field.  The given field must refer to a map.
 UPB_API_INLINE const upb_MiniTable* upb_MiniTable_MapEntrySubMessage(
-    const upb_MiniTable* m, const upb_MiniTableField* f);
+    const upb_MiniTableField* f);
 
 // Returns the MiniTableEnum for a message field, NULL if the field is unlinked.
 UPB_API_INLINE const upb_MiniTableEnum* upb_MiniTable_GetSubEnumTable(
-    const upb_MiniTable* m, const upb_MiniTableField* f);
+    const upb_MiniTableField* f);
 
 // Returns the MiniTableField for the key of a map.
 UPB_API_INLINE const upb_MiniTableField* upb_MiniTable_MapKey(
@@ -66,8 +61,7 @@ UPB_API_INLINE const upb_MiniTableField* upb_MiniTable_MapValue(
 
 // Returns true if this MiniTable field is linked to a MiniTable for the
 // sub-message.
-UPB_API_INLINE bool upb_MiniTable_FieldIsLinked(const upb_MiniTable* m,
-                                                const upb_MiniTableField* f);
+UPB_API_INLINE bool upb_MiniTable_FieldIsLinked(const upb_MiniTableField* f);
 
 // If this field is in a oneof, returns the first field in the oneof.
 //
@@ -94,6 +88,33 @@ bool upb_MiniTable_NextOneofField(const upb_MiniTable* m,
 } /* extern "C" */
 #endif
 
+#ifdef __cplusplus
+// Temporary overloads for functions whose signature has recently changed.
+UPB_DEPRECATE_AND_INLINE()
+inline const upb_MiniTable* upb_MiniTable_SubMessage(
+    const upb_MiniTable* m, const upb_MiniTableField* f) {
+  return upb_MiniTable_SubMessage(f);
+}
+
+UPB_DEPRECATE_AND_INLINE()
+inline const upb_MiniTable* upb_MiniTable_GetSubMessageTable(
+    const upb_MiniTable* m, const upb_MiniTableField* f) {
+  return upb_MiniTable_GetSubMessageTable(f);
+}
+
+UPB_DEPRECATE_AND_INLINE()
+inline const upb_MiniTableEnum* upb_MiniTable_GetSubEnumTable(
+    const upb_MiniTable* m, const upb_MiniTableField* f) {
+  return upb_MiniTable_GetSubEnumTable(f);
+}
+
+UPB_DEPRECATE_AND_INLINE()
+inline bool upb_MiniTable_FieldIsLinked(const upb_MiniTable* m,
+                                        const upb_MiniTableField* f) {
+  return upb_MiniTable_FieldIsLinked(f);
+}
+#endif
+
 #include "upb/port/undef.inc"
 
 #endif /* UPB_MINI_TABLE_MESSAGE_H_ */

data/third_party/upb/upb/port/atomic.h

@@ -31,6 +31,10 @@
                                        failure_order)                          \
   atomic_compare_exchange_weak_explicit(addr, expected, desired,               \
                                         success_order, failure_order)
+#define upb_Atomic_Add(addr, val, order) \
+  atomic_fetch_add_explicit(addr, val, order)
+#define upb_Atomic_Sub(addr, val, order) \
+  atomic_fetch_sub_explicit(addr, val, order)
 
 #elif defined(UPB_USE_MSC_ATOMICS)
 #include <intrin.h>
@@ -39,49 +43,41 @@
 
 #define upb_Atomic_Init(addr, val) (*(addr) = val)
 
+#pragma intrinsic(_InterlockedExchange)
+static int32_t upb_Atomic_LoadMsc32(int32_t volatile* addr) {
+  // Compare exchange with an unlikely value reduces the risk of a spurious
+  // (but harmless) store
+  return _InterlockedCompareExchange(addr, 0xDEADC0DE, 0xDEADC0DE);
+}
+
+#pragma intrinsic(_InterlockedCompareExchange)
+static bool upb_Atomic_CompareExchangeMscP32(int32_t volatile* addr,
+                                             int32_t* expected,
+                                             int32_t desired) {
+  int32_t expect_val = *expected;
+  int32_t actual_val = _InterlockedCompareExchange(addr, desired, expect_val);
+  if (expect_val != actual_val) {
+    *expected = actual_val;
+    return false;
+  }
+  return true;
+}
+
 #if defined(_WIN64)
 // MSVC, without C11 atomics, does not have any way in pure C to force
 // load-acquire store-release behavior, so we hack it with exchanges.
-#pragma intrinsic(_InterlockedExchange64)
-#define upb_Atomic_Store(addr, val, order) \
-  (void)_InterlockedExchange64((uint64_t volatile *)addr, (uint64_t)val)
-
 #pragma intrinsic(_InterlockedCompareExchange64)
-static uintptr_t upb_Atomic_LoadMsc(uint64_t volatile *addr) {
+static uintptr_t upb_Atomic_LoadMsc64(uint64_t volatile* addr) {
   // Compare exchange with an unlikely value reduces the risk of a spurious
   // (but harmless) store
   return _InterlockedCompareExchange64(addr, 0xDEADC0DEBAADF00D,
                                        0xDEADC0DEBAADF00D);
 }
-// If _Generic is available, use it to avoid emitting a "'uintptr_t' differs in
-// levels of indirection from 'void *'" or -Wint-conversion compiler warning.
-#if __STDC_VERSION__ >= 201112L
-#define upb_Atomic_Load(addr, order)                           \
-  _Generic(addr,                                               \
-      UPB_ATOMIC(uintptr_t) *: upb_Atomic_LoadMsc(             \
-                                 (uint64_t volatile *)(addr)), \
-      default: (void *)upb_Atomic_LoadMsc((uint64_t volatile *)(addr)))
-
-#define upb_Atomic_Exchange(addr, val, order)                                 \
-  _Generic(addr,                                                              \
-      UPB_ATOMIC(uintptr_t) *: _InterlockedExchange64(                        \
-                                 (uint64_t volatile *)(addr), (uint64_t)val), \
-      default: (void *)_InterlockedExchange64((uint64_t volatile *)addr,      \
-                                              (uint64_t)val))
-#else
-// Compare exchange with an unlikely value reduces the risk of a spurious
-// (but harmless) store
-#define upb_Atomic_Load(addr, order) \
-  (void *)upb_Atomic_LoadMsc((uint64_t volatile *)(addr))
-
-#define upb_Atomic_Exchange(addr, val, order) \
-  (void *)_InterlockedExchange64((uint64_t volatile *)addr, (uint64_t)val)
-#endif
 
 #pragma intrinsic(_InterlockedCompareExchange64)
-static bool upb_Atomic_CompareExchangeMscP(uint64_t volatile *addr,
-                                           uint64_t *expected,
-                                           uint64_t desired) {
+static bool upb_Atomic_CompareExchangeMscP64(uint64_t volatile* addr,
+                                             uint64_t* expected,
+                                             uint64_t desired) {
   uint64_t expect_val = *expected;
   uint64_t actual_val =
       _InterlockedCompareExchange64(addr, desired, expect_val);
@@ -92,72 +88,179 @@ static bool upb_Atomic_CompareExchangeMscP(uint64_t volatile *addr,
   return true;
 }
 
+#pragma intrinsic(_InterlockedExchange64)
+// If _Generic is available, use it to avoid emitting a "'uintptr_t' differs in
+// levels of indirection from 'void *'" or -Wint-conversion compiler warning.
+#if __STDC_VERSION__ >= 201112L
+#define upb_Atomic_Store(addr, val, order)                            \
+  _Generic(addr,                                                      \
+      UPB_ATOMIC(uintptr_t)*: (void)_InterlockedExchange64(           \
+               (uint64_t volatile*)(addr), (uint64_t)val),            \
+      UPB_ATOMIC(int32_t)*: (void)_InterlockedExchange(               \
+               (int32_t volatile*)(addr), (int32_t)val),              \
+      default: (void)_InterlockedExchange64((uint64_t volatile*)addr, \
+                                            (uint64_t)val))
+
+#define upb_Atomic_Load(addr, order)                                         \
+  _Generic(addr,                                                             \
+      UPB_ATOMIC(uintptr_t)*: upb_Atomic_LoadMsc64(                          \
+               (uint64_t volatile*)(addr)),                                  \
+      UPB_ATOMIC(int32_t)*: upb_Atomic_LoadMsc32((int32_t volatile*)(addr)), \
+      default: (void*)upb_Atomic_LoadMsc64((uint64_t volatile*)(addr)))
+
+#define upb_Atomic_Exchange(addr, val, order)                               \
+  _Generic(addr,                                                            \
+      UPB_ATOMIC(uintptr_t)*: _InterlockedExchange64(                       \
+               (uint64_t volatile*)(addr), (uint64_t)val),                  \
+      UPB_ATOMIC(int32_t)*: _InterlockedExchange((int32_t volatile*)(addr), \
+                                                 (int32_t)val),             \
+      default: (void*)_InterlockedExchange64((uint64_t volatile*)addr,      \
+                                             (uint64_t)val))
+
+#define upb_Atomic_CompareExchangeStrong(addr, expected, desired,           \
+                                         success_order, failure_order)      \
+  _Generic(addr,                                                            \
+      UPB_ATOMIC(int32_t)*: upb_Atomic_CompareExchangeMscP32(               \
+               (int32_t volatile*)(addr), (int32_t*)expected,               \
+               (int32_t)desired),                                           \
+      default: upb_Atomic_CompareExchangeMscP64((uint64_t volatile*)(addr), \
+                                                (uint64_t*)expected,        \
+                                                (uint64_t)desired))
+
+#define upb_Atomic_CompareExchangeWeak(addr, expected, desired, success_order, \
+                                       failure_order)                          \
+  _Generic(addr,                                                               \
+      UPB_ATOMIC(int32_t)*: upb_Atomic_CompareExchangeMscP32(                  \
+               (int32_t volatile*)(addr), (int32_t*)expected,                  \
+               (int32_t)desired),                                              \
+      default: upb_Atomic_CompareExchangeMscP64((uint64_t volatile*)(addr),    \
+                                                (uint64_t*)expected,           \
+                                                (uint64_t)desired))
+
+#else
+
+UPB_INLINE void _upb_Atomic_StoreP(void volatile* addr, uint64_t val,
+                                   size_t size) {
+  if (size == sizeof(int32_t)) {
+    (void)_InterlockedExchange((int32_t volatile*)addr, (int32_t)val);
+  } else {
+    (void)_InterlockedExchange64((uint64_t volatile*)addr, val);
+  }
+}
+
+#define upb_Atomic_Store(addr, val, order) \
+  _upb_Atomic_StoreP(addr, val, sizeof(*addr))
+
+UPB_INLINE int64_t _upb_Atomic_LoadP(void volatile* addr, size_t size) {
+  if (size == sizeof(int32_t)) {
+    return (int64_t)upb_Atomic_LoadMsc32((int32_t volatile*)addr);
+  } else {
+    return upb_Atomic_LoadMsc64((uint64_t volatile*)addr);
+  }
+}
+
+#define upb_Atomic_Load(addr, order) \
+  (void*)_upb_Atomic_LoadP((void volatile*)addr, sizeof(*addr))
+
+UPB_INLINE int64_t _upb_Atomic_ExchangeP(void volatile* addr, uint64_t val,
+                                         size_t size) {
+  if (size == sizeof(int32_t)) {
+    return (int64_t)_InterlockedExchange((int32_t volatile*)addr, (int32_t)val);
+  } else {
+    return (int64_t)_InterlockedExchange64((uint64_t volatile*)addr, val);
+  }
+}
+
+#define upb_Atomic_Exchange(addr, val, order)                       \
+  (void*)_upb_Atomic_ExchangeP((void volatile*)addr, (uint64_t)val, \
+                               sizeof(*addr))
+
+UPB_INLINE bool _upb_Atomic_CompareExchangeMscP(void volatile* addr,
+                                                void* expected,
+                                                uint64_t desired, size_t size) {
+  if (size == sizeof(int32_t)) {
+    return upb_Atomic_CompareExchangeMscP32(
+        (int32_t volatile*)addr, (int32_t*)expected, (int32_t)desired);
+  } else {
+    return upb_Atomic_CompareExchangeMscP64((uint64_t volatile*)addr,
+                                            (uint64_t*)expected, desired);
+  }
+}
+
 #define upb_Atomic_CompareExchangeStrong(addr, expected, desired,      \
                                          success_order, failure_order) \
-  upb_Atomic_CompareExchangeMscP((uint64_t volatile *)addr,            \
-                                 (uint64_t *)expected, (uint64_t)desired)
+  _upb_Atomic_CompareExchangeMscP(addr, expected, (uint64_t)desired,   \
+                                  sizeof(*addr))
 
 #define upb_Atomic_CompareExchangeWeak(addr, expected, desired, success_order, \
                                        failure_order)                          \
-  upb_Atomic_CompareExchangeMscP((uint64_t volatile *)addr,                    \
-                                 (uint64_t *)expected, (uint64_t)desired)
+  _upb_Atomic_CompareExchangeMscP(addr, expected, (uint64_t)desired,           \
+                                  sizeof(*addr))
+
+#endif
 
 #else  // 32 bit pointers
 #pragma intrinsic(_InterlockedExchange)
 #define upb_Atomic_Store(addr, val, order) \
-  (void)_InterlockedExchange((uint32_t volatile *)addr, (uint32_t)val)
+  (void)_InterlockedExchange((uint32_t volatile*)addr, (uint32_t)val)
 
-#pragma intrinsic(_InterlockedCompareExchange)
-static uintptr_t upb_Atomic_LoadMsc(uint32_t volatile *addr) {
-  // Compare exchange with an unlikely value reduces the risk of a spurious
-  // (but harmless) store
-  return _InterlockedCompareExchange(addr, 0xDEADC0DE, 0xDEADC0DE);
-}
 // If _Generic is available, use it to avoid emitting 'uintptr_t' differs in
 // levels of indirection from 'void *'
 #if __STDC_VERSION__ >= 201112L
-#define upb_Atomic_Load(addr, order)                           \
-  _Generic(addr,                                               \
-      UPB_ATOMIC(uintptr_t) *: upb_Atomic_LoadMsc(             \
-                                 (uint32_t volatile *)(addr)), \
-      default: (void *)upb_Atomic_LoadMsc((uint32_t volatile *)(addr)))
-
-#define upb_Atomic_Exchange(addr, val, order)                                 \
-  _Generic(addr,                                                              \
-      UPB_ATOMIC(uintptr_t) *: _InterlockedExchange(                          \
-                                 (uint32_t volatile *)(addr), (uint32_t)val), \
-      default: (void *)_InterlockedExchange64((uint32_t volatile *)addr,      \
-                                              (uint32_t)val))
+#define upb_Atomic_Load(addr, order)                                         \
+  _Generic(addr,                                                             \
+      UPB_ATOMIC(uintptr_t)*: (uintptr_t)upb_Atomic_LoadMsc32(               \
+               (uint32_t volatile*)(addr)),                                  \
+      UPB_ATOMIC(int32_t)*: upb_Atomic_LoadMsc32((int32_t volatile*)(addr)), \
+      default: (void*)upb_Atomic_LoadMsc32((uint32_t volatile*)(addr)))
+
+#define upb_Atomic_Exchange(addr, val, order)                                  \
+  _Generic(addr,                                                               \
+      UPB_ATOMIC(uintptr_t)*: _InterlockedExchange((uint32_t volatile*)(addr), \
+                                                   (uint32_t)val),             \
+      default: (void*)_InterlockedExchange((uint32_t volatile*)addr,           \
+                                           (uint32_t)val))
 #else
 #define upb_Atomic_Load(addr, order) \
-  (void *)upb_Atomic_LoadMsc((uint32_t volatile *)(addr))
+  (void*)upb_Atomic_LoadMsc32((uint32_t volatile*)(addr))
 
 #define upb_Atomic_Exchange(addr, val, order) \
-  (void *)_InterlockedExchange((uint32_t volatile *)addr, (uint32_t)val)
+  (void*)_InterlockedExchange((uint32_t volatile*)addr, (uint32_t)val)
 #endif
 
-#pragma intrinsic(_InterlockedCompareExchange)
-static bool upb_Atomic_CompareExchangeMscP(uint32_t volatile *addr,
-                                           uint32_t *expected,
-                                           uint32_t desired) {
-  uint32_t expect_val = *expected;
-  uint32_t actual_val = _InterlockedCompareExchange(addr, desired, expect_val);
-  if (expect_val != actual_val) {
-    *expected = actual_val;
-    return false;
-  }
-  return true;
-}
-
 #define upb_Atomic_CompareExchangeStrong(addr, expected, desired,      \
                                          success_order, failure_order) \
-  upb_Atomic_CompareExchangeMscP((uint32_t volatile *)addr,            \
-                                 (uint32_t *)expected, (uint32_t)desired)
+  upb_Atomic_CompareExchangeMscP32((uint32_t volatile*)addr,           \
+                                   (uint32_t*)expected, (uint32_t)desired)
 
 #define upb_Atomic_CompareExchangeWeak(addr, expected, desired, success_order, \
                                        failure_order)                          \
-  upb_Atomic_CompareExchangeMscP((uint32_t volatile *)addr,                    \
-                                 (uint32_t *)expected, (uint32_t)desired)
+  upb_Atomic_CompareExchangeMscP32((uint32_t volatile*)addr,                   \
+                                   (uint32_t*)expected, (uint32_t)desired)
+#endif
+
+#pragma intrinsic(_InterlockedExchangeAdd)
+#pragma intrinsic(_InterlockedExchangeAdd64)
+
+// If _Generic is available, use it to switch between 32 and 64 bit types.
+#if __STDC_VERSION__ >= 201112L
+#define upb_Atomic_Add(addr, val, order)                                   \
+  _Generic(addr,                                                           \
+      UPB_ATOMIC(int64_t)*: _InterlockedExchangeAdd64(addr, (int64_t)val), \
+      UPB_ATOMIC(int32_t)*: _InterlockedExchangeAdd(addr, (int32_t)val))
+#define upb_Atomic_Sub(addr, val, order)                                    \
+  _Generic(addr,                                                            \
+      UPB_ATOMIC(int64_t)*: _InterlockedExchangeAdd64(addr, -(int64_t)val), \
+      UPB_ATOMIC(int32_t)*: _InterlockedExchangeAdd(addr, -(int32_t)val))
+#else
+#define upb_Atomic_Add(addr, val, order)                                \
+  sizeof(*addr) == sizeof(int32_t)                                      \
+      ? _InterlockedExchangeAdd((uint32_t volatile*)addr, (int32_t)val) \
+      : _InterlockedExchangeAdd64((uint64_t volatile*)addr, (int64_t)val)
+#define upb_Atomic_Sub(addr, val, order)                                 \
+  sizeof(*addr) == sizeof(int32_t)                                       \
+      ? _InterlockedExchangeAdd((uint32_t volatile*)addr, -(int32_t)val) \
+      : _InterlockedExchangeAdd64((uint64_t volatile*)addr, -(int64_t)val)
 #endif
 
 #else  // No atomics
@@ -203,6 +306,9 @@ UPB_INLINE bool _upb_NonAtomic_CompareExchangeStrongP(void* addr,
                                        failure_order)                          \
   upb_Atomic_CompareExchangeStrong(addr, expected, desired, 0, 0)
 
+#define upb_Atomic_Add(addr, val, order) (*addr += val)
+#define upb_Atomic_Sub(addr, val, order) (*addr -= val)
+
 #endif
 
 #include "upb/port/undef.inc"