third_party/upb/upb/upb.h

   1 /*
   2 ** This file contains shared definitions that are widely used across upb.
   3 */
   4
   5 #ifndef UPB_H_
   6 #define UPB_H_
   7
   8 #include <assert.h>
   9 #include <stdarg.h>
  10 #include <stdbool.h>
  11 #include <stddef.h>
  12 #include <stdint.h>
  13 #include <string.h>
  14
  15 #include "upb/port_def.inc"
  16
  17 #ifdef __cplusplus
  18 extern "C" {
  19 #endif
  20
  21 /* upb_status *****************************************************************/
  22
  23 #define UPB_STATUS_MAX_MESSAGE 127
  24
  25 typedef struct {
  26   bool ok;
  27   char msg[UPB_STATUS_MAX_MESSAGE];  /* Error message; NULL-terminated. */
  28 } upb_status;
  29
  30 const char *upb_status_errmsg(const upb_status *status);
  31 bool upb_ok(const upb_status *status);
  32
  33 /* These are no-op if |status| is NULL. */
  34 void upb_status_clear(upb_status *status);
  35 void upb_status_seterrmsg(upb_status *status, const char *msg);
  36 void upb_status_seterrf(upb_status *status, const char *fmt, ...);
  37 void upb_status_vseterrf(upb_status *status, const char *fmt, va_list args);
  38 void upb_status_vappenderrf(upb_status *status, const char *fmt, va_list args);
  39
  40 /** upb_strview ************************************************************/
  41
  42 typedef struct {
  43   const char *data;
  44   size_t size;
  45 } upb_strview;
  46
  47 UPB_INLINE upb_strview upb_strview_make(const char *data, size_t size) {
  48   upb_strview ret;
  49   ret.data = data;
  50   ret.size = size;
  51   return ret;
  52 }
  53
  54 UPB_INLINE upb_strview upb_strview_makez(const char *data) {
  55   return upb_strview_make(data, strlen(data));
  56 }
  57
  58 UPB_INLINE bool upb_strview_eql(upb_strview a, upb_strview b) {
  59   return a.size == b.size && memcmp(a.data, b.data, a.size) == 0;
  60 }
  61
  62 #define UPB_STRVIEW_INIT(ptr, len) {ptr, len}
  63
  64 #define UPB_STRVIEW_FORMAT "%.*s"
  65 #define UPB_STRVIEW_ARGS(view) (int)(view).size, (view).data
  66
  67 /** upb_alloc *****************************************************************/
  68
  69 /* A upb_alloc is a possibly-stateful allocator object.
  70  *
  71  * It could either be an arena allocator (which doesn't require individual
  72  * free() calls) or a regular malloc() (which does).  The client must therefore
  73  * free memory unless it knows that the allocator is an arena allocator. */
  74
  75 struct upb_alloc;
  76 typedef struct upb_alloc upb_alloc;
  77
  78 /* A malloc()/free() function.
  79  * If "size" is 0 then the function acts like free(), otherwise it acts like
  80  * realloc().  Only "oldsize" bytes from a previous allocation are preserved. */
  81 typedef void *upb_alloc_func(upb_alloc *alloc, void *ptr, size_t oldsize,
  82                              size_t size);
  83
  84 struct upb_alloc {
  85   upb_alloc_func *func;
  86 };
  87
  88 UPB_INLINE void *upb_malloc(upb_alloc *alloc, size_t size) {
  89   UPB_ASSERT(alloc);
  90   return alloc->func(alloc, NULL, 0, size);
  91 }
  92
  93 UPB_INLINE void *upb_realloc(upb_alloc *alloc, void *ptr, size_t oldsize,
  94                              size_t size) {
  95   UPB_ASSERT(alloc);
  96   return alloc->func(alloc, ptr, oldsize, size);
  97 }
  98
  99 UPB_INLINE void upb_free(upb_alloc *alloc, void *ptr) {
 100   assert(alloc);
 101   alloc->func(alloc, ptr, 0, 0);
 102 }
 103
 104 /* The global allocator used by upb.  Uses the standard malloc()/free(). */
 105
 106 extern upb_alloc upb_alloc_global;
 107
 108 /* Functions that hard-code the global malloc.
 109  *
 110  * We still get benefit because we can put custom logic into our global
 111  * allocator, like injecting out-of-memory faults in debug/testing builds. */
 112
 113 UPB_INLINE void *upb_gmalloc(size_t size) {
 114   return upb_malloc(&upb_alloc_global, size);
 115 }
 116
 117 UPB_INLINE void *upb_grealloc(void *ptr, size_t oldsize, size_t size) {
 118   return upb_realloc(&upb_alloc_global, ptr, oldsize, size);
 119 }
 120
 121 UPB_INLINE void upb_gfree(void *ptr) {
 122   upb_free(&upb_alloc_global, ptr);
 123 }
 124
 125 /* upb_arena ******************************************************************/
 126
 127 /* upb_arena is a specific allocator implementation that uses arena allocation.
 128  * The user provides an allocator that will be used to allocate the underlying
 129  * arena blocks.  Arenas by nature do not require the individual allocations
 130  * to be freed.  However the Arena does allow users to register cleanup
 131  * functions that will run when the arena is destroyed.
 132  *
 133  * A upb_arena is *not* thread-safe.
 134  *
 135  * You could write a thread-safe arena allocator that satisfies the
 136  * upb_alloc interface, but it would not be as efficient for the
 137  * single-threaded case. */
 138
 139 typedef void upb_cleanup_func(void *ud);
 140
 141 struct upb_arena;
 142 typedef struct upb_arena upb_arena;
 143
 144 typedef struct {
 145   /* We implement the allocator interface.
 146    * This must be the first member of upb_arena!
 147    * TODO(haberman): remove once handlers are gone. */
 148   upb_alloc alloc;
 149
 150   char *ptr, *end;
 151 } _upb_arena_head;
 152
 153 /* Creates an arena from the given initial block (if any -- n may be 0).
 154  * Additional blocks will be allocated from |alloc|.  If |alloc| is NULL, this
 155  * is a fixed-size arena and cannot grow. */
 156 upb_arena *upb_arena_init(void *mem, size_t n, upb_alloc *alloc);
 157 void upb_arena_free(upb_arena *a);
 158 bool upb_arena_addcleanup(upb_arena *a, void *ud, upb_cleanup_func *func);
 159 void upb_arena_fuse(upb_arena *a, upb_arena *b);
 160 void *_upb_arena_slowmalloc(upb_arena *a, size_t size);
 161
 162 UPB_INLINE upb_alloc *upb_arena_alloc(upb_arena *a) { return (upb_alloc*)a; }
 163
 164 UPB_INLINE size_t _upb_arenahas(upb_arena *a) {
 165   _upb_arena_head *h = (_upb_arena_head*)a;
 166   return (size_t)(h->end - h->ptr);
 167 }
 168
 169 UPB_INLINE void *upb_arena_malloc(upb_arena *a, size_t size) {
 170   _upb_arena_head *h = (_upb_arena_head*)a;
 171   void* ret;
 172   size = UPB_ALIGN_MALLOC(size);
 173
 174   if (UPB_UNLIKELY(_upb_arenahas(a) < size)) {
 175     return _upb_arena_slowmalloc(a, size);
 176   }
 177
 178   ret = h->ptr;
 179   h->ptr += size;
 180   UPB_UNPOISON_MEMORY_REGION(ret, size);
 181
 182 #if UPB_ASAN
 183   {
 184     size_t guard_size = 32;
 185     if (_upb_arenahas(a) >= guard_size) {
 186       h->ptr += guard_size;
 187     } else {
 188       h->ptr = h->end;
 189     }
 190   }
 191 #endif
 192
 193   return ret;
 194 }
 195
 196 UPB_INLINE void *upb_arena_realloc(upb_arena *a, void *ptr, size_t oldsize,
 197                                    size_t size) {
 198   void *ret = upb_arena_malloc(a, size);
 199
 200   if (ret && oldsize > 0) {
 201     memcpy(ret, ptr, oldsize);
 202   }
 203
 204   return ret;
 205 }
 206
 207 UPB_INLINE upb_arena *upb_arena_new(void) {
 208   return upb_arena_init(NULL, 0, &upb_alloc_global);
 209 }
 210
 211 /* Constants ******************************************************************/
 212
 213 /* Generic function type. */
 214 typedef void upb_func(void);
 215
 216 /* A list of types as they are encoded on-the-wire. */
 217 typedef enum {
 218   UPB_WIRE_TYPE_VARINT      = 0,
 219   UPB_WIRE_TYPE_64BIT       = 1,
 220   UPB_WIRE_TYPE_DELIMITED   = 2,
 221   UPB_WIRE_TYPE_START_GROUP = 3,
 222   UPB_WIRE_TYPE_END_GROUP   = 4,
 223   UPB_WIRE_TYPE_32BIT       = 5
 224 } upb_wiretype_t;
 225
 226 /* The types a field can have.  Note that this list is not identical to the
 227  * types defined in descriptor.proto, which gives INT32 and SINT32 separate
 228  * types (we distinguish the two with the "integer encoding" enum below). */
 229 typedef enum {
 230   UPB_TYPE_BOOL     = 1,
 231   UPB_TYPE_FLOAT    = 2,
 232   UPB_TYPE_INT32    = 3,
 233   UPB_TYPE_UINT32   = 4,
 234   UPB_TYPE_ENUM     = 5,  /* Enum values are int32. */
 235   UPB_TYPE_MESSAGE  = 6,
 236   UPB_TYPE_DOUBLE   = 7,
 237   UPB_TYPE_INT64    = 8,
 238   UPB_TYPE_UINT64   = 9,
 239   UPB_TYPE_STRING   = 10,
 240   UPB_TYPE_BYTES    = 11
 241 } upb_fieldtype_t;
 242
 243 /* The repeated-ness of each field; this matches descriptor.proto. */
 244 typedef enum {
 245   UPB_LABEL_OPTIONAL = 1,
 246   UPB_LABEL_REQUIRED = 2,
 247   UPB_LABEL_REPEATED = 3
 248 } upb_label_t;
 249
 250 /* Descriptor types, as defined in descriptor.proto. */
 251 typedef enum {
 252   /* Old (long) names.  TODO(haberman): remove */
 253   UPB_DESCRIPTOR_TYPE_DOUBLE   = 1,
 254   UPB_DESCRIPTOR_TYPE_FLOAT    = 2,
 255   UPB_DESCRIPTOR_TYPE_INT64    = 3,
 256   UPB_DESCRIPTOR_TYPE_UINT64   = 4,
 257   UPB_DESCRIPTOR_TYPE_INT32    = 5,
 258   UPB_DESCRIPTOR_TYPE_FIXED64  = 6,
 259   UPB_DESCRIPTOR_TYPE_FIXED32  = 7,
 260   UPB_DESCRIPTOR_TYPE_BOOL     = 8,
 261   UPB_DESCRIPTOR_TYPE_STRING   = 9,
 262   UPB_DESCRIPTOR_TYPE_GROUP    = 10,
 263   UPB_DESCRIPTOR_TYPE_MESSAGE  = 11,
 264   UPB_DESCRIPTOR_TYPE_BYTES    = 12,
 265   UPB_DESCRIPTOR_TYPE_UINT32   = 13,
 266   UPB_DESCRIPTOR_TYPE_ENUM     = 14,
 267   UPB_DESCRIPTOR_TYPE_SFIXED32 = 15,
 268   UPB_DESCRIPTOR_TYPE_SFIXED64 = 16,
 269   UPB_DESCRIPTOR_TYPE_SINT32   = 17,
 270   UPB_DESCRIPTOR_TYPE_SINT64   = 18,
 271
 272   UPB_DTYPE_DOUBLE   = 1,
 273   UPB_DTYPE_FLOAT    = 2,
 274   UPB_DTYPE_INT64    = 3,
 275   UPB_DTYPE_UINT64   = 4,
 276   UPB_DTYPE_INT32    = 5,
 277   UPB_DTYPE_FIXED64  = 6,
 278   UPB_DTYPE_FIXED32  = 7,
 279   UPB_DTYPE_BOOL     = 8,
 280   UPB_DTYPE_STRING   = 9,
 281   UPB_DTYPE_GROUP    = 10,
 282   UPB_DTYPE_MESSAGE  = 11,
 283   UPB_DTYPE_BYTES    = 12,
 284   UPB_DTYPE_UINT32   = 13,
 285   UPB_DTYPE_ENUM     = 14,
 286   UPB_DTYPE_SFIXED32 = 15,
 287   UPB_DTYPE_SFIXED64 = 16,
 288   UPB_DTYPE_SINT32   = 17,
 289   UPB_DTYPE_SINT64   = 18
 290 } upb_descriptortype_t;
 291
 292 #define UPB_MAP_BEGIN ((size_t)-1)
 293
 294 UPB_INLINE bool _upb_isle(void) {
 295   int x = 1;
 296   return *(char*)&x == 1;
 297 }
 298
 299 UPB_INLINE uint32_t _upb_be_swap32(uint32_t val) {
 300   if (_upb_isle()) {
 301     return val;
 302   } else {
 303     return ((val & 0xff) << 24) | ((val & 0xff00) << 8) |
 304            ((val & 0xff0000) >> 8) | ((val & 0xff000000) >> 24);
 305   }
 306 }
 307
 308 UPB_INLINE uint64_t _upb_be_swap64(uint64_t val) {
 309   if (_upb_isle()) {
 310     return val;
 311   } else {
 312     return ((uint64_t)_upb_be_swap32(val) << 32) | _upb_be_swap32(val >> 32);
 313   }
 314 }
 315
 316 UPB_INLINE int _upb_lg2ceil(int x) {
 317   if (x <= 1) return 0;
 318 #ifdef __GNUC__
 319   return 32 - __builtin_clz(x - 1);
 320 #else
 321   int lg2 = 0;
 322   while (1 << lg2 < x) lg2++;
 323   return lg2;
 324 #endif
 325 }
 326
 327 UPB_INLINE int _upb_lg2ceilsize(int x) {
 328   return 1 << _upb_lg2ceil(x);
 329 }
 330
 331 #include "upb/port_undef.inc"
 332
 333 #ifdef __cplusplus
 334 }  /* extern "C" */
 335 #endif
 336
 337 #endif  /* UPB_H_ */