Chiebot-Mirror
/
protobuf
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

upb: tag upb_MiniTableField:mode as UPB_ONLYBITS()

Browse Source 
PiperOrigin-RevId: 587022805
pull/14926/head
Eric Salo 1 year ago committed by Copybara-Service
parent 29fca8a64b
commit 0e6607a5c9
6 changed files with 40 additions and 32 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 33
      upb/mini_descriptor/decode.c
  2. 4
      upb/mini_descriptor/link.c
  3. 6
      upb/mini_table/compat.c
  4. 18
      upb/mini_table/internal/field.h
  5. 9
      upb/wire/decode.c
  6. 2
      upb_generator/common.cc

33
upb/mini_descriptor/decode.c
Unescape View File

@ -77,7 +77,7 @@ enum PresenceClass {
};
static bool upb_MtDecoder_FieldIsPackable(upb_MiniTableField* field) {
return (field->mode & kUpb_FieldMode_Array) &&
return (field->UPB_PRIVATE(mode) & kUpb_FieldMode_Array) &&
upb_FieldType_IsPackable(field->UPB_PRIVATE(descriptortype));
}
@ -94,18 +94,18 @@ static void upb_MiniTable_SetTypeAndSub(upb_MiniTableField* field,
if (is_proto3_enum) {
UPB_ASSERT(type == kUpb_FieldType_Enum);
type = kUpb_FieldType_Int32;
field->mode |= kUpb_LabelFlags_IsAlternate;
field->UPB_PRIVATE(mode) |= kUpb_LabelFlags_IsAlternate;
} else if (type == kUpb_FieldType_String &&
!(msg_modifiers & kUpb_MessageModifier_ValidateUtf8)) {
type = kUpb_FieldType_Bytes;
field->mode |= kUpb_LabelFlags_IsAlternate;
field->UPB_PRIVATE(mode) |= kUpb_LabelFlags_IsAlternate;
}
field->UPB_PRIVATE(descriptortype) = type;
if (upb_MtDecoder_FieldIsPackable(field) &&
(msg_modifiers & kUpb_MessageModifier_DefaultIsPacked)) {
field->mode |= kUpb_LabelFlags_IsPacked;
field->UPB_PRIVATE(mode) |= kUpb_LabelFlags_IsPacked;
}
if (type == kUpb_FieldType_Message || type == kUpb_FieldType_Group) {
@ -172,18 +172,19 @@ static void upb_MiniTable_SetField(upb_MtDecoder* d, uint8_t ch,
int8_t type = _upb_FromBase92(ch);
if (ch >= _upb_ToBase92(kUpb_EncodedType_RepeatedBase)) {
type -= kUpb_EncodedType_RepeatedBase;
field->mode = kUpb_FieldMode_Array;
field->mode |= pointer_rep << kUpb_FieldRep_Shift;
field->UPB_PRIVATE(mode) = kUpb_FieldMode_Array;
field->UPB_PRIVATE(mode) |= pointer_rep << kUpb_FieldRep_Shift;
field->offset = kNoPresence;
} else {
field->mode = kUpb_FieldMode_Scalar;
field->UPB_PRIVATE(mode) = kUpb_FieldMode_Scalar;
field->offset = kHasbitPresence;
if (type == kUpb_EncodedType_Group || type == kUpb_EncodedType_Message) {
field->mode |= pointer_rep << kUpb_FieldRep_Shift;
field->UPB_PRIVATE(mode) |= pointer_rep << kUpb_FieldRep_Shift;
} else if ((unsigned long)type >= sizeof(kUpb_EncodedToFieldRep)) {
upb_MdDecoder_ErrorJmp(&d->base, "Invalid field type: %d", (int)type);
} else {
field->mode |= kUpb_EncodedToFieldRep[type] << kUpb_FieldRep_Shift;
field->UPB_PRIVATE(mode) |= kUpb_EncodedToFieldRep[type]
<< kUpb_FieldRep_Shift;
}
}
if ((unsigned long)type >= sizeof(kUpb_EncodedToType)) {
@ -203,20 +204,20 @@ static void upb_MtDecoder_ModifyField(upb_MtDecoder* d,
"Cannot flip packed on unpackable field %" PRIu32,
field->number);
}
field->mode ^= kUpb_LabelFlags_IsPacked;
field->UPB_PRIVATE(mode) ^= kUpb_LabelFlags_IsPacked;
}
if (field_modifiers & kUpb_EncodedFieldModifier_FlipValidateUtf8) {
if (field->UPB_PRIVATE(descriptortype) != kUpb_FieldType_Bytes ||
!(field->mode & kUpb_LabelFlags_IsAlternate)) {
!(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->mode);
(int)field->UPB_PRIVATE(mode));
}
field->UPB_PRIVATE(descriptortype) = kUpb_FieldType_String;
field->mode &= ~kUpb_LabelFlags_IsAlternate;
field->UPB_PRIVATE(mode) &= ~kUpb_LabelFlags_IsAlternate;
}
bool singular = field_modifiers & kUpb_EncodedFieldModifier_IsProto3Singular;
@ -332,7 +333,7 @@ static const char* upb_MtDecoder_DecodeOneofField(upb_MtDecoder* d,
}
// Oneof storage must be large enough to accommodate the largest member.
int rep = f->mode >> kUpb_FieldRep_Shift;
int rep = f->UPB_PRIVATE(mode) >> kUpb_FieldRep_Shift;
if (upb_MtDecoder_SizeOfRep(rep, d->platform) >
upb_MtDecoder_SizeOfRep(item->rep, d->platform)) {
item->rep = rep;
@ -517,7 +518,7 @@ static bool upb_MtDecoder_SortLayoutItems(upb_MtDecoder* d) {
upb_MiniTableField* f = &d->fields[i];
if (f->offset >= kOneofBase) continue;
upb_LayoutItem item = {.field_index = i,
.rep = f->mode >> kUpb_FieldRep_Shift,
.rep = f->UPB_PRIVATE(mode) >> kUpb_FieldRep_Shift,
.type = kUpb_LayoutItemType_Field};
upb_MtDecoder_PushItem(d, item);
}
@ -809,7 +810,7 @@ static const char* upb_MtDecoder_DoBuildMiniTableExtension(
upb_MiniTableField* f = &ext->UPB_PRIVATE(field);
f->mode |= kUpb_LabelFlags_IsExtension;
f->UPB_PRIVATE(mode) |= kUpb_LabelFlags_IsExtension;
f->offset = 0;
f->presence = 0;

4
upb/mini_descriptor/link.c
Unescape View File

@ -38,7 +38,9 @@ bool upb_MiniTable_SetSubMessage(upb_MiniTable* table,
table->UPB_PRIVATE(ext) & kUpb_ExtMode_IsMapEntry;
if (UPB_UNLIKELY(table_is_map)) return false;
field->mode = (field->mode & ~kUpb_FieldMode_Mask) | kUpb_FieldMode_Map;
field->UPB_PRIVATE(mode) =
(field->UPB_PRIVATE(mode) & ~kUpb_FieldMode_Mask) |
kUpb_FieldMode_Map;
}
break;

6
upb/mini_table/compat.c
Unescape View File

@ -7,6 +7,9 @@
#include "upb/mini_table/compat.h"
#include <stddef.h>
#include <stdint.h>
#include "upb/base/descriptor_constants.h"
#include "upb/hash/common.h"
#include "upb/hash/int_table.h"
@ -40,7 +43,8 @@ static upb_MiniTableEquals_Status upb_deep_check(const upb_MiniTable* src,
if (upb_MiniTableField_CType(src_field) !=
upb_MiniTableField_CType(dst_field))
return false;
if (src_field->mode != dst_field->mode) return false;
if (src_field->UPB_PRIVATE(mode) != dst_field->UPB_PRIVATE(mode))
return false;
if (src_field->offset != dst_field->offset) return false;
if (src_field->presence != dst_field->presence) return false;
if (src_field->UPB_PRIVATE(submsg_index) !=

18
upb/mini_table/internal/field.h
Unescape View File

@ -29,7 +29,7 @@ struct upb_MiniTableField {
uint8_t UPB_PRIVATE(descriptortype);
// upb_FieldMode | upb_LabelFlags | (upb_FieldRep << kUpb_FieldRep_Shift)
uint8_t mode;
uint8_t UPB_ONLYBITS(mode);
};
#define kUpb_NoSub ((uint16_t)-1)
@ -75,42 +75,42 @@ extern "C" {
UPB_INLINE upb_FieldMode
UPB_PRIVATE(_upb_MiniTableField_Mode)(const struct upb_MiniTableField* f) {
return (upb_FieldMode)(f->mode & kUpb_FieldMode_Mask);
return (upb_FieldMode)(f->UPB_ONLYBITS(mode) & kUpb_FieldMode_Mask);
}
UPB_INLINE upb_FieldRep
UPB_PRIVATE(_upb_MiniTableField_GetRep)(const struct upb_MiniTableField* f) {
return (upb_FieldRep)(f->mode >> kUpb_FieldRep_Shift);
return (upb_FieldRep)(f->UPB_ONLYBITS(mode) >> kUpb_FieldRep_Shift);
}
UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsArray)(
const struct upb_MiniTableField* f) {
return (f->mode & kUpb_FieldMode_Mask) == kUpb_FieldMode_Array;
return UPB_PRIVATE(_upb_MiniTableField_Mode)(f) == kUpb_FieldMode_Array;
}
UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsMap)(
const struct upb_MiniTableField* f) {
return (f->mode & kUpb_FieldMode_Mask) == kUpb_FieldMode_Map;
return UPB_PRIVATE(_upb_MiniTableField_Mode)(f) == kUpb_FieldMode_Map;
}
UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsScalar)(
const struct upb_MiniTableField* f) {
return (f->mode & kUpb_FieldMode_Mask) == kUpb_FieldMode_Scalar;
return UPB_PRIVATE(_upb_MiniTableField_Mode)(f) == kUpb_FieldMode_Scalar;
}
UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsAlternate)(
const struct upb_MiniTableField* f) {
return (f->mode & kUpb_LabelFlags_IsAlternate) != 0;
return (f->UPB_ONLYBITS(mode) & kUpb_LabelFlags_IsAlternate) != 0;
}
UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsExtension)(
const struct upb_MiniTableField* f) {
return (f->mode & kUpb_LabelFlags_IsExtension) != 0;
return (f->UPB_ONLYBITS(mode) & kUpb_LabelFlags_IsExtension) != 0;
}
UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsPacked)(
const struct upb_MiniTableField* f) {
return (f->mode & kUpb_LabelFlags_IsPacked) != 0;
return (f->UPB_ONLYBITS(mode) & kUpb_LabelFlags_IsPacked) != 0;
}
UPB_INLINE upb_FieldType

9
upb/wire/decode.c
Unescape View File

@ -252,7 +252,7 @@ static upb_Message* _upb_Decoder_NewSubMessage(upb_Decoder* d,
// Extensions should not be unlinked. A message extension should not be
// registered until its sub-message type is available to be linked.
bool is_empty = UPB_PRIVATE(_upb_MiniTable_IsEmpty)(subl);
bool is_extension = field->mode & kUpb_LabelFlags_IsExtension;
bool is_extension = field->UPB_PRIVATE(mode) & kUpb_LabelFlags_IsExtension;
UPB_ASSERT(!(is_empty && is_extension));
if (is_empty && !(d->options & kUpb_DecodeOption_ExperimentalAllowUnlinked)) {
@ -392,7 +392,8 @@ static bool _upb_Decoder_CheckEnum(upb_Decoder* d, const char* ptr,
// so we just re-encode the tag and value here.
const uint32_t tag = ((uint32_t)field->number << 3) | kUpb_WireType_Varint;
upb_Message* unknown_msg =
field->mode & kUpb_LabelFlags_IsExtension ? d->unknown_msg : msg;
field->UPB_PRIVATE(mode) & kUpb_LabelFlags_IsExtension ? d->unknown_msg
: msg;
_upb_Decoder_AddUnknownVarints(d, unknown_msg, tag, v);
return false;
}
@ -995,7 +996,7 @@ static void _upb_Decoder_CheckUnlinked(upb_Decoder* d, const upb_MiniTable* mt,
const upb_MiniTableField* field,
int* op) {
// If sub-message is not linked, treat as unknown.
if (field->mode & kUpb_LabelFlags_IsExtension) return;
if (field->UPB_PRIVATE(mode) & kUpb_LabelFlags_IsExtension) return;
const upb_MiniTable* mt_sub =
_upb_MiniTableSubs_MessageByField(mt->UPB_PRIVATE(subs), field);
if ((d->options & kUpb_DecodeOption_ExperimentalAllowUnlinked) ||
@ -1139,7 +1140,7 @@ static const char* _upb_Decoder_DecodeKnownField(
const upb_MiniTable* layout, const upb_MiniTableField* field, int op,
wireval* val) {
const upb_MiniTableSub* subs = layout->UPB_PRIVATE(subs);
uint8_t mode = field->mode;
uint8_t mode = field->UPB_PRIVATE(mode);
if (UPB_UNLIKELY(mode & kUpb_LabelFlags_IsExtension)) {
const upb_MiniTableExtension* ext_layout =

2
upb_generator/common.cc
Unescape View File

@ -106,7 +106,7 @@ std::string ArchDependentSize(int64_t size32, int64_t size64) {
std::string GetModeInit(const upb_MiniTableField* field32,
const upb_MiniTableField* field64) {
std::string ret;
uint8_t mode32 = field32->mode;
uint8_t mode32 = field32->UPB_PRIVATE(mode);
switch (mode32 & kUpb_FieldMode_Mask) {
case kUpb_FieldMode_Map:
ret = "(int)kUpb_FieldMode_Map";

Write Preview
Loading…
Cancel
Save