Chiebot-Mirror
/
protobuf
mirror of https://github.com/protocolbuffers/protobuf.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Revert upb changes to minimize changes as we evaluate performance.

Browse Source
pull/7944/head
Joshua Haberman 4 years ago
parent ec4b194608
commit 05644f0313
2 changed files with 194 additions and 250 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. 348
      php/ext/google/protobuf/php-upb.c
  2. 96
      php/ext/google/protobuf/php-upb.h

348
php/ext/google/protobuf/php-upb.c
Unescape View File

@ -81,10 +81,6 @@
#define UPB_FORCEINLINE __inline__ __attribute__((always_inline))
#define UPB_NOINLINE __attribute__((noinline))
#define UPB_NORETURN __attribute__((__noreturn__))
#elif defined(_MSC_VER)
#define UPB_NOINLINE
#define UPB_FORCEINLINE
#define UPB_NORETURN __declspec(noreturn)
#else /* !defined(__GNUC__) */
#define UPB_FORCEINLINE
#define UPB_NOINLINE
@ -147,7 +143,7 @@ int msvc_vsnprintf(char* s, size_t n, const char* format, va_list arg);
#elif defined _MSC_VER
#define UPB_ASSUME(expr) if (!(expr)) __assume(0)
#else
#define UPB_ASSUME(expr) do {} while (false && (expr))
#define UPB_ASSUME(expr) do {} if (false && (expr))
#endif
#else
#define UPB_ASSUME(expr) assert(expr)
@ -327,6 +323,8 @@ typedef struct {
typedef union {
bool bool_val;
int32_t int32_val;
int64_t int64_val;
uint32_t uint32_val;
uint64_t uint64_val;
upb_strview str_val;
@ -426,21 +424,14 @@ static void decode_munge(int type, wireval *val) {
break;
case UPB_DESCRIPTOR_TYPE_SINT32: {
uint32_t n = val->uint32_val;
val->uint32_val = (n >> 1) ^ -(int32_t)(n & 1);
val->int32_val = (n >> 1) ^ -(int32_t)(n & 1);
break;
}
case UPB_DESCRIPTOR_TYPE_SINT64: {
uint64_t n = val->uint64_val;
val->uint64_val = (n >> 1) ^ -(int64_t)(n & 1);
val->int64_val = (n >> 1) ^ -(int64_t)(n & 1);
break;
}
case UPB_DESCRIPTOR_TYPE_INT32:
case UPB_DESCRIPTOR_TYPE_UINT32:
if (!_upb_isle()) {
/* The next stage will memcpy(dst, &val, 4) */
val->uint32_val = val->uint64_val;
}
break;
}
}
@ -616,7 +607,7 @@ static void decode_tomap(upb_decstate *d, upb_msg *msg,
if (entry->fields[1].descriptortype == UPB_DESCRIPTOR_TYPE_MESSAGE ||
entry->fields[1].descriptortype == UPB_DESCRIPTOR_TYPE_GROUP) {
/* Create proactively to handle the case where it doesn't appear. */
ent.v.val = upb_value_ptr(_upb_msg_new(entry->submsgs[0], d->arena));
ent.v.val.val = (uint64_t)_upb_msg_new(entry->submsgs[0], d->arena);
}
decode_tosubmsg(d, &ent.k, layout, field, val.str_val);
@ -707,16 +698,14 @@ static const char *decode_msg(upb_decstate *d, const char *ptr, upb_msg *msg,
break;
case UPB_WIRE_TYPE_32BIT:
if (d->limit - ptr < 4) decode_err(d);
memcpy(&val.uint32_val, ptr, 4);
val.uint32_val = _upb_be_swap32(val.uint32_val);
memcpy(&val, ptr, 4);
ptr += 4;
op = OP_SCALAR_LG2(2);
if (((1 << field->descriptortype) & fixed32_ok) == 0) goto unknown;
break;
case UPB_WIRE_TYPE_64BIT:
if (d->limit - ptr < 8) decode_err(d);
memcpy(&val.uint64_val, ptr, 8);
val.uint64_val = _upb_be_swap64(val.uint64_val);
memcpy(&val, ptr, 8);
ptr += 8;
op = OP_SCALAR_LG2(3);
if (((1 << field->descriptortype) & fixed64_ok) == 0) goto unknown;
@ -736,7 +725,7 @@ static const char *decode_msg(upb_decstate *d, const char *ptr, upb_msg *msg,
break;
}
case UPB_WIRE_TYPE_START_GROUP:
val.uint32_val = field_number;
val.int32_val = field_number;
op = OP_SUBMSG;
if (field->descriptortype != UPB_DTYPE_GROUP) goto unknown;
break;
@ -805,30 +794,30 @@ bool upb_decode(const char *buf, size_t size, void *msg, const upb_msglayout *l,
/* We encode backwards, to avoid pre-computing lengths (one-pass encode). */
#include <setjmp.h>
#include <string.h>
#define UPB_PB_VARINT_MAX_LEN 10
#define CHK(x) do { if (!(x)) { return false; } } while(0)
UPB_NOINLINE
static size_t encode_varint64(uint64_t val, char *buf) {
size_t i = 0;
do {
static size_t upb_encode_varint(uint64_t val, char *buf) {
size_t i;
if (val < 128) { buf[0] = val; return 1; }
i = 0;
while (val) {
uint8_t byte = val & 0x7fU;
val >>= 7;
if (val) byte |= 0x80U;
buf[i++] = byte;
} while (val);
}
return i;
}
static uint32_t encode_zz32(int32_t n) { return ((uint32_t)n << 1) ^ (n >> 31); }
static uint64_t encode_zz64(int64_t n) { return ((uint64_t)n << 1) ^ (n >> 63); }
static uint32_t upb_zzencode_32(int32_t n) { return ((uint32_t)n << 1) ^ (n >> 31); }
static uint64_t upb_zzencode_64(int64_t n) { return ((uint64_t)n << 1) ^ (n >> 63); }
typedef struct {
jmp_buf err;
upb_alloc *alloc;
char *buf, *ptr, *limit;
} upb_encstate;
@ -841,15 +830,11 @@ static size_t upb_roundup_pow2(size_t bytes) {
return ret;
}
UPB_NORETURN static void encode_err(upb_encstate *e) { longjmp(e->err, 1); }
UPB_NOINLINE
static void encode_growbuffer(upb_encstate *e, size_t bytes) {
static bool upb_encode_growbuffer(upb_encstate *e, size_t bytes) {
size_t old_size = e->limit - e->buf;
size_t new_size = upb_roundup_pow2(bytes + (e->limit - e->ptr));
char *new_buf = upb_realloc(e->alloc, e->buf, old_size, new_size);
if (!new_buf) encode_err(e);
CHK(new_buf);
/* We want previous data at the end, realloc() put it at the beginning. */
if (old_size > 0) {
@ -859,115 +844,99 @@ static void encode_growbuffer(upb_encstate *e, size_t bytes) {
e->ptr = new_buf + new_size - (e->limit - e->ptr);
e->limit = new_buf + new_size;
e->buf = new_buf;
e->ptr -= bytes;
return true;
}
/* Call to ensure that at least "bytes" bytes are available for writing at
* e->ptr. Returns false if the bytes could not be allocated. */
UPB_FORCEINLINE
static void encode_reserve(upb_encstate *e, size_t bytes) {
if ((size_t)(e->ptr - e->buf) < bytes) {
encode_growbuffer(e, bytes);
return;
}
static bool upb_encode_reserve(upb_encstate *e, size_t bytes) {
CHK(UPB_LIKELY((size_t)(e->ptr - e->buf) >= bytes) ||
upb_encode_growbuffer(e, bytes));
e->ptr -= bytes;
return true;
}
/* Writes the given bytes to the buffer, handling reserve/advance. */
static void encode_bytes(upb_encstate *e, const void *data, size_t len) {
if (len == 0) return; /* memcpy() with zero size is UB */
encode_reserve(e, len);
static bool upb_put_bytes(upb_encstate *e, const void *data, size_t len) {
if (len == 0) return true;
CHK(upb_encode_reserve(e, len));
memcpy(e->ptr, data, len);
return true;
}
static void encode_fixed64(upb_encstate *e, uint64_t val) {
val = _upb_be_swap64(val);
encode_bytes(e, &val, sizeof(uint64_t));
static bool upb_put_fixed64(upb_encstate *e, uint64_t val) {
/* TODO(haberman): byte-swap for big endian. */
return upb_put_bytes(e, &val, sizeof(uint64_t));
}
static void encode_fixed32(upb_encstate *e, uint32_t val) {
val = _upb_be_swap32(val);
encode_bytes(e, &val, sizeof(uint32_t));
static bool upb_put_fixed32(upb_encstate *e, uint32_t val) {
/* TODO(haberman): byte-swap for big endian. */
return upb_put_bytes(e, &val, sizeof(uint32_t));
}
UPB_NOINLINE
static void encode_longvarint(upb_encstate *e, uint64_t val) {
static bool upb_put_varint(upb_encstate *e, uint64_t val) {
size_t len;
char *start;
encode_reserve(e, UPB_PB_VARINT_MAX_LEN);
len = encode_varint64(val, e->ptr);
CHK(upb_encode_reserve(e, UPB_PB_VARINT_MAX_LEN));
len = upb_encode_varint(val, e->ptr);
start = e->ptr + UPB_PB_VARINT_MAX_LEN - len;
memmove(start, e->ptr, len);
e->ptr = start;
return true;
}
UPB_FORCEINLINE
static void encode_varint(upb_encstate *e, uint64_t val) {
if (val < 128 && e->ptr != e->buf) {
--e->ptr;
*e->ptr = val;
} else {
encode_longvarint(e, val);
}
}
static void encode_double(upb_encstate *e, double d) {
static bool upb_put_double(upb_encstate *e, double d) {
uint64_t u64;
UPB_ASSERT(sizeof(double) == sizeof(uint64_t));
memcpy(&u64, &d, sizeof(uint64_t));
encode_fixed64(e, u64);
return upb_put_fixed64(e, u64);
}
static void encode_float(upb_encstate *e, float d) {
static bool upb_put_float(upb_encstate *e, float d) {
uint32_t u32;
UPB_ASSERT(sizeof(float) == sizeof(uint32_t));
memcpy(&u32, &d, sizeof(uint32_t));
encode_fixed32(e, u32);
return upb_put_fixed32(e, u32);
}
static void encode_tag(upb_encstate *e, int field_number, int wire_type) {
encode_varint(e, (field_number << 3) | wire_type);
static bool upb_put_tag(upb_encstate *e, int field_number, int wire_type) {
return upb_put_varint(e, (field_number << 3) | wire_type);
}
static void encode_fixedarray(upb_encstate *e, const upb_array *arr,
static bool upb_put_fixedarray(upb_encstate *e, const upb_array *arr,
size_t elem_size, uint32_t tag) {
size_t bytes = arr->len * elem_size;
const char* data = _upb_array_constptr(arr);
const char* ptr = data + bytes - elem_size;
if (tag) {
while (true) {
encode_bytes(e, ptr, elem_size);
encode_varint(e, tag);
CHK(upb_put_bytes(e, ptr, elem_size) && upb_put_varint(e, tag));
if (ptr == data) break;
ptr -= elem_size;
}
return true;
} else {
encode_bytes(e, data, bytes);
return upb_put_bytes(e, data, bytes) && upb_put_varint(e, bytes);
}
}
static void encode_message(upb_encstate *e, const char *msg,
const upb_msglayout *m, size_t *size);
bool upb_encode_message(upb_encstate *e, const char *msg,
const upb_msglayout *m, size_t *size);
static void encode_scalar(upb_encstate *e, const void *_field_mem,
const upb_msglayout *m, const upb_msglayout_field *f,
bool skip_zero_value) {
static bool upb_encode_scalarfield(upb_encstate *e, const void *_field_mem,
const upb_msglayout *m,
const upb_msglayout_field *f,
bool skip_zero_value) {
const char *field_mem = _field_mem;
int wire_type;
#define CASE(ctype, type, wtype, encodeval) \
{ \
ctype val = *(ctype *)field_mem; \
if (skip_zero_value && val == 0) { \
return; \
} \
encode_##type(e, encodeval); \
wire_type = wtype; \
break; \
}
#define CASE(ctype, type, wire_type, encodeval) do { \
ctype val = *(ctype*)field_mem; \
if (skip_zero_value && val == 0) { \
return true; \
} \
return upb_put_ ## type(e, encodeval) && \
upb_put_tag(e, f->number, wire_type); \
} while(0)
switch (f->descriptortype) {
case UPB_DESCRIPTOR_TYPE_DOUBLE:
@ -991,91 +960,90 @@ static void encode_scalar(upb_encstate *e, const void *_field_mem,
case UPB_DESCRIPTOR_TYPE_BOOL:
CASE(bool, varint, UPB_WIRE_TYPE_VARINT, val);
case UPB_DESCRIPTOR_TYPE_SINT32:
CASE(int32_t, varint, UPB_WIRE_TYPE_VARINT, encode_zz32(val));
CASE(int32_t, varint, UPB_WIRE_TYPE_VARINT, upb_zzencode_32(val));
case UPB_DESCRIPTOR_TYPE_SINT64:
CASE(int64_t, varint, UPB_WIRE_TYPE_VARINT, encode_zz64(val));
CASE(int64_t, varint, UPB_WIRE_TYPE_VARINT, upb_zzencode_64(val));
case UPB_DESCRIPTOR_TYPE_STRING:
case UPB_DESCRIPTOR_TYPE_BYTES: {
upb_strview view = *(upb_strview*)field_mem;
if (skip_zero_value && view.size == 0) {
return;
return true;
}
encode_bytes(e, view.data, view.size);
encode_varint(e, view.size);
wire_type = UPB_WIRE_TYPE_DELIMITED;
break;
return upb_put_bytes(e, view.data, view.size) &&
upb_put_varint(e, view.size) &&
upb_put_tag(e, f->number, UPB_WIRE_TYPE_DELIMITED);
}
case UPB_DESCRIPTOR_TYPE_GROUP: {
size_t size;
void *submsg = *(void **)field_mem;
const upb_msglayout *subm = m->submsgs[f->submsg_index];
if (submsg == NULL) {
return;
return true;
}
encode_tag(e, f->number, UPB_WIRE_TYPE_END_GROUP);
encode_message(e, submsg, subm, &size);
wire_type = UPB_WIRE_TYPE_START_GROUP;
break;
return upb_put_tag(e, f->number, UPB_WIRE_TYPE_END_GROUP) &&
upb_encode_message(e, submsg, subm, &size) &&
upb_put_tag(e, f->number, UPB_WIRE_TYPE_START_GROUP);
}
case UPB_DESCRIPTOR_TYPE_MESSAGE: {
size_t size;
void *submsg = *(void **)field_mem;
const upb_msglayout *subm = m->submsgs[f->submsg_index];
if (submsg == NULL) {
return;
return true;
}
encode_message(e, submsg, subm, &size);
encode_varint(e, size);
wire_type = UPB_WIRE_TYPE_DELIMITED;
break;
return upb_encode_message(e, submsg, subm, &size) &&
upb_put_varint(e, size) &&
upb_put_tag(e, f->number, UPB_WIRE_TYPE_DELIMITED);
}
default:
UPB_UNREACHABLE();
}
#undef CASE
encode_tag(e, f->number, wire_type);
UPB_UNREACHABLE();
}
static void encode_array(upb_encstate *e, const char *field_mem,
const upb_msglayout *m, const upb_msglayout_field *f) {
static bool upb_encode_array(upb_encstate *e, const char *field_mem,
const upb_msglayout *m,
const upb_msglayout_field *f) {
const upb_array *arr = *(const upb_array**)field_mem;
bool packed = f->label == _UPB_LABEL_PACKED;
size_t pre_len = e->limit - e->ptr;
if (arr == NULL || arr->len == 0) {
return;
return true;
}
#define VARINT_CASE(ctype, encode) \
{ \
const ctype *start = _upb_array_constptr(arr); \
const ctype *ptr = start + arr->len; \
size_t pre_len = e->limit - e->ptr; \
uint32_t tag = packed ? 0 : (f->number << 3) | UPB_WIRE_TYPE_VARINT; \
do { \
ptr--; \
encode_varint(e, encode); \
if (tag) encode_varint(e, tag); \
CHK(upb_put_varint(e, encode)); \
if (tag) CHK(upb_put_varint(e, tag)); \
} while (ptr != start); \
if (!tag) CHK(upb_put_varint(e, e->limit - e->ptr - pre_len)); \
} \
break;
break; \
do { \
; \
} while (0)
#define TAG(wire_type) (packed ? 0 : (f->number << 3 | wire_type))
switch (f->descriptortype) {
case UPB_DESCRIPTOR_TYPE_DOUBLE:
encode_fixedarray(e, arr, sizeof(double), TAG(UPB_WIRE_TYPE_64BIT));
CHK(upb_put_fixedarray(e, arr, sizeof(double), TAG(UPB_WIRE_TYPE_64BIT)));
break;
case UPB_DESCRIPTOR_TYPE_FLOAT:
encode_fixedarray(e, arr, sizeof(float), TAG(UPB_WIRE_TYPE_32BIT));
CHK(upb_put_fixedarray(e, arr, sizeof(float), TAG(UPB_WIRE_TYPE_32BIT)));
break;
case UPB_DESCRIPTOR_TYPE_SFIXED64:
case UPB_DESCRIPTOR_TYPE_FIXED64:
encode_fixedarray(e, arr, sizeof(uint64_t), TAG(UPB_WIRE_TYPE_64BIT));
CHK(upb_put_fixedarray(e, arr, sizeof(uint64_t), TAG(UPB_WIRE_TYPE_64BIT)));
break;
case UPB_DESCRIPTOR_TYPE_FIXED32:
case UPB_DESCRIPTOR_TYPE_SFIXED32:
encode_fixedarray(e, arr, sizeof(uint32_t), TAG(UPB_WIRE_TYPE_32BIT));
CHK(upb_put_fixedarray(e, arr, sizeof(uint32_t), TAG(UPB_WIRE_TYPE_32BIT)));
break;
case UPB_DESCRIPTOR_TYPE_INT64:
case UPB_DESCRIPTOR_TYPE_UINT64:
@ -1088,20 +1056,20 @@ static void encode_array(upb_encstate *e, const char *field_mem,
case UPB_DESCRIPTOR_TYPE_BOOL:
VARINT_CASE(bool, *ptr);
case UPB_DESCRIPTOR_TYPE_SINT32:
VARINT_CASE(int32_t, encode_zz32(*ptr));
VARINT_CASE(int32_t, upb_zzencode_32(*ptr));
case UPB_DESCRIPTOR_TYPE_SINT64:
VARINT_CASE(int64_t, encode_zz64(*ptr));
VARINT_CASE(int64_t, upb_zzencode_64(*ptr));
case UPB_DESCRIPTOR_TYPE_STRING:
case UPB_DESCRIPTOR_TYPE_BYTES: {
const upb_strview *start = _upb_array_constptr(arr);
const upb_strview *ptr = start + arr->len;
do {
ptr--;
encode_bytes(e, ptr->data, ptr->size);
encode_varint(e, ptr->size);
encode_tag(e, f->number, UPB_WIRE_TYPE_DELIMITED);
CHK(upb_put_bytes(e, ptr->data, ptr->size) &&
upb_put_varint(e, ptr->size) &&
upb_put_tag(e, f->number, UPB_WIRE_TYPE_DELIMITED));
} while (ptr != start);
return;
return true;
}
case UPB_DESCRIPTOR_TYPE_GROUP: {
const void *const*start = _upb_array_constptr(arr);
@ -1110,11 +1078,11 @@ static void encode_array(upb_encstate *e, const char *field_mem,
do {
size_t size;
ptr--;
encode_tag(e, f->number, UPB_WIRE_TYPE_END_GROUP);
encode_message(e, *ptr, subm, &size);
encode_tag(e, f->number, UPB_WIRE_TYPE_START_GROUP);
CHK(upb_put_tag(e, f->number, UPB_WIRE_TYPE_END_GROUP) &&
upb_encode_message(e, *ptr, subm, &size) &&
upb_put_tag(e, f->number, UPB_WIRE_TYPE_START_GROUP));
} while (ptr != start);
return;
return true;
}
case UPB_DESCRIPTOR_TYPE_MESSAGE: {
const void *const*start = _upb_array_constptr(arr);
@ -1123,30 +1091,31 @@ static void encode_array(upb_encstate *e, const char *field_mem,
do {
size_t size;
ptr--;
encode_message(e, *ptr, subm, &size);
encode_varint(e, size);
encode_tag(e, f->number, UPB_WIRE_TYPE_DELIMITED);
CHK(upb_encode_message(e, *ptr, subm, &size) &&
upb_put_varint(e, size) &&
upb_put_tag(e, f->number, UPB_WIRE_TYPE_DELIMITED));
} while (ptr != start);
return;
return true;
}
}
#undef VARINT_CASE
if (packed) {
encode_varint(e, e->limit - e->ptr - pre_len);
encode_tag(e, f->number, UPB_WIRE_TYPE_DELIMITED);
CHK(upb_put_tag(e, f->number, UPB_WIRE_TYPE_DELIMITED));
}
return true;
}
static void encode_map(upb_encstate *e, const char *field_mem,
const upb_msglayout *m, const upb_msglayout_field *f) {
static bool upb_encode_map(upb_encstate *e, const char *field_mem,
const upb_msglayout *m,
const upb_msglayout_field *f) {
const upb_map *map = *(const upb_map**)field_mem;
const upb_msglayout *entry = m->submsgs[f->submsg_index];
const upb_msglayout_field *key_field = &entry->fields[0];
const upb_msglayout_field *val_field = &entry->fields[1];
upb_strtable_iter i;
if (map == NULL) {
return;
return true;
}
upb_strtable_begin(&i, &map->table);
@ -1158,57 +1127,59 @@ static void encode_map(upb_encstate *e, const char *field_mem,
upb_map_entry ent;
_upb_map_fromkey(key, &ent.k, map->key_size);
_upb_map_fromvalue(val, &ent.v, map->val_size);
encode_scalar(e, &ent.v, entry, val_field, false);
encode_scalar(e, &ent.k, entry, key_field, false);
CHK(upb_encode_scalarfield(e, &ent.v, entry, val_field, false));
CHK(upb_encode_scalarfield(e, &ent.k, entry, key_field, false));
size = (e->limit - e->ptr) - pre_len;
encode_varint(e, size);
encode_tag(e, f->number, UPB_WIRE_TYPE_DELIMITED);
CHK(upb_put_varint(e, size));
CHK(upb_put_tag(e, f->number, UPB_WIRE_TYPE_DELIMITED));
}
}
static void encode_scalarfield(upb_encstate *e, const char *msg,
const upb_msglayout *m,
const upb_msglayout_field *f) {
bool skip_empty = false;
if (f->presence == 0) {
/* Proto3 presence. */
skip_empty = true;
} else if (f->presence > 0) {
/* Proto2 presence: hasbit. */
if (!_upb_hasbit_field(msg, f)) return;
} else {
/* Field is in a oneof. */
if (_upb_getoneofcase_field(msg, f) != f->number) return;
}
encode_scalar(e, msg + f->offset, m, f, skip_empty);
return true;
}
static void encode_message(upb_encstate *e, const char *msg,
const upb_msglayout *m, size_t *size) {
bool upb_encode_message(upb_encstate *e, const char *msg,
const upb_msglayout *m, size_t *size) {
int i;
size_t pre_len = e->limit - e->ptr;
const char *unknown;
size_t unknown_size;
const upb_msglayout_field *f = &m->fields[m->field_count];
const upb_msglayout_field *first = &m->fields[0];
unknown = upb_msg_getunknown(msg, &unknown_size);
if (unknown) {
encode_bytes(e, unknown, unknown_size);
upb_put_bytes(e, unknown, unknown_size);
}
while (f != first) {
f--;
for (i = m->field_count - 1; i >= 0; i--) {
const upb_msglayout_field *f = &m->fields[i];
if (_upb_isrepeated(f)) {
encode_array(e, msg + f->offset, m, f);
CHK(upb_encode_array(e, msg + f->offset, m, f));
} else if (f->label == _UPB_LABEL_MAP) {
encode_map(e, msg + f->offset, m, f);
CHK(upb_encode_map(e, msg + f->offset, m, f));
} else {
encode_scalarfield(e, msg, m, f);
bool skip_empty = false;
if (f->presence == 0) {
/* Proto3 presence. */
skip_empty = true;
} else if (f->presence > 0) {
/* Proto2 presence: hasbit. */
if (!_upb_hasbit_field(msg, f)) {
continue;
}
} else {
/* Field is in a oneof. */
if (_upb_getoneofcase_field(msg, f) != f->number) {
continue;
}
}
CHK(upb_encode_scalarfield(e, msg + f->offset, m, f, skip_empty));
}
}
*size = (e->limit - e->ptr) - pre_len;
return true;
}
char *upb_encode(const void *msg, const upb_msglayout *m, upb_arena *arena,
@ -1219,13 +1190,11 @@ char *upb_encode(const void *msg, const upb_msglayout *m, upb_arena *arena,
e.limit = NULL;
e.ptr = NULL;
if (setjmp(e.err)) {
if (!upb_encode_message(&e, msg, m, size)) {
*size = 0;
return NULL;
}
encode_message(&e, msg, m, size);
*size = e.limit - e.ptr;
if (*size == 0) {
@ -1237,6 +1206,8 @@ char *upb_encode(const void *msg, const upb_msglayout *m, upb_arena *arena,
}
}
#undef CHK
@ -3092,7 +3063,7 @@ extern const upb_msglayout google_protobuf_SourceCodeInfo_Location_msginit;
extern const upb_msglayout google_protobuf_GeneratedCodeInfo_msginit;
extern const upb_msglayout google_protobuf_GeneratedCodeInfo_Annotation_msginit;
static const upb_msglayout *google_protobuf_descriptor_proto_layouts[27] = {
static const upb_msglayout *layouts[27] = {
&google_protobuf_FileDescriptorSet_msginit,
&google_protobuf_FileDescriptorProto_msginit,
&google_protobuf_DescriptorProto_msginit,
@ -3122,8 +3093,7 @@ static const upb_msglayout *google_protobuf_descriptor_proto_layouts[27] = {
&google_protobuf_GeneratedCodeInfo_Annotation_msginit,
};
static const char google_protobuf_descriptor_proto_descriptor[7619] = {
'\n', ' ', 'g', 'o', 'o', 'g', 'l', 'e', '/', 'p', 'r', 'o', 't', 'o', 'b', 'u', 'f', '/', 'd', 'e', 's', 'c', 'r', 'i', 'p',
static const char descriptor[7619] = {'\n', ' ', 'g', 'o', 'o', 'g', 'l', 'e', '/', 'p', 'r', 'o', 't', 'o', 'b', 'u', 'f', '/', 'd', 'e', 's', 'c', 'r', 'i', 'p',
't', 'o', 'r', '.', 'p', 'r', 'o', 't', 'o', '\022', '\017', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'p', 'r', 'o', 't', 'o', 'b', 'u',
'f', '\"', 'M', '\n', '\021', 'F', 'i', 'l', 'e', 'D', 'e', 's', 'c', 'r', 'i', 'p', 't', 'o', 'r', 'S', 'e', 't', '\022', '8', '\n',
'\004', 'f', 'i', 'l', 'e', '\030', '\001', ' ', '\003', '(', '\013', '2', '$', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'p', 'r', 'o', 't',
@ -3430,15 +3400,15 @@ static const char google_protobuf_descriptor_proto_descriptor[7619] = {
'P', 'r', 'o', 't', 'o', 'b', 'u', 'f', '.', 'R', 'e', 'f', 'l', 'e', 'c', 't', 'i', 'o', 'n',
};
static upb_def_init *google_protobuf_descriptor_proto_deps[1] = {
static upb_def_init *deps[1] = {
NULL
};
upb_def_init google_protobuf_descriptor_proto_definit = {
google_protobuf_descriptor_proto_deps,
google_protobuf_descriptor_proto_layouts,
upb_def_init google_protobuf_descriptor_proto_upbdefinit = {
deps,
layouts,
"google/protobuf/descriptor.proto",
UPB_STRVIEW_INIT(google_protobuf_descriptor_proto_descriptor, 7619)
UPB_STRVIEW_INIT(descriptor, 7619)
};
@ -5696,7 +5666,11 @@ const upb_fielddef *upb_msg_whichoneof(const upb_msg *msg,
if (upb_oneof_done(&i)) return false;
f = upb_oneof_iter_field(&i);
field = upb_fielddef_layout(f);
oneof_case = _upb_getoneofcase_field(msg, field);
if (in_oneof(field)) {
oneof_case = _upb_getoneofcase_field(msg, field);
} else {
return _upb_hasbit_field(msg, field) ? f : NULL;
}
return oneof_case ? upb_msgdef_itof(m, oneof_case) : NULL;
}

96
php/ext/google/protobuf/php-upb.h
Unescape View File

@ -80,10 +80,6 @@
#define UPB_FORCEINLINE __inline__ __attribute__((always_inline))
#define UPB_NOINLINE __attribute__((noinline))
#define UPB_NORETURN __attribute__((__noreturn__))
#elif defined(_MSC_VER)
#define UPB_NOINLINE
#define UPB_FORCEINLINE
#define UPB_NORETURN __declspec(noreturn)
#else /* !defined(__GNUC__) */
#define UPB_FORCEINLINE
#define UPB_NOINLINE
@ -146,7 +142,7 @@ int msvc_vsnprintf(char* s, size_t n, const char* format, va_list arg);
#elif defined _MSC_VER
#define UPB_ASSUME(expr) if (!(expr)) __assume(0)
#else
#define UPB_ASSUME(expr) do {} while (false && (expr))
#define UPB_ASSUME(expr) do {} if (false && (expr))
#endif
#else
#define UPB_ASSUME(expr) assert(expr)
@ -217,7 +213,7 @@ int msvc_vsnprintf(char* s, size_t n, const char* format, va_list arg);
** store pointers or integers of at least 32 bits (upb isn't really useful on
** systems where sizeof(void*) < 4).
**
** The table must be homogenous (all values of the same type). In debug
** The table must be homogeneous (all values of the same type). In debug
** mode, we check this on insert and lookup.
*/
@ -500,32 +496,6 @@ typedef enum {
#define UPB_MAP_BEGIN ((size_t)-1)
UPB_INLINE bool _upb_isle(void) {
int x = 1;
return *(char*)&x == 1;
}
UPB_INLINE uint32_t _upb_be_swap32(uint32_t val) {
if (_upb_isle()) {
return val;
} else {
return ((val & 0xff) << 24) | ((val & 0xff00) << 8) |
((val & 0xff0000ULL) >> 8) | ((val & 0xff000000ULL) >> 24);
}
}
UPB_INLINE uint64_t _upb_be_swap64(uint64_t val) {
if (_upb_isle()) {
return val;
} else {
return ((val & 0xff) << 56) | ((val & 0xff00) << 40) |
((val & 0xff0000) << 24) | ((val & 0xff000000) << 8) |
((val & 0xff00000000ULL) >> 8) | ((val & 0xff0000000000ULL) >> 24) |
((val & 0xff000000000000ULL) >> 40) |
((val & 0xff00000000000000ULL) >> 56);
}
}
#ifdef __cplusplus
} /* extern "C" */
@ -1281,7 +1251,7 @@ UPB_INLINE upb_value _upb_map_tovalue(const void *val, size_t size,
if (size == UPB_MAPTYPE_STRING) {
upb_strview *strp = (upb_strview*)upb_arena_malloc(a, sizeof(*strp));
*strp = *(upb_strview*)val;
ret = upb_value_ptr(strp);
memcpy(&ret, &strp, sizeof(strp));
} else {
memcpy(&ret, val, size);
}
@ -1412,7 +1382,7 @@ UPB_INLINE void _upb_msg_map_set_value(void* msg, const void* val, size_t size)
/* This is like _upb_map_tovalue() except the entry already exists so we can
* reuse the allocated upb_strview for string fields. */
if (size == UPB_MAPTYPE_STRING) {
upb_strview *strp = (upb_strview*)(uintptr_t)ent->val.val;
upb_strview *strp = (upb_strview*)ent->val.val;
memcpy(strp, val, sizeof(*strp));
} else {
memcpy(&ent->val.val, val, size);
@ -3519,140 +3489,140 @@ extern "C" {
extern upb_def_init google_protobuf_descriptor_proto_definit;
extern upb_def_init google_protobuf_descriptor_proto_upbdefinit;
UPB_INLINE const upb_msgdef *google_protobuf_FileDescriptorSet_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.FileDescriptorSet");
}
UPB_INLINE const upb_msgdef *google_protobuf_FileDescriptorProto_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.FileDescriptorProto");
}
UPB_INLINE const upb_msgdef *google_protobuf_DescriptorProto_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.DescriptorProto");
}
UPB_INLINE const upb_msgdef *google_protobuf_DescriptorProto_ExtensionRange_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.DescriptorProto.ExtensionRange");
}
UPB_INLINE const upb_msgdef *google_protobuf_DescriptorProto_ReservedRange_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.DescriptorProto.ReservedRange");
}
UPB_INLINE const upb_msgdef *google_protobuf_ExtensionRangeOptions_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.ExtensionRangeOptions");
}
UPB_INLINE const upb_msgdef *google_protobuf_FieldDescriptorProto_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.FieldDescriptorProto");
}
UPB_INLINE const upb_msgdef *google_protobuf_OneofDescriptorProto_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.OneofDescriptorProto");
}
UPB_INLINE const upb_msgdef *google_protobuf_EnumDescriptorProto_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.EnumDescriptorProto");
}
UPB_INLINE const upb_msgdef *google_protobuf_EnumDescriptorProto_EnumReservedRange_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.EnumDescriptorProto.EnumReservedRange");
}
UPB_INLINE const upb_msgdef *google_protobuf_EnumValueDescriptorProto_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.EnumValueDescriptorProto");
}
UPB_INLINE const upb_msgdef *google_protobuf_ServiceDescriptorProto_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.ServiceDescriptorProto");
}
UPB_INLINE const upb_msgdef *google_protobuf_MethodDescriptorProto_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.MethodDescriptorProto");
}
UPB_INLINE const upb_msgdef *google_protobuf_FileOptions_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.FileOptions");
}
UPB_INLINE const upb_msgdef *google_protobuf_MessageOptions_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.MessageOptions");
}
UPB_INLINE const upb_msgdef *google_protobuf_FieldOptions_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.FieldOptions");
}
UPB_INLINE const upb_msgdef *google_protobuf_OneofOptions_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.OneofOptions");
}
UPB_INLINE const upb_msgdef *google_protobuf_EnumOptions_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.EnumOptions");
}
UPB_INLINE const upb_msgdef *google_protobuf_EnumValueOptions_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.EnumValueOptions");
}
UPB_INLINE const upb_msgdef *google_protobuf_ServiceOptions_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.ServiceOptions");
}
UPB_INLINE const upb_msgdef *google_protobuf_MethodOptions_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.MethodOptions");
}
UPB_INLINE const upb_msgdef *google_protobuf_UninterpretedOption_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.UninterpretedOption");
}
UPB_INLINE const upb_msgdef *google_protobuf_UninterpretedOption_NamePart_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.UninterpretedOption.NamePart");
}
UPB_INLINE const upb_msgdef *google_protobuf_SourceCodeInfo_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.SourceCodeInfo");
}
UPB_INLINE const upb_msgdef *google_protobuf_SourceCodeInfo_Location_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.SourceCodeInfo.Location");
}
UPB_INLINE const upb_msgdef *google_protobuf_GeneratedCodeInfo_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.GeneratedCodeInfo");
}
UPB_INLINE const upb_msgdef *google_protobuf_GeneratedCodeInfo_Annotation_getmsgdef(upb_symtab *s) {
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_definit);
_upb_symtab_loaddefinit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_symtab_lookupmsg(s, "google.protobuf.GeneratedCodeInfo.Annotation");
}
@ -3857,7 +3827,7 @@ extern "C" {
#endif
enum {
/* When set, emits 0/default values. TOOD(haberman): proto3 only? */
/* When set, emits 0/default values. TODO(haberman): proto3 only? */
UPB_JSONENC_EMITDEFAULTS = 1,
/* When set, use normal (snake_caes) field names instead of JSON (camelCase)

Write Preview
Loading…
Cancel
Save