google-protobuf 4.26.1-x64-mingw-ucrt → 4.27.0.rc.1-x64-mingw-ucrt

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.


This version of google-protobuf might be problematic. Click here for more details.

@@ -113,17 +113,17 @@ Error, UINTPTR_MAX is undefined
113
113
 
114
114
  // Macros for function attributes on compilers that support them.
115
115
  #ifdef __GNUC__
116
- #define UPB_FORCEINLINE __inline__ __attribute__((always_inline))
116
+ #define UPB_FORCEINLINE __inline__ __attribute__((always_inline)) static
117
117
  #define UPB_NOINLINE __attribute__((noinline))
118
118
  #define UPB_NORETURN __attribute__((__noreturn__))
119
119
  #define UPB_PRINTF(str, first_vararg) __attribute__((format (printf, str, first_vararg)))
120
120
  #elif defined(_MSC_VER)
121
121
  #define UPB_NOINLINE
122
- #define UPB_FORCEINLINE
122
+ #define UPB_FORCEINLINE static
123
123
  #define UPB_NORETURN __declspec(noreturn)
124
124
  #define UPB_PRINTF(str, first_vararg)
125
125
  #else /* !defined(__GNUC__) */
126
- #define UPB_FORCEINLINE
126
+ #define UPB_FORCEINLINE static
127
127
  #define UPB_NOINLINE
128
128
  #define UPB_NORETURN
129
129
  #define UPB_PRINTF(str, first_vararg)
@@ -305,10 +305,10 @@ void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
305
305
 
306
306
  /* Disable proto2 arena behavior (TEMPORARY) **********************************/
307
307
 
308
- #ifdef UPB_DISABLE_PROTO2_ENUM_CHECKING
309
- #define UPB_TREAT_PROTO2_ENUMS_LIKE_PROTO3 1
308
+ #ifdef UPB_DISABLE_CLOSED_ENUM_CHECKING
309
+ #define UPB_TREAT_CLOSED_ENUMS_LIKE_OPEN 1
310
310
  #else
311
- #define UPB_TREAT_PROTO2_ENUMS_LIKE_PROTO3 0
311
+ #define UPB_TREAT_CLOSED_ENUMS_LIKE_OPEN 0
312
312
  #endif
313
313
 
314
314
  #if defined(__cplusplus)
@@ -341,6 +341,12 @@ void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
341
341
  #define UPB_DESC_MINITABLE(sym) &google__protobuf__##sym##_msg_init
342
342
  #endif
343
343
 
344
+ #ifdef UPB_TRACING_ENABLED
345
+ #ifdef NDEBUG
346
+ error UPB_TRACING_ENABLED Tracing should be disabled in production builds
347
+ #endif
348
+ #endif
349
+
344
350
 
345
351
  #include <errno.h>
346
352
  #include <float.h>
@@ -416,6 +422,9 @@ const upb_MiniTable google__protobuf__FileDescriptorSet_msg_init = {
416
422
  &google_protobuf_FileDescriptorSet_submsgs[0],
417
423
  &google_protobuf_FileDescriptorSet__fields[0],
418
424
  16, 1, kUpb_ExtMode_NonExtendable, 1, UPB_FASTTABLE_MASK(8), 0,
425
+ #ifdef UPB_TRACING_ENABLED
426
+ "google.protobuf.FileDescriptorSet",
427
+ #endif
419
428
  UPB_FASTTABLE_INIT({
420
429
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
421
430
  {0x000800003f00000a, &upb_prm_1bt_max192b},
@@ -452,6 +461,9 @@ const upb_MiniTable google__protobuf__FileDescriptorProto_msg_init = {
452
461
  &google_protobuf_FileDescriptorProto_submsgs[0],
453
462
  &google_protobuf_FileDescriptorProto__fields[0],
454
463
  UPB_SIZE(80, 136), 13, kUpb_ExtMode_NonExtendable, 12, UPB_FASTTABLE_MASK(120), 0,
464
+ #ifdef UPB_TRACING_ENABLED
465
+ "google.protobuf.FileDescriptorProto",
466
+ #endif
455
467
  UPB_FASTTABLE_INIT({
456
468
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
457
469
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
@@ -500,6 +512,9 @@ const upb_MiniTable google__protobuf__DescriptorProto_msg_init = {
500
512
  &google_protobuf_DescriptorProto_submsgs[0],
501
513
  &google_protobuf_DescriptorProto__fields[0],
502
514
  UPB_SIZE(56, 104), 10, kUpb_ExtMode_NonExtendable, 10, UPB_FASTTABLE_MASK(120), 0,
515
+ #ifdef UPB_TRACING_ENABLED
516
+ "google.protobuf.DescriptorProto",
517
+ #endif
503
518
  UPB_FASTTABLE_INIT({
504
519
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
505
520
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
@@ -534,6 +549,9 @@ const upb_MiniTable google__protobuf__DescriptorProto__ExtensionRange_msg_init =
534
549
  &google_protobuf_DescriptorProto_ExtensionRange_submsgs[0],
535
550
  &google_protobuf_DescriptorProto_ExtensionRange__fields[0],
536
551
  UPB_SIZE(24, 32), 3, kUpb_ExtMode_NonExtendable, 3, UPB_FASTTABLE_MASK(255), 0,
552
+ #ifdef UPB_TRACING_ENABLED
553
+ "google.protobuf.DescriptorProto.ExtensionRange",
554
+ #endif
537
555
  };
538
556
 
539
557
  static const upb_MiniTableField google_protobuf_DescriptorProto_ReservedRange__fields[2] = {
@@ -545,6 +563,9 @@ const upb_MiniTable google__protobuf__DescriptorProto__ReservedRange_msg_init =
545
563
  NULL,
546
564
  &google_protobuf_DescriptorProto_ReservedRange__fields[0],
547
565
  24, 2, kUpb_ExtMode_NonExtendable, 2, UPB_FASTTABLE_MASK(255), 0,
566
+ #ifdef UPB_TRACING_ENABLED
567
+ "google.protobuf.DescriptorProto.ReservedRange",
568
+ #endif
548
569
  };
549
570
 
550
571
  static const upb_MiniTableSub google_protobuf_ExtensionRangeOptions_submsgs[4] = {
@@ -565,6 +586,9 @@ const upb_MiniTable google__protobuf__ExtensionRangeOptions_msg_init = {
565
586
  &google_protobuf_ExtensionRangeOptions_submsgs[0],
566
587
  &google_protobuf_ExtensionRangeOptions__fields[0],
567
588
  UPB_SIZE(32, 40), 4, kUpb_ExtMode_Extendable, 0, UPB_FASTTABLE_MASK(248), 0,
589
+ #ifdef UPB_TRACING_ENABLED
590
+ "google.protobuf.ExtensionRangeOptions",
591
+ #endif
568
592
  UPB_FASTTABLE_INIT({
569
593
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
570
594
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
@@ -613,6 +637,9 @@ const upb_MiniTable google__protobuf__ExtensionRangeOptions__Declaration_msg_ini
613
637
  NULL,
614
638
  &google_protobuf_ExtensionRangeOptions_Declaration__fields[0],
615
639
  UPB_SIZE(40, 56), 5, kUpb_ExtMode_NonExtendable, 3, UPB_FASTTABLE_MASK(255), 0,
640
+ #ifdef UPB_TRACING_ENABLED
641
+ "google.protobuf.ExtensionRangeOptions.Declaration",
642
+ #endif
616
643
  };
617
644
 
618
645
  static const upb_MiniTableSub google_protobuf_FieldDescriptorProto_submsgs[3] = {
@@ -639,6 +666,9 @@ const upb_MiniTable google__protobuf__FieldDescriptorProto_msg_init = {
639
666
  &google_protobuf_FieldDescriptorProto_submsgs[0],
640
667
  &google_protobuf_FieldDescriptorProto__fields[0],
641
668
  UPB_SIZE(80, 120), 11, kUpb_ExtMode_NonExtendable, 10, UPB_FASTTABLE_MASK(255), 0,
669
+ #ifdef UPB_TRACING_ENABLED
670
+ "google.protobuf.FieldDescriptorProto",
671
+ #endif
642
672
  };
643
673
 
644
674
  static const upb_MiniTableSub google_protobuf_OneofDescriptorProto_submsgs[1] = {
@@ -654,6 +684,9 @@ const upb_MiniTable google__protobuf__OneofDescriptorProto_msg_init = {
654
684
  &google_protobuf_OneofDescriptorProto_submsgs[0],
655
685
  &google_protobuf_OneofDescriptorProto__fields[0],
656
686
  UPB_SIZE(24, 40), 2, kUpb_ExtMode_NonExtendable, 2, UPB_FASTTABLE_MASK(255), 0,
687
+ #ifdef UPB_TRACING_ENABLED
688
+ "google.protobuf.OneofDescriptorProto",
689
+ #endif
657
690
  };
658
691
 
659
692
  static const upb_MiniTableSub google_protobuf_EnumDescriptorProto_submsgs[3] = {
@@ -674,6 +707,9 @@ const upb_MiniTable google__protobuf__EnumDescriptorProto_msg_init = {
674
707
  &google_protobuf_EnumDescriptorProto_submsgs[0],
675
708
  &google_protobuf_EnumDescriptorProto__fields[0],
676
709
  UPB_SIZE(40, 64), 5, kUpb_ExtMode_NonExtendable, 5, UPB_FASTTABLE_MASK(56), 0,
710
+ #ifdef UPB_TRACING_ENABLED
711
+ "google.protobuf.EnumDescriptorProto",
712
+ #endif
677
713
  UPB_FASTTABLE_INIT({
678
714
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
679
715
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
@@ -695,6 +731,9 @@ const upb_MiniTable google__protobuf__EnumDescriptorProto__EnumReservedRange_msg
695
731
  NULL,
696
732
  &google_protobuf_EnumDescriptorProto_EnumReservedRange__fields[0],
697
733
  24, 2, kUpb_ExtMode_NonExtendable, 2, UPB_FASTTABLE_MASK(255), 0,
734
+ #ifdef UPB_TRACING_ENABLED
735
+ "google.protobuf.EnumDescriptorProto.EnumReservedRange",
736
+ #endif
698
737
  };
699
738
 
700
739
  static const upb_MiniTableSub google_protobuf_EnumValueDescriptorProto_submsgs[1] = {
@@ -711,6 +750,9 @@ const upb_MiniTable google__protobuf__EnumValueDescriptorProto_msg_init = {
711
750
  &google_protobuf_EnumValueDescriptorProto_submsgs[0],
712
751
  &google_protobuf_EnumValueDescriptorProto__fields[0],
713
752
  UPB_SIZE(32, 40), 3, kUpb_ExtMode_NonExtendable, 3, UPB_FASTTABLE_MASK(255), 0,
753
+ #ifdef UPB_TRACING_ENABLED
754
+ "google.protobuf.EnumValueDescriptorProto",
755
+ #endif
714
756
  };
715
757
 
716
758
  static const upb_MiniTableSub google_protobuf_ServiceDescriptorProto_submsgs[2] = {
@@ -728,6 +770,9 @@ const upb_MiniTable google__protobuf__ServiceDescriptorProto_msg_init = {
728
770
  &google_protobuf_ServiceDescriptorProto_submsgs[0],
729
771
  &google_protobuf_ServiceDescriptorProto__fields[0],
730
772
  UPB_SIZE(32, 48), 3, kUpb_ExtMode_NonExtendable, 3, UPB_FASTTABLE_MASK(24), 0,
773
+ #ifdef UPB_TRACING_ENABLED
774
+ "google.protobuf.ServiceDescriptorProto",
775
+ #endif
731
776
  UPB_FASTTABLE_INIT({
732
777
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
733
778
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
@@ -753,6 +798,9 @@ const upb_MiniTable google__protobuf__MethodDescriptorProto_msg_init = {
753
798
  &google_protobuf_MethodDescriptorProto_submsgs[0],
754
799
  &google_protobuf_MethodDescriptorProto__fields[0],
755
800
  UPB_SIZE(48, 72), 6, kUpb_ExtMode_NonExtendable, 6, UPB_FASTTABLE_MASK(255), 0,
801
+ #ifdef UPB_TRACING_ENABLED
802
+ "google.protobuf.MethodDescriptorProto",
803
+ #endif
756
804
  };
757
805
 
758
806
  static const upb_MiniTableSub google_protobuf_FileOptions_submsgs[3] = {
@@ -789,6 +837,9 @@ const upb_MiniTable google__protobuf__FileOptions_msg_init = {
789
837
  &google_protobuf_FileOptions_submsgs[0],
790
838
  &google_protobuf_FileOptions__fields[0],
791
839
  UPB_SIZE(112, 200), 21, kUpb_ExtMode_Extendable, 1, UPB_FASTTABLE_MASK(248), 0,
840
+ #ifdef UPB_TRACING_ENABLED
841
+ "google.protobuf.FileOptions",
842
+ #endif
792
843
  UPB_FASTTABLE_INIT({
793
844
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
794
845
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
@@ -844,6 +895,9 @@ const upb_MiniTable google__protobuf__MessageOptions_msg_init = {
844
895
  &google_protobuf_MessageOptions_submsgs[0],
845
896
  &google_protobuf_MessageOptions__fields[0],
846
897
  UPB_SIZE(24, 32), 7, kUpb_ExtMode_Extendable, 3, UPB_FASTTABLE_MASK(248), 0,
898
+ #ifdef UPB_TRACING_ENABLED
899
+ "google.protobuf.MessageOptions",
900
+ #endif
847
901
  UPB_FASTTABLE_INIT({
848
902
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
849
903
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
@@ -880,9 +934,10 @@ const upb_MiniTable google__protobuf__MessageOptions_msg_init = {
880
934
  })
881
935
  };
882
936
 
883
- static const upb_MiniTableSub google_protobuf_FieldOptions_submsgs[7] = {
937
+ static const upb_MiniTableSub google_protobuf_FieldOptions_submsgs[8] = {
884
938
  {.UPB_PRIVATE(submsg) = &google__protobuf__FieldOptions__EditionDefault_msg_init},
885
939
  {.UPB_PRIVATE(submsg) = &google__protobuf__FeatureSet_msg_init},
940
+ {.UPB_PRIVATE(submsg) = &google__protobuf__FieldOptions__FeatureSupport_msg_init},
886
941
  {.UPB_PRIVATE(submsg) = &google__protobuf__UninterpretedOption_msg_init},
887
942
  {.UPB_PRIVATE(subenum) = &google_protobuf_FieldOptions_CType_enum_init},
888
943
  {.UPB_PRIVATE(subenum) = &google_protobuf_FieldOptions_JSType_enum_init},
@@ -890,26 +945,30 @@ static const upb_MiniTableSub google_protobuf_FieldOptions_submsgs[7] = {
890
945
  {.UPB_PRIVATE(subenum) = &google_protobuf_FieldOptions_OptionTargetType_enum_init},
891
946
  };
892
947
 
893
- static const upb_MiniTableField google_protobuf_FieldOptions__fields[13] = {
894
- {1, 12, 64, 3, 14, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
948
+ static const upb_MiniTableField google_protobuf_FieldOptions__fields[14] = {
949
+ {1, 12, 64, 4, 14, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
895
950
  {2, 16, 65, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
896
951
  {3, 17, 66, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
897
952
  {5, 18, 67, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
898
- {6, 20, 68, 4, 14, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
953
+ {6, 20, 68, 5, 14, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
899
954
  {10, 24, 69, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
900
955
  {15, 25, 70, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
901
956
  {16, 26, 71, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
902
- {17, 28, 72, 5, 14, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
903
- {19, 32, 0, 6, 14, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
957
+ {17, 28, 72, 6, 14, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
958
+ {19, 32, 0, 7, 14, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
904
959
  {20, UPB_SIZE(36, 40), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
905
960
  {21, UPB_SIZE(40, 48), 73, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
906
- {999, UPB_SIZE(44, 56), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
961
+ {22, UPB_SIZE(44, 56), 74, 2, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
962
+ {999, UPB_SIZE(48, 64), 0, 3, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
907
963
  };
908
964
 
909
965
  const upb_MiniTable google__protobuf__FieldOptions_msg_init = {
910
966
  &google_protobuf_FieldOptions_submsgs[0],
911
967
  &google_protobuf_FieldOptions__fields[0],
912
- UPB_SIZE(48, 64), 13, kUpb_ExtMode_Extendable, 3, UPB_FASTTABLE_MASK(248), 0,
968
+ UPB_SIZE(56, 72), 14, kUpb_ExtMode_Extendable, 3, UPB_FASTTABLE_MASK(248), 0,
969
+ #ifdef UPB_TRACING_ENABLED
970
+ "google.protobuf.FieldOptions",
971
+ #endif
913
972
  UPB_FASTTABLE_INIT({
914
973
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
915
974
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
@@ -934,7 +993,7 @@ const upb_MiniTable google__protobuf__FieldOptions_msg_init = {
934
993
  {0x002800003f0001a2, &upb_prm_2bt_max64b},
935
994
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
936
995
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
937
- {0x003800003f023eba, &upb_prm_2bt_max128b},
996
+ {0x004000003f033eba, &upb_prm_2bt_max128b},
938
997
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
939
998
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
940
999
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
@@ -959,6 +1018,31 @@ const upb_MiniTable google__protobuf__FieldOptions__EditionDefault_msg_init = {
959
1018
  &google_protobuf_FieldOptions_EditionDefault_submsgs[0],
960
1019
  &google_protobuf_FieldOptions_EditionDefault__fields[0],
961
1020
  UPB_SIZE(24, 32), 2, kUpb_ExtMode_NonExtendable, 0, UPB_FASTTABLE_MASK(255), 0,
1021
+ #ifdef UPB_TRACING_ENABLED
1022
+ "google.protobuf.FieldOptions.EditionDefault",
1023
+ #endif
1024
+ };
1025
+
1026
+ static const upb_MiniTableSub google_protobuf_FieldOptions_FeatureSupport_submsgs[3] = {
1027
+ {.UPB_PRIVATE(subenum) = &google_protobuf_Edition_enum_init},
1028
+ {.UPB_PRIVATE(subenum) = &google_protobuf_Edition_enum_init},
1029
+ {.UPB_PRIVATE(subenum) = &google_protobuf_Edition_enum_init},
1030
+ };
1031
+
1032
+ static const upb_MiniTableField google_protobuf_FieldOptions_FeatureSupport__fields[4] = {
1033
+ {1, 12, 64, 0, 14, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
1034
+ {2, 16, 65, 1, 14, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
1035
+ {3, 24, 66, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
1036
+ {4, 20, 67, 2, 14, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
1037
+ };
1038
+
1039
+ const upb_MiniTable google__protobuf__FieldOptions__FeatureSupport_msg_init = {
1040
+ &google_protobuf_FieldOptions_FeatureSupport_submsgs[0],
1041
+ &google_protobuf_FieldOptions_FeatureSupport__fields[0],
1042
+ UPB_SIZE(32, 40), 4, kUpb_ExtMode_NonExtendable, 4, UPB_FASTTABLE_MASK(255), 0,
1043
+ #ifdef UPB_TRACING_ENABLED
1044
+ "google.protobuf.FieldOptions.FeatureSupport",
1045
+ #endif
962
1046
  };
963
1047
 
964
1048
  static const upb_MiniTableSub google_protobuf_OneofOptions_submsgs[2] = {
@@ -975,6 +1059,9 @@ const upb_MiniTable google__protobuf__OneofOptions_msg_init = {
975
1059
  &google_protobuf_OneofOptions_submsgs[0],
976
1060
  &google_protobuf_OneofOptions__fields[0],
977
1061
  UPB_SIZE(24, 32), 2, kUpb_ExtMode_Extendable, 1, UPB_FASTTABLE_MASK(248), 0,
1062
+ #ifdef UPB_TRACING_ENABLED
1063
+ "google.protobuf.OneofOptions",
1064
+ #endif
978
1065
  UPB_FASTTABLE_INIT({
979
1066
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
980
1067
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
@@ -1028,6 +1115,9 @@ const upb_MiniTable google__protobuf__EnumOptions_msg_init = {
1028
1115
  &google_protobuf_EnumOptions_submsgs[0],
1029
1116
  &google_protobuf_EnumOptions__fields[0],
1030
1117
  UPB_SIZE(24, 32), 5, kUpb_ExtMode_Extendable, 0, UPB_FASTTABLE_MASK(248), 0,
1118
+ #ifdef UPB_TRACING_ENABLED
1119
+ "google.protobuf.EnumOptions",
1120
+ #endif
1031
1121
  UPB_FASTTABLE_INIT({
1032
1122
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
1033
1123
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
@@ -1080,6 +1170,9 @@ const upb_MiniTable google__protobuf__EnumValueOptions_msg_init = {
1080
1170
  &google_protobuf_EnumValueOptions_submsgs[0],
1081
1171
  &google_protobuf_EnumValueOptions__fields[0],
1082
1172
  UPB_SIZE(24, 32), 4, kUpb_ExtMode_Extendable, 3, UPB_FASTTABLE_MASK(248), 0,
1173
+ #ifdef UPB_TRACING_ENABLED
1174
+ "google.protobuf.EnumValueOptions",
1175
+ #endif
1083
1176
  UPB_FASTTABLE_INIT({
1084
1177
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
1085
1178
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
@@ -1131,6 +1224,9 @@ const upb_MiniTable google__protobuf__ServiceOptions_msg_init = {
1131
1224
  &google_protobuf_ServiceOptions_submsgs[0],
1132
1225
  &google_protobuf_ServiceOptions__fields[0],
1133
1226
  UPB_SIZE(24, 32), 3, kUpb_ExtMode_Extendable, 0, UPB_FASTTABLE_MASK(248), 0,
1227
+ #ifdef UPB_TRACING_ENABLED
1228
+ "google.protobuf.ServiceOptions",
1229
+ #endif
1134
1230
  UPB_FASTTABLE_INIT({
1135
1231
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
1136
1232
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
@@ -1184,6 +1280,9 @@ const upb_MiniTable google__protobuf__MethodOptions_msg_init = {
1184
1280
  &google_protobuf_MethodOptions_submsgs[0],
1185
1281
  &google_protobuf_MethodOptions__fields[0],
1186
1282
  UPB_SIZE(24, 32), 4, kUpb_ExtMode_Extendable, 0, UPB_FASTTABLE_MASK(248), 0,
1283
+ #ifdef UPB_TRACING_ENABLED
1284
+ "google.protobuf.MethodOptions",
1285
+ #endif
1187
1286
  UPB_FASTTABLE_INIT({
1188
1287
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
1189
1288
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
@@ -1238,6 +1337,9 @@ const upb_MiniTable google__protobuf__UninterpretedOption_msg_init = {
1238
1337
  &google_protobuf_UninterpretedOption_submsgs[0],
1239
1338
  &google_protobuf_UninterpretedOption__fields[0],
1240
1339
  UPB_SIZE(64, 96), 7, kUpb_ExtMode_NonExtendable, 0, UPB_FASTTABLE_MASK(24), 0,
1340
+ #ifdef UPB_TRACING_ENABLED
1341
+ "google.protobuf.UninterpretedOption",
1342
+ #endif
1241
1343
  UPB_FASTTABLE_INIT({
1242
1344
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
1243
1345
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
@@ -1255,6 +1357,9 @@ const upb_MiniTable google__protobuf__UninterpretedOption__NamePart_msg_init = {
1255
1357
  NULL,
1256
1358
  &google_protobuf_UninterpretedOption_NamePart__fields[0],
1257
1359
  UPB_SIZE(24, 32), 2, kUpb_ExtMode_NonExtendable, 2, UPB_FASTTABLE_MASK(255), 2,
1360
+ #ifdef UPB_TRACING_ENABLED
1361
+ "google.protobuf.UninterpretedOption.NamePart",
1362
+ #endif
1258
1363
  };
1259
1364
 
1260
1365
  static const upb_MiniTableSub google_protobuf_FeatureSet_submsgs[6] = {
@@ -1279,6 +1384,9 @@ const upb_MiniTable google__protobuf__FeatureSet_msg_init = {
1279
1384
  &google_protobuf_FeatureSet_submsgs[0],
1280
1385
  &google_protobuf_FeatureSet__fields[0],
1281
1386
  40, 6, kUpb_ExtMode_Extendable, 6, UPB_FASTTABLE_MASK(255), 0,
1387
+ #ifdef UPB_TRACING_ENABLED
1388
+ "google.protobuf.FeatureSet",
1389
+ #endif
1282
1390
  };
1283
1391
 
1284
1392
  static const upb_MiniTableSub google_protobuf_FeatureSetDefaults_submsgs[3] = {
@@ -1297,26 +1405,34 @@ const upb_MiniTable google__protobuf__FeatureSetDefaults_msg_init = {
1297
1405
  &google_protobuf_FeatureSetDefaults_submsgs[0],
1298
1406
  &google_protobuf_FeatureSetDefaults__fields[0],
1299
1407
  UPB_SIZE(24, 32), 3, kUpb_ExtMode_NonExtendable, 1, UPB_FASTTABLE_MASK(8), 0,
1408
+ #ifdef UPB_TRACING_ENABLED
1409
+ "google.protobuf.FeatureSetDefaults",
1410
+ #endif
1300
1411
  UPB_FASTTABLE_INIT({
1301
1412
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
1302
1413
  {0x001800003f00000a, &upb_prm_1bt_max64b},
1303
1414
  })
1304
1415
  };
1305
1416
 
1306
- static const upb_MiniTableSub google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_submsgs[2] = {
1417
+ static const upb_MiniTableSub google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_submsgs[3] = {
1418
+ {.UPB_PRIVATE(submsg) = &google__protobuf__FeatureSet_msg_init},
1307
1419
  {.UPB_PRIVATE(submsg) = &google__protobuf__FeatureSet_msg_init},
1308
1420
  {.UPB_PRIVATE(subenum) = &google_protobuf_Edition_enum_init},
1309
1421
  };
1310
1422
 
1311
- static const upb_MiniTableField google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault__fields[2] = {
1312
- {2, UPB_SIZE(12, 16), 64, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
1313
- {3, UPB_SIZE(16, 12), 65, 1, 14, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
1423
+ static const upb_MiniTableField google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault__fields[3] = {
1424
+ {3, 12, 64, 2, 14, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
1425
+ {4, 16, 65, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
1426
+ {5, UPB_SIZE(20, 24), 66, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
1314
1427
  };
1315
1428
 
1316
1429
  const upb_MiniTable google__protobuf__FeatureSetDefaults__FeatureSetEditionDefault_msg_init = {
1317
1430
  &google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_submsgs[0],
1318
1431
  &google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault__fields[0],
1319
- 24, 2, kUpb_ExtMode_NonExtendable, 0, UPB_FASTTABLE_MASK(255), 0,
1432
+ UPB_SIZE(24, 32), 3, kUpb_ExtMode_NonExtendable, 0, UPB_FASTTABLE_MASK(255), 0,
1433
+ #ifdef UPB_TRACING_ENABLED
1434
+ "google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault",
1435
+ #endif
1320
1436
  };
1321
1437
 
1322
1438
  static const upb_MiniTableSub google_protobuf_SourceCodeInfo_submsgs[1] = {
@@ -1331,6 +1447,9 @@ const upb_MiniTable google__protobuf__SourceCodeInfo_msg_init = {
1331
1447
  &google_protobuf_SourceCodeInfo_submsgs[0],
1332
1448
  &google_protobuf_SourceCodeInfo__fields[0],
1333
1449
  16, 1, kUpb_ExtMode_NonExtendable, 1, UPB_FASTTABLE_MASK(8), 0,
1450
+ #ifdef UPB_TRACING_ENABLED
1451
+ "google.protobuf.SourceCodeInfo",
1452
+ #endif
1334
1453
  UPB_FASTTABLE_INIT({
1335
1454
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
1336
1455
  {0x000800003f00000a, &upb_prm_1bt_max128b},
@@ -1349,6 +1468,9 @@ const upb_MiniTable google__protobuf__SourceCodeInfo__Location_msg_init = {
1349
1468
  NULL,
1350
1469
  &google_protobuf_SourceCodeInfo_Location__fields[0],
1351
1470
  UPB_SIZE(40, 72), 5, kUpb_ExtMode_NonExtendable, 4, UPB_FASTTABLE_MASK(56), 0,
1471
+ #ifdef UPB_TRACING_ENABLED
1472
+ "google.protobuf.SourceCodeInfo.Location",
1473
+ #endif
1352
1474
  UPB_FASTTABLE_INIT({
1353
1475
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
1354
1476
  {0x001000003f00000a, &upb_ppv4_1bt},
@@ -1373,6 +1495,9 @@ const upb_MiniTable google__protobuf__GeneratedCodeInfo_msg_init = {
1373
1495
  &google_protobuf_GeneratedCodeInfo_submsgs[0],
1374
1496
  &google_protobuf_GeneratedCodeInfo__fields[0],
1375
1497
  16, 1, kUpb_ExtMode_NonExtendable, 1, UPB_FASTTABLE_MASK(8), 0,
1498
+ #ifdef UPB_TRACING_ENABLED
1499
+ "google.protobuf.GeneratedCodeInfo",
1500
+ #endif
1376
1501
  UPB_FASTTABLE_INIT({
1377
1502
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
1378
1503
  {0x000800003f00000a, &upb_prm_1bt_max64b},
@@ -1395,13 +1520,16 @@ const upb_MiniTable google__protobuf__GeneratedCodeInfo__Annotation_msg_init = {
1395
1520
  &google_protobuf_GeneratedCodeInfo_Annotation_submsgs[0],
1396
1521
  &google_protobuf_GeneratedCodeInfo_Annotation__fields[0],
1397
1522
  UPB_SIZE(40, 48), 5, kUpb_ExtMode_NonExtendable, 5, UPB_FASTTABLE_MASK(8), 0,
1523
+ #ifdef UPB_TRACING_ENABLED
1524
+ "google.protobuf.GeneratedCodeInfo.Annotation",
1525
+ #endif
1398
1526
  UPB_FASTTABLE_INIT({
1399
1527
  {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
1400
1528
  {0x001800003f00000a, &upb_ppv4_1bt},
1401
1529
  })
1402
1530
  };
1403
1531
 
1404
- static const upb_MiniTable *messages_layout[32] = {
1532
+ static const upb_MiniTable *messages_layout[33] = {
1405
1533
  &google__protobuf__FileDescriptorSet_msg_init,
1406
1534
  &google__protobuf__FileDescriptorProto_msg_init,
1407
1535
  &google__protobuf__DescriptorProto_msg_init,
@@ -1420,6 +1548,7 @@ static const upb_MiniTable *messages_layout[32] = {
1420
1548
  &google__protobuf__MessageOptions_msg_init,
1421
1549
  &google__protobuf__FieldOptions_msg_init,
1422
1550
  &google__protobuf__FieldOptions__EditionDefault_msg_init,
1551
+ &google__protobuf__FieldOptions__FeatureSupport_msg_init,
1423
1552
  &google__protobuf__OneofOptions_msg_init,
1424
1553
  &google__protobuf__EnumOptions_msg_init,
1425
1554
  &google__protobuf__EnumValueOptions_msg_init,
@@ -1438,10 +1567,11 @@ static const upb_MiniTable *messages_layout[32] = {
1438
1567
 
1439
1568
  const upb_MiniTableEnum google_protobuf_Edition_enum_init = {
1440
1569
  64,
1441
- 8,
1570
+ 9,
1442
1571
  {
1443
1572
  0x7,
1444
1573
  0x0,
1574
+ 0x384,
1445
1575
  0x3e6,
1446
1576
  0x3e7,
1447
1577
  0x3e8,
@@ -1621,7 +1751,7 @@ const upb_MiniTableFile google_protobuf_descriptor_proto_upb_file_layout = {
1621
1751
  messages_layout,
1622
1752
  enums_layout,
1623
1753
  NULL,
1624
- 32,
1754
+ 33,
1625
1755
  17,
1626
1756
  0,
1627
1757
  };
@@ -3131,6 +3261,7 @@ static bool upb_JsonDecoder_Decode(jsondec* const d, upb_Message* const msg,
3131
3261
  bool upb_JsonDecode(const char* buf, size_t size, upb_Message* msg,
3132
3262
  const upb_MessageDef* m, const upb_DefPool* symtab,
3133
3263
  int options, upb_Arena* arena, upb_Status* status) {
3264
+ UPB_ASSERT(!upb_Message_IsFrozen(msg));
3134
3265
  jsondec d;
3135
3266
 
3136
3267
  if (size == 0) return true;
@@ -3941,6 +4072,10 @@ static void* upb_global_allocfunc(upb_alloc* alloc, void* ptr, size_t oldsize,
3941
4072
  upb_alloc upb_alloc_global = {&upb_global_allocfunc};
3942
4073
 
3943
4074
 
4075
+ #ifdef UPB_TRACING_ENABLED
4076
+ #include <stdatomic.h>
4077
+ #endif
4078
+
3944
4079
  #include <stddef.h>
3945
4080
  #include <stdint.h>
3946
4081
 
@@ -4047,6 +4182,38 @@ static bool _upb_ArenaInternal_HasInitialBlock(upb_ArenaInternal* ai) {
4047
4182
  return ai->block_alloc & 0x1;
4048
4183
  }
4049
4184
 
4185
+ #ifdef UPB_TRACING_ENABLED
4186
+ static void (*_init_arena_trace_handler)(const upb_Arena*, size_t size) = NULL;
4187
+ static void (*_fuse_arena_trace_handler)(const upb_Arena*,
4188
+ const upb_Arena*) = NULL;
4189
+ static void (*_free_arena_trace_handler)(const upb_Arena*) = NULL;
4190
+
4191
+ void upb_Arena_SetTraceHandler(
4192
+ void (*initArenaTraceHandler)(const upb_Arena*, size_t size),
4193
+ void (*fuseArenaTraceHandler)(const upb_Arena*, const upb_Arena*),
4194
+ void (*freeArenaTraceHandler)(const upb_Arena*)) {
4195
+ _init_arena_trace_handler = initArenaTraceHandler;
4196
+ _fuse_arena_trace_handler = fuseArenaTraceHandler;
4197
+ _free_arena_trace_handler = freeArenaTraceHandler;
4198
+ }
4199
+
4200
+ void upb_Arena_LogInit(const upb_Arena* arena, size_t size) {
4201
+ if (_init_arena_trace_handler) {
4202
+ _init_arena_trace_handler(arena, size);
4203
+ }
4204
+ }
4205
+ void upb_Arena_LogFuse(const upb_Arena* arena1, const upb_Arena* arena2) {
4206
+ if (_fuse_arena_trace_handler) {
4207
+ _fuse_arena_trace_handler(arena1, arena2);
4208
+ }
4209
+ }
4210
+ void upb_Arena_LogFree(const upb_Arena* arena) {
4211
+ if (_free_arena_trace_handler) {
4212
+ _free_arena_trace_handler(arena);
4213
+ }
4214
+ }
4215
+ #endif // UPB_TRACING_ENABLED
4216
+
4050
4217
  static upb_ArenaRoot _upb_Arena_FindRoot(upb_Arena* a) {
4051
4218
  upb_ArenaInternal* ai = upb_Arena_Internal(a);
4052
4219
  uintptr_t poc = upb_Atomic_Load(&ai->parent_or_count, memory_order_acquire);
@@ -4104,6 +4271,21 @@ size_t upb_Arena_SpaceAllocated(upb_Arena* arena, size_t* fused_count) {
4104
4271
  return memsize;
4105
4272
  }
4106
4273
 
4274
+ bool UPB_PRIVATE(_upb_Arena_Contains)(const upb_Arena* a, void* ptr) {
4275
+ upb_ArenaInternal* ai = upb_Arena_Internal(a);
4276
+ UPB_ASSERT(ai);
4277
+
4278
+ upb_MemBlock* block = upb_Atomic_Load(&ai->blocks, memory_order_relaxed);
4279
+ while (block) {
4280
+ uintptr_t beg = (uintptr_t)block;
4281
+ uintptr_t end = beg + block->size;
4282
+ if ((uintptr_t)ptr >= beg && (uintptr_t)ptr < end) return true;
4283
+ block = upb_Atomic_Load(&block->next, memory_order_relaxed);
4284
+ }
4285
+
4286
+ return false;
4287
+ }
4288
+
4107
4289
  uint32_t upb_Arena_DebugRefCount(upb_Arena* a) {
4108
4290
  upb_ArenaInternal* ai = upb_Arena_Internal(a);
4109
4291
  // These loads could probably be relaxed, but given that this is debug-only,
@@ -4195,7 +4377,13 @@ upb_Arena* upb_Arena_Init(void* mem, size_t n, upb_alloc* alloc) {
4195
4377
  n = UPB_ALIGN_DOWN(n, UPB_ALIGN_OF(upb_ArenaState));
4196
4378
 
4197
4379
  if (UPB_UNLIKELY(n < sizeof(upb_ArenaState))) {
4380
+ #ifdef UPB_TRACING_ENABLED
4381
+ upb_Arena* ret = _upb_Arena_InitSlow(alloc);
4382
+ upb_Arena_LogInit(ret, n);
4383
+ return ret;
4384
+ #else
4198
4385
  return _upb_Arena_InitSlow(alloc);
4386
+ #endif
4199
4387
  }
4200
4388
 
4201
4389
  a = UPB_PTR_AT(mem, n - sizeof(upb_ArenaState), upb_ArenaState);
@@ -4208,13 +4396,14 @@ upb_Arena* upb_Arena_Init(void* mem, size_t n, upb_alloc* alloc) {
4208
4396
  a->body.block_alloc = _upb_Arena_MakeBlockAlloc(alloc, 1);
4209
4397
  a->head.UPB_PRIVATE(ptr) = mem;
4210
4398
  a->head.UPB_PRIVATE(end) = UPB_PTR_AT(mem, n - sizeof(upb_ArenaState), char);
4211
-
4399
+ #ifdef UPB_TRACING_ENABLED
4400
+ upb_Arena_LogInit(&a->head, n);
4401
+ #endif
4212
4402
  return &a->head;
4213
4403
  }
4214
4404
 
4215
4405
  static void _upb_Arena_DoFree(upb_ArenaInternal* ai) {
4216
4406
  UPB_ASSERT(_upb_Arena_RefCountFromTagged(ai->parent_or_count) == 1);
4217
-
4218
4407
  while (ai != NULL) {
4219
4408
  // Load first since arena itself is likely from one of its blocks.
4220
4409
  upb_ArenaInternal* next_arena =
@@ -4245,6 +4434,9 @@ retry:
4245
4434
  // expensive then direct loads. As an optimization, we only do RMW ops
4246
4435
  // when we need to update things for other threads to see.
4247
4436
  if (poc == _upb_Arena_TaggedFromRefcount(1)) {
4437
+ #ifdef UPB_TRACING_ENABLED
4438
+ upb_Arena_LogFree(a);
4439
+ #endif
4248
4440
  _upb_Arena_DoFree(ai);
4249
4441
  return;
4250
4442
  }
@@ -4364,6 +4556,10 @@ static bool _upb_Arena_FixupRefs(upb_ArenaInternal* new_root,
4364
4556
  bool upb_Arena_Fuse(upb_Arena* a1, upb_Arena* a2) {
4365
4557
  if (a1 == a2) return true; // trivial fuse
4366
4558
 
4559
+ #ifdef UPB_TRACING_ENABLED
4560
+ upb_Arena_LogFuse(a1, a2);
4561
+ #endif
4562
+
4367
4563
  upb_ArenaInternal* ai1 = upb_Arena_Internal(a1);
4368
4564
  upb_ArenaInternal* ai2 = upb_Arena_Internal(a2);
4369
4565
 
@@ -4430,18 +4626,19 @@ void UPB_PRIVATE(_upb_Arena_SwapOut)(upb_Arena* des, const upb_Arena* src) {
4430
4626
 
4431
4627
  // Must be last.
4432
4628
 
4433
- bool upb_Message_SetMapEntry(upb_Map* map, const upb_MiniTable* mini_table,
4629
+ bool upb_Message_SetMapEntry(upb_Map* map, const upb_MiniTable* m,
4434
4630
  const upb_MiniTableField* f,
4435
4631
  upb_Message* map_entry_message, upb_Arena* arena) {
4632
+ UPB_ASSERT(!upb_Message_IsFrozen(map_entry_message));
4633
+
4436
4634
  // TODO: use a variant of upb_MiniTable_GetSubMessageTable() here.
4437
4635
  const upb_MiniTable* map_entry_mini_table = upb_MiniTableSub_Message(
4438
- mini_table->UPB_PRIVATE(subs)[f->UPB_PRIVATE(submsg_index)]);
4636
+ m->UPB_PRIVATE(subs)[f->UPB_PRIVATE(submsg_index)]);
4439
4637
  UPB_ASSERT(map_entry_mini_table);
4440
- UPB_ASSERT(map_entry_mini_table->UPB_PRIVATE(field_count) == 2);
4441
4638
  const upb_MiniTableField* map_entry_key_field =
4442
- &map_entry_mini_table->UPB_PRIVATE(fields)[0];
4639
+ upb_MiniTable_MapKey(map_entry_mini_table);
4443
4640
  const upb_MiniTableField* map_entry_value_field =
4444
- &map_entry_mini_table->UPB_PRIVATE(fields)[1];
4641
+ upb_MiniTable_MapValue(map_entry_mini_table);
4445
4642
  // Map key/value cannot have explicit defaults,
4446
4643
  // hence assuming a zero default is valid.
4447
4644
  upb_MessageValue default_val;
@@ -4466,31 +4663,33 @@ upb_Array* upb_Array_New(upb_Arena* a, upb_CType type) {
4466
4663
  }
4467
4664
 
4468
4665
  upb_MessageValue upb_Array_Get(const upb_Array* arr, size_t i) {
4666
+ UPB_ASSERT(i < upb_Array_Size(arr));
4469
4667
  upb_MessageValue ret;
4470
4668
  const char* data = upb_Array_DataPtr(arr);
4471
4669
  const int lg2 = UPB_PRIVATE(_upb_Array_ElemSizeLg2)(arr);
4472
- UPB_ASSERT(i < arr->UPB_PRIVATE(size));
4473
4670
  memcpy(&ret, data + (i << lg2), 1 << lg2);
4474
4671
  return ret;
4475
4672
  }
4476
4673
 
4477
4674
  upb_MutableMessageValue upb_Array_GetMutable(upb_Array* arr, size_t i) {
4675
+ UPB_ASSERT(i < upb_Array_Size(arr));
4478
4676
  upb_MutableMessageValue ret;
4479
4677
  char* data = upb_Array_MutableDataPtr(arr);
4480
4678
  const int lg2 = UPB_PRIVATE(_upb_Array_ElemSizeLg2)(arr);
4481
- UPB_ASSERT(i < arr->UPB_PRIVATE(size));
4482
4679
  memcpy(&ret, data + (i << lg2), 1 << lg2);
4483
4680
  return ret;
4484
4681
  }
4485
4682
 
4486
4683
  void upb_Array_Set(upb_Array* arr, size_t i, upb_MessageValue val) {
4684
+ UPB_ASSERT(!upb_Array_IsFrozen(arr));
4685
+ UPB_ASSERT(i < upb_Array_Size(arr));
4487
4686
  char* data = upb_Array_MutableDataPtr(arr);
4488
4687
  const int lg2 = UPB_PRIVATE(_upb_Array_ElemSizeLg2)(arr);
4489
- UPB_ASSERT(i < arr->UPB_PRIVATE(size));
4490
4688
  memcpy(data + (i << lg2), &val, 1 << lg2);
4491
4689
  }
4492
4690
 
4493
4691
  bool upb_Array_Append(upb_Array* arr, upb_MessageValue val, upb_Arena* arena) {
4692
+ UPB_ASSERT(!upb_Array_IsFrozen(arr));
4494
4693
  UPB_ASSERT(arena);
4495
4694
  if (!UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
4496
4695
  arr, arr->UPB_PRIVATE(size) + 1, arena)) {
@@ -4502,6 +4701,7 @@ bool upb_Array_Append(upb_Array* arr, upb_MessageValue val, upb_Arena* arena) {
4502
4701
 
4503
4702
  void upb_Array_Move(upb_Array* arr, size_t dst_idx, size_t src_idx,
4504
4703
  size_t count) {
4704
+ UPB_ASSERT(!upb_Array_IsFrozen(arr));
4505
4705
  const int lg2 = UPB_PRIVATE(_upb_Array_ElemSizeLg2)(arr);
4506
4706
  char* data = upb_Array_MutableDataPtr(arr);
4507
4707
  memmove(&data[dst_idx << lg2], &data[src_idx << lg2], count << lg2);
@@ -4509,6 +4709,7 @@ void upb_Array_Move(upb_Array* arr, size_t dst_idx, size_t src_idx,
4509
4709
 
4510
4710
  bool upb_Array_Insert(upb_Array* arr, size_t i, size_t count,
4511
4711
  upb_Arena* arena) {
4712
+ UPB_ASSERT(!upb_Array_IsFrozen(arr));
4512
4713
  UPB_ASSERT(arena);
4513
4714
  UPB_ASSERT(i <= arr->UPB_PRIVATE(size));
4514
4715
  UPB_ASSERT(count + arr->UPB_PRIVATE(size) >= count);
@@ -4526,6 +4727,7 @@ bool upb_Array_Insert(upb_Array* arr, size_t i, size_t count,
4526
4727
  * |------------|XXXXXXXX|--------|
4527
4728
  */
4528
4729
  void upb_Array_Delete(upb_Array* arr, size_t i, size_t count) {
4730
+ UPB_ASSERT(!upb_Array_IsFrozen(arr));
4529
4731
  const size_t end = i + count;
4530
4732
  UPB_ASSERT(i <= end);
4531
4733
  UPB_ASSERT(end <= arr->UPB_PRIVATE(size));
@@ -4534,6 +4736,7 @@ void upb_Array_Delete(upb_Array* arr, size_t i, size_t count) {
4534
4736
  }
4535
4737
 
4536
4738
  bool upb_Array_Resize(upb_Array* arr, size_t size, upb_Arena* arena) {
4739
+ UPB_ASSERT(!upb_Array_IsFrozen(arr));
4537
4740
  const size_t oldsize = arr->UPB_PRIVATE(size);
4538
4741
  if (UPB_UNLIKELY(
4539
4742
  !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(arr, size, arena))) {
@@ -4567,6 +4770,20 @@ bool UPB_PRIVATE(_upb_Array_Realloc)(upb_Array* array, size_t min_capacity,
4567
4770
  return true;
4568
4771
  }
4569
4772
 
4773
+ void upb_Array_Freeze(upb_Array* arr, const upb_MiniTable* m) {
4774
+ if (upb_Array_IsFrozen(arr)) return;
4775
+ UPB_PRIVATE(_upb_Array_ShallowFreeze)(arr);
4776
+
4777
+ if (m) {
4778
+ const size_t size = upb_Array_Size(arr);
4779
+
4780
+ for (size_t i = 0; i < size; i++) {
4781
+ upb_MessageValue val = upb_Array_Get(arr, i);
4782
+ upb_Message_Freeze((upb_Message*)val.msg_val, m);
4783
+ }
4784
+ }
4785
+ }
4786
+
4570
4787
 
4571
4788
  #include <stddef.h>
4572
4789
  #include <stdint.h>
@@ -4583,19 +4800,20 @@ const upb_MiniTableExtension* upb_Message_ExtensionByIndex(
4583
4800
  return ext[index].ext;
4584
4801
  }
4585
4802
 
4586
- const upb_Extension* upb_Message_FindExtensionByNumber(const upb_Message* msg,
4587
- uint32_t field_number) {
4803
+ const upb_MiniTableExtension* upb_Message_FindExtensionByNumber(
4804
+ const upb_Message* msg, uint32_t field_number) {
4588
4805
  size_t count;
4589
4806
  const upb_Extension* ext = UPB_PRIVATE(_upb_Message_Getexts)(msg, &count);
4590
4807
 
4591
- while (count--) {
4592
- if (upb_MiniTableExtension_Number(ext->ext) == field_number) return ext;
4593
- ext++;
4808
+ for (; count--; ext++) {
4809
+ const upb_MiniTableExtension* e = ext->ext;
4810
+ if (upb_MiniTableExtension_Number(e) == field_number) return e;
4594
4811
  }
4595
4812
  return NULL;
4596
4813
  }
4597
4814
 
4598
4815
 
4816
+ #include <stdint.h>
4599
4817
  #include <string.h>
4600
4818
 
4601
4819
 
@@ -4694,6 +4912,20 @@ upb_MessageValue upb_MapIterator_Value(const upb_Map* map, size_t iter) {
4694
4912
  return ret;
4695
4913
  }
4696
4914
 
4915
+ void upb_Map_Freeze(upb_Map* map, const upb_MiniTable* m) {
4916
+ if (upb_Map_IsFrozen(map)) return;
4917
+ UPB_PRIVATE(_upb_Map_ShallowFreeze)(map);
4918
+
4919
+ if (m) {
4920
+ size_t iter = kUpb_Map_Begin;
4921
+ upb_MessageValue key, val;
4922
+
4923
+ while (upb_Map_Next(map, &key, &val, &iter)) {
4924
+ upb_Message_Freeze((upb_Message*)val.msg_val, m);
4925
+ }
4926
+ }
4927
+ }
4928
+
4697
4929
  // EVERYTHING BELOW THIS LINE IS INTERNAL - DO NOT USE /////////////////////////
4698
4930
 
4699
4931
  upb_Map* _upb_Map_New(upb_Arena* a, size_t key_size, size_t value_size) {
@@ -4703,6 +4935,7 @@ upb_Map* _upb_Map_New(upb_Arena* a, size_t key_size, size_t value_size) {
4703
4935
  upb_strtable_init(&map->table, 4, a);
4704
4936
  map->key_size = key_size;
4705
4937
  map->val_size = value_size;
4938
+ map->UPB_PRIVATE(is_frozen) = false;
4706
4939
 
4707
4940
  return map;
4708
4941
  }
@@ -4866,22 +5099,24 @@ upb_Message* upb_Message_New(const upb_MiniTable* m, upb_Arena* a) {
4866
5099
 
4867
5100
  bool UPB_PRIVATE(_upb_Message_AddUnknown)(upb_Message* msg, const char* data,
4868
5101
  size_t len, upb_Arena* arena) {
5102
+ UPB_ASSERT(!upb_Message_IsFrozen(msg));
4869
5103
  if (!UPB_PRIVATE(_upb_Message_Realloc)(msg, len, arena)) return false;
4870
- upb_Message_Internal* in = msg->internal;
5104
+ upb_Message_Internal* in = UPB_PRIVATE(_upb_Message_GetInternal)(msg);
4871
5105
  memcpy(UPB_PTR_AT(in, in->unknown_end, char), data, len);
4872
5106
  in->unknown_end += len;
4873
5107
  return true;
4874
5108
  }
4875
5109
 
4876
5110
  void _upb_Message_DiscardUnknown_shallow(upb_Message* msg) {
4877
- upb_Message_Internal* in = msg->internal;
5111
+ UPB_ASSERT(!upb_Message_IsFrozen(msg));
5112
+ upb_Message_Internal* in = UPB_PRIVATE(_upb_Message_GetInternal)(msg);
4878
5113
  if (in) {
4879
5114
  in->unknown_end = message_overhead;
4880
5115
  }
4881
5116
  }
4882
5117
 
4883
5118
  const char* upb_Message_GetUnknown(const upb_Message* msg, size_t* len) {
4884
- upb_Message_Internal* in = msg->internal;
5119
+ upb_Message_Internal* in = UPB_PRIVATE(_upb_Message_GetInternal)(msg);
4885
5120
  if (in) {
4886
5121
  *len = in->unknown_end - message_overhead;
4887
5122
  return (char*)(in + 1);
@@ -4892,7 +5127,8 @@ const char* upb_Message_GetUnknown(const upb_Message* msg, size_t* len) {
4892
5127
  }
4893
5128
 
4894
5129
  void upb_Message_DeleteUnknown(upb_Message* msg, const char* data, size_t len) {
4895
- upb_Message_Internal* in = msg->internal;
5130
+ UPB_ASSERT(!upb_Message_IsFrozen(msg));
5131
+ upb_Message_Internal* in = UPB_PRIVATE(_upb_Message_GetInternal)(msg);
4896
5132
  const char* internal_unknown_end = UPB_PTR_AT(in, in->unknown_end, char);
4897
5133
 
4898
5134
  #ifndef NDEBUG
@@ -4916,35 +5152,296 @@ size_t upb_Message_ExtensionCount(const upb_Message* msg) {
4916
5152
  return count;
4917
5153
  }
4918
5154
 
5155
+ void upb_Message_Freeze(upb_Message* msg, const upb_MiniTable* m) {
5156
+ if (upb_Message_IsFrozen(msg)) return;
5157
+ UPB_PRIVATE(_upb_Message_ShallowFreeze)(msg);
5158
+
5159
+ // Base Fields.
5160
+ const size_t field_count = upb_MiniTable_FieldCount(m);
5161
+
5162
+ for (size_t i = 0; i < field_count; i++) {
5163
+ const upb_MiniTableField* f = upb_MiniTable_GetFieldByIndex(m, i);
5164
+ const upb_MiniTable* m2 = upb_MiniTable_SubMessage(m, f);
5165
+
5166
+ switch (UPB_PRIVATE(_upb_MiniTableField_Mode)(f)) {
5167
+ case kUpb_FieldMode_Array: {
5168
+ upb_Array* arr = upb_Message_GetMutableArray(msg, f);
5169
+ if (arr) upb_Array_Freeze(arr, m2);
5170
+ break;
5171
+ }
5172
+ case kUpb_FieldMode_Map: {
5173
+ upb_Map* map = upb_Message_GetMutableMap(msg, f);
5174
+ if (map) {
5175
+ const upb_MiniTableField* f2 = upb_MiniTable_MapValue(m2);
5176
+ const upb_MiniTable* m3 = upb_MiniTable_SubMessage(m2, f2);
5177
+ upb_Map_Freeze(map, m3);
5178
+ }
5179
+ break;
5180
+ }
5181
+ case kUpb_FieldMode_Scalar: {
5182
+ if (m2) {
5183
+ upb_Message* msg2 = upb_Message_GetMutableMessage(msg, f);
5184
+ if (msg2) upb_Message_Freeze(msg2, m2);
5185
+ }
5186
+ break;
5187
+ }
5188
+ }
5189
+ }
5190
+
5191
+ // Extensions.
5192
+ size_t ext_count;
5193
+ const upb_Extension* ext = UPB_PRIVATE(_upb_Message_Getexts)(msg, &ext_count);
5194
+
5195
+ for (size_t i = 0; i < ext_count; i++) {
5196
+ const upb_MiniTableExtension* e = ext[i].ext;
5197
+ const upb_MiniTableField* f = &e->UPB_PRIVATE(field);
5198
+ const upb_MiniTable* m2 = upb_MiniTableExtension_GetSubMessage(e);
5199
+
5200
+ upb_MessageValue val;
5201
+ memcpy(&val, &ext[i].data, sizeof(upb_MessageValue));
5202
+
5203
+ switch (UPB_PRIVATE(_upb_MiniTableField_Mode)(f)) {
5204
+ case kUpb_FieldMode_Array: {
5205
+ upb_Array* arr = (upb_Array*)val.array_val;
5206
+ if (arr) upb_Array_Freeze(arr, m2);
5207
+ break;
5208
+ }
5209
+ case kUpb_FieldMode_Map:
5210
+ UPB_UNREACHABLE(); // Maps cannot be extensions.
5211
+ break;
5212
+ case kUpb_FieldMode_Scalar:
5213
+ if (upb_MiniTableField_IsSubMessage(f)) {
5214
+ upb_Message* msg2 = (upb_Message*)val.msg_val;
5215
+ if (msg2) upb_Message_Freeze(msg2, m2);
5216
+ }
5217
+ break;
5218
+ }
5219
+ }
5220
+ }
4919
5221
 
4920
- #include <string.h>
5222
+
5223
+ #include <stddef.h>
4921
5224
 
4922
5225
 
4923
5226
  // Must be last.
4924
5227
 
4925
- bool upb_Message_IsExactlyEqual(const upb_Message* msg1,
4926
- const upb_Message* msg2,
4927
- const upb_MiniTable* m) {
4928
- if (msg1 == msg2) return true;
5228
+ #define kUpb_BaseField_Begin ((size_t)-1)
5229
+ #define kUpb_Extension_Begin ((size_t)-1)
5230
+
5231
+ #ifdef __cplusplus
5232
+ extern "C" {
5233
+ #endif
5234
+
5235
+ static bool _upb_Message_NextBaseField(const upb_Message* msg,
5236
+ const upb_MiniTable* m,
5237
+ const upb_MiniTableField** out_f,
5238
+ upb_MessageValue* out_v, size_t* iter) {
5239
+ const size_t count = upb_MiniTable_FieldCount(m);
5240
+ size_t i = *iter;
5241
+
5242
+ while (++i < count) {
5243
+ const upb_MiniTableField* f = upb_MiniTable_GetFieldByIndex(m, i);
5244
+ const void* src = UPB_PRIVATE(_upb_Message_DataPtr)(msg, f);
5245
+
5246
+ upb_MessageValue val;
5247
+ UPB_PRIVATE(_upb_MiniTableField_DataCopy)(f, &val, src);
5248
+
5249
+ // Skip field if unset or empty.
5250
+ if (upb_MiniTableField_HasPresence(f)) {
5251
+ if (!upb_Message_HasBaseField(msg, f)) continue;
5252
+ } else {
5253
+ if (UPB_PRIVATE(_upb_MiniTableField_DataIsZero)(f, src)) continue;
5254
+
5255
+ if (upb_MiniTableField_IsArray(f)) {
5256
+ if (upb_Array_Size(val.array_val) == 0) continue;
5257
+ } else if (upb_MiniTableField_IsMap(f)) {
5258
+ if (upb_Map_Size(val.map_val) == 0) continue;
5259
+ }
5260
+ }
5261
+
5262
+ *out_f = f;
5263
+ *out_v = val;
5264
+ *iter = i;
5265
+ return true;
5266
+ }
5267
+
5268
+ return false;
5269
+ }
4929
5270
 
4930
- int opts = kUpb_EncodeOption_SkipUnknown | kUpb_EncodeOption_Deterministic;
4931
- upb_Arena* a = upb_Arena_New();
5271
+ static bool _upb_Message_NextExtension(const upb_Message* msg,
5272
+ const upb_MiniTable* m,
5273
+ const upb_MiniTableExtension** out_e,
5274
+ upb_MessageValue* out_v, size_t* iter) {
5275
+ size_t count;
5276
+ const upb_Extension* exts = UPB_PRIVATE(_upb_Message_Getexts)(msg, &count);
5277
+ size_t i = *iter;
4932
5278
 
4933
- // Compare deterministically serialized payloads with no unknown fields.
4934
- size_t size1, size2;
4935
- char *data1, *data2;
4936
- upb_EncodeStatus status1 = upb_Encode(msg1, m, opts, a, &data1, &size1);
4937
- upb_EncodeStatus status2 = upb_Encode(msg2, m, opts, a, &data2, &size2);
5279
+ if (++i < count) {
5280
+ *out_e = exts[i].ext;
5281
+ *out_v = exts[i].data;
5282
+ *iter = i;
5283
+ return true;
5284
+ }
5285
+
5286
+ return false;
5287
+ }
5288
+
5289
+ bool upb_Message_IsEmpty(const upb_Message* msg, const upb_MiniTable* m) {
5290
+ if (upb_Message_ExtensionCount(msg)) return false;
4938
5291
 
4939
- if (status1 != kUpb_EncodeStatus_Ok || status2 != kUpb_EncodeStatus_Ok) {
4940
- // TODO: How should we fail here? (In Ruby we throw an exception.)
4941
- upb_Arena_Free(a);
5292
+ const upb_MiniTableField* f;
5293
+ upb_MessageValue v;
5294
+ size_t iter = kUpb_BaseField_Begin;
5295
+ return !_upb_Message_NextBaseField(msg, m, &f, &v, &iter);
5296
+ }
5297
+
5298
+ static bool _upb_Array_IsEqual(const upb_Array* arr1, const upb_Array* arr2,
5299
+ upb_CType ctype, const upb_MiniTable* m,
5300
+ int options) {
5301
+ // Check for trivial equality.
5302
+ if (arr1 == arr2) return true;
5303
+
5304
+ // Must have identical element counts.
5305
+ const size_t size1 = arr1 ? upb_Array_Size(arr1) : 0;
5306
+ const size_t size2 = arr2 ? upb_Array_Size(arr2) : 0;
5307
+ if (size1 != size2) return false;
5308
+
5309
+ for (size_t i = 0; i < size1; i++) {
5310
+ const upb_MessageValue val1 = upb_Array_Get(arr1, i);
5311
+ const upb_MessageValue val2 = upb_Array_Get(arr2, i);
5312
+
5313
+ if (!upb_MessageValue_IsEqual(val1, val2, ctype, m, options)) return false;
5314
+ }
5315
+
5316
+ return true;
5317
+ }
5318
+
5319
+ static bool _upb_Map_IsEqual(const upb_Map* map1, const upb_Map* map2,
5320
+ const upb_MiniTable* m, int options) {
5321
+ // Check for trivial equality.
5322
+ if (map1 == map2) return true;
5323
+
5324
+ // Must have identical element counts.
5325
+ size_t size1 = map1 ? upb_Map_Size(map1) : 0;
5326
+ size_t size2 = map2 ? upb_Map_Size(map2) : 0;
5327
+ if (size1 != size2) return false;
5328
+
5329
+ const upb_MiniTableField* f = upb_MiniTable_MapValue(m);
5330
+ const upb_MiniTable* m2_value = upb_MiniTable_SubMessage(m, f);
5331
+ const upb_CType ctype = upb_MiniTableField_CType(f);
5332
+
5333
+ upb_MessageValue key, val1, val2;
5334
+ size_t iter = kUpb_Map_Begin;
5335
+ while (upb_Map_Next(map1, &key, &val1, &iter)) {
5336
+ if (!upb_Map_Get(map2, key, &val2)) return false;
5337
+ if (!upb_MessageValue_IsEqual(val1, val2, ctype, m2_value, options))
5338
+ return false;
5339
+ }
5340
+
5341
+ return true;
5342
+ }
5343
+
5344
+ static bool _upb_Message_BaseFieldsAreEqual(const upb_Message* msg1,
5345
+ const upb_Message* msg2,
5346
+ const upb_MiniTable* m,
5347
+ int options) {
5348
+ // Iterate over all base fields for each message.
5349
+ // The order will always match if the messages are equal.
5350
+ size_t iter1 = kUpb_BaseField_Begin;
5351
+ size_t iter2 = kUpb_BaseField_Begin;
5352
+
5353
+ for (;;) {
5354
+ const upb_MiniTableField *f1, *f2;
5355
+ upb_MessageValue val1, val2;
5356
+
5357
+ const bool got1 = _upb_Message_NextBaseField(msg1, m, &f1, &val1, &iter1);
5358
+ const bool got2 = _upb_Message_NextBaseField(msg2, m, &f2, &val2, &iter2);
5359
+
5360
+ if (got1 != got2) return false; // Must have identical field counts.
5361
+ if (!got1) return true; // Loop termination condition.
5362
+ if (f1 != f2) return false; // Must have identical fields set.
5363
+
5364
+ const upb_MiniTable* subm = upb_MiniTable_SubMessage(m, f1);
5365
+ const upb_CType ctype = upb_MiniTableField_CType(f1);
5366
+
5367
+ bool eq;
5368
+ switch (UPB_PRIVATE(_upb_MiniTableField_Mode)(f1)) {
5369
+ case kUpb_FieldMode_Array:
5370
+ eq = _upb_Array_IsEqual(val1.array_val, val2.array_val, ctype, subm,
5371
+ options);
5372
+ break;
5373
+ case kUpb_FieldMode_Map:
5374
+ eq = _upb_Map_IsEqual(val1.map_val, val2.map_val, subm, options);
5375
+ break;
5376
+ case kUpb_FieldMode_Scalar:
5377
+ eq = upb_MessageValue_IsEqual(val1, val2, ctype, subm, options);
5378
+ break;
5379
+ }
5380
+ if (!eq) return false;
5381
+ }
5382
+ }
5383
+
5384
+ static bool _upb_Message_ExtensionsAreEqual(const upb_Message* msg1,
5385
+ const upb_Message* msg2,
5386
+ const upb_MiniTable* m,
5387
+ int options) {
5388
+ // Must have identical extension counts.
5389
+ if (upb_Message_ExtensionCount(msg1) != upb_Message_ExtensionCount(msg2)) {
4942
5390
  return false;
4943
5391
  }
4944
5392
 
4945
- const bool ret = (size1 == size2) && (memcmp(data1, data2, size1) == 0);
4946
- upb_Arena_Free(a);
4947
- return ret;
5393
+ const upb_MiniTableExtension* e;
5394
+ upb_MessageValue val1;
5395
+
5396
+ // Iterate over all extensions for msg1, and search msg2 for each extension.
5397
+ size_t iter1 = kUpb_Extension_Begin;
5398
+ while (_upb_Message_NextExtension(msg1, m, &e, &val1, &iter1)) {
5399
+ const upb_Extension* ext2 = UPB_PRIVATE(_upb_Message_Getext)(msg2, e);
5400
+ if (!ext2) return false;
5401
+
5402
+ const upb_MessageValue val2 = ext2->data;
5403
+ const upb_MiniTableField* f = &e->UPB_PRIVATE(field);
5404
+ const upb_MiniTable* subm = upb_MiniTableField_IsSubMessage(f)
5405
+ ? upb_MiniTableExtension_GetSubMessage(e)
5406
+ : NULL;
5407
+ const upb_CType ctype = upb_MiniTableField_CType(f);
5408
+
5409
+ bool eq;
5410
+ switch (UPB_PRIVATE(_upb_MiniTableField_Mode)(f)) {
5411
+ case kUpb_FieldMode_Array:
5412
+ eq = _upb_Array_IsEqual(val1.array_val, val2.array_val, ctype, subm,
5413
+ options);
5414
+ break;
5415
+ case kUpb_FieldMode_Map:
5416
+ UPB_UNREACHABLE(); // Maps cannot be extensions.
5417
+ break;
5418
+ case kUpb_FieldMode_Scalar: {
5419
+ eq = upb_MessageValue_IsEqual(val1, val2, ctype, subm, options);
5420
+ break;
5421
+ }
5422
+ }
5423
+ if (!eq) return false;
5424
+ }
5425
+ return true;
5426
+ }
5427
+
5428
+ bool upb_Message_IsEqual(const upb_Message* msg1, const upb_Message* msg2,
5429
+ const upb_MiniTable* m, int options) {
5430
+ if (UPB_UNLIKELY(msg1 == msg2)) return true;
5431
+
5432
+ if (!_upb_Message_BaseFieldsAreEqual(msg1, msg2, m, options)) return false;
5433
+ if (!_upb_Message_ExtensionsAreEqual(msg1, msg2, m, options)) return false;
5434
+
5435
+ if (!(options & kUpb_CompareOption_IncludeUnknownFields)) return true;
5436
+
5437
+ // Check the unknown fields.
5438
+ size_t usize1, usize2;
5439
+ const char* uf1 = upb_Message_GetUnknown(msg1, &usize1);
5440
+ const char* uf2 = upb_Message_GetUnknown(msg2, &usize2);
5441
+
5442
+ // The wire encoder enforces a maximum depth of 100 so we match that here.
5443
+ return UPB_PRIVATE(_upb_Message_UnknownFieldsAreEqual)(
5444
+ uf1, usize1, uf2, usize2, 100) == kUpb_UnknownCompareResult_Equal;
4948
5445
  }
4949
5446
 
4950
5447
 
@@ -5018,7 +5515,7 @@ upb_Map* upb_Map_DeepClone(const upb_Map* map, upb_CType key_type,
5018
5515
  size_t iter = kUpb_Map_Begin;
5019
5516
  while (upb_Map_Next(map, &key, &val, &iter)) {
5020
5517
  const upb_MiniTableField* value_field =
5021
- &map_entry_table->UPB_PRIVATE(fields)[1];
5518
+ upb_MiniTable_MapValue(map_entry_table);
5022
5519
  const upb_MiniTable* value_sub =
5023
5520
  upb_MiniTableField_CType(value_field) == kUpb_CType_Message
5024
5521
  ? upb_MiniTable_GetSubMessageTable(map_entry_table, value_field)
@@ -5044,10 +5541,9 @@ static upb_Map* upb_Message_Map_DeepClone(const upb_Map* map,
5044
5541
  mini_table->UPB_PRIVATE(subs)[f->UPB_PRIVATE(submsg_index)]);
5045
5542
  UPB_ASSERT(map_entry_table);
5046
5543
 
5047
- const upb_MiniTableField* key_field =
5048
- &map_entry_table->UPB_PRIVATE(fields)[0];
5544
+ const upb_MiniTableField* key_field = upb_MiniTable_MapKey(map_entry_table);
5049
5545
  const upb_MiniTableField* value_field =
5050
- &map_entry_table->UPB_PRIVATE(fields)[1];
5546
+ upb_MiniTable_MapValue(map_entry_table);
5051
5547
 
5052
5548
  upb_Map* cloned_map = upb_Map_DeepClone(
5053
5549
  map, upb_MiniTableField_CType(key_field),
@@ -5055,13 +5551,13 @@ static upb_Map* upb_Message_Map_DeepClone(const upb_Map* map,
5055
5551
  if (!cloned_map) {
5056
5552
  return NULL;
5057
5553
  }
5058
- _upb_Message_SetNonExtensionField(clone, f, &cloned_map);
5554
+ upb_Message_SetBaseField(clone, f, &cloned_map);
5059
5555
  return cloned_map;
5060
5556
  }
5061
5557
 
5062
5558
  upb_Array* upb_Array_DeepClone(const upb_Array* array, upb_CType value_type,
5063
5559
  const upb_MiniTable* sub, upb_Arena* arena) {
5064
- const size_t size = array->UPB_PRIVATE(size);
5560
+ const size_t size = upb_Array_Size(array);
5065
5561
  const int lg2 = UPB_PRIVATE(_upb_CType_SizeLg2)(value_type);
5066
5562
  upb_Array* cloned_array = UPB_PRIVATE(_upb_Array_New)(arena, size, lg2);
5067
5563
  if (!cloned_array) {
@@ -5093,7 +5589,7 @@ static bool upb_Message_Array_DeepClone(const upb_Array* array,
5093
5589
  arena);
5094
5590
 
5095
5591
  // Clear out upb_Array* due to parent memcpy.
5096
- _upb_Message_SetNonExtensionField(clone, field, &cloned_array);
5592
+ upb_Message_SetBaseField(clone, field, &cloned_array);
5097
5593
  return true;
5098
5594
  }
5099
5595
 
@@ -5102,8 +5598,7 @@ static bool upb_Clone_ExtensionValue(
5102
5598
  upb_Extension* dest, upb_Arena* arena) {
5103
5599
  dest->data = source->data;
5104
5600
  return upb_Clone_MessageValue(
5105
- &dest->data,
5106
- upb_MiniTableField_CType(&mini_table_ext->UPB_PRIVATE(field)),
5601
+ &dest->data, upb_MiniTableExtension_CType(mini_table_ext),
5107
5602
  upb_MiniTableExtension_GetSubMessage(mini_table_ext), arena);
5108
5603
  }
5109
5604
 
@@ -5113,8 +5608,9 @@ upb_Message* _upb_Message_Copy(upb_Message* dst, const upb_Message* src,
5113
5608
  upb_StringView empty_string = upb_StringView_FromDataAndSize(NULL, 0);
5114
5609
  // Only copy message area skipping upb_Message_Internal.
5115
5610
  memcpy(dst + 1, src + 1, mini_table->UPB_PRIVATE(size) - sizeof(upb_Message));
5116
- for (size_t i = 0; i < mini_table->UPB_PRIVATE(field_count); ++i) {
5117
- const upb_MiniTableField* field = &mini_table->UPB_PRIVATE(fields)[i];
5611
+ for (int i = 0; i < upb_MiniTable_FieldCount(mini_table); ++i) {
5612
+ const upb_MiniTableField* field =
5613
+ upb_MiniTable_GetFieldByIndex(mini_table, i);
5118
5614
  if (upb_MiniTableField_IsScalar(field)) {
5119
5615
  switch (upb_MiniTableField_CType(field)) {
5120
5616
  case kUpb_CType_Message: {
@@ -5188,7 +5684,7 @@ upb_Message* _upb_Message_Copy(upb_Message* dst, const upb_Message* src,
5188
5684
  return NULL;
5189
5685
  }
5190
5686
  } else {
5191
- upb_Array* msg_array = (upb_Array*)msg_ext->data.ptr;
5687
+ upb_Array* msg_array = (upb_Array*)msg_ext->data.array_val;
5192
5688
  UPB_ASSERT(msg_array);
5193
5689
  upb_Array* cloned_array = upb_Array_DeepClone(
5194
5690
  msg_array, upb_MiniTableField_CType(field),
@@ -5196,7 +5692,7 @@ upb_Message* _upb_Message_Copy(upb_Message* dst, const upb_Message* src,
5196
5692
  if (!cloned_array) {
5197
5693
  return NULL;
5198
5694
  }
5199
- dst_ext->data.ptr = (void*)cloned_array;
5695
+ dst_ext->data.array_val = cloned_array;
5200
5696
  }
5201
5697
  }
5202
5698
 
@@ -5348,9 +5844,9 @@ static upb_MiniTableEnum* upb_MtDecoder_BuildMiniTableEnum(
5348
5844
  return upb_MtDecoder_DoBuildMiniTableEnum(decoder, data, len);
5349
5845
  }
5350
5846
 
5351
- upb_MiniTableEnum* upb_MiniDescriptor_BuildEnum(const char* data, size_t len,
5352
- upb_Arena* arena,
5353
- upb_Status* status) {
5847
+ upb_MiniTableEnum* upb_MiniTableEnum_Build(const char* data, size_t len,
5848
+ upb_Arena* arena,
5849
+ upb_Status* status) {
5354
5850
  upb_MdEnumDecoder decoder = {
5355
5851
  .base =
5356
5852
  {
@@ -5391,7 +5887,7 @@ typedef enum {
5391
5887
  kUpb_LayoutItemType_Max = kUpb_LayoutItemType_Field,
5392
5888
  } upb_LayoutItemType;
5393
5889
 
5394
- #define kUpb_LayoutItem_IndexSentinel ((uint16_t)-1)
5890
+ #define kUpb_LayoutItem_IndexSentinel ((uint16_t) - 1)
5395
5891
 
5396
5892
  typedef struct {
5397
5893
  // Index of the corresponding field. When this is a oneof field, the field's
@@ -5588,6 +6084,12 @@ static void upb_MtDecoder_ModifyField(upb_MtDecoder* d,
5588
6084
  upb_MiniTableField_Number(field));
5589
6085
  }
5590
6086
 
6087
+ if (singular && upb_MiniTableField_IsSubMessage(field)) {
6088
+ upb_MdDecoder_ErrorJmp(&d->base,
6089
+ "Field %" PRIu32 " cannot be a singular submessage",
6090
+ upb_MiniTableField_Number(field));
6091
+ }
6092
+
5591
6093
  if (singular) field->UPB_PRIVATE(offset) = kNoPresence;
5592
6094
  if (required) {
5593
6095
  field->UPB_PRIVATE(offset) = kRequiredPresence;
@@ -6074,6 +6576,11 @@ static upb_MiniTable* upb_MtDecoder_DoBuildMiniTableWithBuf(
6074
6576
  decoder->table->UPB_PRIVATE(dense_below) = 0;
6075
6577
  decoder->table->UPB_PRIVATE(table_mask) = -1;
6076
6578
  decoder->table->UPB_PRIVATE(required_count) = 0;
6579
+ #if UPB_TRACING_ENABLED
6580
+ // MiniTables built from MiniDescriptors will not be able to vend the message
6581
+ // name unless it is explicitly set with upb_MiniTable_SetFullName().
6582
+ decoder->table->UPB_PRIVATE(full_name) = 0;
6583
+ #endif
6077
6584
 
6078
6585
  // Strip off and verify the version tag.
6079
6586
  if (!len--) goto done;
@@ -6292,13 +6799,13 @@ bool upb_MiniTable_SetSubEnum(upb_MiniTable* table, upb_MiniTableField* field,
6292
6799
  return true;
6293
6800
  }
6294
6801
 
6295
- uint32_t upb_MiniTable_GetSubList(const upb_MiniTable* mt,
6802
+ uint32_t upb_MiniTable_GetSubList(const upb_MiniTable* m,
6296
6803
  const upb_MiniTableField** subs) {
6297
6804
  uint32_t msg_count = 0;
6298
6805
  uint32_t enum_count = 0;
6299
6806
 
6300
- for (int i = 0; i < mt->UPB_PRIVATE(field_count); i++) {
6301
- const upb_MiniTableField* f = &mt->UPB_PRIVATE(fields)[i];
6807
+ for (int i = 0; i < upb_MiniTable_FieldCount(m); i++) {
6808
+ const upb_MiniTableField* f = upb_MiniTable_GetFieldByIndex(m, i);
6302
6809
  if (upb_MiniTableField_CType(f) == kUpb_CType_Message) {
6303
6810
  *subs = f;
6304
6811
  ++subs;
@@ -6306,9 +6813,9 @@ uint32_t upb_MiniTable_GetSubList(const upb_MiniTable* mt,
6306
6813
  }
6307
6814
  }
6308
6815
 
6309
- for (int i = 0; i < mt->UPB_PRIVATE(field_count); i++) {
6310
- const upb_MiniTableField* f = &mt->UPB_PRIVATE(fields)[i];
6311
- if (upb_MiniTableField_CType(f) == kUpb_CType_Enum) {
6816
+ for (int i = 0; i < upb_MiniTable_FieldCount(m); i++) {
6817
+ const upb_MiniTableField* f = upb_MiniTable_GetFieldByIndex(m, i);
6818
+ if (upb_MiniTableField_IsClosedEnum(f)) {
6312
6819
  *subs = f;
6313
6820
  ++subs;
6314
6821
  enum_count++;
@@ -6321,36 +6828,34 @@ uint32_t upb_MiniTable_GetSubList(const upb_MiniTable* mt,
6321
6828
  // The list of sub_tables and sub_enums must exactly match the number and order
6322
6829
  // of sub-message fields and sub-enum fields given by upb_MiniTable_GetSubList()
6323
6830
  // above.
6324
- bool upb_MiniTable_Link(upb_MiniTable* mt, const upb_MiniTable** sub_tables,
6831
+ bool upb_MiniTable_Link(upb_MiniTable* m, const upb_MiniTable** sub_tables,
6325
6832
  size_t sub_table_count,
6326
6833
  const upb_MiniTableEnum** sub_enums,
6327
6834
  size_t sub_enum_count) {
6328
6835
  uint32_t msg_count = 0;
6329
6836
  uint32_t enum_count = 0;
6330
6837
 
6331
- for (int i = 0; i < mt->UPB_PRIVATE(field_count); i++) {
6332
- upb_MiniTableField* f = (upb_MiniTableField*)&mt->UPB_PRIVATE(fields)[i];
6838
+ for (int i = 0; i < upb_MiniTable_FieldCount(m); i++) {
6839
+ upb_MiniTableField* f =
6840
+ (upb_MiniTableField*)upb_MiniTable_GetFieldByIndex(m, i);
6333
6841
  if (upb_MiniTableField_CType(f) == kUpb_CType_Message) {
6334
6842
  const upb_MiniTable* sub = sub_tables[msg_count++];
6335
6843
  if (msg_count > sub_table_count) return false;
6336
- if (sub != NULL) {
6337
- if (!upb_MiniTable_SetSubMessage(mt, f, sub)) return false;
6338
- }
6844
+ if (sub && !upb_MiniTable_SetSubMessage(m, f, sub)) return false;
6339
6845
  }
6340
6846
  }
6341
6847
 
6342
- for (int i = 0; i < mt->UPB_PRIVATE(field_count); i++) {
6343
- upb_MiniTableField* f = (upb_MiniTableField*)&mt->UPB_PRIVATE(fields)[i];
6848
+ for (int i = 0; i < upb_MiniTable_FieldCount(m); i++) {
6849
+ upb_MiniTableField* f =
6850
+ (upb_MiniTableField*)upb_MiniTable_GetFieldByIndex(m, i);
6344
6851
  if (upb_MiniTableField_IsClosedEnum(f)) {
6345
6852
  const upb_MiniTableEnum* sub = sub_enums[enum_count++];
6346
6853
  if (enum_count > sub_enum_count) return false;
6347
- if (sub != NULL) {
6348
- if (!upb_MiniTable_SetSubEnum(mt, f, sub)) return false;
6349
- }
6854
+ if (sub && !upb_MiniTable_SetSubEnum(m, f, sub)) return false;
6350
6855
  }
6351
6856
  }
6352
6857
 
6353
- return true;
6858
+ return (msg_count == sub_table_count) && (enum_count == sub_enum_count);
6354
6859
  }
6355
6860
 
6356
6861
 
@@ -6705,8 +7210,7 @@ static _upb_DecodeLongVarintReturn _upb_Decoder_DecodeLongVarint(
6705
7210
  const char* ptr, uint64_t val) {
6706
7211
  _upb_DecodeLongVarintReturn ret = {NULL, 0};
6707
7212
  uint64_t byte;
6708
- int i;
6709
- for (i = 1; i < 10; i++) {
7213
+ for (int i = 1; i < 10; i++) {
6710
7214
  byte = (uint8_t)ptr[i];
6711
7215
  val += (byte - 1) << (i * 7);
6712
7216
  if (!(byte & 0x80)) {
@@ -6719,8 +7223,8 @@ static _upb_DecodeLongVarintReturn _upb_Decoder_DecodeLongVarint(
6719
7223
  }
6720
7224
 
6721
7225
  UPB_FORCEINLINE
6722
- static const char* _upb_Decoder_DecodeVarint(upb_Decoder* d, const char* ptr,
6723
- uint64_t* val) {
7226
+ const char* _upb_Decoder_DecodeVarint(upb_Decoder* d, const char* ptr,
7227
+ uint64_t* val) {
6724
7228
  uint64_t byte = (uint8_t)*ptr;
6725
7229
  if (UPB_LIKELY((byte & 0x80) == 0)) {
6726
7230
  *val = byte;
@@ -6734,8 +7238,8 @@ static const char* _upb_Decoder_DecodeVarint(upb_Decoder* d, const char* ptr,
6734
7238
  }
6735
7239
 
6736
7240
  UPB_FORCEINLINE
6737
- static const char* _upb_Decoder_DecodeTag(upb_Decoder* d, const char* ptr,
6738
- uint32_t* val) {
7241
+ const char* _upb_Decoder_DecodeTag(upb_Decoder* d, const char* ptr,
7242
+ uint32_t* val) {
6739
7243
  uint64_t byte = (uint8_t)*ptr;
6740
7244
  if (UPB_LIKELY((byte & 0x80) == 0)) {
6741
7245
  *val = byte;
@@ -6752,8 +7256,8 @@ static const char* _upb_Decoder_DecodeTag(upb_Decoder* d, const char* ptr,
6752
7256
  }
6753
7257
 
6754
7258
  UPB_FORCEINLINE
6755
- static const char* upb_Decoder_DecodeSize(upb_Decoder* d, const char* ptr,
6756
- uint32_t* size) {
7259
+ const char* upb_Decoder_DecodeSize(upb_Decoder* d, const char* ptr,
7260
+ uint32_t* size) {
6757
7261
  uint64_t size64;
6758
7262
  ptr = _upb_Decoder_DecodeVarint(d, ptr, &size64);
6759
7263
  if (size64 >= INT32_MAX ||
@@ -6855,11 +7359,10 @@ static const char* _upb_Decoder_ReadString(upb_Decoder* d, const char* ptr,
6855
7359
  }
6856
7360
 
6857
7361
  UPB_FORCEINLINE
6858
- static const char* _upb_Decoder_RecurseSubMessage(upb_Decoder* d,
6859
- const char* ptr,
6860
- upb_Message* submsg,
6861
- const upb_MiniTable* subl,
6862
- uint32_t expected_end_group) {
7362
+ const char* _upb_Decoder_RecurseSubMessage(upb_Decoder* d, const char* ptr,
7363
+ upb_Message* submsg,
7364
+ const upb_MiniTable* subl,
7365
+ uint32_t expected_end_group) {
6863
7366
  if (--d->depth < 0) {
6864
7367
  _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_MaxDepthExceeded);
6865
7368
  }
@@ -6872,9 +7375,11 @@ static const char* _upb_Decoder_RecurseSubMessage(upb_Decoder* d,
6872
7375
  }
6873
7376
 
6874
7377
  UPB_FORCEINLINE
6875
- static const char* _upb_Decoder_DecodeSubMessage(
6876
- upb_Decoder* d, const char* ptr, upb_Message* submsg,
6877
- const upb_MiniTableSub* subs, const upb_MiniTableField* field, int size) {
7378
+ const char* _upb_Decoder_DecodeSubMessage(upb_Decoder* d, const char* ptr,
7379
+ upb_Message* submsg,
7380
+ const upb_MiniTableSub* subs,
7381
+ const upb_MiniTableField* field,
7382
+ int size) {
6878
7383
  int saved_delta = upb_EpsCopyInputStream_PushLimit(&d->input, ptr, size);
6879
7384
  const upb_MiniTable* subl = _upb_MiniTableSubs_MessageByField(subs, field);
6880
7385
  UPB_ASSERT(subl);
@@ -6884,10 +7389,10 @@ static const char* _upb_Decoder_DecodeSubMessage(
6884
7389
  }
6885
7390
 
6886
7391
  UPB_FORCEINLINE
6887
- static const char* _upb_Decoder_DecodeGroup(upb_Decoder* d, const char* ptr,
6888
- upb_Message* submsg,
6889
- const upb_MiniTable* subl,
6890
- uint32_t number) {
7392
+ const char* _upb_Decoder_DecodeGroup(upb_Decoder* d, const char* ptr,
7393
+ upb_Message* submsg,
7394
+ const upb_MiniTable* subl,
7395
+ uint32_t number) {
6891
7396
  if (_upb_Decoder_IsDone(d, &ptr)) {
6892
7397
  _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_Malformed);
6893
7398
  }
@@ -6897,16 +7402,16 @@ static const char* _upb_Decoder_DecodeGroup(upb_Decoder* d, const char* ptr,
6897
7402
  }
6898
7403
 
6899
7404
  UPB_FORCEINLINE
6900
- static const char* _upb_Decoder_DecodeUnknownGroup(upb_Decoder* d,
6901
- const char* ptr,
6902
- uint32_t number) {
7405
+ const char* _upb_Decoder_DecodeUnknownGroup(upb_Decoder* d, const char* ptr,
7406
+ uint32_t number) {
6903
7407
  return _upb_Decoder_DecodeGroup(d, ptr, NULL, NULL, number);
6904
7408
  }
6905
7409
 
6906
7410
  UPB_FORCEINLINE
6907
- static const char* _upb_Decoder_DecodeKnownGroup(
6908
- upb_Decoder* d, const char* ptr, upb_Message* submsg,
6909
- const upb_MiniTableSub* subs, const upb_MiniTableField* field) {
7411
+ const char* _upb_Decoder_DecodeKnownGroup(upb_Decoder* d, const char* ptr,
7412
+ upb_Message* submsg,
7413
+ const upb_MiniTableSub* subs,
7414
+ const upb_MiniTableField* field) {
6910
7415
  const upb_MiniTable* subl = _upb_MiniTableSubs_MessageByField(subs, field);
6911
7416
  UPB_ASSERT(subl);
6912
7417
  return _upb_Decoder_DecodeGroup(d, ptr, submsg, subl,
@@ -6936,10 +7441,9 @@ static void _upb_Decoder_AddUnknownVarints(upb_Decoder* d, upb_Message* msg,
6936
7441
  }
6937
7442
 
6938
7443
  UPB_FORCEINLINE
6939
- static bool _upb_Decoder_CheckEnum(upb_Decoder* d, const char* ptr,
6940
- upb_Message* msg, const upb_MiniTableEnum* e,
6941
- const upb_MiniTableField* field,
6942
- wireval* val) {
7444
+ bool _upb_Decoder_CheckEnum(upb_Decoder* d, const char* ptr, upb_Message* msg,
7445
+ const upb_MiniTableEnum* e,
7446
+ const upb_MiniTableField* field, wireval* val) {
6943
7447
  const uint32_t v = val->uint32_val;
6944
7448
 
6945
7449
  if (UPB_LIKELY(upb_MiniTableEnum_CheckValue(e, v))) return true;
@@ -6973,9 +7477,10 @@ static const char* _upb_Decoder_DecodeEnumArray(upb_Decoder* d, const char* ptr,
6973
7477
  }
6974
7478
 
6975
7479
  UPB_FORCEINLINE
6976
- static const char* _upb_Decoder_DecodeFixedPacked(
6977
- upb_Decoder* d, const char* ptr, upb_Array* arr, wireval* val,
6978
- const upb_MiniTableField* field, int lg2) {
7480
+ const char* _upb_Decoder_DecodeFixedPacked(upb_Decoder* d, const char* ptr,
7481
+ upb_Array* arr, wireval* val,
7482
+ const upb_MiniTableField* field,
7483
+ int lg2) {
6979
7484
  int mask = (1 << lg2) - 1;
6980
7485
  size_t count = val->size >> lg2;
6981
7486
  if ((val->size & mask) != 0) {
@@ -7010,9 +7515,10 @@ static const char* _upb_Decoder_DecodeFixedPacked(
7010
7515
  }
7011
7516
 
7012
7517
  UPB_FORCEINLINE
7013
- static const char* _upb_Decoder_DecodeVarintPacked(
7014
- upb_Decoder* d, const char* ptr, upb_Array* arr, wireval* val,
7015
- const upb_MiniTableField* field, int lg2) {
7518
+ const char* _upb_Decoder_DecodeVarintPacked(upb_Decoder* d, const char* ptr,
7519
+ upb_Array* arr, wireval* val,
7520
+ const upb_MiniTableField* field,
7521
+ int lg2) {
7016
7522
  int scale = 1 << lg2;
7017
7523
  int saved_limit = upb_EpsCopyInputStream_PushLimit(&d->input, ptr, val->size);
7018
7524
  char* out = UPB_PTR_AT(upb_Array_MutableDataPtr(arr),
@@ -7255,7 +7761,7 @@ static const char* _upb_Decoder_DecodeToSubMessage(
7255
7761
  // Set presence if necessary.
7256
7762
  if (UPB_PRIVATE(_upb_MiniTableField_HasHasbit)(field)) {
7257
7763
  UPB_PRIVATE(_upb_Message_SetHasbit)(msg, field);
7258
- } else if (UPB_PRIVATE(_upb_MiniTableField_IsInOneof)(field)) {
7764
+ } else if (upb_MiniTableField_IsInOneof(field)) {
7259
7765
  // Oneof case
7260
7766
  uint32_t* oneof_case = UPB_PRIVATE(_upb_Message_OneofCasePtr)(msg, field);
7261
7767
  if (op == kUpb_DecodeOp_SubMessage &&
@@ -7318,9 +7824,8 @@ const char* _upb_Decoder_CheckRequired(upb_Decoder* d, const char* ptr,
7318
7824
  }
7319
7825
 
7320
7826
  UPB_FORCEINLINE
7321
- static bool _upb_Decoder_TryFastDispatch(upb_Decoder* d, const char** ptr,
7322
- upb_Message* msg,
7323
- const upb_MiniTable* m) {
7827
+ bool _upb_Decoder_TryFastDispatch(upb_Decoder* d, const char** ptr,
7828
+ upb_Message* msg, const upb_MiniTable* m) {
7324
7829
  #if UPB_FASTTABLE
7325
7830
  if (m && m->UPB_PRIVATE(table_mask) != (unsigned char)-1) {
7326
7831
  uint16_t tag = _upb_FastDecoder_LoadTag(*ptr);
@@ -7558,9 +8063,8 @@ static int _upb_Decoder_GetVarintOp(const upb_MiniTableField* field) {
7558
8063
  }
7559
8064
 
7560
8065
  UPB_FORCEINLINE
7561
- static void _upb_Decoder_CheckUnlinked(upb_Decoder* d, const upb_MiniTable* mt,
7562
- const upb_MiniTableField* field,
7563
- int* op) {
8066
+ void _upb_Decoder_CheckUnlinked(upb_Decoder* d, const upb_MiniTable* mt,
8067
+ const upb_MiniTableField* field, int* op) {
7564
8068
  // If sub-message is not linked, treat as unknown.
7565
8069
  if (field->UPB_PRIVATE(mode) & kUpb_LabelFlags_IsExtension) return;
7566
8070
  const upb_MiniTable* mt_sub =
@@ -7586,9 +8090,8 @@ static void _upb_Decoder_CheckUnlinked(upb_Decoder* d, const upb_MiniTable* mt,
7586
8090
  }
7587
8091
 
7588
8092
  UPB_FORCEINLINE
7589
- static void _upb_Decoder_MaybeVerifyUtf8(upb_Decoder* d,
7590
- const upb_MiniTableField* field,
7591
- int* op) {
8093
+ void _upb_Decoder_MaybeVerifyUtf8(upb_Decoder* d,
8094
+ const upb_MiniTableField* field, int* op) {
7592
8095
  if ((field->UPB_ONLYBITS(mode) & kUpb_LabelFlags_IsAlternate) &&
7593
8096
  UPB_UNLIKELY(d->options & kUpb_DecodeOption_AlwaysValidateUtf8))
7594
8097
  *op = kUpb_DecodeOp_String;
@@ -7658,11 +8161,10 @@ static int _upb_Decoder_GetDelimitedOp(upb_Decoder* d, const upb_MiniTable* mt,
7658
8161
  }
7659
8162
 
7660
8163
  UPB_FORCEINLINE
7661
- static const char* _upb_Decoder_DecodeWireValue(upb_Decoder* d, const char* ptr,
7662
- const upb_MiniTable* mt,
7663
- const upb_MiniTableField* field,
7664
- int wire_type, wireval* val,
7665
- int* op) {
8164
+ const char* _upb_Decoder_DecodeWireValue(upb_Decoder* d, const char* ptr,
8165
+ const upb_MiniTable* mt,
8166
+ const upb_MiniTableField* field,
8167
+ int wire_type, wireval* val, int* op) {
7666
8168
  static const unsigned kFixed32OkMask = (1 << kUpb_FieldType_Float) |
7667
8169
  (1 << kUpb_FieldType_Fixed32) |
7668
8170
  (1 << kUpb_FieldType_SFixed32);
@@ -7712,10 +8214,11 @@ static const char* _upb_Decoder_DecodeWireValue(upb_Decoder* d, const char* ptr,
7712
8214
  }
7713
8215
 
7714
8216
  UPB_FORCEINLINE
7715
- static const char* _upb_Decoder_DecodeKnownField(
7716
- upb_Decoder* d, const char* ptr, upb_Message* msg,
7717
- const upb_MiniTable* layout, const upb_MiniTableField* field, int op,
7718
- wireval* val) {
8217
+ const char* _upb_Decoder_DecodeKnownField(upb_Decoder* d, const char* ptr,
8218
+ upb_Message* msg,
8219
+ const upb_MiniTable* layout,
8220
+ const upb_MiniTableField* field,
8221
+ int op, wireval* val) {
7719
8222
  const upb_MiniTableSub* subs = layout->UPB_PRIVATE(subs);
7720
8223
  uint8_t mode = field->UPB_PRIVATE(mode);
7721
8224
 
@@ -7921,9 +8424,10 @@ static upb_DecodeStatus upb_Decoder_Decode(upb_Decoder* const decoder,
7921
8424
  }
7922
8425
 
7923
8426
  upb_DecodeStatus upb_Decode(const char* buf, size_t size, upb_Message* msg,
7924
- const upb_MiniTable* m,
8427
+ const upb_MiniTable* mt,
7925
8428
  const upb_ExtensionRegistry* extreg, int options,
7926
8429
  upb_Arena* arena) {
8430
+ UPB_ASSERT(!upb_Message_IsFrozen(msg));
7927
8431
  upb_Decoder decoder;
7928
8432
  unsigned depth = (unsigned)options >> 16;
7929
8433
 
@@ -7945,7 +8449,42 @@ upb_DecodeStatus upb_Decode(const char* buf, size_t size, upb_Message* msg,
7945
8449
  // (particularly parent_or_count).
7946
8450
  UPB_PRIVATE(_upb_Arena_SwapIn)(&decoder.arena, arena);
7947
8451
 
7948
- return upb_Decoder_Decode(&decoder, buf, msg, m, arena);
8452
+ return upb_Decoder_Decode(&decoder, buf, msg, mt, arena);
8453
+ }
8454
+
8455
+ upb_DecodeStatus upb_DecodeLengthPrefixed(const char* buf, size_t size,
8456
+ upb_Message* msg,
8457
+ size_t* num_bytes_read,
8458
+ const upb_MiniTable* mt,
8459
+ const upb_ExtensionRegistry* extreg,
8460
+ int options, upb_Arena* arena) {
8461
+ // To avoid needing to make a Decoder just to decode the initial length,
8462
+ // hand-decode the leading varint for the message length here.
8463
+ uint64_t msg_len = 0;
8464
+ for (size_t i = 0;; ++i) {
8465
+ if (i >= size || i > 9) {
8466
+ return kUpb_DecodeStatus_Malformed;
8467
+ }
8468
+ uint64_t b = *buf;
8469
+ buf++;
8470
+ msg_len += (b & 0x7f) << (i * 7);
8471
+ if ((b & 0x80) == 0) {
8472
+ *num_bytes_read = i + 1 + msg_len;
8473
+ break;
8474
+ }
8475
+ }
8476
+
8477
+ // If the total number of bytes we would read (= the bytes from the varint
8478
+ // plus however many bytes that varint says we should read) is larger then the
8479
+ // input buffer then error as malformed.
8480
+ if (*num_bytes_read > size) {
8481
+ return kUpb_DecodeStatus_Malformed;
8482
+ }
8483
+ if (msg_len > INT32_MAX) {
8484
+ return kUpb_DecodeStatus_Malformed;
8485
+ }
8486
+
8487
+ return upb_Decode(buf, msg_len, msg, mt, extreg, options, arena);
7949
8488
  }
7950
8489
 
7951
8490
  #undef OP_FIXPCK_LG2
@@ -8032,7 +8571,7 @@ static void encode_growbuffer(upb_encstate* e, size_t bytes) {
8032
8571
  /* Call to ensure that at least "bytes" bytes are available for writing at
8033
8572
  * e->ptr. Returns false if the bytes could not be allocated. */
8034
8573
  UPB_FORCEINLINE
8035
- static void encode_reserve(upb_encstate* e, size_t bytes) {
8574
+ void encode_reserve(upb_encstate* e, size_t bytes) {
8036
8575
  if ((size_t)(e->ptr - e->buf) < bytes) {
8037
8576
  encode_growbuffer(e, bytes);
8038
8577
  return;
@@ -8071,7 +8610,7 @@ static void encode_longvarint(upb_encstate* e, uint64_t val) {
8071
8610
  }
8072
8611
 
8073
8612
  UPB_FORCEINLINE
8074
- static void encode_varint(upb_encstate* e, uint64_t val) {
8613
+ void encode_varint(upb_encstate* e, uint64_t val) {
8075
8614
  if (val < 128 && e->ptr != e->buf) {
8076
8615
  --e->ptr;
8077
8616
  *e->ptr = val;
@@ -8101,7 +8640,7 @@ static void encode_tag(upb_encstate* e, uint32_t field_number,
8101
8640
 
8102
8641
  static void encode_fixedarray(upb_encstate* e, const upb_Array* arr,
8103
8642
  size_t elem_size, uint32_t tag) {
8104
- size_t bytes = arr->UPB_PRIVATE(size) * elem_size;
8643
+ size_t bytes = upb_Array_Size(arr) * elem_size;
8105
8644
  const char* data = upb_Array_DataPtr(arr);
8106
8645
  const char* ptr = data + bytes - elem_size;
8107
8646
 
@@ -8198,7 +8737,7 @@ static void encode_scalar(upb_encstate* e, const void* _field_mem,
8198
8737
  return;
8199
8738
  }
8200
8739
  if (--e->depth == 0) encode_err(e, kUpb_EncodeStatus_MaxDepthExceeded);
8201
- encode_tag(e, f->UPB_PRIVATE(number), kUpb_WireType_EndGroup);
8740
+ encode_tag(e, upb_MiniTableField_Number(f), kUpb_WireType_EndGroup);
8202
8741
  encode_TaggedMessagePtr(e, submsg, subm, &size);
8203
8742
  wire_type = kUpb_WireType_StartGroup;
8204
8743
  e->depth++;
@@ -8224,7 +8763,7 @@ static void encode_scalar(upb_encstate* e, const void* _field_mem,
8224
8763
  }
8225
8764
  #undef CASE
8226
8765
 
8227
- encode_tag(e, f->UPB_PRIVATE(number), wire_type);
8766
+ encode_tag(e, upb_MiniTableField_Number(f), wire_type);
8228
8767
  }
8229
8768
 
8230
8769
  static void encode_array(upb_encstate* e, const upb_Message* msg,
@@ -8234,14 +8773,14 @@ static void encode_array(upb_encstate* e, const upb_Message* msg,
8234
8773
  bool packed = upb_MiniTableField_IsPacked(f);
8235
8774
  size_t pre_len = e->limit - e->ptr;
8236
8775
 
8237
- if (arr == NULL || arr->UPB_PRIVATE(size) == 0) {
8776
+ if (arr == NULL || upb_Array_Size(arr) == 0) {
8238
8777
  return;
8239
8778
  }
8240
8779
 
8241
8780
  #define VARINT_CASE(ctype, encode) \
8242
8781
  { \
8243
8782
  const ctype* start = upb_Array_DataPtr(arr); \
8244
- const ctype* ptr = start + arr->UPB_PRIVATE(size); \
8783
+ const ctype* ptr = start + upb_Array_Size(arr); \
8245
8784
  uint32_t tag = \
8246
8785
  packed ? 0 : (f->UPB_PRIVATE(number) << 3) | kUpb_WireType_Varint; \
8247
8786
  do { \
@@ -8286,34 +8825,34 @@ static void encode_array(upb_encstate* e, const upb_Message* msg,
8286
8825
  case kUpb_FieldType_String:
8287
8826
  case kUpb_FieldType_Bytes: {
8288
8827
  const upb_StringView* start = upb_Array_DataPtr(arr);
8289
- const upb_StringView* ptr = start + arr->UPB_PRIVATE(size);
8828
+ const upb_StringView* ptr = start + upb_Array_Size(arr);
8290
8829
  do {
8291
8830
  ptr--;
8292
8831
  encode_bytes(e, ptr->data, ptr->size);
8293
8832
  encode_varint(e, ptr->size);
8294
- encode_tag(e, f->UPB_PRIVATE(number), kUpb_WireType_Delimited);
8833
+ encode_tag(e, upb_MiniTableField_Number(f), kUpb_WireType_Delimited);
8295
8834
  } while (ptr != start);
8296
8835
  return;
8297
8836
  }
8298
8837
  case kUpb_FieldType_Group: {
8299
8838
  const upb_TaggedMessagePtr* start = upb_Array_DataPtr(arr);
8300
- const upb_TaggedMessagePtr* ptr = start + arr->UPB_PRIVATE(size);
8839
+ const upb_TaggedMessagePtr* ptr = start + upb_Array_Size(arr);
8301
8840
  const upb_MiniTable* subm =
8302
8841
  upb_MiniTableSub_Message(subs[f->UPB_PRIVATE(submsg_index)]);
8303
8842
  if (--e->depth == 0) encode_err(e, kUpb_EncodeStatus_MaxDepthExceeded);
8304
8843
  do {
8305
8844
  size_t size;
8306
8845
  ptr--;
8307
- encode_tag(e, f->UPB_PRIVATE(number), kUpb_WireType_EndGroup);
8846
+ encode_tag(e, upb_MiniTableField_Number(f), kUpb_WireType_EndGroup);
8308
8847
  encode_TaggedMessagePtr(e, *ptr, subm, &size);
8309
- encode_tag(e, f->UPB_PRIVATE(number), kUpb_WireType_StartGroup);
8848
+ encode_tag(e, upb_MiniTableField_Number(f), kUpb_WireType_StartGroup);
8310
8849
  } while (ptr != start);
8311
8850
  e->depth++;
8312
8851
  return;
8313
8852
  }
8314
8853
  case kUpb_FieldType_Message: {
8315
8854
  const upb_TaggedMessagePtr* start = upb_Array_DataPtr(arr);
8316
- const upb_TaggedMessagePtr* ptr = start + arr->UPB_PRIVATE(size);
8855
+ const upb_TaggedMessagePtr* ptr = start + upb_Array_Size(arr);
8317
8856
  const upb_MiniTable* subm =
8318
8857
  upb_MiniTableSub_Message(subs[f->UPB_PRIVATE(submsg_index)]);
8319
8858
  if (--e->depth == 0) encode_err(e, kUpb_EncodeStatus_MaxDepthExceeded);
@@ -8322,7 +8861,7 @@ static void encode_array(upb_encstate* e, const upb_Message* msg,
8322
8861
  ptr--;
8323
8862
  encode_TaggedMessagePtr(e, *ptr, subm, &size);
8324
8863
  encode_varint(e, size);
8325
- encode_tag(e, f->UPB_PRIVATE(number), kUpb_WireType_Delimited);
8864
+ encode_tag(e, upb_MiniTableField_Number(f), kUpb_WireType_Delimited);
8326
8865
  } while (ptr != start);
8327
8866
  e->depth++;
8328
8867
  return;
@@ -8332,15 +8871,15 @@ static void encode_array(upb_encstate* e, const upb_Message* msg,
8332
8871
 
8333
8872
  if (packed) {
8334
8873
  encode_varint(e, e->limit - e->ptr - pre_len);
8335
- encode_tag(e, f->UPB_PRIVATE(number), kUpb_WireType_Delimited);
8874
+ encode_tag(e, upb_MiniTableField_Number(f), kUpb_WireType_Delimited);
8336
8875
  }
8337
8876
  }
8338
8877
 
8339
8878
  static void encode_mapentry(upb_encstate* e, uint32_t number,
8340
8879
  const upb_MiniTable* layout,
8341
8880
  const upb_MapEntry* ent) {
8342
- const upb_MiniTableField* key_field = &layout->UPB_PRIVATE(fields)[0];
8343
- const upb_MiniTableField* val_field = &layout->UPB_PRIVATE(fields)[1];
8881
+ const upb_MiniTableField* key_field = upb_MiniTable_MapKey(layout);
8882
+ const upb_MiniTableField* val_field = upb_MiniTable_MapValue(layout);
8344
8883
  size_t pre_len = e->limit - e->ptr;
8345
8884
  size_t size;
8346
8885
  encode_scalar(e, &ent->v, layout->UPB_PRIVATE(subs), val_field);
@@ -8356,7 +8895,7 @@ static void encode_map(upb_encstate* e, const upb_Message* msg,
8356
8895
  const upb_Map* map = *UPB_PTR_AT(msg, f->UPB_PRIVATE(offset), const upb_Map*);
8357
8896
  const upb_MiniTable* layout =
8358
8897
  upb_MiniTableSub_Message(subs[f->UPB_PRIVATE(submsg_index)]);
8359
- UPB_ASSERT(layout->UPB_PRIVATE(field_count) == 2);
8898
+ UPB_ASSERT(upb_MiniTable_FieldCount(layout) == 2);
8360
8899
 
8361
8900
  if (!map || !upb_Map_Size(map)) return;
8362
8901
 
@@ -8367,7 +8906,7 @@ static void encode_map(upb_encstate* e, const upb_Message* msg,
8367
8906
  map, &sorted);
8368
8907
  upb_MapEntry ent;
8369
8908
  while (_upb_sortedmap_next(&e->sorter, map, &sorted, &ent)) {
8370
- encode_mapentry(e, f->UPB_PRIVATE(number), layout, &ent);
8909
+ encode_mapentry(e, upb_MiniTableField_Number(f), layout, &ent);
8371
8910
  }
8372
8911
  _upb_mapsorter_popmap(&e->sorter, &sorted);
8373
8912
  } else {
@@ -8378,7 +8917,7 @@ static void encode_map(upb_encstate* e, const upb_Message* msg,
8378
8917
  upb_MapEntry ent;
8379
8918
  _upb_map_fromkey(key, &ent.k, map->key_size);
8380
8919
  _upb_map_fromvalue(val, &ent.v, map->val_size);
8381
- encode_mapentry(e, f->UPB_PRIVATE(number), layout, &ent);
8920
+ encode_mapentry(e, upb_MiniTableField_Number(f), layout, &ent);
8382
8921
  }
8383
8922
  }
8384
8923
  }
@@ -8418,7 +8957,7 @@ static bool encode_shouldencode(upb_encstate* e, const upb_Message* msg,
8418
8957
  } else {
8419
8958
  // Field is in a oneof.
8420
8959
  return UPB_PRIVATE(_upb_Message_GetOneofCase)(msg, f) ==
8421
- f->UPB_PRIVATE(number);
8960
+ upb_MiniTableField_Number(f);
8422
8961
  }
8423
8962
  }
8424
8963
 
@@ -8444,7 +8983,7 @@ static void encode_field(upb_encstate* e, const upb_Message* msg,
8444
8983
  static void encode_msgset_item(upb_encstate* e, const upb_Extension* ext) {
8445
8984
  size_t size;
8446
8985
  encode_tag(e, kUpb_MsgSet_Item, kUpb_WireType_EndGroup);
8447
- encode_message(e, ext->data.ptr,
8986
+ encode_message(e, ext->data.msg_val,
8448
8987
  upb_MiniTableExtension_GetSubMessage(ext->ext), &size);
8449
8988
  encode_varint(e, size);
8450
8989
  encode_tag(e, kUpb_MsgSet_Message, kUpb_WireType_Delimited);
@@ -8508,7 +9047,7 @@ static void encode_message(upb_encstate* e, const upb_Message* msg,
8508
9047
  }
8509
9048
  }
8510
9049
 
8511
- if (m->UPB_PRIVATE(field_count)) {
9050
+ if (upb_MiniTable_FieldCount(m)) {
8512
9051
  const upb_MiniTableField* f =
8513
9052
  &m->UPB_PRIVATE(fields)[m->UPB_PRIVATE(field_count)];
8514
9053
  const upb_MiniTableField* first = &m->UPB_PRIVATE(fields)[0];
@@ -8526,14 +9065,18 @@ static void encode_message(upb_encstate* e, const upb_Message* msg,
8526
9065
  static upb_EncodeStatus upb_Encoder_Encode(upb_encstate* const encoder,
8527
9066
  const upb_Message* const msg,
8528
9067
  const upb_MiniTable* const l,
8529
- char** const buf,
8530
- size_t* const size) {
9068
+ char** const buf, size_t* const size,
9069
+ bool prepend_len) {
8531
9070
  // Unfortunately we must continue to perform hackery here because there are
8532
9071
  // code paths which blindly copy the returned pointer without bothering to
8533
9072
  // check for errors until much later (b/235839510). So we still set *buf to
8534
9073
  // NULL on error and we still set it to non-NULL on a successful empty result.
8535
9074
  if (UPB_SETJMP(encoder->err) == 0) {
8536
- encode_message(encoder, msg, l, size);
9075
+ size_t encoded_msg_size;
9076
+ encode_message(encoder, msg, l, &encoded_msg_size);
9077
+ if (prepend_len) {
9078
+ encode_varint(encoder, encoded_msg_size);
9079
+ }
8537
9080
  *size = encoder->limit - encoder->ptr;
8538
9081
  if (*size == 0) {
8539
9082
  static char ch;
@@ -8552,9 +9095,10 @@ static upb_EncodeStatus upb_Encoder_Encode(upb_encstate* const encoder,
8552
9095
  return encoder->status;
8553
9096
  }
8554
9097
 
8555
- upb_EncodeStatus upb_Encode(const upb_Message* msg, const upb_MiniTable* l,
8556
- int options, upb_Arena* arena, char** buf,
8557
- size_t* size) {
9098
+ static upb_EncodeStatus _upb_Encode(const upb_Message* msg,
9099
+ const upb_MiniTable* l, int options,
9100
+ upb_Arena* arena, char** buf, size_t* size,
9101
+ bool prepend_len) {
8558
9102
  upb_encstate e;
8559
9103
  unsigned depth = (unsigned)options >> 16;
8560
9104
 
@@ -8567,7 +9111,20 @@ upb_EncodeStatus upb_Encode(const upb_Message* msg, const upb_MiniTable* l,
8567
9111
  e.options = options;
8568
9112
  _upb_mapsorter_init(&e.sorter);
8569
9113
 
8570
- return upb_Encoder_Encode(&e, msg, l, buf, size);
9114
+ return upb_Encoder_Encode(&e, msg, l, buf, size, prepend_len);
9115
+ }
9116
+
9117
+ upb_EncodeStatus upb_Encode(const upb_Message* msg, const upb_MiniTable* l,
9118
+ int options, upb_Arena* arena, char** buf,
9119
+ size_t* size) {
9120
+ return _upb_Encode(msg, l, options, arena, buf, size, false);
9121
+ }
9122
+
9123
+ upb_EncodeStatus upb_EncodeLengthPrefixed(const upb_Message* msg,
9124
+ const upb_MiniTable* l, int options,
9125
+ upb_Arena* arena, char** buf,
9126
+ size_t* size) {
9127
+ return _upb_Encode(msg, l, options, arena, buf, size, true);
8571
9128
  }
8572
9129
 
8573
9130
  // Fast decoder: ~3x the speed of decode.c, but requires x86-64/ARM64.
@@ -8617,7 +9174,7 @@ static const char* fastdecode_isdonefallback(UPB_PARSE_PARAMS) {
8617
9174
  }
8618
9175
 
8619
9176
  UPB_FORCEINLINE
8620
- static const char* fastdecode_dispatch(UPB_PARSE_PARAMS) {
9177
+ const char* fastdecode_dispatch(UPB_PARSE_PARAMS) {
8621
9178
  int overrun;
8622
9179
  switch (upb_EpsCopyInputStream_IsDoneStatus(&d->input, ptr, &overrun)) {
8623
9180
  case kUpb_IsDoneStatus_Done:
@@ -8639,7 +9196,7 @@ static const char* fastdecode_dispatch(UPB_PARSE_PARAMS) {
8639
9196
  }
8640
9197
 
8641
9198
  UPB_FORCEINLINE
8642
- static bool fastdecode_checktag(uint16_t data, int tagbytes) {
9199
+ bool fastdecode_checktag(uint16_t data, int tagbytes) {
8643
9200
  if (tagbytes == 1) {
8644
9201
  return (data & 0xff) == 0;
8645
9202
  } else {
@@ -8648,7 +9205,7 @@ static bool fastdecode_checktag(uint16_t data, int tagbytes) {
8648
9205
  }
8649
9206
 
8650
9207
  UPB_FORCEINLINE
8651
- static const char* fastdecode_longsize(const char* ptr, int* size) {
9208
+ const char* fastdecode_longsize(const char* ptr, int* size) {
8652
9209
  int i;
8653
9210
  UPB_ASSERT(*size & 0x80);
8654
9211
  *size &= 0xff;
@@ -8668,7 +9225,7 @@ static const char* fastdecode_longsize(const char* ptr, int* size) {
8668
9225
  }
8669
9226
 
8670
9227
  UPB_FORCEINLINE
8671
- static const char* fastdecode_delimited(
9228
+ const char* fastdecode_delimited(
8672
9229
  upb_Decoder* d, const char* ptr,
8673
9230
  upb_EpsCopyInputStream_ParseDelimitedFunc* func, void* ctx) {
8674
9231
  ptr++;
@@ -8721,8 +9278,8 @@ typedef struct {
8721
9278
  } fastdecode_nextret;
8722
9279
 
8723
9280
  UPB_FORCEINLINE
8724
- static void* fastdecode_resizearr(upb_Decoder* d, void* dst,
8725
- fastdecode_arr* farr, int valbytes) {
9281
+ void* fastdecode_resizearr(upb_Decoder* d, void* dst, fastdecode_arr* farr,
9282
+ int valbytes) {
8726
9283
  if (UPB_UNLIKELY(dst == farr->end)) {
8727
9284
  size_t old_capacity = farr->arr->UPB_PRIVATE(capacity);
8728
9285
  size_t old_bytes = old_capacity * valbytes;
@@ -8740,7 +9297,7 @@ static void* fastdecode_resizearr(upb_Decoder* d, void* dst,
8740
9297
  }
8741
9298
 
8742
9299
  UPB_FORCEINLINE
8743
- static bool fastdecode_tagmatch(uint32_t tag, uint64_t data, int tagbytes) {
9300
+ bool fastdecode_tagmatch(uint32_t tag, uint64_t data, int tagbytes) {
8744
9301
  if (tagbytes == 1) {
8745
9302
  return (uint8_t)tag == (uint8_t)data;
8746
9303
  } else {
@@ -8749,19 +9306,17 @@ static bool fastdecode_tagmatch(uint32_t tag, uint64_t data, int tagbytes) {
8749
9306
  }
8750
9307
 
8751
9308
  UPB_FORCEINLINE
8752
- static void fastdecode_commitarr(void* dst, fastdecode_arr* farr,
8753
- int valbytes) {
9309
+ void fastdecode_commitarr(void* dst, fastdecode_arr* farr, int valbytes) {
8754
9310
  farr->arr->UPB_PRIVATE(size) =
8755
9311
  (size_t)((char*)dst - (char*)upb_Array_MutableDataPtr(farr->arr)) /
8756
9312
  valbytes;
8757
9313
  }
8758
9314
 
8759
9315
  UPB_FORCEINLINE
8760
- static fastdecode_nextret fastdecode_nextrepeated(upb_Decoder* d, void* dst,
8761
- const char** ptr,
8762
- fastdecode_arr* farr,
8763
- uint64_t data, int tagbytes,
8764
- int valbytes) {
9316
+ fastdecode_nextret fastdecode_nextrepeated(upb_Decoder* d, void* dst,
9317
+ const char** ptr,
9318
+ fastdecode_arr* farr, uint64_t data,
9319
+ int tagbytes, int valbytes) {
8765
9320
  fastdecode_nextret ret;
8766
9321
  dst = (char*)dst + valbytes;
8767
9322
 
@@ -8783,16 +9338,15 @@ static fastdecode_nextret fastdecode_nextrepeated(upb_Decoder* d, void* dst,
8783
9338
  }
8784
9339
 
8785
9340
  UPB_FORCEINLINE
8786
- static void* fastdecode_fieldmem(upb_Message* msg, uint64_t data) {
9341
+ void* fastdecode_fieldmem(upb_Message* msg, uint64_t data) {
8787
9342
  size_t ofs = data >> 48;
8788
9343
  return (char*)msg + ofs;
8789
9344
  }
8790
9345
 
8791
9346
  UPB_FORCEINLINE
8792
- static void* fastdecode_getfield(upb_Decoder* d, const char* ptr,
8793
- upb_Message* msg, uint64_t* data,
8794
- uint64_t* hasbits, fastdecode_arr* farr,
8795
- int valbytes, upb_card card) {
9347
+ void* fastdecode_getfield(upb_Decoder* d, const char* ptr, upb_Message* msg,
9348
+ uint64_t* data, uint64_t* hasbits,
9349
+ fastdecode_arr* farr, int valbytes, upb_card card) {
8796
9350
  switch (card) {
8797
9351
  case CARD_s: {
8798
9352
  uint8_t hasbit_index = *data >> 24;
@@ -8831,7 +9385,7 @@ static void* fastdecode_getfield(upb_Decoder* d, const char* ptr,
8831
9385
  }
8832
9386
 
8833
9387
  UPB_FORCEINLINE
8834
- static bool fastdecode_flippacked(uint64_t* data, int tagbytes) {
9388
+ bool fastdecode_flippacked(uint64_t* data, int tagbytes) {
8835
9389
  *data ^= (0x2 ^ 0x0); // Patch data to match packed wiretype.
8836
9390
  return fastdecode_checktag(*data, tagbytes);
8837
9391
  }
@@ -8847,7 +9401,7 @@ static bool fastdecode_flippacked(uint64_t* data, int tagbytes) {
8847
9401
  /* varint fields **************************************************************/
8848
9402
 
8849
9403
  UPB_FORCEINLINE
8850
- static uint64_t fastdecode_munge(uint64_t val, int valbytes, bool zigzag) {
9404
+ uint64_t fastdecode_munge(uint64_t val, int valbytes, bool zigzag) {
8851
9405
  if (valbytes == 1) {
8852
9406
  return val != 0;
8853
9407
  } else if (zigzag) {
@@ -8863,7 +9417,7 @@ static uint64_t fastdecode_munge(uint64_t val, int valbytes, bool zigzag) {
8863
9417
  }
8864
9418
 
8865
9419
  UPB_FORCEINLINE
8866
- static const char* fastdecode_varint64(const char* ptr, uint64_t* val) {
9420
+ const char* fastdecode_varint64(const char* ptr, uint64_t* val) {
8867
9421
  ptr++;
8868
9422
  *val = (uint8_t)ptr[-1];
8869
9423
  if (UPB_UNLIKELY(*val & 0x80)) {
@@ -8938,8 +9492,8 @@ typedef struct {
8938
9492
  } fastdecode_varintdata;
8939
9493
 
8940
9494
  UPB_FORCEINLINE
8941
- static const char* fastdecode_topackedvarint(upb_EpsCopyInputStream* e,
8942
- const char* ptr, void* ctx) {
9495
+ const char* fastdecode_topackedvarint(upb_EpsCopyInputStream* e,
9496
+ const char* ptr, void* ctx) {
8943
9497
  upb_Decoder* d = (upb_Decoder*)e;
8944
9498
  fastdecode_varintdata* data = ctx;
8945
9499
  void* dst = data->dst;
@@ -9218,9 +9772,8 @@ static const char* fastdecode_longstring_noutf8(
9218
9772
  }
9219
9773
 
9220
9774
  UPB_FORCEINLINE
9221
- static void fastdecode_docopy(upb_Decoder* d, const char* ptr, uint32_t size,
9222
- int copy, char* data, size_t data_offset,
9223
- upb_StringView* dst) {
9775
+ void fastdecode_docopy(upb_Decoder* d, const char* ptr, uint32_t size, int copy,
9776
+ char* data, size_t data_offset, upb_StringView* dst) {
9224
9777
  d->arena.UPB_PRIVATE(ptr) += copy;
9225
9778
  dst->data = data + data_offset;
9226
9779
  UPB_UNPOISON_MEMORY_REGION(data, copy);
@@ -9451,8 +10004,8 @@ typedef struct {
9451
10004
  } fastdecode_submsgdata;
9452
10005
 
9453
10006
  UPB_FORCEINLINE
9454
- static const char* fastdecode_tosubmsg(upb_EpsCopyInputStream* e,
9455
- const char* ptr, void* ctx) {
10007
+ const char* fastdecode_tosubmsg(upb_EpsCopyInputStream* e, const char* ptr,
10008
+ void* ctx) {
9456
10009
  upb_Decoder* d = (upb_Decoder*)e;
9457
10010
  fastdecode_submsgdata* submsg = ctx;
9458
10011
  ptr = fastdecode_dispatch(d, ptr, submsg->msg, submsg->table, 0, 0);
@@ -9570,8 +10123,7 @@ UPB_NOINLINE UPB_PRIVATE(_upb_WireReader_LongVarint)
9570
10123
  UPB_PRIVATE(_upb_WireReader_ReadLongVarint)(const char* ptr, uint64_t val) {
9571
10124
  UPB_PRIVATE(_upb_WireReader_LongVarint) ret = {NULL, 0};
9572
10125
  uint64_t byte;
9573
- int i;
9574
- for (i = 1; i < 10; i++) {
10126
+ for (int i = 1; i < 10; i++) {
9575
10127
  byte = (uint8_t)ptr[i];
9576
10128
  val += (byte - 1) << (i * 7);
9577
10129
  if (!(byte & 0x80)) {
@@ -10603,15 +11155,291 @@ int upb_Unicode_ToUTF8(uint32_t cp, char* out) {
10603
11155
  }
10604
11156
 
10605
11157
 
11158
+ #include <stdlib.h>
11159
+
11160
+
11161
+ // Must be last.
11162
+
11163
+ typedef struct upb_UnknownFields upb_UnknownFields;
11164
+
11165
+ typedef struct {
11166
+ uint32_t tag;
11167
+ union {
11168
+ uint64_t varint;
11169
+ uint64_t uint64;
11170
+ uint32_t uint32;
11171
+ upb_StringView delimited;
11172
+ upb_UnknownFields* group;
11173
+ } data;
11174
+ } upb_UnknownField;
11175
+
11176
+ struct upb_UnknownFields {
11177
+ size_t size;
11178
+ size_t capacity;
11179
+ upb_UnknownField* fields;
11180
+ };
11181
+
11182
+ typedef struct {
11183
+ upb_EpsCopyInputStream stream;
11184
+ upb_Arena* arena;
11185
+ upb_UnknownField* tmp;
11186
+ size_t tmp_size;
11187
+ int depth;
11188
+ upb_UnknownCompareResult status;
11189
+ jmp_buf err;
11190
+ } upb_UnknownField_Context;
11191
+
11192
+ UPB_NORETURN static void upb_UnknownFields_OutOfMemory(
11193
+ upb_UnknownField_Context* ctx) {
11194
+ ctx->status = kUpb_UnknownCompareResult_OutOfMemory;
11195
+ UPB_LONGJMP(ctx->err, 1);
11196
+ }
11197
+
11198
+ static void upb_UnknownFields_Grow(upb_UnknownField_Context* ctx,
11199
+ upb_UnknownField** base,
11200
+ upb_UnknownField** ptr,
11201
+ upb_UnknownField** end) {
11202
+ size_t old = (*ptr - *base);
11203
+ size_t new = UPB_MAX(4, old * 2);
11204
+
11205
+ *base = upb_Arena_Realloc(ctx->arena, *base, old * sizeof(**base),
11206
+ new * sizeof(**base));
11207
+ if (!*base) upb_UnknownFields_OutOfMemory(ctx);
11208
+
11209
+ *ptr = *base + old;
11210
+ *end = *base + new;
11211
+ }
11212
+
11213
+ // We have to implement our own sort here, since qsort() is not an in-order
11214
+ // sort. Here we use merge sort, the simplest in-order sort.
11215
+ static void upb_UnknownFields_Merge(upb_UnknownField* arr, size_t start,
11216
+ size_t mid, size_t end,
11217
+ upb_UnknownField* tmp) {
11218
+ memcpy(tmp, &arr[start], (end - start) * sizeof(*tmp));
11219
+
11220
+ upb_UnknownField* ptr1 = tmp;
11221
+ upb_UnknownField* end1 = &tmp[mid - start];
11222
+ upb_UnknownField* ptr2 = &tmp[mid - start];
11223
+ upb_UnknownField* end2 = &tmp[end - start];
11224
+ upb_UnknownField* out = &arr[start];
11225
+
11226
+ while (ptr1 < end1 && ptr2 < end2) {
11227
+ if (ptr1->tag <= ptr2->tag) {
11228
+ *out++ = *ptr1++;
11229
+ } else {
11230
+ *out++ = *ptr2++;
11231
+ }
11232
+ }
11233
+
11234
+ if (ptr1 < end1) {
11235
+ memcpy(out, ptr1, (end1 - ptr1) * sizeof(*out));
11236
+ } else if (ptr2 < end2) {
11237
+ memcpy(out, ptr1, (end2 - ptr2) * sizeof(*out));
11238
+ }
11239
+ }
11240
+
11241
+ static void upb_UnknownFields_SortRecursive(upb_UnknownField* arr, size_t start,
11242
+ size_t end, upb_UnknownField* tmp) {
11243
+ if (end - start > 1) {
11244
+ size_t mid = start + ((end - start) / 2);
11245
+ upb_UnknownFields_SortRecursive(arr, start, mid, tmp);
11246
+ upb_UnknownFields_SortRecursive(arr, mid, end, tmp);
11247
+ upb_UnknownFields_Merge(arr, start, mid, end, tmp);
11248
+ }
11249
+ }
11250
+
11251
+ static void upb_UnknownFields_Sort(upb_UnknownField_Context* ctx,
11252
+ upb_UnknownFields* fields) {
11253
+ if (ctx->tmp_size < fields->size) {
11254
+ const int oldsize = ctx->tmp_size * sizeof(*ctx->tmp);
11255
+ ctx->tmp_size = UPB_MAX(8, ctx->tmp_size);
11256
+ while (ctx->tmp_size < fields->size) ctx->tmp_size *= 2;
11257
+ const int newsize = ctx->tmp_size * sizeof(*ctx->tmp);
11258
+ ctx->tmp = upb_grealloc(ctx->tmp, oldsize, newsize);
11259
+ }
11260
+ upb_UnknownFields_SortRecursive(fields->fields, 0, fields->size, ctx->tmp);
11261
+ }
11262
+
11263
+ static upb_UnknownFields* upb_UnknownFields_DoBuild(
11264
+ upb_UnknownField_Context* ctx, const char** buf) {
11265
+ upb_UnknownField* arr_base = NULL;
11266
+ upb_UnknownField* arr_ptr = NULL;
11267
+ upb_UnknownField* arr_end = NULL;
11268
+ const char* ptr = *buf;
11269
+ uint32_t last_tag = 0;
11270
+ bool sorted = true;
11271
+ while (!upb_EpsCopyInputStream_IsDone(&ctx->stream, &ptr)) {
11272
+ uint32_t tag;
11273
+ ptr = upb_WireReader_ReadTag(ptr, &tag);
11274
+ UPB_ASSERT(tag <= UINT32_MAX);
11275
+ int wire_type = upb_WireReader_GetWireType(tag);
11276
+ if (wire_type == kUpb_WireType_EndGroup) break;
11277
+ if (tag < last_tag) sorted = false;
11278
+ last_tag = tag;
11279
+
11280
+ if (arr_ptr == arr_end) {
11281
+ upb_UnknownFields_Grow(ctx, &arr_base, &arr_ptr, &arr_end);
11282
+ }
11283
+ upb_UnknownField* field = arr_ptr;
11284
+ field->tag = tag;
11285
+ arr_ptr++;
11286
+
11287
+ switch (wire_type) {
11288
+ case kUpb_WireType_Varint:
11289
+ ptr = upb_WireReader_ReadVarint(ptr, &field->data.varint);
11290
+ break;
11291
+ case kUpb_WireType_64Bit:
11292
+ ptr = upb_WireReader_ReadFixed64(ptr, &field->data.uint64);
11293
+ break;
11294
+ case kUpb_WireType_32Bit:
11295
+ ptr = upb_WireReader_ReadFixed32(ptr, &field->data.uint32);
11296
+ break;
11297
+ case kUpb_WireType_Delimited: {
11298
+ int size;
11299
+ ptr = upb_WireReader_ReadSize(ptr, &size);
11300
+ const char* s_ptr = ptr;
11301
+ ptr = upb_EpsCopyInputStream_ReadStringAliased(&ctx->stream, &s_ptr,
11302
+ size);
11303
+ field->data.delimited.data = s_ptr;
11304
+ field->data.delimited.size = size;
11305
+ break;
11306
+ }
11307
+ case kUpb_WireType_StartGroup:
11308
+ if (--ctx->depth == 0) {
11309
+ ctx->status = kUpb_UnknownCompareResult_MaxDepthExceeded;
11310
+ UPB_LONGJMP(ctx->err, 1);
11311
+ }
11312
+ field->data.group = upb_UnknownFields_DoBuild(ctx, &ptr);
11313
+ ctx->depth++;
11314
+ break;
11315
+ default:
11316
+ UPB_UNREACHABLE();
11317
+ }
11318
+ }
11319
+
11320
+ *buf = ptr;
11321
+ upb_UnknownFields* ret = upb_Arena_Malloc(ctx->arena, sizeof(*ret));
11322
+ if (!ret) upb_UnknownFields_OutOfMemory(ctx);
11323
+ ret->fields = arr_base;
11324
+ ret->size = arr_ptr - arr_base;
11325
+ ret->capacity = arr_end - arr_base;
11326
+ if (!sorted) {
11327
+ upb_UnknownFields_Sort(ctx, ret);
11328
+ }
11329
+ return ret;
11330
+ }
11331
+
11332
+ // Builds a upb_UnknownFields data structure from the binary data in buf.
11333
+ static upb_UnknownFields* upb_UnknownFields_Build(upb_UnknownField_Context* ctx,
11334
+ const char* ptr,
11335
+ size_t size) {
11336
+ upb_EpsCopyInputStream_Init(&ctx->stream, &ptr, size, true);
11337
+ upb_UnknownFields* fields = upb_UnknownFields_DoBuild(ctx, &ptr);
11338
+ UPB_ASSERT(upb_EpsCopyInputStream_IsDone(&ctx->stream, &ptr) &&
11339
+ !upb_EpsCopyInputStream_IsError(&ctx->stream));
11340
+ return fields;
11341
+ }
11342
+
11343
+ // Compares two sorted upb_UnknownFields structures for equality.
11344
+ static bool upb_UnknownFields_IsEqual(const upb_UnknownFields* uf1,
11345
+ const upb_UnknownFields* uf2) {
11346
+ if (uf1->size != uf2->size) return false;
11347
+ for (size_t i = 0, n = uf1->size; i < n; i++) {
11348
+ upb_UnknownField* f1 = &uf1->fields[i];
11349
+ upb_UnknownField* f2 = &uf2->fields[i];
11350
+ if (f1->tag != f2->tag) return false;
11351
+ int wire_type = f1->tag & 7;
11352
+ switch (wire_type) {
11353
+ case kUpb_WireType_Varint:
11354
+ if (f1->data.varint != f2->data.varint) return false;
11355
+ break;
11356
+ case kUpb_WireType_64Bit:
11357
+ if (f1->data.uint64 != f2->data.uint64) return false;
11358
+ break;
11359
+ case kUpb_WireType_32Bit:
11360
+ if (f1->data.uint32 != f2->data.uint32) return false;
11361
+ break;
11362
+ case kUpb_WireType_Delimited:
11363
+ if (!upb_StringView_IsEqual(f1->data.delimited, f2->data.delimited)) {
11364
+ return false;
11365
+ }
11366
+ break;
11367
+ case kUpb_WireType_StartGroup:
11368
+ if (!upb_UnknownFields_IsEqual(f1->data.group, f2->data.group)) {
11369
+ return false;
11370
+ }
11371
+ break;
11372
+ default:
11373
+ UPB_UNREACHABLE();
11374
+ }
11375
+ }
11376
+ return true;
11377
+ }
11378
+
11379
+ static upb_UnknownCompareResult upb_UnknownField_DoCompare(
11380
+ upb_UnknownField_Context* ctx, const char* buf1, size_t size1,
11381
+ const char* buf2, size_t size2) {
11382
+ upb_UnknownCompareResult ret;
11383
+ // First build both unknown fields into a sorted data structure (similar
11384
+ // to the UnknownFieldSet in C++).
11385
+ upb_UnknownFields* uf1 = upb_UnknownFields_Build(ctx, buf1, size1);
11386
+ upb_UnknownFields* uf2 = upb_UnknownFields_Build(ctx, buf2, size2);
11387
+
11388
+ // Now perform the equality check on the sorted structures.
11389
+ if (upb_UnknownFields_IsEqual(uf1, uf2)) {
11390
+ ret = kUpb_UnknownCompareResult_Equal;
11391
+ } else {
11392
+ ret = kUpb_UnknownCompareResult_NotEqual;
11393
+ }
11394
+ return ret;
11395
+ }
11396
+
11397
+ static upb_UnknownCompareResult upb_UnknownField_Compare(
11398
+ upb_UnknownField_Context* const ctx, const char* const buf1,
11399
+ const size_t size1, const char* const buf2, const size_t size2) {
11400
+ upb_UnknownCompareResult ret;
11401
+ if (UPB_SETJMP(ctx->err) == 0) {
11402
+ ret = upb_UnknownField_DoCompare(ctx, buf1, size1, buf2, size2);
11403
+ } else {
11404
+ ret = ctx->status;
11405
+ UPB_ASSERT(ret != kUpb_UnknownCompareResult_Equal);
11406
+ }
11407
+
11408
+ upb_Arena_Free(ctx->arena);
11409
+ upb_gfree(ctx->tmp);
11410
+ return ret;
11411
+ }
11412
+
11413
+ upb_UnknownCompareResult UPB_PRIVATE(_upb_Message_UnknownFieldsAreEqual)(
11414
+ const char* buf1, size_t size1, const char* buf2, size_t size2,
11415
+ int max_depth) {
11416
+ if (size1 == 0 && size2 == 0) return kUpb_UnknownCompareResult_Equal;
11417
+ if (size1 == 0 || size2 == 0) return kUpb_UnknownCompareResult_NotEqual;
11418
+ if (memcmp(buf1, buf2, size1) == 0) return kUpb_UnknownCompareResult_Equal;
11419
+
11420
+ upb_UnknownField_Context ctx = {
11421
+ .arena = upb_Arena_New(),
11422
+ .depth = max_depth,
11423
+ .tmp = NULL,
11424
+ .tmp_size = 0,
11425
+ .status = kUpb_UnknownCompareResult_Equal,
11426
+ };
11427
+
11428
+ if (!ctx.arena) return kUpb_UnknownCompareResult_OutOfMemory;
11429
+
11430
+ return upb_UnknownField_Compare(&ctx, buf1, size1, buf2, size2);
11431
+ }
11432
+
11433
+
10606
11434
  #include <string.h>
10607
11435
 
10608
11436
 
10609
11437
  // Must be last.
10610
11438
 
10611
- const struct upb_Extension* UPB_PRIVATE(_upb_Message_Getext)(
11439
+ const upb_Extension* UPB_PRIVATE(_upb_Message_Getext)(
10612
11440
  const struct upb_Message* msg, const upb_MiniTableExtension* e) {
10613
11441
  size_t n;
10614
- const struct upb_Extension* ext = UPB_PRIVATE(_upb_Message_Getexts)(msg, &n);
11442
+ const upb_Extension* ext = UPB_PRIVATE(_upb_Message_Getexts)(msg, &n);
10615
11443
 
10616
11444
  // For now we use linear search exclusively to find extensions.
10617
11445
  // If this becomes an issue due to messages with lots of extensions,
@@ -10625,11 +11453,11 @@ const struct upb_Extension* UPB_PRIVATE(_upb_Message_Getext)(
10625
11453
  return NULL;
10626
11454
  }
10627
11455
 
10628
- const struct upb_Extension* UPB_PRIVATE(_upb_Message_Getexts)(
11456
+ const upb_Extension* UPB_PRIVATE(_upb_Message_Getexts)(
10629
11457
  const struct upb_Message* msg, size_t* count) {
10630
- upb_Message_Internal* in = msg->internal;
11458
+ upb_Message_Internal* in = UPB_PRIVATE(_upb_Message_GetInternal)(msg);
10631
11459
  if (in) {
10632
- *count = (in->size - in->ext_begin) / sizeof(struct upb_Extension);
11460
+ *count = (in->size - in->ext_begin) / sizeof(upb_Extension);
10633
11461
  return UPB_PTR_AT(in, in->ext_begin, void);
10634
11462
  } else {
10635
11463
  *count = 0;
@@ -10637,17 +11465,16 @@ const struct upb_Extension* UPB_PRIVATE(_upb_Message_Getexts)(
10637
11465
  }
10638
11466
  }
10639
11467
 
10640
- struct upb_Extension* UPB_PRIVATE(_upb_Message_GetOrCreateExtension)(
11468
+ upb_Extension* UPB_PRIVATE(_upb_Message_GetOrCreateExtension)(
10641
11469
  struct upb_Message* msg, const upb_MiniTableExtension* e, upb_Arena* a) {
10642
- struct upb_Extension* ext =
10643
- (struct upb_Extension*)UPB_PRIVATE(_upb_Message_Getext)(msg, e);
11470
+ upb_Extension* ext = (upb_Extension*)UPB_PRIVATE(_upb_Message_Getext)(msg, e);
10644
11471
  if (ext) return ext;
10645
- if (!UPB_PRIVATE(_upb_Message_Realloc)(msg, sizeof(struct upb_Extension), a))
11472
+ if (!UPB_PRIVATE(_upb_Message_Realloc)(msg, sizeof(upb_Extension), a))
10646
11473
  return NULL;
10647
- upb_Message_Internal* in = msg->internal;
10648
- in->ext_begin -= sizeof(struct upb_Extension);
11474
+ upb_Message_Internal* in = UPB_PRIVATE(_upb_Message_GetInternal)(msg);
11475
+ in->ext_begin -= sizeof(upb_Extension);
10649
11476
  ext = UPB_PTR_AT(in, in->ext_begin, void);
10650
- memset(ext, 0, sizeof(struct upb_Extension));
11477
+ memset(ext, 0, sizeof(upb_Extension));
10651
11478
  ext->ext = e;
10652
11479
  return ext;
10653
11480
  }
@@ -10667,7 +11494,7 @@ bool UPB_PRIVATE(_upb_Message_Realloc)(struct upb_Message* msg, size_t need,
10667
11494
  upb_Arena* a) {
10668
11495
  const size_t overhead = sizeof(upb_Message_Internal);
10669
11496
 
10670
- upb_Message_Internal* in = msg->internal;
11497
+ upb_Message_Internal* in = UPB_PRIVATE(_upb_Message_GetInternal)(msg);
10671
11498
  if (!in) {
10672
11499
  // No internal data, allocate from scratch.
10673
11500
  size_t size = UPB_MAX(128, upb_Log2CeilingSize(need + overhead));
@@ -10677,7 +11504,7 @@ bool UPB_PRIVATE(_upb_Message_Realloc)(struct upb_Message* msg, size_t need,
10677
11504
  in->size = size;
10678
11505
  in->unknown_end = overhead;
10679
11506
  in->ext_begin = size;
10680
- msg->internal = in;
11507
+ UPB_PRIVATE(_upb_Message_SetInternal)(msg, in);
10681
11508
  } else if (in->ext_begin - in->unknown_end < need) {
10682
11509
  // Internal data is too small, reallocate.
10683
11510
  size_t new_size = upb_Log2CeilingSize(in->size + need);
@@ -10693,13 +11520,30 @@ bool UPB_PRIVATE(_upb_Message_Realloc)(struct upb_Message* msg, size_t need,
10693
11520
  }
10694
11521
  in->ext_begin = new_ext_begin;
10695
11522
  in->size = new_size;
10696
- msg->internal = in;
11523
+ UPB_PRIVATE(_upb_Message_SetInternal)(msg, in);
10697
11524
  }
10698
11525
 
10699
11526
  UPB_ASSERT(in->ext_begin - in->unknown_end >= need);
10700
11527
  return true;
10701
11528
  }
10702
11529
 
11530
+ #if UPB_TRACING_ENABLED
11531
+ static void (*_new_message_trace_handler)(const upb_MiniTable*,
11532
+ const upb_Arena*);
11533
+
11534
+ void UPB_PRIVATE(upb_Message_SetNewMessageTraceHandler)(
11535
+ void (*new_message_trace_handler)(const upb_MiniTable*, const upb_Arena*)) {
11536
+ _new_message_trace_handler = new_message_trace_handler;
11537
+ }
11538
+
11539
+ void UPB_PRIVATE(upb_Message_LogNewMessage)(const upb_MiniTable* mini_table,
11540
+ const upb_Arena* arena) {
11541
+ if (_new_message_trace_handler) {
11542
+ _new_message_trace_handler(mini_table, arena);
11543
+ }
11544
+ }
11545
+ #endif
11546
+
10703
11547
 
10704
11548
  const char _kUpb_ToBase92[] = {
10705
11549
  ' ', '!', '#', '$', '%', '&', '(', ')', '*', '+', ',', '-', '.', '/',
@@ -11729,7 +12573,11 @@ const upb_EnumValueDef* upb_EnumDef_Value(const upb_EnumDef* e, int i) {
11729
12573
  }
11730
12574
 
11731
12575
  bool upb_EnumDef_IsClosed(const upb_EnumDef* e) {
11732
- if (UPB_TREAT_PROTO2_ENUMS_LIKE_PROTO3) return false;
12576
+ if (UPB_TREAT_CLOSED_ENUMS_LIKE_OPEN) return false;
12577
+ return upb_EnumDef_IsSpecifiedAsClosed(e);
12578
+ }
12579
+
12580
+ bool upb_EnumDef_IsSpecifiedAsClosed(const upb_EnumDef* e) {
11733
12581
  return UPB_DESC(FeatureSet_enum_type)(e->resolved_features) ==
11734
12582
  UPB_DESC(FeatureSet_CLOSED);
11735
12583
  }
@@ -12035,15 +12883,10 @@ static void create_enumvaldef(upb_DefBuilder* ctx, const char* prefix,
12035
12883
  static void _upb_EnumValueDef_CheckZeroValue(upb_DefBuilder* ctx,
12036
12884
  const upb_EnumDef* e,
12037
12885
  const upb_EnumValueDef* v, int n) {
12038
- if (upb_EnumDef_IsClosed(e) || n == 0 || v[0].number == 0) return;
12039
-
12040
- // When the special UPB_TREAT_PROTO2_ENUMS_LIKE_PROTO3 is enabled, we have to
12041
- // exempt proto2 enums from this check, even when we are treating them as
12886
+ // When the special UPB_TREAT_CLOSED_ENUMS_LIKE_OPEN is enabled, we have to
12887
+ // exempt closed enums from this check, even when we are treating them as
12042
12888
  // open.
12043
- if (UPB_TREAT_PROTO2_ENUMS_LIKE_PROTO3 &&
12044
- upb_FileDef_Syntax(upb_EnumDef_File(e)) == kUpb_Syntax_Proto2) {
12045
- return;
12046
- }
12889
+ if (upb_EnumDef_IsSpecifiedAsClosed(e) || n == 0 || v[0].number == 0) return;
12047
12890
 
12048
12891
  _upb_DefBuilder_Errf(ctx, "for open enums, the first value must be zero (%s)",
12049
12892
  upb_EnumDef_FullName(e));
@@ -12225,27 +13068,16 @@ upb_CType upb_FieldDef_CType(const upb_FieldDef* f) {
12225
13068
  return upb_FieldType_CType(f->type_);
12226
13069
  }
12227
13070
 
12228
- upb_FieldType upb_FieldDef_Type(const upb_FieldDef* f) {
12229
- // TODO: remove once we can deprecate kUpb_FieldType_Group.
12230
- if (f->type_ == kUpb_FieldType_Message &&
12231
- UPB_DESC(FeatureSet_message_encoding)(f->resolved_features) ==
12232
- UPB_DESC(FeatureSet_DELIMITED)) {
12233
- return kUpb_FieldType_Group;
12234
- }
12235
- return f->type_;
12236
- }
13071
+ upb_FieldType upb_FieldDef_Type(const upb_FieldDef* f) { return f->type_; }
12237
13072
 
12238
13073
  uint32_t upb_FieldDef_Index(const upb_FieldDef* f) { return f->index_; }
12239
13074
 
12240
- upb_Label upb_FieldDef_Label(const upb_FieldDef* f) {
12241
- // TODO: remove once we can deprecate kUpb_Label_Required.
12242
- if (UPB_DESC(FeatureSet_field_presence)(f->resolved_features) ==
12243
- UPB_DESC(FeatureSet_LEGACY_REQUIRED)) {
12244
- return kUpb_Label_Required;
12245
- }
12246
- return f->label_;
13075
+ uint32_t upb_FieldDef_LayoutIndex(const upb_FieldDef* f) {
13076
+ return f->layout_index;
12247
13077
  }
12248
13078
 
13079
+ upb_Label upb_FieldDef_Label(const upb_FieldDef* f) { return f->label_; }
13080
+
12249
13081
  uint32_t upb_FieldDef_Number(const upb_FieldDef* f) { return f->number_; }
12250
13082
 
12251
13083
  bool upb_FieldDef_IsExtension(const upb_FieldDef* f) { return f->is_extension; }
@@ -12376,6 +13208,40 @@ bool _upb_FieldDef_ValidateUtf8(const upb_FieldDef* f) {
12376
13208
  UPB_DESC(FeatureSet_VERIFY);
12377
13209
  }
12378
13210
 
13211
+ bool _upb_FieldDef_IsGroupLike(const upb_FieldDef* f) {
13212
+ // Groups are always tag-delimited.
13213
+ if (UPB_DESC(FeatureSet_message_encoding)(upb_FieldDef_ResolvedFeatures(f)) !=
13214
+ UPB_DESC(FeatureSet_DELIMITED)) {
13215
+ return false;
13216
+ }
13217
+
13218
+ const upb_MessageDef* msg = upb_FieldDef_MessageSubDef(f);
13219
+
13220
+ // Group fields always are always the lowercase type name.
13221
+ const char* mname = upb_MessageDef_Name(msg);
13222
+ const char* fname = upb_FieldDef_Name(f);
13223
+ size_t name_size = strlen(fname);
13224
+ if (name_size != strlen(mname)) return false;
13225
+ for (size_t i = 0; i < name_size; ++i) {
13226
+ if ((mname[i] | 0x20) != fname[i]) {
13227
+ // Case-insensitive ascii comparison.
13228
+ return false;
13229
+ }
13230
+ }
13231
+
13232
+ if (upb_MessageDef_File(msg) != upb_FieldDef_File(f)) {
13233
+ return false;
13234
+ }
13235
+
13236
+ // Group messages are always defined in the same scope as the field. File
13237
+ // level extensions will compare NULL == NULL here, which is why the file
13238
+ // comparison above is necessary to ensure both come from the same file.
13239
+ return upb_FieldDef_IsExtension(f) ? upb_FieldDef_ExtensionScope(f) ==
13240
+ upb_MessageDef_ContainingType(msg)
13241
+ : upb_FieldDef_ContainingType(f) ==
13242
+ upb_MessageDef_ContainingType(msg);
13243
+ }
13244
+
12379
13245
  uint64_t _upb_FieldDef_Modifiers(const upb_FieldDef* f) {
12380
13246
  uint64_t out = upb_FieldDef_IsPacked(f) ? kUpb_FieldModifier_IsPacked : 0;
12381
13247
 
@@ -12707,7 +13573,6 @@ static void _upb_FieldDef_Create(upb_DefBuilder* ctx, const char* prefix,
12707
13573
 
12708
13574
  const upb_StringView name = UPB_DESC(FieldDescriptorProto_name)(field_proto);
12709
13575
  f->full_name = _upb_DefBuilder_MakeFullName(ctx, prefix, name);
12710
- f->label_ = (int)UPB_DESC(FieldDescriptorProto_label)(field_proto);
12711
13576
  f->number_ = UPB_DESC(FieldDescriptorProto_number)(field_proto);
12712
13577
  f->is_proto3_optional =
12713
13578
  UPB_DESC(FieldDescriptorProto_proto3_optional)(field_proto);
@@ -12753,6 +13618,14 @@ static void _upb_FieldDef_Create(upb_DefBuilder* ctx, const char* prefix,
12753
13618
  f->resolved_features = _upb_DefBuilder_DoResolveFeatures(
12754
13619
  ctx, parent_features, unresolved_features, implicit);
12755
13620
 
13621
+ f->label_ = (int)UPB_DESC(FieldDescriptorProto_label)(field_proto);
13622
+ if (f->label_ == kUpb_Label_Optional &&
13623
+ // TODO: remove once we can deprecate kUpb_Label_Required.
13624
+ UPB_DESC(FeatureSet_field_presence)(f->resolved_features) ==
13625
+ UPB_DESC(FeatureSet_LEGACY_REQUIRED)) {
13626
+ f->label_ = kUpb_Label_Required;
13627
+ }
13628
+
12756
13629
  if (!UPB_DESC(FieldDescriptorProto_has_name)(field_proto)) {
12757
13630
  _upb_DefBuilder_Errf(ctx, "field has no name");
12758
13631
  }
@@ -12772,6 +13645,12 @@ static void _upb_FieldDef_Create(upb_DefBuilder* ctx, const char* prefix,
12772
13645
  UPB_DESC(FieldDescriptorProto_has_type_name)(field_proto);
12773
13646
 
12774
13647
  f->type_ = (int)UPB_DESC(FieldDescriptorProto_type)(field_proto);
13648
+ if (f->type_ == kUpb_FieldType_Message &&
13649
+ // TODO: remove once we can deprecate kUpb_FieldType_Group.
13650
+ UPB_DESC(FeatureSet_message_encoding)(f->resolved_features) ==
13651
+ UPB_DESC(FeatureSet_DELIMITED)) {
13652
+ f->type_ = kUpb_FieldType_Group;
13653
+ }
12775
13654
 
12776
13655
  if (has_type) {
12777
13656
  switch (f->type_) {
@@ -12821,10 +13700,11 @@ static void _upb_FieldDef_Create(upb_DefBuilder* ctx, const char* prefix,
12821
13700
 
12822
13701
  f->has_presence =
12823
13702
  (!upb_FieldDef_IsRepeated(f)) &&
12824
- (f->type_ == kUpb_FieldType_Message || f->type_ == kUpb_FieldType_Group ||
12825
- upb_FieldDef_ContainingOneof(f) ||
12826
- UPB_DESC(FeatureSet_field_presence)(f->resolved_features) !=
12827
- UPB_DESC(FeatureSet_IMPLICIT));
13703
+ (f->is_extension ||
13704
+ (f->type_ == kUpb_FieldType_Message ||
13705
+ f->type_ == kUpb_FieldType_Group || upb_FieldDef_ContainingOneof(f) ||
13706
+ UPB_DESC(FeatureSet_field_presence)(f->resolved_features) !=
13707
+ UPB_DESC(FeatureSet_IMPLICIT)));
12828
13708
  }
12829
13709
 
12830
13710
  static void _upb_FieldDef_CreateExt(upb_DefBuilder* ctx, const char* prefix,
@@ -13260,6 +14140,17 @@ const upb_MiniTableExtension* _upb_FileDef_ExtensionMiniTable(
13260
14140
  return f->ext_layouts[i];
13261
14141
  }
13262
14142
 
14143
+ // Note: Import cycles are not allowed so this will terminate.
14144
+ bool upb_FileDef_Resolves(const upb_FileDef* f, const char* path) {
14145
+ if (!strcmp(f->name, path)) return true;
14146
+
14147
+ for (int i = 0; i < upb_FileDef_PublicDependencyCount(f); i++) {
14148
+ const upb_FileDef* dep = upb_FileDef_PublicDependency(f, i);
14149
+ if (upb_FileDef_Resolves(dep, path)) return true;
14150
+ }
14151
+ return false;
14152
+ }
14153
+
13263
14154
  static char* strviewdup(upb_DefBuilder* ctx, upb_StringView view) {
13264
14155
  char* ret = upb_strdup2(view.data, view.size, _upb_DefBuilder_Arena(ctx));
13265
14156
  if (!ret) _upb_DefBuilder_OomErr(ctx);
@@ -13311,20 +14202,35 @@ const UPB_DESC(FeatureSet*)
13311
14202
  size_t n;
13312
14203
  const UPB_DESC(FeatureSetDefaults_FeatureSetEditionDefault)* const* d =
13313
14204
  UPB_DESC(FeatureSetDefaults_defaults)(defaults, &n);
13314
- const UPB_DESC(FeatureSet)* ret = NULL;
14205
+ const UPB_DESC(FeatureSetDefaults_FeatureSetEditionDefault)* result = NULL;
13315
14206
  for (size_t i = 0; i < n; i++) {
13316
14207
  if (UPB_DESC(FeatureSetDefaults_FeatureSetEditionDefault_edition)(d[i]) >
13317
14208
  edition) {
13318
14209
  break;
13319
14210
  }
13320
- ret = UPB_DESC(FeatureSetDefaults_FeatureSetEditionDefault_features)(d[i]);
14211
+ result = d[i];
13321
14212
  }
13322
- if (ret == NULL) {
14213
+ if (result == NULL) {
13323
14214
  _upb_DefBuilder_Errf(ctx, "No valid default found for edition %s",
13324
14215
  upb_FileDef_EditionName(edition));
13325
14216
  return NULL;
13326
14217
  }
13327
- return ret;
14218
+
14219
+ // Merge the fixed and overridable features to get the edition's default
14220
+ // feature set.
14221
+ const UPB_DESC(FeatureSet)* fixed = UPB_DESC(
14222
+ FeatureSetDefaults_FeatureSetEditionDefault_fixed_features)(result);
14223
+ const UPB_DESC(FeatureSet)* overridable = UPB_DESC(
14224
+ FeatureSetDefaults_FeatureSetEditionDefault_overridable_features)(result);
14225
+ if (!fixed && !overridable) {
14226
+ _upb_DefBuilder_Errf(ctx, "No valid default found for edition %s",
14227
+ upb_FileDef_EditionName(edition));
14228
+ return NULL;
14229
+ } else if (!fixed) {
14230
+ return overridable;
14231
+ }
14232
+ return _upb_DefBuilder_DoResolveFeatures(ctx, fixed, overridable,
14233
+ /*is_implicit=*/true);
13328
14234
  }
13329
14235
 
13330
14236
  // Allocate and initialize one file def, and add it to the context object.
@@ -14026,7 +14932,15 @@ make:
14026
14932
 
14027
14933
  bool upb_Message_SetFieldByDef(upb_Message* msg, const upb_FieldDef* f,
14028
14934
  upb_MessageValue val, upb_Arena* a) {
14029
- return upb_Message_SetField(msg, upb_FieldDef_MiniTable(f), val, a);
14935
+ const upb_MiniTableField* m_f = upb_FieldDef_MiniTable(f);
14936
+
14937
+ if (upb_MiniTableField_IsExtension(m_f)) {
14938
+ return upb_Message_SetExtension(msg, (const upb_MiniTableExtension*)m_f,
14939
+ &val, a);
14940
+ } else {
14941
+ upb_Message_SetBaseField(msg, m_f, &val);
14942
+ return true;
14943
+ }
14030
14944
  }
14031
14945
 
14032
14946
  void upb_Message_ClearFieldByDef(upb_Message* msg, const upb_FieldDef* f) {
@@ -14046,19 +14960,20 @@ void upb_Message_ClearByDef(upb_Message* msg, const upb_MessageDef* m) {
14046
14960
  bool upb_Message_Next(const upb_Message* msg, const upb_MessageDef* m,
14047
14961
  const upb_DefPool* ext_pool, const upb_FieldDef** out_f,
14048
14962
  upb_MessageValue* out_val, size_t* iter) {
14963
+ const upb_MiniTable* mt = upb_MessageDef_MiniTable(m);
14049
14964
  size_t i = *iter;
14050
- size_t n = upb_MessageDef_FieldCount(m);
14965
+ size_t n = upb_MiniTable_FieldCount(mt);
14966
+ const upb_MessageValue zero = {0};
14051
14967
  UPB_UNUSED(ext_pool);
14052
14968
 
14053
14969
  // Iterate over normal fields, returning the first one that is set.
14054
14970
  while (++i < n) {
14055
- const upb_FieldDef* f = upb_MessageDef_Field(m, i);
14056
- const upb_MiniTableField* field = upb_FieldDef_MiniTable(f);
14057
- upb_MessageValue val = upb_Message_GetFieldByDef(msg, f);
14971
+ const upb_MiniTableField* field = upb_MiniTable_GetFieldByIndex(mt, i);
14972
+ upb_MessageValue val = upb_Message_GetField(msg, field, zero);
14058
14973
 
14059
14974
  // Skip field if unset or empty.
14060
14975
  if (upb_MiniTableField_HasPresence(field)) {
14061
- if (!upb_Message_HasFieldByDef(msg, f)) continue;
14976
+ if (!upb_Message_HasBaseField(msg, field)) continue;
14062
14977
  } else {
14063
14978
  switch (UPB_PRIVATE(_upb_MiniTableField_Mode)(field)) {
14064
14979
  case kUpb_FieldMode_Map:
@@ -14075,7 +14990,8 @@ bool upb_Message_Next(const upb_Message* msg, const upb_MessageDef* m,
14075
14990
  }
14076
14991
 
14077
14992
  *out_val = val;
14078
- *out_f = f;
14993
+ *out_f =
14994
+ upb_MessageDef_FindFieldByNumber(m, upb_MiniTableField_Number(field));
14079
14995
  *iter = i;
14080
14996
  return true;
14081
14997
  }
@@ -14539,7 +15455,10 @@ void _upb_MessageDef_InsertField(upb_DefBuilder* ctx, upb_MessageDef* m,
14539
15455
  _upb_MessageDef_Insert(m, shortname, shortnamelen, field_v, ctx->arena);
14540
15456
  if (!ok) _upb_DefBuilder_OomErr(ctx);
14541
15457
 
14542
- if (strcmp(shortname, json_name) != 0 &&
15458
+ bool skip_json_conflicts =
15459
+ UPB_DESC(MessageOptions_deprecated_legacy_json_field_conflicts)(
15460
+ upb_MessageDef_Options(m));
15461
+ if (!skip_json_conflicts && strcmp(shortname, json_name) != 0 &&
14543
15462
  UPB_DESC(FeatureSet_json_format)(m->resolved_features) ==
14544
15463
  UPB_DESC(FeatureSet_ALLOW) &&
14545
15464
  upb_strtable_lookup(&m->ntof, json_name, &v)) {
@@ -14549,14 +15468,16 @@ void _upb_MessageDef_InsertField(upb_DefBuilder* ctx, upb_MessageDef* m,
14549
15468
  }
14550
15469
 
14551
15470
  if (upb_strtable_lookup(&m->jtof, json_name, &v)) {
14552
- _upb_DefBuilder_Errf(ctx, "duplicate json_name (%s)", json_name);
15471
+ if (!skip_json_conflicts) {
15472
+ _upb_DefBuilder_Errf(ctx, "duplicate json_name (%s)", json_name);
15473
+ }
15474
+ } else {
15475
+ const size_t json_size = strlen(json_name);
15476
+ ok = upb_strtable_insert(&m->jtof, json_name, json_size,
15477
+ upb_value_constptr(f), ctx->arena);
15478
+ if (!ok) _upb_DefBuilder_OomErr(ctx);
14553
15479
  }
14554
15480
 
14555
- const size_t json_size = strlen(json_name);
14556
- ok = upb_strtable_insert(&m->jtof, json_name, json_size,
14557
- upb_value_constptr(f), ctx->arena);
14558
- if (!ok) _upb_DefBuilder_OomErr(ctx);
14559
-
14560
15481
  if (upb_inttable_lookup(&m->itof, field_number, NULL)) {
14561
15482
  _upb_DefBuilder_Errf(ctx, "duplicate field number (%u)", field_number);
14562
15483
  }
@@ -14570,7 +15491,7 @@ void _upb_MessageDef_CreateMiniTable(upb_DefBuilder* ctx, upb_MessageDef* m) {
14570
15491
  m->layout = _upb_MessageDef_MakeMiniTable(ctx, m);
14571
15492
  } else {
14572
15493
  m->layout = upb_MiniTableFile_Message(ctx->layout, ctx->msg_count++);
14573
- UPB_ASSERT(m->field_count == m->layout->UPB_PRIVATE(field_count));
15494
+ UPB_ASSERT(m->field_count == upb_MiniTable_FieldCount(m->layout));
14574
15495
 
14575
15496
  // We don't need the result of this call, but it will assign layout_index
14576
15497
  // for all the fields in O(n lg n) time.
@@ -14628,7 +15549,7 @@ void _upb_MessageDef_LinkMiniTable(upb_DefBuilder* ctx,
14628
15549
  for (int i = 0; i < m->field_count; i++) {
14629
15550
  const upb_FieldDef* f = upb_MessageDef_Field(m, i);
14630
15551
  const int layout_index = _upb_FieldDef_LayoutIndex(f);
14631
- UPB_ASSERT(layout_index < m->layout->UPB_PRIVATE(field_count));
15552
+ UPB_ASSERT(layout_index < upb_MiniTable_FieldCount(m->layout));
14632
15553
  const upb_MiniTableField* mt_f =
14633
15554
  &m->layout->UPB_PRIVATE(fields)[layout_index];
14634
15555
  UPB_ASSERT(upb_FieldDef_Type(f) == upb_MiniTableField_Type(mt_f));
@@ -15394,7 +16315,7 @@ upb_ServiceDef* _upb_ServiceDefs_New(upb_DefBuilder* ctx, int n,
15394
16315
  #undef UPB_ASAN
15395
16316
  #undef UPB_ASAN_GUARD_SIZE
15396
16317
  #undef UPB_CLANG_ASAN
15397
- #undef UPB_TREAT_PROTO2_ENUMS_LIKE_PROTO3
16318
+ #undef UPB_TREAT_CLOSED_ENUMS_LIKE_OPEN
15398
16319
  #undef UPB_DEPRECATED
15399
16320
  #undef UPB_GNUC_MIN
15400
16321
  #undef UPB_DESCRIPTOR_UPB_H_FILENAME