google-protobuf 3.19.1 → 4.30.2

data/ext/google/protobuf_c/message.h

@@ -1,90 +1,64 @@
 // 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.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file or at
+// https://developers.google.com/open-source/licenses/bsd
 
 #ifndef RUBY_PROTOBUF_MESSAGE_H_
 #define RUBY_PROTOBUF_MESSAGE_H_
 
-#include <ruby/ruby.h>
-
 #include "protobuf.h"
 #include "ruby-upb.h"
 
-// Gets the underlying upb_msg* and upb_msgdef for the given Ruby message
-// wrapper. Requires that |value| is indeed a message object.
-const upb_msg *Message_Get(VALUE value, const upb_msgdef **m);
+// Gets the underlying upb_Message* and upb_MessageDef for the given Ruby
+// message wrapper. Requires that |value| is indeed a message object.
+const upb_Message* Message_Get(VALUE value, const upb_MessageDef** m);
 
 // Like Message_Get(), but checks that the object is not frozen and returns a
 // mutable pointer.
-upb_msg *Message_GetMutable(VALUE value, const upb_msgdef **m);
+upb_Message* Message_GetMutable(VALUE value, const upb_MessageDef** m);
 
 // Returns the Arena object for this message.
 VALUE Message_GetArena(VALUE value);
 
-// Converts |value| into a upb_msg value of the expected upb_msgdef type,
-// raising an error if this is not possible. Used when assigning |value| to a
-// field of another message, which means the message must be of a particular
-// type.
+// Converts |value| into a upb_Message value of the expected upb_MessageDef
+// type, raising an error if this is not possible. Used when assigning |value|
+// to a field of another message, which means the message must be of a
+// particular type.
 //
 // This will perform automatic conversions in some cases (for example, Time ->
 // Google::Protobuf::Timestamp). If any new message is created, it will be
 // created on |arena|, and any existing message will have its arena fused with
 // |arena|.
-const upb_msg* Message_GetUpbMessage(VALUE value, const upb_msgdef* m,
-                                     const char* name, upb_arena* arena);
+const upb_Message* Message_GetUpbMessage(VALUE value, const upb_MessageDef* m,
+                                         const char* name, upb_Arena* arena);
 
 // Gets or constructs a Ruby wrapper object for the given message. The wrapper
 // object will reference |arena| and ensure that it outlives this object.
-VALUE Message_GetRubyWrapper(upb_msg* msg, const upb_msgdef* m, VALUE arena);
+VALUE Message_GetRubyWrapper(const upb_Message* msg, const upb_MessageDef* m,
+                             VALUE arena);
 
 // Gets the given field from this message.
-VALUE Message_getfield(VALUE _self, const upb_fielddef* f);
+VALUE Message_getfield(VALUE _self, const upb_FieldDef* f);
 
 // Implements #inspect for this message, printing the text to |b|.
-void Message_PrintMessage(StringBuilder* b, const upb_msg* msg,
-                          const upb_msgdef* m);
+void Message_PrintMessage(StringBuilder* b, const upb_Message* msg,
+                          const upb_MessageDef* m);
 
 // Returns a hash value for the given message.
-uint64_t Message_Hash(const upb_msg *msg, const upb_msgdef *m, uint64_t seed);
+uint64_t Message_Hash(const upb_Message* msg, const upb_MessageDef* m,
+                      uint64_t seed);
 
 // Returns a deep copy of the given message.
-upb_msg* Message_deep_copy(const upb_msg* msg, const upb_msgdef* m,
-                           upb_arena *arena);
-
-// Returns true if these two messages are equal.
-bool Message_Equal(const upb_msg *m1, const upb_msg *m2, const upb_msgdef *m);
+upb_Message* Message_deep_copy(const upb_Message* msg, const upb_MessageDef* m,
+                               upb_Arena* arena);
 
 // Checks that this Ruby object is a message, and raises an exception if not.
 void Message_CheckClass(VALUE klass);
 
 // Returns a new Hash object containing the contents of this message.
-VALUE Scalar_CreateHash(upb_msgval val, TypeInfo type_info);
+VALUE Scalar_CreateHash(upb_MessageValue val, TypeInfo type_info);
 
 // Creates a message class or enum module for this descriptor, respectively.
 VALUE build_class_from_descriptor(VALUE descriptor);
@@ -95,6 +69,13 @@ VALUE build_module_from_enumdesc(VALUE _enumdesc);
 // module.
 VALUE MessageOrEnum_GetDescriptor(VALUE klass);
 
+// Decodes a Message from a byte sequence.
+VALUE Message_decode_bytes(int size, const char* bytes, int options,
+                           VALUE klass, bool freeze);
+
+// Recursively freeze message
+VALUE Message_freeze(VALUE _self);
+
 // Call at startup to register all types in this module.
 void Message_register(VALUE protobuf);
 

data/ext/google/protobuf_c/protobuf.c

@@ -1,37 +1,12 @@
 // Protocol Buffers - Google's data interchange format
 // Copyright 2014 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.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file or at
+// https://developers.google.com/open-source/licenses/bsd
 
 #include "protobuf.h"
 
-#include <ruby/version.h>
-
 #include "defs.h"
 #include "map.h"
 #include "message.h"
@@ -40,14 +15,14 @@
 VALUE cParseError;
 VALUE cTypeError;
 
-const upb_fielddef* map_field_key(const upb_fielddef* field) {
-  const upb_msgdef *entry = upb_fielddef_msgsubdef(field);
-  return upb_msgdef_itof(entry, 1);
+const upb_FieldDef *map_field_key(const upb_FieldDef *field) {
+  const upb_MessageDef *entry = upb_FieldDef_MessageSubDef(field);
+  return upb_MessageDef_FindFieldByNumber(entry, 1);
 }
 
-const upb_fielddef* map_field_value(const upb_fielddef* field) {
-  const upb_msgdef *entry = upb_fielddef_msgsubdef(field);
-  return upb_msgdef_itof(entry, 2);
+const upb_FieldDef *map_field_value(const upb_FieldDef *field) {
+  const upb_MessageDef *entry = upb_FieldDef_MessageSubDef(field);
+  return upb_MessageDef_FindFieldByNumber(entry, 2);
 }
 
 // -----------------------------------------------------------------------------
@@ -66,21 +41,21 @@ static size_t StringBuilder_SizeOf(size_t cap) {
   return sizeof(StringBuilder) + cap;
 }
 
-StringBuilder* StringBuilder_New() {
+StringBuilder *StringBuilder_New() {
   const size_t cap = 128;
-  StringBuilder* builder = malloc(sizeof(*builder));
+  StringBuilder *builder = malloc(sizeof(*builder));
   builder->size = 0;
   builder->cap = cap;
   builder->data = malloc(builder->cap);
   return builder;
 }
 
-void StringBuilder_Free(StringBuilder* b) {
+void StringBuilder_Free(StringBuilder *b) {
   free(b->data);
   free(b);
 }
 
-void StringBuilder_Printf(StringBuilder* b, const char *fmt, ...) {
+void StringBuilder_Printf(StringBuilder *b, const char *fmt, ...) {
   size_t have = b->cap - b->size;
   size_t n;
   va_list args;
@@ -104,60 +79,62 @@ void StringBuilder_Printf(StringBuilder* b, const char *fmt, ...) {
   b->size += n;
 }
 
-VALUE StringBuilder_ToRubyString(StringBuilder* b) {
+VALUE StringBuilder_ToRubyString(StringBuilder *b) {
   VALUE ret = rb_str_new(b->data, b->size);
   rb_enc_associate(ret, rb_utf8_encoding());
   return ret;
 }
 
-static void StringBuilder_PrintEnum(StringBuilder* b, int32_t val,
-                                    const upb_enumdef* e) {
-  const char *name = upb_enumdef_iton(e, val);
-  if (name) {
-    StringBuilder_Printf(b, ":%s", name);
+static void StringBuilder_PrintEnum(StringBuilder *b, int32_t val,
+                                    const upb_EnumDef *e) {
+  const upb_EnumValueDef *ev = upb_EnumDef_FindValueByNumber(e, val);
+  if (ev) {
+    StringBuilder_Printf(b, ":%s", upb_EnumValueDef_Name(ev));
   } else {
     StringBuilder_Printf(b, "%" PRId32, val);
   }
 }
 
-void StringBuilder_PrintMsgval(StringBuilder* b, upb_msgval val,
+void StringBuilder_PrintMsgval(StringBuilder *b, upb_MessageValue val,
                                TypeInfo info) {
   switch (info.type) {
-    case UPB_TYPE_BOOL:
+    case kUpb_CType_Bool:
       StringBuilder_Printf(b, "%s", val.bool_val ? "true" : "false");
       break;
-    case UPB_TYPE_FLOAT: {
+    case kUpb_CType_Float: {
       VALUE str = rb_inspect(DBL2NUM(val.float_val));
       StringBuilder_Printf(b, "%s", RSTRING_PTR(str));
       break;
     }
-    case UPB_TYPE_DOUBLE: {
+    case kUpb_CType_Double: {
       VALUE str = rb_inspect(DBL2NUM(val.double_val));
       StringBuilder_Printf(b, "%s", RSTRING_PTR(str));
       break;
     }
-    case UPB_TYPE_INT32:
+    case kUpb_CType_Int32:
       StringBuilder_Printf(b, "%" PRId32, val.int32_val);
       break;
-    case UPB_TYPE_UINT32:
+    case kUpb_CType_UInt32:
       StringBuilder_Printf(b, "%" PRIu32, val.uint32_val);
       break;
-    case UPB_TYPE_INT64:
+    case kUpb_CType_Int64:
       StringBuilder_Printf(b, "%" PRId64, val.int64_val);
       break;
-    case UPB_TYPE_UINT64:
+    case kUpb_CType_UInt64:
       StringBuilder_Printf(b, "%" PRIu64, val.uint64_val);
       break;
-    case UPB_TYPE_STRING:
-      StringBuilder_Printf(b, "\"%.*s\"", (int)val.str_val.size, val.str_val.data);
+    case kUpb_CType_String:
+      StringBuilder_Printf(b, "\"%.*s\"", (int)val.str_val.size,
+                           val.str_val.data);
       break;
-    case UPB_TYPE_BYTES:
-      StringBuilder_Printf(b, "\"%.*s\"", (int)val.str_val.size, val.str_val.data);
+    case kUpb_CType_Bytes:
+      StringBuilder_Printf(b, "\"%.*s\"", (int)val.str_val.size,
+                           val.str_val.data);
       break;
-    case UPB_TYPE_ENUM:
+    case kUpb_CType_Enum:
       StringBuilder_PrintEnum(b, val.int32_val, info.def.enumdef);
       break;
-    case UPB_TYPE_MESSAGE:
+    case kUpb_CType_Message:
       Message_PrintMessage(b, val.msg_val, info.def.msgdef);
       break;
   }
@@ -168,7 +145,9 @@ void StringBuilder_PrintMsgval(StringBuilder* b, upb_msgval val,
 // -----------------------------------------------------------------------------
 
 typedef struct {
-  upb_arena *arena;
+  upb_Arena *arena;
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
   VALUE pinned_objs;
 } Arena;
 
@@ -179,53 +158,66 @@ static void Arena_mark(void *data) {
 
 static void Arena_free(void *data) {
   Arena *arena = data;
-  upb_arena_free(arena->arena);
+  upb_Arena_Free(arena->arena);
   xfree(arena);
 }
 
+static size_t Arena_memsize(const void *data) {
+  const Arena *arena = data;
+  size_t fused_count;
+  size_t memsize = upb_Arena_SpaceAllocated(arena->arena, &fused_count);
+  if (fused_count > 1) {
+    // If other arena were fused we attribute an equal
+    // share of memory usage to each one.
+    memsize /= fused_count;
+  }
+  return memsize + sizeof(Arena);
+}
+
 static VALUE cArena;
 
 const rb_data_type_t Arena_type = {
-  "Google::Protobuf::Internal::Arena",
-  { Arena_mark, Arena_free, NULL },
-  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+    "Google::Protobuf::Internal::Arena",
+    {Arena_mark, Arena_free, Arena_memsize},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
+static void *ruby_upb_allocfunc(upb_alloc *alloc, void *ptr, size_t oldsize,
+                                size_t size) {
+  if (size == 0) {
+    xfree(ptr);
+    return NULL;
+  } else {
+    return xrealloc(ptr, size);
+  }
+}
+
+upb_alloc ruby_upb_alloc = {&ruby_upb_allocfunc};
+
 static VALUE Arena_alloc(VALUE klass) {
   Arena *arena = ALLOC(Arena);
-  arena->arena = upb_arena_new();
+  arena->arena = upb_Arena_Init(NULL, 0, &ruby_upb_alloc);
   arena->pinned_objs = Qnil;
   return TypedData_Wrap_Struct(klass, &Arena_type, arena);
 }
 
-upb_arena *Arena_get(VALUE _arena) {
+upb_Arena *Arena_get(VALUE _arena) {
   Arena *arena;
   TypedData_Get_Struct(_arena, Arena, &Arena_type, arena);
   return arena->arena;
 }
 
-void Arena_fuse(VALUE _arena, upb_arena *other) {
+void Arena_fuse(VALUE _arena, upb_Arena *other) {
   Arena *arena;
   TypedData_Get_Struct(_arena, Arena, &Arena_type, arena);
-  if (!upb_arena_fuse(arena->arena, other)) {
+  if (!upb_Arena_Fuse(arena->arena, other)) {
     rb_raise(rb_eRuntimeError,
              "Unable to fuse arenas. This should never happen since Ruby does "
              "not use initial blocks");
   }
 }
 
-VALUE Arena_new() {
-  return Arena_alloc(cArena);
-}
-
-void Arena_Pin(VALUE _arena, VALUE obj) {
-  Arena *arena;
-  TypedData_Get_Struct(_arena, Arena, &Arena_type, arena);
-  if (arena->pinned_objs == Qnil) {
-    arena->pinned_objs = rb_ary_new();
-  }
-  rb_ary_push(arena->pinned_objs, obj);
-}
+VALUE Arena_new() { return Arena_alloc(cArena); }
 
 void Arena_register(VALUE module) {
   VALUE internal = rb_define_module_under(module, "Internal");
@@ -239,164 +231,49 @@ void Arena_register(VALUE module) {
 // Object Cache
 // -----------------------------------------------------------------------------
 
-// A pointer -> Ruby Object cache that keeps references to Ruby wrapper
-// objects.  This allows us to look up any Ruby wrapper object by the address
-// of the object it is wrapping. That way we can avoid ever creating two
-// different wrapper objects for the same C object, which saves memory and
-// preserves object identity.
-//
-// We use WeakMap for the cache. For Ruby <2.7 we also need a secondary Hash
-// to store WeakMap keys because Ruby <2.7 WeakMap doesn't allow non-finalizable
-// keys.
-//
-// We also need the secondary Hash if sizeof(long) < sizeof(VALUE), because this
-// means it may not be possible to fit a pointer into a Fixnum. Keys are
-// pointers, and if they fit into a Fixnum, Ruby doesn't collect them, but if
-// they overflow and require allocating a Bignum, they could get collected
-// prematurely, thus removing the cache entry. This happens on 64-bit Windows,
-// on which pointers are 64 bits but longs are 32 bits. In this case, we enable
-// the secondary Hash to hold the keys and prevent them from being collected.
-
-#if RUBY_API_VERSION_CODE >= 20700 && SIZEOF_LONG >= SIZEOF_VALUE
-#define USE_SECONDARY_MAP 0
-#else
-#define USE_SECONDARY_MAP 1
-#endif
-
-#if USE_SECONDARY_MAP
-
-// Maps Numeric -> Object. The object is then used as a key into the WeakMap.
-// This is needed for Ruby <2.7 where a number cannot be a key to WeakMap.
-// The object is used only for its identity; it does not contain any data.
-VALUE secondary_map = Qnil;
-
-// Mutations to the map are under a mutex, because SeconaryMap_MaybeGC()
-// iterates over the map which cannot happen in parallel with insertions, or
-// Ruby will throw:
-//   can't add a new key into hash during iteration (RuntimeError)
-VALUE secondary_map_mutex = Qnil;
-
-// Lambda that will GC entries from the secondary map that are no longer present
-// in the primary map.
-VALUE gc_secondary_map_lambda = Qnil;
-ID length;
-
-extern VALUE weak_obj_cache;
-
-static void SecondaryMap_Init() {
-  rb_gc_register_address(&secondary_map);
-  rb_gc_register_address(&gc_secondary_map_lambda);
-  rb_gc_register_address(&secondary_map_mutex);
-  secondary_map = rb_hash_new();
-  gc_secondary_map_lambda = rb_eval_string(
-      "->(secondary, weak) {\n"
-      "  secondary.delete_if { |k, v| !weak.key?(v) }\n"
-      "}\n");
-  secondary_map_mutex = rb_mutex_new();
-  length = rb_intern("length");
-}
-
-// The secondary map is a regular Hash, and will never shrink on its own.
-// The main object cache is a WeakMap that will automatically remove entries
-// when the target object is no longer reachable, but unless we manually
-// remove the corresponding entries from the secondary map, it will grow
-// without bound.
-//
-// To avoid this unbounded growth we periodically remove entries from the
-// secondary map that are no longer present in the WeakMap. The logic of
-// how often to perform this GC is an artbirary tuning parameter that
-// represents a straightforward CPU/memory tradeoff.
-//
-// Requires: secondary_map_mutex is held.
-static void SecondaryMap_MaybeGC() {
-  PBRUBY_ASSERT(rb_mutex_locked_p(secondary_map_mutex) == Qtrue);
-  size_t weak_len = NUM2ULL(rb_funcall(weak_obj_cache, length, 0));
-  size_t secondary_len = RHASH_SIZE(secondary_map);
-  if (secondary_len < weak_len) {
-    // Logically this case should not be possible: a valid entry cannot exist in
-    // the weak table unless there is a corresponding entry in the secondary
-    // table. It should *always* be the case that secondary_len >= weak_len.
-    //
-    // However ObjectSpace::WeakMap#length (and therefore weak_len) is
-    // unreliable: it overreports its true length by including non-live objects.
-    // However these non-live objects are not yielded in iteration, so we may
-    // have previously deleted them from the secondary map in a previous
-    // invocation of SecondaryMap_MaybeGC().
-    //
-    // In this case, we can't measure any waste, so we just return.
-    return;
-  }
-  size_t waste = secondary_len - weak_len;
-  // GC if we could remove at least 2000 entries or 20% of the table size
-  // (whichever is greater).  Since the cost of the GC pass is O(N), we
-  // want to make sure that we condition this on overall table size, to
-  // avoid O(N^2) CPU costs.
-  size_t threshold = PBRUBY_MAX(secondary_len * 0.2, 2000);
-  if (waste > threshold) {
-    rb_funcall(gc_secondary_map_lambda, rb_intern("call"), 2,
-               secondary_map, weak_obj_cache);
-  }
-}
-
-// Requires: secondary_map_mutex is held by this thread iff create == true.
-static VALUE SecondaryMap_Get(VALUE key, bool create) {
-  PBRUBY_ASSERT(!create || rb_mutex_locked_p(secondary_map_mutex) == Qtrue);
-  VALUE ret = rb_hash_lookup(secondary_map, key);
-  if (ret == Qnil && create) {
-    SecondaryMap_MaybeGC();
-    ret = rb_class_new_instance(0, NULL, rb_cObject);
-    rb_hash_aset(secondary_map, key, ret);
-  }
-  return ret;
-}
-
-#endif
-
-// Requires: secondary_map_mutex is held by this thread iff create == true.
-static VALUE ObjectCache_GetKey(const void* key, bool create) {
-  VALUE key_val = (VALUE)key;
-  PBRUBY_ASSERT((key_val & 3) == 0);
-  VALUE ret = LL2NUM(key_val >> 2);
-#if USE_SECONDARY_MAP
-  ret = SecondaryMap_Get(ret, create);
-#endif
-  return ret;
-}
-
 // Public ObjectCache API.
 
 VALUE weak_obj_cache = Qnil;
 ID item_get;
-ID item_set;
+ID item_try_add;
+
+static void ObjectCache_Init(VALUE protobuf) {
+  item_get = rb_intern("get");
+  item_try_add = rb_intern("try_add");
 
-static void ObjectCache_Init() {
   rb_gc_register_address(&weak_obj_cache);
-  VALUE klass = rb_eval_string("ObjectSpace::WeakMap");
-  weak_obj_cache = rb_class_new_instance(0, NULL, klass);
-  item_get = rb_intern("[]");
-  item_set = rb_intern("[]=");
-#if USE_SECONDARY_MAP
-  SecondaryMap_Init();
+  VALUE internal = rb_const_get(protobuf, rb_intern("Internal"));
+#if SIZEOF_LONG >= SIZEOF_VALUE
+  VALUE cache_class = rb_const_get(internal, rb_intern("ObjectCache"));
+#else
+  VALUE cache_class = rb_const_get(internal, rb_intern("LegacyObjectCache"));
 #endif
+
+  weak_obj_cache = rb_class_new_instance(0, NULL, cache_class);
+  rb_const_set(internal, rb_intern("OBJECT_CACHE"), weak_obj_cache);
+  rb_const_set(internal, rb_intern("SIZEOF_LONG"), INT2NUM(SIZEOF_LONG));
+  rb_const_set(internal, rb_intern("SIZEOF_VALUE"), INT2NUM(SIZEOF_VALUE));
 }
 
-void ObjectCache_Add(const void* key, VALUE val) {
-  PBRUBY_ASSERT(ObjectCache_Get(key) == Qnil);
-#if USE_SECONDARY_MAP
-  rb_mutex_lock(secondary_map_mutex);
-#endif
-  VALUE key_rb = ObjectCache_GetKey(key, true);
-  rb_funcall(weak_obj_cache, item_set, 2, key_rb, val);
-#if USE_SECONDARY_MAP
-  rb_mutex_unlock(secondary_map_mutex);
-#endif
-  PBRUBY_ASSERT(ObjectCache_Get(key) == val);
+static VALUE ObjectCache_GetKey(const void *key) {
+  VALUE key_val = (VALUE)key;
+  PBRUBY_ASSERT((key_val & 3) == 0);
+  // Ensure the key can be stored as a Fixnum since 1 bit is needed for
+  // FIXNUM_FLAG and 1 bit is needed for the sign bit.
+  VALUE new_key = LL2NUM(key_val >> 2);
+  PBRUBY_ASSERT(FIXNUM_P(new_key));
+  return new_key;
+}
+
+VALUE ObjectCache_TryAdd(const void *key, VALUE val) {
+  VALUE key_val = ObjectCache_GetKey(key);
+  return rb_funcall(weak_obj_cache, item_try_add, 2, key_val, val);
 }
 
 // Returns the cached object for this key, if any. Otherwise returns Qnil.
-VALUE ObjectCache_Get(const void* key) {
-  VALUE key_rb = ObjectCache_GetKey(key, false);
-  return rb_funcall(weak_obj_cache, item_get, 1, key_rb);
+VALUE ObjectCache_Get(const void *key) {
+  VALUE key_val = ObjectCache_GetKey(key);
+  return rb_funcall(weak_obj_cache, item_get, 1, key_val);
 }
 
 /*
@@ -407,9 +284,10 @@ VALUE ObjectCache_Get(const void* key) {
  * unknown fields in submessages.
  */
 static VALUE Google_Protobuf_discard_unknown(VALUE self, VALUE msg_rb) {
-  const upb_msgdef *m;
-  upb_msg *msg = Message_GetMutable(msg_rb, &m);
-  if (!upb_msg_discardunknown(msg, m, 128)) {
+  const upb_MessageDef *m;
+  upb_Message *msg = Message_GetMutable(msg_rb, &m);
+  const upb_DefPool* ext_pool = upb_FileDef_Pool(upb_MessageDef_File(m));
+  if (!upb_Message_DiscardUnknown(msg, m, ext_pool, 128)) {
     rb_raise(rb_eRuntimeError, "Messages nested too deeply.");
   }
 
@@ -431,10 +309,10 @@ VALUE Google_Protobuf_deep_copy(VALUE self, VALUE obj) {
     return Map_deep_copy(obj);
   } else {
     VALUE new_arena_rb = Arena_new();
-    upb_arena *new_arena = Arena_get(new_arena_rb);
-    const upb_msgdef *m;
-    const upb_msg *msg = Message_Get(obj, &m);
-    upb_msg* new_msg = Message_deep_copy(msg, m, new_arena);
+    upb_Arena *new_arena = Arena_get(new_arena_rb);
+    const upb_MessageDef *m;
+    const upb_Message *msg = Message_Get(obj, &m);
+    upb_Message *new_msg = Message_deep_copy(msg, m, new_arena);
     return Message_GetRubyWrapper(new_msg, m, new_arena_rb);
   }
 }
@@ -445,13 +323,11 @@ VALUE Google_Protobuf_deep_copy(VALUE self, VALUE obj) {
 
 // This must be named "Init_protobuf_c" because the Ruby module is named
 // "protobuf_c" -- the VM looks for this symbol in our .so.
-__attribute__ ((visibility ("default")))
-void Init_protobuf_c() {
-  ObjectCache_Init();
-
+__attribute__((visibility("default"))) void Init_protobuf_c() {
   VALUE google = rb_define_module("Google");
   VALUE protobuf = rb_define_module_under(google, "Protobuf");
 
+  ObjectCache_Init(protobuf);
   Arena_register(protobuf);
   Defs_register(protobuf);
   RepeatedField_register(protobuf);
@@ -465,6 +341,17 @@ void Init_protobuf_c() {
 
   rb_define_singleton_method(protobuf, "discard_unknown",
                              Google_Protobuf_discard_unknown, 1);
-  rb_define_singleton_method(protobuf, "deep_copy",
-                             Google_Protobuf_deep_copy, 1);
+  rb_define_singleton_method(protobuf, "deep_copy", Google_Protobuf_deep_copy,
+                             1);
+}
+
+// -----------------------------------------------------------------------------
+// Utilities
+// -----------------------------------------------------------------------------
+
+// Raises a Ruby error if val is frozen in Ruby or UPB.
+void Protobuf_CheckNotFrozen(VALUE val, bool upb_frozen) {
+  if (RB_UNLIKELY(rb_obj_frozen_p(val)||upb_frozen)) {
+    rb_error_frozen_object(val);
+  }
 }