Fasttable: normalized the calling convention

After this CL, fasttable functions always take `upb_DecodeFastNext` as a parameter, instead of having some functions return it.

This helps functions compose more easily, since all functions follow the same calling convention.

Also simplified and normalized the set of `upb_DecodeFastNext` values.

PiperOrigin-RevId: 768667743

Author: haberman

upb/wire/decode_fast/cardinality.h

@@ -371,14 +371,14 @@ bool upb_DecodeFast_DoNextRepeated(upb_Decoder* d, const char** ptr,
 
   if (!upb_DecodeFast_TagMatches(field->expected_tag, tag, tagsize)) {
     // A different tag is encountered; perform regular dispatch.
-    return UPB_DECODEFAST_EXIT(kUpb_DecodeFastNext_TailCallDispatch, next);
+    return UPB_DECODEFAST_EXIT(kUpb_DecodeFastNext_Dispatch, next);
   }
 
   field->dst = UPB_PTR_AT(field->dst, upb_DecodeFast_ValueBytes(type), char);
 
   if (field->dst == field->end) {
     // Out of arena memory; fall back to MiniTable decoder which will realloc.
-    return UPB_DECODEFAST_EXIT(kUpb_DecodeFastNext_Return, next);
+    return UPB_DECODEFAST_EXIT(kUpb_DecodeFastNext_FallbackToMiniTable, next);
   }
 
   // Parse another instance of the repeated field.
@@ -394,7 +394,7 @@ bool upb_DecodeFast_NextRepeated(upb_Decoder* d, const char** ptr,
                                  upb_DecodeFast_TagSize tagsize) {
   if (!upb_DecodeFast_IsRepeated(card)) {
     // No repetition is possible; perform regular dispatch.
-    *next = kUpb_DecodeFastNext_TailCallDispatch;
+    *next = kUpb_DecodeFastNext_Dispatch;
     return false;
   }
 

upb/wire/decode_fast/dispatch.h

@@ -160,20 +160,17 @@ void upb_DecodeFast_SetHasbits(upb_Message* msg, uint64_t hasbits) {
 }
 
 typedef enum {
-  // Call the dispatch function using musttail.
-  kUpb_DecodeFastNext_TailCallDispatch = 0,
+  kUpb_DecodeFastNext_Dispatch = 0,
 
-  // Return from the function with no tail call. This is used either to signal
-  // a fallback to the mini table or the end of the message if
-  // d->message_is_done is true.
-  kUpb_DecodeFastNext_Return = 1,
+  // Fallback to the MiniTable decoder. This is used either to signal a fallback
+  // to the mini table or the end of the message if d->message_is_done is true.
+  kUpb_DecodeFastNext_FallbackToMiniTable = 1,
 
+  // Signal an error.
   kUpb_DecodeFastNext_Error = 2,
 
-  // Alias for clarity in the code.
-  kUpb_DecodeFastNext_FallbackToMiniTable = kUpb_DecodeFastNext_Return,
-
-  // Tail call to the function to parse the current field.
+  // Handle the case where ptr >= limit, which is either end-of-message or
+  // end-of-buffer.
   kUpb_DecodeFastNext_MessageIsDoneFallback = 3,
 
   // Tail call to the function to parse the current field, except parse it as
@@ -202,26 +199,25 @@ const char* _upb_FastDecoder_ErrorJmp(upb_Decoder* d, upb_DecodeStatus status) {
   return _upb_FastDecoder_ErrorJmp2(d);
 }
 
-#define UPB_DECODEFAST_NEXTMAYBEPACKED(next, func_unpacked, func_packed)    \
-  if (UPB_UNLIKELY(next != kUpb_DecodeFastNext_TailCallDispatch)) {         \
-    switch (next) {                                                         \
-      case kUpb_DecodeFastNext_Return:                                      \
-        UPB_MUSTTAIL return _upb_FastDecoder_DecodeGeneric(UPB_PARSE_ARGS); \
-      case kUpb_DecodeFastNext_Error:                                       \
-        UPB_ASSERT(d->status != kUpb_DecodeStatus_Ok);                      \
-        return _upb_FastDecoder_ErrorJmp2(d);                               \
-      case kUpb_DecodeFastNext_MessageIsDoneFallback:                       \
-        UPB_MUSTTAIL return upb_DecodeFast_MessageIsDoneFallback(           \
-            UPB_PARSE_ARGS);                                                \
-      case kUpb_DecodeFastNext_TailCallPacked:                              \
-        UPB_MUSTTAIL return func_packed(UPB_PARSE_ARGS);                    \
-      case kUpb_DecodeFastNext_TailCallUnpacked:                            \
-        UPB_MUSTTAIL return func_unpacked(UPB_PARSE_ARGS);                  \
-      default:                                                              \
-        UPB_UNREACHABLE();                                                  \
-    }                                                                       \
-  }                                                                         \
-  UPB_MUSTTAIL return upb_DecodeFast_Dispatch(UPB_PARSE_ARGS);
+#define UPB_DECODEFAST_NEXTMAYBEPACKED(next, func_unpacked, func_packed)  \
+  switch (next) {                                                         \
+    case kUpb_DecodeFastNext_Dispatch:                                    \
+      UPB_MUSTTAIL return upb_DecodeFast_Dispatch(UPB_PARSE_ARGS);        \
+    case kUpb_DecodeFastNext_FallbackToMiniTable:                         \
+      UPB_MUSTTAIL return _upb_FastDecoder_DecodeGeneric(UPB_PARSE_ARGS); \
+    case kUpb_DecodeFastNext_Error:                                       \
+      UPB_ASSERT(d->status != kUpb_DecodeStatus_Ok);                      \
+      return _upb_FastDecoder_ErrorJmp2(d);                               \
+    case kUpb_DecodeFastNext_MessageIsDoneFallback:                       \
+      UPB_MUSTTAIL return upb_DecodeFast_MessageIsDoneFallback(           \
+          UPB_PARSE_ARGS);                                                \
+    case kUpb_DecodeFastNext_TailCallPacked:                              \
+      UPB_MUSTTAIL return func_packed(UPB_PARSE_ARGS);                    \
+    case kUpb_DecodeFastNext_TailCallUnpacked:                            \
+      UPB_MUSTTAIL return func_unpacked(UPB_PARSE_ARGS);                  \
+    default:                                                              \
+      UPB_UNREACHABLE();                                                  \
+  }
 
 // Uncomment this to see the exit points from the fast decoder.
 // #define UPB_LOG_EXITS

upb/wire/decode_fast/field_fixed.c

@@ -22,43 +22,40 @@
 #include "upb/port/def.inc"
 
 UPB_FORCEINLINE
-int upb_DecodeFast_UnpackedFixed(upb_Decoder* d, const char** ptr,
-                                 upb_Message* msg, intptr_t table,
-                                 uint64_t* hasbits, uint64_t* data,
-                                 upb_DecodeFast_Type type,
-                                 upb_DecodeFast_Cardinality card,
-                                 upb_DecodeFast_TagSize tagsize) {
-  upb_DecodeFastNext ret;
+void upb_DecodeFast_UnpackedFixed(upb_Decoder* d, const char** ptr,
+                                  upb_Message* msg, intptr_t table,
+                                  uint64_t* hasbits, uint64_t* data,
+                                  upb_DecodeFastNext* ret,
+                                  upb_DecodeFast_Type type,
+                                  upb_DecodeFast_Cardinality card,
+                                  upb_DecodeFast_TagSize tagsize) {
   upb_DecodeFastField field;
   int valbytes = upb_DecodeFast_ValueBytes(type);
 
-  if (!upb_DecodeFast_CheckPackableTag(type, card, tagsize, data,
-                                       kUpb_DecodeFastNext_TailCallPacked,
-                                       &ret) ||
-      !Upb_DecodeFast_GetField(d, *ptr, msg, *data, hasbits, &ret, &field, type,
+  if (!upb_DecodeFast_CheckPackableTag(
+          type, card, tagsize, data, kUpb_DecodeFastNext_TailCallPacked, ret) ||
+      !Upb_DecodeFast_GetField(d, *ptr, msg, *data, hasbits, ret, &field, type,
                                card)) {
-    return ret;
+    return;
   }
 
   do {
     *ptr += upb_DecodeFast_TagSizeBytes(tagsize);
     memcpy(field.dst, *ptr, valbytes);
     *ptr += valbytes;
     _upb_Decoder_Trace(d, 'F');
-  } while (upb_DecodeFast_NextRepeated(d, ptr, *data, &ret, &field, type, card,
+  } while (upb_DecodeFast_NextRepeated(d, ptr, *data, ret, &field, type, card,
                                        tagsize));
-
-  return kUpb_DecodeFastNext_TailCallDispatch;
 }
 
 UPB_FORCEINLINE
-int upb_DecodeFast_PackedFixed(upb_Decoder* d, const char** ptr,
-                               upb_Message* msg, intptr_t table,
-                               uint64_t* hasbits, uint64_t* data,
-                               upb_DecodeFast_Type type,
-                               upb_DecodeFast_Cardinality card,
-                               upb_DecodeFast_TagSize tagsize) {
-  upb_DecodeFastNext ret;
+void upb_DecodeFast_PackedFixed(upb_Decoder* d, const char** ptr,
+                                upb_Message* msg, intptr_t table,
+                                uint64_t* hasbits, uint64_t* data,
+                                upb_DecodeFastNext* ret,
+                                upb_DecodeFast_Type type,
+                                upb_DecodeFast_Cardinality card,
+                                upb_DecodeFast_TagSize tagsize) {
   int size;
   upb_DecodeFastField field;
   uint8_t valbytes = upb_DecodeFast_ValueBytes(type);
@@ -67,21 +64,21 @@ int upb_DecodeFast_PackedFixed(upb_Decoder* d, const char** ptr,
 
   if (!upb_DecodeFast_CheckPackableTag(type, card, tagsize, data,
                                        kUpb_DecodeFastNext_TailCallUnpacked,
-                                       &ret) ||
+                                       ret) ||
       !upb_DecodeFast_DecodeShortSizeForImmediateRead(d, &data_ptr, &size,
-                                                      &ret)) {
-    return ret;
+                                                      ret)) {
+    return;
   }
 
   if (size != 0) {
     if (size % valbytes != 0) {
-      UPB_DECODEFAST_ERROR(d, kUpb_DecodeStatus_Malformed, &ret);
-      return ret;
+      UPB_DECODEFAST_ERROR(d, kUpb_DecodeStatus_Malformed, ret);
+      return;
     }
 
     if (!upb_DecodeFast_GetArrayForAppend(d, *ptr, msg, *data, hasbits, &field,
-                                          type, size / valbytes, &ret)) {
-      return ret;
+                                          type, size / valbytes, ret)) {
+      return;
     }
 
     upb_DecodeFast_InlineMemcpy(field.dst, data_ptr, size);
@@ -90,37 +87,36 @@ int upb_DecodeFast_PackedFixed(upb_Decoder* d, const char** ptr,
 
   *ptr = data_ptr + size;
   _upb_Decoder_Trace(d, 'F');
-
-  return kUpb_DecodeFastNext_TailCallDispatch;
 }
 
 UPB_FORCEINLINE
-int upb_DecodeFast_Fixed(upb_Decoder* d, const char** ptr, upb_Message* msg,
-                         intptr_t table, uint64_t* hasbits, uint64_t* data,
-                         upb_DecodeFast_Type type,
-                         upb_DecodeFast_Cardinality card,
-                         upb_DecodeFast_TagSize tagsize) {
+void upb_DecodeFast_Fixed(upb_Decoder* d, const char** ptr, upb_Message* msg,
+                          intptr_t table, uint64_t* hasbits, uint64_t* data,
+                          upb_DecodeFastNext* ret, upb_DecodeFast_Type type,
+                          upb_DecodeFast_Cardinality card,
+                          upb_DecodeFast_TagSize tagsize) {
   if (card == kUpb_DecodeFast_Packed) {
-    return upb_DecodeFast_PackedFixed(d, ptr, msg, table, hasbits, data, type,
-                                      card, tagsize);
+    upb_DecodeFast_PackedFixed(d, ptr, msg, table, hasbits, data, ret, type,
+                               card, tagsize);
   } else {
-    return upb_DecodeFast_UnpackedFixed(d, ptr, msg, table, hasbits, data, type,
-                                        card, tagsize);
+    upb_DecodeFast_UnpackedFixed(d, ptr, msg, table, hasbits, data, ret, type,
+                                 card, tagsize);
   }
 }
 
 /* Generate all combinations:
  * {s,o,r,p} x {f4,f8} x {1bt,2bt} */
 
-#define F(type, card, tagbytes)                                       \
-  UPB_NOINLINE UPB_PRESERVE_NONE const char* UPB_DECODEFAST_FUNCNAME( \
-      type, card, tagbytes)(UPB_PARSE_PARAMS) {                       \
-    int next = upb_DecodeFast_Fixed(                                  \
-        d, &ptr, msg, table, &hasbits, &data, kUpb_DecodeFast_##type, \
-        kUpb_DecodeFast_##card, kUpb_DecodeFast_##tagbytes);          \
-    UPB_DECODEFAST_NEXTMAYBEPACKED(                                   \
-        next, UPB_DECODEFAST_FUNCNAME(type, Repeated, tagbytes),      \
-        UPB_DECODEFAST_FUNCNAME(type, Packed, tagbytes));             \
+#define F(type, card, tagbytes)                                          \
+  UPB_NOINLINE UPB_PRESERVE_NONE const char* UPB_DECODEFAST_FUNCNAME(    \
+      type, card, tagbytes)(UPB_PARSE_PARAMS) {                          \
+    upb_DecodeFastNext next = kUpb_DecodeFastNext_Dispatch;              \
+    upb_DecodeFast_Fixed(d, &ptr, msg, table, &hasbits, &data, &next,    \
+                         kUpb_DecodeFast_##type, kUpb_DecodeFast_##card, \
+                         kUpb_DecodeFast_##tagbytes);                    \
+    UPB_DECODEFAST_NEXTMAYBEPACKED(                                      \
+        next, UPB_DECODEFAST_FUNCNAME(type, Repeated, tagbytes),         \
+        UPB_DECODEFAST_FUNCNAME(type, Packed, tagbytes));                \
   }
 
 UPB_DECODEFAST_CARDINALITIES(UPB_DECODEFAST_TAGSIZES, F, Fixed32)