diff --git a/php/ext/google/protobuf/php-upb.c b/php/ext/google/protobuf/php-upb.c index 2ed7114e7f..d1fc36663d 100644 --- a/php/ext/google/protobuf/php-upb.c +++ b/php/ext/google/protobuf/php-upb.c @@ -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 #include #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; } diff --git a/php/ext/google/protobuf/php-upb.h b/php/ext/google/protobuf/php-upb.h index 973635214e..666ec76d05 100644 --- a/php/ext/google/protobuf/php-upb.h +++ b/php/ext/google/protobuf/php-upb.h @@ -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)