grpc 1.80.0 → 1.81.0

data/third_party/upb/upb/wire/decode.h

@@ -25,6 +25,7 @@
 extern "C" {
 #endif
 
+// LINT.IfChange
 enum {
   /* If set, strings and unknown fields will alias the input buffer instead of
    * copying into the arena. */
@@ -93,21 +94,23 @@ enum {
    * as non-UTF-8 proto3 string fields.
    */
   kUpb_DecodeOption_AlwaysValidateUtf8 = 8,
+
+  /* EXPERIMENTAL:
+   *
+   * If set, the fasttable decoder will not be used. */
+  kUpb_DecodeOption_DisableFastTable = 16,
 };
+// LINT.ThenChange(//depot/google3/third_party/protobuf/rust/upb.rs:decode_status)
 
 UPB_INLINE uint32_t upb_DecodeOptions_MaxDepth(uint16_t depth) {
   return (uint32_t)depth << 16;
 }
 
-UPB_INLINE uint16_t upb_DecodeOptions_GetMaxDepth(uint32_t options) {
-  return options >> 16;
-}
-
 uint16_t upb_DecodeOptions_GetEffectiveMaxDepth(uint32_t options);
 
 // Enforce an upper bound on recursion depth.
 UPB_INLINE int upb_Decode_LimitDepth(uint32_t decode_options, uint32_t limit) {
-  uint32_t max_depth = upb_DecodeOptions_GetMaxDepth(decode_options);
+  uint32_t max_depth = upb_DecodeOptions_GetEffectiveMaxDepth(decode_options);
   if (max_depth > limit) max_depth = limit;
   return upb_DecodeOptions_MaxDepth(max_depth) | (decode_options & 0xffff);
 }
@@ -145,6 +148,12 @@ UPB_API upb_DecodeStatus upb_DecodeLengthPrefixed(
     const upb_MiniTable* mt, const upb_ExtensionRegistry* extreg, int options,
     upb_Arena* arena);
 
+// For testing: decode with tracing.
+UPB_API upb_DecodeStatus upb_DecodeWithTrace(
+    const char* buf, size_t size, upb_Message* msg, const upb_MiniTable* mt,
+    const upb_ExtensionRegistry* extreg, int options, upb_Arena* arena,
+    char* trace_buf, size_t trace_size);
+
 // Utility function for wrapper languages to get an error string from a
 // upb_DecodeStatus.
 UPB_API const char* upb_DecodeStatus_String(upb_DecodeStatus status);

data/third_party/upb/upb/wire/decode_fast/combinations.h

@@ -0,0 +1,217 @@
+// 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_WIRE_INTERNAL_DECODE_FAST_COMBINATIONS_H_
+#define UPB_WIRE_INTERNAL_DECODE_FAST_COMBINATIONS_H_
+
+#include <stdint.h>
+
+#include "upb/base/internal/log2.h"
+#include "upb/wire/types.h"
+
+// Must be last.
+#include "upb/port/def.inc"
+
+// Each fast function is specialized for a cardinality, type, and tag size.
+// These macros enumerate all possibilities for each of these three dimensions.
+//
+// These can be generated in any combination, except that non-primitive types
+// cannot be packed.  So we have:
+//   {1bt,2bt} x {s,o,r,p} x {b,v32,v64,z32,z64,f32,f64,ce}  // Primitive
+//   {1bt,2bt} x {s,o,r}   x {s,b,m}                         // Non-primitive
+
+#define UPB_DECODEFAST_CARDINALITIES(F, ...) \
+  F(__VA_ARGS__, Scalar)                     \
+  F(__VA_ARGS__, Oneof)                      \
+  F(__VA_ARGS__, Repeated)                   \
+  F(__VA_ARGS__, Packed)
+
+#define UPB_DECODEFAST_TYPES(F, ...) \
+  F(__VA_ARGS__, Bool)               \
+  F(__VA_ARGS__, Varint32)           \
+  F(__VA_ARGS__, Varint64)           \
+  F(__VA_ARGS__, ZigZag32)           \
+  F(__VA_ARGS__, ZigZag64)           \
+  F(__VA_ARGS__, Fixed32)            \
+  F(__VA_ARGS__, Fixed64)            \
+  F(__VA_ARGS__, String)             \
+  F(__VA_ARGS__, Bytes)              \
+  F(__VA_ARGS__, Message)
+
+#define UPB_DECODEFAST_TAGSIZES(F, ...) \
+  F(__VA_ARGS__, Tag1Byte)              \
+  F(__VA_ARGS__, Tag2Byte)
+
+#define ENUM_VAL(_, x) kUpb_DecodeFast_##x,
+
+typedef enum {
+  UPB_DECODEFAST_CARDINALITIES(ENUM_VAL)  // kUpb_DecodeFast_Scalar = 0, etc.
+} upb_DecodeFast_Cardinality;
+
+typedef enum {
+  UPB_DECODEFAST_TYPES(ENUM_VAL)  // kUpb_DecodeFast_Bool = 0, etc.
+} upb_DecodeFast_Type;
+
+typedef enum {
+  UPB_DECODEFAST_TAGSIZES(ENUM_VAL)  // kUpb_DecodeFast_Tag1Byte = 0, etc.
+} upb_DecodeFast_TagSize;
+
+#undef ENUM_VAL
+
+#define ADD(_, x) +1
+
+enum {
+  // Counts of the number of enum values for each dimension.
+  kUpb_DecodeFast_CardinalityCount = UPB_DECODEFAST_CARDINALITIES(ADD),
+  kUpb_DecodeFast_TypeCount = UPB_DECODEFAST_TYPES(ADD),
+  kUpb_DecodeFast_TagSizeCount = UPB_DECODEFAST_TAGSIZES(ADD),
+};
+
+#undef ADD
+
+// Attributes of the various dimensions.
+
+UPB_INLINE int upb_DecodeFast_TagSizeBytes(upb_DecodeFast_TagSize size) {
+  switch (size) {
+    case kUpb_DecodeFast_Tag1Byte:
+      return 1;
+    case kUpb_DecodeFast_Tag2Byte:
+      return 2;
+    default:
+      UPB_UNREACHABLE();
+  }
+}
+
+UPB_INLINE int upb_DecodeFast_ValueBytes(upb_DecodeFast_Type type) {
+  switch (type) {
+    case kUpb_DecodeFast_Bool:
+      return 1;
+    case kUpb_DecodeFast_Varint32:
+    case kUpb_DecodeFast_ZigZag32:
+    case kUpb_DecodeFast_Fixed32:
+      return 4;
+    case kUpb_DecodeFast_Varint64:
+    case kUpb_DecodeFast_ZigZag64:
+    case kUpb_DecodeFast_Fixed64:
+    case kUpb_DecodeFast_Message:
+      return 8;
+    case kUpb_DecodeFast_String:
+    case kUpb_DecodeFast_Bytes:
+      return 16;
+    default:
+      UPB_UNREACHABLE();
+  }
+}
+
+UPB_INLINE upb_WireType upb_DecodeFast_WireType(upb_DecodeFast_Type type) {
+  switch (type) {
+    case kUpb_DecodeFast_Bool:
+    case kUpb_DecodeFast_Varint32:
+    case kUpb_DecodeFast_Varint64:
+    case kUpb_DecodeFast_ZigZag32:
+    case kUpb_DecodeFast_ZigZag64:
+      return kUpb_WireType_Varint;
+    case kUpb_DecodeFast_Fixed32:
+      return kUpb_WireType_32Bit;
+    case kUpb_DecodeFast_Fixed64:
+      return kUpb_WireType_64Bit;
+    case kUpb_DecodeFast_Message:
+    case kUpb_DecodeFast_String:
+    case kUpb_DecodeFast_Bytes:
+      return kUpb_WireType_Delimited;
+    default:
+      UPB_UNREACHABLE();
+  }
+}
+
+UPB_INLINE int upb_DecodeFast_ValueBytesLg2(upb_DecodeFast_Type type) {
+  return upb_Log2Ceiling(upb_DecodeFast_ValueBytes(type));
+}
+
+UPB_INLINE bool upb_DecodeFast_IsRepeated(upb_DecodeFast_Cardinality card) {
+  return card == kUpb_DecodeFast_Repeated || card == kUpb_DecodeFast_Packed;
+}
+
+UPB_INLINE bool upb_DecodeFast_IsZigZag(upb_DecodeFast_Type type) {
+  switch (type) {
+    case kUpb_DecodeFast_ZigZag32:
+    case kUpb_DecodeFast_ZigZag64:
+      return true;
+    default:
+      return false;
+  }
+}
+
+// The canonical ordering of functions, used by the arrays of function pointers
+// and function names.  This macro generates the full cross product of the
+// cardinality, type, and tag size enums.
+//
+// This ordering generates some combinations that are not actually used (like
+// packed strings or messages), but it's simpler than trying to avoid them.
+// There are only 14 impossible combinations out of 120 total, so it's not
+// worth optimizing for.
+#define UPB_DECODEFAST_FUNCTIONS(F) \
+  UPB_DECODEFAST_TYPES(UPB_DECODEFAST_CARDINALITIES, UPB_DECODEFAST_TAGSIZES, F)
+
+// The canonical index of a given function.  This must be kept in sync with the
+// ordering above, such that this index selects the same function as the
+// corresponding UPB_DECODEFAST_FUNCNAME() macro.
+#define UPB_DECODEFAST_FUNCTION_IDX(type, card, size)   \
+  (((uint32_t)type * kUpb_DecodeFast_CardinalityCount * \
+    kUpb_DecodeFast_TagSizeCount) +                     \
+   ((uint32_t)card * kUpb_DecodeFast_TagSizeCount) + (uint32_t)size)
+
+// Functions to decompose a function index into its constituent parts.
+UPB_INLINE upb_DecodeFast_TagSize
+upb_DecodeFast_GetTagSize(uint32_t function_idx) {
+  return (upb_DecodeFast_TagSize)(function_idx % kUpb_DecodeFast_TagSizeCount);
+}
+
+UPB_INLINE upb_DecodeFast_Cardinality
+upb_DecodeFast_GetCardinality(uint32_t function_idx) {
+  return (upb_DecodeFast_Cardinality)((function_idx /
+                                       kUpb_DecodeFast_TagSizeCount) %
+                                      kUpb_DecodeFast_CardinalityCount);
+}
+
+UPB_INLINE upb_DecodeFast_Type upb_DecodeFast_GetType(uint32_t function_idx) {
+  return (upb_DecodeFast_Type)(function_idx /
+                               (kUpb_DecodeFast_TagSizeCount *
+                                kUpb_DecodeFast_CardinalityCount));
+}
+
+// The canonical function name for a given cardinality, type, and tag size.
+#define UPB_DECODEFAST_FUNCNAME(type, card, size) \
+  upb_DecodeFast_##type##_##card##_##size
+
+// Returns true if we should disable fast decode for this function_idx.  This is
+// useful for field types that are known not to work yet.  It is also useful for
+// bisecting a test failure to find which function(s) are broken.
+//
+// This must be a macro because it must evaluate to a compile-time constant,
+// since we use it when initializing the fastdecode function array.
+//
+// This function only applies to field types that have been assigned a function
+// index.  Some field types (eg. groups) do not even have a function index at
+// the moment, and so will be rejected by upb_DecodeFast_TryFillEntry() before
+// we even get here.
+#define UPB_DECODEFAST_COMBINATION_IS_ENABLED(type, card, size) \
+  (type == kUpb_DecodeFast_Fixed32 || type == kUpb_DecodeFast_Fixed64)
+
+#ifdef UPB_DECODEFAST_DISABLE_FUNCTIONS_ABOVE
+#define UPB_DECODEFAST_ISENABLED(type, card, size)            \
+  (UPB_DECODEFAST_COMBINATION_IS_ENABLED(type, card, size) && \
+   (UPB_DECODEFAST_FUNCION_IDX(type, card, size) <=           \
+    UPB_DECODEFAST_DISABLE_FUNCTIONS_ABOVE))
+#else
+#define UPB_DECODEFAST_ISENABLED(type, card, size) \
+  UPB_DECODEFAST_COMBINATION_IS_ENABLED(type, card, size)
+#endif
+
+#include "upb/port/undef.inc"
+
+#endif  // UPB_WIRE_INTERNAL_DECODE_FAST_COMBINATIONS_H_

data/third_party/upb/upb/wire/decode_fast/data.h

@@ -0,0 +1,74 @@
+// 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 GOOGLE_UPB_UPB_WIRE_INTERNAL_DECODE_FAST_DATALAYOUT_H__
+#define GOOGLE_UPB_UPB_WIRE_INTERNAL_DECODE_FAST_DATALAYOUT_H__
+
+#include <stdint.h>
+
+// Must be last.
+#include "upb/port/def.inc"
+
+// The layout of the data field of _upb_FastTable_Entry.field_data is as
+// follows:
+//
+//                  48                32                16                 0
+// |--------|--------|--------|--------|--------|--------|--------|--------|
+// |   offset (16)   |case offset (16) |presence| submsg |  exp. tag (16)  |
+// |--------|--------|--------|--------|--------|--------|--------|--------|
+//
+// - `offset` is the offset of the field in the message struct.
+// - `case_offset` is the offset of the oneof selector for a oneof field
+//   (or 0 if not a oneof field).
+// - `presence` is either hasbit index or field number for oneofs.
+// - `submsg_index` is the index of the submessage in the mini table's
+//   subs array (or 0 if not a submessage field).
+// - `expected_tag` is the expected value of the tag for this field.
+
+UPB_INLINE bool upb_DecodeFast_MakeData(uint64_t offset, uint64_t case_offset,
+                                        uint64_t presence,
+                                        uint64_t submsg_index,
+                                        uint64_t expected_tag,
+                                        uint64_t* out_data) {
+  if (offset > 0xffff || case_offset > 0xffff || presence > 0xff ||
+      submsg_index > 0xff || expected_tag > 0xffff) {
+    return false;
+  }
+
+  *out_data = (offset << 48) | (case_offset << 32) | (presence << 24) |
+              (submsg_index << 16) | expected_tag;
+  return true;
+}
+
+UPB_INLINE uint16_t upb_DecodeFastData_GetOffset(uint64_t data) {
+  return data >> 48;
+}
+
+UPB_INLINE uint16_t upb_DecodeFastData_GetCaseOffset(uint64_t data) {
+  return data >> 32;
+}
+
+UPB_INLINE uint8_t upb_DecodeFastData_GetPresence(uint64_t data) {
+  return data >> 24;
+}
+
+UPB_INLINE uint8_t upb_DecodeFastData_GetSubmsgIndex(uint64_t data) {
+  return data >> 16;
+}
+
+UPB_INLINE uint16_t upb_DecodeFastData_GetExpectedTag(uint64_t data) {
+  return data;
+}
+
+UPB_INLINE int upb_DecodeFastData_GetTableSlot(uint64_t data) {
+  uint16_t tag = upb_DecodeFastData_GetExpectedTag(data);
+  return (tag & 0xf8) >> 3;
+}
+
+#include "upb/port/undef.inc"
+
+#endif  // GOOGLE_UPB_UPB_WIRE_INTERNAL_DECODE_FAST_DATALAYOUT_H__

data/third_party/upb/upb/wire/decode_fast/select.c

@@ -0,0 +1,235 @@
+// 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
+
+#include "upb/wire/decode_fast/select.h"
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include "upb/base/descriptor_constants.h"
+#include "upb/base/internal/log2.h"
+#include "upb/mini_table/field.h"
+#include "upb/mini_table/internal/field.h"
+#include "upb/mini_table/message.h"
+#include "upb/wire/decode_fast/combinations.h"
+#include "upb/wire/decode_fast/data.h"
+#include "upb/wire/types.h"
+
+// Must be last.
+#include "upb/port/def.inc"
+
+uint32_t GetWireTypeForField(const upb_MiniTableField* field) {
+  if (upb_MiniTableField_IsPacked(field)) return kUpb_WireType_Delimited;
+  switch (upb_MiniTableField_Type(field)) {
+    case kUpb_FieldType_Double:
+    case kUpb_FieldType_Fixed64:
+    case kUpb_FieldType_SFixed64:
+      return kUpb_WireType_64Bit;
+    case kUpb_FieldType_Float:
+    case kUpb_FieldType_Fixed32:
+    case kUpb_FieldType_SFixed32:
+      return kUpb_WireType_32Bit;
+    case kUpb_FieldType_Int64:
+    case kUpb_FieldType_UInt64:
+    case kUpb_FieldType_Int32:
+    case kUpb_FieldType_Bool:
+    case kUpb_FieldType_UInt32:
+    case kUpb_FieldType_Enum:
+    case kUpb_FieldType_SInt32:
+    case kUpb_FieldType_SInt64:
+      return kUpb_WireType_Varint;
+    case kUpb_FieldType_Group:
+      return kUpb_WireType_StartGroup;
+    case kUpb_FieldType_Message:
+    case kUpb_FieldType_String:
+    case kUpb_FieldType_Bytes:
+      return kUpb_WireType_Delimited;
+    default:
+      UPB_UNREACHABLE();
+  }
+}
+
+static bool upb_DecodeFast_GetEncodedTag(const upb_MiniTableField* field,
+                                         uint16_t* out_tag,
+                                         upb_DecodeFast_TagSize* out_tag_size) {
+  uint32_t num = upb_MiniTableField_Number(field);
+  uint32_t wire_type = GetWireTypeForField(field);
+  if (num >= 2048) {
+    return false;  // Tag >2 bytes, too large for fast decode.
+  } else if (num >= 16) {
+    *out_tag = ((num << 4) & 0x7f00) | 0x80 | ((num << 3) & 0x7f) | wire_type;
+    *out_tag_size = kUpb_DecodeFast_Tag2Byte;
+    return true;
+  } else {
+    *out_tag = (num << 3) | wire_type;
+    *out_tag_size = kUpb_DecodeFast_Tag1Byte;
+    return true;
+  }
+}
+
+static bool upb_DecodeFast_GetFieldCardinality(
+    const upb_MiniTableField* field,
+    upb_DecodeFast_Cardinality* out_cardinality) {
+  switch (UPB_PRIVATE(_upb_MiniTableField_Mode)(field)) {
+    case kUpb_FieldMode_Map:
+      return false;  // Can't parse maps with fast decode.
+    case kUpb_FieldMode_Array:
+      *out_cardinality = upb_MiniTableField_IsPacked(field)
+                             ? kUpb_DecodeFast_Packed
+                             : kUpb_DecodeFast_Repeated;
+      return true;
+    case kUpb_FieldMode_Scalar:
+      *out_cardinality = upb_MiniTableField_IsInOneof(field)
+                             ? kUpb_DecodeFast_Oneof
+                             : kUpb_DecodeFast_Scalar;
+      return true;
+  }
+  UPB_UNREACHABLE();
+}
+
+static bool upb_DecodeFast_GetFieldType(const upb_MiniTable* m,
+                                        const upb_MiniTableField* field,
+                                        upb_DecodeFast_Type* out_type) {
+  upb_FieldType type = upb_MiniTableField_Type(field);
+
+  if (type == kUpb_FieldType_Group || upb_MiniTableField_IsClosedEnum(field)) {
+    return false;  // Currently not supported.
+  }
+
+  static const int8_t types[] = {
+      [kUpb_FieldType_Bool] = kUpb_DecodeFast_Bool,
+      [kUpb_FieldType_Enum] = kUpb_DecodeFast_Varint32,
+      [kUpb_FieldType_Int32] = kUpb_DecodeFast_Varint32,
+      [kUpb_FieldType_UInt32] = kUpb_DecodeFast_Varint32,
+      [kUpb_FieldType_Int64] = kUpb_DecodeFast_Varint64,
+      [kUpb_FieldType_UInt64] = kUpb_DecodeFast_Varint64,
+      [kUpb_FieldType_Fixed32] = kUpb_DecodeFast_Fixed32,
+      [kUpb_FieldType_SFixed32] = kUpb_DecodeFast_Fixed32,
+      [kUpb_FieldType_Float] = kUpb_DecodeFast_Fixed32,
+      [kUpb_FieldType_Fixed64] = kUpb_DecodeFast_Fixed64,
+      [kUpb_FieldType_SFixed64] = kUpb_DecodeFast_Fixed64,
+      [kUpb_FieldType_Double] = kUpb_DecodeFast_Fixed64,
+      [kUpb_FieldType_SInt32] = kUpb_DecodeFast_ZigZag32,
+      [kUpb_FieldType_SInt64] = kUpb_DecodeFast_ZigZag64,
+      [kUpb_FieldType_String] = kUpb_DecodeFast_String,
+      [kUpb_FieldType_Bytes] = kUpb_DecodeFast_Bytes,
+      [kUpb_FieldType_Message] = kUpb_DecodeFast_Message,
+  };
+
+  UPB_ASSERT(type < UPB_ARRAY_SIZE(types));
+  *out_type = types[type];
+  return true;
+}
+
+static bool upb_DecodeFast_GetFunctionIndex(const upb_MiniTable* m,
+                                            const upb_MiniTableField* field,
+                                            upb_DecodeFast_TagSize tag_size,
+                                            uint32_t* out_index) {
+  upb_DecodeFast_Cardinality cardinality;
+  upb_DecodeFast_Type type;
+  if (!upb_DecodeFast_GetFieldCardinality(field, &cardinality)) return false;
+  if (!upb_DecodeFast_GetFieldType(m, field, &type)) return false;
+
+  *out_index = type << 3 | cardinality << 1 | tag_size;
+  return true;
+}
+
+static uint64_t upb_DecodeFast_GetPresence(const upb_MiniTableField* field,
+                                           uint64_t* out_data) {
+  if (upb_MiniTableField_IsInOneof(field)) {
+    *out_data = upb_MiniTableField_Number(field);
+    return true;
+  } else if (UPB_PRIVATE(_upb_MiniTableField_HasHasbit)(field)) {
+    *out_data = field->presence - 64;
+    return *out_data < 32;  // We use uint32_t for hasbits currently.
+  } else {
+    // We only store 32 bits of hasbits back to the message, so for fields that
+    // don't have a hasbit, we just set the high bit which won't be stored.
+    *out_data = 63;
+    return true;
+  }
+}
+
+static bool upb_DecodeFast_GetFunctionData(const upb_MiniTableField* field,
+                                           uint16_t tag, uint64_t* out_data) {
+  uint64_t offset = UPB_PRIVATE(_upb_MiniTableField_Offset)(field);
+  uint64_t case_offset =
+      upb_MiniTableField_IsInOneof(field)
+          ? UPB_PRIVATE(_upb_MiniTableField_OneofOffset)(field)
+          : 0;
+  uint64_t submsg_index = upb_MiniTableField_IsSubMessage(field)
+                              ? field->UPB_PRIVATE(submsg_index)
+                              : 0;
+
+  uint64_t presence;
+
+  return upb_DecodeFast_GetPresence(field, &presence) &&
+         upb_DecodeFast_MakeData(offset, case_offset, presence, submsg_index,
+                                 tag, out_data);
+}
+
+static bool upb_DecodeFast_TryFillEntry(const upb_MiniTable* m,
+                                        const upb_MiniTableField* field,
+                                        upb_DecodeFast_TableEntry* entry) {
+  UPB_ASSERT(!upb_MiniTableField_IsExtension(field));
+  uint16_t tag;
+  upb_DecodeFast_TagSize tag_size;
+  return upb_DecodeFast_GetEncodedTag(field, &tag, &tag_size) &&
+         upb_DecodeFast_GetFunctionIndex(m, field, tag_size,
+                                         &entry->function_idx) &&
+         UPB_DECODEFAST_ISENABLED(
+             upb_DecodeFast_GetType(entry->function_idx),
+             upb_DecodeFast_GetCardinality(entry->function_idx),
+             upb_DecodeFast_GetTagSize(entry->function_idx)) &&
+         upb_DecodeFast_GetFunctionData(field, tag, &entry->function_data);
+}
+
+int upb_DecodeFast_BuildTable(const upb_MiniTable* m,
+                              upb_DecodeFast_TableEntry table[32]) {
+  for (size_t i = 0; i < 32; i++) {
+    table[i].function_idx = UINT32_MAX;
+    table[i].function_data = 0;
+  }
+
+  int max = 0;
+  for (size_t i = 0, n = upb_MiniTable_FieldCount(m); i < n; i++) {
+    const upb_MiniTableField* field = upb_MiniTable_GetFieldByIndex(m, i);
+    upb_DecodeFast_TableEntry entry;
+    if (!upb_DecodeFast_TryFillEntry(m, field, &entry)) continue;
+    int slot = upb_DecodeFastData_GetTableSlot(entry.function_data);
+    if (table[slot].function_idx == UINT32_MAX) {
+      table[slot] = entry;
+      max = UPB_MAX(max, slot);
+    }
+  }
+
+  return max == 0 ? 0 : upb_RoundUpToPowerOfTwo(max + 1);
+}
+
+uint8_t upb_DecodeFast_GetTableMask(int table_size) {
+  return table_size > 0 ? (table_size - 1) << 3 : 255;
+}
+
+const char* upb_DecodeFast_GetFunctionName(uint32_t function_idx) {
+#define STRINGIFY1(x) #x
+#define STRINGIFY2(x) STRINGIFY1(x)
+#define FUNCSTR(...) STRINGIFY2(UPB_DECODEFAST_FUNCNAME(__VA_ARGS__)),
+  // Constructing all combinations of strings at compile time wastes ~2k of
+  // binary size and RAM compared with using eg. snprintf() at runtime.  But
+  // this function is only used from the compiler, where 2k is inconsequential.
+  static const char* names[] = {UPB_DECODEFAST_FUNCTIONS(FUNCSTR)};
+#undef STRINGIFY1
+#undef STRINGIFY2
+#undef FUNCSTR
+
+  if (function_idx == UINT32_MAX) return "_upb_FastDecoder_DecodeGeneric";
+  UPB_ASSERT(function_idx < UPB_ARRAY_SIZE(names));
+  return names[function_idx];
+}
+
+#include "upb/port/undef.inc"

data/third_party/upb/upb/wire/decode_fast/select.h

@@ -0,0 +1,66 @@
+// 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_WIRE_INTERNAL_DECODE_FAST_SELECT_H_
+#define UPB_WIRE_INTERNAL_DECODE_FAST_SELECT_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "upb/mini_table/internal/message.h"
+#include "upb/mini_table/message.h"
+
+// Must be last.
+#include "upb/port/def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  // The function that will be called to parse this field.  The function
+  // pointer for it must be placed into _upb_FastTable_Entry.field_parser.
+  //
+  // The function pointer can be either looked up at runtime via
+  // upb_DecodeFast_GetFunctionPointer(), or be referenced in generated code via
+  // upb_DecodeFast_GetFunctionName().
+  uint32_t function_idx;
+
+  // The associated data that will be passed to the function.  This must be
+  // placed into _upb_FastTable_Entry.field_data.
+  uint64_t function_data;
+} upb_DecodeFast_TableEntry;
+
+// Builds the fasttable for the given message.  The table will be written into
+// the given array.  Returns the number of entries in the table that were
+// actually used, and should be written to the MiniTable (this number may be
+// less than 32).
+//
+// This function will assume that the lower a field number, the hotter the field
+// is.  If at some point we get access to more information about field usage,
+// we should consider using that instead.
+int upb_DecodeFast_BuildTable(const upb_MiniTable* m,
+                              upb_DecodeFast_TableEntry table[32]);
+
+// Returns the mask that should be placed into the table_mask field of the
+// mini table for the given table size.
+uint8_t upb_DecodeFast_GetTableMask(int table_size);
+
+// Translates a function index into the canonical function name which can be
+// emitted into generated code.
+const char* upb_DecodeFast_GetFunctionName(uint32_t function_idx);
+
+// Returns a function pointer for the given function index.
+_upb_FieldParser* upb_DecodeFast_GetFunctionPointer(uint32_t function_idx);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#include "upb/port/undef.inc"
+
+#endif  // UPB_WIRE_INTERNAL_DECODE_FAST_SELECT_H_