Mirrors
/
protobuf
mirror of https://github.com/protocolbuffers/protobuf.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

upb: tag upb_MiniTableField:number as UPB_ONLYBITS() 

PiperOrigin-RevId: 587127664
pull/14920/head
Eric Salo 2023-12-01 14:48:25 -08:00 committed by Copybara-Service
parent e555bd23d0
commit 848a2bfd41
16 changed files with 95 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
upb/message/internal/accessors.h
View File

@ -119,7 +119,7 @@ UPB_INLINE uint32_t _upb_Message_GetOneofCase(const upb_Message* msg,
UPB_INLINE void _upb_Message_SetOneofCase(upb_Message* msg,
const upb_MiniTableField* f) {
*_upb_Message_OneofCasePtr(msg, f) = f->number;
*_upb_Message_OneofCasePtr(msg, f) = upb_MiniTableField_Number(f);
}
// TODO: implement _upb_Message_ClearOneofCase()
@ -227,7 +227,8 @@ UPB_INLINE bool _upb_Message_HasNonExtensionField(
UPB_ASSERT(upb_MiniTableField_HasPresence(field));
UPB_ASSUME(!upb_MiniTableField_IsExtension(field));
if (upb_MiniTableField_IsInOneof(field)) {
return _upb_Message_GetOneofCase(msg, field) == field->number;
return _upb_Message_GetOneofCase(msg, field) ==
upb_MiniTableField_Number(field);
} else {
return _upb_Message_GetHasbitByField(msg, field);
}
@ -325,7 +326,7 @@ UPB_INLINE void _upb_Message_ClearNonExtensionField(
_upb_Message_ClearHasbitByField(msg, field);
} else if (upb_MiniTableField_IsInOneof(field)) {
uint32_t* ptr = _upb_Message_OneofCasePtr(msg, field);
if (*ptr != field->number) return;
if (*ptr != upb_MiniTableField_Number(field)) return;
*ptr = 0;
}
const char zeros[16] = {0};

12
upb/message/promote.c
View File

@ -242,14 +242,16 @@ upb_UnknownToMessageRet upb_MiniTable_PromoteUnknownToMessage(
UPB_ASSERT(upb_MiniTable_GetSubMessageTable(mini_table, field) ==
sub_mini_table);
bool is_oneof = upb_MiniTableField_IsInOneof(field);
if (!is_oneof || _upb_Message_GetOneofCase(msg, field) == field->number) {
if (!is_oneof || _upb_Message_GetOneofCase(msg, field) ==
upb_MiniTableField_Number(field)) {
UPB_ASSERT(upb_Message_GetMessage(msg, field, NULL) == NULL);
}
upb_UnknownToMessageRet ret;
ret.status = kUpb_UnknownToMessage_Ok;
do {
unknown = upb_MiniTable_FindUnknown(
msg, field->number, upb_DecodeOptions_GetMaxDepth(decode_options));
msg, upb_MiniTableField_Number(field),
upb_DecodeOptions_GetMaxDepth(decode_options));
switch (unknown.status) {
case kUpb_FindUnknown_Ok: {
const char* unknown_data = unknown.ptr;
@ -296,7 +298,8 @@ upb_UnknownToMessage_Status upb_MiniTable_PromoteUnknownToMessageArray(
upb_FindUnknownRet unknown;
do {
unknown = upb_MiniTable_FindUnknown(
msg, field->number, upb_DecodeOptions_GetMaxDepth(decode_options));
msg, upb_MiniTableField_Number(field),
upb_DecodeOptions_GetMaxDepth(decode_options));
if (unknown.status == kUpb_FindUnknown_Ok) {
upb_UnknownToMessageRet ret = upb_MiniTable_ParseUnknownMessage(
unknown.ptr, unknown.len, mini_table,
@ -336,7 +339,8 @@ upb_UnknownToMessage_Status upb_MiniTable_PromoteUnknownToMap(
upb_FindUnknownRet unknown;
while (1) {
unknown = upb_MiniTable_FindUnknown(
msg, field->number, upb_DecodeOptions_GetMaxDepth(decode_options));
msg, upb_MiniTableField_Number(field),
upb_DecodeOptions_GetMaxDepth(decode_options));
if (unknown.status != kUpb_FindUnknown_Ok) break;
upb_UnknownToMessageRet ret = upb_MiniTable_ParseUnknownMessage(
unknown.ptr, unknown.len, map_entry_mini_table,

24
upb/mini_descriptor/decode.c
View File

@ -202,7 +202,7 @@ static void upb_MtDecoder_ModifyField(upb_MtDecoder* d,
if (!upb_MtDecoder_FieldIsPackable(field)) {
upb_MdDecoder_ErrorJmp(&d->base,
"Cannot flip packed on unpackable field %" PRIu32,
field->number);
upb_MiniTableField_Number(field));
}
field->UPB_PRIVATE(mode) ^= kUpb_LabelFlags_IsPacked;
}
@ -210,11 +210,12 @@ static void upb_MtDecoder_ModifyField(upb_MtDecoder* d,
if (field_modifiers & kUpb_EncodedFieldModifier_FlipValidateUtf8) {
if (field->UPB_PRIVATE(descriptortype) != kUpb_FieldType_Bytes ||
!(field->UPB_PRIVATE(mode) & kUpb_LabelFlags_IsAlternate)) {
upb_MdDecoder_ErrorJmp(
&d->base,
"Cannot flip ValidateUtf8 on field %" PRIu32 ", type=%d, mode=%d",
field->number, (int)field->UPB_PRIVATE(descriptortype),
(int)field->UPB_PRIVATE(mode));
upb_MdDecoder_ErrorJmp(&d->base,
"Cannot flip ValidateUtf8 on field %" PRIu32
", type=%d, mode=%d",
upb_MiniTableField_Number(field),
(int)field->UPB_PRIVATE(descriptortype),
(int)field->UPB_PRIVATE(mode));
}
field->UPB_PRIVATE(descriptortype) = kUpb_FieldType_String;
field->UPB_PRIVATE(mode) &= ~kUpb_LabelFlags_IsAlternate;
@ -227,12 +228,12 @@ static void upb_MtDecoder_ModifyField(upb_MtDecoder* d,
if ((singular || required) && field->offset != kHasbitPresence) {
upb_MdDecoder_ErrorJmp(&d->base,
"Invalid modifier(s) for repeated field %" PRIu32,
field->number);
upb_MiniTableField_Number(field));
}
if (singular && required) {
upb_MdDecoder_ErrorJmp(
&d->base, "Field %" PRIu32 " cannot be both singular and required",
field->number);
upb_MiniTableField_Number(field));
}
if (singular) field->offset = kNoPresence;
@ -433,7 +434,7 @@ static const char* upb_MtDecoder_Parse(upb_MtDecoder* d, const char* ptr,
upb_MiniTableField* field = fields;
*field_count += 1;
fields = (char*)fields + field_size;
field->number = ++last_field_number;
field->UPB_PRIVATE(number) = ++last_field_number;
last_field = field;
upb_MiniTable_SetField(d, ch, field, msg_modifiers, sub_counts);
} else if (kUpb_EncodedValue_MinModifier <= ch &&
@ -635,10 +636,11 @@ static void upb_MtDecoder_ValidateEntryField(upb_MtDecoder* d,
const upb_MiniTableField* f,
uint32_t expected_num) {
const char* name = expected_num == 1 ? "key" : "val";
if (f->number != expected_num) {
const uint32_t f_number = upb_MiniTableField_Number(f);
if (f_number != expected_num) {
upb_MdDecoder_ErrorJmp(&d->base,
"map %s did not have expected number (%d vs %d)",
name, expected_num, (int)f->number);
name, expected_num, f_number);
}
if (!upb_MiniTableField_IsScalar(f)) {

8
upb/mini_descriptor/internal/encode_test.cc
View File

@ -68,7 +68,7 @@ TEST_P(MiniTableTest, AllScalarTypes) {
absl::flat_hash_set<size_t> offsets;
for (int i = 0; i < 16; i++) {
const upb_MiniTableField* f = &table->UPB_PRIVATE(fields)[i];
EXPECT_EQ(i + 1, f->number);
EXPECT_EQ(i + 1, upb_MiniTableField_Number(f));
EXPECT_TRUE(upb_MiniTableField_IsScalar(f));
EXPECT_TRUE(offsets.insert(f->offset).second);
EXPECT_TRUE(f->offset < table->size);
@ -94,7 +94,7 @@ TEST_P(MiniTableTest, AllRepeatedTypes) {
absl::flat_hash_set<size_t> offsets;
for (int i = 0; i < 16; i++) {
const upb_MiniTableField* f = &table->UPB_PRIVATE(fields)[i];
EXPECT_EQ(i + 1, f->number);
EXPECT_EQ(i + 1, upb_MiniTableField_Number(f));
EXPECT_TRUE(upb_MiniTableField_IsArray(f));
EXPECT_TRUE(offsets.insert(f->offset).second);
EXPECT_TRUE(f->offset < table->size);
@ -122,7 +122,7 @@ TEST_P(MiniTableTest, Skips) {
absl::flat_hash_set<size_t> offsets;
for (size_t i = 0; i < field_numbers.size(); i++) {
const upb_MiniTableField* f = &table->UPB_PRIVATE(fields)[i];
EXPECT_EQ(field_numbers[i], f->number);
EXPECT_EQ(field_numbers[i], upb_MiniTableField_Number(f));
EXPECT_EQ(kUpb_FieldType_Float, upb_MiniTableField_Type(f));
EXPECT_TRUE(upb_MiniTableField_IsScalar(f));
EXPECT_TRUE(offsets.insert(f->offset).second);
@ -152,7 +152,7 @@ TEST_P(MiniTableTest, AllScalarTypesOneof) {
absl::flat_hash_set<size_t> offsets;
for (int i = 0; i < 16; i++) {
const upb_MiniTableField* f = &table->UPB_PRIVATE(fields)[i];
EXPECT_EQ(i + 1, f->number);
EXPECT_EQ(i + 1, upb_MiniTableField_Number(f));
EXPECT_TRUE(upb_MiniTableField_IsScalar(f));
// For a oneof all fields have the same offset.
EXPECT_EQ(table->UPB_PRIVATE(fields)[0].offset, f->offset);

4
upb/mini_table/compat.c
View File

@ -37,8 +37,8 @@ static upb_MiniTableEquals_Status upb_deep_check(const upb_MiniTable* src,
bool marked_src = false;
for (int i = 0; i < upb_MiniTable_FieldCount(src); i++) {
const upb_MiniTableField* src_field = upb_MiniTable_GetFieldByIndex(src, i);
const upb_MiniTableField* dst_field =
upb_MiniTable_FindFieldByNumber(dst, src_field->number);
const upb_MiniTableField* dst_field = upb_MiniTable_FindFieldByNumber(
dst, upb_MiniTableField_Number(src_field));
if (upb_MiniTableField_CType(src_field) !=
upb_MiniTableField_CType(dst_field))

6
upb/mini_table/field.h
View File

@ -8,6 +8,8 @@
#ifndef UPB_MINI_TABLE_FIELD_H_
#define UPB_MINI_TABLE_FIELD_H_
#include <stdint.h>
#include "upb/base/descriptor_constants.h"
#include "upb/mini_table/internal/field.h"
@ -64,6 +66,10 @@ UPB_API_INLINE bool upb_MiniTableField_IsSubMessage(
return UPB_PRIVATE(_upb_MiniTableField_IsSubMessage)(f);
}
UPB_API_INLINE uint32_t upb_MiniTableField_Number(const upb_MiniTableField* f) {
return UPB_PRIVATE(_upb_MiniTableField_Number)(f);
}
UPB_API_INLINE upb_FieldType
upb_MiniTableField_Type(const upb_MiniTableField* f) {
return UPB_PRIVATE(_upb_MiniTableField_Type)(f);

2
upb/mini_table/internal/extension.h
View File

@ -35,7 +35,7 @@ UPB_INLINE const struct upb_MiniTableField* UPB_PRIVATE(
UPB_INLINE uint32_t UPB_PRIVATE(_upb_MiniTableExtension_Number)(
const struct upb_MiniTableExtension* e) {
return e->UPB_PRIVATE(field).number;
return e->UPB_PRIVATE(field).UPB_ONLYBITS(number);
}
UPB_INLINE const struct upb_MiniTable* UPB_PRIVATE(

7
upb/mini_table/internal/field.h
View File

@ -19,7 +19,7 @@
// LINT.IfChange(struct_definition)
struct upb_MiniTableField {
uint32_t number;
uint32_t UPB_ONLYBITS(number);
uint16_t offset;
int16_t presence; // If >0, hasbit_index. If <0, ~oneof_index
@ -155,6 +155,11 @@ UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_HasPresence)(
}
}
UPB_INLINE uint32_t
UPB_PRIVATE(_upb_MiniTableField_Number)(const struct upb_MiniTableField* f) {
return f->UPB_ONLYBITS(number);
}
UPB_INLINE void UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(
const struct upb_MiniTableField* f) {
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) ==

4
upb/mini_table/message.c
View File

@ -23,7 +23,7 @@ const upb_MiniTableField* upb_MiniTable_FindFieldByNumber(
// Ideal case: index into dense fields
if (i < m->UPB_PRIVATE(dense_below)) {
UPB_ASSERT(m->UPB_PRIVATE(fields)[i].number == number);
UPB_ASSERT(m->UPB_PRIVATE(fields)[i].UPB_PRIVATE(number) == number);
return &m->UPB_PRIVATE(fields)[i];
}
@ -32,7 +32,7 @@ const upb_MiniTableField* upb_MiniTable_FindFieldByNumber(
int hi = m->UPB_PRIVATE(field_count) - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
uint32_t num = m->UPB_PRIVATE(fields)[mid].number;
uint32_t num = m->UPB_PRIVATE(fields)[mid].UPB_PRIVATE(number);
if (num < number) {
lo = mid + 1;
continue;

1
upb/test/BUILD
View File

@ -245,7 +245,6 @@ cc_test(
":test_upb_proto",
"@com_google_googletest//:gtest_main",
"//upb:mini_table",
"//upb:port",
],
)

5
upb/test/test_mini_table_oneof.cc
View File

@ -11,9 +11,6 @@
#include "upb/mini_table/message.h"
#include "upb/test/proto3_test.upb.h"
// Must be last.
#include "upb/port/def.inc"
TEST(MiniTableOneofTest, OneOfIteratorProto2) {
constexpr int oneof_first_field_number = 111;
constexpr int oneof_test_field_number = 116;
@ -26,7 +23,7 @@ TEST(MiniTableOneofTest, OneOfIteratorProto2) {
const upb_MiniTableField* ptr = upb_MiniTable_GetOneof(google_protobuf_table, field);
int field_num = oneof_first_field_number;
do {
EXPECT_EQ(ptr->number, field_num++);
EXPECT_EQ(upb_MiniTableField_Number(ptr), field_num++);
} while (upb_MiniTable_NextOneofField(google_protobuf_table, &ptr));
}

22
upb/wire/decode.c
View File

@ -353,7 +353,8 @@ static const char* _upb_Decoder_DecodeKnownGroup(
const upb_MiniTableSub* subs, const upb_MiniTableField* field) {
const upb_MiniTable* subl = _upb_MiniTableSubs_MessageByField(subs, field);
UPB_ASSERT(subl);
return _upb_Decoder_DecodeGroup(d, ptr, submsg, subl, field->number);
return _upb_Decoder_DecodeGroup(d, ptr, submsg, subl,
field->UPB_PRIVATE(number));
}
static char* upb_Decoder_EncodeVarint32(uint32_t val, char* ptr) {
@ -390,7 +391,8 @@ static bool _upb_Decoder_CheckEnum(upb_Decoder* d, const char* ptr,
// Unrecognized enum goes into unknown fields.
// For packed fields the tag could be arbitrarily far in the past,
// so we just re-encode the tag and value here.
const uint32_t tag = ((uint32_t)field->number << 3) | kUpb_WireType_Varint;
const uint32_t tag =
((uint32_t)field->UPB_PRIVATE(number) << 3) | kUpb_WireType_Varint;
upb_Message* unknown_msg =
field->UPB_PRIVATE(mode) & kUpb_LabelFlags_IsExtension ? d->unknown_msg
: msg;
@ -650,7 +652,8 @@ static const char* _upb_Decoder_DecodeToMap(upb_Decoder* d, const char* ptr,
if (size != 0) {
char* buf;
size_t size;
uint32_t tag = ((uint32_t)field->number << 3) | kUpb_WireType_Delimited;
uint32_t tag =
((uint32_t)field->UPB_PRIVATE(number) << 3) | kUpb_WireType_Delimited;
upb_EncodeStatus status =
upb_Encode(&ent.data, entry, 0, &d->arena, &buf, &size);
if (status != kUpb_EncodeStatus_Ok) {
@ -690,10 +693,11 @@ static const char* _upb_Decoder_DecodeToSubMessage(
} else if (field->presence < 0) {
/* Oneof case */
uint32_t* oneof_case = _upb_Message_OneofCasePtr(msg, field);
if (op == kUpb_DecodeOp_SubMessage && *oneof_case != field->number) {
if (op == kUpb_DecodeOp_SubMessage &&
*oneof_case != field->UPB_PRIVATE(number)) {
memset(mem, 0, sizeof(void*));
}
*oneof_case = field->number;
*oneof_case = field->UPB_PRIVATE(number);
}
/* Store into message. */
@ -926,13 +930,13 @@ static const upb_MiniTableField* _upb_Decoder_FindField(upb_Decoder* d,
* since fields are usually in order. */
size_t last = *last_field_index;
for (idx = last; idx < t->UPB_PRIVATE(field_count); idx++) {
if (t->UPB_PRIVATE(fields)[idx].number == field_number) {
if (t->UPB_PRIVATE(fields)[idx].UPB_PRIVATE(number) == field_number) {
goto found;
}
}
for (idx = t->UPB_PRIVATE(dense_below); idx < last; idx++) {
if (t->UPB_PRIVATE(fields)[idx].number == field_number) {
if (t->UPB_PRIVATE(fields)[idx].UPB_PRIVATE(number) == field_number) {
goto found;
}
}
@ -959,7 +963,7 @@ static const upb_MiniTableField* _upb_Decoder_FindField(upb_Decoder* d,
return &none; /* Unknown field. */
found:
UPB_ASSERT(t->UPB_PRIVATE(fields)[idx].number == field_number);
UPB_ASSERT(t->UPB_PRIVATE(fields)[idx].UPB_PRIVATE(number) == field_number);
*last_field_index = idx;
return &t->UPB_PRIVATE(fields)[idx];
}
@ -1117,7 +1121,7 @@ static const char* _upb_Decoder_DecodeWireValue(upb_Decoder* d, const char* ptr,
*op = _upb_Decoder_GetDelimitedOp(d, mt, field);
return ptr;
case kUpb_WireType_StartGroup:
val->uint32_val = field->number;
val->uint32_val = field->UPB_PRIVATE(number);
if (field->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Group) {
*op = kUpb_DecodeOp_SubMessage;
_upb_Decoder_CheckUnlinked(d, mt, field, op);

45
upb/wire/encode.c
View File

@ -277,7 +277,7 @@ static void encode_scalar(upb_encstate* e, const void* _field_mem,
return;
}
if (--e->depth == 0) encode_err(e, kUpb_EncodeStatus_MaxDepthExceeded);
encode_tag(e, f->number, kUpb_WireType_EndGroup);
encode_tag(e, f->UPB_PRIVATE(number), kUpb_WireType_EndGroup);
encode_TaggedMessagePtr(e, submsg, subm, &size);
wire_type = kUpb_WireType_StartGroup;
e->depth++;
@ -303,7 +303,7 @@ static void encode_scalar(upb_encstate* e, const void* _field_mem,
}
#undef CASE
encode_tag(e, f->number, wire_type);
encode_tag(e, f->UPB_PRIVATE(number), wire_type);
}
static void encode_array(upb_encstate* e, const upb_Message* msg,
@ -317,20 +317,21 @@ static void encode_array(upb_encstate* e, const upb_Message* msg,
return;
}
#define VARINT_CASE(ctype, encode) \
{ \
const ctype* start = _upb_array_constptr(arr); \
const ctype* ptr = start + arr->size; \
uint32_t tag = packed ? 0 : (f->number << 3) | kUpb_WireType_Varint; \
do { \
ptr--; \
encode_varint(e, encode); \
if (tag) encode_varint(e, tag); \
} while (ptr != start); \
} \
#define VARINT_CASE(ctype, encode) \
{ \
const ctype* start = _upb_array_constptr(arr); \
const ctype* ptr = start + arr->size; \
uint32_t tag = \
packed ? 0 : (f->UPB_PRIVATE(number) << 3) | kUpb_WireType_Varint; \
do { \
ptr--; \
encode_varint(e, encode); \
if (tag) encode_varint(e, tag); \
} while (ptr != start); \
} \
break;
#define TAG(wire_type) (packed ? 0 : (f->number << 3 | wire_type))
#define TAG(wire_type) (packed ? 0 : (f->UPB_PRIVATE(number) << 3 | wire_type))
switch (f->UPB_PRIVATE(descriptortype)) {
case kUpb_FieldType_Double:
@ -369,7 +370,7 @@ static void encode_array(upb_encstate* e, const upb_Message* msg,
ptr--;
encode_bytes(e, ptr->data, ptr->size);
encode_varint(e, ptr->size);
encode_tag(e, f->number, kUpb_WireType_Delimited);
encode_tag(e, f->UPB_PRIVATE(number), kUpb_WireType_Delimited);
} while (ptr != start);
return;
}
@ -382,9 +383,9 @@ static void encode_array(upb_encstate* e, const upb_Message* msg,
do {
size_t size;
ptr--;
encode_tag(e, f->number, kUpb_WireType_EndGroup);
encode_tag(e, f->UPB_PRIVATE(number), kUpb_WireType_EndGroup);
encode_TaggedMessagePtr(e, *ptr, subm, &size);
encode_tag(e, f->number, kUpb_WireType_StartGroup);
encode_tag(e, f->UPB_PRIVATE(number), kUpb_WireType_StartGroup);
} while (ptr != start);
e->depth++;
return;
@ -400,7 +401,7 @@ static void encode_array(upb_encstate* e, const upb_Message* msg,
ptr--;
encode_TaggedMessagePtr(e, *ptr, subm, &size);
encode_varint(e, size);
encode_tag(e, f->number, kUpb_WireType_Delimited);
encode_tag(e, f->UPB_PRIVATE(number), kUpb_WireType_Delimited);
} while (ptr != start);
e->depth++;
return;
@ -410,7 +411,7 @@ static void encode_array(upb_encstate* e, const upb_Message* msg,
if (packed) {
encode_varint(e, e->limit - e->ptr - pre_len);
encode_tag(e, f->number, kUpb_WireType_Delimited);
encode_tag(e, f->UPB_PRIVATE(number), kUpb_WireType_Delimited);
}
}
@ -445,7 +446,7 @@ static void encode_map(upb_encstate* e, const upb_Message* msg,
map, &sorted);
upb_MapEntry ent;
while (_upb_sortedmap_next(&e->sorter, map, &sorted, &ent)) {
encode_mapentry(e, f->number, layout, &ent);
encode_mapentry(e, f->UPB_PRIVATE(number), layout, &ent);
}
_upb_mapsorter_popmap(&e->sorter, &sorted);
} else {
@ -456,7 +457,7 @@ static void encode_map(upb_encstate* e, const upb_Message* msg,
upb_MapEntry ent;
_upb_map_fromkey(key, &ent.data.k, map->key_size);
_upb_map_fromvalue(val, &ent.data.v, map->val_size);
encode_mapentry(e, f->number, layout, &ent);
encode_mapentry(e, f->UPB_PRIVATE(number), layout, &ent);
}
}
}
@ -495,7 +496,7 @@ static bool encode_shouldencode(upb_encstate* e, const upb_Message* msg,
return _upb_Message_GetHasbitByField(msg, f);
} else {
// Field is in a oneof.
return _upb_Message_GetOneofCase(msg, f) == f->number;
return _upb_Message_GetOneofCase(msg, f) == f->UPB_PRIVATE(number);
}
}

9
upb_generator/code_generator_request.c
View File

@ -11,6 +11,7 @@
#include "google/protobuf/compiler/plugin.upb.h"
#include "upb/mini_descriptor/decode.h"
#include "upb/mini_table/field.h"
#include "upb/reflection/def.h"
// Must be last.
@ -171,8 +172,8 @@ static void upbc_Scrape_MessageSubs(upbc_State* s,
uint32_t enum_count = counts & 0xffff;
for (uint32_t i = 0; i < msg_count; i++) {
const upb_FieldDef* f =
upb_MessageDef_FindFieldByNumber(m, fields[i]->number);
const upb_FieldDef* f = upb_MessageDef_FindFieldByNumber(
m, upb_MiniTableField_Number(fields[i]));
if (!f) upbc_Error(s, __func__, "Missing f");
const upb_MessageDef* sub = upb_FieldDef_MessageSubDef(f);
if (!sub) upbc_Error(s, __func__, "Missing sub");
@ -181,8 +182,8 @@ static void upbc_Scrape_MessageSubs(upbc_State* s,
}
for (uint32_t i = 0; i < enum_count; i++) {
const upb_FieldDef* f =
upb_MessageDef_FindFieldByNumber(m, fields[msg_count + i]->number);
const upb_FieldDef* f = upb_MessageDef_FindFieldByNumber(
m, upb_MiniTableField_Number(fields[msg_count + i]));
if (!f) upbc_Error(s, __func__, "Missing f (2)");
const upb_EnumDef* sub = upb_FieldDef_EnumSubDef(f);
if (!sub) upbc_Error(s, __func__, "Missing sub (2)");

2
upb_generator/common.cc
View File

@ -84,7 +84,7 @@ std::string FieldInitializer(upb::FieldDefPtr field,
const upb_MiniTableField* field64,
const upb_MiniTableField* field32) {
return absl::Substitute(
"{$0, $1, $2, $3, $4, $5}", field64->number,
"{$0, $1, $2, $3, $4, $5}", upb_MiniTableField_Number(field64),
ArchDependentSize(field32->offset, field64->offset),
ArchDependentSize(field32->presence, field64->presence),
field64->UPB_PRIVATE(submsg_index) == kUpb_NoSub

11
upb_generator/protoc-gen-upb_minitable.cc
View File

@ -414,8 +414,9 @@ void WriteMessage(upb::MessageDefPtr message, const DefPoolPair& pools,
const upb_MiniTableField* f = &mt_64->UPB_PRIVATE(fields)[i];
uint32_t index = f->UPB_PRIVATE(submsg_index);
if (index != kUpb_NoSub) {
const int f_number = upb_MiniTableField_Number(f);
auto pair =
subs.emplace(index, GetSub(message.FindFieldByNumber(f->number)));
subs.emplace(index, GetSub(message.FindFieldByNumber(f_number)));
ABSL_CHECK(pair.second);
}
}
@ -441,10 +442,10 @@ void WriteMessage(upb::MessageDefPtr message, const DefPoolPair& pools,
output("static const upb_MiniTableField $0[$1] = {\n", fields_array_name,
mt_64->UPB_PRIVATE(field_count));
for (int i = 0; i < mt_64->UPB_PRIVATE(field_count); i++) {
WriteMessageField(
message.FindFieldByNumber(mt_64->UPB_PRIVATE(fields)[i].number),
&mt_64->UPB_PRIVATE(fields)[i], &mt_32->UPB_PRIVATE(fields)[i],
output);
WriteMessageField(message.FindFieldByNumber(
mt_64->UPB_PRIVATE(fields)[i].UPB_PRIVATE(number)),
&mt_64->UPB_PRIVATE(fields)[i],
&mt_32->UPB_PRIVATE(fields)[i], output);
}
output("};\n\n");
}