grpc 1.80.0 → 1.81.0

data/third_party/upb/upb/mini_descriptor/decode.c

@@ -11,6 +11,7 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "upb/base/descriptor_constants.h"
 #include "upb/base/status.h"
@@ -18,6 +19,7 @@
 #include "upb/mem/alloc.h"
 #include "upb/mem/arena.h"
 #include "upb/message/internal/map_entry.h"
+#include "upb/message/internal/types.h"
 #include "upb/mini_descriptor/internal/base92.h"
 #include "upb/mini_descriptor/internal/decoder.h"
 #include "upb/mini_descriptor/internal/modifiers.h"
@@ -30,6 +32,20 @@
 #include "upb/mini_table/message.h"
 #include "upb/mini_table/sub.h"
 
+// Our awkward dance for including fasttable only when it is enabled.
+#include "upb/port/def.inc"
+#if UPB_FASTTABLE
+#define UPB_INCLUDE_FAST_DECODE
+#endif
+#include "upb/port/undef.inc"
+
+#ifdef UPB_INCLUDE_FAST_DECODE
+#include "upb/wire/decode_fast/function_array.h"
+#include "upb/wire/decode_fast/select.h"
+#endif
+
+#undef UPB_INCLUDE_FAST_DECODE
+
 // Must be last.
 #include "upb/port/def.inc"
 
@@ -44,6 +60,11 @@
 // Stores the field number of the present value of the oneof
 #define kUpb_OneOf_CaseFieldRep (kUpb_FieldRep_4Byte)
 
+// The maximum field number that can be encoded on the wire.
+// Note that this limit does not apply to MessageSet, which can have field
+// numbers up to INT32_MAX.
+#define kUpb_MaxFieldNumber ((1 << 29) - 1)
+
 typedef struct {
   // Index of the corresponding field. The field's offset will be the index of
   // the next field in a linked list.
@@ -61,7 +82,6 @@ typedef struct {
 
 typedef struct {
   upb_MdDecoder base;
-  upb_MiniTable* table;
   upb_MiniTableField* fields;
   upb_MiniTablePlatform platform;
   upb_OneOfLayoutItemVector oneofs;
@@ -69,6 +89,12 @@ typedef struct {
   // Initially tracks the count of each field rep type; then, during assignment,
   // tracks the base offset for the next processed field of the given rep.
   uint16_t rep_counts_offsets[kUpb_FieldRep_Max + 1];
+  bool is_extension;
+
+  // When building fasttables, we don't know the total size of the table until
+  // we're done decoding, so we allocate a temporary table on the stack and
+  // allocate the real thing from the arena later.
+  upb_MiniTable table;
 } upb_MtDecoder;
 
 // In each field's offset, we temporarily store a presence classifier:
@@ -276,40 +302,45 @@ static void upb_MtDecoder_PushOneof(upb_MtDecoder* d,
 
 static size_t upb_MtDecoder_SizeOfRep(upb_FieldRep rep,
                                       upb_MiniTablePlatform platform) {
+  enum { string_view_size_32 = 8, string_view_size_64 = 16 };
+  UPB_STATIC_ASSERT(sizeof(upb_StringView) ==
+                        UPB_SIZE(string_view_size_32, string_view_size_64),
+                    "StringView size mismatch");
   static const uint8_t kRepToSize32[] = {
       [kUpb_FieldRep_1Byte] = 1,
       [kUpb_FieldRep_4Byte] = 4,
-      [kUpb_FieldRep_StringView] = 8,
+      [kUpb_FieldRep_StringView] = string_view_size_32,
       [kUpb_FieldRep_8Byte] = 8,
   };
   static const uint8_t kRepToSize64[] = {
       [kUpb_FieldRep_1Byte] = 1,
       [kUpb_FieldRep_4Byte] = 4,
-      [kUpb_FieldRep_StringView] = 16,
+      [kUpb_FieldRep_StringView] = string_view_size_64,
       [kUpb_FieldRep_8Byte] = 8,
   };
-  UPB_ASSERT(sizeof(upb_StringView) ==
-             UPB_SIZE(kRepToSize32, kRepToSize64)[kUpb_FieldRep_StringView]);
   return platform == kUpb_MiniTablePlatform_32Bit ? kRepToSize32[rep]
                                                   : kRepToSize64[rep];
 }
 
 static size_t upb_MtDecoder_AlignOfRep(upb_FieldRep rep,
                                        upb_MiniTablePlatform platform) {
+  enum { string_view_align_32 = 4, string_view_align_64 = 8 };
+  UPB_STATIC_ASSERT(UPB_ALIGN_OF(upb_StringView) ==
+                        UPB_SIZE(string_view_align_32, string_view_align_64),
+                    "StringView size mismatch");
+
   static const uint8_t kRepToAlign32[] = {
       [kUpb_FieldRep_1Byte] = 1,
       [kUpb_FieldRep_4Byte] = 4,
-      [kUpb_FieldRep_StringView] = 4,
+      [kUpb_FieldRep_StringView] = string_view_align_32,
       [kUpb_FieldRep_8Byte] = 8,
   };
   static const uint8_t kRepToAlign64[] = {
       [kUpb_FieldRep_1Byte] = 1,
       [kUpb_FieldRep_4Byte] = 4,
-      [kUpb_FieldRep_StringView] = 8,
+      [kUpb_FieldRep_StringView] = string_view_align_64,
       [kUpb_FieldRep_8Byte] = 8,
   };
-  UPB_ASSERT(UPB_ALIGN_OF(upb_StringView) ==
-             UPB_SIZE(kRepToAlign32, kRepToAlign64)[kUpb_FieldRep_StringView]);
   return platform == kUpb_MiniTablePlatform_32Bit ? kRepToAlign32[rep]
                                                   : kRepToAlign64[rep];
 }
@@ -323,7 +354,7 @@ static const char* upb_MtDecoder_DecodeOneofField(upb_MtDecoder* d,
       &d->base, ptr, first_ch, kUpb_EncodedValue_MinOneofField,
       kUpb_EncodedValue_MaxOneofField, &field_num);
   upb_MiniTableField* f =
-      (void*)upb_MiniTable_FindFieldByNumber(d->table, field_num);
+      (void*)upb_MiniTable_FindFieldByNumber(&d->table, field_num);
 
   if (!f) {
     upb_MdDecoder_ErrorJmp(&d->base,
@@ -393,7 +424,7 @@ static const char* upb_MtDecoder_ParseModifier(upb_MtDecoder* d,
   if (last_field) {
     upb_MtDecoder_ModifyField(d, *msg_modifiers, mod, last_field);
   } else {
-    if (!d->table) {
+    if (d->is_extension) {
       upb_MdDecoder_ErrorJmp(&d->base,
                              "Extensions cannot have message modifiers");
     }
@@ -403,15 +434,21 @@ static const char* upb_MtDecoder_ParseModifier(upb_MtDecoder* d,
   return ptr;
 }
 
+static void* upb_MtDecoder_CheckedMalloc(upb_MtDecoder* d, size_t size) {
+  void* ptr = upb_Arena_Malloc(d->arena, size);
+  upb_MdDecoder_CheckOutOfMemory(&d->base, ptr);
+  return ptr;
+}
+
 static void upb_MtDecoder_AllocateSubs(upb_MtDecoder* d,
                                        upb_SubCounts sub_counts) {
   uint32_t total_count = sub_counts.submsg_count + sub_counts.subenum_count;
-  size_t subs_bytes = sizeof(*d->table->UPB_PRIVATE(subs)) * total_count;
+  size_t subs_bytes = sizeof(*d->table.UPB_PRIVATE(subs)) * total_count;
   size_t ptrs_bytes = sizeof(upb_MiniTable*) * sub_counts.submsg_count;
-  upb_MiniTableSubInternal* subs = upb_Arena_Malloc(d->arena, subs_bytes);
-  const upb_MiniTable** subs_ptrs = upb_Arena_Malloc(d->arena, ptrs_bytes);
-  upb_MdDecoder_CheckOutOfMemory(&d->base, subs);
-  upb_MdDecoder_CheckOutOfMemory(&d->base, subs_ptrs);
+  upb_MiniTableSubInternal* subs =
+      subs_bytes ? upb_MtDecoder_CheckedMalloc(d, subs_bytes) : NULL;
+  const upb_MiniTable** subs_ptrs =
+      ptrs_bytes ? upb_MtDecoder_CheckedMalloc(d, ptrs_bytes) : NULL;
   uint32_t i = 0;
   for (; i < sub_counts.submsg_count; i++) {
     subs_ptrs[i] = UPB_PRIVATE(_upb_MiniTable_Empty)();
@@ -419,7 +456,7 @@ static void upb_MtDecoder_AllocateSubs(upb_MtDecoder* d,
   }
   if (sub_counts.subenum_count) {
     upb_MiniTableField* f = d->fields;
-    upb_MiniTableField* end_f = f + d->table->UPB_PRIVATE(field_count);
+    upb_MiniTableField* end_f = f + d->table.UPB_PRIVATE(field_count);
     for (; f < end_f; f++) {
       if (f->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Enum) {
         f->UPB_PRIVATE(submsg_index) += sub_counts.submsg_count;
@@ -429,7 +466,7 @@ static void upb_MtDecoder_AllocateSubs(upb_MtDecoder* d,
       subs[i].UPB_PRIVATE(subenum) = NULL;
     }
   }
-  d->table->UPB_PRIVATE(subs) = subs;
+  d->table.UPB_PRIVATE(subs) = subs;
 }
 
 static const char* upb_MtDecoder_Parse(upb_MtDecoder* d, const char* ptr,
@@ -439,38 +476,43 @@ static const char* upb_MtDecoder_Parse(upb_MtDecoder* d, const char* ptr,
   uint64_t msg_modifiers = 0;
   uint32_t last_field_number = 0;
   upb_MiniTableField* last_field = NULL;
-  bool need_dense_below = d->table != NULL;
+  bool need_dense_below = !d->is_extension;
 
   d->base.end = UPB_PTRADD(ptr, len);
 
   while (ptr < d->base.end) {
     char ch = *ptr++;
     if (ch <= kUpb_EncodedValue_MaxField) {
-      if (!d->table && last_field) {
+      if (d->is_extension && last_field) {
         // For extensions, consume only a single field and then return.
         return --ptr;
       }
       upb_MiniTableField* field = fields;
       *field_count += 1;
       fields = (char*)fields + field_size;
-      field->UPB_PRIVATE(number) = ++last_field_number;
+      uint32_t number = ++last_field_number;
+      if (number == 0 || (number > kUpb_MaxFieldNumber && !d->is_extension)) {
+        upb_MdDecoder_ErrorJmp(&d->base, "Invalid field number: %" PRIu32,
+                               number);
+      }
+      field->UPB_PRIVATE(number) = number;
       last_field = field;
       upb_MiniTable_SetField(d, ch, field, msg_modifiers, sub_counts);
     } else if (kUpb_EncodedValue_MinModifier <= ch &&
                ch <= kUpb_EncodedValue_MaxModifier) {
       ptr = upb_MtDecoder_ParseModifier(d, ptr, ch, last_field, &msg_modifiers);
       if (msg_modifiers & kUpb_MessageModifier_IsExtendable) {
-        d->table->UPB_PRIVATE(ext) |= kUpb_ExtMode_Extendable;
+        d->table.UPB_PRIVATE(ext) |= kUpb_ExtMode_Extendable;
       }
     } else if (ch == kUpb_EncodedValue_End) {
-      if (!d->table) {
+      if (d->is_extension) {
         upb_MdDecoder_ErrorJmp(&d->base, "Extensions cannot have oneofs.");
       }
       ptr = upb_MtDecoder_DecodeOneofs(d, ptr);
     } else if (kUpb_EncodedValue_MinSkip <= ch &&
                ch <= kUpb_EncodedValue_MaxSkip) {
       if (need_dense_below) {
-        d->table->UPB_PRIVATE(dense_below) = d->table->UPB_PRIVATE(field_count);
+        d->table.UPB_PRIVATE(dense_below) = d->table.UPB_PRIVATE(field_count);
         need_dense_below = false;
       }
       uint32_t skip;
@@ -485,7 +527,7 @@ static const char* upb_MtDecoder_Parse(upb_MtDecoder* d, const char* ptr,
   }
 
   if (need_dense_below) {
-    d->table->UPB_PRIVATE(dense_below) = d->table->UPB_PRIVATE(field_count);
+    d->table.UPB_PRIVATE(dense_below) = d->table.UPB_PRIVATE(field_count);
   }
 
   return ptr;
@@ -502,20 +544,20 @@ static void upb_MtDecoder_ParseMessage(upb_MtDecoder* d, const char* data,
   upb_MdDecoder_CheckOutOfMemory(&d->base, d->fields);
 
   upb_SubCounts sub_counts = {0, 0};
-  d->table->UPB_PRIVATE(field_count) = 0;
-  d->table->UPB_PRIVATE(fields) = d->fields;
+  d->table.UPB_PRIVATE(field_count) = 0;
+  d->table.UPB_PRIVATE(fields) = d->fields;
   upb_MtDecoder_Parse(d, data, len, d->fields, sizeof(*d->fields),
-                      &d->table->UPB_PRIVATE(field_count), &sub_counts);
+                      &d->table.UPB_PRIVATE(field_count), &sub_counts);
 
   upb_Arena_ShrinkLast(d->arena, d->fields, sizeof(*d->fields) * len,
-                       sizeof(*d->fields) * d->table->UPB_PRIVATE(field_count));
-  d->table->UPB_PRIVATE(fields) = d->fields;
+                       sizeof(*d->fields) * d->table.UPB_PRIVATE(field_count));
+  d->table.UPB_PRIVATE(fields) = d->fields;
   upb_MtDecoder_AllocateSubs(d, sub_counts);
 }
 
 static void upb_MtDecoder_CalculateAlignments(upb_MtDecoder* d) {
   // Add alignment counts for non-oneof fields (oneofs were added already)
-  int n = d->table->UPB_PRIVATE(field_count);
+  int n = d->table.UPB_PRIVATE(field_count);
   for (int i = 0; i < n; i++) {
     upb_MiniTableField* f = &d->fields[i];
     if (f->UPB_PRIVATE(offset) >= kOneofBase) continue;
@@ -525,7 +567,7 @@ static void upb_MtDecoder_CalculateAlignments(upb_MtDecoder* d) {
   // Reserve properly aligned space for each type of field representation
   // present in this message. When we iterate over the fields, they will obtain
   // their offset from within the region matching their alignment requirements.
-  size_t base = d->table->UPB_PRIVATE(size);
+  size_t base = d->table.UPB_PRIVATE(size);
   // Start with the lowest alignment requirement, going up, because:
   // 1. If there are presence bits, we won't be aligned to start, but adding
   //    some lower-alignment fields may get us closer without wasting space to
@@ -548,7 +590,7 @@ static void upb_MtDecoder_CalculateAlignments(upb_MtDecoder* d) {
     upb_MdDecoder_ErrorJmp(
         &d->base, "Message size exceeded maximum size of %zu bytes", max);
   }
-  d->table->UPB_PRIVATE(size) = (uint16_t)base;
+  d->table.UPB_PRIVATE(size) = (uint16_t)base;
 }
 
 static size_t upb_MiniTable_DivideRoundUp(size_t n, size_t d) {
@@ -556,14 +598,13 @@ static size_t upb_MiniTable_DivideRoundUp(size_t n, size_t d) {
 }
 
 static void upb_MtDecoder_AssignHasbits(upb_MtDecoder* d) {
-  upb_MiniTable* ret = d->table;
-  int n = ret->UPB_PRIVATE(field_count);
+  int n = d->table.UPB_PRIVATE(field_count);
   size_t last_hasbit = kUpb_Reserved_Hasbits - 1;
 
   // First assign required fields, which must have the lowest hasbits.
   for (int i = 0; i < n; i++) {
     upb_MiniTableField* field =
-        (upb_MiniTableField*)&ret->UPB_PRIVATE(fields)[i];
+        (upb_MiniTableField*)&d->table.UPB_PRIVATE(fields)[i];
     if (field->UPB_PRIVATE(offset) == kRequiredPresence) {
       field->presence = ++last_hasbit;
     } else if (field->UPB_PRIVATE(offset) == kNoPresence) {
@@ -574,18 +615,19 @@ static void upb_MtDecoder_AssignHasbits(upb_MtDecoder* d) {
     upb_MdDecoder_ErrorJmp(&d->base, "Too many required fields");
   }
 
-  ret->UPB_PRIVATE(required_count) = last_hasbit - (kUpb_Reserved_Hasbits - 1);
+  d->table.UPB_PRIVATE(required_count) =
+      last_hasbit - (kUpb_Reserved_Hasbits - 1);
 
   // Next assign non-required hasbit fields.
   for (int i = 0; i < n; i++) {
     upb_MiniTableField* field =
-        (upb_MiniTableField*)&ret->UPB_PRIVATE(fields)[i];
+        (upb_MiniTableField*)&d->table.UPB_PRIVATE(fields)[i];
     if (field->UPB_PRIVATE(offset) == kHasbitPresence) {
       field->presence = ++last_hasbit;
     }
   }
 
-  ret->UPB_PRIVATE(size) =
+  d->table.UPB_PRIVATE(size) =
       last_hasbit ? upb_MiniTable_DivideRoundUp(last_hasbit + 1, 8) : 0;
 }
 
@@ -598,7 +640,7 @@ static size_t upb_MtDecoder_Place(upb_MtDecoder* d, upb_FieldRep rep) {
 
 static void upb_MtDecoder_AssignOffsets(upb_MtDecoder* d) {
   upb_MiniTableField* field_end =
-      UPB_PTRADD(d->fields, d->table->UPB_PRIVATE(field_count));
+      UPB_PTRADD(d->fields, d->table.UPB_PRIVATE(field_count));
   for (upb_MiniTableField* field = d->fields; field < field_end; field++) {
     if (field->UPB_PRIVATE(offset) >= kOneofBase) continue;
     field->UPB_PRIVATE(offset) =
@@ -616,17 +658,18 @@ static void upb_MtDecoder_AssignOffsets(upb_MtDecoder* d) {
       uint16_t next_offset = f->UPB_PRIVATE(offset);
       f->UPB_PRIVATE(offset) = data_offset;
       if (next_offset == kUpb_OneOfLayoutItem_IndexSentinel) break;
-      UPB_ASSERT(next_offset - kOneofBase < d->table->UPB_PRIVATE(field_count));
+      UPB_ASSERT(next_offset - kOneofBase < d->table.UPB_PRIVATE(field_count));
       f = &d->fields[next_offset - kOneofBase];
     }
   }
 
-  // The fasttable parser (supported on 64-bit only) depends on this being a
-  // multiple of 8 in order to satisfy UPB_MALLOC_ALIGN, which is also 8.
-  //
-  // On 32-bit we could potentially make this smaller, but there is no
-  // compelling reason to optimize this right now.
-  d->table->UPB_PRIVATE(size) = UPB_ALIGN_UP(d->table->UPB_PRIVATE(size), 8);
+  // Since messages are always allocated on arenas, we can save repeatedly
+  // realigning by doing alignment at minitable construction time. We don't want
+  // to align to UPB_MALLOC_ALIGN because it can change with sanitizers, and if
+  // we're generating code we don't want to calculate size differently depending
+  // on the proto compiler's host or build configuration.
+  d->table.UPB_PRIVATE(size) =
+      UPB_ALIGN_UP(d->table.UPB_PRIVATE(size), kUpb_Message_Align);
 }
 
 static void upb_MtDecoder_ValidateEntryField(upb_MtDecoder* d,
@@ -665,9 +708,9 @@ static void upb_MtDecoder_ParseMap(upb_MtDecoder* d, const char* data,
   upb_MtDecoder_ParseMessage(d, data, len);
   upb_MtDecoder_AssignHasbits(d);
 
-  if (UPB_UNLIKELY(d->table->UPB_PRIVATE(field_count) != 2)) {
+  if (UPB_UNLIKELY(d->table.UPB_PRIVATE(field_count) != 2)) {
     upb_MdDecoder_ErrorJmp(&d->base, "%hu fields in map",
-                           d->table->UPB_PRIVATE(field_count));
+                           d->table.UPB_PRIVATE(field_count));
     UPB_UNREACHABLE();
   }
 
@@ -675,16 +718,16 @@ static void upb_MtDecoder_ParseMap(upb_MtDecoder* d, const char* data,
     upb_MdDecoder_ErrorJmp(&d->base, "Map entry cannot have oneof");
   }
 
-  upb_MtDecoder_ValidateEntryField(d, &d->table->UPB_PRIVATE(fields)[0], 1);
-  upb_MtDecoder_ValidateEntryField(d, &d->table->UPB_PRIVATE(fields)[1], 2);
+  upb_MtDecoder_ValidateEntryField(d, &d->table.UPB_PRIVATE(fields)[0], 1);
+  upb_MtDecoder_ValidateEntryField(d, &d->table.UPB_PRIVATE(fields)[1], 2);
 
   d->fields[0].UPB_PRIVATE(offset) = offsetof(upb_MapEntry, k);
   d->fields[1].UPB_PRIVATE(offset) = offsetof(upb_MapEntry, v);
-  d->table->UPB_PRIVATE(size) = sizeof(upb_MapEntry);
+  d->table.UPB_PRIVATE(size) = sizeof(upb_MapEntry);
 
   // Map entries have a special bit set to signal it's a map entry, used in
   // upb_MiniTable_SetSubMessage() below.
-  d->table->UPB_PRIVATE(ext) |= kUpb_ExtMode_IsMapEntry;
+  d->table.UPB_PRIVATE(ext) |= kUpb_ExtMode_IsMapEntry;
 }
 
 static void upb_MtDecoder_ParseMessageSet(upb_MtDecoder* d, const char* data,
@@ -694,7 +737,7 @@ static void upb_MtDecoder_ParseMessageSet(upb_MtDecoder* d, const char* data,
                            len);
   }
 
-  upb_MiniTable* ret = d->table;
+  upb_MiniTable* ret = &d->table;
   ret->UPB_PRIVATE(size) = kUpb_Reserved_Hasbytes;
   ret->UPB_PRIVATE(field_count) = 0;
   ret->UPB_PRIVATE(ext) = kUpb_ExtMode_IsMessageSet;
@@ -706,18 +749,16 @@ static void upb_MtDecoder_ParseMessageSet(upb_MtDecoder* d, const char* data,
 static upb_MiniTable* upb_MtDecoder_DoBuildMiniTableWithBuf(
     upb_MtDecoder* decoder, const char* data, size_t len, void** buf,
     size_t* buf_size) {
-  upb_MdDecoder_CheckOutOfMemory(&decoder->base, decoder->table);
-
-  decoder->table->UPB_PRIVATE(size) = kUpb_Reserved_Hasbytes;
-  decoder->table->UPB_PRIVATE(field_count) = 0;
-  decoder->table->UPB_PRIVATE(ext) = kUpb_ExtMode_NonExtendable;
-  decoder->table->UPB_PRIVATE(dense_below) = 0;
-  decoder->table->UPB_PRIVATE(table_mask) = -1;
-  decoder->table->UPB_PRIVATE(required_count) = 0;
+  decoder->table.UPB_PRIVATE(size) = kUpb_Reserved_Hasbytes;
+  decoder->table.UPB_PRIVATE(field_count) = 0;
+  decoder->table.UPB_PRIVATE(ext) = kUpb_ExtMode_NonExtendable;
+  decoder->table.UPB_PRIVATE(dense_below) = 0;
+  decoder->table.UPB_PRIVATE(table_mask) = -1;
+  decoder->table.UPB_PRIVATE(required_count) = 0;
 #ifdef UPB_TRACING_ENABLED
   // MiniTables built from MiniDescriptors will not be able to vend the message
   // name unless it is explicitly set with upb_MiniTable_SetFullName().
-  decoder->table->UPB_PRIVATE(full_name) = 0;
+  decoder->table.UPB_PRIVATE(full_name) = 0;
 #endif
 
   // Strip off and verify the version tag.
@@ -748,7 +789,27 @@ static upb_MiniTable* upb_MtDecoder_DoBuildMiniTableWithBuf(
 done:
   *buf = decoder->oneofs.data;
   *buf_size = decoder->oneofs.buf_capacity_bytes;
-  return decoder->table;
+  size_t mt_size = sizeof(upb_MiniTable);
+
+#if UPB_FASTTABLE
+  upb_DecodeFast_TableEntry fasttable[32];
+  int fasttable_size = upb_DecodeFast_BuildTable(&decoder->table, fasttable);
+  mt_size += fasttable_size * sizeof(fasttable[0]);
+#endif
+
+  upb_MiniTable* ret = upb_Arena_Malloc(decoder->arena, mt_size);
+  memcpy(ret, &decoder->table, sizeof(*ret));
+
+#if UPB_FASTTABLE
+  ret->UPB_PRIVATE(table_mask) = upb_DecodeFast_GetTableMask(fasttable_size);
+  for (int i = 0; i < fasttable_size; i++) {
+    ret->UPB_PRIVATE(fasttable)[i].field_data = fasttable[i].function_data;
+    ret->UPB_PRIVATE(fasttable)[i].field_parser =
+        upb_DecodeFast_GetFunctionPointer(fasttable[i].function_idx);
+  }
+#endif
+  UPB_PRIVATE(upb_MiniTable_CheckInvariants)(ret);
+  return ret;
 }
 
 static upb_MiniTable* upb_MtDecoder_BuildMiniTableWithBuf(
@@ -772,6 +833,7 @@ upb_MiniTable* upb_MiniTable_BuildWithBuf(const char* data, size_t len,
   upb_MtDecoder decoder = {
       .base = {.status = status},
       .platform = platform,
+      .is_extension = false,
       .oneofs =
           {
               .data = *buf,
@@ -779,7 +841,6 @@ upb_MiniTable* upb_MiniTable_BuildWithBuf(const char* data, size_t len,
               .size = 0,
           },
       .arena = arena,
-      .table = upb_Arena_Malloc(arena, sizeof(*decoder.table)),
   };
 
   return upb_MtDecoder_BuildMiniTableWithBuf(&decoder, data, len, buf,
@@ -848,8 +909,8 @@ const char* _upb_MiniTableExtension_Init(const char* data, size_t len,
   upb_MtDecoder decoder = {
       .base = {.status = status},
       .arena = NULL,
-      .table = NULL,
       .platform = platform,
+      .is_extension = true,
   };
 
   return upb_MtDecoder_BuildMiniTableExtension(&decoder, data, len, ext,

data/third_party/upb/upb/mini_descriptor/decode.h

@@ -8,9 +8,13 @@
 #ifndef UPB_MINI_TABLE_DECODE_H_
 #define UPB_MINI_TABLE_DECODE_H_
 
+#include <stddef.h>
+
 #include "upb/base/status.h"
 #include "upb/mem/arena.h"
+#include "upb/mini_table/enum.h"
 #include "upb/mini_table/extension.h"
+#include "upb/mini_table/message.h"
 #include "upb/mini_table/sub.h"
 
 // Export the newer headers, for legacy users.  New users should include the
@@ -81,7 +85,7 @@ UPB_API_INLINE upb_MiniTableExtension* upb_MiniTableExtension_Build(
 
 UPB_API_INLINE upb_MiniTableExtension* upb_MiniTableExtension_BuildMessage(
     const char* data, size_t len, const upb_MiniTable* extendee,
-    upb_MiniTable* submsg, upb_Arena* arena, upb_Status* status) {
+    const upb_MiniTable* submsg, upb_Arena* arena, upb_Status* status) {
   upb_MiniTableSub sub = upb_MiniTableSub_FromMessage(submsg);
   return _upb_MiniTableExtension_Build(
       data, len, extendee, sub, kUpb_MiniTablePlatform_Native, arena, status);
@@ -89,7 +93,7 @@ UPB_API_INLINE upb_MiniTableExtension* upb_MiniTableExtension_BuildMessage(
 
 UPB_API_INLINE upb_MiniTableExtension* upb_MiniTableExtension_BuildEnum(
     const char* data, size_t len, const upb_MiniTable* extendee,
-    upb_MiniTableEnum* subenum, upb_Arena* arena, upb_Status* status) {
+    const upb_MiniTableEnum* subenum, upb_Arena* arena, upb_Status* status) {
   upb_MiniTableSub sub = upb_MiniTableSub_FromEnum(subenum);
   return _upb_MiniTableExtension_Build(
       data, len, extendee, sub, kUpb_MiniTablePlatform_Native, arena, status);

data/third_party/upb/upb/mini_descriptor/internal/encode.hpp

@@ -8,8 +8,10 @@
 #ifndef UPB_MINI_TABLE_ENCODE_INTERNAL_HPP_
 #define UPB_MINI_TABLE_ENCODE_INTERNAL_HPP_
 
+#include <cstdint>
 #include <string>
 
+#include "upb/base/descriptor_constants.h"
 #include "upb/base/internal/log2.h"
 #include "upb/mini_descriptor/internal/encode.h"
 

data/third_party/upb/upb/mini_descriptor/link.c

@@ -74,6 +74,17 @@ bool upb_MiniTable_SetSubEnum(upb_MiniTable* table, upb_MiniTableField* field,
     return false;
   }
 
+  if ((table->UPB_PRIVATE(ext) & kUpb_ExtMode_IsMapEntry) &&
+      !upb_MiniTableEnum_CheckValue(sub, 0)) {
+    // An enum used in a map must include 0 as a value.  This matches a check
+    // performed in protoc ("Enum value in map must define 0 as the first
+    // value").  Protoc should ensure that we never get here.
+    //
+    // This ends up being important if we receive wire messages where a map
+    // entry omits the value (and thus defaults to 0).
+    return false;
+  }
+
   upb_MiniTableSub* table_sub =
       (void*)&table->UPB_PRIVATE(subs)[field->UPB_PRIVATE(submsg_index)];
   *table_sub = upb_MiniTableSub_FromEnum(sub);

data/third_party/upb/upb/mini_table/extension.h

@@ -12,6 +12,7 @@
 
 #include "upb/base/descriptor_constants.h"
 #include "upb/mini_table/enum.h"
+#include "upb/mini_table/field.h"
 #include "upb/mini_table/internal/extension.h"
 #include "upb/mini_table/message.h"
 
@@ -30,6 +31,9 @@ upb_MiniTableExtension_CType(const upb_MiniTableExtension* e);
 UPB_API_INLINE uint32_t
 upb_MiniTableExtension_Number(const upb_MiniTableExtension* e);
 
+UPB_API_INLINE const upb_MiniTable* upb_MiniTableExtension_Extendee(
+    const upb_MiniTableExtension* e);
+
 UPB_API_INLINE const upb_MiniTable* upb_MiniTableExtension_GetSubMessage(
     const upb_MiniTableExtension* e);
 
@@ -42,6 +46,9 @@ UPB_API_INLINE bool upb_MiniTableExtension_SetSubMessage(
 UPB_API_INLINE bool upb_MiniTableExtension_SetSubEnum(
     upb_MiniTableExtension* e, const upb_MiniTableEnum* m);
 
+UPB_API_INLINE const upb_MiniTableField* upb_MiniTableExtension_ToField(
+    const upb_MiniTableExtension* e);
+
 #ifdef __cplusplus
 } /* extern "C" */
 #endif

data/third_party/upb/upb/mini_table/extension_registry.c

@@ -42,8 +42,17 @@ upb_ExtensionRegistry* upb_ExtensionRegistry_New(upb_Arena* arena) {
 
 UPB_API upb_ExtensionRegistryStatus upb_ExtensionRegistry_Add(
     upb_ExtensionRegistry* r, const upb_MiniTableExtension* e) {
+  uint32_t fieldnum = upb_MiniTableExtension_Number(e);
+  const upb_MiniTable* extendee = upb_MiniTableExtension_Extendee(e);
+
+  const uint32_t kMaxFieldNumber = (1 << 29) - 1;
+  if (fieldnum == 0 ||
+      (fieldnum > kMaxFieldNumber && !upb_MiniTable_IsMessageSet(extendee))) {
+    return kUpb_ExtensionRegistryStatus_InvalidExtension;
+  }
+
   char buf[EXTREG_KEY_SIZE];
-  extreg_key(buf, e->UPB_PRIVATE(extendee), upb_MiniTableExtension_Number(e));
+  extreg_key(buf, extendee, fieldnum);
 
   if (upb_strtable_lookup2(&r->exts, buf, EXTREG_KEY_SIZE, NULL)) {
     return kUpb_ExtensionRegistryStatus_DuplicateEntry;

data/third_party/upb/upb/mini_table/extension_registry.h

@@ -62,6 +62,7 @@ typedef enum {
   kUpb_ExtensionRegistryStatus_Ok = 0,
   kUpb_ExtensionRegistryStatus_DuplicateEntry = 1,
   kUpb_ExtensionRegistryStatus_OutOfMemory = 2,
+  kUpb_ExtensionRegistryStatus_InvalidExtension = 3,
 } upb_ExtensionRegistryStatus;
 
 // Creates a upb_ExtensionRegistry in the given arena.

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

@@ -40,6 +40,11 @@ upb_MiniTableExtension_Number(const struct upb_MiniTableExtension* e) {
   return e->UPB_PRIVATE(field).UPB_ONLYBITS(number);
 }
 
+UPB_API_INLINE const struct upb_MiniTable* upb_MiniTableExtension_Extendee(
+    const struct upb_MiniTableExtension* e) {
+  return e->UPB_PRIVATE(extendee);
+}
+
 UPB_API_INLINE const struct upb_MiniTable* upb_MiniTableExtension_GetSubMessage(
     const struct upb_MiniTableExtension* e) {
   if (upb_MiniTableExtension_CType(e) != kUpb_CType_Message) {
@@ -76,6 +81,11 @@ UPB_API_INLINE bool upb_MiniTableExtension_SetSubEnum(
   return true;
 }
 
+UPB_API_INLINE const upb_MiniTableField* upb_MiniTableExtension_ToField(
+    const struct upb_MiniTableExtension* e) {
+  return &e->UPB_PRIVATE(field);
+}
+
 UPB_INLINE upb_FieldRep UPB_PRIVATE(_upb_MiniTableExtension_GetRep)(
     const struct upb_MiniTableExtension* e) {
   return UPB_PRIVATE(_upb_MiniTableField_GetRep)(&e->UPB_PRIVATE(field));

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

@@ -139,7 +139,7 @@ UPB_INLINE char UPB_PRIVATE(_upb_MiniTableField_HasbitMask)(
     const struct upb_MiniTableField* f) {
   UPB_ASSERT(UPB_PRIVATE(_upb_MiniTableField_HasHasbit)(f));
   const uint16_t index = f->presence;
-  return 1 << (index % 8);
+  return (char)(1 << (index % 8));
 }
 
 UPB_INLINE uint16_t UPB_PRIVATE(_upb_MiniTableField_HasbitOffset)(