Auto-generate files after cl/586542236
diff --git a/ruby/ext/google/protobuf_c/ruby-upb.h b/ruby/ext/google/protobuf_c/ruby-upb.h
index 61342b0..a93465d 100755
--- a/ruby/ext/google/protobuf_c/ruby-upb.h
+++ b/ruby/ext/google/protobuf_c/ruby-upb.h
@@ -182,6 +182,12 @@
#define UPB_PRIVATE(x) x##_dont_copy_me__upb_internal_use_only
+#ifdef UPB_ALLOW_PRIVATE_ACCESS__FOR_BITS_ONLY
+#define UPB_ONLYBITS(x) x
+#else
+#define UPB_ONLYBITS(x) UPB_PRIVATE(x)
+#endif
+
/* Configure whether fasttable is switched on or not. *************************/
#ifdef __has_attribute
@@ -1311,82 +1317,6 @@
#define UPB_MINI_TABLE_INTERNAL_MESSAGE_H_
-// Must be last.
-
-struct upb_Decoder;
-typedef const char* _upb_FieldParser(struct upb_Decoder* d, const char* ptr,
- upb_Message* msg, intptr_t table,
- uint64_t hasbits, uint64_t data);
-typedef struct {
- uint64_t field_data;
- _upb_FieldParser* field_parser;
-} _upb_FastTable_Entry;
-
-typedef enum {
- kUpb_ExtMode_NonExtendable = 0, // Non-extendable message.
- kUpb_ExtMode_Extendable = 1, // Normal extendable message.
- kUpb_ExtMode_IsMessageSet = 2, // MessageSet message.
- kUpb_ExtMode_IsMessageSet_ITEM =
- 3, // MessageSet item (temporary only, see decode.c)
-
- // During table building we steal a bit to indicate that the message is a map
- // entry. *Only* used during table building!
- kUpb_ExtMode_IsMapEntry = 4,
-} upb_ExtMode;
-
-// upb_MiniTable represents the memory layout of a given upb_MessageDef.
-// The members are public so generated code can initialize them,
-// but users MUST NOT directly read or write any of its members.
-struct upb_MiniTable {
- const union upb_MiniTableSub* subs;
- const struct upb_MiniTableField* fields;
-
- // Must be aligned to sizeof(void*). Doesn't include internal members like
- // unknown fields, extension dict, pointer to msglayout, etc.
- uint16_t size;
-
- uint16_t field_count;
- uint8_t ext; // upb_ExtMode, declared as uint8_t so sizeof(ext) == 1
- uint8_t dense_below;
- uint8_t table_mask;
- uint8_t required_count; // Required fields have the lowest hasbits.
-
- // To statically initialize the tables of variable length, we need a flexible
- // array member, and we need to compile in gnu99 mode (constant initialization
- // of flexible array members is a GNU extension, not in C99 unfortunately.
- _upb_FastTable_Entry fasttable[];
-};
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// A MiniTable for an empty message, used for unlinked sub-messages.
-extern const struct upb_MiniTable _kUpb_MiniTable_Empty;
-
-// Computes a bitmask in which the |l->required_count| lowest bits are set,
-// except that we skip the lowest bit (because upb never uses hasbit 0).
-//
-// Sample output:
-// requiredmask(1) => 0b10 (0x2)
-// requiredmask(5) => 0b111110 (0x3e)
-UPB_INLINE uint64_t upb_MiniTable_requiredmask(const struct upb_MiniTable* l) {
- int n = l->required_count;
- assert(0 < n && n <= 63);
- return ((1ULL << n) - 1) << 1;
-}
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-
-#endif /* UPB_MINI_TABLE_INTERNAL_MESSAGE_H_ */
-
-#ifndef UPB_MINI_TABLE_SUB_H_
-#define UPB_MINI_TABLE_SUB_H_
-
-
#ifndef UPB_MINI_TABLE_INTERNAL_SUB_H_
#define UPB_MINI_TABLE_INTERNAL_SUB_H_
@@ -1434,34 +1364,117 @@
// Must be last.
-typedef union upb_MiniTableSub upb_MiniTableSub;
+struct upb_Decoder;
+typedef const char* _upb_FieldParser(struct upb_Decoder* d, const char* ptr,
+ upb_Message* msg, intptr_t table,
+ uint64_t hasbits, uint64_t data);
+typedef struct {
+ uint64_t field_data;
+ _upb_FieldParser* field_parser;
+} _upb_FastTable_Entry;
+
+typedef enum {
+ kUpb_ExtMode_NonExtendable = 0, // Non-extendable message.
+ kUpb_ExtMode_Extendable = 1, // Normal extendable message.
+ kUpb_ExtMode_IsMessageSet = 2, // MessageSet message.
+ kUpb_ExtMode_IsMessageSet_ITEM =
+ 3, // MessageSet item (temporary only, see decode.c)
+
+ // During table building we steal a bit to indicate that the message is a map
+ // entry. *Only* used during table building!
+ kUpb_ExtMode_IsMapEntry = 4,
+} upb_ExtMode;
+
+// upb_MiniTable represents the memory layout of a given upb_MessageDef.
+// The members are public so generated code can initialize them,
+// but users MUST NOT directly read or write any of its members.
+struct upb_MiniTable {
+ const union upb_MiniTableSub* UPB_PRIVATE(subs);
+ const struct upb_MiniTableField* UPB_ONLYBITS(fields);
+
+ // Must be aligned to sizeof(void*). Doesn't include internal members like
+ // unknown fields, extension dict, pointer to msglayout, etc.
+ uint16_t size;
+
+ uint16_t UPB_ONLYBITS(field_count);
+
+ uint8_t UPB_PRIVATE(ext); // upb_ExtMode, uint8_t here so sizeof(ext) == 1
+ uint8_t UPB_PRIVATE(dense_below);
+ uint8_t UPB_PRIVATE(table_mask);
+ uint8_t UPB_PRIVATE(required_count); // Required fields have the low hasbits.
+
+ // To statically initialize the tables of variable length, we need a flexible
+ // array member, and we need to compile in gnu99 mode (constant initialization
+ // of flexible array members is a GNU extension, not in C99 unfortunately.
+ _upb_FastTable_Entry UPB_PRIVATE(fasttable)[];
+};
#ifdef __cplusplus
extern "C" {
#endif
-// Constructors
+UPB_INLINE const struct upb_MiniTable* UPB_PRIVATE(_upb_MiniTable_Empty)(void) {
+ extern const struct upb_MiniTable UPB_PRIVATE(_kUpb_MiniTable_Empty);
-UPB_API_INLINE upb_MiniTableSub
-upb_MiniTableSub_FromEnum(const struct upb_MiniTableEnum* subenum) {
- return UPB_PRIVATE(_upb_MiniTableSub_FromEnum)(subenum);
+ return &UPB_PRIVATE(_kUpb_MiniTable_Empty);
}
-UPB_API_INLINE upb_MiniTableSub
-upb_MiniTableSub_FromMessage(const struct upb_MiniTable* submsg) {
- return UPB_PRIVATE(_upb_MiniTableSub_FromMessage)(submsg);
+UPB_INLINE int UPB_PRIVATE(_upb_MiniTable_FieldCount)(
+ const struct upb_MiniTable* m) {
+ return m->UPB_ONLYBITS(field_count);
}
-// Getters
+UPB_INLINE bool UPB_PRIVATE(_upb_MiniTable_IsEmpty)(
+ const struct upb_MiniTable* m) {
+ extern const struct upb_MiniTable UPB_PRIVATE(_kUpb_MiniTable_Empty);
-UPB_API_INLINE const struct upb_MiniTableEnum* upb_MiniTableSub_Enum(
- upb_MiniTableSub sub) {
- return UPB_PRIVATE(_upb_MiniTableSub_Enum)(sub);
+ return m == &UPB_PRIVATE(_kUpb_MiniTable_Empty);
}
-UPB_API_INLINE const struct upb_MiniTable* upb_MiniTableSub_Message(
- upb_MiniTableSub sub) {
- return UPB_PRIVATE(_upb_MiniTableSub_Message)(sub);
+UPB_INLINE const struct upb_MiniTableField* UPB_PRIVATE(
+ _upb_MiniTable_GetFieldByIndex)(const struct upb_MiniTable* m, uint32_t i) {
+ return &m->UPB_ONLYBITS(fields)[i];
+}
+
+UPB_INLINE const union upb_MiniTableSub* UPB_PRIVATE(
+ _upb_MiniTable_GetSubByIndex)(const struct upb_MiniTable* m, uint32_t i) {
+ return &m->UPB_PRIVATE(subs)[i];
+}
+
+UPB_INLINE const struct upb_MiniTable* UPB_PRIVATE(
+ _upb_MiniTable_GetSubMessageTable)(const struct upb_MiniTable* m,
+ const struct upb_MiniTableField* f) {
+ UPB_ASSERT(UPB_PRIVATE(_upb_MiniTableField_CType)(f) == kUpb_CType_Message);
+ const struct upb_MiniTable* ret = UPB_PRIVATE(_upb_MiniTableSub_Message)(
+ m->UPB_PRIVATE(subs)[f->UPB_PRIVATE(submsg_index)]);
+ UPB_ASSUME(ret);
+ return UPB_PRIVATE(_upb_MiniTable_IsEmpty)(ret) ? NULL : ret;
+}
+
+UPB_INLINE const struct upb_MiniTableEnum* UPB_PRIVATE(
+ _upb_MiniTable_GetSubEnumTable)(const struct upb_MiniTable* m,
+ const struct upb_MiniTableField* f) {
+ UPB_ASSERT(UPB_PRIVATE(_upb_MiniTableField_CType)(f) == kUpb_CType_Enum);
+ return UPB_PRIVATE(_upb_MiniTableSub_Enum)(
+ m->UPB_PRIVATE(subs)[f->UPB_PRIVATE(submsg_index)]);
+}
+
+UPB_INLINE bool UPB_PRIVATE(_upb_MiniTable_MessageFieldIsLinked)(
+ const struct upb_MiniTable* m, const struct upb_MiniTableField* f) {
+ return UPB_PRIVATE(_upb_MiniTable_GetSubMessageTable)(m, f) != NULL;
+}
+
+// Computes a bitmask in which the |m->required_count| lowest bits are set,
+// except that we skip the lowest bit (because upb never uses hasbit 0).
+//
+// Sample output:
+// RequiredMask(1) => 0b10 (0x2)
+// RequiredMask(5) => 0b111110 (0x3e)
+UPB_INLINE uint64_t
+UPB_PRIVATE(_upb_MiniTable_RequiredMask)(const struct upb_MiniTable* m) {
+ int n = m->UPB_PRIVATE(required_count);
+ UPB_ASSERT(0 < n && n <= 63);
+ return ((1ULL << n) - 1) << 1;
}
#ifdef __cplusplus
@@ -1469,50 +1482,54 @@
#endif
-#endif /* UPB_MINI_TABLE_SUB_H_ */
+#endif /* UPB_MINI_TABLE_INTERNAL_MESSAGE_H_ */
// Must be last.
+typedef struct upb_MiniTable upb_MiniTable;
+
#ifdef __cplusplus
extern "C" {
#endif
-typedef struct upb_MiniTable upb_MiniTable;
-
UPB_API const upb_MiniTableField* upb_MiniTable_FindFieldByNumber(
- const upb_MiniTable* table, uint32_t number);
+ const upb_MiniTable* m, uint32_t number);
UPB_API_INLINE const upb_MiniTableField* upb_MiniTable_GetFieldByIndex(
- const upb_MiniTable* t, uint32_t index) {
- return &t->fields[index];
+ const upb_MiniTable* m, uint32_t index) {
+ return UPB_PRIVATE(_upb_MiniTable_GetFieldByIndex)(m, index);
}
-// Returns the MiniTable for this message field. If the field is unlinked,
-// returns NULL.
+UPB_API_INLINE int upb_MiniTable_FieldCount(const upb_MiniTable* m) {
+ return UPB_PRIVATE(_upb_MiniTable_FieldCount)(m);
+}
+
+// Returns the MiniTable for a message field, NULL if the field is unlinked.
UPB_API_INLINE const upb_MiniTable* upb_MiniTable_GetSubMessageTable(
- const upb_MiniTable* mini_table, const upb_MiniTableField* field) {
- UPB_ASSERT(upb_MiniTableField_CType(field) == kUpb_CType_Message);
- const upb_MiniTable* ret = upb_MiniTableSub_Message(
- mini_table->subs[field->UPB_PRIVATE(submsg_index)]);
- UPB_ASSUME(ret);
- return ret == &_kUpb_MiniTable_Empty ? NULL : ret;
+ const upb_MiniTable* m, const upb_MiniTableField* f) {
+ return UPB_PRIVATE(_upb_MiniTable_GetSubMessageTable)(m, f);
}
-// Returns the MiniTableEnum for this enum field. If the field is unlinked,
-// returns NULL.
+// Returns the MiniTableEnum for a message field, NULL if the field is unlinked.
UPB_API_INLINE const upb_MiniTableEnum* upb_MiniTable_GetSubEnumTable(
- const upb_MiniTable* mini_table, const upb_MiniTableField* f) {
- UPB_ASSERT(upb_MiniTableField_CType(f) == kUpb_CType_Enum);
- return upb_MiniTableSub_Enum(mini_table->subs[f->UPB_PRIVATE(submsg_index)]);
+ const upb_MiniTable* m, const upb_MiniTableField* f) {
+ return UPB_PRIVATE(_upb_MiniTable_GetSubEnumTable)(m, f);
}
// Returns true if this MiniTable field is linked to a MiniTable for the
// sub-message.
UPB_API_INLINE bool upb_MiniTable_MessageFieldIsLinked(
- const upb_MiniTable* mini_table, const upb_MiniTableField* field) {
- return upb_MiniTable_GetSubMessageTable(mini_table, field) != NULL;
+ const upb_MiniTable* m, const upb_MiniTableField* f) {
+ return UPB_PRIVATE(_upb_MiniTable_MessageFieldIsLinked)(m, f);
}
+// TODO: Implement convenience getters for map entries:
+//
+// upb_MiniTable_GetMapKey()
+// upb_MiniTable_GetMapValue()
+// These could also assert that this is indeed a map entry (well, as best we
+// can. We can assert that there are two fields with field numbers 1 and 2).
+
// If this field is in a oneof, returns the first field in the oneof.
//
// Otherwise returns NULL.
@@ -2402,8 +2419,8 @@
/* Maps upb_CType -> memory size. */
extern char _upb_CTypeo_size[12];
-UPB_INLINE size_t upb_msg_sizeof(const upb_MiniTable* t) {
- return t->size + sizeof(upb_Message_Internal);
+UPB_INLINE size_t upb_msg_sizeof(const upb_MiniTable* m) {
+ return m->size + sizeof(upb_Message_Internal);
}
// Inline version upb_Message_New(), for internal use.
@@ -2899,6 +2916,49 @@
#endif /* UPB_MESSAGE_INTERNAL_ARRAY_H_ */
+#ifndef UPB_MINI_TABLE_SUB_H_
+#define UPB_MINI_TABLE_SUB_H_
+
+
+// Must be last.
+
+typedef union upb_MiniTableSub upb_MiniTableSub;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Constructors
+
+UPB_API_INLINE upb_MiniTableSub
+upb_MiniTableSub_FromEnum(const struct upb_MiniTableEnum* subenum) {
+ return UPB_PRIVATE(_upb_MiniTableSub_FromEnum)(subenum);
+}
+
+UPB_API_INLINE upb_MiniTableSub
+upb_MiniTableSub_FromMessage(const struct upb_MiniTable* submsg) {
+ return UPB_PRIVATE(_upb_MiniTableSub_FromMessage)(submsg);
+}
+
+// Getters
+
+UPB_API_INLINE const struct upb_MiniTableEnum* upb_MiniTableSub_Enum(
+ upb_MiniTableSub sub) {
+ return UPB_PRIVATE(_upb_MiniTableSub_Enum)(sub);
+}
+
+UPB_API_INLINE const struct upb_MiniTable* upb_MiniTableSub_Message(
+ upb_MiniTableSub sub) {
+ return UPB_PRIVATE(_upb_MiniTableSub_Message)(sub);
+}
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_MINI_TABLE_SUB_H_ */
+
// Must be last.
#ifdef __cplusplus
@@ -3214,7 +3274,7 @@
UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte));
UPB_ASSUME(upb_MiniTableField_IsScalar(field));
UPB_ASSERT(upb_MiniTableSub_Message(
- mini_table->subs[field->UPB_PRIVATE(submsg_index)]));
+ mini_table->UPB_PRIVATE(subs)[field->UPB_PRIVATE(submsg_index)]));
_upb_Message_SetNonExtensionField(msg, field, &sub_message);
}
@@ -3234,7 +3294,7 @@
upb_Message* sub_message = *UPB_PTR_AT(msg, field->offset, upb_Message*);
if (!sub_message) {
const upb_MiniTable* sub_mini_table = upb_MiniTableSub_Message(
- mini_table->subs[field->UPB_PRIVATE(submsg_index)]);
+ mini_table->UPB_PRIVATE(subs)[field->UPB_PRIVATE(submsg_index)]);
UPB_ASSERT(sub_mini_table);
sub_message = _upb_Message_New(sub_mini_table, arena);
*UPB_PTR_AT(msg, field->offset, upb_Message*) = sub_message;
@@ -3304,9 +3364,9 @@
const upb_MiniTableField* field, upb_Arena* arena) {
UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Message);
const upb_MiniTableField* map_entry_key_field =
- &map_entry_mini_table->fields[0];
+ &map_entry_mini_table->UPB_PRIVATE(fields)[0];
const upb_MiniTableField* map_entry_value_field =
- &map_entry_mini_table->fields[1];
+ &map_entry_mini_table->UPB_PRIVATE(fields)[1];
return _upb_Message_GetOrCreateMutableMap(
msg, field,
_upb_Map_CTypeSize(upb_MiniTableField_CType(map_entry_key_field)),
@@ -13239,12 +13299,12 @@
const char* _upb_Decoder_CheckRequired(upb_Decoder* d, const char* ptr,
const upb_Message* msg,
- const upb_MiniTable* l);
+ const upb_MiniTable* m);
/* x86-64 pointers always have the high 16 bits matching. So we can shift
* left 8 and right 8 without loss of information. */
UPB_INLINE intptr_t decode_totable(const upb_MiniTable* tablep) {
- return ((intptr_t)tablep << 8) | tablep->table_mask;
+ return ((intptr_t)tablep << 8) | tablep->UPB_PRIVATE(table_mask);
}
UPB_INLINE const upb_MiniTable* decode_totablep(intptr_t table) {
@@ -13285,9 +13345,9 @@
size_t idx = tag & mask;
UPB_ASSUME((idx & 7) == 0);
idx >>= 3;
- data = table_p->fasttable[idx].field_data ^ tag;
- UPB_MUSTTAIL return table_p->fasttable[idx].field_parser(d, ptr, msg, table,
- hasbits, data);
+ data = table_p->UPB_PRIVATE(fasttable)[idx].field_data ^ tag;
+ UPB_MUSTTAIL return table_p->UPB_PRIVATE(fasttable)[idx].field_parser(
+ d, ptr, msg, table, hasbits, data);
}
#endif
@@ -13597,3 +13657,4 @@
#undef UPB_ATOMIC
#undef UPB_USE_C11_ATOMICS
#undef UPB_PRIVATE
+#undef UPB_ONLYBITS
