Merge branch 'master' into apitweaks

56 files changed, 4258 insertions, 16497 deletions

diff --git a/upb/bindings/lua/def.c b/upb/bindings/lua/def.c
index 194acc3..a9ab9a8 100644
--- a/upb/bindings/lua/def.c
+++ b/upb/bindings/lua/def.c
@@ -6,7 +6,6 @@
 #include "lauxlib.h"
 #include "upb/bindings/lua/upb.h"
 #include "upb/def.h"
-#include "upb/pb/glue.h"
 
 #define LUPB_ENUMDEF "lupb.enumdef"
 #define LUPB_FIELDDEF "lupb.fielddef"
@@ -16,46 +15,25 @@
 #define LUPB_SYMTAB "lupb.symtab"
 #define LUPB_OBJCACHE "lupb.objcache"
 
-#define CHK(pred) do { \
-    upb_status status = UPB_STATUS_INIT; \
-    pred; \
+#define CHK(pred)                 \
+  do {                            \
+    upb_status status;            \
+    upb_status_clear(&status);    \
+    pred;                         \
     lupb_checkstatus(L, &status); \
   } while (0)
 
+/* lupb_wrapper ***************************************************************/
 
-const char *lupb_checkname(lua_State *L, int narg) {
-  size_t len;
-  const char *name = luaL_checklstring(L, narg, &len);
-  if (strlen(name) != len)
-    luaL_error(L, "names cannot have embedded NULLs");
-  return name;
-}
-
-upb_fieldtype_t lupb_checkfieldtype(lua_State *L, int narg) {
-  int type = luaL_checkint(L, narg);
-  if (!upb_fielddef_checktype(type))
-    luaL_argerror(L, narg, "invalid field type");
-  return type;
-}
-
-
-/* lupb_refcounted ************************************************************/
-
-/* All upb objects that use upb_refcounted have a userdata that begins with a
- * pointer to that object.  Each type has its own metatable.  Objects are cached
- * in a weak table indexed by the C pointer of the object they are caching.
- *
- * Note that we consistently use memcpy() to read to/from the object.  This
- * allows the userdata to use its own struct without violating aliasing, as
- * long as it begins with a pointer. */
+/* Wrappers around upb objects. */
 
 /* Checks type; if it matches, pulls the pointer out of the wrapper. */
-void *lupb_refcounted_check(lua_State *L, int narg, const char *type) {
+void *lupb_checkwrapper(lua_State *L, int narg, const char *type) {
   void *ud = lua_touserdata(L, narg);
   void *ret;
 
   if (!ud) {
-    luaL_typerror(L, narg, "refcounted");
+    luaL_typerror(L, narg, "upb wrapper");
   }
 
   memcpy(&ret, ud, sizeof(ret));
@@ -67,15 +45,12 @@ void *lupb_refcounted_check(lua_State *L, int narg, const char *type) {
   return ret;
 }
 
-bool lupb_refcounted_pushwrapper(lua_State *L, const upb_refcounted *obj,
-                                 const char *type, const void *ref_donor,
-                                 size_t size) {
-  bool create;
+void lupb_pushwrapper(lua_State *L, const void *obj, const char *type) {
   void *ud;
 
   if (obj == NULL) {
     lua_pushnil(L);
-    return false;
+    return;
   }
 
   /* Lookup our cache in the registry (we don't put our objects in the registry
@@ -86,34 +61,11 @@ bool lupb_refcounted_pushwrapper(lua_State *L, const upb_refcounted *obj,
   lua_rawget(L, -2);
   /* Stack is now: objcache, cached value. */
 
-  create = false;
-
   if (lua_isnil(L, -1)) {
-    create = true;
-  } else {
-    void *ud = lua_touserdata(L, -1);
-    void *ud_obj;
-    lupb_assert(L, ud);
-    memcpy(&ud_obj, ud, sizeof(void*));
-
-    /* A corner case: it is possible for the value to be GC'd
-     * already, in which case we should evict this entry and create
-     * a new one. */
-    if (ud_obj == NULL) {
-      create = true;
-    }
-  }
-
-  ud = NULL;
-
-  if (create) {
     /* Remove bad cached value and push new value. */
     lua_pop(L, 1);
-
-    /* All of our userdata begin with a pointer to the obj. */
-    ud = lua_newuserdata(L, size);
-    memcpy(ud, &obj, sizeof(void*));
-    upb_refcounted_donateref(obj, ref_donor, ud);
+    ud = lua_newuserdata(L, sizeof(*ud));
+    memcpy(ud, &obj, sizeof(*ud));
 
     luaL_getmetatable(L, type);
     /* Should have been created by luaopen_upb. */
@@ -124,207 +76,36 @@ bool lupb_refcounted_pushwrapper(lua_State *L, const upb_refcounted *obj,
     lua_pushlightuserdata(L, (void*)obj);
     lua_pushvalue(L, -2);
     lua_rawset(L, -4);
-  } else {
-    /* Existing wrapper obj already has a ref. */
-    ud = lua_touserdata(L, -1);
-    upb_refcounted_checkref(obj, ud);
-    if (ref_donor)
-      upb_refcounted_unref(obj, ref_donor);
   }
 
   lua_insert(L, -2);
   lua_pop(L, 1);
-  return create;
-}
-
-void lupb_refcounted_pushnewrapper(lua_State *L, const upb_refcounted *obj,
-                                   const char *type, const void *ref_donor) {
-  bool created =
-      lupb_refcounted_pushwrapper(L, obj, type, ref_donor, sizeof(void *));
-  UPB_ASSERT(created == true);
-}
-
-int lupb_refcounted_gc(lua_State *L) {
-  void *ud = lua_touserdata(L, 1);
-  void *nullp;
-  upb_refcounted *obj;
-  memcpy(&obj, ud, sizeof(obj));
-  upb_refcounted_unref(obj, ud);
-
-  /* Zero out pointer so we can detect a call into a GC'd object. */
-  nullp = NULL;
-  memcpy(ud, &nullp, sizeof(nullp));
-
-  return 0;
-}
-
-
-/* lupb_def *******************************************************************/
-
-static const upb_def *lupb_def_check(lua_State *L, int narg) {
-  upb_def *ret;
-  void *ud, *ud2;
-
-  ud = lua_touserdata(L, narg);
-  if (!ud) {
-    luaL_typerror(L, narg, "upb def");
-  }
-
-  memcpy(&ret, ud, sizeof(ret));
-  if (!ret) {
-    luaL_error(L, "called into dead object");
-  }
-
-  ud2 = luaL_testudata(L, narg, LUPB_MSGDEF);
-  if (!ud2) ud2 = luaL_testudata(L, narg, LUPB_ENUMDEF);
-  if (!ud2) ud2 = luaL_testudata(L, narg, LUPB_FIELDDEF);
-  if (!ud2) luaL_typerror(L, narg, "upb def");
-
-  return ret;
-}
-
-static upb_def *lupb_def_checkmutable(lua_State *L, int narg) {
-  const upb_def *def = lupb_def_check(L, narg);
-  if (upb_def_isfrozen(def))
-    luaL_error(L, "not allowed on frozen value");
-  return (upb_def*)def;
-}
-
-bool lupb_def_pushwrapper(lua_State *L, const upb_def *def,
-                          const void *ref_donor) {
-  const char *type = NULL;
-  bool created;
-
-  if (def == NULL) {
-    lua_pushnil(L);
-    return false;
-  }
-
-  switch (upb_def_type(def)) {
-    case UPB_DEF_MSG:
-      type = LUPB_MSGDEF;
-      break;
-    case UPB_DEF_FIELD:
-      type = LUPB_FIELDDEF;
-      break;
-    case UPB_DEF_ENUM:
-      type = LUPB_ENUMDEF;
-      break;
-    default:
-      printf("Def type: %d\n", (int)upb_def_type(def));
-      UPB_UNREACHABLE();
-  }
-
-  created = lupb_refcounted_pushwrapper(L, upb_def_upcast(def), type, ref_donor,
-                                        sizeof(void *));
-  return created;
-}
-
-void lupb_def_pushnewrapper(lua_State *L, const upb_def *def,
-                            const void *ref_donor) {
-  bool created = lupb_def_pushwrapper(L, def, ref_donor);
-  UPB_ASSERT(created == true);
 }
 
-static int lupb_def_type(lua_State *L) {
-  const upb_def *def = lupb_def_check(L, 1);
-  lua_pushinteger(L, upb_def_type(def));
-  return 1;
-}
-
-void lupb_filedef_pushwrapper(lua_State *L, const upb_filedef *f,
-                              const void *ref_donor);
-
-static int lupb_def_file(lua_State *L) {
-  const upb_def *def = lupb_def_check(L, 1);
-  lupb_filedef_pushwrapper(L, upb_def_file(def), NULL);
-  return 1;
-}
-
-static int lupb_def_freeze(lua_State *L) {
-  upb_def *def = lupb_def_checkmutable(L, 1);
-  CHK(upb_def_freeze(&def, 1, &status));
-  return 0;
-}
-
-static int lupb_def_isfrozen(lua_State *L) {
-  const upb_def *def = lupb_def_check(L, 1);
-  lua_pushboolean(L, upb_def_isfrozen(def));
-  return 1;
-}
-
-static int lupb_def_fullname(lua_State *L) {
-  const upb_def *def = lupb_def_check(L, 1);
-  lua_pushstring(L, upb_def_fullname(def));
-  return 1;
-}
-
-static int lupb_def_name(lua_State *L) {
-  const upb_def *def = lupb_def_check(L, 1);
-  lua_pushstring(L, upb_def_name(def));
-  return 1;
-}
-
-static int lupb_def_setfullname(lua_State *L) {
-  const char *name = lupb_checkname(L, 2);
-  CHK(upb_def_setfullname(lupb_def_checkmutable(L, 1), name, &status));
-  return 0;
-}
-
-#define LUPB_COMMON_DEF_METHODS \
-  {"def_type", lupb_def_type},  \
-  {"file", lupb_def_file}, \
-  {"full_name", lupb_def_fullname}, \
-  {"freeze", lupb_def_freeze}, \
-  {"is_frozen", lupb_def_isfrozen}, \
-  {"name", lupb_def_name}, \
-  {"set_full_name", lupb_def_setfullname}, \
+void lupb_msgdef_pushwrapper(lua_State *L, const upb_msgdef *m);
+void lupb_oneofdef_pushwrapper(lua_State *L, const upb_oneofdef *o);
+static void lupb_enumdef_pushwrapper(lua_State *L, const upb_enumdef *e);
 
 
 /* lupb_fielddef **************************************************************/
 
-void lupb_fielddef_pushwrapper(lua_State *L, const upb_fielddef *f,
-                               const void *ref_donor) {
-  lupb_def_pushwrapper(L, upb_fielddef_upcast(f), ref_donor);
+void lupb_fielddef_pushwrapper(lua_State *L, const upb_fielddef *f) {
+  lupb_pushwrapper(L, f, LUPB_FIELDDEF);
 }
 
 const upb_fielddef *lupb_fielddef_check(lua_State *L, int narg) {
-  return lupb_refcounted_check(L, narg, LUPB_FIELDDEF);
+  return lupb_checkwrapper(L, narg, LUPB_FIELDDEF);
 }
 
-static upb_fielddef *lupb_fielddef_checkmutable(lua_State *L, int narg) {
-  const upb_fielddef *f = lupb_fielddef_check(L, narg);
-  if (upb_fielddef_isfrozen(f))
-    luaL_error(L, "not allowed on frozen value");
-  return (upb_fielddef*)f;
-}
-
-static int lupb_fielddef_new(lua_State *L) {
-  upb_fielddef *f = upb_fielddef_new(&f);
-  lupb_def_pushnewrapper(L, upb_fielddef_upcast(f), &f);
-  return 1;
-}
-
-/* Getters */
-
-void lupb_oneofdef_pushwrapper(lua_State *L, const upb_oneofdef *o,
-                               const void *ref_donor);
-
 static int lupb_fielddef_containingoneof(lua_State *L) {
   const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  lupb_oneofdef_pushwrapper(L, upb_fielddef_containingoneof(f), NULL);
+  lupb_oneofdef_pushwrapper(L, upb_fielddef_containingoneof(f));
   return 1;
 }
 
 static int lupb_fielddef_containingtype(lua_State *L) {
   const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  lupb_msgdef_pushwrapper(L, upb_fielddef_containingtype(f), NULL);
-  return 1;
-}
-
-static int lupb_fielddef_containingtypename(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  lua_pushstring(L, upb_fielddef_containingtypename(f));
+  lupb_msgdef_pushwrapper(L, upb_fielddef_containingtype(f));
   return 1;
 }
 
@@ -332,7 +113,7 @@ static int lupb_fielddef_default(lua_State *L) {
   const upb_fielddef *f = lupb_fielddef_check(L, 1);
   switch (upb_fielddef_type(f)) {
     case UPB_TYPE_INT32:
-    int32:
+    case UPB_TYPE_ENUM:
       lupb_pushint32(L, upb_fielddef_defaultint32(f)); break;
     case UPB_TYPE_INT64:
       lupb_pushint64(L, upb_fielddef_defaultint64(f)); break;
@@ -346,18 +127,8 @@ static int lupb_fielddef_default(lua_State *L) {
       lua_pushnumber(L, upb_fielddef_defaultfloat(f)); break;
     case UPB_TYPE_BOOL:
       lua_pushboolean(L, upb_fielddef_defaultbool(f)); break;
-    case UPB_TYPE_ENUM:
-      if (upb_fielddef_enumhasdefaultstr(f)) {
-        goto str;
-      } else if (upb_fielddef_enumhasdefaultint32(f)) {
-        goto int32;
-      } else {
-        lua_pushnil(L);
-      }
-      break;
     case UPB_TYPE_STRING:
-    case UPB_TYPE_BYTES:
-    str: {
+    case UPB_TYPE_BYTES: {
       size_t len;
       const char *data = upb_fielddef_defaultstr(f, &len);
       lua_pushlstring(L, data, len);
@@ -398,24 +169,12 @@ static int lupb_fielddef_index(lua_State *L) {
   return 1;
 }
 
-static int lupb_fielddef_intfmt(lua_State *L) {
-  const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  lua_pushinteger(L, upb_fielddef_intfmt(f));
-  return 1;
-}
-
 static int lupb_fielddef_isextension(lua_State *L) {
   const upb_fielddef *f = lupb_fielddef_check(L, 1);
   lua_pushboolean(L, upb_fielddef_isextension(f));
   return 1;
 }
 
-static int lupb_fielddef_istagdelim(lua_State *L) {
-  const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  lua_pushboolean(L, upb_fielddef_istagdelim(f));
-  return 1;
-}
-
 static int lupb_fielddef_label(lua_State *L) {
   const upb_fielddef *f = lupb_fielddef_check(L, 1);
   lua_pushinteger(L, upb_fielddef_label(f));
@@ -450,22 +209,15 @@ static int lupb_fielddef_packed(lua_State *L) {
   return 1;
 }
 
-static int lupb_fielddef_subdef(lua_State *L) {
+static int lupb_fielddef_msgsubdef(lua_State *L) {
   const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  const upb_def *def;
-
-  if (!upb_fielddef_hassubdef(f))
-    luaL_error(L, "Tried to get subdef of non-message field");
-  def = upb_fielddef_subdef(f);
-  lupb_def_pushwrapper(L, def, NULL);
+  lupb_msgdef_pushwrapper(L, upb_fielddef_msgsubdef(f));
   return 1;
 }
 
-static int lupb_fielddef_subdefname(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  if (!upb_fielddef_hassubdef(f))
-    luaL_error(L, "Tried to get subdef name of non-message field");
-  lua_pushstring(L, upb_fielddef_subdefname(f));
+static int lupb_fielddef_enumsubdef(lua_State *L) {
+  const upb_fielddef *f = lupb_fielddef_check(L, 1);
+  lupb_enumdef_pushwrapper(L, upb_fielddef_enumsubdef(f));
   return 1;
 }
 
@@ -478,216 +230,40 @@ static int lupb_fielddef_type(lua_State *L) {
   return 1;
 }
 
-/* Setters */
-
-static int lupb_fielddef_setcontainingtypename(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  const char *name = NULL;
-  if (!lua_isnil(L, 2))
-    name = lupb_checkname(L, 2);
-  CHK(upb_fielddef_setcontainingtypename(f, name, &status));
-  return 0;
-}
-
-static int lupb_fielddef_setdefault(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-
-  switch (upb_fielddef_type(f)) {
-    case UPB_TYPE_INT32:
-      upb_fielddef_setdefaultint32(f, lupb_checkint32(L, 2));
-      break;
-    case UPB_TYPE_INT64:
-      upb_fielddef_setdefaultint64(f, lupb_checkint64(L, 2));
-      break;
-    case UPB_TYPE_UINT32:
-      upb_fielddef_setdefaultuint32(f, lupb_checkuint32(L, 2));
-      break;
-    case UPB_TYPE_UINT64:
-      upb_fielddef_setdefaultuint64(f, lupb_checkuint64(L, 2));
-      break;
-    case UPB_TYPE_DOUBLE:
-      upb_fielddef_setdefaultdouble(f, lupb_checkdouble(L, 2));
-      break;
-    case UPB_TYPE_FLOAT:
-      upb_fielddef_setdefaultfloat(f, lupb_checkfloat(L, 2));
-      break;
-    case UPB_TYPE_BOOL:
-      upb_fielddef_setdefaultbool(f, lupb_checkbool(L, 2));
-      break;
-    case UPB_TYPE_MESSAGE:
-      return luaL_error(L, "Message types cannot have defaults.");
-    case UPB_TYPE_ENUM:
-      if (lua_type(L, 2) != LUA_TSTRING) {
-        upb_fielddef_setdefaultint32(f, lupb_checkint32(L, 2));
-        break;
-      }
-      /* Else fall through and set string default. */
-    case UPB_TYPE_BYTES:
-    case UPB_TYPE_STRING: {
-      size_t len;
-      const char *str = lua_tolstring(L, 2, &len);
-      CHK(upb_fielddef_setdefaultstr(f, str, len, &status));
-    }
-  }
-  return 0;
-}
-
-static int lupb_fielddef_setisextension(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  CHK(upb_fielddef_setisextension(f, lupb_checkbool(L, 2)));
-  return 0;
-}
-
-static int lupb_fielddef_setlabel(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  int label = luaL_checkint(L, 2);
-  if (!upb_fielddef_checklabel(label))
-    luaL_argerror(L, 2, "invalid field label");
-  upb_fielddef_setlabel(f, label);
-  return 0;
-}
-
-static int lupb_fielddef_setlazy(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  upb_fielddef_setlazy(f, lupb_checkbool(L, 2));
-  return 0;
-}
-
-static int lupb_fielddef_setname(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  CHK(upb_fielddef_setname(f, lupb_checkname(L, 2), &status));
-  return 0;
-}
-
-static int lupb_fielddef_setnumber(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  CHK(upb_fielddef_setnumber(f, luaL_checkint(L, 2), &status));
-  return 0;
-}
-
-static int lupb_fielddef_setpacked(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  upb_fielddef_setpacked(f, lupb_checkbool(L, 2));
-  return 0;
-}
-
-static int lupb_fielddef_setsubdef(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  const upb_def *def = NULL;
-  if (!lua_isnil(L, 2))
-    def = lupb_def_check(L, 2);
-  CHK(upb_fielddef_setsubdef(f, def, &status));
-  return 0;
-}
-
-static int lupb_fielddef_setsubdefname(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  const char *name = NULL;
-  if (!lua_isnil(L, 2))
-    name = lupb_checkname(L, 2);
-  CHK(upb_fielddef_setsubdefname(f, name, &status));
-  return 0;
-}
-
-static int lupb_fielddef_settype(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  upb_fielddef_settype(f, lupb_checkfieldtype(L, 2));
-  return 0;
-}
-
-static int lupb_fielddef_setintfmt(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  int32_t intfmt = luaL_checknumber(L, 2);
-  if (!upb_fielddef_checkintfmt(intfmt))
-    luaL_argerror(L, 2, "invalid intfmt");
-  upb_fielddef_setintfmt(f, intfmt);
-  return 0;
-}
-
-static int lupb_fielddef_settagdelim(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  bool is_tag_delim = lupb_checkbool(L, 2);
-  CHK(upb_fielddef_settagdelim(f, is_tag_delim));
-  return 0;
-}
-
-static const struct luaL_Reg lupb_fielddef_mm[] = {
-  {"__gc", lupb_refcounted_gc},
-  {NULL, NULL}
-};
-
 static const struct luaL_Reg lupb_fielddef_m[] = {
-  LUPB_COMMON_DEF_METHODS
-
   {"containing_oneof", lupb_fielddef_containingoneof},
   {"containing_type", lupb_fielddef_containingtype},
-  {"containing_type_name", lupb_fielddef_containingtypename},
   {"default", lupb_fielddef_default},
   {"descriptor_type", lupb_fielddef_descriptortype},
   {"getsel", lupb_fielddef_getsel},
   {"has_subdef", lupb_fielddef_hassubdef},
   {"index", lupb_fielddef_index},
-  {"intfmt", lupb_fielddef_intfmt},
   {"is_extension", lupb_fielddef_isextension},
-  {"istagdelim", lupb_fielddef_istagdelim},
   {"label", lupb_fielddef_label},
   {"lazy", lupb_fielddef_lazy},
   {"name", lupb_fielddef_name},
   {"number", lupb_fielddef_number},
   {"packed", lupb_fielddef_packed},
-  {"subdef", lupb_fielddef_subdef},
-  {"subdef_name", lupb_fielddef_subdefname},
+  {"msgsubdef", lupb_fielddef_msgsubdef},
+  {"enumsubdef", lupb_fielddef_enumsubdef},
   {"type", lupb_fielddef_type},
-
-  {"set_containing_type_name", lupb_fielddef_setcontainingtypename},
-  {"set_default", lupb_fielddef_setdefault},
-  {"set_is_extension", lupb_fielddef_setisextension},
-  {"set_label", lupb_fielddef_setlabel},
-  {"set_lazy", lupb_fielddef_setlazy},
-  {"set_name", lupb_fielddef_setname},
-  {"set_number", lupb_fielddef_setnumber},
-  {"set_packed", lupb_fielddef_setpacked},
-  {"set_subdef", lupb_fielddef_setsubdef},
-  {"set_subdef_name", lupb_fielddef_setsubdefname},
-  {"set_type", lupb_fielddef_settype},
-  {"set_intfmt", lupb_fielddef_setintfmt},
-  {"set_tagdelim", lupb_fielddef_settagdelim},
-
   {NULL, NULL}
 };
 
 
 /* lupb_oneofdef **************************************************************/
 
-void lupb_oneofdef_pushwrapper(lua_State *L, const upb_oneofdef *o,
-                               const void *ref_donor) {
-  lupb_refcounted_pushwrapper(L, upb_oneofdef_upcast(o), LUPB_ONEOFDEF,
-                              ref_donor, sizeof(void *));
+void lupb_oneofdef_pushwrapper(lua_State *L, const upb_oneofdef *o) {
+  lupb_pushwrapper(L, o, LUPB_ONEOFDEF);
 }
 
 const upb_oneofdef *lupb_oneofdef_check(lua_State *L, int narg) {
-  return lupb_refcounted_check(L, narg, LUPB_ONEOFDEF);
-}
-
-static upb_oneofdef *lupb_oneofdef_checkmutable(lua_State *L, int narg) {
-  const upb_oneofdef *o = lupb_oneofdef_check(L, narg);
-  if (upb_oneofdef_isfrozen(o))
-    luaL_error(L, "not allowed on frozen value");
-  return (upb_oneofdef*)o;
+  return lupb_checkwrapper(L, narg, LUPB_ONEOFDEF);
 }
 
-static int lupb_oneofdef_new(lua_State *L) {
-  upb_oneofdef *o = upb_oneofdef_new(&o);
-  lupb_refcounted_pushnewrapper(L, upb_oneofdef_upcast(o), LUPB_ONEOFDEF, &o);
-  return 1;
-}
-
-/* Getters */
-
 static int lupb_oneofdef_containingtype(lua_State *L) {
   const upb_oneofdef *o = lupb_oneofdef_check(L, 1);
-  lupb_def_pushwrapper(L, upb_msgdef_upcast(upb_oneofdef_containingtype(o)),
-                       NULL);
+  lupb_msgdef_pushwrapper(L, upb_oneofdef_containingtype(o));
   return 1;
 }
 
@@ -705,14 +281,14 @@ static int lupb_oneofdef_field(lua_State *L) {
     return luaL_argerror(L, 2, msg);
   }
 
-  lupb_def_pushwrapper(L, upb_fielddef_upcast(f), NULL);
+  lupb_fielddef_pushwrapper(L, f);
   return 1;
 }
 
 static int lupb_oneofiter_next(lua_State *L) {
   upb_oneof_iter *i = lua_touserdata(L, lua_upvalueindex(1));
   if (upb_oneof_done(i)) return 0;
-  lupb_fielddef_pushwrapper(L, upb_oneof_iter_field(i), NULL);
+  lupb_fielddef_pushwrapper(L, upb_oneof_iter_field(i));
   upb_oneof_next(i);
   return 1;
 }
@@ -739,35 +315,15 @@ static int lupb_oneofdef_name(lua_State *L) {
   return 1;
 }
 
-/* Setters */
-
-static int lupb_oneofdef_add(lua_State *L) {
-  upb_oneofdef *o = lupb_oneofdef_checkmutable(L, 1);
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 2);
-  CHK(upb_oneofdef_addfield(o, f, NULL, &status));
-  return 0;
-}
-
-static int lupb_oneofdef_setname(lua_State *L) {
-  upb_oneofdef *o = lupb_oneofdef_checkmutable(L, 1);
-  CHK(upb_oneofdef_setname(o, lupb_checkname(L, 2), &status));
-  return 0;
-}
-
 static const struct luaL_Reg lupb_oneofdef_m[] = {
   {"containing_type", lupb_oneofdef_containingtype},
   {"field", lupb_oneofdef_field},
   {"fields", lupb_oneofdef_fields},
   {"name", lupb_oneofdef_name},
-
-  {"add", lupb_oneofdef_add},
-  {"set_name", lupb_oneofdef_setname},
-
   {NULL, NULL}
 };
 
 static const struct luaL_Reg lupb_oneofdef_mm[] = {
-  {"__gc", lupb_refcounted_gc},
   {"__len", lupb_oneofdef_len},
   {NULL, NULL}
 };
@@ -779,40 +335,12 @@ typedef struct {
   const upb_msgdef *md;
 } lupb_msgdef;
 
-void lupb_msgdef_pushwrapper(lua_State *L, const upb_msgdef *m,
-                             const void *ref_donor) {
-  lupb_def_pushwrapper(L, upb_msgdef_upcast(m), ref_donor);
+void lupb_msgdef_pushwrapper(lua_State *L, const upb_msgdef *m) {
+  lupb_pushwrapper(L, m, LUPB_MSGDEF);
 }
 
 const upb_msgdef *lupb_msgdef_check(lua_State *L, int narg) {
-  return lupb_refcounted_check(L, narg, LUPB_MSGDEF);
-}
-
-static upb_msgdef *lupb_msgdef_checkmutable(lua_State *L, int narg) {
-  const upb_msgdef *m = lupb_msgdef_check(L, narg);
-  if (upb_msgdef_isfrozen(m))
-    luaL_error(L, "not allowed on frozen value");
-  return (upb_msgdef*)m;
-}
-
-static int lupb_msgdef_new(lua_State *L) {
-  upb_msgdef *md = upb_msgdef_new(&md);
-  lupb_def_pushnewrapper(L, upb_msgdef_upcast(md), &md);
-  return 1;
-}
-
-static int lupb_msgdef_add(lua_State *L) {
-  upb_msgdef *m = lupb_msgdef_checkmutable(L, 1);
-
-  /* Both oneofs and fields can be added. */
-  if (luaL_testudata(L, 2, LUPB_FIELDDEF)) {
-    upb_fielddef *f = lupb_fielddef_checkmutable(L, 2);
-    CHK(upb_msgdef_addfield(m, f, NULL, &status));
-  } else if (luaL_testudata(L, 2, LUPB_ONEOFDEF)) {
-    upb_oneofdef *o = lupb_oneofdef_checkmutable(L, 2);
-    CHK(upb_msgdef_addoneof(m, o, NULL, &status));
-  }
-  return 0;
+  return lupb_checkwrapper(L, narg, LUPB_MSGDEF);
 }
 
 static int lupb_msgdef_len(lua_State *L) {
@@ -835,7 +363,7 @@ static int lupb_msgdef_field(lua_State *L) {
     return luaL_argerror(L, 2, msg);
   }
 
-  lupb_def_pushwrapper(L, upb_fielddef_upcast(f), NULL);
+  lupb_fielddef_pushwrapper(L, f);
   return 1;
 }
 
@@ -846,9 +374,9 @@ static int lupb_msgdef_lookupname(lua_State *L) {
   if (!upb_msgdef_lookupnamez(m, lua_tostring(L, 2), &f, &o)) {
     lua_pushnil(L);
   } else if (o) {
-    lupb_oneofdef_pushwrapper(L, o, NULL);
+    lupb_oneofdef_pushwrapper(L, o);
   } else {
-    lupb_fielddef_pushwrapper(L, f, NULL);
+    lupb_fielddef_pushwrapper(L, f);
   }
   return 1;
 }
@@ -856,7 +384,7 @@ static int lupb_msgdef_lookupname(lua_State *L) {
 static int lupb_msgfielditer_next(lua_State *L) {
   upb_msg_field_iter *i = lua_touserdata(L, lua_upvalueindex(1));
   if (upb_msg_field_done(i)) return 0;
-  lupb_def_pushwrapper(L, upb_fielddef_upcast(upb_msg_iter_field(i)), NULL);
+  lupb_fielddef_pushwrapper(L, upb_msg_iter_field(i));
   upb_msg_field_next(i);
   return 1;
 }
@@ -874,7 +402,7 @@ static int lupb_msgdef_fields(lua_State *L) {
 static int lupb_msgoneofiter_next(lua_State *L) {
   upb_msg_oneof_iter *i = lua_touserdata(L, lua_upvalueindex(1));
   if (upb_msg_oneof_done(i)) return 0;
-  lupb_oneofdef_pushwrapper(L, upb_msg_iter_oneof(i), NULL);
+  lupb_oneofdef_pushwrapper(L, upb_msg_iter_oneof(i));
   upb_msg_oneof_next(i);
   return 1;
 }
@@ -903,20 +431,16 @@ static int lupb_msgdef_syntax(lua_State *L) {
 
 static const struct luaL_Reg lupb_msgdef_mm[] = {
   {"__len", lupb_msgdef_len},
-  {"__gc", lupb_refcounted_gc},
   {NULL, NULL}
 };
 
 static const struct luaL_Reg lupb_msgdef_m[] = {
-  LUPB_COMMON_DEF_METHODS
-  {"add", lupb_msgdef_add},
   {"field", lupb_msgdef_field},
   {"fields", lupb_msgdef_fields},
   {"lookup_name", lupb_msgdef_lookupname},
   {"oneofs", lupb_msgdef_oneofs},
   {"syntax", lupb_msgdef_syntax},
   {"_map_entry", lupb_msgdef_mapentry},
-
   {NULL, NULL}
 };
 
@@ -924,28 +448,11 @@ static const struct luaL_Reg lupb_msgdef_m[] = {
 /* lupb_enumdef ***************************************************************/
 
 const upb_enumdef *lupb_enumdef_check(lua_State *L, int narg) {
-  return lupb_refcounted_check(L, narg, LUPB_ENUMDEF);
-}
-
-static upb_enumdef *lupb_enumdef_checkmutable(lua_State *L, int narg) {
-  const upb_enumdef *f = lupb_enumdef_check(L, narg);
-  if (upb_enumdef_isfrozen(f))
-    luaL_error(L, "not allowed on frozen value");
-  return (upb_enumdef*)f;
+  return lupb_checkwrapper(L, narg, LUPB_ENUMDEF);
 }
 
-static int lupb_enumdef_new(lua_State *L) {
-  upb_enumdef *e = upb_enumdef_new(&e);
-  lupb_def_pushnewrapper(L, upb_enumdef_upcast(e), &e);
-  return 1;
-}
-
-static int lupb_enumdef_add(lua_State *L) {
-  upb_enumdef *e = lupb_enumdef_checkmutable(L, 1);
-  const char *name = lupb_checkname(L, 2);
-  int32_t val = lupb_checkint32(L, 3);
-  CHK(upb_enumdef_addval(e, name, val, &status));
-  return 0;
+static void lupb_enumdef_pushwrapper(lua_State *L, const upb_enumdef *e) {
+  lupb_pushwrapper(L, e, LUPB_ENUMDEF);
 }
 
 static int lupb_enumdef_len(lua_State *L) {
@@ -997,14 +504,11 @@ static int lupb_enumdef_values(lua_State *L) {
 }
 
 static const struct luaL_Reg lupb_enumdef_mm[] = {
-  {"__gc", lupb_refcounted_gc},
   {"__len", lupb_enumdef_len},
   {NULL, NULL}
 };
 
 static const struct luaL_Reg lupb_enumdef_m[] = {
-  LUPB_COMMON_DEF_METHODS
-  {"add", lupb_enumdef_add},
   {"value", lupb_enumdef_value},
   {"values", lupb_enumdef_values},
   {NULL, NULL}
@@ -1013,68 +517,50 @@ static const struct luaL_Reg lupb_enumdef_m[] = {
 
 /* lupb_filedef ***************************************************************/
 
-void lupb_filedef_pushwrapper(lua_State *L, const upb_filedef *f,
-                              const void *ref_donor) {
-  lupb_refcounted_pushwrapper(L, upb_filedef_upcast(f), LUPB_FILEDEF, ref_donor,
-                              sizeof(void *));
-}
-
-void lupb_filedef_pushnewrapper(lua_State *L, const upb_filedef *f,
-                                const void *ref_donor) {
-  lupb_refcounted_pushnewrapper(L, upb_filedef_upcast(f), LUPB_FILEDEF,
-                                ref_donor);
+void lupb_filedef_pushwrapper(lua_State *L, const upb_filedef *f) {
+  lupb_pushwrapper(L, f, LUPB_FILEDEF);
 }
 
 const upb_filedef *lupb_filedef_check(lua_State *L, int narg) {
-  return lupb_refcounted_check(L, narg, LUPB_FILEDEF);
+  return lupb_checkwrapper(L, narg, LUPB_FILEDEF);
 }
 
-static upb_filedef *lupb_filedef_checkmutable(lua_State *L, int narg) {
-  const upb_filedef *f = lupb_filedef_check(L, narg);
-  if (upb_filedef_isfrozen(f))
-    luaL_error(L, "not allowed on frozen value");
-  return (upb_filedef*)f;
+static int lupb_filedef_dep(lua_State *L) {
+  const upb_filedef *f = lupb_filedef_check(L, 1);
+  int index = luaL_checkint(L, 2);
+  lupb_filedef_pushwrapper(L, upb_filedef_dep(f, index));
+  return 1;
 }
 
-static int lupb_filedef_new(lua_State *L) {
-  upb_filedef *f = upb_filedef_new(&f);
-  lupb_filedef_pushnewrapper(L, f, &f);
+static int lupb_filedef_depcount(lua_State *L) {
+  const upb_filedef *f = lupb_filedef_check(L, 1);
+  lua_pushnumber(L, upb_filedef_depcount(f));
   return 1;
 }
 
-static int lupb_filedef_def(lua_State *L) {
+static int lupb_filedef_enum(lua_State *L) {
   const upb_filedef *f = lupb_filedef_check(L, 1);
   int index = luaL_checkint(L, 2);
-  const upb_def *def = upb_filedef_def(f, index);
-
-  if (!def) {
-    return luaL_error(L, "index out of range");
-  }
-
-  lupb_def_pushwrapper(L, def, NULL);
+  lupb_enumdef_pushwrapper(L, upb_filedef_enum(f, index));
   return 1;
 }
 
-static int lupb_filedefdepiter_next(lua_State *L) {
-  const upb_filedef *f = lupb_filedef_check(L, lua_upvalueindex(1));
-  size_t i = lua_tointeger(L, lua_upvalueindex(2));
-
-  if (i >= upb_filedef_depcount(f)) {
-    return 0;
-  }
-
-  lupb_filedef_pushwrapper(L, upb_filedef_dep(f, i), NULL);
-  lua_pushinteger(L, i + 1);
-  lua_replace(L, lua_upvalueindex(2));
+static int lupb_filedef_enumcount(lua_State *L) {
+  const upb_filedef *f = lupb_filedef_check(L, 1);
+  lua_pushnumber(L, upb_filedef_enumcount(f));
   return 1;
 }
 
+static int lupb_filedef_msg(lua_State *L) {
+  const upb_filedef *f = lupb_filedef_check(L, 1);
+  int index = luaL_checkint(L, 2);
+  lupb_msgdef_pushwrapper(L, upb_filedef_msg(f, index));
+  return 1;
+}
 
-static int lupb_filedef_dependencies(lua_State *L) {
-  lupb_filedef_check(L, 1);
-  lua_pushvalue(L, 1);
-  lua_pushnumber(L, 0);      /* Index, starts at zero. */
-  lua_pushcclosure(L, &lupb_filedefdepiter_next, 2);
+static int lupb_filedef_msgcount(lua_State *L) {
+  const upb_filedef *f = lupb_filedef_check(L, 1);
+  lua_pushnumber(L, upb_filedef_msgcount(f));
   return 1;
 }
 
@@ -1096,72 +582,16 @@ static int lupb_filedef_syntax(lua_State *L) {
   return 1;
 }
 
-static int lupb_filedef_len(lua_State *L) {
-  const upb_filedef *f = lupb_filedef_check(L, 1);
-  lua_pushinteger(L, upb_filedef_defcount(f));
-  return 1;
-}
-
-static int lupb_filedef_setname(lua_State *L) {
-  upb_filedef *f = lupb_filedef_checkmutable(L, 1);
-  CHK(upb_filedef_setname(f, lupb_checkname(L, 2), &status));
-  return 0;
-}
-
-static int lupb_filedef_setpackage(lua_State *L) {
-  upb_filedef *f = lupb_filedef_checkmutable(L, 1);
-  CHK(upb_filedef_setpackage(f, lupb_checkname(L, 2), &status));
-  return 0;
-}
-
-static int lupb_filedefiter_next(lua_State *L) {
-  const upb_filedef *f = lupb_filedef_check(L, lua_upvalueindex(1));
-  int type = lua_tointeger(L, lua_upvalueindex(2));
-  size_t i = lua_tointeger(L, lua_upvalueindex(3));
-  size_t n = upb_filedef_defcount(f);
-
-  for (; i < n; i++) {
-    const upb_def *def;
-
-    def = upb_filedef_def(f, i);
-    UPB_ASSERT(def);
-
-    if (type == UPB_DEF_ANY || upb_def_type(def) == type) {
-      lua_pushinteger(L, i + 1);
-      lua_replace(L, lua_upvalueindex(3));
-      lupb_def_pushwrapper(L, def, NULL);
-      return 1;
-    }
-  }
-
-  return 0;
-}
-
-static int lupb_filedef_defs(lua_State *L) {
-  lupb_filedef_check(L, 1);
-  luaL_checkinteger(L, 2);   /* Def type.  Could make this optional. */
-  lua_pushnumber(L, 0);      /* Index, starts at zero. */
-  lua_pushcclosure(L, &lupb_filedefiter_next, 3);
-  return 1;
-}
-
-static const struct luaL_Reg lupb_filedef_mm[] = {
-  {"__gc", lupb_refcounted_gc},
-  {"__len", lupb_filedef_len},
-  {NULL, NULL}
-};
-
 static const struct luaL_Reg lupb_filedef_m[] = {
-  {"def", lupb_filedef_def},
-  {"defs", lupb_filedef_defs},
-  {"dependencies", lupb_filedef_dependencies},
+  {"dep", lupb_filedef_dep},
+  {"depcount", lupb_filedef_depcount},
+  {"enum", lupb_filedef_enum},
+  {"enumcount", lupb_filedef_enumcount},
+  {"msg", lupb_filedef_msg},
+  {"msgcount", lupb_filedef_msgcount},
   {"name", lupb_filedef_name},
   {"package", lupb_filedef_package},
   {"syntax", lupb_filedef_syntax},
-
-  {"set_name", lupb_filedef_setname},
-  {"set_package", lupb_filedef_setpackage},
-
   {NULL, NULL}
 };
 
@@ -1195,76 +625,52 @@ static int lupb_symtab_gc(lua_State *L) {
   return 0;
 }
 
+/* TODO(haberman): perhaps this should take a message object instead of a
+ * serialized string once we have a good story for vending compiled-in
+ * messages. */
 static int lupb_symtab_add(lua_State *L) {
+  upb_arena *arena;
+  size_t i, n, len;
+  const google_protobuf_FileDescriptorProto *const *files;
+  google_protobuf_FileDescriptorSet *set;
   upb_symtab *s = lupb_symtab_check(L, 1);
-  int n;
-  upb_def **defs;
-
-  luaL_checktype(L, 2, LUA_TTABLE);
-  /* Iterate over table twice.  First iteration to count entries and
-   * check constraints. */
-  n = 0;
-  for (lua_pushnil(L); lua_next(L, 2); lua_pop(L, 1)) {
-    lupb_def_checkmutable(L, -1);
-    ++n;
-  }
+  const char *str = luaL_checklstring(L, 2, &len);
+
+  lupb_arena_new(L);
+  arena = lupb_arena_check(L, -1);
 
-  /* Second iteration to build deflist.
-   * Allocate list with lua_newuserdata() so it is anchored as a GC root in
-   * case any Lua functions longjmp(). */
-  defs = lua_newuserdata(L, n * sizeof(*defs));
-  n = 0;
-  for (lua_pushnil(L); lua_next(L, 2); lua_pop(L, 1)) {
-    upb_def *def = lupb_def_checkmutable(L, -1);
-    defs[n++] = def;
+  set = google_protobuf_FileDescriptorSet_parse(str, len, arena);
+
+  if (!set) {
+    luaL_argerror(L, 2, "failed to parse descriptor");
   }
 
-  CHK(upb_symtab_add(s, defs, n, NULL, &status));
-  return 0;
-}
+  files = google_protobuf_FileDescriptorSet_file(set, &n);
+  for (i = 0; i < n; i++) {
+    CHK(upb_symtab_addfile(s, files[i], &status));
+  }
 
-static int lupb_symtab_addfile(lua_State *L) {
-  upb_symtab *s = lupb_symtab_check(L, 1);
-  upb_filedef *f = lupb_filedef_checkmutable(L, 2);
-  CHK(upb_symtab_addfile(s, f, &status));
   return 0;
 }
 
-static int lupb_symtab_lookup(lua_State *L) {
+static int lupb_symtab_lookupmsg(lua_State *L) {
   const upb_symtab *s = lupb_symtab_check(L, 1);
-  int i;
-  for (i = 2; i <= lua_gettop(L); i++) {
-    const upb_def *def = upb_symtab_lookup(s, luaL_checkstring(L, i));
-    lupb_def_pushwrapper(L, def, NULL);
-    lua_replace(L, i);
-  }
-  return lua_gettop(L) - 1;
-}
-
-static int lupb_symtabiter_next(lua_State *L) {
-  upb_symtab_iter *i = lua_touserdata(L, lua_upvalueindex(1));
-  if (upb_symtab_done(i)) return 0;
-  lupb_def_pushwrapper(L, upb_symtab_iter_def(i), NULL);
-  upb_symtab_next(i);
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, luaL_checkstring(L, 2));
+  lupb_msgdef_pushwrapper(L, m);
   return 1;
 }
 
-static int lupb_symtab_defs(lua_State *L) {
+static int lupb_symtab_lookupenum(lua_State *L) {
   const upb_symtab *s = lupb_symtab_check(L, 1);
-  upb_deftype_t type = lua_gettop(L) > 1 ? luaL_checkint(L, 2) : UPB_DEF_ANY;
-  upb_symtab_iter *i = lua_newuserdata(L, sizeof(upb_symtab_iter));
-  upb_symtab_begin(i, s, type);
-  /* Need to guarantee that the symtab outlives the iter. */
-  lua_pushvalue(L, 1);
-  lua_pushcclosure(L, &lupb_symtabiter_next, 2);
+  const upb_enumdef *e = upb_symtab_lookupenum(s, luaL_checkstring(L, 2));
+  lupb_enumdef_pushwrapper(L, e);
   return 1;
 }
 
 static const struct luaL_Reg lupb_symtab_m[] = {
   {"add", lupb_symtab_add},
-  {"add_file", lupb_symtab_addfile},
-  {"defs", lupb_symtab_defs},
-  {"lookup", lupb_symtab_lookup},
+  {"lookup_msg", lupb_symtab_lookupmsg},
+  {"lookup_enum", lupb_symtab_lookupenum},
   {NULL, NULL}
 };
 
@@ -1275,55 +681,13 @@ static const struct luaL_Reg lupb_symtab_mm[] = {
 
 /* lupb toplevel **************************************************************/
 
-static int lupb_freeze(lua_State *L) {
-  int n = lua_gettop(L);
-  int i;
-  /* Scratch memory; lua_newuserdata() anchors it as a GC root in case any Lua
-   * functions fail. */
-  upb_def **defs = lua_newuserdata(L, n * sizeof(upb_def*));
-
-  for (i = 0; i < n; i++) {
-    /* Could allow an array of defs here also. */
-    defs[i] = lupb_def_checkmutable(L, i + 1);
-  }
-  CHK(upb_def_freeze(defs, n, &status));
-  return 0;
-}
-
-/* This is a *temporary* API that will be removed once pending refactorings are
- * complete (it does not belong here in core because it depends on both
- * the descriptor.proto schema and the protobuf binary format. */
-static int lupb_loaddescriptor(lua_State *L) {
-  size_t len;
-  const char *str = luaL_checklstring(L, 1, &len);
-  size_t i;
-  upb_filedef **files = NULL;
-  CHK(files = upb_loaddescriptor(str, len, &files, &status));
-
-  lua_newtable(L);
-  for (i = 1; *files; i++, files++) {
-    lupb_filedef_pushnewrapper(L, *files, &files);
-    lua_rawseti(L, -2, i);
-  }
-
-  return 1;
-}
-
 static void lupb_setfieldi(lua_State *L, const char *field, int i) {
   lua_pushinteger(L, i);
   lua_setfield(L, -2, field);
 }
 
 static const struct luaL_Reg lupbdef_toplevel_m[] = {
-  {"EnumDef", lupb_enumdef_new},
-  {"FieldDef", lupb_fielddef_new},
-  {"FileDef", lupb_filedef_new},
-  {"MessageDef", lupb_msgdef_new},
-  {"OneofDef", lupb_oneofdef_new},
   {"SymbolTable", lupb_symtab_new},
-  {"freeze", lupb_freeze},
-  {"load_descriptor", lupb_loaddescriptor},
-
   {NULL, NULL}
 };
 
@@ -1332,8 +696,8 @@ void lupb_def_registertypes(lua_State *L) {
 
   /* Refcounted types. */
   lupb_register_type(L, LUPB_ENUMDEF,  lupb_enumdef_m,  lupb_enumdef_mm);
-  lupb_register_type(L, LUPB_FIELDDEF, lupb_fielddef_m, lupb_fielddef_mm);
-  lupb_register_type(L, LUPB_FILEDEF,  lupb_filedef_m,  lupb_filedef_mm);
+  lupb_register_type(L, LUPB_FIELDDEF, lupb_fielddef_m, NULL);
+  lupb_register_type(L, LUPB_FILEDEF,  lupb_filedef_m,  NULL);
   lupb_register_type(L, LUPB_MSGDEF,   lupb_msgdef_m,   lupb_msgdef_mm);
   lupb_register_type(L, LUPB_ONEOFDEF, lupb_oneofdef_m, lupb_oneofdef_mm);
   lupb_register_type(L, LUPB_SYMTAB,   lupb_symtab_m,   lupb_symtab_mm);
@@ -1363,10 +727,6 @@ void lupb_def_registertypes(lua_State *L) {
   lupb_setfieldi(L, "TYPE_UINT32",    UPB_TYPE_UINT32);
   lupb_setfieldi(L, "TYPE_ENUM",      UPB_TYPE_ENUM);
 
-  lupb_setfieldi(L, "INTFMT_VARIABLE",  UPB_INTFMT_VARIABLE);
-  lupb_setfieldi(L, "INTFMT_FIXED",     UPB_INTFMT_FIXED);
-  lupb_setfieldi(L, "INTFMT_ZIGZAG",    UPB_INTFMT_ZIGZAG);
-
   lupb_setfieldi(L, "DESCRIPTOR_TYPE_DOUBLE",    UPB_DESCRIPTOR_TYPE_DOUBLE);
   lupb_setfieldi(L, "DESCRIPTOR_TYPE_FLOAT",     UPB_DESCRIPTOR_TYPE_FLOAT);
   lupb_setfieldi(L, "DESCRIPTOR_TYPE_INT64",     UPB_DESCRIPTOR_TYPE_INT64);
@@ -1386,12 +746,6 @@ void lupb_def_registertypes(lua_State *L) {
   lupb_setfieldi(L, "DESCRIPTOR_TYPE_SINT32",    UPB_DESCRIPTOR_TYPE_SINT32);
   lupb_setfieldi(L, "DESCRIPTOR_TYPE_SINT64",    UPB_DESCRIPTOR_TYPE_SINT64);
 
-  lupb_setfieldi(L, "DEF_MSG",      UPB_DEF_MSG);
-  lupb_setfieldi(L, "DEF_FIELD",    UPB_DEF_FIELD);
-  lupb_setfieldi(L, "DEF_ENUM",     UPB_DEF_ENUM);
-  lupb_setfieldi(L, "DEF_SERVICE",  UPB_DEF_SERVICE);
-  lupb_setfieldi(L, "DEF_ANY",      UPB_DEF_ANY);
-
   lupb_setfieldi(L, "HANDLER_INT32",       UPB_HANDLER_INT32);
   lupb_setfieldi(L, "HANDLER_INT64",       UPB_HANDLER_INT64);
   lupb_setfieldi(L, "HANDLER_UINT32",      UPB_HANDLER_UINT32);
diff --git a/upb/bindings/lua/msg.c b/upb/bindings/lua/msg.c
index e983f46..df5a143 100644
--- a/upb/bindings/lua/msg.c
+++ b/upb/bindings/lua/msg.c
@@ -100,16 +100,21 @@ static void *lupb_newuserdata(lua_State *L, size_t size, const char *type) {
  * it is an internal memory management detail.  Other objects refer to this
  * object from their userdata to keep the arena-owned data alive. */
 
+typedef struct {
+  upb_arena *arena;
+} lupb_arena;
+
 upb_arena *lupb_arena_check(lua_State *L, int narg) {
-  return luaL_checkudata(L, narg, LUPB_ARENA);
+  lupb_arena *a = luaL_checkudata(L, narg, LUPB_ARENA);
+  return a ? a->arena : NULL;
 }
 
 int lupb_arena_new(lua_State *L) {
-  upb_arena *a = lupb_newuserdata(L, sizeof(upb_arena), LUPB_ARENA);
+  lupb_arena *a = lupb_newuserdata(L, sizeof(lupb_arena), LUPB_ARENA);
 
   /* TODO(haberman): use Lua alloc func as block allocator?  Would need to
    * verify that all cases of upb_malloc in msg/table are longjmp-safe. */
-  upb_arena_init(a);
+  a->arena = upb_arena_new();
 
   return 1;
 }
@@ -140,7 +145,7 @@ static void lupb_arena_initsingleton(lua_State *L) {
 
 static int lupb_arena_gc(lua_State *L) {
   upb_arena *a = lupb_arena_check(L, 1);
-  upb_arena_uninit(a);
+  upb_arena_free(a);
   return 0;
 }
 
diff --git a/upb/bindings/lua/upb.h b/upb/bindings/lua/upb.h
index 820a317..6861286 100644
--- a/upb/bindings/lua/upb.h
+++ b/upb/bindings/lua/upb.h
@@ -84,9 +84,7 @@ void lupb_pushuint32(lua_State *L, uint32_t val);
 void lupb_pushdouble(lua_State *L, double val);
 void lupb_pushfloat(lua_State *L, float val);
 
-/* Registers a type with the given name, methods, and metamethods.
- * If "refcount_gc" is true, adds a __gc metamethod that does an unref.
- * Refcounted types must be allocated with lupb_refcounted_push[new]wrapper. */
+/* Registers a type with the given name, methods, and metamethods. */
 void lupb_register_type(lua_State *L, const char *name, const luaL_Reg *m,
                         const luaL_Reg *mm);
 
@@ -98,29 +96,13 @@ void lupb_checkstatus(lua_State *L, upb_status *s);
 
 upb_fieldtype_t lupb_checkfieldtype(lua_State *L, int narg);
 
-void *lupb_refcounted_check(lua_State *L, int narg, const char *type);
 const upb_msgdef *lupb_msgdef_check(lua_State *L, int narg);
 const upb_enumdef *lupb_enumdef_check(lua_State *L, int narg);
 const upb_fielddef *lupb_fielddef_check(lua_State *L, int narg);
 upb_symtab *lupb_symtab_check(lua_State *L, int narg);
 
-void lupb_refcounted_pushnewrapper(lua_State *L, const upb_refcounted *obj,
-                                   const char *type, const void *ref_donor);
-bool lupb_def_pushwrapper(lua_State *L, const upb_def *def,
-                          const void *ref_donor);
-void lupb_def_pushnewrapper(lua_State *L, const upb_def *def,
-                            const void *ref_donor);
-void lupb_msgdef_pushwrapper(lua_State *L, const upb_msgdef *m,
-                             const void *ref_donor);
-void lupb_symtab_pushwrapper(lua_State *L, const upb_symtab *s,
-                             const void *ref_donor);
-void lupb_symtab_pushnewrapper(lua_State *L, const upb_symtab *s,
-                               const void *ref_donor);
-
 void lupb_def_registertypes(lua_State *L);
 
-int lupb_refcounted_gc(lua_State *L);
-
 
 /** From msg.c. ***************************************************************/
 
diff --git a/upb/bindings/lua/upb/pb.c b/upb/bindings/lua/upb/pb.c
index 824ac13..b02fa3e 100644
--- a/upb/bindings/lua/upb/pb.c
+++ b/upb/bindings/lua/upb/pb.c
@@ -26,17 +26,15 @@ static int lupb_pb_decode(lua_State *L) {
 static int lupb_pb_encode(lua_State *L) {
   const upb_msglayout *layout;
   const upb_msg *msg = lupb_msg_checkmsg2(L, 1, &layout);
-  upb_arena arena;
+  upb_arena *arena = upb_arena_new();
   size_t size;
   char *result;
 
-  upb_arena_init(&arena);
-
-  result = upb_encode(msg, (const void*)layout, &arena, &size);
+  result = upb_encode(msg, (const void*)layout, arena, &size);
 
   /* Free resources before we potentially bail on error. */
   lua_pushlstring(L, result, size);
-  upb_arena_uninit(&arena);
+  upb_arena_free(arena);
   /* TODO(haberman): check for error. */
 
   return 1;
diff --git a/upb/bindings/lua/upb/table.c b/upb/bindings/lua/upb/table.c
deleted file mode 100644
index 3a9319d..0000000
--- a/upb/bindings/lua/upb/table.c
+++ /dev/null
@@ -1,210 +0,0 @@
-/*
-** require("upb.table") -- a Lua extension for accessing upb_table
-**
-** This is an internal-only interface and exists for the sole purpose of
-** writing a C code generator in Lua that can dump a upb_table as static C
-** initializers.  This lets us use Lua for convenient string manipulation while
-** saving us from re-implementing the upb_table hash function and hash table
-** layout / collision strategy in Lua.
-**
-** Since this is used only as part of the toolchain (and not part of the
-** runtime) we do not hold this module to the same stringent requirements as
-** the main Lua modules (for example that misbehaving Lua programs cannot
-** crash the interpreter).
-*/
-
-#include <float.h>
-#include <math.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lauxlib.h"
-#include "upb/bindings/lua/upb.h"
-#include "upb/def.h"
-#include "upb/table.int.h"
-
-static void lupbtable_setnum(lua_State *L, int tab, const char *key,
-                             lua_Number val) {
-  lua_pushnumber(L, val);
-  lua_setfield(L, tab - 1, key);
-}
-
-static void lupbtable_pushval(lua_State *L, upb_tabval val, upb_ctype_t ctype) {
-  switch (ctype) {
-    case UPB_CTYPE_INT32:
-      lua_pushnumber(L, val.val);
-      break;
-    case UPB_CTYPE_PTR:
-      lupb_def_pushwrapper(L, (void*)val.val, NULL);
-      break;
-    case UPB_CTYPE_CSTR:
-      lua_pushstring(L, (const char*)val.val);
-      break;
-    default:
-      luaL_error(L, "Unexpected type: %d", ctype);
-  }
-}
-
-/* Sets a few fields common to both hash table entries and arrays. */
-static void lupbtable_setmetafields(lua_State *L, int ctype, const void *ptr) {
-  /* We tack this onto every entry so we know it even if the entries
-   * don't stay with the table. */
-  lua_pushnumber(L, ctype);
-  lua_setfield(L, -2, "valtype");
-
-  /* Set this to facilitate linking. */
-  lua_pushlightuserdata(L, (void*)ptr);
-  lua_setfield(L, -2, "ptr");
-}
-
-static void lupbtable_pushent(lua_State *L, const upb_tabent *e,
-                              bool inttab, int ctype) {
-  lua_newtable(L);
-  if (!upb_tabent_isempty(e)) {
-    if (inttab) {
-      lua_pushnumber(L, e->key);
-    } else {
-      uint32_t len;
-      const char *str = upb_tabstr(e->key, &len);
-      lua_pushlstring(L, str, len);
-    }
-    lua_setfield(L, -2, "key");
-    lupbtable_pushval(L, e->val, ctype);
-    lua_setfield(L, -2, "value");
-  }
-  lua_pushlightuserdata(L, (void*)e->next);
-  lua_setfield(L, -2, "next");
-  lupbtable_setmetafields(L, ctype, e);
-}
-
-/* Dumps the shared part of upb_table into a Lua table. */
-static void lupbtable_pushtable(lua_State *L, const upb_table *t, bool inttab) {
-  size_t i;
-
-  lua_newtable(L);
-  lupbtable_setnum(L, -1, "count", t->count);
-  lupbtable_setnum(L, -1, "mask",  t->mask);
-  lupbtable_setnum(L, -1, "ctype", t->ctype);
-  lupbtable_setnum(L, -1, "size_lg2",  t->size_lg2);
-
-  lua_newtable(L);
-  for (i = 0; i < upb_table_size(t); i++) {
-    lupbtable_pushent(L, &t->entries[i], inttab, t->ctype);
-    lua_rawseti(L, -2, i + 1);
-  }
-  lua_setfield(L, -2, "entries");
-}
-
-/* Dumps a upb_inttable to a Lua table. */
-static void lupbtable_pushinttable(lua_State *L, const upb_inttable *t) {
-  size_t i;
-
-  lupbtable_pushtable(L, &t->t, true);
-  lupbtable_setnum(L, -1, "array_size", t->array_size);
-  lupbtable_setnum(L, -1, "array_count", t->array_count);
-
-  lua_newtable(L);
-  for (i = 0; i < t->array_size; i++) {
-    lua_newtable(L);
-    if (upb_arrhas(t->array[i])) {
-      lupbtable_pushval(L, t->array[i], t->t.ctype);
-      lua_setfield(L, -2, "val");
-    }
-    lupbtable_setmetafields(L, t->t.ctype, &t->array[i]);
-    lua_rawseti(L, -2, i + 1);
-  }
-  lua_setfield(L, -2, "array");
-}
-
-static void lupbtable_pushstrtable(lua_State *L, const upb_strtable *t) {
-  lupbtable_pushtable(L, &t->t, false);
-}
-
-static int lupbtable_msgdef_itof(lua_State *L) {
-  const upb_msgdef *m = lupb_msgdef_check(L, 1);
-  lupbtable_pushinttable(L, &m->itof);
-  return 1;
-}
-
-static int lupbtable_msgdef_ntof(lua_State *L) {
-  const upb_msgdef *m = lupb_msgdef_check(L, 1);
-  lupbtable_pushstrtable(L, &m->ntof);
-  return 1;
-}
-
-static int lupbtable_enumdef_iton(lua_State *L) {
-  const upb_enumdef *e = lupb_enumdef_check(L, 1);
-  lupbtable_pushinttable(L, &e->iton);
-  return 1;
-}
-
-static int lupbtable_enumdef_ntoi(lua_State *L) {
-  const upb_enumdef *e = lupb_enumdef_check(L, 1);
-  lupbtable_pushstrtable(L, &e->ntoi);
-  return 1;
-}
-
-static int lupbtable_symtab_symtab(lua_State *L) {
-  const upb_symtab *s = lupb_symtab_check(L, 1);
-  lupbtable_pushstrtable(L, &s->symtab);
-  return 1;
-}
-
-static void lupbtable_setfieldi(lua_State *L, const char *field, int i) {
-  lua_pushnumber(L, i);
-  lua_setfield(L, -2, field);
-}
-
-/* These aren't from the table, but they access other internal-only
- * definitions. */
-static int lupb_fielddef_selectorbase(lua_State *L) {
-  const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  if (!upb_fielddef_isfrozen(f))
-    luaL_error(L, "_selectorbase is only defined for frozen fielddefs");
-  lua_pushinteger(L, f->selector_base);
-  return 1;
-}
-
-static int lupb_msgdef_selectorcount(lua_State *L) {
-  const upb_msgdef *m = lupb_msgdef_check(L, 1);
-  lua_pushinteger(L, m->selector_count);
-  return 1;
-}
-
-static int lupb_msgdef_submsgfieldcount(lua_State *L) {
-  const upb_msgdef *m = lupb_msgdef_check(L, 1);
-  lua_pushinteger(L, m->submsg_field_count);
-  return 1;
-}
-
-static const struct luaL_Reg lupbtable_toplevel_m[] = {
-  {"msgdef_itof", lupbtable_msgdef_itof},
-  {"msgdef_ntof", lupbtable_msgdef_ntof},
-  {"enumdef_iton", lupbtable_enumdef_iton},
-  {"enumdef_ntoi", lupbtable_enumdef_ntoi},
-  {"symtab_symtab", lupbtable_symtab_symtab},
-
-  {"msgdef_selector_count", lupb_msgdef_selectorcount},
-  {"msgdef_submsg_field_count", lupb_msgdef_submsgfieldcount},
-
-  {"fielddef_selector_base", lupb_fielddef_selectorbase},
-
-  {NULL, NULL}
-};
-
-int luaopen_upb_table_c(lua_State *L) {
-  static char module_key;
-  if (lupb_openlib(L, &module_key, "upb.table", lupbtable_toplevel_m)) {
-    return 1;
-  }
-
-  /* We define these here because they are not public. */
-  lupbtable_setfieldi(L, "CTYPE_PTR",   UPB_CTYPE_PTR);
-  lupbtable_setfieldi(L, "CTYPE_CSTR",  UPB_CTYPE_CSTR);
-  lupbtable_setfieldi(L, "CTYPE_INT32", UPB_CTYPE_INT32);
-
-  lua_pushlightuserdata(L, NULL);
-  lua_setfield(L, -2, "NULL");
-
-  return 1;  /* Return a single Lua value, the package table created above. */
-}
diff --git a/upb/bindings/lua/upb/table.lua b/upb/bindings/lua/upb/table.lua
deleted file mode 100644
index ad8b066..0000000
--- a/upb/bindings/lua/upb/table.lua
+++ /dev/null
@@ -1,3 +0,0 @@
-
-require "upb"
-return require "upb.table_c"
diff --git a/upb/bindings/stdc++/string.h b/upb/bindings/stdc++/string.h
index 99efd4f..55b44cf 100644
--- a/upb/bindings/stdc++/string.h
+++ b/upb/bindings/stdc++/string.h
@@ -9,7 +9,7 @@ namespace upb {
 template <class T>
 class FillStringHandler {
  public:
-  static void SetHandler(BytesHandler* handler) {
+  static void SetHandler(upb_byteshandler* handler) {
     upb_byteshandler_setstartstr(handler, &FillStringHandler::StartString,
                                  NULL);
     upb_byteshandler_setstring(handler, &FillStringHandler::StringBuf, NULL);
@@ -28,7 +28,7 @@ class FillStringHandler {
   }
 
   static size_t StringBuf(void* c, const void* hd, const char* buf, size_t n,
-                          const BufferHandle* h) {
+                          const upb_bufhandle* h) {
     UPB_UNUSED(hd);
     UPB_UNUSED(h);
 
@@ -48,14 +48,15 @@ class StringSink {
   explicit StringSink(T* target) {
     // TODO(haberman): we need to avoid rebuilding a new handler every time,
     // but with class globals disallowed for google3 C++ this is tricky.
+    upb_byteshandler_init(&handler_);
     FillStringHandler<T>::SetHandler(&handler_);
     input_.Reset(&handler_, target);
   }
 
-  BytesSink* input() { return &input_; }
+  BytesSink input() { return input_; }
 
  private:
-  BytesHandler handler_;
+  upb_byteshandler handler_;
   BytesSink input_;
 };
 
diff --git a/upb/decode.c b/upb/decode.c
index 5315187..8ea0573 100644
--- a/upb/decode.c
+++ b/upb/decode.c
@@ -1,4 +1,5 @@
 
+#include <string.h>
 #include "upb/upb.h"
 #include "upb/decode.h"
 #include "upb/structs.int.h"
diff --git a/upb/decode.h b/upb/decode.h
index 224e606..d21b659 100644
--- a/upb/decode.h
+++ b/upb/decode.h
@@ -7,11 +7,15 @@
 
 #include "upb/msg.h"
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 bool upb_decode(const char *buf, size_t size, upb_msg *msg,
                 const upb_msglayout *l);
 
-UPB_END_EXTERN_C
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
 
 #endif  /* UPB_DECODE_H_ */
diff --git a/upb/def.c b/upb/def.c
index 8adf8c1..8d40b8e 100644
--- a/upb/def.c
+++ b/upb/def.c
@@ -2,8 +2,10 @@
 #include "upb/def.h"
 
 #include <ctype.h>
+#include <errno.h>
 #include <stdlib.h>
 #include <string.h>
+#include "google/protobuf/descriptor.upb.h"
 #include "upb/handlers.h"
 
 typedef struct {
@@ -11,8 +13,8 @@ typedef struct {
   char str[1];  /* Null-terminated string data follows. */
 } str_t;
 
-static str_t *newstr(const char *data, size_t len) {
-  str_t *ret = upb_gmalloc(sizeof(*ret) + len);
+static str_t *newstr(upb_alloc *alloc, const char *data, size_t len) {
+  str_t *ret = upb_malloc(alloc, sizeof(*ret) + len);
   if (!ret) return NULL;
   ret->len = len;
   memcpy(ret->str, data, len);
@@ -20,7 +22,113 @@ static str_t *newstr(const char *data, size_t len) {
   return ret;
 }
 
-static void freestr(str_t *s) { upb_gfree(s); }
+struct upb_fielddef {
+  const upb_filedef *file;
+  const upb_msgdef *msgdef;
+  const char *full_name;
+  union {
+    int64_t sint;
+    uint64_t uint;
+    double dbl;
+    float flt;
+    bool boolean;
+    str_t *str;
+  } defaultval;
+  const upb_oneofdef *oneof;
+  union {
+    const upb_msgdef *msgdef;
+    const upb_enumdef *enumdef;
+    const google_protobuf_FieldDescriptorProto *unresolved;
+  } sub;
+  uint32_t number_;
+  uint32_t index_;
+  uint32_t selector_base;  /* Used to index into a upb::Handlers table. */
+  bool is_extension_;
+  bool lazy_;
+  bool packed_;
+  upb_descriptortype_t type_;
+  upb_label_t label_;
+};
+
+struct upb_msgdef {
+  const upb_filedef *file;
+  const char *full_name;
+  uint32_t selector_count;
+  uint32_t submsg_field_count;
+
+  /* Tables for looking up fields by number and name. */
+  upb_inttable itof;
+  upb_strtable ntof;
+
+  const upb_fielddef *fields;
+  const upb_oneofdef *oneofs;
+  int field_count;
+  int oneof_count;
+
+  /* Is this a map-entry message? */
+  bool map_entry;
+  upb_wellknowntype_t well_known_type;
+
+  /* TODO(haberman): proper extension ranges (there can be multiple). */
+};
+
+struct upb_enumdef {
+  const upb_filedef *file;
+  const char *full_name;
+  upb_strtable ntoi;
+  upb_inttable iton;
+  int32_t defaultval;
+};
+
+struct upb_oneofdef {
+  const upb_msgdef *parent;
+  const char *full_name;
+  uint32_t index;
+  upb_strtable ntof;
+  upb_inttable itof;
+};
+
+struct upb_filedef {
+  const char *name;
+  const char *package;
+  const char *phpprefix;
+  const char *phpnamespace;
+  upb_syntax_t syntax;
+
+  const upb_filedef **deps;
+  const upb_msgdef *msgs;
+  const upb_enumdef *enums;
+  const upb_fielddef *exts;
+
+  int dep_count;
+  int msg_count;
+  int enum_count;
+  int ext_count;
+};
+
+struct upb_symtab {
+  upb_arena *arena;
+  upb_strtable syms;  /* full_name -> packed def ptr */
+  upb_strtable files;  /* file_name -> upb_filedef* */
+};
+
+/* Inside a symtab we store tagged pointers to specific def types. */
+typedef enum {
+  UPB_DEFTYPE_MSG = 0,
+  UPB_DEFTYPE_ENUM = 1,
+  UPB_DEFTYPE_FIELD = 2,
+  UPB_DEFTYPE_ONEOF = 3
+} upb_deftype_t;
+
+static const void *unpack_def(upb_value v, upb_deftype_t type) {
+  uintptr_t num = (uintptr_t)upb_value_getconstptr(v);
+  return (num & 3) == type ? (const void*)(num & ~3) : NULL;
+}
+
+static upb_value pack_def(const void *ptr, upb_deftype_t type) {
+  uintptr_t num = (uintptr_t)ptr | type;
+  return upb_value_constptr((const void*)num);
+}
 
 /* isalpha() etc. from <ctype.h> are locale-dependent, which we don't want. */
 static bool upb_isbetween(char c, char low, char high) {
@@ -35,7 +143,9 @@ static bool upb_isalphanum(char c) {
   return upb_isletter(c) || upb_isbetween(c, '0', '9');
 }
 
-static bool upb_isident(const char *str, size_t len, bool full, upb_status *s) {
+static bool upb_isident(upb_strview name, bool full, upb_status *s) {
+  const char *str = name.data;
+  size_t len = name.size;
   bool start = true;
   size_t i;
   for (i = 0; i < len; i++) {
@@ -65,187 +175,20 @@ static bool upb_isident(const char *str, size_t len, bool full, upb_status *s) {
   return !start;
 }
 
-static bool upb_isoneof(const upb_refcounted *def) {
-  return def->vtbl == &upb_oneofdef_vtbl;
-}
-
-static bool upb_isfield(const upb_refcounted *def) {
-  return def->vtbl == &upb_fielddef_vtbl;
-}
-
-static const upb_oneofdef *upb_trygetoneof(const upb_refcounted *def) {
-  return upb_isoneof(def) ? (const upb_oneofdef*)def : NULL;
-}
-
-static const upb_fielddef *upb_trygetfield(const upb_refcounted *def) {
-  return upb_isfield(def) ? (const upb_fielddef*)def : NULL;
-}
-
-
-/* upb_def ********************************************************************/
-
-upb_deftype_t upb_def_type(const upb_def *d) { return d->type; }
-
-const char *upb_def_fullname(const upb_def *d) { return d->fullname; }
-
-const char *upb_def_name(const upb_def *d) {
+static const char *shortdefname(const char *fullname) {
   const char *p;
 
-  if (d->fullname == NULL) {
+  if (fullname == NULL) {
     return NULL;
-  } else if ((p = strrchr(d->fullname, '.')) == NULL) {
+  } else if ((p = strrchr(fullname, '.')) == NULL) {
     /* No '.' in the name, return the full string. */
-    return d->fullname;
+    return fullname;
   } else {
     /* Return one past the last '.'. */
     return p + 1;
   }
 }
 
-bool upb_def_setfullname(upb_def *def, const char *fullname, upb_status *s) {
-  UPB_ASSERT(!upb_def_isfrozen(def));
-  if (!upb_isident(fullname, strlen(fullname), true, s)) {
-    return false;
-  }
-
-  fullname = upb_gstrdup(fullname);
-  if (!fullname) {
-    upb_upberr_setoom(s);
-    return false;
-  }
-
-  upb_gfree((void*)def->fullname);
-  def->fullname = fullname;
-  return true;
-}
-
-const upb_filedef *upb_def_file(const upb_def *d) { return d->file; }
-
-static bool upb_def_init(upb_def *def, upb_deftype_t type,
-                         const struct upb_refcounted_vtbl *vtbl,
-                         const void *owner) {
-  if (!upb_refcounted_init(upb_def_upcast_mutable(def), vtbl, owner)) return false;
-  def->type = type;
-  def->fullname = NULL;
-  def->came_from_user = false;
-  def->file = NULL;
-  return true;
-}
-
-static void upb_def_uninit(upb_def *def) {
-  upb_gfree((void*)def->fullname);
-}
-
-static const char *msgdef_name(const upb_msgdef *m) {
-  const char *name = upb_def_fullname(upb_msgdef_upcast(m));
-  return name ? name : "(anonymous)";
-}
-
-static bool upb_validate_field(upb_fielddef *f, upb_status *s) {
-  if (upb_fielddef_name(f) == NULL || upb_fielddef_number(f) == 0) {
-    upb_status_seterrmsg(s, "fielddef must have name and number set");
-    return false;
-  }
-
-  if (!f->type_is_set_) {
-    upb_status_seterrmsg(s, "fielddef type was not initialized");
-    return false;
-  }
-
-  if (upb_fielddef_lazy(f) &&
-      upb_fielddef_descriptortype(f) != UPB_DESCRIPTOR_TYPE_MESSAGE) {
-    upb_status_seterrmsg(s,
-                         "only length-delimited submessage fields may be lazy");
-    return false;
-  }
-
-  if (upb_fielddef_hassubdef(f)) {
-    const upb_def *subdef;
-
-    if (f->subdef_is_symbolic) {
-      upb_status_seterrf(s, "field '%s.%s' has not been resolved",
-                         msgdef_name(f->msg.def), upb_fielddef_name(f));
-      return false;
-    }
-
-    subdef = upb_fielddef_subdef(f);
-    if (subdef == NULL) {
-      upb_status_seterrf(s, "field %s.%s is missing required subdef",
-                         msgdef_name(f->msg.def), upb_fielddef_name(f));
-      return false;
-    }
-
-    if (!upb_def_isfrozen(subdef) && !subdef->came_from_user) {
-      upb_status_seterrf(s,
-                         "subdef of field %s.%s is not frozen or being frozen",
-                         msgdef_name(f->msg.def), upb_fielddef_name(f));
-      return false;
-    }
-  }
-
-  if (upb_fielddef_type(f) == UPB_TYPE_ENUM) {
-    bool has_default_name = upb_fielddef_enumhasdefaultstr(f);
-    bool has_default_number = upb_fielddef_enumhasdefaultint32(f);
-
-    /* Previously verified by upb_validate_enumdef(). */
-    UPB_ASSERT(upb_enumdef_numvals(upb_fielddef_enumsubdef(f)) > 0);
-
-    /* We've already validated that we have an associated enumdef and that it
-     * has at least one member, so at least one of these should be true.
-     * Because if the user didn't set anything, we'll pick up the enum's
-     * default, but if the user *did* set something we should at least pick up
-     * the one they set (int32 or string). */
-    UPB_ASSERT(has_default_name || has_default_number);
-
-    if (!has_default_name) {
-      upb_status_seterrf(s,
-                         "enum default for field %s.%s (%d) is not in the enum",
-                         msgdef_name(f->msg.def), upb_fielddef_name(f),
-                         upb_fielddef_defaultint32(f));
-      return false;
-    }
-
-    if (!has_default_number) {
-      upb_status_seterrf(s,
-                         "enum default for field %s.%s (%s) is not in the enum",
-                         msgdef_name(f->msg.def), upb_fielddef_name(f),
-                         upb_fielddef_defaultstr(f, NULL));
-      return false;
-    }
-
-    /* Lift the effective numeric default into the field's default slot, in case
-     * we were only getting it "by reference" from the enumdef. */
-    upb_fielddef_setdefaultint32(f, upb_fielddef_defaultint32(f));
-  }
-
-  /* Ensure that MapEntry submessages only appear as repeated fields, not
-   * optional/required (singular) fields. */
-  if (upb_fielddef_type(f) == UPB_TYPE_MESSAGE &&
-      upb_fielddef_msgsubdef(f) != NULL) {
-    const upb_msgdef *subdef = upb_fielddef_msgsubdef(f);
-    if (upb_msgdef_mapentry(subdef) && !upb_fielddef_isseq(f)) {
-      upb_status_seterrf(s,
-                         "Field %s refers to mapentry message but is not "
-                         "a repeated field",
-                         upb_fielddef_name(f) ? upb_fielddef_name(f) :
-                         "(unnamed)");
-      return false;
-    }
-  }
-
-  return true;
-}
-
-static bool upb_validate_enumdef(const upb_enumdef *e, upb_status *s) {
-  if (upb_enumdef_numvals(e) == 0) {
-    upb_status_seterrf(s, "enum %s has no members (must have at least one)",
-                       upb_enumdef_fullname(e));
-    return false;
-  }
-
-  return true;
-}
-
 /* All submessage fields are lower than all other fields.
  * Secondly, fields are increasing in order. */
 uint32_t field_rank(const upb_fielddef *f) {
@@ -281,7 +224,7 @@ static bool assign_msg_indices(upb_msgdef *m, upb_status *s) {
 
   fields = upb_gmalloc(n * sizeof(*fields));
   if (!fields) {
-    upb_upberr_setoom(s);
+    upb_status_setoom(s);
     return false;
   }
 
@@ -290,11 +233,7 @@ static bool assign_msg_indices(upb_msgdef *m, upb_status *s) {
       !upb_msg_field_done(&j);
       upb_msg_field_next(&j), i++) {
     upb_fielddef *f = upb_msg_iter_field(&j);
-    UPB_ASSERT(f->msg.def == m);
-    if (!upb_validate_field(f, s)) {
-      upb_gfree(fields);
-      return false;
-    }
+    UPB_ASSERT(f->msgdef == m);
     if (upb_fielddef_issubmsg(f)) {
       m->submsg_field_count++;
     }
@@ -316,7 +255,7 @@ static bool assign_msg_indices(upb_msgdef *m, upb_status *s) {
   {
     /* Verify that all selectors for the message are distinct. */
 #define TRY(type) \
-    if (upb_handlers_getselector(f, type, &sel)) upb_inttable_insert(&t, sel, v);
+    if (upb_handlers_getselector(f, type, &sel)) { upb_inttable_insert(&t, sel, v); }
 
     upb_inttable t;
     upb_value v;
@@ -356,7 +295,7 @@ static bool assign_msg_indices(upb_msgdef *m, upb_status *s) {
   for(upb_msg_oneof_begin(&k, m), i = 0;
       !upb_msg_oneof_done(&k);
       upb_msg_oneof_next(&k), i++) {
-    upb_oneofdef *o = upb_msg_iter_oneof(&k);
+    upb_oneofdef *o = (upb_oneofdef*)upb_msg_iter_oneof(&k);
     o->index = i;
   }
 
@@ -407,173 +346,19 @@ static void assign_msg_wellknowntype(upb_msgdef *m) {
   }
 }
 
-bool _upb_def_validate(upb_def *const*defs, size_t n, upb_status *s) {
-  size_t i;
-
-  /* First perform validation, in two passes so we can check that we have a
-   * transitive closure without needing to search. */
-  for (i = 0; i < n; i++) {
-    upb_def *def = defs[i];
-    if (upb_def_isfrozen(def)) {
-      /* Could relax this requirement if it's annoying. */
-      upb_status_seterrmsg(s, "def is already frozen");
-      goto err;
-    } else if (def->type == UPB_DEF_FIELD) {
-      upb_status_seterrmsg(s, "standalone fielddefs can not be frozen");
-      goto err;
-    } else {
-      /* Set now to detect transitive closure in the second pass. */
-      def->came_from_user = true;
-
-      if (def->type == UPB_DEF_ENUM &&
-          !upb_validate_enumdef(upb_dyncast_enumdef(def), s)) {
-        goto err;
-      }
-    }
-  }
-
-  /* Second pass of validation.  Also assign selector bases and indexes, and
-   * compact tables. */
-  for (i = 0; i < n; i++) {
-    upb_def *def = defs[i];
-    upb_msgdef *m = upb_dyncast_msgdef_mutable(def);
-    upb_enumdef *e = upb_dyncast_enumdef_mutable(def);
-    if (m) {
-      upb_inttable_compact(&m->itof);
-      if (!assign_msg_indices(m, s)) {
-        goto err;
-      }
-      assign_msg_wellknowntype(m);
-      /* m->well_known_type = UPB_WELLKNOWN_UNSPECIFIED; */
-    } else if (e) {
-      upb_inttable_compact(&e->iton);
-    }
-  }
-
-  return true;
-
-err:
-  for (i = 0; i < n; i++) {
-    upb_def *def = defs[i];
-    def->came_from_user = false;
-  }
-  UPB_ASSERT(!(s && upb_ok(s)));
-  return false;
-}
-
-bool upb_def_freeze(upb_def *const* defs, size_t n, upb_status *s) {
-  /* Def graph contains FieldDefs between each MessageDef, so double the
-   * limit. */
-  const size_t maxdepth = UPB_MAX_MESSAGE_DEPTH * 2;
-
-  if (!_upb_def_validate(defs, n, s)) {
-    return false;
-  }
-
-
-  /* Validation all passed; freeze the objects. */
-  return upb_refcounted_freeze((upb_refcounted *const*)defs, n, s, maxdepth);
-}
-
 
 /* upb_enumdef ****************************************************************/
 
-static void visitenum(const upb_refcounted *r, upb_refcounted_visit *visit,
-                      void *closure) {
-  const upb_enumdef *e = (const upb_enumdef*)r;
-  const upb_def *def = upb_enumdef_upcast(e);
-  if (upb_def_file(def)) {
-    visit(r, upb_filedef_upcast(upb_def_file(def)), closure);
-  }
-}
-
-static void freeenum(upb_refcounted *r) {
-  upb_enumdef *e = (upb_enumdef*)r;
-  upb_inttable_iter i;
-  upb_inttable_begin(&i, &e->iton);
-  for( ; !upb_inttable_done(&i); upb_inttable_next(&i)) {
-    /* To clean up the upb_gstrdup() from upb_enumdef_addval(). */
-    upb_gfree(upb_value_getcstr(upb_inttable_iter_value(&i)));
-  }
-  upb_strtable_uninit(&e->ntoi);
-  upb_inttable_uninit(&e->iton);
-  upb_def_uninit(upb_enumdef_upcast_mutable(e));
-  upb_gfree(e);
-}
-
-const struct upb_refcounted_vtbl upb_enumdef_vtbl = {&visitenum, &freeenum};
-
-upb_enumdef *upb_enumdef_new(const void *owner) {
-  upb_enumdef *e = upb_gmalloc(sizeof(*e));
-  if (!e) return NULL;
-
-  if (!upb_def_init(upb_enumdef_upcast_mutable(e), UPB_DEF_ENUM,
-                    &upb_enumdef_vtbl, owner)) {
-    goto err2;
-  }
-
-  if (!upb_strtable_init(&e->ntoi, UPB_CTYPE_INT32)) goto err2;
-  if (!upb_inttable_init(&e->iton, UPB_CTYPE_CSTR)) goto err1;
-  return e;
-
-err1:
-  upb_strtable_uninit(&e->ntoi);
-err2:
-  upb_gfree(e);
-  return NULL;
-}
-
-bool upb_enumdef_freeze(upb_enumdef *e, upb_status *status) {
-  upb_def *d = upb_enumdef_upcast_mutable(e);
-  return upb_def_freeze(&d, 1, status);
-}
-
 const char *upb_enumdef_fullname(const upb_enumdef *e) {
-  return upb_def_fullname(upb_enumdef_upcast(e));
+  return e->full_name;
 }
 
 const char *upb_enumdef_name(const upb_enumdef *e) {
-  return upb_def_name(upb_enumdef_upcast(e));
+  return shortdefname(e->full_name);
 }
 
-bool upb_enumdef_setfullname(upb_enumdef *e, const char *fullname,
-                             upb_status *s) {
-  return upb_def_setfullname(upb_enumdef_upcast_mutable(e), fullname, s);
-}
-
-bool upb_enumdef_addval(upb_enumdef *e, const char *name, int32_t num,
-                        upb_status *status) {
-  char *name2;
-
-  if (!upb_isident(name, strlen(name), false, status)) {
-    return false;
-  }
-
-  if (upb_enumdef_ntoiz(e, name, NULL)) {
-    upb_status_seterrf(status, "name '%s' is already defined", name);
-    return false;
-  }
-
-  if (!upb_strtable_insert(&e->ntoi, name, upb_value_int32(num))) {
-    upb_status_seterrmsg(status, "out of memory");
-    return false;
-  }
-
-  if (!upb_inttable_lookup(&e->iton, num, NULL)) {
-    name2 = upb_gstrdup(name);
-    if (!name2 || !upb_inttable_insert(&e->iton, num, upb_value_cstr(name2))) {
-      upb_status_seterrmsg(status, "out of memory");
-      upb_strtable_remove(&e->ntoi, name, NULL);
-      return false;
-    }
-  }
-
-  if (upb_enumdef_numvals(e) == 1) {
-    bool ok = upb_enumdef_setdefault(e, num, NULL);
-    UPB_ASSERT(ok);
-  }
-
-  return true;
+const upb_filedef *upb_enumdef_file(const upb_enumdef *e) {
+  return e->file;
 }
 
 int32_t upb_enumdef_default(const upb_enumdef *e) {
@@ -581,16 +366,6 @@ int32_t upb_enumdef_default(const upb_enumdef *e) {
   return e->defaultval;
 }
 
-bool upb_enumdef_setdefault(upb_enumdef *e, int32_t val, upb_status *s) {
-  UPB_ASSERT(!upb_enumdef_isfrozen(e));
-  if (!upb_enumdef_iton(e, val)) {
-    upb_status_seterrf(s, "number '%d' is not in the enum.", val);
-    return false;
-  }
-  e->defaultval = val;
-  return true;
-}
-
 int upb_enumdef_numvals(const upb_enumdef *e) {
   return upb_strtable_count(&e->ntoi);
 }
@@ -630,141 +405,46 @@ int32_t upb_enum_iter_number(upb_enum_iter *iter) {
 
 /* upb_fielddef ***************************************************************/
 
-static void upb_fielddef_init_default(upb_fielddef *f);
-
-static void upb_fielddef_uninit_default(upb_fielddef *f) {
-  if (f->type_is_set_ && f->default_is_string && f->defaultval.bytes)
-    freestr(f->defaultval.bytes);
-}
-
-const char *upb_fielddef_fullname(const upb_fielddef *e) {
-  return upb_def_fullname(upb_fielddef_upcast(e));
-}
-
-static void visitfield(const upb_refcounted *r, upb_refcounted_visit *visit,
-                       void *closure) {
-  const upb_fielddef *f = (const upb_fielddef*)r;
-  const upb_def *def = upb_fielddef_upcast(f);
-  if (upb_fielddef_containingtype(f)) {
-    visit(r, upb_msgdef_upcast2(upb_fielddef_containingtype(f)), closure);
-  }
-  if (upb_fielddef_containingoneof(f)) {
-    visit(r, upb_oneofdef_upcast(upb_fielddef_containingoneof(f)), closure);
-  }
-  if (upb_fielddef_subdef(f)) {
-    visit(r, upb_def_upcast(upb_fielddef_subdef(f)), closure);
-  }
-  if (upb_def_file(def)) {
-    visit(r, upb_filedef_upcast(upb_def_file(def)), closure);
-  }
-}
-
-static void freefield(upb_refcounted *r) {
-  upb_fielddef *f = (upb_fielddef*)r;
-  upb_fielddef_uninit_default(f);
-  if (f->subdef_is_symbolic)
-    upb_gfree(f->sub.name);
-  if (f->msg_is_symbolic)
-    upb_gfree(f->msg.name);
-  upb_def_uninit(upb_fielddef_upcast_mutable(f));
-  upb_gfree(f);
-}
-
-static const char *enumdefaultstr(const upb_fielddef *f) {
-  const upb_enumdef *e;
-  UPB_ASSERT(f->type_is_set_ && f->type_ == UPB_TYPE_ENUM);
-  e = upb_fielddef_enumsubdef(f);
-  if (f->default_is_string && f->defaultval.bytes) {
-    /* Default was explicitly set as a string. */
-    str_t *s = f->defaultval.bytes;
-    return s->str;
-  } else if (e) {
-    if (!f->default_is_string) {
-      /* Default was explicitly set as an integer; look it up in enumdef. */
-      const char *name = upb_enumdef_iton(e, f->defaultval.sint);
-      if (name) {
-        return name;
-      }
-    } else {
-      /* Default is completely unset; pull enumdef default. */
-      if (upb_enumdef_numvals(e) > 0) {
-        const char *name = upb_enumdef_iton(e, upb_enumdef_default(e));
-        UPB_ASSERT(name);
-        return name;
-      }
-    }
-  }
-  return NULL;
-}
-
-static bool enumdefaultint32(const upb_fielddef *f, int32_t *val) {
-  const upb_enumdef *e;
-  UPB_ASSERT(f->type_is_set_ && f->type_ == UPB_TYPE_ENUM);
-  e = upb_fielddef_enumsubdef(f);
-  if (!f->default_is_string) {
-    /* Default was explicitly set as an integer. */
-    *val = f->defaultval.sint;
-    return true;
-  } else if (e) {
-    if (f->defaultval.bytes) {
-      /* Default was explicitly set as a str; try to lookup corresponding int. */
-      str_t *s = f->defaultval.bytes;
-      if (upb_enumdef_ntoiz(e, s->str, val)) {
-        return true;
-      }
-    } else {
-      /* Default is unset; try to pull in enumdef default. */
-      if (upb_enumdef_numvals(e) > 0) {
-        *val = upb_enumdef_default(e);
-        return true;
-      }
-    }
-  }
-  return false;
+const char *upb_fielddef_fullname(const upb_fielddef *f) {
+  return f->full_name;
 }
 
-const struct upb_refcounted_vtbl upb_fielddef_vtbl = {visitfield, freefield};
-
-upb_fielddef *upb_fielddef_new(const void *o) {
-  upb_fielddef *f = upb_gmalloc(sizeof(*f));
-  if (!f) return NULL;
-  if (!upb_def_init(upb_fielddef_upcast_mutable(f), UPB_DEF_FIELD,
-                    &upb_fielddef_vtbl, o)) {
-    upb_gfree(f);
-    return NULL;
+upb_fieldtype_t upb_fielddef_type(const upb_fielddef *f) {
+  switch (f->type_) {
+    case UPB_DESCRIPTOR_TYPE_DOUBLE:
+      return UPB_TYPE_DOUBLE;
+    case UPB_DESCRIPTOR_TYPE_FLOAT:
+      return UPB_TYPE_FLOAT;
+    case UPB_DESCRIPTOR_TYPE_INT64:
+    case UPB_DESCRIPTOR_TYPE_SINT64:
+    case UPB_DESCRIPTOR_TYPE_SFIXED64:
+      return UPB_TYPE_INT64;
+    case UPB_DESCRIPTOR_TYPE_INT32:
+    case UPB_DESCRIPTOR_TYPE_SFIXED32:
+    case UPB_DESCRIPTOR_TYPE_SINT32:
+      return UPB_TYPE_INT32;
+    case UPB_DESCRIPTOR_TYPE_UINT64:
+    case UPB_DESCRIPTOR_TYPE_FIXED64:
+      return UPB_TYPE_UINT64;
+    case UPB_DESCRIPTOR_TYPE_UINT32:
+    case UPB_DESCRIPTOR_TYPE_FIXED32:
+      return UPB_TYPE_UINT32;
+    case UPB_DESCRIPTOR_TYPE_ENUM:
+      return UPB_TYPE_ENUM;
+    case UPB_DESCRIPTOR_TYPE_BOOL:
+      return UPB_TYPE_BOOL;
+    case UPB_DESCRIPTOR_TYPE_STRING:
+      return UPB_TYPE_STRING;
+    case UPB_DESCRIPTOR_TYPE_BYTES:
+      return UPB_TYPE_BYTES;
+    case UPB_DESCRIPTOR_TYPE_GROUP:
+    case UPB_DESCRIPTOR_TYPE_MESSAGE:
+      return UPB_TYPE_MESSAGE;
   }
-  f->msg.def = NULL;
-  f->sub.def = NULL;
-  f->oneof = NULL;
-  f->subdef_is_symbolic = false;
-  f->msg_is_symbolic = false;
-  f->label_ = UPB_LABEL_OPTIONAL;
-  f->type_ = UPB_TYPE_INT32;
-  f->number_ = 0;
-  f->type_is_set_ = false;
-  f->tagdelim = false;
-  f->is_extension_ = false;
-  f->lazy_ = false;
-  f->packed_ = true;
-
-  /* For the moment we default this to UPB_INTFMT_VARIABLE, since it will work
-   * with all integer types and is in some since more "default" since the most
-   * normal-looking proto2 types int32/int64/uint32/uint64 use variable.
-   *
-   * Other options to consider:
-   * - there is no default; users must set this manually (like type).
-   * - default signed integers to UPB_INTFMT_ZIGZAG, since it's more likely to
-   *   be an optimal default for signed integers. */
-  f->intfmt = UPB_INTFMT_VARIABLE;
-  return f;
-}
-
-bool upb_fielddef_typeisset(const upb_fielddef *f) {
-  return f->type_is_set_;
+  UPB_UNREACHABLE();
 }
 
-upb_fieldtype_t upb_fielddef_type(const upb_fielddef *f) {
-  UPB_ASSERT(f->type_is_set_);
+upb_descriptortype_t upb_fielddef_descriptortype(const upb_fielddef *f) {
   return f->type_;
 }
 
@@ -776,14 +456,6 @@ upb_label_t upb_fielddef_label(const upb_fielddef *f) {
   return f->label_;
 }
 
-upb_intfmt_t upb_fielddef_intfmt(const upb_fielddef *f) {
-  return f->intfmt;
-}
-
-bool upb_fielddef_istagdelim(const upb_fielddef *f) {
-  return f->tagdelim;
-}
-
 uint32_t upb_fielddef_number(const upb_fielddef *f) {
   return f->number_;
 }
@@ -801,7 +473,11 @@ bool upb_fielddef_packed(const upb_fielddef *f) {
 }
 
 const char *upb_fielddef_name(const upb_fielddef *f) {
-  return upb_def_fullname(upb_fielddef_upcast(f));
+  return shortdefname(f->full_name);
+}
+
+uint32_t upb_fielddef_selectorbase(const upb_fielddef *f) {
+  return f->selector_base;
 }
 
 size_t upb_fielddef_getjsonname(const upb_fielddef *f, char *buf, size_t len) {
@@ -844,60 +520,16 @@ size_t upb_fielddef_getjsonname(const upb_fielddef *f, char *buf, size_t len) {
 }
 
 const upb_msgdef *upb_fielddef_containingtype(const upb_fielddef *f) {
-  return f->msg_is_symbolic ? NULL : f->msg.def;
+  return f->msgdef;
 }
 
 const upb_oneofdef *upb_fielddef_containingoneof(const upb_fielddef *f) {
   return f->oneof;
 }
 
-upb_msgdef *upb_fielddef_containingtype_mutable(upb_fielddef *f) {
-  return (upb_msgdef*)upb_fielddef_containingtype(f);
-}
-
-const char *upb_fielddef_containingtypename(upb_fielddef *f) {
-  return f->msg_is_symbolic ? f->msg.name : NULL;
-}
-
-static void release_containingtype(upb_fielddef *f) {
-  if (f->msg_is_symbolic) upb_gfree(f->msg.name);
-}
-
-bool upb_fielddef_setcontainingtypename(upb_fielddef *f, const char *name,
-                                        upb_status *s) {
-  char *name_copy;
-  UPB_ASSERT(!upb_fielddef_isfrozen(f));
-  if (upb_fielddef_containingtype(f)) {
-    upb_status_seterrmsg(s, "field has already been added to a message.");
-    return false;
-  }
-  /* TODO: validate name (upb_isident() doesn't quite work atm because this name
-   * may have a leading "."). */
-
-  name_copy = upb_gstrdup(name);
-  if (!name_copy) {
-    upb_upberr_setoom(s);
-    return false;
-  }
-
-  release_containingtype(f);
-  f->msg.name = name_copy;
-  f->msg_is_symbolic = true;
-  return true;
-}
-
-bool upb_fielddef_setname(upb_fielddef *f, const char *name, upb_status *s) {
-  if (upb_fielddef_containingtype(f) || upb_fielddef_containingoneof(f)) {
-    upb_status_seterrmsg(s, "Already added to message or oneof");
-    return false;
-  }
-  return upb_def_setfullname(upb_fielddef_upcast_mutable(f), name, s);
-}
-
-static void chkdefaulttype(const upb_fielddef *f, upb_fieldtype_t type) {
+static void chkdefaulttype(const upb_fielddef *f, int ctype) {
   UPB_UNUSED(f);
-  UPB_UNUSED(type);
-  UPB_ASSERT(f->type_is_set_ && upb_fielddef_type(f) == type);
+  UPB_UNUSED(ctype);
 }
 
 int64_t upb_fielddef_defaultint64(const upb_fielddef *f) {
@@ -906,15 +538,8 @@ int64_t upb_fielddef_defaultint64(const upb_fielddef *f) {
 }
 
 int32_t upb_fielddef_defaultint32(const upb_fielddef *f) {
-  if (f->type_is_set_ && upb_fielddef_type(f) == UPB_TYPE_ENUM) {
-    int32_t val;
-    bool ok = enumdefaultint32(f, &val);
-    UPB_ASSERT(ok);
-    return val;
-  } else {
-    chkdefaulttype(f, UPB_TYPE_INT32);
-    return f->defaultval.sint;
-  }
+  chkdefaulttype(f, UPB_TYPE_INT32);
+  return f->defaultval.sint;
 }
 
 uint64_t upb_fielddef_defaultuint64(const upb_fielddef *f) {
@@ -929,7 +554,7 @@ uint32_t upb_fielddef_defaultuint32(const upb_fielddef *f) {
 
 bool upb_fielddef_defaultbool(const upb_fielddef *f) {
   chkdefaulttype(f, UPB_TYPE_BOOL);
-  return f->defaultval.uint;
+  return f->defaultval.boolean;
 }
 
 float upb_fielddef_defaultfloat(const upb_fielddef *f) {
@@ -943,394 +568,27 @@ double upb_fielddef_defaultdouble(const upb_fielddef *f) {
 }
 
 const char *upb_fielddef_defaultstr(const upb_fielddef *f, size_t *len) {
-  UPB_ASSERT(f->type_is_set_);
+  str_t *str = f->defaultval.str;
   UPB_ASSERT(upb_fielddef_type(f) == UPB_TYPE_STRING ||
          upb_fielddef_type(f) == UPB_TYPE_BYTES ||
          upb_fielddef_type(f) == UPB_TYPE_ENUM);
-
-  if (upb_fielddef_type(f) == UPB_TYPE_ENUM) {
-    const char *ret = enumdefaultstr(f);
-    UPB_ASSERT(ret);
-    /* Enum defaults can't have embedded NULLs. */
-    if (len) *len = strlen(ret);
-    return ret;
-  }
-
-  if (f->default_is_string) {
-    str_t *str = f->defaultval.bytes;
+  if (str) {
     if (len) *len = str->len;
     return str->str;
-  }
-
-  return NULL;
-}
-
-static void upb_fielddef_init_default(upb_fielddef *f) {
-  f->default_is_string = false;
-  switch (upb_fielddef_type(f)) {
-    case UPB_TYPE_DOUBLE: f->defaultval.dbl = 0; break;
-    case UPB_TYPE_FLOAT: f->defaultval.flt = 0; break;
-    case UPB_TYPE_INT32:
-    case UPB_TYPE_INT64: f->defaultval.sint = 0; break;
-    case UPB_TYPE_UINT64:
-    case UPB_TYPE_UINT32:
-    case UPB_TYPE_BOOL: f->defaultval.uint = 0; break;
-    case UPB_TYPE_STRING:
-    case UPB_TYPE_BYTES:
-      f->defaultval.bytes = newstr("", 0);
-      f->default_is_string = true;
-      break;
-    case UPB_TYPE_MESSAGE: break;
-    case UPB_TYPE_ENUM:
-      /* This is our special sentinel that indicates "not set" for an enum. */
-      f->default_is_string = true;
-      f->defaultval.bytes = NULL;
-      break;
-  }
-}
-
-const upb_def *upb_fielddef_subdef(const upb_fielddef *f) {
-  return f->subdef_is_symbolic ? NULL : f->sub.def;
-}
-
-const upb_msgdef *upb_fielddef_msgsubdef(const upb_fielddef *f) {
-  const upb_def *def = upb_fielddef_subdef(f);
-  return def ? upb_dyncast_msgdef(def) : NULL;
-}
-
-const upb_enumdef *upb_fielddef_enumsubdef(const upb_fielddef *f) {
-  const upb_def *def = upb_fielddef_subdef(f);
-  return def ? upb_dyncast_enumdef(def) : NULL;
-}
-
-upb_def *upb_fielddef_subdef_mutable(upb_fielddef *f) {
-  return (upb_def*)upb_fielddef_subdef(f);
-}
-
-const char *upb_fielddef_subdefname(const upb_fielddef *f) {
-  if (f->subdef_is_symbolic) {
-    return f->sub.name;
-  } else if (f->sub.def) {
-    return upb_def_fullname(f->sub.def);
   } else {
+    if (len) *len = 0;
     return NULL;
   }
 }
 
-bool upb_fielddef_setnumber(upb_fielddef *f, uint32_t number, upb_status *s) {
-  if (upb_fielddef_containingtype(f)) {
-    upb_status_seterrmsg(
-        s, "cannot change field number after adding to a message");
-    return false;
-  }
-  if (number == 0) {
-    upb_status_seterrf(s, "invalid field number (%u)", number);
-    return false;
-  }
-  f->number_ = number;
-  return true;
-}
-
-void upb_fielddef_settype(upb_fielddef *f, upb_fieldtype_t type) {
-  UPB_ASSERT(!upb_fielddef_isfrozen(f));
-  UPB_ASSERT(upb_fielddef_checktype(type));
-  upb_fielddef_uninit_default(f);
-  f->type_ = type;
-  f->type_is_set_ = true;
-  upb_fielddef_init_default(f);
-}
-
-void upb_fielddef_setdescriptortype(upb_fielddef *f, int type) {
-  UPB_ASSERT(!upb_fielddef_isfrozen(f));
-  switch (type) {
-    case UPB_DESCRIPTOR_TYPE_DOUBLE:
-      upb_fielddef_settype(f, UPB_TYPE_DOUBLE);
-      break;
-    case UPB_DESCRIPTOR_TYPE_FLOAT:
-      upb_fielddef_settype(f, UPB_TYPE_FLOAT);
-      break;
-    case UPB_DESCRIPTOR_TYPE_INT64:
-    case UPB_DESCRIPTOR_TYPE_SFIXED64:
-    case UPB_DESCRIPTOR_TYPE_SINT64:
-      upb_fielddef_settype(f, UPB_TYPE_INT64);
-      break;
-    case UPB_DESCRIPTOR_TYPE_UINT64:
-    case UPB_DESCRIPTOR_TYPE_FIXED64:
-      upb_fielddef_settype(f, UPB_TYPE_UINT64);
-      break;
-    case UPB_DESCRIPTOR_TYPE_INT32:
-    case UPB_DESCRIPTOR_TYPE_SFIXED32:
-    case UPB_DESCRIPTOR_TYPE_SINT32:
-      upb_fielddef_settype(f, UPB_TYPE_INT32);
-      break;
-    case UPB_DESCRIPTOR_TYPE_UINT32:
-    case UPB_DESCRIPTOR_TYPE_FIXED32:
-      upb_fielddef_settype(f, UPB_TYPE_UINT32);
-      break;
-    case UPB_DESCRIPTOR_TYPE_BOOL:
-      upb_fielddef_settype(f, UPB_TYPE_BOOL);
-      break;
-    case UPB_DESCRIPTOR_TYPE_STRING:
-      upb_fielddef_settype(f, UPB_TYPE_STRING);
-      break;
-    case UPB_DESCRIPTOR_TYPE_BYTES:
-      upb_fielddef_settype(f, UPB_TYPE_BYTES);
-      break;
-    case UPB_DESCRIPTOR_TYPE_GROUP:
-    case UPB_DESCRIPTOR_TYPE_MESSAGE:
-      upb_fielddef_settype(f, UPB_TYPE_MESSAGE);
-      break;
-    case UPB_DESCRIPTOR_TYPE_ENUM:
-      upb_fielddef_settype(f, UPB_TYPE_ENUM);
-      break;
-    default: UPB_ASSERT(false);
-  }
-
-  if (type == UPB_DESCRIPTOR_TYPE_FIXED64 ||
-      type == UPB_DESCRIPTOR_TYPE_FIXED32 ||
-      type == UPB_DESCRIPTOR_TYPE_SFIXED64 ||
-      type == UPB_DESCRIPTOR_TYPE_SFIXED32) {
-    upb_fielddef_setintfmt(f, UPB_INTFMT_FIXED);
-  } else if (type == UPB_DESCRIPTOR_TYPE_SINT64 ||
-             type == UPB_DESCRIPTOR_TYPE_SINT32) {
-    upb_fielddef_setintfmt(f, UPB_INTFMT_ZIGZAG);
-  } else {
-    upb_fielddef_setintfmt(f, UPB_INTFMT_VARIABLE);
-  }
-
-  upb_fielddef_settagdelim(f, type == UPB_DESCRIPTOR_TYPE_GROUP);
-}
-
-upb_descriptortype_t upb_fielddef_descriptortype(const upb_fielddef *f) {
-  switch (upb_fielddef_type(f)) {
-    case UPB_TYPE_FLOAT:  return UPB_DESCRIPTOR_TYPE_FLOAT;
-    case UPB_TYPE_DOUBLE: return UPB_DESCRIPTOR_TYPE_DOUBLE;
-    case UPB_TYPE_BOOL:   return UPB_DESCRIPTOR_TYPE_BOOL;
-    case UPB_TYPE_STRING: return UPB_DESCRIPTOR_TYPE_STRING;
-    case UPB_TYPE_BYTES:  return UPB_DESCRIPTOR_TYPE_BYTES;
-    case UPB_TYPE_ENUM:   return UPB_DESCRIPTOR_TYPE_ENUM;
-    case UPB_TYPE_INT32:
-      switch (upb_fielddef_intfmt(f)) {
-        case UPB_INTFMT_VARIABLE: return UPB_DESCRIPTOR_TYPE_INT32;
-        case UPB_INTFMT_FIXED:    return UPB_DESCRIPTOR_TYPE_SFIXED32;
-        case UPB_INTFMT_ZIGZAG:   return UPB_DESCRIPTOR_TYPE_SINT32;
-      }
-    case UPB_TYPE_INT64:
-      switch (upb_fielddef_intfmt(f)) {
-        case UPB_INTFMT_VARIABLE: return UPB_DESCRIPTOR_TYPE_INT64;
-        case UPB_INTFMT_FIXED:    return UPB_DESCRIPTOR_TYPE_SFIXED64;
-        case UPB_INTFMT_ZIGZAG:   return UPB_DESCRIPTOR_TYPE_SINT64;
-      }
-    case UPB_TYPE_UINT32:
-      switch (upb_fielddef_intfmt(f)) {
-        case UPB_INTFMT_VARIABLE: return UPB_DESCRIPTOR_TYPE_UINT32;
-        case UPB_INTFMT_FIXED:    return UPB_DESCRIPTOR_TYPE_FIXED32;
-        case UPB_INTFMT_ZIGZAG:   return -1;
-      }
-    case UPB_TYPE_UINT64:
-      switch (upb_fielddef_intfmt(f)) {
-        case UPB_INTFMT_VARIABLE: return UPB_DESCRIPTOR_TYPE_UINT64;
-        case UPB_INTFMT_FIXED:    return UPB_DESCRIPTOR_TYPE_FIXED64;
-        case UPB_INTFMT_ZIGZAG:   return -1;
-      }
-    case UPB_TYPE_MESSAGE:
-      return upb_fielddef_istagdelim(f) ?
-          UPB_DESCRIPTOR_TYPE_GROUP : UPB_DESCRIPTOR_TYPE_MESSAGE;
-  }
-  return 0;
-}
-
-void upb_fielddef_setisextension(upb_fielddef *f, bool is_extension) {
-  UPB_ASSERT(!upb_fielddef_isfrozen(f));
-  f->is_extension_ = is_extension;
-}
-
-void upb_fielddef_setlazy(upb_fielddef *f, bool lazy) {
-  UPB_ASSERT(!upb_fielddef_isfrozen(f));
-  f->lazy_ = lazy;
-}
-
-void upb_fielddef_setpacked(upb_fielddef *f, bool packed) {
-  UPB_ASSERT(!upb_fielddef_isfrozen(f));
-  f->packed_ = packed;
-}
-
-void upb_fielddef_setlabel(upb_fielddef *f, upb_label_t label) {
-  UPB_ASSERT(!upb_fielddef_isfrozen(f));
-  UPB_ASSERT(upb_fielddef_checklabel(label));
-  f->label_ = label;
-}
-
-void upb_fielddef_setintfmt(upb_fielddef *f, upb_intfmt_t fmt) {
-  UPB_ASSERT(!upb_fielddef_isfrozen(f));
-  UPB_ASSERT(upb_fielddef_checkintfmt(fmt));
-  f->intfmt = fmt;
-}
-
-void upb_fielddef_settagdelim(upb_fielddef *f, bool tag_delim) {
-  UPB_ASSERT(!upb_fielddef_isfrozen(f));
-  f->tagdelim = tag_delim;
-  f->tagdelim = tag_delim;
-}
-
-static bool checksetdefault(upb_fielddef *f, upb_fieldtype_t type) {
-  if (!f->type_is_set_ || upb_fielddef_isfrozen(f) ||
-      upb_fielddef_type(f) != type) {
-    UPB_ASSERT(false);
-    return false;
-  }
-  if (f->default_is_string) {
-    str_t *s = f->defaultval.bytes;
-    UPB_ASSERT(s || type == UPB_TYPE_ENUM);
-    if (s) freestr(s);
-  }
-  f->default_is_string = false;
-  return true;
-}
-
-void upb_fielddef_setdefaultint64(upb_fielddef *f, int64_t value) {
-  if (checksetdefault(f, UPB_TYPE_INT64))
-    f->defaultval.sint = value;
-}
-
-void upb_fielddef_setdefaultint32(upb_fielddef *f, int32_t value) {
-  if ((upb_fielddef_type(f) == UPB_TYPE_ENUM &&
-       checksetdefault(f, UPB_TYPE_ENUM)) ||
-      checksetdefault(f, UPB_TYPE_INT32)) {
-    f->defaultval.sint = value;
-  }
-}
-
-void upb_fielddef_setdefaultuint64(upb_fielddef *f, uint64_t value) {
-  if (checksetdefault(f, UPB_TYPE_UINT64))
-    f->defaultval.uint = value;
-}
-
-void upb_fielddef_setdefaultuint32(upb_fielddef *f, uint32_t value) {
-  if (checksetdefault(f, UPB_TYPE_UINT32))
-    f->defaultval.uint = value;
-}
-
-void upb_fielddef_setdefaultbool(upb_fielddef *f, bool value) {
-  if (checksetdefault(f, UPB_TYPE_BOOL))
-    f->defaultval.uint = value;
-}
-
-void upb_fielddef_setdefaultfloat(upb_fielddef *f, float value) {
-  if (checksetdefault(f, UPB_TYPE_FLOAT))
-    f->defaultval.flt = value;
-}
-
-void upb_fielddef_setdefaultdouble(upb_fielddef *f, double value) {
-  if (checksetdefault(f, UPB_TYPE_DOUBLE))
-    f->defaultval.dbl = value;
-}
-
-bool upb_fielddef_setdefaultstr(upb_fielddef *f, const void *str, size_t len,
-                                upb_status *s) {
-  str_t *str2;
-  UPB_ASSERT(upb_fielddef_isstring(f) || f->type_ == UPB_TYPE_ENUM);
-  if (f->type_ == UPB_TYPE_ENUM && !upb_isident(str, len, false, s))
-    return false;
-
-  if (f->default_is_string) {
-    str_t *s = f->defaultval.bytes;
-    UPB_ASSERT(s || f->type_ == UPB_TYPE_ENUM);
-    if (s) freestr(s);
-  } else {
-    UPB_ASSERT(f->type_ == UPB_TYPE_ENUM);
-  }
-
-  str2 = newstr(str, len);
-  f->defaultval.bytes = str2;
-  f->default_is_string = true;
-  return true;
-}
-
-void upb_fielddef_setdefaultcstr(upb_fielddef *f, const char *str,
-                                 upb_status *s) {
-  UPB_ASSERT(f->type_is_set_);
-  upb_fielddef_setdefaultstr(f, str, str ? strlen(str) : 0, s);
-}
-
-bool upb_fielddef_enumhasdefaultint32(const upb_fielddef *f) {
-  int32_t val;
-  UPB_ASSERT(f->type_is_set_ && f->type_ == UPB_TYPE_ENUM);
-  return enumdefaultint32(f, &val);
-}
-
-bool upb_fielddef_enumhasdefaultstr(const upb_fielddef *f) {
-  UPB_ASSERT(f->type_is_set_ && f->type_ == UPB_TYPE_ENUM);
-  return enumdefaultstr(f) != NULL;
-}
-
-static bool upb_subdef_typecheck(upb_fielddef *f, const upb_def *subdef,
-                                 upb_status *s) {
-  if (f->type_ == UPB_TYPE_MESSAGE) {
-    if (upb_dyncast_msgdef(subdef)) return true;
-    upb_status_seterrmsg(s, "invalid subdef type for this submessage field");
-    return false;
-  } else if (f->type_ == UPB_TYPE_ENUM) {
-    if (upb_dyncast_enumdef(subdef)) return true;
-    upb_status_seterrmsg(s, "invalid subdef type for this enum field");
-    return false;
-  } else {
-    upb_status_seterrmsg(s, "only message and enum fields can have a subdef");
-    return false;
-  }
-}
-
-static void release_subdef(upb_fielddef *f) {
-  if (f->subdef_is_symbolic) {
-    upb_gfree(f->sub.name);
-  } else if (f->sub.def) {
-    upb_unref2(f->sub.def, f);
-  }
-}
-
-bool upb_fielddef_setsubdef(upb_fielddef *f, const upb_def *subdef,
-                            upb_status *s) {
-  UPB_ASSERT(!upb_fielddef_isfrozen(f));
-  UPB_ASSERT(upb_fielddef_hassubdef(f));
-  if (subdef && !upb_subdef_typecheck(f, subdef, s)) return false;
-  release_subdef(f);
-  f->sub.def = subdef;
-  f->subdef_is_symbolic = false;
-  if (f->sub.def) upb_ref2(f->sub.def, f);
-  return true;
-}
-
-bool upb_fielddef_setmsgsubdef(upb_fielddef *f, const upb_msgdef *subdef,
-                               upb_status *s) {
-  return upb_fielddef_setsubdef(f, upb_msgdef_upcast(subdef), s);
-}
-
-bool upb_fielddef_setenumsubdef(upb_fielddef *f, const upb_enumdef *subdef,
-                                upb_status *s) {
-  return upb_fielddef_setsubdef(f, upb_enumdef_upcast(subdef), s);
+const upb_msgdef *upb_fielddef_msgsubdef(const upb_fielddef *f) {
+  UPB_ASSERT(upb_fielddef_type(f) == UPB_TYPE_MESSAGE);
+  return f->sub.msgdef;
 }
 
-bool upb_fielddef_setsubdefname(upb_fielddef *f, const char *name,
-                                upb_status *s) {
-  char *name_copy;
-  UPB_ASSERT(!upb_fielddef_isfrozen(f));
-  if (!upb_fielddef_hassubdef(f)) {
-    upb_status_seterrmsg(s, "field type does not accept a subdef");
-    return false;
-  }
-
-  name_copy = upb_gstrdup(name);
-  if (!name_copy) {
-    upb_upberr_setoom(s);
-    return false;
-  }
-
-  /* TODO: validate name (upb_isident() doesn't quite work atm because this name
-   * may have a leading "."). */
-  release_subdef(f);
-  f->sub.name = name_copy;
-  f->subdef_is_symbolic = true;
-  return true;
+const upb_enumdef *upb_fielddef_enumsubdef(const upb_fielddef *f) {
+  UPB_ASSERT(upb_fielddef_type(f) == UPB_TYPE_ENUM);
+  return f->sub.enumdef;
 }
 
 bool upb_fielddef_issubmsg(const upb_fielddef *f) {
@@ -1355,18 +613,14 @@ bool upb_fielddef_ismap(const upb_fielddef *f) {
          upb_msgdef_mapentry(upb_fielddef_msgsubdef(f));
 }
 
+bool upb_fielddef_hassubdef(const upb_fielddef *f) {
+  return upb_fielddef_issubmsg(f) || upb_fielddef_type(f) == UPB_TYPE_ENUM;
+}
+
 bool upb_fielddef_haspresence(const upb_fielddef *f) {
   if (upb_fielddef_isseq(f)) return false;
   if (upb_fielddef_issubmsg(f)) return true;
-
-  /* Primitive field: return true unless there is a message that specifies
-   * presence should not exist. */
-  if (f->msg_is_symbolic || !f->msg.def) return true;
-  return f->msg.def->syntax == UPB_SYNTAX_PROTO2;
-}
-
-bool upb_fielddef_hassubdef(const upb_fielddef *f) {
-  return upb_fielddef_issubmsg(f) || upb_fielddef_type(f) == UPB_TYPE_ENUM;
+  return f->file->syntax == UPB_SYNTAX_PROTO2;
 }
 
 static bool between(int32_t x, int32_t low, int32_t high) {
@@ -1383,205 +637,34 @@ bool upb_fielddef_checkdescriptortype(int32_t type) {
 
 /* upb_msgdef *****************************************************************/
 
-static void visitmsg(const upb_refcounted *r, upb_refcounted_visit *visit,
-                     void *closure) {
-  upb_msg_oneof_iter o;
-  const upb_msgdef *m = (const upb_msgdef*)r;
-  const upb_def *def = upb_msgdef_upcast(m);
-  upb_msg_field_iter i;
-  for(upb_msg_field_begin(&i, m);
-      !upb_msg_field_done(&i);
-      upb_msg_field_next(&i)) {
-    upb_fielddef *f = upb_msg_iter_field(&i);
-    visit(r, upb_fielddef_upcast2(f), closure);
-  }
-  for(upb_msg_oneof_begin(&o, m);
-      !upb_msg_oneof_done(&o);
-      upb_msg_oneof_next(&o)) {
-    upb_oneofdef *f = upb_msg_iter_oneof(&o);
-    visit(r, upb_oneofdef_upcast(f), closure);
-  }
-  if (upb_def_file(def)) {
-    visit(r, upb_filedef_upcast(upb_def_file(def)), closure);
-  }
-}
-
-static void freemsg(upb_refcounted *r) {
-  upb_msgdef *m = (upb_msgdef*)r;
-  upb_strtable_uninit(&m->ntof);
-  upb_inttable_uninit(&m->itof);
-  upb_def_uninit(upb_msgdef_upcast_mutable(m));
-  upb_gfree(m);
-}
-
-const struct upb_refcounted_vtbl upb_msgdef_vtbl = {visitmsg, freemsg};
-
-upb_msgdef *upb_msgdef_new(const void *owner) {
-  upb_msgdef *m = upb_gmalloc(sizeof(*m));
-  if (!m) return NULL;
-
-  if (!upb_def_init(upb_msgdef_upcast_mutable(m), UPB_DEF_MSG, &upb_msgdef_vtbl,
-                    owner)) {
-    goto err2;
-  }
-
-  if (!upb_inttable_init(&m->itof, UPB_CTYPE_PTR)) goto err2;
-  if (!upb_strtable_init(&m->ntof, UPB_CTYPE_PTR)) goto err1;
-  m->map_entry = false;
-  m->syntax = UPB_SYNTAX_PROTO2;
-  return m;
-
-err1:
-  upb_inttable_uninit(&m->itof);
-err2:
-  upb_gfree(m);
-  return NULL;
-}
-
-bool upb_msgdef_freeze(upb_msgdef *m, upb_status *status) {
-  upb_def *d = upb_msgdef_upcast_mutable(m);
-  return upb_def_freeze(&d, 1, status);
-}
-
 const char *upb_msgdef_fullname(const upb_msgdef *m) {
-  return upb_def_fullname(upb_msgdef_upcast(m));
-}
-
-const char *upb_msgdef_name(const upb_msgdef *m) {
-  return upb_def_name(upb_msgdef_upcast(m));
+  return m->full_name;
 }
 
-bool upb_msgdef_setfullname(upb_msgdef *m, const char *fullname,
-                            upb_status *s) {
-  return upb_def_setfullname(upb_msgdef_upcast_mutable(m), fullname, s);
+const upb_filedef *upb_msgdef_file(const upb_msgdef *m) {
+  return m->file;
 }
 
-bool upb_msgdef_setsyntax(upb_msgdef *m, upb_syntax_t syntax) {
-  if (syntax != UPB_SYNTAX_PROTO2 && syntax != UPB_SYNTAX_PROTO3) {
-    return false;
-  }
-
-  m->syntax = syntax;
-  return true;
+const char *upb_msgdef_name(const upb_msgdef *m) {
+  return shortdefname(m->full_name);
 }
 
 upb_syntax_t upb_msgdef_syntax(const upb_msgdef *m) {
-  return m->syntax;
-}
-
-/* Helper: check that the field |f| is safe to add to msgdef |m|. Set an error
- * on status |s| and return false if not. */
-static bool check_field_add(const upb_msgdef *m, const upb_fielddef *f,
-                            upb_status *s) {
-  if (upb_fielddef_containingtype(f) != NULL) {
-    upb_status_seterrmsg(s, "fielddef already belongs to a message");
-    return false;
-  } else if (upb_fielddef_name(f) == NULL || upb_fielddef_number(f) == 0) {
-    upb_status_seterrmsg(s, "field name or number were not set");
-    return false;
-  } else if (upb_msgdef_itof(m, upb_fielddef_number(f))) {
-    upb_status_seterrmsg(s, "duplicate field number");
-    return false;
-  } else if (upb_strtable_lookup(&m->ntof, upb_fielddef_name(f), NULL)) {
-    upb_status_seterrmsg(s, "name conflicts with existing field or oneof");
-    return false;
-  }
-  return true;
+  return m->file->syntax;
 }
 
-static void add_field(upb_msgdef *m, upb_fielddef *f, const void *ref_donor) {
-  release_containingtype(f);
-  f->msg.def = m;
-  f->msg_is_symbolic = false;
-  upb_inttable_insert(&m->itof, upb_fielddef_number(f), upb_value_ptr(f));
-  upb_strtable_insert(&m->ntof, upb_fielddef_name(f), upb_value_ptr(f));
-  upb_ref2(f, m);
-  upb_ref2(m, f);
-  if (ref_donor) upb_fielddef_unref(f, ref_donor);
-}
-
-bool upb_msgdef_addfield(upb_msgdef *m, upb_fielddef *f, const void *ref_donor,
-                         upb_status *s) {
-  /* TODO: extensions need to have a separate namespace, because proto2 allows a
-   * top-level extension (ie. one not in any package) to have the same name as a
-   * field from the message.
-   *
-   * This also implies that there needs to be a separate lookup-by-name method
-   * for extensions.  It seems desirable for iteration to return both extensions
-   * and non-extensions though.
-   *
-   * We also need to validate that the field number is in an extension range iff
-   * it is an extension.
-   *
-   * This method is idempotent. Check if |f| is already part of this msgdef and
-   * return immediately if so. */
-  if (upb_fielddef_containingtype(f) == m) {
-    if (ref_donor) upb_fielddef_unref(f, ref_donor);
-    return true;
-  }
-
-  /* Check constraints for all fields before performing any action. */
-  if (!check_field_add(m, f, s)) {
-    return false;
-  } else if (upb_fielddef_containingoneof(f) != NULL) {
-    /* Fields in a oneof can only be added by adding the oneof to the msgdef. */
-    upb_status_seterrmsg(s, "fielddef is part of a oneof");
-    return false;
-  }
-
-  /* Constraint checks ok, perform the action. */
-  add_field(m, f, ref_donor);
-  return true;
+size_t upb_msgdef_selectorcount(const upb_msgdef *m) {
+  return m->selector_count;
 }
 
-bool upb_msgdef_addoneof(upb_msgdef *m, upb_oneofdef *o, const void *ref_donor,
-                         upb_status *s) {
-  upb_oneof_iter it;
-
-  /* Check various conditions that would prevent this oneof from being added. */
-  if (upb_oneofdef_containingtype(o)) {
-    upb_status_seterrmsg(s, "oneofdef already belongs to a message");
-    return false;
-  } else if (upb_oneofdef_name(o) == NULL) {
-    upb_status_seterrmsg(s, "oneofdef name was not set");
-    return false;
-  } else if (upb_strtable_lookup(&m->ntof, upb_oneofdef_name(o), NULL)) {
-    upb_status_seterrmsg(s, "name conflicts with existing field or oneof");
-    return false;
-  }
-
-  /* Check that all of the oneof's fields do not conflict with names or numbers
-   * of fields already in the message. */
-  for (upb_oneof_begin(&it, o); !upb_oneof_done(&it); upb_oneof_next(&it)) {
-    const upb_fielddef *f = upb_oneof_iter_field(&it);
-    if (!check_field_add(m, f, s)) {
-      return false;
-    }
-  }
-
-  /* Everything checks out -- commit now. */
-
-  /* Add oneof itself first. */
-  o->parent = m;
-  upb_strtable_insert(&m->ntof, upb_oneofdef_name(o), upb_value_ptr(o));
-  upb_ref2(o, m);
-  upb_ref2(m, o);
-
-  /* Add each field of the oneof directly to the msgdef. */
-  for (upb_oneof_begin(&it, o); !upb_oneof_done(&it); upb_oneof_next(&it)) {
-    upb_fielddef *f = upb_oneof_iter_field(&it);
-    add_field(m, f, NULL);
-  }
-
-  if (ref_donor) upb_oneofdef_unref(o, ref_donor);
-
-  return true;
+uint32_t upb_msgdef_submsgfieldcount(const upb_msgdef *m) {
+  return m->submsg_field_count;
 }
 
 const upb_fielddef *upb_msgdef_itof(const upb_msgdef *m, uint32_t i) {
   upb_value val;
   return upb_inttable_lookup32(&m->itof, i, &val) ?
-      upb_value_getptr(val) : NULL;
+      upb_value_getconstptr(val) : NULL;
 }
 
 const upb_fielddef *upb_msgdef_ntof(const upb_msgdef *m, const char *name,
@@ -1592,7 +675,7 @@ const upb_fielddef *upb_msgdef_ntof(const upb_msgdef *m, const char *name,
     return NULL;
   }
 
-  return upb_trygetfield(upb_value_getptr(val));
+  return unpack_def(val, UPB_DEFTYPE_FIELD);
 }
 
 const upb_oneofdef *upb_msgdef_ntoo(const upb_msgdef *m, const char *name,
@@ -1603,7 +686,7 @@ const upb_oneofdef *upb_msgdef_ntoo(const upb_msgdef *m, const char *name,
     return NULL;
   }
 
-  return upb_trygetoneof(upb_value_getptr(val));
+  return unpack_def(val, UPB_DEFTYPE_ONEOF);
 }
 
 bool upb_msgdef_lookupname(const upb_msgdef *m, const char *name, size_t len,
@@ -1614,8 +697,8 @@ bool upb_msgdef_lookupname(const upb_msgdef *m, const char *name, size_t len,
     return false;
   }
 
-  *o = upb_trygetoneof(upb_value_getptr(val));
-  *f = upb_trygetfield(upb_value_getptr(val));
+  *o = unpack_def(val, UPB_DEFTYPE_ONEOF);
+  *f = unpack_def(val, UPB_DEFTYPE_FIELD);
   UPB_ASSERT((*o != NULL) ^ (*f != NULL));  /* Exactly one of the two should be set. */
   return true;
 }
@@ -1630,11 +713,6 @@ int upb_msgdef_numoneofs(const upb_msgdef *m) {
   return upb_strtable_count(&m->ntof) - upb_inttable_count(&m->itof);
 }
 
-void upb_msgdef_setmapentry(upb_msgdef *m, bool map_entry) {
-  UPB_ASSERT(!upb_msgdef_isfrozen(m));
-  m->map_entry = map_entry;
-}
-
 bool upb_msgdef_mapentry(const upb_msgdef *m) {
   return m->map_entry;
 }
@@ -1660,18 +738,23 @@ bool upb_msg_field_done(const upb_msg_field_iter *iter) {
 }
 
 upb_fielddef *upb_msg_iter_field(const upb_msg_field_iter *iter) {
-  return (upb_fielddef*)upb_value_getptr(upb_inttable_iter_value(iter));
+  return (upb_fielddef *)upb_value_getconstptr(upb_inttable_iter_value(iter));
 }
 
 void upb_msg_field_iter_setdone(upb_msg_field_iter *iter) {
   upb_inttable_iter_setdone(iter);
 }
 
+bool upb_msg_field_iter_isequal(const upb_msg_field_iter * iter1,
+                                const upb_msg_field_iter * iter2) {
+  return upb_inttable_iter_isequal(iter1, iter2);
+}
+
 void upb_msg_oneof_begin(upb_msg_oneof_iter *iter, const upb_msgdef *m) {
   upb_strtable_begin(iter, &m->ntof);
   /* We need to skip past any initial fields. */
   while (!upb_strtable_done(iter) &&
-         !upb_isoneof(upb_value_getptr(upb_strtable_iter_value(iter)))) {
+         !unpack_def(upb_strtable_iter_value(iter), UPB_DEFTYPE_ONEOF)) {
     upb_strtable_next(iter);
   }
 }
@@ -1681,95 +764,30 @@ void upb_msg_oneof_next(upb_msg_oneof_iter *iter) {
   do {
     upb_strtable_next(iter);
   } while (!upb_strtable_done(iter) &&
-           !upb_isoneof(upb_value_getptr(upb_strtable_iter_value(iter))));
+           !unpack_def(upb_strtable_iter_value(iter), UPB_DEFTYPE_ONEOF));
 }
 
 bool upb_msg_oneof_done(const upb_msg_oneof_iter *iter) {
   return upb_strtable_done(iter);
 }
 
-upb_oneofdef *upb_msg_iter_oneof(const upb_msg_oneof_iter *iter) {
-  return (upb_oneofdef*)upb_value_getptr(upb_strtable_iter_value(iter));
+const upb_oneofdef *upb_msg_iter_oneof(const upb_msg_oneof_iter *iter) {
+  return unpack_def(upb_strtable_iter_value(iter), UPB_DEFTYPE_ONEOF);
 }
 
 void upb_msg_oneof_iter_setdone(upb_msg_oneof_iter *iter) {
   upb_strtable_iter_setdone(iter);
 }
 
-/* upb_oneofdef ***************************************************************/
-
-static void visitoneof(const upb_refcounted *r, upb_refcounted_visit *visit,
-                       void *closure) {
-  const upb_oneofdef *o = (const upb_oneofdef*)r;
-  upb_oneof_iter i;
-  for (upb_oneof_begin(&i, o); !upb_oneof_done(&i); upb_oneof_next(&i)) {
-    const upb_fielddef *f = upb_oneof_iter_field(&i);
-    visit(r, upb_fielddef_upcast2(f), closure);
-  }
-  if (o->parent) {
-    visit(r, upb_msgdef_upcast2(o->parent), closure);
-  }
-}
-
-static void freeoneof(upb_refcounted *r) {
-  upb_oneofdef *o = (upb_oneofdef*)r;
-  upb_strtable_uninit(&o->ntof);
-  upb_inttable_uninit(&o->itof);
-  upb_gfree((void*)o->name);
-  upb_gfree(o);
+bool upb_msg_oneof_iter_isequal(const upb_msg_oneof_iter *iter1,
+                                const upb_msg_oneof_iter *iter2) {
+  return upb_strtable_iter_isequal(iter1, iter2);
 }
 
-const struct upb_refcounted_vtbl upb_oneofdef_vtbl = {visitoneof, freeoneof};
-
-upb_oneofdef *upb_oneofdef_new(const void *owner) {
-  upb_oneofdef *o = upb_gmalloc(sizeof(*o));
-
-  if (!o) {
-    return NULL;
-  }
-
-  o->parent = NULL;
-  o->name = NULL;
-
-  if (!upb_refcounted_init(upb_oneofdef_upcast_mutable(o), &upb_oneofdef_vtbl,
-                           owner)) {
-    goto err2;
-  }
-
-  if (!upb_inttable_init(&o->itof, UPB_CTYPE_PTR)) goto err2;
-  if (!upb_strtable_init(&o->ntof, UPB_CTYPE_PTR)) goto err1;
-
-  return o;
-
-err1:
-  upb_inttable_uninit(&o->itof);
-err2:
-  upb_gfree(o);
-  return NULL;
-}
-
-const char *upb_oneofdef_name(const upb_oneofdef *o) { return o->name; }
-
-bool upb_oneofdef_setname(upb_oneofdef *o, const char *name, upb_status *s) {
-  UPB_ASSERT(!upb_oneofdef_isfrozen(o));
-  if (upb_oneofdef_containingtype(o)) {
-    upb_status_seterrmsg(s, "oneof already added to a message");
-    return false;
-  }
-
-  if (!upb_isident(name, strlen(name), true, s)) {
-    return false;
-  }
-
-  name = upb_gstrdup(name);
-  if (!name) {
-    upb_status_seterrmsg(s, "One of memory");
-    return false;
-  }
+/* upb_oneofdef ***************************************************************/
 
-  upb_gfree((void*)o->name);
-  o->name = name;
-  return true;
+const char *upb_oneofdef_name(const upb_oneofdef *o) {
+  return shortdefname(o->full_name);
 }
 
 const upb_msgdef *upb_oneofdef_containingtype(const upb_oneofdef *o) {
@@ -1784,81 +802,6 @@ uint32_t upb_oneofdef_index(const upb_oneofdef *o) {
   return o->index;
 }
 
-bool upb_oneofdef_addfield(upb_oneofdef *o, upb_fielddef *f,
-                           const void *ref_donor,
-                           upb_status *s) {
-  UPB_ASSERT(!upb_oneofdef_isfrozen(o));
-  UPB_ASSERT(!o->parent || !upb_msgdef_isfrozen(o->parent));
-
-  /* This method is idempotent. Check if |f| is already part of this oneofdef
-   * and return immediately if so. */
-  if (upb_fielddef_containingoneof(f) == o) {
-    return true;
-  }
-
-  /* The field must have an OPTIONAL label. */
-  if (upb_fielddef_label(f) != UPB_LABEL_OPTIONAL) {
-    upb_status_seterrmsg(s, "fields in oneof must have OPTIONAL label");
-    return false;
-  }
-
-  /* Check that no field with this name or number exists already in the oneof.
-   * Also check that the field is not already part of a oneof. */
-  if (upb_fielddef_name(f) == NULL || upb_fielddef_number(f) == 0) {
-    upb_status_seterrmsg(s, "field name or number were not set");
-    return false;
-  } else if (upb_oneofdef_itof(o, upb_fielddef_number(f)) ||
-             upb_oneofdef_ntofz(o, upb_fielddef_name(f))) {
-    upb_status_seterrmsg(s, "duplicate field name or number");
-    return false;
-  } else if (upb_fielddef_containingoneof(f) != NULL) {
-    upb_status_seterrmsg(s, "fielddef already belongs to a oneof");
-    return false;
-  }
-
-  /* We allow adding a field to the oneof either if the field is not part of a
-   * msgdef, or if it is and we are also part of the same msgdef. */
-  if (o->parent == NULL) {
-    /* If we're not in a msgdef, the field cannot be either. Otherwise we would
-     * need to magically add this oneof to a msgdef to remain consistent, which
-     * is surprising behavior. */
-    if (upb_fielddef_containingtype(f) != NULL) {
-      upb_status_seterrmsg(s, "fielddef already belongs to a message, but "
-                              "oneof does not");
-      return false;
-    }
-  } else {
-    /* If we're in a msgdef, the user can add fields that either aren't in any
-     * msgdef (in which case they're added to our msgdef) or already a part of
-     * our msgdef. */
-    if (upb_fielddef_containingtype(f) != NULL &&
-        upb_fielddef_containingtype(f) != o->parent) {
-      upb_status_seterrmsg(s, "fielddef belongs to a different message "
-                              "than oneof");
-      return false;
-    }
-  }
-
-  /* Commit phase. First add the field to our parent msgdef, if any, because
-   * that may fail; then add the field to our own tables. */
-
-  if (o->parent != NULL && upb_fielddef_containingtype(f) == NULL) {
-    if (!upb_msgdef_addfield((upb_msgdef*)o->parent, f, NULL, s)) {
-      return false;
-    }
-  }
-
-  release_containingtype(f);
-  f->oneof = o;
-  upb_inttable_insert(&o->itof, upb_fielddef_number(f), upb_value_ptr(f));
-  upb_strtable_insert(&o->ntof, upb_fielddef_name(f), upb_value_ptr(f));
-  upb_ref2(f, o);
-  upb_ref2(o, f);
-  if (ref_donor) upb_fielddef_unref(f, ref_donor);
-
-  return true;
-}
-
 const upb_fielddef *upb_oneofdef_ntof(const upb_oneofdef *o,
                                       const char *name, size_t length) {
   upb_value val;
@@ -1885,543 +828,944 @@ bool upb_oneof_done(upb_oneof_iter *iter) {
 }
 
 upb_fielddef *upb_oneof_iter_field(const upb_oneof_iter *iter) {
-  return (upb_fielddef*)upb_value_getptr(upb_inttable_iter_value(iter));
+  return (upb_fielddef *)upb_value_getconstptr(upb_inttable_iter_value(iter));
 }
 
 void upb_oneof_iter_setdone(upb_oneof_iter *iter) {
   upb_inttable_iter_setdone(iter);
 }
 
-/* upb_filedef ****************************************************************/
+/* Code to build defs from descriptor protos. *********************************/
 
-static void visitfiledef(const upb_refcounted *r, upb_refcounted_visit *visit,
-                         void *closure) {
-  const upb_filedef *f = (const upb_filedef*)r;
-  size_t i;
+/* There is a question of how much validation to do here.  It will be difficult
+ * to perfectly match the amount of validation performed by proto2.  But since
+ * this code is used to directly build defs from Ruby (for example) we do need
+ * to validate important constraints like uniqueness of names and numbers. */
 
-  for(i = 0; i < upb_filedef_defcount(f); i++) {
-    visit(r, upb_def_upcast(upb_filedef_def(f, i)), closure);
-  }
-}
+#define CHK(x) if (!(x)) { return false; }
+#define CHK_OOM(x) if (!(x)) { upb_status_setoom(ctx->status); return false; }
 
-static void freefiledef(upb_refcounted *r) {
-  upb_filedef *f = (upb_filedef*)r;
-  size_t i;
+typedef struct {
+  const upb_symtab *symtab;
+  upb_filedef *file;  /* File we are building. */
+  upb_alloc *alloc;    /* Allocate defs here. */
+  upb_alloc *tmp;      /* Alloc for addtab and any other tmp data. */
+  upb_strtable *addtab;  /* full_name -> packed def ptr for new defs. */
+  upb_status *status;  /* Record errors here. */
+} symtab_addctx;
 
-  for(i = 0; i < upb_filedef_depcount(f); i++) {
-    upb_filedef_unref(upb_filedef_dep(f, i), f);
-  }
+static char* strviewdup(const symtab_addctx *ctx, upb_strview view) {
+  return upb_strdup2(view.data, view.size, ctx->alloc);
+}
 
-  upb_inttable_uninit(&f->defs);
-  upb_inttable_uninit(&f->deps);
-  upb_gfree((void*)f->name);
-  upb_gfree((void*)f->package);
-  upb_gfree((void*)f->phpprefix);
-  upb_gfree((void*)f->phpnamespace);
-  upb_gfree(f);
+static bool streql2(const char *a, size_t n, const char *b) {
+  return n == strlen(b) && memcmp(a, b, n) == 0;
 }
 
-const struct upb_refcounted_vtbl upb_filedef_vtbl = {visitfiledef, freefiledef};
+static bool streql_view(upb_strview view, const char *b) {
+  return streql2(view.data, view.size, b);
+}
 
-upb_filedef *upb_filedef_new(const void *owner) {
-  upb_filedef *f = upb_gmalloc(sizeof(*f));
+static const char *makefullname(const symtab_addctx *ctx, const char *prefix,
+                                upb_strview name) {
+  if (prefix) {
+    /* ret = prefix + '.' + name; */
+    size_t n = strlen(prefix);
+    char *ret = upb_malloc(ctx->alloc, n + name.size + 2);
+    CHK_OOM(ret);
+    strcpy(ret, prefix);
+    ret[n] = '.';
+    memcpy(&ret[n + 1], name.data, name.size);
+    ret[n + 1 + name.size] = '\0';
+    return ret;
+  } else {
+    return strviewdup(ctx, name);
+  }
+}
 
-  if (!f) {
-    return NULL;
+static bool symtab_add(const symtab_addctx *ctx, const char *name,
+                       upb_value v) {
+  upb_value tmp;
+  if (upb_strtable_lookup(ctx->addtab, name, &tmp) ||
+      upb_strtable_lookup(&ctx->symtab->syms, name, &tmp)) {
+    upb_status_seterrf(ctx->status, "duplicate symbol '%s'", name);
+    return false;
   }
 
-  f->package = NULL;
-  f->name = NULL;
-  f->phpprefix = NULL;
-  f->phpnamespace = NULL;
-  f->syntax = UPB_SYNTAX_PROTO2;
+  CHK_OOM(upb_strtable_insert3(ctx->addtab, name, strlen(name), v, ctx->tmp));
+  return true;
+}
 
-  if (!upb_refcounted_init(upb_filedef_upcast_mutable(f), &upb_filedef_vtbl,
-                           owner)) {
-    goto err;
-  }
+/* Given a symbol and the base symbol inside which it is defined, find the
+ * symbol's definition in t. */
+static bool resolvename(const upb_strtable *t, const upb_fielddef *f,
+                        const char *base, upb_strview sym,
+                        upb_deftype_t type, upb_status *status,
+                        const void **def) {
+  if(sym.size == 0) return NULL;
+  if(sym.data[0] == '.') {
+    /* Symbols starting with '.' are absolute, so we do a single lookup.
+     * Slice to omit the leading '.' */
+    upb_value v;
+    if (!upb_strtable_lookup2(t, sym.data + 1, sym.size - 1, &v)) {
+      return false;
+    }
 
-  if (!upb_inttable_init(&f->defs, UPB_CTYPE_CONSTPTR)) {
-    goto err;
+    *def = unpack_def(v, type);
+
+    if (!*def) {
+      upb_status_seterrf(status,
+                         "type mismatch when resolving field %s, name %s",
+                         f->full_name, sym.data);
+      return false;
+    }
+
+    return true;
+  } else {
+    /* Remove components from base until we find an entry or run out.
+     * TODO: This branch is totally broken, but currently not used. */
+    (void)base;
+    UPB_ASSERT(false);
+    return false;
   }
+}
 
-  if (!upb_inttable_init(&f->deps, UPB_CTYPE_CONSTPTR)) {
-    goto err2;
+const void *symtab_resolve(const symtab_addctx *ctx, const upb_fielddef *f,
+                           const char *base, upb_strview sym,
+                           upb_deftype_t type) {
+  const void *ret;
+  if (!resolvename(ctx->addtab, f, base, sym, type, ctx->status, &ret) &&
+      !resolvename(&ctx->symtab->syms, f, base, sym, type, ctx->status, &ret)) {
+    if (upb_ok(ctx->status)) {
+      upb_status_seterrf(ctx->status, "couldn't resolve name '%s'", sym.data);
+    }
+    return false;
   }
+  return ret;
+}
 
-  return f;
+static bool create_oneofdef(
+    const symtab_addctx *ctx, upb_msgdef *m,
+    const google_protobuf_OneofDescriptorProto *oneof_proto) {
+  upb_oneofdef *o;
+  upb_strview name = google_protobuf_OneofDescriptorProto_name(oneof_proto);
+  upb_value v;
 
+  o = (upb_oneofdef*)&m->oneofs[m->oneof_count++];
+  o->parent = m;
+  o->full_name = makefullname(ctx, m->full_name, name);
 
-err2:
-  upb_inttable_uninit(&f->defs);
+  v = pack_def(o, UPB_DEFTYPE_ONEOF);
+  CHK_OOM(symtab_add(ctx, o->full_name, v));
+  CHK_OOM(upb_strtable_insert3(&m->ntof, name.data, name.size, v, ctx->alloc));
 
-err:
-  upb_gfree(f);
-  return NULL;
-}
+  CHK_OOM(upb_inttable_init2(&o->itof, UPB_CTYPE_CONSTPTR, ctx->alloc));
+  CHK_OOM(upb_strtable_init2(&o->ntof, UPB_CTYPE_CONSTPTR, ctx->alloc));
 
-const char *upb_filedef_name(const upb_filedef *f) {
-  return f->name;
+  return true;
 }
 
-const char *upb_filedef_package(const upb_filedef *f) {
-  return f->package;
-}
+static bool parse_default(const symtab_addctx *ctx, const char *str, size_t len,
+                          upb_fielddef *f) {
+  char *end;
+  char nullz[64];
+  errno = 0;
 
-const char *upb_filedef_phpprefix(const upb_filedef *f) {
-  return f->phpprefix;
-}
+  switch (upb_fielddef_type(f)) {
+    case UPB_TYPE_INT32:
+    case UPB_TYPE_INT64:
+    case UPB_TYPE_UINT32:
+    case UPB_TYPE_UINT64:
+    case UPB_TYPE_DOUBLE:
+    case UPB_TYPE_FLOAT:
+      /* Standard C number parsing functions expect null-terminated strings. */
+      if (len >= sizeof(nullz) - 1) {
+        return false;
+      }
+      memcpy(nullz, str, len);
+      nullz[len] = '\0';
+      str = nullz;
+      break;
+    default:
+      break;
+  }
 
-const char *upb_filedef_phpnamespace(const upb_filedef *f) {
-  return f->phpnamespace;
+  switch (upb_fielddef_type(f)) {
+    case UPB_TYPE_INT32: {
+      long val = strtol(str, &end, 0);
+      CHK(val <= INT32_MAX && val >= INT32_MIN && errno != ERANGE && !*end);
+      f->defaultval.sint = val;
+      break;
+    }
+    case UPB_TYPE_ENUM: {
+      const upb_enumdef *e = f->sub.enumdef;
+      int32_t val;
+      CHK(upb_enumdef_ntoi(e, str, len, &val));
+      f->defaultval.sint = val;
+      break;
+    }
+    case UPB_TYPE_INT64: {
+      /* XXX: Need to write our own strtoll, since it's not available in c89. */
+      long long val = strtol(str, &end, 0);
+      CHK(val <= INT64_MAX && val >= INT64_MIN && errno != ERANGE && !*end);
+      f->defaultval.sint = val;
+      break;
+    }
+    case UPB_TYPE_UINT32: {
+      unsigned long val = strtoul(str, &end, 0);
+      CHK(val <= UINT32_MAX && errno != ERANGE && !*end);
+      f->defaultval.uint = val;
+      break;
+    }
+    case UPB_TYPE_UINT64: {
+      /* XXX: Need to write our own strtoull, since it's not available in c89. */
+      unsigned long long val = strtoul(str, &end, 0);
+      CHK(val <= UINT64_MAX && errno != ERANGE && !*end);
+      f->defaultval.uint = val;
+      break;
+    }
+    case UPB_TYPE_DOUBLE: {
+      double val = strtod(str, &end);
+      CHK(errno != ERANGE && !*end);
+      f->defaultval.dbl = val;
+      break;
+    }
+    case UPB_TYPE_FLOAT: {
+      /* XXX: Need to write our own strtof, since it's not available in c89. */
+      float val = strtod(str, &end);
+      CHK(errno != ERANGE && !*end);
+      f->defaultval.flt = val;
+      break;
+    }
+    case UPB_TYPE_BOOL: {
+      if (streql2(str, len, "false")) {
+        f->defaultval.boolean = false;
+      } else if (streql2(str, len, "true")) {
+        f->defaultval.boolean = true;
+      } else {
+        return false;
+      }
+    }
+    case UPB_TYPE_STRING:
+      f->defaultval.str = newstr(ctx->alloc, str, len);
+      break;
+    case UPB_TYPE_BYTES:
+      /* XXX: need to interpret the C-escaped value. */
+      f->defaultval.str = newstr(ctx->alloc, str, len);
+      break;
+    case UPB_TYPE_MESSAGE:
+      /* Should not have a default value. */
+      return false;
+  }
+  return true;
 }
 
-upb_syntax_t upb_filedef_syntax(const upb_filedef *f) {
-  return f->syntax;
+static void set_default_default(const symtab_addctx *ctx, upb_fielddef *f) {
+  switch (upb_fielddef_type(f)) {
+    case UPB_TYPE_INT32:
+    case UPB_TYPE_INT64:
+    case UPB_TYPE_ENUM:
+      f->defaultval.sint = 0;
+      break;
+    case UPB_TYPE_UINT64:
+    case UPB_TYPE_UINT32:
+      f->defaultval.uint = 0;
+      break;
+    case UPB_TYPE_DOUBLE:
+    case UPB_TYPE_FLOAT:
+      f->defaultval.dbl = 0;
+      break;
+    case UPB_TYPE_STRING:
+    case UPB_TYPE_BYTES:
+      f->defaultval.str = newstr(ctx->alloc, NULL, 0);
+      break;
+    case UPB_TYPE_BOOL:
+      f->defaultval.boolean = false;
+      break;
+    case UPB_TYPE_MESSAGE:
+      break;
+  }
 }
 
-size_t upb_filedef_defcount(const upb_filedef *f) {
-  return upb_inttable_count(&f->defs);
-}
+static bool create_fielddef(
+    const symtab_addctx *ctx, const char *prefix, upb_msgdef *m,
+    const google_protobuf_FieldDescriptorProto *field_proto) {
+  upb_alloc *alloc = ctx->alloc;
+  upb_fielddef *f;
+  const google_protobuf_FieldOptions *options;
+  upb_strview name;
+  const char *full_name;
+  const char *shortname;
+  uint32_t field_number;
 
-size_t upb_filedef_depcount(const upb_filedef *f) {
-  return upb_inttable_count(&f->deps);
-}
+  if (!google_protobuf_FieldDescriptorProto_has_name(field_proto)) {
+    upb_status_seterrmsg(ctx->status, "field has no name");
+    return false;
+  }
 
-const upb_def *upb_filedef_def(const upb_filedef *f, size_t i) {
-  upb_value v;
+  name = google_protobuf_FieldDescriptorProto_name(field_proto);
+  CHK(upb_isident(name, false, ctx->status));
+  full_name = makefullname(ctx, prefix, name);
+  shortname = shortdefname(full_name);
 
-  if (upb_inttable_lookup32(&f->defs, i, &v)) {
-    return upb_value_getconstptr(v);
-  } else {
-    return NULL;
+  field_number = google_protobuf_FieldDescriptorProto_number(field_proto);
+
+  if (field_number == 0 || field_number > UPB_MAX_FIELDNUMBER) {
+    upb_status_seterrf(ctx->status, "invalid field number (%u)", field_number);
+    return false;
   }
-}
 
-const upb_filedef *upb_filedef_dep(const upb_filedef *f, size_t i) {
-  upb_value v;
+  if (m) {
+    /* direct message field. */
+    upb_value v, packed_v;
+
+    f = (upb_fielddef*)&m->fields[m->field_count++];
+    f->msgdef = m;
+    f->is_extension_ = false;
 
-  if (upb_inttable_lookup32(&f->deps, i, &v)) {
-    return upb_value_getconstptr(v);
+    packed_v = pack_def(f, UPB_DEFTYPE_FIELD);
+    v = upb_value_constptr(f);
+
+    if (!upb_strtable_insert3(&m->ntof, name.data, name.size, packed_v, alloc)) {
+      upb_status_seterrf(ctx->status, "duplicate field name (%s)", shortname);
+      return false;
+    }
+
+    if (!upb_inttable_insert2(&m->itof, field_number, v, alloc)) {
+      upb_status_seterrf(ctx->status, "duplicate field number (%u)",
+                         field_number);
+      return false;
+    }
   } else {
-    return NULL;
+    /* extension field. */
+    f = (upb_fielddef*)&ctx->file->exts[ctx->file->ext_count];
+    f->is_extension_ = true;
+    CHK_OOM(symtab_add(ctx, full_name, pack_def(f, UPB_DEFTYPE_FIELD)));
   }
-}
 
-bool upb_filedef_setname(upb_filedef *f, const char *name, upb_status *s) {
-  name = upb_gstrdup(name);
-  if (!name) {
-    upb_upberr_setoom(s);
-    return false;
-  }
-  upb_gfree((void*)f->name);
-  f->name = name;
-  return true;
-}
+  f->full_name = full_name;
+  f->file = ctx->file;
+  f->type_ = (int)google_protobuf_FieldDescriptorProto_type(field_proto);
+  f->label_ = (int)google_protobuf_FieldDescriptorProto_label(field_proto);
+  f->number_ = field_number;
+  f->oneof = NULL;
 
-bool upb_filedef_setpackage(upb_filedef *f, const char *package,
-                            upb_status *s) {
-  if (!upb_isident(package, strlen(package), true, s)) return false;
-  package = upb_gstrdup(package);
-  if (!package) {
-    upb_upberr_setoom(s);
+  /* We can't resolve the subdef or (in the case of extensions) the containing
+   * message yet, because it may not have been defined yet.  We stash a pointer
+   * to the field_proto until later when we can properly resolve it. */
+  f->sub.unresolved = field_proto;
+
+  if (f->label_ == UPB_LABEL_REQUIRED && f->file->syntax == UPB_SYNTAX_PROTO3) {
+    upb_status_seterrf(ctx->status, "proto3 fields cannot be required (%s)",
+                       f->full_name);
     return false;
   }
-  upb_gfree((void*)f->package);
-  f->package = package;
-  return true;
-}
 
-bool upb_filedef_setphpprefix(upb_filedef *f, const char *phpprefix,
-                              upb_status *s) {
-  phpprefix = upb_gstrdup(phpprefix);
-  if (!phpprefix) {
-    upb_upberr_setoom(s);
-    return false;
+  if (google_protobuf_FieldDescriptorProto_has_oneof_index(field_proto)) {
+    int oneof_index =
+        google_protobuf_FieldDescriptorProto_oneof_index(field_proto);
+    upb_oneofdef *oneof;
+    upb_value v = upb_value_constptr(f);
+
+    if (upb_fielddef_label(f) != UPB_LABEL_OPTIONAL) {
+      upb_status_seterrf(ctx->status,
+                         "fields in oneof must have OPTIONAL label (%s)",
+                         f->full_name);
+      return false;
+    }
+
+    if (!m) {
+      upb_status_seterrf(ctx->status,
+                         "oneof_index provided for extension field (%s)",
+                         f->full_name);
+      return false;
+    }
+
+    if (oneof_index >= m->oneof_count) {
+      upb_status_seterrf(ctx->status, "oneof_index out of range (%s)",
+                         f->full_name);
+      return false;
+    }
+
+    oneof = (upb_oneofdef*)&m->oneofs[oneof_index];
+    f->oneof = oneof;
+
+    CHK(upb_inttable_insert2(&oneof->itof, f->number_, v, alloc));
+    CHK(upb_strtable_insert3(&oneof->ntof, name.data, name.size, v, alloc));
+  } else {
+    f->oneof = NULL;
   }
-  upb_gfree((void*)f->phpprefix);
-  f->phpprefix = phpprefix;
-  return true;
-}
 
-bool upb_filedef_setphpnamespace(upb_filedef *f, const char *phpnamespace,
-                                 upb_status *s) {
-  phpnamespace = upb_gstrdup(phpnamespace);
-  if (!phpnamespace) {
-    upb_upberr_setoom(s);
-    return false;
+  if (google_protobuf_FieldDescriptorProto_has_options(field_proto)) {
+    options = google_protobuf_FieldDescriptorProto_options(field_proto);
+    f->lazy_ = google_protobuf_FieldOptions_lazy(options);
+    f->packed_ = google_protobuf_FieldOptions_packed(options);
+  } else {
+    f->lazy_ = false;
+    f->packed_ = false;
   }
-  upb_gfree((void*)f->phpnamespace);
-  f->phpnamespace = phpnamespace;
+
   return true;
 }
 
-bool upb_filedef_setsyntax(upb_filedef *f, upb_syntax_t syntax,
-                           upb_status *s) {
-  UPB_UNUSED(s);
-  if (syntax != UPB_SYNTAX_PROTO2 &&
-      syntax != UPB_SYNTAX_PROTO3) {
-    upb_status_seterrmsg(s, "Unknown syntax value.");
+static bool create_enumdef(
+    const symtab_addctx *ctx, const char *prefix,
+    const google_protobuf_EnumDescriptorProto *enum_proto) {
+  upb_enumdef *e;
+  const google_protobuf_EnumValueDescriptorProto *const *values;
+  upb_strview name;
+  size_t i, n;
+
+  name = google_protobuf_EnumDescriptorProto_name(enum_proto);
+  CHK(upb_isident(name, false, ctx->status));
+
+  e = (upb_enumdef*)&ctx->file->enums[ctx->file->enum_count++];
+  e->full_name = makefullname(ctx, prefix, name);
+  CHK_OOM(symtab_add(ctx, e->full_name, pack_def(e, UPB_DEFTYPE_ENUM)));
+
+  CHK_OOM(upb_strtable_init2(&e->ntoi, UPB_CTYPE_INT32, ctx->alloc));
+  CHK_OOM(upb_inttable_init2(&e->iton, UPB_CTYPE_CSTR, ctx->alloc));
+
+  e->file = ctx->file;
+  e->defaultval = 0;
+
+  values = google_protobuf_EnumDescriptorProto_value(enum_proto, &n);
+
+  if (n == 0) {
+    upb_status_seterrf(ctx->status,
+                       "enums must contain at least one value (%s)",
+                       e->full_name);
     return false;
   }
-  f->syntax = syntax;
 
-  {
-    /* Set all messages in this file to match. */
-    size_t i;
-    for (i = 0; i < upb_filedef_defcount(f); i++) {
-      /* Casting const away is safe since all defs in mutable filedef must
-       * also be mutable. */
-      upb_def *def = (upb_def*)upb_filedef_def(f, i);
-
-      upb_msgdef *m = upb_dyncast_msgdef_mutable(def);
-      if (m) {
-        m->syntax = syntax;
-      }
+  for (i = 0; i < n; i++) {
+    const google_protobuf_EnumValueDescriptorProto *value = values[i];
+    upb_strview name = google_protobuf_EnumValueDescriptorProto_name(value);
+    char *name2 = strviewdup(ctx, name);
+    int32_t num = google_protobuf_EnumValueDescriptorProto_number(value);
+    upb_value v = upb_value_int32(num);
+
+    if (i == 0 && e->file->syntax == UPB_SYNTAX_PROTO3 && num != 0) {
+      upb_status_seterrf(ctx->status,
+                         "for proto3, the first enum value must be zero (%s)",
+                         e->full_name);
+      return false;
+    }
+
+    if (upb_strtable_lookup(&e->ntoi, name2, NULL)) {
+      upb_status_seterrf(ctx->status, "duplicate enum label '%s'", name2);
+      return false;
+    }
+
+    CHK_OOM(name2)
+    CHK_OOM(
+        upb_strtable_insert3(&e->ntoi, name2, strlen(name2), v, ctx->alloc));
+
+    if (!upb_inttable_lookup(&e->iton, num, NULL)) {
+      upb_value v = upb_value_cstr(name2);
+      CHK_OOM(upb_inttable_insert2(&e->iton, num, v, ctx->alloc));
     }
   }
 
+  upb_inttable_compact2(&e->iton, ctx->alloc);
+
   return true;
 }
 
-bool upb_filedef_adddef(upb_filedef *f, upb_def *def, const void *ref_donor,
-                        upb_status *s) {
-  if (def->file) {
-    upb_status_seterrmsg(s, "Def is already part of another filedef.");
-    return false;
+static bool create_msgdef(const symtab_addctx *ctx, const char *prefix,
+                          const google_protobuf_DescriptorProto *msg_proto) {
+  upb_msgdef *m;
+  const google_protobuf_MessageOptions *options;
+  const google_protobuf_OneofDescriptorProto *const *oneofs;
+  const google_protobuf_FieldDescriptorProto *const *fields;
+  const google_protobuf_EnumDescriptorProto *const *enums;
+  const google_protobuf_DescriptorProto *const *msgs;
+  size_t i, n;
+  upb_strview name;
+
+  name = google_protobuf_DescriptorProto_name(msg_proto);
+  CHK(upb_isident(name, false, ctx->status));
+
+  m = (upb_msgdef*)&ctx->file->msgs[ctx->file->msg_count++];
+  m->full_name = makefullname(ctx, prefix, name);
+  CHK_OOM(symtab_add(ctx, m->full_name, pack_def(m, UPB_DEFTYPE_MSG)));
+
+  CHK_OOM(upb_inttable_init2(&m->itof, UPB_CTYPE_CONSTPTR, ctx->alloc));
+  CHK_OOM(upb_strtable_init2(&m->ntof, UPB_CTYPE_CONSTPTR, ctx->alloc));
+
+  m->file = ctx->file;
+  m->map_entry = false;
+
+  options = google_protobuf_DescriptorProto_options(msg_proto);
+
+  if (options) {
+    m->map_entry = google_protobuf_MessageOptions_map_entry(options);
   }
 
-  if (upb_inttable_push(&f->defs, upb_value_constptr(def))) {
-    def->file = f;
-    upb_ref2(def, f);
-    upb_ref2(f, def);
-    if (ref_donor) upb_def_unref(def, ref_donor);
-    if (def->type == UPB_DEF_MSG) {
-      upb_downcast_msgdef_mutable(def)->syntax = f->syntax;
-    }
-    return true;
-  } else {
-    upb_upberr_setoom(s);
-    return false;
+  oneofs = google_protobuf_DescriptorProto_oneof_decl(msg_proto, &n);
+  m->oneof_count = 0;
+  m->oneofs = upb_malloc(ctx->alloc, sizeof(*m->oneofs) * n);
+  for (i = 0; i < n; i++) {
+    CHK(create_oneofdef(ctx, m, oneofs[i]));
   }
-}
 
-bool upb_filedef_adddep(upb_filedef *f, const upb_filedef *dep) {
-  if (upb_inttable_push(&f->deps, upb_value_constptr(dep))) {
-    /* Regular ref instead of ref2 because files can't form cycles. */
-    upb_filedef_ref(dep, f);
-    return true;
-  } else {
-    return false;
+  fields = google_protobuf_DescriptorProto_field(msg_proto, &n);
+  m->field_count = 0;
+  m->fields = upb_malloc(ctx->alloc, sizeof(*m->fields) * n);
+  for (i = 0; i < n; i++) {
+    CHK(create_fielddef(ctx, m->full_name, m, fields[i]));
   }
-}
 
-void upb_symtab_free(upb_symtab *s) {
-  upb_strtable_iter i;
-  upb_strtable_begin(&i, &s->symtab);
-  for (; !upb_strtable_done(&i); upb_strtable_next(&i)) {
-    const upb_def *def = upb_value_getptr(upb_strtable_iter_value(&i));
-    upb_def_unref(def, s);
+  CHK(assign_msg_indices(m, ctx->status));
+  assign_msg_wellknowntype(m);
+  upb_inttable_compact2(&m->itof, ctx->alloc);
+
+  /* This message is built.  Now build nested messages and enums. */
+
+  enums = google_protobuf_DescriptorProto_enum_type(msg_proto, &n);
+  for (i = 0; i < n; i++) {
+    CHK(create_enumdef(ctx, m->full_name, enums[i]));
   }
-  upb_strtable_uninit(&s->symtab);
-  upb_gfree(s);
-}
 
-upb_symtab *upb_symtab_new() {
-  upb_symtab *s = upb_gmalloc(sizeof(*s));
-  if (!s) {
-    return NULL;
+  msgs = google_protobuf_DescriptorProto_nested_type(msg_proto, &n);
+  for (i = 0; i < n; i++) {
+    CHK(create_msgdef(ctx, m->full_name, msgs[i]));
   }
 
-  upb_strtable_init(&s->symtab, UPB_CTYPE_PTR);
-  return s;
+  return true;
 }
 
-const upb_def *upb_symtab_lookup(const upb_symtab *s, const char *sym) {
-  upb_value v;
-  upb_def *ret = upb_strtable_lookup(&s->symtab, sym, &v) ?
-      upb_value_getptr(v) : NULL;
-  return ret;
-}
+typedef struct {
+  int msg_count;
+  int enum_count;
+  int ext_count;
+} decl_counts;
 
-const upb_msgdef *upb_symtab_lookupmsg(const upb_symtab *s, const char *sym) {
-  upb_value v;
-  upb_def *def = upb_strtable_lookup(&s->symtab, sym, &v) ?
-      upb_value_getptr(v) : NULL;
-  return def ? upb_dyncast_msgdef(def) : NULL;
-}
+static void count_types_in_msg(const google_protobuf_DescriptorProto *msg_proto,
+                               decl_counts *counts) {
+  const google_protobuf_DescriptorProto *const *msgs;
+  size_t i, n;
 
-const upb_msgdef *upb_symtab_lookupmsg2(const upb_symtab *s, const char *sym,
-                                        size_t len) {
-  upb_value v;
-  upb_def *def = upb_strtable_lookup2(&s->symtab, sym, len, &v) ?
-      upb_value_getptr(v) : NULL;
-  return def ? upb_dyncast_msgdef(def) : NULL;
-}
+  counts->msg_count++;
 
-const upb_enumdef *upb_symtab_lookupenum(const upb_symtab *s, const char *sym) {
-  upb_value v;
-  upb_def *def = upb_strtable_lookup(&s->symtab, sym, &v) ?
-      upb_value_getptr(v) : NULL;
-  return def ? upb_dyncast_enumdef(def) : NULL;
+  msgs = google_protobuf_DescriptorProto_nested_type(msg_proto, &n);
+  for (i = 0; i < n; i++) {
+    count_types_in_msg(msgs[i], counts);
+  }
+
+  google_protobuf_DescriptorProto_enum_type(msg_proto, &n);
+  counts->enum_count += n;
+
+  google_protobuf_DescriptorProto_extension(msg_proto, &n);
+  counts->ext_count += n;
 }
 
-/* Given a symbol and the base symbol inside which it is defined, find the
- * symbol's definition in t. */
-static upb_def *upb_resolvename(const upb_strtable *t,
-                                const char *base, const char *sym) {
-  if(strlen(sym) == 0) return NULL;
-  if(sym[0] == '.') {
-    /* Symbols starting with '.' are absolute, so we do a single lookup.
-     * Slice to omit the leading '.' */
-    upb_value v;
-    return upb_strtable_lookup(t, sym + 1, &v) ? upb_value_getptr(v) : NULL;
-  } else {
-    /* Remove components from base until we find an entry or run out.
-     * TODO: This branch is totally broken, but currently not used. */
-    (void)base;
-    UPB_ASSERT(false);
-    return NULL;
+static void count_types_in_file(
+    const google_protobuf_FileDescriptorProto *file_proto,
+    decl_counts *counts) {
+  const google_protobuf_DescriptorProto *const *msgs;
+  size_t i, n;
+
+  msgs = google_protobuf_FileDescriptorProto_message_type(file_proto, &n);
+  for (i = 0; i < n; i++) {
+    count_types_in_msg(msgs[i], counts);
   }
-}
 
-const upb_def *upb_symtab_resolve(const upb_symtab *s, const char *base,
-                                  const char *sym) {
-  upb_def *ret = upb_resolvename(&s->symtab, base, sym);
-  return ret;
+  google_protobuf_FileDescriptorProto_enum_type(file_proto, &n);
+  counts->enum_count += n;
+
+  google_protobuf_FileDescriptorProto_extension(file_proto, &n);
+  counts->ext_count += n;
 }
 
-/* TODO(haberman): we need a lot more testing of error conditions. */
-static bool symtab_add(upb_symtab *s, upb_def *const*defs, size_t n,
-                       void *ref_donor, upb_refcounted *freeze_also,
-                       upb_status *status) {
-  size_t i;
-  size_t add_n;
-  size_t freeze_n;
-  upb_strtable_iter iter;
-  upb_refcounted **add_objs = NULL;
-  upb_def **add_defs = NULL;
-  size_t add_objs_size;
-  upb_strtable addtab;
+static bool resolve_fielddef(const symtab_addctx *ctx, const char *prefix,
+                             upb_fielddef *f) {
+  upb_strview name;
+  const google_protobuf_FieldDescriptorProto *field_proto = f->sub.unresolved;
 
-  if (n == 0 && !freeze_also) {
-    return true;
+  if (f->is_extension_) {
+    if (!google_protobuf_FieldDescriptorProto_has_extendee(field_proto)) {
+      upb_status_seterrf(ctx->status,
+                         "extension for field '%s' had no extendee",
+                         f->full_name);
+      return false;
+    }
+
+    name = google_protobuf_FieldDescriptorProto_extendee(field_proto);
+    f->msgdef = symtab_resolve(ctx, f, prefix, name, UPB_DEFTYPE_MSG);
+    CHK(f->msgdef);
   }
 
-  if (!upb_strtable_init(&addtab, UPB_CTYPE_PTR)) {
-    upb_status_seterrmsg(status, "out of memory");
+  if ((upb_fielddef_issubmsg(f) || f->type_ == UPB_DESCRIPTOR_TYPE_ENUM) &&
+      !google_protobuf_FieldDescriptorProto_has_type_name(field_proto)) {
+    upb_status_seterrf(ctx->status, "field '%s' is missing type name",
+                       f->full_name);
     return false;
   }
 
-  /* Add new defs to our "add" set. */
-  for (i = 0; i < n; i++) {
-    upb_def *def = defs[i];
-    const char *fullname;
-    upb_fielddef *f;
+  name = google_protobuf_FieldDescriptorProto_type_name(field_proto);
 
-    if (upb_def_isfrozen(def)) {
-      upb_status_seterrmsg(status, "added defs must be mutable");
-      goto err;
-    }
-    UPB_ASSERT(!upb_def_isfrozen(def));
-    fullname = upb_def_fullname(def);
-    if (!fullname) {
-      upb_status_seterrmsg(
-          status, "Anonymous defs cannot be added to a symtab");
-      goto err;
-    }
+  if (upb_fielddef_issubmsg(f)) {
+    f->sub.msgdef = symtab_resolve(ctx, f, prefix, name, UPB_DEFTYPE_MSG);
+    CHK(f->sub.msgdef);
+  } else if (f->type_ == UPB_DESCRIPTOR_TYPE_ENUM) {
+    f->sub.enumdef = symtab_resolve(ctx, f, prefix, name, UPB_DEFTYPE_ENUM);
+    CHK(f->sub.enumdef);
+  }
 
-    f = upb_dyncast_fielddef_mutable(def);
+  /* Have to delay resolving of the default value until now because of the enum
+   * case, since enum defaults are specified with a label. */
+  if (google_protobuf_FieldDescriptorProto_has_default_value(field_proto)) {
+    upb_strview defaultval =
+        google_protobuf_FieldDescriptorProto_default_value(field_proto);
 
-    if (f) {
-      if (!upb_fielddef_containingtypename(f)) {
-        upb_status_seterrmsg(status,
-                             "Standalone fielddefs must have a containing type "
-                             "(extendee) name set");
-        goto err;
-      }
-    } else {
-      if (upb_strtable_lookup(&addtab, fullname, NULL)) {
-        upb_status_seterrf(status, "Conflicting defs named '%s'", fullname);
-        goto err;
-      }
-      if (upb_strtable_lookup(&s->symtab, fullname, NULL)) {
-        upb_status_seterrf(status, "Symtab already has a def named '%s'",
-                           fullname);
-        goto err;
-      }
-      if (!upb_strtable_insert(&addtab, fullname, upb_value_ptr(def)))
-        goto oom_err;
-      upb_def_donateref(def, ref_donor, s);
+    if (f->file->syntax == UPB_SYNTAX_PROTO3) {
+      upb_status_seterrf(ctx->status,
+                         "proto3 fields cannot have explicit defaults (%s)",
+                         f->full_name);
+      return false;
     }
 
-    if (upb_dyncast_fielddef_mutable(def)) {
-      /* TODO(haberman): allow adding extensions attached to files. */
-      upb_status_seterrf(status, "Can't add extensions to symtab.\n");
-      goto err;
+    if (upb_fielddef_issubmsg(f)) {
+      upb_status_seterrf(ctx->status,
+                         "message fields cannot have explicit defaults (%s)",
+                         f->full_name);
+      return false;
     }
+
+    if (!parse_default(ctx, defaultval.data, defaultval.size, f)) {
+      upb_status_seterrf(ctx->status,
+                         "couldn't parse default '" UPB_STRVIEW_FORMAT
+                         "' for field (%s)",
+                         UPB_STRVIEW_ARGS(defaultval), f->full_name);
+      return false;
+    }
+  } else {
+    set_default_default(ctx, f);
   }
 
-  /* Now using the table, resolve symbolic references for subdefs. */
-  upb_strtable_begin(&iter, &addtab);
-  for (; !upb_strtable_done(&iter); upb_strtable_next(&iter)) {
-    const char *base;
-    upb_def *def = upb_value_getptr(upb_strtable_iter_value(&iter));
-    upb_msgdef *m = upb_dyncast_msgdef_mutable(def);
-    upb_msg_field_iter j;
+  return true;
+}
 
-    if (!m) continue;
-    /* Type names are resolved relative to the message in which they appear. */
-    base = upb_msgdef_fullname(m);
+static bool build_filedef(
+    const symtab_addctx *ctx, upb_filedef *file,
+    const google_protobuf_FileDescriptorProto *file_proto) {
+  upb_alloc *alloc = ctx->alloc;
+  const google_protobuf_FileOptions *file_options_proto;
+  const google_protobuf_DescriptorProto *const *msgs;
+  const google_protobuf_EnumDescriptorProto *const *enums;
+  const google_protobuf_FieldDescriptorProto *const *exts;
+  const upb_strview* strs;
+  size_t i, n;
+  decl_counts counts = {0};
 
-    for(upb_msg_field_begin(&j, m);
-        !upb_msg_field_done(&j);
-        upb_msg_field_next(&j)) {
-      upb_fielddef *f = upb_msg_iter_field(&j);
-      const char *name = upb_fielddef_subdefname(f);
-      if (name && !upb_fielddef_subdef(f)) {
-        /* Try the lookup in the current set of to-be-added defs first. If not
-         * there, try existing defs. */
-        upb_def *subdef = upb_resolvename(&addtab, base, name);
-        if (subdef == NULL) {
-          subdef = upb_resolvename(&s->symtab, base, name);
-        }
-        if (subdef == NULL) {
-          upb_status_seterrf(
-              status, "couldn't resolve name '%s' in message '%s'", name, base);
-          goto err;
-        } else if (!upb_fielddef_setsubdef(f, subdef, status)) {
-          goto err;
-        }
-      }
+  count_types_in_file(file_proto, &counts);
+
+  file->msgs = upb_malloc(alloc, sizeof(*file->msgs) * counts.msg_count);
+  file->enums = upb_malloc(alloc, sizeof(*file->enums) * counts.enum_count);
+  file->exts = upb_malloc(alloc, sizeof(*file->exts) * counts.ext_count);
+
+  CHK_OOM(counts.msg_count == 0 || file->msgs);
+  CHK_OOM(counts.enum_count == 0 || file->enums);
+  CHK_OOM(counts.ext_count == 0 || file->exts);
+
+  /* We increment these as defs are added. */
+  file->msg_count = 0;
+  file->enum_count = 0;
+  file->ext_count = 0;
+
+  if (!google_protobuf_FileDescriptorProto_has_name(file_proto)) {
+    upb_status_seterrmsg(ctx->status, "File has no name");
+    return false;
+  }
+
+  file->name =
+      strviewdup(ctx, google_protobuf_FileDescriptorProto_name(file_proto));
+  file->phpprefix = NULL;
+  file->phpnamespace = NULL;
+
+  if (google_protobuf_FileDescriptorProto_has_package(file_proto)) {
+    upb_strview package =
+        google_protobuf_FileDescriptorProto_package(file_proto);
+    CHK(upb_isident(package, true, ctx->status));
+    file->package = strviewdup(ctx, package);
+  } else {
+    file->package = NULL;
+  }
+
+  if (google_protobuf_FileDescriptorProto_has_syntax(file_proto)) {
+    upb_strview syntax =
+        google_protobuf_FileDescriptorProto_syntax(file_proto);
+
+    if (streql_view(syntax, "proto2")) {
+      file->syntax = UPB_SYNTAX_PROTO2;
+    } else if (streql_view(syntax, "proto3")) {
+      file->syntax = UPB_SYNTAX_PROTO3;
+    } else {
+      upb_status_seterrf(ctx->status, "Invalid syntax '%s'", syntax);
+      return false;
     }
+  } else {
+    file->syntax = UPB_SYNTAX_PROTO2;
   }
 
-  /* We need an array of the defs in addtab, for passing to
-   * upb_refcounted_freeze(). */
-  add_objs_size = upb_strtable_count(&addtab);
-  if (freeze_also) {
-    add_objs_size++;
+  /* Read options. */
+  file_options_proto = google_protobuf_FileDescriptorProto_options(file_proto);
+  if (file_options_proto) {
+    if (google_protobuf_FileOptions_has_php_class_prefix(file_options_proto)) {
+      file->phpprefix = strviewdup(
+          ctx,
+          google_protobuf_FileOptions_php_class_prefix(file_options_proto));
+    }
+    if (google_protobuf_FileOptions_has_php_namespace(file_options_proto)) {
+      file->phpnamespace = strviewdup(
+          ctx, google_protobuf_FileOptions_php_namespace(file_options_proto));
+    }
   }
 
-  add_defs = upb_gmalloc(sizeof(void*) * add_objs_size);
-  if (add_defs == NULL) goto oom_err;
-  upb_strtable_begin(&iter, &addtab);
-  for (add_n = 0; !upb_strtable_done(&iter); upb_strtable_next(&iter)) {
-    add_defs[add_n++] = upb_value_getptr(upb_strtable_iter_value(&iter));
+  /* Verify dependencies. */
+  strs = google_protobuf_FileDescriptorProto_dependency(file_proto, &n);
+  file->deps = upb_malloc(alloc, sizeof(*file->deps) * n) ;
+  CHK_OOM(n == 0 || file->deps);
+
+  for (i = 0; i < n; i++) {
+    upb_strview dep_name = strs[i];
+    upb_value v;
+    if (!upb_strtable_lookup2(&ctx->symtab->files, dep_name.data,
+                              dep_name.size, &v)) {
+      upb_status_seterrf(ctx->status,
+                         "Depends on file '" UPB_STRVIEW_FORMAT
+                         "', but it has not been loaded",
+                         UPB_STRVIEW_ARGS(dep_name));
+      return false;
+    }
+    file->deps[i] = upb_value_getconstptr(v);
   }
 
-  /* Validate defs. */
-  if (!_upb_def_validate(add_defs, add_n, status)) {
-    goto err;
+  /* Create messages. */
+  msgs = google_protobuf_FileDescriptorProto_message_type(file_proto, &n);
+  for (i = 0; i < n; i++) {
+    CHK(create_msgdef(ctx, file->package, msgs[i]));
   }
 
-  /* Cheat a little and give the array a new type.
-   * This is probably undefined behavior, but this code will be deleted soon. */
-  add_objs = (upb_refcounted**)add_defs;
+  /* Create enums. */
+  enums = google_protobuf_FileDescriptorProto_enum_type(file_proto, &n);
+  for (i = 0; i < n; i++) {
+    CHK(create_enumdef(ctx, file->package, enums[i]));
+  }
 
-  freeze_n = add_n;
-  if (freeze_also) {
-    add_objs[freeze_n++] = freeze_also;
+  /* Create extensions. */
+  exts = google_protobuf_FileDescriptorProto_extension(file_proto, &n);
+  file->exts = upb_malloc(alloc, sizeof(*file->exts) * n);
+  CHK_OOM(n == 0 || file->exts);
+  for (i = 0; i < n; i++) {
+    CHK(create_fielddef(ctx, file->package, NULL, exts[i]));
   }
 
-  if (!upb_refcounted_freeze(add_objs, freeze_n, status,
-                             UPB_MAX_MESSAGE_DEPTH * 2)) {
-    goto err;
+  /* Now that all names are in the table, resolve references. */
+  for (i = 0; i < file->ext_count; i++) {
+    CHK(resolve_fielddef(ctx, file->package, (upb_fielddef*)&file->exts[i]));
   }
 
-  /* This must be delayed until all errors have been detected, since error
-   * recovery code uses this table to cleanup defs. */
-  upb_strtable_uninit(&addtab);
-
-  /* TODO(haberman) we don't properly handle errors after this point (like
-   * OOM in upb_strtable_insert() below). */
-  for (i = 0; i < add_n; i++) {
-    upb_def *def = (upb_def*)add_objs[i];
-    const char *name = upb_def_fullname(def);
-    bool success;
-    success = upb_strtable_insert(&s->symtab, name, upb_value_ptr(def));
-    UPB_ASSERT(success);
+  for (i = 0; i < file->msg_count; i++) {
+    const upb_msgdef *m = &file->msgs[i];
+    int j;
+    for (j = 0; j < m->field_count; j++) {
+      CHK(resolve_fielddef(ctx, m->full_name, (upb_fielddef*)&m->fields[j]));
+    }
   }
-  upb_gfree(add_defs);
+
   return true;
+ }
 
-oom_err:
-  upb_status_seterrmsg(status, "out of memory");
-err: {
-    /* We need to donate the refs back. */
-    upb_strtable_begin(&iter, &addtab);
-    for (; !upb_strtable_done(&iter); upb_strtable_next(&iter)) {
-      upb_def *def = upb_value_getptr(upb_strtable_iter_value(&iter));
-      upb_def_donateref(def, s, ref_donor);
-    }
+static bool upb_symtab_addtotabs(upb_symtab *s, symtab_addctx *ctx,
+                                 upb_status *status) {
+  const upb_filedef *file = ctx->file;
+  upb_alloc *alloc = upb_arena_alloc(s->arena);
+  upb_strtable_iter iter;
+
+  CHK_OOM(upb_strtable_insert3(&s->files, file->name, strlen(file->name),
+                               upb_value_constptr(file), alloc));
+
+  upb_strtable_begin(&iter, ctx->addtab);
+  for (; !upb_strtable_done(&iter); upb_strtable_next(&iter)) {
+    const char *key = upb_strtable_iter_key(&iter);
+    size_t keylen = upb_strtable_iter_keylength(&iter);
+    upb_value value = upb_strtable_iter_value(&iter);
+    CHK_OOM(upb_strtable_insert3(&s->syms, key, keylen, value, alloc));
   }
-  upb_strtable_uninit(&addtab);
-  upb_gfree(add_defs);
-  UPB_ASSERT(!upb_ok(status));
-  return false;
+
+  return true;
 }
 
-bool upb_symtab_add(upb_symtab *s, upb_def *const*defs, size_t n,
-                    void *ref_donor, upb_status *status) {
-  return symtab_add(s, defs, n, ref_donor, NULL, status);
+/* upb_filedef ****************************************************************/
+
+const char *upb_filedef_name(const upb_filedef *f) {
+  return f->name;
 }
 
-bool upb_symtab_addfile(upb_symtab *s, upb_filedef *file, upb_status *status) {
-  size_t n;
-  size_t i;
-  upb_def **defs;
-  bool ret;
+const char *upb_filedef_package(const upb_filedef *f) {
+  return f->package;
+}
 
-  n = upb_filedef_defcount(file);
-  if (n == 0) {
-    return true;
-  }
-  defs = upb_gmalloc(sizeof(*defs) * n);
+const char *upb_filedef_phpprefix(const upb_filedef *f) {
+  return f->phpprefix;
+}
 
-  if (defs == NULL) {
-    upb_status_seterrmsg(status, "Out of memory");
-    return false;
-  }
+const char *upb_filedef_phpnamespace(const upb_filedef *f) {
+  return f->phpnamespace;
+}
 
-  for (i = 0; i < n; i++) {
-    defs[i] = upb_filedef_mutabledef(file, i);
-  }
+upb_syntax_t upb_filedef_syntax(const upb_filedef *f) {
+  return f->syntax;
+}
+
+int upb_filedef_msgcount(const upb_filedef *f) {
+  return f->msg_count;
+}
 
-  ret = symtab_add(s, defs, n, NULL, upb_filedef_upcast_mutable(file), status);
+int upb_filedef_depcount(const upb_filedef *f) {
+  return f->dep_count;
+}
 
-  upb_gfree(defs);
-  return ret;
+int upb_filedef_enumcount(const upb_filedef *f) {
+  return f->enum_count;
 }
 
-/* Iteration. */
+const upb_filedef *upb_filedef_dep(const upb_filedef *f, int i) {
+  return i < 0 || i >= f->dep_count ? NULL : f->deps[i];
+}
 
-static void advance_to_matching(upb_symtab_iter *iter) {
-  if (iter->type == UPB_DEF_ANY)
-    return;
+const upb_msgdef *upb_filedef_msg(const upb_filedef *f, int i) {
+  return i < 0 || i >= f->msg_count ? NULL : &f->msgs[i];
+}
+
+const upb_enumdef *upb_filedef_enum(const upb_filedef *f, int i) {
+  return i < 0 || i >= f->enum_count ? NULL : &f->enums[i];
+}
+
+void upb_symtab_free(upb_symtab *s) {
+  upb_arena_free(s->arena);
+  upb_gfree(s);
+}
+
+upb_symtab *upb_symtab_new() {
+  upb_symtab *s = upb_gmalloc(sizeof(*s));
+  upb_alloc *alloc;
 
-  while (!upb_strtable_done(&iter->iter) &&
-         iter->type != upb_symtab_iter_def(iter)->type) {
-    upb_strtable_next(&iter->iter);
+  if (!s) {
+    return NULL;
   }
+
+  s->arena = upb_arena_new();
+  alloc = upb_arena_alloc(s->arena);
+
+  if (!upb_strtable_init2(&s->syms, UPB_CTYPE_CONSTPTR, alloc) ||
+      !upb_strtable_init2(&s->files, UPB_CTYPE_CONSTPTR, alloc)) {
+    upb_arena_free(s->arena);
+    upb_gfree(s);
+    s = NULL;
+  }
+  return s;
+}
+
+const upb_msgdef *upb_symtab_lookupmsg(const upb_symtab *s, const char *sym) {
+  upb_value v;
+  return upb_strtable_lookup(&s->syms, sym, &v) ?
+      unpack_def(v, UPB_DEFTYPE_MSG) : NULL;
+}
+
+const upb_msgdef *upb_symtab_lookupmsg2(const upb_symtab *s, const char *sym,
+                                        size_t len) {
+  upb_value v;
+  return upb_strtable_lookup2(&s->syms, sym, len, &v) ?
+      unpack_def(v, UPB_DEFTYPE_MSG) : NULL;
 }
 
-void upb_symtab_begin(upb_symtab_iter *iter, const upb_symtab *s,
-                      upb_deftype_t type) {
-  upb_strtable_begin(&iter->iter, &s->symtab);
-  iter->type = type;
-  advance_to_matching(iter);
+const upb_enumdef *upb_symtab_lookupenum(const upb_symtab *s, const char *sym) {
+  upb_value v;
+  return upb_strtable_lookup(&s->syms, sym, &v) ?
+      unpack_def(v, UPB_DEFTYPE_ENUM) : NULL;
 }
 
-void upb_symtab_next(upb_symtab_iter *iter) {
-  upb_strtable_next(&iter->iter);
-  advance_to_matching(iter);
+const upb_filedef *upb_symtab_lookupfile(const upb_symtab *s, const char *name) {
+  upb_value v;
+  return upb_strtable_lookup(&s->files, name, &v) ? upb_value_getconstptr(v)
+                                                  : NULL;
 }
 
-bool upb_symtab_done(const upb_symtab_iter *iter) {
-  return upb_strtable_done(&iter->iter);
+const upb_filedef *upb_symtab_addfile(
+    upb_symtab *s, const google_protobuf_FileDescriptorProto *file_proto,
+    upb_status *status) {
+  upb_arena *tmparena = upb_arena_new();
+  upb_strtable addtab;
+  upb_alloc *alloc = upb_arena_alloc(s->arena);
+  upb_filedef *file = upb_malloc(alloc, sizeof(*file));
+  bool ok;
+  symtab_addctx ctx;
+
+  ctx.file = file;
+  ctx.symtab = s;
+  ctx.alloc = alloc;
+  ctx.tmp = upb_arena_alloc(tmparena);
+  ctx.addtab = &addtab;
+  ctx.status = status;
+
+  ok = file &&
+      upb_strtable_init2(&addtab, UPB_CTYPE_CONSTPTR, ctx.tmp) &&
+      build_filedef(&ctx, file, file_proto) &&
+      upb_symtab_addtotabs(s, &ctx, status);
+
+  upb_arena_free(tmparena);
+  return ok ? file : NULL;
 }
 
-const upb_def *upb_symtab_iter_def(const upb_symtab_iter *iter) {
-  return upb_value_getptr(upb_strtable_iter_value(&iter->iter));
+/* Include here since we want most of this file to be stdio-free. */
+#include <stdio.h>
+
+bool _upb_symtab_loaddefinit(upb_symtab *s, const upb_def_init *init) {
+  /* Since this function should never fail (it would indicate a bug in upb) we
+   * print errors to stderr instead of returning error status to the user. */
+  upb_def_init **deps = init->deps;
+  google_protobuf_FileDescriptorProto *file;
+  upb_arena *arena;
+  upb_status status;
+
+  upb_status_clear(&status);
+
+  if (upb_strtable_lookup(&s->files, init->filename, NULL)) {
+    return true;
+  }
+
+  arena = upb_arena_new();
+
+  for (; *deps; deps++) {
+    if (!_upb_symtab_loaddefinit(s, *deps)) goto err;
+  }
+
+  file = google_protobuf_FileDescriptorProto_parse(
+      init->descriptor.data, init->descriptor.size, arena);
+
+  if (!file) {
+    upb_status_seterrf(
+        &status,
+        "Failed to parse compiled-in descriptor for file '%s'. This should "
+        "never happen.",
+        init->filename);
+    goto err;
+  }
+
+  if (!upb_symtab_addfile(s, file, &status)) goto err;
+
+  upb_arena_free(arena);
+  return true;
+
+err:
+  fprintf(stderr, "Error loading compiled-in descriptor: %s\n",
+          upb_status_errmsg(&status));
+  upb_arena_free(arena);
+  return false;
 }
+
+#undef CHK
+#undef CHK_OOM
diff --git a/upb/def.h b/upb/def.h
index ea22e40..c585aa8 100644
--- a/upb/def.h
+++ b/upb/def.h
@@ -2,18 +2,14 @@
 ** Defs are upb's internal representation of the constructs that can appear
 ** in a .proto file:
 **
-** - upb::MessageDef (upb_msgdef): describes a "message" construct.
-** - upb::FieldDef (upb_fielddef): describes a message field.
-** - upb::FileDef (upb_filedef): describes a .proto file and its defs.
-** - upb::EnumDef (upb_enumdef): describes an enum.
-** - upb::OneofDef (upb_oneofdef): describes a oneof.
-** - upb::Def (upb_def): base class of all the others.
+** - upb::MessageDefPtr (upb_msgdef): describes a "message" construct.
+** - upb::FieldDefPtr (upb_fielddef): describes a message field.
+** - upb::FileDefPtr (upb_filedef): describes a .proto file and its defs.
+** - upb::EnumDefPtr (upb_enumdef): describes an enum.
+** - upb::OneofDefPtr (upb_oneofdef): describes a oneof.
 **
 ** TODO: definitions of services.
 **
-** Like upb_refcounted objects, defs are mutable only until frozen, and are
-** only thread-safe once frozen.
-**
 ** This is a mixed C/C++ interface that offers a full API to both languages.
 ** See the top-level README for more information.
 */
@@ -21,273 +17,38 @@
 #ifndef UPB_DEF_H_
 #define UPB_DEF_H_
 
-#include "upb/refcounted.h"
+#include "upb/upb.h"
+#include "upb/table.int.h"
+#include "google/protobuf/descriptor.upb.h"
 
 #ifdef __cplusplus
 #include <cstring>
+#include <memory>
 #include <string>
 #include <vector>
 
 namespace upb {
-class Def;
-class EnumDef;
-class FieldDef;
-class FileDef;
-class MessageDef;
-class OneofDef;
+class EnumDefPtr;
+class FieldDefPtr;
+class FileDefPtr;
+class MessageDefPtr;
+class OneofDefPtr;
 class SymbolTable;
 }
 #endif
 
-UPB_DECLARE_DERIVED_TYPE(upb::Def, upb::RefCounted, upb_def, upb_refcounted)
-UPB_DECLARE_DERIVED_TYPE(upb::OneofDef, upb::RefCounted, upb_oneofdef,
-                         upb_refcounted)
-UPB_DECLARE_DERIVED_TYPE(upb::FileDef, upb::RefCounted, upb_filedef,
-                         upb_refcounted)
-UPB_DECLARE_TYPE(upb::SymbolTable, upb_symtab)
-
-
-/* The maximum message depth that the type graph can have.  This is a resource
- * limit for the C stack since we sometimes need to recursively traverse the
- * graph.  Cycles are ok; the traversal will stop when it detects a cycle, but
- * we must hit the cycle before the maximum depth is reached.
- *
- * If having a single static limit is too inflexible, we can add another variant
- * of Def::Freeze that allows specifying this as a parameter. */
-#define UPB_MAX_MESSAGE_DEPTH 64
-
-
-/* upb::Def: base class for top-level defs  ***********************************/
-
-/* All the different kind of defs that can be defined at the top-level and put
- * in a SymbolTable or appear in a FileDef::defs() list.  This excludes some
- * defs (like oneofs and files).  It only includes fields because they can be
- * defined as extensions. */
-typedef enum {
-  UPB_DEF_MSG,
-  UPB_DEF_FIELD,
-  UPB_DEF_ENUM,
-  UPB_DEF_SERVICE,   /* Not yet implemented. */
-  UPB_DEF_ANY = -1   /* Wildcard for upb_symtab_get*() */
-} upb_deftype_t;
-
-#ifdef __cplusplus
-
-/* The base class of all defs.  Its base is upb::RefCounted (use upb::upcast()
- * to convert). */
-class upb::Def {
- public:
-  typedef upb_deftype_t Type;
-
-  /* upb::RefCounted methods like Ref()/Unref(). */
-  UPB_REFCOUNTED_CPPMETHODS
-
-  Type def_type() const;
-
-  /* "fullname" is the def's fully-qualified name (eg. foo.bar.Message). */
-  const char *full_name() const;
-
-  /* The final part of a def's name (eg. Message). */
-  const char *name() const;
-
-  /* The def must be mutable.  Caller retains ownership of fullname.  Defs are
-   * not required to have a name; if a def has no name when it is frozen, it
-   * will remain an anonymous def.  On failure, returns false and details in "s"
-   * if non-NULL. */
-  bool set_full_name(const char* fullname, upb::Status* s);
-  bool set_full_name(const std::string &fullname, upb::Status* s);
-
-  /* The file in which this def appears.  It is not necessary to add a def to a
-   * file (and consequently the accessor may return NULL).  Set this by calling
-   * file->Add(def). */
-  FileDef* file() const;
-
-  /* Freezes the given defs; this validates all constraints and marks the defs
-   * as frozen (read-only).  "defs" may not contain any fielddefs, but fields
-   * of any msgdefs will be frozen.
-   *
-   * Symbolic references to sub-types and enum defaults must have already been
-   * resolved.  Any mutable defs reachable from any of "defs" must also be in
-   * the list; more formally, "defs" must be a transitive closure of mutable
-   * defs.
-   *
-   * After this operation succeeds, the finalized defs must only be accessed
-   * through a const pointer! */
-  static bool Freeze(Def* const* defs, size_t n, Status* status);
-  static bool Freeze(const std::vector<Def*>& defs, Status* status);
-
- private:
-  UPB_DISALLOW_POD_OPS(Def, upb::Def)
-#else
-struct upb_def {
-  upb_refcounted base;
-
-  const char *fullname;
-  const upb_filedef* file;
-  char type;  /* A upb_deftype_t (char to save space) */
-
-  /* Used as a flag during the def's mutable stage.  Must be false unless
-   * it is currently being used by a function on the stack.  This allows
-   * us to easily determine which defs were passed into the function's
-   * current invocation. */
-  bool came_from_user;
-#endif
-};
-
-#define UPB_DEF_INIT(name, type, vtbl, refs, ref2s) \
-    { UPB_REFCOUNT_INIT(vtbl, refs, ref2s), name, NULL, type, false }
-
-UPB_BEGIN_EXTERN_C
-
-/* Include upb_refcounted methods like upb_def_ref()/upb_def_unref(). */
-UPB_REFCOUNTED_CMETHODS(upb_def, upb_def_upcast)
-
-upb_deftype_t upb_def_type(const upb_def *d);
-const char *upb_def_fullname(const upb_def *d);
-const char *upb_def_name(const upb_def *d);
-const upb_filedef *upb_def_file(const upb_def *d);
-bool upb_def_setfullname(upb_def *def, const char *fullname, upb_status *s);
-bool upb_def_freeze(upb_def *const *defs, size_t n, upb_status *s);
-
-/* Temporary API: for internal use only. */
-bool _upb_def_validate(upb_def *const*defs, size_t n, upb_status *s);
-
-UPB_END_EXTERN_C
-
-
-/* upb::Def casts *************************************************************/
-
-#ifdef __cplusplus
-#define UPB_CPP_CASTS(cname, cpptype)                                          \
-  namespace upb {                                                              \
-  template <>                                                                  \
-  inline cpptype *down_cast<cpptype *, Def>(Def * def) {                       \
-    return upb_downcast_##cname##_mutable(def);                                \
-  }                                                                            \
-  template <>                                                                  \
-  inline cpptype *dyn_cast<cpptype *, Def>(Def * def) {                        \
-    return upb_dyncast_##cname##_mutable(def);                                 \
-  }                                                                            \
-  template <>                                                                  \
-  inline const cpptype *down_cast<const cpptype *, const Def>(                 \
-      const Def *def) {                                                        \
-    return upb_downcast_##cname(def);                                          \
-  }                                                                            \
-  template <>                                                                  \
-  inline const cpptype *dyn_cast<const cpptype *, const Def>(const Def *def) { \
-    return upb_dyncast_##cname(def);                                           \
-  }                                                                            \
-  template <>                                                                  \
-  inline const cpptype *down_cast<const cpptype *, Def>(Def * def) {           \
-    return upb_downcast_##cname(def);                                          \
-  }                                                                            \
-  template <>                                                                  \
-  inline const cpptype *dyn_cast<const cpptype *, Def>(Def * def) {            \
-    return upb_dyncast_##cname(def);                                           \
-  }                                                                            \
-  }  /* namespace upb */
-#else
-#define UPB_CPP_CASTS(cname, cpptype)
-#endif  /* __cplusplus */
-
-/* Dynamic casts, for determining if a def is of a particular type at runtime.
- * Downcasts, for when some wants to assert that a def is of a particular type.
- * These are only checked if we are building debug. */
-#define UPB_DEF_CASTS(lower, upper, cpptype)                               \
-  UPB_INLINE const upb_##lower *upb_dyncast_##lower(const upb_def *def) {  \
-    if (upb_def_type(def) != UPB_DEF_##upper) return NULL;                 \
-    return (upb_##lower *)def;                                             \
-  }                                                                        \
-  UPB_INLINE const upb_##lower *upb_downcast_##lower(const upb_def *def) { \
-    UPB_ASSERT(upb_def_type(def) == UPB_DEF_##upper);                          \
-    return (const upb_##lower *)def;                                       \
-  }                                                                        \
-  UPB_INLINE upb_##lower *upb_dyncast_##lower##_mutable(upb_def *def) {    \
-    return (upb_##lower *)upb_dyncast_##lower(def);                        \
-  }                                                                        \
-  UPB_INLINE upb_##lower *upb_downcast_##lower##_mutable(upb_def *def) {   \
-    return (upb_##lower *)upb_downcast_##lower(def);                       \
-  }                                                                        \
-  UPB_CPP_CASTS(lower, cpptype)
-
-#define UPB_DEFINE_DEF(cppname, lower, upper, cppmethods, members)             \
-  UPB_DEFINE_CLASS2(cppname, upb::Def, upb::RefCounted, cppmethods,            \
-                   members)                                                    \
-  UPB_DEF_CASTS(lower, upper, cppname)
-
-#define UPB_DECLARE_DEF_TYPE(cppname, lower, upper) \
-  UPB_DECLARE_DERIVED_TYPE2(cppname, upb::Def, upb::RefCounted, \
-                            upb_ ## lower, upb_def, upb_refcounted) \
-  UPB_DEF_CASTS(lower, upper, cppname)
-
-UPB_DECLARE_DEF_TYPE(upb::FieldDef, fielddef, FIELD)
-UPB_DECLARE_DEF_TYPE(upb::MessageDef, msgdef, MSG)
-UPB_DECLARE_DEF_TYPE(upb::EnumDef, enumdef, ENUM)
-
-#undef UPB_DECLARE_DEF_TYPE
-#undef UPB_DEF_CASTS
-#undef UPB_CPP_CASTS
-
-
-/* upb::FieldDef **************************************************************/
-
-/* The types a field can have.  Note that this list is not identical to the
- * types defined in descriptor.proto, which gives INT32 and SINT32 separate
- * types (we distinguish the two with the "integer encoding" enum below). */
-typedef enum {
-  /* Types stored in 1 byte. */
-  UPB_TYPE_BOOL     = 1,
-  /* Types stored in 4 bytes. */
-  UPB_TYPE_FLOAT    = 2,
-  UPB_TYPE_INT32    = 3,
-  UPB_TYPE_UINT32   = 4,
-  UPB_TYPE_ENUM     = 5,  /* Enum values are int32. */
-  /* Types stored as pointers (probably 4 or 8 bytes). */
-  UPB_TYPE_STRING   = 6,
-  UPB_TYPE_BYTES    = 7,
-  UPB_TYPE_MESSAGE  = 8,
-  /* Types stored as 8 bytes. */
-  UPB_TYPE_DOUBLE   = 9,
-  UPB_TYPE_INT64    = 10,
-  UPB_TYPE_UINT64   = 11
-} upb_fieldtype_t;
-
-/* The repeated-ness of each field; this matches descriptor.proto. */
-typedef enum {
-  UPB_LABEL_OPTIONAL = 1,
-  UPB_LABEL_REQUIRED = 2,
-  UPB_LABEL_REPEATED = 3
-} upb_label_t;
-
-/* How integers should be encoded in serializations that offer multiple
- * integer encoding methods. */
-typedef enum {
-  UPB_INTFMT_VARIABLE = 1,
-  UPB_INTFMT_FIXED = 2,
-  UPB_INTFMT_ZIGZAG = 3   /* Only for signed types (INT32/INT64). */
-} upb_intfmt_t;
-
-/* Descriptor types, as defined in descriptor.proto. */
-typedef enum {
-  UPB_DESCRIPTOR_TYPE_DOUBLE   = 1,
-  UPB_DESCRIPTOR_TYPE_FLOAT    = 2,
-  UPB_DESCRIPTOR_TYPE_INT64    = 3,
-  UPB_DESCRIPTOR_TYPE_UINT64   = 4,
-  UPB_DESCRIPTOR_TYPE_INT32    = 5,
-  UPB_DESCRIPTOR_TYPE_FIXED64  = 6,
-  UPB_DESCRIPTOR_TYPE_FIXED32  = 7,
-  UPB_DESCRIPTOR_TYPE_BOOL     = 8,
-  UPB_DESCRIPTOR_TYPE_STRING   = 9,
-  UPB_DESCRIPTOR_TYPE_GROUP    = 10,
-  UPB_DESCRIPTOR_TYPE_MESSAGE  = 11,
-  UPB_DESCRIPTOR_TYPE_BYTES    = 12,
-  UPB_DESCRIPTOR_TYPE_UINT32   = 13,
-  UPB_DESCRIPTOR_TYPE_ENUM     = 14,
-  UPB_DESCRIPTOR_TYPE_SFIXED32 = 15,
-  UPB_DESCRIPTOR_TYPE_SFIXED64 = 16,
-  UPB_DESCRIPTOR_TYPE_SINT32   = 17,
-  UPB_DESCRIPTOR_TYPE_SINT64   = 18
-} upb_descriptortype_t;
+struct upb_enumdef;
+typedef struct upb_enumdef upb_enumdef;
+struct upb_fielddef;
+typedef struct upb_fielddef upb_fielddef;
+struct upb_filedef;
+typedef struct upb_filedef upb_filedef;
+struct upb_msgdef;
+typedef struct upb_msgdef upb_msgdef;
+struct upb_oneofdef;
+typedef struct upb_oneofdef upb_oneofdef;
+struct upb_symtab;
+typedef struct upb_symtab upb_symtab;
 
 typedef enum {
   UPB_SYNTAX_PROTO2 = 2,
@@ -320,56 +81,75 @@ typedef enum {
   UPB_WELLKNOWN_STRUCT
 } upb_wellknowntype_t;
 
-
-/* Maps descriptor type -> upb field type.  */
-extern const uint8_t upb_desctype_to_fieldtype[];
+/* upb_fielddef ***************************************************************/
 
 /* Maximum field number allowed for FieldDefs.  This is an inherent limit of the
  * protobuf wire format. */
 #define UPB_MAX_FIELDNUMBER ((1 << 29) - 1)
 
 #ifdef __cplusplus
+extern "C" {
+#endif
+
+const char *upb_fielddef_fullname(const upb_fielddef *f);
+upb_fieldtype_t upb_fielddef_type(const upb_fielddef *f);
+upb_descriptortype_t upb_fielddef_descriptortype(const upb_fielddef *f);
+upb_label_t upb_fielddef_label(const upb_fielddef *f);
+uint32_t upb_fielddef_number(const upb_fielddef *f);
+const char *upb_fielddef_name(const upb_fielddef *f);
+bool upb_fielddef_isextension(const upb_fielddef *f);
+bool upb_fielddef_lazy(const upb_fielddef *f);
+bool upb_fielddef_packed(const upb_fielddef *f);
+size_t upb_fielddef_getjsonname(const upb_fielddef *f, char *buf, size_t len);
+const upb_msgdef *upb_fielddef_containingtype(const upb_fielddef *f);
+const upb_oneofdef *upb_fielddef_containingoneof(const upb_fielddef *f);
+uint32_t upb_fielddef_index(const upb_fielddef *f);
+bool upb_fielddef_issubmsg(const upb_fielddef *f);
+bool upb_fielddef_isstring(const upb_fielddef *f);
+bool upb_fielddef_isseq(const upb_fielddef *f);
+bool upb_fielddef_isprimitive(const upb_fielddef *f);
+bool upb_fielddef_ismap(const upb_fielddef *f);
+int64_t upb_fielddef_defaultint64(const upb_fielddef *f);
+int32_t upb_fielddef_defaultint32(const upb_fielddef *f);
+uint64_t upb_fielddef_defaultuint64(const upb_fielddef *f);
+uint32_t upb_fielddef_defaultuint32(const upb_fielddef *f);
+bool upb_fielddef_defaultbool(const upb_fielddef *f);
+float upb_fielddef_defaultfloat(const upb_fielddef *f);
+double upb_fielddef_defaultdouble(const upb_fielddef *f);
+const char *upb_fielddef_defaultstr(const upb_fielddef *f, size_t *len);
+bool upb_fielddef_hassubdef(const upb_fielddef *f);
+bool upb_fielddef_haspresence(const upb_fielddef *f);
+const upb_msgdef *upb_fielddef_msgsubdef(const upb_fielddef *f);
+const upb_enumdef *upb_fielddef_enumsubdef(const upb_fielddef *f);
+
+/* Internal only. */
+uint32_t upb_fielddef_selectorbase(const upb_fielddef *f);
+
+#ifdef __cplusplus
+}  /* extern "C" */
 
 /* A upb_fielddef describes a single field in a message.  It is most often
  * found as a part of a upb_msgdef, but can also stand alone to represent
- * an extension.
- *
- * Its base class is upb::Def (use upb::upcast() to convert). */
-class upb::FieldDef {
+ * an extension. */
+class upb::FieldDefPtr {
  public:
+  FieldDefPtr() : ptr_(nullptr) {}
+  explicit FieldDefPtr(const upb_fielddef *ptr) : ptr_(ptr) {}
+
+  const upb_fielddef* ptr() const { return ptr_; }
+  explicit operator bool() const { return ptr_ != nullptr; }
+
   typedef upb_fieldtype_t Type;
   typedef upb_label_t Label;
-  typedef upb_intfmt_t IntegerFormat;
   typedef upb_descriptortype_t DescriptorType;
 
-  /* These return true if the given value is a valid member of the enumeration. */
-  static bool CheckType(int32_t val);
-  static bool CheckLabel(int32_t val);
-  static bool CheckDescriptorType(int32_t val);
-  static bool CheckIntegerFormat(int32_t val);
-
-  /* These convert to the given enumeration; they require that the value is
-   * valid. */
-  static Type ConvertType(int32_t val);
-  static Label ConvertLabel(int32_t val);
-  static DescriptorType ConvertDescriptorType(int32_t val);
-  static IntegerFormat ConvertIntegerFormat(int32_t val);
+  const char* full_name() const { return upb_fielddef_fullname(ptr_); }
 
-  /* Returns NULL if memory allocation failed. */
-  static reffed_ptr<FieldDef> New();
-
-  /* upb::RefCounted methods like Ref()/Unref(). */
-  UPB_REFCOUNTED_CPPMETHODS
-
-  /* Functionality from upb::Def. */
-  const char* full_name() const;
-
-  bool type_is_set() const;  /* set_[descriptor_]type() has been called? */
-  Type type() const;         /* Requires that type_is_set() == true. */
-  Label label() const;       /* Defaults to UPB_LABEL_OPTIONAL. */
-  const char* name() const;  /* NULL if uninitialized. */
-  uint32_t number() const;   /* Returns 0 if uninitialized. */
-  bool is_extension() const;
+  Type type() const { return upb_fielddef_type(ptr_); }
+  Label label() const { return upb_fielddef_label(ptr_); }
+  const char* name() const { return upb_fielddef_name(ptr_); }
+  uint32_t number() const { return upb_fielddef_number(ptr_); }
+  bool is_extension() const { return upb_fielddef_isextension(ptr_); }
 
   /* Copies the JSON name for this field into the given buffer.  Returns the
    * actual size of the JSON name, including the NULL terminator.  If the
@@ -381,7 +161,9 @@ class upb::FieldDef {
    * name.  However if the regular name is unset, the JSON name will be unset
    * also.
    */
-  size_t GetJsonName(char* buf, size_t len) const;
+  size_t GetJsonName(char *buf, size_t len) const {
+    return upb_fielddef_getjsonname(ptr_, buf, len);
+  }
 
   /* Convenience version of the above function which copies the JSON name
    * into the given string, returning false if the name is not set. */
@@ -399,20 +181,20 @@ class upb::FieldDef {
    * TODO(haberman): I think we want to move this into a FieldOptions container
    * when we add support for custom options (the FieldOptions struct will
    * contain both regular FieldOptions like "lazy" *and* custom options). */
-  bool lazy() const;
+  bool lazy() const { return upb_fielddef_lazy(ptr_); }
 
   /* For non-string, non-submessage fields, this indicates whether binary
    * protobufs are encoded in packed or non-packed format.
    *
    * TODO(haberman): see note above about putting options like this into a
    * FieldOptions container. */
-  bool packed() const;
+  bool packed() const { return upb_fielddef_packed(ptr_); }
 
   /* An integer that can be used as an index into an array of fields for
    * whatever message this field belongs to.  Guaranteed to be less than
    * f->containing_type()->field_count().  May only be accessed once the def has
    * been finalized. */
-  uint32_t index() const;
+  uint32_t index() const { return upb_fielddef_index(ptr_); }
 
   /* The MessageDef to which this field belongs.
    *
@@ -422,41 +204,27 @@ class upb::FieldDef {
    * If the field has not yet been added to a MessageDef, you can set the name
    * of the containing type symbolically instead.  This is mostly useful for
    * extensions, where the extension is declared separately from the message. */
-  const MessageDef* containing_type() const;
-  const char* containing_type_name();
+  MessageDefPtr containing_type() const;
 
   /* The OneofDef to which this field belongs, or NULL if this field is not part
    * of a oneof. */
-  const OneofDef* containing_oneof() const;
+  OneofDefPtr containing_oneof() const;
 
   /* The field's type according to the enum in descriptor.proto.  This is not
    * the same as UPB_TYPE_*, because it distinguishes between (for example)
    * INT32 and SINT32, whereas our "type" enum does not.  This return of
    * descriptor_type() is a function of type(), integer_format(), and
-   * is_tag_delimited().  Likewise set_descriptor_type() sets all three
-   * appropriately. */
-  DescriptorType descriptor_type() const;
+   * is_tag_delimited().  */
+  DescriptorType descriptor_type() const {
+    return upb_fielddef_descriptortype(ptr_);
+  }
 
   /* Convenient field type tests. */
-  bool IsSubMessage() const;
-  bool IsString() const;
-  bool IsSequence() const;
-  bool IsPrimitive() const;
-  bool IsMap() const;
-
-  /* Returns whether this field explicitly represents presence.
-   *
-   * For proto2 messages: Returns true for any scalar (non-repeated) field.
-   * For proto3 messages: Returns true for scalar submessage or oneof fields. */
-  bool HasPresence() const;
-
-  /* How integers are encoded.  Only meaningful for integer types.
-   * Defaults to UPB_INTFMT_VARIABLE, and is reset when "type" changes. */
-  IntegerFormat integer_format() const;
-
-  /* Whether a submessage field is tag-delimited or not (if false, then
-   * length-delimited).  May only be set when type() == UPB_TYPE_MESSAGE. */
-  bool is_tag_delimited() const;
+  bool IsSubMessage() const { return upb_fielddef_issubmsg(ptr_); }
+  bool IsString() const { return upb_fielddef_isstring(ptr_); }
+  bool IsSequence() const { return upb_fielddef_isseq(ptr_); }
+  bool IsPrimitive() const { return upb_fielddef_isprimitive(ptr_); }
+  bool IsMap() const { return upb_fielddef_ismap(ptr_); }
 
   /* Returns the non-string default value for this fielddef, which may either
    * be something the client set explicitly or the "default default" (0 for
@@ -464,631 +232,196 @@ class upb::FieldDef {
    * returned value, except for enum fields that are still mutable.
    *
    * Requires that the given function matches the field's current type. */
-  int64_t default_int64() const;
-  int32_t default_int32() const;
-  uint64_t default_uint64() const;
-  uint32_t default_uint32() const;
-  bool default_bool() const;
-  float default_float() const;
-  double default_double() const;
+  int64_t default_int64() const { return upb_fielddef_defaultint64(ptr_); }
+  int32_t default_int32() const { return upb_fielddef_defaultint32(ptr_); }
+  uint64_t default_uint64() const { return upb_fielddef_defaultuint64(ptr_); }
+  uint32_t default_uint32() const { return upb_fielddef_defaultuint32(ptr_); }
+  bool default_bool() const { return upb_fielddef_defaultbool(ptr_); }
+  float default_float() const { return upb_fielddef_defaultfloat(ptr_); }
+  double default_double() const { return upb_fielddef_defaultdouble(ptr_); }
 
   /* The resulting string is always NULL-terminated.  If non-NULL, the length
    * will be stored in *len. */
-  const char *default_string(size_t* len) const;
-
-  /* For frozen UPB_TYPE_ENUM fields, enum defaults can always be read as either
-   * string or int32, and both of these methods will always return true.
-   *
-   * For mutable UPB_TYPE_ENUM fields, the story is a bit more complicated.
-   * Enum defaults are unusual. They can be specified either as string or int32,
-   * but to be valid the enum must have that value as a member.  And if no
-   * default is specified, the "default default" comes from the EnumDef.
-   *
-   * We allow reading the default as either an int32 or a string, but only if
-   * we have a meaningful value to report.  We have a meaningful value if it was
-   * set explicitly, or if we could get the "default default" from the EnumDef.
-   * Also if you explicitly set the name and we find the number in the EnumDef */
-  bool EnumHasStringDefault() const;
-  bool EnumHasInt32Default() const;
-
-  /* Submessage and enum fields must reference a "subdef", which is the
-   * upb::MessageDef or upb::EnumDef that defines their type.  Note that when
-   * the FieldDef is mutable it may not have a subdef *yet*, but this function
-   * still returns true to indicate that the field's type requires a subdef. */
-  bool HasSubDef() const;
+  const char *default_string(size_t * len) const {
+    return upb_fielddef_defaultstr(ptr_, len);
+  }
 
   /* Returns the enum or submessage def for this field, if any.  The field's
    * type must match (ie. you may only call enum_subdef() for fields where
-   * type() == UPB_TYPE_ENUM).  Returns NULL if the subdef has not been set or
-   * is currently set symbolically. */
-  const EnumDef* enum_subdef() const;
-  const MessageDef* message_subdef() const;
-
-  /* Returns the generic subdef for this field.  Requires that HasSubDef() (ie.
-   * only works for UPB_TYPE_ENUM and UPB_TYPE_MESSAGE fields). */
-  const Def* subdef() const;
-
-  /* Returns the symbolic name of the subdef.  If the subdef is currently set
-   * unresolved (ie. set symbolically) returns the symbolic name.  If it has
-   * been resolved to a specific subdef, returns the name from that subdef. */
-  const char* subdef_name() const;
-
-  /* Setters (non-const methods), only valid for mutable FieldDefs! ***********/
-
-  bool set_full_name(const char* fullname, upb::Status* s);
-  bool set_full_name(const std::string& fullname, upb::Status* s);
-
-  /* This may only be called if containing_type() == NULL (ie. the field has not
-   * been added to a message yet). */
-  bool set_containing_type_name(const char *name, Status* status);
-  bool set_containing_type_name(const std::string& name, Status* status);
-
-  /* Defaults to false.  When we freeze, we ensure that this can only be true
-   * for length-delimited message fields.  Prior to freezing this can be true or
-   * false with no restrictions. */
-  void set_lazy(bool lazy);
-
-  /* Defaults to true.  Sets whether this field is encoded in packed format. */
-  void set_packed(bool packed);
-
-  /* "type" or "descriptor_type" MUST be set explicitly before the fielddef is
-   * finalized.  These setters require that the enum value is valid; if the
-   * value did not come directly from an enum constant, the caller should
-   * validate it first with the functions above (CheckFieldType(), etc). */
-  void set_type(Type type);
-  void set_label(Label label);
-  void set_descriptor_type(DescriptorType type);
-  void set_is_extension(bool is_extension);
-
-  /* "number" and "name" must be set before the FieldDef is added to a
-   * MessageDef, and may not be set after that.
-   *
-   * "name" is the same as full_name()/set_full_name(), but since fielddefs
-   * most often use simple, non-qualified names, we provide this accessor
-   * also.  Generally only extensions will want to think of this name as
-   * fully-qualified. */
-  bool set_number(uint32_t number, upb::Status* s);
-  bool set_name(const char* name, upb::Status* s);
-  bool set_name(const std::string& name, upb::Status* s);
-
-  /* Sets the JSON name to the given string. */
-  /* TODO(haberman): implement.  Right now only default json_name (camelCase)
-   * is supported. */
-  bool set_json_name(const char* json_name, upb::Status* s);
-  bool set_json_name(const std::string& name, upb::Status* s);
-
-  /* Clears the JSON name. This will make it revert to its default, which is
-   * a camelCased version of the regular field name. */
-  void clear_json_name();
-
-  void set_integer_format(IntegerFormat format);
-  bool set_tag_delimited(bool tag_delimited, upb::Status* s);
-
-  /* Sets default value for the field.  The call must exactly match the type
-   * of the field.  Enum fields may use either setint32 or setstring to set
-   * the default numerically or symbolically, respectively, but symbolic
-   * defaults must be resolved before finalizing (see ResolveEnumDefault()).
-   *
-   * Changing the type of a field will reset its default. */
-  void set_default_int64(int64_t val);
-  void set_default_int32(int32_t val);
-  void set_default_uint64(uint64_t val);
-  void set_default_uint32(uint32_t val);
-  void set_default_bool(bool val);
-  void set_default_float(float val);
-  void set_default_double(double val);
-  bool set_default_string(const void *str, size_t len, Status *s);
-  bool set_default_string(const std::string &str, Status *s);
-  void set_default_cstr(const char *str, Status *s);
-
-  /* Before a fielddef is frozen, its subdef may be set either directly (with a
-   * upb::Def*) or symbolically.  Symbolic refs must be resolved before the
-   * containing msgdef can be frozen (see upb_resolve() above).  upb always
-   * guarantees that any def reachable from a live def will also be kept alive.
-   *
-   * Both methods require that upb_hassubdef(f) (so the type must be set prior
-   * to calling these methods).  Returns false if this is not the case, or if
-   * the given subdef is not of the correct type.  The subdef is reset if the
-   * field's type is changed.  The subdef can be set to NULL to clear it. */
-  bool set_subdef(const Def* subdef, Status* s);
-  bool set_enum_subdef(const EnumDef* subdef, Status* s);
-  bool set_message_subdef(const MessageDef* subdef, Status* s);
-  bool set_subdef_name(const char* name, Status* s);
-  bool set_subdef_name(const std::string &name, Status* s);
+   * type() == UPB_TYPE_ENUM). */
+  EnumDefPtr enum_subdef() const;
+  MessageDefPtr message_subdef() const;
 
  private:
-  UPB_DISALLOW_POD_OPS(FieldDef, upb::FieldDef)
-#else
-struct upb_fielddef {
-  upb_def base;
-
-  union {
-    int64_t sint;
-    uint64_t uint;
-    double dbl;
-    float flt;
-    void *bytes;
-  } defaultval;
-  union {
-    const upb_msgdef *def;  /* If !msg_is_symbolic. */
-    char *name;             /* If msg_is_symbolic. */
-  } msg;
-  union {
-    const upb_def *def;  /* If !subdef_is_symbolic. */
-    char *name;          /* If subdef_is_symbolic. */
-  } sub;  /* The msgdef or enumdef for this field, if upb_hassubdef(f). */
-  bool subdef_is_symbolic;
-  bool msg_is_symbolic;
-  const upb_oneofdef *oneof;
-  bool default_is_string;
-  bool type_is_set_;     /* False until type is explicitly set. */
-  bool is_extension_;
-  bool lazy_;
-  bool packed_;
-  upb_intfmt_t intfmt;
-  bool tagdelim;
-  upb_fieldtype_t type_;
-  upb_label_t label_;
-  uint32_t number_;
-  uint32_t selector_base;  /* Used to index into a upb::Handlers table. */
-  uint32_t index_;
-# endif  /* defined(__cplusplus) */
+  const upb_fielddef *ptr_;
 };
 
-UPB_BEGIN_EXTERN_C
-
-extern const struct upb_refcounted_vtbl upb_fielddef_vtbl;
-
-#define UPB_FIELDDEF_INIT(label, type, intfmt, tagdelim, is_extension, lazy,   \
-                          packed, name, num, msgdef, subdef, selector_base,    \
-                          index, defaultval, refs, ref2s)                      \
-  {                                                                            \
-    UPB_DEF_INIT(name, UPB_DEF_FIELD, &upb_fielddef_vtbl, refs, ref2s),        \
-        defaultval, {msgdef}, {subdef}, NULL, false, false,                    \
-        type == UPB_TYPE_STRING || type == UPB_TYPE_BYTES, true, is_extension, \
-        lazy, packed, intfmt, tagdelim, type, label, num, selector_base, index \
-  }
-
-/* Native C API. */
-upb_fielddef *upb_fielddef_new(const void *owner);
-
-/* Include upb_refcounted methods like upb_fielddef_ref(). */
-UPB_REFCOUNTED_CMETHODS(upb_fielddef, upb_fielddef_upcast2)
+#endif  /* __cplusplus */
 
-/* Methods from upb_def. */
-const char *upb_fielddef_fullname(const upb_fielddef *f);
-bool upb_fielddef_setfullname(upb_fielddef *f, const char *fullname,
-                              upb_status *s);
+/* upb_oneofdef ***************************************************************/
 
-bool upb_fielddef_typeisset(const upb_fielddef *f);
-upb_fieldtype_t upb_fielddef_type(const upb_fielddef *f);
-upb_descriptortype_t upb_fielddef_descriptortype(const upb_fielddef *f);
-upb_label_t upb_fielddef_label(const upb_fielddef *f);
-uint32_t upb_fielddef_number(const upb_fielddef *f);
-const char *upb_fielddef_name(const upb_fielddef *f);
-bool upb_fielddef_isextension(const upb_fielddef *f);
-bool upb_fielddef_lazy(const upb_fielddef *f);
-bool upb_fielddef_packed(const upb_fielddef *f);
-size_t upb_fielddef_getjsonname(const upb_fielddef *f, char *buf, size_t len);
-const upb_msgdef *upb_fielddef_containingtype(const upb_fielddef *f);
-const upb_oneofdef *upb_fielddef_containingoneof(const upb_fielddef *f);
-upb_msgdef *upb_fielddef_containingtype_mutable(upb_fielddef *f);
-const char *upb_fielddef_containingtypename(upb_fielddef *f);
-upb_intfmt_t upb_fielddef_intfmt(const upb_fielddef *f);
-uint32_t upb_fielddef_index(const upb_fielddef *f);
-bool upb_fielddef_istagdelim(const upb_fielddef *f);
-bool upb_fielddef_issubmsg(const upb_fielddef *f);
-bool upb_fielddef_isstring(const upb_fielddef *f);
-bool upb_fielddef_isseq(const upb_fielddef *f);
-bool upb_fielddef_isprimitive(const upb_fielddef *f);
-bool upb_fielddef_ismap(const upb_fielddef *f);
-bool upb_fielddef_haspresence(const upb_fielddef *f);
-int64_t upb_fielddef_defaultint64(const upb_fielddef *f);
-int32_t upb_fielddef_defaultint32(const upb_fielddef *f);
-uint64_t upb_fielddef_defaultuint64(const upb_fielddef *f);
-uint32_t upb_fielddef_defaultuint32(const upb_fielddef *f);
-bool upb_fielddef_defaultbool(const upb_fielddef *f);
-float upb_fielddef_defaultfloat(const upb_fielddef *f);
-double upb_fielddef_defaultdouble(const upb_fielddef *f);
-const char *upb_fielddef_defaultstr(const upb_fielddef *f, size_t *len);
-bool upb_fielddef_enumhasdefaultint32(const upb_fielddef *f);
-bool upb_fielddef_enumhasdefaultstr(const upb_fielddef *f);
-bool upb_fielddef_hassubdef(const upb_fielddef *f);
-const upb_def *upb_fielddef_subdef(const upb_fielddef *f);
-const upb_msgdef *upb_fielddef_msgsubdef(const upb_fielddef *f);
-const upb_enumdef *upb_fielddef_enumsubdef(const upb_fielddef *f);
-const char *upb_fielddef_subdefname(const upb_fielddef *f);
-
-void upb_fielddef_settype(upb_fielddef *f, upb_fieldtype_t type);
-void upb_fielddef_setdescriptortype(upb_fielddef *f, int type);
-void upb_fielddef_setlabel(upb_fielddef *f, upb_label_t label);
-bool upb_fielddef_setnumber(upb_fielddef *f, uint32_t number, upb_status *s);
-bool upb_fielddef_setname(upb_fielddef *f, const char *name, upb_status *s);
-bool upb_fielddef_setjsonname(upb_fielddef *f, const char *name, upb_status *s);
-bool upb_fielddef_clearjsonname(upb_fielddef *f);
-bool upb_fielddef_setcontainingtypename(upb_fielddef *f, const char *name,
-                                        upb_status *s);
-void upb_fielddef_setisextension(upb_fielddef *f, bool is_extension);
-void upb_fielddef_setlazy(upb_fielddef *f, bool lazy);
-void upb_fielddef_setpacked(upb_fielddef *f, bool packed);
-void upb_fielddef_setintfmt(upb_fielddef *f, upb_intfmt_t fmt);
-void upb_fielddef_settagdelim(upb_fielddef *f, bool tag_delim);
-void upb_fielddef_setdefaultint64(upb_fielddef *f, int64_t val);
-void upb_fielddef_setdefaultint32(upb_fielddef *f, int32_t val);
-void upb_fielddef_setdefaultuint64(upb_fielddef *f, uint64_t val);
-void upb_fielddef_setdefaultuint32(upb_fielddef *f, uint32_t val);
-void upb_fielddef_setdefaultbool(upb_fielddef *f, bool val);
-void upb_fielddef_setdefaultfloat(upb_fielddef *f, float val);
-void upb_fielddef_setdefaultdouble(upb_fielddef *f, double val);
-bool upb_fielddef_setdefaultstr(upb_fielddef *f, const void *str, size_t len,
-                                upb_status *s);
-void upb_fielddef_setdefaultcstr(upb_fielddef *f, const char *str,
-                                 upb_status *s);
-bool upb_fielddef_setsubdef(upb_fielddef *f, const upb_def *subdef,
-                            upb_status *s);
-bool upb_fielddef_setmsgsubdef(upb_fielddef *f, const upb_msgdef *subdef,
-                               upb_status *s);
-bool upb_fielddef_setenumsubdef(upb_fielddef *f, const upb_enumdef *subdef,
-                                upb_status *s);
-bool upb_fielddef_setsubdefname(upb_fielddef *f, const char *name,
-                                upb_status *s);
-
-bool upb_fielddef_checklabel(int32_t label);
-bool upb_fielddef_checktype(int32_t type);
-bool upb_fielddef_checkdescriptortype(int32_t type);
-bool upb_fielddef_checkintfmt(int32_t fmt);
-
-UPB_END_EXTERN_C
-
-
-/* upb::MessageDef ************************************************************/
-
-typedef upb_inttable_iter upb_msg_field_iter;
-typedef upb_strtable_iter upb_msg_oneof_iter;
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-/* Well-known field tag numbers for map-entry messages. */
-#define UPB_MAPENTRY_KEY   1
-#define UPB_MAPENTRY_VALUE 2
+typedef upb_inttable_iter upb_oneof_iter;
 
-/* Well-known field tag numbers for Any messages. */
-#define UPB_ANY_TYPE 1
-#define UPB_ANY_VALUE 2
+const char *upb_oneofdef_name(const upb_oneofdef *o);
+const upb_msgdef *upb_oneofdef_containingtype(const upb_oneofdef *o);
+int upb_oneofdef_numfields(const upb_oneofdef *o);
+uint32_t upb_oneofdef_index(const upb_oneofdef *o);
 
-/* Well-known field tag numbers for timestamp messages. */
-#define UPB_DURATION_SECONDS 1
-#define UPB_DURATION_NANOS 2
+/* Oneof lookups:
+ * - ntof:  look up a field by name.
+ * - ntofz: look up a field by name (as a null-terminated string).
+ * - itof:  look up a field by number. */
+const upb_fielddef *upb_oneofdef_ntof(const upb_oneofdef *o,
+                                      const char *name, size_t length);
+UPB_INLINE const upb_fielddef *upb_oneofdef_ntofz(const upb_oneofdef *o,
+                                                  const char *name) {
+  return upb_oneofdef_ntof(o, name, strlen(name));
+}
+const upb_fielddef *upb_oneofdef_itof(const upb_oneofdef *o, uint32_t num);
 
-/* Well-known field tag numbers for duration messages. */
-#define UPB_TIMESTAMP_SECONDS 1
-#define UPB_TIMESTAMP_NANOS 2
+/*  upb_oneof_iter i;
+ *  for(upb_oneof_begin(&i, e); !upb_oneof_done(&i); upb_oneof_next(&i)) {
+ *    // ...
+ *  }
+ */
+void upb_oneof_begin(upb_oneof_iter *iter, const upb_oneofdef *o);
+void upb_oneof_next(upb_oneof_iter *iter);
+bool upb_oneof_done(upb_oneof_iter *iter);
+upb_fielddef *upb_oneof_iter_field(const upb_oneof_iter *iter);
+void upb_oneof_iter_setdone(upb_oneof_iter *iter);
+bool upb_oneof_iter_isequal(const upb_oneof_iter *iter1,
+                            const upb_oneof_iter *iter2);
 
 #ifdef __cplusplus
+}  /* extern "C" */
 
-/* Structure that describes a single .proto message type.
- *
- * Its base class is upb::Def (use upb::upcast() to convert). */
-class upb::MessageDef {
+/* Class that represents a oneof. */
+class upb::OneofDefPtr {
  public:
-  /* Returns NULL if memory allocation failed. */
-  static reffed_ptr<MessageDef> New();
-
-  /* upb::RefCounted methods like Ref()/Unref(). */
-  UPB_REFCOUNTED_CPPMETHODS
+  OneofDefPtr() : ptr_(nullptr) {}
+  explicit OneofDefPtr(const upb_oneofdef *ptr) : ptr_(ptr) {}
 
-  /* Functionality from upb::Def. */
-  const char* full_name() const;
-  const char* name() const;
-  bool set_full_name(const char* fullname, Status* s);
-  bool set_full_name(const std::string& fullname, Status* s);
+  const upb_oneofdef* ptr() const { return ptr_; }
+  explicit operator bool() { return ptr_ != nullptr; }
 
-  /* Call to freeze this MessageDef.
-   * WARNING: this will fail if this message has any unfrozen submessages!
-   * Messages with cycles must be frozen as a batch using upb::Def::Freeze(). */
-  bool Freeze(Status* s);
+  /* Returns the MessageDef that owns this OneofDef. */
+  MessageDefPtr containing_type() const;
 
-  /* The number of fields that belong to the MessageDef. */
-  int field_count() const;
+  /* Returns the name of this oneof. This is the name used to look up the oneof
+   * by name once added to a message def. */
+  const char* name() const { return upb_oneofdef_name(ptr_); }
 
-  /* The number of oneofs that belong to the MessageDef. */
-  int oneof_count() const;
+  /* Returns the number of fields currently defined in the oneof. */
+  int field_count() const { return upb_oneofdef_numfields(ptr_); }
 
-  /* Adds a field (upb_fielddef object) to a msgdef.  Requires that the msgdef
-   * and the fielddefs are mutable.  The fielddef's name and number must be
-   * set, and the message may not already contain any field with this name or
-   * number, and this fielddef may not be part of another message.  In error
-   * cases false is returned and the msgdef is unchanged.
-   *
-   * If the given field is part of a oneof, this call succeeds if and only if
-   * that oneof is already part of this msgdef. (Note that adding a oneof to a
-   * msgdef automatically adds all of its fields to the msgdef at the time that
-   * the oneof is added, so it is usually more idiomatic to add the oneof's
-   * fields first then add the oneof to the msgdef. This case is supported for
-   * convenience.)
-   *
-   * If |f| is already part of this MessageDef, this method performs no action
-   * and returns true (success). Thus, this method is idempotent. */
-  bool AddField(FieldDef* f, Status* s);
-  bool AddField(const reffed_ptr<FieldDef>& f, Status* s);
-
-  /* Adds a oneof (upb_oneofdef object) to a msgdef. Requires that the msgdef,
-   * oneof, and any fielddefs are mutable, that the fielddefs contained in the
-   * oneof do not have any name or number conflicts with existing fields in the
-   * msgdef, and that the oneof's name is unique among all oneofs in the msgdef.
-   * If the oneof is added successfully, all of its fields will be added
-   * directly to the msgdef as well. In error cases, false is returned and the
-   * msgdef is unchanged. */
-  bool AddOneof(OneofDef* o, Status* s);
-  bool AddOneof(const reffed_ptr<OneofDef>& o, Status* s);
-
-  upb_syntax_t syntax() const;
-
-  /* Returns false if we don't support this syntax value. */
-  bool set_syntax(upb_syntax_t syntax);
-
-  /* Set this to false to indicate that primitive fields should not have
-   * explicit presence information associated with them.  This will affect all
-   * fields added to this message.  Defaults to true. */
-  void SetPrimitivesHavePresence(bool have_presence);
-
-  /* These return NULL if the field is not found. */
-  FieldDef* FindFieldByNumber(uint32_t number);
-  FieldDef* FindFieldByName(const char *name, size_t len);
-  const FieldDef* FindFieldByNumber(uint32_t number) const;
-  const FieldDef* FindFieldByName(const char* name, size_t len) const;
-
-
-  FieldDef* FindFieldByName(const char *name) {
-    return FindFieldByName(name, strlen(name));
+  /* Looks up by name. */
+  FieldDefPtr FindFieldByName(const char *name, size_t len) const {
+    return FieldDefPtr(upb_oneofdef_ntof(ptr_, name, len));
   }
-  const FieldDef* FindFieldByName(const char *name) const {
-    return FindFieldByName(name, strlen(name));
+  FieldDefPtr FindFieldByName(const char* name) const {
+    return FieldDefPtr(upb_oneofdef_ntofz(ptr_, name));
   }
 
   template <class T>
-  FieldDef* FindFieldByName(const T& str) {
-    return FindFieldByName(str.c_str(), str.size());
-  }
-  template <class T>
-  const FieldDef* FindFieldByName(const T& str) const {
+  FieldDefPtr FindFieldByName(const T& str) const {
     return FindFieldByName(str.c_str(), str.size());
   }
 
-  OneofDef* FindOneofByName(const char* name, size_t len);
-  const OneofDef* FindOneofByName(const char* name, size_t len) const;
-
-  OneofDef* FindOneofByName(const char* name) {
-    return FindOneofByName(name, strlen(name));
-  }
-  const OneofDef* FindOneofByName(const char* name) const {
-    return FindOneofByName(name, strlen(name));
-  }
-
-  template<class T>
-  OneofDef* FindOneofByName(const T& str) {
-    return FindOneofByName(str.c_str(), str.size());
-  }
-  template<class T>
-  const OneofDef* FindOneofByName(const T& str) const {
-    return FindOneofByName(str.c_str(), str.size());
+  /* Looks up by tag number. */
+  FieldDefPtr FindFieldByNumber(uint32_t num) const {
+    return FieldDefPtr(upb_oneofdef_itof(ptr_, num));
   }
 
-  /* Is this message a map entry? */
-  void setmapentry(bool map_entry);
-  bool mapentry() const;
-
-  /* Return the type of well known type message. UPB_WELLKNOWN_UNSPECIFIED for
-   * non-well-known message. */
-  upb_wellknowntype_t wellknowntype() const;
-
-  /* Whether is a number wrapper. */
-  bool isnumberwrapper() const;
-
-  /* Iteration over fields.  The order is undefined. */
-  class field_iterator
-      : public std::iterator<std::forward_iterator_tag, FieldDef*> {
-   public:
-    explicit field_iterator(MessageDef* md);
-    static field_iterator end(MessageDef* md);
-
-    void operator++();
-    FieldDef* operator*() const;
-    bool operator!=(const field_iterator& other) const;
-    bool operator==(const field_iterator& other) const;
-
-   private:
-    upb_msg_field_iter iter_;
-  };
-
-  class const_field_iterator
-      : public std::iterator<std::forward_iterator_tag, const FieldDef*> {
-   public:
-    explicit const_field_iterator(const MessageDef* md);
-    static const_field_iterator end(const MessageDef* md);
-
-    void operator++();
-    const FieldDef* operator*() const;
-    bool operator!=(const const_field_iterator& other) const;
-    bool operator==(const const_field_iterator& other) const;
-
-   private:
-    upb_msg_field_iter iter_;
-  };
-
-  /* Iteration over oneofs. The order is undefined. */
-  class oneof_iterator
-      : public std::iterator<std::forward_iterator_tag, FieldDef*> {
+  class const_iterator
+      : public std::iterator<std::forward_iterator_tag, FieldDefPtr> {
    public:
-    explicit oneof_iterator(MessageDef* md);
-    static oneof_iterator end(MessageDef* md);
+    void operator++() { upb_oneof_next(&iter_); }
 
-    void operator++();
-    OneofDef* operator*() const;
-    bool operator!=(const oneof_iterator& other) const;
-    bool operator==(const oneof_iterator& other) const;
+    FieldDefPtr operator*() const {
+      return FieldDefPtr(upb_oneof_iter_field(&iter_));
+    }
 
-   private:
-    upb_msg_oneof_iter iter_;
-  };
+    bool operator!=(const const_iterator& other) const {
+      return !upb_oneof_iter_isequal(&iter_, &other.iter_);
+    }
 
-  class const_oneof_iterator
-      : public std::iterator<std::forward_iterator_tag, const FieldDef*> {
-   public:
-    explicit const_oneof_iterator(const MessageDef* md);
-    static const_oneof_iterator end(const MessageDef* md);
-
-    void operator++();
-    const OneofDef* operator*() const;
-    bool operator!=(const const_oneof_iterator& other) const;
-    bool operator==(const const_oneof_iterator& other) const;
+    bool operator==(const const_iterator& other) const {
+      return upb_oneof_iter_isequal(&iter_, &other.iter_);
+    }
 
    private:
-    upb_msg_oneof_iter iter_;
-  };
+    friend class OneofDefPtr;
+
+    const_iterator() {}
+    explicit const_iterator(OneofDefPtr o) {
+      upb_oneof_begin(&iter_, o.ptr());
+    }
+    static const_iterator end() {
+      const_iterator iter;
+      upb_oneof_iter_setdone(&iter.iter_);
+      return iter;
+    }
 
-  class FieldAccessor {
-   public:
-    explicit FieldAccessor(MessageDef* msg) : msg_(msg) {}
-    field_iterator begin() { return msg_->field_begin(); }
-    field_iterator end() { return msg_->field_end(); }
-   private:
-    MessageDef* msg_;
-  };
-
-  class ConstFieldAccessor {
-   public:
-    explicit ConstFieldAccessor(const MessageDef* msg) : msg_(msg) {}
-    const_field_iterator begin() { return msg_->field_begin(); }
-    const_field_iterator end() { return msg_->field_end(); }
-   private:
-    const MessageDef* msg_;
-  };
-
-  class OneofAccessor {
-   public:
-    explicit OneofAccessor(MessageDef* msg) : msg_(msg) {}
-    oneof_iterator begin() { return msg_->oneof_begin(); }
-    oneof_iterator end() { return msg_->oneof_end(); }
-   private:
-    MessageDef* msg_;
-  };
-
-  class ConstOneofAccessor {
-   public:
-    explicit ConstOneofAccessor(const MessageDef* msg) : msg_(msg) {}
-    const_oneof_iterator begin() { return msg_->oneof_begin(); }
-    const_oneof_iterator end() { return msg_->oneof_end(); }
-   private:
-    const MessageDef* msg_;
+    upb_oneof_iter iter_;
   };
 
-  field_iterator field_begin();
-  field_iterator field_end();
-  const_field_iterator field_begin() const;
-  const_field_iterator field_end() const;
-
-  oneof_iterator oneof_begin();
-  oneof_iterator oneof_end();
-  const_oneof_iterator oneof_begin() const;
-  const_oneof_iterator oneof_end() const;
-
-  FieldAccessor fields() { return FieldAccessor(this); }
-  ConstFieldAccessor fields() const { return ConstFieldAccessor(this); }
-  OneofAccessor oneofs() { return OneofAccessor(this); }
-  ConstOneofAccessor oneofs() const { return ConstOneofAccessor(this); }
+  const_iterator begin() const { return const_iterator(*this); }
+  const_iterator end() const { return const_iterator::end(); }
 
  private:
-  UPB_DISALLOW_POD_OPS(MessageDef, upb::MessageDef)
-#else
-struct upb_msgdef {
-  upb_def base;
-
-  size_t selector_count;
-  uint32_t submsg_field_count;
-
-  /* Tables for looking up fields by number and name. */
-  upb_inttable itof;  /* int to field */
-  upb_strtable ntof;  /* name to field/oneof */
-
-  /* Is this a map-entry message? */
-  bool map_entry;
-
-  /* Whether this message has proto2 or proto3 semantics. */
-  upb_syntax_t syntax;
+  const upb_oneofdef *ptr_;
+};
 
-  /* Type of well known type message. UPB_WELLKNOWN_UNSPECIFIED for
-   * non-well-known message. */
-  upb_wellknowntype_t well_known_type;
+inline upb::OneofDefPtr upb::FieldDefPtr::containing_oneof() const {
+  return OneofDefPtr(upb_fielddef_containingoneof(ptr_));
+}
 
-  /* TODO(haberman): proper extension ranges (there can be multiple). */
 #endif  /* __cplusplus */
-};
 
-UPB_BEGIN_EXTERN_C
+/* upb_msgdef *****************************************************************/
 
-extern const struct upb_refcounted_vtbl upb_msgdef_vtbl;
+typedef upb_inttable_iter upb_msg_field_iter;
+typedef upb_strtable_iter upb_msg_oneof_iter;
 
-/* TODO: also support static initialization of the oneofs table. This will be
- * needed if we compile in descriptors that contain oneofs. */
-#define UPB_MSGDEF_INIT(name, selector_count, submsg_field_count, itof, ntof, \
-                        map_entry, syntax, well_known_type, refs, ref2s)      \
-  {                                                                           \
-    UPB_DEF_INIT(name, UPB_DEF_MSG, &upb_fielddef_vtbl, refs, ref2s),         \
-        selector_count, submsg_field_count, itof, ntof, map_entry, syntax,    \
-        well_known_type                                                       \
-  }
+/* Well-known field tag numbers for map-entry messages. */
+#define UPB_MAPENTRY_KEY   1
+#define UPB_MAPENTRY_VALUE 2
 
-/* Returns NULL if memory allocation failed. */
-upb_msgdef *upb_msgdef_new(const void *owner);
+/* Well-known field tag numbers for Any messages. */
+#define UPB_ANY_TYPE 1
+#define UPB_ANY_VALUE 2
 
-/* Include upb_refcounted methods like upb_msgdef_ref(). */
-UPB_REFCOUNTED_CMETHODS(upb_msgdef, upb_msgdef_upcast2)
+/* Well-known field tag numbers for timestamp messages. */
+#define UPB_DURATION_SECONDS 1
+#define UPB_DURATION_NANOS 2
 
-bool upb_msgdef_freeze(upb_msgdef *m, upb_status *status);
+/* Well-known field tag numbers for duration messages. */
+#define UPB_TIMESTAMP_SECONDS 1
+#define UPB_TIMESTAMP_NANOS 2
+
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 const char *upb_msgdef_fullname(const upb_msgdef *m);
+const upb_filedef *upb_msgdef_file(const upb_msgdef *m);
 const char *upb_msgdef_name(const upb_msgdef *m);
 int upb_msgdef_numoneofs(const upb_msgdef *m);
 upb_syntax_t upb_msgdef_syntax(const upb_msgdef *m);
-
-bool upb_msgdef_addfield(upb_msgdef *m, upb_fielddef *f, const void *ref_donor,
-                         upb_status *s);
-bool upb_msgdef_addoneof(upb_msgdef *m, upb_oneofdef *o, const void *ref_donor,
-                         upb_status *s);
-bool upb_msgdef_setfullname(upb_msgdef *m, const char *fullname, upb_status *s);
-void upb_msgdef_setmapentry(upb_msgdef *m, bool map_entry);
 bool upb_msgdef_mapentry(const upb_msgdef *m);
 upb_wellknowntype_t upb_msgdef_wellknowntype(const upb_msgdef *m);
 bool upb_msgdef_isnumberwrapper(const upb_msgdef *m);
 bool upb_msgdef_setsyntax(upb_msgdef *m, upb_syntax_t syntax);
-
-/* Field lookup in a couple of different variations:
- *   - itof = int to field
- *   - ntof = name to field
- *   - ntofz = name to field, null-terminated string. */
 const upb_fielddef *upb_msgdef_itof(const upb_msgdef *m, uint32_t i);
 const upb_fielddef *upb_msgdef_ntof(const upb_msgdef *m, const char *name,
                                     size_t len);
-int upb_msgdef_numfields(const upb_msgdef *m);
-
-UPB_INLINE const upb_fielddef *upb_msgdef_ntofz(const upb_msgdef *m,
-                                                const char *name) {
-  return upb_msgdef_ntof(m, name, strlen(name));
-}
-
-UPB_INLINE upb_fielddef *upb_msgdef_itof_mutable(upb_msgdef *m, uint32_t i) {
-  return (upb_fielddef*)upb_msgdef_itof(m, i);
-}
-
-UPB_INLINE upb_fielddef *upb_msgdef_ntof_mutable(upb_msgdef *m,
-                                                 const char *name, size_t len) {
-  return (upb_fielddef *)upb_msgdef_ntof(m, name, len);
-}
-
-/* Oneof lookup:
- *   - ntoo = name to oneof
- *   - ntooz = name to oneof, null-terminated string. */
 const upb_oneofdef *upb_msgdef_ntoo(const upb_msgdef *m, const char *name,
                                     size_t len);
+int upb_msgdef_numfields(const upb_msgdef *m);
 int upb_msgdef_numoneofs(const upb_msgdef *m);
 
 UPB_INLINE const upb_oneofdef *upb_msgdef_ntooz(const upb_msgdef *m,
@@ -1096,11 +429,15 @@ UPB_INLINE const upb_oneofdef *upb_msgdef_ntooz(const upb_msgdef *m,
   return upb_msgdef_ntoo(m, name, strlen(name));
 }
 
-UPB_INLINE upb_oneofdef *upb_msgdef_ntoo_mutable(upb_msgdef *m,
-                                                 const char *name, size_t len) {
-  return (upb_oneofdef *)upb_msgdef_ntoo(m, name, len);
+UPB_INLINE const upb_fielddef *upb_msgdef_ntofz(const upb_msgdef *m,
+                                                const char *name) {
+  return upb_msgdef_ntof(m, name, strlen(name));
 }
 
+/* Internal-only. */
+size_t upb_msgdef_selectorcount(const upb_msgdef *m);
+uint32_t upb_msgdef_submsgfieldcount(const upb_msgdef *m);
+
 /* Lookup of either field or oneof by name.  Returns whether either was found.
  * If the return is true, then the found def will be set, and the non-found
  * one set to NULL. */
@@ -1131,127 +468,216 @@ void upb_msg_field_next(upb_msg_field_iter *iter);
 bool upb_msg_field_done(const upb_msg_field_iter *iter);
 upb_fielddef *upb_msg_iter_field(const upb_msg_field_iter *iter);
 void upb_msg_field_iter_setdone(upb_msg_field_iter *iter);
+bool upb_msg_field_iter_isequal(const upb_msg_field_iter * iter1,
+                                const upb_msg_field_iter * iter2);
 
 /* Similar to above, we also support iterating through the oneofs in a
  * msgdef. */
-void upb_msg_oneof_begin(upb_msg_oneof_iter *iter, const upb_msgdef *m);
-void upb_msg_oneof_next(upb_msg_oneof_iter *iter);
+void upb_msg_oneof_begin(upb_msg_oneof_iter * iter, const upb_msgdef *m);
+void upb_msg_oneof_next(upb_msg_oneof_iter * iter);
 bool upb_msg_oneof_done(const upb_msg_oneof_iter *iter);
-upb_oneofdef *upb_msg_iter_oneof(const upb_msg_oneof_iter *iter);
-void upb_msg_oneof_iter_setdone(upb_msg_oneof_iter *iter);
+const upb_oneofdef *upb_msg_iter_oneof(const upb_msg_oneof_iter *iter);
+void upb_msg_oneof_iter_setdone(upb_msg_oneof_iter * iter);
+bool upb_msg_oneof_iter_isequal(const upb_msg_oneof_iter *iter1,
+                                const upb_msg_oneof_iter *iter2);
 
-UPB_END_EXTERN_C
+#ifdef __cplusplus
+}  /* extern "C" */
 
+/* Structure that describes a single .proto message type. */
+class upb::MessageDefPtr {
+ public:
+  MessageDefPtr() : ptr_(nullptr) {}
+  explicit MessageDefPtr(const upb_msgdef *ptr) : ptr_(ptr) {}
 
-/* upb::EnumDef ***************************************************************/
+  const upb_msgdef *ptr() const { return ptr_; }
+  explicit operator bool() const { return ptr_ != nullptr; }
 
-typedef upb_strtable_iter upb_enum_iter;
+  const char* full_name() const { return upb_msgdef_fullname(ptr_); }
+  const char* name() const { return upb_msgdef_name(ptr_); }
 
-#ifdef __cplusplus
+  /* The number of fields that belong to the MessageDef. */
+  int field_count() const { return upb_msgdef_numfields(ptr_); }
 
-/* Class that represents an enum.  Its base class is upb::Def (convert with
- * upb::upcast()). */
-class upb::EnumDef {
- public:
-  /* Returns NULL if memory allocation failed. */
-  static reffed_ptr<EnumDef> New();
+  /* The number of oneofs that belong to the MessageDef. */
+  int oneof_count() const { return upb_msgdef_numoneofs(ptr_); }
 
-  /* upb::RefCounted methods like Ref()/Unref(). */
-  UPB_REFCOUNTED_CPPMETHODS
+  upb_syntax_t syntax() const { return upb_msgdef_syntax(ptr_); }
 
-  /* Functionality from upb::Def. */
-  const char* full_name() const;
-  const char* name() const;
-  bool set_full_name(const char* fullname, Status* s);
-  bool set_full_name(const std::string& fullname, Status* s);
+  /* These return null pointers if the field is not found. */
+  FieldDefPtr FindFieldByNumber(uint32_t number) const {
+    return FieldDefPtr(upb_msgdef_itof(ptr_, number));
+  }
+  FieldDefPtr FindFieldByName(const char* name, size_t len) const {
+    return FieldDefPtr(upb_msgdef_ntof(ptr_, name, len));
+  }
+  FieldDefPtr FindFieldByName(const char *name) const {
+    return FieldDefPtr(upb_msgdef_ntofz(ptr_, name));
+  }
 
-  /* Call to freeze this EnumDef. */
-  bool Freeze(Status* s);
+  template <class T>
+  FieldDefPtr FindFieldByName(const T& str) const {
+    return FindFieldByName(str.c_str(), str.size());
+  }
 
-  /* The value that is used as the default when no field default is specified.
-   * If not set explicitly, the first value that was added will be used.
-   * The default value must be a member of the enum.
-   * Requires that value_count() > 0. */
-  int32_t default_value() const;
+  OneofDefPtr FindOneofByName(const char* name, size_t len) const {
+    return OneofDefPtr(upb_msgdef_ntoo(ptr_, name, len));
+  }
 
-  /* Sets the default value.  If this value is not valid, returns false and an
-   * error message in status. */
-  bool set_default_value(int32_t val, Status* status);
+  OneofDefPtr FindOneofByName(const char *name) const {
+    return OneofDefPtr(upb_msgdef_ntooz(ptr_, name));
+  }
 
-  /* Returns the number of values currently defined in the enum.  Note that
-   * multiple names can refer to the same number, so this may be greater than
-   * the total number of unique numbers. */
-  int value_count() const;
+  template <class T>
+  OneofDefPtr FindOneofByName(const T &str) const {
+    return FindOneofByName(str.c_str(), str.size());
+  }
 
-  /* Adds a single name/number pair to the enum.  Fails if this name has
-   * already been used by another value. */
-  bool AddValue(const char* name, int32_t num, Status* status);
-  bool AddValue(const std::string& name, int32_t num, Status* status);
+  /* Is this message a map entry? */
+  bool mapentry() const { return upb_msgdef_mapentry(ptr_); }
 
-  /* Lookups from name to integer, returning true if found. */
-  bool FindValueByName(const char* name, int32_t* num) const;
+  /* Return the type of well known type message. UPB_WELLKNOWN_UNSPECIFIED for
+   * non-well-known message. */
+  upb_wellknowntype_t wellknowntype() const {
+    return upb_msgdef_wellknowntype(ptr_);
+  }
 
-  /* Finds the name corresponding to the given number, or NULL if none was
-   * found.  If more than one name corresponds to this number, returns the
-   * first one that was added. */
-  const char* FindValueByNumber(int32_t num) const;
+  /* Whether is a number wrapper. */
+  bool isnumberwrapper() const { return upb_msgdef_isnumberwrapper(ptr_); }
 
-  /* Iteration over name/value pairs.  The order is undefined.
-   * Adding an enum val invalidates any iterators.
-   *
-   * TODO: make compatible with range-for, with elements as pairs? */
-  class Iterator {
+  /* Iteration over fields.  The order is undefined. */
+  class const_field_iterator
+      : public std::iterator<std::forward_iterator_tag, FieldDefPtr> {
    public:
-    explicit Iterator(const EnumDef*);
+    void operator++() { upb_msg_field_next(&iter_); }
+
+    FieldDefPtr operator*() const {
+      return FieldDefPtr(upb_msg_iter_field(&iter_));
+    }
 
-    int32_t number();
-    const char *name();
-    bool Done();
-    void Next();
+    bool operator!=(const const_field_iterator &other) const {
+      return !upb_msg_field_iter_isequal(&iter_, &other.iter_);
+    }
+
+    bool operator==(const const_field_iterator &other) const {
+      return upb_msg_field_iter_isequal(&iter_, &other.iter_);
+    }
 
    private:
-    upb_enum_iter iter_;
+    friend class MessageDefPtr;
+
+    explicit const_field_iterator() {}
+
+    explicit const_field_iterator(MessageDefPtr msg) {
+      upb_msg_field_begin(&iter_, msg.ptr());
+    }
+
+    static const_field_iterator end() {
+      const_field_iterator iter;
+      upb_msg_field_iter_setdone(&iter.iter_);
+      return iter;
+    }
+
+    upb_msg_field_iter iter_;
+  };
+
+  /* Iteration over oneofs. The order is undefined. */
+  class const_oneof_iterator
+      : public std::iterator<std::forward_iterator_tag, OneofDefPtr> {
+   public:
+
+    void operator++() { upb_msg_oneof_next(&iter_); }
+
+    OneofDefPtr operator*() const {
+      return OneofDefPtr(upb_msg_iter_oneof(&iter_));
+    }
+
+    bool operator!=(const const_oneof_iterator& other) const {
+      return !upb_msg_oneof_iter_isequal(&iter_, &other.iter_);
+    }
+
+    bool operator==(const const_oneof_iterator &other) const {
+      return upb_msg_oneof_iter_isequal(&iter_, &other.iter_);
+    }
+
+   private:
+    friend class MessageDefPtr;
+
+    const_oneof_iterator() {}
+
+    explicit const_oneof_iterator(MessageDefPtr msg) {
+      upb_msg_oneof_begin(&iter_, msg.ptr());
+    }
+
+    static const_oneof_iterator end() {
+      const_oneof_iterator iter;
+      upb_msg_oneof_iter_setdone(&iter.iter_);
+      return iter;
+    }
+
+    upb_msg_oneof_iter iter_;
   };
 
+  class ConstFieldAccessor {
+   public:
+    explicit ConstFieldAccessor(const upb_msgdef* md) : md_(md) {}
+    const_field_iterator begin() { return MessageDefPtr(md_).field_begin(); }
+    const_field_iterator end() { return MessageDefPtr(md_).field_end(); }
+   private:
+    const upb_msgdef* md_;
+  };
+
+  class ConstOneofAccessor {
+   public:
+    explicit ConstOneofAccessor(const upb_msgdef* md) : md_(md) {}
+    const_oneof_iterator begin() { return MessageDefPtr(md_).oneof_begin(); }
+    const_oneof_iterator end() { return MessageDefPtr(md_).oneof_end(); }
+   private:
+    const upb_msgdef* md_;
+  };
+
+  const_field_iterator field_begin() const {
+    return const_field_iterator(*this);
+  }
+
+  const_field_iterator field_end() const { return const_field_iterator::end(); }
+
+  const_oneof_iterator oneof_begin() const {
+    return const_oneof_iterator(*this);
+  }
+
+  const_oneof_iterator oneof_end() const { return const_oneof_iterator::end(); }
+
+  ConstFieldAccessor fields() const { return ConstFieldAccessor(ptr()); }
+  ConstOneofAccessor oneofs() const { return ConstOneofAccessor(ptr()); }
+
  private:
-  UPB_DISALLOW_POD_OPS(EnumDef, upb::EnumDef)
-#else
-struct upb_enumdef {
-  upb_def base;
-
-  upb_strtable ntoi;
-  upb_inttable iton;
-  int32_t defaultval;
-#endif  /* __cplusplus */
+  const upb_msgdef* ptr_;
 };
 
-UPB_BEGIN_EXTERN_C
+inline upb::MessageDefPtr upb::FieldDefPtr::message_subdef() const {
+  return MessageDefPtr(upb_fielddef_msgsubdef(ptr_));
+}
 
-extern const struct upb_refcounted_vtbl upb_enumdef_vtbl;
+inline upb::MessageDefPtr upb::FieldDefPtr::containing_type() const {
+  return MessageDefPtr(upb_fielddef_containingtype(ptr_));
+}
 
-#define UPB_ENUMDEF_INIT(name, ntoi, iton, defaultval, refs, ref2s) \
-  { UPB_DEF_INIT(name, UPB_DEF_ENUM, &upb_enumdef_vtbl, refs, ref2s), ntoi,    \
-    iton, defaultval }
+inline upb::MessageDefPtr upb::OneofDefPtr::containing_type() const {
+  return MessageDefPtr(upb_oneofdef_containingtype(ptr_));
+}
 
-/* Native C API. */
-upb_enumdef *upb_enumdef_new(const void *owner);
+#endif  /* __cplusplus */
 
-/* Include upb_refcounted methods like upb_enumdef_ref(). */
-UPB_REFCOUNTED_CMETHODS(upb_enumdef, upb_enumdef_upcast2)
+/* upb_enumdef ****************************************************************/
 
-bool upb_enumdef_freeze(upb_enumdef *e, upb_status *status);
+typedef upb_strtable_iter upb_enum_iter;
 
-/* From upb_def. */
 const char *upb_enumdef_fullname(const upb_enumdef *e);
 const char *upb_enumdef_name(const upb_enumdef *e);
-bool upb_enumdef_setfullname(upb_enumdef *e, const char *fullname,
-                             upb_status *s);
-
+const upb_filedef *upb_enumdef_file(const upb_enumdef *e);
 int32_t upb_enumdef_default(const upb_enumdef *e);
-bool upb_enumdef_setdefault(upb_enumdef *e, int32_t val, upb_status *s);
 int upb_enumdef_numvals(const upb_enumdef *e);
-bool upb_enumdef_addval(upb_enumdef *e, const char *name, int32_t num,
-                        upb_status *status);
 
 /* Enum lookups:
  * - ntoi:  look up a name with specified length.
@@ -1277,1102 +703,203 @@ bool upb_enum_done(upb_enum_iter *iter);
 const char *upb_enum_iter_name(upb_enum_iter *iter);
 int32_t upb_enum_iter_number(upb_enum_iter *iter);
 
-UPB_END_EXTERN_C
-
-
-/* upb::OneofDef **************************************************************/
-
-typedef upb_inttable_iter upb_oneof_iter;
-
 #ifdef __cplusplus
 
-/* Class that represents a oneof. */
-class upb::OneofDef {
+class upb::EnumDefPtr {
  public:
-  /* Returns NULL if memory allocation failed. */
-  static reffed_ptr<OneofDef> New();
+  EnumDefPtr() : ptr_(nullptr) {}
+  explicit EnumDefPtr(const upb_enumdef* ptr) : ptr_(ptr) {}
 
-  /* upb::RefCounted methods like Ref()/Unref(). */
-  UPB_REFCOUNTED_CPPMETHODS
+  const upb_enumdef* ptr() const { return ptr_; }
+  explicit operator bool() const { return ptr_ != nullptr; }
 
-  /* Returns the MessageDef that owns this OneofDef. */
-  const MessageDef* containing_type() const;
+  const char* full_name() const { return upb_enumdef_fullname(ptr_); }
+  const char* name() const { return upb_enumdef_name(ptr_); }
 
-  /* Returns the name of this oneof. This is the name used to look up the oneof
-   * by name once added to a message def. */
-  const char* name() const;
-  bool set_name(const char* name, Status* s);
-  bool set_name(const std::string& name, Status* s);
+  /* The value that is used as the default when no field default is specified.
+   * If not set explicitly, the first value that was added will be used.
+   * The default value must be a member of the enum.
+   * Requires that value_count() > 0. */
+  int32_t default_value() const { return upb_enumdef_default(ptr_); }
 
-  /* Returns the number of fields currently defined in the oneof. */
-  int field_count() const;
-
-  /* Adds a field to the oneof. The field must not have been added to any other
-   * oneof or msgdef. If the oneof is not yet part of a msgdef, then when the
-   * oneof is eventually added to a msgdef, all fields added to the oneof will
-   * also be added to the msgdef at that time. If the oneof is already part of a
-   * msgdef, the field must either be a part of that msgdef already, or must not
-   * be a part of any msgdef; in the latter case, the field is added to the
-   * msgdef as a part of this operation.
-   *
-   * The field may only have an OPTIONAL label, never REQUIRED or REPEATED.
-   *
-   * If |f| is already part of this MessageDef, this method performs no action
-   * and returns true (success). Thus, this method is idempotent. */
-  bool AddField(FieldDef* field, Status* s);
-  bool AddField(const reffed_ptr<FieldDef>& field, Status* s);
+  /* Returns the number of values currently defined in the enum.  Note that
+   * multiple names can refer to the same number, so this may be greater than
+   * the total number of unique numbers. */
+  int value_count() const { return upb_enumdef_numvals(ptr_); }
 
-  /* Looks up by name. */
-  const FieldDef* FindFieldByName(const char* name, size_t len) const;
-  FieldDef* FindFieldByName(const char* name, size_t len);
-  const FieldDef* FindFieldByName(const char* name) const {
-    return FindFieldByName(name, strlen(name));
-  }
-  FieldDef* FindFieldByName(const char* name) {
-    return FindFieldByName(name, strlen(name));
+  /* Lookups from name to integer, returning true if found. */
+  bool FindValueByName(const char *name, int32_t *num) const {
+    return upb_enumdef_ntoiz(ptr_, name, num);
   }
 
-  template <class T>
-  FieldDef* FindFieldByName(const T& str) {
-    return FindFieldByName(str.c_str(), str.size());
-  }
-  template <class T>
-  const FieldDef* FindFieldByName(const T& str) const {
-    return FindFieldByName(str.c_str(), str.size());
+  /* Finds the name corresponding to the given number, or NULL if none was
+   * found.  If more than one name corresponds to this number, returns the
+   * first one that was added. */
+  const char *FindValueByNumber(int32_t num) const {
+    return upb_enumdef_iton(ptr_, num);
   }
 
-  /* Looks up by tag number. */
-  const FieldDef* FindFieldByNumber(uint32_t num) const;
-
-  /* Iteration over fields.  The order is undefined. */
-  class iterator : public std::iterator<std::forward_iterator_tag, FieldDef*> {
-   public:
-    explicit iterator(OneofDef* md);
-    static iterator end(OneofDef* md);
-
-    void operator++();
-    FieldDef* operator*() const;
-    bool operator!=(const iterator& other) const;
-    bool operator==(const iterator& other) const;
-
-   private:
-    upb_oneof_iter iter_;
-  };
-
-  class const_iterator
-      : public std::iterator<std::forward_iterator_tag, const FieldDef*> {
+  /* Iteration over name/value pairs.  The order is undefined.
+   * Adding an enum val invalidates any iterators.
+   *
+   * TODO: make compatible with range-for, with elements as pairs? */
+  class Iterator {
    public:
-    explicit const_iterator(const OneofDef* md);
-    static const_iterator end(const OneofDef* md);
+    explicit Iterator(EnumDefPtr e) { upb_enum_begin(&iter_, e.ptr()); }
 
-    void operator++();
-    const FieldDef* operator*() const;
-    bool operator!=(const const_iterator& other) const;
-    bool operator==(const const_iterator& other) const;
+    int32_t number() { return upb_enum_iter_number(&iter_); }
+    const char *name() { return upb_enum_iter_name(&iter_); }
+    bool Done() { return upb_enum_done(&iter_); }
+    void Next() { return upb_enum_next(&iter_); }
 
    private:
-    upb_oneof_iter iter_;
+    upb_enum_iter iter_;
   };
 
-  iterator begin();
-  iterator end();
-  const_iterator begin() const;
-  const_iterator end() const;
-
  private:
-  UPB_DISALLOW_POD_OPS(OneofDef, upb::OneofDef)
-#else
-struct upb_oneofdef {
-  upb_refcounted base;
-
-  uint32_t index;  /* Index within oneofs. */
-  const char *name;
-  upb_strtable ntof;
-  upb_inttable itof;
-  const upb_msgdef *parent;
-#endif  /* __cplusplus */
+  const upb_enumdef *ptr_;
 };
 
-UPB_BEGIN_EXTERN_C
-
-extern const struct upb_refcounted_vtbl upb_oneofdef_vtbl;
-
-#define UPB_ONEOFDEF_INIT(name, ntof, itof, refs, ref2s) \
-  { UPB_REFCOUNT_INIT(&upb_oneofdef_vtbl, refs, ref2s), 0, name, ntof, itof }
-
-/* Native C API. */
-upb_oneofdef *upb_oneofdef_new(const void *owner);
-
-/* Include upb_refcounted methods like upb_oneofdef_ref(). */
-UPB_REFCOUNTED_CMETHODS(upb_oneofdef, upb_oneofdef_upcast)
-
-const char *upb_oneofdef_name(const upb_oneofdef *o);
-const upb_msgdef *upb_oneofdef_containingtype(const upb_oneofdef *o);
-int upb_oneofdef_numfields(const upb_oneofdef *o);
-uint32_t upb_oneofdef_index(const upb_oneofdef *o);
-
-bool upb_oneofdef_setname(upb_oneofdef *o, const char *name, upb_status *s);
-bool upb_oneofdef_addfield(upb_oneofdef *o, upb_fielddef *f,
-                           const void *ref_donor,
-                           upb_status *s);
-
-/* Oneof lookups:
- * - ntof:  look up a field by name.
- * - ntofz: look up a field by name (as a null-terminated string).
- * - itof:  look up a field by number. */
-const upb_fielddef *upb_oneofdef_ntof(const upb_oneofdef *o,
-                                      const char *name, size_t length);
-UPB_INLINE const upb_fielddef *upb_oneofdef_ntofz(const upb_oneofdef *o,
-                                                  const char *name) {
-  return upb_oneofdef_ntof(o, name, strlen(name));
+inline upb::EnumDefPtr upb::FieldDefPtr::enum_subdef() const {
+  return EnumDefPtr(upb_fielddef_enumsubdef(ptr_));
 }
-const upb_fielddef *upb_oneofdef_itof(const upb_oneofdef *o, uint32_t num);
 
-/*  upb_oneof_iter i;
- *  for(upb_oneof_begin(&i, e); !upb_oneof_done(&i); upb_oneof_next(&i)) {
- *    // ...
- *  }
- */
-void upb_oneof_begin(upb_oneof_iter *iter, const upb_oneofdef *o);
-void upb_oneof_next(upb_oneof_iter *iter);
-bool upb_oneof_done(upb_oneof_iter *iter);
-upb_fielddef *upb_oneof_iter_field(const upb_oneof_iter *iter);
-void upb_oneof_iter_setdone(upb_oneof_iter *iter);
+#endif  /* __cplusplus */
 
-UPB_END_EXTERN_C
+/* upb_filedef ****************************************************************/
 
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-/* upb::FileDef ***************************************************************/
+const char *upb_filedef_name(const upb_filedef *f);
+const char *upb_filedef_package(const upb_filedef *f);
+const char *upb_filedef_phpprefix(const upb_filedef *f);
+const char *upb_filedef_phpnamespace(const upb_filedef *f);
+upb_syntax_t upb_filedef_syntax(const upb_filedef *f);
+int upb_filedef_depcount(const upb_filedef *f);
+int upb_filedef_msgcount(const upb_filedef *f);
+int upb_filedef_enumcount(const upb_filedef *f);
+const upb_filedef *upb_filedef_dep(const upb_filedef *f, int i);
+const upb_msgdef *upb_filedef_msg(const upb_filedef *f, int i);
+const upb_enumdef *upb_filedef_enum(const upb_filedef *f, int i);
 
 #ifdef __cplusplus
+}  /* extern "C" */
 
 /* Class that represents a .proto file with some things defined in it.
  *
  * Many users won't care about FileDefs, but they are necessary if you want to
  * read the values of file-level options. */
-class upb::FileDef {
+class upb::FileDefPtr {
  public:
-  /* Returns NULL if memory allocation failed. */
-  static reffed_ptr<FileDef> New();
+  explicit FileDefPtr(const upb_filedef *ptr) : ptr_(ptr) {}
 
-  /* upb::RefCounted methods like Ref()/Unref(). */
-  UPB_REFCOUNTED_CPPMETHODS
+  const upb_filedef* ptr() const { return ptr_; }
+  explicit operator bool() const { return ptr_ != nullptr; }
 
   /* Get/set name of the file (eg. "foo/bar.proto"). */
-  const char* name() const;
-  bool set_name(const char* name, Status* s);
-  bool set_name(const std::string& name, Status* s);
+  const char* name() const { return upb_filedef_name(ptr_); }
 
   /* Package name for definitions inside the file (eg. "foo.bar"). */
-  const char* package() const;
-  bool set_package(const char* package, Status* s);
+  const char* package() const { return upb_filedef_package(ptr_); }
 
   /* Sets the php class prefix which is prepended to all php generated classes
    * from this .proto. Default is empty. */
-  const char* phpprefix() const;
-  bool set_phpprefix(const char* phpprefix, Status* s);
+  const char* phpprefix() const { return upb_filedef_phpprefix(ptr_); }
 
   /* Use this option to change the namespace of php generated classes. Default
    * is empty. When this option is empty, the package name will be used for
    * determining the namespace. */
-  const char* phpnamespace() const;
-  bool set_phpnamespace(const char* phpnamespace, Status* s);
+  const char* phpnamespace() const { return upb_filedef_phpnamespace(ptr_); }
 
   /* Syntax for the file.  Defaults to proto2. */
-  upb_syntax_t syntax() const;
-  void set_syntax(upb_syntax_t syntax);
-
-  /* Get the list of defs from the file.  These are returned in the order that
-   * they were added to the FileDef. */
-  int def_count() const;
-  const Def* def(int index) const;
-  Def* def(int index);
+  upb_syntax_t syntax() const { return upb_filedef_syntax(ptr_); }
 
   /* Get the list of dependencies from the file.  These are returned in the
-   * order that they were added to the FileDef. */
-  int dependency_count() const;
-  const FileDef* dependency(int index) const;
-
-  /* Adds defs to this file.  The def must not already belong to another
-   * file.
-   *
-   * Note: this does *not* ensure that this def's name is unique in this file!
-   * Use a SymbolTable if you want to check this property.  Especially since
-   * properly checking uniqueness would require a check across *all* files
-   * (including dependencies). */
-  bool AddDef(Def* def, Status* s);
-  bool AddMessage(MessageDef* m, Status* s);
-  bool AddEnum(EnumDef* e, Status* s);
-  bool AddExtension(FieldDef* f, Status* s);
-
-  /* Adds a dependency of this file. */
-  bool AddDependency(const FileDef* file);
-
-  /* Freezes this FileDef and all messages/enums under it.  All subdefs must be
-   * resolved and all messages/enums must validate.  Returns true if this
-   * succeeded.
-   *
-   * TODO(haberman): should we care whether the file's dependencies are frozen
-   * already? */
-  bool Freeze(Status* s);
+   * order that they were added to the FileDefPtr. */
+  int dependency_count() const { return upb_filedef_depcount(ptr_); }
+  const FileDefPtr dependency(int index) const {
+    return FileDefPtr(upb_filedef_dep(ptr_, index));
+  }
 
  private:
-  UPB_DISALLOW_POD_OPS(FileDef, upb::FileDef)
-#else
-struct upb_filedef {
-  upb_refcounted base;
-
-  const char *name;
-  const char *package;
-  const char *phpprefix;
-  const char *phpnamespace;
-  upb_syntax_t syntax;
-
-  upb_inttable defs;
-  upb_inttable deps;
-#endif
+  const upb_filedef* ptr_;
 };
 
-UPB_BEGIN_EXTERN_C
-
-extern const struct upb_refcounted_vtbl upb_filedef_vtbl;
-
-upb_filedef *upb_filedef_new(const void *owner);
-
-/* Include upb_refcounted methods like upb_msgdef_ref(). */
-UPB_REFCOUNTED_CMETHODS(upb_filedef, upb_filedef_upcast)
+#endif  /* __cplusplus */
 
-const char *upb_filedef_name(const upb_filedef *f);
-const char *upb_filedef_package(const upb_filedef *f);
-const char *upb_filedef_phpprefix(const upb_filedef *f);
-const char *upb_filedef_phpnamespace(const upb_filedef *f);
-upb_syntax_t upb_filedef_syntax(const upb_filedef *f);
-size_t upb_filedef_defcount(const upb_filedef *f);
-size_t upb_filedef_depcount(const upb_filedef *f);
-const upb_def *upb_filedef_def(const upb_filedef *f, size_t i);
-const upb_filedef *upb_filedef_dep(const upb_filedef *f, size_t i);
-
-bool upb_filedef_freeze(upb_filedef *f, upb_status *s);
-bool upb_filedef_setname(upb_filedef *f, const char *name, upb_status *s);
-bool upb_filedef_setpackage(upb_filedef *f, const char *package, upb_status *s);
-bool upb_filedef_setphpprefix(upb_filedef *f, const char *phpprefix,
-                              upb_status *s);
-bool upb_filedef_setphpnamespace(upb_filedef *f, const char *phpnamespace,
-                                 upb_status *s);
-bool upb_filedef_setsyntax(upb_filedef *f, upb_syntax_t syntax, upb_status *s);
-
-bool upb_filedef_adddef(upb_filedef *f, upb_def *def, const void *ref_donor,
-                        upb_status *s);
-bool upb_filedef_adddep(upb_filedef *f, const upb_filedef *dep);
-
-UPB_INLINE bool upb_filedef_addmsg(upb_filedef *f, upb_msgdef *m,
-                                   const void *ref_donor, upb_status *s) {
-  return upb_filedef_adddef(f, upb_msgdef_upcast_mutable(m), ref_donor, s);
-}
+/* upb_symtab *****************************************************************/
 
-UPB_INLINE bool upb_filedef_addenum(upb_filedef *f, upb_enumdef *e,
-                                    const void *ref_donor, upb_status *s) {
-  return upb_filedef_adddef(f, upb_enumdef_upcast_mutable(e), ref_donor, s);
-}
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-UPB_INLINE bool upb_filedef_addext(upb_filedef *file, upb_fielddef *f,
-                                   const void *ref_donor, upb_status *s) {
-  return upb_filedef_adddef(file, upb_fielddef_upcast_mutable(f), ref_donor, s);
-}
-UPB_INLINE upb_def *upb_filedef_mutabledef(upb_filedef *f, int i) {
-  return (upb_def*)upb_filedef_def(f, i);
-}
+upb_symtab *upb_symtab_new();
+void upb_symtab_free(upb_symtab* s);
+const upb_msgdef *upb_symtab_lookupmsg(const upb_symtab *s, const char *sym);
+const upb_msgdef *upb_symtab_lookupmsg2(
+    const upb_symtab *s, const char *sym, size_t len);
+const upb_enumdef *upb_symtab_lookupenum(const upb_symtab *s, const char *sym);
+const upb_filedef *upb_symtab_lookupfile(const upb_symtab *s, const char *name);
+int upb_symtab_filecount(const upb_symtab *s);
+const upb_filedef *upb_symtab_addfile(
+    upb_symtab *s, const google_protobuf_FileDescriptorProto *file,
+    upb_status *status);
 
-UPB_END_EXTERN_C
+/* For generated code only: loads a generated descriptor. */
+typedef struct upb_def_init {
+  struct upb_def_init **deps;
+  const char *filename;
+  upb_strview descriptor;
+} upb_def_init;
 
-typedef struct {
- UPB_PRIVATE_FOR_CPP
-  upb_strtable_iter iter;
-  upb_deftype_t type;
-} upb_symtab_iter;
+bool _upb_symtab_loaddefinit(upb_symtab *s, const upb_def_init *init);
 
 #ifdef __cplusplus
+}  /* extern "C" */
 
 /* Non-const methods in upb::SymbolTable are NOT thread-safe. */
 class upb::SymbolTable {
  public:
-  /* Returns a new symbol table with a single ref owned by "owner."
-   * Returns NULL if memory allocation failed. */
-  static SymbolTable* New();
-  static void Free(upb::SymbolTable* table);
-
-  /* For all lookup functions, the returned pointer is not owned by the
-   * caller; it may be invalidated by any non-const call or unref of the
-   * SymbolTable!  To protect against this, take a ref if desired. */
-
-  /* Freezes the symbol table: prevents further modification of it.
-   * After the Freeze() operation is successful, the SymbolTable must only be
-   * accessed via a const pointer.
-   *
-   * Unlike with upb::MessageDef/upb::EnumDef/etc, freezing a SymbolTable is not
-   * a necessary step in using a SymbolTable.  If you have no need for it to be
-   * immutable, there is no need to freeze it ever.  However sometimes it is
-   * useful, and SymbolTables that are statically compiled into the binary are
-   * always frozen by nature. */
-  void Freeze();
-
-  /* Resolves the given symbol using the rules described in descriptor.proto,
-   * namely:
-   *
-   *    If the name starts with a '.', it is fully-qualified.  Otherwise,
-   *    C++-like scoping rules are used to find the type (i.e. first the nested
-   *    types within this message are searched, then within the parent, on up
-   *    to the root namespace).
-   *
-   * If not found, returns NULL. */
-  const Def* Resolve(const char* base, const char* sym) const;
+  SymbolTable() : ptr_(upb_symtab_new(), upb_symtab_free) {}
+  explicit SymbolTable(upb_symtab* s) : ptr_(s, upb_symtab_free) {}
+
+  const upb_symtab* ptr() const { return ptr_.get(); }
+  upb_symtab* ptr() { return ptr_.get(); }
 
   /* Finds an entry in the symbol table with this exact name.  If not found,
    * returns NULL. */
-  const Def* Lookup(const char *sym) const;
-  const MessageDef* LookupMessage(const char *sym) const;
-  const EnumDef* LookupEnum(const char *sym) const;
-
-  /* TODO: introduce a C++ iterator, but make it nice and templated so that if
-   * you ask for an iterator of MessageDef the iterated elements are strongly
-   * typed as MessageDef*. */
-
-  /* Adds the given mutable defs to the symtab, resolving all symbols (including
-   * enum default values) and finalizing the defs.  Only one def per name may be
-   * in the list, and the defs may not duplicate any name already in the symtab.
-   * All defs must have a name -- anonymous defs are not allowed.  Anonymous
-   * defs can still be frozen by calling upb_def_freeze() directly.
-   *
-   * The entire operation either succeeds or fails.  If the operation fails,
-   * the symtab is unchanged, false is returned, and status indicates the
-   * error.  The caller passes a ref on all defs to the symtab (even if the
-   * operation fails).
-   *
-   * TODO(haberman): currently failure will leave the symtab unchanged, but may
-   * leave the defs themselves partially resolved.  Does this matter?  If so we
-   * could do a prepass that ensures that all symbols are resolvable and bail
-   * if not, so we don't mutate anything until we know the operation will
-   * succeed. */
-  bool Add(Def*const* defs, size_t n, void* ref_donor, Status* status);
-
-  bool Add(const std::vector<Def*>& defs, void *owner, Status* status) {
-    return Add((Def*const*)&defs[0], defs.size(), owner, status);
+  MessageDefPtr LookupMessage(const char *sym) const {
+    return MessageDefPtr(upb_symtab_lookupmsg(ptr_.get(), sym));
   }
 
-  /* Resolves all subdefs for messages in this file and attempts to freeze the
-   * file.  If this succeeds, adds all the symbols to this SymbolTable
-   * (replacing any existing ones with the same names). */
-  bool AddFile(FileDef* file, Status* s);
-
- private:
-  UPB_DISALLOW_POD_OPS(SymbolTable, upb::SymbolTable)
-#else
-struct upb_symtab {
-  upb_refcounted base;
-
-  upb_strtable symtab;
-#endif  /* __cplusplus */
-};
-
-UPB_BEGIN_EXTERN_C
-
-/* Native C API. */
+  EnumDefPtr LookupEnum(const char *sym) const {
+    return EnumDefPtr(upb_symtab_lookupenum(ptr_.get(), sym));
+  }
 
-upb_symtab *upb_symtab_new();
-void upb_symtab_free(upb_symtab* s);
-const upb_def *upb_symtab_resolve(const upb_symtab *s, const char *base,
-                                  const char *sym);
-const upb_def *upb_symtab_lookup(const upb_symtab *s, const char *sym);
-const upb_msgdef *upb_symtab_lookupmsg(const upb_symtab *s, const char *sym);
-const upb_msgdef *upb_symtab_lookupmsg2(
-    const upb_symtab *s, const char *sym, size_t len);
-const upb_enumdef *upb_symtab_lookupenum(const upb_symtab *s, const char *sym);
-bool upb_symtab_add(upb_symtab *s, upb_def *const*defs, size_t n,
-                    void *ref_donor, upb_status *status);
-bool upb_symtab_addfile(upb_symtab *s, upb_filedef *file, upb_status* status);
-
-/* upb_symtab_iter i;
- * for(upb_symtab_begin(&i, s, type); !upb_symtab_done(&i);
- *     upb_symtab_next(&i)) {
- *   const upb_def *def = upb_symtab_iter_def(&i);
- *    // ...
- * }
- *
- * For C we don't have separate iterators for const and non-const.
- * It is the caller's responsibility to cast the upb_fielddef* to
- * const if the upb_msgdef* is const. */
-void upb_symtab_begin(upb_symtab_iter *iter, const upb_symtab *s,
-                      upb_deftype_t type);
-void upb_symtab_next(upb_symtab_iter *iter);
-bool upb_symtab_done(const upb_symtab_iter *iter);
-const upb_def *upb_symtab_iter_def(const upb_symtab_iter *iter);
+  FileDefPtr LookupFile(const char *name) const {
+    return FileDefPtr(upb_symtab_lookupfile(ptr_.get(), name));
+  }
 
-UPB_END_EXTERN_C
+  /* TODO: iteration? */
 
-#ifdef __cplusplus
-/* C++ inline wrappers. */
-namespace upb {
-inline SymbolTable* SymbolTable::New() {
-  return upb_symtab_new();
-}
-inline void SymbolTable::Free(SymbolTable* s) {
-  upb_symtab_free(s);
-}
-inline const Def *SymbolTable::Resolve(const char *base,
-                                       const char *sym) const {
-  return upb_symtab_resolve(this, base, sym);
-}
-inline const Def* SymbolTable::Lookup(const char *sym) const {
-  return upb_symtab_lookup(this, sym);
-}
-inline const MessageDef *SymbolTable::LookupMessage(const char *sym) const {
-  return upb_symtab_lookupmsg(this, sym);
-}
-inline bool SymbolTable::Add(
-    Def*const* defs, size_t n, void* ref_donor, Status* status) {
-  return upb_symtab_add(this, (upb_def*const*)defs, n, ref_donor, status);
-}
-inline bool SymbolTable::AddFile(FileDef* file, Status* s) {
-  return upb_symtab_addfile(this, file, s);
-}
-}  /* namespace upb */
-#endif
+  /* Adds the given serialized FileDescriptorProto to the pool. */
+  FileDefPtr AddFile(const google_protobuf_FileDescriptorProto *file_proto,
+                     Status *status) {
+    return FileDefPtr(
+        upb_symtab_addfile(ptr_.get(), file_proto, status->ptr()));
+  }
 
-#ifdef __cplusplus
+ private:
+  std::unique_ptr<upb_symtab, decltype(&upb_symtab_free)> ptr_;
+};
 
 UPB_INLINE const char* upb_safecstr(const std::string& str) {
   UPB_ASSERT(str.size() == std::strlen(str.c_str()));
   return str.c_str();
 }
 
-/* Inline C++ wrappers. */
-namespace upb {
-
-inline Def::Type Def::def_type() const { return upb_def_type(this); }
-inline const char* Def::full_name() const { return upb_def_fullname(this); }
-inline const char* Def::name() const { return upb_def_name(this); }
-inline bool Def::set_full_name(const char* fullname, Status* s) {
-  return upb_def_setfullname(this, fullname, s);
-}
-inline bool Def::set_full_name(const std::string& fullname, Status* s) {
-  return upb_def_setfullname(this, upb_safecstr(fullname), s);
-}
-inline bool Def::Freeze(Def* const* defs, size_t n, Status* status) {
-  return upb_def_freeze(defs, n, status);
-}
-inline bool Def::Freeze(const std::vector<Def*>& defs, Status* status) {
-  return upb_def_freeze((Def* const*)&defs[0], defs.size(), status);
-}
-
-inline bool FieldDef::CheckType(int32_t val) {
-  return upb_fielddef_checktype(val);
-}
-inline bool FieldDef::CheckLabel(int32_t val) {
-  return upb_fielddef_checklabel(val);
-}
-inline bool FieldDef::CheckDescriptorType(int32_t val) {
-  return upb_fielddef_checkdescriptortype(val);
-}
-inline bool FieldDef::CheckIntegerFormat(int32_t val) {
-  return upb_fielddef_checkintfmt(val);
-}
-inline FieldDef::Type FieldDef::ConvertType(int32_t val) {
-  UPB_ASSERT(CheckType(val));
-  return static_cast<FieldDef::Type>(val);
-}
-inline FieldDef::Label FieldDef::ConvertLabel(int32_t val) {
-  UPB_ASSERT(CheckLabel(val));
-  return static_cast<FieldDef::Label>(val);
-}
-inline FieldDef::DescriptorType FieldDef::ConvertDescriptorType(int32_t val) {
-  UPB_ASSERT(CheckDescriptorType(val));
-  return static_cast<FieldDef::DescriptorType>(val);
-}
-inline FieldDef::IntegerFormat FieldDef::ConvertIntegerFormat(int32_t val) {
-  UPB_ASSERT(CheckIntegerFormat(val));
-  return static_cast<FieldDef::IntegerFormat>(val);
-}
-
-inline reffed_ptr<FieldDef> FieldDef::New() {
-  upb_fielddef *f = upb_fielddef_new(&f);
-  return reffed_ptr<FieldDef>(f, &f);
-}
-inline const char* FieldDef::full_name() const {
-  return upb_fielddef_fullname(this);
-}
-inline bool FieldDef::set_full_name(const char* fullname, Status* s) {
-  return upb_fielddef_setfullname(this, fullname, s);
-}
-inline bool FieldDef::set_full_name(const std::string& fullname, Status* s) {
-  return upb_fielddef_setfullname(this, upb_safecstr(fullname), s);
-}
-inline bool FieldDef::type_is_set() const {
-  return upb_fielddef_typeisset(this);
-}
-inline FieldDef::Type FieldDef::type() const { return upb_fielddef_type(this); }
-inline FieldDef::DescriptorType FieldDef::descriptor_type() const {
-  return upb_fielddef_descriptortype(this);
-}
-inline FieldDef::Label FieldDef::label() const {
-  return upb_fielddef_label(this);
-}
-inline uint32_t FieldDef::number() const { return upb_fielddef_number(this); }
-inline const char* FieldDef::name() const { return upb_fielddef_name(this); }
-inline bool FieldDef::is_extension() const {
-  return upb_fielddef_isextension(this);
-}
-inline size_t FieldDef::GetJsonName(char* buf, size_t len) const {
-  return upb_fielddef_getjsonname(this, buf, len);
-}
-inline bool FieldDef::lazy() const {
-  return upb_fielddef_lazy(this);
-}
-inline void FieldDef::set_lazy(bool lazy) {
-  upb_fielddef_setlazy(this, lazy);
-}
-inline bool FieldDef::packed() const {
-  return upb_fielddef_packed(this);
-}
-inline uint32_t FieldDef::index() const {
-  return upb_fielddef_index(this);
-}
-inline void FieldDef::set_packed(bool packed) {
-  upb_fielddef_setpacked(this, packed);
-}
-inline const MessageDef* FieldDef::containing_type() const {
-  return upb_fielddef_containingtype(this);
-}
-inline const OneofDef* FieldDef::containing_oneof() const {
-  return upb_fielddef_containingoneof(this);
-}
-inline const char* FieldDef::containing_type_name() {
-  return upb_fielddef_containingtypename(this);
-}
-inline bool FieldDef::set_number(uint32_t number, Status* s) {
-  return upb_fielddef_setnumber(this, number, s);
-}
-inline bool FieldDef::set_name(const char *name, Status* s) {
-  return upb_fielddef_setname(this, name, s);
-}
-inline bool FieldDef::set_name(const std::string& name, Status* s) {
-  return upb_fielddef_setname(this, upb_safecstr(name), s);
-}
-inline bool FieldDef::set_json_name(const char *name, Status* s) {
-  return upb_fielddef_setjsonname(this, name, s);
-}
-inline bool FieldDef::set_json_name(const std::string& name, Status* s) {
-  return upb_fielddef_setjsonname(this, upb_safecstr(name), s);
-}
-inline void FieldDef::clear_json_name() {
-  upb_fielddef_clearjsonname(this);
-}
-inline bool FieldDef::set_containing_type_name(const char *name, Status* s) {
-  return upb_fielddef_setcontainingtypename(this, name, s);
-}
-inline bool FieldDef::set_containing_type_name(const std::string &name,
-                                               Status *s) {
-  return upb_fielddef_setcontainingtypename(this, upb_safecstr(name), s);
-}
-inline void FieldDef::set_type(upb_fieldtype_t type) {
-  upb_fielddef_settype(this, type);
-}
-inline void FieldDef::set_is_extension(bool is_extension) {
-  upb_fielddef_setisextension(this, is_extension);
-}
-inline void FieldDef::set_descriptor_type(FieldDef::DescriptorType type) {
-  upb_fielddef_setdescriptortype(this, type);
-}
-inline void FieldDef::set_label(upb_label_t label) {
-  upb_fielddef_setlabel(this, label);
-}
-inline bool FieldDef::IsSubMessage() const {
-  return upb_fielddef_issubmsg(this);
-}
-inline bool FieldDef::IsString() const { return upb_fielddef_isstring(this); }
-inline bool FieldDef::IsSequence() const { return upb_fielddef_isseq(this); }
-inline bool FieldDef::IsMap() const { return upb_fielddef_ismap(this); }
-inline int64_t FieldDef::default_int64() const {
-  return upb_fielddef_defaultint64(this);
-}
-inline int32_t FieldDef::default_int32() const {
-  return upb_fielddef_defaultint32(this);
-}
-inline uint64_t FieldDef::default_uint64() const {
-  return upb_fielddef_defaultuint64(this);
-}
-inline uint32_t FieldDef::default_uint32() const {
-  return upb_fielddef_defaultuint32(this);
-}
-inline bool FieldDef::default_bool() const {
-  return upb_fielddef_defaultbool(this);
-}
-inline float FieldDef::default_float() const {
-  return upb_fielddef_defaultfloat(this);
-}
-inline double FieldDef::default_double() const {
-  return upb_fielddef_defaultdouble(this);
-}
-inline const char* FieldDef::default_string(size_t* len) const {
-  return upb_fielddef_defaultstr(this, len);
-}
-inline void FieldDef::set_default_int64(int64_t value) {
-  upb_fielddef_setdefaultint64(this, value);
-}
-inline void FieldDef::set_default_int32(int32_t value) {
-  upb_fielddef_setdefaultint32(this, value);
-}
-inline void FieldDef::set_default_uint64(uint64_t value) {
-  upb_fielddef_setdefaultuint64(this, value);
-}
-inline void FieldDef::set_default_uint32(uint32_t value) {
-  upb_fielddef_setdefaultuint32(this, value);
-}
-inline void FieldDef::set_default_bool(bool value) {
-  upb_fielddef_setdefaultbool(this, value);
-}
-inline void FieldDef::set_default_float(float value) {
-  upb_fielddef_setdefaultfloat(this, value);
-}
-inline void FieldDef::set_default_double(double value) {
-  upb_fielddef_setdefaultdouble(this, value);
-}
-inline bool FieldDef::set_default_string(const void *str, size_t len,
-                                         Status *s) {
-  return upb_fielddef_setdefaultstr(this, str, len, s);
-}
-inline bool FieldDef::set_default_string(const std::string& str, Status* s) {
-  return upb_fielddef_setdefaultstr(this, str.c_str(), str.size(), s);
-}
-inline void FieldDef::set_default_cstr(const char* str, Status* s) {
-  return upb_fielddef_setdefaultcstr(this, str, s);
-}
-inline bool FieldDef::HasSubDef() const { return upb_fielddef_hassubdef(this); }
-inline const Def* FieldDef::subdef() const { return upb_fielddef_subdef(this); }
-inline const MessageDef *FieldDef::message_subdef() const {
-  return upb_fielddef_msgsubdef(this);
-}
-inline const EnumDef *FieldDef::enum_subdef() const {
-  return upb_fielddef_enumsubdef(this);
-}
-inline const char* FieldDef::subdef_name() const {
-  return upb_fielddef_subdefname(this);
-}
-inline bool FieldDef::set_subdef(const Def* subdef, Status* s) {
-  return upb_fielddef_setsubdef(this, subdef, s);
-}
-inline bool FieldDef::set_enum_subdef(const EnumDef* subdef, Status* s) {
-  return upb_fielddef_setenumsubdef(this, subdef, s);
-}
-inline bool FieldDef::set_message_subdef(const MessageDef* subdef, Status* s) {
-  return upb_fielddef_setmsgsubdef(this, subdef, s);
-}
-inline bool FieldDef::set_subdef_name(const char* name, Status* s) {
-  return upb_fielddef_setsubdefname(this, name, s);
-}
-inline bool FieldDef::set_subdef_name(const std::string& name, Status* s) {
-  return upb_fielddef_setsubdefname(this, upb_safecstr(name), s);
-}
-
-inline reffed_ptr<MessageDef> MessageDef::New() {
-  upb_msgdef *m = upb_msgdef_new(&m);
-  return reffed_ptr<MessageDef>(m, &m);
-}
-inline const char *MessageDef::full_name() const {
-  return upb_msgdef_fullname(this);
-}
-inline const char *MessageDef::name() const {
-  return upb_msgdef_name(this);
-}
-inline upb_syntax_t MessageDef::syntax() const {
-  return upb_msgdef_syntax(this);
-}
-inline bool MessageDef::set_full_name(const char* fullname, Status* s) {
-  return upb_msgdef_setfullname(this, fullname, s);
-}
-inline bool MessageDef::set_full_name(const std::string& fullname, Status* s) {
-  return upb_msgdef_setfullname(this, upb_safecstr(fullname), s);
-}
-inline bool MessageDef::set_syntax(upb_syntax_t syntax) {
-  return upb_msgdef_setsyntax(this, syntax);
-}
-inline bool MessageDef::Freeze(Status* status) {
-  return upb_msgdef_freeze(this, status);
-}
-inline int MessageDef::field_count() const {
-  return upb_msgdef_numfields(this);
-}
-inline int MessageDef::oneof_count() const {
-  return upb_msgdef_numoneofs(this);
-}
-inline bool MessageDef::AddField(upb_fielddef* f, Status* s) {
-  return upb_msgdef_addfield(this, f, NULL, s);
-}
-inline bool MessageDef::AddField(const reffed_ptr<FieldDef>& f, Status* s) {
-  return upb_msgdef_addfield(this, f.get(), NULL, s);
-}
-inline bool MessageDef::AddOneof(upb_oneofdef* o, Status* s) {
-  return upb_msgdef_addoneof(this, o, NULL, s);
-}
-inline bool MessageDef::AddOneof(const reffed_ptr<OneofDef>& o, Status* s) {
-  return upb_msgdef_addoneof(this, o.get(), NULL, s);
-}
-inline FieldDef* MessageDef::FindFieldByNumber(uint32_t number) {
-  return upb_msgdef_itof_mutable(this, number);
-}
-inline FieldDef* MessageDef::FindFieldByName(const char* name, size_t len) {
-  return upb_msgdef_ntof_mutable(this, name, len);
-}
-inline const FieldDef* MessageDef::FindFieldByNumber(uint32_t number) const {
-  return upb_msgdef_itof(this, number);
-}
-inline const FieldDef *MessageDef::FindFieldByName(const char *name,
-                                                   size_t len) const {
-  return upb_msgdef_ntof(this, name, len);
-}
-inline OneofDef* MessageDef::FindOneofByName(const char* name, size_t len) {
-  return upb_msgdef_ntoo_mutable(this, name, len);
-}
-inline const OneofDef* MessageDef::FindOneofByName(const char* name,
-                                                   size_t len) const {
-  return upb_msgdef_ntoo(this, name, len);
-}
-inline void MessageDef::setmapentry(bool map_entry) {
-  upb_msgdef_setmapentry(this, map_entry);
-}
-inline bool MessageDef::mapentry() const {
-  return upb_msgdef_mapentry(this);
-}
-inline upb_wellknowntype_t MessageDef::wellknowntype() const {
-  return upb_msgdef_wellknowntype(this);
-}
-inline bool MessageDef::isnumberwrapper() const {
-  return upb_msgdef_isnumberwrapper(this);
-}
-inline MessageDef::field_iterator MessageDef::field_begin() {
-  return field_iterator(this);
-}
-inline MessageDef::field_iterator MessageDef::field_end() {
-  return field_iterator::end(this);
-}
-inline MessageDef::const_field_iterator MessageDef::field_begin() const {
-  return const_field_iterator(this);
-}
-inline MessageDef::const_field_iterator MessageDef::field_end() const {
-  return const_field_iterator::end(this);
-}
-
-inline MessageDef::oneof_iterator MessageDef::oneof_begin() {
-  return oneof_iterator(this);
-}
-inline MessageDef::oneof_iterator MessageDef::oneof_end() {
-  return oneof_iterator::end(this);
-}
-inline MessageDef::const_oneof_iterator MessageDef::oneof_begin() const {
-  return const_oneof_iterator(this);
-}
-inline MessageDef::const_oneof_iterator MessageDef::oneof_end() const {
-  return const_oneof_iterator::end(this);
-}
-
-inline MessageDef::field_iterator::field_iterator(MessageDef* md) {
-  upb_msg_field_begin(&iter_, md);
-}
-inline MessageDef::field_iterator MessageDef::field_iterator::end(
-    MessageDef* md) {
-  MessageDef::field_iterator iter(md);
-  upb_msg_field_iter_setdone(&iter.iter_);
-  return iter;
-}
-inline FieldDef* MessageDef::field_iterator::operator*() const {
-  return upb_msg_iter_field(&iter_);
-}
-inline void MessageDef::field_iterator::operator++() {
-  return upb_msg_field_next(&iter_);
-}
-inline bool MessageDef::field_iterator::operator==(
-    const field_iterator &other) const {
-  return upb_inttable_iter_isequal(&iter_, &other.iter_);
-}
-inline bool MessageDef::field_iterator::operator!=(
-    const field_iterator &other) const {
-  return !(*this == other);
-}
-
-inline MessageDef::const_field_iterator::const_field_iterator(
-    const MessageDef* md) {
-  upb_msg_field_begin(&iter_, md);
-}
-inline MessageDef::const_field_iterator MessageDef::const_field_iterator::end(
-    const MessageDef *md) {
-  MessageDef::const_field_iterator iter(md);
-  upb_msg_field_iter_setdone(&iter.iter_);
-  return iter;
-}
-inline const FieldDef* MessageDef::const_field_iterator::operator*() const {
-  return upb_msg_iter_field(&iter_);
-}
-inline void MessageDef::const_field_iterator::operator++() {
-  return upb_msg_field_next(&iter_);
-}
-inline bool MessageDef::const_field_iterator::operator==(
-    const const_field_iterator &other) const {
-  return upb_inttable_iter_isequal(&iter_, &other.iter_);
-}
-inline bool MessageDef::const_field_iterator::operator!=(
-    const const_field_iterator &other) const {
-  return !(*this == other);
-}
-
-inline MessageDef::oneof_iterator::oneof_iterator(MessageDef* md) {
-  upb_msg_oneof_begin(&iter_, md);
-}
-inline MessageDef::oneof_iterator MessageDef::oneof_iterator::end(
-    MessageDef* md) {
-  MessageDef::oneof_iterator iter(md);
-  upb_msg_oneof_iter_setdone(&iter.iter_);
-  return iter;
-}
-inline OneofDef* MessageDef::oneof_iterator::operator*() const {
-  return upb_msg_iter_oneof(&iter_);
-}
-inline void MessageDef::oneof_iterator::operator++() {
-  return upb_msg_oneof_next(&iter_);
-}
-inline bool MessageDef::oneof_iterator::operator==(
-    const oneof_iterator &other) const {
-  return upb_strtable_iter_isequal(&iter_, &other.iter_);
-}
-inline bool MessageDef::oneof_iterator::operator!=(
-    const oneof_iterator &other) const {
-  return !(*this == other);
-}
-
-inline MessageDef::const_oneof_iterator::const_oneof_iterator(
-    const MessageDef* md) {
-  upb_msg_oneof_begin(&iter_, md);
-}
-inline MessageDef::const_oneof_iterator MessageDef::const_oneof_iterator::end(
-    const MessageDef *md) {
-  MessageDef::const_oneof_iterator iter(md);
-  upb_msg_oneof_iter_setdone(&iter.iter_);
-  return iter;
-}
-inline const OneofDef* MessageDef::const_oneof_iterator::operator*() const {
-  return upb_msg_iter_oneof(&iter_);
-}
-inline void MessageDef::const_oneof_iterator::operator++() {
-  return upb_msg_oneof_next(&iter_);
-}
-inline bool MessageDef::const_oneof_iterator::operator==(
-    const const_oneof_iterator &other) const {
-  return upb_strtable_iter_isequal(&iter_, &other.iter_);
-}
-inline bool MessageDef::const_oneof_iterator::operator!=(
-    const const_oneof_iterator &other) const {
-  return !(*this == other);
-}
-
-inline reffed_ptr<EnumDef> EnumDef::New() {
-  upb_enumdef *e = upb_enumdef_new(&e);
-  return reffed_ptr<EnumDef>(e, &e);
-}
-inline const char* EnumDef::full_name() const {
-  return upb_enumdef_fullname(this);
-}
-inline const char* EnumDef::name() const {
-  return upb_enumdef_name(this);
-}
-inline bool EnumDef::set_full_name(const char* fullname, Status* s) {
-  return upb_enumdef_setfullname(this, fullname, s);
-}
-inline bool EnumDef::set_full_name(const std::string& fullname, Status* s) {
-  return upb_enumdef_setfullname(this, upb_safecstr(fullname), s);
-}
-inline bool EnumDef::Freeze(Status* status) {
-  return upb_enumdef_freeze(this, status);
-}
-inline int32_t EnumDef::default_value() const {
-  return upb_enumdef_default(this);
-}
-inline bool EnumDef::set_default_value(int32_t val, Status* status) {
-  return upb_enumdef_setdefault(this, val, status);
-}
-inline int EnumDef::value_count() const { return upb_enumdef_numvals(this); }
-inline bool EnumDef::AddValue(const char* name, int32_t num, Status* status) {
-  return upb_enumdef_addval(this, name, num, status);
-}
-inline bool EnumDef::AddValue(const std::string& name, int32_t num,
-                              Status* status) {
-  return upb_enumdef_addval(this, upb_safecstr(name), num, status);
-}
-inline bool EnumDef::FindValueByName(const char* name, int32_t *num) const {
-  return upb_enumdef_ntoiz(this, name, num);
-}
-inline const char* EnumDef::FindValueByNumber(int32_t num) const {
-  return upb_enumdef_iton(this, num);
-}
-
-inline EnumDef::Iterator::Iterator(const EnumDef* e) {
-  upb_enum_begin(&iter_, e);
-}
-inline int32_t EnumDef::Iterator::number() {
-  return upb_enum_iter_number(&iter_);
-}
-inline const char* EnumDef::Iterator::name() {
-  return upb_enum_iter_name(&iter_);
-}
-inline bool EnumDef::Iterator::Done() { return upb_enum_done(&iter_); }
-inline void EnumDef::Iterator::Next() { return upb_enum_next(&iter_); }
-
-inline reffed_ptr<OneofDef> OneofDef::New() {
-  upb_oneofdef *o = upb_oneofdef_new(&o);
-  return reffed_ptr<OneofDef>(o, &o);
-}
-
-inline const MessageDef* OneofDef::containing_type() const {
-  return upb_oneofdef_containingtype(this);
-}
-inline const char* OneofDef::name() const {
-  return upb_oneofdef_name(this);
-}
-inline bool OneofDef::set_name(const char* name, Status* s) {
-  return upb_oneofdef_setname(this, name, s);
-}
-inline bool OneofDef::set_name(const std::string& name, Status* s) {
-  return upb_oneofdef_setname(this, upb_safecstr(name), s);
-}
-inline int OneofDef::field_count() const {
-  return upb_oneofdef_numfields(this);
-}
-inline bool OneofDef::AddField(FieldDef* field, Status* s) {
-  return upb_oneofdef_addfield(this, field, NULL, s);
-}
-inline bool OneofDef::AddField(const reffed_ptr<FieldDef>& field, Status* s) {
-  return upb_oneofdef_addfield(this, field.get(), NULL, s);
-}
-inline const FieldDef* OneofDef::FindFieldByName(const char* name,
-                                                 size_t len) const {
-  return upb_oneofdef_ntof(this, name, len);
-}
-inline const FieldDef* OneofDef::FindFieldByNumber(uint32_t num) const {
-  return upb_oneofdef_itof(this, num);
-}
-inline OneofDef::iterator OneofDef::begin() { return iterator(this); }
-inline OneofDef::iterator OneofDef::end() { return iterator::end(this); }
-inline OneofDef::const_iterator OneofDef::begin() const {
-  return const_iterator(this);
-}
-inline OneofDef::const_iterator OneofDef::end() const {
-  return const_iterator::end(this);
-}
-
-inline OneofDef::iterator::iterator(OneofDef* o) {
-  upb_oneof_begin(&iter_, o);
-}
-inline OneofDef::iterator OneofDef::iterator::end(OneofDef* o) {
-  OneofDef::iterator iter(o);
-  upb_oneof_iter_setdone(&iter.iter_);
-  return iter;
-}
-inline FieldDef* OneofDef::iterator::operator*() const {
-  return upb_oneof_iter_field(&iter_);
-}
-inline void OneofDef::iterator::operator++() { return upb_oneof_next(&iter_); }
-inline bool OneofDef::iterator::operator==(const iterator &other) const {
-  return upb_inttable_iter_isequal(&iter_, &other.iter_);
-}
-inline bool OneofDef::iterator::operator!=(const iterator &other) const {
-  return !(*this == other);
-}
-
-inline OneofDef::const_iterator::const_iterator(const OneofDef* md) {
-  upb_oneof_begin(&iter_, md);
-}
-inline OneofDef::const_iterator OneofDef::const_iterator::end(
-    const OneofDef *md) {
-  OneofDef::const_iterator iter(md);
-  upb_oneof_iter_setdone(&iter.iter_);
-  return iter;
-}
-inline const FieldDef* OneofDef::const_iterator::operator*() const {
-  return upb_msg_iter_field(&iter_);
-}
-inline void OneofDef::const_iterator::operator++() {
-  return upb_oneof_next(&iter_);
-}
-inline bool OneofDef::const_iterator::operator==(
-    const const_iterator &other) const {
-  return upb_inttable_iter_isequal(&iter_, &other.iter_);
-}
-inline bool OneofDef::const_iterator::operator!=(
-    const const_iterator &other) const {
-  return !(*this == other);
-}
-
-inline reffed_ptr<FileDef> FileDef::New() {
-  upb_filedef *f = upb_filedef_new(&f);
-  return reffed_ptr<FileDef>(f, &f);
-}
-
-inline const char* FileDef::name() const {
-  return upb_filedef_name(this);
-}
-inline bool FileDef::set_name(const char* name, Status* s) {
-  return upb_filedef_setname(this, name, s);
-}
-inline bool FileDef::set_name(const std::string& name, Status* s) {
-  return upb_filedef_setname(this, upb_safecstr(name), s);
-}
-inline const char* FileDef::package() const {
-  return upb_filedef_package(this);
-}
-inline bool FileDef::set_package(const char* package, Status* s) {
-  return upb_filedef_setpackage(this, package, s);
-}
-inline const char* FileDef::phpprefix() const {
-  return upb_filedef_phpprefix(this);
-}
-inline bool FileDef::set_phpprefix(const char* phpprefix, Status* s) {
-  return upb_filedef_setphpprefix(this, phpprefix, s);
-}
-inline const char* FileDef::phpnamespace() const {
-  return upb_filedef_phpnamespace(this);
-}
-inline bool FileDef::set_phpnamespace(const char* phpnamespace, Status* s) {
-  return upb_filedef_setphpnamespace(this, phpnamespace, s);
-}
-inline int FileDef::def_count() const {
-  return upb_filedef_defcount(this);
-}
-inline const Def* FileDef::def(int index) const {
-  return upb_filedef_def(this, index);
-}
-inline Def* FileDef::def(int index) {
-  return const_cast<Def*>(upb_filedef_def(this, index));
-}
-inline int FileDef::dependency_count() const {
-  return upb_filedef_depcount(this);
-}
-inline const FileDef* FileDef::dependency(int index) const {
-  return upb_filedef_dep(this, index);
-}
-inline bool FileDef::AddDef(Def* def, Status* s) {
-  return upb_filedef_adddef(this, def, NULL, s);
-}
-inline bool FileDef::AddMessage(MessageDef* m, Status* s) {
-  return upb_filedef_addmsg(this, m, NULL, s);
-}
-inline bool FileDef::AddEnum(EnumDef* e, Status* s) {
-  return upb_filedef_addenum(this, e, NULL, s);
-}
-inline bool FileDef::AddExtension(FieldDef* f, Status* s) {
-  return upb_filedef_addext(this, f, NULL, s);
-}
-inline bool FileDef::AddDependency(const FileDef* file) {
-  return upb_filedef_adddep(this, file);
-}
-
-}  /* namespace upb */
-#endif
+#endif  /* __cplusplus */
 
 #endif /* UPB_DEF_H_ */
diff --git a/upb/descriptor/descriptor.pb b/upb/descriptor/descriptor.pb
deleted file mode 100644
index 74bc3bc..0000000
--- a/upb/descriptor/descriptor.pb
+++ /dev/null
diff --git a/upb/descriptor/descriptor.proto b/upb/descriptor/descriptor.proto
deleted file mode 100644
index b6e303e..0000000
--- a/upb/descriptor/descriptor.proto
+++ /dev/null
@@ -1,788 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Author: kenton@google.com (Kenton Varda)
-//  Based on original Protocol Buffers design by
-//  Sanjay Ghemawat, Jeff Dean, and others.
-//
-// The messages in this file describe the definitions found in .proto files.
-// A valid .proto file can be translated directly to a FileDescriptorProto
-// without any other information (e.g. without reading its imports).
-
-
-syntax = "proto2";
-
-package google.protobuf;
-option go_package = "descriptor";
-option java_package = "com.google.protobuf";
-option java_outer_classname = "DescriptorProtos";
-option csharp_namespace = "Google.Protobuf.Reflection";
-option objc_class_prefix = "GPB";
-
-// descriptor.proto must be optimized for speed because reflection-based
-// algorithms don't work during bootstrapping.
-option optimize_for = SPEED;
-
-// The protocol compiler can output a FileDescriptorSet containing the .proto
-// files it parses.
-message FileDescriptorSet {
-  repeated FileDescriptorProto file = 1;
-}
-
-// Describes a complete .proto file.
-message FileDescriptorProto {
-  optional string name = 1;       // file name, relative to root of source tree
-  optional string package = 2;    // e.g. "foo", "foo.bar", etc.
-
-  // Names of files imported by this file.
-  repeated string dependency = 3;
-  // Indexes of the public imported files in the dependency list above.
-  repeated int32 public_dependency = 10;
-  // Indexes of the weak imported files in the dependency list.
-  // For Google-internal migration only. Do not use.
-  repeated int32 weak_dependency = 11;
-
-  // All top-level definitions in this file.
-  repeated DescriptorProto message_type = 4;
-  repeated EnumDescriptorProto enum_type = 5;
-  repeated ServiceDescriptorProto service = 6;
-  repeated FieldDescriptorProto extension = 7;
-
-  optional FileOptions options = 8;
-
-  // This field contains optional information about the original source code.
-  // You may safely remove this entire field without harming runtime
-  // functionality of the descriptors -- the information is needed only by
-  // development tools.
-  optional SourceCodeInfo source_code_info = 9;
-
-  // The syntax of the proto file.
-  // The supported values are "proto2" and "proto3".
-  optional string syntax = 12;
-}
-
-// Describes a message type.
-message DescriptorProto {
-  optional string name = 1;
-
-  repeated FieldDescriptorProto field = 2;
-  repeated FieldDescriptorProto extension = 6;
-
-  repeated DescriptorProto nested_type = 3;
-  repeated EnumDescriptorProto enum_type = 4;
-
-  message ExtensionRange {
-    optional int32 start = 1;
-    optional int32 end = 2;
-  }
-  repeated ExtensionRange extension_range = 5;
-
-  repeated OneofDescriptorProto oneof_decl = 8;
-
-  optional MessageOptions options = 7;
-
-  // Range of reserved tag numbers. Reserved tag numbers may not be used by
-  // fields or extension ranges in the same message. Reserved ranges may
-  // not overlap.
-  message ReservedRange {
-    optional int32 start = 1; // Inclusive.
-    optional int32 end = 2;   // Exclusive.
-  }
-  repeated ReservedRange reserved_range = 9;
-  // Reserved field names, which may not be used by fields in the same message.
-  // A given name may only be reserved once.
-  repeated string reserved_name = 10;
-}
-
-// Describes a field within a message.
-message FieldDescriptorProto {
-  enum Type {
-    // 0 is reserved for errors.
-    // Order is weird for historical reasons.
-    TYPE_DOUBLE         = 1;
-    TYPE_FLOAT          = 2;
-    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
-    // negative values are likely.
-    TYPE_INT64          = 3;
-    TYPE_UINT64         = 4;
-    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
-    // negative values are likely.
-    TYPE_INT32          = 5;
-    TYPE_FIXED64        = 6;
-    TYPE_FIXED32        = 7;
-    TYPE_BOOL           = 8;
-    TYPE_STRING         = 9;
-    TYPE_GROUP          = 10;  // Tag-delimited aggregate.
-    TYPE_MESSAGE        = 11;  // Length-delimited aggregate.
-
-    // New in version 2.
-    TYPE_BYTES          = 12;
-    TYPE_UINT32         = 13;
-    TYPE_ENUM           = 14;
-    TYPE_SFIXED32       = 15;
-    TYPE_SFIXED64       = 16;
-    TYPE_SINT32         = 17;  // Uses ZigZag encoding.
-    TYPE_SINT64         = 18;  // Uses ZigZag encoding.
-  };
-
-  enum Label {
-    // 0 is reserved for errors
-    LABEL_OPTIONAL      = 1;
-    LABEL_REQUIRED      = 2;
-    LABEL_REPEATED      = 3;
-    // TODO(sanjay): Should we add LABEL_MAP?
-  };
-
-  optional string name = 1;
-  optional int32 number = 3;
-  optional Label label = 4;
-
-  // If type_name is set, this need not be set.  If both this and type_name
-  // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
-  optional Type type = 5;
-
-  // For message and enum types, this is the name of the type.  If the name
-  // starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
-  // rules are used to find the type (i.e. first the nested types within this
-  // message are searched, then within the parent, on up to the root
-  // namespace).
-  optional string type_name = 6;
-
-  // For extensions, this is the name of the type being extended.  It is
-  // resolved in the same manner as type_name.
-  optional string extendee = 2;
-
-  // For numeric types, contains the original text representation of the value.
-  // For booleans, "true" or "false".
-  // For strings, contains the default text contents (not escaped in any way).
-  // For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
-  // TODO(kenton):  Base-64 encode?
-  optional string default_value = 7;
-
-  // If set, gives the index of a oneof in the containing type's oneof_decl
-  // list.  This field is a member of that oneof.
-  optional int32 oneof_index = 9;
-
-  // JSON name of this field. The value is set by protocol compiler. If the
-  // user has set a "json_name" option on this field, that option's value
-  // will be used. Otherwise, it's deduced from the field's name by converting
-  // it to camelCase.
-  optional string json_name = 10;
-
-  optional FieldOptions options = 8;
-}
-
-// Describes a oneof.
-message OneofDescriptorProto {
-  optional string name = 1;
-}
-
-// Describes an enum type.
-message EnumDescriptorProto {
-  optional string name = 1;
-
-  repeated EnumValueDescriptorProto value = 2;
-
-  optional EnumOptions options = 3;
-}
-
-// Describes a value within an enum.
-message EnumValueDescriptorProto {
-  optional string name = 1;
-  optional int32 number = 2;
-
-  optional EnumValueOptions options = 3;
-}
-
-// Describes a service.
-message ServiceDescriptorProto {
-  optional string name = 1;
-  repeated MethodDescriptorProto method = 2;
-
-  optional ServiceOptions options = 3;
-}
-
-// Describes a method of a service.
-message MethodDescriptorProto {
-  optional string name = 1;
-
-  // Input and output type names.  These are resolved in the same way as
-  // FieldDescriptorProto.type_name, but must refer to a message type.
-  optional string input_type = 2;
-  optional string output_type = 3;
-
-  optional MethodOptions options = 4;
-
-  // Identifies if client streams multiple client messages
-  optional bool client_streaming = 5 [default=false];
-  // Identifies if server streams multiple server messages
-  optional bool server_streaming = 6 [default=false];
-}
-
-
-// ===================================================================
-// Options
-
-// Each of the definitions above may have "options" attached.  These are
-// just annotations which may cause code to be generated slightly differently
-// or may contain hints for code that manipulates protocol messages.
-//
-// Clients may define custom options as extensions of the *Options messages.
-// These extensions may not yet be known at parsing time, so the parser cannot
-// store the values in them.  Instead it stores them in a field in the *Options
-// message called uninterpreted_option. This field must have the same name
-// across all *Options messages. We then use this field to populate the
-// extensions when we build a descriptor, at which point all protos have been
-// parsed and so all extensions are known.
-//
-// Extension numbers for custom options may be chosen as follows:
-// * For options which will only be used within a single application or
-//   organization, or for experimental options, use field numbers 50000
-//   through 99999.  It is up to you to ensure that you do not use the
-//   same number for multiple options.
-// * For options which will be published and used publicly by multiple
-//   independent entities, e-mail protobuf-global-extension-registry@google.com
-//   to reserve extension numbers. Simply provide your project name (e.g.
-//   Objective-C plugin) and your project website (if available) -- there's no
-//   need to explain how you intend to use them. Usually you only need one
-//   extension number. You can declare multiple options with only one extension
-//   number by putting them in a sub-message. See the Custom Options section of
-//   the docs for examples:
-//   https://developers.google.com/protocol-buffers/docs/proto#options
-//   If this turns out to be popular, a web service will be set up
-//   to automatically assign option numbers.
-
-
-message FileOptions {
-
-  // Sets the Java package where classes generated from this .proto will be
-  // placed.  By default, the proto package is used, but this is often
-  // inappropriate because proto packages do not normally start with backwards
-  // domain names.
-  optional string java_package = 1;
-
-
-  // If set, all the classes from the .proto file are wrapped in a single
-  // outer class with the given name.  This applies to both Proto1
-  // (equivalent to the old "--one_java_file" option) and Proto2 (where
-  // a .proto always translates to a single class, but you may want to
-  // explicitly choose the class name).
-  optional string java_outer_classname = 8;
-
-  // If set true, then the Java code generator will generate a separate .java
-  // file for each top-level message, enum, and service defined in the .proto
-  // file.  Thus, these types will *not* be nested inside the outer class
-  // named by java_outer_classname.  However, the outer class will still be
-  // generated to contain the file's getDescriptor() method as well as any
-  // top-level extensions defined in the file.
-  optional bool java_multiple_files = 10 [default=false];
-
-  // If set true, then the Java code generator will generate equals() and
-  // hashCode() methods for all messages defined in the .proto file.
-  // This increases generated code size, potentially substantially for large
-  // protos, which may harm a memory-constrained application.
-  // - In the full runtime this is a speed optimization, as the
-  // AbstractMessage base class includes reflection-based implementations of
-  // these methods.
-  // - In the lite runtime, setting this option changes the semantics of
-  // equals() and hashCode() to more closely match those of the full runtime;
-  // the generated methods compute their results based on field values rather
-  // than object identity. (Implementations should not assume that hashcodes
-  // will be consistent across runtimes or versions of the protocol compiler.)
-  optional bool java_generate_equals_and_hash = 20 [default=false];
-
-  // If set true, then the Java2 code generator will generate code that
-  // throws an exception whenever an attempt is made to assign a non-UTF-8
-  // byte sequence to a string field.
-  // Message reflection will do the same.
-  // However, an extension field still accepts non-UTF-8 byte sequences.
-  // This option has no effect on when used with the lite runtime.
-  optional bool java_string_check_utf8 = 27 [default=false];
-
-
-  // Generated classes can be optimized for speed or code size.
-  enum OptimizeMode {
-    SPEED = 1;        // Generate complete code for parsing, serialization,
-                      // etc.
-    CODE_SIZE = 2;    // Use ReflectionOps to implement these methods.
-    LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime.
-  }
-  optional OptimizeMode optimize_for = 9 [default=SPEED];
-
-  // Sets the Go package where structs generated from this .proto will be
-  // placed. If omitted, the Go package will be derived from the following:
-  //   - The basename of the package import path, if provided.
-  //   - Otherwise, the package statement in the .proto file, if present.
-  //   - Otherwise, the basename of the .proto file, without extension.
-  optional string go_package = 11;
-
-
-
-  // Should generic services be generated in each language?  "Generic" services
-  // are not specific to any particular RPC system.  They are generated by the
-  // main code generators in each language (without additional plugins).
-  // Generic services were the only kind of service generation supported by
-  // early versions of google.protobuf.
-  //
-  // Generic services are now considered deprecated in favor of using plugins
-  // that generate code specific to your particular RPC system.  Therefore,
-  // these default to false.  Old code which depends on generic services should
-  // explicitly set them to true.
-  optional bool cc_generic_services = 16 [default=false];
-  optional bool java_generic_services = 17 [default=false];
-  optional bool py_generic_services = 18 [default=false];
-
-  // Is this file deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for everything in the file, or it will be completely ignored; in the very
-  // least, this is a formalization for deprecating files.
-  optional bool deprecated = 23 [default=false];
-
-  // Enables the use of arenas for the proto messages in this file. This applies
-  // only to generated classes for C++.
-  optional bool cc_enable_arenas = 31 [default=false];
-
-
-  // Sets the objective c class prefix which is prepended to all objective c
-  // generated classes from this .proto. There is no default.
-  optional string objc_class_prefix = 36;
-
-  // Namespace for generated classes; defaults to the package.
-  optional string csharp_namespace = 37;
-
-  // Whether the nano proto compiler should generate in the deprecated non-nano
-  // suffixed package.
-  optional bool javanano_use_deprecated_package = 38;
-
-  // Sets the php class prefix which is prepended to all php generated classes
-  // from this .proto. Default is empty.
-  optional string php_class_prefix = 40;
-
-  // Use this option to change the namespace of php generated classes. Default
-  // is empty. When this option is empty, the package name will be used for
-  // determining the namespace.
-  optional string php_namespace = 41;
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message MessageOptions {
-  // Set true to use the old proto1 MessageSet wire format for extensions.
-  // This is provided for backwards-compatibility with the MessageSet wire
-  // format.  You should not use this for any other reason:  It's less
-  // efficient, has fewer features, and is more complicated.
-  //
-  // The message must be defined exactly as follows:
-  //   message Foo {
-  //     option message_set_wire_format = true;
-  //     extensions 4 to max;
-  //   }
-  // Note that the message cannot have any defined fields; MessageSets only
-  // have extensions.
-  //
-  // All extensions of your type must be singular messages; e.g. they cannot
-  // be int32s, enums, or repeated messages.
-  //
-  // Because this is an option, the above two restrictions are not enforced by
-  // the protocol compiler.
-  optional bool message_set_wire_format = 1 [default=false];
-
-  // Disables the generation of the standard "descriptor()" accessor, which can
-  // conflict with a field of the same name.  This is meant to make migration
-  // from proto1 easier; new code should avoid fields named "descriptor".
-  optional bool no_standard_descriptor_accessor = 2 [default=false];
-
-  // Is this message deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for the message, or it will be completely ignored; in the very least,
-  // this is a formalization for deprecating messages.
-  optional bool deprecated = 3 [default=false];
-
-  // Whether the message is an automatically generated map entry type for the
-  // maps field.
-  //
-  // For maps fields:
-  //     map<KeyType, ValueType> map_field = 1;
-  // The parsed descriptor looks like:
-  //     message MapFieldEntry {
-  //         option map_entry = true;
-  //         optional KeyType key = 1;
-  //         optional ValueType value = 2;
-  //     }
-  //     repeated MapFieldEntry map_field = 1;
-  //
-  // Implementations may choose not to generate the map_entry=true message, but
-  // use a native map in the target language to hold the keys and values.
-  // The reflection APIs in such implementions still need to work as
-  // if the field is a repeated message field.
-  //
-  // NOTE: Do not set the option in .proto files. Always use the maps syntax
-  // instead. The option should only be implicitly set by the proto compiler
-  // parser.
-  optional bool map_entry = 7;
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message FieldOptions {
-  // The ctype option instructs the C++ code generator to use a different
-  // representation of the field than it normally would.  See the specific
-  // options below.  This option is not yet implemented in the open source
-  // release -- sorry, we'll try to include it in a future version!
-  optional CType ctype = 1 [default = STRING];
-  enum CType {
-    // Default mode.
-    STRING = 0;
-
-    CORD = 1;
-
-    STRING_PIECE = 2;
-  }
-  // The packed option can be enabled for repeated primitive fields to enable
-  // a more efficient representation on the wire. Rather than repeatedly
-  // writing the tag and type for each element, the entire array is encoded as
-  // a single length-delimited blob. In proto3, only explicit setting it to
-  // false will avoid using packed encoding.
-  optional bool packed = 2;
-
-
-  // The jstype option determines the JavaScript type used for values of the
-  // field.  The option is permitted only for 64 bit integral and fixed types
-  // (int64, uint64, sint64, fixed64, sfixed64).  By default these types are
-  // represented as JavaScript strings.  This avoids loss of precision that can
-  // happen when a large value is converted to a floating point JavaScript
-  // numbers.  Specifying JS_NUMBER for the jstype causes the generated
-  // JavaScript code to use the JavaScript "number" type instead of strings.
-  // This option is an enum to permit additional types to be added,
-  // e.g. goog.math.Integer.
-  optional JSType jstype = 6 [default = JS_NORMAL];
-  enum JSType {
-    // Use the default type.
-    JS_NORMAL = 0;
-
-    // Use JavaScript strings.
-    JS_STRING = 1;
-
-    // Use JavaScript numbers.
-    JS_NUMBER = 2;
-  }
-
-  // Should this field be parsed lazily?  Lazy applies only to message-type
-  // fields.  It means that when the outer message is initially parsed, the
-  // inner message's contents will not be parsed but instead stored in encoded
-  // form.  The inner message will actually be parsed when it is first accessed.
-  //
-  // This is only a hint.  Implementations are free to choose whether to use
-  // eager or lazy parsing regardless of the value of this option.  However,
-  // setting this option true suggests that the protocol author believes that
-  // using lazy parsing on this field is worth the additional bookkeeping
-  // overhead typically needed to implement it.
-  //
-  // This option does not affect the public interface of any generated code;
-  // all method signatures remain the same.  Furthermore, thread-safety of the
-  // interface is not affected by this option; const methods remain safe to
-  // call from multiple threads concurrently, while non-const methods continue
-  // to require exclusive access.
-  //
-  //
-  // Note that implementations may choose not to check required fields within
-  // a lazy sub-message.  That is, calling IsInitialized() on the outher message
-  // may return true even if the inner message has missing required fields.
-  // This is necessary because otherwise the inner message would have to be
-  // parsed in order to perform the check, defeating the purpose of lazy
-  // parsing.  An implementation which chooses not to check required fields
-  // must be consistent about it.  That is, for any particular sub-message, the
-  // implementation must either *always* check its required fields, or *never*
-  // check its required fields, regardless of whether or not the message has
-  // been parsed.
-  optional bool lazy = 5 [default=false];
-
-  // Is this field deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for accessors, or it will be completely ignored; in the very least, this
-  // is a formalization for deprecating fields.
-  optional bool deprecated = 3 [default=false];
-
-  // For Google-internal migration only. Do not use.
-  optional bool weak = 10 [default=false];
-
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message EnumOptions {
-
-  // Set this option to true to allow mapping different tag names to the same
-  // value.
-  optional bool allow_alias = 2;
-
-  // Is this enum deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for the enum, or it will be completely ignored; in the very least, this
-  // is a formalization for deprecating enums.
-  optional bool deprecated = 3 [default=false];
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message EnumValueOptions {
-  // Is this enum value deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for the enum value, or it will be completely ignored; in the very least,
-  // this is a formalization for deprecating enum values.
-  optional bool deprecated = 1 [default=false];
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message ServiceOptions {
-
-  // Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
-  //   framework.  We apologize for hoarding these numbers to ourselves, but
-  //   we were already using them long before we decided to release Protocol
-  //   Buffers.
-
-  // Is this service deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for the service, or it will be completely ignored; in the very least,
-  // this is a formalization for deprecating services.
-  optional bool deprecated = 33 [default=false];
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message MethodOptions {
-
-  // Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
-  //   framework.  We apologize for hoarding these numbers to ourselves, but
-  //   we were already using them long before we decided to release Protocol
-  //   Buffers.
-
-  // Is this method deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for the method, or it will be completely ignored; in the very least,
-  // this is a formalization for deprecating methods.
-  optional bool deprecated = 33 [default=false];
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-
-// A message representing a option the parser does not recognize. This only
-// appears in options protos created by the compiler::Parser class.
-// DescriptorPool resolves these when building Descriptor objects. Therefore,
-// options protos in descriptor objects (e.g. returned by Descriptor::options(),
-// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
-// in them.
-message UninterpretedOption {
-  // The name of the uninterpreted option.  Each string represents a segment in
-  // a dot-separated name.  is_extension is true iff a segment represents an
-  // extension (denoted with parentheses in options specs in .proto files).
-  // E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
-  // "foo.(bar.baz).qux".
-  message NamePart {
-    required string name_part = 1;
-    required bool is_extension = 2;
-  }
-  repeated NamePart name = 2;
-
-  // The value of the uninterpreted option, in whatever type the tokenizer
-  // identified it as during parsing. Exactly one of these should be set.
-  optional string identifier_value = 3;
-  optional uint64 positive_int_value = 4;
-  optional int64 negative_int_value = 5;
-  optional double double_value = 6;
-  optional bytes string_value = 7;
-  optional string aggregate_value = 8;
-}
-
-// ===================================================================
-// Optional source code info
-
-// Encapsulates information about the original source file from which a
-// FileDescriptorProto was generated.
-message SourceCodeInfo {
-  // A Location identifies a piece of source code in a .proto file which
-  // corresponds to a particular definition.  This information is intended
-  // to be useful to IDEs, code indexers, documentation generators, and similar
-  // tools.
-  //
-  // For example, say we have a file like:
-  //   message Foo {
-  //     optional string foo = 1;
-  //   }
-  // Let's look at just the field definition:
-  //   optional string foo = 1;
-  //   ^       ^^     ^^  ^  ^^^
-  //   a       bc     de  f  ghi
-  // We have the following locations:
-  //   span   path               represents
-  //   [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.
-  //   [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).
-  //   [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).
-  //   [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).
-  //   [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).
-  //
-  // Notes:
-  // - A location may refer to a repeated field itself (i.e. not to any
-  //   particular index within it).  This is used whenever a set of elements are
-  //   logically enclosed in a single code segment.  For example, an entire
-  //   extend block (possibly containing multiple extension definitions) will
-  //   have an outer location whose path refers to the "extensions" repeated
-  //   field without an index.
-  // - Multiple locations may have the same path.  This happens when a single
-  //   logical declaration is spread out across multiple places.  The most
-  //   obvious example is the "extend" block again -- there may be multiple
-  //   extend blocks in the same scope, each of which will have the same path.
-  // - A location's span is not always a subset of its parent's span.  For
-  //   example, the "extendee" of an extension declaration appears at the
-  //   beginning of the "extend" block and is shared by all extensions within
-  //   the block.
-  // - Just because a location's span is a subset of some other location's span
-  //   does not mean that it is a descendent.  For example, a "group" defines
-  //   both a type and a field in a single declaration.  Thus, the locations
-  //   corresponding to the type and field and their components will overlap.
-  // - Code which tries to interpret locations should probably be designed to
-  //   ignore those that it doesn't understand, as more types of locations could
-  //   be recorded in the future.
-  repeated Location location = 1;
-  message Location {
-    // Identifies which part of the FileDescriptorProto was defined at this
-    // location.
-    //
-    // Each element is a field number or an index.  They form a path from
-    // the root FileDescriptorProto to the place where the definition.  For
-    // example, this path:
-    //   [ 4, 3, 2, 7, 1 ]
-    // refers to:
-    //   file.message_type(3)  // 4, 3
-    //       .field(7)         // 2, 7
-    //       .name()           // 1
-    // This is because FileDescriptorProto.message_type has field number 4:
-    //   repeated DescriptorProto message_type = 4;
-    // and DescriptorProto.field has field number 2:
-    //   repeated FieldDescriptorProto field = 2;
-    // and FieldDescriptorProto.name has field number 1:
-    //   optional string name = 1;
-    //
-    // Thus, the above path gives the location of a field name.  If we removed
-    // the last element:
-    //   [ 4, 3, 2, 7 ]
-    // this path refers to the whole field declaration (from the beginning
-    // of the label to the terminating semicolon).
-    repeated int32 path = 1 [packed=true];
-
-    // Always has exactly three or four elements: start line, start column,
-    // end line (optional, otherwise assumed same as start line), end column.
-    // These are packed into a single field for efficiency.  Note that line
-    // and column numbers are zero-based -- typically you will want to add
-    // 1 to each before displaying to a user.
-    repeated int32 span = 2 [packed=true];
-
-    // If this SourceCodeInfo represents a complete declaration, these are any
-    // comments appearing before and after the declaration which appear to be
-    // attached to the declaration.
-    //
-    // A series of line comments appearing on consecutive lines, with no other
-    // tokens appearing on those lines, will be treated as a single comment.
-    //
-    // leading_detached_comments will keep paragraphs of comments that appear
-    // before (but not connected to) the current element. Each paragraph,
-    // separated by empty lines, will be one comment element in the repeated
-    // field.
-    //
-    // Only the comment content is provided; comment markers (e.g. //) are
-    // stripped out.  For block comments, leading whitespace and an asterisk
-    // will be stripped from the beginning of each line other than the first.
-    // Newlines are included in the output.
-    //
-    // Examples:
-    //
-    //   optional int32 foo = 1;  // Comment attached to foo.
-    //   // Comment attached to bar.
-    //   optional int32 bar = 2;
-    //
-    //   optional string baz = 3;
-    //   // Comment attached to baz.
-    //   // Another line attached to baz.
-    //
-    //   // Comment attached to qux.
-    //   //
-    //   // Another line attached to qux.
-    //   optional double qux = 4;
-    //
-    //   // Detached comment for corge. This is not leading or trailing comments
-    //   // to qux or corge because there are blank lines separating it from
-    //   // both.
-    //
-    //   // Detached comment for corge paragraph 2.
-    //
-    //   optional string corge = 5;
-    //   /* Block comment attached
-    //    * to corge.  Leading asterisks
-    //    * will be removed. */
-    //   /* Block comment attached to
-    //    * grault. */
-    //   optional int32 grault = 6;
-    //
-    //   // ignored detached comments.
-    optional string leading_comments = 3;
-    optional string trailing_comments = 4;
-    repeated string leading_detached_comments = 6;
-  }
-}
diff --git a/upb/descriptor/descriptor.upbdefs.c b/upb/descriptor/descriptor.upbdefs.c
deleted file mode 100644
index d91f674..0000000
--- a/upb/descriptor/descriptor.upbdefs.c
+++ /dev/null
@@ -1,925 +0,0 @@
-/* This file was generated by upbc (the upb compiler) from the input
- * file:
- *
- *     upb/descriptor/descriptor.proto
- *
- * Do not edit -- your changes will be discarded when the file is
- * regenerated. */
-
-#include "upb/def.h"
-static const upb_msgdef msgs[22];
-static const upb_fielddef fields[107];
-static const upb_enumdef enums[5];
-static const upb_tabent strentries[236];
-static const upb_tabent intentries[18];
-static const upb_tabval arrays[187];
-
-#ifdef UPB_DEBUG_REFS
-static upb_inttable reftables[268];
-#endif
-
-static const upb_msgdef msgs[22] = {
-  UPB_MSGDEF_INIT("google.protobuf.DescriptorProto", 41, 8, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[0], 11, 10), UPB_STRTABLE_INIT(10, 15, UPB_CTYPE_PTR, 4, &strentries[0]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[0], &reftables[1]),
-  UPB_MSGDEF_INIT("google.protobuf.DescriptorProto.ExtensionRange", 5, 0, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[11], 3, 2), UPB_STRTABLE_INIT(2, 3, UPB_CTYPE_PTR, 2, &strentries[16]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[2], &reftables[3]),
-  UPB_MSGDEF_INIT("google.protobuf.DescriptorProto.ReservedRange", 5, 0, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[14], 3, 2), UPB_STRTABLE_INIT(2, 3, UPB_CTYPE_PTR, 2, &strentries[20]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[4], &reftables[5]),
-  UPB_MSGDEF_INIT("google.protobuf.EnumDescriptorProto", 12, 2, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[17], 4, 3), UPB_STRTABLE_INIT(3, 3, UPB_CTYPE_PTR, 2, &strentries[24]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[6], &reftables[7]),
-  UPB_MSGDEF_INIT("google.protobuf.EnumOptions", 9, 1, UPB_INTTABLE_INIT(1, 1, UPB_CTYPE_PTR, 1, &intentries[0], &arrays[21], 4, 2), UPB_STRTABLE_INIT(3, 3, UPB_CTYPE_PTR, 2, &strentries[28]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[8], &reftables[9]),
-  UPB_MSGDEF_INIT("google.protobuf.EnumValueDescriptorProto", 9, 1, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[25], 4, 3), UPB_STRTABLE_INIT(3, 3, UPB_CTYPE_PTR, 2, &strentries[32]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[10], &reftables[11]),
-  UPB_MSGDEF_INIT("google.protobuf.EnumValueOptions", 8, 1, UPB_INTTABLE_INIT(1, 1, UPB_CTYPE_PTR, 1, &intentries[2], &arrays[29], 2, 1), UPB_STRTABLE_INIT(2, 3, UPB_CTYPE_PTR, 2, &strentries[36]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[12], &reftables[13]),
-  UPB_MSGDEF_INIT("google.protobuf.FieldDescriptorProto", 24, 1, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[31], 11, 10), UPB_STRTABLE_INIT(10, 15, UPB_CTYPE_PTR, 4, &strentries[40]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[14], &reftables[15]),
-  UPB_MSGDEF_INIT("google.protobuf.FieldOptions", 13, 1, UPB_INTTABLE_INIT(1, 1, UPB_CTYPE_PTR, 1, &intentries[4], &arrays[42], 11, 6), UPB_STRTABLE_INIT(7, 15, UPB_CTYPE_PTR, 4, &strentries[56]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[16], &reftables[17]),
-  UPB_MSGDEF_INIT("google.protobuf.FileDescriptorProto", 43, 6, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[53], 13, 12), UPB_STRTABLE_INIT(12, 15, UPB_CTYPE_PTR, 4, &strentries[72]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[18], &reftables[19]),
-  UPB_MSGDEF_INIT("google.protobuf.FileDescriptorSet", 7, 1, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[66], 2, 1), UPB_STRTABLE_INIT(1, 3, UPB_CTYPE_PTR, 2, &strentries[88]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[20], &reftables[21]),
-  UPB_MSGDEF_INIT("google.protobuf.FileOptions", 38, 1, UPB_INTTABLE_INIT(1, 1, UPB_CTYPE_PTR, 1, &intentries[6], &arrays[68], 42, 17), UPB_STRTABLE_INIT(18, 31, UPB_CTYPE_PTR, 5, &strentries[92]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[22], &reftables[23]),
-  UPB_MSGDEF_INIT("google.protobuf.MessageOptions", 11, 1, UPB_INTTABLE_INIT(1, 1, UPB_CTYPE_PTR, 1, &intentries[8], &arrays[110], 8, 4), UPB_STRTABLE_INIT(5, 7, UPB_CTYPE_PTR, 3, &strentries[124]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[24], &reftables[25]),
-  UPB_MSGDEF_INIT("google.protobuf.MethodDescriptorProto", 16, 1, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[118], 7, 6), UPB_STRTABLE_INIT(6, 7, UPB_CTYPE_PTR, 3, &strentries[132]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[26], &reftables[27]),
-  UPB_MSGDEF_INIT("google.protobuf.MethodOptions", 8, 1, UPB_INTTABLE_INIT(2, 3, UPB_CTYPE_PTR, 2, &intentries[10], &arrays[125], 1, 0), UPB_STRTABLE_INIT(2, 3, UPB_CTYPE_PTR, 2, &strentries[140]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[28], &reftables[29]),
-  UPB_MSGDEF_INIT("google.protobuf.OneofDescriptorProto", 6, 0, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[126], 2, 1), UPB_STRTABLE_INIT(1, 3, UPB_CTYPE_PTR, 2, &strentries[144]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[30], &reftables[31]),
-  UPB_MSGDEF_INIT("google.protobuf.ServiceDescriptorProto", 12, 2, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[128], 4, 3), UPB_STRTABLE_INIT(3, 3, UPB_CTYPE_PTR, 2, &strentries[148]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[32], &reftables[33]),
-  UPB_MSGDEF_INIT("google.protobuf.ServiceOptions", 8, 1, UPB_INTTABLE_INIT(2, 3, UPB_CTYPE_PTR, 2, &intentries[14], &arrays[132], 1, 0), UPB_STRTABLE_INIT(2, 3, UPB_CTYPE_PTR, 2, &strentries[152]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[34], &reftables[35]),
-  UPB_MSGDEF_INIT("google.protobuf.SourceCodeInfo", 7, 1, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[133], 2, 1), UPB_STRTABLE_INIT(1, 3, UPB_CTYPE_PTR, 2, &strentries[156]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[36], &reftables[37]),
-  UPB_MSGDEF_INIT("google.protobuf.SourceCodeInfo.Location", 20, 0, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[135], 7, 5), UPB_STRTABLE_INIT(5, 7, UPB_CTYPE_PTR, 3, &strentries[160]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[38], &reftables[39]),
-  UPB_MSGDEF_INIT("google.protobuf.UninterpretedOption", 19, 1, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[142], 9, 7), UPB_STRTABLE_INIT(7, 15, UPB_CTYPE_PTR, 4, &strentries[168]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[40], &reftables[41]),
-  UPB_MSGDEF_INIT("google.protobuf.UninterpretedOption.NamePart", 7, 0, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[151], 3, 2), UPB_STRTABLE_INIT(2, 3, UPB_CTYPE_PTR, 2, &strentries[184]), false, UPB_SYNTAX_PROTO2, UPB_WELLKNOWN_UNSPECIFIED, &reftables[42], &reftables[43]),
-};
-
-static const upb_fielddef fields[107] = {
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "aggregate_value", 8, &msgs[20], NULL, 16, 6, {0},&reftables[44], &reftables[45]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "allow_alias", 2, &msgs[4], NULL, 7, 1, {0},&reftables[46], &reftables[47]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "cc_enable_arenas", 31, &msgs[11], NULL, 24, 12, {0},&reftables[48], &reftables[49]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "cc_generic_services", 16, &msgs[11], NULL, 18, 6, {0},&reftables[50], &reftables[51]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "client_streaming", 5, &msgs[13], NULL, 14, 4, {0},&reftables[52], &reftables[53]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "csharp_namespace", 37, &msgs[11], NULL, 28, 14, {0},&reftables[54], &reftables[55]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_ENUM, 0, false, false, false, false, "ctype", 1, &msgs[8], (const upb_def*)(&enums[2]), 7, 1, {0},&reftables[56], &reftables[57]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "default_value", 7, &msgs[7], NULL, 17, 7, {0},&reftables[58], &reftables[59]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_STRING, 0, false, false, false, false, "dependency", 3, &msgs[9], NULL, 31, 8, {0},&reftables[60], &reftables[61]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "deprecated", 3, &msgs[8], NULL, 9, 3, {0},&reftables[62], &reftables[63]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "deprecated", 33, &msgs[14], NULL, 7, 1, {0},&reftables[64], &reftables[65]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "deprecated", 3, &msgs[12], NULL, 9, 3, {0},&reftables[66], &reftables[67]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "deprecated", 23, &msgs[11], NULL, 22, 10, {0},&reftables[68], &reftables[69]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "deprecated", 1, &msgs[6], NULL, 7, 1, {0},&reftables[70], &reftables[71]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "deprecated", 3, &msgs[4], NULL, 8, 2, {0},&reftables[72], &reftables[73]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "deprecated", 33, &msgs[17], NULL, 7, 1, {0},&reftables[74], &reftables[75]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_DOUBLE, 0, false, false, false, false, "double_value", 6, &msgs[20], NULL, 12, 4, {0},&reftables[76], &reftables[77]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_INT32, UPB_INTFMT_VARIABLE, false, false, false, false, "end", 2, &msgs[2], NULL, 4, 1, {0},&reftables[78], &reftables[79]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_INT32, UPB_INTFMT_VARIABLE, false, false, false, false, "end", 2, &msgs[1], NULL, 4, 1, {0},&reftables[80], &reftables[81]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "enum_type", 5, &msgs[9], (const upb_def*)(&msgs[3]), 14, 1, {0},&reftables[82], &reftables[83]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "enum_type", 4, &msgs[0], (const upb_def*)(&msgs[3]), 19, 2, {0},&reftables[84], &reftables[85]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "extendee", 2, &msgs[7], NULL, 8, 2, {0},&reftables[86], &reftables[87]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "extension", 6, &msgs[0], (const upb_def*)(&msgs[7]), 25, 4, {0},&reftables[88], &reftables[89]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "extension", 7, &msgs[9], (const upb_def*)(&msgs[7]), 20, 3, {0},&reftables[90], &reftables[91]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "extension_range", 5, &msgs[0], (const upb_def*)(&msgs[1]), 22, 3, {0},&reftables[92], &reftables[93]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "field", 2, &msgs[0], (const upb_def*)(&msgs[7]), 13, 0, {0},&reftables[94], &reftables[95]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "file", 1, &msgs[10], (const upb_def*)(&msgs[9]), 6, 0, {0},&reftables[96], &reftables[97]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "go_package", 11, &msgs[11], NULL, 15, 5, {0},&reftables[98], &reftables[99]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "identifier_value", 3, &msgs[20], NULL, 7, 1, {0},&reftables[100], &reftables[101]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "input_type", 2, &msgs[13], NULL, 8, 2, {0},&reftables[102], &reftables[103]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REQUIRED, UPB_TYPE_BOOL, 0, false, false, false, false, "is_extension", 2, &msgs[21], NULL, 6, 1, {0},&reftables[104], &reftables[105]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "java_generate_equals_and_hash", 20, &msgs[11], NULL, 21, 9, {0},&reftables[106], &reftables[107]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "java_generic_services", 17, &msgs[11], NULL, 19, 7, {0},&reftables[108], &reftables[109]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "java_multiple_files", 10, &msgs[11], NULL, 14, 4, {0},&reftables[110], &reftables[111]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "java_outer_classname", 8, &msgs[11], NULL, 10, 2, {0},&reftables[112], &reftables[113]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "java_package", 1, &msgs[11], NULL, 7, 1, {0},&reftables[114], &reftables[115]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "java_string_check_utf8", 27, &msgs[11], NULL, 23, 11, {0},&reftables[116], &reftables[117]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "javanano_use_deprecated_package", 38, &msgs[11], NULL, 31, 15, {0},&reftables[118], &reftables[119]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "json_name", 10, &msgs[7], NULL, 21, 9, {0},&reftables[120], &reftables[121]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_ENUM, 0, false, false, false, false, "jstype", 6, &msgs[8], (const upb_def*)(&enums[3]), 11, 5, {0},&reftables[122], &reftables[123]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_ENUM, 0, false, false, false, false, "label", 4, &msgs[7], (const upb_def*)(&enums[0]), 12, 4, {0},&reftables[124], &reftables[125]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "lazy", 5, &msgs[8], NULL, 10, 4, {0},&reftables[126], &reftables[127]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "leading_comments", 3, &msgs[19], NULL, 9, 2, {0},&reftables[128], &reftables[129]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_STRING, 0, false, false, false, false, "leading_detached_comments", 6, &msgs[19], NULL, 17, 4, {0},&reftables[130], &reftables[131]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "location", 1, &msgs[18], (const upb_def*)(&msgs[19]), 6, 0, {0},&reftables[132], &reftables[133]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "map_entry", 7, &msgs[12], NULL, 10, 4, {0},&reftables[134], &reftables[135]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "message_set_wire_format", 1, &msgs[12], NULL, 7, 1, {0},&reftables[136], &reftables[137]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "message_type", 4, &msgs[9], (const upb_def*)(&msgs[0]), 11, 0, {0},&reftables[138], &reftables[139]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "method", 2, &msgs[16], (const upb_def*)(&msgs[13]), 7, 0, {0},&reftables[140], &reftables[141]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "name", 2, &msgs[20], (const upb_def*)(&msgs[21]), 6, 0, {0},&reftables[142], &reftables[143]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "name", 1, &msgs[5], NULL, 5, 1, {0},&reftables[144], &reftables[145]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "name", 1, &msgs[9], NULL, 23, 6, {0},&reftables[146], &reftables[147]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "name", 1, &msgs[3], NULL, 9, 2, {0},&reftables[148], &reftables[149]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "name", 1, &msgs[16], NULL, 9, 2, {0},&reftables[150], &reftables[151]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "name", 1, &msgs[15], NULL, 3, 0, {0},&reftables[152], &reftables[153]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "name", 1, &msgs[13], NULL, 5, 1, {0},&reftables[154], &reftables[155]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "name", 1, &msgs[7], NULL, 5, 1, {0},&reftables[156], &reftables[157]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "name", 1, &msgs[0], NULL, 33, 8, {0},&reftables[158], &reftables[159]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REQUIRED, UPB_TYPE_STRING, 0, false, false, false, false, "name_part", 1, &msgs[21], NULL, 3, 0, {0},&reftables[160], &reftables[161]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_INT64, UPB_INTFMT_VARIABLE, false, false, false, false, "negative_int_value", 5, &msgs[20], NULL, 11, 3, {0},&reftables[162], &reftables[163]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "nested_type", 3, &msgs[0], (const upb_def*)(&msgs[0]), 16, 1, {0},&reftables[164], &reftables[165]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "no_standard_descriptor_accessor", 2, &msgs[12], NULL, 8, 2, {0},&reftables[166], &reftables[167]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_INT32, UPB_INTFMT_VARIABLE, false, false, false, false, "number", 3, &msgs[7], NULL, 11, 3, {0},&reftables[168], &reftables[169]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_INT32, UPB_INTFMT_VARIABLE, false, false, false, false, "number", 2, &msgs[5], NULL, 8, 2, {0},&reftables[170], &reftables[171]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "objc_class_prefix", 36, &msgs[11], NULL, 25, 13, {0},&reftables[172], &reftables[173]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "oneof_decl", 8, &msgs[0], (const upb_def*)(&msgs[15]), 29, 6, {0},&reftables[174], &reftables[175]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_INT32, UPB_INTFMT_VARIABLE, false, false, false, false, "oneof_index", 9, &msgs[7], NULL, 20, 8, {0},&reftables[176], &reftables[177]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_ENUM, 0, false, false, false, false, "optimize_for", 9, &msgs[11], (const upb_def*)(&enums[4]), 13, 3, {0},&reftables[178], &reftables[179]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_MESSAGE, 0, false, false, false, false, "options", 7, &msgs[0], (const upb_def*)(&msgs[12]), 26, 5, {0},&reftables[180], &reftables[181]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_MESSAGE, 0, false, false, false, false, "options", 8, &msgs[9], (const upb_def*)(&msgs[11]), 21, 4, {0},&reftables[182], &reftables[183]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_MESSAGE, 0, false, false, false, false, "options", 8, &msgs[7], (const upb_def*)(&msgs[8]), 4, 0, {0},&reftables[184], &reftables[185]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_MESSAGE, 0, false, false, false, false, "options", 4, &msgs[13], (const upb_def*)(&msgs[14]), 4, 0, {0},&reftables[186], &reftables[187]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_MESSAGE, 0, false, false, false, false, "options", 3, &msgs[16], (const upb_def*)(&msgs[17]), 8, 1, {0},&reftables[188], &reftables[189]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_MESSAGE, 0, false, false, false, false, "options", 3, &msgs[3], (const upb_def*)(&msgs[4]), 8, 1, {0},&reftables[190], &reftables[191]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_MESSAGE, 0, false, false, false, false, "options", 3, &msgs[5], (const upb_def*)(&msgs[6]), 4, 0, {0},&reftables[192], &reftables[193]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "output_type", 3, &msgs[13], NULL, 11, 3, {0},&reftables[194], &reftables[195]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "package", 2, &msgs[9], NULL, 26, 7, {0},&reftables[196], &reftables[197]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "packed", 2, &msgs[8], NULL, 8, 2, {0},&reftables[198], &reftables[199]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_INT32, UPB_INTFMT_VARIABLE, false, false, false, true, "path", 1, &msgs[19], NULL, 5, 0, {0},&reftables[200], &reftables[201]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "php_class_prefix", 40, &msgs[11], NULL, 32, 16, {0},&reftables[202], &reftables[203]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "php_namespace", 41, &msgs[11], NULL, 35, 17, {0},&reftables[204], &reftables[205]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_UINT64, UPB_INTFMT_VARIABLE, false, false, false, false, "positive_int_value", 4, &msgs[20], NULL, 10, 2, {0},&reftables[206], &reftables[207]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_INT32, UPB_INTFMT_VARIABLE, false, false, false, false, "public_dependency", 10, &msgs[9], NULL, 36, 9, {0},&reftables[208], &reftables[209]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "py_generic_services", 18, &msgs[11], NULL, 20, 8, {0},&reftables[210], &reftables[211]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_STRING, 0, false, false, false, false, "reserved_name", 10, &msgs[0], NULL, 38, 9, {0},&reftables[212], &reftables[213]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "reserved_range", 9, &msgs[0], (const upb_def*)(&msgs[2]), 32, 7, {0},&reftables[214], &reftables[215]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "server_streaming", 6, &msgs[13], NULL, 15, 5, {0},&reftables[216], &reftables[217]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "service", 6, &msgs[9], (const upb_def*)(&msgs[16]), 17, 2, {0},&reftables[218], &reftables[219]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_MESSAGE, 0, false, false, false, false, "source_code_info", 9, &msgs[9], (const upb_def*)(&msgs[18]), 22, 5, {0},&reftables[220], &reftables[221]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_INT32, UPB_INTFMT_VARIABLE, false, false, false, true, "span", 2, &msgs[19], NULL, 8, 1, {0},&reftables[222], &reftables[223]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_INT32, UPB_INTFMT_VARIABLE, false, false, false, false, "start", 1, &msgs[2], NULL, 3, 0, {0},&reftables[224], &reftables[225]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_INT32, UPB_INTFMT_VARIABLE, false, false, false, false, "start", 1, &msgs[1], NULL, 3, 0, {0},&reftables[226], &reftables[227]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BYTES, 0, false, false, false, false, "string_value", 7, &msgs[20], NULL, 13, 5, {0},&reftables[228], &reftables[229]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "syntax", 12, &msgs[9], NULL, 40, 11, {0},&reftables[230], &reftables[231]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "trailing_comments", 4, &msgs[19], NULL, 12, 3, {0},&reftables[232], &reftables[233]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_ENUM, 0, false, false, false, false, "type", 5, &msgs[7], (const upb_def*)(&enums[1]), 13, 5, {0},&reftables[234], &reftables[235]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "type_name", 6, &msgs[7], NULL, 14, 6, {0},&reftables[236], &reftables[237]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "uninterpreted_option", 999, &msgs[12], (const upb_def*)(&msgs[20]), 6, 0, {0},&reftables[238], &reftables[239]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "uninterpreted_option", 999, &msgs[17], (const upb_def*)(&msgs[20]), 6, 0, {0},&reftables[240], &reftables[241]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "uninterpreted_option", 999, &msgs[11], (const upb_def*)(&msgs[20]), 6, 0, {0},&reftables[242], &reftables[243]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "uninterpreted_option", 999, &msgs[14], (const upb_def*)(&msgs[20]), 6, 0, {0},&reftables[244], &reftables[245]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "uninterpreted_option", 999, &msgs[8], (const upb_def*)(&msgs[20]), 6, 0, {0},&reftables[246], &reftables[247]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "uninterpreted_option", 999, &msgs[6], (const upb_def*)(&msgs[20]), 6, 0, {0},&reftables[248], &reftables[249]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "uninterpreted_option", 999, &msgs[4], (const upb_def*)(&msgs[20]), 6, 0, {0},&reftables[250], &reftables[251]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "value", 2, &msgs[3], (const upb_def*)(&msgs[5]), 7, 0, {0},&reftables[252], &reftables[253]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "weak", 10, &msgs[8], NULL, 12, 6, {0},&reftables[254], &reftables[255]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_INT32, UPB_INTFMT_VARIABLE, false, false, false, false, "weak_dependency", 11, &msgs[9], NULL, 39, 10, {0},&reftables[256], &reftables[257]),
-};
-
-static const upb_enumdef enums[5] = {
-  UPB_ENUMDEF_INIT("google.protobuf.FieldDescriptorProto.Label", UPB_STRTABLE_INIT(3, 3, UPB_CTYPE_INT32, 2, &strentries[188]), UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_CSTR, 0, NULL, &arrays[154], 4, 3), 0, &reftables[258], &reftables[259]),
-  UPB_ENUMDEF_INIT("google.protobuf.FieldDescriptorProto.Type", UPB_STRTABLE_INIT(18, 31, UPB_CTYPE_INT32, 5, &strentries[192]), UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_CSTR, 0, NULL, &arrays[158], 19, 18), 0, &reftables[260], &reftables[261]),
-  UPB_ENUMDEF_INIT("google.protobuf.FieldOptions.CType", UPB_STRTABLE_INIT(3, 3, UPB_CTYPE_INT32, 2, &strentries[224]), UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_CSTR, 0, NULL, &arrays[177], 3, 3), 0, &reftables[262], &reftables[263]),
-  UPB_ENUMDEF_INIT("google.protobuf.FieldOptions.JSType", UPB_STRTABLE_INIT(3, 3, UPB_CTYPE_INT32, 2, &strentries[228]), UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_CSTR, 0, NULL, &arrays[180], 3, 3), 0, &reftables[264], &reftables[265]),
-  UPB_ENUMDEF_INIT("google.protobuf.FileOptions.OptimizeMode", UPB_STRTABLE_INIT(3, 3, UPB_CTYPE_INT32, 2, &strentries[232]), UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_CSTR, 0, NULL, &arrays[183], 4, 3), 0, &reftables[266], &reftables[267]),
-};
-
-static const upb_tabent strentries[236] = {
-  {UPB_TABKEY_STR("\011", "\000", "\000", "\000", "extension"), UPB_TABVALUE_PTR_INIT(&fields[22]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\015", "\000", "\000", "\000", "reserved_name"), UPB_TABVALUE_PTR_INIT(&fields[84]), NULL},
-  {UPB_TABKEY_STR("\004", "\000", "\000", "\000", "name"), UPB_TABVALUE_PTR_INIT(&fields[57]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\005", "\000", "\000", "\000", "field"), UPB_TABVALUE_PTR_INIT(&fields[25]), &strentries[12]},
-  {UPB_TABKEY_STR("\017", "\000", "\000", "\000", "extension_range"), UPB_TABVALUE_PTR_INIT(&fields[24]), &strentries[14]},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\013", "\000", "\000", "\000", "nested_type"), UPB_TABVALUE_PTR_INIT(&fields[60]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\016", "\000", "\000", "\000", "reserved_range"), UPB_TABVALUE_PTR_INIT(&fields[85]), NULL},
-  {UPB_TABKEY_STR("\007", "\000", "\000", "\000", "options"), UPB_TABVALUE_PTR_INIT(&fields[68]), NULL},
-  {UPB_TABKEY_STR("\012", "\000", "\000", "\000", "oneof_decl"), UPB_TABVALUE_PTR_INIT(&fields[65]), NULL},
-  {UPB_TABKEY_STR("\011", "\000", "\000", "\000", "enum_type"), UPB_TABVALUE_PTR_INIT(&fields[20]), &strentries[13]},
-  {UPB_TABKEY_STR("\005", "\000", "\000", "\000", "start"), UPB_TABVALUE_PTR_INIT(&fields[91]), NULL},
-  {UPB_TABKEY_STR("\003", "\000", "\000", "\000", "end"), UPB_TABVALUE_PTR_INIT(&fields[18]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\005", "\000", "\000", "\000", "start"), UPB_TABVALUE_PTR_INIT(&fields[90]), NULL},
-  {UPB_TABKEY_STR("\003", "\000", "\000", "\000", "end"), UPB_TABVALUE_PTR_INIT(&fields[17]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\005", "\000", "\000", "\000", "value"), UPB_TABVALUE_PTR_INIT(&fields[104]), NULL},
-  {UPB_TABKEY_STR("\007", "\000", "\000", "\000", "options"), UPB_TABVALUE_PTR_INIT(&fields[73]), NULL},
-  {UPB_TABKEY_STR("\004", "\000", "\000", "\000", "name"), UPB_TABVALUE_PTR_INIT(&fields[52]), &strentries[26]},
-  {UPB_TABKEY_STR("\024", "\000", "\000", "\000", "uninterpreted_option"), UPB_TABVALUE_PTR_INIT(&fields[103]), NULL},
-  {UPB_TABKEY_STR("\012", "\000", "\000", "\000", "deprecated"), UPB_TABVALUE_PTR_INIT(&fields[14]), NULL},
-  {UPB_TABKEY_STR("\013", "\000", "\000", "\000", "allow_alias"), UPB_TABVALUE_PTR_INIT(&fields[1]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\006", "\000", "\000", "\000", "number"), UPB_TABVALUE_PTR_INIT(&fields[63]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\007", "\000", "\000", "\000", "options"), UPB_TABVALUE_PTR_INIT(&fields[74]), NULL},
-  {UPB_TABKEY_STR("\004", "\000", "\000", "\000", "name"), UPB_TABVALUE_PTR_INIT(&fields[50]), &strentries[34]},
-  {UPB_TABKEY_STR("\024", "\000", "\000", "\000", "uninterpreted_option"), UPB_TABVALUE_PTR_INIT(&fields[102]), NULL},
-  {UPB_TABKEY_STR("\012", "\000", "\000", "\000", "deprecated"), UPB_TABVALUE_PTR_INIT(&fields[13]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\013", "\000", "\000", "\000", "oneof_index"), UPB_TABVALUE_PTR_INIT(&fields[66]), NULL},
-  {UPB_TABKEY_STR("\005", "\000", "\000", "\000", "label"), UPB_TABVALUE_PTR_INIT(&fields[40]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\004", "\000", "\000", "\000", "name"), UPB_TABVALUE_PTR_INIT(&fields[56]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\006", "\000", "\000", "\000", "number"), UPB_TABVALUE_PTR_INIT(&fields[62]), &strentries[53]},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\010", "\000", "\000", "\000", "extendee"), UPB_TABVALUE_PTR_INIT(&fields[21]), NULL},
-  {UPB_TABKEY_STR("\011", "\000", "\000", "\000", "type_name"), UPB_TABVALUE_PTR_INIT(&fields[96]), NULL},
-  {UPB_TABKEY_STR("\011", "\000", "\000", "\000", "json_name"), UPB_TABVALUE_PTR_INIT(&fields[38]), NULL},
-  {UPB_TABKEY_STR("\004", "\000", "\000", "\000", "type"), UPB_TABVALUE_PTR_INIT(&fields[95]), &strentries[50]},
-  {UPB_TABKEY_STR("\015", "\000", "\000", "\000", "default_value"), UPB_TABVALUE_PTR_INIT(&fields[7]), NULL},
-  {UPB_TABKEY_STR("\007", "\000", "\000", "\000", "options"), UPB_TABVALUE_PTR_INIT(&fields[70]), NULL},
-  {UPB_TABKEY_STR("\024", "\000", "\000", "\000", "uninterpreted_option"), UPB_TABVALUE_PTR_INIT(&fields[101]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\004", "\000", "\000", "\000", "weak"), UPB_TABVALUE_PTR_INIT(&fields[105]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\006", "\000", "\000", "\000", "packed"), UPB_TABVALUE_PTR_INIT(&fields[77]), NULL},
-  {UPB_TABKEY_STR("\004", "\000", "\000", "\000", "lazy"), UPB_TABVALUE_PTR_INIT(&fields[41]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\005", "\000", "\000", "\000", "ctype"), UPB_TABVALUE_PTR_INIT(&fields[6]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\006", "\000", "\000", "\000", "jstype"), UPB_TABVALUE_PTR_INIT(&fields[39]), NULL},
-  {UPB_TABKEY_STR("\012", "\000", "\000", "\000", "deprecated"), UPB_TABVALUE_PTR_INIT(&fields[9]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\011", "\000", "\000", "\000", "extension"), UPB_TABVALUE_PTR_INIT(&fields[23]), NULL},
-  {UPB_TABKEY_STR("\017", "\000", "\000", "\000", "weak_dependency"), UPB_TABVALUE_PTR_INIT(&fields[106]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\004", "\000", "\000", "\000", "name"), UPB_TABVALUE_PTR_INIT(&fields[51]), NULL},
-  {UPB_TABKEY_STR("\007", "\000", "\000", "\000", "service"), UPB_TABVALUE_PTR_INIT(&fields[87]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\020", "\000", "\000", "\000", "source_code_info"), UPB_TABVALUE_PTR_INIT(&fields[88]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\006", "\000", "\000", "\000", "syntax"), UPB_TABVALUE_PTR_INIT(&fields[93]), NULL},
-  {UPB_TABKEY_STR("\012", "\000", "\000", "\000", "dependency"), UPB_TABVALUE_PTR_INIT(&fields[8]), NULL},
-  {UPB_TABKEY_STR("\014", "\000", "\000", "\000", "message_type"), UPB_TABVALUE_PTR_INIT(&fields[47]), NULL},
-  {UPB_TABKEY_STR("\007", "\000", "\000", "\000", "package"), UPB_TABVALUE_PTR_INIT(&fields[76]), NULL},
-  {UPB_TABKEY_STR("\007", "\000", "\000", "\000", "options"), UPB_TABVALUE_PTR_INIT(&fields[69]), &strentries[86]},
-  {UPB_TABKEY_STR("\011", "\000", "\000", "\000", "enum_type"), UPB_TABVALUE_PTR_INIT(&fields[19]), NULL},
-  {UPB_TABKEY_STR("\021", "\000", "\000", "\000", "public_dependency"), UPB_TABVALUE_PTR_INIT(&fields[82]), &strentries[85]},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\004", "\000", "\000", "\000", "file"), UPB_TABVALUE_PTR_INIT(&fields[26]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\023", "\000", "\000", "\000", "cc_generic_services"), UPB_TABVALUE_PTR_INIT(&fields[3]), NULL},
-  {UPB_TABKEY_STR("\020", "\000", "\000", "\000", "csharp_namespace"), UPB_TABVALUE_PTR_INIT(&fields[5]), &strentries[116]},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\012", "\000", "\000", "\000", "go_package"), UPB_TABVALUE_PTR_INIT(&fields[27]), NULL},
-  {UPB_TABKEY_STR("\014", "\000", "\000", "\000", "java_package"), UPB_TABVALUE_PTR_INIT(&fields[35]), &strentries[120]},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\024", "\000", "\000", "\000", "java_outer_classname"), UPB_TABVALUE_PTR_INIT(&fields[34]), NULL},
-  {UPB_TABKEY_STR("\015", "\000", "\000", "\000", "php_namespace"), UPB_TABVALUE_PTR_INIT(&fields[80]), &strentries[113]},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\023", "\000", "\000", "\000", "java_multiple_files"), UPB_TABVALUE_PTR_INIT(&fields[33]), &strentries[117]},
-  {UPB_TABKEY_STR("\024", "\000", "\000", "\000", "uninterpreted_option"), UPB_TABVALUE_PTR_INIT(&fields[99]), NULL},
-  {UPB_TABKEY_STR("\025", "\000", "\000", "\000", "java_generic_services"), UPB_TABVALUE_PTR_INIT(&fields[32]), &strentries[118]},
-  {UPB_TABKEY_STR("\035", "\000", "\000", "\000", "java_generate_equals_and_hash"), UPB_TABVALUE_PTR_INIT(&fields[31]), NULL},
-  {UPB_TABKEY_STR("\020", "\000", "\000", "\000", "php_class_prefix"), UPB_TABVALUE_PTR_INIT(&fields[79]), NULL},
-  {UPB_TABKEY_STR("\037", "\000", "\000", "\000", "javanano_use_deprecated_package"), UPB_TABVALUE_PTR_INIT(&fields[37]), &strentries[123]},
-  {UPB_TABKEY_STR("\023", "\000", "\000", "\000", "py_generic_services"), UPB_TABVALUE_PTR_INIT(&fields[83]), NULL},
-  {UPB_TABKEY_STR("\014", "\000", "\000", "\000", "optimize_for"), UPB_TABVALUE_PTR_INIT(&fields[67]), NULL},
-  {UPB_TABKEY_STR("\026", "\000", "\000", "\000", "java_string_check_utf8"), UPB_TABVALUE_PTR_INIT(&fields[36]), NULL},
-  {UPB_TABKEY_STR("\012", "\000", "\000", "\000", "deprecated"), UPB_TABVALUE_PTR_INIT(&fields[12]), &strentries[119]},
-  {UPB_TABKEY_STR("\021", "\000", "\000", "\000", "objc_class_prefix"), UPB_TABVALUE_PTR_INIT(&fields[64]), NULL},
-  {UPB_TABKEY_STR("\020", "\000", "\000", "\000", "cc_enable_arenas"), UPB_TABVALUE_PTR_INIT(&fields[2]), NULL},
-  {UPB_TABKEY_STR("\027", "\000", "\000", "\000", "message_set_wire_format"), UPB_TABVALUE_PTR_INIT(&fields[46]), &strentries[128]},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\024", "\000", "\000", "\000", "uninterpreted_option"), UPB_TABVALUE_PTR_INIT(&fields[97]), NULL},
-  {UPB_TABKEY_STR("\012", "\000", "\000", "\000", "deprecated"), UPB_TABVALUE_PTR_INIT(&fields[11]), NULL},
-  {UPB_TABKEY_STR("\011", "\000", "\000", "\000", "map_entry"), UPB_TABVALUE_PTR_INIT(&fields[45]), NULL},
-  {UPB_TABKEY_STR("\037", "\000", "\000", "\000", "no_standard_descriptor_accessor"), UPB_TABVALUE_PTR_INIT(&fields[61]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\020", "\000", "\000", "\000", "client_streaming"), UPB_TABVALUE_PTR_INIT(&fields[4]), NULL},
-  {UPB_TABKEY_STR("\020", "\000", "\000", "\000", "server_streaming"), UPB_TABVALUE_PTR_INIT(&fields[86]), NULL},
-  {UPB_TABKEY_STR("\004", "\000", "\000", "\000", "name"), UPB_TABVALUE_PTR_INIT(&fields[55]), NULL},
-  {UPB_TABKEY_STR("\012", "\000", "\000", "\000", "input_type"), UPB_TABVALUE_PTR_INIT(&fields[29]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\013", "\000", "\000", "\000", "output_type"), UPB_TABVALUE_PTR_INIT(&fields[75]), NULL},
-  {UPB_TABKEY_STR("\007", "\000", "\000", "\000", "options"), UPB_TABVALUE_PTR_INIT(&fields[71]), NULL},
-  {UPB_TABKEY_STR("\024", "\000", "\000", "\000", "uninterpreted_option"), UPB_TABVALUE_PTR_INIT(&fields[100]), NULL},
-  {UPB_TABKEY_STR("\012", "\000", "\000", "\000", "deprecated"), UPB_TABVALUE_PTR_INIT(&fields[10]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\004", "\000", "\000", "\000", "name"), UPB_TABVALUE_PTR_INIT(&fields[54]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\007", "\000", "\000", "\000", "options"), UPB_TABVALUE_PTR_INIT(&fields[72]), &strentries[150]},
-  {UPB_TABKEY_STR("\006", "\000", "\000", "\000", "method"), UPB_TABVALUE_PTR_INIT(&fields[48]), NULL},
-  {UPB_TABKEY_STR("\004", "\000", "\000", "\000", "name"), UPB_TABVALUE_PTR_INIT(&fields[53]), &strentries[149]},
-  {UPB_TABKEY_STR("\024", "\000", "\000", "\000", "uninterpreted_option"), UPB_TABVALUE_PTR_INIT(&fields[98]), NULL},
-  {UPB_TABKEY_STR("\012", "\000", "\000", "\000", "deprecated"), UPB_TABVALUE_PTR_INIT(&fields[15]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\010", "\000", "\000", "\000", "location"), UPB_TABVALUE_PTR_INIT(&fields[44]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\004", "\000", "\000", "\000", "span"), UPB_TABVALUE_PTR_INIT(&fields[89]), &strentries[167]},
-  {UPB_TABKEY_STR("\031", "\000", "\000", "\000", "leading_detached_comments"), UPB_TABVALUE_PTR_INIT(&fields[43]), &strentries[165]},
-  {UPB_TABKEY_STR("\021", "\000", "\000", "\000", "trailing_comments"), UPB_TABVALUE_PTR_INIT(&fields[94]), NULL},
-  {UPB_TABKEY_STR("\020", "\000", "\000", "\000", "leading_comments"), UPB_TABVALUE_PTR_INIT(&fields[42]), &strentries[164]},
-  {UPB_TABKEY_STR("\004", "\000", "\000", "\000", "path"), UPB_TABVALUE_PTR_INIT(&fields[78]), NULL},
-  {UPB_TABKEY_STR("\014", "\000", "\000", "\000", "double_value"), UPB_TABVALUE_PTR_INIT(&fields[16]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\004", "\000", "\000", "\000", "name"), UPB_TABVALUE_PTR_INIT(&fields[49]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\022", "\000", "\000", "\000", "negative_int_value"), UPB_TABVALUE_PTR_INIT(&fields[59]), NULL},
-  {UPB_TABKEY_STR("\017", "\000", "\000", "\000", "aggregate_value"), UPB_TABVALUE_PTR_INIT(&fields[0]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\022", "\000", "\000", "\000", "positive_int_value"), UPB_TABVALUE_PTR_INIT(&fields[81]), NULL},
-  {UPB_TABKEY_STR("\020", "\000", "\000", "\000", "identifier_value"), UPB_TABVALUE_PTR_INIT(&fields[28]), NULL},
-  {UPB_TABKEY_STR("\014", "\000", "\000", "\000", "string_value"), UPB_TABVALUE_PTR_INIT(&fields[92]), &strentries[182]},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\014", "\000", "\000", "\000", "is_extension"), UPB_TABVALUE_PTR_INIT(&fields[30]), NULL},
-  {UPB_TABKEY_STR("\011", "\000", "\000", "\000", "name_part"), UPB_TABVALUE_PTR_INIT(&fields[58]), NULL},
-  {UPB_TABKEY_STR("\016", "\000", "\000", "\000", "LABEL_REQUIRED"), UPB_TABVALUE_INT_INIT(2), &strentries[190]},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\016", "\000", "\000", "\000", "LABEL_REPEATED"), UPB_TABVALUE_INT_INIT(3), NULL},
-  {UPB_TABKEY_STR("\016", "\000", "\000", "\000", "LABEL_OPTIONAL"), UPB_TABVALUE_INT_INIT(1), NULL},
-  {UPB_TABKEY_STR("\014", "\000", "\000", "\000", "TYPE_FIXED64"), UPB_TABVALUE_INT_INIT(6), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\013", "\000", "\000", "\000", "TYPE_STRING"), UPB_TABVALUE_INT_INIT(9), NULL},
-  {UPB_TABKEY_STR("\012", "\000", "\000", "\000", "TYPE_FLOAT"), UPB_TABVALUE_INT_INIT(2), &strentries[221]},
-  {UPB_TABKEY_STR("\013", "\000", "\000", "\000", "TYPE_DOUBLE"), UPB_TABVALUE_INT_INIT(1), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\012", "\000", "\000", "\000", "TYPE_INT32"), UPB_TABVALUE_INT_INIT(5), NULL},
-  {UPB_TABKEY_STR("\015", "\000", "\000", "\000", "TYPE_SFIXED32"), UPB_TABVALUE_INT_INIT(15), NULL},
-  {UPB_TABKEY_STR("\014", "\000", "\000", "\000", "TYPE_FIXED32"), UPB_TABVALUE_INT_INIT(7), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\014", "\000", "\000", "\000", "TYPE_MESSAGE"), UPB_TABVALUE_INT_INIT(11), &strentries[222]},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\012", "\000", "\000", "\000", "TYPE_INT64"), UPB_TABVALUE_INT_INIT(3), &strentries[219]},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\011", "\000", "\000", "\000", "TYPE_ENUM"), UPB_TABVALUE_INT_INIT(14), NULL},
-  {UPB_TABKEY_STR("\013", "\000", "\000", "\000", "TYPE_UINT32"), UPB_TABVALUE_INT_INIT(13), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\013", "\000", "\000", "\000", "TYPE_UINT64"), UPB_TABVALUE_INT_INIT(4), &strentries[218]},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\015", "\000", "\000", "\000", "TYPE_SFIXED64"), UPB_TABVALUE_INT_INIT(16), NULL},
-  {UPB_TABKEY_STR("\012", "\000", "\000", "\000", "TYPE_BYTES"), UPB_TABVALUE_INT_INIT(12), NULL},
-  {UPB_TABKEY_STR("\013", "\000", "\000", "\000", "TYPE_SINT64"), UPB_TABVALUE_INT_INIT(18), NULL},
-  {UPB_TABKEY_STR("\011", "\000", "\000", "\000", "TYPE_BOOL"), UPB_TABVALUE_INT_INIT(8), NULL},
-  {UPB_TABKEY_STR("\012", "\000", "\000", "\000", "TYPE_GROUP"), UPB_TABVALUE_INT_INIT(10), NULL},
-  {UPB_TABKEY_STR("\013", "\000", "\000", "\000", "TYPE_SINT32"), UPB_TABVALUE_INT_INIT(17), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\004", "\000", "\000", "\000", "CORD"), UPB_TABVALUE_INT_INIT(1), NULL},
-  {UPB_TABKEY_STR("\006", "\000", "\000", "\000", "STRING"), UPB_TABVALUE_INT_INIT(0), &strentries[225]},
-  {UPB_TABKEY_STR("\014", "\000", "\000", "\000", "STRING_PIECE"), UPB_TABVALUE_INT_INIT(2), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\011", "\000", "\000", "\000", "JS_NORMAL"), UPB_TABVALUE_INT_INIT(0), NULL},
-  {UPB_TABKEY_STR("\011", "\000", "\000", "\000", "JS_NUMBER"), UPB_TABVALUE_INT_INIT(2), NULL},
-  {UPB_TABKEY_STR("\011", "\000", "\000", "\000", "JS_STRING"), UPB_TABVALUE_INT_INIT(1), NULL},
-  {UPB_TABKEY_STR("\011", "\000", "\000", "\000", "CODE_SIZE"), UPB_TABVALUE_INT_INIT(2), NULL},
-  {UPB_TABKEY_STR("\005", "\000", "\000", "\000", "SPEED"), UPB_TABVALUE_INT_INIT(1), &strentries[235]},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\014", "\000", "\000", "\000", "LITE_RUNTIME"), UPB_TABVALUE_INT_INIT(3), NULL},
-};
-
-static const upb_tabent intentries[18] = {
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NUM(999), UPB_TABVALUE_PTR_INIT(&fields[103]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NUM(999), UPB_TABVALUE_PTR_INIT(&fields[102]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NUM(999), UPB_TABVALUE_PTR_INIT(&fields[101]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NUM(999), UPB_TABVALUE_PTR_INIT(&fields[99]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NUM(999), UPB_TABVALUE_PTR_INIT(&fields[97]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NUM(33), UPB_TABVALUE_PTR_INIT(&fields[10]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NUM(999), UPB_TABVALUE_PTR_INIT(&fields[100]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NUM(33), UPB_TABVALUE_PTR_INIT(&fields[15]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NUM(999), UPB_TABVALUE_PTR_INIT(&fields[98]), NULL},
-};
-
-static const upb_tabval arrays[187] = {
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[57]),
-  UPB_TABVALUE_PTR_INIT(&fields[25]),
-  UPB_TABVALUE_PTR_INIT(&fields[60]),
-  UPB_TABVALUE_PTR_INIT(&fields[20]),
-  UPB_TABVALUE_PTR_INIT(&fields[24]),
-  UPB_TABVALUE_PTR_INIT(&fields[22]),
-  UPB_TABVALUE_PTR_INIT(&fields[68]),
-  UPB_TABVALUE_PTR_INIT(&fields[65]),
-  UPB_TABVALUE_PTR_INIT(&fields[85]),
-  UPB_TABVALUE_PTR_INIT(&fields[84]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[91]),
-  UPB_TABVALUE_PTR_INIT(&fields[18]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[90]),
-  UPB_TABVALUE_PTR_INIT(&fields[17]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[52]),
-  UPB_TABVALUE_PTR_INIT(&fields[104]),
-  UPB_TABVALUE_PTR_INIT(&fields[73]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[1]),
-  UPB_TABVALUE_PTR_INIT(&fields[14]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[50]),
-  UPB_TABVALUE_PTR_INIT(&fields[63]),
-  UPB_TABVALUE_PTR_INIT(&fields[74]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[13]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[56]),
-  UPB_TABVALUE_PTR_INIT(&fields[21]),
-  UPB_TABVALUE_PTR_INIT(&fields[62]),
-  UPB_TABVALUE_PTR_INIT(&fields[40]),
-  UPB_TABVALUE_PTR_INIT(&fields[95]),
-  UPB_TABVALUE_PTR_INIT(&fields[96]),
-  UPB_TABVALUE_PTR_INIT(&fields[7]),
-  UPB_TABVALUE_PTR_INIT(&fields[70]),
-  UPB_TABVALUE_PTR_INIT(&fields[66]),
-  UPB_TABVALUE_PTR_INIT(&fields[38]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[6]),
-  UPB_TABVALUE_PTR_INIT(&fields[77]),
-  UPB_TABVALUE_PTR_INIT(&fields[9]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[41]),
-  UPB_TABVALUE_PTR_INIT(&fields[39]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[105]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[51]),
-  UPB_TABVALUE_PTR_INIT(&fields[76]),
-  UPB_TABVALUE_PTR_INIT(&fields[8]),
-  UPB_TABVALUE_PTR_INIT(&fields[47]),
-  UPB_TABVALUE_PTR_INIT(&fields[19]),
-  UPB_TABVALUE_PTR_INIT(&fields[87]),
-  UPB_TABVALUE_PTR_INIT(&fields[23]),
-  UPB_TABVALUE_PTR_INIT(&fields[69]),
-  UPB_TABVALUE_PTR_INIT(&fields[88]),
-  UPB_TABVALUE_PTR_INIT(&fields[82]),
-  UPB_TABVALUE_PTR_INIT(&fields[106]),
-  UPB_TABVALUE_PTR_INIT(&fields[93]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[26]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[35]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[34]),
-  UPB_TABVALUE_PTR_INIT(&fields[67]),
-  UPB_TABVALUE_PTR_INIT(&fields[33]),
-  UPB_TABVALUE_PTR_INIT(&fields[27]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[3]),
-  UPB_TABVALUE_PTR_INIT(&fields[32]),
-  UPB_TABVALUE_PTR_INIT(&fields[83]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[31]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[12]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[36]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[2]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[64]),
-  UPB_TABVALUE_PTR_INIT(&fields[5]),
-  UPB_TABVALUE_PTR_INIT(&fields[37]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[79]),
-  UPB_TABVALUE_PTR_INIT(&fields[80]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[46]),
-  UPB_TABVALUE_PTR_INIT(&fields[61]),
-  UPB_TABVALUE_PTR_INIT(&fields[11]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[45]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[55]),
-  UPB_TABVALUE_PTR_INIT(&fields[29]),
-  UPB_TABVALUE_PTR_INIT(&fields[75]),
-  UPB_TABVALUE_PTR_INIT(&fields[71]),
-  UPB_TABVALUE_PTR_INIT(&fields[4]),
-  UPB_TABVALUE_PTR_INIT(&fields[86]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[54]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[53]),
-  UPB_TABVALUE_PTR_INIT(&fields[48]),
-  UPB_TABVALUE_PTR_INIT(&fields[72]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[44]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[78]),
-  UPB_TABVALUE_PTR_INIT(&fields[89]),
-  UPB_TABVALUE_PTR_INIT(&fields[42]),
-  UPB_TABVALUE_PTR_INIT(&fields[94]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[43]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[49]),
-  UPB_TABVALUE_PTR_INIT(&fields[28]),
-  UPB_TABVALUE_PTR_INIT(&fields[81]),
-  UPB_TABVALUE_PTR_INIT(&fields[59]),
-  UPB_TABVALUE_PTR_INIT(&fields[16]),
-  UPB_TABVALUE_PTR_INIT(&fields[92]),
-  UPB_TABVALUE_PTR_INIT(&fields[0]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[58]),
-  UPB_TABVALUE_PTR_INIT(&fields[30]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT("LABEL_OPTIONAL"),
-  UPB_TABVALUE_PTR_INIT("LABEL_REQUIRED"),
-  UPB_TABVALUE_PTR_INIT("LABEL_REPEATED"),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT("TYPE_DOUBLE"),
-  UPB_TABVALUE_PTR_INIT("TYPE_FLOAT"),
-  UPB_TABVALUE_PTR_INIT("TYPE_INT64"),
-  UPB_TABVALUE_PTR_INIT("TYPE_UINT64"),
-  UPB_TABVALUE_PTR_INIT("TYPE_INT32"),
-  UPB_TABVALUE_PTR_INIT("TYPE_FIXED64"),
-  UPB_TABVALUE_PTR_INIT("TYPE_FIXED32"),
-  UPB_TABVALUE_PTR_INIT("TYPE_BOOL"),
-  UPB_TABVALUE_PTR_INIT("TYPE_STRING"),
-  UPB_TABVALUE_PTR_INIT("TYPE_GROUP"),
-  UPB_TABVALUE_PTR_INIT("TYPE_MESSAGE"),
-  UPB_TABVALUE_PTR_INIT("TYPE_BYTES"),
-  UPB_TABVALUE_PTR_INIT("TYPE_UINT32"),
-  UPB_TABVALUE_PTR_INIT("TYPE_ENUM"),
-  UPB_TABVALUE_PTR_INIT("TYPE_SFIXED32"),
-  UPB_TABVALUE_PTR_INIT("TYPE_SFIXED64"),
-  UPB_TABVALUE_PTR_INIT("TYPE_SINT32"),
-  UPB_TABVALUE_PTR_INIT("TYPE_SINT64"),
-  UPB_TABVALUE_PTR_INIT("STRING"),
-  UPB_TABVALUE_PTR_INIT("CORD"),
-  UPB_TABVALUE_PTR_INIT("STRING_PIECE"),
-  UPB_TABVALUE_PTR_INIT("JS_NORMAL"),
-  UPB_TABVALUE_PTR_INIT("JS_STRING"),
-  UPB_TABVALUE_PTR_INIT("JS_NUMBER"),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT("SPEED"),
-  UPB_TABVALUE_PTR_INIT("CODE_SIZE"),
-  UPB_TABVALUE_PTR_INIT("LITE_RUNTIME"),
-};
-
-#ifdef UPB_DEBUG_REFS
-static upb_inttable reftables[268] = {
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-};
-#endif
-
-static const upb_msgdef *refm(const upb_msgdef *m, const void *owner) {
-  upb_msgdef_ref(m, owner);
-  return m;
-}
-
-static const upb_enumdef *refe(const upb_enumdef *e, const void *owner) {
-  upb_enumdef_ref(e, owner);
-  return e;
-}
-
-/* Public API. */
-const upb_msgdef *upbdefs_google_protobuf_DescriptorProto_get(const void *owner) { return refm(&msgs[0], owner); }
-const upb_msgdef *upbdefs_google_protobuf_DescriptorProto_ExtensionRange_get(const void *owner) { return refm(&msgs[1], owner); }
-const upb_msgdef *upbdefs_google_protobuf_DescriptorProto_ReservedRange_get(const void *owner) { return refm(&msgs[2], owner); }
-const upb_msgdef *upbdefs_google_protobuf_EnumDescriptorProto_get(const void *owner) { return refm(&msgs[3], owner); }
-const upb_msgdef *upbdefs_google_protobuf_EnumOptions_get(const void *owner) { return refm(&msgs[4], owner); }
-const upb_msgdef *upbdefs_google_protobuf_EnumValueDescriptorProto_get(const void *owner) { return refm(&msgs[5], owner); }
-const upb_msgdef *upbdefs_google_protobuf_EnumValueOptions_get(const void *owner) { return refm(&msgs[6], owner); }
-const upb_msgdef *upbdefs_google_protobuf_FieldDescriptorProto_get(const void *owner) { return refm(&msgs[7], owner); }
-const upb_msgdef *upbdefs_google_protobuf_FieldOptions_get(const void *owner) { return refm(&msgs[8], owner); }
-const upb_msgdef *upbdefs_google_protobuf_FileDescriptorProto_get(const void *owner) { return refm(&msgs[9], owner); }
-const upb_msgdef *upbdefs_google_protobuf_FileDescriptorSet_get(const void *owner) { return refm(&msgs[10], owner); }
-const upb_msgdef *upbdefs_google_protobuf_FileOptions_get(const void *owner) { return refm(&msgs[11], owner); }
-const upb_msgdef *upbdefs_google_protobuf_MessageOptions_get(const void *owner) { return refm(&msgs[12], owner); }
-const upb_msgdef *upbdefs_google_protobuf_MethodDescriptorProto_get(const void *owner) { return refm(&msgs[13], owner); }
-const upb_msgdef *upbdefs_google_protobuf_MethodOptions_get(const void *owner) { return refm(&msgs[14], owner); }
-const upb_msgdef *upbdefs_google_protobuf_OneofDescriptorProto_get(const void *owner) { return refm(&msgs[15], owner); }
-const upb_msgdef *upbdefs_google_protobuf_ServiceDescriptorProto_get(const void *owner) { return refm(&msgs[16], owner); }
-const upb_msgdef *upbdefs_google_protobuf_ServiceOptions_get(const void *owner) { return refm(&msgs[17], owner); }
-const upb_msgdef *upbdefs_google_protobuf_SourceCodeInfo_get(const void *owner) { return refm(&msgs[18], owner); }
-const upb_msgdef *upbdefs_google_protobuf_SourceCodeInfo_Location_get(const void *owner) { return refm(&msgs[19], owner); }
-const upb_msgdef *upbdefs_google_protobuf_UninterpretedOption_get(const void *owner) { return refm(&msgs[20], owner); }
-const upb_msgdef *upbdefs_google_protobuf_UninterpretedOption_NamePart_get(const void *owner) { return refm(&msgs[21], owner); }
-
-const upb_enumdef *upbdefs_google_protobuf_FieldDescriptorProto_Label_get(const void *owner) { return refe(&enums[0], owner); }
-const upb_enumdef *upbdefs_google_protobuf_FieldDescriptorProto_Type_get(const void *owner) { return refe(&enums[1], owner); }
-const upb_enumdef *upbdefs_google_protobuf_FieldOptions_CType_get(const void *owner) { return refe(&enums[2], owner); }
-const upb_enumdef *upbdefs_google_protobuf_FieldOptions_JSType_get(const void *owner) { return refe(&enums[3], owner); }
-const upb_enumdef *upbdefs_google_protobuf_FileOptions_OptimizeMode_get(const void *owner) { return refe(&enums[4], owner); }
diff --git a/upb/descriptor/descriptor.upbdefs.h b/upb/descriptor/descriptor.upbdefs.h
deleted file mode 100644
index dd118a0..0000000
--- a/upb/descriptor/descriptor.upbdefs.h
+++ /dev/null
@@ -1,608 +0,0 @@
-/* This file contains accessors for a set of compiled-in defs.
- * Note that unlike Google's protobuf, it does *not* define
- * generated classes or any other kind of data structure for
- * actually storing protobufs.  It only contains *defs* which
- * let you reflect over a protobuf *schema*.
- */
-/* This file was generated by upbc (the upb compiler) from the input
- * file:
- *
- *     upb/descriptor/descriptor.proto
- *
- * Do not edit -- your changes will be discarded when the file is
- * regenerated. */
-
-#ifndef UPB_DESCRIPTOR_DESCRIPTOR_PROTO_UPB_H_
-#define UPB_DESCRIPTOR_DESCRIPTOR_PROTO_UPB_H_
-
-#include "upb/def.h"
-
-UPB_BEGIN_EXTERN_C
-
-/* MessageDefs: call these functions to get a ref to a msgdef. */
-const upb_msgdef *upbdefs_google_protobuf_DescriptorProto_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_DescriptorProto_ExtensionRange_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_DescriptorProto_ReservedRange_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_EnumDescriptorProto_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_EnumOptions_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_EnumValueDescriptorProto_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_EnumValueOptions_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_FieldDescriptorProto_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_FieldOptions_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_FileDescriptorProto_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_FileDescriptorSet_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_FileOptions_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_MessageOptions_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_MethodDescriptorProto_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_MethodOptions_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_OneofDescriptorProto_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_ServiceDescriptorProto_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_ServiceOptions_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_SourceCodeInfo_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_SourceCodeInfo_Location_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_UninterpretedOption_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_UninterpretedOption_NamePart_get(const void *owner);
-
-/* EnumDefs: call these functions to get a ref to an enumdef. */
-const upb_enumdef *upbdefs_google_protobuf_FieldDescriptorProto_Label_get(const void *owner);
-const upb_enumdef *upbdefs_google_protobuf_FieldDescriptorProto_Type_get(const void *owner);
-const upb_enumdef *upbdefs_google_protobuf_FieldOptions_CType_get(const void *owner);
-const upb_enumdef *upbdefs_google_protobuf_FieldOptions_JSType_get(const void *owner);
-const upb_enumdef *upbdefs_google_protobuf_FileOptions_OptimizeMode_get(const void *owner);
-
-/* Functions to test whether this message is of a certain type. */
-UPB_INLINE bool upbdefs_google_protobuf_DescriptorProto_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.DescriptorProto") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_DescriptorProto_ExtensionRange_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.DescriptorProto.ExtensionRange") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_DescriptorProto_ReservedRange_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.DescriptorProto.ReservedRange") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_EnumDescriptorProto_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.EnumDescriptorProto") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_EnumOptions_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.EnumOptions") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_EnumValueDescriptorProto_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.EnumValueDescriptorProto") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_EnumValueOptions_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.EnumValueOptions") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_FieldDescriptorProto_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.FieldDescriptorProto") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_FieldOptions_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.FieldOptions") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_FileDescriptorProto_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.FileDescriptorProto") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_FileDescriptorSet_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.FileDescriptorSet") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_FileOptions_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.FileOptions") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_MessageOptions_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.MessageOptions") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_MethodDescriptorProto_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.MethodDescriptorProto") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_MethodOptions_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.MethodOptions") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_OneofDescriptorProto_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.OneofDescriptorProto") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_ServiceDescriptorProto_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.ServiceDescriptorProto") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_ServiceOptions_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.ServiceOptions") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_SourceCodeInfo_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.SourceCodeInfo") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_SourceCodeInfo_Location_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.SourceCodeInfo.Location") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_UninterpretedOption_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.UninterpretedOption") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_UninterpretedOption_NamePart_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.UninterpretedOption.NamePart") == 0;
-}
-
-/* Functions to test whether this enum is of a certain type. */
-UPB_INLINE bool upbdefs_google_protobuf_FieldDescriptorProto_Label_is(const upb_enumdef *e) {
-  return strcmp(upb_enumdef_fullname(e), "google.protobuf.FieldDescriptorProto.Label") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_FieldDescriptorProto_Type_is(const upb_enumdef *e) {
-  return strcmp(upb_enumdef_fullname(e), "google.protobuf.FieldDescriptorProto.Type") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_FieldOptions_CType_is(const upb_enumdef *e) {
-  return strcmp(upb_enumdef_fullname(e), "google.protobuf.FieldOptions.CType") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_FieldOptions_JSType_is(const upb_enumdef *e) {
-  return strcmp(upb_enumdef_fullname(e), "google.protobuf.FieldOptions.JSType") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_FileOptions_OptimizeMode_is(const upb_enumdef *e) {
-  return strcmp(upb_enumdef_fullname(e), "google.protobuf.FileOptions.OptimizeMode") == 0;
-}
-
-
-/* Functions to get a fielddef from a msgdef reference. */
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_ExtensionRange_f_end(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_ExtensionRange_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_ExtensionRange_f_start(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_ExtensionRange_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_ReservedRange_f_end(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_ReservedRange_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_ReservedRange_f_start(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_ReservedRange_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_f_enum_type(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m)); return upb_msgdef_itof(m, 4); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_f_extension(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m)); return upb_msgdef_itof(m, 6); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_f_extension_range(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m)); return upb_msgdef_itof(m, 5); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_f_field(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_f_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_f_nested_type(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_f_oneof_decl(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m)); return upb_msgdef_itof(m, 8); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_f_options(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m)); return upb_msgdef_itof(m, 7); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_f_reserved_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m)); return upb_msgdef_itof(m, 10); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_f_reserved_range(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m)); return upb_msgdef_itof(m, 9); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumDescriptorProto_f_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumDescriptorProto_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumDescriptorProto_f_options(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumDescriptorProto_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumDescriptorProto_f_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumDescriptorProto_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumOptions_f_allow_alias(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumOptions_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumOptions_f_deprecated(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumOptions_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumOptions_f_uninterpreted_option(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumOptions_is(m)); return upb_msgdef_itof(m, 999); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumValueDescriptorProto_f_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumValueDescriptorProto_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumValueDescriptorProto_f_number(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumValueDescriptorProto_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumValueDescriptorProto_f_options(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumValueDescriptorProto_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumValueOptions_f_deprecated(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumValueOptions_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumValueOptions_f_uninterpreted_option(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumValueOptions_is(m)); return upb_msgdef_itof(m, 999); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_f_default_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m)); return upb_msgdef_itof(m, 7); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_f_extendee(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_f_json_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m)); return upb_msgdef_itof(m, 10); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_f_label(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m)); return upb_msgdef_itof(m, 4); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_f_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_f_number(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_f_oneof_index(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m)); return upb_msgdef_itof(m, 9); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_f_options(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m)); return upb_msgdef_itof(m, 8); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_f_type(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m)); return upb_msgdef_itof(m, 5); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_f_type_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m)); return upb_msgdef_itof(m, 6); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_f_ctype(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldOptions_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_f_deprecated(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldOptions_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_f_jstype(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldOptions_is(m)); return upb_msgdef_itof(m, 6); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_f_lazy(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldOptions_is(m)); return upb_msgdef_itof(m, 5); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_f_packed(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldOptions_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_f_uninterpreted_option(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldOptions_is(m)); return upb_msgdef_itof(m, 999); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_f_weak(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldOptions_is(m)); return upb_msgdef_itof(m, 10); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_dependency(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_enum_type(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 5); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_extension(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 7); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_message_type(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 4); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_options(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 8); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_package(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_public_dependency(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 10); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_service(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 6); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_source_code_info(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 9); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_syntax(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 12); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_weak_dependency(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 11); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorSet_f_file(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorSet_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_cc_enable_arenas(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 31); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_cc_generic_services(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 16); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_csharp_namespace(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 37); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_deprecated(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 23); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_go_package(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 11); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_java_generate_equals_and_hash(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 20); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_java_generic_services(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 17); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_java_multiple_files(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 10); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_java_outer_classname(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 8); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_java_package(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_java_string_check_utf8(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 27); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_javanano_use_deprecated_package(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 38); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_objc_class_prefix(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 36); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_optimize_for(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 9); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_php_class_prefix(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 40); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_php_namespace(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 41); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_py_generic_services(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 18); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_uninterpreted_option(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 999); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MessageOptions_f_deprecated(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MessageOptions_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MessageOptions_f_map_entry(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MessageOptions_is(m)); return upb_msgdef_itof(m, 7); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MessageOptions_f_message_set_wire_format(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MessageOptions_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MessageOptions_f_no_standard_descriptor_accessor(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MessageOptions_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MessageOptions_f_uninterpreted_option(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MessageOptions_is(m)); return upb_msgdef_itof(m, 999); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodDescriptorProto_f_client_streaming(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MethodDescriptorProto_is(m)); return upb_msgdef_itof(m, 5); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodDescriptorProto_f_input_type(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MethodDescriptorProto_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodDescriptorProto_f_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MethodDescriptorProto_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodDescriptorProto_f_options(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MethodDescriptorProto_is(m)); return upb_msgdef_itof(m, 4); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodDescriptorProto_f_output_type(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MethodDescriptorProto_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodDescriptorProto_f_server_streaming(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MethodDescriptorProto_is(m)); return upb_msgdef_itof(m, 6); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodOptions_f_deprecated(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MethodOptions_is(m)); return upb_msgdef_itof(m, 33); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodOptions_f_uninterpreted_option(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MethodOptions_is(m)); return upb_msgdef_itof(m, 999); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_OneofDescriptorProto_f_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_OneofDescriptorProto_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_ServiceDescriptorProto_f_method(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_ServiceDescriptorProto_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_ServiceDescriptorProto_f_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_ServiceDescriptorProto_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_ServiceDescriptorProto_f_options(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_ServiceDescriptorProto_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_ServiceOptions_f_deprecated(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_ServiceOptions_is(m)); return upb_msgdef_itof(m, 33); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_ServiceOptions_f_uninterpreted_option(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_ServiceOptions_is(m)); return upb_msgdef_itof(m, 999); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_SourceCodeInfo_Location_f_leading_comments(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_SourceCodeInfo_Location_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_SourceCodeInfo_Location_f_leading_detached_comments(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_SourceCodeInfo_Location_is(m)); return upb_msgdef_itof(m, 6); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_SourceCodeInfo_Location_f_path(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_SourceCodeInfo_Location_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_SourceCodeInfo_Location_f_span(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_SourceCodeInfo_Location_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_SourceCodeInfo_Location_f_trailing_comments(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_SourceCodeInfo_Location_is(m)); return upb_msgdef_itof(m, 4); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_SourceCodeInfo_f_location(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_SourceCodeInfo_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_NamePart_f_is_extension(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_NamePart_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_NamePart_f_name_part(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_NamePart_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_f_aggregate_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_is(m)); return upb_msgdef_itof(m, 8); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_f_double_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_is(m)); return upb_msgdef_itof(m, 6); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_f_identifier_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_f_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_f_negative_int_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_is(m)); return upb_msgdef_itof(m, 5); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_f_positive_int_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_is(m)); return upb_msgdef_itof(m, 4); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_f_string_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_is(m)); return upb_msgdef_itof(m, 7); }
-
-UPB_END_EXTERN_C
-
-#ifdef __cplusplus
-
-namespace upbdefs {
-namespace google {
-namespace protobuf {
-
-class DescriptorProto : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  DescriptorProto(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m));
-  }
-
-  static DescriptorProto get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_DescriptorProto_get(&m);
-    return DescriptorProto(m, &m);
-  }
-
-  class ExtensionRange : public ::upb::reffed_ptr<const ::upb::MessageDef> {
-   public:
-    ExtensionRange(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-        : reffed_ptr(m, ref_donor) {
-      UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_ExtensionRange_is(m));
-    }
-
-    static ExtensionRange get() {
-      const ::upb::MessageDef* m = upbdefs_google_protobuf_DescriptorProto_ExtensionRange_get(&m);
-      return ExtensionRange(m, &m);
-    }
-  };
-
-  class ReservedRange : public ::upb::reffed_ptr<const ::upb::MessageDef> {
-   public:
-    ReservedRange(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-        : reffed_ptr(m, ref_donor) {
-      UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_ReservedRange_is(m));
-    }
-
-    static ReservedRange get() {
-      const ::upb::MessageDef* m = upbdefs_google_protobuf_DescriptorProto_ReservedRange_get(&m);
-      return ReservedRange(m, &m);
-    }
-  };
-};
-
-class EnumDescriptorProto : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  EnumDescriptorProto(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_EnumDescriptorProto_is(m));
-  }
-
-  static EnumDescriptorProto get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_EnumDescriptorProto_get(&m);
-    return EnumDescriptorProto(m, &m);
-  }
-};
-
-class EnumOptions : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  EnumOptions(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_EnumOptions_is(m));
-  }
-
-  static EnumOptions get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_EnumOptions_get(&m);
-    return EnumOptions(m, &m);
-  }
-};
-
-class EnumValueDescriptorProto : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  EnumValueDescriptorProto(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_EnumValueDescriptorProto_is(m));
-  }
-
-  static EnumValueDescriptorProto get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_EnumValueDescriptorProto_get(&m);
-    return EnumValueDescriptorProto(m, &m);
-  }
-};
-
-class EnumValueOptions : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  EnumValueOptions(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_EnumValueOptions_is(m));
-  }
-
-  static EnumValueOptions get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_EnumValueOptions_get(&m);
-    return EnumValueOptions(m, &m);
-  }
-};
-
-class FieldDescriptorProto : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  FieldDescriptorProto(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m));
-  }
-
-  static FieldDescriptorProto get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_FieldDescriptorProto_get(&m);
-    return FieldDescriptorProto(m, &m);
-  }
-
-  class Label : public ::upb::reffed_ptr<const ::upb::EnumDef> {
-   public:
-    Label(const ::upb::EnumDef* e, const void *ref_donor = NULL)
-        : reffed_ptr(e, ref_donor) {
-      UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_Label_is(e));
-    }
-    static Label get() {
-      const ::upb::EnumDef* e = upbdefs_google_protobuf_FieldDescriptorProto_Label_get(&e);
-      return Label(e, &e);
-    }
-  };
-
-  class Type : public ::upb::reffed_ptr<const ::upb::EnumDef> {
-   public:
-    Type(const ::upb::EnumDef* e, const void *ref_donor = NULL)
-        : reffed_ptr(e, ref_donor) {
-      UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_Type_is(e));
-    }
-    static Type get() {
-      const ::upb::EnumDef* e = upbdefs_google_protobuf_FieldDescriptorProto_Type_get(&e);
-      return Type(e, &e);
-    }
-  };
-};
-
-class FieldOptions : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  FieldOptions(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_FieldOptions_is(m));
-  }
-
-  static FieldOptions get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_FieldOptions_get(&m);
-    return FieldOptions(m, &m);
-  }
-
-  class CType : public ::upb::reffed_ptr<const ::upb::EnumDef> {
-   public:
-    CType(const ::upb::EnumDef* e, const void *ref_donor = NULL)
-        : reffed_ptr(e, ref_donor) {
-      UPB_ASSERT(upbdefs_google_protobuf_FieldOptions_CType_is(e));
-    }
-    static CType get() {
-      const ::upb::EnumDef* e = upbdefs_google_protobuf_FieldOptions_CType_get(&e);
-      return CType(e, &e);
-    }
-  };
-
-  class JSType : public ::upb::reffed_ptr<const ::upb::EnumDef> {
-   public:
-    JSType(const ::upb::EnumDef* e, const void *ref_donor = NULL)
-        : reffed_ptr(e, ref_donor) {
-      UPB_ASSERT(upbdefs_google_protobuf_FieldOptions_JSType_is(e));
-    }
-    static JSType get() {
-      const ::upb::EnumDef* e = upbdefs_google_protobuf_FieldOptions_JSType_get(&e);
-      return JSType(e, &e);
-    }
-  };
-};
-
-class FileDescriptorProto : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  FileDescriptorProto(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m));
-  }
-
-  static FileDescriptorProto get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_FileDescriptorProto_get(&m);
-    return FileDescriptorProto(m, &m);
-  }
-};
-
-class FileDescriptorSet : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  FileDescriptorSet(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorSet_is(m));
-  }
-
-  static FileDescriptorSet get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_FileDescriptorSet_get(&m);
-    return FileDescriptorSet(m, &m);
-  }
-};
-
-class FileOptions : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  FileOptions(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m));
-  }
-
-  static FileOptions get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_FileOptions_get(&m);
-    return FileOptions(m, &m);
-  }
-
-  class OptimizeMode : public ::upb::reffed_ptr<const ::upb::EnumDef> {
-   public:
-    OptimizeMode(const ::upb::EnumDef* e, const void *ref_donor = NULL)
-        : reffed_ptr(e, ref_donor) {
-      UPB_ASSERT(upbdefs_google_protobuf_FileOptions_OptimizeMode_is(e));
-    }
-    static OptimizeMode get() {
-      const ::upb::EnumDef* e = upbdefs_google_protobuf_FileOptions_OptimizeMode_get(&e);
-      return OptimizeMode(e, &e);
-    }
-  };
-};
-
-class MessageOptions : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  MessageOptions(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_MessageOptions_is(m));
-  }
-
-  static MessageOptions get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_MessageOptions_get(&m);
-    return MessageOptions(m, &m);
-  }
-};
-
-class MethodDescriptorProto : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  MethodDescriptorProto(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_MethodDescriptorProto_is(m));
-  }
-
-  static MethodDescriptorProto get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_MethodDescriptorProto_get(&m);
-    return MethodDescriptorProto(m, &m);
-  }
-};
-
-class MethodOptions : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  MethodOptions(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_MethodOptions_is(m));
-  }
-
-  static MethodOptions get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_MethodOptions_get(&m);
-    return MethodOptions(m, &m);
-  }
-};
-
-class OneofDescriptorProto : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  OneofDescriptorProto(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_OneofDescriptorProto_is(m));
-  }
-
-  static OneofDescriptorProto get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_OneofDescriptorProto_get(&m);
-    return OneofDescriptorProto(m, &m);
-  }
-};
-
-class ServiceDescriptorProto : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  ServiceDescriptorProto(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_ServiceDescriptorProto_is(m));
-  }
-
-  static ServiceDescriptorProto get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_ServiceDescriptorProto_get(&m);
-    return ServiceDescriptorProto(m, &m);
-  }
-};
-
-class ServiceOptions : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  ServiceOptions(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_ServiceOptions_is(m));
-  }
-
-  static ServiceOptions get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_ServiceOptions_get(&m);
-    return ServiceOptions(m, &m);
-  }
-};
-
-class SourceCodeInfo : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  SourceCodeInfo(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_SourceCodeInfo_is(m));
-  }
-
-  static SourceCodeInfo get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_SourceCodeInfo_get(&m);
-    return SourceCodeInfo(m, &m);
-  }
-
-  class Location : public ::upb::reffed_ptr<const ::upb::MessageDef> {
-   public:
-    Location(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-        : reffed_ptr(m, ref_donor) {
-      UPB_ASSERT(upbdefs_google_protobuf_SourceCodeInfo_Location_is(m));
-    }
-
-    static Location get() {
-      const ::upb::MessageDef* m = upbdefs_google_protobuf_SourceCodeInfo_Location_get(&m);
-      return Location(m, &m);
-    }
-  };
-};
-
-class UninterpretedOption : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  UninterpretedOption(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_is(m));
-  }
-
-  static UninterpretedOption get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_UninterpretedOption_get(&m);
-    return UninterpretedOption(m, &m);
-  }
-
-  class NamePart : public ::upb::reffed_ptr<const ::upb::MessageDef> {
-   public:
-    NamePart(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-        : reffed_ptr(m, ref_donor) {
-      UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_NamePart_is(m));
-    }
-
-    static NamePart get() {
-      const ::upb::MessageDef* m = upbdefs_google_protobuf_UninterpretedOption_NamePart_get(&m);
-      return NamePart(m, &m);
-    }
-  };
-};
-
-}  /* namespace protobuf */
-}  /* namespace google */
-}  /* namespace upbdefs */
-
-#endif  /* __cplusplus */
-
-#endif  /* UPB_DESCRIPTOR_DESCRIPTOR_PROTO_UPB_H_ */
diff --git a/upb/descriptor/reader.c b/upb/descriptor/reader.c
deleted file mode 100644
index fd219fe..0000000
--- a/upb/descriptor/reader.c
+++ /dev/null
@@ -1,920 +0,0 @@
-/*
-** XXX: The routines in this file that consume a string do not currently
-** support having the string span buffers.  In the future, as upb_sink and
-** its buffering/sharing functionality evolve there should be an easy and
-** idiomatic way of correctly handling this case.  For now, we accept this
-** limitation since we currently only parse descriptors from single strings.
-*/
-
-#include "upb/descriptor/reader.h"
-
-#include <errno.h>
-#include <stdlib.h>
-#include <string.h>
-#include "upb/def.h"
-#include "upb/sink.h"
-#include "upb/descriptor/descriptor.upbdefs.h"
-
-/* Compares a NULL-terminated string with a non-NULL-terminated string. */
-static bool upb_streq(const char *str, const char *buf, size_t n) {
-  return strlen(str) == n && memcmp(str, buf, n) == 0;
-}
-
-/* We keep a stack of all the messages scopes we are currently in, as well as
- * the top-level file scope.  This is necessary to correctly qualify the
- * definitions that are contained inside.  "name" tracks the name of the
- * message or package (a bare name -- not qualified by any enclosing scopes). */
-typedef struct {
-  char *name;
-  /* Index of the first def that is under this scope.  For msgdefs, the
-   * msgdef itself is at start-1. */
-  int start;
-  uint32_t oneof_start;
-  uint32_t oneof_index;
-} upb_descreader_frame;
-
-/* The maximum number of nested declarations that are allowed, ie.
- * message Foo {
- *   message Bar {
- *     message Baz {
- *     }
- *   }
- * }
- *
- * This is a resource limit that affects how big our runtime stack can grow.
- * TODO: make this a runtime-settable property of the Reader instance. */
-#define UPB_MAX_MESSAGE_NESTING 64
-
-struct upb_descreader {
-  upb_sink sink;
-  upb_inttable files;
-  upb_strtable files_by_name;
-  upb_filedef *file;  /* The last file in files. */
-  upb_descreader_frame stack[UPB_MAX_MESSAGE_NESTING];
-  int stack_len;
-  upb_inttable oneofs;
-
-  uint32_t number;
-  char *name;
-  bool saw_number;
-  bool saw_name;
-
-  char *default_string;
-
-  upb_fielddef *f;
-};
-
-static char *upb_gstrndup(const char *buf, size_t n) {
-  char *ret = upb_gmalloc(n + 1);
-  if (!ret) return NULL;
-  memcpy(ret, buf, n);
-  ret[n] = '\0';
-  return ret;
-}
-
-/* Returns a newly allocated string that joins input strings together, for
- * example:
- *   join("Foo.Bar", "Baz") -> "Foo.Bar.Baz"
- *   join("", "Baz") -> "Baz"
- * Caller owns a ref on the returned string. */
-static char *upb_join(const char *base, const char *name) {
-  if (!base || strlen(base) == 0) {
-    return upb_gstrdup(name);
-  } else {
-    char *ret = upb_gmalloc(strlen(base) + strlen(name) + 2);
-    if (!ret) {
-      return NULL;
-    }
-    ret[0] = '\0';
-    strcat(ret, base);
-    strcat(ret, ".");
-    strcat(ret, name);
-    return ret;
-  }
-}
-
-/* Qualify the defname for all defs starting with offset "start" with "str". */
-static bool upb_descreader_qualify(upb_filedef *f, char *str, int32_t start) {
-  size_t i;
-  for (i = start; i < upb_filedef_defcount(f); i++) {
-    upb_def *def = upb_filedef_mutabledef(f, i);
-    char *name = upb_join(str, upb_def_fullname(def));
-    if (!name) {
-      /* Need better logic here; at this point we've qualified some names but
-       * not others. */
-      return false;
-    }
-    upb_def_setfullname(def, name, NULL);
-    upb_gfree(name);
-  }
-  return true;
-}
-
-
-/* upb_descreader  ************************************************************/
-
-static upb_msgdef *upb_descreader_top(upb_descreader *r) {
-  int index;
-  UPB_ASSERT(r->stack_len > 1);
-  index = r->stack[r->stack_len-1].start - 1;
-  UPB_ASSERT(index >= 0);
-  return upb_downcast_msgdef_mutable(upb_filedef_mutabledef(r->file, index));
-}
-
-static upb_def *upb_descreader_last(upb_descreader *r) {
-  return upb_filedef_mutabledef(r->file, upb_filedef_defcount(r->file) - 1);
-}
-
-/* Start/end handlers for FileDescriptorProto and DescriptorProto (the two
- * entities that have names and can contain sub-definitions. */
-void upb_descreader_startcontainer(upb_descreader *r) {
-  upb_descreader_frame *f = &r->stack[r->stack_len++];
-  f->start = upb_filedef_defcount(r->file);
-  f->oneof_start = upb_inttable_count(&r->oneofs);
-  f->oneof_index = 0;
-  f->name = NULL;
-}
-
-bool upb_descreader_endcontainer(upb_descreader *r) {
-  upb_descreader_frame *f = &r->stack[r->stack_len - 1];
-
-  while (upb_inttable_count(&r->oneofs) > f->oneof_start) {
-    upb_oneofdef *o = upb_value_getptr(upb_inttable_pop(&r->oneofs));
-    bool ok = upb_msgdef_addoneof(upb_descreader_top(r), o, &r->oneofs, NULL);
-    UPB_ASSERT(ok);
-  }
-
-  if (!upb_descreader_qualify(r->file, f->name, f->start)) {
-    return false;
-  }
-  upb_gfree(f->name);
-  f->name = NULL;
-
-  r->stack_len--;
-  return true;
-}
-
-void upb_descreader_setscopename(upb_descreader *r, char *str) {
-  upb_descreader_frame *f = &r->stack[r->stack_len-1];
-  upb_gfree(f->name);
-  f->name = str;
-}
-
-static upb_oneofdef *upb_descreader_getoneof(upb_descreader *r,
-                                             uint32_t index) {
-  bool found;
-  upb_value val;
-  upb_descreader_frame *f = &r->stack[r->stack_len-1];
-
-  /* DescriptorProto messages can be nested, so we will see the nested messages
-   * between when we see the FieldDescriptorProto and the OneofDescriptorProto.
-   * We need to preserve the oneofs in between these two things. */
-  index += f->oneof_start;
-
-  while (upb_inttable_count(&r->oneofs) <= index) {
-    upb_inttable_push(&r->oneofs, upb_value_ptr(upb_oneofdef_new(&r->oneofs)));
-  }
-
-  found = upb_inttable_lookup(&r->oneofs, index, &val);
-  UPB_ASSERT(found);
-  return upb_value_getptr(val);
-}
-
-/** Handlers for google.protobuf.FileDescriptorSet. ***************************/
-
-static void *fileset_startfile(void *closure, const void *hd) {
-  upb_descreader *r = closure;
-  UPB_UNUSED(hd);
-  r->file = upb_filedef_new(&r->files);
-  upb_inttable_push(&r->files, upb_value_ptr(r->file));
-  return r;
-}
-
-/** Handlers for google.protobuf.FileDescriptorProto. *************************/
-
-static bool file_start(void *closure, const void *hd) {
-  upb_descreader *r = closure;
-  UPB_UNUSED(hd);
-  upb_descreader_startcontainer(r);
-  return true;
-}
-
-static bool file_end(void *closure, const void *hd, upb_status *status) {
-  upb_descreader *r = closure;
-  UPB_UNUSED(hd);
-  UPB_UNUSED(status);
-  return upb_descreader_endcontainer(r);
-}
-
-static size_t file_onname(void *closure, const void *hd, const char *buf,
-                          size_t n, const upb_bufhandle *handle) {
-  upb_descreader *r = closure;
-  char *name;
-  bool ok;
-  UPB_UNUSED(hd);
-  UPB_UNUSED(handle);
-
-  name = upb_gstrndup(buf, n);
-  upb_strtable_insert(&r->files_by_name, name, upb_value_ptr(r->file));
-  /* XXX: see comment at the top of the file. */
-  ok = upb_filedef_setname(r->file, name, NULL);
-  upb_gfree(name);
-  UPB_ASSERT(ok);
-  return n;
-}
-
-static size_t file_onpackage(void *closure, const void *hd, const char *buf,
-                             size_t n, const upb_bufhandle *handle) {
-  upb_descreader *r = closure;
-  char *package;
-  bool ok;
-  UPB_UNUSED(hd);
-  UPB_UNUSED(handle);
-
-  package = upb_gstrndup(buf, n);
-  /* XXX: see comment at the top of the file. */
-  upb_descreader_setscopename(r, package);
-  ok = upb_filedef_setpackage(r->file, package, NULL);
-  UPB_ASSERT(ok);
-  return n;
-}
-
-static void *file_startphpnamespace(void *closure, const void *hd,
-                                    size_t size_hint) {
-  upb_descreader *r = closure;
-  bool ok;
-  UPB_UNUSED(hd);
-  UPB_UNUSED(size_hint);
-
-  ok = upb_filedef_setphpnamespace(r->file, "", NULL);
-  UPB_ASSERT(ok);
-  return closure;
-}
-
-static size_t file_onphpnamespace(void *closure, const void *hd,
-                                  const char *buf, size_t n,
-                                  const upb_bufhandle *handle) {
-  upb_descreader *r = closure;
-  char *php_namespace;
-  bool ok;
-  UPB_UNUSED(hd);
-  UPB_UNUSED(handle);
-
-  php_namespace = upb_gstrndup(buf, n);
-  ok = upb_filedef_setphpnamespace(r->file, php_namespace, NULL);
-  upb_gfree(php_namespace);
-  UPB_ASSERT(ok);
-  return n;
-}
-
-static size_t file_onphpprefix(void *closure, const void *hd, const char *buf,
-                             size_t n, const upb_bufhandle *handle) {
-  upb_descreader *r = closure;
-  char *prefix;
-  bool ok;
-  UPB_UNUSED(hd);
-  UPB_UNUSED(handle);
-
-  prefix = upb_gstrndup(buf, n);
-  ok = upb_filedef_setphpprefix(r->file, prefix, NULL);
-  upb_gfree(prefix);
-  UPB_ASSERT(ok);
-  return n;
-}
-
-static size_t file_onsyntax(void *closure, const void *hd, const char *buf,
-                            size_t n, const upb_bufhandle *handle) {
-  upb_descreader *r = closure;
-  bool ok;
-  UPB_UNUSED(hd);
-  UPB_UNUSED(handle);
-  /* XXX: see comment at the top of the file. */
-  if (upb_streq("proto2", buf, n)) {
-    ok = upb_filedef_setsyntax(r->file, UPB_SYNTAX_PROTO2, NULL);
-  } else if (upb_streq("proto3", buf, n)) {
-    ok = upb_filedef_setsyntax(r->file, UPB_SYNTAX_PROTO3, NULL);
-  } else {
-    ok = false;
-  }
-
-  UPB_ASSERT(ok);
-  return n;
-}
-
-static void *file_startmsg(void *closure, const void *hd) {
-  upb_descreader *r = closure;
-  upb_msgdef *m = upb_msgdef_new(&m);
-  bool ok = upb_filedef_addmsg(r->file, m, &m, NULL);
-  UPB_UNUSED(hd);
-  UPB_ASSERT(ok);
-  return r;
-}
-
-static void *file_startenum(void *closure, const void *hd) {
-  upb_descreader *r = closure;
-  upb_enumdef *e = upb_enumdef_new(&e);
-  bool ok = upb_filedef_addenum(r->file, e, &e, NULL);
-  UPB_UNUSED(hd);
-  UPB_ASSERT(ok);
-  return r;
-}
-
-static void *file_startext(void *closure, const void *hd) {
-  upb_descreader *r = closure;
-  r->f = upb_fielddef_new(r);
-  UPB_UNUSED(hd);
-  return r;
-}
-
-static bool file_endext(void *closure, const void *hd) {
-  /* The current symtab code can't handle extensions, so we just discard
-   * them for now. */
-  upb_descreader *r = closure;
-  upb_fielddef_unref(r->f, r);
-  UPB_UNUSED(hd);
-  r->f = NULL;
-  return true;
-}
-
-static size_t file_ondep(void *closure, const void *hd, const char *buf,
-                         size_t n, const upb_bufhandle *handle) {
-  upb_descreader *r = closure;
-  upb_value val;
-  if (upb_strtable_lookup2(&r->files_by_name, buf, n, &val)) {
-    upb_filedef_adddep(r->file, upb_value_getptr(val));
-  }
-  UPB_UNUSED(hd);
-  UPB_UNUSED(handle);
-  return n;
-}
-
-/** Handlers for google.protobuf.EnumValueDescriptorProto. *********************/
-
-static bool enumval_startmsg(void *closure, const void *hd) {
-  upb_descreader *r = closure;
-  UPB_UNUSED(hd);
-  r->saw_number = false;
-  r->saw_name = false;
-  return true;
-}
-
-static size_t enumval_onname(void *closure, const void *hd, const char *buf,
-                             size_t n, const upb_bufhandle *handle) {
-  upb_descreader *r = closure;
-  UPB_UNUSED(hd);
-  UPB_UNUSED(handle);
-  /* XXX: see comment at the top of the file. */
-  upb_gfree(r->name);
-  r->name = upb_gstrndup(buf, n);
-  r->saw_name = true;
-  return n;
-}
-
-static bool enumval_onnumber(void *closure, const void *hd, int32_t val) {
-  upb_descreader *r = closure;
-  UPB_UNUSED(hd);
-  r->number = val;
-  r->saw_number = true;
-  return true;
-}
-
-static bool enumval_endmsg(void *closure, const void *hd, upb_status *status) {
-  upb_descreader *r = closure;
-  upb_enumdef *e;
-  UPB_UNUSED(hd);
-
-  if(!r->saw_number || !r->saw_name) {
-    upb_status_seterrmsg(status, "Enum value missing name or number.");
-    return false;
-  }
-  e = upb_downcast_enumdef_mutable(upb_descreader_last(r));
-  upb_enumdef_addval(e, r->name, r->number, status);
-  upb_gfree(r->name);
-  r->name = NULL;
-  return true;
-}
-
-/** Handlers for google.protobuf.EnumDescriptorProto. *************************/
-
-static bool enum_endmsg(void *closure, const void *hd, upb_status *status) {
-  upb_descreader *r = closure;
-  upb_enumdef *e;
-  UPB_UNUSED(hd);
-
-  e = upb_downcast_enumdef_mutable(upb_descreader_last(r));
-  if (upb_def_fullname(upb_descreader_last(r)) == NULL) {
-    upb_status_seterrmsg(status, "Enum had no name.");
-    return false;
-  }
-  if (upb_enumdef_numvals(e) == 0) {
-    upb_status_seterrmsg(status, "Enum had no values.");
-    return false;
-  }
-  return true;
-}
-
-static size_t enum_onname(void *closure, const void *hd, const char *buf,
-                          size_t n, const upb_bufhandle *handle) {
-  upb_descreader *r = closure;
-  char *fullname = upb_gstrndup(buf, n);
-  UPB_UNUSED(hd);
-  UPB_UNUSED(handle);
-  /* XXX: see comment at the top of the file. */
-  upb_def_setfullname(upb_descreader_last(r), fullname, NULL);
-  upb_gfree(fullname);
-  return n;
-}
-
-/** Handlers for google.protobuf.FieldDescriptorProto *************************/
-
-static bool field_startmsg(void *closure, const void *hd) {
-  upb_descreader *r = closure;
-  UPB_UNUSED(hd);
-  UPB_ASSERT(r->f);
-  upb_gfree(r->default_string);
-  r->default_string = NULL;
-
-  /* fielddefs default to packed, but descriptors default to non-packed. */
-  upb_fielddef_setpacked(r->f, false);
-  return true;
-}
-
-/* Converts the default value in string "str" into "d".  Passes a ref on str.
- * Returns true on success. */
-static bool parse_default(char *str, upb_fielddef *f) {
-  bool success = true;
-  char *end;
-  switch (upb_fielddef_type(f)) {
-    case UPB_TYPE_INT32: {
-      long val = strtol(str, &end, 0);
-      if (val > INT32_MAX || val < INT32_MIN || errno == ERANGE || *end)
-        success = false;
-      else
-        upb_fielddef_setdefaultint32(f, val);
-      break;
-    }
-    case UPB_TYPE_INT64: {
-      /* XXX: Need to write our own strtoll, since it's not available in c89. */
-      long long val = strtol(str, &end, 0);
-      if (val > INT64_MAX || val < INT64_MIN || errno == ERANGE || *end)
-        success = false;
-      else
-        upb_fielddef_setdefaultint64(f, val);
-      break;
-    }
-    case UPB_TYPE_UINT32: {
-      unsigned long val = strtoul(str, &end, 0);
-      if (val > UINT32_MAX || errno == ERANGE || *end)
-        success = false;
-      else
-        upb_fielddef_setdefaultuint32(f, val);
-      break;
-    }
-    case UPB_TYPE_UINT64: {
-      /* XXX: Need to write our own strtoull, since it's not available in c89. */
-      unsigned long long val = strtoul(str, &end, 0);
-      if (val > UINT64_MAX || errno == ERANGE || *end)
-        success = false;
-      else
-        upb_fielddef_setdefaultuint64(f, val);
-      break;
-    }
-    case UPB_TYPE_DOUBLE: {
-      double val = strtod(str, &end);
-      if (errno == ERANGE || *end)
-        success = false;
-      else
-        upb_fielddef_setdefaultdouble(f, val);
-      break;
-    }
-    case UPB_TYPE_FLOAT: {
-      /* XXX: Need to write our own strtof, since it's not available in c89. */
-      float val = strtod(str, &end);
-      if (errno == ERANGE || *end)
-        success = false;
-      else
-        upb_fielddef_setdefaultfloat(f, val);
-      break;
-    }
-    case UPB_TYPE_BOOL: {
-      if (strcmp(str, "false") == 0)
-        upb_fielddef_setdefaultbool(f, false);
-      else if (strcmp(str, "true") == 0)
-        upb_fielddef_setdefaultbool(f, true);
-      else
-        success = false;
-      break;
-    }
-    default: abort();
-  }
-  return success;
-}
-
-static bool field_endmsg(void *closure, const void *hd, upb_status *status) {
-  upb_descreader *r = closure;
-  upb_fielddef *f = r->f;
-  UPB_UNUSED(hd);
-
-  /* TODO: verify that all required fields were present. */
-  UPB_ASSERT(upb_fielddef_number(f) != 0);
-  UPB_ASSERT(upb_fielddef_name(f) != NULL);
-  UPB_ASSERT((upb_fielddef_subdefname(f) != NULL) == upb_fielddef_hassubdef(f));
-
-  if (r->default_string) {
-    if (upb_fielddef_issubmsg(f)) {
-      upb_status_seterrmsg(status, "Submessages cannot have defaults.");
-      return false;
-    }
-    if (upb_fielddef_isstring(f) || upb_fielddef_type(f) == UPB_TYPE_ENUM) {
-      upb_fielddef_setdefaultcstr(f, r->default_string, NULL);
-    } else {
-      if (r->default_string && !parse_default(r->default_string, f)) {
-        /* We don't worry too much about giving a great error message since the
-         * compiler should have ensured this was correct. */
-        upb_status_seterrmsg(status, "Error converting default value.");
-        return false;
-      }
-    }
-  }
-  return true;
-}
-
-static bool field_onlazy(void *closure, const void *hd, bool val) {
-  upb_descreader *r = closure;
-  UPB_UNUSED(hd);
-
-  upb_fielddef_setlazy(r->f, val);
-  return true;
-}
-
-static bool field_onpacked(void *closure, const void *hd, bool val) {
-  upb_descreader *r = closure;
-  UPB_UNUSED(hd);
-
-  upb_fielddef_setpacked(r->f, val);
-  return true;
-}
-
-static bool field_ontype(void *closure, const void *hd, int32_t val) {
-  upb_descreader *r = closure;
-  UPB_UNUSED(hd);
-
-  upb_fielddef_setdescriptortype(r->f, val);
-  return true;
-}
-
-static bool field_onlabel(void *closure, const void *hd, int32_t val) {
-  upb_descreader *r = closure;
-  UPB_UNUSED(hd);
-
-  upb_fielddef_setlabel(r->f, val);
-  return true;
-}
-
-static bool field_onnumber(void *closure, const void *hd, int32_t val) {
-  upb_descreader *r = closure;
-  bool ok;
-  UPB_UNUSED(hd);
-
-  ok = upb_fielddef_setnumber(r->f, val, NULL);
-  UPB_ASSERT(ok);
-  return true;
-}
-
-static size_t field_onname(void *closure, const void *hd, const char *buf,
-                           size_t n, const upb_bufhandle *handle) {
-  upb_descreader *r = closure;
-  char *name = upb_gstrndup(buf, n);
-  UPB_UNUSED(hd);
-  UPB_UNUSED(handle);
-
-  /* XXX: see comment at the top of the file. */
-  upb_fielddef_setname(r->f, name, NULL);
-  upb_gfree(name);
-  return n;
-}
-
-static size_t field_ontypename(void *closure, const void *hd, const char *buf,
-                               size_t n, const upb_bufhandle *handle) {
-  upb_descreader *r = closure;
-  char *name = upb_gstrndup(buf, n);
-  UPB_UNUSED(hd);
-  UPB_UNUSED(handle);
-
-  /* XXX: see comment at the top of the file. */
-  upb_fielddef_setsubdefname(r->f, name, NULL);
-  upb_gfree(name);
-  return n;
-}
-
-static size_t field_onextendee(void *closure, const void *hd, const char *buf,
-                               size_t n, const upb_bufhandle *handle) {
-  upb_descreader *r = closure;
-  char *name = upb_gstrndup(buf, n);
-  UPB_UNUSED(hd);
-  UPB_UNUSED(handle);
-
-  /* XXX: see comment at the top of the file. */
-  upb_fielddef_setcontainingtypename(r->f, name, NULL);
-  upb_gfree(name);
-  return n;
-}
-
-static size_t field_ondefaultval(void *closure, const void *hd, const char *buf,
-                                 size_t n, const upb_bufhandle *handle) {
-  upb_descreader *r = closure;
-  UPB_UNUSED(hd);
-  UPB_UNUSED(handle);
-
-  /* Have to convert from string to the correct type, but we might not know the
-   * type yet, so we save it as a string until the end of the field.
-   * XXX: see comment at the top of the file. */
-  upb_gfree(r->default_string);
-  r->default_string = upb_gstrndup(buf, n);
-  return n;
-}
-
-static bool field_ononeofindex(void *closure, const void *hd, int32_t index) {
-  upb_descreader *r = closure;
-  upb_oneofdef *o = upb_descreader_getoneof(r, index);
-  bool ok = upb_oneofdef_addfield(o, r->f, &r->f, NULL);
-  UPB_UNUSED(hd);
-
-  UPB_ASSERT(ok);
-  return true;
-}
-
-/** Handlers for google.protobuf.OneofDescriptorProto. ************************/
-
-static size_t oneof_name(void *closure, const void *hd, const char *buf,
-                         size_t n, const upb_bufhandle *handle) {
-  upb_descreader *r = closure;
-  upb_descreader_frame *f = &r->stack[r->stack_len-1];
-  upb_oneofdef *o = upb_descreader_getoneof(r, f->oneof_index++);
-  char *name_null_terminated = upb_gstrndup(buf, n);
-  bool ok = upb_oneofdef_setname(o, name_null_terminated, NULL);
-  UPB_UNUSED(hd);
-  UPB_UNUSED(handle);
-
-  UPB_ASSERT(ok);
-  free(name_null_terminated);
-  return n;
-}
-
-/** Handlers for google.protobuf.DescriptorProto ******************************/
-
-static bool msg_start(void *closure, const void *hd) {
-  upb_descreader *r = closure;
-  UPB_UNUSED(hd);
-
-  upb_descreader_startcontainer(r);
-  return true;
-}
-
-static bool msg_end(void *closure, const void *hd, upb_status *status) {
-  upb_descreader *r = closure;
-  upb_msgdef *m = upb_descreader_top(r);
-  UPB_UNUSED(hd);
-
-  if(!upb_def_fullname(upb_msgdef_upcast_mutable(m))) {
-    upb_status_seterrmsg(status, "Encountered message with no name.");
-    return false;
-  }
-  return upb_descreader_endcontainer(r);
-}
-
-static size_t msg_name(void *closure, const void *hd, const char *buf,
-                       size_t n, const upb_bufhandle *handle) {
-  upb_descreader *r = closure;
-  upb_msgdef *m = upb_descreader_top(r);
-  /* XXX: see comment at the top of the file. */
-  char *name = upb_gstrndup(buf, n);
-  UPB_UNUSED(hd);
-  UPB_UNUSED(handle);
-
-  upb_def_setfullname(upb_msgdef_upcast_mutable(m), name, NULL);
-  upb_descreader_setscopename(r, name);  /* Passes ownership of name. */
-
-  return n;
-}
-
-static void *msg_startmsg(void *closure, const void *hd) {
-  upb_descreader *r = closure;
-  upb_msgdef *m = upb_msgdef_new(&m);
-  bool ok = upb_filedef_addmsg(r->file, m, &m, NULL);
-  UPB_UNUSED(hd);
-  UPB_ASSERT(ok);
-  return r;
-}
-
-static void *msg_startext(void *closure, const void *hd) {
-  upb_descreader *r = closure;
-  r->f = upb_fielddef_new(r);
-  UPB_UNUSED(hd);
-  return r;
-}
-
-static bool msg_endext(void *closure, const void *hd) {
-  /* The current symtab code can't handle extensions, so we just discard
-   * them for now. */
-  upb_descreader *r = closure;
-  upb_fielddef_unref(r->f, r);
-  UPB_UNUSED(hd);
-  r->f = NULL;
-  return true;
-}
-
-static void *msg_startfield(void *closure, const void *hd) {
-  upb_descreader *r = closure;
-  r->f = upb_fielddef_new(&r->f);
-  /* We can't add the new field to the message until its name/number are
-   * filled in. */
-  UPB_UNUSED(hd);
-  return r;
-}
-
-static bool msg_endfield(void *closure, const void *hd) {
-  upb_descreader *r = closure;
-  upb_msgdef *m = upb_descreader_top(r);
-  bool ok;
-  UPB_UNUSED(hd);
-
-  /* Oneof fields are added to the msgdef through their oneof, so don't need to
-   * be added here. */
-  if (upb_fielddef_containingoneof(r->f) == NULL) {
-    ok = upb_msgdef_addfield(m, r->f, &r->f, NULL);
-    UPB_ASSERT(ok);
-  }
-  r->f = NULL;
-  return true;
-}
-
-static bool msg_onmapentry(void *closure, const void *hd, bool mapentry) {
-  upb_descreader *r = closure;
-  upb_msgdef *m = upb_descreader_top(r);
-  UPB_UNUSED(hd);
-
-  upb_msgdef_setmapentry(m, mapentry);
-  r->f = NULL;
-  return true;
-}
-
-
-
-/** Code to register handlers *************************************************/
-
-#define F(msg, field) upbdefs_google_protobuf_ ## msg ## _f_ ## field(m)
-
-static void reghandlers(const void *closure, upb_handlers *h) {
-  const upb_msgdef *m = upb_handlers_msgdef(h);
-  UPB_UNUSED(closure);
-
-  if (upbdefs_google_protobuf_FileDescriptorSet_is(m)) {
-    upb_handlers_setstartsubmsg(h, F(FileDescriptorSet, file),
-                                &fileset_startfile, NULL);
-  } else if (upbdefs_google_protobuf_DescriptorProto_is(m)) {
-    upb_handlers_setstartmsg(h, &msg_start, NULL);
-    upb_handlers_setendmsg(h, &msg_end, NULL);
-    upb_handlers_setstring(h, F(DescriptorProto, name), &msg_name, NULL);
-    upb_handlers_setstartsubmsg(h, F(DescriptorProto, extension), &msg_startext,
-                                NULL);
-    upb_handlers_setendsubmsg(h, F(DescriptorProto, extension), &msg_endext,
-                              NULL);
-    upb_handlers_setstartsubmsg(h, F(DescriptorProto, nested_type),
-                                &msg_startmsg, NULL);
-    upb_handlers_setstartsubmsg(h, F(DescriptorProto, field),
-                                &msg_startfield, NULL);
-    upb_handlers_setendsubmsg(h, F(DescriptorProto, field),
-                              &msg_endfield, NULL);
-    upb_handlers_setstartsubmsg(h, F(DescriptorProto, enum_type),
-                                &file_startenum, NULL);
-  } else if (upbdefs_google_protobuf_FileDescriptorProto_is(m)) {
-    upb_handlers_setstartmsg(h, &file_start, NULL);
-    upb_handlers_setendmsg(h, &file_end, NULL);
-    upb_handlers_setstring(h, F(FileDescriptorProto, name), &file_onname,
-                           NULL);
-    upb_handlers_setstring(h, F(FileDescriptorProto, package), &file_onpackage,
-                           NULL);
-    upb_handlers_setstring(h, F(FileDescriptorProto, syntax), &file_onsyntax,
-                           NULL);
-    upb_handlers_setstartsubmsg(h, F(FileDescriptorProto, message_type),
-                                &file_startmsg, NULL);
-    upb_handlers_setstartsubmsg(h, F(FileDescriptorProto, enum_type),
-                                &file_startenum, NULL);
-    upb_handlers_setstartsubmsg(h, F(FileDescriptorProto, extension),
-                                &file_startext, NULL);
-    upb_handlers_setendsubmsg(h, F(FileDescriptorProto, extension),
-                              &file_endext, NULL);
-    upb_handlers_setstring(h, F(FileDescriptorProto, dependency),
-                           &file_ondep, NULL);
-  } else if (upbdefs_google_protobuf_EnumValueDescriptorProto_is(m)) {
-    upb_handlers_setstartmsg(h, &enumval_startmsg, NULL);
-    upb_handlers_setendmsg(h, &enumval_endmsg, NULL);
-    upb_handlers_setstring(h, F(EnumValueDescriptorProto, name), &enumval_onname, NULL);
-    upb_handlers_setint32(h, F(EnumValueDescriptorProto, number), &enumval_onnumber,
-                          NULL);
-  } else if (upbdefs_google_protobuf_EnumDescriptorProto_is(m)) {
-    upb_handlers_setendmsg(h, &enum_endmsg, NULL);
-    upb_handlers_setstring(h, F(EnumDescriptorProto, name), &enum_onname, NULL);
-  } else if (upbdefs_google_protobuf_FieldDescriptorProto_is(m)) {
-    upb_handlers_setstartmsg(h, &field_startmsg, NULL);
-    upb_handlers_setendmsg(h, &field_endmsg, NULL);
-    upb_handlers_setint32(h, F(FieldDescriptorProto, type), &field_ontype,
-                          NULL);
-    upb_handlers_setint32(h, F(FieldDescriptorProto, label), &field_onlabel,
-                          NULL);
-    upb_handlers_setint32(h, F(FieldDescriptorProto, number), &field_onnumber,
-                          NULL);
-    upb_handlers_setstring(h, F(FieldDescriptorProto, name), &field_onname,
-                           NULL);
-    upb_handlers_setstring(h, F(FieldDescriptorProto, type_name),
-                           &field_ontypename, NULL);
-    upb_handlers_setstring(h, F(FieldDescriptorProto, extendee),
-                           &field_onextendee, NULL);
-    upb_handlers_setstring(h, F(FieldDescriptorProto, default_value),
-                           &field_ondefaultval, NULL);
-    upb_handlers_setint32(h, F(FieldDescriptorProto, oneof_index),
-                          &field_ononeofindex, NULL);
-  } else if (upbdefs_google_protobuf_OneofDescriptorProto_is(m)) {
-    upb_handlers_setstring(h, F(OneofDescriptorProto, name), &oneof_name, NULL);
-  } else if (upbdefs_google_protobuf_FieldOptions_is(m)) {
-    upb_handlers_setbool(h, F(FieldOptions, lazy), &field_onlazy, NULL);
-    upb_handlers_setbool(h, F(FieldOptions, packed), &field_onpacked, NULL);
-  } else if (upbdefs_google_protobuf_MessageOptions_is(m)) {
-    upb_handlers_setbool(h, F(MessageOptions, map_entry), &msg_onmapentry, NULL);
-  } else if (upbdefs_google_protobuf_FileOptions_is(m)) {
-    upb_handlers_setstring(h, F(FileOptions, php_class_prefix),
-                           &file_onphpprefix, NULL);
-    upb_handlers_setstartstr(h, F(FileOptions, php_namespace),
-                             &file_startphpnamespace, NULL);
-    upb_handlers_setstring(h, F(FileOptions, php_namespace),
-                           &file_onphpnamespace, NULL);
-  }
-
-  UPB_ASSERT(upb_ok(upb_handlers_status(h)));
-}
-
-#undef F
-
-void descreader_cleanup(void *_r) {
-  upb_descreader *r = _r;
-  size_t i;
-
-  for (i = 0; i < upb_descreader_filecount(r); i++) {
-    upb_filedef_unref(upb_descreader_file(r, i), &r->files);
-  }
-
-  upb_gfree(r->name);
-  upb_inttable_uninit(&r->files);
-  upb_strtable_uninit(&r->files_by_name);
-  upb_inttable_uninit(&r->oneofs);
-  upb_gfree(r->default_string);
-  while (r->stack_len > 0) {
-    upb_descreader_frame *f = &r->stack[--r->stack_len];
-    upb_gfree(f->name);
-  }
-}
-
-
-/* Public API  ****************************************************************/
-
-upb_descreader *upb_descreader_create(upb_env *e, const upb_handlers *h) {
-  upb_descreader *r = upb_env_malloc(e, sizeof(upb_descreader));
-  if (!r || !upb_env_addcleanup(e, descreader_cleanup, r)) {
-    return NULL;
-  }
-
-  upb_inttable_init(&r->files, UPB_CTYPE_PTR);
-  upb_strtable_init(&r->files_by_name, UPB_CTYPE_PTR);
-  upb_inttable_init(&r->oneofs, UPB_CTYPE_PTR);
-  upb_sink_reset(upb_descreader_input(r), h, r);
-  r->stack_len = 0;
-  r->name = NULL;
-  r->default_string = NULL;
-
-  return r;
-}
-
-size_t upb_descreader_filecount(const upb_descreader *r) {
-  return upb_inttable_count(&r->files);
-}
-
-upb_filedef *upb_descreader_file(const upb_descreader *r, size_t i) {
-  upb_value v;
-  if (upb_inttable_lookup(&r->files, i, &v)) {
-    return upb_value_getptr(v);
-  } else {
-    return NULL;
-  }
-}
-
-upb_sink *upb_descreader_input(upb_descreader *r) {
-  return &r->sink;
-}
-
-const upb_handlers *upb_descreader_newhandlers(const void *owner) {
-  const upb_msgdef *m = upbdefs_google_protobuf_FileDescriptorSet_get(&m);
-  const upb_handlers *h = upb_handlers_newfrozen(m, owner, reghandlers, NULL);
-  upb_msgdef_unref(m, &m);
-  return h;
-}
diff --git a/upb/descriptor/reader.h b/upb/descriptor/reader.h
deleted file mode 100644
index e8ede0d..0000000
--- a/upb/descriptor/reader.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
-** upb::descriptor::Reader (upb_descreader)
-**
-** Provides a way of building upb::Defs from data in descriptor.proto format.
-*/
-
-#ifndef UPB_DESCRIPTOR_H
-#define UPB_DESCRIPTOR_H
-
-#include "upb/sink.h"
-
-#ifdef __cplusplus
-namespace upb {
-namespace descriptor {
-class Reader;
-}  /* namespace descriptor */
-}  /* namespace upb */
-#endif
-
-UPB_DECLARE_TYPE(upb::descriptor::Reader, upb_descreader)
-
-#ifdef __cplusplus
-
-/* Class that receives descriptor data according to the descriptor.proto schema
- * and use it to build upb::Defs corresponding to that schema. */
-class upb::descriptor::Reader {
- public:
-  /* These handlers must have come from NewHandlers() and must outlive the
-   * Reader.
-   *
-   * TODO: generate the handlers statically (like we do with the
-   * descriptor.proto defs) so that there is no need to pass this parameter (or
-   * to build/memory-manage the handlers at runtime at all).  Unfortunately this
-   * is a bit tricky to implement for Handlers, but necessary to simplify this
-   * interface. */
-  static Reader* Create(Environment* env, const Handlers* handlers);
-
-  /* The reader's input; this is where descriptor.proto data should be sent. */
-  Sink* input();
-
-  /* Use to get the FileDefs that have been parsed. */
-  size_t file_count() const;
-  FileDef* file(size_t i) const;
-
-  /* Builds and returns handlers for the reader, owned by "owner." */
-  static Handlers* NewHandlers(const void* owner);
-
- private:
-  UPB_DISALLOW_POD_OPS(Reader, upb::descriptor::Reader)
-};
-
-#endif
-
-UPB_BEGIN_EXTERN_C
-
-/* C API. */
-upb_descreader *upb_descreader_create(upb_env *e, const upb_handlers *h);
-upb_sink *upb_descreader_input(upb_descreader *r);
-size_t upb_descreader_filecount(const upb_descreader *r);
-upb_filedef *upb_descreader_file(const upb_descreader *r, size_t i);
-const upb_handlers *upb_descreader_newhandlers(const void *owner);
-
-UPB_END_EXTERN_C
-
-#ifdef __cplusplus
-/* C++ implementation details. ************************************************/
-namespace upb {
-namespace descriptor {
-inline Reader* Reader::Create(Environment* e, const Handlers *h) {
-  return upb_descreader_create(e, h);
-}
-inline Sink* Reader::input() { return upb_descreader_input(this); }
-inline size_t Reader::file_count() const {
-  return upb_descreader_filecount(this);
-}
-inline FileDef* Reader::file(size_t i) const {
-  return upb_descreader_file(this, i);
-}
-}  /* namespace descriptor */
-}  /* namespace upb */
-#endif
-
-#endif  /* UPB_DESCRIPTOR_H */
diff --git a/upb/encode.c b/upb/encode.c
index b728353..18b35d9 100644
--- a/upb/encode.c
+++ b/upb/encode.c
@@ -1,5 +1,6 @@
 /* We encode backwards, to avoid pre-computing lengths (one-pass encode). */
 
+#include <string.h>
 #include "upb/upb.h"
 #include "upb/encode.h"
 #include "upb/structs.int.h"
diff --git a/upb/encode.h b/upb/encode.h
index 1a451b0..6842777 100644
--- a/upb/encode.h
+++ b/upb/encode.h
@@ -7,11 +7,15 @@
 
 #include "upb/msg.h"
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 char *upb_encode(const void *msg, const upb_msglayout *l, upb_arena *arena,
                  size_t *size);
 
-UPB_END_EXTERN_C
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
 
 #endif  /* UPB_ENCODE_H_ */
diff --git a/upb/generated_util.h b/upb/generated_util.h
index bd47389..657280f 100644
--- a/upb/generated_util.h
+++ b/upb/generated_util.h
@@ -7,6 +7,7 @@
 #define UPB_GENERATED_UTIL_H_
 
 #include <stdint.h>
+#include "upb/msg.h"
 #include "upb/structs.int.h"
 
 #define PTR_AT(msg, ofs, type) (type*)((const char*)msg + ofs)
@@ -15,7 +16,7 @@ UPB_INLINE const void *_upb_array_accessor(const void *msg, size_t ofs,
                                            size_t *size) {
   const upb_array *arr = *PTR_AT(msg, ofs, const upb_array*);
   if (arr) {
-    if (size) *size = arr->size;
+    if (size) *size = arr->len;
     return arr->data;
   } else {
     if (size) *size = 0;
@@ -27,7 +28,7 @@ UPB_INLINE void *_upb_array_mutable_accessor(void *msg, size_t ofs,
                                              size_t *size) {
   upb_array *arr = *PTR_AT(msg, ofs, upb_array*);
   if (arr) {
-    if (size) *size = arr->size;
+    if (size) *size = arr->len;
     return arr->data;
   } else {
     if (size) *size = 0;
@@ -53,10 +54,9 @@ UPB_INLINE void *_upb_array_resize_accessor(void *msg, size_t ofs, size_t size,
     size_t new_size = UPB_MAX(arr->size, 4);
     size_t old_bytes = arr->size * elem_size;
     size_t new_bytes;
-    upb_alloc *alloc = upb_arena_alloc(arr->arena);
     while (new_size < size) new_size *= 2;
     new_bytes = new_size * elem_size;
-    arr->data = upb_realloc(alloc, arr->data, old_bytes, new_bytes);
+    arr->data = upb_arena_realloc(arena, arr->data, old_bytes, new_bytes);
     if (!arr->data) {
       return NULL;
     }
@@ -82,7 +82,7 @@ UPB_INLINE bool _upb_array_append_accessor(void *msg, size_t ofs,
 }
 
 UPB_INLINE bool _upb_has_field(const void *msg, size_t idx) {
-  return (*PTR_AT(msg, idx / 8, const char) & (idx % 8)) != 0;
+  return (*PTR_AT(msg, idx / 8, const char) & (1 << (idx % 8))) != 0;
 }
 
 UPB_INLINE bool _upb_sethas(const void *msg, size_t idx) {
diff --git a/upb/handlers-inl.h b/upb/handlers-inl.h
index 4a0494c..40a0047 100644
--- a/upb/handlers-inl.h
+++ b/upb/handlers-inl.h
@@ -7,42 +7,9 @@
 #define UPB_HANDLERS_INL_H_
 
 #include <limits.h>
-#include "upb/upb.h"
+#include <stddef.h>
 #include "upb/handlers.h"
 
-/* C inline methods. */
-
-/* upb_bufhandle */
-UPB_INLINE void upb_bufhandle_init(upb_bufhandle *h) {
-  h->obj_ = NULL;
-  h->objtype_ = NULL;
-  h->buf_ = NULL;
-  h->objofs_ = 0;
-}
-UPB_INLINE void upb_bufhandle_uninit(upb_bufhandle *h) {
-  UPB_UNUSED(h);
-}
-UPB_INLINE void upb_bufhandle_setobj(upb_bufhandle *h, const void *obj,
-                                     const void *type) {
-  h->obj_ = obj;
-  h->objtype_ = type;
-}
-UPB_INLINE void upb_bufhandle_setbuf(upb_bufhandle *h, const char *buf,
-                                     size_t ofs) {
-  h->buf_ = buf;
-  h->objofs_ = ofs;
-}
-UPB_INLINE const void *upb_bufhandle_obj(const upb_bufhandle *h) {
-  return h->obj_;
-}
-UPB_INLINE const void *upb_bufhandle_objtype(const upb_bufhandle *h) {
-  return h->objtype_;
-}
-UPB_INLINE const char *upb_bufhandle_buf(const upb_bufhandle *h) {
-  return h->buf_;
-}
-
-
 #ifdef __cplusplus
 
 /* Type detection and typedefs for integer types.
@@ -197,8 +164,8 @@ struct FuncInfo {
  * These functions are not bound to a handler data so have no data or cleanup
  * handler. */
 struct UnboundFunc {
-  CleanupFunc *GetCleanup() { return NULL; }
-  void *GetData() { return NULL; }
+  CleanupFunc *GetCleanup() { return nullptr; }
+  void *GetData() { return nullptr; }
 };
 
 template <class R, class P1, R F(P1), class I>
@@ -606,9 +573,9 @@ void *ReturnClosureOrBreak3(P1 p1, P2 p2, P3 p3) {
 
 /* For the string callback, which takes five params, returns the size param. */
 template <class P1, class P2,
-          void F(P1, P2, const char *, size_t, const BufferHandle *)>
+          void F(P1, P2, const char *, size_t, const upb_bufhandle *)>
 size_t ReturnStringLen(P1 p1, P2 p2, const char *p3, size_t p4,
-                       const BufferHandle *p5) {
+                       const upb_bufhandle *p5) {
   F(p1, p2, p3, p4, p5);
   return p4;
 }
@@ -616,9 +583,9 @@ size_t ReturnStringLen(P1 p1, P2 p2, const char *p3, size_t p4,
 /* For the string callback, which takes five params, returns the size param or
  * zero. */
 template <class P1, class P2,
-          bool F(P1, P2, const char *, size_t, const BufferHandle *)>
+          bool F(P1, P2, const char *, size_t, const upb_bufhandle *)>
 size_t ReturnNOr0(P1 p1, P2 p2, const char *p3, size_t p4,
-                  const BufferHandle *p5) {
+                  const upb_bufhandle *p5) {
   return F(p1, p2, p3, p4, p5) ? p4 : 0;
 }
 
@@ -677,22 +644,22 @@ struct MaybeWrapReturn<Func3<bool, P1, P2, P3, F, I>, void *> {
 /* If our function returns void but we want one returning size_t, wrap it in a
  * function that returns the size argument. */
 template <class P1, class P2,
-          void F(P1, P2, const char *, size_t, const BufferHandle *), class I>
+          void F(P1, P2, const char *, size_t, const upb_bufhandle *), class I>
 struct MaybeWrapReturn<
-    Func5<void, P1, P2, const char *, size_t, const BufferHandle *, F, I>,
+    Func5<void, P1, P2, const char *, size_t, const upb_bufhandle *, F, I>,
           size_t> {
-  typedef Func5<size_t, P1, P2, const char *, size_t, const BufferHandle *,
+  typedef Func5<size_t, P1, P2, const char *, size_t, const upb_bufhandle *,
                 ReturnStringLen<P1, P2, F>, I> Func;
 };
 
 /* If our function returns bool but we want one returning size_t, wrap it in a
  * function that returns either 0 or the buf size. */
 template <class P1, class P2,
-          bool F(P1, P2, const char *, size_t, const BufferHandle *), class I>
+          bool F(P1, P2, const char *, size_t, const upb_bufhandle *), class I>
 struct MaybeWrapReturn<
-    Func5<bool, P1, P2, const char *, size_t, const BufferHandle *, F, I>,
+    Func5<bool, P1, P2, const char *, size_t, const upb_bufhandle *, F, I>,
     size_t> {
-  typedef Func5<size_t, P1, P2, const char *, size_t, const BufferHandle *,
+  typedef Func5<size_t, P1, P2, const char *, size_t, const upb_bufhandle *,
                 ReturnNOr0<P1, P2, F>, I> Func;
 };
 
@@ -733,7 +700,7 @@ R IgnoreHandlerData5(void *p1, const void *hd, P2 p2, P3 p3, P4 p4) {
 
 template <class R, class P1, R F(P1, const char*, size_t)>
 R IgnoreHandlerDataIgnoreHandle(void *p1, const void *hd, const char *p2,
-                                size_t p3, const BufferHandle *handle) {
+                                size_t p3, const upb_bufhandle *handle) {
   UPB_UNUSED(hd);
   UPB_UNUSED(handle);
   return F(static_cast<P1>(p1), p2, p3);
@@ -759,7 +726,7 @@ R CastHandlerData5(void *c, const void *hd, P3 p3, P4 p4, P5 p5) {
 
 template <class R, class P1, class P2, R F(P1, P2, const char *, size_t)>
 R CastHandlerDataIgnoreHandle(void *c, const void *hd, const char *p3,
-                              size_t p4, const BufferHandle *handle) {
+                              size_t p4, const upb_bufhandle *handle) {
   UPB_UNUSED(handle);
   return F(static_cast<P1>(c), static_cast<P2>(hd), p3, p4);
 }
@@ -779,11 +746,11 @@ struct ConvertParams<Func2<R, P1, P2, F, I>,
 };
 
 /* For StringBuffer only; this ignores both the handler data and the
- * BufferHandle. */
+ * upb_bufhandle. */
 template <class R, class P1, R F(P1, const char *, size_t), class I, class T>
 struct ConvertParams<Func3<R, P1, const char *, size_t, F, I>, T> {
   typedef Func5<R, void *, const void *, const char *, size_t,
-                const BufferHandle *, IgnoreHandlerDataIgnoreHandle<R, P1, F>,
+                const upb_bufhandle *, IgnoreHandlerDataIgnoreHandle<R, P1, F>,
                 I> Func;
 };
 
@@ -809,13 +776,14 @@ struct ConvertParams<BoundFunc3<R, P1, P2, P3, F, I>,
                 CastHandlerData3<R, P1, P2, P3_2, P3, F>, I> Func;
 };
 
-/* For StringBuffer only; this ignores the BufferHandle. */
+/* For StringBuffer only; this ignores the upb_bufhandle. */
 template <class R, class P1, class P2, R F(P1, P2, const char *, size_t),
           class I, class T>
 struct ConvertParams<BoundFunc4<R, P1, P2, const char *, size_t, F, I>, T> {
   typedef Func5<R, void *, const void *, const char *, size_t,
-                const BufferHandle *, CastHandlerDataIgnoreHandle<R, P1, P2, F>,
-                I> Func;
+                const upb_bufhandle *,
+                CastHandlerDataIgnoreHandle<R, P1, P2, F>, I>
+      Func;
 };
 
 template <class R, class P1, class P2, class P3, class P4, class P5,
@@ -827,19 +795,18 @@ struct ConvertParams<BoundFunc5<R, P1, P2, P3, P4, P5, F, I>, T> {
 
 /* utype/ltype are upper/lower-case, ctype is canonical C type, vtype is
  * variant C type. */
-#define TYPE_METHODS(utype, ltype, ctype, vtype)                               \
-  template <> struct CanonicalType<vtype> {                                    \
-    typedef ctype Type;                                                        \
-  };                                                                           \
-  template <>                                                                  \
-  inline bool Handlers::SetValueHandler<vtype>(                                \
-      const FieldDef *f,                                                       \
-      const Handlers::utype ## Handler& handler) {                             \
-    UPB_ASSERT(!handler.registered_);                                              \
-    handler.AddCleanup(this);                                                  \
-    handler.registered_ = true;                                                \
-    return upb_handlers_set##ltype(this, f, handler.handler_, &handler.attr_); \
-  }                                                                            \
+#define TYPE_METHODS(utype, ltype, ctype, vtype)                      \
+  template <>                                                         \
+  struct CanonicalType<vtype> {                                       \
+    typedef ctype Type;                                               \
+  };                                                                  \
+  template <>                                                         \
+  inline bool HandlersPtr::SetValueHandler<vtype>(                    \
+      FieldDefPtr f, const HandlersPtr::utype##Handler &handler) {    \
+    handler.AddCleanup(ptr());                                        \
+    return upb_handlers_set##ltype(ptr(), f.ptr(), handler.handler(), \
+                                   &handler.attr());                  \
+  }
 
 TYPE_METHODS(Double, double, double,   double)
 TYPE_METHODS(Float,  float,  float,    float)
@@ -864,24 +831,6 @@ template <> struct CanonicalType<Status*> {
   typedef Status* Type;
 };
 
-/* Type methods that are only one-per-canonical-type and not
- * one-per-cvariant. */
-
-#define TYPE_METHODS(utype, ctype) \
-    inline bool Handlers::Set##utype##Handler(const FieldDef *f, \
-                                              const utype##Handler &h) { \
-      return SetValueHandler<ctype>(f, h); \
-    } \
-
-TYPE_METHODS(Double, double)
-TYPE_METHODS(Float,  float)
-TYPE_METHODS(UInt64, uint64_t)
-TYPE_METHODS(UInt32, uint32_t)
-TYPE_METHODS(Int64,  int64_t)
-TYPE_METHODS(Int32,  int32_t)
-TYPE_METHODS(Bool,   bool)
-#undef TYPE_METHODS
-
 template <class F> struct ReturnOf;
 
 template <class R, class P1, class P2>
@@ -904,10 +853,6 @@ struct ReturnOf<R (*)(P1, P2, P3, P4, P5)> {
   typedef R Return;
 };
 
-template<class T> const void *UniquePtrForType() {
-  static const char ch = 0;
-  return &ch;
-}
 
 template <class T>
 template <class F>
@@ -915,7 +860,7 @@ inline Handler<T>::Handler(F func)
     : registered_(false),
       cleanup_data_(func.GetData()),
       cleanup_func_(func.GetCleanup()) {
-  upb_handlerattr_sethandlerdata(&attr_, func.GetData());
+  attr_.handler_data = func.GetData();
   typedef typename ReturnOf<T>::Return Return;
   typedef typename ConvertParams<F, T>::Func ConvertedParamsFunc;
   typedef typename MaybeWrapReturn<ConvertedParamsFunc, Return>::Func
@@ -928,10 +873,10 @@ inline Handler<T>::Handler(F func)
   /* If the original function returns void, then we know that we wrapped it to
    * always return ok. */
   bool always_ok = is_same<typename F::FuncInfo::Return, void>::value;
-  attr_.SetAlwaysOk(always_ok);
+  attr_.alwaysok = always_ok;
 
   /* Closure parameter and return type. */
-  attr_.SetClosureType(UniquePtrForType<typename F::FuncInfo::Closure>());
+  attr_.closure_type = UniquePtrForType<typename F::FuncInfo::Closure>();
 
   /* We use the closure type (from the first parameter) if the return type is
    * void or bool, since these are the two cases we wrap to return the closure's
@@ -942,188 +887,19 @@ inline Handler<T>::Handler(F func)
   typedef typename FirstUnlessVoidOrBool<typename F::FuncInfo::Return,
                                          typename F::FuncInfo::Closure>::value
       EffectiveReturn;
-  attr_.SetReturnClosureType(UniquePtrForType<EffectiveReturn>());
+  attr_.return_closure_type = UniquePtrForType<EffectiveReturn>();
 }
 
 template <class T>
-inline Handler<T>::~Handler() {
-  UPB_ASSERT(registered_);
-}
-
-inline HandlerAttributes::HandlerAttributes() { upb_handlerattr_init(this); }
-inline HandlerAttributes::~HandlerAttributes() { upb_handlerattr_uninit(this); }
-inline bool HandlerAttributes::SetHandlerData(const void *hd) {
-  return upb_handlerattr_sethandlerdata(this, hd);
-}
-inline const void* HandlerAttributes::handler_data() const {
-  return upb_handlerattr_handlerdata(this);
-}
-inline bool HandlerAttributes::SetClosureType(const void *type) {
-  return upb_handlerattr_setclosuretype(this, type);
-}
-inline const void* HandlerAttributes::closure_type() const {
-  return upb_handlerattr_closuretype(this);
-}
-inline bool HandlerAttributes::SetReturnClosureType(const void *type) {
-  return upb_handlerattr_setreturnclosuretype(this, type);
-}
-inline const void* HandlerAttributes::return_closure_type() const {
-  return upb_handlerattr_returnclosuretype(this);
-}
-inline bool HandlerAttributes::SetAlwaysOk(bool always_ok) {
-  return upb_handlerattr_setalwaysok(this, always_ok);
-}
-inline bool HandlerAttributes::always_ok() const {
-  return upb_handlerattr_alwaysok(this);
-}
-
-inline BufferHandle::BufferHandle() { upb_bufhandle_init(this); }
-inline BufferHandle::~BufferHandle() { upb_bufhandle_uninit(this); }
-inline const char* BufferHandle::buffer() const {
-  return upb_bufhandle_buf(this);
-}
-inline size_t BufferHandle::object_offset() const {
-  return upb_bufhandle_objofs(this);
-}
-inline void BufferHandle::SetBuffer(const char* buf, size_t ofs) {
-  upb_bufhandle_setbuf(this, buf, ofs);
-}
-template <class T>
-void BufferHandle::SetAttachedObject(const T* obj) {
-  upb_bufhandle_setobj(this, obj, UniquePtrForType<T>());
-}
-template <class T>
-const T* BufferHandle::GetAttachedObject() const {
-  return upb_bufhandle_objtype(this) == UniquePtrForType<T>()
-      ? static_cast<const T *>(upb_bufhandle_obj(this))
-                               : NULL;
-}
-
-inline reffed_ptr<Handlers> Handlers::New(const MessageDef *m) {
-  upb_handlers *h = upb_handlers_new(m, &h);
-  return reffed_ptr<Handlers>(h, &h);
-}
-inline reffed_ptr<const Handlers> Handlers::NewFrozen(
-    const MessageDef *m, upb_handlers_callback *callback,
-    const void *closure) {
-  const upb_handlers *h = upb_handlers_newfrozen(m, &h, callback, closure);
-  return reffed_ptr<const Handlers>(h, &h);
-}
-inline const Status* Handlers::status() {
-  return upb_handlers_status(this);
-}
-inline void Handlers::ClearError() {
-  return upb_handlers_clearerr(this);
-}
-inline bool Handlers::Freeze(Status *s) {
-  upb::Handlers* h = this;
-  return upb_handlers_freeze(&h, 1, s);
-}
-inline bool Handlers::Freeze(Handlers *const *handlers, int n, Status *s) {
-  return upb_handlers_freeze(handlers, n, s);
-}
-inline bool Handlers::Freeze(const std::vector<Handlers*>& h, Status* status) {
-  return upb_handlers_freeze((Handlers* const*)&h[0], h.size(), status);
-}
-inline const MessageDef *Handlers::message_def() const {
-  return upb_handlers_msgdef(this);
-}
-inline bool Handlers::AddCleanup(void *p, upb_handlerfree *func) {
-  return upb_handlers_addcleanup(this, p, func);
-}
-inline bool Handlers::SetStartMessageHandler(
-    const Handlers::StartMessageHandler &handler) {
-  UPB_ASSERT(!handler.registered_);
-  handler.registered_ = true;
-  handler.AddCleanup(this);
-  return upb_handlers_setstartmsg(this, handler.handler_, &handler.attr_);
-}
-inline bool Handlers::SetEndMessageHandler(
-    const Handlers::EndMessageHandler &handler) {
-  UPB_ASSERT(!handler.registered_);
-  handler.registered_ = true;
-  handler.AddCleanup(this);
-  return upb_handlers_setendmsg(this, handler.handler_, &handler.attr_);
-}
-inline bool Handlers::SetStartStringHandler(const FieldDef *f,
-                                            const StartStringHandler &handler) {
-  UPB_ASSERT(!handler.registered_);
-  handler.registered_ = true;
-  handler.AddCleanup(this);
-  return upb_handlers_setstartstr(this, f, handler.handler_, &handler.attr_);
-}
-inline bool Handlers::SetEndStringHandler(const FieldDef *f,
-                                          const EndFieldHandler &handler) {
-  UPB_ASSERT(!handler.registered_);
-  handler.registered_ = true;
-  handler.AddCleanup(this);
-  return upb_handlers_setendstr(this, f, handler.handler_, &handler.attr_);
-}
-inline bool Handlers::SetStringHandler(const FieldDef *f,
-                                       const StringHandler& handler) {
-  UPB_ASSERT(!handler.registered_);
-  handler.registered_ = true;
-  handler.AddCleanup(this);
-  return upb_handlers_setstring(this, f, handler.handler_, &handler.attr_);
-}
-inline bool Handlers::SetStartSequenceHandler(
-    const FieldDef *f, const StartFieldHandler &handler) {
-  UPB_ASSERT(!handler.registered_);
-  handler.registered_ = true;
-  handler.AddCleanup(this);
-  return upb_handlers_setstartseq(this, f, handler.handler_, &handler.attr_);
-}
-inline bool Handlers::SetStartSubMessageHandler(
-    const FieldDef *f, const StartFieldHandler &handler) {
-  UPB_ASSERT(!handler.registered_);
-  handler.registered_ = true;
-  handler.AddCleanup(this);
-  return upb_handlers_setstartsubmsg(this, f, handler.handler_, &handler.attr_);
-}
-inline bool Handlers::SetEndSubMessageHandler(const FieldDef *f,
-                                              const EndFieldHandler &handler) {
-  UPB_ASSERT(!handler.registered_);
-  handler.registered_ = true;
-  handler.AddCleanup(this);
-  return upb_handlers_setendsubmsg(this, f, handler.handler_, &handler.attr_);
-}
-inline bool Handlers::SetEndSequenceHandler(const FieldDef *f,
-                                            const EndFieldHandler &handler) {
-  UPB_ASSERT(!handler.registered_);
-  handler.registered_ = true;
-  handler.AddCleanup(this);
-  return upb_handlers_setendseq(this, f, handler.handler_, &handler.attr_);
-}
-inline bool Handlers::SetSubHandlers(const FieldDef *f, const Handlers *sub) {
-  return upb_handlers_setsubhandlers(this, f, sub);
-}
-inline const Handlers *Handlers::GetSubHandlers(const FieldDef *f) const {
-  return upb_handlers_getsubhandlers(this, f);
-}
-inline const Handlers *Handlers::GetSubHandlers(Handlers::Selector sel) const {
-  return upb_handlers_getsubhandlers_sel(this, sel);
-}
-inline bool Handlers::GetSelector(const FieldDef *f, Handlers::Type type,
-                                  Handlers::Selector *s) {
-  return upb_handlers_getselector(f, type, s);
-}
-inline Handlers::Selector Handlers::GetEndSelector(Handlers::Selector start) {
-  return upb_handlers_getendselector(start);
-}
-inline Handlers::GenericFunction *Handlers::GetHandler(
-    Handlers::Selector selector) {
-  return upb_handlers_gethandler(this, selector);
-}
-inline const void *Handlers::GetHandlerData(Handlers::Selector selector) {
-  return upb_handlers_gethandlerdata(this, selector);
-}
-
-inline BytesHandler::BytesHandler() {
-  upb_byteshandler_init(this);
+inline void Handler<T>::AddCleanup(upb_handlers* h) const {
+  UPB_ASSERT(!registered_);
+  registered_ = true;
+  if (cleanup_func_) {
+    bool ok = upb_handlers_addcleanup(h, cleanup_data_, cleanup_func_);
+    UPB_ASSERT(ok);
+  }
 }
 
-inline BytesHandler::~BytesHandler() {}
-
 }  /* namespace upb */
 
 #endif  /* __cplusplus */
diff --git a/upb/handlers.c b/upb/handlers.c
index 33c43c3..7abf948 100644
--- a/upb/handlers.c
+++ b/upb/handlers.c
@@ -9,8 +9,17 @@
 
 #include "upb/sink.h"
 
-static void *upb_calloc(size_t size) {
-  void *mem = upb_gmalloc(size);
+
+struct upb_handlers {
+  upb_handlercache *cache;
+  const upb_msgdef *msg;
+  const upb_handlers **sub;
+  const void *top_closure_type;
+  upb_handlers_tabent table[1];  /* Dynamically-sized field handler array. */
+};
+
+static void *upb_calloc(upb_arena *arena, size_t size) {
+  void *mem = upb_malloc(upb_arena_alloc(arena), size);
   if (mem) {
     memset(mem, 0, size);
   }
@@ -21,111 +30,23 @@ static void *upb_calloc(size_t size) {
  * UPB_NO_CLOSURE. */
 char _upb_noclosure;
 
-static void freehandlers(upb_refcounted *r) {
-  upb_handlers *h = (upb_handlers*)r;
-
-  upb_inttable_iter i;
-  upb_inttable_begin(&i, &h->cleanup_);
-  for(; !upb_inttable_done(&i); upb_inttable_next(&i)) {
-    void *val = (void*)upb_inttable_iter_key(&i);
-    upb_value func_val = upb_inttable_iter_value(&i);
-    upb_handlerfree *func = upb_value_getfptr(func_val);
-    func(val);
-  }
-
-  upb_inttable_uninit(&h->cleanup_);
-  upb_msgdef_unref(h->msg, h);
-  upb_gfree(h->sub);
-  upb_gfree(h);
-}
-
-static void visithandlers(const upb_refcounted *r, upb_refcounted_visit *visit,
-                          void *closure) {
-  const upb_handlers *h = (const upb_handlers*)r;
-  upb_msg_field_iter i;
-  for(upb_msg_field_begin(&i, h->msg);
-      !upb_msg_field_done(&i);
-      upb_msg_field_next(&i)) {
-    upb_fielddef *f = upb_msg_iter_field(&i);
-    const upb_handlers *sub;
-    if (!upb_fielddef_issubmsg(f)) continue;
-    sub = upb_handlers_getsubhandlers(h, f);
-    if (sub) visit(r, upb_handlers_upcast(sub), closure);
-  }
-}
-
-static const struct upb_refcounted_vtbl vtbl = {visithandlers, freehandlers};
-
-typedef struct {
-  upb_inttable tab;  /* maps upb_msgdef* -> upb_handlers*. */
-  upb_handlers_callback *callback;
-  const void *closure;
-} dfs_state;
-
-/* TODO(haberman): discard upb_handlers* objects that do not actually have any
- * handlers set and cannot reach any upb_handlers* object that does.  This is
- * slightly tricky to do correctly. */
-static upb_handlers *newformsg(const upb_msgdef *m, const void *owner,
-                               dfs_state *s) {
-  upb_msg_field_iter i;
-  upb_handlers *h = upb_handlers_new(m, owner);
-  if (!h) return NULL;
-  if (!upb_inttable_insertptr(&s->tab, m, upb_value_ptr(h))) goto oom;
-
-  s->callback(s->closure, h);
-
-  /* For each submessage field, get or create a handlers object and set it as
-   * the subhandlers. */
-  for(upb_msg_field_begin(&i, m);
-      !upb_msg_field_done(&i);
-      upb_msg_field_next(&i)) {
-    upb_fielddef *f = upb_msg_iter_field(&i);
-    const upb_msgdef *subdef;
-    upb_value subm_ent;
-
-    if (!upb_fielddef_issubmsg(f)) continue;
-
-    subdef = upb_downcast_msgdef(upb_fielddef_subdef(f));
-    if (upb_inttable_lookupptr(&s->tab, subdef, &subm_ent)) {
-      upb_handlers_setsubhandlers(h, f, upb_value_getptr(subm_ent));
-    } else {
-      upb_handlers *sub_mh = newformsg(subdef, &sub_mh, s);
-      if (!sub_mh) goto oom;
-      upb_handlers_setsubhandlers(h, f, sub_mh);
-      upb_handlers_unref(sub_mh, &sub_mh);
-    }
-  }
-  return h;
-
-oom:
-  upb_handlers_unref(h, owner);
-  return NULL;
-}
-
 /* Given a selector for a STARTSUBMSG handler, resolves to a pointer to the
  * subhandlers for this submessage field. */
 #define SUBH(h, selector) (h->sub[selector])
 
 /* The selector for a submessage field is the field index. */
-#define SUBH_F(h, f) SUBH(h, f->index_)
+#define SUBH_F(h, f) SUBH(h, upb_fielddef_index(f))
 
 static int32_t trygetsel(upb_handlers *h, const upb_fielddef *f,
                          upb_handlertype_t type) {
   upb_selector_t sel;
-  UPB_ASSERT(!upb_handlers_isfrozen(h));
-  if (upb_handlers_msgdef(h) != upb_fielddef_containingtype(f)) {
-    upb_status_seterrf(
-        &h->status_, "type mismatch: field %s does not belong to message %s",
-        upb_fielddef_name(f), upb_msgdef_fullname(upb_handlers_msgdef(h)));
-    return -1;
-  }
-  if (!upb_handlers_getselector(f, type, &sel)) {
-    upb_status_seterrf(
-        &h->status_,
-        "type mismatch: cannot register handler type %d for field %s",
-        type, upb_fielddef_name(f));
-    return -1;
-  }
+  bool ok;
+
+  ok = upb_handlers_getselector(f, type, &sel);
+
+  UPB_ASSERT(upb_handlers_msgdef(h) == upb_fielddef_containingtype(f));
+  UPB_ASSERT(ok);
+
   return sel;
 }
 
@@ -138,29 +59,17 @@ static upb_selector_t handlers_getsel(upb_handlers *h, const upb_fielddef *f,
 
 static const void **returntype(upb_handlers *h, const upb_fielddef *f,
                                upb_handlertype_t type) {
-  return &h->table[handlers_getsel(h, f, type)].attr.return_closure_type_;
+  return &h->table[handlers_getsel(h, f, type)].attr.return_closure_type;
 }
 
 static bool doset(upb_handlers *h, int32_t sel, const upb_fielddef *f,
                   upb_handlertype_t type, upb_func *func,
-                  upb_handlerattr *attr) {
-  upb_handlerattr set_attr = UPB_HANDLERATTR_INITIALIZER;
+                  const upb_handlerattr *attr) {
+  upb_handlerattr set_attr = UPB_HANDLERATTR_INIT;
   const void *closure_type;
   const void **context_closure_type;
 
-  UPB_ASSERT(!upb_handlers_isfrozen(h));
-
-  if (sel < 0) {
-    upb_status_seterrmsg(&h->status_,
-                         "incorrect handler type for this field.");
-    return false;
-  }
-
-  if (h->table[sel].func) {
-    upb_status_seterrmsg(&h->status_,
-                         "cannot change handler once it has been set.");
-    return false;
-  }
+  UPB_ASSERT(!h->table[sel].func);
 
   if (attr) {
     set_attr = *attr;
@@ -168,7 +77,7 @@ static bool doset(upb_handlers *h, int32_t sel, const upb_fielddef *f,
 
   /* Check that the given closure type matches the closure type that has been
    * established for this context (if any). */
-  closure_type = upb_handlerattr_closuretype(&set_attr);
+  closure_type = set_attr.closure_type;
 
   if (type == UPB_HANDLER_STRING) {
     context_closure_type = returntype(h, f, UPB_HANDLER_STARTSTR);
@@ -182,15 +91,6 @@ static bool doset(upb_handlers *h, int32_t sel, const upb_fielddef *f,
 
   if (closure_type && *context_closure_type &&
       closure_type != *context_closure_type) {
-    /* TODO(haberman): better message for debugging. */
-    if (f) {
-      upb_status_seterrf(&h->status_,
-                         "closure type does not match for field %s",
-                         upb_fielddef_name(f));
-    } else {
-      upb_status_seterrmsg(
-          &h->status_, "closure type does not match for message-level handler");
-    }
     return false;
   }
 
@@ -200,16 +100,15 @@ static bool doset(upb_handlers *h, int32_t sel, const upb_fielddef *f,
   /* If this is a STARTSEQ or STARTSTR handler, check that the returned pointer
    * matches any pre-existing expectations about what type is expected. */
   if (type == UPB_HANDLER_STARTSEQ || type == UPB_HANDLER_STARTSTR) {
-    const void *return_type = upb_handlerattr_returnclosuretype(&set_attr);
-    const void *table_return_type =
-        upb_handlerattr_returnclosuretype(&h->table[sel].attr);
+    const void *return_type = set_attr.return_closure_type;
+    const void *table_return_type = h->table[sel].attr.return_closure_type;
     if (return_type && table_return_type && return_type != table_return_type) {
-      upb_status_seterrmsg(&h->status_, "closure return type does not match");
       return false;
     }
 
-    if (table_return_type && !return_type)
-      upb_handlerattr_setreturnclosuretype(&set_attr, table_return_type);
+    if (table_return_type && !return_type) {
+      set_attr.return_closure_type = table_return_type;
+    }
   }
 
   h->table[sel].func = (upb_func*)func;
@@ -235,18 +134,18 @@ const void *effective_closure_type(upb_handlers *h, const upb_fielddef *f,
       type != UPB_HANDLER_STARTSEQ &&
       type != UPB_HANDLER_ENDSEQ &&
       h->table[sel = handlers_getsel(h, f, UPB_HANDLER_STARTSEQ)].func) {
-    ret = upb_handlerattr_returnclosuretype(&h->table[sel].attr);
+    ret = h->table[sel].attr.return_closure_type;
   }
 
   if (type == UPB_HANDLER_STRING &&
       h->table[sel = handlers_getsel(h, f, UPB_HANDLER_STARTSTR)].func) {
-    ret = upb_handlerattr_returnclosuretype(&h->table[sel].attr);
+    ret = h->table[sel].attr.return_closure_type;
   }
 
   /* The effective type of the submessage; not used yet.
    * if (type == SUBMESSAGE &&
    *     h->table[sel = handlers_getsel(h, f, UPB_HANDLER_STARTSUBMSG)].func) {
-   *   ret = upb_handlerattr_returnclosuretype(&h->table[sel].attr);
+   *   ret = h->table[sel].attr.return_closure_type;
    * } */
 
   return ret;
@@ -266,92 +165,47 @@ bool checkstart(upb_handlers *h, const upb_fielddef *f, upb_handlertype_t type,
   if (h->table[sel].func) return true;
   closure_type = effective_closure_type(h, f, type);
   attr = &h->table[sel].attr;
-  return_closure_type = upb_handlerattr_returnclosuretype(attr);
+  return_closure_type = attr->return_closure_type;
   if (closure_type && return_closure_type &&
       closure_type != return_closure_type) {
-    upb_status_seterrf(status,
-                       "expected start handler to return sub type for field %f",
-                       upb_fielddef_name(f));
     return false;
   }
   return true;
 }
 
-/* Public interface ***********************************************************/
-
-upb_handlers *upb_handlers_new(const upb_msgdef *md, const void *owner) {
+static upb_handlers *upb_handlers_new(const upb_msgdef *md,
+                                      upb_handlercache *cache,
+                                      upb_arena *arena) {
   int extra;
   upb_handlers *h;
 
-  UPB_ASSERT(upb_msgdef_isfrozen(md));
-
-  extra = sizeof(upb_handlers_tabent) * (md->selector_count - 1);
-  h = upb_calloc(sizeof(*h) + extra);
+  extra = sizeof(upb_handlers_tabent) * (upb_msgdef_selectorcount(md) - 1);
+  h = upb_calloc(arena, sizeof(*h) + extra);
   if (!h) return NULL;
 
+  h->cache = cache;
   h->msg = md;
-  upb_msgdef_ref(h->msg, h);
-  upb_status_clear(&h->status_);
 
-  if (md->submsg_field_count > 0) {
-    h->sub = upb_calloc(md->submsg_field_count * sizeof(*h->sub));
-    if (!h->sub) goto oom;
+  if (upb_msgdef_submsgfieldcount(md) > 0) {
+    size_t bytes = upb_msgdef_submsgfieldcount(md) * sizeof(*h->sub);
+    h->sub = upb_calloc(arena, bytes);
+    if (!h->sub) return NULL;
   } else {
     h->sub = 0;
   }
 
-  if (!upb_refcounted_init(upb_handlers_upcast_mutable(h), &vtbl, owner))
-    goto oom;
-  if (!upb_inttable_init(&h->cleanup_, UPB_CTYPE_FPTR)) goto oom;
-
   /* calloc() above initialized all handlers to NULL. */
   return h;
-
-oom:
-  freehandlers(upb_handlers_upcast_mutable(h));
-  return NULL;
-}
-
-const upb_handlers *upb_handlers_newfrozen(const upb_msgdef *m,
-                                           const void *owner,
-                                           upb_handlers_callback *callback,
-                                           const void *closure) {
-  dfs_state state;
-  upb_handlers *ret;
-  bool ok;
-  upb_refcounted *r;
-
-  state.callback = callback;
-  state.closure = closure;
-  if (!upb_inttable_init(&state.tab, UPB_CTYPE_PTR)) return NULL;
-
-  ret = newformsg(m, owner, &state);
-
-  upb_inttable_uninit(&state.tab);
-  if (!ret) return NULL;
-
-  r = upb_handlers_upcast_mutable(ret);
-  ok = upb_refcounted_freeze(&r, 1, NULL, UPB_MAX_HANDLER_DEPTH);
-  UPB_ASSERT(ok);
-
-  return ret;
-}
-
-const upb_status *upb_handlers_status(upb_handlers *h) {
-  UPB_ASSERT(!upb_handlers_isfrozen(h));
-  return &h->status_;
 }
 
-void upb_handlers_clearerr(upb_handlers *h) {
-  UPB_ASSERT(!upb_handlers_isfrozen(h));
-  upb_status_clear(&h->status_);
-}
+/* Public interface ***********************************************************/
 
-#define SETTER(name, handlerctype, handlertype) \
-  bool upb_handlers_set ## name(upb_handlers *h, const upb_fielddef *f, \
-                                handlerctype func, upb_handlerattr *attr) { \
-    int32_t sel = trygetsel(h, f, handlertype); \
-    return doset(h, sel, f, handlertype, (upb_func*)func, attr); \
+#define SETTER(name, handlerctype, handlertype)                       \
+  bool upb_handlers_set##name(upb_handlers *h, const upb_fielddef *f, \
+                              handlerctype func,                      \
+                              const upb_handlerattr *attr) {          \
+    int32_t sel = trygetsel(h, f, handlertype);                       \
+    return doset(h, sel, f, handlertype, (upb_func *)func, attr);     \
   }
 
 SETTER(int32,       upb_int32_handlerfunc*,       UPB_HANDLER_INT32)
@@ -372,20 +226,19 @@ SETTER(endseq,      upb_endfield_handlerfunc*,    UPB_HANDLER_ENDSEQ)
 #undef SETTER
 
 bool upb_handlers_setunknown(upb_handlers *h, upb_unknown_handlerfunc *func,
-                             upb_handlerattr *attr) {
+                             const upb_handlerattr *attr) {
   return doset(h, UPB_UNKNOWN_SELECTOR, NULL, UPB_HANDLER_INT32,
                (upb_func *)func, attr);
 }
 
 bool upb_handlers_setstartmsg(upb_handlers *h, upb_startmsg_handlerfunc *func,
-                              upb_handlerattr *attr) {
+                              const upb_handlerattr *attr) {
   return doset(h, UPB_STARTMSG_SELECTOR, NULL, UPB_HANDLER_INT32,
                (upb_func *)func, attr);
 }
 
 bool upb_handlers_setendmsg(upb_handlers *h, upb_endmsg_handlerfunc *func,
-                            upb_handlerattr *attr) {
-  UPB_ASSERT(!upb_handlers_isfrozen(h));
+                            const upb_handlerattr *attr) {
   return doset(h, UPB_ENDMSG_SELECTOR, NULL, UPB_HANDLER_INT32,
                (upb_func *)func, attr);
 }
@@ -393,14 +246,12 @@ bool upb_handlers_setendmsg(upb_handlers *h, upb_endmsg_handlerfunc *func,
 bool upb_handlers_setsubhandlers(upb_handlers *h, const upb_fielddef *f,
                                  const upb_handlers *sub) {
   UPB_ASSERT(sub);
-  UPB_ASSERT(!upb_handlers_isfrozen(h));
   UPB_ASSERT(upb_fielddef_issubmsg(f));
   if (SUBH_F(h, f)) return false;  /* Can't reset. */
-  if (upb_msgdef_upcast(upb_handlers_msgdef(sub)) != upb_fielddef_subdef(f)) {
+  if (upb_handlers_msgdef(sub) != upb_fielddef_msgsubdef(f)) {
     return false;
   }
   SUBH_F(h, f) = sub;
-  upb_ref2(sub, h);
   return true;
 }
 
@@ -410,9 +261,18 @@ const upb_handlers *upb_handlers_getsubhandlers(const upb_handlers *h,
   return SUBH_F(h, f);
 }
 
+upb_func *upb_handlers_gethandler(const upb_handlers *h, upb_selector_t s,
+                                  const void **handler_data) {
+  upb_func *ret = (upb_func *)h->table[s].func;
+  if (ret && handler_data) {
+    *handler_data = h->table[s].attr.handler_data;
+  }
+  return ret;
+}
+
 bool upb_handlers_getattr(const upb_handlers *h, upb_selector_t sel,
                           upb_handlerattr *attr) {
-  if (!upb_handlers_gethandler(h, sel))
+  if (!upb_handlers_gethandler(h, sel, NULL))
     return false;
   *attr = h->table[sel].attr;
   return true;
@@ -427,100 +287,7 @@ const upb_handlers *upb_handlers_getsubhandlers_sel(const upb_handlers *h,
 const upb_msgdef *upb_handlers_msgdef(const upb_handlers *h) { return h->msg; }
 
 bool upb_handlers_addcleanup(upb_handlers *h, void *p, upb_handlerfree *func) {
-  bool ok;
-  if (upb_inttable_lookupptr(&h->cleanup_, p, NULL)) {
-    return false;
-  }
-  ok = upb_inttable_insertptr(&h->cleanup_, p, upb_value_fptr(func));
-  UPB_ASSERT(ok);
-  return true;
-}
-
-
-/* "Static" methods ***********************************************************/
-
-bool upb_handlers_freeze(upb_handlers *const*handlers, int n, upb_status *s) {
-  /* TODO: verify we have a transitive closure. */
-  int i;
-  for (i = 0; i < n; i++) {
-    upb_msg_field_iter j;
-    upb_handlers *h = handlers[i];
-
-    if (!upb_ok(&h->status_)) {
-      upb_status_seterrf(s, "handlers for message %s had error status: %s",
-                         upb_msgdef_fullname(upb_handlers_msgdef(h)),
-                         upb_status_errmsg(&h->status_));
-      return false;
-    }
-
-    /* Check that there are no closure mismatches due to missing Start* handlers
-     * or subhandlers with different type-level types. */
-    for(upb_msg_field_begin(&j, h->msg);
-        !upb_msg_field_done(&j);
-        upb_msg_field_next(&j)) {
-
-      const upb_fielddef *f = upb_msg_iter_field(&j);
-      if (upb_fielddef_isseq(f)) {
-        if (!checkstart(h, f, UPB_HANDLER_STARTSEQ, s))
-          return false;
-      }
-
-      if (upb_fielddef_isstring(f)) {
-        if (!checkstart(h, f, UPB_HANDLER_STARTSTR, s))
-          return false;
-      }
-
-      if (upb_fielddef_issubmsg(f)) {
-        bool hashandler = false;
-        if (upb_handlers_gethandler(
-                h, handlers_getsel(h, f, UPB_HANDLER_STARTSUBMSG)) ||
-            upb_handlers_gethandler(
-                h, handlers_getsel(h, f, UPB_HANDLER_ENDSUBMSG))) {
-          hashandler = true;
-        }
-
-        if (upb_fielddef_isseq(f) &&
-            (upb_handlers_gethandler(
-                 h, handlers_getsel(h, f, UPB_HANDLER_STARTSEQ)) ||
-             upb_handlers_gethandler(
-                 h, handlers_getsel(h, f, UPB_HANDLER_ENDSEQ)))) {
-          hashandler = true;
-        }
-
-        if (hashandler && !upb_handlers_getsubhandlers(h, f)) {
-          /* For now we add an empty subhandlers in this case.  It makes the
-           * decoder code generator simpler, because it only has to handle two
-           * cases (submessage has handlers or not) as opposed to three
-           * (submessage has handlers in enclosing message but no subhandlers).
-           *
-           * This makes parsing less efficient in the case that we want to
-           * notice a submessage but skip its contents (like if we're testing
-           * for submessage presence or counting the number of repeated
-           * submessages).  In this case we will end up parsing the submessage
-           * field by field and throwing away the results for each, instead of
-           * skipping the whole delimited thing at once.  If this is an issue we
-           * can revisit it, but do remember that this only arises when you have
-           * handlers (startseq/startsubmsg/endsubmsg/endseq) set for the
-           * submessage but no subhandlers.  The uses cases for this are
-           * limited. */
-          upb_handlers *sub = upb_handlers_new(upb_fielddef_msgsubdef(f), &sub);
-          upb_handlers_setsubhandlers(h, f, sub);
-          upb_handlers_unref(sub, &sub);
-        }
-
-        /* TODO(haberman): check type of submessage.
-         * This is slightly tricky; also consider whether we should check that
-         * they match at setsubhandlers time. */
-      }
-    }
-  }
-
-  if (!upb_refcounted_freeze((upb_refcounted*const*)handlers, n, s,
-                             UPB_MAX_HANDLER_DEPTH)) {
-    return false;
-  }
-
-  return true;
+  return upb_handlercache_addcleanup(h->cache, p, func);
 }
 
 upb_handlertype_t upb_handlers_getprimitivehandlertype(const upb_fielddef *f) {
@@ -539,6 +306,7 @@ upb_handlertype_t upb_handlers_getprimitivehandlertype(const upb_fielddef *f) {
 
 bool upb_handlers_getselector(const upb_fielddef *f, upb_handlertype_t type,
                               upb_selector_t *s) {
+  uint32_t selector_base = upb_fielddef_selectorbase(f);
   switch (type) {
     case UPB_HANDLER_INT32:
     case UPB_HANDLER_INT64:
@@ -550,38 +318,38 @@ bool upb_handlers_getselector(const upb_fielddef *f, upb_handlertype_t type,
       if (!upb_fielddef_isprimitive(f) ||
           upb_handlers_getprimitivehandlertype(f) != type)
         return false;
-      *s = f->selector_base;
+      *s = selector_base;
       break;
     case UPB_HANDLER_STRING:
       if (upb_fielddef_isstring(f)) {
-        *s = f->selector_base;
+        *s = selector_base;
       } else if (upb_fielddef_lazy(f)) {
-        *s = f->selector_base + 3;
+        *s = selector_base + 3;
       } else {
         return false;
       }
       break;
     case UPB_HANDLER_STARTSTR:
       if (upb_fielddef_isstring(f) || upb_fielddef_lazy(f)) {
-        *s = f->selector_base + 1;
+        *s = selector_base + 1;
       } else {
         return false;
       }
       break;
     case UPB_HANDLER_ENDSTR:
       if (upb_fielddef_isstring(f) || upb_fielddef_lazy(f)) {
-        *s = f->selector_base + 2;
+        *s = selector_base + 2;
       } else {
         return false;
       }
       break;
     case UPB_HANDLER_STARTSEQ:
       if (!upb_fielddef_isseq(f)) return false;
-      *s = f->selector_base - 2;
+      *s = selector_base - 2;
       break;
     case UPB_HANDLER_ENDSEQ:
       if (!upb_fielddef_isseq(f)) return false;
-      *s = f->selector_base - 1;
+      *s = selector_base - 1;
       break;
     case UPB_HANDLER_STARTSUBMSG:
       if (!upb_fielddef_issubmsg(f)) return false;
@@ -589,14 +357,14 @@ bool upb_handlers_getselector(const upb_fielddef *f, upb_handlertype_t type,
        * selector can also be used as an index into the "sub" array of
        * subhandlers.  The indexes for the two into these two tables are the
        * same, except that in the handler table the static selectors come first. */
-      *s = f->index_ + UPB_STATIC_SELECTOR_COUNT;
+      *s = upb_fielddef_index(f) + UPB_STATIC_SELECTOR_COUNT;
       break;
     case UPB_HANDLER_ENDSUBMSG:
       if (!upb_fielddef_issubmsg(f)) return false;
-      *s = f->selector_base;
+      *s = selector_base;
       break;
   }
-  UPB_ASSERT((size_t)*s < upb_fielddef_containingtype(f)->selector_count);
+  UPB_ASSERT((size_t)*s < upb_msgdef_selectorcount(upb_fielddef_containingtype(f)));
   return true;
 }
 
@@ -619,90 +387,108 @@ uint32_t upb_handlers_selectorcount(const upb_fielddef *f) {
   return ret;
 }
 
+/* upb_handlercache ***********************************************************/
 
-/* upb_handlerattr ************************************************************/
+struct upb_handlercache {
+  upb_arena *arena;
+  upb_inttable tab;  /* maps upb_msgdef* -> upb_handlers*. */
+  upb_handlers_callback *callback;
+  const void *closure;
+};
 
-void upb_handlerattr_init(upb_handlerattr *attr) {
-  upb_handlerattr from = UPB_HANDLERATTR_INITIALIZER;
-  memcpy(attr, &from, sizeof(*attr));
-}
+const upb_handlers *upb_handlercache_get(upb_handlercache *c,
+                                         const upb_msgdef *md) {
+  upb_msg_field_iter i;
+  upb_value v;
+  upb_handlers *h;
 
-void upb_handlerattr_uninit(upb_handlerattr *attr) {
-  UPB_UNUSED(attr);
-}
+  if (upb_inttable_lookupptr(&c->tab, md, &v)) {
+    return upb_value_getptr(v);
+  }
 
-bool upb_handlerattr_sethandlerdata(upb_handlerattr *attr, const void *hd) {
-  attr->handler_data_ = hd;
-  return true;
-}
+  h = upb_handlers_new(md, c, c->arena);
+  v = upb_value_ptr(h);
 
-bool upb_handlerattr_setclosuretype(upb_handlerattr *attr, const void *type) {
-  attr->closure_type_ = type;
-  return true;
-}
+  if (!h) return NULL;
+  if (!upb_inttable_insertptr(&c->tab, md, v)) return NULL;
 
-const void *upb_handlerattr_closuretype(const upb_handlerattr *attr) {
-  return attr->closure_type_;
-}
+  c->callback(c->closure, h);
 
-bool upb_handlerattr_setreturnclosuretype(upb_handlerattr *attr,
-                                          const void *type) {
-  attr->return_closure_type_ = type;
-  return true;
-}
+  /* For each submessage field, get or create a handlers object and set it as
+   * the subhandlers. */
+  for(upb_msg_field_begin(&i, md);
+      !upb_msg_field_done(&i);
+      upb_msg_field_next(&i)) {
+    upb_fielddef *f = upb_msg_iter_field(&i);
 
-const void *upb_handlerattr_returnclosuretype(const upb_handlerattr *attr) {
-  return attr->return_closure_type_;
-}
+    if (upb_fielddef_issubmsg(f)) {
+      const upb_msgdef *subdef = upb_fielddef_msgsubdef(f);
+      const upb_handlers *sub_mh = upb_handlercache_get(c, subdef);
 
-bool upb_handlerattr_setalwaysok(upb_handlerattr *attr, bool alwaysok) {
-  attr->alwaysok_ = alwaysok;
-  return true;
-}
+      if (!sub_mh) return NULL;
 
-bool upb_handlerattr_alwaysok(const upb_handlerattr *attr) {
-  return attr->alwaysok_;
+      upb_handlers_setsubhandlers(h, f, sub_mh);
+    }
+  }
+
+  return h;
 }
 
-/* upb_bufhandle **************************************************************/
 
-size_t upb_bufhandle_objofs(const upb_bufhandle *h) {
-  return h->objofs_;
-}
+upb_handlercache *upb_handlercache_new(upb_handlers_callback *callback,
+                                       const void *closure) {
+  upb_handlercache *cache = upb_gmalloc(sizeof(*cache));
 
-/* upb_byteshandler ***********************************************************/
+  if (!cache) return NULL;
+
+  cache->arena = upb_arena_new();
+
+  cache->callback = callback;
+  cache->closure = closure;
 
-void upb_byteshandler_init(upb_byteshandler* h) {
-  memset(h, 0, sizeof(*h));
+  if (!upb_inttable_init(&cache->tab, UPB_CTYPE_PTR)) goto oom;
+
+  return cache;
+
+oom:
+  upb_gfree(cache);
+  return NULL;
 }
 
-/* For when we support handlerfree callbacks. */
-void upb_byteshandler_uninit(upb_byteshandler* h) {
-  UPB_UNUSED(h);
+void upb_handlercache_free(upb_handlercache *cache) {
+  upb_inttable_uninit(&cache->tab);
+  upb_arena_free(cache->arena);
+  upb_gfree(cache);
 }
 
+bool upb_handlercache_addcleanup(upb_handlercache *c, void *p,
+                                 upb_handlerfree *func) {
+  return upb_arena_addcleanup(c->arena, p, func);
+}
+
+/* upb_byteshandler ***********************************************************/
+
 bool upb_byteshandler_setstartstr(upb_byteshandler *h,
                                   upb_startstr_handlerfunc *func, void *d) {
   h->table[UPB_STARTSTR_SELECTOR].func = (upb_func*)func;
-  h->table[UPB_STARTSTR_SELECTOR].attr.handler_data_ = d;
+  h->table[UPB_STARTSTR_SELECTOR].attr.handler_data = d;
   return true;
 }
 
 bool upb_byteshandler_setstring(upb_byteshandler *h,
                                 upb_string_handlerfunc *func, void *d) {
   h->table[UPB_STRING_SELECTOR].func = (upb_func*)func;
-  h->table[UPB_STRING_SELECTOR].attr.handler_data_ = d;
+  h->table[UPB_STRING_SELECTOR].attr.handler_data = d;
   return true;
 }
 
 bool upb_byteshandler_setendstr(upb_byteshandler *h,
                                 upb_endfield_handlerfunc *func, void *d) {
   h->table[UPB_ENDSTR_SELECTOR].func = (upb_func*)func;
-  h->table[UPB_ENDSTR_SELECTOR].attr.handler_data_ = d;
+  h->table[UPB_ENDSTR_SELECTOR].attr.handler_data = d;
   return true;
 }
 
-
 /** Handlers for upb_msg ******************************************************/
 
 typedef struct {
@@ -731,7 +517,7 @@ MSG_WRITER(bool,   bool)
 
 bool upb_msg_setscalarhandler(upb_handlers *h, const upb_fielddef *f,
                               size_t offset, int32_t hasbit) {
-  upb_handlerattr attr = UPB_HANDLERATTR_INITIALIZER;
+  upb_handlerattr attr = UPB_HANDLERATTR_INIT;
   bool ok;
 
   upb_msg_handlerdata *d = upb_gmalloc(sizeof(*d));
@@ -739,8 +525,8 @@ bool upb_msg_setscalarhandler(upb_handlers *h, const upb_fielddef *f,
   d->offset = offset;
   d->hasbit = hasbit;
 
-  upb_handlerattr_sethandlerdata(&attr, d);
-  upb_handlerattr_setalwaysok(&attr, true);
+  attr.handler_data = d;
+  attr.alwaysok = true;
   upb_handlers_addcleanup(h, d, upb_gfree);
 
 #define TYPE(u, l) \
@@ -762,7 +548,6 @@ bool upb_msg_setscalarhandler(upb_handlers *h, const upb_fielddef *f,
   }
 #undef TYPE
 
-  upb_handlerattr_uninit(&attr);
   return ok;
 }
 
@@ -772,7 +557,8 @@ bool upb_msg_getscalarhandlerdata(const upb_handlers *h,
                                   size_t *offset,
                                   int32_t *hasbit) {
   const upb_msg_handlerdata *d;
-  upb_func *f = upb_handlers_gethandler(h, s);
+  const void *p;
+  upb_func *f = upb_handlers_gethandler(h, s, &p);
 
   if ((upb_int64_handlerfunc*)f == upb_msg_setint64) {
     *type = UPB_TYPE_INT64;
@@ -792,7 +578,7 @@ bool upb_msg_getscalarhandlerdata(const upb_handlers *h,
     return false;
   }
 
-  d = upb_handlers_gethandlerdata(h, s);
+  d = p;
   *offset = d->offset;
   *hasbit = d->hasbit;
   return true;
diff --git a/upb/handlers.h b/upb/handlers.h
index a4e2a04..e267f12 100644
--- a/upb/handlers.h
+++ b/upb/handlers.h
@@ -24,20 +24,13 @@
 
 #ifdef __cplusplus
 namespace upb {
-class BufferHandle;
-class BytesHandler;
-class HandlerAttributes;
-class Handlers;
+class HandlersPtr;
+class HandlerCache;
 template <class T> class Handler;
 template <class T> struct CanonicalType;
 }  /* namespace upb */
 #endif
 
-UPB_DECLARE_TYPE(upb::BufferHandle, upb_bufhandle)
-UPB_DECLARE_TYPE(upb::BytesHandler, upb_byteshandler)
-UPB_DECLARE_TYPE(upb::HandlerAttributes, upb_handlerattr)
-UPB_DECLARE_DERIVED_TYPE(upb::Handlers, upb::RefCounted,
-                         upb_handlers, upb_refcounted)
 
 /* The maximum depth that the handler graph can have.  This is a resource limit
  * for the C stack since we sometimes need to recursively traverse the graph.
@@ -79,28 +72,6 @@ extern char _upb_noclosure;
  * (for example: the STARTSUBMSG handler for field "field15"). */
 typedef int32_t upb_selector_t;
 
-UPB_BEGIN_EXTERN_C
-
-/* Forward-declares for C inline accessors.  We need to declare these here
- * so we can "friend" them in the class declarations in C++. */
-UPB_INLINE upb_func *upb_handlers_gethandler(const upb_handlers *h,
-                                             upb_selector_t s);
-UPB_INLINE const void *upb_handlerattr_handlerdata(const upb_handlerattr *attr);
-UPB_INLINE const void *upb_handlers_gethandlerdata(const upb_handlers *h,
-                                                   upb_selector_t s);
-
-UPB_INLINE void upb_bufhandle_init(upb_bufhandle *h);
-UPB_INLINE void upb_bufhandle_setobj(upb_bufhandle *h, const void *obj,
-                                     const void *type);
-UPB_INLINE void upb_bufhandle_setbuf(upb_bufhandle *h, const char *buf,
-                                     size_t ofs);
-UPB_INLINE const void *upb_bufhandle_obj(const upb_bufhandle *h);
-UPB_INLINE const void *upb_bufhandle_objtype(const upb_bufhandle *h);
-UPB_INLINE const char *upb_bufhandle_buf(const upb_bufhandle *h);
-
-UPB_END_EXTERN_C
-
-
 /* Static selectors for upb::Handlers. */
 #define UPB_STARTMSG_SELECTOR 0
 #define UPB_ENDMSG_SELECTOR 1
@@ -112,125 +83,236 @@ UPB_END_EXTERN_C
 #define UPB_STRING_SELECTOR 1
 #define UPB_ENDSTR_SELECTOR 2
 
-typedef void upb_handlerfree(void *d);
-
 #ifdef __cplusplus
-
-/* A set of attributes that accompanies a handler's function pointer. */
-class upb::HandlerAttributes {
- public:
-  HandlerAttributes();
-  ~HandlerAttributes();
-
-  /* Sets the handler data that will be passed as the second parameter of the
-   * handler.  To free this pointer when the handlers are freed, call
-   * Handlers::AddCleanup(). */
-  bool SetHandlerData(const void *handler_data);
-  const void* handler_data() const;
-
-  /* Use this to specify the type of the closure.  This will be checked against
-   * all other closure types for handler that use the same closure.
-   * Registration will fail if this does not match all other non-NULL closure
-   * types. */
-  bool SetClosureType(const void *closure_type);
-  const void* closure_type() const;
-
-  /* Use this to specify the type of the returned closure.  Only used for
-   * Start*{String,SubMessage,Sequence} handlers.  This must match the closure
-   * type of any handlers that use it (for example, the StringBuf handler must
-   * match the closure returned from StartString). */
-  bool SetReturnClosureType(const void *return_closure_type);
-  const void* return_closure_type() const;
-
-  /* Set to indicate that the handler always returns "ok" (either "true" or a
-   * non-NULL closure).  This is a hint that can allow code generators to
-   * generate more efficient code. */
-  bool SetAlwaysOk(bool always_ok);
-  bool always_ok() const;
-
- private:
-  friend UPB_INLINE const void * ::upb_handlerattr_handlerdata(
-      const upb_handlerattr *attr);
-#else
-struct upb_handlerattr {
+template<class T> const void *UniquePtrForType() {
+  static const char ch = 0;
+  return &ch;
+}
 #endif
-  const void *handler_data_;
-  const void *closure_type_;
-  const void *return_closure_type_;
-  bool alwaysok_;
-};
 
-#define UPB_HANDLERATTR_INITIALIZER {NULL, NULL, NULL, false}
+/* upb_handlers ************************************************************/
 
+/* Handler attributes, to be registered with the handler itself. */
 typedef struct {
-  upb_func *func;
+  const void *handler_data;
+  const void *closure_type;
+  const void *return_closure_type;
+  bool alwaysok;
+} upb_handlerattr;
 
-  /* It is wasteful to include the entire attributes here:
-   *
-   * * Some of the information is redundant (like storing the closure type
-   *   separately for each handler that must match).
-   * * Some of the info is only needed prior to freeze() (like closure types).
-   * * alignment padding wastes a lot of space for alwaysok_.
-   *
-   * If/when the size and locality of handlers is an issue, we can optimize this
-   * not to store the entire attr like this.  We do not expose the table's
-   * layout to allow this optimization in the future. */
-  upb_handlerattr attr;
-} upb_handlers_tabent;
-
-#ifdef __cplusplus
-
-/* Extra information about a buffer that is passed to a StringBuf handler.
- * TODO(haberman): allow the handle to be pinned so that it will outlive
- * the handler invocation. */
-class upb::BufferHandle {
- public:
-  BufferHandle();
-  ~BufferHandle();
+#define UPB_HANDLERATTR_INIT {NULL, NULL, NULL, false}
 
+/* Bufhandle, data passed along with a buffer to indicate its provenance. */
+typedef struct {
   /* The beginning of the buffer.  This may be different than the pointer
    * passed to a StringBuf handler because the handler may receive data
    * that is from the middle or end of a larger buffer. */
-  const char* buffer() const;
+  const char *buf;
 
   /* The offset within the attached object where this buffer begins.  Only
    * meaningful if there is an attached object. */
-  size_t object_offset() const;
+  size_t objofs;
 
-  /* Note that object_offset is the offset of "buf" within the attached
-   * object. */
-  void SetBuffer(const char* buf, size_t object_offset);
+  /* The attached object (if any) and a pointer representing its type. */
+  const void *obj;
+  const void *objtype;
 
-  /* The BufferHandle can have an "attached object", which can be used to
-   * tunnel through a pointer to the buffer's underlying representation. */
+#ifdef __cplusplus
   template <class T>
-  void SetAttachedObject(const T* obj);
+  void SetAttachedObject(const T* _obj) {
+    obj = _obj;
+    objtype = UniquePtrForType<T>();
+  }
 
-  /* Returns NULL if the attached object is not of this type. */
   template <class T>
-  const T* GetAttachedObject() const;
+  const T *GetAttachedObject() const {
+    return objtype == UniquePtrForType<T>() ? static_cast<const T *>(obj)
+                                            : NULL;
+  }
+#endif
+} upb_bufhandle;
 
- private:
-  friend UPB_INLINE void ::upb_bufhandle_init(upb_bufhandle *h);
-  friend UPB_INLINE void ::upb_bufhandle_setobj(upb_bufhandle *h,
-                                                const void *obj,
-                                                const void *type);
-  friend UPB_INLINE void ::upb_bufhandle_setbuf(upb_bufhandle *h,
-                                                const char *buf, size_t ofs);
-  friend UPB_INLINE const void* ::upb_bufhandle_obj(const upb_bufhandle *h);
-  friend UPB_INLINE const void* ::upb_bufhandle_objtype(
-      const upb_bufhandle *h);
-  friend UPB_INLINE const char* ::upb_bufhandle_buf(const upb_bufhandle *h);
-#else
-struct upb_bufhandle {
+#define UPB_BUFHANDLE_INIT {NULL, 0, NULL, NULL}
+
+/* Handler function typedefs. */
+typedef void upb_handlerfree(void *d);
+typedef bool upb_unknown_handlerfunc(void *c, const void *hd, const char *buf,
+                                     size_t n);
+typedef bool upb_startmsg_handlerfunc(void *c, const void*);
+typedef bool upb_endmsg_handlerfunc(void *c, const void *, upb_status *status);
+typedef void* upb_startfield_handlerfunc(void *c, const void *hd);
+typedef bool upb_endfield_handlerfunc(void *c, const void *hd);
+typedef bool upb_int32_handlerfunc(void *c, const void *hd, int32_t val);
+typedef bool upb_int64_handlerfunc(void *c, const void *hd, int64_t val);
+typedef bool upb_uint32_handlerfunc(void *c, const void *hd, uint32_t val);
+typedef bool upb_uint64_handlerfunc(void *c, const void *hd, uint64_t val);
+typedef bool upb_float_handlerfunc(void *c, const void *hd, float val);
+typedef bool upb_double_handlerfunc(void *c, const void *hd, double val);
+typedef bool upb_bool_handlerfunc(void *c, const void *hd, bool val);
+typedef void *upb_startstr_handlerfunc(void *c, const void *hd,
+                                       size_t size_hint);
+typedef size_t upb_string_handlerfunc(void *c, const void *hd, const char *buf,
+                                      size_t n, const upb_bufhandle* handle);
+
+struct upb_handlers;
+typedef struct upb_handlers upb_handlers;
+
+#ifdef __cplusplus
+extern "C" {
 #endif
-  const char *buf_;
-  const void *obj_;
-  const void *objtype_;
-  size_t objofs_;
-};
+
+/* Mutating accessors. */
+const upb_status *upb_handlers_status(upb_handlers *h);
+void upb_handlers_clearerr(upb_handlers *h);
+const upb_msgdef *upb_handlers_msgdef(const upb_handlers *h);
+bool upb_handlers_addcleanup(upb_handlers *h, void *p, upb_handlerfree *hfree);
+bool upb_handlers_setunknown(upb_handlers *h, upb_unknown_handlerfunc *func,
+                             const upb_handlerattr *attr);
+bool upb_handlers_setstartmsg(upb_handlers *h, upb_startmsg_handlerfunc *func,
+                              const upb_handlerattr *attr);
+bool upb_handlers_setendmsg(upb_handlers *h, upb_endmsg_handlerfunc *func,
+                            const upb_handlerattr *attr);
+bool upb_handlers_setint32(upb_handlers *h, const upb_fielddef *f,
+                           upb_int32_handlerfunc *func,
+                           const upb_handlerattr *attr);
+bool upb_handlers_setint64(upb_handlers *h, const upb_fielddef *f,
+                           upb_int64_handlerfunc *func,
+                           const upb_handlerattr *attr);
+bool upb_handlers_setuint32(upb_handlers *h, const upb_fielddef *f,
+                            upb_uint32_handlerfunc *func,
+                            const upb_handlerattr *attr);
+bool upb_handlers_setuint64(upb_handlers *h, const upb_fielddef *f,
+                            upb_uint64_handlerfunc *func,
+                            const upb_handlerattr *attr);
+bool upb_handlers_setfloat(upb_handlers *h, const upb_fielddef *f,
+                           upb_float_handlerfunc *func,
+                           const upb_handlerattr *attr);
+bool upb_handlers_setdouble(upb_handlers *h, const upb_fielddef *f,
+                            upb_double_handlerfunc *func,
+                            const upb_handlerattr *attr);
+bool upb_handlers_setbool(upb_handlers *h, const upb_fielddef *f,
+                          upb_bool_handlerfunc *func,
+                          const upb_handlerattr *attr);
+bool upb_handlers_setstartstr(upb_handlers *h, const upb_fielddef *f,
+                              upb_startstr_handlerfunc *func,
+                              const upb_handlerattr *attr);
+bool upb_handlers_setstring(upb_handlers *h, const upb_fielddef *f,
+                            upb_string_handlerfunc *func,
+                            const upb_handlerattr *attr);
+bool upb_handlers_setendstr(upb_handlers *h, const upb_fielddef *f,
+                            upb_endfield_handlerfunc *func,
+                            const upb_handlerattr *attr);
+bool upb_handlers_setstartseq(upb_handlers *h, const upb_fielddef *f,
+                              upb_startfield_handlerfunc *func,
+                              const upb_handlerattr *attr);
+bool upb_handlers_setstartsubmsg(upb_handlers *h, const upb_fielddef *f,
+                                 upb_startfield_handlerfunc *func,
+                                 const upb_handlerattr *attr);
+bool upb_handlers_setendsubmsg(upb_handlers *h, const upb_fielddef *f,
+                               upb_endfield_handlerfunc *func,
+                               const upb_handlerattr *attr);
+bool upb_handlers_setendseq(upb_handlers *h, const upb_fielddef *f,
+                            upb_endfield_handlerfunc *func,
+                            const upb_handlerattr *attr);
+
+/* Read-only accessors. */
+const upb_handlers *upb_handlers_getsubhandlers(const upb_handlers *h,
+                                                const upb_fielddef *f);
+const upb_handlers *upb_handlers_getsubhandlers_sel(const upb_handlers *h,
+                                                    upb_selector_t sel);
+upb_func *upb_handlers_gethandler(const upb_handlers *h, upb_selector_t s,
+                                  const void **handler_data);
+bool upb_handlers_getattr(const upb_handlers *h, upb_selector_t s,
+                          upb_handlerattr *attr);
+
+/* "Static" methods */
+upb_handlertype_t upb_handlers_getprimitivehandlertype(const upb_fielddef *f);
+bool upb_handlers_getselector(const upb_fielddef *f, upb_handlertype_t type,
+                              upb_selector_t *s);
+UPB_INLINE upb_selector_t upb_handlers_getendselector(upb_selector_t start) {
+  return start + 1;
+}
+
+/* Internal-only. */
+uint32_t upb_handlers_selectorbaseoffset(const upb_fielddef *f);
+uint32_t upb_handlers_selectorcount(const upb_fielddef *f);
 
 #ifdef __cplusplus
+}  /* extern "C" */
+
+namespace upb {
+typedef upb_handlers Handlers;
+}
+
+/* Convenience macros for creating a Handler object that is wrapped with a
+ * type-safe wrapper function that converts the "void*" parameters/returns
+ * of the underlying C API into nice C++ function.
+ *
+ * Sample usage:
+ *   void OnValue1(MyClosure* c, const MyHandlerData* d, int32_t val) {
+ *     // do stuff ...
+ *   }
+ *
+ *   // Handler that doesn't need any data bound to it.
+ *   void OnValue2(MyClosure* c, int32_t val) {
+ *     // do stuff ...
+ *   }
+ *
+ *   // Handler that returns bool so it can return failure if necessary.
+ *   bool OnValue3(MyClosure* c, int32_t val) {
+ *     // do stuff ...
+ *     return ok;
+ *   }
+ *
+ *   // Member function handler.
+ *   class MyClosure {
+ *    public:
+ *     void OnValue(int32_t val) {
+ *       // do stuff ...
+ *     }
+ *   };
+ *
+ *   // Takes ownership of the MyHandlerData.
+ *   handlers->SetInt32Handler(f1, UpbBind(OnValue1, new MyHandlerData(...)));
+ *   handlers->SetInt32Handler(f2, UpbMakeHandler(OnValue2));
+ *   handlers->SetInt32Handler(f1, UpbMakeHandler(OnValue3));
+ *   handlers->SetInt32Handler(f2, UpbMakeHandler(&MyClosure::OnValue));
+ */
+
+/* In C++11, the "template" disambiguator can appear even outside templates,
+ * so all calls can safely use this pair of macros. */
+
+#define UpbMakeHandler(f) upb::MatchFunc(f).template GetFunc<f>()
+
+/* We have to be careful to only evaluate "d" once. */
+#define UpbBind(f, d) upb::MatchFunc(f).template GetFunc<f>((d))
+
+/* Handler: a struct that contains the (handler, data, deleter) tuple that is
+ * used to register all handlers.  Users can Make() these directly but it's
+ * more convenient to use the UpbMakeHandler/UpbBind macros above. */
+template <class T> class upb::Handler {
+ public:
+  /* The underlying, handler function signature that upb uses internally. */
+  typedef T FuncPtr;
+
+  /* Intentionally implicit. */
+  template <class F> Handler(F func);
+  ~Handler() { UPB_ASSERT(registered_); }
+
+  void AddCleanup(upb_handlers* h) const;
+  FuncPtr handler() const { return handler_; }
+  const upb_handlerattr& attr() const { return attr_; }
+
+ private:
+  Handler(const Handler&) = delete;
+  Handler& operator=(const Handler&) = delete;
+
+  FuncPtr handler_;
+  mutable upb_handlerattr attr_;
+  mutable bool registered_;
+  void *cleanup_data_;
+  upb_handlerfree *cleanup_func_;
+};
 
 /* A upb::Handlers object represents the set of handlers associated with a
  * message in the graph of messages.  You can think of it as a big virtual
@@ -243,18 +325,24 @@ struct upb_bufhandle {
  *
  * The easiest way to create the *Handler objects needed by the Set* methods is
  * with the UpbBind() and UpbMakeHandler() macros; see below. */
-class upb::Handlers {
+class upb::HandlersPtr {
  public:
+  HandlersPtr(upb_handlers* ptr) : ptr_(ptr) {}
+
+  upb_handlers* ptr() const { return ptr_; }
+
   typedef upb_selector_t Selector;
   typedef upb_handlertype_t Type;
 
   typedef Handler<void *(*)(void *, const void *)> StartFieldHandler;
   typedef Handler<bool (*)(void *, const void *)> EndFieldHandler;
   typedef Handler<bool (*)(void *, const void *)> StartMessageHandler;
-  typedef Handler<bool (*)(void *, const void *, Status*)> EndMessageHandler;
+  typedef Handler<bool (*)(void *, const void *, upb_status *)>
+      EndMessageHandler;
   typedef Handler<void *(*)(void *, const void *, size_t)> StartStringHandler;
   typedef Handler<size_t (*)(void *, const void *, const char *, size_t,
-                             const BufferHandle *)> StringHandler;
+                             const upb_bufhandle *)>
+      StringHandler;
 
   template <class T> struct ValueHandler {
     typedef Handler<bool(*)(void *, const void *, T)> H;
@@ -274,47 +362,17 @@ class upb::Handlers {
 
   typedef void HandlersCallback(const void *closure, upb_handlers *h);
 
-  /* Returns a new handlers object for the given frozen msgdef.
-   * Returns NULL if memory allocation failed. */
-  static reffed_ptr<Handlers> New(const MessageDef *m);
-
-  /* Convenience function for registering a graph of handlers that mirrors the
-   * graph of msgdefs for some message.  For "m" and all its children a new set
-   * of handlers will be created and the given callback will be invoked,
-   * allowing the client to register handlers for this message.  Note that any
-   * subhandlers set by the callback will be overwritten. */
-  static reffed_ptr<const Handlers> NewFrozen(const MessageDef *m,
-                                              HandlersCallback *callback,
-                                              const void *closure);
-
-  /* Functionality from upb::RefCounted. */
-  UPB_REFCOUNTED_CPPMETHODS
-
-  /* All handler registration functions return bool to indicate success or
-   * failure; details about failures are stored in this status object.  If a
-   * failure does occur, it must be cleared before the Handlers are frozen,
-   * otherwise the freeze() operation will fail.  The functions may *only* be
-   * used while the Handlers are mutable. */
-  const Status* status();
-  void ClearError();
-
-  /* Call to freeze these Handlers.  Requires that any SubHandlers are already
-   * frozen.  For cycles, you must use the static version below and freeze the
-   * whole graph at once. */
-  bool Freeze(Status* s);
-
-  /* Freezes the given set of handlers.  You may not freeze a handler without
-   * also freezing any handlers they point to. */
-  static bool Freeze(Handlers*const* handlers, int n, Status* s);
-  static bool Freeze(const std::vector<Handlers*>& handlers, Status* s);
-
   /* Returns the msgdef associated with this handlers object. */
-  const MessageDef* message_def() const;
+  MessageDefPtr message_def() const {
+    return MessageDefPtr(upb_handlers_msgdef(ptr()));
+  }
 
   /* Adds the given pointer and function to the list of cleanup functions that
    * will be run when these handlers are freed.  If this pointer has previously
    * been registered, the function returns false and does nothing. */
-  bool AddCleanup(void *ptr, upb_handlerfree *cleanup);
+  bool AddCleanup(void *ptr, upb_handlerfree *cleanup) {
+    return upb_handlers_addcleanup(ptr_, ptr, cleanup);
+  }
 
   /* Sets the startmsg handler for the message, which is defined as follows:
    *
@@ -324,7 +382,10 @@ class upb::Handlers {
    *     return true;
    *   }
    */
-  bool SetStartMessageHandler(const StartMessageHandler& handler);
+  bool SetStartMessageHandler(const StartMessageHandler &h) {
+    h.AddCleanup(ptr());
+    return upb_handlers_setstartmsg(ptr(), h.handler(), &h.attr());
+  }
 
   /* Sets the endmsg handler for the message, which is defined as follows:
    *
@@ -334,7 +395,10 @@ class upb::Handlers {
    *     // can also be modified in-place to update the final status.
    *   }
    */
-  bool SetEndMessageHandler(const EndMessageHandler& handler);
+  bool SetEndMessageHandler(const EndMessageHandler& h) {
+    h.AddCleanup(ptr());
+    return upb_handlers_setendmsg(ptr(), h.handler(), &h.attr());
+  }
 
   /* Sets the value handler for the given field, which is defined as follows
    * (this is for an int32 field; other field types will pass their native
@@ -356,13 +420,40 @@ class upb::Handlers {
    * Returns false if the handler failed to register; in this case the cleanup
    * handler (if any) will be called immediately.
    */
-  bool SetInt32Handler (const FieldDef* f,  const Int32Handler& h);
-  bool SetInt64Handler (const FieldDef* f,  const Int64Handler& h);
-  bool SetUInt32Handler(const FieldDef* f, const UInt32Handler& h);
-  bool SetUInt64Handler(const FieldDef* f, const UInt64Handler& h);
-  bool SetFloatHandler (const FieldDef* f,  const FloatHandler& h);
-  bool SetDoubleHandler(const FieldDef* f, const DoubleHandler& h);
-  bool SetBoolHandler  (const FieldDef* f,   const BoolHandler& h);
+  bool SetInt32Handler(FieldDefPtr f, const Int32Handler &h) {
+    h.AddCleanup(ptr());
+    return upb_handlers_setint32(ptr(), f.ptr(), h.handler(), &h.attr());
+  }
+
+  bool SetInt64Handler (FieldDefPtr f,  const Int64Handler& h) {
+    h.AddCleanup(ptr());
+    return upb_handlers_setint64(ptr(), f.ptr(), h.handler(), &h.attr());
+  }
+
+  bool SetUInt32Handler(FieldDefPtr f, const UInt32Handler& h) {
+    h.AddCleanup(ptr());
+    return upb_handlers_setuint32(ptr(), f.ptr(), h.handler(), &h.attr());
+  }
+
+  bool SetUInt64Handler(FieldDefPtr f, const UInt64Handler& h) {
+    h.AddCleanup(ptr());
+    return upb_handlers_setuint64(ptr(), f.ptr(), h.handler(), &h.attr());
+  }
+
+  bool SetFloatHandler (FieldDefPtr f,  const FloatHandler& h) {
+    h.AddCleanup(ptr());
+    return upb_handlers_setfloat(ptr(), f.ptr(), h.handler(), &h.attr());
+  }
+
+  bool SetDoubleHandler(FieldDefPtr f, const DoubleHandler& h) {
+    h.AddCleanup(ptr());
+    return upb_handlers_setdouble(ptr(), f.ptr(), h.handler(), &h.attr());
+  }
+
+  bool SetBoolHandler(FieldDefPtr f, const BoolHandler &h) {
+    h.AddCleanup(ptr());
+    return upb_handlers_setbool(ptr(), f.ptr(), h.handler(), &h.attr());
+  }
 
   /* Like the previous, but templated on the type on the value (ie. int32).
    * This is mostly useful to call from other templates.  To call this you must
@@ -370,8 +461,8 @@ class upb::Handlers {
    *   h->SetValueHandler<T>(f, UpbBind(MyHandler<T>, MyData)); */
   template <class T>
   bool SetValueHandler(
-      const FieldDef *f,
-      const typename ValueHandler<typename CanonicalType<T>::Type>::H& handler);
+      FieldDefPtr f,
+      const typename ValueHandler<typename CanonicalType<T>::Type>::H &handler);
 
   /* Sets handlers for a string field, which are defined as follows:
    *
@@ -409,9 +500,20 @@ class upb::Handlers {
    *     return true;
    *   }
    */
-  bool SetStartStringHandler(const FieldDef* f, const StartStringHandler& h);
-  bool SetStringHandler(const FieldDef* f, const StringHandler& h);
-  bool SetEndStringHandler(const FieldDef* f, const EndFieldHandler& h);
+  bool SetStartStringHandler(FieldDefPtr f, const StartStringHandler &h) {
+    h.AddCleanup(ptr());
+    return upb_handlers_setstartstr(ptr(), f.ptr(), h.handler(), &h.attr());
+  }
+
+  bool SetStringHandler(FieldDefPtr f, const StringHandler& h) {
+    h.AddCleanup(ptr());
+    return upb_handlers_setstring(ptr(), f.ptr(), h.handler(), &h.attr());
+  }
+
+  bool SetEndStringHandler(FieldDefPtr f, const EndFieldHandler& h) {
+    h.AddCleanup(ptr());
+    return upb_handlers_setendstr(ptr(), f.ptr(), h.handler(), &h.attr());
+  }
 
   /* Sets the startseq handler, which is defined as follows:
    *
@@ -427,7 +529,10 @@ class upb::Handlers {
    * Returns "false" if "f" does not belong to this message or is not a
    * repeated field.
    */
-  bool SetStartSequenceHandler(const FieldDef* f, const StartFieldHandler& h);
+  bool SetStartSequenceHandler(FieldDefPtr f, const StartFieldHandler &h) {
+    h.AddCleanup(ptr());
+    return upb_handlers_setstartseq(ptr(), f.ptr(), h.handler(), &h.attr());
+  }
 
   /* Sets the startsubmsg handler for the given field, which is defined as
    * follows:
@@ -444,7 +549,10 @@ class upb::Handlers {
    * Returns "false" if "f" does not belong to this message or is not a
    * submessage/group field.
    */
-  bool SetStartSubMessageHandler(const FieldDef* f, const StartFieldHandler& h);
+  bool SetStartSubMessageHandler(FieldDefPtr f, const StartFieldHandler& h) {
+    h.AddCleanup(ptr());
+    return upb_handlers_setstartsubmsg(ptr(), f.ptr(), h.handler(), &h.attr());
+  }
 
   /* Sets the endsubmsg handler for the given field, which is defined as
    * follows:
@@ -457,7 +565,10 @@ class upb::Handlers {
    * Returns "false" if "f" does not belong to this message or is not a
    * submessage/group field.
    */
-  bool SetEndSubMessageHandler(const FieldDef *f, const EndFieldHandler &h);
+  bool SetEndSubMessageHandler(FieldDefPtr f, const EndFieldHandler &h) {
+    h.AddCleanup(ptr());
+    return upb_handlers_setendsubmsg(ptr(), f.ptr(), h.handler(), &h.attr());
+  }
 
   /* Starts the endsubseq handler for the given field, which is defined as
    * follows:
@@ -470,315 +581,102 @@ class upb::Handlers {
    * Returns "false" if "f" does not belong to this message or is not a
    * repeated field.
    */
-  bool SetEndSequenceHandler(const FieldDef* f, const EndFieldHandler& h);
-
-  /* Sets or gets the object that specifies handlers for the given field, which
-   * must be a submessage or group.  Returns NULL if no handlers are set. */
-  bool SetSubHandlers(const FieldDef* f, const Handlers* sub);
-  const Handlers* GetSubHandlers(const FieldDef* f) const;
-
-  /* Equivalent to GetSubHandlers, but takes the STARTSUBMSG selector for the
-   * field. */
-  const Handlers* GetSubHandlers(Selector startsubmsg) const;
-
-  /* A selector refers to a specific field handler in the Handlers object
-   * (for example: the STARTSUBMSG handler for field "field15").
-   * On success, returns true and stores the selector in "s".
-   * If the FieldDef or Type are invalid, returns false.
-   * The returned selector is ONLY valid for Handlers whose MessageDef
-   * contains this FieldDef. */
-  static bool GetSelector(const FieldDef* f, Type type, Selector* s);
-
-  /* Given a START selector of any kind, returns the corresponding END selector. */
-  static Selector GetEndSelector(Selector start_selector);
-
-  /* Returns the function pointer for this handler.  It is the client's
-   * responsibility to cast to the correct function type before calling it. */
-  GenericFunction* GetHandler(Selector selector);
-
-  /* Sets the given attributes to the attributes for this selector. */
-  bool GetAttributes(Selector selector, HandlerAttributes* attr);
-
-  /* Returns the handler data that was registered with this handler. */
-  const void* GetHandlerData(Selector selector);
-
-  /* Could add any of the following functions as-needed, with some minor
-   * implementation changes:
-   *
-   * const FieldDef* GetFieldDef(Selector selector);
-   * static bool IsSequence(Selector selector); */
+  bool SetEndSequenceHandler(FieldDefPtr f, const EndFieldHandler &h) {
+    h.AddCleanup(ptr());
+    return upb_handlers_setendseq(ptr(), f.ptr(), h.handler(), &h.attr());
+  }
 
  private:
-  UPB_DISALLOW_POD_OPS(Handlers, upb::Handlers)
-
-  friend UPB_INLINE GenericFunction *::upb_handlers_gethandler(
-      const upb_handlers *h, upb_selector_t s);
-  friend UPB_INLINE const void *::upb_handlers_gethandlerdata(
-      const upb_handlers *h, upb_selector_t s);
-#else
-struct upb_handlers {
-#endif
-  upb_refcounted base;
-
-  const upb_msgdef *msg;
-  const upb_handlers **sub;
-  const void *top_closure_type;
-  upb_inttable cleanup_;
-  upb_status status_;  /* Used only when mutable. */
-  upb_handlers_tabent table[1];  /* Dynamically-sized field handler array. */
+  upb_handlers* ptr_;
 };
 
-#ifdef __cplusplus
-
-namespace upb {
-
-/* Convenience macros for creating a Handler object that is wrapped with a
- * type-safe wrapper function that converts the "void*" parameters/returns
- * of the underlying C API into nice C++ function.
- *
- * Sample usage:
- *   void OnValue1(MyClosure* c, const MyHandlerData* d, int32_t val) {
- *     // do stuff ...
- *   }
- *
- *   // Handler that doesn't need any data bound to it.
- *   void OnValue2(MyClosure* c, int32_t val) {
- *     // do stuff ...
- *   }
- *
- *   // Handler that returns bool so it can return failure if necessary.
- *   bool OnValue3(MyClosure* c, int32_t val) {
- *     // do stuff ...
- *     return ok;
- *   }
- *
- *   // Member function handler.
- *   class MyClosure {
- *    public:
- *     void OnValue(int32_t val) {
- *       // do stuff ...
- *     }
- *   };
- *
- *   // Takes ownership of the MyHandlerData.
- *   handlers->SetInt32Handler(f1, UpbBind(OnValue1, new MyHandlerData(...)));
- *   handlers->SetInt32Handler(f2, UpbMakeHandler(OnValue2));
- *   handlers->SetInt32Handler(f1, UpbMakeHandler(OnValue3));
- *   handlers->SetInt32Handler(f2, UpbMakeHandler(&MyClosure::OnValue));
- */
-
-#ifdef UPB_CXX11
-
-/* In C++11, the "template" disambiguator can appear even outside templates,
- * so all calls can safely use this pair of macros. */
-
-#define UpbMakeHandler(f) upb::MatchFunc(f).template GetFunc<f>()
-
-/* We have to be careful to only evaluate "d" once. */
-#define UpbBind(f, d) upb::MatchFunc(f).template GetFunc<f>((d))
+#endif  /* __cplusplus */
 
-#else
+/* upb_handlercache ***********************************************************/
 
-/* Prior to C++11, the "template" disambiguator may only appear inside a
- * template, so the regular macro must not use "template" */
+/* A upb_handlercache lazily builds and caches upb_handlers.  You pass it a
+ * function (with optional closure) that can build handlers for a given
+ * message on-demand, and the cache maintains a map of msgdef->handlers. */
 
-#define UpbMakeHandler(f) upb::MatchFunc(f).GetFunc<f>()
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-#define UpbBind(f, d) upb::MatchFunc(f).GetFunc<f>((d))
+struct upb_handlercache;
+typedef struct upb_handlercache upb_handlercache;
 
-#endif  /* UPB_CXX11 */
+typedef void upb_handlers_callback(const void *closure, upb_handlers *h);
 
-/* This macro must be used in C++98 for calls from inside a template.  But we
- * define this variant in all cases; code that wants to be compatible with both
- * C++98 and C++11 should always use this macro when calling from a template. */
-#define UpbMakeHandlerT(f) upb::MatchFunc(f).template GetFunc<f>()
+upb_handlercache *upb_handlercache_new(upb_handlers_callback *callback,
+                                       const void *closure);
+void upb_handlercache_free(upb_handlercache *cache);
+const upb_handlers *upb_handlercache_get(upb_handlercache *cache,
+                                         const upb_msgdef *md);
+bool upb_handlercache_addcleanup(upb_handlercache *h, void *p,
+                                 upb_handlerfree *hfree);
 
-/* We have to be careful to only evaluate "d" once. */
-#define UpbBindT(f, d) upb::MatchFunc(f).template GetFunc<f>((d))
+#ifdef __cplusplus
+}  /* extern "C" */
 
-/* Handler: a struct that contains the (handler, data, deleter) tuple that is
- * used to register all handlers.  Users can Make() these directly but it's
- * more convenient to use the UpbMakeHandler/UpbBind macros above. */
-template <class T> class Handler {
+class upb::HandlerCache {
  public:
-  /* The underlying, handler function signature that upb uses internally. */
-  typedef T FuncPtr;
+  HandlerCache(upb_handlers_callback *callback, const void *closure)
+      : ptr_(upb_handlercache_new(callback, closure), upb_handlercache_free) {}
+  HandlerCache(HandlerCache&&) = default;
+  HandlerCache& operator=(HandlerCache&&) = default;
+  HandlerCache(upb_handlercache* c) : ptr_(c, upb_handlercache_free) {}
 
-  /* Intentionally implicit. */
-  template <class F> Handler(F func);
-  ~Handler();
+  upb_handlercache* ptr() { return ptr_.get(); }
 
- private:
-  void AddCleanup(Handlers* h) const {
-    if (cleanup_func_) {
-      bool ok = h->AddCleanup(cleanup_data_, cleanup_func_);
-      UPB_ASSERT(ok);
-    }
+  const upb_handlers *Get(MessageDefPtr md) {
+    return upb_handlercache_get(ptr_.get(), md.ptr());
   }
 
-  UPB_DISALLOW_COPY_AND_ASSIGN(Handler)
-  friend class Handlers;
-  FuncPtr handler_;
-  mutable HandlerAttributes attr_;
-  mutable bool registered_;
-  void *cleanup_data_;
-  upb_handlerfree *cleanup_func_;
+ private:
+  std::unique_ptr<upb_handlercache, decltype(&upb_handlercache_free)> ptr_;
 };
 
-}  /* namespace upb */
-
 #endif  /* __cplusplus */
 
-UPB_BEGIN_EXTERN_C
-
-/* Native C API. */
-
-/* Handler function typedefs. */
-typedef bool upb_unknown_handlerfunc(void *c, const void *hd, const char *buf,
-                                     size_t n);
-typedef bool upb_startmsg_handlerfunc(void *c, const void*);
-typedef bool upb_endmsg_handlerfunc(void *c, const void *, upb_status *status);
-typedef void* upb_startfield_handlerfunc(void *c, const void *hd);
-typedef bool upb_endfield_handlerfunc(void *c, const void *hd);
-typedef bool upb_int32_handlerfunc(void *c, const void *hd, int32_t val);
-typedef bool upb_int64_handlerfunc(void *c, const void *hd, int64_t val);
-typedef bool upb_uint32_handlerfunc(void *c, const void *hd, uint32_t val);
-typedef bool upb_uint64_handlerfunc(void *c, const void *hd, uint64_t val);
-typedef bool upb_float_handlerfunc(void *c, const void *hd, float val);
-typedef bool upb_double_handlerfunc(void *c, const void *hd, double val);
-typedef bool upb_bool_handlerfunc(void *c, const void *hd, bool val);
-typedef void *upb_startstr_handlerfunc(void *c, const void *hd,
-                                       size_t size_hint);
-typedef size_t upb_string_handlerfunc(void *c, const void *hd, const char *buf,
-                                      size_t n, const upb_bufhandle* handle);
-
-/* upb_bufhandle */
-size_t upb_bufhandle_objofs(const upb_bufhandle *h);
-
-/* upb_handlerattr */
-void upb_handlerattr_init(upb_handlerattr *attr);
-void upb_handlerattr_uninit(upb_handlerattr *attr);
-
-bool upb_handlerattr_sethandlerdata(upb_handlerattr *attr, const void *hd);
-bool upb_handlerattr_setclosuretype(upb_handlerattr *attr, const void *type);
-const void *upb_handlerattr_closuretype(const upb_handlerattr *attr);
-bool upb_handlerattr_setreturnclosuretype(upb_handlerattr *attr,
-                                          const void *type);
-const void *upb_handlerattr_returnclosuretype(const upb_handlerattr *attr);
-bool upb_handlerattr_setalwaysok(upb_handlerattr *attr, bool alwaysok);
-bool upb_handlerattr_alwaysok(const upb_handlerattr *attr);
-
-UPB_INLINE const void *upb_handlerattr_handlerdata(
-    const upb_handlerattr *attr) {
-  return attr->handler_data_;
-}
+/* upb_byteshandler ***********************************************************/
 
-/* upb_handlers */
-typedef void upb_handlers_callback(const void *closure, upb_handlers *h);
-upb_handlers *upb_handlers_new(const upb_msgdef *m,
-                               const void *owner);
-const upb_handlers *upb_handlers_newfrozen(const upb_msgdef *m,
-                                           const void *owner,
-                                           upb_handlers_callback *callback,
-                                           const void *closure);
-
-/* Include refcounted methods like upb_handlers_ref(). */
-UPB_REFCOUNTED_CMETHODS(upb_handlers, upb_handlers_upcast)
-
-const upb_status *upb_handlers_status(upb_handlers *h);
-void upb_handlers_clearerr(upb_handlers *h);
-const upb_msgdef *upb_handlers_msgdef(const upb_handlers *h);
-bool upb_handlers_addcleanup(upb_handlers *h, void *p, upb_handlerfree *hfree);
-bool upb_handlers_setunknown(upb_handlers *h, upb_unknown_handlerfunc *func,
-                             upb_handlerattr *attr);
+typedef struct {
+  upb_func *func;
 
-bool upb_handlers_setstartmsg(upb_handlers *h, upb_startmsg_handlerfunc *func,
-                              upb_handlerattr *attr);
-bool upb_handlers_setendmsg(upb_handlers *h, upb_endmsg_handlerfunc *func,
-                            upb_handlerattr *attr);
-bool upb_handlers_setint32(upb_handlers *h, const upb_fielddef *f,
-                           upb_int32_handlerfunc *func, upb_handlerattr *attr);
-bool upb_handlers_setint64(upb_handlers *h, const upb_fielddef *f,
-                           upb_int64_handlerfunc *func, upb_handlerattr *attr);
-bool upb_handlers_setuint32(upb_handlers *h, const upb_fielddef *f,
-                            upb_uint32_handlerfunc *func,
-                            upb_handlerattr *attr);
-bool upb_handlers_setuint64(upb_handlers *h, const upb_fielddef *f,
-                            upb_uint64_handlerfunc *func,
-                            upb_handlerattr *attr);
-bool upb_handlers_setfloat(upb_handlers *h, const upb_fielddef *f,
-                           upb_float_handlerfunc *func, upb_handlerattr *attr);
-bool upb_handlers_setdouble(upb_handlers *h, const upb_fielddef *f,
-                            upb_double_handlerfunc *func,
-                            upb_handlerattr *attr);
-bool upb_handlers_setbool(upb_handlers *h, const upb_fielddef *f,
-                          upb_bool_handlerfunc *func,
-                          upb_handlerattr *attr);
-bool upb_handlers_setstartstr(upb_handlers *h, const upb_fielddef *f,
-                              upb_startstr_handlerfunc *func,
-                              upb_handlerattr *attr);
-bool upb_handlers_setstring(upb_handlers *h, const upb_fielddef *f,
-                            upb_string_handlerfunc *func,
-                            upb_handlerattr *attr);
-bool upb_handlers_setendstr(upb_handlers *h, const upb_fielddef *f,
-                            upb_endfield_handlerfunc *func,
-                            upb_handlerattr *attr);
-bool upb_handlers_setstartseq(upb_handlers *h, const upb_fielddef *f,
-                              upb_startfield_handlerfunc *func,
-                              upb_handlerattr *attr);
-bool upb_handlers_setstartsubmsg(upb_handlers *h, const upb_fielddef *f,
-                                 upb_startfield_handlerfunc *func,
-                                 upb_handlerattr *attr);
-bool upb_handlers_setendsubmsg(upb_handlers *h, const upb_fielddef *f,
-                               upb_endfield_handlerfunc *func,
-                               upb_handlerattr *attr);
-bool upb_handlers_setendseq(upb_handlers *h, const upb_fielddef *f,
-                            upb_endfield_handlerfunc *func,
-                            upb_handlerattr *attr);
+  /* It is wasteful to include the entire attributes here:
+   *
+   * * Some of the information is redundant (like storing the closure type
+   *   separately for each handler that must match).
+   * * Some of the info is only needed prior to freeze() (like closure types).
+   * * alignment padding wastes a lot of space for alwaysok_.
+   *
+   * If/when the size and locality of handlers is an issue, we can optimize this
+   * not to store the entire attr like this.  We do not expose the table's
+   * layout to allow this optimization in the future. */
+  upb_handlerattr attr;
+} upb_handlers_tabent;
 
-bool upb_handlers_setsubhandlers(upb_handlers *h, const upb_fielddef *f,
-                                 const upb_handlers *sub);
-const upb_handlers *upb_handlers_getsubhandlers(const upb_handlers *h,
-                                                const upb_fielddef *f);
-const upb_handlers *upb_handlers_getsubhandlers_sel(const upb_handlers *h,
-                                                    upb_selector_t sel);
+#define UPB_TABENT_INIT {NULL, UPB_HANDLERATTR_INIT}
 
-UPB_INLINE upb_func *upb_handlers_gethandler(const upb_handlers *h,
-                                             upb_selector_t s) {
-  return (upb_func *)h->table[s].func;
-}
+typedef struct {
+  upb_handlers_tabent table[3];
+} upb_byteshandler;
 
-bool upb_handlers_getattr(const upb_handlers *h, upb_selector_t s,
-                          upb_handlerattr *attr);
+#define UPB_BYTESHANDLER_INIT                             \
+  {                                                       \
+    { UPB_TABENT_INIT, UPB_TABENT_INIT, UPB_TABENT_INIT } \
+  }
 
-UPB_INLINE const void *upb_handlers_gethandlerdata(const upb_handlers *h,
-                                                   upb_selector_t s) {
-  return upb_handlerattr_handlerdata(&h->table[s].attr);
+UPB_INLINE void upb_byteshandler_init(upb_byteshandler *handler) {
+  upb_byteshandler init = UPB_BYTESHANDLER_INIT;
+  *handler = init;
 }
 
 #ifdef __cplusplus
-
-/* Handler types for single fields.
- * Right now we only have one for TYPE_BYTES but ones for other types
- * should follow.
- *
- * These follow the same handlers protocol for fields of a message. */
-class upb::BytesHandler {
- public:
-  BytesHandler();
-  ~BytesHandler();
-#else
-struct upb_byteshandler {
+extern "C" {
 #endif
-  upb_handlers_tabent table[3];
-};
 
-void upb_byteshandler_init(upb_byteshandler *h);
-
-/* Caller must ensure that "d" outlives the handlers.
- * TODO(haberman): should this have a "freeze" operation?  It's not necessary
- * for memory management, but could be useful to force immutability and provide
- * a convenient moment to verify that all registration succeeded. */
+/* Caller must ensure that "d" outlives the handlers. */
 bool upb_byteshandler_setstartstr(upb_byteshandler *h,
                                   upb_startstr_handlerfunc *func, void *d);
 bool upb_byteshandler_setstring(upb_byteshandler *h,
@@ -786,22 +684,20 @@ bool upb_byteshandler_setstring(upb_byteshandler *h,
 bool upb_byteshandler_setendstr(upb_byteshandler *h,
                                 upb_endfield_handlerfunc *func, void *d);
 
-/* "Static" methods */
-bool upb_handlers_freeze(upb_handlers *const *handlers, int n, upb_status *s);
-upb_handlertype_t upb_handlers_getprimitivehandlertype(const upb_fielddef *f);
-bool upb_handlers_getselector(const upb_fielddef *f, upb_handlertype_t type,
-                              upb_selector_t *s);
-UPB_INLINE upb_selector_t upb_handlers_getendselector(upb_selector_t start) {
-  return start + 1;
-}
-
-/* Internal-only. */
-uint32_t upb_handlers_selectorbaseoffset(const upb_fielddef *f);
-uint32_t upb_handlers_selectorcount(const upb_fielddef *f);
+#ifdef __cplusplus
+}  /* extern "C" */
 
+namespace upb {
+typedef upb_byteshandler BytesHandler;
+}
+#endif
 
 /** Message handlers ******************************************************************/
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* These are the handlers used internally by upb_msgfactory_getmergehandlers().
  * They write scalar data to a known offset from the message pointer.
  *
@@ -827,7 +723,9 @@ bool upb_msg_getscalarhandlerdata(const upb_handlers *h,
 
 
 
-UPB_END_EXTERN_C
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
 
 #include "upb/handlers-inl.h"
 
diff --git a/upb/json/parser.c b/upb/json/parser.c
index 42539ee..db7f14f 100644
--- a/upb/json/parser.c
+++ b/upb/json/parser.c
@@ -21,6 +21,7 @@
 ** - handling of keys/escape-sequences/etc that span input buffers.
 */
 
+#include <ctype.h>
 #include <errno.h>
 #include <float.h>
 #include <math.h>
@@ -29,10 +30,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-/* Need to define __USE_XOPEN before including time.h to make strptime work. */
-#ifndef __USE_XOPEN
-#define __USE_XOPEN
-#endif
 #include <time.h>
 
 #include "upb/json/parser.h"
@@ -63,7 +60,6 @@ static bool is_string_wrapper_object(upb_json_parser *p);
 static bool does_string_wrapper_start(upb_json_parser *p);
 static bool does_string_wrapper_end(upb_json_parser *p);
 
-static bool is_fieldmask_object(upb_json_parser *p);
 static bool does_fieldmask_start(upb_json_parser *p);
 static bool does_fieldmask_end(upb_json_parser *p);
 static void start_fieldmask_object(upb_json_parser *p);
@@ -160,14 +156,13 @@ void upb_stringsink_uninit(upb_stringsink *sink) { free(sink->ptr); }
 
 typedef struct {
   /* For encoding Any value field in binary format. */
-  const upb_handlers *encoder_handlers;
-  upb_pb_encoder *encoder;
+  upb_handlercache *encoder_handlercache;
   upb_stringsink stringsink;
 
   /* For decoding Any value field in json format. */
-  upb_json_parsermethod *parser_method;
-  upb_json_parser* parser;
+  upb_json_codecache *parser_codecache;
   upb_sink sink;
+  upb_json_parser *parser;
 
   /* Mark the range of uninterpreted values in json input before type url. */
   const char *before_type_url_start;
@@ -186,7 +181,12 @@ typedef struct {
   const upb_fielddef *f;
 
   /* The table mapping json name to fielddef for this message. */
-  upb_strtable *name_table;
+  const upb_strtable *name_table;
+
+  /* We are in a repeated-field context. We need this flag to decide whether to
+   * handle the array as a normal repeated field or a
+   * google.protobuf.ListValue/google.protobuf.Value. */
+  bool is_repeated;
 
   /* We are in a repeated-field context, ready to emit mapentries as
    * submessages. This flag alters the start-of-object (open-brace) behavior to
@@ -218,8 +218,21 @@ typedef struct {
   bool is_unknown_field;
 } upb_jsonparser_frame;
 
+static void init_frame(upb_jsonparser_frame* frame) {
+  frame->m = NULL;
+  frame->f = NULL;
+  frame->name_table = NULL;
+  frame->is_repeated = false;
+  frame->is_map = false;
+  frame->is_mapentry = false;
+  frame->mapfield = NULL;
+  frame->is_any = false;
+  frame->any_frame = NULL;
+  frame->is_unknown_field = false;
+}
+
 struct upb_json_parser {
-  upb_env *env;
+  upb_arena *arena;
   const upb_json_parsermethod *method;
   upb_bytessink input_;
 
@@ -228,7 +241,7 @@ struct upb_json_parser {
   upb_jsonparser_frame *top;
   upb_jsonparser_frame *limit;
 
-  upb_status status;
+  upb_status *status;
 
   /* Ragel's internal parsing stack for the parsing state machine. */
   int current_state;
@@ -265,64 +278,75 @@ struct upb_json_parser {
   struct tm tm;
 };
 
-struct upb_json_parsermethod {
-  upb_refcounted base;
+static upb_jsonparser_frame* start_jsonparser_frame(upb_json_parser *p) {
+  upb_jsonparser_frame *inner;
+  inner = p->top + 1;
+  init_frame(inner);
+  return inner;
+}
 
-  upb_byteshandler input_handler_;
+struct upb_json_codecache {
+  upb_arena *arena;
+  upb_inttable methods;   /* upb_msgdef* -> upb_json_parsermethod* */
+};
 
-  /* Mainly for the purposes of refcounting, so all the fielddefs we point
-   * to stay alive. */
-  const upb_msgdef *msg;
+struct upb_json_parsermethod {
+  const upb_json_codecache *cache;
+  upb_byteshandler input_handler_;
 
-  /* Keys are upb_msgdef*, values are upb_strtable (json_name -> fielddef) */
-  upb_inttable name_tables;
+  /* Maps json_name -> fielddef */
+  upb_strtable name_table;
 };
 
 #define PARSER_CHECK_RETURN(x) if (!(x)) return false
 
-static void json_parser_any_frame_reset(upb_jsonparser_any_frame *frame) {
-  frame->encoder_handlers = NULL;
-  frame->encoder = NULL;
-  frame->parser_method = NULL;
+static upb_jsonparser_any_frame *json_parser_any_frame_new(
+    upb_json_parser *p) {
+  upb_jsonparser_any_frame *frame;
+
+  frame = upb_arena_malloc(p->arena, sizeof(upb_jsonparser_any_frame));
+
+  frame->encoder_handlercache = upb_pb_encoder_newcache();
+  frame->parser_codecache = upb_json_codecache_new();
   frame->parser = NULL;
   frame->before_type_url_start = NULL;
   frame->before_type_url_end = NULL;
   frame->after_type_url_start = NULL;
+
+  upb_stringsink_init(&frame->stringsink);
+
+  return frame;
 }
 
 static void json_parser_any_frame_set_payload_type(
     upb_json_parser *p,
     upb_jsonparser_any_frame *frame,
     const upb_msgdef *payload_type) {
+  const upb_handlers *h;
+  const upb_json_parsermethod *parser_method;
+  upb_pb_encoder *encoder;
+
   /* Initialize encoder. */
-  frame->encoder_handlers =
-      upb_pb_encoder_newhandlers(payload_type, &frame->encoder_handlers);
-  upb_stringsink_init(&frame->stringsink);
-  frame->encoder =
-      upb_pb_encoder_create(
-          p->env, frame->encoder_handlers,
-          &frame->stringsink.sink);
+  h = upb_handlercache_get(frame->encoder_handlercache, payload_type);
+  encoder = upb_pb_encoder_create(p->arena, h, frame->stringsink.sink);
 
   /* Initialize parser. */
-  frame->parser_method =
-      upb_json_parsermethod_new(payload_type, &frame->parser_method);
-  upb_sink_reset(&frame->sink, frame->encoder_handlers, frame->encoder);
+  parser_method = upb_json_codecache_get(frame->parser_codecache, payload_type);
+  upb_sink_reset(&frame->sink, h, encoder);
   frame->parser =
-      upb_json_parser_create(p->env, frame->parser_method, p->symtab,
-                             &frame->sink, p->ignore_json_unknown);
+      upb_json_parser_create(p->arena, parser_method, p->symtab, frame->sink,
+                             p->status, p->ignore_json_unknown);
 }
 
 static void json_parser_any_frame_free(upb_jsonparser_any_frame *frame) {
-  upb_handlers_unref(frame->encoder_handlers,
-                     &frame->encoder_handlers);
-  upb_json_parsermethod_unref(frame->parser_method,
-                              &frame->parser_method);
+  upb_handlercache_free(frame->encoder_handlercache);
+  upb_json_codecache_free(frame->parser_codecache);
   upb_stringsink_uninit(&frame->stringsink);
 }
 
 static bool json_parser_any_frame_has_type_url(
   upb_jsonparser_any_frame *frame) {
-  return frame->encoder != NULL;
+  return frame->parser != NULL;
 }
 
 static bool json_parser_any_frame_has_value_before_type_url(
@@ -344,7 +368,7 @@ static bool json_parser_any_frame_has_value(
 static void json_parser_any_frame_set_before_type_url_end(
     upb_jsonparser_any_frame *frame,
     const char *ptr) {
-  if (frame->encoder == NULL) {
+  if (frame->parser == NULL) {
     frame->before_type_url_end = ptr;
   }
 }
@@ -376,8 +400,7 @@ static upb_selector_t parser_getsel(upb_json_parser *p) {
 
 static bool check_stack(upb_json_parser *p) {
   if ((p->top + 1) == p->limit) {
-    upb_status_seterrmsg(&p->status, "Nesting too deep");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "Nesting too deep");
     return false;
   }
 
@@ -386,9 +409,15 @@ static bool check_stack(upb_json_parser *p) {
 
 static void set_name_table(upb_json_parser *p, upb_jsonparser_frame *frame) {
   upb_value v;
-  bool ok = upb_inttable_lookupptr(&p->method->name_tables, frame->m, &v);
+  const upb_json_codecache *cache = p->method->cache;
+  bool ok;
+  const upb_json_parsermethod *method;
+
+  ok = upb_inttable_lookupptr(&cache->methods, frame->m, &v);
   UPB_ASSERT(ok);
-  frame->name_table = upb_value_getptr(v);
+  method = upb_value_getconstptr(v);
+
+  frame->name_table = &method->name_table;
 }
 
 /* There are GCC/Clang built-ins for overflow checking which we could start
@@ -466,10 +495,9 @@ static bool base64_push(upb_json_parser *p, upb_selector_t sel, const char *ptr,
     char output[3];
 
     if (limit - ptr < 4) {
-      upb_status_seterrf(&p->status,
+      upb_status_seterrf(p->status,
                          "Base64 input for bytes field not a multiple of 4: %s",
                          upb_fielddef_name(p->top->f));
-      upb_env_reporterror(p->env, &p->status);
       return false;
     }
 
@@ -486,17 +514,16 @@ static bool base64_push(upb_json_parser *p, upb_selector_t sel, const char *ptr,
     output[0] = val >> 16;
     output[1] = (val >> 8) & 0xff;
     output[2] = val & 0xff;
-    upb_sink_putstring(&p->top->sink, sel, output, 3, NULL);
+    upb_sink_putstring(p->top->sink, sel, output, 3, NULL);
   }
   return true;
 
 otherchar:
   if (nonbase64(ptr[0]) || nonbase64(ptr[1]) || nonbase64(ptr[2]) ||
       nonbase64(ptr[3]) ) {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
                        "Non-base64 characters in bytes field: %s",
                        upb_fielddef_name(p->top->f));
-    upb_env_reporterror(p->env, &p->status);
     return false;
   } if (ptr[2] == '=') {
     uint32_t val;
@@ -512,7 +539,7 @@ otherchar:
 
     UPB_ASSERT(!(val & 0x80000000));
     output = val >> 16;
-    upb_sink_putstring(&p->top->sink, sel, &output, 1, NULL);
+    upb_sink_putstring(p->top->sink, sel, &output, 1, NULL);
     return true;
   } else {
     uint32_t val;
@@ -529,16 +556,15 @@ otherchar:
 
     output[0] = val >> 16;
     output[1] = (val >> 8) & 0xff;
-    upb_sink_putstring(&p->top->sink, sel, output, 2, NULL);
+    upb_sink_putstring(p->top->sink, sel, output, 2, NULL);
     return true;
   }
 
 badpadding:
-  upb_status_seterrf(&p->status,
+  upb_status_seterrf(p->status,
                      "Incorrect base64 padding for field: %s (%.*s)",
                      upb_fielddef_name(p->top->f),
                      4, ptr);
-  upb_env_reporterror(p->env, &p->status);
   return false;
 }
 
@@ -582,10 +608,9 @@ static bool accumulate_realloc(upb_json_parser *p, size_t need) {
     new_size = saturating_multiply(new_size, 2);
   }
 
-  mem = upb_env_realloc(p->env, p->accumulate_buf, old_size, new_size);
+  mem = upb_arena_realloc(p->arena, p->accumulate_buf, old_size, new_size);
   if (!mem) {
-    upb_status_seterrmsg(&p->status, "Out of memory allocating buffer.");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "Out of memory allocating buffer.");
     return false;
   }
 
@@ -608,8 +633,7 @@ static bool accumulate_append(upb_json_parser *p, const char *buf, size_t len,
   }
 
   if (!checked_add(p->accumulated_len, len, &need)) {
-    upb_status_seterrmsg(&p->status, "Integer overflow.");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "Integer overflow.");
     return false;
   }
 
@@ -687,8 +711,7 @@ static bool multipart_text(upb_json_parser *p, const char *buf, size_t len,
   switch (p->multipart_state) {
     case MULTIPART_INACTIVE:
       upb_status_seterrmsg(
-          &p->status, "Internal error: unexpected state MULTIPART_INACTIVE");
-      upb_env_reporterror(p->env, &p->status);
+          p->status, "Internal error: unexpected state MULTIPART_INACTIVE");
       return false;
 
     case MULTIPART_ACCUMULATE:
@@ -699,7 +722,7 @@ static bool multipart_text(upb_json_parser *p, const char *buf, size_t len,
 
     case MULTIPART_PUSHEAGERLY: {
       const upb_bufhandle *handle = can_alias ? p->handle : NULL;
-      upb_sink_putstring(&p->top->sink, p->string_selector, buf, len, handle);
+      upb_sink_putstring(p->top->sink, p->string_selector, buf, len, handle);
       break;
     }
   }
@@ -945,7 +968,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
       } else if (val > INT32_MAX || val < INT32_MIN) {
         return false;
       } else {
-        upb_sink_putint32(&p->top->sink, parser_getsel(p), val);
+        upb_sink_putint32(p->top->sink, parser_getsel(p), val);
         return true;
       }
     }
@@ -956,7 +979,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
       } else if (val > UINT32_MAX || errno == ERANGE) {
         return false;
       } else {
-        upb_sink_putuint32(&p->top->sink, parser_getsel(p), val);
+        upb_sink_putuint32(p->top->sink, parser_getsel(p), val);
         return true;
       }
     }
@@ -967,7 +990,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
       if (errno == ERANGE || end != bufend) {
         break;
       } else {
-        upb_sink_putint64(&p->top->sink, parser_getsel(p), val);
+        upb_sink_putint64(p->top->sink, parser_getsel(p), val);
         return true;
       }
     }
@@ -978,7 +1001,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
       } else if (errno == ERANGE) {
         return false;
       } else {
-        upb_sink_putuint64(&p->top->sink, parser_getsel(p), val);
+        upb_sink_putuint64(p->top->sink, parser_getsel(p), val);
         return true;
       }
     }
@@ -1009,7 +1032,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
       if (modf(val, &dummy) != 0 || val > max || val < min) {             \
         return false;                                                     \
       } else {                                                            \
-        upb_sink_put ## smalltype(&p->top->sink, parser_getsel(p),        \
+        upb_sink_put ## smalltype(p->top->sink, parser_getsel(p),        \
                                   (ctype)val);                            \
         return true;                                                      \
       }                                                                   \
@@ -1023,13 +1046,13 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
 #undef CASE
 
     case UPB_TYPE_DOUBLE:
-      upb_sink_putdouble(&p->top->sink, parser_getsel(p), val);
+      upb_sink_putdouble(p->top->sink, parser_getsel(p), val);
       return true;
     case UPB_TYPE_FLOAT:
       if ((val > FLT_MAX || val < -FLT_MAX) && val != inf && val != -inf) {
         return false;
       } else {
-        upb_sink_putfloat(&p->top->sink, parser_getsel(p), val);
+        upb_sink_putfloat(p->top->sink, parser_getsel(p), val);
         return true;
       }
     default:
@@ -1053,8 +1076,7 @@ static bool parse_number(upb_json_parser *p, bool is_quoted) {
     multipart_end(p);
     return true;
   } else {
-    upb_status_seterrf(&p->status, "error parsing number: %s", buf);
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrf(p->status, "error parsing number: %s", buf);
     multipart_end(p);
     return false;
   }
@@ -1068,14 +1090,13 @@ static bool parser_putbool(upb_json_parser *p, bool val) {
   }
 
   if (upb_fielddef_type(p->top->f) != UPB_TYPE_BOOL) {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
                        "Boolean value specified for non-bool field: %s",
                        upb_fielddef_name(p->top->f));
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
-  ok = upb_sink_putbool(&p->top->sink, parser_getsel(p), val);
+  ok = upb_sink_putbool(p->top->sink, parser_getsel(p), val);
   UPB_ASSERT(ok);
 
   return true;
@@ -1222,17 +1243,11 @@ static bool start_stringval(upb_json_parser *p) {
 
     /* Start a new parser frame: parser frames correspond one-to-one with
      * handler frames, and string events occur in a sub-frame. */
-    inner = p->top + 1;
+    inner = start_jsonparser_frame(p);
     sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
-    upb_sink_startstr(&p->top->sink, sel, 0, &inner->sink);
+    upb_sink_startstr(p->top->sink, sel, 0, &inner->sink);
     inner->m = p->top->m;
     inner->f = p->top->f;
-    inner->name_table = NULL;
-    inner->is_map = false;
-    inner->is_mapentry = false;
-    inner->is_any = false;
-    inner->any_frame = NULL;
-    inner->is_unknown_field = false;
     p->top = inner;
 
     if (upb_fielddef_type(p->top->f) == UPB_TYPE_STRING) {
@@ -1255,10 +1270,9 @@ static bool start_stringval(upb_json_parser *p) {
     multipart_startaccum(p);
     return true;
   } else {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
                        "String specified for bool or submessage field: %s",
                        upb_fielddef_name(p->top->f));
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 }
@@ -1274,11 +1288,11 @@ static bool end_any_stringval(upb_json_parser *p) {
   inner = p->top + 1;
 
   sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
-  upb_sink_startstr(&p->top->sink, sel, 0, &inner->sink);
+  upb_sink_startstr(p->top->sink, sel, 0, &inner->sink);
   sel = getsel_for_handlertype(p, UPB_HANDLER_STRING);
-  upb_sink_putstring(&inner->sink, sel, buf, len, NULL);
+  upb_sink_putstring(inner->sink, sel, buf, len, NULL);
   sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
-  upb_sink_endstr(&inner->sink, sel);
+  upb_sink_endstr(inner->sink, sel);
 
   multipart_end(p);
 
@@ -1291,18 +1305,16 @@ static bool end_any_stringval(upb_json_parser *p) {
     payload_type = upb_symtab_lookupmsg2(p->symtab, buf, len);
     if (payload_type == NULL) {
       upb_status_seterrf(
-          &p->status, "Cannot find packed type: %.*s\n", (int)len, buf);
-      upb_env_reporterror(p->env, &p->status);
+          p->status, "Cannot find packed type: %.*s\n", (int)len, buf);
       return false;
     }
 
     json_parser_any_frame_set_payload_type(p, p->top->any_frame, payload_type);
-    
+
     return true;
   } else {
     upb_status_seterrf(
-        &p->status, "Invalid type url: %.*s\n", (int)len, buf);
-    upb_env_reporterror(p->env, &p->status);
+        p->status, "Invalid type url: %.*s\n", (int)len, buf);
     return false;
   }
 }
@@ -1335,15 +1347,14 @@ static bool end_stringval_nontop(upb_json_parser *p) {
 
     case UPB_TYPE_STRING: {
       upb_selector_t sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
-      upb_sink_endstr(&p->top->sink, sel);
+      upb_sink_endstr(p->top->sink, sel);
       p->top--;
       break;
     }
 
     case UPB_TYPE_ENUM: {
       /* Resolve enum symbolic name to integer value. */
-      const upb_enumdef *enumdef =
-          (const upb_enumdef*)upb_fielddef_subdef(p->top->f);
+      const upb_enumdef *enumdef = upb_fielddef_enumsubdef(p->top->f);
 
       size_t len;
       const char *buf = accumulate_getptr(p, &len);
@@ -1353,10 +1364,9 @@ static bool end_stringval_nontop(upb_json_parser *p) {
 
       if (ok) {
         upb_selector_t sel = parser_getsel(p);
-        upb_sink_putint32(&p->top->sink, sel, int_val);
+        upb_sink_putint32(p->top->sink, sel, int_val);
       } else {
-        upb_status_seterrf(&p->status, "Enum value unknown: '%.*s'", len, buf);
-        upb_env_reporterror(p->env, &p->status);
+        upb_status_seterrf(p->status, "Enum value unknown: '%.*s'", len, buf);
       }
 
       break;
@@ -1373,8 +1383,7 @@ static bool end_stringval_nontop(upb_json_parser *p) {
 
     default:
       UPB_ASSERT(false);
-      upb_status_seterrmsg(&p->status, "Internal error in JSON decoder");
-      upb_env_reporterror(p->env, &p->status);
+      upb_status_seterrmsg(p->status, "Internal error in JSON decoder");
       ok = false;
       break;
   }
@@ -1464,25 +1473,22 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
   memcpy(seconds_buf, buf, fraction_start);
   seconds = strtol(seconds_buf, &end, 10);
   if (errno == ERANGE || end != seconds_buf + fraction_start) {
-    upb_status_seterrf(&p->status, "error parsing duration: %s",
+    upb_status_seterrf(p->status, "error parsing duration: %s",
                        seconds_buf);
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
   if (seconds > 315576000000) {
-    upb_status_seterrf(&p->status, "error parsing duration: "
+    upb_status_seterrf(p->status, "error parsing duration: "
                                    "maximum acceptable value is "
                                    "315576000000");
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
   if (seconds < -315576000000) {
-    upb_status_seterrf(&p->status, "error parsing duration: "
+    upb_status_seterrf(p->status, "error parsing duration: "
                                    "minimum acceptable value is "
                                    "-315576000000");
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1491,9 +1497,8 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
   memcpy(nanos_buf + 1, buf + fraction_start, len - fraction_start);
   val = strtod(nanos_buf, &end);
   if (errno == ERANGE || end != nanos_buf + len - fraction_start + 1) {
-    upb_status_seterrf(&p->status, "error parsing duration: %s",
+    upb_status_seterrf(p->status, "error parsing duration: %s",
                        nanos_buf);
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1508,7 +1513,7 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
   capture_begin(p, seconds_membername);
   capture_end(p, seconds_membername + 7);
   end_membername(p);
-  upb_sink_putint64(&p->top->sink, parser_getsel(p), seconds);
+  upb_sink_putint64(p->top->sink, parser_getsel(p), seconds);
   end_member(p);
 
   /* Set nanos */
@@ -1516,51 +1521,109 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
   capture_begin(p, nanos_membername);
   capture_end(p, nanos_membername + 5);
   end_membername(p);
-  upb_sink_putint32(&p->top->sink, parser_getsel(p), nanos);
+  upb_sink_putint32(p->top->sink, parser_getsel(p), nanos);
   end_member(p);
 
-  /* Continue previous environment */
+  /* Continue previous arena */
   multipart_startaccum(p);
 
   return true;
 }
 
-static void start_timestamp_base(upb_json_parser *p, const char *ptr) {
+static int parse_timestamp_number(upb_json_parser *p) {
+  size_t len;
+  const char *buf;
+  char *end;
+  int val;
+
+  /* atoi() and friends unfortunately do not support specifying the length of
+   * the input string, so we need to force a copy into a NULL-terminated buffer. */
+  multipart_text(p, "\0", 1, false);
+
+  buf = accumulate_getptr(p, &len);
+  val = atoi(buf);
+  multipart_end(p);
+  multipart_startaccum(p);
+
+  return val;
+}
+
+static void start_year(upb_json_parser *p, const char *ptr) {
   capture_begin(p, ptr);
 }
 
-#define UPB_TIMESTAMP_BASE_SIZE 19
+static bool end_year(upb_json_parser *p, const char *ptr) {
+  if (!capture_end(p, ptr)) {
+    return false;
+  }
+  p->tm.tm_year = parse_timestamp_number(p) - 1900;
+  return true;
+}
 
-static bool end_timestamp_base(upb_json_parser *p, const char *ptr) {
-  size_t len;
-  const char *buf;
-  /* 3 for GMT and 1 for ending 0 */
-  char timestamp_buf[UPB_TIMESTAMP_BASE_SIZE + 4];
+static void start_month(upb_json_parser *p, const char *ptr) {
+  capture_begin(p, ptr);
+}
 
+static bool end_month(upb_json_parser *p, const char *ptr) {
   if (!capture_end(p, ptr)) {
     return false;
   }
+  p->tm.tm_mon = parse_timestamp_number(p) - 1;
+  return true;
+}
 
-  buf = accumulate_getptr(p, &len);
-  UPB_ASSERT(len == UPB_TIMESTAMP_BASE_SIZE);
-  memcpy(timestamp_buf, buf, UPB_TIMESTAMP_BASE_SIZE);
-  memcpy(timestamp_buf + UPB_TIMESTAMP_BASE_SIZE, "GMT", 3);
-  timestamp_buf[UPB_TIMESTAMP_BASE_SIZE + 3] = 0;
-
-  /* Parse seconds */
-  if (strptime(timestamp_buf, "%FT%H:%M:%S%Z", &p->tm) == NULL) {
-    upb_status_seterrf(&p->status, "error parsing timestamp: %s", buf);
-    upb_env_reporterror(p->env, &p->status);
+static void start_day(upb_json_parser *p, const char *ptr) {
+  capture_begin(p, ptr);
+}
+
+static bool end_day(upb_json_parser *p, const char *ptr) {
+  if (!capture_end(p, ptr)) {
     return false;
   }
+  p->tm.tm_mday = parse_timestamp_number(p);
+  return true;
+}
 
-  /* Clean up buffer */
-  multipart_end(p);
-  multipart_startaccum(p);
+static void start_hour(upb_json_parser *p, const char *ptr) {
+  capture_begin(p, ptr);
+}
+
+static bool end_hour(upb_json_parser *p, const char *ptr) {
+  if (!capture_end(p, ptr)) {
+    return false;
+  }
+  p->tm.tm_hour = parse_timestamp_number(p);
+  return true;
+}
+
+static void start_minute(upb_json_parser *p, const char *ptr) {
+  capture_begin(p, ptr);
+}
+
+static bool end_minute(upb_json_parser *p, const char *ptr) {
+  if (!capture_end(p, ptr)) {
+    return false;
+  }
+  p->tm.tm_min = parse_timestamp_number(p);
+  return true;
+}
+
+static void start_second(upb_json_parser *p, const char *ptr) {
+  capture_begin(p, ptr);
+}
 
+static bool end_second(upb_json_parser *p, const char *ptr) {
+  if (!capture_end(p, ptr)) {
+    return false;
+  }
+  p->tm.tm_sec = parse_timestamp_number(p);
   return true;
 }
 
+static void start_timestamp_base(upb_json_parser *p) {
+  memset(&p->tm, 0, sizeof(struct tm));
+}
+
 static void start_timestamp_fraction(upb_json_parser *p, const char *ptr) {
   capture_begin(p, ptr);
 }
@@ -1583,9 +1646,8 @@ static bool end_timestamp_fraction(upb_json_parser *p, const char *ptr) {
   buf = accumulate_getptr(p, &len);
 
   if (len > 10) {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
         "error parsing timestamp: at most 9-digit fraction.");
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1595,9 +1657,8 @@ static bool end_timestamp_fraction(upb_json_parser *p, const char *ptr) {
   val = strtod(nanos_buf, &end);
 
   if (errno == ERANGE || end != nanos_buf + len + 1) {
-    upb_status_seterrf(&p->status, "error parsing timestamp nanos: %s",
+    upb_status_seterrf(p->status, "error parsing timestamp nanos: %s",
                        nanos_buf);
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1611,7 +1672,7 @@ static bool end_timestamp_fraction(upb_json_parser *p, const char *ptr) {
   capture_begin(p, nanos_membername);
   capture_end(p, nanos_membername + 5);
   end_membername(p);
-  upb_sink_putint32(&p->top->sink, parser_getsel(p), nanos);
+  upb_sink_putint32(p->top->sink, parser_getsel(p), nanos);
   end_member(p);
 
   /* Continue previous environment */
@@ -1639,8 +1700,7 @@ static bool end_timestamp_zone(upb_json_parser *p, const char *ptr) {
 
   if (buf[0] != 'Z') {
     if (sscanf(buf + 1, "%2d:00", &hours) != 1) {
-      upb_status_seterrf(&p->status, "error parsing timestamp offset");
-      upb_env_reporterror(p->env, &p->status);
+      upb_status_seterrf(p->status, "error parsing timestamp offset");
       return false;
     }
 
@@ -1656,10 +1716,9 @@ static bool end_timestamp_zone(upb_json_parser *p, const char *ptr) {
 
   /* Check timestamp boundary */
   if (seconds < -62135596800) {
-    upb_status_seterrf(&p->status, "error parsing timestamp: "
+    upb_status_seterrf(p->status, "error parsing timestamp: "
                                    "minimum acceptable value is "
                                    "0001-01-01T00:00:00Z");
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1671,7 +1730,7 @@ static bool end_timestamp_zone(upb_json_parser *p, const char *ptr) {
   capture_begin(p, seconds_membername);
   capture_end(p, seconds_membername + 7);
   end_membername(p);
-  upb_sink_putint64(&p->top->sink, parser_getsel(p), seconds);
+  upb_sink_putint64(p->top->sink, parser_getsel(p), seconds);
   end_member(p);
 
   /* Continue previous environment */
@@ -1685,9 +1744,7 @@ static void start_fieldmask_path_text(upb_json_parser *p, const char *ptr) {
 }
 
 static bool end_fieldmask_path_text(upb_json_parser *p, const char *ptr) {
-  if (!capture_end(p, ptr)) {
-    return false;
-  }
+  return capture_end(p, ptr);
 }
 
 static bool start_fieldmask_path(upb_json_parser *p) {
@@ -1698,17 +1755,11 @@ static bool start_fieldmask_path(upb_json_parser *p) {
 
   /* Start a new parser frame: parser frames correspond one-to-one with
    * handler frames, and string events occur in a sub-frame. */
-  inner = p->top + 1;
+  inner = start_jsonparser_frame(p);
   sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
-  upb_sink_startstr(&p->top->sink, sel, 0, &inner->sink);
+  upb_sink_startstr(p->top->sink, sel, 0, &inner->sink);
   inner->m = p->top->m;
   inner->f = p->top->f;
-  inner->name_table = NULL;
-  inner->is_map = false;
-  inner->is_mapentry = false;
-  inner->is_any = false;
-  inner->any_frame = NULL;
-  inner->is_unknown_field = false;
   p->top = inner;
 
   multipart_startaccum(p);
@@ -1722,10 +1773,10 @@ static bool lower_camel_push(
   for (;ptr < limit; ptr++) {
     if (*ptr >= 'A' && *ptr <= 'Z' && !first) {
       char lower = tolower(*ptr);
-      upb_sink_putstring(&p->top->sink, sel, "_", 1, NULL);
-      upb_sink_putstring(&p->top->sink, sel, &lower, 1, NULL);
+      upb_sink_putstring(p->top->sink, sel, "_", 1, NULL);
+      upb_sink_putstring(p->top->sink, sel, &lower, 1, NULL);
     } else {
-      upb_sink_putstring(&p->top->sink, sel, ptr, 1, NULL);
+      upb_sink_putstring(p->top->sink, sel, ptr, 1, NULL);
     }
     first = false;
   }
@@ -1742,7 +1793,7 @@ static bool end_fieldmask_path(upb_json_parser *p) {
   }
 
   sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
-  upb_sink_endstr(&p->top->sink, sel);
+  upb_sink_endstr(p->top->sink, sel);
   p->top--;
 
   multipart_end(p);
@@ -1769,8 +1820,7 @@ static bool parse_mapentry_key(upb_json_parser *p) {
 
   p->top->f = upb_msgdef_itof(p->top->m, UPB_MAPENTRY_KEY);
   if (p->top->f == NULL) {
-    upb_status_seterrmsg(&p->status, "mapentry message has no key");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "mapentry message has no key");
     return false;
   }
   switch (upb_fielddef_type(p->top->f)) {
@@ -1793,9 +1843,8 @@ static bool parse_mapentry_key(upb_json_parser *p) {
           return false;
         }
       } else {
-        upb_status_seterrmsg(&p->status,
+        upb_status_seterrmsg(p->status,
                              "Map bool key not 'true' or 'false'");
-        upb_env_reporterror(p->env, &p->status);
         return false;
       }
       multipart_end(p);
@@ -1804,17 +1853,16 @@ static bool parse_mapentry_key(upb_json_parser *p) {
     case UPB_TYPE_BYTES: {
       upb_sink subsink;
       upb_selector_t sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
-      upb_sink_startstr(&p->top->sink, sel, len, &subsink);
+      upb_sink_startstr(p->top->sink, sel, len, &subsink);
       sel = getsel_for_handlertype(p, UPB_HANDLER_STRING);
-      upb_sink_putstring(&subsink, sel, buf, len, NULL);
+      upb_sink_putstring(subsink, sel, buf, len, NULL);
       sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
-      upb_sink_endstr(&subsink, sel);
+      upb_sink_endstr(subsink, sel);
       multipart_end(p);
       break;
     }
     default:
-      upb_status_seterrmsg(&p->status, "Invalid field type for map key");
-      upb_env_reporterror(p->env, &p->status);
+      upb_status_seterrmsg(p->status, "Invalid field type for map key");
       return false;
   }
 
@@ -1844,17 +1892,12 @@ static bool handle_mapentry(upb_json_parser *p) {
   mapfield = p->top->mapfield;
   mapentrymsg = upb_fielddef_msgsubdef(mapfield);
 
-  inner = p->top + 1;
+  inner = start_jsonparser_frame(p);
   p->top->f = mapfield;
   sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSUBMSG);
-  upb_sink_startsubmsg(&p->top->sink, sel, &inner->sink);
+  upb_sink_startsubmsg(p->top->sink, sel, &inner->sink);
   inner->m = mapentrymsg;
-  inner->name_table = NULL;
   inner->mapfield = mapfield;
-  inner->is_map = false;
-  inner->is_any = false;
-  inner->any_frame = NULL;
-  inner->is_unknown_field = false;
 
   /* Don't set this to true *yet* -- we reuse parsing handlers below to push
    * the key field value to the sink, and these handlers will pop the frame
@@ -1864,7 +1907,7 @@ static bool handle_mapentry(upb_json_parser *p) {
   p->top = inner;
 
   /* send STARTMSG in submsg frame. */
-  upb_sink_startmsg(&p->top->sink);
+  upb_sink_startmsg(p->top->sink);
 
   parse_mapentry_key(p);
 
@@ -1873,8 +1916,7 @@ static bool handle_mapentry(upb_json_parser *p) {
   p->top->is_mapentry = true;  /* set up to pop frame after value is parsed. */
   p->top->mapfield = mapfield;
   if (p->top->f == NULL) {
-    upb_status_seterrmsg(&p->status, "mapentry message has no value");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "mapentry message has no value");
     return false;
   }
 
@@ -1909,8 +1951,7 @@ static bool end_membername(upb_json_parser *p) {
       multipart_end(p);
       return true;
     } else {
-      upb_status_seterrf(&p->status, "No such field: %.*s\n", (int)len, buf);
-      upb_env_reporterror(p->env, &p->status);
+      upb_status_seterrf(p->status, "No such field: %.*s\n", (int)len, buf);
       return false;
     }
   }
@@ -1936,21 +1977,20 @@ static bool end_any_membername(upb_json_parser *p) {
 static void end_member(upb_json_parser *p) {
   /* If we just parsed a map-entry value, end that frame too. */
   if (p->top->is_mapentry) {
-    upb_status s = UPB_STATUS_INIT;
     upb_selector_t sel;
     bool ok;
     const upb_fielddef *mapfield;
 
     UPB_ASSERT(p->top > p->stack);
     /* send ENDMSG on submsg. */
-    upb_sink_endmsg(&p->top->sink, &s);
+    upb_sink_endmsg(p->top->sink, p->status);
     mapfield = p->top->mapfield;
 
     /* send ENDSUBMSG in repeated-field-of-mapentries frame. */
     p->top--;
     ok = upb_handlers_getselector(mapfield, UPB_HANDLER_ENDSUBMSG, &sel);
     UPB_ASSERT(ok);
-    upb_sink_endsubmsg(&p->top->sink, sel);
+    upb_sink_endsubmsg(p->top->sink, sel);
   }
 
   p->top->f = NULL;
@@ -1972,15 +2012,7 @@ static bool start_subobject(upb_json_parser *p) {
     upb_jsonparser_frame *inner;
     if (!check_stack(p)) return false;
 
-    inner = p->top + 1;
-    inner->m = NULL;
-    inner->f = NULL;
-    inner->is_map = false;
-    inner->is_mapentry = false;
-    inner->is_any = false;
-    inner->any_frame = NULL;
-    inner->is_unknown_field = false;
-    p->top = inner;
+    p->top = start_jsonparser_frame(p);
     return true;
   }
 
@@ -1992,18 +2024,12 @@ static bool start_subobject(upb_json_parser *p) {
      * context. */
     if (!check_stack(p)) return false;
 
-    inner = p->top + 1;
+    inner = start_jsonparser_frame(p);
     sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSEQ);
-    upb_sink_startseq(&p->top->sink, sel, &inner->sink);
+    upb_sink_startseq(p->top->sink, sel, &inner->sink);
     inner->m = upb_fielddef_msgsubdef(p->top->f);
-    inner->name_table = NULL;
     inner->mapfield = p->top->f;
-    inner->f = NULL;
     inner->is_map = true;
-    inner->is_mapentry = false;
-    inner->is_any = false;
-    inner->any_frame = NULL;
-    inner->is_unknown_field = false;
     p->top = inner;
 
     return true;
@@ -2015,23 +2041,16 @@ static bool start_subobject(upb_json_parser *p) {
      * context. */
     if (!check_stack(p)) return false;
 
-    inner = p->top + 1;
-
+    inner = start_jsonparser_frame(p);
     sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSUBMSG);
-    upb_sink_startsubmsg(&p->top->sink, sel, &inner->sink);
+    upb_sink_startsubmsg(p->top->sink, sel, &inner->sink);
     inner->m = upb_fielddef_msgsubdef(p->top->f);
     set_name_table(p, inner);
-    inner->f = NULL;
-    inner->is_map = false;
-    inner->is_mapentry = false;
-    inner->is_unknown_field = false;
     p->top = inner;
 
     if (is_wellknown_msg(p, UPB_WELLKNOWN_ANY)) {
       p->top->is_any = true;
-      p->top->any_frame =
-          upb_env_malloc(p->env, sizeof(upb_jsonparser_any_frame));
-      json_parser_any_frame_reset(p->top->any_frame);
+      p->top->any_frame = json_parser_any_frame_new(p);
     } else {
       p->top->is_any = false;
       p->top->any_frame = NULL;
@@ -2039,10 +2058,9 @@ static bool start_subobject(upb_json_parser *p) {
 
     return true;
   } else {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
                        "Object specified for non-message/group field: %s",
                        upb_fielddef_name(p->top->f));
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 }
@@ -2080,14 +2098,14 @@ static void end_subobject(upb_json_parser *p) {
     upb_selector_t sel;
     p->top--;
     sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSEQ);
-    upb_sink_endseq(&p->top->sink, sel);
+    upb_sink_endseq(p->top->sink, sel);
   } else {
     upb_selector_t sel;
     bool is_unknown = p->top->m == NULL;
     p->top--;
     if (!is_unknown) {
       sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSUBMSG);
-      upb_sink_endsubmsg(&p->top->sink, sel);
+      upb_sink_endsubmsg(p->top->sink, sel);
     }
   }
 }
@@ -2124,10 +2142,14 @@ static bool start_array(upb_json_parser *p) {
     } else {
       return false;
     }
-  } else if (is_wellknown_field(p, UPB_WELLKNOWN_LISTVALUE)) {
+  } else if (is_wellknown_field(p, UPB_WELLKNOWN_LISTVALUE) &&
+             (!upb_fielddef_isseq(p->top->f) ||
+              p->top->is_repeated)) {
     if (!start_subobject(p)) return false;
     start_listvalue_object(p);
-  } else if (is_wellknown_field(p, UPB_WELLKNOWN_VALUE)) {
+  } else if (is_wellknown_field(p, UPB_WELLKNOWN_VALUE) &&
+             (!upb_fielddef_isseq(p->top->f) ||
+              p->top->is_repeated)) {
     if (!start_subobject(p)) return false;
     start_value_object(p, VALUE_LISTVALUE);
     if (!start_subobject(p)) return false;
@@ -2135,14 +2157,7 @@ static bool start_array(upb_json_parser *p) {
   }
 
   if (p->top->is_unknown_field) {
-    inner = p->top + 1;
-    inner->m = NULL;
-    inner->name_table = NULL;
-    inner->f = NULL;
-    inner->is_map = false;
-    inner->is_mapentry = false;
-    inner->is_any = false;
-    inner->any_frame = NULL;
+    inner = start_jsonparser_frame(p);
     inner->is_unknown_field = true;
     p->top = inner;
 
@@ -2150,26 +2165,20 @@ static bool start_array(upb_json_parser *p) {
   }
 
   if (!upb_fielddef_isseq(p->top->f)) {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
                        "Array specified for non-repeated field: %s",
                        upb_fielddef_name(p->top->f));
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
   if (!check_stack(p)) return false;
 
-  inner = p->top + 1;
+  inner = start_jsonparser_frame(p);
   sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSEQ);
-  upb_sink_startseq(&p->top->sink, sel, &inner->sink);
+  upb_sink_startseq(p->top->sink, sel, &inner->sink);
   inner->m = p->top->m;
-  inner->name_table = NULL;
   inner->f = p->top->f;
-  inner->is_map = false;
-  inner->is_mapentry = false;
-  inner->is_any = false;
-  inner->any_frame = NULL;
-  inner->is_unknown_field = false;
+  inner->is_repeated = true;
   p->top = inner;
 
   return true;
@@ -2187,7 +2196,7 @@ static void end_array(upb_json_parser *p) {
   }
 
   sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSEQ);
-  upb_sink_endseq(&p->top->sink, sel);
+  upb_sink_endseq(p->top->sink, sel);
 
   if (is_wellknown_msg(p, UPB_WELLKNOWN_LISTVALUE)) {
     end_listvalue_object(p);
@@ -2206,18 +2215,13 @@ static void end_array(upb_json_parser *p) {
 
 static void start_object(upb_json_parser *p) {
   if (!p->top->is_map && p->top->m != NULL) {
-    upb_sink_startmsg(&p->top->sink);
+    upb_sink_startmsg(p->top->sink);
   }
 }
 
 static void end_object(upb_json_parser *p) {
   if (!p->top->is_map && p->top->m != NULL) {
-    upb_status status;
-    upb_status_clear(&status);
-    upb_sink_endmsg(&p->top->sink, &status);
-    if (!upb_ok(&status)) {
-      upb_env_reporterror(p->env, &status);
-    }
+    upb_sink_endmsg(p->top->sink, p->status);
   }
 }
 
@@ -2236,8 +2240,7 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
 
   if (json_parser_any_frame_has_value(p->top->any_frame) &&
       !json_parser_any_frame_has_type_url(p->top->any_frame)) {
-    upb_status_seterrmsg(&p->status, "No valid type url");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "No valid type url");
     return false;
   }
 
@@ -2252,8 +2255,7 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
                  p->top->any_frame->before_type_url_end -
                  p->top->any_frame->before_type_url_start);
       if (p->top->any_frame->before_type_url_start == NULL) {
-        upb_status_seterrmsg(&p->status, "invalid data for well known type.");
-        upb_env_reporterror(p->env, &p->status);
+        upb_status_seterrmsg(p->status, "invalid data for well known type.");
         return false;
       }
       p->top->any_frame->before_type_url_start++;
@@ -2265,8 +2267,7 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
                  (ptr + 1) -
                  p->top->any_frame->after_type_url_start);
       if (p->top->any_frame->after_type_url_start == NULL) {
-        upb_status_seterrmsg(&p->status, "Invalid data for well known type.");
-        upb_env_reporterror(p->env, &p->status);
+        upb_status_seterrmsg(p->status, "Invalid data for well known type.");
         return false;
       }
       p->top->any_frame->after_type_url_start++;
@@ -2326,12 +2327,12 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
   inner = p->top + 1;
 
   sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
-  upb_sink_startstr(&p->top->sink, sel, 0, &inner->sink);
+  upb_sink_startstr(p->top->sink, sel, 0, &inner->sink);
   sel = getsel_for_handlertype(p, UPB_HANDLER_STRING);
-  upb_sink_putstring(&inner->sink, sel, p->top->any_frame->stringsink.ptr,
+  upb_sink_putstring(inner->sink, sel, p->top->any_frame->stringsink.ptr,
                      p->top->any_frame->stringsink.len, NULL);
   sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
-  upb_sink_endstr(&inner->sink, sel);
+  upb_sink_endstr(inner->sink, sel);
 
   end_member(p);
 
@@ -2339,7 +2340,6 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
 
   /* Deallocate any parse frame. */
   json_parser_any_frame_free(p->top->any_frame);
-  upb_env_free(p->env, p->top->any_frame);
 
   return true;
 }
@@ -2523,10 +2523,6 @@ static bool does_fieldmask_end(upb_json_parser *p) {
   return p->top->m != NULL && is_fieldmask(p->top->m);
 }
 
-static bool is_fieldmask_object(upb_json_parser *p) {
-  return p->top->m != NULL && is_fieldmask(p->top->m);
-}
-
 #define CHECK_RETURN_TOP(x) if (!(x)) goto error
 
 
@@ -2548,27 +2544,30 @@ static bool is_fieldmask_object(upb_json_parser *p) {
  * final state once, when the closing '"' is seen. */
 
 
-#line 2730 "upb/json/parser.rl"
+#line 2749 "upb/json/parser.rl"
 
 
 
-#line 2556 "upb/json/parser.c"
+#line 2552 "upb/json/parser.c"
 static const char _json_actions[] = {
 	0, 1, 0, 1, 1, 1, 3, 1, 
 	4, 1, 6, 1, 7, 1, 8, 1, 
-	9, 1, 10, 1, 11, 1, 12, 1, 
-	13, 1, 24, 1, 26, 1, 28, 1, 
-	29, 1, 31, 1, 32, 1, 33, 1, 
-	35, 1, 37, 1, 38, 1, 39, 1, 
-	40, 1, 42, 1, 43, 2, 4, 9, 
-	2, 5, 6, 2, 7, 3, 2, 7, 
-	9, 2, 14, 15, 2, 16, 17, 2, 
-	18, 19, 2, 21, 23, 2, 22, 20, 
-	2, 27, 25, 2, 29, 31, 2, 34, 
-	2, 2, 35, 43, 2, 36, 25, 2, 
-	38, 43, 2, 39, 43, 2, 40, 43, 
-	2, 41, 30, 2, 42, 43, 3, 21, 
-	23, 24, 4, 14, 15, 16, 17
+	9, 1, 11, 1, 12, 1, 13, 1, 
+	14, 1, 15, 1, 16, 1, 17, 1, 
+	18, 1, 19, 1, 20, 1, 22, 1, 
+	23, 1, 24, 1, 35, 1, 37, 1, 
+	39, 1, 40, 1, 42, 1, 43, 1, 
+	44, 1, 46, 1, 48, 1, 49, 1, 
+	50, 1, 51, 1, 53, 1, 54, 2, 
+	4, 9, 2, 5, 6, 2, 7, 3, 
+	2, 7, 9, 2, 21, 26, 2, 25, 
+	10, 2, 27, 28, 2, 29, 30, 2, 
+	32, 34, 2, 33, 31, 2, 38, 36, 
+	2, 40, 42, 2, 45, 2, 2, 46, 
+	54, 2, 47, 36, 2, 49, 54, 2, 
+	50, 54, 2, 51, 54, 2, 52, 41, 
+	2, 53, 54, 3, 32, 34, 35, 4, 
+	21, 26, 27, 28
 };
 
 static const short _json_key_offsets[] = {
@@ -2752,30 +2751,30 @@ static const char _json_trans_targs[] = {
 	106
 };
 
-static const char _json_trans_actions[] = {
-	0, 0, 92, 86, 35, 0, 0, 0, 
-	104, 41, 27, 0, 37, 0, 0, 0, 
+static const unsigned char _json_trans_actions[] = {
+	0, 0, 113, 107, 53, 0, 0, 0, 
+	125, 59, 45, 0, 55, 0, 0, 0, 
 	0, 0, 0, 0, 0, 0, 0, 0, 
-	0, 0, 80, 33, 29, 0, 0, 27, 
-	31, 31, 83, 0, 0, 0, 0, 0, 
+	0, 0, 101, 51, 47, 0, 0, 45, 
+	49, 49, 104, 0, 0, 0, 0, 0, 
 	3, 0, 0, 0, 0, 0, 5, 15, 
-	0, 0, 53, 7, 13, 0, 56, 9, 
-	9, 9, 59, 62, 11, 17, 17, 17, 
-	0, 0, 0, 19, 0, 21, 23, 0, 
-	0, 0, 0, 0, 0, 0, 0, 0, 
-	0, 0, 0, 0, 0, 0, 0, 0, 
-	0, 114, 65, 114, 0, 0, 0, 0, 
-	0, 71, 0, 68, 68, 77, 25, 0, 
-	110, 74, 92, 86, 35, 0, 0, 0, 
-	104, 41, 51, 89, 27, 0, 37, 0, 
-	0, 0, 0, 0, 0, 98, 0, 0, 
-	0, 101, 0, 0, 0, 95, 0, 80, 
-	33, 29, 0, 0, 27, 31, 31, 83, 
-	0, 0, 107, 0, 39, 45, 47, 43, 
-	49
+	0, 0, 71, 7, 13, 0, 74, 9, 
+	9, 9, 77, 80, 11, 37, 37, 37, 
+	0, 0, 0, 39, 0, 41, 86, 0, 
+	0, 0, 17, 19, 0, 21, 23, 0, 
+	25, 27, 0, 29, 31, 0, 33, 35, 
+	0, 135, 83, 135, 0, 0, 0, 0, 
+	0, 92, 0, 89, 89, 98, 43, 0, 
+	131, 95, 113, 107, 53, 0, 0, 0, 
+	125, 59, 69, 110, 45, 0, 55, 0, 
+	0, 0, 0, 0, 0, 119, 0, 0, 
+	0, 122, 0, 0, 0, 116, 0, 101, 
+	51, 47, 0, 0, 45, 49, 49, 104, 
+	0, 0, 128, 0, 57, 63, 65, 61, 
+	67
 };
 
-static const char _json_eof_actions[] = {
+static const unsigned char _json_eof_actions[] = {
 	0, 0, 0, 0, 0, 0, 0, 0, 
 	0, 0, 0, 0, 0, 0, 0, 0, 
 	0, 0, 0, 0, 0, 0, 0, 0, 
@@ -2789,7 +2788,7 @@ static const char _json_eof_actions[] = {
 	0, 0, 0, 0, 0, 0, 0, 0, 
 	0, 0, 0, 0, 0, 0, 0, 0, 
 	0, 0, 0, 0, 0, 0, 0, 0, 
-	0, 0, 0, 39, 45, 47, 43, 49, 
+	0, 0, 0, 57, 63, 65, 61, 67, 
 	0, 0, 0, 0, 0, 0
 };
 
@@ -2804,7 +2803,7 @@ static const int json_en_value_machine = 78;
 static const int json_en_main = 1;
 
 
-#line 2733 "upb/json/parser.rl"
+#line 2752 "upb/json/parser.rl"
 
 size_t parse(void *closure, const void *hd, const char *buf, size_t size,
              const upb_bufhandle *handle) {
@@ -2827,7 +2826,7 @@ size_t parse(void *closure, const void *hd, const char *buf, size_t size,
   capture_resume(parser, buf);
 
   
-#line 2831 "upb/json/parser.c"
+#line 2830 "upb/json/parser.c"
 	{
 	int _klen;
 	unsigned int _trans;
@@ -2902,103 +2901,147 @@ _match:
 		switch ( *_acts++ )
 		{
 	case 1:
-#line 2561 "upb/json/parser.rl"
+#line 2557 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; goto _again;} }
 	break;
 	case 2:
-#line 2563 "upb/json/parser.rl"
+#line 2559 "upb/json/parser.rl"
 	{ p--; {stack[top++] = cs; cs = 23;goto _again;} }
 	break;
 	case 3:
-#line 2567 "upb/json/parser.rl"
+#line 2563 "upb/json/parser.rl"
 	{ start_text(parser, p); }
 	break;
 	case 4:
-#line 2568 "upb/json/parser.rl"
+#line 2564 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_text(parser, p)); }
 	break;
 	case 5:
-#line 2574 "upb/json/parser.rl"
+#line 2570 "upb/json/parser.rl"
 	{ start_hex(parser); }
 	break;
 	case 6:
-#line 2575 "upb/json/parser.rl"
+#line 2571 "upb/json/parser.rl"
 	{ hexdigit(parser, p); }
 	break;
 	case 7:
-#line 2576 "upb/json/parser.rl"
+#line 2572 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_hex(parser)); }
 	break;
 	case 8:
-#line 2582 "upb/json/parser.rl"
+#line 2578 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(escape(parser, p)); }
 	break;
 	case 9:
-#line 2588 "upb/json/parser.rl"
+#line 2584 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; goto _again;} }
 	break;
 	case 10:
-#line 2600 "upb/json/parser.rl"
-	{ start_duration_base(parser, p); }
+#line 2589 "upb/json/parser.rl"
+	{ start_year(parser, p); }
 	break;
 	case 11:
-#line 2601 "upb/json/parser.rl"
-	{ CHECK_RETURN_TOP(end_duration_base(parser, p)); }
+#line 2590 "upb/json/parser.rl"
+	{ CHECK_RETURN_TOP(end_year(parser, p)); }
 	break;
 	case 12:
-#line 2603 "upb/json/parser.rl"
-	{ p--; {cs = stack[--top]; goto _again;} }
+#line 2594 "upb/json/parser.rl"
+	{ start_month(parser, p); }
 	break;
 	case 13:
-#line 2608 "upb/json/parser.rl"
-	{ start_timestamp_base(parser, p); }
+#line 2595 "upb/json/parser.rl"
+	{ CHECK_RETURN_TOP(end_month(parser, p)); }
 	break;
 	case 14:
-#line 2609 "upb/json/parser.rl"
-	{ CHECK_RETURN_TOP(end_timestamp_base(parser, p)); }
+#line 2599 "upb/json/parser.rl"
+	{ start_day(parser, p); }
 	break;
 	case 15:
-#line 2611 "upb/json/parser.rl"
-	{ start_timestamp_fraction(parser, p); }
+#line 2600 "upb/json/parser.rl"
+	{ CHECK_RETURN_TOP(end_day(parser, p)); }
 	break;
 	case 16:
-#line 2612 "upb/json/parser.rl"
-	{ CHECK_RETURN_TOP(end_timestamp_fraction(parser, p)); }
+#line 2604 "upb/json/parser.rl"
+	{ start_hour(parser, p); }
 	break;
 	case 17:
-#line 2614 "upb/json/parser.rl"
-	{ start_timestamp_zone(parser, p); }
+#line 2605 "upb/json/parser.rl"
+	{ CHECK_RETURN_TOP(end_hour(parser, p)); }
 	break;
 	case 18:
-#line 2615 "upb/json/parser.rl"
-	{ CHECK_RETURN_TOP(end_timestamp_zone(parser, p)); }
+#line 2609 "upb/json/parser.rl"
+	{ start_minute(parser, p); }
 	break;
 	case 19:
-#line 2617 "upb/json/parser.rl"
-	{ p--; {cs = stack[--top]; goto _again;} }
+#line 2610 "upb/json/parser.rl"
+	{ CHECK_RETURN_TOP(end_minute(parser, p)); }
 	break;
 	case 20:
-#line 2622 "upb/json/parser.rl"
-	{ start_fieldmask_path_text(parser, p); }
+#line 2614 "upb/json/parser.rl"
+	{ start_second(parser, p); }
 	break;
 	case 21:
-#line 2623 "upb/json/parser.rl"
-	{ end_fieldmask_path_text(parser, p); }
+#line 2615 "upb/json/parser.rl"
+	{ CHECK_RETURN_TOP(end_second(parser, p)); }
 	break;
 	case 22:
-#line 2628 "upb/json/parser.rl"
-	{ start_fieldmask_path(parser); }
+#line 2620 "upb/json/parser.rl"
+	{ start_duration_base(parser, p); }
 	break;
 	case 23:
-#line 2629 "upb/json/parser.rl"
-	{ end_fieldmask_path(parser); }
+#line 2621 "upb/json/parser.rl"
+	{ CHECK_RETURN_TOP(end_duration_base(parser, p)); }
 	break;
 	case 24:
-#line 2635 "upb/json/parser.rl"
+#line 2623 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; goto _again;} }
 	break;
 	case 25:
-#line 2640 "upb/json/parser.rl"
+#line 2628 "upb/json/parser.rl"
+	{ start_timestamp_base(parser); }
+	break;
+	case 26:
+#line 2630 "upb/json/parser.rl"
+	{ start_timestamp_fraction(parser, p); }
+	break;
+	case 27:
+#line 2631 "upb/json/parser.rl"
+	{ CHECK_RETURN_TOP(end_timestamp_fraction(parser, p)); }
+	break;
+	case 28:
+#line 2633 "upb/json/parser.rl"
+	{ start_timestamp_zone(parser, p); }
+	break;
+	case 29:
+#line 2634 "upb/json/parser.rl"
+	{ CHECK_RETURN_TOP(end_timestamp_zone(parser, p)); }
+	break;
+	case 30:
+#line 2636 "upb/json/parser.rl"
+	{ p--; {cs = stack[--top]; goto _again;} }
+	break;
+	case 31:
+#line 2641 "upb/json/parser.rl"
+	{ start_fieldmask_path_text(parser, p); }
+	break;
+	case 32:
+#line 2642 "upb/json/parser.rl"
+	{ end_fieldmask_path_text(parser, p); }
+	break;
+	case 33:
+#line 2647 "upb/json/parser.rl"
+	{ start_fieldmask_path(parser); }
+	break;
+	case 34:
+#line 2648 "upb/json/parser.rl"
+	{ end_fieldmask_path(parser); }
+	break;
+	case 35:
+#line 2654 "upb/json/parser.rl"
+	{ p--; {cs = stack[--top]; goto _again;} }
+	break;
+	case 36:
+#line 2659 "upb/json/parser.rl"
 	{
         if (is_wellknown_msg(parser, UPB_WELLKNOWN_TIMESTAMP)) {
           {stack[top++] = cs; cs = 47;goto _again;}
@@ -3011,12 +3054,12 @@ _match:
         }
       }
 	break;
-	case 26:
-#line 2653 "upb/json/parser.rl"
+	case 37:
+#line 2672 "upb/json/parser.rl"
 	{ p--; {stack[top++] = cs; cs = 78;goto _again;} }
 	break;
-	case 27:
-#line 2658 "upb/json/parser.rl"
+	case 38:
+#line 2677 "upb/json/parser.rl"
 	{
         if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
           start_any_member(parser, p);
@@ -3025,12 +3068,12 @@ _match:
         }
       }
 	break;
-	case 28:
-#line 2665 "upb/json/parser.rl"
+	case 39:
+#line 2684 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_membername(parser)); }
 	break;
-	case 29:
-#line 2668 "upb/json/parser.rl"
+	case 40:
+#line 2687 "upb/json/parser.rl"
 	{
         if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
           end_any_member(parser, p);
@@ -3039,8 +3082,8 @@ _match:
         }
       }
 	break;
-	case 30:
-#line 2679 "upb/json/parser.rl"
+	case 41:
+#line 2698 "upb/json/parser.rl"
 	{
         if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
           start_any_object(parser, p);
@@ -3049,8 +3092,8 @@ _match:
         }
       }
 	break;
-	case 31:
-#line 2688 "upb/json/parser.rl"
+	case 42:
+#line 2707 "upb/json/parser.rl"
 	{
         if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
           CHECK_RETURN_TOP(end_any_object(parser, p));
@@ -3059,55 +3102,55 @@ _match:
         }
       }
 	break;
-	case 32:
-#line 2700 "upb/json/parser.rl"
+	case 43:
+#line 2719 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(start_array(parser)); }
 	break;
-	case 33:
-#line 2704 "upb/json/parser.rl"
+	case 44:
+#line 2723 "upb/json/parser.rl"
 	{ end_array(parser); }
 	break;
-	case 34:
-#line 2709 "upb/json/parser.rl"
+	case 45:
+#line 2728 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(start_number(parser, p)); }
 	break;
-	case 35:
-#line 2710 "upb/json/parser.rl"
+	case 46:
+#line 2729 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_number(parser, p)); }
 	break;
-	case 36:
-#line 2712 "upb/json/parser.rl"
+	case 47:
+#line 2731 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(start_stringval(parser)); }
 	break;
-	case 37:
-#line 2713 "upb/json/parser.rl"
+	case 48:
+#line 2732 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_stringval(parser)); }
 	break;
-	case 38:
-#line 2715 "upb/json/parser.rl"
+	case 49:
+#line 2734 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_bool(parser, true)); }
 	break;
-	case 39:
-#line 2717 "upb/json/parser.rl"
+	case 50:
+#line 2736 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_bool(parser, false)); }
 	break;
-	case 40:
-#line 2719 "upb/json/parser.rl"
+	case 51:
+#line 2738 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_null(parser)); }
 	break;
-	case 41:
-#line 2721 "upb/json/parser.rl"
+	case 52:
+#line 2740 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(start_subobject_full(parser)); }
 	break;
-	case 42:
-#line 2722 "upb/json/parser.rl"
+	case 53:
+#line 2741 "upb/json/parser.rl"
 	{ end_subobject_full(parser); }
 	break;
-	case 43:
-#line 2727 "upb/json/parser.rl"
+	case 54:
+#line 2746 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; goto _again;} }
 	break;
-#line 3111 "upb/json/parser.c"
+#line 3154 "upb/json/parser.c"
 		}
 	}
 
@@ -3124,32 +3167,32 @@ _again:
 	while ( __nacts-- > 0 ) {
 		switch ( *__acts++ ) {
 	case 0:
-#line 2559 "upb/json/parser.rl"
+#line 2555 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; 	if ( p == pe )
 		goto _test_eof;
 goto _again;} }
 	break;
-	case 35:
-#line 2710 "upb/json/parser.rl"
+	case 46:
+#line 2729 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_number(parser, p)); }
 	break;
-	case 38:
-#line 2715 "upb/json/parser.rl"
+	case 49:
+#line 2734 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_bool(parser, true)); }
 	break;
-	case 39:
-#line 2717 "upb/json/parser.rl"
+	case 50:
+#line 2736 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_bool(parser, false)); }
 	break;
-	case 40:
-#line 2719 "upb/json/parser.rl"
+	case 51:
+#line 2738 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_null(parser)); }
 	break;
-	case 42:
-#line 2722 "upb/json/parser.rl"
+	case 53:
+#line 2741 "upb/json/parser.rl"
 	{ end_subobject_full(parser); }
 	break;
-#line 3153 "upb/json/parser.c"
+#line 3196 "upb/json/parser.c"
 		}
 	}
 	}
@@ -3157,11 +3200,10 @@ goto _again;} }
 	_out: {}
 	}
 
-#line 2755 "upb/json/parser.rl"
+#line 2774 "upb/json/parser.rl"
 
   if (p != pe) {
-    upb_status_seterrf(&parser->status, "Parse error at '%.*s'\n", pe - p, p);
-    upb_env_reporterror(parser->env, &parser->status);
+    upb_status_seterrf(parser->status, "Parse error at '%.*s'\n", pe - p, p);
   } else {
     capture_suspend(parser, &p);
   }
@@ -3197,132 +3239,95 @@ static void json_parser_reset(upb_json_parser *p) {
   int top;
 
   p->top = p->stack;
-  p->top->f = NULL;
-  p->top->is_map = false;
-  p->top->is_mapentry = false;
-  p->top->is_any = false;
-  p->top->any_frame = NULL;
-  p->top->is_unknown_field = false;
+  init_frame(p->top);
 
   /* Emit Ragel initialization of the parser. */
   
-#line 3210 "upb/json/parser.c"
+#line 3247 "upb/json/parser.c"
 	{
 	cs = json_start;
 	top = 0;
 	}
 
-#line 2803 "upb/json/parser.rl"
+#line 2816 "upb/json/parser.rl"
   p->current_state = cs;
   p->parser_top = top;
   accumulate_clear(p);
   p->multipart_state = MULTIPART_INACTIVE;
   p->capture = NULL;
   p->accumulated = NULL;
-  upb_status_clear(&p->status);
-}
-
-static void visit_json_parsermethod(const upb_refcounted *r,
-                                    upb_refcounted_visit *visit,
-                                    void *closure) {
-  const upb_json_parsermethod *method = (upb_json_parsermethod*)r;
-  visit(r, upb_msgdef_upcast2(method->msg), closure);
 }
 
-static void free_json_parsermethod(upb_refcounted *r) {
-  upb_json_parsermethod *method = (upb_json_parsermethod*)r;
-
-  upb_inttable_iter i;
-  upb_inttable_begin(&i, &method->name_tables);
-  for(; !upb_inttable_done(&i); upb_inttable_next(&i)) {
-    upb_value val = upb_inttable_iter_value(&i);
-    upb_strtable *t = upb_value_getptr(val);
-    upb_strtable_uninit(t);
-    upb_gfree(t);
-  }
+static upb_json_parsermethod *parsermethod_new(upb_json_codecache *c,
+                                               const upb_msgdef *md) {
+  upb_msg_field_iter i;
+  upb_alloc *alloc = upb_arena_alloc(c->arena);
 
-  upb_inttable_uninit(&method->name_tables);
+  upb_json_parsermethod *m = upb_malloc(alloc, sizeof(*m));
 
-  upb_gfree(r);
-}
+  m->cache = c;
 
-static void add_jsonname_table(upb_json_parsermethod *m, const upb_msgdef* md) {
-  upb_msg_field_iter i;
-  upb_strtable *t;
+  upb_byteshandler_init(&m->input_handler_);
+  upb_byteshandler_setstring(&m->input_handler_, parse, m);
+  upb_byteshandler_setendstr(&m->input_handler_, end, m);
 
-  /* It would be nice to stack-allocate this, but protobufs do not limit the
-   * length of fields to any reasonable limit. */
-  char *buf = NULL;
-  size_t len = 0;
-
-  if (upb_inttable_lookupptr(&m->name_tables, md, NULL)) {
-    return;
-  }
+  upb_strtable_init2(&m->name_table, UPB_CTYPE_CONSTPTR, alloc);
 
-  /* TODO(haberman): handle malloc failure. */
-  t = upb_gmalloc(sizeof(*t));
-  upb_strtable_init(t, UPB_CTYPE_CONSTPTR);
-  upb_inttable_insertptr(&m->name_tables, md, upb_value_ptr(t));
+  /* Build name_table */
 
   for(upb_msg_field_begin(&i, md);
       !upb_msg_field_done(&i);
       upb_msg_field_next(&i)) {
     const upb_fielddef *f = upb_msg_iter_field(&i);
+    upb_value v = upb_value_constptr(f);
+    char *buf;
 
     /* Add an entry for the JSON name. */
-    size_t field_len = upb_fielddef_getjsonname(f, buf, len);
-    if (field_len > len) {
-      size_t len2;
-      buf = upb_grealloc(buf, 0, field_len);
-      len = field_len;
-      len2 = upb_fielddef_getjsonname(f, buf, len);
-      UPB_ASSERT(len == len2);
-    }
-    upb_strtable_insert(t, buf, upb_value_constptr(f));
+    size_t len = upb_fielddef_getjsonname(f, NULL, 0);
+    buf = upb_malloc(alloc, len);
+    upb_fielddef_getjsonname(f, buf, len);
+    upb_strtable_insert3(&m->name_table, buf, strlen(buf), v, alloc);
 
     if (strcmp(buf, upb_fielddef_name(f)) != 0) {
       /* Since the JSON name is different from the regular field name, add an
        * entry for the raw name (compliant proto3 JSON parsers must accept
        * both). */
-      upb_strtable_insert(t, upb_fielddef_name(f), upb_value_constptr(f));
-    }
-
-    if (upb_fielddef_issubmsg(f)) {
-      add_jsonname_table(m, upb_fielddef_msgsubdef(f));
+      const char *name = upb_fielddef_name(f);
+      upb_strtable_insert3(&m->name_table, name, strlen(name), v, alloc);
     }
   }
 
-  upb_gfree(buf);
+  return m;
 }
 
 /* Public API *****************************************************************/
 
-upb_json_parser *upb_json_parser_create(upb_env *env,
+upb_json_parser *upb_json_parser_create(upb_arena *arena,
                                         const upb_json_parsermethod *method,
                                         const upb_symtab* symtab,
-                                        upb_sink *output,
+                                        upb_sink output,
+                                        upb_status *status,
                                         bool ignore_json_unknown) {
 #ifndef NDEBUG
-  const size_t size_before = upb_env_bytesallocated(env);
+  const size_t size_before = upb_arena_bytesallocated(arena);
 #endif
-  upb_json_parser *p = upb_env_malloc(env, sizeof(upb_json_parser));
+  upb_json_parser *p = upb_arena_malloc(arena, sizeof(upb_json_parser));
   if (!p) return false;
 
-  p->env = env;
+  p->arena = arena;
   p->method = method;
+  p->status = status;
   p->limit = p->stack + UPB_JSON_MAX_DEPTH;
   p->accumulate_buf = NULL;
   p->accumulate_buf_size = 0;
   upb_bytessink_reset(&p->input_, &method->input_handler_, p);
 
   json_parser_reset(p);
-  upb_sink_reset(&p->top->sink, output->handlers, output->closure);
-  p->top->m = upb_handlers_msgdef(output->handlers);
+  p->top->sink = output;
+  p->top->m = upb_handlers_msgdef(output.handlers);
   if (is_wellknown_msg(p, UPB_WELLKNOWN_ANY)) {
     p->top->is_any = true;
-    p->top->any_frame =
-        upb_env_malloc(p->env, sizeof(upb_jsonparser_any_frame));
-    json_parser_any_frame_reset(p->top->any_frame);
+    p->top->any_frame = json_parser_any_frame_new(p);
   } else {
     p->top->is_any = false;
     p->top->any_frame = NULL;
@@ -3333,38 +3338,72 @@ upb_json_parser *upb_json_parser_create(upb_env *env,
   p->ignore_json_unknown = ignore_json_unknown;
 
   /* If this fails, uncomment and increase the value in parser.h. */
-  /* fprintf(stderr, "%zd\n", upb_env_bytesallocated(env) - size_before); */
-  UPB_ASSERT_DEBUGVAR(upb_env_bytesallocated(env) - size_before <=
+  /* fprintf(stderr, "%zd\n", upb_arena_bytesallocated(arena) - size_before); */
+  UPB_ASSERT_DEBUGVAR(upb_arena_bytesallocated(arena) - size_before <=
                       UPB_JSON_PARSER_SIZE);
   return p;
 }
 
-upb_bytessink *upb_json_parser_input(upb_json_parser *p) {
-  return &p->input_;
+upb_bytessink upb_json_parser_input(upb_json_parser *p) {
+  return p->input_;
 }
 
-upb_json_parsermethod *upb_json_parsermethod_new(const upb_msgdef* md,
-                                                 const void* owner) {
-  static const struct upb_refcounted_vtbl vtbl = {visit_json_parsermethod,
-                                                  free_json_parsermethod};
-  upb_json_parsermethod *ret = upb_gmalloc(sizeof(*ret));
-  upb_refcounted_init(upb_json_parsermethod_upcast_mutable(ret), &vtbl, owner);
+const upb_byteshandler *upb_json_parsermethod_inputhandler(
+    const upb_json_parsermethod *m) {
+  return &m->input_handler_;
+}
 
-  ret->msg = md;
-  upb_ref2(md, ret);
+upb_json_codecache *upb_json_codecache_new() {
+  upb_alloc *alloc;
+  upb_json_codecache *c;
 
-  upb_byteshandler_init(&ret->input_handler_);
-  upb_byteshandler_setstring(&ret->input_handler_, parse, ret);
-  upb_byteshandler_setendstr(&ret->input_handler_, end, ret);
+  c = upb_gmalloc(sizeof(*c));
 
-  upb_inttable_init(&ret->name_tables, UPB_CTYPE_PTR);
+  c->arena = upb_arena_new();
+  alloc = upb_arena_alloc(c->arena);
 
-  add_jsonname_table(ret, md);
+  upb_inttable_init2(&c->methods, UPB_CTYPE_CONSTPTR, alloc);
 
-  return ret;
+  return c;
 }
 
-const upb_byteshandler *upb_json_parsermethod_inputhandler(
-    const upb_json_parsermethod *m) {
-  return &m->input_handler_;
+void upb_json_codecache_free(upb_json_codecache *c) {
+  upb_arena_free(c->arena);
+  upb_gfree(c);
+}
+
+const upb_json_parsermethod *upb_json_codecache_get(upb_json_codecache *c,
+                                                    const upb_msgdef *md) {
+  upb_json_parsermethod *m;
+  upb_value v;
+  upb_msg_field_iter i;
+  upb_alloc *alloc = upb_arena_alloc(c->arena);
+
+  if (upb_inttable_lookupptr(&c->methods, md, &v)) {
+    return upb_value_getconstptr(v);
+  }
+
+  m = parsermethod_new(c, md);
+  v = upb_value_constptr(m);
+
+  if (!m) return NULL;
+  if (!upb_inttable_insertptr2(&c->methods, md, v, alloc)) return NULL;
+
+  /* Populate parser methods for all submessages, so the name tables will
+   * be available during parsing. */
+  for(upb_msg_field_begin(&i, md);
+      !upb_msg_field_done(&i);
+      upb_msg_field_next(&i)) {
+    upb_fielddef *f = upb_msg_iter_field(&i);
+
+    if (upb_fielddef_issubmsg(f)) {
+      const upb_msgdef *subdef = upb_fielddef_msgsubdef(f);
+      const upb_json_parsermethod *sub_method =
+          upb_json_codecache_get(c, subdef);
+
+      if (!sub_method) return NULL;
+    }
+  }
+
+  return m;
 }
diff --git a/upb/json/parser.h b/upb/json/parser.h
index fb5fd2f..c063a77 100644
--- a/upb/json/parser.h
+++ b/upb/json/parser.h
@@ -13,17 +13,46 @@
 #ifdef __cplusplus
 namespace upb {
 namespace json {
-class Parser;
-class ParserMethod;
+class CodeCache;
+class ParserPtr;
+class ParserMethodPtr;
 }  /* namespace json */
 }  /* namespace upb */
 #endif
 
-UPB_DECLARE_TYPE(upb::json::Parser, upb_json_parser)
-UPB_DECLARE_DERIVED_TYPE(upb::json::ParserMethod, upb::RefCounted,
-                         upb_json_parsermethod, upb_refcounted)
+/* upb_json_parsermethod ******************************************************/
 
-/* upb::json::Parser **********************************************************/
+struct upb_json_parsermethod;
+typedef struct upb_json_parsermethod upb_json_parsermethod;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+const upb_byteshandler* upb_json_parsermethod_inputhandler(
+    const upb_json_parsermethod* m);
+
+#ifdef __cplusplus
+}  /* extern "C" */
+
+class upb::json::ParserMethodPtr {
+ public:
+  ParserMethodPtr() : ptr_(nullptr) {}
+  ParserMethodPtr(const upb_json_parsermethod* ptr) : ptr_(ptr) {}
+
+  const upb_json_parsermethod* ptr() const { return ptr_; }
+
+  const BytesHandler* input_handler() const {
+    return upb_json_parsermethod_inputhandler(ptr());
+  }
+
+ private:
+  const upb_json_parsermethod* ptr_;
+};
+
+#endif  /* __cplusplus */
+
+/* upb_json_parser ************************************************************/
 
 /* Preallocation hint: parser won't allocate more bytes than this when first
  * constructed.  This hint may be an overestimate for some build configurations.
@@ -31,96 +60,81 @@ UPB_DECLARE_DERIVED_TYPE(upb::json::ParserMethod, upb::RefCounted,
  * it may be an underestimate. */
 #define UPB_JSON_PARSER_SIZE 5712
 
-#ifdef __cplusplus
+struct upb_json_parser;
+typedef struct upb_json_parser upb_json_parser;
 
-/* Parses an incoming BytesStream, pushing the results to the destination
- * sink. */
-class upb::json::Parser {
- public:
-  static Parser* Create(Environment* env, const ParserMethod* method,
-                        const SymbolTable* symtab,
-                        Sink* output, bool ignore_json_unknown);
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-  BytesSink* input();
+upb_json_parser* upb_json_parser_create(upb_arena* a,
+                                        const upb_json_parsermethod* m,
+                                        const upb_symtab* symtab,
+                                        upb_sink output,
+                                        upb_status *status,
+                                        bool ignore_json_unknown);
+upb_bytessink upb_json_parser_input(upb_json_parser* p);
 
- private:
-  UPB_DISALLOW_POD_OPS(Parser, upb::json::Parser)
-};
+#ifdef __cplusplus
+}  /* extern "C" */
 
-class upb::json::ParserMethod {
+/* Parses an incoming BytesStream, pushing the results to the destination
+ * sink. */
+class upb::json::ParserPtr {
  public:
-  /* Include base methods from upb::ReferenceCounted. */
-  UPB_REFCOUNTED_CPPMETHODS
+  ParserPtr(upb_json_parser* ptr) : ptr_(ptr) {}
 
-  /* Returns handlers for parsing according to the specified schema. */
-  static reffed_ptr<const ParserMethod> New(const upb::MessageDef* md);
+  static ParserPtr Create(Arena* arena, ParserMethodPtr method,
+                          SymbolTable* symtab, Sink output, Status* status,
+                          bool ignore_json_unknown) {
+    upb_symtab* symtab_ptr = symtab ? symtab->ptr() : nullptr;
+    return ParserPtr(upb_json_parser_create(
+        arena->ptr(), method.ptr(), symtab_ptr, output.sink(), status->ptr(),
+        ignore_json_unknown));
+  }
 
-  /* The destination handlers that are statically bound to this method.
-   * This method is only capable of outputting to a sink that uses these
-   * handlers. */
-  const Handlers* dest_handlers() const;
-
-  /* The input handlers for this decoder method. */
-  const BytesHandler* input_handler() const;
+  BytesSink input() { return upb_json_parser_input(ptr_); }
 
  private:
-  UPB_DISALLOW_POD_OPS(ParserMethod, upb::json::ParserMethod)
+  upb_json_parser* ptr_;
 };
 
-#endif
+#endif  /* __cplusplus */
 
-UPB_BEGIN_EXTERN_C
+/* upb_json_codecache *********************************************************/
 
-upb_json_parser* upb_json_parser_create(upb_env* e,
-                                        const upb_json_parsermethod* m,
-                                        const upb_symtab* symtab,
-                                        upb_sink* output,
-                                        bool ignore_json_unknown);
-upb_bytessink *upb_json_parser_input(upb_json_parser *p);
+/* Lazily builds and caches decoder methods that will push data to the given
+ * handlers.  The upb_symtab object(s) must outlive this object. */
 
-upb_json_parsermethod* upb_json_parsermethod_new(const upb_msgdef* md,
-                                                 const void* owner);
-const upb_handlers *upb_json_parsermethod_desthandlers(
-    const upb_json_parsermethod *m);
-const upb_byteshandler *upb_json_parsermethod_inputhandler(
-    const upb_json_parsermethod *m);
+struct upb_json_codecache;
+typedef struct upb_json_codecache upb_json_codecache;
 
-/* Include refcounted methods like upb_json_parsermethod_ref(). */
-UPB_REFCOUNTED_CMETHODS(upb_json_parsermethod, upb_json_parsermethod_upcast)
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-UPB_END_EXTERN_C
+upb_json_codecache *upb_json_codecache_new();
+void upb_json_codecache_free(upb_json_codecache *cache);
+const upb_json_parsermethod* upb_json_codecache_get(upb_json_codecache* cache,
+                                                    const upb_msgdef* md);
 
 #ifdef __cplusplus
+}  /* extern "C" */
 
-namespace upb {
-namespace json {
-inline Parser* Parser::Create(Environment* env, const ParserMethod* method,
-                              const SymbolTable* symtab,
-                              Sink* output, bool ignore_json_unknown) {
-  return upb_json_parser_create(
-      env, method, symtab, output, ignore_json_unknown);
-}
-inline BytesSink* Parser::input() {
-  return upb_json_parser_input(this);
-}
-
-inline const Handlers* ParserMethod::dest_handlers() const {
-  return upb_json_parsermethod_desthandlers(this);
-}
-inline const BytesHandler* ParserMethod::input_handler() const {
-  return upb_json_parsermethod_inputhandler(this);
-}
-/* static */
-inline reffed_ptr<const ParserMethod> ParserMethod::New(
-    const MessageDef* md) {
-  const upb_json_parsermethod *m = upb_json_parsermethod_new(md, &m);
-  return reffed_ptr<const ParserMethod>(m, &m);
-}
+class upb::json::CodeCache {
+ public:
+  CodeCache() : ptr_(upb_json_codecache_new(), upb_json_codecache_free) {}
 
-}  /* namespace json */
-}  /* namespace upb */
+  /* Returns a DecoderMethod that can push data to the given handlers.
+   * If a suitable method already exists, it will be returned from the cache. */
+  ParserMethodPtr Get(MessageDefPtr md) {
+    return upb_json_codecache_get(ptr_.get(), md.ptr());
+  }
 
-#endif
+ private:
+  std::unique_ptr<upb_json_codecache, decltype(&upb_json_codecache_free)> ptr_;
+};
 
+#endif
 
 #endif  /* UPB_JSON_PARSER_H_ */
diff --git a/upb/json/parser.rl b/upb/json/parser.rl
index 70a45cb..e7c456a 100644
--- a/upb/json/parser.rl
+++ b/upb/json/parser.rl
@@ -19,6 +19,7 @@
 ** - handling of keys/escape-sequences/etc that span input buffers.
 */
 
+#include <ctype.h>
 #include <errno.h>
 #include <float.h>
 #include <math.h>
@@ -27,10 +28,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-/* Need to define __USE_XOPEN before including time.h to make strptime work. */
-#ifndef __USE_XOPEN
-#define __USE_XOPEN
-#endif
 #include <time.h>
 
 #include "upb/json/parser.h"
@@ -61,7 +58,6 @@ static bool is_string_wrapper_object(upb_json_parser *p);
 static bool does_string_wrapper_start(upb_json_parser *p);
 static bool does_string_wrapper_end(upb_json_parser *p);
 
-static bool is_fieldmask_object(upb_json_parser *p);
 static bool does_fieldmask_start(upb_json_parser *p);
 static bool does_fieldmask_end(upb_json_parser *p);
 static void start_fieldmask_object(upb_json_parser *p);
@@ -158,14 +154,13 @@ void upb_stringsink_uninit(upb_stringsink *sink) { free(sink->ptr); }
 
 typedef struct {
   /* For encoding Any value field in binary format. */
-  const upb_handlers *encoder_handlers;
-  upb_pb_encoder *encoder;
+  upb_handlercache *encoder_handlercache;
   upb_stringsink stringsink;
 
   /* For decoding Any value field in json format. */
-  upb_json_parsermethod *parser_method;
-  upb_json_parser* parser;
+  upb_json_codecache *parser_codecache;
   upb_sink sink;
+  upb_json_parser *parser;
 
   /* Mark the range of uninterpreted values in json input before type url. */
   const char *before_type_url_start;
@@ -184,7 +179,12 @@ typedef struct {
   const upb_fielddef *f;
 
   /* The table mapping json name to fielddef for this message. */
-  upb_strtable *name_table;
+  const upb_strtable *name_table;
+
+  /* We are in a repeated-field context. We need this flag to decide whether to
+   * handle the array as a normal repeated field or a
+   * google.protobuf.ListValue/google.protobuf.Value. */
+  bool is_repeated;
 
   /* We are in a repeated-field context, ready to emit mapentries as
    * submessages. This flag alters the start-of-object (open-brace) behavior to
@@ -216,8 +216,21 @@ typedef struct {
   bool is_unknown_field;
 } upb_jsonparser_frame;
 
+static void init_frame(upb_jsonparser_frame* frame) {
+  frame->m = NULL;
+  frame->f = NULL;
+  frame->name_table = NULL;
+  frame->is_repeated = false;
+  frame->is_map = false;
+  frame->is_mapentry = false;
+  frame->mapfield = NULL;
+  frame->is_any = false;
+  frame->any_frame = NULL;
+  frame->is_unknown_field = false;
+}
+
 struct upb_json_parser {
-  upb_env *env;
+  upb_arena *arena;
   const upb_json_parsermethod *method;
   upb_bytessink input_;
 
@@ -226,7 +239,7 @@ struct upb_json_parser {
   upb_jsonparser_frame *top;
   upb_jsonparser_frame *limit;
 
-  upb_status status;
+  upb_status *status;
 
   /* Ragel's internal parsing stack for the parsing state machine. */
   int current_state;
@@ -263,64 +276,75 @@ struct upb_json_parser {
   struct tm tm;
 };
 
-struct upb_json_parsermethod {
-  upb_refcounted base;
+static upb_jsonparser_frame* start_jsonparser_frame(upb_json_parser *p) {
+  upb_jsonparser_frame *inner;
+  inner = p->top + 1;
+  init_frame(inner);
+  return inner;
+}
 
-  upb_byteshandler input_handler_;
+struct upb_json_codecache {
+  upb_arena *arena;
+  upb_inttable methods;   /* upb_msgdef* -> upb_json_parsermethod* */
+};
 
-  /* Mainly for the purposes of refcounting, so all the fielddefs we point
-   * to stay alive. */
-  const upb_msgdef *msg;
+struct upb_json_parsermethod {
+  const upb_json_codecache *cache;
+  upb_byteshandler input_handler_;
 
-  /* Keys are upb_msgdef*, values are upb_strtable (json_name -> fielddef) */
-  upb_inttable name_tables;
+  /* Maps json_name -> fielddef */
+  upb_strtable name_table;
 };
 
 #define PARSER_CHECK_RETURN(x) if (!(x)) return false
 
-static void json_parser_any_frame_reset(upb_jsonparser_any_frame *frame) {
-  frame->encoder_handlers = NULL;
-  frame->encoder = NULL;
-  frame->parser_method = NULL;
+static upb_jsonparser_any_frame *json_parser_any_frame_new(
+    upb_json_parser *p) {
+  upb_jsonparser_any_frame *frame;
+
+  frame = upb_arena_malloc(p->arena, sizeof(upb_jsonparser_any_frame));
+
+  frame->encoder_handlercache = upb_pb_encoder_newcache();
+  frame->parser_codecache = upb_json_codecache_new();
   frame->parser = NULL;
   frame->before_type_url_start = NULL;
   frame->before_type_url_end = NULL;
   frame->after_type_url_start = NULL;
+
+  upb_stringsink_init(&frame->stringsink);
+
+  return frame;
 }
 
 static void json_parser_any_frame_set_payload_type(
     upb_json_parser *p,
     upb_jsonparser_any_frame *frame,
     const upb_msgdef *payload_type) {
+  const upb_handlers *h;
+  const upb_json_parsermethod *parser_method;
+  upb_pb_encoder *encoder;
+
   /* Initialize encoder. */
-  frame->encoder_handlers =
-      upb_pb_encoder_newhandlers(payload_type, &frame->encoder_handlers);
-  upb_stringsink_init(&frame->stringsink);
-  frame->encoder =
-      upb_pb_encoder_create(
-          p->env, frame->encoder_handlers,
-          &frame->stringsink.sink);
+  h = upb_handlercache_get(frame->encoder_handlercache, payload_type);
+  encoder = upb_pb_encoder_create(p->arena, h, frame->stringsink.sink);
 
   /* Initialize parser. */
-  frame->parser_method =
-      upb_json_parsermethod_new(payload_type, &frame->parser_method);
-  upb_sink_reset(&frame->sink, frame->encoder_handlers, frame->encoder);
+  parser_method = upb_json_codecache_get(frame->parser_codecache, payload_type);
+  upb_sink_reset(&frame->sink, h, encoder);
   frame->parser =
-      upb_json_parser_create(p->env, frame->parser_method, p->symtab,
-                             &frame->sink, p->ignore_json_unknown);
+      upb_json_parser_create(p->arena, parser_method, p->symtab, frame->sink,
+                             p->status, p->ignore_json_unknown);
 }
 
 static void json_parser_any_frame_free(upb_jsonparser_any_frame *frame) {
-  upb_handlers_unref(frame->encoder_handlers,
-                     &frame->encoder_handlers);
-  upb_json_parsermethod_unref(frame->parser_method,
-                              &frame->parser_method);
+  upb_handlercache_free(frame->encoder_handlercache);
+  upb_json_codecache_free(frame->parser_codecache);
   upb_stringsink_uninit(&frame->stringsink);
 }
 
 static bool json_parser_any_frame_has_type_url(
   upb_jsonparser_any_frame *frame) {
-  return frame->encoder != NULL;
+  return frame->parser != NULL;
 }
 
 static bool json_parser_any_frame_has_value_before_type_url(
@@ -342,7 +366,7 @@ static bool json_parser_any_frame_has_value(
 static void json_parser_any_frame_set_before_type_url_end(
     upb_jsonparser_any_frame *frame,
     const char *ptr) {
-  if (frame->encoder == NULL) {
+  if (frame->parser == NULL) {
     frame->before_type_url_end = ptr;
   }
 }
@@ -374,8 +398,7 @@ static upb_selector_t parser_getsel(upb_json_parser *p) {
 
 static bool check_stack(upb_json_parser *p) {
   if ((p->top + 1) == p->limit) {
-    upb_status_seterrmsg(&p->status, "Nesting too deep");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "Nesting too deep");
     return false;
   }
 
@@ -384,9 +407,15 @@ static bool check_stack(upb_json_parser *p) {
 
 static void set_name_table(upb_json_parser *p, upb_jsonparser_frame *frame) {
   upb_value v;
-  bool ok = upb_inttable_lookupptr(&p->method->name_tables, frame->m, &v);
+  const upb_json_codecache *cache = p->method->cache;
+  bool ok;
+  const upb_json_parsermethod *method;
+
+  ok = upb_inttable_lookupptr(&cache->methods, frame->m, &v);
   UPB_ASSERT(ok);
-  frame->name_table = upb_value_getptr(v);
+  method = upb_value_getconstptr(v);
+
+  frame->name_table = &method->name_table;
 }
 
 /* There are GCC/Clang built-ins for overflow checking which we could start
@@ -464,10 +493,9 @@ static bool base64_push(upb_json_parser *p, upb_selector_t sel, const char *ptr,
     char output[3];
 
     if (limit - ptr < 4) {
-      upb_status_seterrf(&p->status,
+      upb_status_seterrf(p->status,
                          "Base64 input for bytes field not a multiple of 4: %s",
                          upb_fielddef_name(p->top->f));
-      upb_env_reporterror(p->env, &p->status);
       return false;
     }
 
@@ -484,17 +512,16 @@ static bool base64_push(upb_json_parser *p, upb_selector_t sel, const char *ptr,
     output[0] = val >> 16;
     output[1] = (val >> 8) & 0xff;
     output[2] = val & 0xff;
-    upb_sink_putstring(&p->top->sink, sel, output, 3, NULL);
+    upb_sink_putstring(p->top->sink, sel, output, 3, NULL);
   }
   return true;
 
 otherchar:
   if (nonbase64(ptr[0]) || nonbase64(ptr[1]) || nonbase64(ptr[2]) ||
       nonbase64(ptr[3]) ) {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
                        "Non-base64 characters in bytes field: %s",
                        upb_fielddef_name(p->top->f));
-    upb_env_reporterror(p->env, &p->status);
     return false;
   } if (ptr[2] == '=') {
     uint32_t val;
@@ -510,7 +537,7 @@ otherchar:
 
     UPB_ASSERT(!(val & 0x80000000));
     output = val >> 16;
-    upb_sink_putstring(&p->top->sink, sel, &output, 1, NULL);
+    upb_sink_putstring(p->top->sink, sel, &output, 1, NULL);
     return true;
   } else {
     uint32_t val;
@@ -527,16 +554,15 @@ otherchar:
 
     output[0] = val >> 16;
     output[1] = (val >> 8) & 0xff;
-    upb_sink_putstring(&p->top->sink, sel, output, 2, NULL);
+    upb_sink_putstring(p->top->sink, sel, output, 2, NULL);
     return true;
   }
 
 badpadding:
-  upb_status_seterrf(&p->status,
+  upb_status_seterrf(p->status,
                      "Incorrect base64 padding for field: %s (%.*s)",
                      upb_fielddef_name(p->top->f),
                      4, ptr);
-  upb_env_reporterror(p->env, &p->status);
   return false;
 }
 
@@ -580,10 +606,9 @@ static bool accumulate_realloc(upb_json_parser *p, size_t need) {
     new_size = saturating_multiply(new_size, 2);
   }
 
-  mem = upb_env_realloc(p->env, p->accumulate_buf, old_size, new_size);
+  mem = upb_arena_realloc(p->arena, p->accumulate_buf, old_size, new_size);
   if (!mem) {
-    upb_status_seterrmsg(&p->status, "Out of memory allocating buffer.");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "Out of memory allocating buffer.");
     return false;
   }
 
@@ -606,8 +631,7 @@ static bool accumulate_append(upb_json_parser *p, const char *buf, size_t len,
   }
 
   if (!checked_add(p->accumulated_len, len, &need)) {
-    upb_status_seterrmsg(&p->status, "Integer overflow.");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "Integer overflow.");
     return false;
   }
 
@@ -685,8 +709,7 @@ static bool multipart_text(upb_json_parser *p, const char *buf, size_t len,
   switch (p->multipart_state) {
     case MULTIPART_INACTIVE:
       upb_status_seterrmsg(
-          &p->status, "Internal error: unexpected state MULTIPART_INACTIVE");
-      upb_env_reporterror(p->env, &p->status);
+          p->status, "Internal error: unexpected state MULTIPART_INACTIVE");
       return false;
 
     case MULTIPART_ACCUMULATE:
@@ -697,7 +720,7 @@ static bool multipart_text(upb_json_parser *p, const char *buf, size_t len,
 
     case MULTIPART_PUSHEAGERLY: {
       const upb_bufhandle *handle = can_alias ? p->handle : NULL;
-      upb_sink_putstring(&p->top->sink, p->string_selector, buf, len, handle);
+      upb_sink_putstring(p->top->sink, p->string_selector, buf, len, handle);
       break;
     }
   }
@@ -943,7 +966,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
       } else if (val > INT32_MAX || val < INT32_MIN) {
         return false;
       } else {
-        upb_sink_putint32(&p->top->sink, parser_getsel(p), val);
+        upb_sink_putint32(p->top->sink, parser_getsel(p), val);
         return true;
       }
     }
@@ -954,7 +977,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
       } else if (val > UINT32_MAX || errno == ERANGE) {
         return false;
       } else {
-        upb_sink_putuint32(&p->top->sink, parser_getsel(p), val);
+        upb_sink_putuint32(p->top->sink, parser_getsel(p), val);
         return true;
       }
     }
@@ -965,7 +988,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
       if (errno == ERANGE || end != bufend) {
         break;
       } else {
-        upb_sink_putint64(&p->top->sink, parser_getsel(p), val);
+        upb_sink_putint64(p->top->sink, parser_getsel(p), val);
         return true;
       }
     }
@@ -976,7 +999,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
       } else if (errno == ERANGE) {
         return false;
       } else {
-        upb_sink_putuint64(&p->top->sink, parser_getsel(p), val);
+        upb_sink_putuint64(p->top->sink, parser_getsel(p), val);
         return true;
       }
     }
@@ -1007,7 +1030,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
       if (modf(val, &dummy) != 0 || val > max || val < min) {             \
         return false;                                                     \
       } else {                                                            \
-        upb_sink_put ## smalltype(&p->top->sink, parser_getsel(p),        \
+        upb_sink_put ## smalltype(p->top->sink, parser_getsel(p),        \
                                   (ctype)val);                            \
         return true;                                                      \
       }                                                                   \
@@ -1021,13 +1044,13 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
 #undef CASE
 
     case UPB_TYPE_DOUBLE:
-      upb_sink_putdouble(&p->top->sink, parser_getsel(p), val);
+      upb_sink_putdouble(p->top->sink, parser_getsel(p), val);
       return true;
     case UPB_TYPE_FLOAT:
       if ((val > FLT_MAX || val < -FLT_MAX) && val != inf && val != -inf) {
         return false;
       } else {
-        upb_sink_putfloat(&p->top->sink, parser_getsel(p), val);
+        upb_sink_putfloat(p->top->sink, parser_getsel(p), val);
         return true;
       }
     default:
@@ -1051,8 +1074,7 @@ static bool parse_number(upb_json_parser *p, bool is_quoted) {
     multipart_end(p);
     return true;
   } else {
-    upb_status_seterrf(&p->status, "error parsing number: %s", buf);
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrf(p->status, "error parsing number: %s", buf);
     multipart_end(p);
     return false;
   }
@@ -1066,14 +1088,13 @@ static bool parser_putbool(upb_json_parser *p, bool val) {
   }
 
   if (upb_fielddef_type(p->top->f) != UPB_TYPE_BOOL) {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
                        "Boolean value specified for non-bool field: %s",
                        upb_fielddef_name(p->top->f));
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
-  ok = upb_sink_putbool(&p->top->sink, parser_getsel(p), val);
+  ok = upb_sink_putbool(p->top->sink, parser_getsel(p), val);
   UPB_ASSERT(ok);
 
   return true;
@@ -1220,17 +1241,11 @@ static bool start_stringval(upb_json_parser *p) {
 
     /* Start a new parser frame: parser frames correspond one-to-one with
      * handler frames, and string events occur in a sub-frame. */
-    inner = p->top + 1;
+    inner = start_jsonparser_frame(p);
     sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
-    upb_sink_startstr(&p->top->sink, sel, 0, &inner->sink);
+    upb_sink_startstr(p->top->sink, sel, 0, &inner->sink);
     inner->m = p->top->m;
     inner->f = p->top->f;
-    inner->name_table = NULL;
-    inner->is_map = false;
-    inner->is_mapentry = false;
-    inner->is_any = false;
-    inner->any_frame = NULL;
-    inner->is_unknown_field = false;
     p->top = inner;
 
     if (upb_fielddef_type(p->top->f) == UPB_TYPE_STRING) {
@@ -1253,10 +1268,9 @@ static bool start_stringval(upb_json_parser *p) {
     multipart_startaccum(p);
     return true;
   } else {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
                        "String specified for bool or submessage field: %s",
                        upb_fielddef_name(p->top->f));
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 }
@@ -1272,11 +1286,11 @@ static bool end_any_stringval(upb_json_parser *p) {
   inner = p->top + 1;
 
   sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
-  upb_sink_startstr(&p->top->sink, sel, 0, &inner->sink);
+  upb_sink_startstr(p->top->sink, sel, 0, &inner->sink);
   sel = getsel_for_handlertype(p, UPB_HANDLER_STRING);
-  upb_sink_putstring(&inner->sink, sel, buf, len, NULL);
+  upb_sink_putstring(inner->sink, sel, buf, len, NULL);
   sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
-  upb_sink_endstr(&inner->sink, sel);
+  upb_sink_endstr(inner->sink, sel);
 
   multipart_end(p);
 
@@ -1289,18 +1303,16 @@ static bool end_any_stringval(upb_json_parser *p) {
     payload_type = upb_symtab_lookupmsg2(p->symtab, buf, len);
     if (payload_type == NULL) {
       upb_status_seterrf(
-          &p->status, "Cannot find packed type: %.*s\n", (int)len, buf);
-      upb_env_reporterror(p->env, &p->status);
+          p->status, "Cannot find packed type: %.*s\n", (int)len, buf);
       return false;
     }
 
     json_parser_any_frame_set_payload_type(p, p->top->any_frame, payload_type);
-    
+
     return true;
   } else {
     upb_status_seterrf(
-        &p->status, "Invalid type url: %.*s\n", (int)len, buf);
-    upb_env_reporterror(p->env, &p->status);
+        p->status, "Invalid type url: %.*s\n", (int)len, buf);
     return false;
   }
 }
@@ -1333,15 +1345,14 @@ static bool end_stringval_nontop(upb_json_parser *p) {
 
     case UPB_TYPE_STRING: {
       upb_selector_t sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
-      upb_sink_endstr(&p->top->sink, sel);
+      upb_sink_endstr(p->top->sink, sel);
       p->top--;
       break;
     }
 
     case UPB_TYPE_ENUM: {
       /* Resolve enum symbolic name to integer value. */
-      const upb_enumdef *enumdef =
-          (const upb_enumdef*)upb_fielddef_subdef(p->top->f);
+      const upb_enumdef *enumdef = upb_fielddef_enumsubdef(p->top->f);
 
       size_t len;
       const char *buf = accumulate_getptr(p, &len);
@@ -1351,10 +1362,9 @@ static bool end_stringval_nontop(upb_json_parser *p) {
 
       if (ok) {
         upb_selector_t sel = parser_getsel(p);
-        upb_sink_putint32(&p->top->sink, sel, int_val);
+        upb_sink_putint32(p->top->sink, sel, int_val);
       } else {
-        upb_status_seterrf(&p->status, "Enum value unknown: '%.*s'", len, buf);
-        upb_env_reporterror(p->env, &p->status);
+        upb_status_seterrf(p->status, "Enum value unknown: '%.*s'", len, buf);
       }
 
       break;
@@ -1371,8 +1381,7 @@ static bool end_stringval_nontop(upb_json_parser *p) {
 
     default:
       UPB_ASSERT(false);
-      upb_status_seterrmsg(&p->status, "Internal error in JSON decoder");
-      upb_env_reporterror(p->env, &p->status);
+      upb_status_seterrmsg(p->status, "Internal error in JSON decoder");
       ok = false;
       break;
   }
@@ -1462,25 +1471,22 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
   memcpy(seconds_buf, buf, fraction_start);
   seconds = strtol(seconds_buf, &end, 10);
   if (errno == ERANGE || end != seconds_buf + fraction_start) {
-    upb_status_seterrf(&p->status, "error parsing duration: %s",
+    upb_status_seterrf(p->status, "error parsing duration: %s",
                        seconds_buf);
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
   if (seconds > 315576000000) {
-    upb_status_seterrf(&p->status, "error parsing duration: "
+    upb_status_seterrf(p->status, "error parsing duration: "
                                    "maximum acceptable value is "
                                    "315576000000");
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
   if (seconds < -315576000000) {
-    upb_status_seterrf(&p->status, "error parsing duration: "
+    upb_status_seterrf(p->status, "error parsing duration: "
                                    "minimum acceptable value is "
                                    "-315576000000");
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1489,9 +1495,8 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
   memcpy(nanos_buf + 1, buf + fraction_start, len - fraction_start);
   val = strtod(nanos_buf, &end);
   if (errno == ERANGE || end != nanos_buf + len - fraction_start + 1) {
-    upb_status_seterrf(&p->status, "error parsing duration: %s",
+    upb_status_seterrf(p->status, "error parsing duration: %s",
                        nanos_buf);
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1506,7 +1511,7 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
   capture_begin(p, seconds_membername);
   capture_end(p, seconds_membername + 7);
   end_membername(p);
-  upb_sink_putint64(&p->top->sink, parser_getsel(p), seconds);
+  upb_sink_putint64(p->top->sink, parser_getsel(p), seconds);
   end_member(p);
 
   /* Set nanos */
@@ -1514,51 +1519,109 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
   capture_begin(p, nanos_membername);
   capture_end(p, nanos_membername + 5);
   end_membername(p);
-  upb_sink_putint32(&p->top->sink, parser_getsel(p), nanos);
+  upb_sink_putint32(p->top->sink, parser_getsel(p), nanos);
   end_member(p);
 
-  /* Continue previous environment */
+  /* Continue previous arena */
   multipart_startaccum(p);
 
   return true;
 }
 
-static void start_timestamp_base(upb_json_parser *p, const char *ptr) {
+static int parse_timestamp_number(upb_json_parser *p) {
+  size_t len;
+  const char *buf;
+  char *end;
+  int val;
+
+  /* atoi() and friends unfortunately do not support specifying the length of
+   * the input string, so we need to force a copy into a NULL-terminated buffer. */
+  multipart_text(p, "\0", 1, false);
+
+  buf = accumulate_getptr(p, &len);
+  val = atoi(buf);
+  multipart_end(p);
+  multipart_startaccum(p);
+
+  return val;
+}
+
+static void start_year(upb_json_parser *p, const char *ptr) {
   capture_begin(p, ptr);
 }
 
-#define UPB_TIMESTAMP_BASE_SIZE 19
+static bool end_year(upb_json_parser *p, const char *ptr) {
+  if (!capture_end(p, ptr)) {
+    return false;
+  }
+  p->tm.tm_year = parse_timestamp_number(p) - 1900;
+  return true;
+}
 
-static bool end_timestamp_base(upb_json_parser *p, const char *ptr) {
-  size_t len;
-  const char *buf;
-  /* 3 for GMT and 1 for ending 0 */
-  char timestamp_buf[UPB_TIMESTAMP_BASE_SIZE + 4];
+static void start_month(upb_json_parser *p, const char *ptr) {
+  capture_begin(p, ptr);
+}
 
+static bool end_month(upb_json_parser *p, const char *ptr) {
   if (!capture_end(p, ptr)) {
     return false;
   }
+  p->tm.tm_mon = parse_timestamp_number(p) - 1;
+  return true;
+}
 
-  buf = accumulate_getptr(p, &len);
-  UPB_ASSERT(len == UPB_TIMESTAMP_BASE_SIZE);
-  memcpy(timestamp_buf, buf, UPB_TIMESTAMP_BASE_SIZE);
-  memcpy(timestamp_buf + UPB_TIMESTAMP_BASE_SIZE, "GMT", 3);
-  timestamp_buf[UPB_TIMESTAMP_BASE_SIZE + 3] = 0;
-
-  /* Parse seconds */
-  if (strptime(timestamp_buf, "%FT%H:%M:%S%Z", &p->tm) == NULL) {
-    upb_status_seterrf(&p->status, "error parsing timestamp: %s", buf);
-    upb_env_reporterror(p->env, &p->status);
+static void start_day(upb_json_parser *p, const char *ptr) {
+  capture_begin(p, ptr);
+}
+
+static bool end_day(upb_json_parser *p, const char *ptr) {
+  if (!capture_end(p, ptr)) {
     return false;
   }
+  p->tm.tm_mday = parse_timestamp_number(p);
+  return true;
+}
 
-  /* Clean up buffer */
-  multipart_end(p);
-  multipart_startaccum(p);
+static void start_hour(upb_json_parser *p, const char *ptr) {
+  capture_begin(p, ptr);
+}
+
+static bool end_hour(upb_json_parser *p, const char *ptr) {
+  if (!capture_end(p, ptr)) {
+    return false;
+  }
+  p->tm.tm_hour = parse_timestamp_number(p);
+  return true;
+}
+
+static void start_minute(upb_json_parser *p, const char *ptr) {
+  capture_begin(p, ptr);
+}
+
+static bool end_minute(upb_json_parser *p, const char *ptr) {
+  if (!capture_end(p, ptr)) {
+    return false;
+  }
+  p->tm.tm_min = parse_timestamp_number(p);
+  return true;
+}
+
+static void start_second(upb_json_parser *p, const char *ptr) {
+  capture_begin(p, ptr);
+}
 
+static bool end_second(upb_json_parser *p, const char *ptr) {
+  if (!capture_end(p, ptr)) {
+    return false;
+  }
+  p->tm.tm_sec = parse_timestamp_number(p);
   return true;
 }
 
+static void start_timestamp_base(upb_json_parser *p) {
+  memset(&p->tm, 0, sizeof(struct tm));
+}
+
 static void start_timestamp_fraction(upb_json_parser *p, const char *ptr) {
   capture_begin(p, ptr);
 }
@@ -1581,9 +1644,8 @@ static bool end_timestamp_fraction(upb_json_parser *p, const char *ptr) {
   buf = accumulate_getptr(p, &len);
 
   if (len > 10) {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
         "error parsing timestamp: at most 9-digit fraction.");
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1593,9 +1655,8 @@ static bool end_timestamp_fraction(upb_json_parser *p, const char *ptr) {
   val = strtod(nanos_buf, &end);
 
   if (errno == ERANGE || end != nanos_buf + len + 1) {
-    upb_status_seterrf(&p->status, "error parsing timestamp nanos: %s",
+    upb_status_seterrf(p->status, "error parsing timestamp nanos: %s",
                        nanos_buf);
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1609,7 +1670,7 @@ static bool end_timestamp_fraction(upb_json_parser *p, const char *ptr) {
   capture_begin(p, nanos_membername);
   capture_end(p, nanos_membername + 5);
   end_membername(p);
-  upb_sink_putint32(&p->top->sink, parser_getsel(p), nanos);
+  upb_sink_putint32(p->top->sink, parser_getsel(p), nanos);
   end_member(p);
 
   /* Continue previous environment */
@@ -1637,8 +1698,7 @@ static bool end_timestamp_zone(upb_json_parser *p, const char *ptr) {
 
   if (buf[0] != 'Z') {
     if (sscanf(buf + 1, "%2d:00", &hours) != 1) {
-      upb_status_seterrf(&p->status, "error parsing timestamp offset");
-      upb_env_reporterror(p->env, &p->status);
+      upb_status_seterrf(p->status, "error parsing timestamp offset");
       return false;
     }
 
@@ -1654,10 +1714,9 @@ static bool end_timestamp_zone(upb_json_parser *p, const char *ptr) {
 
   /* Check timestamp boundary */
   if (seconds < -62135596800) {
-    upb_status_seterrf(&p->status, "error parsing timestamp: "
+    upb_status_seterrf(p->status, "error parsing timestamp: "
                                    "minimum acceptable value is "
                                    "0001-01-01T00:00:00Z");
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1669,7 +1728,7 @@ static bool end_timestamp_zone(upb_json_parser *p, const char *ptr) {
   capture_begin(p, seconds_membername);
   capture_end(p, seconds_membername + 7);
   end_membername(p);
-  upb_sink_putint64(&p->top->sink, parser_getsel(p), seconds);
+  upb_sink_putint64(p->top->sink, parser_getsel(p), seconds);
   end_member(p);
 
   /* Continue previous environment */
@@ -1683,9 +1742,7 @@ static void start_fieldmask_path_text(upb_json_parser *p, const char *ptr) {
 }
 
 static bool end_fieldmask_path_text(upb_json_parser *p, const char *ptr) {
-  if (!capture_end(p, ptr)) {
-    return false;
-  }
+  return capture_end(p, ptr);
 }
 
 static bool start_fieldmask_path(upb_json_parser *p) {
@@ -1696,17 +1753,11 @@ static bool start_fieldmask_path(upb_json_parser *p) {
 
   /* Start a new parser frame: parser frames correspond one-to-one with
    * handler frames, and string events occur in a sub-frame. */
-  inner = p->top + 1;
+  inner = start_jsonparser_frame(p);
   sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
-  upb_sink_startstr(&p->top->sink, sel, 0, &inner->sink);
+  upb_sink_startstr(p->top->sink, sel, 0, &inner->sink);
   inner->m = p->top->m;
   inner->f = p->top->f;
-  inner->name_table = NULL;
-  inner->is_map = false;
-  inner->is_mapentry = false;
-  inner->is_any = false;
-  inner->any_frame = NULL;
-  inner->is_unknown_field = false;
   p->top = inner;
 
   multipart_startaccum(p);
@@ -1720,10 +1771,10 @@ static bool lower_camel_push(
   for (;ptr < limit; ptr++) {
     if (*ptr >= 'A' && *ptr <= 'Z' && !first) {
       char lower = tolower(*ptr);
-      upb_sink_putstring(&p->top->sink, sel, "_", 1, NULL);
-      upb_sink_putstring(&p->top->sink, sel, &lower, 1, NULL);
+      upb_sink_putstring(p->top->sink, sel, "_", 1, NULL);
+      upb_sink_putstring(p->top->sink, sel, &lower, 1, NULL);
     } else {
-      upb_sink_putstring(&p->top->sink, sel, ptr, 1, NULL);
+      upb_sink_putstring(p->top->sink, sel, ptr, 1, NULL);
     }
     first = false;
   }
@@ -1740,7 +1791,7 @@ static bool end_fieldmask_path(upb_json_parser *p) {
   }
 
   sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
-  upb_sink_endstr(&p->top->sink, sel);
+  upb_sink_endstr(p->top->sink, sel);
   p->top--;
 
   multipart_end(p);
@@ -1767,8 +1818,7 @@ static bool parse_mapentry_key(upb_json_parser *p) {
 
   p->top->f = upb_msgdef_itof(p->top->m, UPB_MAPENTRY_KEY);
   if (p->top->f == NULL) {
-    upb_status_seterrmsg(&p->status, "mapentry message has no key");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "mapentry message has no key");
     return false;
   }
   switch (upb_fielddef_type(p->top->f)) {
@@ -1791,9 +1841,8 @@ static bool parse_mapentry_key(upb_json_parser *p) {
           return false;
         }
       } else {
-        upb_status_seterrmsg(&p->status,
+        upb_status_seterrmsg(p->status,
                              "Map bool key not 'true' or 'false'");
-        upb_env_reporterror(p->env, &p->status);
         return false;
       }
       multipart_end(p);
@@ -1802,17 +1851,16 @@ static bool parse_mapentry_key(upb_json_parser *p) {
     case UPB_TYPE_BYTES: {
       upb_sink subsink;
       upb_selector_t sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
-      upb_sink_startstr(&p->top->sink, sel, len, &subsink);
+      upb_sink_startstr(p->top->sink, sel, len, &subsink);
       sel = getsel_for_handlertype(p, UPB_HANDLER_STRING);
-      upb_sink_putstring(&subsink, sel, buf, len, NULL);
+      upb_sink_putstring(subsink, sel, buf, len, NULL);
       sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
-      upb_sink_endstr(&subsink, sel);
+      upb_sink_endstr(subsink, sel);
       multipart_end(p);
       break;
     }
     default:
-      upb_status_seterrmsg(&p->status, "Invalid field type for map key");
-      upb_env_reporterror(p->env, &p->status);
+      upb_status_seterrmsg(p->status, "Invalid field type for map key");
       return false;
   }
 
@@ -1842,17 +1890,12 @@ static bool handle_mapentry(upb_json_parser *p) {
   mapfield = p->top->mapfield;
   mapentrymsg = upb_fielddef_msgsubdef(mapfield);
 
-  inner = p->top + 1;
+  inner = start_jsonparser_frame(p);
   p->top->f = mapfield;
   sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSUBMSG);
-  upb_sink_startsubmsg(&p->top->sink, sel, &inner->sink);
+  upb_sink_startsubmsg(p->top->sink, sel, &inner->sink);
   inner->m = mapentrymsg;
-  inner->name_table = NULL;
   inner->mapfield = mapfield;
-  inner->is_map = false;
-  inner->is_any = false;
-  inner->any_frame = NULL;
-  inner->is_unknown_field = false;
 
   /* Don't set this to true *yet* -- we reuse parsing handlers below to push
    * the key field value to the sink, and these handlers will pop the frame
@@ -1862,7 +1905,7 @@ static bool handle_mapentry(upb_json_parser *p) {
   p->top = inner;
 
   /* send STARTMSG in submsg frame. */
-  upb_sink_startmsg(&p->top->sink);
+  upb_sink_startmsg(p->top->sink);
 
   parse_mapentry_key(p);
 
@@ -1871,8 +1914,7 @@ static bool handle_mapentry(upb_json_parser *p) {
   p->top->is_mapentry = true;  /* set up to pop frame after value is parsed. */
   p->top->mapfield = mapfield;
   if (p->top->f == NULL) {
-    upb_status_seterrmsg(&p->status, "mapentry message has no value");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "mapentry message has no value");
     return false;
   }
 
@@ -1907,8 +1949,7 @@ static bool end_membername(upb_json_parser *p) {
       multipart_end(p);
       return true;
     } else {
-      upb_status_seterrf(&p->status, "No such field: %.*s\n", (int)len, buf);
-      upb_env_reporterror(p->env, &p->status);
+      upb_status_seterrf(p->status, "No such field: %.*s\n", (int)len, buf);
       return false;
     }
   }
@@ -1934,21 +1975,20 @@ static bool end_any_membername(upb_json_parser *p) {
 static void end_member(upb_json_parser *p) {
   /* If we just parsed a map-entry value, end that frame too. */
   if (p->top->is_mapentry) {
-    upb_status s = UPB_STATUS_INIT;
     upb_selector_t sel;
     bool ok;
     const upb_fielddef *mapfield;
 
     UPB_ASSERT(p->top > p->stack);
     /* send ENDMSG on submsg. */
-    upb_sink_endmsg(&p->top->sink, &s);
+    upb_sink_endmsg(p->top->sink, p->status);
     mapfield = p->top->mapfield;
 
     /* send ENDSUBMSG in repeated-field-of-mapentries frame. */
     p->top--;
     ok = upb_handlers_getselector(mapfield, UPB_HANDLER_ENDSUBMSG, &sel);
     UPB_ASSERT(ok);
-    upb_sink_endsubmsg(&p->top->sink, sel);
+    upb_sink_endsubmsg(p->top->sink, sel);
   }
 
   p->top->f = NULL;
@@ -1970,15 +2010,7 @@ static bool start_subobject(upb_json_parser *p) {
     upb_jsonparser_frame *inner;
     if (!check_stack(p)) return false;
 
-    inner = p->top + 1;
-    inner->m = NULL;
-    inner->f = NULL;
-    inner->is_map = false;
-    inner->is_mapentry = false;
-    inner->is_any = false;
-    inner->any_frame = NULL;
-    inner->is_unknown_field = false;
-    p->top = inner;
+    p->top = start_jsonparser_frame(p);
     return true;
   }
 
@@ -1990,18 +2022,12 @@ static bool start_subobject(upb_json_parser *p) {
      * context. */
     if (!check_stack(p)) return false;
 
-    inner = p->top + 1;
+    inner = start_jsonparser_frame(p);
     sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSEQ);
-    upb_sink_startseq(&p->top->sink, sel, &inner->sink);
+    upb_sink_startseq(p->top->sink, sel, &inner->sink);
     inner->m = upb_fielddef_msgsubdef(p->top->f);
-    inner->name_table = NULL;
     inner->mapfield = p->top->f;
-    inner->f = NULL;
     inner->is_map = true;
-    inner->is_mapentry = false;
-    inner->is_any = false;
-    inner->any_frame = NULL;
-    inner->is_unknown_field = false;
     p->top = inner;
 
     return true;
@@ -2013,23 +2039,16 @@ static bool start_subobject(upb_json_parser *p) {
      * context. */
     if (!check_stack(p)) return false;
 
-    inner = p->top + 1;
-
+    inner = start_jsonparser_frame(p);
     sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSUBMSG);
-    upb_sink_startsubmsg(&p->top->sink, sel, &inner->sink);
+    upb_sink_startsubmsg(p->top->sink, sel, &inner->sink);
     inner->m = upb_fielddef_msgsubdef(p->top->f);
     set_name_table(p, inner);
-    inner->f = NULL;
-    inner->is_map = false;
-    inner->is_mapentry = false;
-    inner->is_unknown_field = false;
     p->top = inner;
 
     if (is_wellknown_msg(p, UPB_WELLKNOWN_ANY)) {
       p->top->is_any = true;
-      p->top->any_frame =
-          upb_env_malloc(p->env, sizeof(upb_jsonparser_any_frame));
-      json_parser_any_frame_reset(p->top->any_frame);
+      p->top->any_frame = json_parser_any_frame_new(p);
     } else {
       p->top->is_any = false;
       p->top->any_frame = NULL;
@@ -2037,10 +2056,9 @@ static bool start_subobject(upb_json_parser *p) {
 
     return true;
   } else {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
                        "Object specified for non-message/group field: %s",
                        upb_fielddef_name(p->top->f));
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 }
@@ -2078,14 +2096,14 @@ static void end_subobject(upb_json_parser *p) {
     upb_selector_t sel;
     p->top--;
     sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSEQ);
-    upb_sink_endseq(&p->top->sink, sel);
+    upb_sink_endseq(p->top->sink, sel);
   } else {
     upb_selector_t sel;
     bool is_unknown = p->top->m == NULL;
     p->top--;
     if (!is_unknown) {
       sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSUBMSG);
-      upb_sink_endsubmsg(&p->top->sink, sel);
+      upb_sink_endsubmsg(p->top->sink, sel);
     }
   }
 }
@@ -2122,10 +2140,14 @@ static bool start_array(upb_json_parser *p) {
     } else {
       return false;
     }
-  } else if (is_wellknown_field(p, UPB_WELLKNOWN_LISTVALUE)) {
+  } else if (is_wellknown_field(p, UPB_WELLKNOWN_LISTVALUE) &&
+             (!upb_fielddef_isseq(p->top->f) ||
+              p->top->is_repeated)) {
     if (!start_subobject(p)) return false;
     start_listvalue_object(p);
-  } else if (is_wellknown_field(p, UPB_WELLKNOWN_VALUE)) {
+  } else if (is_wellknown_field(p, UPB_WELLKNOWN_VALUE) &&
+             (!upb_fielddef_isseq(p->top->f) ||
+              p->top->is_repeated)) {
     if (!start_subobject(p)) return false;
     start_value_object(p, VALUE_LISTVALUE);
     if (!start_subobject(p)) return false;
@@ -2133,14 +2155,7 @@ static bool start_array(upb_json_parser *p) {
   }
 
   if (p->top->is_unknown_field) {
-    inner = p->top + 1;
-    inner->m = NULL;
-    inner->name_table = NULL;
-    inner->f = NULL;
-    inner->is_map = false;
-    inner->is_mapentry = false;
-    inner->is_any = false;
-    inner->any_frame = NULL;
+    inner = start_jsonparser_frame(p);
     inner->is_unknown_field = true;
     p->top = inner;
 
@@ -2148,26 +2163,20 @@ static bool start_array(upb_json_parser *p) {
   }
 
   if (!upb_fielddef_isseq(p->top->f)) {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
                        "Array specified for non-repeated field: %s",
                        upb_fielddef_name(p->top->f));
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
   if (!check_stack(p)) return false;
 
-  inner = p->top + 1;
+  inner = start_jsonparser_frame(p);
   sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSEQ);
-  upb_sink_startseq(&p->top->sink, sel, &inner->sink);
+  upb_sink_startseq(p->top->sink, sel, &inner->sink);
   inner->m = p->top->m;
-  inner->name_table = NULL;
   inner->f = p->top->f;
-  inner->is_map = false;
-  inner->is_mapentry = false;
-  inner->is_any = false;
-  inner->any_frame = NULL;
-  inner->is_unknown_field = false;
+  inner->is_repeated = true;
   p->top = inner;
 
   return true;
@@ -2185,7 +2194,7 @@ static void end_array(upb_json_parser *p) {
   }
 
   sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSEQ);
-  upb_sink_endseq(&p->top->sink, sel);
+  upb_sink_endseq(p->top->sink, sel);
 
   if (is_wellknown_msg(p, UPB_WELLKNOWN_LISTVALUE)) {
     end_listvalue_object(p);
@@ -2204,18 +2213,13 @@ static void end_array(upb_json_parser *p) {
 
 static void start_object(upb_json_parser *p) {
   if (!p->top->is_map && p->top->m != NULL) {
-    upb_sink_startmsg(&p->top->sink);
+    upb_sink_startmsg(p->top->sink);
   }
 }
 
 static void end_object(upb_json_parser *p) {
   if (!p->top->is_map && p->top->m != NULL) {
-    upb_status status;
-    upb_status_clear(&status);
-    upb_sink_endmsg(&p->top->sink, &status);
-    if (!upb_ok(&status)) {
-      upb_env_reporterror(p->env, &status);
-    }
+    upb_sink_endmsg(p->top->sink, p->status);
   }
 }
 
@@ -2234,8 +2238,7 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
 
   if (json_parser_any_frame_has_value(p->top->any_frame) &&
       !json_parser_any_frame_has_type_url(p->top->any_frame)) {
-    upb_status_seterrmsg(&p->status, "No valid type url");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "No valid type url");
     return false;
   }
 
@@ -2250,8 +2253,7 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
                  p->top->any_frame->before_type_url_end -
                  p->top->any_frame->before_type_url_start);
       if (p->top->any_frame->before_type_url_start == NULL) {
-        upb_status_seterrmsg(&p->status, "invalid data for well known type.");
-        upb_env_reporterror(p->env, &p->status);
+        upb_status_seterrmsg(p->status, "invalid data for well known type.");
         return false;
       }
       p->top->any_frame->before_type_url_start++;
@@ -2263,8 +2265,7 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
                  (ptr + 1) -
                  p->top->any_frame->after_type_url_start);
       if (p->top->any_frame->after_type_url_start == NULL) {
-        upb_status_seterrmsg(&p->status, "Invalid data for well known type.");
-        upb_env_reporterror(p->env, &p->status);
+        upb_status_seterrmsg(p->status, "Invalid data for well known type.");
         return false;
       }
       p->top->any_frame->after_type_url_start++;
@@ -2324,12 +2325,12 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
   inner = p->top + 1;
 
   sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
-  upb_sink_startstr(&p->top->sink, sel, 0, &inner->sink);
+  upb_sink_startstr(p->top->sink, sel, 0, &inner->sink);
   sel = getsel_for_handlertype(p, UPB_HANDLER_STRING);
-  upb_sink_putstring(&inner->sink, sel, p->top->any_frame->stringsink.ptr,
+  upb_sink_putstring(inner->sink, sel, p->top->any_frame->stringsink.ptr,
                      p->top->any_frame->stringsink.len, NULL);
   sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
-  upb_sink_endstr(&inner->sink, sel);
+  upb_sink_endstr(inner->sink, sel);
 
   end_member(p);
 
@@ -2337,7 +2338,6 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
 
   /* Deallocate any parse frame. */
   json_parser_any_frame_free(p->top->any_frame);
-  upb_env_free(p->env, p->top->any_frame);
 
   return true;
 }
@@ -2521,10 +2521,6 @@ static bool does_fieldmask_end(upb_json_parser *p) {
   return p->top->m != NULL && is_fieldmask(p->top->m);
 }
 
-static bool is_fieldmask_object(upb_json_parser *p) {
-  return p->top->m != NULL && is_fieldmask(p->top->m);
-}
-
 #define CHECK_RETURN_TOP(x) if (!(x)) goto error
 
 
@@ -2588,12 +2584,36 @@ static bool is_fieldmask_object(upb_json_parser *p) {
       @{ fhold; fret; }
     ;
 
-  year = digit digit digit digit;
-  month = digit digit;
-  day = digit digit;
-  hour = digit digit;
-  minute = digit digit;
-  second = digit digit;
+  year = 
+    (digit digit digit digit)
+      >{ start_year(parser, p); }
+      %{ CHECK_RETURN_TOP(end_year(parser, p)); }
+    ;
+  month =
+    (digit digit)
+      >{ start_month(parser, p); }
+      %{ CHECK_RETURN_TOP(end_month(parser, p)); }
+    ;
+  day =
+    (digit digit)
+      >{ start_day(parser, p); }
+      %{ CHECK_RETURN_TOP(end_day(parser, p)); }
+    ;
+  hour =
+    (digit digit)
+      >{ start_hour(parser, p); }
+      %{ CHECK_RETURN_TOP(end_hour(parser, p)); }
+    ;
+  minute =
+    (digit digit)
+      >{ start_minute(parser, p); }
+      %{ CHECK_RETURN_TOP(end_minute(parser, p)); }
+    ;
+  second =
+    (digit digit)
+      >{ start_second(parser, p); }
+      %{ CHECK_RETURN_TOP(end_second(parser, p)); }
+    ;
 
   duration_machine :=
     ("-"? integer decimal?)
@@ -2605,12 +2625,11 @@ static bool is_fieldmask_object(upb_json_parser *p) {
 
   timestamp_machine :=
     (year "-" month "-" day "T" hour ":" minute ":" second)
-      >{ start_timestamp_base(parser, p); }
-      %{ CHECK_RETURN_TOP(end_timestamp_base(parser, p)); }
+      >{ start_timestamp_base(parser); }
     ("." digit+)?
       >{ start_timestamp_fraction(parser, p); }
       %{ CHECK_RETURN_TOP(end_timestamp_fraction(parser, p)); }
-    ([+\-] hour ":00" | "Z")
+    ([+\-] digit digit ":00" | "Z")
       >{ start_timestamp_zone(parser, p); }
       %{ CHECK_RETURN_TOP(end_timestamp_zone(parser, p)); }
     '"'
@@ -2754,8 +2773,7 @@ size_t parse(void *closure, const void *hd, const char *buf, size_t size,
   %% write exec;
 
   if (p != pe) {
-    upb_status_seterrf(&parser->status, "Parse error at '%.*s'\n", pe - p, p);
-    upb_env_reporterror(parser->env, &parser->status);
+    upb_status_seterrf(parser->status, "Parse error at '%.*s'\n", pe - p, p);
   } else {
     capture_suspend(parser, &p);
   }
@@ -2791,12 +2809,7 @@ static void json_parser_reset(upb_json_parser *p) {
   int top;
 
   p->top = p->stack;
-  p->top->f = NULL;
-  p->top->is_map = false;
-  p->top->is_mapentry = false;
-  p->top->is_any = false;
-  p->top->any_frame = NULL;
-  p->top->is_unknown_field = false;
+  init_frame(p->top);
 
   /* Emit Ragel initialization of the parser. */
   %% write init;
@@ -2806,110 +2819,78 @@ static void json_parser_reset(upb_json_parser *p) {
   p->multipart_state = MULTIPART_INACTIVE;
   p->capture = NULL;
   p->accumulated = NULL;
-  upb_status_clear(&p->status);
-}
-
-static void visit_json_parsermethod(const upb_refcounted *r,
-                                    upb_refcounted_visit *visit,
-                                    void *closure) {
-  const upb_json_parsermethod *method = (upb_json_parsermethod*)r;
-  visit(r, upb_msgdef_upcast2(method->msg), closure);
 }
 
-static void free_json_parsermethod(upb_refcounted *r) {
-  upb_json_parsermethod *method = (upb_json_parsermethod*)r;
-
-  upb_inttable_iter i;
-  upb_inttable_begin(&i, &method->name_tables);
-  for(; !upb_inttable_done(&i); upb_inttable_next(&i)) {
-    upb_value val = upb_inttable_iter_value(&i);
-    upb_strtable *t = upb_value_getptr(val);
-    upb_strtable_uninit(t);
-    upb_gfree(t);
-  }
+static upb_json_parsermethod *parsermethod_new(upb_json_codecache *c,
+                                               const upb_msgdef *md) {
+  upb_msg_field_iter i;
+  upb_alloc *alloc = upb_arena_alloc(c->arena);
 
-  upb_inttable_uninit(&method->name_tables);
+  upb_json_parsermethod *m = upb_malloc(alloc, sizeof(*m));
 
-  upb_gfree(r);
-}
-
-static void add_jsonname_table(upb_json_parsermethod *m, const upb_msgdef* md) {
-  upb_msg_field_iter i;
-  upb_strtable *t;
+  m->cache = c;
 
-  /* It would be nice to stack-allocate this, but protobufs do not limit the
-   * length of fields to any reasonable limit. */
-  char *buf = NULL;
-  size_t len = 0;
+  upb_byteshandler_init(&m->input_handler_);
+  upb_byteshandler_setstring(&m->input_handler_, parse, m);
+  upb_byteshandler_setendstr(&m->input_handler_, end, m);
 
-  if (upb_inttable_lookupptr(&m->name_tables, md, NULL)) {
-    return;
-  }
+  upb_strtable_init2(&m->name_table, UPB_CTYPE_CONSTPTR, alloc);
 
-  /* TODO(haberman): handle malloc failure. */
-  t = upb_gmalloc(sizeof(*t));
-  upb_strtable_init(t, UPB_CTYPE_CONSTPTR);
-  upb_inttable_insertptr(&m->name_tables, md, upb_value_ptr(t));
+  /* Build name_table */
 
   for(upb_msg_field_begin(&i, md);
       !upb_msg_field_done(&i);
       upb_msg_field_next(&i)) {
     const upb_fielddef *f = upb_msg_iter_field(&i);
+    upb_value v = upb_value_constptr(f);
+    char *buf;
 
     /* Add an entry for the JSON name. */
-    size_t field_len = upb_fielddef_getjsonname(f, buf, len);
-    if (field_len > len) {
-      size_t len2;
-      buf = upb_grealloc(buf, 0, field_len);
-      len = field_len;
-      len2 = upb_fielddef_getjsonname(f, buf, len);
-      UPB_ASSERT(len == len2);
-    }
-    upb_strtable_insert(t, buf, upb_value_constptr(f));
+    size_t len = upb_fielddef_getjsonname(f, NULL, 0);
+    buf = upb_malloc(alloc, len);
+    upb_fielddef_getjsonname(f, buf, len);
+    upb_strtable_insert3(&m->name_table, buf, strlen(buf), v, alloc);
 
     if (strcmp(buf, upb_fielddef_name(f)) != 0) {
       /* Since the JSON name is different from the regular field name, add an
        * entry for the raw name (compliant proto3 JSON parsers must accept
        * both). */
-      upb_strtable_insert(t, upb_fielddef_name(f), upb_value_constptr(f));
-    }
-
-    if (upb_fielddef_issubmsg(f)) {
-      add_jsonname_table(m, upb_fielddef_msgsubdef(f));
+      const char *name = upb_fielddef_name(f);
+      upb_strtable_insert3(&m->name_table, name, strlen(name), v, alloc);
     }
   }
 
-  upb_gfree(buf);
+  return m;
 }
 
 /* Public API *****************************************************************/
 
-upb_json_parser *upb_json_parser_create(upb_env *env,
+upb_json_parser *upb_json_parser_create(upb_arena *arena,
                                         const upb_json_parsermethod *method,
                                         const upb_symtab* symtab,
-                                        upb_sink *output,
+                                        upb_sink output,
+                                        upb_status *status,
                                         bool ignore_json_unknown) {
 #ifndef NDEBUG
-  const size_t size_before = upb_env_bytesallocated(env);
+  const size_t size_before = upb_arena_bytesallocated(arena);
 #endif
-  upb_json_parser *p = upb_env_malloc(env, sizeof(upb_json_parser));
+  upb_json_parser *p = upb_arena_malloc(arena, sizeof(upb_json_parser));
   if (!p) return false;
 
-  p->env = env;
+  p->arena = arena;
   p->method = method;
+  p->status = status;
   p->limit = p->stack + UPB_JSON_MAX_DEPTH;
   p->accumulate_buf = NULL;
   p->accumulate_buf_size = 0;
   upb_bytessink_reset(&p->input_, &method->input_handler_, p);
 
   json_parser_reset(p);
-  upb_sink_reset(&p->top->sink, output->handlers, output->closure);
-  p->top->m = upb_handlers_msgdef(output->handlers);
+  p->top->sink = output;
+  p->top->m = upb_handlers_msgdef(output.handlers);
   if (is_wellknown_msg(p, UPB_WELLKNOWN_ANY)) {
     p->top->is_any = true;
-    p->top->any_frame =
-        upb_env_malloc(p->env, sizeof(upb_jsonparser_any_frame));
-    json_parser_any_frame_reset(p->top->any_frame);
+    p->top->any_frame = json_parser_any_frame_new(p);
   } else {
     p->top->is_any = false;
     p->top->any_frame = NULL;
@@ -2920,38 +2901,72 @@ upb_json_parser *upb_json_parser_create(upb_env *env,
   p->ignore_json_unknown = ignore_json_unknown;
 
   /* If this fails, uncomment and increase the value in parser.h. */
-  /* fprintf(stderr, "%zd\n", upb_env_bytesallocated(env) - size_before); */
-  UPB_ASSERT_DEBUGVAR(upb_env_bytesallocated(env) - size_before <=
+  /* fprintf(stderr, "%zd\n", upb_arena_bytesallocated(arena) - size_before); */
+  UPB_ASSERT_DEBUGVAR(upb_arena_bytesallocated(arena) - size_before <=
                       UPB_JSON_PARSER_SIZE);
   return p;
 }
 
-upb_bytessink *upb_json_parser_input(upb_json_parser *p) {
-  return &p->input_;
+upb_bytessink upb_json_parser_input(upb_json_parser *p) {
+  return p->input_;
 }
 
-upb_json_parsermethod *upb_json_parsermethod_new(const upb_msgdef* md,
-                                                 const void* owner) {
-  static const struct upb_refcounted_vtbl vtbl = {visit_json_parsermethod,
-                                                  free_json_parsermethod};
-  upb_json_parsermethod *ret = upb_gmalloc(sizeof(*ret));
-  upb_refcounted_init(upb_json_parsermethod_upcast_mutable(ret), &vtbl, owner);
+const upb_byteshandler *upb_json_parsermethod_inputhandler(
+    const upb_json_parsermethod *m) {
+  return &m->input_handler_;
+}
 
-  ret->msg = md;
-  upb_ref2(md, ret);
+upb_json_codecache *upb_json_codecache_new() {
+  upb_alloc *alloc;
+  upb_json_codecache *c;
 
-  upb_byteshandler_init(&ret->input_handler_);
-  upb_byteshandler_setstring(&ret->input_handler_, parse, ret);
-  upb_byteshandler_setendstr(&ret->input_handler_, end, ret);
+  c = upb_gmalloc(sizeof(*c));
 
-  upb_inttable_init(&ret->name_tables, UPB_CTYPE_PTR);
+  c->arena = upb_arena_new();
+  alloc = upb_arena_alloc(c->arena);
 
-  add_jsonname_table(ret, md);
+  upb_inttable_init2(&c->methods, UPB_CTYPE_CONSTPTR, alloc);
 
-  return ret;
+  return c;
 }
 
-const upb_byteshandler *upb_json_parsermethod_inputhandler(
-    const upb_json_parsermethod *m) {
-  return &m->input_handler_;
+void upb_json_codecache_free(upb_json_codecache *c) {
+  upb_arena_free(c->arena);
+  upb_gfree(c);
+}
+
+const upb_json_parsermethod *upb_json_codecache_get(upb_json_codecache *c,
+                                                    const upb_msgdef *md) {
+  upb_json_parsermethod *m;
+  upb_value v;
+  upb_msg_field_iter i;
+  upb_alloc *alloc = upb_arena_alloc(c->arena);
+
+  if (upb_inttable_lookupptr(&c->methods, md, &v)) {
+    return upb_value_getconstptr(v);
+  }
+
+  m = parsermethod_new(c, md);
+  v = upb_value_constptr(m);
+
+  if (!m) return NULL;
+  if (!upb_inttable_insertptr2(&c->methods, md, v, alloc)) return NULL;
+
+  /* Populate parser methods for all submessages, so the name tables will
+   * be available during parsing. */
+  for(upb_msg_field_begin(&i, md);
+      !upb_msg_field_done(&i);
+      upb_msg_field_next(&i)) {
+    upb_fielddef *f = upb_msg_iter_field(&i);
+
+    if (upb_fielddef_issubmsg(f)) {
+      const upb_msgdef *subdef = upb_fielddef_msgsubdef(f);
+      const upb_json_parsermethod *sub_method =
+          upb_json_codecache_get(c, subdef);
+
+      if (!sub_method) return NULL;
+    }
+  }
+
+  return m;
 }
diff --git a/upb/json/printer.c b/upb/json/printer.c
index 2283d55..72f26b2 100644
--- a/upb/json/printer.c
+++ b/upb/json/printer.c
@@ -5,15 +5,16 @@
 
 #include "upb/json/printer.h"
 
-#include <string.h>
+#include <ctype.h>
 #include <stdint.h>
+#include <string.h>
 #include <time.h>
 
 struct upb_json_printer {
   upb_sink input_;
   /* BytesSink closure. */
   void *subc_;
-  upb_bytessink *output_;
+  upb_bytessink output_;
 
   /* We track the depth so that we know when to emit startstr/endstr on the
    * output. */
@@ -48,6 +49,10 @@ void freestrpc(void *ptr) {
   upb_gfree(pc);
 }
 
+typedef struct {
+  bool preserve_fieldnames;
+} upb_json_printercache;
+
 /* Convert fielddef name to JSON name and return as a string piece. */
 strpc *newstrpc(upb_handlers *h, const upb_fielddef *f,
                 bool preserve_fieldnames) {
@@ -445,9 +450,14 @@ static size_t putbytes(void *closure, const void *handler_data, const char *str,
   UPB_UNUSED(handler_data);
   UPB_UNUSED(handle);
 
+  print_data(p, "\"", 1);
+
   while (remaining > 2) {
-    /* TODO(haberman): handle encoded lengths > sizeof(data) */
-    UPB_ASSERT((limit - to) >= 4);
+    if (limit - to < 4) {
+      bytes = to - data;
+      putstring(p, data, bytes);
+      to = data;
+    }
 
     to[0] = base64[from[0] >> 2];
     to[1] = base64[((from[0] & 0x3) << 4) | (from[1] >> 4)];
@@ -479,7 +489,6 @@ static size_t putbytes(void *closure, const void *handler_data, const char *str,
   }
 
   bytes = to - data;
-  print_data(p, "\"", 1);
   putstring(p, data, bytes);
   print_data(p, "\"", 1);
   return len;
@@ -594,10 +603,10 @@ static void set_enum_hd(upb_handlers *h,
                         bool preserve_fieldnames,
                         upb_handlerattr *attr) {
   EnumHandlerData *hd = upb_gmalloc(sizeof(EnumHandlerData));
-  hd->enumdef = (const upb_enumdef *)upb_fielddef_subdef(f);
+  hd->enumdef = upb_fielddef_enumsubdef(f);
   hd->keyname = newstrpc(h, f, preserve_fieldnames);
   upb_handlers_addcleanup(h, hd, upb_gfree);
-  upb_handlerattr_sethandlerdata(attr, hd);
+  attr->handler_data = hd;
 }
 
 /* Set up handlers for a mapentry submessage (i.e., an individual key/value pair
@@ -622,7 +631,7 @@ void printer_sethandlers_mapentry(const void *closure, bool preserve_fieldnames,
   const upb_fielddef* key_field = upb_msgdef_itof(md, UPB_MAPENTRY_KEY);
   const upb_fielddef* value_field = upb_msgdef_itof(md, UPB_MAPENTRY_VALUE);
 
-  upb_handlerattr empty_attr = UPB_HANDLERATTR_INITIALIZER;
+  upb_handlerattr empty_attr = UPB_HANDLERATTR_INIT;
 
   UPB_UNUSED(closure);
 
@@ -686,10 +695,9 @@ void printer_sethandlers_mapentry(const void *closure, bool preserve_fieldnames,
       upb_handlers_setstring(h, value_field, putbytes, &empty_attr);
       break;
     case UPB_TYPE_ENUM: {
-      upb_handlerattr enum_attr = UPB_HANDLERATTR_INITIALIZER;
+      upb_handlerattr enum_attr = UPB_HANDLERATTR_INIT;
       set_enum_hd(h, value_field, preserve_fieldnames, &enum_attr);
       upb_handlers_setint32(h, value_field, mapvalue_enum, &enum_attr);
-      upb_handlerattr_uninit(&enum_attr);
       break;
     }
     case UPB_TYPE_MESSAGE:
@@ -697,8 +705,6 @@ void printer_sethandlers_mapentry(const void *closure, bool preserve_fieldnames,
        * as appropriate. */
       break;
   }
-
-  upb_handlerattr_uninit(&empty_attr);
 }
 
 static bool putseconds(void *closure, const void *handler_data,
@@ -752,7 +758,6 @@ static void *startseq_fieldmask(void *closure, const void *handler_data) {
   UPB_UNUSED(handler_data);
   p->depth_++;
   p->first_elem_[p->depth_] = true;
-  print_data(p, "\"", 1);
   return closure;
 }
 
@@ -760,7 +765,6 @@ static bool endseq_fieldmask(void *closure, const void *handler_data) {
   upb_json_printer *p = closure;
   UPB_UNUSED(handler_data);
   p->depth_--;
-  print_data(p, "\"", 1);
   return true;
 }
 
@@ -980,6 +984,29 @@ static bool printer_endmsg_noframe(
   return true;
 }
 
+static bool printer_startmsg_fieldmask(
+    void *closure, const void *handler_data) {
+  upb_json_printer *p = closure;
+  UPB_UNUSED(handler_data);
+  if (p->depth_ == 0) {
+    upb_bytessink_start(p->output_, 0, &p->subc_);
+  }
+  print_data(p, "\"", 1);
+  return true;
+}
+
+static bool printer_endmsg_fieldmask(
+    void *closure, const void *handler_data, upb_status *s) {
+  upb_json_printer *p = closure;
+  UPB_UNUSED(handler_data);
+  UPB_UNUSED(s);
+  print_data(p, "\"", 1);
+  if (p->depth_ == 0) {
+    upb_bytessink_end(p->output_);
+  }
+  return true;
+}
+
 static void *scalar_startstr_onlykey(
     void *closure, const void *handler_data, size_t size_hint) {
   upb_json_printer *p = closure;
@@ -995,16 +1022,16 @@ void printer_sethandlers_any(const void *closure, upb_handlers *h) {
   const upb_fielddef* type_field = upb_msgdef_itof(md, UPB_ANY_TYPE);
   const upb_fielddef* value_field = upb_msgdef_itof(md, UPB_ANY_VALUE);
 
-  upb_handlerattr empty_attr = UPB_HANDLERATTR_INITIALIZER;
+  upb_handlerattr empty_attr = UPB_HANDLERATTR_INIT;
 
   /* type_url's json name is "@type" */
-  upb_handlerattr type_name_attr = UPB_HANDLERATTR_INITIALIZER;
-  upb_handlerattr value_name_attr = UPB_HANDLERATTR_INITIALIZER;
+  upb_handlerattr type_name_attr = UPB_HANDLERATTR_INIT;
+  upb_handlerattr value_name_attr = UPB_HANDLERATTR_INIT;
   strpc *type_url_json_name = newstrpc_str(h, "@type");
   strpc *value_json_name = newstrpc_str(h, "value");
 
-  upb_handlerattr_sethandlerdata(&type_name_attr, type_url_json_name);
-  upb_handlerattr_sethandlerdata(&value_name_attr, value_json_name);
+  type_name_attr.handler_data = type_url_json_name;
+  value_name_attr.handler_data = value_json_name;
 
   /* Set up handlers. */
   upb_handlers_setstartmsg(h, printer_startmsg, &empty_attr);
@@ -1028,13 +1055,13 @@ void printer_sethandlers_fieldmask(const void *closure, upb_handlers *h) {
   const upb_msgdef *md = upb_handlers_msgdef(h);
   const upb_fielddef* f = upb_msgdef_itof(md, 1);
 
-  upb_handlerattr empty_attr = UPB_HANDLERATTR_INITIALIZER;
+  upb_handlerattr empty_attr = UPB_HANDLERATTR_INIT;
 
   upb_handlers_setstartseq(h, f, startseq_fieldmask, &empty_attr);
   upb_handlers_setendseq(h, f, endseq_fieldmask, &empty_attr);
 
-  upb_handlers_setstartmsg(h, printer_startmsg_noframe, &empty_attr);
-  upb_handlers_setendmsg(h, printer_endmsg_noframe, &empty_attr);
+  upb_handlers_setstartmsg(h, printer_startmsg_fieldmask, &empty_attr);
+  upb_handlers_setendmsg(h, printer_endmsg_fieldmask, &empty_attr);
 
   upb_handlers_setstartstr(h, f, repeated_startstr_fieldmask, &empty_attr);
   upb_handlers_setstring(h, f, repeated_str_fieldmask, &empty_attr);
@@ -1051,7 +1078,7 @@ void printer_sethandlers_duration(const void *closure, upb_handlers *h) {
   const upb_fielddef* nanos_field =
       upb_msgdef_itof(md, UPB_DURATION_NANOS);
 
-  upb_handlerattr empty_attr = UPB_HANDLERATTR_INITIALIZER;
+  upb_handlerattr empty_attr = UPB_HANDLERATTR_INIT;
 
   upb_handlers_setstartmsg(h, printer_startdurationmsg, &empty_attr);
   upb_handlers_setint64(h, seconds_field, putseconds, &empty_attr);
@@ -1071,7 +1098,7 @@ void printer_sethandlers_timestamp(const void *closure, upb_handlers *h) {
   const upb_fielddef* nanos_field =
       upb_msgdef_itof(md, UPB_TIMESTAMP_NANOS);
 
-  upb_handlerattr empty_attr = UPB_HANDLERATTR_INITIALIZER;
+  upb_handlerattr empty_attr = UPB_HANDLERATTR_INIT;
 
   upb_handlers_setstartmsg(h, printer_starttimestampmsg, &empty_attr);
   upb_handlers_setint64(h, seconds_field, putseconds, &empty_attr);
@@ -1085,7 +1112,7 @@ void printer_sethandlers_value(const void *closure, upb_handlers *h) {
   const upb_msgdef *md = upb_handlers_msgdef(h);
   upb_msg_field_iter i;
 
-  upb_handlerattr empty_attr = UPB_HANDLERATTR_INITIALIZER;
+  upb_handlerattr empty_attr = UPB_HANDLERATTR_INIT;
 
   upb_handlers_setstartmsg(h, printer_startmsg_noframe, &empty_attr);
   upb_handlers_setendmsg(h, printer_endmsg_noframe, &empty_attr);
@@ -1124,7 +1151,7 @@ void printer_sethandlers_value(const void *closure, upb_handlers *h) {
 void printer_sethandlers_##wrapper(const void *closure, upb_handlers *h) { \
   const upb_msgdef *md = upb_handlers_msgdef(h);                           \
   const upb_fielddef* f = upb_msgdef_itof(md, 1);                          \
-  upb_handlerattr empty_attr = UPB_HANDLERATTR_INITIALIZER;                \
+  upb_handlerattr empty_attr = UPB_HANDLERATTR_INIT;                \
   upb_handlers_setstartmsg(h, printer_startmsg_noframe, &empty_attr);      \
   upb_handlers_setendmsg(h, printer_endmsg_noframe, &empty_attr);          \
   upb_handlers_set##type(h, f, putmethod, &empty_attr);                    \
@@ -1147,7 +1174,7 @@ void printer_sethandlers_listvalue(const void *closure, upb_handlers *h) {
   const upb_msgdef *md = upb_handlers_msgdef(h);
   const upb_fielddef* f = upb_msgdef_itof(md, 1);
 
-  upb_handlerattr empty_attr = UPB_HANDLERATTR_INITIALIZER;
+  upb_handlerattr empty_attr = UPB_HANDLERATTR_INIT;
 
   upb_handlers_setstartseq(h, f, startseq_nokey, &empty_attr);
   upb_handlers_setendseq(h, f, endseq, &empty_attr);
@@ -1164,7 +1191,7 @@ void printer_sethandlers_structvalue(const void *closure, upb_handlers *h) {
   const upb_msgdef *md = upb_handlers_msgdef(h);
   const upb_fielddef* f = upb_msgdef_itof(md, 1);
 
-  upb_handlerattr empty_attr = UPB_HANDLERATTR_INITIALIZER;
+  upb_handlerattr empty_attr = UPB_HANDLERATTR_INIT;
 
   upb_handlers_setstartseq(h, f, startmap_nokey, &empty_attr);
   upb_handlers_setendseq(h, f, endmap, &empty_attr);
@@ -1180,10 +1207,10 @@ void printer_sethandlers_structvalue(const void *closure, upb_handlers *h) {
 void printer_sethandlers(const void *closure, upb_handlers *h) {
   const upb_msgdef *md = upb_handlers_msgdef(h);
   bool is_mapentry = upb_msgdef_mapentry(md);
-  upb_handlerattr empty_attr = UPB_HANDLERATTR_INITIALIZER;
+  upb_handlerattr empty_attr = UPB_HANDLERATTR_INIT;
   upb_msg_field_iter i;
-  const bool *preserve_fieldnames_ptr = closure;
-  const bool preserve_fieldnames = *preserve_fieldnames_ptr;
+  const upb_json_printercache *cache = closure;
+  const bool preserve_fieldnames = cache->preserve_fieldnames;
 
   if (is_mapentry) {
     /* mapentry messages are sufficiently different that we handle them
@@ -1250,9 +1277,8 @@ void printer_sethandlers(const void *closure, upb_handlers *h) {
   for(; !upb_msg_field_done(&i); upb_msg_field_next(&i)) {
     const upb_fielddef *f = upb_msg_iter_field(&i);
 
-    upb_handlerattr name_attr = UPB_HANDLERATTR_INITIALIZER;
-    upb_handlerattr_sethandlerdata(&name_attr,
-                                   newstrpc(h, f, preserve_fieldnames));
+    upb_handlerattr name_attr = UPB_HANDLERATTR_INIT;
+    name_attr.handler_data = newstrpc(h, f, preserve_fieldnames);
 
     if (upb_fielddef_ismap(f)) {
       upb_handlers_setstartseq(h, f, startmap, &name_attr);
@@ -1274,7 +1300,7 @@ void printer_sethandlers(const void *closure, upb_handlers *h) {
         /* For now, we always emit symbolic names for enums. We may want an
          * option later to control this behavior, but we will wait for a real
          * need first. */
-        upb_handlerattr enum_attr = UPB_HANDLERATTR_INITIALIZER;
+        upb_handlerattr enum_attr = UPB_HANDLERATTR_INIT;
         set_enum_hd(h, f, preserve_fieldnames, &enum_attr);
 
         if (upb_fielddef_isseq(f)) {
@@ -1283,7 +1309,6 @@ void printer_sethandlers(const void *closure, upb_handlers *h) {
           upb_handlers_setint32(h, f, scalar_enum, &enum_attr);
         }
 
-        upb_handlerattr_uninit(&enum_attr);
         break;
       }
       case UPB_TYPE_STRING:
@@ -1314,11 +1339,8 @@ void printer_sethandlers(const void *closure, upb_handlers *h) {
         }
         break;
     }
-
-    upb_handlerattr_uninit(&name_attr);
   }
 
-  upb_handlerattr_uninit(&empty_attr);
 #undef TYPE
 }
 
@@ -1329,13 +1351,13 @@ static void json_printer_reset(upb_json_printer *p) {
 
 /* Public API *****************************************************************/
 
-upb_json_printer *upb_json_printer_create(upb_env *e, const upb_handlers *h,
-                                          upb_bytessink *output) {
+upb_json_printer *upb_json_printer_create(upb_arena *a, const upb_handlers *h,
+                                          upb_bytessink output) {
 #ifndef NDEBUG
-  size_t size_before = upb_env_bytesallocated(e);
+  size_t size_before = upb_arena_bytesallocated(a);
 #endif
 
-  upb_json_printer *p = upb_env_malloc(e, sizeof(upb_json_printer));
+  upb_json_printer *p = upb_arena_malloc(a, sizeof(upb_json_printer));
   if (!p) return NULL;
 
   p->output_ = output;
@@ -1345,18 +1367,21 @@ upb_json_printer *upb_json_printer_create(upb_env *e, const upb_handlers *h,
   p->nanos = 0;
 
   /* If this fails, increase the value in printer.h. */
-  UPB_ASSERT_DEBUGVAR(upb_env_bytesallocated(e) - size_before <=
+  UPB_ASSERT_DEBUGVAR(upb_arena_bytesallocated(a) - size_before <=
                       UPB_JSON_PRINTER_SIZE);
   return p;
 }
 
-upb_sink *upb_json_printer_input(upb_json_printer *p) {
-  return &p->input_;
+upb_sink upb_json_printer_input(upb_json_printer *p) {
+  return p->input_;
 }
 
-const upb_handlers *upb_json_printer_newhandlers(const upb_msgdef *md,
-                                                 bool preserve_fieldnames,
-                                                 const void *owner) {
-  return upb_handlers_newfrozen(
-      md, owner, printer_sethandlers, &preserve_fieldnames);
+upb_handlercache *upb_json_printer_newcache(bool preserve_proto_fieldnames) {
+  upb_json_printercache *cache = upb_gmalloc(sizeof(*cache));
+  upb_handlercache *ret = upb_handlercache_new(printer_sethandlers, cache);
+
+  cache->preserve_fieldnames = preserve_proto_fieldnames;
+  upb_handlercache_addcleanup(ret, cache, upb_gfree);
+
+  return ret;
 }
diff --git a/upb/json/printer.h b/upb/json/printer.h
index 80644f1..85b9b12 100644
--- a/upb/json/printer.h
+++ b/upb/json/printer.h
@@ -12,74 +12,61 @@
 #ifdef __cplusplus
 namespace upb {
 namespace json {
-class Printer;
+class PrinterPtr;
 }  /* namespace json */
 }  /* namespace upb */
 #endif
 
-UPB_DECLARE_TYPE(upb::json::Printer, upb_json_printer)
+/* upb_json_printer ***********************************************************/
 
+#define UPB_JSON_PRINTER_SIZE 192
 
-/* upb::json::Printer *********************************************************/
+struct upb_json_printer;
+typedef struct upb_json_printer upb_json_printer;
 
-#define UPB_JSON_PRINTER_SIZE 192
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Native C API. */
+upb_json_printer *upb_json_printer_create(upb_arena *a, const upb_handlers *h,
+                                          upb_bytessink output);
+upb_sink upb_json_printer_input(upb_json_printer *p);
+const upb_handlers *upb_json_printer_newhandlers(const upb_msgdef *md,
+                                                 bool preserve_fieldnames,
+                                                 const void *owner);
+
+/* Lazily builds and caches handlers that will push encoded data to a bytessink.
+ * Any msgdef objects used with this object must outlive it. */
+upb_handlercache *upb_json_printer_newcache(bool preserve_proto_fieldnames);
 
 #ifdef __cplusplus
+}  /* extern "C" */
 
 /* Prints an incoming stream of data to a BytesSink in JSON format. */
-class upb::json::Printer {
+class upb::json::PrinterPtr {
  public:
-  static Printer* Create(Environment* env, const upb::Handlers* handlers,
-                         BytesSink* output);
+  PrinterPtr(upb_json_printer* ptr) : ptr_(ptr) {}
 
-  /* The input to the printer. */
-  Sink* input();
+  static PrinterPtr Create(Arena *arena, const upb::Handlers *handlers,
+                           BytesSink output) {
+    return PrinterPtr(
+        upb_json_printer_create(arena->ptr(), handlers, output.sink()));
+  }
 
-  /* Returns handlers for printing according to the specified schema.
-   * If preserve_proto_fieldnames is true, the output JSON will use the
-   * original .proto field names (ie. {"my_field":3}) instead of using
-   * camelCased names, which is the default: (eg. {"myField":3}). */
-  static reffed_ptr<const Handlers> NewHandlers(const upb::MessageDef* md,
-                                                bool preserve_proto_fieldnames);
+  /* The input to the printer. */
+  Sink input() { return upb_json_printer_input(ptr_); }
 
   static const size_t kSize = UPB_JSON_PRINTER_SIZE;
 
+  static HandlerCache NewCache(bool preserve_proto_fieldnames) {
+    return upb_json_printer_newcache(preserve_proto_fieldnames);
+  }
+
  private:
-  UPB_DISALLOW_POD_OPS(Printer, upb::json::Printer)
+  upb_json_printer* ptr_;
 };
 
-#endif
-
-UPB_BEGIN_EXTERN_C
-
-/* Native C API. */
-upb_json_printer *upb_json_printer_create(upb_env *e, const upb_handlers *h,
-                                          upb_bytessink *output);
-upb_sink *upb_json_printer_input(upb_json_printer *p);
-const upb_handlers *upb_json_printer_newhandlers(const upb_msgdef *md,
-                                                 bool preserve_fieldnames,
-                                                 const void *owner);
-
-UPB_END_EXTERN_C
-
-#ifdef __cplusplus
-
-namespace upb {
-namespace json {
-inline Printer* Printer::Create(Environment* env, const upb::Handlers* handlers,
-                                BytesSink* output) {
-  return upb_json_printer_create(env, handlers, output);
-}
-inline Sink* Printer::input() { return upb_json_printer_input(this); }
-inline reffed_ptr<const Handlers> Printer::NewHandlers(
-    const upb::MessageDef *md, bool preserve_proto_fieldnames) {
-  const Handlers* h = upb_json_printer_newhandlers(
-      md, preserve_proto_fieldnames, &h);
-  return reffed_ptr<const Handlers>(h, &h);
-}
-}  /* namespace json */
-}  /* namespace upb */
-
-#endif
+#endif  /* __cplusplus */
 
 #endif  /* UPB_JSON_TYPED_PRINTER_H_ */
diff --git a/upb/msg.c b/upb/msg.c
index c6f0c17..b46d41c 100644
--- a/upb/msg.c
+++ b/upb/msg.c
@@ -1,4 +1,6 @@
 
+#include <string.h>
+#include "upb/table.int.h"
 #include "upb/msg.h"
 #include "upb/structs.int.h"
 
@@ -15,8 +17,6 @@ bool upb_fieldtype_mapkeyok(upb_fieldtype_t type) {
 
 /** upb_msgval ****************************************************************/
 
-#define upb_alignof(t) offsetof(struct { char c; t x; }, x)
-
 /* These functions will generate real memcpy() calls on ARM sadly, because
  * the compiler assumes they might not be aligned. */
 
diff --git a/upb/msg.h b/upb/msg.h
index 058f4a9..78c3633 100644
--- a/upb/msg.h
+++ b/upb/msg.h
@@ -21,9 +21,10 @@
 #ifndef UPB_MSG_H_
 #define UPB_MSG_H_
 
-#include "upb/def.h"
-#include "upb/handlers.h"
-#include "upb/sink.h"
+#include <stdint.h>
+#include <string.h>
+#include "upb/upb.h"
+#include "upb/structs.int.h"
 
 #ifdef __cplusplus
 
@@ -36,18 +37,22 @@ class MessageLayout;
 
 #endif
 
-UPB_DECLARE_TYPE(upb::Map, upb_map)
-UPB_DECLARE_TYPE(upb::MapIterator, upb_mapiter)
-
-struct upb_array;
-typedef struct upb_array upb_array;
-
 /* TODO(haberman): C++ accessors */
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 typedef void upb_msg;
 
+struct upb_array;
+typedef struct upb_array upb_array;
+
+struct upb_map;
+typedef struct upb_map upb_map;
+
+struct upb_mapiter;
+typedef struct upb_mapiter upb_mapiter;
 
 /** upb_msglayout *************************************************************/
 
@@ -74,7 +79,6 @@ typedef struct upb_msglayout {
   bool extendable;
 } upb_msglayout;
 
-
 /** upb_strview ************************************************************/
 
 typedef struct {
@@ -89,8 +93,18 @@ UPB_INLINE upb_strview upb_strview_make(const char *data, size_t size) {
   return ret;
 }
 
+UPB_INLINE upb_strview upb_strview_makez(const char *data) {
+  return upb_strview_make(data, strlen(data));
+}
+
+UPB_INLINE bool upb_strview_eql(upb_strview a, upb_strview b) {
+  return a.size == b.size && memcmp(a.data, b.data, a.size) == 0;
+}
+
 #define UPB_STRVIEW_INIT(ptr, len) {ptr, len}
 
+#define UPB_STRVIEW_FORMAT "%.*s"
+#define UPB_STRVIEW_ARGS(view) (int)(view).size, (view).data
 
 /** upb_msgval ****************************************************************/
 
@@ -144,7 +158,6 @@ UPB_INLINE upb_msgval upb_msgval_makestr(const char *data, size_t size) {
   return upb_msgval_str(upb_strview_make(data, size));
 }
 
-
 /** upb_msg *******************************************************************/
 
 /* A upb_msg represents a protobuf message.  It always corresponds to a specific
@@ -204,7 +217,6 @@ bool upb_msg_clearfield(upb_msg *msg,
 
 /* TODO(haberman): copyfrom()/mergefrom()? */
 
-
 /** upb_array *****************************************************************/
 
 /* A upb_array stores data for a repeated field.  The memory management
@@ -224,7 +236,6 @@ upb_msgval upb_array_get(const upb_array *arr, size_t i);
 
 bool upb_array_set(upb_array *arr, size_t i, upb_msgval val);
 
-
 /** upb_map *******************************************************************/
 
 /* A upb_map stores data for a map field.  The memory management semantics are
@@ -256,7 +267,6 @@ bool upb_map_set(upb_map *map,
 /* Deletes an entry in the map.  Returns true if the key was present. */
 bool upb_map_del(upb_map *map, upb_msgval key);
 
-
 /** upb_mapiter ***************************************************************/
 
 /* For iterating over a map.  Map iterators are invalidated by mutations to the
@@ -278,6 +288,8 @@ upb_msgval upb_mapiter_value(const upb_mapiter *i);
 void upb_mapiter_setdone(upb_mapiter *i);
 bool upb_mapiter_isequal(const upb_mapiter *i1, const upb_mapiter *i2);
 
-UPB_END_EXTERN_C
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
 
 #endif /* UPB_MSG_H_ */
diff --git a/upb/msgfactory.c b/upb/msgfactory.c
index 05f5975..f082042 100644
--- a/upb/msgfactory.c
+++ b/upb/msgfactory.c
@@ -1,4 +1,5 @@
 
+#include "upb/handlers.h"
 #include "upb/msgfactory.h"
 
 static bool is_power_of_two(size_t val) {
@@ -196,7 +197,6 @@ static bool upb_msglayout_init(const upb_msgdef *m,
 struct upb_msgfactory {
   const upb_symtab *symtab;  /* We own a ref. */
   upb_inttable layouts;
-  upb_inttable mergehandlers;
 };
 
 upb_msgfactory *upb_msgfactory_new(const upb_symtab *symtab) {
@@ -204,7 +204,6 @@ upb_msgfactory *upb_msgfactory_new(const upb_symtab *symtab) {
 
   ret->symtab = symtab;
   upb_inttable_init(&ret->layouts, UPB_CTYPE_PTR);
-  upb_inttable_init(&ret->mergehandlers, UPB_CTYPE_CONSTPTR);
 
   return ret;
 }
@@ -217,14 +216,7 @@ void upb_msgfactory_free(upb_msgfactory *f) {
     upb_msglayout_free(l);
   }
 
-  upb_inttable_begin(&i, &f->mergehandlers);
-  for(; !upb_inttable_done(&i); upb_inttable_next(&i)) {
-    const upb_handlers *h = upb_value_getconstptr(upb_inttable_iter_value(&i));
-    upb_handlers_unref(h, f);
-  }
-
   upb_inttable_uninit(&f->layouts);
-  upb_inttable_uninit(&f->mergehandlers);
   upb_gfree(f);
 }
 
diff --git a/upb/msgfactory.h b/upb/msgfactory.h
index 8b12461..9b3b599 100644
--- a/upb/msgfactory.h
+++ b/upb/msgfactory.h
@@ -5,15 +5,14 @@
 #ifndef UPB_MSGFACTORY_H_
 #define UPB_MSGFACTORY_H_
 
-#ifdef __cplusplus
-namespace upb {
-class MessageFactory;
-}
-#endif
+/** upb_msgfactory ************************************************************/
 
-UPB_DECLARE_TYPE(upb::MessageFactory, upb_msgfactory)
+struct upb_msgfactory;
+typedef struct upb_msgfactory upb_msgfactory;
 
-/** upb_msgfactory ************************************************************/
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 /* A upb_msgfactory contains a cache of upb_msglayout, upb_handlers, and
  * upb_visitorplan objects.  These are the objects necessary to represent,
@@ -42,5 +41,8 @@ const upb_symtab *upb_msgfactory_symtab(const upb_msgfactory *f);
 const upb_msglayout *upb_msgfactory_getlayout(upb_msgfactory *f,
                                               const upb_msgdef *m);
 
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
 
 #endif /* UPB_MSGFACTORY_H_ */
diff --git a/upb/pb/compile_decoder.c b/upb/pb/compile_decoder.c
index cec7b2a..89f000a 100644
--- a/upb/pb/compile_decoder.c
+++ b/upb/pb/compile_decoder.c
@@ -4,11 +4,6 @@
 ** Code to compile a upb::Handlers into bytecode for decoding a protobuf
 ** according to that specific schema and destination handlers.
 **
-** Compiling to bytecode is always the first step.  If we are using the
-** interpreted decoder we leave it as bytecode and interpret that.  If we are
-** using a JIT decoder we use a code generator to turn the bytecode into native
-** code, LLVM IR, etc.
-**
 ** Bytecode definition is in decoder.int.h.
 */
 
@@ -23,80 +18,22 @@
 #define MAXLABEL 5
 #define EMPTYLABEL -1
 
-/* mgroup *********************************************************************/
-
-static void freegroup(upb_refcounted *r) {
-  mgroup *g = (mgroup*)r;
-  upb_inttable_uninit(&g->methods);
-#ifdef UPB_USE_JIT_X64
-  upb_pbdecoder_freejit(g);
-#endif
-  upb_gfree(g->bytecode);
-  upb_gfree(g);
-}
-
-static void visitgroup(const upb_refcounted *r, upb_refcounted_visit *visit,
-                       void *closure) {
-  const mgroup *g = (const mgroup*)r;
-  upb_inttable_iter i;
-  upb_inttable_begin(&i, &g->methods);
-  for(; !upb_inttable_done(&i); upb_inttable_next(&i)) {
-    upb_pbdecodermethod *method = upb_value_getptr(upb_inttable_iter_value(&i));
-    visit(r, upb_pbdecodermethod_upcast(method), closure);
-  }
-}
-
-mgroup *newgroup(const void *owner) {
-  mgroup *g = upb_gmalloc(sizeof(*g));
-  static const struct upb_refcounted_vtbl vtbl = {visitgroup, freegroup};
-  upb_refcounted_init(mgroup_upcast_mutable(g), &vtbl, owner);
-  upb_inttable_init(&g->methods, UPB_CTYPE_PTR);
-  g->bytecode = NULL;
-  g->bytecode_end = NULL;
-  return g;
-}
-
-
 /* upb_pbdecodermethod ********************************************************/
 
-static void freemethod(upb_refcounted *r) {
-  upb_pbdecodermethod *method = (upb_pbdecodermethod*)r;
-
-  if (method->dest_handlers_) {
-    upb_handlers_unref(method->dest_handlers_, method);
-  }
-
+static void freemethod(upb_pbdecodermethod *method) {
   upb_inttable_uninit(&method->dispatch);
   upb_gfree(method);
 }
 
-static void visitmethod(const upb_refcounted *r, upb_refcounted_visit *visit,
-                        void *closure) {
-  const upb_pbdecodermethod *m = (const upb_pbdecodermethod*)r;
-  visit(r, m->group, closure);
-}
-
 static upb_pbdecodermethod *newmethod(const upb_handlers *dest_handlers,
                                       mgroup *group) {
-  static const struct upb_refcounted_vtbl vtbl = {visitmethod, freemethod};
   upb_pbdecodermethod *ret = upb_gmalloc(sizeof(*ret));
-  upb_refcounted_init(upb_pbdecodermethod_upcast_mutable(ret), &vtbl, &ret);
   upb_byteshandler_init(&ret->input_handler_);
 
-  /* The method references the group and vice-versa, in a circular reference. */
-  upb_ref2(ret, group);
-  upb_ref2(group, ret);
-  upb_inttable_insertptr(&group->methods, dest_handlers, upb_value_ptr(ret));
-  upb_pbdecodermethod_unref(ret, &ret);
-
-  ret->group = mgroup_upcast_mutable(group);
+  ret->group = group;
   ret->dest_handlers_ = dest_handlers;
-  ret->is_native_ = false;  /* If we JIT, it will update this later. */
   upb_inttable_init(&ret->dispatch, UPB_CTYPE_UINT64);
 
-  if (ret->dest_handlers_) {
-    upb_handlers_ref(ret->dest_handlers_, ret);
-  }
   return ret;
 }
 
@@ -114,16 +51,28 @@ bool upb_pbdecodermethod_isnative(const upb_pbdecodermethod *m) {
   return m->is_native_;
 }
 
-const upb_pbdecodermethod *upb_pbdecodermethod_new(
-    const upb_pbdecodermethodopts *opts, const void *owner) {
-  const upb_pbdecodermethod *ret;
-  upb_pbcodecache cache;
 
-  upb_pbcodecache_init(&cache);
-  ret = upb_pbcodecache_getdecodermethod(&cache, opts);
-  upb_pbdecodermethod_ref(ret, owner);
-  upb_pbcodecache_uninit(&cache);
-  return ret;
+/* mgroup *********************************************************************/
+
+static void freegroup(mgroup *g) {
+  upb_inttable_iter i;
+
+  upb_inttable_begin(&i, &g->methods);
+  for(; !upb_inttable_done(&i); upb_inttable_next(&i)) {
+    freemethod(upb_value_getptr(upb_inttable_iter_value(&i)));
+  }
+
+  upb_inttable_uninit(&g->methods);
+  upb_gfree(g->bytecode);
+  upb_gfree(g);
+}
+
+mgroup *newgroup() {
+  mgroup *g = upb_gmalloc(sizeof(*g));
+  upb_inttable_init(&g->methods, UPB_CTYPE_PTR);
+  g->bytecode = NULL;
+  g->bytecode_end = NULL;
+  return g;
 }
 
 
@@ -355,7 +304,7 @@ static void putop(compiler *c, int op, ...) {
   va_end(ap);
 }
 
-#if defined(UPB_USE_JIT_X64) || defined(UPB_DUMP_BYTECODE)
+#if defined(UPB_DUMP_BYTECODE)
 
 const char *upb_pbdecoder_getopname(unsigned int op) {
 #define QUOTE(x) #x
@@ -558,7 +507,7 @@ static upb_pbdecodermethod *find_submethod(const compiler *c,
 
 static void putsel(compiler *c, opcode op, upb_selector_t sel,
                    const upb_handlers *h) {
-  if (upb_handlers_gethandler(h, sel)) {
+  if (upb_handlers_gethandler(h, sel, NULL)) {
     putop(c, op, sel);
   }
 }
@@ -574,9 +523,9 @@ static bool haslazyhandlers(const upb_handlers *h, const upb_fielddef *f) {
   if (!upb_fielddef_lazy(f))
     return false;
 
-  return upb_handlers_gethandler(h, getsel(f, UPB_HANDLER_STARTSTR)) ||
-         upb_handlers_gethandler(h, getsel(f, UPB_HANDLER_STRING)) ||
-         upb_handlers_gethandler(h, getsel(f, UPB_HANDLER_ENDSTR));
+  return upb_handlers_gethandler(h, getsel(f, UPB_HANDLER_STARTSTR), NULL) ||
+         upb_handlers_gethandler(h, getsel(f, UPB_HANDLER_STRING), NULL) ||
+         upb_handlers_gethandler(h, getsel(f, UPB_HANDLER_ENDSTR), NULL);
 }
 
 
@@ -814,10 +763,13 @@ static void find_methods(compiler *c, const upb_handlers *h) {
   upb_value v;
   upb_msg_field_iter i;
   const upb_msgdef *md;
+  upb_pbdecodermethod *method;
 
   if (upb_inttable_lookupptr(&c->group->methods, h, &v))
     return;
-  newmethod(h, c->group);
+
+  method = newmethod(h, c->group);
+  upb_inttable_insertptr(&c->group->methods, h, upb_value_ptr(method));
 
   /* Find submethods. */
   md = upb_handlers_msgdef(h);
@@ -866,42 +818,15 @@ static void set_bytecode_handlers(mgroup *g) {
 }
 
 
-/* JIT setup. *****************************************************************/
-
-#ifdef UPB_USE_JIT_X64
-
-static void sethandlers(mgroup *g, bool allowjit) {
-  g->jit_code = NULL;
-  if (allowjit) {
-    /* Compile byte-code into machine code, create handlers. */
-    upb_pbdecoder_jit(g);
-  } else {
-    set_bytecode_handlers(g);
-  }
-}
-
-#else  /* UPB_USE_JIT_X64 */
-
-static void sethandlers(mgroup *g, bool allowjit) {
-  /* No JIT compiled in; use bytecode handlers unconditionally. */
-  UPB_UNUSED(allowjit);
-  set_bytecode_handlers(g);
-}
-
-#endif  /* UPB_USE_JIT_X64 */
-
-
 /* TODO(haberman): allow this to be constructed for an arbitrary set of dest
  * handlers and other mgroups (but verify we have a transitive closure). */
-const mgroup *mgroup_new(const upb_handlers *dest, bool allowjit, bool lazy,
-                         const void *owner) {
+const mgroup *mgroup_new(const upb_handlers *dest, bool allowjit, bool lazy) {
   mgroup *g;
   compiler *c;
 
   UPB_UNUSED(allowjit);
-  UPB_ASSERT(upb_handlers_isfrozen(dest));
 
-  g = newgroup(owner);
+  g = newgroup();
   c = newcompiler(g, lazy);
   find_methods(c, dest);
 
@@ -932,63 +857,71 @@ const mgroup *mgroup_new(const upb_handlers *dest, bool allowjit, bool lazy,
   }
 #endif
 
-  sethandlers(g, allowjit);
+  set_bytecode_handlers(g);
   return g;
 }
 
 
 /* upb_pbcodecache ************************************************************/
 
-void upb_pbcodecache_init(upb_pbcodecache *c) {
-  upb_inttable_init(&c->groups, UPB_CTYPE_CONSTPTR);
-  c->allow_jit_ = true;
+upb_pbcodecache *upb_pbcodecache_new(upb_handlercache *dest) {
+  upb_pbcodecache *c = upb_gmalloc(sizeof(*c));
+
+  if (!c) return NULL;
+
+  c->dest = dest;
+  c->allow_jit = true;
+  c->lazy = false;
+
+  c->arena = upb_arena_new();
+  if (!upb_inttable_init(&c->groups, UPB_CTYPE_CONSTPTR)) return NULL;
+
+  return c;
 }
 
-void upb_pbcodecache_uninit(upb_pbcodecache *c) {
-  upb_inttable_iter i;
-  upb_inttable_begin(&i, &c->groups);
-  for(; !upb_inttable_done(&i); upb_inttable_next(&i)) {
-    const mgroup *group = upb_value_getconstptr(upb_inttable_iter_value(&i));
-    mgroup_unref(group, c);
+void upb_pbcodecache_free(upb_pbcodecache *c) {
+  size_t i;
+
+  for (i = 0; i < upb_inttable_count(&c->groups); i++) {
+    upb_value v;
+    bool ok = upb_inttable_lookup(&c->groups, i, &v);
+    UPB_ASSERT(ok);
+    freegroup((void*)upb_value_getconstptr(v));
   }
+
   upb_inttable_uninit(&c->groups);
+  upb_arena_free(c->arena);
+  upb_gfree(c);
 }
 
 bool upb_pbcodecache_allowjit(const upb_pbcodecache *c) {
-  return c->allow_jit_;
+  return c->allow_jit;
 }
 
-bool upb_pbcodecache_setallowjit(upb_pbcodecache *c, bool allow) {
-  if (upb_inttable_count(&c->groups) > 0)
-    return false;
-  c->allow_jit_ = allow;
-  return true;
+void upb_pbcodecache_setallowjit(upb_pbcodecache *c, bool allow) {
+  UPB_ASSERT(upb_inttable_count(&c->groups) == 0);
+  c->allow_jit = allow;
+}
+
+void upb_pbdecodermethodopts_setlazy(upb_pbcodecache *c, bool lazy) {
+  UPB_ASSERT(upb_inttable_count(&c->groups) == 0);
+  c->lazy = lazy;
 }
 
-const upb_pbdecodermethod *upb_pbcodecache_getdecodermethod(
-    upb_pbcodecache *c, const upb_pbdecodermethodopts *opts) {
+const upb_pbdecodermethod *upb_pbcodecache_get(upb_pbcodecache *c,
+                                               const upb_msgdef *md) {
   upb_value v;
   bool ok;
+  const upb_handlers *h;
+  const mgroup *g;
 
   /* Right now we build a new DecoderMethod every time.
    * TODO(haberman): properly cache methods by their true key. */
-  const mgroup *g = mgroup_new(opts->handlers, c->allow_jit_, opts->lazy, c);
+  h = upb_handlercache_get(c->dest, md);
+  g = mgroup_new(h, c->allow_jit, c->lazy);
   upb_inttable_push(&c->groups, upb_value_constptr(g));
 
-  ok = upb_inttable_lookupptr(&g->methods, opts->handlers, &v);
+  ok = upb_inttable_lookupptr(&g->methods, h, &v);
   UPB_ASSERT(ok);
   return upb_value_getptr(v);
 }
-
-
-/* upb_pbdecodermethodopts ****************************************************/
-
-void upb_pbdecodermethodopts_init(upb_pbdecodermethodopts *opts,
-                                  const upb_handlers *h) {
-  opts->handlers = h;
-  opts->lazy = false;
-}
-
-void upb_pbdecodermethodopts_setlazy(upb_pbdecodermethodopts *opts, bool lazy) {
-  opts->lazy = lazy;
-}
diff --git a/upb/pb/compile_decoder_x64.c b/upb/pb/compile_decoder_x64.c
deleted file mode 100644
index fd541a4..0000000
--- a/upb/pb/compile_decoder_x64.c
+++ /dev/null
@@ -1,510 +0,0 @@
-/*
-** Driver code for the x64 JIT compiler.
-*/
-
-/* Needed to ensure we get defines like MAP_ANON. */
-#define _GNU_SOURCE
-
-#include <dlfcn.h>
-#include <stdio.h>
-#include <sys/mman.h>
-#include <unistd.h>
-#include "upb/msg.h"
-#include "upb/pb/decoder.h"
-#include "upb/pb/decoder.int.h"
-#include "upb/pb/varint.int.h"
-
-/* To debug the JIT:
- *
- * 1. Uncomment:
- * #define UPB_JIT_LOAD_SO
- *
- * Note: this mode requires that we can shell out to gcc.
- *
- * 2. Run the test locally.  This will load the JIT code by building a
- *    .so (/tmp/upb-jit-code.so) and using dlopen, so more of the tooling will
- *    work properly (like GDB).
- *
- * IF YOU ALSO WANT AUTOMATIC JIT DEBUG OUTPUT:
- *
- * 3. Run: upb/pb/make-gdb-script.rb > script.gdb.  This reads
- *    /tmp/upb-jit-code.so as input and generates a GDB script that is specific
- *    to this jit code.
- *
- * 4. Run: gdb --command=script.gdb --args path/to/test
- *    This will drop you to a GDB prompt which you can now use normally.
- *    But when you run the test it will print a message to stdout every time
- *    the JIT executes assembly for a particular bytecode.  Sample output:
- *
- *    X.enterjit bytes=18
- *    buf_ofs=1 data_rem=17 delim_rem=-2 X.0x6.OP_PARSE_DOUBLE
- *    buf_ofs=9 data_rem=9 delim_rem=-10 X.0x7.OP_CHECKDELIM
- *    buf_ofs=9 data_rem=9 delim_rem=-10 X.0x8.OP_TAG1
- *    X.0x3.dispatch.DecoderTest
- *    X.parse_unknown
- *    X.0x3.dispatch.DecoderTest
- *    X.decode_unknown_tag_fallback
- *    X.exitjit
- *
- *    This output should roughly correspond to the output that the bytecode
- *    interpreter emits when compiled with UPB_DUMP_BYTECODE (modulo some
- *    extra JIT-specific output). */
-
-/* These defines are necessary for DynASM codegen.
- * See dynasm/dasm_proto.h for more info. */
-#define Dst_DECL jitcompiler *jc
-#define Dst_REF (jc->dynasm)
-#define Dst (jc)
-
-/* In debug mode, make DynASM do internal checks (must be defined before any
- * dasm header is included. */
-#ifndef NDEBUG
-#define DASM_CHECKS
-#endif
-
-#ifndef MAP_ANONYMOUS
-#define MAP_ANONYMOUS MAP_ANON
-#endif
-
-typedef struct {
-  mgroup *group;
-  uint32_t *pc;
-
-  /* This pointer is allocated by dasm_init() and freed by dasm_free(). */
-  struct dasm_State *dynasm;
-
-  /* Maps some key (an arbitrary void*) to a pclabel.
-   *
-   *  The pclabel represents a location in the generated code -- DynASM exposes
-   *  a pclabel -> (machine code offset) lookup function.
-   *
-   *  The key can be anything.  There are two main kinds of keys:
-   *    - bytecode location -- the void* points to the bytecode instruction
-   *      itself.  We can then use this to generate jumps to this instruction.
-   *    - other object (like dispatch table).  We use these to represent parts
-   *      of the generated code that do not exactly correspond to a bytecode
-   *      instruction. */
-   upb_inttable jmptargets;
-
-#ifndef NDEBUG
-  /* Like jmptargets, but members are present in the table when they have had
-   * define_jmptarget() (as opposed to jmptarget) called.  Used to verify that
-   * define_jmptarget() is called exactly once for every target.
-   * The value is ignored. */
-  upb_inttable jmpdefined;
-
-  /* For checking that two asmlabels aren't defined for the same byte. */
-  int lastlabelofs;
-#endif
-
-#ifdef UPB_JIT_LOAD_SO
-  /* For marking labels that should go into the generated code.
-   * Maps pclabel -> char* label (string is owned by the table). */
-  upb_inttable asmlabels;
-#endif
-
-  /* The total number of pclabels currently defined.
-   * Note that this contains both jmptargets and asmlabels, which both use
-   * pclabels but for different purposes. */
-  uint32_t pclabel_count;
-
-  /* Used by DynASM to store globals. */
-  void **globals;
-} jitcompiler;
-
-/* Functions called by codegen. */
-static int jmptarget(jitcompiler *jc, const void *key);
-static int define_jmptarget(jitcompiler *jc, const void *key);
-static void asmlabel(jitcompiler *jc, const char *fmt, ...);
-static int pcofs(jitcompiler* jc);
-static int alloc_pclabel(jitcompiler *jc);
-
-#ifdef UPB_JIT_LOAD_SO
-static char *upb_vasprintf(const char *fmt, va_list ap);
-static char *upb_asprintf(const char *fmt, ...);
-#endif
-
-#include "third_party/dynasm/dasm_proto.h"
-#include "third_party/dynasm/dasm_x86.h"
-#include "upb/pb/compile_decoder_x64.h"
-
-static jitcompiler *newjitcompiler(mgroup *group) {
-  jitcompiler *jc = malloc(sizeof(jitcompiler));
-  jc->group = group;
-  jc->pclabel_count = 0;
-  upb_inttable_init(&jc->jmptargets, UPB_CTYPE_UINT32);
-#ifndef NDEBUG
-  jc->lastlabelofs = -1;
-  upb_inttable_init(&jc->jmpdefined, UPB_CTYPE_BOOL);
-#endif
-#ifdef UPB_JIT_LOAD_SO
-  upb_inttable_init(&jc->asmlabels, UPB_CTYPE_PTR);
-#endif
-  jc->globals = malloc(UPB_JIT_GLOBAL__MAX * sizeof(*jc->globals));
-
-  dasm_init(jc, 1);
-  dasm_setupglobal(jc, jc->globals, UPB_JIT_GLOBAL__MAX);
-  dasm_setup(jc, upb_jit_actionlist);
-
-  return jc;
-}
-
-static void freejitcompiler(jitcompiler *jc) {
-#ifdef UPB_JIT_LOAD_SO
-  upb_inttable_iter i;
-  upb_inttable_begin(&i, &jc->asmlabels);
-  for (; !upb_inttable_done(&i); upb_inttable_next(&i)) {
-    free(upb_value_getptr(upb_inttable_iter_value(&i)));
-  }
-  upb_inttable_uninit(&jc->asmlabels);
-#endif
-#ifndef NDEBUG
-  upb_inttable_uninit(&jc->jmpdefined);
-#endif
-  upb_inttable_uninit(&jc->jmptargets);
-  dasm_free(jc);
-  free(jc->globals);
-  free(jc);
-}
-
-#ifdef UPB_JIT_LOAD_SO
-
-/* Like sprintf except allocates the string, which is returned and owned by the
- * caller.
- *
- * Like the GNU extension asprintf(), except we abort on error (since this is
- * only for debugging). */
-static char *upb_vasprintf(const char *fmt, va_list args) {
-  /* Run once to get the length of the string. */
-  va_list args_copy;
-  va_copy(args_copy, args);
-  int len = _upb_vsnprintf(NULL, 0, fmt, args_copy);
-  va_end(args_copy);
-
-  char *ret = malloc(len + 1);  /* + 1 for NULL terminator. */
-  if (!ret) abort();
-  int written = _upb_vsnprintf(ret, len + 1, fmt, args);
-  UPB_ASSERT(written == len);
-
-  return ret;
-}
-
-static char *upb_asprintf(const char *fmt, ...) {
-  va_list args;
-  va_start(args, fmt);
-  char *ret = upb_vasprintf(fmt, args);
-  va_end(args);
-  return ret;
-}
-
-#endif
-
-static int alloc_pclabel(jitcompiler *jc) {
-  int newpc = jc->pclabel_count++;
-  dasm_growpc(jc, jc->pclabel_count);
-  return newpc;
-}
-
-static bool try_getjmptarget(jitcompiler *jc, const void *key, int *pclabel) {
-  upb_value v;
-  if (upb_inttable_lookupptr(&jc->jmptargets, key, &v)) {
-    *pclabel = upb_value_getuint32(v);
-    return true;
-  } else {
-    return false;
-  }
-}
-
-/* Gets the pclabel for this bytecode location's jmptarget.  Requires that the
- * jmptarget() has been previously defined. */
-static int getjmptarget(jitcompiler *jc, const void *key) {
-  int pclabel = 0;
-  bool ok;
-
-  UPB_ASSERT_DEBUGVAR(upb_inttable_lookupptr(&jc->jmpdefined, key, NULL));
-  ok = try_getjmptarget(jc, key, &pclabel);
-  UPB_ASSERT(ok);
-  return pclabel;
-}
-
-/* Returns a pclabel that serves as a jmp target for the given bytecode pointer.
- * This should only be called for code that is jumping to the target; code
- * defining the target should use define_jmptarget().
- *
- * Creates/allocates a pclabel for this target if one does not exist already. */
-static int jmptarget(jitcompiler *jc, const void *key) {
-  // Optimizer sometimes can't figure out that initializing this is unnecessary.
-  int pclabel = 0;
-  if (!try_getjmptarget(jc, key, &pclabel)) {
-    pclabel = alloc_pclabel(jc);
-    upb_inttable_insertptr(&jc->jmptargets, key, upb_value_uint32(pclabel));
-  }
-  return pclabel;
-}
-
-/* Defines a pclabel associated with the given bytecode location.
- * Must be called exactly once by the code that is generating the code for this
- * bytecode.
- *
- * Must be called exactly once before bytecode generation is complete (this is a
- * sanity check to make sure the label is defined exactly once). */
-static int define_jmptarget(jitcompiler *jc, const void *key) {
-#ifndef NDEBUG
-  upb_inttable_insertptr(&jc->jmpdefined, key, upb_value_bool(true));
-#endif
-  return jmptarget(jc, key);
-}
-
-/* Returns a bytecode pc offset relative to the beginning of the group's
- * code. */
-static int pcofs(jitcompiler *jc) {
-  return jc->pc - jc->group->bytecode;
-}
-
-/* Returns a machine code offset corresponding to the given key.
- * Requires that this key was defined with define_jmptarget. */
-static int machine_code_ofs(jitcompiler *jc, const void *key) {
-  int pclabel = getjmptarget(jc, key);
-  /* Despite its name, this function takes a pclabel and returns the
-   * corresponding machine code offset. */
-  return dasm_getpclabel(jc, pclabel);
-}
-
-/* Returns a machine code offset corresponding to the given method-relative
- * bytecode offset.  Note that the bytecode offset is relative to the given
- * method, but the returned machine code offset is relative to the beginning of
- * *all* the machine code. */
-static int machine_code_ofs2(jitcompiler *jc, const upb_pbdecodermethod *method,
-                             int pcofs) {
-  void *bc_target = jc->group->bytecode + method->code_base.ofs + pcofs;
-  return machine_code_ofs(jc, bc_target);
-}
-
-/* Given a pcofs relative to this method's base, returns a machine code offset
- * relative to jmptarget(dispatch->array) (which is used in jitdispatch as the
- * machine code base for dispatch table lookups). */
-uint32_t dispatchofs(jitcompiler *jc, const upb_pbdecodermethod *method,
-                     int pcofs) {
-  int mc_base = machine_code_ofs(jc, method->dispatch.array);
-  int mc_target = machine_code_ofs2(jc, method, pcofs);
-  int ret;
-
-  UPB_ASSERT(mc_base > 0);
-  UPB_ASSERT(mc_target > 0);
-  ret = mc_target - mc_base;
-  UPB_ASSERT(ret > 0);
-  return ret;
-}
-
-/* Rewrites the dispatch tables into machine code offsets. */
-static void patchdispatch(jitcompiler *jc) {
-  upb_inttable_iter i;
-  upb_inttable_begin(&i, &jc->group->methods);
-  for (; !upb_inttable_done(&i); upb_inttable_next(&i)) {
-    upb_pbdecodermethod *method = upb_value_getptr(upb_inttable_iter_value(&i));
-    upb_inttable *dispatch = &method->dispatch;
-    upb_inttable_iter i2;
-
-    method->is_native_ = true;
-
-    /* Remove DISPATCH_ENDMSG -- only the bytecode interpreter needs it.
-     * And leaving it around will cause us to find field 0 improperly. */
-    upb_inttable_remove(dispatch, DISPATCH_ENDMSG, NULL);
-
-    upb_inttable_begin(&i2, dispatch);
-    for (; !upb_inttable_done(&i2); upb_inttable_next(&i2)) {
-      uintptr_t key = upb_inttable_iter_key(&i2);
-      uint64_t val = upb_value_getuint64(upb_inttable_iter_value(&i2));
-      uint64_t newval;
-      bool ok;
-      if (key <= UPB_MAX_FIELDNUMBER) {
-        /* Primary slot. */
-        uint64_t ofs;
-        uint8_t wt1;
-        uint8_t wt2;
-        upb_pbdecoder_unpackdispatch(val, &ofs, &wt1, &wt2);
-
-        /* Update offset and repack. */
-        ofs = dispatchofs(jc, method, ofs);
-        newval = upb_pbdecoder_packdispatch(ofs, wt1, wt2);
-        UPB_ASSERT((int64_t)newval > 0);
-      } else {
-        /* Secondary slot.  Since we have 64 bits for the value, we use an
-         * absolute offset. */
-        int mcofs = machine_code_ofs2(jc, method, val);
-        newval = (uint64_t)((char*)jc->group->jit_code + mcofs);
-      }
-      ok = upb_inttable_replace(dispatch, key, upb_value_uint64(newval));
-      UPB_ASSERT(ok);
-    }
-
-    /* Update entry point for this method to point at mc base instead of bc
-     * base.  Set this only *after* we have patched the offsets
-     * (machine_code_ofs2() uses this). */
-    method->code_base.ptr = (char*)jc->group->jit_code + machine_code_ofs(jc, method);
-
-    {
-      upb_byteshandler *h = &method->input_handler_;
-      upb_byteshandler_setstartstr(h, upb_pbdecoder_startjit, NULL);
-      upb_byteshandler_setstring(h, jc->group->jit_code, method->code_base.ptr);
-      upb_byteshandler_setendstr(h, upb_pbdecoder_end, method);
-    }
-  }
-}
-
-#ifdef UPB_JIT_LOAD_SO
-
-static void load_so(jitcompiler *jc) {
-  /* Dump to a .so file in /tmp and load that, so all the tooling works right
-   * (for example, debuggers and profilers will see symbol names for the JIT-ted
-   * code).  This is the same goal of the GDB JIT code below, but the GDB JIT
-   * interface is only used/understood by GDB.  Hopefully a standard will
-   * develop for registering JIT-ted code that all tools will recognize,
-   * rendering this obsolete.
-   *
-   * jc->asmlabels maps:
-   *   pclabel -> char* label
-   *
-   * Use this to build mclabels, which maps:
-   *   machine code offset -> char* label
-   *
-   * Then we can use mclabels to emit the labels as we iterate over the bytes we
-   * are outputting. */
-  upb_inttable_iter i;
-  upb_inttable mclabels;
-  upb_inttable_init(&mclabels, UPB_CTYPE_PTR);
-  upb_inttable_begin(&i, &jc->asmlabels);
-  for (; !upb_inttable_done(&i); upb_inttable_next(&i)) {
-    upb_inttable_insert(&mclabels,
-                        dasm_getpclabel(jc, upb_inttable_iter_key(&i)),
-                        upb_inttable_iter_value(&i));
-  }
-
-  /* We write a .s file in text format, as input to the assembler.
-   * Then we run gcc to turn it into a .so file.
-   *
-   * The last "XXXXXX" will be replaced with something randomly generated by
-   * mkstmemp().  We don't add ".s" to this filename because it makes the string
-   * processing for mkstemp() and system() more complicated. */
-  char s_filename[] = "/tmp/upb-jit-codeXXXXXX";
-  int fd = mkstemp(s_filename);
-  FILE *f;
-  if (fd >= 0 && (f = fdopen(fd, "wb")) != NULL) {
-    uint8_t *jit_code = (uint8_t*)jc->group->jit_code;
-    size_t linelen = 0;
-    size_t i;
-    fputs("  .text\n\n", f);
-    for (i = 0; i < jc->group->jit_size; i++) {
-      upb_value v;
-      if (upb_inttable_lookup(&mclabels, i, &v)) {
-        const char *label = upb_value_getptr(v);
-        /* "X." makes our JIT syms recognizable as such, which we build into
-         * other tooling. */
-        fprintf(f, "\n\nX.%s:\n", label);
-        fprintf(f, "  .globl X.%s", label);
-        linelen = 1000;
-      }
-      if (linelen >= 77) {
-        linelen = fprintf(f, "\n  .byte %u", jit_code[i]);
-      } else {
-        linelen += fprintf(f, ",%u", jit_code[i]);
-      }
-    }
-    fputs("\n", f);
-    fclose(f);
-  } else {
-    fprintf(stderr, "Error opening tmp file for JIT debug output.\n");
-    abort();
-  }
-
-  /* This is exploitable if you have an adversary on your machine who can write
-   * to this tmp directory.  But this is just for debugging so we don't worry
-   * too much about that.  It shouldn't be prone to races against concurrent
-   * (non-adversarial) upb JIT's because we used mkstemp(). */
-  char *cmd = upb_asprintf("gcc -shared -o %s.so -x assembler %s", s_filename,
-                           s_filename);
-  if (system(cmd) != 0) {
-    fprintf(stderr, "Error compiling %s\n", s_filename);
-    abort();
-  }
-  free(cmd);
-
-  char *so_filename = upb_asprintf("%s.so", s_filename);
-
-  /* Some convenience symlinks.
-   * This is racy, but just for convenience. */
-  int ret;
-  unlink("/tmp/upb-jit-code.so");
-  unlink("/tmp/upb-jit-code.s");
-  ret = symlink(s_filename, "/tmp/upb-jit-code.s");
-  ret = symlink(so_filename, "/tmp/upb-jit-code.so");
-  UPB_UNUSED(ret);  // We don't care if this fails.
-
-  jc->group->dl = dlopen(so_filename, RTLD_LAZY);
-  free(so_filename);
-  if (!jc->group->dl) {
-    fprintf(stderr, "Couldn't dlopen(): %s\n", dlerror());
-    abort();
-  }
-
-  munmap(jc->group->jit_code, jc->group->jit_size);
-  jc->group->jit_code = dlsym(jc->group->dl, "X.enterjit");
-  if (!jc->group->jit_code) {
-    fprintf(stderr, "Couldn't find enterjit sym\n");
-    abort();
-  }
-
-  upb_inttable_uninit(&mclabels);
-}
-
-#endif
-
-void upb_pbdecoder_jit(mgroup *group) {
-  jitcompiler *jc;
-  char *jit_code;
-  int dasm_status;
-
-  group->debug_info = NULL;
-  group->dl = NULL;
-
-  UPB_ASSERT(group->bytecode);
-  jc = newjitcompiler(group);
-  emit_static_asm(jc);
-  jitbytecode(jc);
-
-  dasm_status = dasm_link(jc, &jc->group->jit_size);
-  if (dasm_status != DASM_S_OK) {
-    fprintf(stderr, "DynASM error; returned status: 0x%08x\n", dasm_status);
-    abort();
-  }
-
-  jit_code = mmap(NULL, jc->group->jit_size, PROT_READ | PROT_WRITE,
-                  MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
-  dasm_encode(jc, jit_code);
-  mprotect(jit_code, jc->group->jit_size, PROT_EXEC | PROT_READ);
-  jc->group->jit_code = (upb_string_handlerfunc *)jit_code;
-
-#ifdef UPB_JIT_LOAD_SO
-  load_so(jc);
-#endif
-
-  patchdispatch(jc);
-
-  freejitcompiler(jc);
-
-  /* Now the bytecode is no longer needed. */
-  free(group->bytecode);
-  group->bytecode = NULL;
-}
-
-void upb_pbdecoder_freejit(mgroup *group) {
-  if (!group->jit_code) return;
-  if (group->dl) {
-#ifdef UPB_JIT_LOAD_SO
-    dlclose(group->dl);
-#endif
-  } else {
-    munmap((void*)group->jit_code, group->jit_size);
-  }
-  free(group->debug_info);
-}
diff --git a/upb/pb/compile_decoder_x64.dasc b/upb/pb/compile_decoder_x64.dasc
deleted file mode 100644
index 7fcd006..0000000
--- a/upb/pb/compile_decoder_x64.dasc
+++ /dev/null
@@ -1,1145 +0,0 @@
-|//
-|// upb - a minimalist implementation of protocol buffers.
-|//
-|// Copyright (c) 2011-2013 Google Inc.  See LICENSE for details.
-|// Author: Josh Haberman <jhaberman@gmail.com>
-|//
-|// JIT compiler for upb_pbdecoder on x86-64.  Generates machine code from the
-|// bytecode generated in compile_decoder.c.
-|
-|.arch x64
-|.actionlist upb_jit_actionlist
-|.globals UPB_JIT_GLOBAL_
-|.globalnames upb_jit_globalnames
-|
-|// Calling conventions.  Note -- this will need to be changed for
-|// Windows, which uses a different calling convention!
-|.define ARG1_64,   rdi
-|.define ARG2_8,    r6b  // DynASM's equivalent to "sil" -- low byte of esi.
-|.define ARG2_32,   esi
-|.define ARG2_64,   rsi
-|.define ARG3_8,    dl
-|.define ARG3_32,   edx
-|.define ARG3_64,   rdx
-|.define ARG4_64,   rcx
-|.define ARG5_64,   r8
-|.define XMMARG1,   xmm0
-|
-|// Register allocation / type map.
-|// ALL of the code in this file uses these register allocations.
-|// When we "call" within this file, we do not use regular calling
-|// conventions, but of course when calling to user callbacks we must.
-|.define PTR,       rbx                       // DECODER->ptr      (unsynced)
-|.define DATAEND,   r12                       // DECODER->data_end (unsynced)
-|.define CLOSURE,   r13                       // FRAME->closure    (unsynced)
-|.type   FRAME,     upb_pbdecoder_frame, r14  // DECODER->top      (unsynced)
-|.type   DECODER,   upb_pbdecoder, r15        // DECODER           (immutable)
-|.define DELIMEND,  rbp
-|
-| // Spills unsynced registers back to memory.
-|.macro commit_regs
-|  mov  DECODER->top, FRAME
-|  mov  DECODER->ptr, PTR
-|  mov  DECODER->data_end, DATAEND
-|  // We don't guarantee that delim_end is NULL when out of range like the
-|  // interpreter does.
-|  mov  DECODER->delim_end, DELIMEND
-|  sub  DELIMEND, DECODER->buf
-|  add  DELIMEND, DECODER->bufstart_ofs
-|  mov  FRAME->end_ofs, DELIMEND
-|  mov  FRAME->sink.closure, CLOSURE
-|.endmacro
-|
-| // Loads unsynced registers from memory back into registers.
-|.macro load_regs
-|  mov  FRAME, DECODER->top
-|  mov  PTR, DECODER->ptr
-|  mov  DATAEND, DECODER->data_end
-|  mov  CLOSURE, FRAME->sink.closure
-|  mov  DELIMEND, FRAME->end_ofs
-|  sub  DELIMEND, DECODER->bufstart_ofs
-|  add  DELIMEND, DECODER->buf
-|.endmacro
-|
-| // Calls an external C function at address "addr".
-|.macro callp, addr
-|    mov64  rax, (uintptr_t)addr
-|
-|    // Stack must be 16-byte aligned (x86-64 ABI requires this).
-|    //
-|    // OPT: possibly remove this by statically ensuring correct alignment.
-|    //
-|    // OPT: use "call rel32" where possible.
-|    push   r12
-|    mov    r12, rsp
-|    and    rsp, 0xfffffffffffffff0UL   // Align stack.
-|    call   rax
-|    mov    rsp, r12
-|    pop    r12
-|.endmacro
-|
-|.macro ld64, val
-|| {
-|| uintptr_t v = (uintptr_t)val;
-|| if (v > 0xffffffff) {
-|    mov64  ARG2_64, v
-|| } else if (v) {
-|    mov    ARG2_32, v
-|| } else {
-|    xor    ARG2_32, ARG2_32
-|| }
-|| }
-|.endmacro
-|
-|.macro load_handler_data, h, arg
-|  ld64   upb_handlers_gethandlerdata(h, arg)
-|.endmacro
-|
-|.macro chkeob, bytes, target
-|| if (bytes == 1) {
-|  cmp    PTR, DATAEND
-|  je     target
-|| } else {
-|  mov    rcx, DATAEND
-|  sub    rcx, PTR
-|  cmp    rcx, bytes
-|  jb     target
-|| }
-|.endmacro
-|
-|.macro chkneob, bytes, target
-|| if (bytes == 1) {
-|  cmp    PTR, DATAEND
-|  jne    target
-|| } else {
-|  mov    rcx, DATAEND
-|  sub    rcx, PTR
-|  cmp    rcx, bytes
-|  jae    target
-|| }
-|.endmacro
-
-|.macro sethas, reg, hasbit
-|| if (hasbit >= 0) {
-|    or   byte [reg + ((uint32_t)hasbit / 8)], (1 << ((uint32_t)hasbit % 8))
-|| }
-|.endmacro
-|
-| // Decodes 32-bit varint into rdx, inlining 1 byte.
-|.macro dv32
-|  chkeob  1, >7
-|  movzx   edx, byte [PTR]
-|  test    dl, dl
-|  jns     >8
-|7:
-|  call    ->decodev32_fallback
-|8:
-|  add     PTR, 1
-|.endmacro
-
-#define DECODE_EOF -3
-
-static upb_func *gethandler(const upb_handlers *h, upb_selector_t sel) {
-  return h ? upb_handlers_gethandler(h, sel) : NULL;
-}
-
-/* Defines an "assembly label" for the current code generation offset.
- * This label exists *purely* for debugging purposes: it is emitted into
- * the .so, and printed as part of JIT debugging output when UPB_JIT_LOAD_SO is
- * defined.
- *
- * We would define this in the .c file except that it conditionally defines a
- * pclabel. */
-static void asmlabel(jitcompiler *jc, const char *fmt, ...) {
-#ifndef NDEBUG
-  int ofs = jc->dynasm->section->ofs;
-  UPB_ASSERT(ofs != jc->lastlabelofs);
-  jc->lastlabelofs = ofs;
-#endif
-
-#ifndef UPB_JIT_LOAD_SO
-  UPB_UNUSED(jc);
-  UPB_UNUSED(fmt);
-#else
-  va_list args;
-  va_start(args, fmt);
-  char *str = upb_vasprintf(fmt, args);
-  va_end(args);
-
-  int pclabel = alloc_pclabel(jc);
-  /* Normally we would prefer to allocate this inline with the codegen,
-   * ie.
-   *   |=>asmlabel(...)
-   * But since we do this conditionally, only when UPB_JIT_LOAD_SO is defined,
-   * we do it here instead. */
-  |=>pclabel:
-  upb_inttable_insert(&jc->asmlabels, pclabel, upb_value_ptr(str));
-#endif
-}
-
-/* Should only be called when the associated handler is known to exist. */
-static bool alwaysok(const upb_handlers *h, upb_selector_t sel) {
-  upb_handlerattr attr = UPB_HANDLERATTR_INITIALIZER;
-  bool ok = upb_handlers_getattr(h, sel, &attr);
-  bool ret;
-
-  UPB_ASSERT(ok);
-  ret = upb_handlerattr_alwaysok(&attr);
-  upb_handlerattr_uninit(&attr);
-  return ret;
-}
-
-/* Emit static assembly routines; code that does not vary based on the message
- * schema.  Since it's not input-dependent, we only need one single copy of it.
- * For the moment we generate a single copy per generated handlers.  Eventually
- * we should generate this code at compile time and link it into the binary so
- * we have one copy total.  To do that we'll want to be sure that it is within
- * 2GB of our JIT code, so that branches between the two are near (rel32).
- *
- * We'd put this assembly in a .s file directly, but DynASM's ability to
- * calculate structure offsets automatically is too useful to pass up (it's way
- * more convenient to write DECODER->sink than [rbx + 0x96], especially since
- * the latter would have to be changed whenever the structure is updated). */
-static void emit_static_asm(jitcompiler *jc) {
-  | // Trampolines for entering/exiting the JIT.  These are a bit tricky to
-  | // support full resuming; when we suspend we copy the JIT's portion of
-  | // the call stack into the upb_pbdecoder and restore it when we resume.
-  asmlabel(jc, "enterjit");
-  |->enterjit:
-  |1:
-  |  push  rbp
-  |  push  r15
-  |  push  r14
-  |  push  r13
-  |  push  r12
-  |  push  rbx
-  |
-  |  mov   rbx, ARG2_64  // Preserve JIT method.
-  |
-  |  mov   DECODER, rdi
-  |  callp upb_pbdecoder_resume  // Same args as us; reuse regs.
-  |  test  eax, eax
-  |  jns   >1
-  |  mov   DECODER->saved_rsp, rsp
-  |  mov   rax, rbx
-  |  load_regs
-  |
-  |  // Test whether we have a saved stack to resume.
-  |  mov   ARG3_64, DECODER->call_len
-  |  test  ARG3_64, ARG3_64
-  |  jnz   >2
-  |
-  |  call  rax
-  |
-  |  mov   rax, DECODER->size_param
-  |  mov   qword DECODER->call_len, 0
-  |1:
-  |  pop   rbx
-  |  pop   r12
-  |  pop   r13
-  |  pop   r14
-  |  pop   r15
-  |  pop   rbp
-  |  ret
-  |
-  |2:
-  |  // Resume decoder.
-  |  mov   ARG2_64, DECODER->callstack
-  |  sub   rsp, ARG3_64
-  |  mov   ARG1_64, rsp
-  |  callp memcpy  // Restore stack.
-  |  ret  // Return to resumed function (not ->enterjit caller).
-  |
-  | // Other code can call this to suspend the JIT.
-  | // To the calling code, it will appear that the function returns when
-  | // the JIT resumes, and more buffer space will be available.
-  | // Args: eax=the value that decode() should return.
-  asmlabel(jc, "exitjit");
-  |->exitjit:
-  |  // Save the stack into DECODER->callstack.
-  |  mov   ARG1_64, DECODER->callstack
-  |  mov   ARG2_64, rsp
-  |  mov   ARG3_64, DECODER->saved_rsp
-  |  sub   ARG3_64, rsp
-  |  mov   DECODER->call_len, ARG3_64  // Preserve len for next resume.
-  |  mov   ebx, eax  // Preserve return value across memcpy.
-  |  callp memcpy    // Copy stack into decoder.
-  |  mov   eax, ebx  // This will be our return value.
-  |
-  |  // Must NOT do this before the memcpy(), otherwise memcpy() will
-  |  // clobber the stack we are trying to save!
-  |  mov   rsp, DECODER->saved_rsp
-  |  pop   rbx
-  |  pop   r12
-  |  pop   r13
-  |  pop   r14
-  |  pop   r15
-  |  pop   rbp
-  |  ret
-  |
-  | // Like suspend() in the C decoder, except that the function appears
-  | // (from the caller's perspective) not to return until the decoder is
-  | // resumed.
-  asmlabel(jc, "suspend");
-  |->suspend:
-  |  cmp   DECODER->ptr, PTR
-  |  je    >1
-  |  mov   DECODER->checkpoint, PTR
-  |1:
-  |  commit_regs
-  |  mov   rdi, DECODER
-  |  callp upb_pbdecoder_suspend
-  |  jmp   ->exitjit
-  |
-  asmlabel(jc, "pushlendelim");
-  |->pushlendelim:
-  |1:
-  |  mov   FRAME->sink.closure, CLOSURE
-  |  mov   DECODER->checkpoint, PTR
-  |  dv32
-  |  mov   rcx, DELIMEND
-  |  sub   rcx, PTR
-  |  sub   rcx, rdx
-  |  jb    >4   // Len is greater than enclosing message.
-  |  mov   FRAME->end_ofs, rcx
-  |  cmp   FRAME, DECODER->limit
-  |  je    >3   // Stack overflow
-  |  add   FRAME, sizeof(upb_pbdecoder_frame)
-  |  mov   DELIMEND, PTR
-  |  add   DELIMEND, rdx
-  |  mov   dword FRAME->groupnum, 0
-  |  test  rcx, rcx
-  |  jz    >2
-  |  mov   DATAEND, DECODER->end
-  |  cmp   PTR, DELIMEND
-  |  ja    >2
-  |  cmp   DELIMEND, DATAEND
-  |  ja    >2
-  |  mov   DATAEND, DELIMEND  // If DELIMEND >= PTR && DELIMEND < DATAEND
-  |2:
-  |  ret
-  |3:
-  |  // Stack overflow error.
-  |  mov   PTR, DECODER->checkpoint  // Rollback to before the delim len.
-  |  // Prepare seterr args.
-  |  mov   ARG1_64, DECODER
-  |  ld64  kPbDecoderStackOverflow
-  |  callp upb_pbdecoder_seterr
-  |  call  ->suspend
-  |  jmp   <1
-  |4:
-  |  // Overextended len.
-  |  mov   PTR, DECODER->checkpoint  // Rollback to before the delim len.
-  |  // Prepare seterr args.
-  |  mov   ARG1_64, DECODER
-  |  ld64  kPbDecoderSubmessageTooLong
-  |  callp upb_pbdecoder_seterr
-  |  call  ->suspend
-  |  jmp   <1
-  |
-  | // For getting a value that spans a buffer seam.  Falls back to C.
-  |.macro getvalue_slow, func, bytes
-  |  sub   rsp, 8           // Need stack space for func to write value to.
-  |1:
-  |  mov   qword [rsp], 0   // For parsing routines that only parse 32 bits.
-  |  mov   ARG1_64, DECODER
-  |  mov   ARG2_64, rsp
-  |  mov   DECODER->checkpoint, PTR
-  |  commit_regs
-  |  callp func
-  |  load_regs
-  |  test  eax, eax
-  |  jns   >2
-  |  // Success; return parsed data (in rdx AND xmm0).
-  |  mov   rdx, [rsp]
-  |  movsd xmm0, qword [rsp]
-  |  add   rsp, 8
-  |  sub   PTR, bytes       // Bias our buffer pointer to rejoin the fast-path.
-  |  mov   DECODER->ptr, PTR
-  |  ret
-  |2:
-  |  call  ->exitjit   // Return eax from decode function.
-  |  jmp   <1
-  |.endmacro
-  |
-  asmlabel(jc, "parse_unknown");
-  | // Args: edx=fieldnum, cl=wire type
-  |->parse_unknown:
-  |  // OPT: handle directly instead of kicking to C.
-  |  // Check for ENDGROUP.
-  |  mov     ARG1_64, DECODER
-  |  mov     ARG2_32, edx
-  |  movzx   ARG3_32, cl
-  |  commit_regs
-  |  callp   upb_pbdecoder_skipunknown
-  |  load_regs
-  |  cmp     eax, DECODE_ENDGROUP
-  |  jne     >1
-  |  ret     // Return eax=DECODE_ENDGROUP, not zero
-  |1:
-  |  cmp     eax, DECODE_OK
-  |  je      >1
-  |  call    ->exitjit  // Return eax from decode function.
-  |1:
-  |  xor     eax, eax
-  |  ret
-  |
-  | // Fallback functions for parsing single values.  These are used when the
-  | // buffer doesn't contain enough remaining data for the fast path.  Each
-  | // primitive type (v32, v64, f32, f64) has two functions: decode & skip.
-  | // Decode functions return their value in rsi/esi.
-  | //
-  | // These functions leave PTR = value_end - fast_path_bytes, so that we can
-  | // re-join the fast path which will add fast_path_bytes after the callback
-  | // completes.  We also set DECODER->ptr to this value which is a signal to
-  | // ->suspend that DECODER->checkpoint is up to date.
-  asmlabel(jc, "skip_decode_f32_fallback");
-  |->skipf32_fallback:
-  |->decodef32_fallback:
-  |  getvalue_slow upb_pbdecoder_decode_f32, 4
-  |
-  asmlabel(jc, "skip_decode_f64_fallback");
-  |->skipf64_fallback:
-  |->decodef64_fallback:
-  |  getvalue_slow upb_pbdecoder_decode_f64, 8
-  |
-  | // Called for varint >= 1 byte.
-  asmlabel(jc, "skip_decode_v32_fallback");
-  |->skipv32_fallback:
-  |->skipv64_fallback:
-  |  chkeob   16, >1
-  |  // With at least 16 bytes left, we can do a branch-less SSE version.
-  |  movdqu   xmm0, [PTR]
-  |  pmovmskb eax, xmm0   // bits 0-15 are continuation bits, 16-31 are 0.
-  |  not      eax
-  |  bsf      eax, eax
-  |  cmp      al, 10
-  |  jae      ->decode_varint_slow  // Error (>10 byte varint).
-  |  add      PTR, rax    // bsf result is 0-based, so PTR=end-1, as desired.
-  |  ret
-  |
-  |1:
-  |  // With fewer than 16 bytes, we have to read byte by byte.
-  |  lea      rcx, [PTR + 10]
-  |  mov      rax, PTR    // Preserve PTR in case of fallback to slow path.
-  |  cmp      rcx, DATAEND
-  |  cmova    rcx, DATAEND    // rcx = MIN(DATAEND, PTR + 10)
-  |2:
-  |  cmp      rax, rcx
-  |  je       ->decode_varint_slow
-  |  test     byte [rax], 0x80
-  |  jz       >3
-  |  add      rax, 1
-  |  jmp      <2
-  |3:
-  |  mov      PTR, rax  // PTR = varint_end - 1, as desired
-  |  ret
-  |
-  | // Returns tag in edx
-  asmlabel(jc, "decode_unknown_tag_fallback");
-  |->decode_unknown_tag_fallback:
-  |  sub   rsp, 16
-  |1:
-  |  cmp      PTR, DELIMEND
-  |  jne      >2
-  |  add      rsp, 16
-  |  xor      eax, eax
-  |  ret
-  |2:
-  |  // OPT: Have a medium-fast path before falling back to _slow.
-  |  mov   ARG1_64, DECODER
-  |  mov   ARG2_64, rsp
-  |  commit_regs
-  |  callp upb_pbdecoder_decode_varint_slow
-  |  load_regs
-  |  cmp   eax, 0
-  |  jge   >3
-  |  mov   edx, [rsp]   // Success; return parsed data.
-  |  add   rsp, 16
-  |  ret
-  |3:
-  |  call  ->exitjit   // Return eax from decode function.
-  |  jmp   <1
-  |
-  | // Called for varint >= 1 byte.
-  asmlabel(jc, "decode_v32_v64_fallback");
-  |->decodev32_fallback:
-  |->decodev64_fallback:
-  |  chkeob   10, ->decode_varint_slow
-  |  // OPT: do something faster than just calling the C version.
-  |  mov      rdi, PTR
-  |  callp    upb_vdecode_fast
-  |  test     rax, rax
-  |  je       ->decode_varint_slow  // Unterminated varint.
-  |  mov      PTR, rax
-  |  sub      PTR, 1
-  |  mov      DECODER->ptr, PTR
-  |  ret
-  |
-  asmlabel(jc, "decode_varint_slow");
-  |->decode_varint_slow:
-  |  // Slow path: end of buffer or error (varint length >= 10).
-  |  getvalue_slow upb_pbdecoder_decode_varint_slow, 1
-  |
-  | // Args: rsi=expected tag, return=rax (DECODE_{OK,MISMATCH})
-  asmlabel(jc, "checktag_fallback");
-  |->checktag_fallback:
-  |  sub      rsp, 8
-  |  mov      [rsp], rsi  // Preserve expected tag.
-  |1:
-  |  mov      ARG1_64, DECODER
-  |  commit_regs
-  |  mov      DECODER->checkpoint, PTR
-  |  callp    upb_pbdecoder_checktag_slow
-  |  load_regs
-  |  cmp      eax, 0
-  |  jge      >2
-  |  add      rsp, 8
-  |  ret
-  |2:
-  |  call     ->exitjit
-  |  mov      rsi, [rsp]
-  |  cmp      PTR, DELIMEND
-  |  jne      <1
-  |  mov      eax, DECODE_EOF
-  |  add      rsp, 8
-  |  ret
-  |
-  | // Args: rsi=upb_inttable, rdx=key, return=rax (-1 if not found).
-  | // Preserves: rcx, rdx
-  | // OPT: Could write this in assembly if it's a hotspot.
-  asmlabel(jc, "hashlookup");
-  |->hashlookup:
-  |  push   rcx
-  |  push   rdx
-  |  sub    rsp, 16
-  |  mov    rdi, rsi
-  |  mov    rsi, rdx
-  |  mov    rdx, rsp
-  |  callp  upb_inttable_lookup
-  |  add    rsp, 16
-  |  pop    rdx
-  |  pop    rcx
-  |  test   al, al
-  |  jz     >2  // Unknown field.
-  |  mov    rax, [rsp-32]  // Value from table.
-  |  ret
-  |2:
-  |  xor    rax, rax
-  |  not    rax
-  |  ret
-}
-
-static void jitprimitive(jitcompiler *jc, opcode op,
-                         const upb_handlers *h, upb_selector_t sel) {
-  typedef enum { V32, V64, F32, F64, X } valtype_t;
-  static valtype_t types[] = {
-    X, F64, F32, V64, V64, V32, F64, F32, V64, X, X, X, X, V32, V32, F32, F64,
-    V32, V64 };
-  static char fastpath_bytes[] = { 1, 1, 4, 8 };
-  const valtype_t vtype = types[op];
-  const int fastbytes = fastpath_bytes[vtype];
-  upb_func *handler = gethandler(h, sel);
-  upb_fieldtype_t ftype;
-  size_t offset;
-  int32_t hasbit;
-
-  if (handler) {
-    |1:
-    |  chkneob  fastbytes, >3
-    |2:
-    switch (vtype) {
-    case V32:
-      |  call   ->decodev32_fallback
-      break;
-    case V64:
-      |  call   ->decodev64_fallback
-      break;
-    case F32:
-      |  call   ->decodef32_fallback
-      break;
-    case F64:
-      |  call   ->decodef64_fallback
-      break;
-    case X: break;
-    }
-    |  jmp    >4
-
-    /* Fast path decode; for when check_bytes bytes are available. */
-    |3:
-    switch (op) {
-    case OP_PARSE_SFIXED32:
-    case OP_PARSE_FIXED32:
-      |  mov    edx, dword [PTR]
-      break;
-    case OP_PARSE_SFIXED64:
-    case OP_PARSE_FIXED64:
-      |  mov    rdx, qword [PTR]
-      break;
-    case OP_PARSE_FLOAT:
-      |  movss  xmm0, dword [PTR]
-      break;
-    case OP_PARSE_DOUBLE:
-      |  movsd  xmm0, qword [PTR]
-      break;
-    default:
-      /* Inline one byte of varint decoding. */
-      |  movzx  edx, byte [PTR]
-      |  test   dl, dl
-      |  js     <2   // Fallback to slow path for >1 byte varint.
-      break;
-    }
-
-    /* Second-stage decode; used for both fast and slow paths */
-    /* (only needed for a few types). */
-    |4:
-    switch (op) {
-    case OP_PARSE_SINT32:
-      /* 32-bit zig-zag decode. */
-      |  mov    eax, edx
-      |  shr    edx, 1
-      |  and    eax, 1
-      |  neg    eax
-      |  xor    edx, eax
-      break;
-    case OP_PARSE_SINT64:
-      /* 64-bit zig-zag decode. */
-      |  mov    rax, rdx
-      |  shr    rdx, 1
-      |  and    rax, 1
-      |  neg    rax
-      |  xor    rdx, rax
-      break;
-    case OP_PARSE_BOOL:
-      |  test   rdx, rdx
-      |  setne  dl
-      break;
-    default: break;
-    }
-
-    /* Call callback (or specialize if we can). */
-    if (upb_msg_getscalarhandlerdata(h, sel, &ftype, &offset, &hasbit)) {
-      switch (ftype) {
-        case UPB_TYPE_INT64:
-        case UPB_TYPE_UINT64:
-          |  mov   [CLOSURE + offset], rdx
-          break;
-        case UPB_TYPE_INT32:
-        case UPB_TYPE_UINT32:
-        case UPB_TYPE_ENUM:
-          |  mov   [CLOSURE + offset], edx
-          break;
-        case UPB_TYPE_DOUBLE:
-          |  movsd  qword [CLOSURE + offset], XMMARG1
-          break;
-        case UPB_TYPE_FLOAT:
-          |  movss  dword [CLOSURE + offset], XMMARG1
-          break;
-        case UPB_TYPE_BOOL:
-          |  mov   [CLOSURE + offset], dl
-          break;
-        case UPB_TYPE_STRING:
-        case UPB_TYPE_BYTES:
-        case UPB_TYPE_MESSAGE:
-          UPB_ASSERT(false); break;
-      }
-      |  sethas CLOSURE, hasbit
-    } else if (handler) {
-      |  mov    ARG1_64, CLOSURE
-      |  load_handler_data h, sel
-      |  callp  handler
-      if (!alwaysok(h, sel)) {
-        |  test   al, al
-        |  jnz    >5
-        |  call   ->suspend
-        |  jmp    <1
-        |5:
-      }
-    }
-
-    /* We do this last so that the checkpoint is not advanced past the user's
-     * data until the callback has returned success. */
-    |  add    PTR, fastbytes
-  } else {
-    /* No handler registered for this value, just skip it. */
-    |  chkneob  fastbytes, >3
-    |2:
-    switch (vtype) {
-    case V32:
-      |  call   ->skipv32_fallback
-      break;
-    case V64:
-      |  call   ->skipv64_fallback
-      break;
-    case F32:
-      |  call   ->skipf32_fallback
-      break;
-    case F64:
-      |  call   ->skipf64_fallback
-      break;
-    case X: break;
-    }
-
-    /* Fast-path skip. */
-    |3:
-    if (vtype == V32 || vtype == V64) {
-      |  test   byte [PTR], 0x80
-      |  jnz    <2
-    }
-    |  add    PTR, fastbytes
-  }
-}
-
-static void jitdispatch(jitcompiler *jc,
-                        const upb_pbdecodermethod *method) {
-  /* Lots of room for tweaking/optimization here. */
-
-  const upb_inttable *dispatch = &method->dispatch;
-  bool has_hash_entries = (dispatch->t.count > 0);
-
-  /* Whether any of the fields for this message can have two wire types which
-   * are both valid (packed & non-packed).
-   *
-   * OPT: populate this more precisely; not all messages with hash entries have
-   * this characteristic. */
-  bool has_multi_wiretype = has_hash_entries;
-
-  |=>define_jmptarget(jc, &method->dispatch):
-  |1:
-  /* Decode the field tag. */
-  |  mov     aword DECODER->checkpoint, PTR
-  |  chkeob  2, >6
-  |  movzx   edx, byte [PTR]
-  |  test    dl, dl
-  |  jns     >7    // Jump if first byte has no continuation bit.
-  |  movzx   ecx, byte [PTR + 1]
-  |  test    cl, cl
-  |  js      >6    // Jump if second byte has continuation bit.
-  |  // Confirmed two-byte varint.
-  |  shl     ecx, 7
-  |  and     edx, 0x7f
-  |  or      edx, ecx
-  |  add     PTR, 2
-  |  jmp     >8
-  |6:
-  |  call    ->decode_unknown_tag_fallback
-  |  test    eax, eax  // Hit DELIMEND?
-  |  jnz     >8
-  |  ret
-  |7:
-  |  add     PTR, 1
-  |8:
-  |  mov     ecx, edx
-  |  shr     edx, 3
-  |  and     cl, 7
-
-  /* See comment attached to upb_pbdecodermethod.dispatch for layout of the
-   * dispatch table. */
-  |2:
-  |  cmp     edx, dispatch->array_size
-  if (has_hash_entries) {
-    |  jae     >7
-  } else {
-    |  jae     >5
-  }
-  |  // OPT: Compact the lookup arr into 32-bit entries.
-  if ((uintptr_t)dispatch->array > 0x7fffffff) {
-    |  mov64 rax, (uintptr_t)dispatch->array
-    |  mov   rax, qword [rax + rdx * 8]
-  } else {
-    |  mov   rax, qword [rdx * 8 + dispatch->array]
-  }
-  |3:
-  |  // We take advantage of the fact that non-present entries are stored
-  |  // as -1, which will result in wire types that will never match.
-  |  cmp  al, cl
-  if (has_multi_wiretype) {
-    |  jne  >6
-  } else {
-    |  jne  >5
-  }
-  |  shr  rax, 16
-  |
-  |  // Load the machine code address from the table entry.
-  |  // The table entry is relative to the dispatch->array jmptarget
-  |  // (patchdispatch() took care of this) which is the same as
-  |  // local label "4".  The "lea" is really just trying to do
-  |  //    lea  rax, [>4 + rax]
-  |  //
-  |  // But we can't write that directly for some reason, so we use
-  |  // rdx as a temporary.
-  |  lea  rdx, [>4]
-  |=>define_jmptarget(jc, dispatch->array):
-  |4:
-  |  add  rax, rdx
-  |  ret
-  |
-  |5:
-  |  // Field isn't in our table.
-  |
-  |  // For pushing unknown fields to the unknown field handler.
-  |  mov64 rax, (uintptr_t)method->dest_handlers_
-  |  mov FRAME->sink.handlers, rax
-  |
-  |  call ->parse_unknown
-  |  test eax, eax  // ENDGROUP?
-  |  jz   <1
-  |  lea  rax, [>9]  // ENDGROUP; Load address of OP_ENDMSG.
-  |  ret
-
-  if (has_multi_wiretype) {
-    |6:
-    |  // Primary wire type didn't match, check secondary wire type.
-    |  cmp  ah, cl
-    |  jne  <5
-    |  // Secondary wire type is a match, look up fn + UPB_MAX_FIELDNUMBER.
-    |  add   rdx, UPB_MAX_FIELDNUMBER
-    |  // This key will never be in the array part, so do a hash lookup.
-    UPB_ASSERT(has_hash_entries);
-    |  ld64  dispatch
-    |  jmp   ->hashlookup  // Tail call.
-  }
-
-  if (has_hash_entries) {
-    |7:
-    |  // Hash table lookup.
-    |  ld64   dispatch
-    |  call   ->hashlookup
-    |  jmp    <3
-  }
-}
-
-static void jittag(jitcompiler *jc, uint64_t tag, int n, int ofs,
-                   const upb_pbdecodermethod *method) {
-  /* Internally we parse unknown fields; if this runs us into DELIMEND we jump
-   * to the corresponding DELIMEND target (either msg end or repeated field
-   * end), which we find from the OP_CHECKDELIM which must have necessarily
-   * preceded us. */
-  uint32_t last_instruction = *(jc->pc - 2);
-  int last_arg = (int32_t)last_instruction >> 8;
-  uint32_t *delimend = (jc->pc - 1) + last_arg;
-  const size_t ptr_words = sizeof(void*) / sizeof(uint32_t);
-
-  UPB_ASSERT((last_instruction & 0xff) == OP_CHECKDELIM);
-
-  if (getop(*(jc->pc - 1)) == OP_TAGN) {
-    jc->pc += ptr_words;
-  }
-
-  |  chkneob n, >1
-
-  |  // OPT: this is way too much fallback code to put here.
-  |  // Reduce and/or move to a separate section to make better icache usage.
-  |  ld64  tag
-  |  call  ->checktag_fallback
-  |  cmp   eax, DECODE_MISMATCH
-  |  je    >3
-  |  cmp   eax, DECODE_EOF
-  |  je     =>jmptarget(jc, delimend)
-  |  jmp   >5
-
-  |1:
-  switch (n) {
-  case 1:
-    |  cmp  byte [PTR], tag
-    break;
-  case 2:
-    |  cmp  word [PTR], tag
-    break;
-  case 3:
-    |   // OPT: Slightly more efficient code, but depends on an extra byte.
-    |   // mov  eax, dword [PTR]
-    |   // shl  eax, 8
-    |   // cmp  eax, tag << 8
-    |   cmp  word [PTR], (tag & 0xffff)
-    |   jne  >2
-    |   cmp  byte [PTR + 2], (tag >> 16)
-    |2:
-    break;
-  case 4:
-    |   cmp  dword [PTR], tag
-    break;
-  case 5:
-    |   cmp  dword [PTR], (tag & 0xffffffff)
-    |   jne  >3
-    |   cmp  byte  [PTR + 4], (tag >> 32)
-  }
-  |  je    >4
-  |3:
-  if (ofs == 0) {
-    |  call   =>jmptarget(jc, &method->dispatch)
-    |  test   rax, rax
-    |  jz     =>jmptarget(jc, delimend)
-    |  jmp    rax
-  } else {
-    |  jmp    =>jmptarget(jc, jc->pc + ofs)
-  }
-  |4:
-  |  add    PTR, n
-  |5:
-}
-
-/* Compile the bytecode to x64. */
-static void jitbytecode(jitcompiler *jc) {
-  upb_pbdecodermethod *method = NULL;
-  const upb_handlers *h = NULL;
-  for (jc->pc = jc->group->bytecode; jc->pc < jc->group->bytecode_end; ) {
-    int32_t instr = *jc->pc;
-    opcode op = instr & 0xff;
-    uint32_t arg = instr >> 8;
-    int32_t longofs = arg;
-
-    if (op != OP_SETDISPATCH) {
-      /* Skipped for SETDISPATCH because it defines its own asmlabel for the
-       * dispatch code it emits. */
-      asmlabel(jc, "0x%lx.%s", pcofs(jc), upb_pbdecoder_getopname(op));
-
-      /* Skipped for SETDISPATCH because it should point at the function
-       * prologue, not the dispatch function that is emitted first.
-       * TODO: optimize this to only define pclabels that are actually used. */
-      |=>define_jmptarget(jc, jc->pc):
-    }
-
-    jc->pc++;
-
-    switch (op) {
-    case OP_STARTMSG: {
-      upb_func *startmsg = gethandler(h, UPB_STARTMSG_SELECTOR);
-      if (startmsg) {
-        /* bool startmsg(void *closure, const void *hd) */
-        |1:
-        |  mov   ARG1_64, CLOSURE
-        |  load_handler_data h, UPB_STARTMSG_SELECTOR
-        |  callp startmsg
-        if (!alwaysok(h, UPB_STARTMSG_SELECTOR)) {
-          |  test  al, al
-          |  jnz   >2
-          |  call  ->suspend
-          |  jmp   <1
-          |2:
-        }
-      } else {
-        | nop
-      }
-      break;
-    }
-    case OP_ENDMSG: {
-      upb_func *endmsg = gethandler(h, UPB_ENDMSG_SELECTOR);
-      |9:
-      if (endmsg) {
-        /* bool endmsg(void *closure, const void *hd, upb_status *status) */
-        |  mov   ARG1_64, CLOSURE
-        |  load_handler_data h, UPB_ENDMSG_SELECTOR
-        |  mov   ARG3_64, DECODER->status
-        |  callp endmsg
-      }
-      break;
-    }
-    case OP_SETDISPATCH: {
-      uint32_t *op_pc = jc->pc - 1;
-      const char *msgname;
-      upb_inttable *dispatch;
-
-      /* Load info for new method. */
-      memcpy(&dispatch, jc->pc, sizeof(void*));
-      jc->pc += sizeof(void*) / sizeof(uint32_t);
-      /* The OP_SETDISPATCH bytecode contains a pointer that is
-       * &method->dispatch; we want to go backwards and recover method. */
-      method =
-          (void*)((char*)dispatch - offsetof(upb_pbdecodermethod, dispatch));
-      /* May be NULL, in which case no handlers for this message will be found.
-       * OPT: we should do better by completely skipping the message in this
-       * case instead of parsing it field by field.  We should also do the skip
-       * in the containing message's code. */
-      h = method->dest_handlers_;
-      msgname = upb_msgdef_fullname(upb_handlers_msgdef(h));
-
-      /* Emit dispatch code for new method. */
-      asmlabel(jc, "0x%lx.dispatch.%s", pcofs(jc), msgname);
-      jitdispatch(jc, method);
-
-      /* Emit function prologue for new method. */
-      asmlabel(jc, "0x%lx.parse.%s", pcofs(jc), msgname);
-      |=>define_jmptarget(jc, op_pc):
-      |=>define_jmptarget(jc, method):
-      |  sub   rsp, 8
-
-      break;
-    }
-    case OP_PARSE_DOUBLE:
-    case OP_PARSE_FLOAT:
-    case OP_PARSE_INT64:
-    case OP_PARSE_UINT64:
-    case OP_PARSE_INT32:
-    case OP_PARSE_FIXED64:
-    case OP_PARSE_FIXED32:
-    case OP_PARSE_BOOL:
-    case OP_PARSE_UINT32:
-    case OP_PARSE_SFIXED32:
-    case OP_PARSE_SFIXED64:
-    case OP_PARSE_SINT32:
-    case OP_PARSE_SINT64:
-      jitprimitive(jc, op, h, arg);
-      break;
-    case OP_STARTSEQ:
-    case OP_STARTSUBMSG:
-    case OP_STARTSTR: {
-      upb_func *start = gethandler(h, arg);
-      if (start) {
-        /* void *startseq(void *closure, const void *hd)
-         * void *startsubmsg(void *closure, const void *hd)
-         * void *startstr(void *closure, const void *hd, size_t size_hint) */
-        |1:
-        |  mov   ARG1_64, CLOSURE
-        |  load_handler_data h, arg
-        if (op == OP_STARTSTR) {
-          |  mov    ARG3_64, DELIMEND
-          |  sub    ARG3_64, PTR
-        }
-        |  callp start
-        if (!alwaysok(h, arg)) {
-          |  test  rax, rax
-          |  jnz   >2
-          |  call  ->suspend
-          |  jmp   <1
-          |2:
-        }
-        |  mov   CLOSURE, rax
-      } else {
-        /* TODO: nop is only required because of asmlabel(). */
-        |  nop
-      }
-      break;
-    }
-    case OP_ENDSEQ:
-    case OP_ENDSUBMSG:
-    case OP_ENDSTR: {
-      upb_func *end = gethandler(h, arg);
-      if (end) {
-        /* bool endseq(void *closure, const void *hd)
-         * bool endsubmsg(void *closure, const void *hd)
-         * bool endstr(void *closure, const void *hd) */
-        |1:
-        |  mov   ARG1_64, CLOSURE
-        |  load_handler_data h, arg
-        |  callp end
-        if (!alwaysok(h, arg)) {
-          |  test  al, al
-          |  jnz   >2
-          |  call  ->suspend
-          |  jmp   <1
-          |2:
-        }
-      } else {
-        /* TODO: nop is only required because of asmlabel(). */
-        |  nop
-      }
-      break;
-    }
-    case OP_STRING: {
-      upb_func *str = gethandler(h, arg);
-      |  cmp   PTR, DELIMEND
-      |  je    >4
-      |1:
-      |  cmp   PTR, DATAEND
-      |  jne   >2
-      |  call  ->suspend
-      |  jmp   <1
-      |2:
-      if (str) {
-        /* size_t str(void *closure, const void *hd, const char *str,
-         *            size_t n) */
-        |  mov   ARG1_64, CLOSURE
-        |  load_handler_data h, arg
-        |  mov   ARG3_64, PTR
-        |  mov   ARG4_64, DATAEND
-        |  sub   ARG4_64, PTR
-        |  mov   ARG5_64, qword DECODER->handle
-        |  callp str
-        |  add   PTR, rax
-        if (!alwaysok(h, arg)) {
-          |  cmp   PTR, DATAEND
-          |  je    >3
-          |  call  ->strret_fallback
-          |3:
-        }
-      } else {
-        |  mov   PTR, DATAEND
-      }
-      |  cmp   PTR, DELIMEND
-      |  jne   <1
-      |4:
-      break;
-    }
-    case OP_PUSHTAGDELIM:
-      |  mov   FRAME->sink.closure, CLOSURE
-      |  // This shouldn't need to be read, because tag-delimited fields
-      |  // shouldn't have an OP_SETDELIM after them.  But for the moment
-      |  // non-packed repeated fields do OP_SETDELIM so they can share more
-      |  // code with the packed code-path.  If this is changed later, this
-      |  // store can be removed.
-      |  mov   qword FRAME->end_ofs, 0
-      |  cmp   FRAME, DECODER->limit
-      |  je    ->err
-      |  add   FRAME, sizeof(upb_pbdecoder_frame)
-      |  mov   dword FRAME->groupnum, arg
-      break;
-    case OP_PUSHLENDELIM:
-      |  call  ->pushlendelim
-      break;
-    case OP_POP:
-      |  sub   FRAME, sizeof(upb_pbdecoder_frame)
-      |  mov   CLOSURE, FRAME->sink.closure
-      break;
-    case OP_SETDELIM:
-      /* OPT: experiment with testing vs old offset to optimize away. */
-      |  mov   DATAEND, DECODER->end
-      |  add   DELIMEND, FRAME->end_ofs
-      |  cmp   DELIMEND, DECODER->buf
-      |  jb    >1
-      |  cmp   DELIMEND, DATAEND
-      |  ja    >1   // OPT: try cmov.
-      |  mov   DATAEND, DELIMEND
-      |1:
-      break;
-    case OP_SETBIGGROUPNUM:
-      |  mov   dword FRAME->groupnum, *jc->pc++
-      break;
-    case OP_CHECKDELIM:
-      |  cmp  DELIMEND, PTR
-      |  je   =>jmptarget(jc, jc->pc + longofs)
-      break;
-    case OP_CALL:
-      |  call =>jmptarget(jc, jc->pc + longofs)
-      break;
-    case OP_BRANCH:
-      |  jmp  =>jmptarget(jc, jc->pc + longofs);
-      break;
-    case OP_RET:
-      |9:
-      |  add  rsp, 8
-      |  ret
-      break;
-    case OP_TAG1:
-      jittag(jc, (arg >> 8) & 0xff, 1, (int8_t)arg, method);
-      break;
-    case OP_TAG2:
-      jittag(jc, (arg >> 8) & 0xffff, 2, (int8_t)arg, method);
-      break;
-    case OP_TAGN: {
-      uint64_t tag;
-      memcpy(&tag, jc->pc, 8);
-      jittag(jc, tag, arg >> 8, (int8_t)arg, method);
-      break;
-    }
-    case OP_DISPATCH:
-      |  call   =>jmptarget(jc, &method->dispatch)
-      break;
-    case OP_HALT:
-      UPB_ASSERT(false);
-    }
-  }
-
-  asmlabel(jc, "eof");
-  |  nop
-}
diff --git a/upb/pb/compile_decoder_x64.h b/upb/pb/compile_decoder_x64.h
deleted file mode 100644
index 2c07063..0000000
--- a/upb/pb/compile_decoder_x64.h
+++ /dev/null
@@ -1,1732 +0,0 @@
-/*
-** This file has been pre-processed with DynASM.
-** http://luajit.org/dynasm.html
-** DynASM version 1.3.0, DynASM x64 version 1.3.0
-** DO NOT EDIT! The original file is in "upb/pb/compile_decoder_x64.dasc".
-*/
-
-#if DASM_VERSION != 10300
-#error "Version mismatch between DynASM and included encoding engine"
-#endif
-
-# 1 "upb/pb/compile_decoder_x64.dasc"
-/*|// */
-/*|// upb - a minimalist implementation of protocol buffers. */
-/*|// */
-/*|// Copyright (c) 2011-2013 Google Inc.  See LICENSE for details. */
-/*|// Author: Josh Haberman <jhaberman@gmail.com> */
-/*|// */
-/*|// JIT compiler for upb_pbdecoder on x86-64.  Generates machine code from the */
-/*|// bytecode generated in compile_decoder.c. */
-/*| */
-/*|.arch x64 */
-/*|.actionlist upb_jit_actionlist */
-static const unsigned char upb_jit_actionlist[2467] = {
-  249,255,248,10,248,1,85,65,87,65,86,65,85,65,84,83,72,137,252,243,73,137,
-  252,255,72,184,237,237,65,84,73,137,228,72,129,228,239,252,255,208,76,137,
-  228,65,92,133,192,15,137,244,247,73,137,167,233,72,137,216,77,139,183,233,
-  73,139,159,233,77,139,167,233,77,139,174,233,73,139,174,233,73,43,175,233,
-  73,3,175,233,73,139,151,233,72,133,210,15,133,244,248,252,255,208,73,139,
-  135,233,73,199,135,233,0,0,0,0,248,1,255,91,65,92,65,93,65,94,65,95,93,195,
-  248,2,73,139,183,233,72,41,212,72,137,231,72,184,237,237,65,84,73,137,228,
-  72,129,228,239,252,255,208,76,137,228,65,92,195,255,248,11,73,139,191,233,
-  72,137,230,73,139,151,233,72,41,226,73,137,151,233,137,195,72,184,237,237,
-  65,84,73,137,228,72,129,228,239,252,255,208,76,137,228,65,92,137,216,73,139,
-  167,233,91,65,92,65,93,65,94,65,95,93,195,255,248,12,73,57,159,233,15,132,
-  244,247,73,137,159,233,248,1,77,137,183,233,73,137,159,233,77,137,167,233,
-  73,137,175,233,73,43,175,233,73,3,175,233,73,137,174,233,77,137,174,233,76,
-  137,252,255,72,184,237,237,65,84,73,137,228,72,129,228,239,252,255,208,76,
-  137,228,65,92,252,233,244,11,255,248,13,248,1,77,137,174,233,73,137,159,233,
-  255,76,57,227,15,132,244,253,255,76,137,225,72,41,217,72,131,252,249,1,15,
-  130,244,253,255,15,182,19,132,210,15,137,244,254,248,7,232,244,14,248,8,72,
-  131,195,1,72,137,252,233,72,41,217,72,41,209,15,130,244,250,73,137,142,233,
-  77,59,183,233,15,132,244,249,73,129,198,239,72,137,221,72,1,213,65,199,134,
-  233,0,0,0,0,72,133,201,15,132,244,248,77,139,167,233,72,57,252,235,15,135,
-  244,248,76,57,229,15,135,244,248,255,73,137,252,236,248,2,195,248,3,73,139,
-  159,233,76,137,252,255,255,72,190,237,237,255,190,237,255,49,252,246,255,
-  72,184,237,237,65,84,73,137,228,72,129,228,239,252,255,208,76,137,228,65,
-  92,232,244,12,252,233,244,1,248,4,73,139,159,233,76,137,252,255,255,72,184,
-  237,237,65,84,73,137,228,72,129,228,239,252,255,208,76,137,228,65,92,232,
-  244,12,252,233,244,1,255,248,15,76,137,252,255,137,214,15,182,209,77,137,
-  183,233,73,137,159,233,77,137,167,233,73,137,175,233,73,43,175,233,73,3,175,
-  233,73,137,174,233,77,137,174,233,72,184,237,237,65,84,73,137,228,72,129,
-  228,239,252,255,208,76,137,228,65,92,77,139,183,233,73,139,159,233,77,139,
-  167,233,77,139,174,233,73,139,174,233,73,43,175,233,73,3,175,233,129,252,
-  248,239,255,15,133,244,247,195,248,1,129,252,248,239,15,132,244,247,232,244,
-  11,248,1,49,192,195,255,248,16,248,17,72,131,252,236,8,248,1,72,199,4,36,
-  0,0,0,0,76,137,252,255,72,137,230,73,137,159,233,77,137,183,233,73,137,159,
-  233,77,137,167,233,73,137,175,233,73,43,175,233,73,3,175,233,73,137,174,233,
-  77,137,174,233,72,184,237,237,65,84,73,137,228,72,129,228,239,252,255,208,
-  76,137,228,65,92,77,139,183,233,73,139,159,233,77,139,167,233,77,139,174,
-  233,73,139,174,233,255,73,43,175,233,73,3,175,233,133,192,15,137,244,248,
-  72,139,20,36,252,242,15,16,4,36,72,131,196,8,72,131,252,235,4,73,137,159,
-  233,195,248,2,232,244,11,252,233,244,1,255,248,18,248,19,72,131,252,236,8,
-  248,1,72,199,4,36,0,0,0,0,76,137,252,255,72,137,230,73,137,159,233,77,137,
-  183,233,73,137,159,233,77,137,167,233,73,137,175,233,73,43,175,233,73,3,175,
-  233,73,137,174,233,77,137,174,233,72,184,237,237,65,84,73,137,228,72,129,
-  228,239,252,255,208,76,137,228,65,92,77,139,183,233,73,139,159,233,77,139,
-  167,233,77,139,174,233,73,139,174,233,255,73,43,175,233,73,3,175,233,133,
-  192,15,137,244,248,72,139,20,36,252,242,15,16,4,36,72,131,196,8,72,131,252,
-  235,8,73,137,159,233,195,248,2,232,244,11,252,233,244,1,255,248,20,248,21,
-  255,76,57,227,15,132,244,247,255,76,137,225,72,41,217,72,131,252,249,16,15,
-  130,244,247,255,252,243,15,111,3,102,15,215,192,252,247,208,15,188,192,60,
-  10,15,131,244,22,72,1,195,195,248,1,72,141,139,233,72,137,216,76,57,225,73,
-  15,71,204,248,2,72,57,200,15,132,244,22,252,246,0,128,15,132,244,249,72,131,
-  192,1,252,233,244,2,248,3,72,137,195,195,255,248,23,72,131,252,236,16,248,
-  1,72,57,252,235,15,133,244,248,72,131,196,16,49,192,195,248,2,76,137,252,
-  255,72,137,230,77,137,183,233,73,137,159,233,77,137,167,233,73,137,175,233,
-  73,43,175,233,73,3,175,233,73,137,174,233,77,137,174,233,72,184,237,237,65,
-  84,73,137,228,72,129,228,239,252,255,208,76,137,228,65,92,77,139,183,233,
-  73,139,159,233,77,139,167,233,77,139,174,233,255,73,139,174,233,73,43,175,
-  233,73,3,175,233,131,252,248,0,15,141,244,249,139,20,36,72,131,196,16,195,
-  248,3,232,244,11,252,233,244,1,255,248,14,248,24,255,76,57,227,15,132,244,
-  22,255,76,137,225,72,41,217,72,131,252,249,10,15,130,244,22,255,72,137,223,
-  72,184,237,237,65,84,73,137,228,72,129,228,239,252,255,208,76,137,228,65,
-  92,72,133,192,15,132,244,22,72,137,195,72,131,252,235,1,73,137,159,233,195,
-  255,248,22,72,131,252,236,8,248,1,72,199,4,36,0,0,0,0,76,137,252,255,72,137,
-  230,73,137,159,233,77,137,183,233,73,137,159,233,77,137,167,233,73,137,175,
-  233,73,43,175,233,73,3,175,233,73,137,174,233,77,137,174,233,72,184,237,237,
-  65,84,73,137,228,72,129,228,239,252,255,208,76,137,228,65,92,77,139,183,233,
-  73,139,159,233,77,139,167,233,77,139,174,233,73,139,174,233,73,43,175,233,
-  255,73,3,175,233,133,192,15,137,244,248,72,139,20,36,252,242,15,16,4,36,72,
-  131,196,8,72,131,252,235,1,73,137,159,233,195,248,2,232,244,11,252,233,244,
-  1,255,248,25,72,131,252,236,8,72,137,52,36,248,1,76,137,252,255,77,137,183,
-  233,73,137,159,233,77,137,167,233,73,137,175,233,73,43,175,233,73,3,175,233,
-  73,137,174,233,77,137,174,233,73,137,159,233,72,184,237,237,65,84,73,137,
-  228,72,129,228,239,252,255,208,76,137,228,65,92,77,139,183,233,73,139,159,
-  233,77,139,167,233,77,139,174,233,73,139,174,233,73,43,175,233,255,73,3,175,
-  233,131,252,248,0,15,141,244,248,72,131,196,8,195,248,2,232,244,11,72,139,
-  52,36,72,57,252,235,15,133,244,1,184,237,72,131,196,8,195,255,248,26,81,82,
-  72,131,252,236,16,72,137,252,247,72,137,214,72,137,226,72,184,237,237,65,
-  84,73,137,228,72,129,228,239,252,255,208,76,137,228,65,92,72,131,196,16,90,
-  89,132,192,15,132,244,248,72,139,68,36,224,195,248,2,72,49,192,72,252,247,
-  208,195,255,76,57,227,15,133,244,249,255,76,137,225,72,41,217,72,129,252,
-  249,239,15,131,244,249,255,248,2,255,232,244,14,255,232,244,24,255,232,244,
-  17,255,232,244,19,255,252,233,244,250,255,248,3,255,139,19,255,72,139,19,
-  255,252,243,15,16,3,255,252,242,15,16,3,255,15,182,19,132,210,15,136,244,
-  2,255,248,4,255,137,208,209,252,234,131,224,1,252,247,216,49,194,255,72,137,
-  208,72,209,252,234,72,131,224,1,72,252,247,216,72,49,194,255,72,133,210,15,
-  149,210,255,73,137,149,233,255,65,137,149,233,255,252,242,65,15,17,133,233,
-  255,252,243,65,15,17,133,233,255,65,136,149,233,255,65,128,141,233,235,255,
-  76,137,252,239,255,72,184,237,237,65,84,73,137,228,72,129,228,239,252,255,
-  208,76,137,228,65,92,255,132,192,15,133,244,251,232,244,12,252,233,244,1,
-  248,5,255,72,129,195,239,255,232,244,20,255,232,244,21,255,232,244,16,255,
-  232,244,18,255,252,246,3,128,15,133,244,2,255,249,248,1,255,76,57,227,15,
-  132,244,252,255,76,137,225,72,41,217,72,131,252,249,2,15,130,244,252,255,
-  15,182,19,132,210,15,137,244,253,15,182,139,233,132,201,15,136,244,252,193,
-  225,7,131,226,127,9,202,72,131,195,2,252,233,244,254,248,6,232,244,23,133,
-  192,15,133,244,254,195,248,7,72,131,195,1,248,8,137,209,193,252,234,3,128,
-  225,7,255,248,2,129,252,250,239,255,15,131,244,253,255,15,131,244,251,255,
-  72,184,237,237,72,139,4,208,255,72,139,4,213,237,255,248,3,56,200,255,15,
-  133,244,252,255,15,133,244,251,255,72,193,232,16,72,141,21,244,250,249,248,
-  4,72,1,208,195,248,5,72,184,237,237,73,137,134,233,232,244,15,133,192,15,
-  132,244,1,72,141,5,244,255,195,255,248,6,56,204,15,133,244,5,72,129,194,239,
-  255,252,233,244,26,255,248,7,255,232,244,26,252,233,244,3,255,76,57,227,15,
-  133,244,247,255,76,137,225,72,41,217,72,129,252,249,239,15,131,244,247,255,
-  232,244,25,129,252,248,239,15,132,244,249,129,252,248,239,15,132,245,252,
-  233,244,251,255,128,59,235,255,102,129,59,238,255,102,129,59,238,15,133,244,
-  248,128,187,233,235,248,2,255,129,59,239,255,129,59,239,15,133,244,249,128,
-  187,233,235,255,15,132,244,250,248,3,255,232,245,72,133,192,15,132,245,252,
-  255,224,255,252,233,245,255,248,4,72,129,195,239,248,5,255,248,1,76,137,252,
-  239,255,132,192,15,133,244,248,232,244,12,252,233,244,1,248,2,255,144,255,
-  248,9,255,73,139,151,233,72,184,237,237,65,84,73,137,228,72,129,228,239,252,
-  255,208,76,137,228,65,92,255,249,249,72,131,252,236,8,255,72,137,252,234,
-  72,41,218,255,72,133,192,15,133,244,248,232,244,12,252,233,244,1,248,2,255,
-  73,137,197,255,72,57,252,235,15,132,244,250,248,1,76,57,227,15,133,244,248,
-  232,244,12,252,233,244,1,248,2,255,72,137,218,76,137,225,72,41,217,77,139,
-  135,233,72,184,237,237,65,84,73,137,228,72,129,228,239,252,255,208,76,137,
-  228,65,92,72,1,195,255,76,57,227,15,132,244,249,232,244,27,248,3,255,76,137,
-  227,255,72,57,252,235,15,133,244,1,248,4,255,77,137,174,233,73,199,134,233,
-  0,0,0,0,77,59,183,233,15,132,244,28,73,129,198,239,65,199,134,233,237,255,
-  232,244,13,255,73,129,252,238,239,77,139,174,233,255,77,139,167,233,73,3,
-  174,233,73,59,175,233,15,130,244,247,76,57,229,15,135,244,247,73,137,252,
-  236,248,1,255,72,57,221,15,132,245,255,232,245,255,248,9,72,131,196,8,195,
-  255
-};
-
-# 12 "upb/pb/compile_decoder_x64.dasc"
-/*|.globals UPB_JIT_GLOBAL_ */
-enum {
-  UPB_JIT_GLOBAL_enterjit,
-  UPB_JIT_GLOBAL_exitjit,
-  UPB_JIT_GLOBAL_suspend,
-  UPB_JIT_GLOBAL_pushlendelim,
-  UPB_JIT_GLOBAL_decodev32_fallback,
-  UPB_JIT_GLOBAL_parse_unknown,
-  UPB_JIT_GLOBAL_skipf32_fallback,
-  UPB_JIT_GLOBAL_decodef32_fallback,
-  UPB_JIT_GLOBAL_skipf64_fallback,
-  UPB_JIT_GLOBAL_decodef64_fallback,
-  UPB_JIT_GLOBAL_skipv32_fallback,
-  UPB_JIT_GLOBAL_skipv64_fallback,
-  UPB_JIT_GLOBAL_decode_varint_slow,
-  UPB_JIT_GLOBAL_decode_unknown_tag_fallback,
-  UPB_JIT_GLOBAL_decodev64_fallback,
-  UPB_JIT_GLOBAL_checktag_fallback,
-  UPB_JIT_GLOBAL_hashlookup,
-  UPB_JIT_GLOBAL_strret_fallback,
-  UPB_JIT_GLOBAL_err,
-  UPB_JIT_GLOBAL__MAX
-};
-# 13 "upb/pb/compile_decoder_x64.dasc"
-/*|.globalnames upb_jit_globalnames */
-static const char *const upb_jit_globalnames[] = {
-  "enterjit",
-  "exitjit",
-  "suspend",
-  "pushlendelim",
-  "decodev32_fallback",
-  "parse_unknown",
-  "skipf32_fallback",
-  "decodef32_fallback",
-  "skipf64_fallback",
-  "decodef64_fallback",
-  "skipv32_fallback",
-  "skipv64_fallback",
-  "decode_varint_slow",
-  "decode_unknown_tag_fallback",
-  "decodev64_fallback",
-  "checktag_fallback",
-  "hashlookup",
-  "strret_fallback",
-  "err",
-  (const char *)0
-};
-# 14 "upb/pb/compile_decoder_x64.dasc"
-/*| */
-/*|// Calling conventions.  Note -- this will need to be changed for */
-/*|// Windows, which uses a different calling convention! */
-/*|.define ARG1_64,   rdi */
-/*|.define ARG2_8,    r6b  // DynASM's equivalent to "sil" -- low byte of esi. */
-/*|.define ARG2_32,   esi */
-/*|.define ARG2_64,   rsi */
-/*|.define ARG3_8,    dl */
-/*|.define ARG3_32,   edx */
-/*|.define ARG3_64,   rdx */
-/*|.define ARG4_64,   rcx */
-/*|.define ARG5_64,   r8 */
-/*|.define XMMARG1,   xmm0 */
-/*| */
-/*|// Register allocation / type map. */
-/*|// ALL of the code in this file uses these register allocations. */
-/*|// When we "call" within this file, we do not use regular calling */
-/*|// conventions, but of course when calling to user callbacks we must. */
-/*|.define PTR,       rbx                       // DECODER->ptr      (unsynced) */
-/*|.define DATAEND,   r12                       // DECODER->data_end (unsynced) */
-/*|.define CLOSURE,   r13                       // FRAME->closure    (unsynced) */
-/*|.type   FRAME,     upb_pbdecoder_frame, r14  // DECODER->top      (unsynced) */
-#define Dt1(_V) (int)(ptrdiff_t)&(((upb_pbdecoder_frame *)0)_V)
-# 36 "upb/pb/compile_decoder_x64.dasc"
-/*|.type   DECODER,   upb_pbdecoder, r15        // DECODER           (immutable) */
-#define Dt2(_V) (int)(ptrdiff_t)&(((upb_pbdecoder *)0)_V)
-# 37 "upb/pb/compile_decoder_x64.dasc"
-/*|.define DELIMEND,  rbp */
-/*| */
-/*| // Spills unsynced registers back to memory. */
-/*|.macro commit_regs */
-/*|  mov  DECODER->top, FRAME */
-/*|  mov  DECODER->ptr, PTR */
-/*|  mov  DECODER->data_end, DATAEND */
-/*|  // We don't guarantee that delim_end is NULL when out of range like the */
-/*|  // interpreter does. */
-/*|  mov  DECODER->delim_end, DELIMEND */
-/*|  sub  DELIMEND, DECODER->buf */
-/*|  add  DELIMEND, DECODER->bufstart_ofs */
-/*|  mov  FRAME->end_ofs, DELIMEND */
-/*|  mov  FRAME->sink.closure, CLOSURE */
-/*|.endmacro */
-/*| */
-/*| // Loads unsynced registers from memory back into registers. */
-/*|.macro load_regs */
-/*|  mov  FRAME, DECODER->top */
-/*|  mov  PTR, DECODER->ptr */
-/*|  mov  DATAEND, DECODER->data_end */
-/*|  mov  CLOSURE, FRAME->sink.closure */
-/*|  mov  DELIMEND, FRAME->end_ofs */
-/*|  sub  DELIMEND, DECODER->bufstart_ofs */
-/*|  add  DELIMEND, DECODER->buf */
-/*|.endmacro */
-/*| */
-/*| // Calls an external C function at address "addr". */
-/*|.macro callp, addr */
-/*|    mov64  rax, (uintptr_t)addr */
-/*| */
-/*|    // Stack must be 16-byte aligned (x86-64 ABI requires this). */
-/*|    // */
-/*|    // OPT: possibly remove this by statically ensuring correct alignment. */
-/*|    // */
-/*|    // OPT: use "call rel32" where possible. */
-/*|    push   r12 */
-/*|    mov    r12, rsp */
-/*|    and    rsp, 0xfffffffffffffff0UL   // Align stack. */
-/*|    call   rax */
-/*|    mov    rsp, r12 */
-/*|    pop    r12 */
-/*|.endmacro */
-/*| */
-/*|.macro ld64, val */
-/*|| { */
-/*|| uintptr_t v = (uintptr_t)val; */
-/*|| if (v > 0xffffffff) { */
-/*|    mov64  ARG2_64, v */
-/*|| } else if (v) { */
-/*|    mov    ARG2_32, v */
-/*|| } else { */
-/*|    xor    ARG2_32, ARG2_32 */
-/*|| } */
-/*|| } */
-/*|.endmacro */
-/*| */
-/*|.macro load_handler_data, h, arg */
-/*|  ld64   upb_handlers_gethandlerdata(h, arg) */
-/*|.endmacro */
-/*| */
-/*|.macro chkeob, bytes, target */
-/*|| if (bytes == 1) { */
-/*|  cmp    PTR, DATAEND */
-/*|  je     target */
-/*|| } else { */
-/*|  mov    rcx, DATAEND */
-/*|  sub    rcx, PTR */
-/*|  cmp    rcx, bytes */
-/*|  jb     target */
-/*|| } */
-/*|.endmacro */
-/*| */
-/*|.macro chkneob, bytes, target */
-/*|| if (bytes == 1) { */
-/*|  cmp    PTR, DATAEND */
-/*|  jne    target */
-/*|| } else { */
-/*|  mov    rcx, DATAEND */
-/*|  sub    rcx, PTR */
-/*|  cmp    rcx, bytes */
-/*|  jae    target */
-/*|| } */
-/*|.endmacro */
-
-/*|.macro sethas, reg, hasbit */
-/*|| if (hasbit >= 0) { */
-/*|    or   byte [reg + ((uint32_t)hasbit / 8)], (1 << ((uint32_t)hasbit % 8)) */
-/*|| } */
-/*|.endmacro */
-/*| */
-/*| // Decodes 32-bit varint into rdx, inlining 1 byte. */
-/*|.macro dv32 */
-/*|  chkeob  1, >7 */
-/*|  movzx   edx, byte [PTR] */
-/*|  test    dl, dl */
-/*|  jns     >8 */
-/*|7: */
-/*|  call    ->decodev32_fallback */
-/*|8: */
-/*|  add     PTR, 1 */
-/*|.endmacro */
-
-#define DECODE_EOF -3
-
-static upb_func *gethandler(const upb_handlers *h, upb_selector_t sel) {
-  return h ? upb_handlers_gethandler(h, sel) : NULL;
-}
-
-/* Defines an "assembly label" for the current code generation offset.
- * This label exists *purely* for debugging purposes: it is emitted into
- * the .so, and printed as part of JIT debugging output when UPB_JIT_LOAD_SO is
- * defined.
- *
- * We would define this in the .c file except that it conditionally defines a
- * pclabel. */
-static void asmlabel(jitcompiler *jc, const char *fmt, ...) {
-#ifndef NDEBUG
-  int ofs = jc->dynasm->section->ofs;
-  UPB_ASSERT(ofs != jc->lastlabelofs);
-  jc->lastlabelofs = ofs;
-#endif
-
-#ifndef UPB_JIT_LOAD_SO
-  UPB_UNUSED(jc);
-  UPB_UNUSED(fmt);
-#else
-  va_list args;
-  va_start(args, fmt);
-  char *str = upb_vasprintf(fmt, args);
-  va_end(args);
-
-  int pclabel = alloc_pclabel(jc);
-  /* Normally we would prefer to allocate this inline with the codegen,
-   * ie.
-   *   |=>asmlabel(...)
-   * But since we do this conditionally, only when UPB_JIT_LOAD_SO is defined,
-   * we do it here instead. */
-  /*|=>pclabel: */
-  dasm_put(Dst, 0, pclabel);
-# 176 "upb/pb/compile_decoder_x64.dasc"
-  upb_inttable_insert(&jc->asmlabels, pclabel, upb_value_ptr(str));
-#endif
-}
-
-/* Should only be called when the associated handler is known to exist. */
-static bool alwaysok(const upb_handlers *h, upb_selector_t sel) {
-  upb_handlerattr attr = UPB_HANDLERATTR_INITIALIZER;
-  bool ok = upb_handlers_getattr(h, sel, &attr);
-  bool ret;
-
-  UPB_ASSERT(ok);
-  ret = upb_handlerattr_alwaysok(&attr);
-  upb_handlerattr_uninit(&attr);
-  return ret;
-}
-
-/* Emit static assembly routines; code that does not vary based on the message
- * schema.  Since it's not input-dependent, we only need one single copy of it.
- * For the moment we generate a single copy per generated handlers.  Eventually
- * we should generate this code at compile time and link it into the binary so
- * we have one copy total.  To do that we'll want to be sure that it is within
- * 2GB of our JIT code, so that branches between the two are near (rel32).
- *
- * We'd put this assembly in a .s file directly, but DynASM's ability to
- * calculate structure offsets automatically is too useful to pass up (it's way
- * more convenient to write DECODER->sink than [rbx + 0x96], especially since
- * the latter would have to be changed whenever the structure is updated). */
-static void emit_static_asm(jitcompiler *jc) {
-  /*| // Trampolines for entering/exiting the JIT.  These are a bit tricky to */
-  /*| // support full resuming; when we suspend we copy the JIT's portion of */
-  /*| // the call stack into the upb_pbdecoder and restore it when we resume. */
-  asmlabel(jc, "enterjit");
-  /*|->enterjit: */
-  /*|1: */
-  /*|  push  rbp */
-  /*|  push  r15 */
-  /*|  push  r14 */
-  /*|  push  r13 */
-  /*|  push  r12 */
-  /*|  push  rbx */
-  /*| */
-  /*|  mov   rbx, ARG2_64  // Preserve JIT method. */
-  /*| */
-  /*|  mov   DECODER, rdi */
-  /*|  callp upb_pbdecoder_resume  // Same args as us; reuse regs. */
-  /*|  test  eax, eax */
-  /*|  jns   >1 */
-  /*|  mov   DECODER->saved_rsp, rsp */
-  /*|  mov   rax, rbx */
-  /*|  load_regs */
-  /*| */
-  /*|  // Test whether we have a saved stack to resume. */
-  /*|  mov   ARG3_64, DECODER->call_len */
-  /*|  test  ARG3_64, ARG3_64 */
-  /*|  jnz   >2 */
-  /*| */
-  /*|  call  rax */
-  /*| */
-  /*|  mov   rax, DECODER->size_param */
-  /*|  mov   qword DECODER->call_len, 0 */
-  /*|1: */
-  /*|  pop   rbx */
-  dasm_put(Dst, 2, (unsigned int)((uintptr_t)upb_pbdecoder_resume), (unsigned int)(((uintptr_t)upb_pbdecoder_resume)>>32), 0xfffffffffffffff0UL, Dt2(->saved_rsp), Dt2(->top), Dt2(->ptr), Dt2(->data_end), Dt1(->sink.closure), Dt1(->end_ofs), Dt2(->bufstart_ofs), Dt2(->buf), Dt2(->call_len), Dt2(->size_param), Dt2(->call_len));
-# 238 "upb/pb/compile_decoder_x64.dasc"
-  /*|  pop   r12 */
-  /*|  pop   r13 */
-  /*|  pop   r14 */
-  /*|  pop   r15 */
-  /*|  pop   rbp */
-  /*|  ret */
-  /*| */
-  /*|2: */
-  /*|  // Resume decoder. */
-  /*|  mov   ARG2_64, DECODER->callstack */
-  /*|  sub   rsp, ARG3_64 */
-  /*|  mov   ARG1_64, rsp */
-  /*|  callp memcpy  // Restore stack. */
-  /*|  ret  // Return to resumed function (not ->enterjit caller). */
-  /*| */
-  /*| // Other code can call this to suspend the JIT. */
-  /*| // To the calling code, it will appear that the function returns when */
-  /*| // the JIT resumes, and more buffer space will be available. */
-  /*| // Args: eax=the value that decode() should return. */
-  dasm_put(Dst, 115, Dt2(->callstack), (unsigned int)((uintptr_t)memcpy), (unsigned int)(((uintptr_t)memcpy)>>32), 0xfffffffffffffff0UL);
-# 257 "upb/pb/compile_decoder_x64.dasc"
-  asmlabel(jc, "exitjit");
-  /*|->exitjit: */
-  /*|  // Save the stack into DECODER->callstack. */
-  /*|  mov   ARG1_64, DECODER->callstack */
-  /*|  mov   ARG2_64, rsp */
-  /*|  mov   ARG3_64, DECODER->saved_rsp */
-  /*|  sub   ARG3_64, rsp */
-  /*|  mov   DECODER->call_len, ARG3_64  // Preserve len for next resume. */
-  /*|  mov   ebx, eax  // Preserve return value across memcpy. */
-  /*|  callp memcpy    // Copy stack into decoder. */
-  /*|  mov   eax, ebx  // This will be our return value. */
-  /*| */
-  /*|  // Must NOT do this before the memcpy(), otherwise memcpy() will */
-  /*|  // clobber the stack we are trying to save! */
-  /*|  mov   rsp, DECODER->saved_rsp */
-  /*|  pop   rbx */
-  /*|  pop   r12 */
-  /*|  pop   r13 */
-  /*|  pop   r14 */
-  /*|  pop   r15 */
-  /*|  pop   rbp */
-  /*|  ret */
-  /*| */
-  /*| // Like suspend() in the C decoder, except that the function appears */
-  /*| // (from the caller's perspective) not to return until the decoder is */
-  /*| // resumed. */
-  dasm_put(Dst, 161, Dt2(->callstack), Dt2(->saved_rsp), Dt2(->call_len), (unsigned int)((uintptr_t)memcpy), (unsigned int)(((uintptr_t)memcpy)>>32), 0xfffffffffffffff0UL, Dt2(->saved_rsp));
-# 283 "upb/pb/compile_decoder_x64.dasc"
-  asmlabel(jc, "suspend");
-  /*|->suspend: */
-  /*|  cmp   DECODER->ptr, PTR */
-  /*|  je    >1 */
-  /*|  mov   DECODER->checkpoint, PTR */
-  /*|1: */
-  /*|  commit_regs */
-  /*|  mov   rdi, DECODER */
-  /*|  callp upb_pbdecoder_suspend */
-  /*|  jmp   ->exitjit */
-  /*| */
-  dasm_put(Dst, 222, Dt2(->ptr), Dt2(->checkpoint), Dt2(->top), Dt2(->ptr), Dt2(->data_end), Dt2(->delim_end), Dt2(->buf), Dt2(->bufstart_ofs), Dt1(->end_ofs), Dt1(->sink.closure), (unsigned int)((uintptr_t)upb_pbdecoder_suspend), (unsigned int)(((uintptr_t)upb_pbdecoder_suspend)>>32), 0xfffffffffffffff0UL);
-# 294 "upb/pb/compile_decoder_x64.dasc"
-  asmlabel(jc, "pushlendelim");
-  /*|->pushlendelim: */
-  /*|1: */
-  /*|  mov   FRAME->sink.closure, CLOSURE */
-  /*|  mov   DECODER->checkpoint, PTR */
-  /*|  dv32 */
-  dasm_put(Dst, 300, Dt1(->sink.closure), Dt2(->checkpoint));
-   if (1 == 1) {
-  dasm_put(Dst, 313);
-   } else {
-  dasm_put(Dst, 321);
-   }
-# 300 "upb/pb/compile_decoder_x64.dasc"
-  /*|  mov   rcx, DELIMEND */
-  /*|  sub   rcx, PTR */
-  /*|  sub   rcx, rdx */
-  /*|  jb    >4   // Len is greater than enclosing message. */
-  /*|  mov   FRAME->end_ofs, rcx */
-  /*|  cmp   FRAME, DECODER->limit */
-  /*|  je    >3   // Stack overflow */
-  /*|  add   FRAME, sizeof(upb_pbdecoder_frame) */
-  /*|  mov   DELIMEND, PTR */
-  /*|  add   DELIMEND, rdx */
-  /*|  mov   dword FRAME->groupnum, 0 */
-  /*|  test  rcx, rcx */
-  /*|  jz    >2 */
-  /*|  mov   DATAEND, DECODER->end */
-  /*|  cmp   PTR, DELIMEND */
-  /*|  ja    >2 */
-  /*|  cmp   DELIMEND, DATAEND */
-  /*|  ja    >2 */
-  /*|  mov   DATAEND, DELIMEND  // If DELIMEND >= PTR && DELIMEND < DATAEND */
-  dasm_put(Dst, 337, Dt1(->end_ofs), Dt2(->limit), sizeof(upb_pbdecoder_frame), Dt1(->groupnum), Dt2(->end));
-# 319 "upb/pb/compile_decoder_x64.dasc"
-  /*|2: */
-  /*|  ret */
-  /*|3: */
-  /*|  // Stack overflow error. */
-  /*|  mov   PTR, DECODER->checkpoint  // Rollback to before the delim len. */
-  /*|  // Prepare seterr args. */
-  /*|  mov   ARG1_64, DECODER */
-  /*|  ld64  kPbDecoderStackOverflow */
-  dasm_put(Dst, 428, Dt2(->checkpoint));
-   {
-   uintptr_t v = (uintptr_t)kPbDecoderStackOverflow;
-   if (v > 0xffffffff) {
-  dasm_put(Dst, 446, (unsigned int)(v), (unsigned int)((v)>>32));
-   } else if (v) {
-  dasm_put(Dst, 451, v);
-   } else {
-  dasm_put(Dst, 454);
-   }
-   }
-# 327 "upb/pb/compile_decoder_x64.dasc"
-  /*|  callp upb_pbdecoder_seterr */
-  /*|  call  ->suspend */
-  /*|  jmp   <1 */
-  /*|4: */
-  /*|  // Overextended len. */
-  /*|  mov   PTR, DECODER->checkpoint  // Rollback to before the delim len. */
-  /*|  // Prepare seterr args. */
-  /*|  mov   ARG1_64, DECODER */
-  /*|  ld64  kPbDecoderSubmessageTooLong */
-  dasm_put(Dst, 458, (unsigned int)((uintptr_t)upb_pbdecoder_seterr), (unsigned int)(((uintptr_t)upb_pbdecoder_seterr)>>32), 0xfffffffffffffff0UL, Dt2(->checkpoint));
-   {
-   uintptr_t v = (uintptr_t)kPbDecoderSubmessageTooLong;
-   if (v > 0xffffffff) {
-  dasm_put(Dst, 446, (unsigned int)(v), (unsigned int)((v)>>32));
-   } else if (v) {
-  dasm_put(Dst, 451, v);
-   } else {
-  dasm_put(Dst, 454);
-   }
-   }
-# 336 "upb/pb/compile_decoder_x64.dasc"
-  /*|  callp upb_pbdecoder_seterr */
-  /*|  call  ->suspend */
-  /*|  jmp   <1 */
-  /*| */
-  /*| // For getting a value that spans a buffer seam.  Falls back to C. */
-  /*|.macro getvalue_slow, func, bytes */
-  /*|  sub   rsp, 8           // Need stack space for func to write value to. */
-  /*|1: */
-  /*|  mov   qword [rsp], 0   // For parsing routines that only parse 32 bits. */
-  /*|  mov   ARG1_64, DECODER */
-  /*|  mov   ARG2_64, rsp */
-  /*|  mov   DECODER->checkpoint, PTR */
-  /*|  commit_regs */
-  /*|  callp func */
-  /*|  load_regs */
-  /*|  test  eax, eax */
-  /*|  jns   >2 */
-  /*|  // Success; return parsed data (in rdx AND xmm0). */
-  /*|  mov   rdx, [rsp] */
-  /*|  movsd xmm0, qword [rsp] */
-  /*|  add   rsp, 8 */
-  /*|  sub   PTR, bytes       // Bias our buffer pointer to rejoin the fast-path. */
-  /*|  mov   DECODER->ptr, PTR */
-  /*|  ret */
-  /*|2: */
-  /*|  call  ->exitjit   // Return eax from decode function. */
-  /*|  jmp   <1 */
-  /*|.endmacro */
-  /*| */
-  dasm_put(Dst, 497, (unsigned int)((uintptr_t)upb_pbdecoder_seterr), (unsigned int)(((uintptr_t)upb_pbdecoder_seterr)>>32), 0xfffffffffffffff0UL);
-# 365 "upb/pb/compile_decoder_x64.dasc"
-  asmlabel(jc, "parse_unknown");
-  /*| // Args: edx=fieldnum, cl=wire type */
-  /*|->parse_unknown: */
-  /*|  // OPT: handle directly instead of kicking to C. */
-  /*|  // Check for ENDGROUP. */
-  /*|  mov     ARG1_64, DECODER */
-  /*|  mov     ARG2_32, edx */
-  /*|  movzx   ARG3_32, cl */
-  /*|  commit_regs */
-  /*|  callp   upb_pbdecoder_skipunknown */
-  /*|  load_regs */
-  /*|  cmp     eax, DECODE_ENDGROUP */
-  /*|  jne     >1 */
-  dasm_put(Dst, 526, Dt2(->top), Dt2(->ptr), Dt2(->data_end), Dt2(->delim_end), Dt2(->buf), Dt2(->bufstart_ofs), Dt1(->end_ofs), Dt1(->sink.closure), (unsigned int)((uintptr_t)upb_pbdecoder_skipunknown), (unsigned int)(((uintptr_t)upb_pbdecoder_skipunknown)>>32), 0xfffffffffffffff0UL, Dt2(->top), Dt2(->ptr), Dt2(->data_end), Dt1(->sink.closure), Dt1(->end_ofs), Dt2(->bufstart_ofs), Dt2(->buf), DECODE_ENDGROUP);
-# 378 "upb/pb/compile_decoder_x64.dasc"
-  /*|  ret     // Return eax=DECODE_ENDGROUP, not zero */
-  /*|1: */
-  /*|  cmp     eax, DECODE_OK */
-  /*|  je      >1 */
-  /*|  call    ->exitjit  // Return eax from decode function. */
-  /*|1: */
-  /*|  xor     eax, eax */
-  /*|  ret */
-  /*| */
-  /*| // Fallback functions for parsing single values.  These are used when the */
-  /*| // buffer doesn't contain enough remaining data for the fast path.  Each */
-  /*| // primitive type (v32, v64, f32, f64) has two functions: decode & skip. */
-  /*| // Decode functions return their value in rsi/esi. */
-  /*| // */
-  /*| // These functions leave PTR = value_end - fast_path_bytes, so that we can */
-  /*| // re-join the fast path which will add fast_path_bytes after the callback */
-  /*| // completes.  We also set DECODER->ptr to this value which is a signal to */
-  /*| // ->suspend that DECODER->checkpoint is up to date. */
-  dasm_put(Dst, 623, DECODE_OK);
-# 396 "upb/pb/compile_decoder_x64.dasc"
-  asmlabel(jc, "skip_decode_f32_fallback");
-  /*|->skipf32_fallback: */
-  /*|->decodef32_fallback: */
-  /*|  getvalue_slow upb_pbdecoder_decode_f32, 4 */
-  dasm_put(Dst, 647, Dt2(->checkpoint), Dt2(->top), Dt2(->ptr), Dt2(->data_end), Dt2(->delim_end), Dt2(->buf), Dt2(->bufstart_ofs), Dt1(->end_ofs), Dt1(->sink.closure), (unsigned int)((uintptr_t)upb_pbdecoder_decode_f32), (unsigned int)(((uintptr_t)upb_pbdecoder_decode_f32)>>32), 0xfffffffffffffff0UL, Dt2(->top), Dt2(->ptr), Dt2(->data_end), Dt1(->sink.closure), Dt1(->end_ofs));
-# 400 "upb/pb/compile_decoder_x64.dasc"
-  /*| */
-  dasm_put(Dst, 751, Dt2(->bufstart_ofs), Dt2(->buf), Dt2(->ptr));
-# 401 "upb/pb/compile_decoder_x64.dasc"
-  asmlabel(jc, "skip_decode_f64_fallback");
-  /*|->skipf64_fallback: */
-  /*|->decodef64_fallback: */
-  /*|  getvalue_slow upb_pbdecoder_decode_f64, 8 */
-  dasm_put(Dst, 799, Dt2(->checkpoint), Dt2(->top), Dt2(->ptr), Dt2(->data_end), Dt2(->delim_end), Dt2(->buf), Dt2(->bufstart_ofs), Dt1(->end_ofs), Dt1(->sink.closure), (unsigned int)((uintptr_t)upb_pbdecoder_decode_f64), (unsigned int)(((uintptr_t)upb_pbdecoder_decode_f64)>>32), 0xfffffffffffffff0UL, Dt2(->top), Dt2(->ptr), Dt2(->data_end), Dt1(->sink.closure), Dt1(->end_ofs));
-# 405 "upb/pb/compile_decoder_x64.dasc"
-  /*| */
-  /*| // Called for varint >= 1 byte. */
-  dasm_put(Dst, 903, Dt2(->bufstart_ofs), Dt2(->buf), Dt2(->ptr));
-# 407 "upb/pb/compile_decoder_x64.dasc"
-  asmlabel(jc, "skip_decode_v32_fallback");
-  /*|->skipv32_fallback: */
-  /*|->skipv64_fallback: */
-  /*|  chkeob   16, >1 */
-  dasm_put(Dst, 951);
-   if (16 == 1) {
-  dasm_put(Dst, 956);
-   } else {
-  dasm_put(Dst, 964);
-   }
-# 411 "upb/pb/compile_decoder_x64.dasc"
-  /*|  // With at least 16 bytes left, we can do a branch-less SSE version. */
-  /*|  movdqu   xmm0, [PTR] */
-  /*|  pmovmskb eax, xmm0   // bits 0-15 are continuation bits, 16-31 are 0. */
-  /*|  not      eax */
-  /*|  bsf      eax, eax */
-  /*|  cmp      al, 10 */
-  /*|  jae      ->decode_varint_slow  // Error (>10 byte varint). */
-  /*|  add      PTR, rax    // bsf result is 0-based, so PTR=end-1, as desired. */
-  /*|  ret */
-  /*| */
-  /*|1: */
-  /*|  // With fewer than 16 bytes, we have to read byte by byte. */
-  /*|  lea      rcx, [PTR + 10] */
-  /*|  mov      rax, PTR    // Preserve PTR in case of fallback to slow path. */
-  /*|  cmp      rcx, DATAEND */
-  /*|  cmova    rcx, DATAEND    // rcx = MIN(DATAEND, PTR + 10) */
-  /*|2: */
-  /*|  cmp      rax, rcx */
-  /*|  je       ->decode_varint_slow */
-  /*|  test     byte [rax], 0x80 */
-  /*|  jz       >3 */
-  /*|  add      rax, 1 */
-  /*|  jmp      <2 */
-  /*|3: */
-  /*|  mov      PTR, rax  // PTR = varint_end - 1, as desired */
-  /*|  ret */
-  /*| */
-  /*| // Returns tag in edx */
-  dasm_put(Dst, 980, 10);
-# 439 "upb/pb/compile_decoder_x64.dasc"
-  asmlabel(jc, "decode_unknown_tag_fallback");
-  /*|->decode_unknown_tag_fallback: */
-  /*|  sub   rsp, 16 */
-  /*|1: */
-  /*|  cmp      PTR, DELIMEND */
-  /*|  jne      >2 */
-  /*|  add      rsp, 16 */
-  /*|  xor      eax, eax */
-  /*|  ret */
-  /*|2: */
-  /*|  // OPT: Have a medium-fast path before falling back to _slow. */
-  /*|  mov   ARG1_64, DECODER */
-  /*|  mov   ARG2_64, rsp */
-  /*|  commit_regs */
-  /*|  callp upb_pbdecoder_decode_varint_slow */
-  /*|  load_regs */
-  dasm_put(Dst, 1053, Dt2(->top), Dt2(->ptr), Dt2(->data_end), Dt2(->delim_end), Dt2(->buf), Dt2(->bufstart_ofs), Dt1(->end_ofs), Dt1(->sink.closure), (unsigned int)((uintptr_t)upb_pbdecoder_decode_varint_slow), (unsigned int)(((uintptr_t)upb_pbdecoder_decode_varint_slow)>>32), 0xfffffffffffffff0UL, Dt2(->top), Dt2(->ptr), Dt2(->data_end), Dt1(->sink.closure));
-# 455 "upb/pb/compile_decoder_x64.dasc"
-  /*|  cmp   eax, 0 */
-  /*|  jge   >3 */
-  /*|  mov   edx, [rsp]   // Success; return parsed data. */
-  /*|  add   rsp, 16 */
-  /*|  ret */
-  /*|3: */
-  /*|  call  ->exitjit   // Return eax from decode function. */
-  /*|  jmp   <1 */
-  /*| */
-  /*| // Called for varint >= 1 byte. */
-  dasm_put(Dst, 1156, Dt1(->end_ofs), Dt2(->bufstart_ofs), Dt2(->buf));
-# 465 "upb/pb/compile_decoder_x64.dasc"
-  asmlabel(jc, "decode_v32_v64_fallback");
-  /*|->decodev32_fallback: */
-  /*|->decodev64_fallback: */
-  /*|  chkeob   10, ->decode_varint_slow */
-  dasm_put(Dst, 1194);
-   if (10 == 1) {
-  dasm_put(Dst, 1199);
-   } else {
-  dasm_put(Dst, 1207);
-   }
-# 469 "upb/pb/compile_decoder_x64.dasc"
-  /*|  // OPT: do something faster than just calling the C version. */
-  /*|  mov      rdi, PTR */
-  /*|  callp    upb_vdecode_fast */
-  /*|  test     rax, rax */
-  /*|  je       ->decode_varint_slow  // Unterminated varint. */
-  /*|  mov      PTR, rax */
-  /*|  sub      PTR, 1 */
-  /*|  mov      DECODER->ptr, PTR */
-  /*|  ret */
-  /*| */
-  dasm_put(Dst, 1223, (unsigned int)((uintptr_t)upb_vdecode_fast), (unsigned int)(((uintptr_t)upb_vdecode_fast)>>32), 0xfffffffffffffff0UL, Dt2(->ptr));
-# 479 "upb/pb/compile_decoder_x64.dasc"
-  asmlabel(jc, "decode_varint_slow");
-  /*|->decode_varint_slow: */
-  /*|  // Slow path: end of buffer or error (varint length >= 10). */
-  /*|  getvalue_slow upb_pbdecoder_decode_varint_slow, 1 */
-  dasm_put(Dst, 1268, Dt2(->checkpoint), Dt2(->top), Dt2(->ptr), Dt2(->data_end), Dt2(->delim_end), Dt2(->buf), Dt2(->bufstart_ofs), Dt1(->end_ofs), Dt1(->sink.closure), (unsigned int)((uintptr_t)upb_pbdecoder_decode_varint_slow), (unsigned int)(((uintptr_t)upb_pbdecoder_decode_varint_slow)>>32), 0xfffffffffffffff0UL, Dt2(->top), Dt2(->ptr), Dt2(->data_end), Dt1(->sink.closure), Dt1(->end_ofs), Dt2(->bufstart_ofs));
-# 483 "upb/pb/compile_decoder_x64.dasc"
-  /*| */
-  /*| // Args: rsi=expected tag, return=rax (DECODE_{OK,MISMATCH}) */
-  dasm_put(Dst, 1374, Dt2(->buf), Dt2(->ptr));
-# 485 "upb/pb/compile_decoder_x64.dasc"
-  asmlabel(jc, "checktag_fallback");
-  /*|->checktag_fallback: */
-  /*|  sub      rsp, 8 */
-  /*|  mov      [rsp], rsi  // Preserve expected tag. */
-  /*|1: */
-  /*|  mov      ARG1_64, DECODER */
-  /*|  commit_regs */
-  /*|  mov      DECODER->checkpoint, PTR */
-  /*|  callp    upb_pbdecoder_checktag_slow */
-  /*|  load_regs */
-  dasm_put(Dst, 1418, Dt2(->top), Dt2(->ptr), Dt2(->data_end), Dt2(->delim_end), Dt2(->buf), Dt2(->bufstart_ofs), Dt1(->end_ofs), Dt1(->sink.closure), Dt2(->checkpoint), (unsigned int)((uintptr_t)upb_pbdecoder_checktag_slow), (unsigned int)(((uintptr_t)upb_pbdecoder_checktag_slow)>>32), 0xfffffffffffffff0UL, Dt2(->top), Dt2(->ptr), Dt2(->data_end), Dt1(->sink.closure), Dt1(->end_ofs), Dt2(->bufstart_ofs));
-# 495 "upb/pb/compile_decoder_x64.dasc"
-  /*|  cmp      eax, 0 */
-  /*|  jge      >2 */
-  /*|  add      rsp, 8 */
-  /*|  ret */
-  /*|2: */
-  /*|  call     ->exitjit */
-  /*|  mov      rsi, [rsp] */
-  /*|  cmp      PTR, DELIMEND */
-  /*|  jne      <1 */
-  /*|  mov      eax, DECODE_EOF */
-  /*|  add      rsp, 8 */
-  /*|  ret */
-  /*| */
-  /*| // Args: rsi=upb_inttable, rdx=key, return=rax (-1 if not found). */
-  /*| // Preserves: rcx, rdx */
-  /*| // OPT: Could write this in assembly if it's a hotspot. */
-  dasm_put(Dst, 1517, Dt2(->buf), DECODE_EOF);
-# 511 "upb/pb/compile_decoder_x64.dasc"
-  asmlabel(jc, "hashlookup");
-  /*|->hashlookup: */
-  /*|  push   rcx */
-  /*|  push   rdx */
-  /*|  sub    rsp, 16 */
-  /*|  mov    rdi, rsi */
-  /*|  mov    rsi, rdx */
-  /*|  mov    rdx, rsp */
-  /*|  callp  upb_inttable_lookup */
-  /*|  add    rsp, 16 */
-  /*|  pop    rdx */
-  /*|  pop    rcx */
-  /*|  test   al, al */
-  /*|  jz     >2  // Unknown field. */
-  /*|  mov    rax, [rsp-32]  // Value from table. */
-  /*|  ret */
-  /*|2: */
-  /*|  xor    rax, rax */
-  /*|  not    rax */
-  /*|  ret */
-  dasm_put(Dst, 1559, (unsigned int)((uintptr_t)upb_inttable_lookup), (unsigned int)(((uintptr_t)upb_inttable_lookup)>>32), 0xfffffffffffffff0UL);
-# 531 "upb/pb/compile_decoder_x64.dasc"
-}
-
-static void jitprimitive(jitcompiler *jc, opcode op,
-                         const upb_handlers *h, upb_selector_t sel) {
-  typedef enum { V32, V64, F32, F64, X } valtype_t;
-  static valtype_t types[] = {
-    X, F64, F32, V64, V64, V32, F64, F32, V64, X, X, X, X, V32, V32, F32, F64,
-    V32, V64 };
-  static char fastpath_bytes[] = { 1, 1, 4, 8 };
-  const valtype_t vtype = types[op];
-  const int fastbytes = fastpath_bytes[vtype];
-  upb_func *handler = gethandler(h, sel);
-  upb_fieldtype_t ftype;
-  size_t offset;
-  int32_t hasbit;
-
-  if (handler) {
-    /*|1: */
-    /*|  chkneob  fastbytes, >3 */
-    dasm_put(Dst, 112);
-     if (fastbytes == 1) {
-    dasm_put(Dst, 1628);
-     } else {
-    dasm_put(Dst, 1636, fastbytes);
-     }
-# 550 "upb/pb/compile_decoder_x64.dasc"
-    /*|2: */
-    dasm_put(Dst, 1652);
-# 551 "upb/pb/compile_decoder_x64.dasc"
-    switch (vtype) {
-    case V32:
-      /*|  call   ->decodev32_fallback */
-      dasm_put(Dst, 1655);
-# 554 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case V64:
-      /*|  call   ->decodev64_fallback */
-      dasm_put(Dst, 1659);
-# 557 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case F32:
-      /*|  call   ->decodef32_fallback */
-      dasm_put(Dst, 1663);
-# 560 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case F64:
-      /*|  call   ->decodef64_fallback */
-      dasm_put(Dst, 1667);
-# 563 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case X: break;
-    }
-    /*|  jmp    >4 */
-    dasm_put(Dst, 1671);
-# 567 "upb/pb/compile_decoder_x64.dasc"
-
-    /* Fast path decode; for when check_bytes bytes are available. */
-    /*|3: */
-    dasm_put(Dst, 1676);
-# 570 "upb/pb/compile_decoder_x64.dasc"
-    switch (op) {
-    case OP_PARSE_SFIXED32:
-    case OP_PARSE_FIXED32:
-      /*|  mov    edx, dword [PTR] */
-      dasm_put(Dst, 1679);
-# 574 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case OP_PARSE_SFIXED64:
-    case OP_PARSE_FIXED64:
-      /*|  mov    rdx, qword [PTR] */
-      dasm_put(Dst, 1682);
-# 578 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case OP_PARSE_FLOAT:
-      /*|  movss  xmm0, dword [PTR] */
-      dasm_put(Dst, 1686);
-# 581 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case OP_PARSE_DOUBLE:
-      /*|  movsd  xmm0, qword [PTR] */
-      dasm_put(Dst, 1692);
-# 584 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    default:
-      /* Inline one byte of varint decoding. */
-      /*|  movzx  edx, byte [PTR] */
-      /*|  test   dl, dl */
-      /*|  js     <2   // Fallback to slow path for >1 byte varint. */
-      dasm_put(Dst, 1698);
-# 590 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    }
-
-    /* Second-stage decode; used for both fast and slow paths */
-    /* (only needed for a few types). */
-    /*|4: */
-    dasm_put(Dst, 1708);
-# 596 "upb/pb/compile_decoder_x64.dasc"
-    switch (op) {
-    case OP_PARSE_SINT32:
-      /* 32-bit zig-zag decode. */
-      /*|  mov    eax, edx */
-      /*|  shr    edx, 1 */
-      /*|  and    eax, 1 */
-      /*|  neg    eax */
-      /*|  xor    edx, eax */
-      dasm_put(Dst, 1711);
-# 604 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case OP_PARSE_SINT64:
-      /* 64-bit zig-zag decode. */
-      /*|  mov    rax, rdx */
-      /*|  shr    rdx, 1 */
-      /*|  and    rax, 1 */
-      /*|  neg    rax */
-      /*|  xor    rdx, rax */
-      dasm_put(Dst, 1725);
-# 612 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case OP_PARSE_BOOL:
-      /*|  test   rdx, rdx */
-      /*|  setne  dl */
-      dasm_put(Dst, 1744);
-# 616 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    default: break;
-    }
-
-    /* Call callback (or specialize if we can). */
-    if (upb_msg_getscalarhandlerdata(h, sel, &ftype, &offset, &hasbit)) {
-      switch (ftype) {
-        case UPB_TYPE_INT64:
-        case UPB_TYPE_UINT64:
-          /*|  mov   [CLOSURE + offset], rdx */
-          dasm_put(Dst, 1751, offset);
-# 626 "upb/pb/compile_decoder_x64.dasc"
-          break;
-        case UPB_TYPE_INT32:
-        case UPB_TYPE_UINT32:
-        case UPB_TYPE_ENUM:
-          /*|  mov   [CLOSURE + offset], edx */
-          dasm_put(Dst, 1756, offset);
-# 631 "upb/pb/compile_decoder_x64.dasc"
-          break;
-        case UPB_TYPE_DOUBLE:
-          /*|  movsd  qword [CLOSURE + offset], XMMARG1 */
-          dasm_put(Dst, 1761, offset);
-# 634 "upb/pb/compile_decoder_x64.dasc"
-          break;
-        case UPB_TYPE_FLOAT:
-          /*|  movss  dword [CLOSURE + offset], XMMARG1 */
-          dasm_put(Dst, 1769, offset);
-# 637 "upb/pb/compile_decoder_x64.dasc"
-          break;
-        case UPB_TYPE_BOOL:
-          /*|  mov   [CLOSURE + offset], dl */
-          dasm_put(Dst, 1777, offset);
-# 640 "upb/pb/compile_decoder_x64.dasc"
-          break;
-        case UPB_TYPE_STRING:
-        case UPB_TYPE_BYTES:
-        case UPB_TYPE_MESSAGE:
-          UPB_ASSERT(false); break;
-      }
-      /*|  sethas CLOSURE, hasbit */
-       if (hasbit >= 0) {
-      dasm_put(Dst, 1782, ((uint32_t)hasbit / 8), (1 << ((uint32_t)hasbit % 8)));
-       }
-# 647 "upb/pb/compile_decoder_x64.dasc"
-    } else if (handler) {
-      /*|  mov    ARG1_64, CLOSURE */
-      /*|  load_handler_data h, sel */
-      dasm_put(Dst, 1788);
-       {
-       uintptr_t v = (uintptr_t)upb_handlers_gethandlerdata(h, sel);
-       if (v > 0xffffffff) {
-      dasm_put(Dst, 446, (unsigned int)(v), (unsigned int)((v)>>32));
-       } else if (v) {
-      dasm_put(Dst, 451, v);
-       } else {
-      dasm_put(Dst, 454);
-       }
-       }
-# 650 "upb/pb/compile_decoder_x64.dasc"
-      /*|  callp  handler */
-      dasm_put(Dst, 1793, (unsigned int)((uintptr_t)handler), (unsigned int)(((uintptr_t)handler)>>32), 0xfffffffffffffff0UL);
-# 651 "upb/pb/compile_decoder_x64.dasc"
-      if (!alwaysok(h, sel)) {
-        /*|  test   al, al */
-        /*|  jnz    >5 */
-        /*|  call   ->suspend */
-        /*|  jmp    <1 */
-        /*|5: */
-        dasm_put(Dst, 1815);
-# 657 "upb/pb/compile_decoder_x64.dasc"
-      }
-    }
-
-    /* We do this last so that the checkpoint is not advanced past the user's
-     * data until the callback has returned success. */
-    /*|  add    PTR, fastbytes */
-    dasm_put(Dst, 1831, fastbytes);
-# 663 "upb/pb/compile_decoder_x64.dasc"
-  } else {
-    /* No handler registered for this value, just skip it. */
-    /*|  chkneob  fastbytes, >3 */
-     if (fastbytes == 1) {
-    dasm_put(Dst, 1628);
-     } else {
-    dasm_put(Dst, 1636, fastbytes);
-     }
-# 666 "upb/pb/compile_decoder_x64.dasc"
-    /*|2: */
-    dasm_put(Dst, 1652);
-# 667 "upb/pb/compile_decoder_x64.dasc"
-    switch (vtype) {
-    case V32:
-      /*|  call   ->skipv32_fallback */
-      dasm_put(Dst, 1836);
-# 670 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case V64:
-      /*|  call   ->skipv64_fallback */
-      dasm_put(Dst, 1840);
-# 673 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case F32:
-      /*|  call   ->skipf32_fallback */
-      dasm_put(Dst, 1844);
-# 676 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case F64:
-      /*|  call   ->skipf64_fallback */
-      dasm_put(Dst, 1848);
-# 679 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case X: break;
-    }
-
-    /* Fast-path skip. */
-    /*|3: */
-    dasm_put(Dst, 1676);
-# 685 "upb/pb/compile_decoder_x64.dasc"
-    if (vtype == V32 || vtype == V64) {
-      /*|  test   byte [PTR], 0x80 */
-      /*|  jnz    <2 */
-      dasm_put(Dst, 1852);
-# 688 "upb/pb/compile_decoder_x64.dasc"
-    }
-    /*|  add    PTR, fastbytes */
-    dasm_put(Dst, 1831, fastbytes);
-# 690 "upb/pb/compile_decoder_x64.dasc"
-  }
-}
-
-static void jitdispatch(jitcompiler *jc,
-                        const upb_pbdecodermethod *method) {
-  /* Lots of room for tweaking/optimization here. */
-
-  const upb_inttable *dispatch = &method->dispatch;
-  bool has_hash_entries = (dispatch->t.count > 0);
-
-  /* Whether any of the fields for this message can have two wire types which
-   * are both valid (packed & non-packed).
-   *
-   * OPT: populate this more precisely; not all messages with hash entries have
-   * this characteristic. */
-  bool has_multi_wiretype = has_hash_entries;
-
-  /*|=>define_jmptarget(jc, &method->dispatch): */
-  /*|1: */
-  dasm_put(Dst, 1861, define_jmptarget(jc, &method->dispatch));
-# 709 "upb/pb/compile_decoder_x64.dasc"
-  /* Decode the field tag. */
-  /*|  mov     aword DECODER->checkpoint, PTR */
-  /*|  chkeob  2, >6 */
-  dasm_put(Dst, 308, Dt2(->checkpoint));
-   if (2 == 1) {
-  dasm_put(Dst, 1865);
-   } else {
-  dasm_put(Dst, 1873);
-   }
-# 712 "upb/pb/compile_decoder_x64.dasc"
-  /*|  movzx   edx, byte [PTR] */
-  /*|  test    dl, dl */
-  /*|  jns     >7    // Jump if first byte has no continuation bit. */
-  /*|  movzx   ecx, byte [PTR + 1] */
-  /*|  test    cl, cl */
-  /*|  js      >6    // Jump if second byte has continuation bit. */
-  /*|  // Confirmed two-byte varint. */
-  /*|  shl     ecx, 7 */
-  /*|  and     edx, 0x7f */
-  /*|  or      edx, ecx */
-  /*|  add     PTR, 2 */
-  /*|  jmp     >8 */
-  /*|6: */
-  /*|  call    ->decode_unknown_tag_fallback */
-  /*|  test    eax, eax  // Hit DELIMEND? */
-  /*|  jnz     >8 */
-  /*|  ret */
-  /*|7: */
-  /*|  add     PTR, 1 */
-  /*|8: */
-  /*|  mov     ecx, edx */
-  /*|  shr     edx, 3 */
-  /*|  and     cl, 7 */
-  dasm_put(Dst, 1889, 1);
-# 735 "upb/pb/compile_decoder_x64.dasc"
-
-  /* See comment attached to upb_pbdecodermethod.dispatch for layout of the
-   * dispatch table. */
-  /*|2: */
-  /*|  cmp     edx, dispatch->array_size */
-  dasm_put(Dst, 1954, dispatch->array_size);
-# 740 "upb/pb/compile_decoder_x64.dasc"
-  if (has_hash_entries) {
-    /*|  jae     >7 */
-    dasm_put(Dst, 1961);
-# 742 "upb/pb/compile_decoder_x64.dasc"
-  } else {
-    /*|  jae     >5 */
-    dasm_put(Dst, 1966);
-# 744 "upb/pb/compile_decoder_x64.dasc"
-  }
-  /*|  // OPT: Compact the lookup arr into 32-bit entries. */
-  if ((uintptr_t)dispatch->array > 0x7fffffff) {
-    /*|  mov64 rax, (uintptr_t)dispatch->array */
-    /*|  mov   rax, qword [rax + rdx * 8] */
-    dasm_put(Dst, 1971, (unsigned int)((uintptr_t)dispatch->array), (unsigned int)(((uintptr_t)dispatch->array)>>32));
-# 749 "upb/pb/compile_decoder_x64.dasc"
-  } else {
-    /*|  mov   rax, qword [rdx * 8 + dispatch->array] */
-    dasm_put(Dst, 1980, dispatch->array);
-# 751 "upb/pb/compile_decoder_x64.dasc"
-  }
-  /*|3: */
-  /*|  // We take advantage of the fact that non-present entries are stored */
-  /*|  // as -1, which will result in wire types that will never match. */
-  /*|  cmp  al, cl */
-  dasm_put(Dst, 1986);
-# 756 "upb/pb/compile_decoder_x64.dasc"
-  if (has_multi_wiretype) {
-    /*|  jne  >6 */
-    dasm_put(Dst, 1991);
-# 758 "upb/pb/compile_decoder_x64.dasc"
-  } else {
-    /*|  jne  >5 */
-    dasm_put(Dst, 1996);
-# 760 "upb/pb/compile_decoder_x64.dasc"
-  }
-  /*|  shr  rax, 16 */
-  /*| */
-  /*|  // Load the machine code address from the table entry. */
-  /*|  // The table entry is relative to the dispatch->array jmptarget */
-  /*|  // (patchdispatch() took care of this) which is the same as */
-  /*|  // local label "4".  The "lea" is really just trying to do */
-  /*|  //    lea  rax, [>4 + rax] */
-  /*|  // */
-  /*|  // But we can't write that directly for some reason, so we use */
-  /*|  // rdx as a temporary. */
-  /*|  lea  rdx, [>4] */
-  /*|=>define_jmptarget(jc, dispatch->array): */
-  /*|4: */
-  /*|  add  rax, rdx */
-  /*|  ret */
-  /*| */
-  /*|5: */
-  /*|  // Field isn't in our table. */
-  /*| */
-  /*|  // For pushing unknown fields to the unknown field handler. */
-  /*|  mov64 rax, (uintptr_t)method->dest_handlers_ */
-  /*|  mov FRAME->sink.handlers, rax */
-  /*| */
-  /*|  call ->parse_unknown */
-  /*|  test eax, eax  // ENDGROUP? */
-  /*|  jz   <1 */
-  /*|  lea  rax, [>9]  // ENDGROUP; Load address of OP_ENDMSG. */
-  /*|  ret */
-  dasm_put(Dst, 2001, define_jmptarget(jc, dispatch->array), (unsigned int)((uintptr_t)method->dest_handlers_), (unsigned int)(((uintptr_t)method->dest_handlers_)>>32), Dt1(->sink.handlers));
-# 789 "upb/pb/compile_decoder_x64.dasc"
-
-  if (has_multi_wiretype) {
-    /*|6: */
-    /*|  // Primary wire type didn't match, check secondary wire type. */
-    /*|  cmp  ah, cl */
-    /*|  jne  <5 */
-    /*|  // Secondary wire type is a match, look up fn + UPB_MAX_FIELDNUMBER. */
-    /*|  add   rdx, UPB_MAX_FIELDNUMBER */
-    /*|  // This key will never be in the array part, so do a hash lookup. */
-    dasm_put(Dst, 2043, UPB_MAX_FIELDNUMBER);
-# 798 "upb/pb/compile_decoder_x64.dasc"
-    UPB_ASSERT(has_hash_entries);
-    /*|  ld64  dispatch */
-     {
-     uintptr_t v = (uintptr_t)dispatch;
-     if (v > 0xffffffff) {
-    dasm_put(Dst, 446, (unsigned int)(v), (unsigned int)((v)>>32));
-     } else if (v) {
-    dasm_put(Dst, 451, v);
-     } else {
-    dasm_put(Dst, 454);
-     }
-     }
-# 800 "upb/pb/compile_decoder_x64.dasc"
-    /*|  jmp   ->hashlookup  // Tail call. */
-    dasm_put(Dst, 2056);
-# 801 "upb/pb/compile_decoder_x64.dasc"
-  }
-
-  if (has_hash_entries) {
-    /*|7: */
-    /*|  // Hash table lookup. */
-    /*|  ld64   dispatch */
-    dasm_put(Dst, 2061);
-     {
-     uintptr_t v = (uintptr_t)dispatch;
-     if (v > 0xffffffff) {
-    dasm_put(Dst, 446, (unsigned int)(v), (unsigned int)((v)>>32));
-     } else if (v) {
-    dasm_put(Dst, 451, v);
-     } else {
-    dasm_put(Dst, 454);
-     }
-     }
-# 807 "upb/pb/compile_decoder_x64.dasc"
-    /*|  call   ->hashlookup */
-    /*|  jmp    <3 */
-    dasm_put(Dst, 2064);
-# 809 "upb/pb/compile_decoder_x64.dasc"
-  }
-}
-
-static void jittag(jitcompiler *jc, uint64_t tag, int n, int ofs,
-                   const upb_pbdecodermethod *method) {
-  /* Internally we parse unknown fields; if this runs us into DELIMEND we jump
-   * to the corresponding DELIMEND target (either msg end or repeated field
-   * end), which we find from the OP_CHECKDELIM which must have necessarily
-   * preceded us. */
-  uint32_t last_instruction = *(jc->pc - 2);
-  int last_arg = (int32_t)last_instruction >> 8;
-  uint32_t *delimend = (jc->pc - 1) + last_arg;
-  const size_t ptr_words = sizeof(void*) / sizeof(uint32_t);
-
-  UPB_ASSERT((last_instruction & 0xff) == OP_CHECKDELIM);
-
-  if (getop(*(jc->pc - 1)) == OP_TAGN) {
-    jc->pc += ptr_words;
-  }
-
-  /*|  chkneob n, >1 */
-   if (n == 1) {
-  dasm_put(Dst, 2072);
-   } else {
-  dasm_put(Dst, 2080, n);
-   }
-# 830 "upb/pb/compile_decoder_x64.dasc"
-
-  /*|  // OPT: this is way too much fallback code to put here. */
-  /*|  // Reduce and/or move to a separate section to make better icache usage. */
-  /*|  ld64  tag */
-   {
-   uintptr_t v = (uintptr_t)tag;
-   if (v > 0xffffffff) {
-  dasm_put(Dst, 446, (unsigned int)(v), (unsigned int)((v)>>32));
-   } else if (v) {
-  dasm_put(Dst, 451, v);
-   } else {
-  dasm_put(Dst, 454);
-   }
-   }
-# 834 "upb/pb/compile_decoder_x64.dasc"
-  /*|  call  ->checktag_fallback */
-  /*|  cmp   eax, DECODE_MISMATCH */
-  /*|  je    >3 */
-  /*|  cmp   eax, DECODE_EOF */
-  /*|  je     =>jmptarget(jc, delimend) */
-  /*|  jmp   >5 */
-  dasm_put(Dst, 2096, DECODE_MISMATCH, DECODE_EOF, jmptarget(jc, delimend));
-# 840 "upb/pb/compile_decoder_x64.dasc"
-
-  /*|1: */
-  dasm_put(Dst, 112);
-# 842 "upb/pb/compile_decoder_x64.dasc"
-  switch (n) {
-  case 1:
-    /*|  cmp  byte [PTR], tag */
-    dasm_put(Dst, 2119, tag);
-# 845 "upb/pb/compile_decoder_x64.dasc"
-    break;
-  case 2:
-    /*|  cmp  word [PTR], tag */
-    dasm_put(Dst, 2123, tag);
-# 848 "upb/pb/compile_decoder_x64.dasc"
-    break;
-  case 3:
-    /*|   // OPT: Slightly more efficient code, but depends on an extra byte. */
-    /*|   // mov  eax, dword [PTR] */
-    /*|   // shl  eax, 8 */
-    /*|   // cmp  eax, tag << 8 */
-    /*|   cmp  word [PTR], (tag & 0xffff) */
-    /*|   jne  >2 */
-    /*|   cmp  byte [PTR + 2], (tag >> 16) */
-    /*|2: */
-    dasm_put(Dst, 2128, (tag & 0xffff), 2, (tag >> 16));
-# 858 "upb/pb/compile_decoder_x64.dasc"
-    break;
-  case 4:
-    /*|   cmp  dword [PTR], tag */
-    dasm_put(Dst, 2143, tag);
-# 861 "upb/pb/compile_decoder_x64.dasc"
-    break;
-  case 5:
-    /*|   cmp  dword [PTR], (tag & 0xffffffff) */
-    /*|   jne  >3 */
-    /*|   cmp  byte  [PTR + 4], (tag >> 32) */
-    dasm_put(Dst, 2147, (tag & 0xffffffff), 4, (tag >> 32));
-# 866 "upb/pb/compile_decoder_x64.dasc"
-  }
-  /*|  je    >4 */
-  /*|3: */
-  dasm_put(Dst, 2159);
-# 869 "upb/pb/compile_decoder_x64.dasc"
-  if (ofs == 0) {
-    /*|  call   =>jmptarget(jc, &method->dispatch) */
-    /*|  test   rax, rax */
-    /*|  jz     =>jmptarget(jc, delimend) */
-    /*|  jmp    rax */
-    dasm_put(Dst, 2166, jmptarget(jc, &method->dispatch), jmptarget(jc, delimend));
-# 874 "upb/pb/compile_decoder_x64.dasc"
-  } else {
-    /*|  jmp    =>jmptarget(jc, jc->pc + ofs) */
-    dasm_put(Dst, 2178, jmptarget(jc, jc->pc + ofs));
-# 876 "upb/pb/compile_decoder_x64.dasc"
-  }
-  /*|4: */
-  /*|  add    PTR, n */
-  /*|5: */
-  dasm_put(Dst, 2182, n);
-# 880 "upb/pb/compile_decoder_x64.dasc"
-}
-
-/* Compile the bytecode to x64. */
-static void jitbytecode(jitcompiler *jc) {
-  upb_pbdecodermethod *method = NULL;
-  const upb_handlers *h = NULL;
-  for (jc->pc = jc->group->bytecode; jc->pc < jc->group->bytecode_end; ) {
-    int32_t instr = *jc->pc;
-    opcode op = instr & 0xff;
-    uint32_t arg = instr >> 8;
-    int32_t longofs = arg;
-
-    if (op != OP_SETDISPATCH) {
-      /* Skipped for SETDISPATCH because it defines its own asmlabel for the
-       * dispatch code it emits. */
-      asmlabel(jc, "0x%lx.%s", pcofs(jc), upb_pbdecoder_getopname(op));
-
-      /* Skipped for SETDISPATCH because it should point at the function
-       * prologue, not the dispatch function that is emitted first.
-       * TODO: optimize this to only define pclabels that are actually used. */
-      /*|=>define_jmptarget(jc, jc->pc): */
-      dasm_put(Dst, 0, define_jmptarget(jc, jc->pc));
-# 901 "upb/pb/compile_decoder_x64.dasc"
-    }
-
-    jc->pc++;
-
-    switch (op) {
-    case OP_STARTMSG: {
-      upb_func *startmsg = gethandler(h, UPB_STARTMSG_SELECTOR);
-      if (startmsg) {
-        /* bool startmsg(void *closure, const void *hd) */
-        /*|1: */
-        /*|  mov   ARG1_64, CLOSURE */
-        /*|  load_handler_data h, UPB_STARTMSG_SELECTOR */
-        dasm_put(Dst, 2191);
-         {
-         uintptr_t v = (uintptr_t)upb_handlers_gethandlerdata(h, UPB_STARTMSG_SELECTOR);
-         if (v > 0xffffffff) {
-        dasm_put(Dst, 446, (unsigned int)(v), (unsigned int)((v)>>32));
-         } else if (v) {
-        dasm_put(Dst, 451, v);
-         } else {
-        dasm_put(Dst, 454);
-         }
-         }
-# 913 "upb/pb/compile_decoder_x64.dasc"
-        /*|  callp startmsg */
-        dasm_put(Dst, 1793, (unsigned int)((uintptr_t)startmsg), (unsigned int)(((uintptr_t)startmsg)>>32), 0xfffffffffffffff0UL);
-# 914 "upb/pb/compile_decoder_x64.dasc"
-        if (!alwaysok(h, UPB_STARTMSG_SELECTOR)) {
-          /*|  test  al, al */
-          /*|  jnz   >2 */
-          /*|  call  ->suspend */
-          /*|  jmp   <1 */
-          /*|2: */
-          dasm_put(Dst, 2198);
-# 920 "upb/pb/compile_decoder_x64.dasc"
-        }
-      } else {
-        /*| nop */
-        dasm_put(Dst, 2214);
-# 923 "upb/pb/compile_decoder_x64.dasc"
-      }
-      break;
-    }
-    case OP_ENDMSG: {
-      upb_func *endmsg = gethandler(h, UPB_ENDMSG_SELECTOR);
-      /*|9: */
-      dasm_put(Dst, 2216);
-# 929 "upb/pb/compile_decoder_x64.dasc"
-      if (endmsg) {
-        /* bool endmsg(void *closure, const void *hd, upb_status *status) */
-        /*|  mov   ARG1_64, CLOSURE */
-        /*|  load_handler_data h, UPB_ENDMSG_SELECTOR */
-        dasm_put(Dst, 1788);
-         {
-         uintptr_t v = (uintptr_t)upb_handlers_gethandlerdata(h, UPB_ENDMSG_SELECTOR);
-         if (v > 0xffffffff) {
-        dasm_put(Dst, 446, (unsigned int)(v), (unsigned int)((v)>>32));
-         } else if (v) {
-        dasm_put(Dst, 451, v);
-         } else {
-        dasm_put(Dst, 454);
-         }
-         }
-# 933 "upb/pb/compile_decoder_x64.dasc"
-        /*|  mov   ARG3_64, DECODER->status */
-        /*|  callp endmsg */
-        dasm_put(Dst, 2219, Dt2(->status), (unsigned int)((uintptr_t)endmsg), (unsigned int)(((uintptr_t)endmsg)>>32), 0xfffffffffffffff0UL);
-# 935 "upb/pb/compile_decoder_x64.dasc"
-      }
-      break;
-    }
-    case OP_SETDISPATCH: {
-      uint32_t *op_pc = jc->pc - 1;
-      const char *msgname;
-      upb_inttable *dispatch;
-
-      /* Load info for new method. */
-      memcpy(&dispatch, jc->pc, sizeof(void*));
-      jc->pc += sizeof(void*) / sizeof(uint32_t);
-      /* The OP_SETDISPATCH bytecode contains a pointer that is
-       * &method->dispatch; we want to go backwards and recover method. */
-      method =
-          (void*)((char*)dispatch - offsetof(upb_pbdecodermethod, dispatch));
-      /* May be NULL, in which case no handlers for this message will be found.
-       * OPT: we should do better by completely skipping the message in this
-       * case instead of parsing it field by field.  We should also do the skip
-       * in the containing message's code. */
-      h = method->dest_handlers_;
-      msgname = upb_msgdef_fullname(upb_handlers_msgdef(h));
-
-      /* Emit dispatch code for new method. */
-      asmlabel(jc, "0x%lx.dispatch.%s", pcofs(jc), msgname);
-      jitdispatch(jc, method);
-
-      /* Emit function prologue for new method. */
-      asmlabel(jc, "0x%lx.parse.%s", pcofs(jc), msgname);
-      /*|=>define_jmptarget(jc, op_pc): */
-      /*|=>define_jmptarget(jc, method): */
-      /*|  sub   rsp, 8 */
-      dasm_put(Dst, 2245, define_jmptarget(jc, op_pc), define_jmptarget(jc, method));
-# 966 "upb/pb/compile_decoder_x64.dasc"
-
-      break;
-    }
-    case OP_PARSE_DOUBLE:
-    case OP_PARSE_FLOAT:
-    case OP_PARSE_INT64:
-    case OP_PARSE_UINT64:
-    case OP_PARSE_INT32:
-    case OP_PARSE_FIXED64:
-    case OP_PARSE_FIXED32:
-    case OP_PARSE_BOOL:
-    case OP_PARSE_UINT32:
-    case OP_PARSE_SFIXED32:
-    case OP_PARSE_SFIXED64:
-    case OP_PARSE_SINT32:
-    case OP_PARSE_SINT64:
-      jitprimitive(jc, op, h, arg);
-      break;
-    case OP_STARTSEQ:
-    case OP_STARTSUBMSG:
-    case OP_STARTSTR: {
-      upb_func *start = gethandler(h, arg);
-      if (start) {
-        /* void *startseq(void *closure, const void *hd)
-         * void *startsubmsg(void *closure, const void *hd)
-         * void *startstr(void *closure, const void *hd, size_t size_hint) */
-        /*|1: */
-        /*|  mov   ARG1_64, CLOSURE */
-        /*|  load_handler_data h, arg */
-        dasm_put(Dst, 2191);
-         {
-         uintptr_t v = (uintptr_t)upb_handlers_gethandlerdata(h, arg);
-         if (v > 0xffffffff) {
-        dasm_put(Dst, 446, (unsigned int)(v), (unsigned int)((v)>>32));
-         } else if (v) {
-        dasm_put(Dst, 451, v);
-         } else {
-        dasm_put(Dst, 454);
-         }
-         }
-# 995 "upb/pb/compile_decoder_x64.dasc"
-        if (op == OP_STARTSTR) {
-          /*|  mov    ARG3_64, DELIMEND */
-          /*|  sub    ARG3_64, PTR */
-          dasm_put(Dst, 2253);
-# 998 "upb/pb/compile_decoder_x64.dasc"
-        }
-        /*|  callp start */
-        dasm_put(Dst, 1793, (unsigned int)((uintptr_t)start), (unsigned int)(((uintptr_t)start)>>32), 0xfffffffffffffff0UL);
-# 1000 "upb/pb/compile_decoder_x64.dasc"
-        if (!alwaysok(h, arg)) {
-          /*|  test  rax, rax */
-          /*|  jnz   >2 */
-          /*|  call  ->suspend */
-          /*|  jmp   <1 */
-          /*|2: */
-          dasm_put(Dst, 2261);
-# 1006 "upb/pb/compile_decoder_x64.dasc"
-        }
-        /*|  mov   CLOSURE, rax */
-        dasm_put(Dst, 2278);
-# 1008 "upb/pb/compile_decoder_x64.dasc"
-      } else {
-        /* TODO: nop is only required because of asmlabel(). */
-        /*|  nop */
-        dasm_put(Dst, 2214);
-# 1011 "upb/pb/compile_decoder_x64.dasc"
-      }
-      break;
-    }
-    case OP_ENDSEQ:
-    case OP_ENDSUBMSG:
-    case OP_ENDSTR: {
-      upb_func *end = gethandler(h, arg);
-      if (end) {
-        /* bool endseq(void *closure, const void *hd)
-         * bool endsubmsg(void *closure, const void *hd)
-         * bool endstr(void *closure, const void *hd) */
-        /*|1: */
-        /*|  mov   ARG1_64, CLOSURE */
-        /*|  load_handler_data h, arg */
-        dasm_put(Dst, 2191);
-         {
-         uintptr_t v = (uintptr_t)upb_handlers_gethandlerdata(h, arg);
-         if (v > 0xffffffff) {
-        dasm_put(Dst, 446, (unsigned int)(v), (unsigned int)((v)>>32));
-         } else if (v) {
-        dasm_put(Dst, 451, v);
-         } else {
-        dasm_put(Dst, 454);
-         }
-         }
-# 1025 "upb/pb/compile_decoder_x64.dasc"
-        /*|  callp end */
-        dasm_put(Dst, 1793, (unsigned int)((uintptr_t)end), (unsigned int)(((uintptr_t)end)>>32), 0xfffffffffffffff0UL);
-# 1026 "upb/pb/compile_decoder_x64.dasc"
-        if (!alwaysok(h, arg)) {
-          /*|  test  al, al */
-          /*|  jnz   >2 */
-          /*|  call  ->suspend */
-          /*|  jmp   <1 */
-          /*|2: */
-          dasm_put(Dst, 2198);
-# 1032 "upb/pb/compile_decoder_x64.dasc"
-        }
-      } else {
-        /* TODO: nop is only required because of asmlabel(). */
-        /*|  nop */
-        dasm_put(Dst, 2214);
-# 1036 "upb/pb/compile_decoder_x64.dasc"
-      }
-      break;
-    }
-    case OP_STRING: {
-      upb_func *str = gethandler(h, arg);
-      /*|  cmp   PTR, DELIMEND */
-      /*|  je    >4 */
-      /*|1: */
-      /*|  cmp   PTR, DATAEND */
-      /*|  jne   >2 */
-      /*|  call  ->suspend */
-      /*|  jmp   <1 */
-      /*|2: */
-      dasm_put(Dst, 2282);
-# 1049 "upb/pb/compile_decoder_x64.dasc"
-      if (str) {
-        /* size_t str(void *closure, const void *hd, const char *str,
-         *            size_t n) */
-        /*|  mov   ARG1_64, CLOSURE */
-        /*|  load_handler_data h, arg */
-        dasm_put(Dst, 1788);
-         {
-         uintptr_t v = (uintptr_t)upb_handlers_gethandlerdata(h, arg);
-         if (v > 0xffffffff) {
-        dasm_put(Dst, 446, (unsigned int)(v), (unsigned int)((v)>>32));
-         } else if (v) {
-        dasm_put(Dst, 451, v);
-         } else {
-        dasm_put(Dst, 454);
-         }
-         }
-# 1054 "upb/pb/compile_decoder_x64.dasc"
-        /*|  mov   ARG3_64, PTR */
-        /*|  mov   ARG4_64, DATAEND */
-        /*|  sub   ARG4_64, PTR */
-        /*|  mov   ARG5_64, qword DECODER->handle */
-        /*|  callp str */
-        /*|  add   PTR, rax */
-        dasm_put(Dst, 2309, Dt2(->handle), (unsigned int)((uintptr_t)str), (unsigned int)(((uintptr_t)str)>>32), 0xfffffffffffffff0UL);
-# 1060 "upb/pb/compile_decoder_x64.dasc"
-        if (!alwaysok(h, arg)) {
-          /*|  cmp   PTR, DATAEND */
-          /*|  je    >3 */
-          /*|  call  ->strret_fallback */
-          /*|3: */
-          dasm_put(Dst, 2347);
-# 1065 "upb/pb/compile_decoder_x64.dasc"
-        }
-      } else {
-        /*|  mov   PTR, DATAEND */
-        dasm_put(Dst, 2360);
-# 1068 "upb/pb/compile_decoder_x64.dasc"
-      }
-      /*|  cmp   PTR, DELIMEND */
-      /*|  jne   <1 */
-      /*|4: */
-      dasm_put(Dst, 2364);
-# 1072 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    }
-    case OP_PUSHTAGDELIM:
-      /*|  mov   FRAME->sink.closure, CLOSURE */
-      /*|  // This shouldn't need to be read, because tag-delimited fields */
-      /*|  // shouldn't have an OP_SETDELIM after them.  But for the moment */
-      /*|  // non-packed repeated fields do OP_SETDELIM so they can share more */
-      /*|  // code with the packed code-path.  If this is changed later, this */
-      /*|  // store can be removed. */
-      /*|  mov   qword FRAME->end_ofs, 0 */
-      /*|  cmp   FRAME, DECODER->limit */
-      /*|  je    ->err */
-      /*|  add   FRAME, sizeof(upb_pbdecoder_frame) */
-      /*|  mov   dword FRAME->groupnum, arg */
-      dasm_put(Dst, 2375, Dt1(->sink.closure), Dt1(->end_ofs), Dt2(->limit), sizeof(upb_pbdecoder_frame), Dt1(->groupnum), arg);
-# 1086 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case OP_PUSHLENDELIM:
-      /*|  call  ->pushlendelim */
-      dasm_put(Dst, 2405);
-# 1089 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case OP_POP:
-      /*|  sub   FRAME, sizeof(upb_pbdecoder_frame) */
-      /*|  mov   CLOSURE, FRAME->sink.closure */
-      dasm_put(Dst, 2409, sizeof(upb_pbdecoder_frame), Dt1(->sink.closure));
-# 1093 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case OP_SETDELIM:
-      /* OPT: experiment with testing vs old offset to optimize away. */
-      /*|  mov   DATAEND, DECODER->end */
-      /*|  add   DELIMEND, FRAME->end_ofs */
-      /*|  cmp   DELIMEND, DECODER->buf */
-      /*|  jb    >1 */
-      /*|  cmp   DELIMEND, DATAEND */
-      /*|  ja    >1   // OPT: try cmov. */
-      /*|  mov   DATAEND, DELIMEND */
-      /*|1: */
-      dasm_put(Dst, 2419, Dt2(->end), Dt1(->end_ofs), Dt2(->buf));
-# 1104 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case OP_SETBIGGROUPNUM:
-      /*|  mov   dword FRAME->groupnum, *jc->pc++ */
-      dasm_put(Dst, 2399, Dt1(->groupnum), *jc->pc++);
-# 1107 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case OP_CHECKDELIM:
-      /*|  cmp  DELIMEND, PTR */
-      /*|  je   =>jmptarget(jc, jc->pc + longofs) */
-      dasm_put(Dst, 2449, jmptarget(jc, jc->pc + longofs));
-# 1111 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case OP_CALL:
-      /*|  call =>jmptarget(jc, jc->pc + longofs) */
-      dasm_put(Dst, 2456, jmptarget(jc, jc->pc + longofs));
-# 1114 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case OP_BRANCH:
-      /*|  jmp  =>jmptarget(jc, jc->pc + longofs); */
-      dasm_put(Dst, 2178, jmptarget(jc, jc->pc + longofs));
-# 1117 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case OP_RET:
-      /*|9: */
-      /*|  add  rsp, 8 */
-      /*|  ret */
-      dasm_put(Dst, 2459);
-# 1122 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case OP_TAG1:
-      jittag(jc, (arg >> 8) & 0xff, 1, (int8_t)arg, method);
-      break;
-    case OP_TAG2:
-      jittag(jc, (arg >> 8) & 0xffff, 2, (int8_t)arg, method);
-      break;
-    case OP_TAGN: {
-      uint64_t tag;
-      memcpy(&tag, jc->pc, 8);
-      jittag(jc, tag, arg >> 8, (int8_t)arg, method);
-      break;
-    }
-    case OP_DISPATCH:
-      /*|  call   =>jmptarget(jc, &method->dispatch) */
-      dasm_put(Dst, 2456, jmptarget(jc, &method->dispatch));
-# 1137 "upb/pb/compile_decoder_x64.dasc"
-      break;
-    case OP_HALT:
-      UPB_ASSERT(false);
-    }
-  }
-
-  asmlabel(jc, "eof");
-  /*|  nop */
-  dasm_put(Dst, 2214);
-# 1145 "upb/pb/compile_decoder_x64.dasc"
-}
diff --git a/upb/pb/decoder.c b/upb/pb/decoder.c
index 0cae05b..2384312 100644
--- a/upb/pb/decoder.c
+++ b/upb/pb/decoder.c
@@ -99,9 +99,7 @@ static bool in_residual_buf(const upb_pbdecoder *d, const char *p);
  * benchmarks. */
 
 static void seterr(upb_pbdecoder *d, const char *msg) {
-  upb_status status = UPB_STATUS_INIT;
-  upb_status_seterrmsg(&status, msg);
-  upb_env_reporterror(d->env, &status);
+  upb_status_seterrmsg(d->status, msg);
 }
 
 void upb_pbdecoder_seterr(upb_pbdecoder *d, const char *msg) {
@@ -596,7 +594,7 @@ have_tag:
 
     if (d->top->groupnum >= 0) {
       /* TODO: More code needed for handling unknown groups. */
-      upb_sink_putunknown(&d->top->sink, d->checkpoint, d->ptr - d->checkpoint);
+      upb_sink_putunknown(d->top->sink, d->checkpoint, d->ptr - d->checkpoint);
       return DECODE_OK;
     }
 
@@ -690,7 +688,7 @@ size_t run_decoder_vm(upb_pbdecoder *d, const mgroup *group,
   VMCASE(OP_PARSE_ ## type, { \
     ctype val; \
     CHECK_RETURN(decode_ ## wt(d, &val)); \
-    upb_sink_put ## name(&d->top->sink, arg, (convfunc)(val)); \
+    upb_sink_put ## name(d->top->sink, arg, (convfunc)(val)); \
   })
 
   while(1) {
@@ -742,36 +740,36 @@ size_t run_decoder_vm(upb_pbdecoder *d, const mgroup *group,
         d->pc += sizeof(void*) / sizeof(uint32_t);
       )
       VMCASE(OP_STARTMSG,
-        CHECK_SUSPEND(upb_sink_startmsg(&d->top->sink));
+        CHECK_SUSPEND(upb_sink_startmsg(d->top->sink));
       )
       VMCASE(OP_ENDMSG,
-        CHECK_SUSPEND(upb_sink_endmsg(&d->top->sink, d->status));
+        CHECK_SUSPEND(upb_sink_endmsg(d->top->sink, d->status));
       )
       VMCASE(OP_STARTSEQ,
         upb_pbdecoder_frame *outer = outer_frame(d);
-        CHECK_SUSPEND(upb_sink_startseq(&outer->sink, arg, &d->top->sink));
+        CHECK_SUSPEND(upb_sink_startseq(outer->sink, arg, &d->top->sink));
       )
       VMCASE(OP_ENDSEQ,
-        CHECK_SUSPEND(upb_sink_endseq(&d->top->sink, arg));
+        CHECK_SUSPEND(upb_sink_endseq(d->top->sink, arg));
       )
       VMCASE(OP_STARTSUBMSG,
         upb_pbdecoder_frame *outer = outer_frame(d);
-        CHECK_SUSPEND(upb_sink_startsubmsg(&outer->sink, arg, &d->top->sink));
+        CHECK_SUSPEND(upb_sink_startsubmsg(outer->sink, arg, &d->top->sink));
       )
       VMCASE(OP_ENDSUBMSG,
-        CHECK_SUSPEND(upb_sink_endsubmsg(&d->top->sink, arg));
+        CHECK_SUSPEND(upb_sink_endsubmsg(d->top->sink, arg));
       )
       VMCASE(OP_STARTSTR,
         uint32_t len = delim_remaining(d);
         upb_pbdecoder_frame *outer = outer_frame(d);
-        CHECK_SUSPEND(upb_sink_startstr(&outer->sink, arg, len, &d->top->sink));
+        CHECK_SUSPEND(upb_sink_startstr(outer->sink, arg, len, &d->top->sink));
         if (len == 0) {
           d->pc++;  /* Skip OP_STRING. */
         }
       )
       VMCASE(OP_STRING,
         uint32_t len = curbufleft(d);
-        size_t n = upb_sink_putstring(&d->top->sink, arg, d->ptr, len, handle);
+        size_t n = upb_sink_putstring(d->top->sink, arg, d->ptr, len, handle);
         if (n > len) {
           if (n > delim_remaining(d)) {
             seterr(d, "Tried to skip past end of string.");
@@ -792,7 +790,7 @@ size_t run_decoder_vm(upb_pbdecoder *d, const mgroup *group,
         }
       )
       VMCASE(OP_ENDSTR,
-        CHECK_SUSPEND(upb_sink_endstr(&d->top->sink, arg));
+        CHECK_SUSPEND(upb_sink_endstr(d->top->sink, arg));
       )
       VMCASE(OP_PUSHTAGDELIM,
         CHECK_SUSPEND(pushtagdelim(d, arg));
@@ -992,40 +990,39 @@ void upb_pbdecoder_reset(upb_pbdecoder *d) {
   d->residual_end = d->residual;
 }
 
-upb_pbdecoder *upb_pbdecoder_create(upb_env *e, const upb_pbdecodermethod *m,
-                                    upb_sink *sink) {
+upb_pbdecoder *upb_pbdecoder_create(upb_arena *a, const upb_pbdecodermethod *m,
+                                    upb_sink sink, upb_status *status) {
   const size_t default_max_nesting = 64;
 #ifndef NDEBUG
-  size_t size_before = upb_env_bytesallocated(e);
+  size_t size_before = upb_arena_bytesallocated(a);
 #endif
 
-  upb_pbdecoder *d = upb_env_malloc(e, sizeof(upb_pbdecoder));
+  upb_pbdecoder *d = upb_arena_malloc(a, sizeof(upb_pbdecoder));
   if (!d) return NULL;
 
   d->method_ = m;
-  d->callstack = upb_env_malloc(e, callstacksize(d, default_max_nesting));
-  d->stack = upb_env_malloc(e, stacksize(d, default_max_nesting));
+  d->callstack = upb_arena_malloc(a, callstacksize(d, default_max_nesting));
+  d->stack = upb_arena_malloc(a, stacksize(d, default_max_nesting));
   if (!d->stack || !d->callstack) {
     return NULL;
   }
 
-  d->env = e;
+  d->arena = a;
   d->limit = d->stack + default_max_nesting - 1;
   d->stack_size = default_max_nesting;
-  d->status = NULL;
+  d->status = status;
 
   upb_pbdecoder_reset(d);
   upb_bytessink_reset(&d->input_, &m->input_handler_, d);
 
-  UPB_ASSERT(sink);
   if (d->method_->dest_handlers_) {
-    if (sink->handlers != d->method_->dest_handlers_)
+    if (sink.handlers != d->method_->dest_handlers_)
       return NULL;
   }
-  upb_sink_reset(&d->top->sink, sink->handlers, sink->closure);
+  d->top->sink = sink;
 
   /* If this fails, increase the value in decoder.h. */
-  UPB_ASSERT_DEBUGVAR(upb_env_bytesallocated(e) - size_before <=
+  UPB_ASSERT_DEBUGVAR(upb_arena_bytesallocated(a) - size_before <=
                       UPB_PB_DECODER_SIZE);
   return d;
 }
@@ -1038,8 +1035,8 @@ const upb_pbdecodermethod *upb_pbdecoder_method(const upb_pbdecoder *d) {
   return d->method_;
 }
 
-upb_bytessink *upb_pbdecoder_input(upb_pbdecoder *d) {
-  return &d->input_;
+upb_bytessink upb_pbdecoder_input(upb_pbdecoder *d) {
+  return d->input_;
 }
 
 size_t upb_pbdecoder_maxnesting(const upb_pbdecoder *d) {
@@ -1058,7 +1055,7 @@ bool upb_pbdecoder_setmaxnesting(upb_pbdecoder *d, size_t max) {
     /* Need to reallocate stack and callstack to accommodate. */
     size_t old_size = stacksize(d, d->stack_size);
     size_t new_size = stacksize(d, max);
-    void *p = upb_env_realloc(d->env, d->stack, old_size, new_size);
+    void *p = upb_arena_realloc(d->arena, d->stack, old_size, new_size);
     if (!p) {
       return false;
     }
@@ -1066,7 +1063,7 @@ bool upb_pbdecoder_setmaxnesting(upb_pbdecoder *d, size_t max) {
 
     old_size = callstacksize(d, d->stack_size);
     new_size = callstacksize(d, max);
-    p = upb_env_realloc(d->env, d->callstack, old_size, new_size);
+    p = upb_arena_realloc(d->arena, d->callstack, old_size, new_size);
     if (!p) {
       return false;
     }
diff --git a/upb/pb/decoder.h b/upb/pb/decoder.h
index 7c1877a..709db49 100644
--- a/upb/pb/decoder.h
+++ b/upb/pb/decoder.h
@@ -21,20 +21,13 @@
 namespace upb {
 namespace pb {
 class CodeCache;
-class Decoder;
-class DecoderMethod;
+class DecoderPtr;
+class DecoderMethodPtr;
 class DecoderMethodOptions;
 }  /* namespace pb */
 }  /* namespace upb */
 #endif
 
-UPB_DECLARE_TYPE(upb::pb::CodeCache, upb_pbcodecache)
-UPB_DECLARE_TYPE(upb::pb::Decoder, upb_pbdecoder)
-UPB_DECLARE_TYPE(upb::pb::DecoderMethodOptions, upb_pbdecodermethodopts)
-
-UPB_DECLARE_DERIVED_TYPE(upb::pb::DecoderMethod, upb::RefCounted,
-                         upb_pbdecodermethod, upb_refcounted)
-
 /* The maximum number of bytes we are required to buffer internally between
  * calls to the decoder.  The value is 14: a 5 byte unknown tag plus ten-byte
  * varint, less one because we are buffering an incomplete value.
@@ -42,83 +35,111 @@ UPB_DECLARE_DERIVED_TYPE(upb::pb::DecoderMethod, upb::RefCounted,
  * Should only be used by unit tests. */
 #define UPB_DECODER_MAX_RESIDUAL_BYTES 14
 
-#ifdef __cplusplus
+/* upb_pbdecodermethod ********************************************************/
 
-/* The parameters one uses to construct a DecoderMethod.
- * TODO(haberman): move allowjit here?  Seems more convenient for users.
- * TODO(haberman): move this to be heap allocated for ABI stability. */
-class upb::pb::DecoderMethodOptions {
- public:
-  /* Parameter represents the destination handlers that this method will push
-   * to. */
-  explicit DecoderMethodOptions(const Handlers* dest_handlers);
+struct upb_pbdecodermethod;
+typedef struct upb_pbdecodermethod upb_pbdecodermethod;
 
-  /* Should the decoder push submessages to lazy handlers for fields that have
-   * them?  The caller should set this iff the lazy handlers expect data that is
-   * in protobuf binary format and the caller wishes to lazy parse it. */
-  void set_lazy(bool lazy);
-#else
-struct upb_pbdecodermethodopts {
+#ifdef __cplusplus
+extern "C" {
 #endif
-  const upb_handlers *handlers;
-  bool lazy;
-};
+
+const upb_handlers *upb_pbdecodermethod_desthandlers(
+    const upb_pbdecodermethod *m);
+const upb_byteshandler *upb_pbdecodermethod_inputhandler(
+    const upb_pbdecodermethod *m);
+bool upb_pbdecodermethod_isnative(const upb_pbdecodermethod *m);
 
 #ifdef __cplusplus
+}  /* extern "C" */
 
 /* Represents the code to parse a protobuf according to a destination
  * Handlers. */
-class upb::pb::DecoderMethod {
+class upb::pb::DecoderMethodPtr {
  public:
-  /* Include base methods from upb::ReferenceCounted. */
-  UPB_REFCOUNTED_CPPMETHODS
+  DecoderMethodPtr() : ptr_(nullptr) {}
+  DecoderMethodPtr(const upb_pbdecodermethod* ptr) : ptr_(ptr) {}
+
+  const upb_pbdecodermethod* ptr() { return ptr_; }
 
   /* The destination handlers that are statically bound to this method.
    * This method is only capable of outputting to a sink that uses these
    * handlers. */
-  const Handlers* dest_handlers() const;
+  const Handlers *dest_handlers() const {
+    return upb_pbdecodermethod_desthandlers(ptr_);
+  }
 
   /* The input handlers for this decoder method. */
-  const BytesHandler* input_handler() const;
+  const BytesHandler* input_handler() const {
+    return upb_pbdecodermethod_inputhandler(ptr_);
+  }
 
   /* Whether this method is native. */
-  bool is_native() const;
-
-  /* Convenience method for generating a DecoderMethod without explicitly
-   * creating a CodeCache. */
-  static reffed_ptr<const DecoderMethod> New(const DecoderMethodOptions& opts);
+  bool is_native() const {
+    return upb_pbdecodermethod_isnative(ptr_);
+  }
 
  private:
-  UPB_DISALLOW_POD_OPS(DecoderMethod, upb::pb::DecoderMethod)
+  const upb_pbdecodermethod* ptr_;
 };
 
 #endif
 
+/* upb_pbdecoder **************************************************************/
+
 /* Preallocation hint: decoder won't allocate more bytes than this when first
  * constructed.  This hint may be an overestimate for some build configurations.
  * But if the decoder library is upgraded without recompiling the application,
  * it may be an underestimate. */
 #define UPB_PB_DECODER_SIZE 4416
 
+struct upb_pbdecoder;
+typedef struct upb_pbdecoder upb_pbdecoder;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+upb_pbdecoder *upb_pbdecoder_create(upb_arena *arena,
+                                    const upb_pbdecodermethod *method,
+                                    upb_sink output, upb_status *status);
+const upb_pbdecodermethod *upb_pbdecoder_method(const upb_pbdecoder *d);
+upb_bytessink upb_pbdecoder_input(upb_pbdecoder *d);
+uint64_t upb_pbdecoder_bytesparsed(const upb_pbdecoder *d);
+size_t upb_pbdecoder_maxnesting(const upb_pbdecoder *d);
+bool upb_pbdecoder_setmaxnesting(upb_pbdecoder *d, size_t max);
+void upb_pbdecoder_reset(upb_pbdecoder *d);
+
 #ifdef __cplusplus
+}  /* extern "C" */
 
 /* A Decoder receives binary protobuf data on its input sink and pushes the
  * decoded data to its output sink. */
-class upb::pb::Decoder {
+class upb::pb::DecoderPtr {
  public:
+  DecoderPtr() : ptr_(nullptr) {}
+  DecoderPtr(upb_pbdecoder* ptr) : ptr_(ptr) {}
+
+  upb_pbdecoder* ptr() { return ptr_; }
+
   /* Constructs a decoder instance for the given method, which must outlive this
    * decoder.  Any errors during parsing will be set on the given status, which
    * must also outlive this decoder.
    *
    * The sink must match the given method. */
-  static Decoder* Create(Environment* env, const DecoderMethod* method,
-                         Sink* output);
+  static DecoderPtr Create(Arena *arena, DecoderMethodPtr method,
+                           upb::Sink output, Status *status) {
+    return DecoderPtr(upb_pbdecoder_create(arena->ptr(), method.ptr(),
+                                           output.sink(), status->ptr()));
+  }
 
   /* Returns the DecoderMethod this decoder is parsing from. */
-  const DecoderMethod* method() const;
+  const DecoderMethodPtr method() const {
+    return DecoderMethodPtr(upb_pbdecoder_method(ptr_));
+  }
 
   /* The sink on which this decoder receives input. */
-  BytesSink* input();
+  BytesSink input() { return BytesSink(upb_pbdecoder_input(ptr())); }
 
   /* Returns number of bytes successfully parsed.
    *
@@ -127,7 +148,7 @@ class upb::pb::Decoder {
    *
    * This value may not be up-to-date when called from inside a parsing
    * callback. */
-  uint64_t BytesParsed() const;
+  uint64_t BytesParsed() { return upb_pbdecoder_bytesparsed(ptr()); }
 
   /* Gets/sets the parsing nexting limit.  If the total number of nested
    * submessages and repeated fields hits this limit, parsing will fail.  This
@@ -136,31 +157,55 @@ class upb::pb::Decoder {
    *
    * Setting the limit will fail if the parser is currently suspended at a depth
    * greater than this, or if memory allocation of the stack fails. */
-  size_t max_nesting() const;
-  bool set_max_nesting(size_t max);
+  size_t max_nesting() { return upb_pbdecoder_maxnesting(ptr()); }
+  bool set_max_nesting(size_t max) { return upb_pbdecoder_maxnesting(ptr()); }
 
-  void Reset();
+  void Reset() { upb_pbdecoder_reset(ptr()); }
 
   static const size_t kSize = UPB_PB_DECODER_SIZE;
 
  private:
-  UPB_DISALLOW_POD_OPS(Decoder, upb::pb::Decoder)
+  upb_pbdecoder *ptr_;
 };
 
 #endif  /* __cplusplus */
 
+/* upb_pbcodecache ************************************************************/
+
+/* Lazily builds and caches decoder methods that will push data to the given
+ * handlers.  The destination handlercache must outlive this object. */
+
+struct upb_pbcodecache;
+typedef struct upb_pbcodecache upb_pbcodecache;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+upb_pbcodecache *upb_pbcodecache_new(upb_handlercache *dest);
+void upb_pbcodecache_free(upb_pbcodecache *c);
+bool upb_pbcodecache_allowjit(const upb_pbcodecache *c);
+void upb_pbcodecache_setallowjit(upb_pbcodecache *c, bool allow);
+void upb_pbcodecache_setlazy(upb_pbcodecache *c, bool lazy);
+const upb_pbdecodermethod *upb_pbcodecache_get(upb_pbcodecache *c,
+                                               const upb_msgdef *md);
+
 #ifdef __cplusplus
+}  /* extern "C" */
 
 /* A class for caching protobuf processing code, whether bytecode for the
  * interpreted decoder or machine code for the JIT.
  *
- * This class is not thread-safe.
- *
- * TODO(haberman): move this to be heap allocated for ABI stability. */
+ * This class is not thread-safe. */
 class upb::pb::CodeCache {
  public:
-  CodeCache();
-  ~CodeCache();
+  CodeCache(upb::HandlerCache *dest)
+      : ptr_(upb_pbcodecache_new(dest->ptr()), upb_pbcodecache_free) {}
+  CodeCache(CodeCache&&) = default;
+  CodeCache& operator=(CodeCache&&) = default;
+
+  upb_pbcodecache* ptr() { return ptr_.get(); }
+  const upb_pbcodecache* ptr() const { return ptr_.get(); }
 
   /* Whether the cache is allowed to generate machine code.  Defaults to true.
    * There is no real reason to turn it off except for testing or if you are
@@ -169,144 +214,27 @@ class upb::pb::CodeCache {
    * Note that allow_jit = true does not *guarantee* that the code will be JIT
    * compiled.  If this platform is not supported or the JIT was not compiled
    * in, the code may still be interpreted. */
-  bool allow_jit() const;
+  bool allow_jit() const { return upb_pbcodecache_allowjit(ptr()); }
 
   /* This may only be called when the object is first constructed, and prior to
-   * any code generation, otherwise returns false and does nothing. */
-  bool set_allow_jit(bool allow);
+   * any code generation. */
+  void set_allow_jit(bool allow) { upb_pbcodecache_setallowjit(ptr(), allow); }
 
-  /* Returns a DecoderMethod that can push data to the given handlers.
-   * If a suitable method already exists, it will be returned from the cache.
-   *
-   * Specifying the destination handlers here allows the DecoderMethod to be
-   * statically bound to the destination handlers if possible, which can allow
-   * more efficient decoding.  However the returned method may or may not
-   * actually be statically bound.  But in all cases, the returned method can
-   * push data to the given handlers. */
-  const DecoderMethod *GetDecoderMethod(const DecoderMethodOptions& opts);
+  /* Should the decoder push submessages to lazy handlers for fields that have
+   * them?  The caller should set this iff the lazy handlers expect data that is
+   * in protobuf binary format and the caller wishes to lazy parse it. */
+  void set_lazy(bool lazy) { upb_pbcodecache_setlazy(ptr(), lazy); }
 
-  /* If/when someone needs to explicitly create a dynamically-bound
-   * DecoderMethod*, we can add a method to get it here. */
+  /* Returns a DecoderMethod that can push data to the given handlers.
+   * If a suitable method already exists, it will be returned from the cache. */
+  const DecoderMethodPtr Get(MessageDefPtr md) {
+    return DecoderMethodPtr(upb_pbcodecache_get(ptr(), md.ptr()));
+  }
 
  private:
-  UPB_DISALLOW_COPY_AND_ASSIGN(CodeCache)
-#else
-struct upb_pbcodecache {
-#endif
-  bool allow_jit_;
-
-  /* Array of mgroups. */
-  upb_inttable groups;
+  std::unique_ptr<upb_pbcodecache, decltype(&upb_pbcodecache_free)> ptr_;
 };
 
-UPB_BEGIN_EXTERN_C
-
-upb_pbdecoder *upb_pbdecoder_create(upb_env *e,
-                                    const upb_pbdecodermethod *method,
-                                    upb_sink *output);
-const upb_pbdecodermethod *upb_pbdecoder_method(const upb_pbdecoder *d);
-upb_bytessink *upb_pbdecoder_input(upb_pbdecoder *d);
-uint64_t upb_pbdecoder_bytesparsed(const upb_pbdecoder *d);
-size_t upb_pbdecoder_maxnesting(const upb_pbdecoder *d);
-bool upb_pbdecoder_setmaxnesting(upb_pbdecoder *d, size_t max);
-void upb_pbdecoder_reset(upb_pbdecoder *d);
-
-void upb_pbdecodermethodopts_init(upb_pbdecodermethodopts *opts,
-                                  const upb_handlers *h);
-void upb_pbdecodermethodopts_setlazy(upb_pbdecodermethodopts *opts, bool lazy);
-
-
-/* Include refcounted methods like upb_pbdecodermethod_ref(). */
-UPB_REFCOUNTED_CMETHODS(upb_pbdecodermethod, upb_pbdecodermethod_upcast)
-
-const upb_handlers *upb_pbdecodermethod_desthandlers(
-    const upb_pbdecodermethod *m);
-const upb_byteshandler *upb_pbdecodermethod_inputhandler(
-    const upb_pbdecodermethod *m);
-bool upb_pbdecodermethod_isnative(const upb_pbdecodermethod *m);
-const upb_pbdecodermethod *upb_pbdecodermethod_new(
-    const upb_pbdecodermethodopts *opts, const void *owner);
-
-void upb_pbcodecache_init(upb_pbcodecache *c);
-void upb_pbcodecache_uninit(upb_pbcodecache *c);
-bool upb_pbcodecache_allowjit(const upb_pbcodecache *c);
-bool upb_pbcodecache_setallowjit(upb_pbcodecache *c, bool allow);
-const upb_pbdecodermethod *upb_pbcodecache_getdecodermethod(
-    upb_pbcodecache *c, const upb_pbdecodermethodopts *opts);
-
-UPB_END_EXTERN_C
-
-#ifdef __cplusplus
-
-namespace upb {
-
-namespace pb {
-
-/* static */
-inline Decoder* Decoder::Create(Environment* env, const DecoderMethod* m,
-                                Sink* sink) {
-  return upb_pbdecoder_create(env, m, sink);
-}
-inline const DecoderMethod* Decoder::method() const {
-  return upb_pbdecoder_method(this);
-}
-inline BytesSink* Decoder::input() {
-  return upb_pbdecoder_input(this);
-}
-inline uint64_t Decoder::BytesParsed() const {
-  return upb_pbdecoder_bytesparsed(this);
-}
-inline size_t Decoder::max_nesting() const {
-  return upb_pbdecoder_maxnesting(this);
-}
-inline bool Decoder::set_max_nesting(size_t max) {
-  return upb_pbdecoder_setmaxnesting(this, max);
-}
-inline void Decoder::Reset() { upb_pbdecoder_reset(this); }
-
-inline DecoderMethodOptions::DecoderMethodOptions(const Handlers* h) {
-  upb_pbdecodermethodopts_init(this, h);
-}
-inline void DecoderMethodOptions::set_lazy(bool lazy) {
-  upb_pbdecodermethodopts_setlazy(this, lazy);
-}
-
-inline const Handlers* DecoderMethod::dest_handlers() const {
-  return upb_pbdecodermethod_desthandlers(this);
-}
-inline const BytesHandler* DecoderMethod::input_handler() const {
-  return upb_pbdecodermethod_inputhandler(this);
-}
-inline bool DecoderMethod::is_native() const {
-  return upb_pbdecodermethod_isnative(this);
-}
-/* static */
-inline reffed_ptr<const DecoderMethod> DecoderMethod::New(
-    const DecoderMethodOptions &opts) {
-  const upb_pbdecodermethod *m = upb_pbdecodermethod_new(&opts, &m);
-  return reffed_ptr<const DecoderMethod>(m, &m);
-}
-
-inline CodeCache::CodeCache() {
-  upb_pbcodecache_init(this);
-}
-inline CodeCache::~CodeCache() {
-  upb_pbcodecache_uninit(this);
-}
-inline bool CodeCache::allow_jit() const {
-  return upb_pbcodecache_allowjit(this);
-}
-inline bool CodeCache::set_allow_jit(bool allow) {
-  return upb_pbcodecache_setallowjit(this, allow);
-}
-inline const DecoderMethod *CodeCache::GetDecoderMethod(
-    const DecoderMethodOptions& opts) {
-  return upb_pbcodecache_getdecodermethod(this, &opts);
-}
-
-}  /* namespace pb */
-}  /* namespace upb */
-
 #endif  /* __cplusplus */
 
 #endif  /* UPB_DECODER_H_ */
diff --git a/upb/pb/decoder.int.h b/upb/pb/decoder.int.h
index c9ad551..42fd7f8 100644
--- a/upb/pb/decoder.int.h
+++ b/upb/pb/decoder.int.h
@@ -11,11 +11,6 @@
 #include "upb/sink.h"
 #include "upb/table.int.h"
 
-#ifndef __cplusplus
-
-UPB_DECLARE_DERIVED_TYPE(upb::pb::MessageGroup, upb::RefCounted,
-                         mgroup, upb_refcounted)
-
 /* Opcode definitions.  The canonical meaning of each opcode is its
  * implementation in the interpreter (the JIT is written to match this).
  *
@@ -77,30 +72,25 @@ typedef enum {
 
 UPB_INLINE opcode getop(uint32_t instr) { return (opcode)(instr & 0xff); }
 
+struct upb_pbcodecache {
+  upb_arena *arena;
+  upb_handlercache *dest;
+  bool allow_jit;
+  bool lazy;
+
+  /* Array of mgroups. */
+  upb_inttable groups;
+};
+
 /* Method group; represents a set of decoder methods that had their code
- * emitted together, and must therefore be freed together.  Immutable once
- * created.  It is possible we may want to expose this to users at some point.
- *
- * Overall ownership of Decoder objects looks like this:
- *
- *                +----------+
- *                |          | <---> DecoderMethod
- *                | method   |
- * CodeCache ---> |  group   | <---> DecoderMethod
- *                |          |
- *                | (mgroup) | <---> DecoderMethod
- *                +----------+
- */
-struct mgroup {
-  upb_refcounted base;
-
-  /* Maps upb_msgdef/upb_handlers -> upb_pbdecodermethod.  We own refs on the
-   * methods. */
+ * emitted together.  Immutable once created.  */
+typedef struct {
+  /* Maps upb_msgdef/upb_handlers -> upb_pbdecodermethod.  Owned by us.
+   *
+   * Ideally this would be on pbcodecache (if we were actually caching code).
+   * Right now we don't actually cache anything, which is wasteful. */
   upb_inttable methods;
 
-  /* When we add the ability to link to previously existing mgroups, we'll
-   * need an array of mgroups we reference here, and own refs on them. */
-
   /* The bytecode for our methods, if any exists.  Owned by us. */
   uint32_t *bytecode;
   uint32_t *bytecode_end;
@@ -113,7 +103,7 @@ struct mgroup {
   char *debug_info;
   void *dl;
 #endif
-};
+} mgroup;
 
 /* The maximum that any submessages can be nested.  Matches proto2's limit.
  * This specifies the size of the decoder's statically-sized array and therefore
@@ -153,8 +143,6 @@ typedef struct {
 } upb_pbdecoder_frame;
 
 struct upb_pbdecodermethod {
-  upb_refcounted base;
-
   /* While compiling, the base is relative in "ofs", after compiling it is
    * absolute in "ptr". */
   union {
@@ -162,14 +150,8 @@ struct upb_pbdecodermethod {
     void *ptr;        /* Pointer to bytecode or machine code for this method. */
   } code_base;
 
-  /* The decoder method group to which this method belongs.  We own a ref.
-   * Owning a ref on the entire group is more coarse-grained than is strictly
-   * necessary; all we truly require is that methods we directly reference
-   * outlive us, while the group could contain many other messages we don't
-   * require.  But the group represents the messages that were
-   * allocated+compiled together, so it makes the most sense to free them
-   * together also. */
-  const upb_refcounted *group;
+  /* The decoder method group to which this method belongs. */
+  const mgroup *group;
 
   /* Whether this method is native code or bytecode. */
   bool is_native_;
@@ -187,7 +169,7 @@ struct upb_pbdecodermethod {
 };
 
 struct upb_pbdecoder {
-  upb_env *env;
+  upb_arena *arena;
 
   /* Our input sink. */
   upb_bytessink input_;
@@ -270,7 +252,6 @@ const char *upb_pbdecoder_getopname(unsigned int op);
 /* JIT codegen entry point. */
 void upb_pbdecoder_jit(mgroup *group);
 void upb_pbdecoder_freejit(mgroup *group);
-UPB_REFCOUNTED_CMETHODS(mgroup, mgroup_upcast)
 
 /* A special label that means "do field dispatch for this message and branch to
  * wherever that takes you." */
@@ -322,6 +303,4 @@ UPB_INLINE void upb_pbdecoder_unpackdispatch(uint64_t dispatch, uint64_t *ofs,
 
 #define CHECK_RETURN(x) { int32_t ret = x; if (ret >= 0) return ret; }
 
-#endif  /* __cplusplus */
-
 #endif  /* UPB_DECODER_INT_H_ */
diff --git a/upb/pb/encoder.c b/upb/pb/encoder.c
index 839ede0..5f74010 100644
--- a/upb/pb/encoder.c
+++ b/upb/pb/encoder.c
@@ -91,11 +91,11 @@ typedef struct {
 } upb_pb_encoder_segment;
 
 struct upb_pb_encoder {
-  upb_env *env;
+  upb_arena *arena;
 
   /* Our input and output. */
   upb_sink input_;
-  upb_bytessink *output_;
+  upb_bytessink output_;
 
   /* The "subclosure" -- used as the inner closure as part of the bytessink
    * protocol. */
@@ -150,7 +150,7 @@ static bool reserve(upb_pb_encoder *e, size_t bytes) {
       new_size *= 2;
     }
 
-    new_buf = upb_env_realloc(e->env, e->buf, old_size, new_size);
+    new_buf = upb_arena_realloc(e->arena, e->buf, old_size, new_size);
 
     if (new_buf == NULL) {
       return false;
@@ -230,7 +230,7 @@ static bool start_delim(upb_pb_encoder *e) {
           (e->seglimit - e->segbuf) * sizeof(upb_pb_encoder_segment);
       size_t new_size = old_size * 2;
       upb_pb_encoder_segment *new_buf =
-          upb_env_realloc(e->env, e->segbuf, old_size, new_size);
+          upb_arena_realloc(e->arena, e->segbuf, old_size, new_size);
 
       if (new_buf == NULL) {
         return false;
@@ -304,8 +304,7 @@ static void new_tag(upb_handlers *h, const upb_fielddef *f, upb_wiretype_t wt,
   tag_t *tag = upb_gmalloc(sizeof(tag_t));
   tag->bytes = upb_vencode64((n << 3) | wt, tag->tag);
 
-  upb_handlerattr_init(attr);
-  upb_handlerattr_sethandlerdata(attr, tag);
+  attr->handler_data = tag;
   upb_handlers_addcleanup(h, tag, upb_gfree);
 }
 
@@ -434,6 +433,7 @@ T(sint64,   int64_t,  upb_zzenc_64, encode_varint)
 
 /* code to build the handlers *************************************************/
 
+#include <stdio.h>
 static void newhandlers_callback(const void *closure, upb_handlers *h) {
   const upb_msgdef *m;
   upb_msg_field_iter i;
@@ -451,7 +451,7 @@ static void newhandlers_callback(const void *closure, upb_handlers *h) {
     const upb_fielddef *f = upb_msg_iter_field(&i);
     bool packed = upb_fielddef_isseq(f) && upb_fielddef_isprimitive(f) &&
                   upb_fielddef_packed(f);
-    upb_handlerattr attr;
+    upb_handlerattr attr = UPB_HANDLERATTR_INIT;
     upb_wiretype_t wt =
         packed ? UPB_WIRE_TYPE_DELIMITED
                : upb_pb_native_wire_types[upb_fielddef_descriptortype(f)];
@@ -500,20 +500,17 @@ static void newhandlers_callback(const void *closure, upb_handlers *h) {
         break;
       case UPB_DESCRIPTOR_TYPE_GROUP: {
         /* Endgroup takes a different tag (wire_type = END_GROUP). */
-        upb_handlerattr attr2;
+        upb_handlerattr attr2 = UPB_HANDLERATTR_INIT;
         new_tag(h, f, UPB_WIRE_TYPE_END_GROUP, &attr2);
 
         upb_handlers_setstartsubmsg(h, f, encode_startgroup, &attr);
         upb_handlers_setendsubmsg(h, f, encode_endgroup, &attr2);
 
-        upb_handlerattr_uninit(&attr2);
         break;
       }
     }
 
 #undef T
-
-    upb_handlerattr_uninit(&attr);
   }
 }
 
@@ -526,27 +523,26 @@ void upb_pb_encoder_reset(upb_pb_encoder *e) {
 
 /* public API *****************************************************************/
 
-const upb_handlers *upb_pb_encoder_newhandlers(const upb_msgdef *m,
-                                               const void *owner) {
-  return upb_handlers_newfrozen(m, owner, newhandlers_callback, NULL);
+upb_handlercache *upb_pb_encoder_newcache() {
+  return upb_handlercache_new(newhandlers_callback, NULL);
 }
 
-upb_pb_encoder *upb_pb_encoder_create(upb_env *env, const upb_handlers *h,
-                                      upb_bytessink *output) {
+upb_pb_encoder *upb_pb_encoder_create(upb_arena *arena, const upb_handlers *h,
+                                      upb_bytessink output) {
   const size_t initial_bufsize = 256;
   const size_t initial_segbufsize = 16;
   /* TODO(haberman): make this configurable. */
   const size_t stack_size = 64;
 #ifndef NDEBUG
-  const size_t size_before = upb_env_bytesallocated(env);
+  const size_t size_before = upb_arena_bytesallocated(arena);
 #endif
 
-  upb_pb_encoder *e = upb_env_malloc(env, sizeof(upb_pb_encoder));
+  upb_pb_encoder *e = upb_arena_malloc(arena, sizeof(upb_pb_encoder));
   if (!e) return NULL;
 
-  e->buf = upb_env_malloc(env, initial_bufsize);
-  e->segbuf = upb_env_malloc(env, initial_segbufsize * sizeof(*e->segbuf));
-  e->stack = upb_env_malloc(env, stack_size * sizeof(*e->stack));
+  e->buf = upb_arena_malloc(arena, initial_bufsize);
+  e->segbuf = upb_arena_malloc(arena, initial_segbufsize * sizeof(*e->segbuf));
+  e->stack = upb_arena_malloc(arena, stack_size * sizeof(*e->stack));
 
   if (!e->buf || !e->segbuf || !e->stack) {
     return NULL;
@@ -559,15 +555,15 @@ upb_pb_encoder *upb_pb_encoder_create(upb_env *env, const upb_handlers *h,
   upb_pb_encoder_reset(e);
   upb_sink_reset(&e->input_, h, e);
 
-  e->env = env;
+  e->arena = arena;
   e->output_ = output;
-  e->subc = output->closure;
+  e->subc = output.closure;
   e->ptr = e->buf;
 
   /* If this fails, increase the value in encoder.h. */
-  UPB_ASSERT_DEBUGVAR(upb_env_bytesallocated(env) - size_before <=
+  UPB_ASSERT_DEBUGVAR(upb_arena_bytesallocated(arena) - size_before <=
                       UPB_PB_ENCODER_SIZE);
   return e;
 }
 
-upb_sink *upb_pb_encoder_input(upb_pb_encoder *e) { return &e->input_; }
+upb_sink upb_pb_encoder_input(upb_pb_encoder *e) { return e->input_; }
diff --git a/upb/pb/encoder.h b/upb/pb/encoder.h
index 41b7e7b..1113c3a 100644
--- a/upb/pb/encoder.h
+++ b/upb/pb/encoder.h
@@ -17,75 +17,67 @@
 #ifdef __cplusplus
 namespace upb {
 namespace pb {
-class Encoder;
+class EncoderPtr;
 }  /* namespace pb */
 }  /* namespace upb */
 #endif
 
-UPB_DECLARE_TYPE(upb::pb::Encoder, upb_pb_encoder)
-
 #define UPB_PBENCODER_MAX_NESTING 100
 
-/* upb::pb::Encoder ***********************************************************/
+/* upb_pb_encoder *************************************************************/
 
 /* Preallocation hint: decoder won't allocate more bytes than this when first
  * constructed.  This hint may be an overestimate for some build configurations.
  * But if the decoder library is upgraded without recompiling the application,
  * it may be an underestimate. */
-#define UPB_PB_ENCODER_SIZE 768
+#define UPB_PB_ENCODER_SIZE 784
+
+struct upb_pb_encoder;
+typedef struct upb_pb_encoder upb_pb_encoder;
 
 #ifdef __cplusplus
+extern "C" {
+#endif
 
-class upb::pb::Encoder {
+upb_sink upb_pb_encoder_input(upb_pb_encoder *p);
+upb_pb_encoder* upb_pb_encoder_create(upb_arena* a, const upb_handlers* h,
+                                      upb_bytessink output);
+
+/* Lazily builds and caches handlers that will push encoded data to a bytessink.
+ * Any msgdef objects used with this object must outlive it. */
+upb_handlercache *upb_pb_encoder_newcache();
+
+#ifdef __cplusplus
+}  /* extern "C" { */
+
+class upb::pb::EncoderPtr {
  public:
+  EncoderPtr(upb_pb_encoder* ptr) : ptr_(ptr) {}
+
+  upb_pb_encoder* ptr() { return ptr_; }
+
   /* Creates a new encoder in the given environment.  The Handlers must have
    * come from NewHandlers() below. */
-  static Encoder* Create(Environment* env, const Handlers* handlers,
-                         BytesSink* output);
+  static EncoderPtr Create(Arena* arena, const Handlers* handlers,
+                           BytesSink output) {
+    return EncoderPtr(
+        upb_pb_encoder_create(arena->ptr(), handlers, output.sink()));
+  }
 
   /* The input to the encoder. */
-  Sink* input();
+  upb::Sink input() { return upb_pb_encoder_input(ptr()); }
 
   /* Creates a new set of handlers for this MessageDef. */
-  static reffed_ptr<const Handlers> NewHandlers(const MessageDef* msg);
+  static HandlerCache NewCache() {
+    return HandlerCache(upb_pb_encoder_newcache());
+  }
 
   static const size_t kSize = UPB_PB_ENCODER_SIZE;
 
  private:
-  UPB_DISALLOW_POD_OPS(Encoder, upb::pb::Encoder)
+  upb_pb_encoder* ptr_;
 };
 
-#endif
-
-UPB_BEGIN_EXTERN_C
-
-const upb_handlers *upb_pb_encoder_newhandlers(const upb_msgdef *m,
-                                               const void *owner);
-upb_sink *upb_pb_encoder_input(upb_pb_encoder *p);
-upb_pb_encoder* upb_pb_encoder_create(upb_env* e, const upb_handlers* h,
-                                      upb_bytessink* output);
-
-UPB_END_EXTERN_C
-
-#ifdef __cplusplus
-
-namespace upb {
-namespace pb {
-inline Encoder* Encoder::Create(Environment* env, const Handlers* handlers,
-                                BytesSink* output) {
-  return upb_pb_encoder_create(env, handlers, output);
-}
-inline Sink* Encoder::input() {
-  return upb_pb_encoder_input(this);
-}
-inline reffed_ptr<const Handlers> Encoder::NewHandlers(
-    const upb::MessageDef *md) {
-  const Handlers* h = upb_pb_encoder_newhandlers(md, &h);
-  return reffed_ptr<const Handlers>(h, &h);
-}
-}  /* namespace pb */
-}  /* namespace upb */
-
-#endif
+#endif  /* __cplusplus */
 
 #endif  /* UPB_ENCODER_H_ */
diff --git a/upb/pb/glue.c b/upb/pb/glue.c
deleted file mode 100644
index fb2b769..0000000
--- a/upb/pb/glue.c
+++ /dev/null
@@ -1,54 +0,0 @@
-
-#include "upb/pb/glue.h"
-
-#include "upb/descriptor/reader.h"
-#include "upb/pb/decoder.h"
-
-upb_filedef **upb_loaddescriptor(const char *buf, size_t n, const void *owner,
-                                 upb_status *status) {
-  /* Create handlers. */
-  const upb_pbdecodermethod *decoder_m;
-  const upb_handlers *reader_h = upb_descreader_newhandlers(&reader_h);
-  upb_env env;
-  upb_pbdecodermethodopts opts;
-  upb_pbdecoder *decoder;
-  upb_descreader *reader;
-  bool ok;
-  size_t i;
-  upb_filedef **ret = NULL;
-
-  upb_pbdecodermethodopts_init(&opts, reader_h);
-  decoder_m = upb_pbdecodermethod_new(&opts, &decoder_m);
-
-  upb_env_init(&env);
-  upb_env_reporterrorsto(&env, status);
-
-  reader = upb_descreader_create(&env, reader_h);
-  decoder = upb_pbdecoder_create(&env, decoder_m, upb_descreader_input(reader));
-
-  /* Push input data. */
-  ok = upb_bufsrc_putbuf(buf, n, upb_pbdecoder_input(decoder));
-
-  if (!ok) {
-    goto cleanup;
-  }
-
-  ret = upb_gmalloc(sizeof (*ret) * (upb_descreader_filecount(reader) + 1));
-
-  if (!ret) {
-    goto cleanup;
-  }
-
-  for (i = 0; i < upb_descreader_filecount(reader); i++) {
-    ret[i] = upb_descreader_file(reader, i);
-    upb_filedef_ref(ret[i], owner);
-  }
-
-  ret[i] = NULL;
-
-cleanup:
-  upb_env_uninit(&env);
-  upb_handlers_unref(reader_h, &reader_h);
-  upb_pbdecodermethod_unref(decoder_m, &decoder_m);
-  return ret;
-}
diff --git a/upb/pb/glue.h b/upb/pb/glue.h
deleted file mode 100644
index 716fc0e..0000000
--- a/upb/pb/glue.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
-** upb's core components like upb_decoder and upb_msg are carefully designed to
-** avoid depending on each other for maximum orthogonality.  In other words,
-** you can use a upb_decoder to decode into *any* kind of structure; upb_msg is
-** just one such structure.  A upb_msg can be serialized/deserialized into any
-** format, protobuf binary format is just one such format.
-**
-** However, for convenience we provide functions here for doing common
-** operations like deserializing protobuf binary format into a upb_msg.  The
-** compromise is that this file drags in almost all of upb as a dependency,
-** which could be undesirable if you're trying to use a trimmed-down build of
-** upb.
-**
-** While these routines are convenient, they do not reuse any encoding/decoding
-** state.  For example, if a decoder is JIT-based, it will be re-JITted every
-** time these functions are called.  For this reason, if you are parsing lots
-** of data and efficiency is an issue, these may not be the best functions to
-** use (though they are useful for prototyping, before optimizing).
-*/
-
-#ifndef UPB_GLUE_H
-#define UPB_GLUE_H
-
-#include <stdbool.h>
-#include "upb/def.h"
-
-#ifdef __cplusplus
-#include <vector>
-
-extern "C" {
-#endif
-
-/* Loads a binary descriptor and returns a NULL-terminated array of unfrozen
- * filedefs.  The caller owns the returned array, which must be freed with
- * upb_gfree(). */
-upb_filedef **upb_loaddescriptor(const char *buf, size_t n, const void *owner,
-                                 upb_status *status);
-
-#ifdef __cplusplus
-}  /* extern "C" */
-
-namespace upb {
-
-inline bool LoadDescriptor(const char* buf, size_t n, Status* status,
-                           std::vector<reffed_ptr<FileDef> >* files) {
-  FileDef** parsed_files = upb_loaddescriptor(buf, n, &parsed_files, status);
-
-  if (parsed_files) {
-    FileDef** p = parsed_files;
-    while (*p) {
-      files->push_back(reffed_ptr<FileDef>(*p, &parsed_files));
-      ++p;
-    }
-    free(parsed_files);
-    return true;
-  } else {
-    return false;
-  }
-}
-
-/* Templated so it can accept both string and std::string. */
-template <typename T>
-bool LoadDescriptor(const T& desc, Status* status,
-                    std::vector<reffed_ptr<FileDef> >* files) {
-  return LoadDescriptor(desc.c_str(), desc.size(), status, files);
-}
-
-}  /* namespace upb */
-
-#endif
-
-#endif  /* UPB_GLUE_H */
diff --git a/upb/pb/textprinter.c b/upb/pb/textprinter.c
index abfc2eb..934130e 100644
--- a/upb/pb/textprinter.c
+++ b/upb/pb/textprinter.c
@@ -18,7 +18,7 @@
 
 struct upb_textprinter {
   upb_sink input_;
-  upb_bytessink *output_;
+  upb_bytessink output_;
   int indent_depth_;
   bool single_line_;
   void *subc;
@@ -183,7 +183,7 @@ static bool textprinter_putenum(void *closure, const void *handler_data,
                                 int32_t val) {
   upb_textprinter *p = closure;
   const upb_fielddef *f = handler_data;
-  const upb_enumdef *enum_def = upb_downcast_enumdef(upb_fielddef_subdef(f));
+  const upb_enumdef *enum_def = upb_fielddef_enumsubdef(f);
   const char *label = upb_enumdef_iton(enum_def, val);
   if (label) {
     indent(p);
@@ -260,8 +260,8 @@ static void onmreg(const void *c, upb_handlers *h) {
       !upb_msg_field_done(&i);
       upb_msg_field_next(&i)) {
     upb_fielddef *f = upb_msg_iter_field(&i);
-    upb_handlerattr attr = UPB_HANDLERATTR_INITIALIZER;
-    upb_handlerattr_sethandlerdata(&attr, f);
+    upb_handlerattr attr = UPB_HANDLERATTR_INIT;
+    attr.handler_data = f;
     switch (upb_fielddef_type(f)) {
       case UPB_TYPE_INT32:
         upb_handlers_setint32(h, f, textprinter_putint32, &attr);
@@ -292,10 +292,10 @@ static void onmreg(const void *c, upb_handlers *h) {
         break;
       case UPB_TYPE_MESSAGE: {
         const char *name =
-            upb_fielddef_istagdelim(f)
+            upb_fielddef_descriptortype(f) == UPB_DESCRIPTOR_TYPE_GROUP
                 ? shortname(upb_msgdef_fullname(upb_fielddef_msgsubdef(f)))
                 : upb_fielddef_name(f);
-        upb_handlerattr_sethandlerdata(&attr, name);
+        attr.handler_data = name;
         upb_handlers_setstartsubmsg(h, f, textprinter_startsubmsg, &attr);
         upb_handlers_setendsubmsg(h, f, textprinter_endsubmsg, &attr);
         break;
@@ -315,9 +315,9 @@ static void textprinter_reset(upb_textprinter *p, bool single_line) {
 
 /* Public API *****************************************************************/
 
-upb_textprinter *upb_textprinter_create(upb_env *env, const upb_handlers *h,
-                                        upb_bytessink *output) {
-  upb_textprinter *p = upb_env_malloc(env, sizeof(upb_textprinter));
+upb_textprinter *upb_textprinter_create(upb_arena *arena, const upb_handlers *h,
+                                        upb_bytessink output) {
+  upb_textprinter *p = upb_arena_malloc(arena, sizeof(upb_textprinter));
   if (!p) return NULL;
 
   p->output_ = output;
@@ -327,12 +327,11 @@ upb_textprinter *upb_textprinter_create(upb_env *env, const upb_handlers *h,
   return p;
 }
 
-const upb_handlers *upb_textprinter_newhandlers(const upb_msgdef *m,
-                                                const void *owner) {
-  return upb_handlers_newfrozen(m, owner, &onmreg, NULL);
+upb_handlercache *upb_textprinter_newcache() {
+  return upb_handlercache_new(&onmreg, NULL);
 }
 
-upb_sink *upb_textprinter_input(upb_textprinter *p) { return &p->input_; }
+upb_sink upb_textprinter_input(upb_textprinter *p) { return p->input_; }
 
 void upb_textprinter_setsingleline(upb_textprinter *p, bool single_line) {
   p->single_line_ = single_line;
diff --git a/upb/pb/textprinter.h b/upb/pb/textprinter.h
index 2f40ed8..0af2b1a 100644
--- a/upb/pb/textprinter.h
+++ b/upb/pb/textprinter.h
@@ -12,68 +12,57 @@
 #ifdef __cplusplus
 namespace upb {
 namespace pb {
-class TextPrinter;
+class TextPrinterPtr;
 }  /* namespace pb */
 }  /* namespace upb */
 #endif
 
-UPB_DECLARE_TYPE(upb::pb::TextPrinter, upb_textprinter)
+/* upb_textprinter ************************************************************/
+
+struct upb_textprinter;
+typedef struct upb_textprinter upb_textprinter;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* C API. */
+upb_textprinter *upb_textprinter_create(upb_arena *arena, const upb_handlers *h,
+                                        upb_bytessink output);
+void upb_textprinter_setsingleline(upb_textprinter *p, bool single_line);
+upb_sink upb_textprinter_input(upb_textprinter *p);
+upb_handlercache *upb_textprinter_newcache();
 
 #ifdef __cplusplus
+}  /* extern "C" */
 
-class upb::pb::TextPrinter {
+class upb::pb::TextPrinterPtr {
  public:
+  TextPrinterPtr(upb_textprinter* ptr) : ptr_(ptr) {}
+
   /* The given handlers must have come from NewHandlers().  It must outlive the
    * TextPrinter. */
-  static TextPrinter *Create(Environment *env, const upb::Handlers *handlers,
-                             BytesSink *output);
+  static TextPrinterPtr Create(Arena *arena, upb::HandlersPtr *handlers,
+                               BytesSink output) {
+    return TextPrinterPtr(
+        upb_textprinter_create(arena->ptr(), handlers->ptr(), output.sink()));
+  }
 
-  void SetSingleLineMode(bool single_line);
+  void SetSingleLineMode(bool single_line) {
+    upb_textprinter_setsingleline(ptr_, single_line);
+  }
 
-  Sink* input();
+  Sink input() { return upb_textprinter_input(ptr_); }
 
   /* If handler caching becomes a requirement we can add a code cache as in
    * decoder.h */
-  static reffed_ptr<const Handlers> NewHandlers(const MessageDef* md);
-};
-
-#endif
-
-UPB_BEGIN_EXTERN_C
+  static HandlerCache NewCache() {
+    return HandlerCache(upb_textprinter_newcache());
+  }
 
-/* C API. */
-upb_textprinter *upb_textprinter_create(upb_env *env, const upb_handlers *h,
-                                        upb_bytessink *output);
-void upb_textprinter_setsingleline(upb_textprinter *p, bool single_line);
-upb_sink *upb_textprinter_input(upb_textprinter *p);
-
-const upb_handlers *upb_textprinter_newhandlers(const upb_msgdef *m,
-                                                const void *owner);
-
-UPB_END_EXTERN_C
-
-#ifdef __cplusplus
-
-namespace upb {
-namespace pb {
-inline TextPrinter *TextPrinter::Create(Environment *env,
-                                        const upb::Handlers *handlers,
-                                        BytesSink *output) {
-  return upb_textprinter_create(env, handlers, output);
-}
-inline void TextPrinter::SetSingleLineMode(bool single_line) {
-  upb_textprinter_setsingleline(this, single_line);
-}
-inline Sink* TextPrinter::input() {
-  return upb_textprinter_input(this);
-}
-inline reffed_ptr<const Handlers> TextPrinter::NewHandlers(
-    const MessageDef *md) {
-  const Handlers* h = upb_textprinter_newhandlers(md, &h);
-  return reffed_ptr<const Handlers>(h, &h);
-}
-}  /* namespace pb */
-}  /* namespace upb */
+ private:
+  upb_textprinter* ptr_;
+};
 
 #endif
 
diff --git a/upb/pb/varint.int.h b/upb/pb/varint.int.h
index 9c54311..b216a94 100644
--- a/upb/pb/varint.int.h
+++ b/upb/pb/varint.int.h
@@ -24,6 +24,18 @@ extern "C" {
  * descriptor type (upb_descriptortype_t). */
 extern const uint8_t upb_pb_native_wire_types[];
 
+UPB_INLINE uint64_t byteswap64(uint64_t val)
+{
+  return ((((val) & 0xff00000000000000ull) >> 56)
+    | (((val) & 0x00ff000000000000ull) >> 40)
+    | (((val) & 0x0000ff0000000000ull) >> 24)
+    | (((val) & 0x000000ff00000000ull) >> 8)
+    | (((val) & 0x00000000ff000000ull) << 8)
+    | (((val) & 0x0000000000ff0000ull) << 24)
+    | (((val) & 0x000000000000ff00ull) << 40)
+    | (((val) & 0x00000000000000ffull) << 56));
+}
+
 /* Zig-zag encoding/decoding **************************************************/
 
 UPB_INLINE int32_t upb_zzdec_32(uint32_t n) {
@@ -130,6 +142,9 @@ UPB_INLINE uint64_t upb_vencode32(uint32_t val) {
   uint64_t ret = 0;
   UPB_ASSERT(bytes <= 5);
   memcpy(&ret, buf, bytes);
+#ifdef UPB_BIG_ENDIAN
+  ret = byteswap64(ret);
+#endif
   UPB_ASSERT(ret <= 0xffffffffffU);
   return ret;
 }
diff --git a/upb/port_def.inc b/upb/port_def.inc
index 33ff78c..fe975a0 100644
--- a/upb/port_def.inc
+++ b/upb/port_def.inc
@@ -1,4 +1,8 @@
 
+#ifndef UINTPTR_MAX
+#error must include stdint.h first
+#endif
+
 #if UINTPTR_MAX == 0xffffffff
 #define UPB_SIZE(size32, size64) size32
 #else
diff --git a/upb/refcounted.c b/upb/refcounted.c
deleted file mode 100644
index f00dbb7..0000000
--- a/upb/refcounted.c
+++ /dev/null
@@ -1,851 +0,0 @@
-/*
-** upb::RefCounted Implementation
-**
-** Our key invariants are:
-** 1. reference cycles never span groups
-** 2. for ref2(to, from), we increment to's count iff group(from) != group(to)
-**
-** The previous two are how we avoid leaking cycles.  Other important
-** invariants are:
-** 3. for mutable objects "from" and "to", if there exists a ref2(to, from)
-**    this implies group(from) == group(to).  (In practice, what we implement
-**    is even stronger; "from" and "to" will share a group if there has *ever*
-**    been a ref2(to, from), but all that is necessary for correctness is the
-**    weaker one).
-** 4. mutable and immutable objects are never in the same group.
-*/
-
-#include "upb/refcounted.h"
-
-#include <setjmp.h>
-
-static void freeobj(upb_refcounted *o);
-
-const char untracked_val;
-const void *UPB_UNTRACKED_REF = &untracked_val;
-
-/* arch-specific atomic primitives  *******************************************/
-
-#ifdef UPB_THREAD_UNSAFE /*---------------------------------------------------*/
-
-static void atomic_inc(uint32_t *a) { (*a)++; }
-static bool atomic_dec(uint32_t *a) { return --(*a) == 0; }
-
-#elif defined(__GNUC__) || defined(__clang__) /*------------------------------*/
-
-static void atomic_inc(uint32_t *a) { __sync_fetch_and_add(a, 1); }
-static bool atomic_dec(uint32_t *a) { return __sync_sub_and_fetch(a, 1) == 0; }
-
-#elif defined(WIN32) /*-------------------------------------------------------*/
-
-#include <Windows.h>
-
-static void atomic_inc(upb_atomic_t *a) { InterlockedIncrement(&a->val); }
-static bool atomic_dec(upb_atomic_t *a) {
-  return InterlockedDecrement(&a->val) == 0;
-}
-
-#else
-#error Atomic primitives not defined for your platform/CPU.  \
-       Implement them or compile with UPB_THREAD_UNSAFE.
-#endif
-
-/* All static objects point to this refcount.
- * It is special-cased in ref/unref below.  */
-uint32_t static_refcount = -1;
-
-/* We can avoid atomic ops for statically-declared objects.
- * This is a minor optimization but nice since we can avoid degrading under
- * contention in this case. */
-
-static void refgroup(uint32_t *group) {
-  if (group != &static_refcount)
-    atomic_inc(group);
-}
-
-static bool unrefgroup(uint32_t *group) {
-  if (group == &static_refcount) {
-    return false;
-  } else {
-    return atomic_dec(group);
-  }
-}
-
-
-/* Reference tracking (debug only) ********************************************/
-
-#ifdef UPB_DEBUG_REFS
-
-#ifdef UPB_THREAD_UNSAFE
-
-static void upb_lock() {}
-static void upb_unlock() {}
-
-#else
-
-/* User must define functions that lock/unlock a global mutex and link this
- * file against them. */
-void upb_lock();
-void upb_unlock();
-
-#endif
-
-/* UPB_DEBUG_REFS mode counts on being able to malloc() memory in some
- * code-paths that can normally never fail, like upb_refcounted_ref().  Since
- * we have no way to propagage out-of-memory errors back to the user, and since
- * these errors can only occur in UPB_DEBUG_REFS mode, we use an allocator that
- * immediately aborts on failure (avoiding the global allocator, which might
- * inject failures). */
-
-#include <stdlib.h>
-
-static void *upb_debugrefs_allocfunc(upb_alloc *alloc, void *ptr,
-                                     size_t oldsize, size_t size) {
-  UPB_UNUSED(alloc);
-  UPB_UNUSED(oldsize);
-  if (size == 0) {
-    free(ptr);
-    return NULL;
-  } else {
-    void *ret = realloc(ptr, size);
-
-    if (!ret) {
-      abort();
-    }
-
-    return ret;
-  }
-}
-
-upb_alloc upb_alloc_debugrefs = {&upb_debugrefs_allocfunc};
-
-typedef struct {
-  int count;  /* How many refs there are (duplicates only allowed for ref2). */
-  bool is_ref2;
-} trackedref;
-
-static trackedref *trackedref_new(bool is_ref2) {
-  trackedref *ret = upb_malloc(&upb_alloc_debugrefs, sizeof(*ret));
-  ret->count = 1;
-  ret->is_ref2 = is_ref2;
-  return ret;
-}
-
-static void track(const upb_refcounted *r, const void *owner, bool ref2) {
-  upb_value v;
-
-  UPB_ASSERT(owner);
-  if (owner == UPB_UNTRACKED_REF) return;
-
-  upb_lock();
-  if (upb_inttable_lookupptr(r->refs, owner, &v)) {
-    trackedref *ref = upb_value_getptr(v);
-    /* Since we allow multiple ref2's for the same to/from pair without
-     * allocating separate memory for each one, we lose the fine-grained
-     * tracking behavior we get with regular refs.  Since ref2s only happen
-     * inside upb, we'll accept this limitation until/unless there is a really
-     * difficult upb-internal bug that can't be figured out without it. */
-    UPB_ASSERT(ref2);
-    UPB_ASSERT(ref->is_ref2);
-    ref->count++;
-  } else {
-    trackedref *ref = trackedref_new(ref2);
-    upb_inttable_insertptr2(r->refs, owner, upb_value_ptr(ref),
-                            &upb_alloc_debugrefs);
-    if (ref2) {
-      /* We know this cast is safe when it is a ref2, because it's coming from
-       * another refcounted object. */
-      const upb_refcounted *from = owner;
-      UPB_ASSERT(!upb_inttable_lookupptr(from->ref2s, r, NULL));
-      upb_inttable_insertptr2(from->ref2s, r, upb_value_ptr(NULL),
-                              &upb_alloc_debugrefs);
-    }
-  }
-  upb_unlock();
-}
-
-static void untrack(const upb_refcounted *r, const void *owner, bool ref2) {
-  upb_value v;
-  bool found;
-  trackedref *ref;
-
-  UPB_ASSERT(owner);
-  if (owner == UPB_UNTRACKED_REF) return;
-
-  upb_lock();
-  found = upb_inttable_lookupptr(r->refs, owner, &v);
-  /* This assert will fail if an owner attempts to release a ref it didn't have. */
-  UPB_ASSERT(found);
-  ref = upb_value_getptr(v);
-  UPB_ASSERT(ref->is_ref2 == ref2);
-  if (--ref->count == 0) {
-    free(ref);
-    upb_inttable_removeptr(r->refs, owner, NULL);
-    if (ref2) {
-      /* We know this cast is safe when it is a ref2, because it's coming from
-       * another refcounted object. */
-      const upb_refcounted *from = owner;
-      bool removed = upb_inttable_removeptr(from->ref2s, r, NULL);
-      UPB_ASSERT(removed);
-    }
-  }
-  upb_unlock();
-}
-
-static void checkref(const upb_refcounted *r, const void *owner, bool ref2) {
-  upb_value v;
-  bool found;
-  trackedref *ref;
-
-  upb_lock();
-  found = upb_inttable_lookupptr(r->refs, owner, &v);
-  UPB_ASSERT(found);
-  ref = upb_value_getptr(v);
-  UPB_ASSERT(ref->is_ref2 == ref2);
-  upb_unlock();
-}
-
-/* Populates the given UPB_CTYPE_INT32 inttable with counts of ref2's that
- * originate from the given owner. */
-static void getref2s(const upb_refcounted *owner, upb_inttable *tab) {
-  upb_inttable_iter i;
-
-  upb_lock();
-  upb_inttable_begin(&i, owner->ref2s);
-  for(; !upb_inttable_done(&i); upb_inttable_next(&i)) {
-    upb_value v;
-    upb_value count;
-    trackedref *ref;
-    bool found;
-
-    upb_refcounted *to = (upb_refcounted*)upb_inttable_iter_key(&i);
-
-    /* To get the count we need to look in the target's table. */
-    found = upb_inttable_lookupptr(to->refs, owner, &v);
-    UPB_ASSERT(found);
-    ref = upb_value_getptr(v);
-    count = upb_value_int32(ref->count);
-
-    upb_inttable_insertptr2(tab, to, count, &upb_alloc_debugrefs);
-  }
-  upb_unlock();
-}
-
-typedef struct {
-  upb_inttable ref2;
-  const upb_refcounted *obj;
-} check_state;
-
-static void visit_check(const upb_refcounted *obj, const upb_refcounted *subobj,
-                        void *closure) {
-  check_state *s = closure;
-  upb_inttable *ref2 = &s->ref2;
-  upb_value v;
-  bool removed;
-  int32_t newcount;
-
-  UPB_ASSERT(obj == s->obj);
-  UPB_ASSERT(subobj);
-  removed = upb_inttable_removeptr(ref2, subobj, &v);
-  /* The following assertion will fail if the visit() function visits a subobj
-   * that it did not have a ref2 on, or visits the same subobj too many times. */
-  UPB_ASSERT(removed);
-  newcount = upb_value_getint32(v) - 1;
-  if (newcount > 0) {
-    upb_inttable_insert2(ref2, (uintptr_t)subobj, upb_value_int32(newcount),
-                         &upb_alloc_debugrefs);
-  }
-}
-
-static void visit(const upb_refcounted *r, upb_refcounted_visit *v,
-                  void *closure) {
-  /* In DEBUG_REFS mode we know what existing ref2 refs there are, so we know
-   * exactly the set of nodes that visit() should visit.  So we verify visit()'s
-   * correctness here. */
-  check_state state;
-  state.obj = r;
-  upb_inttable_init2(&state.ref2, UPB_CTYPE_INT32, &upb_alloc_debugrefs);
-  getref2s(r, &state.ref2);
-
-  /* This should visit any children in the ref2 table. */
-  if (r->vtbl->visit) r->vtbl->visit(r, visit_check, &state);
-
-  /* This assertion will fail if the visit() function missed any children. */
-  UPB_ASSERT(upb_inttable_count(&state.ref2) == 0);
-  upb_inttable_uninit2(&state.ref2, &upb_alloc_debugrefs);
-  if (r->vtbl->visit) r->vtbl->visit(r, v, closure);
-}
-
-static void trackinit(upb_refcounted *r) {
-  r->refs = upb_malloc(&upb_alloc_debugrefs, sizeof(*r->refs));
-  r->ref2s = upb_malloc(&upb_alloc_debugrefs, sizeof(*r->ref2s));
-  upb_inttable_init2(r->refs, UPB_CTYPE_PTR, &upb_alloc_debugrefs);
-  upb_inttable_init2(r->ref2s, UPB_CTYPE_PTR, &upb_alloc_debugrefs);
-}
-
-static void trackfree(const upb_refcounted *r) {
-  upb_inttable_uninit2(r->refs, &upb_alloc_debugrefs);
-  upb_inttable_uninit2(r->ref2s, &upb_alloc_debugrefs);
-  upb_free(&upb_alloc_debugrefs, r->refs);
-  upb_free(&upb_alloc_debugrefs, r->ref2s);
-}
-
-#else
-
-static void track(const upb_refcounted *r, const void *owner, bool ref2) {
-  UPB_UNUSED(r);
-  UPB_UNUSED(owner);
-  UPB_UNUSED(ref2);
-}
-
-static void untrack(const upb_refcounted *r, const void *owner, bool ref2) {
-  UPB_UNUSED(r);
-  UPB_UNUSED(owner);
-  UPB_UNUSED(ref2);
-}
-
-static void checkref(const upb_refcounted *r, const void *owner, bool ref2) {
-  UPB_UNUSED(r);
-  UPB_UNUSED(owner);
-  UPB_UNUSED(ref2);
-}
-
-static void trackinit(upb_refcounted *r) {
-  UPB_UNUSED(r);
-}
-
-static void trackfree(const upb_refcounted *r) {
-  UPB_UNUSED(r);
-}
-
-static void visit(const upb_refcounted *r, upb_refcounted_visit *v,
-                  void *closure) {
-  if (r->vtbl->visit) r->vtbl->visit(r, v, closure);
-}
-
-#endif  /* UPB_DEBUG_REFS */
-
-
-/* freeze() *******************************************************************/
-
-/* The freeze() operation is by far the most complicated part of this scheme.
- * We compute strongly-connected components and then mutate the graph such that
- * we preserve the invariants documented at the top of this file.  And we must
- * handle out-of-memory errors gracefully (without leaving the graph
- * inconsistent), which adds to the fun. */
-
-/* The state used by the freeze operation (shared across many functions). */
-typedef struct {
-  int depth;
-  int maxdepth;
-  uint64_t index;
-  /* Maps upb_refcounted* -> attributes (color, etc).  attr layout varies by
-   * color. */
-  upb_inttable objattr;
-  upb_inttable stack;   /* stack of upb_refcounted* for Tarjan's algorithm. */
-  upb_inttable groups;  /* array of uint32_t*, malloc'd refcounts for new groups */
-  upb_status *status;
-  jmp_buf err;
-} tarjan;
-
-static void release_ref2(const upb_refcounted *obj,
-                         const upb_refcounted *subobj,
-                         void *closure);
-
-/* Node attributes -----------------------------------------------------------*/
-
-/* After our analysis phase all nodes will be either GRAY or WHITE. */
-
-typedef enum {
-  BLACK = 0,  /* Object has not been seen. */
-  GRAY,   /* Object has been found via a refgroup but may not be reachable. */
-  GREEN,  /* Object is reachable and is currently on the Tarjan stack. */
-  WHITE   /* Object is reachable and has been assigned a group (SCC). */
-} color_t;
-
-UPB_NORETURN static void err(tarjan *t) { longjmp(t->err, 1); }
-UPB_NORETURN static void oom(tarjan *t) {
-  upb_status_seterrmsg(t->status, "out of memory");
-  err(t);
-}
-
-static uint64_t trygetattr(const tarjan *t, const upb_refcounted *r) {
-  upb_value v;
-  return upb_inttable_lookupptr(&t->objattr, r, &v) ?
-      upb_value_getuint64(v) : 0;
-}
-
-static uint64_t getattr(const tarjan *t, const upb_refcounted *r) {
-  upb_value v;
-  bool found = upb_inttable_lookupptr(&t->objattr, r, &v);
-  UPB_ASSERT(found);
-  return upb_value_getuint64(v);
-}
-
-static void setattr(tarjan *t, const upb_refcounted *r, uint64_t attr) {
-  upb_inttable_removeptr(&t->objattr, r, NULL);
-  upb_inttable_insertptr(&t->objattr, r, upb_value_uint64(attr));
-}
-
-static color_t color(tarjan *t, const upb_refcounted *r) {
-  return trygetattr(t, r) & 0x3;  /* Color is always stored in the low 2 bits. */
-}
-
-static void set_gray(tarjan *t, const upb_refcounted *r) {
-  UPB_ASSERT(color(t, r) == BLACK);
-  setattr(t, r, GRAY);
-}
-
-/* Pushes an obj onto the Tarjan stack and sets it to GREEN. */
-static void push(tarjan *t, const upb_refcounted *r) {
-  UPB_ASSERT(color(t, r) == BLACK || color(t, r) == GRAY);
-  /* This defines the attr layout for the GREEN state.  "index" and "lowlink"
-   * get 31 bits, which is plenty (limit of 2B objects frozen at a time). */
-  setattr(t, r, GREEN | (t->index << 2) | (t->index << 33));
-  if (++t->index == 0x80000000) {
-    upb_status_seterrmsg(t->status, "too many objects to freeze");
-    err(t);
-  }
-  upb_inttable_push(&t->stack, upb_value_ptr((void*)r));
-}
-
-/* Pops an obj from the Tarjan stack and sets it to WHITE, with a ptr to its
- * SCC group. */
-static upb_refcounted *pop(tarjan *t) {
-  upb_refcounted *r = upb_value_getptr(upb_inttable_pop(&t->stack));
-  UPB_ASSERT(color(t, r) == GREEN);
-  /* This defines the attr layout for nodes in the WHITE state.
-   * Top of group stack is [group, NULL]; we point at group. */
-  setattr(t, r, WHITE | (upb_inttable_count(&t->groups) - 2) << 8);
-  return r;
-}
-
-static void tarjan_newgroup(tarjan *t) {
-  uint32_t *group = upb_gmalloc(sizeof(*group));
-  if (!group) oom(t);
-  /* Push group and empty group leader (we'll fill in leader later). */
-  if (!upb_inttable_push(&t->groups, upb_value_ptr(group)) ||
-      !upb_inttable_push(&t->groups, upb_value_ptr(NULL))) {
-    upb_gfree(group);
-    oom(t);
-  }
-  *group = 0;
-}
-
-static uint32_t idx(tarjan *t, const upb_refcounted *r) {
-  UPB_ASSERT(color(t, r) == GREEN);
-  return (getattr(t, r) >> 2) & 0x7FFFFFFF;
-}
-
-static uint32_t lowlink(tarjan *t, const upb_refcounted *r) {
-  if (color(t, r) == GREEN) {
-    return getattr(t, r) >> 33;
-  } else {
-    return UINT32_MAX;
-  }
-}
-
-static void set_lowlink(tarjan *t, const upb_refcounted *r, uint32_t lowlink) {
-  UPB_ASSERT(color(t, r) == GREEN);
-  setattr(t, r, ((uint64_t)lowlink << 33) | (getattr(t, r) & 0x1FFFFFFFF));
-}
-
-static uint32_t *group(tarjan *t, upb_refcounted *r) {
-  uint64_t groupnum;
-  upb_value v;
-  bool found;
-
-  UPB_ASSERT(color(t, r) == WHITE);
-  groupnum = getattr(t, r) >> 8;
-  found = upb_inttable_lookup(&t->groups, groupnum, &v);
-  UPB_ASSERT(found);
-  return upb_value_getptr(v);
-}
-
-/* If the group leader for this object's group has not previously been set,
- * the given object is assigned to be its leader. */
-static upb_refcounted *groupleader(tarjan *t, upb_refcounted *r) {
-  uint64_t leader_slot;
-  upb_value v;
-  bool found;
-
-  UPB_ASSERT(color(t, r) == WHITE);
-  leader_slot = (getattr(t, r) >> 8) + 1;
-  found = upb_inttable_lookup(&t->groups, leader_slot, &v);
-  UPB_ASSERT(found);
-  if (upb_value_getptr(v)) {
-    return upb_value_getptr(v);
-  } else {
-    upb_inttable_remove(&t->groups, leader_slot, NULL);
-    upb_inttable_insert(&t->groups, leader_slot, upb_value_ptr(r));
-    return r;
-  }
-}
-
-
-/* Tarjan's algorithm --------------------------------------------------------*/
-
-/* See:
- *   http://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm */
-static void do_tarjan(const upb_refcounted *obj, tarjan *t);
-
-static void tarjan_visit(const upb_refcounted *obj,
-                         const upb_refcounted *subobj,
-                         void *closure) {
-  tarjan *t = closure;
-  if (++t->depth > t->maxdepth) {
-    upb_status_seterrf(t->status, "graph too deep to freeze (%d)", t->maxdepth);
-    err(t);
-  } else if (subobj->is_frozen || color(t, subobj) == WHITE) {
-    /* Do nothing: we don't want to visit or color already-frozen nodes,
-     * and WHITE nodes have already been assigned a SCC. */
-  } else if (color(t, subobj) < GREEN) {
-    /* Subdef has not yet been visited; recurse on it. */
-    do_tarjan(subobj, t);
-    set_lowlink(t, obj, UPB_MIN(lowlink(t, obj), lowlink(t, subobj)));
-  } else if (color(t, subobj) == GREEN) {
-    /* Subdef is in the stack and hence in the current SCC. */
-    set_lowlink(t, obj, UPB_MIN(lowlink(t, obj), idx(t, subobj)));
-  }
-  --t->depth;
-}
-
-static void do_tarjan(const upb_refcounted *obj, tarjan *t) {
-  if (color(t, obj) == BLACK) {
-    /* We haven't seen this object's group; mark the whole group GRAY. */
-    const upb_refcounted *o = obj;
-    do { set_gray(t, o); } while ((o = o->next) != obj);
-  }
-
-  push(t, obj);
-  visit(obj, tarjan_visit, t);
-  if (lowlink(t, obj) == idx(t, obj)) {
-    tarjan_newgroup(t);
-    while (pop(t) != obj)
-      ;
-  }
-}
-
-
-/* freeze() ------------------------------------------------------------------*/
-
-static void crossref(const upb_refcounted *r, const upb_refcounted *subobj,
-                     void *_t) {
-  tarjan *t = _t;
-  UPB_ASSERT(color(t, r) > BLACK);
-  if (color(t, subobj) > BLACK && r->group != subobj->group) {
-    /* Previously this ref was not reflected in subobj->group because they
-     * were in the same group; now that they are split a ref must be taken. */
-    refgroup(subobj->group);
-  }
-}
-
-static bool freeze(upb_refcounted *const*roots, int n, upb_status *s,
-                   int maxdepth) {
-  volatile bool ret = false;
-  int i;
-  upb_inttable_iter iter;
-
-  /* We run in two passes so that we can allocate all memory before performing
-   * any mutation of the input -- this allows us to leave the input unchanged
-   * in the case of memory allocation failure. */
-  tarjan t;
-  t.index = 0;
-  t.depth = 0;
-  t.maxdepth = maxdepth;
-  t.status = s;
-  if (!upb_inttable_init(&t.objattr, UPB_CTYPE_UINT64)) goto err1;
-  if (!upb_inttable_init(&t.stack, UPB_CTYPE_PTR)) goto err2;
-  if (!upb_inttable_init(&t.groups, UPB_CTYPE_PTR)) goto err3;
-  if (setjmp(t.err) != 0) goto err4;
-
-
-  for (i = 0; i < n; i++) {
-    if (color(&t, roots[i]) < GREEN) {
-      do_tarjan(roots[i], &t);
-    }
-  }
-
-  /* If we've made it this far, no further errors are possible so it's safe to
-   * mutate the objects without risk of leaving them in an inconsistent state. */
-  ret = true;
-
-  /* The transformation that follows requires care.  The preconditions are:
-   * - all objects in attr map are WHITE or GRAY, and are in mutable groups
-   *   (groups of all mutable objs)
-   * - no ref2(to, from) refs have incremented count(to) if both "to" and
-   *   "from" are in our attr map (this follows from invariants (2) and (3)) */
-
-  /* Pass 1: we remove WHITE objects from their mutable groups, and add them to
-   * new groups  according to the SCC's we computed.  These new groups will
-   * consist of only frozen objects.  None will be immediately collectible,
-   * because WHITE objects are by definition reachable from one of "roots",
-   * which the caller must own refs on. */
-  upb_inttable_begin(&iter, &t.objattr);
-  for(; !upb_inttable_done(&iter); upb_inttable_next(&iter)) {
-    upb_refcounted *obj = (upb_refcounted*)upb_inttable_iter_key(&iter);
-    /* Since removal from a singly-linked list requires access to the object's
-     * predecessor, we consider obj->next instead of obj for moving.  With the
-     * while() loop we guarantee that we will visit every node's predecessor.
-     * Proof:
-     *  1. every node's predecessor is in our attr map.
-     *  2. though the loop body may change a node's predecessor, it will only
-     *     change it to be the node we are currently operating on, so with a
-     *     while() loop we guarantee ourselves the chance to remove each node. */
-    while (color(&t, obj->next) == WHITE &&
-           group(&t, obj->next) != obj->next->group) {
-      upb_refcounted *leader;
-
-      /* Remove from old group. */
-      upb_refcounted *move = obj->next;
-      if (obj == move) {
-        /* Removing the last object from a group. */
-        UPB_ASSERT(*obj->group == obj->individual_count);
-        upb_gfree(obj->group);
-      } else {
-        obj->next = move->next;
-        /* This may decrease to zero; we'll collect GRAY objects (if any) that
-         * remain in the group in the third pass. */
-        UPB_ASSERT(*move->group >= move->individual_count);
-        *move->group -= move->individual_count;
-      }
-
-      /* Add to new group. */
-      leader = groupleader(&t, move);
-      if (move == leader) {
-        /* First object added to new group is its leader. */
-        move->group = group(&t, move);
-        move->next = move;
-        *move->group = move->individual_count;
-      } else {
-        /* Group already has at least one object in it. */
-        UPB_ASSERT(leader->group == group(&t, move));
-        move->group = group(&t, move);
-        move->next = leader->next;
-        leader->next = move;
-        *move->group += move->individual_count;
-      }
-
-      move->is_frozen = true;
-    }
-  }
-
-  /* Pass 2: GRAY and WHITE objects "obj" with ref2(to, obj) references must
-   * increment count(to) if group(obj) != group(to) (which could now be the
-   * case if "to" was just frozen). */
-  upb_inttable_begin(&iter, &t.objattr);
-  for(; !upb_inttable_done(&iter); upb_inttable_next(&iter)) {
-    upb_refcounted *obj = (upb_refcounted*)upb_inttable_iter_key(&iter);
-    visit(obj, crossref, &t);
-  }
-
-  /* Pass 3: GRAY objects are collected if their group's refcount dropped to
-   * zero when we removed its white nodes.  This can happen if they had only
-   * been kept alive by virtue of sharing a group with an object that was just
-   * frozen.
-   *
-   * It is important that we do this last, since the GRAY object's free()
-   * function could call unref2() on just-frozen objects, which will decrement
-   * refs that were added in pass 2. */
-  upb_inttable_begin(&iter, &t.objattr);
-  for(; !upb_inttable_done(&iter); upb_inttable_next(&iter)) {
-    upb_refcounted *obj = (upb_refcounted*)upb_inttable_iter_key(&iter);
-    if (obj->group == NULL || *obj->group == 0) {
-      if (obj->group) {
-        upb_refcounted *o;
-
-        /* We eagerly free() the group's count (since we can't easily determine
-         * the group's remaining size it's the easiest way to ensure it gets
-         * done). */
-        upb_gfree(obj->group);
-
-        /* Visit to release ref2's (done in a separate pass since release_ref2
-         * depends on o->group being unmodified so it can test merged()). */
-        o = obj;
-        do { visit(o, release_ref2, NULL); } while ((o = o->next) != obj);
-
-        /* Mark "group" fields as NULL so we know to free the objects later in
-         * this loop, but also don't try to delete the group twice. */
-        o = obj;
-        do { o->group = NULL; } while ((o = o->next) != obj);
-      }
-      freeobj(obj);
-    }
-  }
-
-err4:
-  if (!ret) {
-    upb_inttable_begin(&iter, &t.groups);
-    for(; !upb_inttable_done(&iter); upb_inttable_next(&iter))
-      upb_gfree(upb_value_getptr(upb_inttable_iter_value(&iter)));
-  }
-  upb_inttable_uninit(&t.groups);
-err3:
-  upb_inttable_uninit(&t.stack);
-err2:
-  upb_inttable_uninit(&t.objattr);
-err1:
-  return ret;
-}
-
-
-/* Misc internal functions  ***************************************************/
-
-static bool merged(const upb_refcounted *r, const upb_refcounted *r2) {
-  return r->group == r2->group;
-}
-
-static void merge(upb_refcounted *r, upb_refcounted *from) {
-  upb_refcounted *base;
-  upb_refcounted *tmp;
-
-  if (merged(r, from)) return;
-  *r->group += *from->group;
-  upb_gfree(from->group);
-  base = from;
-
-  /* Set all refcount pointers in the "from" chain to the merged refcount.
-   *
-   * TODO(haberman): this linear algorithm can result in an overall O(n^2) bound
-   * if the user continuously extends a group by one object.  Prevent this by
-   * using one of the techniques in this paper:
-   *     http://bioinfo.ict.ac.cn/~dbu/AlgorithmCourses/Lectures/Union-Find-Tarjan.pdf */
-  do { from->group = r->group; } while ((from = from->next) != base);
-
-  /* Merge the two circularly linked lists by swapping their next pointers. */
-  tmp = r->next;
-  r->next = base->next;
-  base->next = tmp;
-}
-
-static void unref(const upb_refcounted *r);
-
-static void release_ref2(const upb_refcounted *obj,
-                         const upb_refcounted *subobj,
-                         void *closure) {
-  UPB_UNUSED(closure);
-  untrack(subobj, obj, true);
-  if (!merged(obj, subobj)) {
-    UPB_ASSERT(subobj->is_frozen);
-    unref(subobj);
-  }
-}
-
-static void unref(const upb_refcounted *r) {
-  if (unrefgroup(r->group)) {
-    const upb_refcounted *o;
-
-    upb_gfree(r->group);
-
-    /* In two passes, since release_ref2 needs a guarantee that any subobjs
-     * are alive. */
-    o = r;
-    do { visit(o, release_ref2, NULL); } while((o = o->next) != r);
-
-    o = r;
-    do {
-      const upb_refcounted *next = o->next;
-      UPB_ASSERT(o->is_frozen || o->individual_count == 0);
-      freeobj((upb_refcounted*)o);
-      o = next;
-    } while(o != r);
-  }
-}
-
-static void freeobj(upb_refcounted *o) {
-  trackfree(o);
-  o->vtbl->free((upb_refcounted*)o);
-}
-
-
-/* Public interface ***********************************************************/
-
-bool upb_refcounted_init(upb_refcounted *r,
-                         const struct upb_refcounted_vtbl *vtbl,
-                         const void *owner) {
-#ifndef NDEBUG
-  /* Endianness check.  This is unrelated to upb_refcounted, it's just a
-   * convenient place to put the check that we can be assured will run for
-   * basically every program using upb. */
-  const int x = 1;
-#ifdef UPB_BIG_ENDIAN
-  UPB_ASSERT(*(char*)&x != 1);
-#else
-  UPB_ASSERT(*(char*)&x == 1);
-#endif
-#endif
-
-  r->next = r;
-  r->vtbl = vtbl;
-  r->individual_count = 0;
-  r->is_frozen = false;
-  r->group = upb_gmalloc(sizeof(*r->group));
-  if (!r->group) return false;
-  *r->group = 0;
-  trackinit(r);
-  upb_refcounted_ref(r, owner);
-  return true;
-}
-
-bool upb_refcounted_isfrozen(const upb_refcounted *r) {
-  return r->is_frozen;
-}
-
-void upb_refcounted_ref(const upb_refcounted *r, const void *owner) {
-  track(r, owner, false);
-  if (!r->is_frozen)
-    ((upb_refcounted*)r)->individual_count++;
-  refgroup(r->group);
-}
-
-void upb_refcounted_unref(const upb_refcounted *r, const void *owner) {
-  untrack(r, owner, false);
-  if (!r->is_frozen)
-    ((upb_refcounted*)r)->individual_count--;
-  unref(r);
-}
-
-void upb_refcounted_ref2(const upb_refcounted *r, upb_refcounted *from) {
-  UPB_ASSERT(!from->is_frozen);  /* Non-const pointer implies this. */
-  track(r, from, true);
-  if (r->is_frozen) {
-    refgroup(r->group);
-  } else {
-    merge((upb_refcounted*)r, from);
-  }
-}
-
-void upb_refcounted_unref2(const upb_refcounted *r, upb_refcounted *from) {
-  UPB_ASSERT(!from->is_frozen);  /* Non-const pointer implies this. */
-  untrack(r, from, true);
-  if (r->is_frozen) {
-    unref(r);
-  } else {
-    UPB_ASSERT(merged(r, from));
-  }
-}
-
-void upb_refcounted_donateref(
-    const upb_refcounted *r, const void *from, const void *to) {
-  UPB_ASSERT(from != to);
-  if (to != NULL)
-    upb_refcounted_ref(r, to);
-  if (from != NULL)
-    upb_refcounted_unref(r, from);
-}
-
-void upb_refcounted_checkref(const upb_refcounted *r, const void *owner) {
-  checkref(r, owner, false);
-}
-
-bool upb_refcounted_freeze(upb_refcounted *const*roots, int n, upb_status *s,
-                           int maxdepth) {
-  int i;
-  bool ret;
-  for (i = 0; i < n; i++) {
-    UPB_ASSERT(!roots[i]->is_frozen);
-  }
-  ret = freeze(roots, n, s, maxdepth);
-  UPB_ASSERT(!s || ret == upb_ok(s));
-  return ret;
-}
diff --git a/upb/refcounted.h b/upb/refcounted.h
deleted file mode 100644
index 6698d38..0000000
--- a/upb/refcounted.h
+++ /dev/null
@@ -1,348 +0,0 @@
-/*
-** upb::RefCounted (upb_refcounted)
-**
-** A refcounting scheme that supports circular refs.  It accomplishes this by
-** partitioning the set of objects into groups such that no cycle spans groups;
-** we can then reference-count the group as a whole and ignore refs within the
-** group.  When objects are mutable, these groups are computed very
-** conservatively; we group any objects that have ever had a link between them.
-** When objects are frozen, we compute strongly-connected components which
-** allows us to be precise and only group objects that are actually cyclic.
-**
-** This is a mixed C/C++ interface that offers a full API to both languages.
-** See the top-level README for more information.
-*/
-
-#ifndef UPB_REFCOUNTED_H_
-#define UPB_REFCOUNTED_H_
-
-#include "upb/table.int.h"
-
-/* Reference tracking will check ref()/unref() operations to make sure the
- * ref ownership is correct.  Where possible it will also make tools like
- * Valgrind attribute ref leaks to the code that took the leaked ref, not
- * the code that originally created the object.
- *
- * Enabling this requires the application to define upb_lock()/upb_unlock()
- * functions that acquire/release a global mutex (or #define UPB_THREAD_UNSAFE).
- * For this reason we don't enable it by default, even in debug builds.
- */
-
-/* #define UPB_DEBUG_REFS */
-
-#ifdef __cplusplus
-namespace upb {
-class RefCounted;
-template <class T> class reffed_ptr;
-}
-#endif
-
-UPB_DECLARE_TYPE(upb::RefCounted, upb_refcounted)
-
-struct upb_refcounted_vtbl;
-
-#ifdef __cplusplus
-
-class upb::RefCounted {
- public:
-  /* Returns true if the given object is frozen. */
-  bool IsFrozen() const;
-
-  /* Increases the ref count, the new ref is owned by "owner" which must not
-   * already own a ref (and should not itself be a refcounted object if the ref
-   * could possibly be circular; see below).
-   * Thread-safe iff "this" is frozen. */
-  void Ref(const void *owner) const;
-
-  /* Release a ref that was acquired from upb_refcounted_ref() and collects any
-   * objects it can. */
-  void Unref(const void *owner) const;
-
-  /* Moves an existing ref from "from" to "to", without changing the overall
-   * ref count.  DonateRef(foo, NULL, owner) is the same as Ref(foo, owner),
-   * but "to" may not be NULL. */
-  void DonateRef(const void *from, const void *to) const;
-
-  /* Verifies that a ref to the given object is currently held by the given
-   * owner.  Only effective in UPB_DEBUG_REFS builds. */
-  void CheckRef(const void *owner) const;
-
- private:
-  UPB_DISALLOW_POD_OPS(RefCounted, upb::RefCounted)
-#else
-struct upb_refcounted {
-#endif
-  /* TODO(haberman): move the actual structure definition to structdefs.int.h.
-   * The only reason they are here is because inline functions need to see the
-   * definition of upb_handlers, which needs to see this definition.  But we
-   * can change the upb_handlers inline functions to deal in raw offsets
-   * instead.
-   */
-
-  /* A single reference count shared by all objects in the group. */
-  uint32_t *group;
-
-  /* A singly-linked list of all objects in the group. */
-  upb_refcounted *next;
-
-  /* Table of function pointers for this type. */
-  const struct upb_refcounted_vtbl *vtbl;
-
-  /* Maintained only when mutable, this tracks the number of refs (but not
-   * ref2's) to this object.  *group should be the sum of all individual_count
-   * in the group. */
-  uint32_t individual_count;
-
-  bool is_frozen;
-
-#ifdef UPB_DEBUG_REFS
-  upb_inttable *refs;  /* Maps owner -> trackedref for incoming refs. */
-  upb_inttable *ref2s; /* Set of targets for outgoing ref2s. */
-#endif
-};
-
-#ifdef UPB_DEBUG_REFS
-extern upb_alloc upb_alloc_debugrefs;
-#define UPB_REFCOUNT_INIT(vtbl, refs, ref2s) \
-    {&static_refcount, NULL, vtbl, 0, true, refs, ref2s}
-#else
-#define UPB_REFCOUNT_INIT(vtbl, refs, ref2s) \
-    {&static_refcount, NULL, vtbl, 0, true}
-#endif
-
-UPB_BEGIN_EXTERN_C
-
-/* It is better to use tracked refs when possible, for the extra debugging
- * capability.  But if this is not possible (because you don't have easy access
- * to a stable pointer value that is associated with the ref), you can pass
- * UPB_UNTRACKED_REF instead.  */
-extern const void *UPB_UNTRACKED_REF;
-
-/* Native C API. */
-bool upb_refcounted_isfrozen(const upb_refcounted *r);
-void upb_refcounted_ref(const upb_refcounted *r, const void *owner);
-void upb_refcounted_unref(const upb_refcounted *r, const void *owner);
-void upb_refcounted_donateref(
-    const upb_refcounted *r, const void *from, const void *to);
-void upb_refcounted_checkref(const upb_refcounted *r, const void *owner);
-
-#define UPB_REFCOUNTED_CMETHODS(type, upcastfunc) \
-  UPB_INLINE bool type ## _isfrozen(const type *v) { \
-    return upb_refcounted_isfrozen(upcastfunc(v)); \
-  } \
-  UPB_INLINE void type ## _ref(const type *v, const void *owner) { \
-    upb_refcounted_ref(upcastfunc(v), owner); \
-  } \
-  UPB_INLINE void type ## _unref(const type *v, const void *owner) { \
-    upb_refcounted_unref(upcastfunc(v), owner); \
-  } \
-  UPB_INLINE void type ## _donateref(const type *v, const void *from, const void *to) { \
-    upb_refcounted_donateref(upcastfunc(v), from, to); \
-  } \
-  UPB_INLINE void type ## _checkref(const type *v, const void *owner) { \
-    upb_refcounted_checkref(upcastfunc(v), owner); \
-  }
-
-#define UPB_REFCOUNTED_CPPMETHODS \
-  bool IsFrozen() const { \
-    return upb::upcast_to<const upb::RefCounted>(this)->IsFrozen(); \
-  } \
-  void Ref(const void *owner) const { \
-    return upb::upcast_to<const upb::RefCounted>(this)->Ref(owner); \
-  } \
-  void Unref(const void *owner) const { \
-    return upb::upcast_to<const upb::RefCounted>(this)->Unref(owner); \
-  } \
-  void DonateRef(const void *from, const void *to) const { \
-    return upb::upcast_to<const upb::RefCounted>(this)->DonateRef(from, to); \
-  } \
-  void CheckRef(const void *owner) const { \
-    return upb::upcast_to<const upb::RefCounted>(this)->CheckRef(owner); \
-  }
-
-/* Internal-to-upb Interface **************************************************/
-
-typedef void upb_refcounted_visit(const upb_refcounted *r,
-                                  const upb_refcounted *subobj,
-                                  void *closure);
-
-struct upb_refcounted_vtbl {
-  /* Must visit all subobjects that are currently ref'd via upb_refcounted_ref2.
-   * Must be longjmp()-safe. */
-  void (*visit)(const upb_refcounted *r, upb_refcounted_visit *visit, void *c);
-
-  /* Must free the object and release all references to other objects. */
-  void (*free)(upb_refcounted *r);
-};
-
-/* Initializes the refcounted with a single ref for the given owner.  Returns
- * false if memory could not be allocated. */
-bool upb_refcounted_init(upb_refcounted *r,
-                         const struct upb_refcounted_vtbl *vtbl,
-                         const void *owner);
-
-/* Adds a ref from one refcounted object to another ("from" must not already
- * own a ref).  These refs may be circular; cycles will be collected correctly
- * (if conservatively).  These refs do not need to be freed in from's free()
- * function. */
-void upb_refcounted_ref2(const upb_refcounted *r, upb_refcounted *from);
-
-/* Removes a ref that was acquired from upb_refcounted_ref2(), and collects any
- * object it can.  This is only necessary when "from" no longer points to "r",
- * and not from from's "free" function. */
-void upb_refcounted_unref2(const upb_refcounted *r, upb_refcounted *from);
-
-#define upb_ref2(r, from) \
-    upb_refcounted_ref2((const upb_refcounted*)r, (upb_refcounted*)from)
-#define upb_unref2(r, from) \
-    upb_refcounted_unref2((const upb_refcounted*)r, (upb_refcounted*)from)
-
-/* Freezes all mutable object reachable by ref2() refs from the given roots.
- * This will split refcounting groups into precise SCC groups, so that
- * refcounting of frozen objects can be more aggressive.  If memory allocation
- * fails, or if more than 2**31 mutable objects are reachable from "roots", or
- * if the maximum depth of the graph exceeds "maxdepth", false is returned and
- * the objects are unchanged.
- *
- * After this operation succeeds, the objects are frozen/const, and may not be
- * used through non-const pointers.  In particular, they may not be passed as
- * the second parameter of upb_refcounted_{ref,unref}2().  On the upside, all
- * operations on frozen refcounteds are threadsafe, and objects will be freed
- * at the precise moment that they become unreachable.
- *
- * Caller must own refs on each object in the "roots" list. */
-bool upb_refcounted_freeze(upb_refcounted *const*roots, int n, upb_status *s,
-                           int maxdepth);
-
-/* Shared by all compiled-in refcounted objects. */
-extern uint32_t static_refcount;
-
-UPB_END_EXTERN_C
-
-#ifdef __cplusplus
-/* C++ Wrappers. */
-namespace upb {
-inline bool RefCounted::IsFrozen() const {
-  return upb_refcounted_isfrozen(this);
-}
-inline void RefCounted::Ref(const void *owner) const {
-  upb_refcounted_ref(this, owner);
-}
-inline void RefCounted::Unref(const void *owner) const {
-  upb_refcounted_unref(this, owner);
-}
-inline void RefCounted::DonateRef(const void *from, const void *to) const {
-  upb_refcounted_donateref(this, from, to);
-}
-inline void RefCounted::CheckRef(const void *owner) const {
-  upb_refcounted_checkref(this, owner);
-}
-}  /* namespace upb */
-#endif
-
-
-/* upb::reffed_ptr ************************************************************/
-
-#ifdef __cplusplus
-
-#include <algorithm>  /* For std::swap(). */
-
-/* Provides RAII semantics for upb refcounted objects.  Each reffed_ptr owns a
- * ref on whatever object it points to (if any). */
-template <class T> class upb::reffed_ptr {
- public:
-  reffed_ptr() : ptr_(NULL) {}
-
-  /* If ref_donor is NULL, takes a new ref, otherwise adopts from ref_donor. */
-  template <class U>
-  reffed_ptr(U* val, const void* ref_donor = NULL)
-      : ptr_(upb::upcast(val)) {
-    if (ref_donor) {
-      UPB_ASSERT(ptr_);
-      ptr_->DonateRef(ref_donor, this);
-    } else if (ptr_) {
-      ptr_->Ref(this);
-    }
-  }
-
-  template <class U>
-  reffed_ptr(const reffed_ptr<U>& other)
-      : ptr_(upb::upcast(other.get())) {
-    if (ptr_) ptr_->Ref(this);
-  }
-
-  reffed_ptr(const reffed_ptr& other)
-      : ptr_(upb::upcast(other.get())) {
-    if (ptr_) ptr_->Ref(this);
-  }
-
-  ~reffed_ptr() { if (ptr_) ptr_->Unref(this); }
-
-  template <class U>
-  reffed_ptr& operator=(const reffed_ptr<U>& other) {
-    reset(other.get());
-    return *this;
-  }
-
-  reffed_ptr& operator=(const reffed_ptr& other) {
-    reset(other.get());
-    return *this;
-  }
-
-  /* TODO(haberman): add C++11 move construction/assignment for greater
-   * efficiency. */
-
-  void swap(reffed_ptr& other) {
-    if (ptr_ == other.ptr_) {
-      return;
-    }
-
-    if (ptr_) ptr_->DonateRef(this, &other);
-    if (other.ptr_) other.ptr_->DonateRef(&other, this);
-    std::swap(ptr_, other.ptr_);
-  }
-
-  T& operator*() const {
-    UPB_ASSERT(ptr_);
-    return *ptr_;
-  }
-
-  T* operator->() const {
-    UPB_ASSERT(ptr_);
-    return ptr_;
-  }
-
-  T* get() const { return ptr_; }
-
-  /* If ref_donor is NULL, takes a new ref, otherwise adopts from ref_donor. */
-  template <class U>
-  void reset(U* ptr = NULL, const void* ref_donor = NULL) {
-    reffed_ptr(ptr, ref_donor).swap(*this);
-  }
-
-  template <class U>
-  reffed_ptr<U> down_cast() {
-    return reffed_ptr<U>(upb::down_cast<U*>(get()));
-  }
-
-  template <class U>
-  reffed_ptr<U> dyn_cast() {
-    return reffed_ptr<U>(upb::dyn_cast<U*>(get()));
-  }
-
-  /* Plain release() is unsafe; if we were the only owner, it would leak the
-   * object.  Instead we provide this: */
-  T* ReleaseTo(const void* new_owner) {
-    T* ret = NULL;
-    ptr_->DonateRef(this, new_owner);
-    std::swap(ret, ptr_);
-    return ret;
-  }
-
- private:
-  T* ptr_;
-};
-
-#endif  /* __cplusplus */
-
-#endif  /* UPB_REFCOUNT_H_ */
diff --git a/upb/sink.c b/upb/sink.c
index e6ede49..d55d258 100644
--- a/upb/sink.c
+++ b/upb/sink.c
@@ -1,12 +1,11 @@
 
 #include "upb/sink.h"
 
-bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink *sink) {
+bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink sink) {
   void *subc;
   bool ret;
-  upb_bufhandle handle;
-  upb_bufhandle_init(&handle);
-  upb_bufhandle_setbuf(&handle, buf, 0);
+  upb_bufhandle handle = UPB_BUFHANDLE_INIT;
+  handle.buf = buf;
   ret = upb_bytessink_start(sink, len, &subc);
   if (ret && len != 0) {
     ret = (upb_bytessink_putbuf(sink, subc, buf, len, &handle) >= len);
@@ -14,76 +13,5 @@ bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink *sink) {
   if (ret) {
     ret = upb_bytessink_end(sink);
   }
-  upb_bufhandle_uninit(&handle);
   return ret;
 }
-
-struct upb_bufsink {
-  upb_byteshandler handler;
-  upb_bytessink sink;
-  upb_env *env;
-  char *ptr;
-  size_t len, size;
-};
-
-static void *upb_bufsink_start(void *_sink, const void *hd, size_t size_hint) {
-  upb_bufsink *sink = _sink;
-  UPB_UNUSED(hd);
-  UPB_UNUSED(size_hint);
-  sink->len = 0;
-  return sink;
-}
-
-static size_t upb_bufsink_string(void *_sink, const void *hd, const char *ptr,
-                                size_t len, const upb_bufhandle *handle) {
-  upb_bufsink *sink = _sink;
-  size_t new_size = sink->size;
-
-  UPB_ASSERT(new_size > 0);
-  UPB_UNUSED(hd);
-  UPB_UNUSED(handle);
-
-  while (sink->len + len > new_size) {
-    new_size *= 2;
-  }
-
-  if (new_size != sink->size) {
-    sink->ptr = upb_env_realloc(sink->env, sink->ptr, sink->size, new_size);
-    sink->size = new_size;
-  }
-
-  memcpy(sink->ptr + sink->len, ptr, len);
-  sink->len += len;
-
-  return len;
-}
-
-upb_bufsink *upb_bufsink_new(upb_env *env) {
-  upb_bufsink *sink = upb_env_malloc(env, sizeof(upb_bufsink));
-  upb_byteshandler_init(&sink->handler);
-  upb_byteshandler_setstartstr(&sink->handler, upb_bufsink_start, NULL);
-  upb_byteshandler_setstring(&sink->handler, upb_bufsink_string, NULL);
-
-  upb_bytessink_reset(&sink->sink, &sink->handler, sink);
-
-  sink->env = env;
-  sink->size = 32;
-  sink->ptr = upb_env_malloc(env, sink->size);
-  sink->len = 0;
-
-  return sink;
-}
-
-void upb_bufsink_free(upb_bufsink *sink) {
-  upb_env_free(sink->env, sink->ptr);
-  upb_env_free(sink->env, sink);
-}
-
-upb_bytessink *upb_bufsink_sink(upb_bufsink *sink) {
-  return &sink->sink;
-}
-
-const char *upb_bufsink_getdata(const upb_bufsink *sink, size_t *len) {
-  *len = sink->len;
-  return sink->ptr;
-}
diff --git a/upb/sink.h b/upb/sink.h
index 0b98f07..4d6d0a3 100644
--- a/upb/sink.h
+++ b/upb/sink.h
@@ -22,19 +22,180 @@
 
 #ifdef __cplusplus
 namespace upb {
-class BufferSink;
-class BufferSource;
 class BytesSink;
 class Sink;
 }
 #endif
 
-UPB_DECLARE_TYPE(upb::BufferSink, upb_bufsink)
-UPB_DECLARE_TYPE(upb::BufferSource, upb_bufsrc)
-UPB_DECLARE_TYPE(upb::BytesSink, upb_bytessink)
-UPB_DECLARE_TYPE(upb::Sink, upb_sink)
+/* upb_sink *******************************************************************/
 
 #ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  const upb_handlers *handlers;
+  void *closure;
+} upb_sink;
+
+#define PUTVAL(type, ctype)                                           \
+  UPB_INLINE bool upb_sink_put##type(upb_sink s, upb_selector_t sel,  \
+                                     ctype val) {                     \
+    typedef upb_##type##_handlerfunc functype;                        \
+    functype *func;                                                   \
+    const void *hd;                                                   \
+    if (!s.handlers) return true;                                     \
+    func = (functype *)upb_handlers_gethandler(s.handlers, sel, &hd); \
+    if (!func) return true;                                           \
+    return func(s.closure, hd, val);                                  \
+  }
+
+PUTVAL(int32,  int32_t)
+PUTVAL(int64,  int64_t)
+PUTVAL(uint32, uint32_t)
+PUTVAL(uint64, uint64_t)
+PUTVAL(float,  float)
+PUTVAL(double, double)
+PUTVAL(bool,   bool)
+#undef PUTVAL
+
+UPB_INLINE void upb_sink_reset(upb_sink *s, const upb_handlers *h, void *c) {
+  s->handlers = h;
+  s->closure = c;
+}
+
+UPB_INLINE size_t upb_sink_putstring(upb_sink s, upb_selector_t sel,
+                                     const char *buf, size_t n,
+                                     const upb_bufhandle *handle) {
+  typedef upb_string_handlerfunc func;
+  func *handler;
+  const void *hd;
+  if (!s.handlers) return n;
+  handler = (func *)upb_handlers_gethandler(s.handlers, sel, &hd);
+
+  if (!handler) return n;
+  return handler(s.closure, hd, buf, n, handle);
+}
+
+UPB_INLINE bool upb_sink_putunknown(upb_sink s, const char *buf, size_t n) {
+  typedef upb_unknown_handlerfunc func;
+  func *handler;
+  const void *hd;
+  if (!s.handlers) return true;
+  handler =
+      (func *)upb_handlers_gethandler(s.handlers, UPB_UNKNOWN_SELECTOR, &hd);
+
+  if (!handler) return n;
+  return handler(s.closure, hd, buf, n);
+}
+
+UPB_INLINE bool upb_sink_startmsg(upb_sink s) {
+  typedef upb_startmsg_handlerfunc func;
+  func *startmsg;
+  const void *hd;
+  if (!s.handlers) return true;
+  startmsg =
+      (func *)upb_handlers_gethandler(s.handlers, UPB_STARTMSG_SELECTOR, &hd);
+
+  if (!startmsg) return true;
+  return startmsg(s.closure, hd);
+}
+
+UPB_INLINE bool upb_sink_endmsg(upb_sink s, upb_status *status) {
+  typedef upb_endmsg_handlerfunc func;
+  func *endmsg;
+  const void *hd;
+  if (!s.handlers) return true;
+  endmsg =
+      (func *)upb_handlers_gethandler(s.handlers, UPB_ENDMSG_SELECTOR, &hd);
+
+  if (!endmsg) return true;
+  return endmsg(s.closure, hd, status);
+}
+
+UPB_INLINE bool upb_sink_startseq(upb_sink s, upb_selector_t sel,
+                                  upb_sink *sub) {
+  typedef upb_startfield_handlerfunc func;
+  func *startseq;
+  const void *hd;
+  sub->closure = s.closure;
+  sub->handlers = s.handlers;
+  if (!s.handlers) return true;
+  startseq = (func*)upb_handlers_gethandler(s.handlers, sel, &hd);
+
+  if (!startseq) return true;
+  sub->closure = startseq(s.closure, hd);
+  return sub->closure ? true : false;
+}
+
+UPB_INLINE bool upb_sink_endseq(upb_sink s, upb_selector_t sel) {
+  typedef upb_endfield_handlerfunc func;
+  func *endseq;
+  const void *hd;
+  if (!s.handlers) return true;
+  endseq = (func*)upb_handlers_gethandler(s.handlers, sel, &hd);
+
+  if (!endseq) return true;
+  return endseq(s.closure, hd);
+}
+
+UPB_INLINE bool upb_sink_startstr(upb_sink s, upb_selector_t sel,
+                                  size_t size_hint, upb_sink *sub) {
+  typedef upb_startstr_handlerfunc func;
+  func *startstr;
+  const void *hd;
+  sub->closure = s.closure;
+  sub->handlers = s.handlers;
+  if (!s.handlers) return true;
+  startstr = (func*)upb_handlers_gethandler(s.handlers, sel, &hd);
+
+  if (!startstr) return true;
+  sub->closure = startstr(s.closure, hd, size_hint);
+  return sub->closure ? true : false;
+}
+
+UPB_INLINE bool upb_sink_endstr(upb_sink s, upb_selector_t sel) {
+  typedef upb_endfield_handlerfunc func;
+  func *endstr;
+  const void *hd;
+  if (!s.handlers) return true;
+  endstr = (func*)upb_handlers_gethandler(s.handlers, sel, &hd);
+
+  if (!endstr) return true;
+  return endstr(s.closure, hd);
+}
+
+UPB_INLINE bool upb_sink_startsubmsg(upb_sink s, upb_selector_t sel,
+                                     upb_sink *sub) {
+  typedef upb_startfield_handlerfunc func;
+  func *startsubmsg;
+  const void *hd;
+  sub->closure = s.closure;
+  if (!s.handlers) {
+    sub->handlers = NULL;
+    return true;
+  }
+  sub->handlers = upb_handlers_getsubhandlers_sel(s.handlers, sel);
+  startsubmsg = (func*)upb_handlers_gethandler(s.handlers, sel, &hd);
+
+  if (!startsubmsg) return true;
+  sub->closure = startsubmsg(s.closure, hd);
+  return sub->closure ? true : false;
+}
+
+UPB_INLINE bool upb_sink_endsubmsg(upb_sink s, upb_selector_t sel) {
+  typedef upb_endfield_handlerfunc func;
+  func *endsubmsg;
+  const void *hd;
+  if (!s.handlers) return true;
+  endsubmsg = (func*)upb_handlers_gethandler(s.handlers, sel, &hd);
+
+  if (!endsubmsg) return s.closure;
+  return endsubmsg(s.closure, hd);
+}
+
+#ifdef __cplusplus
+}  /* extern "C" */
 
 /* A upb::Sink is an object that binds a upb::Handlers object to some runtime
  * state.  It represents an endpoint to which data can be sent.
@@ -77,20 +238,39 @@ class upb::Sink {
   /* Constructor with no initialization; must be Reset() before use. */
   Sink() {}
 
+  Sink(const Sink&) = default;
+  Sink& operator=(const Sink&) = default;
+
+  Sink(const upb_sink& sink) : sink_(sink) {}
+  Sink &operator=(const upb_sink &sink) {
+    sink_ = sink;
+    return *this;
+  }
+
+  upb_sink sink() { return sink_; }
+
   /* Constructs a new sink for the given frozen handlers and closure.
    *
    * TODO: once the Handlers know the expected closure type, verify that T
    * matches it. */
-  template <class T> Sink(const Handlers* handlers, T* closure);
+  template <class T> Sink(const upb_handlers* handlers, T* closure) {
+    Reset(handlers, closure);
+  }
+
+  upb_sink* ptr() { return &sink_; }
 
   /* Resets the value of the sink. */
-  template <class T> void Reset(const Handlers* handlers, T* closure);
+  template <class T> void Reset(const upb_handlers* handlers, T* closure) {
+    upb_sink_reset(&sink_, handlers, closure);
+  }
 
   /* Returns the top-level object that is bound to this sink.
    *
    * TODO: once the Handlers know the expected closure type, verify that T
    * matches it. */
-  template <class T> T* GetObject() const;
+  template <class T> T* GetObject() const {
+    return static_cast<T*>(sink_.closure);
+  }
 
   /* Functions for pushing data into the sink.
    *
@@ -108,37 +288,78 @@ class upb::Sink {
    *   // ...
    *   sink->EndMessage(&status);
    *   sink->EndSubMessage(endsubmsg_selector); */
-  bool StartMessage();
-  bool EndMessage(Status* status);
+  bool StartMessage() { return upb_sink_startmsg(sink_); }
+  bool EndMessage(upb_status *status) {
+    return upb_sink_endmsg(sink_, status);
+  }
 
   /* Putting of individual values.  These work for both repeated and
    * non-repeated fields, but for repeated fields you must wrap them in
    * calls to StartSequence()/EndSequence(). */
-  bool PutInt32(Handlers::Selector s, int32_t val);
-  bool PutInt64(Handlers::Selector s, int64_t val);
-  bool PutUInt32(Handlers::Selector s, uint32_t val);
-  bool PutUInt64(Handlers::Selector s, uint64_t val);
-  bool PutFloat(Handlers::Selector s, float val);
-  bool PutDouble(Handlers::Selector s, double val);
-  bool PutBool(Handlers::Selector s, bool val);
+  bool PutInt32(HandlersPtr::Selector s, int32_t val) {
+    return upb_sink_putint32(sink_, s, val);
+  }
+
+  bool PutInt64(HandlersPtr::Selector s, int64_t val) {
+    return upb_sink_putint64(sink_, s, val);
+  }
+
+  bool PutUInt32(HandlersPtr::Selector s, uint32_t val) {
+    return upb_sink_putuint32(sink_, s, val);
+  }
+
+  bool PutUInt64(HandlersPtr::Selector s, uint64_t val) {
+    return upb_sink_putuint64(sink_, s, val);
+  }
+
+  bool PutFloat(HandlersPtr::Selector s, float val) {
+    return upb_sink_putfloat(sink_, s, val);
+  }
+
+  bool PutDouble(HandlersPtr::Selector s, double val) {
+    return upb_sink_putdouble(sink_, s, val);
+  }
+
+  bool PutBool(HandlersPtr::Selector s, bool val) {
+    return upb_sink_putbool(sink_, s, val);
+  }
 
   /* Putting of string/bytes values.  Each string can consist of zero or more
    * non-contiguous buffers of data.
    *
    * For StartString(), the function will write a sink for the string to "sub."
    * The sub-sink must be used for any/all PutStringBuffer() calls. */
-  bool StartString(Handlers::Selector s, size_t size_hint, Sink* sub);
-  size_t PutStringBuffer(Handlers::Selector s, const char *buf, size_t len,
-                         const BufferHandle *handle);
-  bool EndString(Handlers::Selector s);
+  bool StartString(HandlersPtr::Selector s, size_t size_hint, Sink* sub) {
+    upb_sink sub_c;
+    bool ret = upb_sink_startstr(sink_, s, size_hint, &sub_c);
+    *sub = sub_c;
+    return ret;
+  }
+
+  size_t PutStringBuffer(HandlersPtr::Selector s, const char *buf, size_t len,
+                         const upb_bufhandle *handle) {
+    return upb_sink_putstring(sink_, s, buf, len, handle);
+  }
+
+  bool EndString(HandlersPtr::Selector s) {
+    return upb_sink_endstr(sink_, s);
+  }
 
   /* For submessage fields.
    *
    * For StartSubMessage(), the function will write a sink for the string to
    * "sub." The sub-sink must be used for any/all handlers called within the
    * submessage. */
-  bool StartSubMessage(Handlers::Selector s, Sink* sub);
-  bool EndSubMessage(Handlers::Selector s);
+  bool StartSubMessage(HandlersPtr::Selector s, Sink* sub) {
+    upb_sink sub_c;
+    bool ret = upb_sink_startsubmsg(sink_, s, &sub_c);
+    *sub = sub_c;
+    return ret;
+  }
+
+  bool EndSubMessage(HandlersPtr::Selector s) {
+    return upb_sink_endsubmsg(sink_, s);
+  }
 
   /* For repeated fields of any type, the sequence of values must be wrapped in
    * these calls.
@@ -146,388 +367,146 @@ class upb::Sink {
    * For StartSequence(), the function will write a sink for the string to
    * "sub." The sub-sink must be used for any/all handlers called within the
    * sequence. */
-  bool StartSequence(Handlers::Selector s, Sink* sub);
-  bool EndSequence(Handlers::Selector s);
+  bool StartSequence(HandlersPtr::Selector s, Sink* sub) {
+    upb_sink sub_c;
+    bool ret = upb_sink_startseq(sink_, s, &sub_c);
+    *sub = sub_c;
+    return ret;
+  }
+
+  bool EndSequence(HandlersPtr::Selector s) {
+    return upb_sink_endseq(sink_, s);
+  }
 
   /* Copy and assign specifically allowed.
    * We don't even bother making these members private because so many
    * functions need them and this is mainly just a dumb data container anyway.
    */
-#else
-struct upb_sink {
-#endif
-  const upb_handlers *handlers;
-  void *closure;
+
+ private:
+  upb_sink sink_;
 };
 
-#ifdef __cplusplus
-class upb::BytesSink {
- public:
-  BytesSink() {}
+#endif  /* __cplusplus */
 
-  /* Constructs a new sink for the given frozen handlers and closure.
-   *
-   * TODO(haberman): once the Handlers know the expected closure type, verify
-   * that T matches it. */
-  template <class T> BytesSink(const BytesHandler* handler, T* closure);
+/* upb_bytessink **************************************************************/
 
-  /* Resets the value of the sink. */
-  template <class T> void Reset(const BytesHandler* handler, T* closure);
-
-  bool Start(size_t size_hint, void **subc);
-  size_t PutBuffer(void *subc, const char *buf, size_t len,
-                   const BufferHandle *handle);
-  bool End();
-#else
-struct upb_bytessink {
-#endif
+typedef struct {
   const upb_byteshandler *handler;
   void *closure;
-};
-
-#ifdef __cplusplus
-
-/* A class for pushing a flat buffer of data to a BytesSink.
- * You can construct an instance of this to get a resumable source,
- * or just call the static PutBuffer() to do a non-resumable push all in one
- * go. */
-class upb::BufferSource {
- public:
-  BufferSource();
-  BufferSource(const char* buf, size_t len, BytesSink* sink);
-
-  /* Returns true if the entire buffer was pushed successfully.  Otherwise the
-   * next call to PutNext() will resume where the previous one left off.
-   * TODO(haberman): implement this. */
-  bool PutNext();
-
-  /* A static version; with this version is it not possible to resume in the
-   * case of failure or a partially-consumed buffer. */
-  static bool PutBuffer(const char* buf, size_t len, BytesSink* sink);
+} upb_bytessink ;
 
-  template <class T> static bool PutBuffer(const T& str, BytesSink* sink) {
-    return PutBuffer(str.c_str(), str.size(), sink);
-  }
-#else
-struct upb_bufsrc {
-  char dummy;
-#endif
-};
-
-UPB_BEGIN_EXTERN_C
-
-/* A class for accumulating output string data in a flat buffer. */
-
-upb_bufsink *upb_bufsink_new(upb_env *env);
-void upb_bufsink_free(upb_bufsink *sink);
-upb_bytessink *upb_bufsink_sink(upb_bufsink *sink);
-const char *upb_bufsink_getdata(const upb_bufsink *sink, size_t *len);
-
-/* Inline definitions. */
-
-UPB_INLINE void upb_bytessink_reset(upb_bytessink *s, const upb_byteshandler *h,
+UPB_INLINE void upb_bytessink_reset(upb_bytessink* s, const upb_byteshandler *h,
                                     void *closure) {
   s->handler = h;
   s->closure = closure;
 }
 
-UPB_INLINE bool upb_bytessink_start(upb_bytessink *s, size_t size_hint,
+UPB_INLINE bool upb_bytessink_start(upb_bytessink s, size_t size_hint,
                                     void **subc) {
   typedef upb_startstr_handlerfunc func;
   func *start;
-  *subc = s->closure;
-  if (!s->handler) return true;
-  start = (func *)s->handler->table[UPB_STARTSTR_SELECTOR].func;
+  *subc = s.closure;
+  if (!s.handler) return true;
+  start = (func *)s.handler->table[UPB_STARTSTR_SELECTOR].func;
 
   if (!start) return true;
-  *subc = start(s->closure, upb_handlerattr_handlerdata(
-                                &s->handler->table[UPB_STARTSTR_SELECTOR].attr),
+  *subc = start(s.closure,
+                s.handler->table[UPB_STARTSTR_SELECTOR].attr.handler_data,
                 size_hint);
   return *subc != NULL;
 }
 
-UPB_INLINE size_t upb_bytessink_putbuf(upb_bytessink *s, void *subc,
+UPB_INLINE size_t upb_bytessink_putbuf(upb_bytessink s, void *subc,
                                        const char *buf, size_t size,
                                        const upb_bufhandle* handle) {
   typedef upb_string_handlerfunc func;
   func *putbuf;
-  if (!s->handler) return true;
-  putbuf = (func *)s->handler->table[UPB_STRING_SELECTOR].func;
+  if (!s.handler) return true;
+  putbuf = (func *)s.handler->table[UPB_STRING_SELECTOR].func;
 
   if (!putbuf) return true;
-  return putbuf(subc, upb_handlerattr_handlerdata(
-                          &s->handler->table[UPB_STRING_SELECTOR].attr),
+  return putbuf(subc, s.handler->table[UPB_STRING_SELECTOR].attr.handler_data,
                 buf, size, handle);
 }
 
-UPB_INLINE bool upb_bytessink_end(upb_bytessink *s) {
+UPB_INLINE bool upb_bytessink_end(upb_bytessink s) {
   typedef upb_endfield_handlerfunc func;
   func *end;
-  if (!s->handler) return true;
-  end = (func *)s->handler->table[UPB_ENDSTR_SELECTOR].func;
+  if (!s.handler) return true;
+  end = (func *)s.handler->table[UPB_ENDSTR_SELECTOR].func;
 
   if (!end) return true;
-  return end(s->closure,
-             upb_handlerattr_handlerdata(
-                 &s->handler->table[UPB_ENDSTR_SELECTOR].attr));
+  return end(s.closure,
+             s.handler->table[UPB_ENDSTR_SELECTOR].attr.handler_data);
 }
 
-bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink *sink);
-
-#define PUTVAL(type, ctype)                                                    \
-  UPB_INLINE bool upb_sink_put##type(upb_sink *s, upb_selector_t sel,          \
-                                     ctype val) {                              \
-    typedef upb_##type##_handlerfunc functype;                                 \
-    functype *func;                                                            \
-    const void *hd;                                                            \
-    if (!s->handlers) return true;                                             \
-    func = (functype *)upb_handlers_gethandler(s->handlers, sel);              \
-    if (!func) return true;                                                    \
-    hd = upb_handlers_gethandlerdata(s->handlers, sel);                        \
-    return func(s->closure, hd, val);                                          \
-  }
-
-PUTVAL(int32,  int32_t)
-PUTVAL(int64,  int64_t)
-PUTVAL(uint32, uint32_t)
-PUTVAL(uint64, uint64_t)
-PUTVAL(float,  float)
-PUTVAL(double, double)
-PUTVAL(bool,   bool)
-#undef PUTVAL
-
-UPB_INLINE void upb_sink_reset(upb_sink *s, const upb_handlers *h, void *c) {
-  s->handlers = h;
-  s->closure = c;
-}
-
-UPB_INLINE size_t upb_sink_putstring(upb_sink *s, upb_selector_t sel,
-                                     const char *buf, size_t n,
-                                     const upb_bufhandle *handle) {
-  typedef upb_string_handlerfunc func;
-  func *handler;
-  const void *hd;
-  if (!s->handlers) return n;
-  handler = (func *)upb_handlers_gethandler(s->handlers, sel);
-
-  if (!handler) return n;
-  hd = upb_handlers_gethandlerdata(s->handlers, sel);
-  return handler(s->closure, hd, buf, n, handle);
-}
-
-UPB_INLINE bool upb_sink_putunknown(upb_sink *s, const char *buf, size_t n) {
-  typedef upb_unknown_handlerfunc func;
-  func *handler;
-  const void *hd;
-  if (!s->handlers) return true;
-  handler = (func *)upb_handlers_gethandler(s->handlers, UPB_UNKNOWN_SELECTOR);
-
-  if (!handler) return n;
-  hd = upb_handlers_gethandlerdata(s->handlers, UPB_UNKNOWN_SELECTOR);
-  return handler(s->closure, hd, buf, n);
-}
-
-UPB_INLINE bool upb_sink_startmsg(upb_sink *s) {
-  typedef upb_startmsg_handlerfunc func;
-  func *startmsg;
-  const void *hd;
-  if (!s->handlers) return true;
-  startmsg = (func*)upb_handlers_gethandler(s->handlers, UPB_STARTMSG_SELECTOR);
-
-  if (!startmsg) return true;
-  hd = upb_handlers_gethandlerdata(s->handlers, UPB_STARTMSG_SELECTOR);
-  return startmsg(s->closure, hd);
-}
-
-UPB_INLINE bool upb_sink_endmsg(upb_sink *s, upb_status *status) {
-  typedef upb_endmsg_handlerfunc func;
-  func *endmsg;
-  const void *hd;
-  if (!s->handlers) return true;
-  endmsg = (func *)upb_handlers_gethandler(s->handlers, UPB_ENDMSG_SELECTOR);
-
-  if (!endmsg) return true;
-  hd = upb_handlers_gethandlerdata(s->handlers, UPB_ENDMSG_SELECTOR);
-  return endmsg(s->closure, hd, status);
-}
-
-UPB_INLINE bool upb_sink_startseq(upb_sink *s, upb_selector_t sel,
-                                  upb_sink *sub) {
-  typedef upb_startfield_handlerfunc func;
-  func *startseq;
-  const void *hd;
-  sub->closure = s->closure;
-  sub->handlers = s->handlers;
-  if (!s->handlers) return true;
-  startseq = (func*)upb_handlers_gethandler(s->handlers, sel);
+#ifdef __cplusplus
 
-  if (!startseq) return true;
-  hd = upb_handlers_gethandlerdata(s->handlers, sel);
-  sub->closure = startseq(s->closure, hd);
-  return sub->closure ? true : false;
-}
+class upb::BytesSink {
+ public:
+  BytesSink() {}
 
-UPB_INLINE bool upb_sink_endseq(upb_sink *s, upb_selector_t sel) {
-  typedef upb_endfield_handlerfunc func;
-  func *endseq;
-  const void *hd;
-  if (!s->handlers) return true;
-  endseq = (func*)upb_handlers_gethandler(s->handlers, sel);
+  BytesSink(const BytesSink&) = default;
+  BytesSink& operator=(const BytesSink&) = default;
 
-  if (!endseq) return true;
-  hd = upb_handlers_gethandlerdata(s->handlers, sel);
-  return endseq(s->closure, hd);
-}
+  BytesSink(const upb_bytessink& sink) : sink_(sink) {}
+  BytesSink &operator=(const upb_bytessink &sink) {
+    sink_ = sink;
+    return *this;
+  }
 
-UPB_INLINE bool upb_sink_startstr(upb_sink *s, upb_selector_t sel,
-                                  size_t size_hint, upb_sink *sub) {
-  typedef upb_startstr_handlerfunc func;
-  func *startstr;
-  const void *hd;
-  sub->closure = s->closure;
-  sub->handlers = s->handlers;
-  if (!s->handlers) return true;
-  startstr = (func*)upb_handlers_gethandler(s->handlers, sel);
+  upb_bytessink sink() { return sink_; }
 
-  if (!startstr) return true;
-  hd = upb_handlers_gethandlerdata(s->handlers, sel);
-  sub->closure = startstr(s->closure, hd, size_hint);
-  return sub->closure ? true : false;
-}
+  /* Constructs a new sink for the given frozen handlers and closure.
+   *
+   * TODO(haberman): once the Handlers know the expected closure type, verify
+   * that T matches it. */
+  template <class T> BytesSink(const upb_byteshandler* handler, T* closure) {
+    upb_bytessink_reset(sink_, handler, closure);
+  }
 
-UPB_INLINE bool upb_sink_endstr(upb_sink *s, upb_selector_t sel) {
-  typedef upb_endfield_handlerfunc func;
-  func *endstr;
-  const void *hd;
-  if (!s->handlers) return true;
-  endstr = (func*)upb_handlers_gethandler(s->handlers, sel);
+  /* Resets the value of the sink. */
+  template <class T> void Reset(const upb_byteshandler* handler, T* closure) {
+    upb_bytessink_reset(&sink_, handler, closure);
+  }
 
-  if (!endstr) return true;
-  hd = upb_handlers_gethandlerdata(s->handlers, sel);
-  return endstr(s->closure, hd);
-}
+  bool Start(size_t size_hint, void **subc) {
+    return upb_bytessink_start(sink_, size_hint, subc);
+  }
 
-UPB_INLINE bool upb_sink_startsubmsg(upb_sink *s, upb_selector_t sel,
-                                     upb_sink *sub) {
-  typedef upb_startfield_handlerfunc func;
-  func *startsubmsg;
-  const void *hd;
-  sub->closure = s->closure;
-  if (!s->handlers) {
-    sub->handlers = NULL;
-    return true;
+  size_t PutBuffer(void *subc, const char *buf, size_t len,
+                   const upb_bufhandle *handle) {
+    return upb_bytessink_putbuf(sink_, subc, buf, len, handle);
   }
-  sub->handlers = upb_handlers_getsubhandlers_sel(s->handlers, sel);
-  startsubmsg = (func*)upb_handlers_gethandler(s->handlers, sel);
 
-  if (!startsubmsg) return true;
-  hd = upb_handlers_gethandlerdata(s->handlers, sel);
-  sub->closure = startsubmsg(s->closure, hd);
-  return sub->closure ? true : false;
-}
+  bool End() {
+    return upb_bytessink_end(sink_);
+  }
 
-UPB_INLINE bool upb_sink_endsubmsg(upb_sink *s, upb_selector_t sel) {
-  typedef upb_endfield_handlerfunc func;
-  func *endsubmsg;
-  const void *hd;
-  if (!s->handlers) return true;
-  endsubmsg = (func*)upb_handlers_gethandler(s->handlers, sel);
+ private:
+  upb_bytessink sink_;
+};
 
-  if (!endsubmsg) return s->closure;
-  hd = upb_handlers_gethandlerdata(s->handlers, sel);
-  return endsubmsg(s->closure, hd);
-}
+#endif  /* __cplusplus */
 
-UPB_END_EXTERN_C
+/* upb_bufsrc *****************************************************************/
 
 #ifdef __cplusplus
+extern "C" {
+#endif
 
-namespace upb {
-
-template <class T> Sink::Sink(const Handlers* handlers, T* closure) {
-  upb_sink_reset(this, handlers, closure);
-}
-template <class T>
-inline void Sink::Reset(const Handlers* handlers, T* closure) {
-  upb_sink_reset(this, handlers, closure);
-}
-inline bool Sink::StartMessage() {
-  return upb_sink_startmsg(this);
-}
-inline bool Sink::EndMessage(Status* status) {
-  return upb_sink_endmsg(this, status);
-}
-inline bool Sink::PutInt32(Handlers::Selector sel, int32_t val) {
-  return upb_sink_putint32(this, sel, val);
-}
-inline bool Sink::PutInt64(Handlers::Selector sel, int64_t val) {
-  return upb_sink_putint64(this, sel, val);
-}
-inline bool Sink::PutUInt32(Handlers::Selector sel, uint32_t val) {
-  return upb_sink_putuint32(this, sel, val);
-}
-inline bool Sink::PutUInt64(Handlers::Selector sel, uint64_t val) {
-  return upb_sink_putuint64(this, sel, val);
-}
-inline bool Sink::PutFloat(Handlers::Selector sel, float val) {
-  return upb_sink_putfloat(this, sel, val);
-}
-inline bool Sink::PutDouble(Handlers::Selector sel, double val) {
-  return upb_sink_putdouble(this, sel, val);
-}
-inline bool Sink::PutBool(Handlers::Selector sel, bool val) {
-  return upb_sink_putbool(this, sel, val);
-}
-inline bool Sink::StartString(Handlers::Selector sel, size_t size_hint,
-                              Sink *sub) {
-  return upb_sink_startstr(this, sel, size_hint, sub);
-}
-inline size_t Sink::PutStringBuffer(Handlers::Selector sel, const char *buf,
-                                    size_t len, const BufferHandle* handle) {
-  return upb_sink_putstring(this, sel, buf, len, handle);
-}
-inline bool Sink::EndString(Handlers::Selector sel) {
-  return upb_sink_endstr(this, sel);
-}
-inline bool Sink::StartSubMessage(Handlers::Selector sel, Sink* sub) {
-  return upb_sink_startsubmsg(this, sel, sub);
-}
-inline bool Sink::EndSubMessage(Handlers::Selector sel) {
-  return upb_sink_endsubmsg(this, sel);
-}
-inline bool Sink::StartSequence(Handlers::Selector sel, Sink* sub) {
-  return upb_sink_startseq(this, sel, sub);
-}
-inline bool Sink::EndSequence(Handlers::Selector sel) {
-  return upb_sink_endseq(this, sel);
-}
+bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink sink);
 
-template <class T>
-BytesSink::BytesSink(const BytesHandler* handler, T* closure) {
-  Reset(handler, closure);
-}
+#ifdef __cplusplus
+}  /* extern "C" */
 
-template <class T>
-void BytesSink::Reset(const BytesHandler *handler, T *closure) {
-  upb_bytessink_reset(this, handler, closure);
-}
-inline bool BytesSink::Start(size_t size_hint, void **subc) {
-  return upb_bytessink_start(this, size_hint, subc);
-}
-inline size_t BytesSink::PutBuffer(void *subc, const char *buf, size_t len,
-                                   const BufferHandle *handle) {
-  return upb_bytessink_putbuf(this, subc, buf, len, handle);
-}
-inline bool BytesSink::End() {
-  return upb_bytessink_end(this);
+namespace upb {
+template <class T> bool PutBuffer(const T& str, BytesSink sink) {
+  return upb_bufsrc_putbuf(str.data(), str.size(), sink.sink());
 }
-
-inline bool BufferSource::PutBuffer(const char *buf, size_t len,
-                                    BytesSink *sink) {
-  return upb_bufsrc_putbuf(buf, len, sink);
 }
 
-}  /* namespace upb */
-#endif
+#endif  /* __cplusplus */
 
 #endif
diff --git a/upb/structs.int.h b/upb/structs.int.h
index 1394dd4..ec7a4ae 100644
--- a/upb/structs.int.h
+++ b/upb/structs.int.h
@@ -5,8 +5,7 @@
 #ifndef UPB_STRUCTS_H_
 #define UPB_STRUCTS_H_
 
-#include "upb/def.h"
-#include "upb/msg.h"
+#include "upb/upb.h"
 
 struct upb_array {
   upb_fieldtype_t type;
diff --git a/upb/table.c b/upb/table.c
index 4239c6f..128f607 100644
--- a/upb/table.c
+++ b/upb/table.c
@@ -381,6 +381,7 @@ void upb_strtable_next(upb_strtable_iter *i) {
 }
 
 bool upb_strtable_done(const upb_strtable_iter *i) {
+  if (!i->t) return true;
   return i->index >= upb_table_size(&i->t->t) ||
          upb_tabent_isempty(str_tabent(i));
 }
@@ -403,6 +404,7 @@ upb_value upb_strtable_iter_value(const upb_strtable_iter *i) {
 }
 
 void upb_strtable_iter_setdone(upb_strtable_iter *i) {
+  i->t = NULL;
   i->index = SIZE_MAX;
 }
 
@@ -692,6 +694,7 @@ void upb_inttable_next(upb_inttable_iter *iter) {
 }
 
 bool upb_inttable_done(const upb_inttable_iter *i) {
+  if (!i->t) return true;
   if (i->array_part) {
     return i->index >= i->t->array_size ||
            !upb_arrhas(int_arrent(i));
@@ -714,6 +717,7 @@ upb_value upb_inttable_iter_value(const upb_inttable_iter *i) {
 }
 
 void upb_inttable_iter_setdone(upb_inttable_iter *i) {
+  i->t = NULL;
   i->index = SIZE_MAX;
   i->array_part = false;
 }
@@ -726,7 +730,7 @@ bool upb_inttable_iter_isequal(const upb_inttable_iter *i1,
          i1->array_part == i2->array_part;
 }
 
-#ifdef UPB_UNALIGNED_READS_OK
+#if defined(UPB_UNALIGNED_READS_OK) || defined(__s390x__)
 /* -----------------------------------------------------------------------------
  * MurmurHash2, by Austin Appleby (released as public domain).
  * Reformatted and C99-ified by Joshua Haberman.
diff --git a/upb/table.int.h b/upb/table.int.h
index 225235e..2b86390 100644
--- a/upb/table.int.h
+++ b/upb/table.int.h
@@ -156,21 +156,6 @@ UPB_INLINE upb_value upb_value_double(double cval) {
  * initializing a non-first union member. */
 typedef uintptr_t upb_tabkey;
 
-#define UPB_TABKEY_NUM(n) n
-#define UPB_TABKEY_NONE 0
-/* The preprocessor isn't quite powerful enough to turn the compile-time string
- * length into a byte-wise string representation, so code generation needs to
- * help it along.
- *
- * "len1" is the low byte and len4 is the high byte. */
-#ifdef UPB_BIG_ENDIAN
-#define UPB_TABKEY_STR(len1, len2, len3, len4, strval) \
-    (uintptr_t)(len4 len3 len2 len1 strval)
-#else
-#define UPB_TABKEY_STR(len1, len2, len3, len4, strval) \
-    (uintptr_t)(len1 len2 len3 len4 strval)
-#endif
-
 UPB_INLINE char *upb_tabstr(upb_tabkey key, uint32_t *len) {
   char* mem = (char*)key;
   if (len) memcpy(len, mem, sizeof(*len));
@@ -180,69 +165,11 @@ UPB_INLINE char *upb_tabstr(upb_tabkey key, uint32_t *len) {
 
 /* upb_tabval *****************************************************************/
 
-#ifdef __cplusplus
-
-/* Status initialization not supported.
- *
- * This separate definition is necessary because in C++, UINTPTR_MAX isn't
- * reliably available. */
 typedef struct {
   uint64_t val;
 } upb_tabval;
 
-#else
-
-/* C -- supports static initialization, but to support static initialization of
- * both integers and points for both 32 and 64 bit targets, it takes a little
- * bit of doing. */
-
-#if UINTPTR_MAX == 0xffffffffffffffffULL
-#define UPB_PTR_IS_64BITS
-#elif UINTPTR_MAX != 0xffffffff
-#error Could not determine how many bits pointers are.
-#endif
-
-typedef union {
-  /* For static initialization.
-   *
-   * Unfortunately this ugliness is necessary -- it is the only way that we can,
-   * with -std=c89 -pedantic, statically initialize this to either a pointer or
-   * an integer on 32-bit platforms. */
-  struct {
-#ifdef UPB_PTR_IS_64BITS
-    uintptr_t val;
-#else
-    uintptr_t val1;
-    uintptr_t val2;
-#endif
-  } staticinit;
-
-  /* The normal accessor that we use for everything at runtime. */
-  uint64_t val;
-} upb_tabval;
-
-#ifdef UPB_PTR_IS_64BITS
-#define UPB_TABVALUE_INT_INIT(v) {{v}}
-#define UPB_TABVALUE_EMPTY_INIT  {{-1}}
-#else
-
-/* 32-bit pointers */
-
-#ifdef UPB_BIG_ENDIAN
-#define UPB_TABVALUE_INT_INIT(v) {{0, v}}
-#define UPB_TABVALUE_EMPTY_INIT  {{-1, -1}}
-#else
-#define UPB_TABVALUE_INT_INIT(v) {{v, 0}}
-#define UPB_TABVALUE_EMPTY_INIT  {{-1, -1}}
-#endif
-
-#endif
-
-#define UPB_TABVALUE_PTR_INIT(v) UPB_TABVALUE_INT_INIT((uintptr_t)v)
-
-#undef UPB_PTR_IS_64BITS
-
-#endif  /* __cplusplus */
+#define UPB_TABVALUE_EMPTY_INIT  {-1}
 
 
 /* upb_table ******************************************************************/
@@ -284,31 +211,10 @@ typedef struct {
 #endif
 } upb_table;
 
-#ifdef NDEBUG
-#  define UPB_TABLE_INIT(count, mask, ctype, size_lg2, entries) \
-     {count, mask, ctype, size_lg2, entries}
-#else
-#  ifdef UPB_DEBUG_REFS
-/* At the moment the only mutable tables we statically initialize are debug
- * ref tables. */
-#    define UPB_TABLE_INIT(count, mask, ctype, size_lg2, entries) \
-       {count, mask, ctype, size_lg2, entries, &upb_alloc_debugrefs}
-#  else
-#    define UPB_TABLE_INIT(count, mask, ctype, size_lg2, entries) \
-       {count, mask, ctype, size_lg2, entries, NULL}
-#  endif
-#endif
-
 typedef struct {
   upb_table t;
 } upb_strtable;
 
-#define UPB_STRTABLE_INIT(count, mask, ctype, size_lg2, entries) \
-  {UPB_TABLE_INIT(count, mask, ctype, size_lg2, entries)}
-
-#define UPB_EMPTY_STRTABLE_INIT(ctype)                           \
-  UPB_STRTABLE_INIT(0, 0, ctype, 0, NULL)
-
 typedef struct {
   upb_table t;              /* For entries that don't fit in the array part. */
   const upb_tabval *array;  /* Array part of the table. See const note above. */
diff --git a/upb/upb.c b/upb/upb.c
index 97f6c61..0cf5b50 100644
--- a/upb/upb.c
+++ b/upb/upb.c
@@ -8,12 +8,6 @@
 #include <string.h>
 #include "upb/upb.h"
 
-bool upb_dumptostderr(void *closure, const upb_status* status) {
-  UPB_UNUSED(closure);
-  fprintf(stderr, "%s\n", upb_status_errmsg(status));
-  return false;
-}
-
 /* Guarantee null-termination and provide ellipsis truncation.
  * It may be tempting to "optimize" this by initializing these final
  * four bytes up-front and then being careful never to overwrite them,
@@ -25,39 +19,21 @@ static void nullz(upb_status *status) {
   memcpy(status->msg + sizeof(status->msg) - len, ellipsis, len);
 }
 
-
-/* upb_upberr *****************************************************************/
-
-upb_errorspace upb_upberr = {"upb error"};
-
-void upb_upberr_setoom(upb_status *status) {
-  status->error_space_ = &upb_upberr;
-  upb_status_seterrmsg(status, "Out of memory");
-}
-
-
 /* upb_status *****************************************************************/
 
 void upb_status_clear(upb_status *status) {
   if (!status) return;
-  status->ok_ = true;
-  status->code_ = 0;
+  status->ok = true;
   status->msg[0] = '\0';
 }
 
-bool upb_ok(const upb_status *status) { return status->ok_; }
-
-upb_errorspace *upb_status_errspace(const upb_status *status) {
-  return status->error_space_;
-}
-
-int upb_status_errcode(const upb_status *status) { return status->code_; }
+bool upb_ok(const upb_status *status) { return status->ok; }
 
 const char *upb_status_errmsg(const upb_status *status) { return status->msg; }
 
 void upb_status_seterrmsg(upb_status *status, const char *msg) {
   if (!status) return;
-  status->ok_ = false;
+  status->ok = false;
   strncpy(status->msg, msg, sizeof(status->msg));
   nullz(status);
 }
@@ -71,17 +47,11 @@ void upb_status_seterrf(upb_status *status, const char *fmt, ...) {
 
 void upb_status_vseterrf(upb_status *status, const char *fmt, va_list args) {
   if (!status) return;
-  status->ok_ = false;
+  status->ok = false;
   _upb_vsnprintf(status->msg, sizeof(status->msg), fmt, args);
   nullz(status);
 }
 
-void upb_status_copy(upb_status *to, const upb_status *from) {
-  if (!to) return;
-  *to = *from;
-}
-
-
 /* upb_alloc ******************************************************************/
 
 static void *upb_global_allocfunc(upb_alloc *alloc, void *ptr, size_t oldsize,
@@ -98,7 +68,6 @@ static void *upb_global_allocfunc(upb_alloc *alloc, void *ptr, size_t oldsize,
 
 upb_alloc upb_alloc_global = {&upb_global_allocfunc};
 
-
 /* upb_arena ******************************************************************/
 
 /* Be conservative and choose 16 in case anyone is using SSE. */
@@ -108,6 +77,26 @@ static size_t align_up_max(size_t size) {
   return ((size + maxalign - 1) / maxalign) * maxalign;
 }
 
+struct upb_arena {
+  /* We implement the allocator interface.
+   * This must be the first member of upb_arena! */
+  upb_alloc alloc;
+
+  /* Allocator to allocate arena blocks.  We are responsible for freeing these
+   * when we are destroyed. */
+  upb_alloc *block_alloc;
+
+  size_t bytes_allocated;
+  size_t next_block_size;
+  size_t max_block_size;
+
+  /* Linked list of blocks.  Points to an arena_block, defined in env.c */
+  void *block_head;
+
+  /* Cleanup entries.  Pointer to a cleanup_ent, defined in env.c */
+  void *cleanup_head;
+};
+
 typedef struct mem_block {
   struct mem_block *next;
   size_t size;
@@ -136,7 +125,6 @@ static void upb_arena_addblock(upb_arena *a, void *ptr, size_t size,
   /* TODO(haberman): ASAN poison. */
 }
 
-
 static mem_block *upb_arena_allocblock(upb_arena *a, size_t size) {
   size_t block_size = UPB_MAX(size, a->next_block_size) + sizeof(mem_block);
   mem_block *block = upb_malloc(a->block_alloc, block_size);
@@ -189,7 +177,29 @@ static void *upb_arena_doalloc(upb_alloc *alloc, void *ptr, size_t oldsize,
 
 /* Public Arena API ***********************************************************/
 
-void upb_arena_init(upb_arena *a) {
+#define upb_alignof(type) offsetof (struct { char c; type member; }, member)
+
+upb_arena *upb_arena_init(void *mem, size_t n, upb_alloc *alloc) {
+  const size_t first_block_overhead = sizeof(upb_arena) + sizeof(mem_block);
+  upb_arena *a;
+  bool owned = false;
+
+  /* Round block size down to alignof(*a) since we will allocate the arena
+   * itself at the end. */
+  n &= ~(upb_alignof(upb_arena) - 1);
+
+  if (n < first_block_overhead) {
+    /* We need to malloc the initial block. */
+    n = first_block_overhead + 256;
+    owned = true;
+    if (!alloc || !(mem = upb_malloc(alloc, n))) {
+      return NULL;
+    }
+  }
+
+  a = (void*)((char*)mem + n - sizeof(*a));
+  n -= sizeof(*a);
+
   a->alloc.func = &upb_arena_doalloc;
   a->block_alloc = &upb_alloc_global;
   a->bytes_allocated = 0;
@@ -197,21 +207,16 @@ void upb_arena_init(upb_arena *a) {
   a->max_block_size = 16384;
   a->cleanup_head = NULL;
   a->block_head = NULL;
-}
-
-void upb_arena_init2(upb_arena *a, void *mem, size_t size, upb_alloc *alloc) {
-  upb_arena_init(a);
+  a->block_alloc = alloc;
 
-  if (size > sizeof(mem_block)) {
-    upb_arena_addblock(a, mem, size, false);
-  }
+  upb_arena_addblock(a, mem, n, owned);
 
-  if (alloc) {
-    a->block_alloc = alloc;
-  }
+  return a;
 }
 
-void upb_arena_uninit(upb_arena *a) {
+#undef upb_alignof
+
+void upb_arena_free(upb_arena *a) {
   cleanup_ent *ent = a->cleanup_head;
   mem_block *block = a->block_head;
 
@@ -223,6 +228,7 @@ void upb_arena_uninit(upb_arena *a) {
   /* Must do this after running cleanup functions, because this will delete
    * the memory we store our cleanup entries in! */
   while (block) {
+    /* Load first since we are deleting block. */
     mem_block *next = block->next;
 
     if (block->owned) {
@@ -231,13 +237,9 @@ void upb_arena_uninit(upb_arena *a) {
 
     block = next;
   }
-
-  /* Protect against multiple-uninit. */
-  a->cleanup_head = NULL;
-  a->block_head = NULL;
 }
 
-bool upb_arena_addcleanup(upb_arena *a, upb_cleanup_func *func, void *ud) {
+bool upb_arena_addcleanup(upb_arena *a, void *ud, upb_cleanup_func *func) {
   cleanup_ent *ent = upb_malloc(&a->alloc, sizeof(cleanup_ent));
   if (!ent) {
     return false;  /* Out of memory. */
@@ -254,76 +256,3 @@ bool upb_arena_addcleanup(upb_arena *a, upb_cleanup_func *func, void *ud) {
 size_t upb_arena_bytesallocated(const upb_arena *a) {
   return a->bytes_allocated;
 }
-
-
-/* Standard error functions ***************************************************/
-
-static bool default_err(void *ud, const upb_status *status) {
-  UPB_UNUSED(ud);
-  UPB_UNUSED(status);
-  return false;
-}
-
-static bool write_err_to(void *ud, const upb_status *status) {
-  upb_status *copy_to = ud;
-  upb_status_copy(copy_to, status);
-  return false;
-}
-
-
-/* upb_env ********************************************************************/
-
-void upb_env_initonly(upb_env *e) {
-  e->ok_ = true;
-  e->error_func_ = &default_err;
-  e->error_ud_ = NULL;
-}
-
-void upb_env_init(upb_env *e) {
-  upb_arena_init(&e->arena_);
-  upb_env_initonly(e);
-}
-
-void upb_env_init2(upb_env *e, void *mem, size_t n, upb_alloc *alloc) {
-  upb_arena_init2(&e->arena_, mem, n, alloc);
-  upb_env_initonly(e);
-}
-
-void upb_env_uninit(upb_env *e) {
-  upb_arena_uninit(&e->arena_);
-}
-
-void upb_env_seterrorfunc(upb_env *e, upb_error_func *func, void *ud) {
-  e->error_func_ = func;
-  e->error_ud_ = ud;
-}
-
-void upb_env_reporterrorsto(upb_env *e, upb_status *s) {
-  e->error_func_ = &write_err_to;
-  e->error_ud_ = s;
-}
-
-bool upb_env_reporterror(upb_env *e, const upb_status *status) {
-  e->ok_ = false;
-  return e->error_func_(e->error_ud_, status);
-}
-
-void *upb_env_malloc(upb_env *e, size_t size) {
-  return upb_malloc(&e->arena_.alloc, size);
-}
-
-void *upb_env_realloc(upb_env *e, void *ptr, size_t oldsize, size_t size) {
-  return upb_realloc(&e->arena_.alloc, ptr, oldsize, size);
-}
-
-void upb_env_free(upb_env *e, void *ptr) {
-  upb_free(&e->arena_.alloc, ptr);
-}
-
-bool upb_env_addcleanup(upb_env *e, upb_cleanup_func *func, void *ud) {
-  return upb_arena_addcleanup(&e->arena_, func, ud);
-}
-
-size_t upb_env_bytesallocated(const upb_env *e) {
-  return upb_arena_bytesallocated(&e->arena_);
-}
diff --git a/upb/upb.h b/upb/upb.h
index 2d6db8e..92db893 100644
--- a/upb/upb.h
+++ b/upb/upb.h
@@ -12,16 +12,14 @@
 #include <stdarg.h>
 #include <stdbool.h>
 #include <stddef.h>
+#include <stdint.h>
 
 #ifdef __cplusplus
+#include <memory>
 namespace upb {
-class Allocator;
 class Arena;
-class Environment;
-class ErrorSpace;
 class Status;
 template <int N> class InlinedArena;
-template <int N> class InlinedEnvironment;
 }
 #endif
 
@@ -73,128 +71,15 @@ template <int N> class InlinedEnvironment;
 #error Need implementations of [v]snprintf and va_copy
 #endif
 
-
-#if ((defined(__cplusplus) && __cplusplus >= 201103L) || \
-      defined(__GXX_EXPERIMENTAL_CXX0X__)) && !defined(UPB_NO_CXX11)
-#define UPB_CXX11
+#ifdef __cplusplus
+#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__) || \
+    (defined(_MSC_VER) && _MSC_VER >= 1900)
+// C++11 is present
+#else
+#error upb requires C++11 for C++ support
 #endif
-
-/* UPB_DISALLOW_COPY_AND_ASSIGN()
- * UPB_DISALLOW_POD_OPS()
- *
- * Declare these in the "private" section of a C++ class to forbid copy/assign
- * or all POD ops (construct, destruct, copy, assign) on that class. */
-#ifdef UPB_CXX11
-#include <type_traits>
-#define UPB_DISALLOW_COPY_AND_ASSIGN(class_name) \
-  class_name(const class_name&) = delete; \
-  void operator=(const class_name&) = delete;
-#define UPB_DISALLOW_POD_OPS(class_name, full_class_name) \
-  class_name() = delete; \
-  ~class_name() = delete; \
-  UPB_DISALLOW_COPY_AND_ASSIGN(class_name)
-#define UPB_ASSERT_STDLAYOUT(type) \
-  static_assert(std::is_standard_layout<type>::value, \
-                #type " must be standard layout");
-#define UPB_FINAL final
-#else  /* !defined(UPB_CXX11) */
-#define UPB_DISALLOW_COPY_AND_ASSIGN(class_name) \
-  class_name(const class_name&); \
-  void operator=(const class_name&);
-#define UPB_DISALLOW_POD_OPS(class_name, full_class_name) \
-  class_name(); \
-  ~class_name(); \
-  UPB_DISALLOW_COPY_AND_ASSIGN(class_name)
-#define UPB_ASSERT_STDLAYOUT(type)
-#define UPB_FINAL
 #endif
 
-/* UPB_DECLARE_TYPE()
- * UPB_DECLARE_DERIVED_TYPE()
- * UPB_DECLARE_DERIVED_TYPE2()
- *
- * Macros for declaring C and C++ types both, including inheritance.
- * The inheritance doesn't use real C++ inheritance, to stay compatible with C.
- *
- * These macros also provide upcasts:
- *  - in C: types-specific functions (ie. upb_foo_upcast(foo))
- *  - in C++: upb::upcast(foo) along with implicit conversions
- *
- * Downcasts are not provided, but upb/def.h defines downcasts for upb::Def. */
-
-#define UPB_C_UPCASTS(ty, base)                                      \
-  UPB_INLINE base *ty ## _upcast_mutable(ty *p) { return (base*)p; } \
-  UPB_INLINE const base *ty ## _upcast(const ty *p) { return (const base*)p; }
-
-#define UPB_C_UPCASTS2(ty, base, base2)                                 \
-  UPB_C_UPCASTS(ty, base)                                               \
-  UPB_INLINE base2 *ty ## _upcast2_mutable(ty *p) { return (base2*)p; } \
-  UPB_INLINE const base2 *ty ## _upcast2(const ty *p) { return (const base2*)p; }
-
-#ifdef __cplusplus
-
-#define UPB_BEGIN_EXTERN_C extern "C" {
-#define UPB_END_EXTERN_C }
-#define UPB_PRIVATE_FOR_CPP private:
-#define UPB_DECLARE_TYPE(cppname, cname) typedef cppname cname;
-
-#define UPB_DECLARE_DERIVED_TYPE(cppname, cppbase, cname, cbase)  \
-  UPB_DECLARE_TYPE(cppname, cname)                                \
-  UPB_C_UPCASTS(cname, cbase)                                     \
-  namespace upb {                                                 \
-  template <>                                                     \
-  class Pointer<cppname> : public PointerBase<cppname, cppbase> { \
-   public:                                                        \
-    explicit Pointer(cppname* ptr)                                \
-        : PointerBase<cppname, cppbase>(ptr) {}                   \
-  };                                                              \
-  template <>                                                     \
-  class Pointer<const cppname>                                    \
-      : public PointerBase<const cppname, const cppbase> {        \
-   public:                                                        \
-    explicit Pointer(const cppname* ptr)                          \
-        : PointerBase<const cppname, const cppbase>(ptr) {}       \
-  };                                                              \
-  }
-
-#define UPB_DECLARE_DERIVED_TYPE2(cppname, cppbase, cppbase2, cname, cbase,  \
-                                  cbase2)                                    \
-  UPB_DECLARE_TYPE(cppname, cname)                                           \
-  UPB_C_UPCASTS2(cname, cbase, cbase2)                                       \
-  namespace upb {                                                            \
-  template <>                                                                \
-  class Pointer<cppname> : public PointerBase2<cppname, cppbase, cppbase2> { \
-   public:                                                                   \
-    explicit Pointer(cppname* ptr)                                           \
-        : PointerBase2<cppname, cppbase, cppbase2>(ptr) {}                   \
-  };                                                                         \
-  template <>                                                                \
-  class Pointer<const cppname>                                               \
-      : public PointerBase2<const cppname, const cppbase, const cppbase2> {  \
-   public:                                                                   \
-    explicit Pointer(const cppname* ptr)                                     \
-        : PointerBase2<const cppname, const cppbase, const cppbase2>(ptr) {} \
-  };                                                                         \
-  }
-
-#else  /* !defined(__cplusplus) */
-
-#define UPB_BEGIN_EXTERN_C
-#define UPB_END_EXTERN_C
-#define UPB_PRIVATE_FOR_CPP
-#define UPB_DECLARE_TYPE(cppname, cname) \
-  struct cname;                          \
-  typedef struct cname cname;
-#define UPB_DECLARE_DERIVED_TYPE(cppname, cppbase, cname, cbase) \
-  UPB_DECLARE_TYPE(cppname, cname)                               \
-  UPB_C_UPCASTS(cname, cbase)
-#define UPB_DECLARE_DERIVED_TYPE2(cppname, cppbase, cppbase2,    \
-                                  cname, cbase, cbase2)          \
-  UPB_DECLARE_TYPE(cppname, cname)                               \
-  UPB_C_UPCASTS2(cname, cbase, cbase2)
-
-#endif  /* defined(__cplusplus) */
-
 #define UPB_MAX(x, y) ((x) > (y) ? (x) : (y))
 #define UPB_MIN(x, y) ((x) < (y) ? (x) : (y))
 
@@ -218,135 +103,26 @@ template <int N> class InlinedEnvironment;
 #define UPB_UNREACHABLE() do { assert(0); } while(0)
 #endif
 
-/* Generic function type. */
-typedef void upb_func();
-
-
-/* C++ Casts ******************************************************************/
-
-#ifdef __cplusplus
-
-namespace upb {
-
-template <class T> class Pointer;
-
-/* Casts to a subclass.  The caller must know that cast is correct; an
- * incorrect cast will throw an assertion failure in debug mode.
- *
- * Example:
- *   upb::Def* def = GetDef();
- *   // Assert-fails if this was not actually a MessageDef.
- *   upb::MessgeDef* md = upb::down_cast<upb::MessageDef>(def);
- *
- * Note that downcasts are only defined for some types (at the moment you can
- * only downcast from a upb::Def to a specific Def type). */
-template<class To, class From> To down_cast(From* f);
-
-/* Casts to a subclass.  If the class does not actually match the given To type,
- * returns NULL.
- *
- * Example:
- *   upb::Def* def = GetDef();
- *   // md will be NULL if this was not actually a MessageDef.
- *   upb::MessgeDef* md = upb::down_cast<upb::MessageDef>(def);
- *
- * Note that dynamic casts are only defined for some types (at the moment you
- * can only downcast from a upb::Def to a specific Def type).. */
-template<class To, class From> To dyn_cast(From* f);
-
-/* Casts to any base class, or the type itself (ie. can be a no-op).
- *
- * Example:
- *   upb::MessageDef* md = GetDef();
- *   // This will fail to compile if this wasn't actually a base class.
- *   upb::Def* def = upb::upcast(md);
- */
-template <class T> inline Pointer<T> upcast(T *f) { return Pointer<T>(f); }
-
-/* Attempt upcast to specific base class.
- *
- * Example:
- *   upb::MessageDef* md = GetDef();
- *   upb::upcast_to<upb::Def>(md)->MethodOnDef();
- */
-template <class T, class F> inline T* upcast_to(F *f) {
-  return static_cast<T*>(upcast(f));
-}
-
-/* PointerBase<T>: implementation detail of upb::upcast().
- * It is implicitly convertable to pointers to the Base class(es).
- */
-template <class T, class Base>
-class PointerBase {
- public:
-  explicit PointerBase(T* ptr) : ptr_(ptr) {}
-  operator T*() { return ptr_; }
-  operator Base*() { return (Base*)ptr_; }
-
- private:
-  T* ptr_;
-};
-
-template <class T, class Base, class Base2>
-class PointerBase2 : public PointerBase<T, Base> {
- public:
-  explicit PointerBase2(T* ptr) : PointerBase<T, Base>(ptr) {}
-  operator Base2*() { return Pointer<Base>(*this); }
-};
-
-}
-
-#endif
-
-/* A list of types as they are encoded on-the-wire. */
-typedef enum {
-  UPB_WIRE_TYPE_VARINT      = 0,
-  UPB_WIRE_TYPE_64BIT       = 1,
-  UPB_WIRE_TYPE_DELIMITED   = 2,
-  UPB_WIRE_TYPE_START_GROUP = 3,
-  UPB_WIRE_TYPE_END_GROUP   = 4,
-  UPB_WIRE_TYPE_32BIT       = 5
-} upb_wiretype_t;
-
-
-/* upb::ErrorSpace ************************************************************/
-
-/* A upb::ErrorSpace represents some domain of possible error values.  This lets
- * upb::Status attach specific error codes to operations, like POSIX/C errno,
- * Win32 error codes, etc.  Clients who want to know the very specific error
- * code can check the error space and then know the type of the integer code.
- *
- * NOTE: upb::ErrorSpace is currently not used and should be considered
- * experimental.  It is important primarily in cases where upb is performing
- * I/O, but upb doesn't currently have any components that do this. */
-
-UPB_DECLARE_TYPE(upb::ErrorSpace, upb_errorspace)
-
-#ifdef __cplusplus
-class upb::ErrorSpace {
-#else
-struct upb_errorspace {
-#endif
-  const char *name;
-};
-
-
-/* upb::Status ****************************************************************/
+/* upb_status *****************************************************************/
 
-/* upb::Status represents a success or failure status and error message.
+/* upb_status represents a success or failure status and error message.
  * It owns no resources and allocates no memory, so it should work
  * even in OOM situations. */
-UPB_DECLARE_TYPE(upb::Status, upb_status)
 
 /* The maximum length of an error message before it will get truncated. */
-#define UPB_STATUS_MAX_MESSAGE 128
+#define UPB_STATUS_MAX_MESSAGE 127
+
+typedef struct {
+  bool ok;
+  char msg[UPB_STATUS_MAX_MESSAGE];  /* Error message; NULL-terminated. */
+} upb_status;
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 const char *upb_status_errmsg(const upb_status *status);
 bool upb_ok(const upb_status *status);
-upb_errorspace *upb_status_errspace(const upb_status *status);
-int upb_status_errcode(const upb_status *status);
 
 /* Any of the functions that write to a status object allow status to be NULL,
  * to support use cases where the function's caller does not care about the
@@ -355,88 +131,55 @@ void upb_status_clear(upb_status *status);
 void upb_status_seterrmsg(upb_status *status, const char *msg);
 void upb_status_seterrf(upb_status *status, const char *fmt, ...);
 void upb_status_vseterrf(upb_status *status, const char *fmt, va_list args);
-void upb_status_copy(upb_status *to, const upb_status *from);
 
-UPB_END_EXTERN_C
+UPB_INLINE void upb_status_setoom(upb_status *status) {
+  upb_status_seterrmsg(status, "out of memory");
+}
 
 #ifdef __cplusplus
+}  /* extern "C" */
 
 class upb::Status {
  public:
-  Status() { upb_status_clear(this); }
+  Status() { upb_status_clear(&status_); }
 
-  /* Returns true if there is no error. */
-  bool ok() const { return upb_ok(this); }
+  upb_status* ptr() { return &status_; }
 
-  /* Optional error space and code, useful if the caller wants to
-   * programmatically check the specific kind of error. */
-  ErrorSpace* error_space() { return upb_status_errspace(this); }
-  int error_code() const { return upb_status_errcode(this); }
+  /* Returns true if there is no error. */
+  bool ok() const { return upb_ok(&status_); }
 
-  /* The returned string is invalidated by any other call into the status. */
-  const char *error_message() const { return upb_status_errmsg(this); }
+  /* Guaranteed to be NULL-terminated. */
+  const char *error_message() const { return upb_status_errmsg(&status_); }
 
   /* The error message will be truncated if it is longer than
    * UPB_STATUS_MAX_MESSAGE-4. */
-  void SetErrorMessage(const char* msg) { upb_status_seterrmsg(this, msg); }
-  void SetFormattedErrorMessage(const char* fmt, ...) {
+  void SetErrorMessage(const char *msg) { upb_status_seterrmsg(&status_, msg); }
+  void SetFormattedErrorMessage(const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    upb_status_vseterrf(this, fmt, args);
+    upb_status_vseterrf(&status_, fmt, args);
     va_end(args);
   }
 
   /* Resets the status to a successful state with no message. */
-  void Clear() { upb_status_clear(this); }
-
-  void CopyFrom(const Status& other) { upb_status_copy(this, &other); }
+  void Clear() { upb_status_clear(&status_); }
 
  private:
-  UPB_DISALLOW_COPY_AND_ASSIGN(Status)
-#else
-struct upb_status {
-#endif
-  bool ok_;
-
-  /* Specific status code defined by some error space (optional). */
-  int code_;
-  upb_errorspace *error_space_;
-
-  /* TODO(haberman): add file/line of error? */
-
-  /* Error message; NULL-terminated. */
-  char msg[UPB_STATUS_MAX_MESSAGE];
+  upb_status status_;
 };
 
-#define UPB_STATUS_INIT {true, 0, NULL, {0}}
-
-
-/** Built-in error spaces. ****************************************************/
-
-/* Errors raised by upb that we want to be able to detect programmatically. */
-typedef enum {
-  UPB_NOMEM   /* Can't reuse ENOMEM because it is POSIX, not ISO C. */
-} upb_errcode_t;
-
-extern upb_errorspace upb_upberr;
-
-void upb_upberr_setoom(upb_status *s);
-
-/* Since errno is defined by standard C, we define an error space for it in
- * core upb.  Other error spaces should be defined in other, platform-specific
- * modules. */
-
-extern upb_errorspace upb_errnoerr;
-
+#endif  /* __cplusplus */
 
-/** upb::Allocator ************************************************************/
+/** upb_alloc *****************************************************************/
 
-/* A upb::Allocator is a possibly-stateful allocator object.
+/* A upb_alloc is a possibly-stateful allocator object.
  *
  * It could either be an arena allocator (which doesn't require individual
  * free() calls) or a regular malloc() (which does).  The client must therefore
  * free memory unless it knows that the allocator is an arena allocator. */
-UPB_DECLARE_TYPE(upb::Allocator, upb_alloc)
+
+struct upb_alloc;
+typedef struct upb_alloc upb_alloc;
 
 /* A malloc()/free() function.
  * If "size" is 0 then the function acts like free(), otherwise it acts like
@@ -444,19 +187,7 @@ UPB_DECLARE_TYPE(upb::Allocator, upb_alloc)
 typedef void *upb_alloc_func(upb_alloc *alloc, void *ptr, size_t oldsize,
                              size_t size);
 
-#ifdef __cplusplus
-
-class upb::Allocator UPB_FINAL {
- public:
-  Allocator() {}
-
- private:
-  UPB_DISALLOW_COPY_AND_ASSIGN(Allocator)
-
- public:
-#else
 struct upb_alloc {
-#endif  /* __cplusplus */
   upb_alloc_func *func;
 };
 
@@ -497,212 +228,91 @@ UPB_INLINE void upb_gfree(void *ptr) {
   upb_free(&upb_alloc_global, ptr);
 }
 
-/* upb::Arena *****************************************************************/
+/* upb_arena ******************************************************************/
 
-/* upb::Arena is a specific allocator implementation that uses arena allocation.
+/* upb_arena is a specific allocator implementation that uses arena allocation.
  * The user provides an allocator that will be used to allocate the underlying
  * arena blocks.  Arenas by nature do not require the individual allocations
  * to be freed.  However the Arena does allow users to register cleanup
  * functions that will run when the arena is destroyed.
  *
- * A upb::Arena is *not* thread-safe.
+ * A upb_arena is *not* thread-safe.
  *
  * You could write a thread-safe arena allocator that satisfies the
- * upb::Allocator interface, but it would not be as efficient for the
+ * upb_alloc interface, but it would not be as efficient for the
  * single-threaded case. */
-UPB_DECLARE_TYPE(upb::Arena, upb_arena)
 
 typedef void upb_cleanup_func(void *ud);
 
-#define UPB_ARENA_BLOCK_OVERHEAD (sizeof(size_t)*4)
+struct upb_arena;
+typedef struct upb_arena upb_arena;
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-void upb_arena_init(upb_arena *a);
-void upb_arena_init2(upb_arena *a, void *mem, size_t n, upb_alloc *alloc);
-void upb_arena_uninit(upb_arena *a);
-bool upb_arena_addcleanup(upb_arena *a, upb_cleanup_func *func, void *ud);
+/* Creates an arena from the given initial block (if any -- n may be 0).
+ * Additional blocks will be allocated from |alloc|.  If |alloc| is NULL, this
+ * is a fixed-size arena and cannot grow. */
+upb_arena *upb_arena_init(void *mem, size_t n, upb_alloc *alloc);
+void upb_arena_free(upb_arena *a);
+bool upb_arena_addcleanup(upb_arena *a, void *ud, upb_cleanup_func *func);
 size_t upb_arena_bytesallocated(const upb_arena *a);
-void upb_arena_setnextblocksize(upb_arena *a, size_t size);
-void upb_arena_setmaxblocksize(upb_arena *a, size_t size);
+
 UPB_INLINE upb_alloc *upb_arena_alloc(upb_arena *a) { return (upb_alloc*)a; }
 
-UPB_END_EXTERN_C
+/* Convenience wrappers around upb_alloc functions. */
+
+UPB_INLINE void *upb_arena_malloc(upb_arena *a, size_t size) {
+  return upb_malloc(upb_arena_alloc(a), size);
+}
+
+UPB_INLINE void *upb_arena_realloc(upb_arena *a, void *ptr, size_t oldsize,
+                                   size_t size) {
+  return upb_realloc(upb_arena_alloc(a), ptr, oldsize, size);
+}
+
+UPB_INLINE upb_arena *upb_arena_new() {
+  return upb_arena_init(NULL, 0, &upb_alloc_global);
+}
 
 #ifdef __cplusplus
+}  /* extern "C" */
 
 class upb::Arena {
  public:
   /* A simple arena with no initial memory block and the default allocator. */
-  Arena() { upb_arena_init(this); }
-
-  /* Constructs an arena with the given initial block which allocates blocks
-   * with the given allocator.  The given allocator must outlive the Arena.
-   *
-   * If you pass NULL for the allocator it will default to the global allocator
-   * upb_alloc_global, and NULL/0 for the initial block will cause there to be
-   * no initial block. */
-  Arena(void *mem, size_t len, Allocator* a) {
-    upb_arena_init2(this, mem, len, a);
-  }
+  Arena() : ptr_(upb_arena_new(), upb_arena_free) {}
 
-  ~Arena() { upb_arena_uninit(this); }
-
-  /* Sets the size of the next block the Arena will request (unless the
-   * requested allocation is larger).  Each block will double in size until the
-   * max limit is reached. */
-  void SetNextBlockSize(size_t size) { upb_arena_setnextblocksize(this, size); }
-
-  /* Sets the maximum block size.  No blocks larger than this will be requested
-   * from the underlying allocator unless individual arena allocations are
-   * larger. */
-  void SetMaxBlockSize(size_t size) { upb_arena_setmaxblocksize(this, size); }
+  upb_arena* ptr() { return ptr_.get(); }
 
   /* Allows this arena to be used as a generic allocator.
    *
    * The arena does not need free() calls so when using Arena as an allocator
    * it is safe to skip them.  However they are no-ops so there is no harm in
    * calling free() either. */
-  Allocator* allocator() { return upb_arena_alloc(this); }
+  upb_alloc *allocator() { return upb_arena_alloc(ptr_.get()); }
 
   /* Add a cleanup function to run when the arena is destroyed.
    * Returns false on out-of-memory. */
-  bool AddCleanup(upb_cleanup_func* func, void* ud) {
-    return upb_arena_addcleanup(this, func, ud);
+  bool AddCleanup(void *ud, upb_cleanup_func* func) {
+    return upb_arena_addcleanup(ptr_.get(), ud, func);
   }
 
   /* Total number of bytes that have been allocated.  It is undefined what
-   * Realloc() does to this counter. */
-  size_t BytesAllocated() const {
-    return upb_arena_bytesallocated(this);
-  }
-
- private:
-  UPB_DISALLOW_COPY_AND_ASSIGN(Arena)
-
-#else
-struct upb_arena {
-#endif  /* __cplusplus */
-  /* We implement the allocator interface.
-   * This must be the first member of upb_arena! */
-  upb_alloc alloc;
-
-  /* Allocator to allocate arena blocks.  We are responsible for freeing these
-   * when we are destroyed. */
-  upb_alloc *block_alloc;
-
-  size_t bytes_allocated;
-  size_t next_block_size;
-  size_t max_block_size;
-
-  /* Linked list of blocks.  Points to an arena_block, defined in env.c */
-  void *block_head;
-
-  /* Cleanup entries.  Pointer to a cleanup_ent, defined in env.c */
-  void *cleanup_head;
-
-  /* For future expansion, since the size of this struct is exposed to users. */
-  void *future1;
-  void *future2;
-};
-
-
-/* upb::Environment ***********************************************************/
-
-/* A upb::Environment provides a means for injecting malloc and an
- * error-reporting callback into encoders/decoders.  This allows them to be
- * independent of nearly all assumptions about their actual environment.
- *
- * It is also a container for allocating the encoders/decoders themselves that
- * insulates clients from knowing their actual size.  This provides ABI
- * compatibility even if the size of the objects change.  And this allows the
- * structure definitions to be in the .c files instead of the .h files, making
- * the .h files smaller and more readable.
- *
- * We might want to consider renaming this to "Pipeline" if/when the concept of
- * a pipeline element becomes more formalized. */
-UPB_DECLARE_TYPE(upb::Environment, upb_env)
-
-/* A function that receives an error report from an encoder or decoder.  The
- * callback can return true to request that the error should be recovered, but
- * if the error is not recoverable this has no effect. */
-typedef bool upb_error_func(void *ud, const upb_status *status);
-
-UPB_BEGIN_EXTERN_C
-
-void upb_env_init(upb_env *e);
-void upb_env_init2(upb_env *e, void *mem, size_t n, upb_alloc *alloc);
-void upb_env_uninit(upb_env *e);
-
-void upb_env_initonly(upb_env *e);
-
-UPB_INLINE upb_arena *upb_env_arena(upb_env *e) { return (upb_arena*)e; }
-bool upb_env_ok(const upb_env *e);
-void upb_env_seterrorfunc(upb_env *e, upb_error_func *func, void *ud);
-
-/* Convenience wrappers around the methods of the contained arena. */
-void upb_env_reporterrorsto(upb_env *e, upb_status *s);
-bool upb_env_reporterror(upb_env *e, const upb_status *s);
-void *upb_env_malloc(upb_env *e, size_t size);
-void *upb_env_realloc(upb_env *e, void *ptr, size_t oldsize, size_t size);
-void upb_env_free(upb_env *e, void *ptr);
-bool upb_env_addcleanup(upb_env *e, upb_cleanup_func *func, void *ud);
-size_t upb_env_bytesallocated(const upb_env *e);
-
-UPB_END_EXTERN_C
-
-#ifdef __cplusplus
-
-class upb::Environment {
- public:
-  /* The given Arena must outlive this environment. */
-  Environment() { upb_env_initonly(this); }
-
-  Environment(void *mem, size_t len, Allocator *a) : arena_(mem, len, a) {
-    upb_env_initonly(this);
-  }
-
-  Arena* arena() { return upb_env_arena(this); }
-
-  /* Set a custom error reporting function. */
-  void SetErrorFunction(upb_error_func* func, void* ud) {
-    upb_env_seterrorfunc(this, func, ud);
-  }
-
-  /* Set the error reporting function to simply copy the status to the given
-   * status and abort. */
-  void ReportErrorsTo(Status* status) { upb_env_reporterrorsto(this, status); }
-
-  /* Returns true if all allocations and AddCleanup() calls have succeeded,
-   * and no errors were reported with ReportError() (except ones that recovered
-   * successfully). */
-  bool ok() const { return upb_env_ok(this); }
-
-  /* Reports an error to this environment's callback, returning true if
-   * the caller should try to recover. */
-  bool ReportError(const Status* status) {
-    return upb_env_reporterror(this, status);
-  }
+   * Realloc() does to &arena_ counter. */
+  size_t BytesAllocated() const { return upb_arena_bytesallocated(ptr_.get()); }
 
  private:
-  UPB_DISALLOW_COPY_AND_ASSIGN(Environment)
-
-#else
-struct upb_env {
-#endif  /* __cplusplus */
-  upb_arena arena_;
-  upb_error_func *error_func_;
-  void *error_ud_;
-  bool ok_;
+  std::unique_ptr<upb_arena, decltype(&upb_arena_free)> ptr_;
 };
 
+#endif
 
 /* upb::InlinedArena **********************************************************/
-/* upb::InlinedEnvironment ****************************************************/
 
-/* upb::InlinedArena and upb::InlinedEnvironment seed their arenas with a
- * predefined amount of memory.  No heap memory will be allocated until the
- * initial block is exceeded.
+/* upb::InlinedArena seeds the arenas with a predefined amount of memory.  No
+ * heap memory will be allocated until the initial block is exceeded.
  *
  * These types only exist in C++ */
 
@@ -710,29 +320,85 @@ struct upb_env {
 
 template <int N> class upb::InlinedArena : public upb::Arena {
  public:
-  InlinedArena() : Arena(initial_block_, N, NULL) {}
-  explicit InlinedArena(Allocator* a) : Arena(initial_block_, N, a) {}
+  InlinedArena() : ptr_(upb_arena_new(&initial_block_, N, &upb_alloc_global)) {}
+
+  upb_arena* ptr() { return ptr_.get(); }
 
  private:
-  UPB_DISALLOW_COPY_AND_ASSIGN(InlinedArena)
+  InlinedArena(const InlinedArena*) = delete;
+  InlinedArena& operator=(const InlinedArena*) = delete;
 
-  char initial_block_[N + UPB_ARENA_BLOCK_OVERHEAD];
+  std::unique_ptr<upb_arena, decltype(&upb_arena_free)> ptr_;
+  char initial_block_[N];
 };
 
-template <int N> class upb::InlinedEnvironment : public upb::Environment {
- public:
-  InlinedEnvironment() : Environment(initial_block_, N, NULL) {}
-  explicit InlinedEnvironment(Allocator *a)
-      : Environment(initial_block_, N, a) {}
+#endif  /* __cplusplus */
 
- private:
-  UPB_DISALLOW_COPY_AND_ASSIGN(InlinedEnvironment)
+/* Constants ******************************************************************/
 
-  char initial_block_[N + UPB_ARENA_BLOCK_OVERHEAD];
-};
+/* Generic function type. */
+typedef void upb_func();
 
-#endif  /* __cplusplus */
+/* A list of types as they are encoded on-the-wire. */
+typedef enum {
+  UPB_WIRE_TYPE_VARINT      = 0,
+  UPB_WIRE_TYPE_64BIT       = 1,
+  UPB_WIRE_TYPE_DELIMITED   = 2,
+  UPB_WIRE_TYPE_START_GROUP = 3,
+  UPB_WIRE_TYPE_END_GROUP   = 4,
+  UPB_WIRE_TYPE_32BIT       = 5
+} upb_wiretype_t;
 
+/* The types a field can have.  Note that this list is not identical to the
+ * types defined in descriptor.proto, which gives INT32 and SINT32 separate
+ * types (we distinguish the two with the "integer encoding" enum below). */
+typedef enum {
+  /* Types stored in 1 byte. */
+  UPB_TYPE_BOOL     = 1,
+  /* Types stored in 4 bytes. */
+  UPB_TYPE_FLOAT    = 2,
+  UPB_TYPE_INT32    = 3,
+  UPB_TYPE_UINT32   = 4,
+  UPB_TYPE_ENUM     = 5,  /* Enum values are int32. */
+  /* Types stored as pointers (probably 4 or 8 bytes). */
+  UPB_TYPE_STRING   = 6,
+  UPB_TYPE_BYTES    = 7,
+  UPB_TYPE_MESSAGE  = 8,
+  /* Types stored as 8 bytes. */
+  UPB_TYPE_DOUBLE   = 9,
+  UPB_TYPE_INT64    = 10,
+  UPB_TYPE_UINT64   = 11
+} upb_fieldtype_t;
+
+/* The repeated-ness of each field; this matches descriptor.proto. */
+typedef enum {
+  UPB_LABEL_OPTIONAL = 1,
+  UPB_LABEL_REQUIRED = 2,
+  UPB_LABEL_REPEATED = 3
+} upb_label_t;
 
+/* Descriptor types, as defined in descriptor.proto. */
+typedef enum {
+  UPB_DESCRIPTOR_TYPE_DOUBLE   = 1,
+  UPB_DESCRIPTOR_TYPE_FLOAT    = 2,
+  UPB_DESCRIPTOR_TYPE_INT64    = 3,
+  UPB_DESCRIPTOR_TYPE_UINT64   = 4,
+  UPB_DESCRIPTOR_TYPE_INT32    = 5,
+  UPB_DESCRIPTOR_TYPE_FIXED64  = 6,
+  UPB_DESCRIPTOR_TYPE_FIXED32  = 7,
+  UPB_DESCRIPTOR_TYPE_BOOL     = 8,
+  UPB_DESCRIPTOR_TYPE_STRING   = 9,
+  UPB_DESCRIPTOR_TYPE_GROUP    = 10,
+  UPB_DESCRIPTOR_TYPE_MESSAGE  = 11,
+  UPB_DESCRIPTOR_TYPE_BYTES    = 12,
+  UPB_DESCRIPTOR_TYPE_UINT32   = 13,
+  UPB_DESCRIPTOR_TYPE_ENUM     = 14,
+  UPB_DESCRIPTOR_TYPE_SFIXED32 = 15,
+  UPB_DESCRIPTOR_TYPE_SFIXED64 = 16,
+  UPB_DESCRIPTOR_TYPE_SINT32   = 17,
+  UPB_DESCRIPTOR_TYPE_SINT64   = 18
+} upb_descriptortype_t;
+
+extern const uint8_t upb_desctype_to_fieldtype[];
 
 #endif  /* UPB_H_ */