ruby_memprofiler_pprof 0.0.1

data/ext/ruby_memprofiler_pprof/vendor/upb/upb/mini_table.h

@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2009-2022, Google LLC
+ * All rights reserved.
+ *
+ * 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 LLC 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 Google LLC 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.
+ */
+
+#ifndef UPB_MINI_TABLE_H_
+#define UPB_MINI_TABLE_H_
+
+#include "upb/msg_internal.h"
+
+// Must be last.
+#include "upb/port_def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+const upb_MiniTable_Field* upb_MiniTable_FindFieldByNumber(
+    const upb_MiniTable* table, uint32_t number);
+
+UPB_INLINE const upb_MiniTable* upb_MiniTable_GetSubMessageTable(
+    const upb_MiniTable* mini_table, const upb_MiniTable_Field* field) {
+  return mini_table->subs[field->submsg_index].submsg;
+}
+
+UPB_INLINE bool upb_MiniTable_Enum_CheckValue(const upb_MiniTable_Enum* e,
+                                              int32_t val) {
+  uint32_t uval = (uint32_t)val;
+  if (uval < 64) return e->mask & (1ULL << uval);
+  // OPT: binary search long lists?
+  int n = e->value_count;
+  for (int i = 0; i < n; i++) {
+    if (e->values[i] == val) return true;
+  }
+  return false;
+}
+
+/** upb_MtDataEncoder *********************************************************/
+
+// Functions to encode a string in a format that can be loaded by
+// upb_MiniTable_Build().
+
+typedef enum {
+  kUpb_MessageModifier_ValidateUtf8 = 1 << 0,
+  kUpb_MessageModifier_DefaultIsPacked = 1 << 1,
+  kUpb_MessageModifier_IsExtendable = 1 << 2,
+} kUpb_MessageModifier;
+
+typedef enum {
+  kUpb_FieldModifier_IsRepeated = 1 << 0,
+  kUpb_FieldModifier_IsPacked = 1 << 1,
+  kUpb_FieldModifier_IsClosedEnum = 1 << 2,
+  kUpb_FieldModifier_IsProto3Singular = 1 << 3,
+  kUpb_FieldModifier_IsRequired = 1 << 4,
+} kUpb_FieldModifier;
+
+typedef struct {
+  char* end;  // Limit of the buffer passed as a parameter.
+  // Aliased to internal-only members in .cc.
+  char internal[32];
+} upb_MtDataEncoder;
+
+// If the input buffer has at least this many bytes available, the encoder call
+// is guaranteed to succeed (as long as field number order is maintained).
+#define kUpb_MtDataEncoder_MinSize 16
+
+// Encodes field/oneof information for a given message.  The sequence of calls
+// should look like:
+//
+//   upb_MtDataEncoder e;
+//   char buf[256];
+//   char* ptr = buf;
+//   e.end = ptr + sizeof(buf);
+//   ptr = upb_MtDataEncoder_StartMessage(&e, ptr);
+//   // Fields *must* be in field number order.
+//   ptr = upb_MtDataEncoder_PutField(&e, ptr, ...);
+//   ptr = upb_MtDataEncoder_PutField(&e, ptr, ...);
+//   ptr = upb_MtDataEncoder_PutField(&e, ptr, ...);
+//
+//   // If oneofs are present.  Oneofs must be encoded after regular fields.
+//   ptr = upb_MiniTable_StartOneof(&e, ptr)
+//   ptr = upb_MiniTable_PutOneofField(&e, ptr, ...);
+//   ptr = upb_MiniTable_PutOneofField(&e, ptr, ...);
+//
+//   ptr = upb_MiniTable_StartOneof(&e, ptr);
+//   ptr = upb_MiniTable_PutOneofField(&e, ptr, ...);
+//   ptr = upb_MiniTable_PutOneofField(&e, ptr, ...);
+//
+// Oneofs must be encoded after all regular fields.
+char* upb_MtDataEncoder_StartMessage(upb_MtDataEncoder* e, char* ptr,
+                                     uint64_t msg_mod);
+char* upb_MtDataEncoder_PutField(upb_MtDataEncoder* e, char* ptr,
+                                 upb_FieldType type, uint32_t field_num,
+                                 uint64_t field_mod);
+char* upb_MtDataEncoder_StartOneof(upb_MtDataEncoder* e, char* ptr);
+char* upb_MtDataEncoder_PutOneofField(upb_MtDataEncoder* e, char* ptr,
+                                      uint32_t field_num);
+
+// Encodes the set of values for a given enum.  The values must be given in
+// order (after casting to uint32_t), and repeats are not allowed.
+void upb_MtDataEncoder_StartEnum(upb_MtDataEncoder* e);
+char* upb_MtDataEncoder_PutEnumValue(upb_MtDataEncoder* e, char* ptr,
+                                     uint32_t val);
+char* upb_MtDataEncoder_EndEnum(upb_MtDataEncoder* e, char* ptr);
+
+/** upb_MiniTable *************************************************************/
+
+typedef enum {
+  kUpb_MiniTablePlatform_32Bit,
+  kUpb_MiniTablePlatform_64Bit,
+  kUpb_MiniTablePlatform_Native =
+      UPB_SIZE(kUpb_MiniTablePlatform_32Bit, kUpb_MiniTablePlatform_64Bit),
+} upb_MiniTablePlatform;
+
+// Builds a mini table from the data encoded in the buffer [data, len]. If any
+// errors occur, returns NULL and sets a status message. In the success case,
+// the caller must call upb_MiniTable_SetSub*() for all message or proto2 enum
+// fields to link the table to the appropriate sub-tables.
+upb_MiniTable* upb_MiniTable_Build(const char* data, size_t len,
+                                   upb_MiniTablePlatform platform,
+                                   upb_Arena* arena, upb_Status* status);
+void upb_MiniTable_SetSubMessage(upb_MiniTable* table,
+                                 upb_MiniTable_Field* field,
+                                 const upb_MiniTable* sub);
+void upb_MiniTable_SetSubEnum(upb_MiniTable* table, upb_MiniTable_Field* field,
+                              const upb_MiniTable_Enum* sub);
+
+bool upb_MiniTable_BuildExtension(const char* data, size_t len,
+                                  upb_MiniTable_Extension* ext,
+                                  upb_MiniTable_Sub sub, upb_Status* status);
+
+// Special-case functions for MessageSet layout and map entries.
+upb_MiniTable* upb_MiniTable_BuildMessageSet(upb_MiniTablePlatform platform,
+                                             upb_Arena* arena);
+upb_MiniTable* upb_MiniTable_BuildMapEntry(upb_FieldType key_type,
+                                           upb_FieldType value_type,
+                                           bool value_is_proto3_enum,
+                                           upb_MiniTablePlatform platform,
+                                           upb_Arena* arena);
+
+upb_MiniTable_Enum* upb_MiniTable_BuildEnum(const char* data, size_t len,
+                                            upb_Arena* arena,
+                                            upb_Status* status);
+
+// Like upb_MiniTable_Build(), but the user provides a buffer of layout data so
+// it can be reused from call to call, avoiding repeated realloc()/free().
+//
+// The caller owns `*buf` both before and after the call, and must free() it
+// when it is no longer in use.  The function will realloc() `*buf` as
+// necessary, updating `*size` accordingly.
+upb_MiniTable* upb_MiniTable_BuildWithBuf(const char* data, size_t len,
+                                          upb_MiniTablePlatform platform,
+                                          upb_Arena* arena, void** buf,
+                                          size_t* buf_size, upb_Status* status);
+
+// For testing only.
+char upb_ToBase92(int8_t ch);
+char upb_FromBase92(uint8_t ch);
+bool upb_IsTypePackable(upb_FieldType type);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#include "upb/port_undef.inc"
+
+#endif /* UPB_MINI_TABLE_H_ */

data/ext/ruby_memprofiler_pprof/vendor/upb/upb/mini_table.hpp

@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * 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 LLC 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 Google LLC 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.
+ */
+
+#ifndef UPB_MINI_TABLE_HPP_
+#define UPB_MINI_TABLE_HPP_
+
+#include <assert.h>
+
+#include <string>
+
+#include "upb/mini_table.h"
+
+namespace upb {
+
+class MtDataEncoder {
+ public:
+  MtDataEncoder() : appender_(&encoder_) {}
+
+  bool StartMessage(uint64_t msg_mod) {
+    return appender_([=](char* buf) {
+      return upb_MtDataEncoder_StartMessage(&encoder_, buf, msg_mod);
+    });
+  }
+
+  bool PutField(upb_FieldType type, uint32_t field_num, uint64_t field_mod) {
+    return appender_([=](char* buf) {
+      return upb_MtDataEncoder_PutField(&encoder_, buf, type, field_num,
+                                        field_mod);
+    });
+  }
+
+  bool StartOneof() {
+    return appender_([=](char* buf) {
+      return upb_MtDataEncoder_StartOneof(&encoder_, buf);
+    });
+  }
+
+  bool PutOneofField(uint32_t field_num) {
+    return appender_([=](char* buf) {
+      return upb_MtDataEncoder_PutOneofField(&encoder_, buf, field_num);
+    });
+  }
+
+  void StartEnum() { upb_MtDataEncoder_StartEnum(&encoder_); }
+
+  bool PutEnumValue(uint32_t enum_value) {
+    return appender_([=](char* buf) {
+      return upb_MtDataEncoder_PutEnumValue(&encoder_, buf, enum_value);
+    });
+  }
+
+  bool EndEnum() {
+    return appender_(
+        [=](char* buf) { return upb_MtDataEncoder_EndEnum(&encoder_, buf); });
+  }
+
+  const std::string& data() const { return appender_.data(); }
+
+ private:
+  class StringAppender {
+   public:
+    StringAppender(upb_MtDataEncoder* e) { e->end = buf_ + sizeof(buf_); }
+
+    template <class T>
+    bool operator()(T&& func) {
+      char* end = func(buf_);
+      if (!end) return false;
+      // C++ does not guarantee that string has doubling growth behavior, but
+      // we need it to avoid O(n^2).
+      str_.reserve(_upb_Log2CeilingSize(str_.size() + (end - buf_)));
+      str_.append(buf_, end - buf_);
+      return true;
+    }
+
+    const std::string& data() const { return str_; }
+
+   private:
+    char buf_[kUpb_MtDataEncoder_MinSize];
+    std::string str_;
+  };
+
+  upb_MtDataEncoder encoder_;
+  StringAppender appender_;
+};
+
+}  // namespace upb
+
+#endif /* UPB_MINI_TABLE_HPP_ */

data/ext/ruby_memprofiler_pprof/vendor/upb/upb/mini_table_accessors.c

@@ -0,0 +1,363 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * 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 LLC 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 Google LLC 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.
+ */
+
+#include "upb/mini_table_accessors.h"
+
+#include "upb/mini_table.h"
+#include "upb/msg_internal.h"
+
+// Must be last.
+#include "upb/port_def.inc"
+
+size_t upb_MiniTable_Field_GetSize(const upb_MiniTable_Field* f) {
+  static unsigned char sizes[] = {
+      0,                      /* 0 */
+      8,                      /* kUpb_FieldType_Double */
+      4,                      /* kUpb_FieldType_Float */
+      8,                      /* kUpb_FieldType_Int64 */
+      8,                      /* kUpb_FieldType_UInt64 */
+      4,                      /* kUpb_FieldType_Int32 */
+      8,                      /* kUpb_FieldType_Fixed64 */
+      4,                      /* kUpb_FieldType_Fixed32 */
+      1,                      /* kUpb_FieldType_Bool */
+      sizeof(upb_StringView), /* kUpb_FieldType_String */
+      sizeof(void*),          /* kUpb_FieldType_Group */
+      sizeof(void*),          /* kUpb_FieldType_Message */
+      sizeof(upb_StringView), /* kUpb_FieldType_Bytes */
+      4,                      /* kUpb_FieldType_UInt32 */
+      4,                      /* kUpb_FieldType_Enum */
+      4,                      /* kUpb_FieldType_SFixed32 */
+      8,                      /* kUpb_FieldType_SFixed64 */
+      4,                      /* kUpb_FieldType_SInt32 */
+      8,                      /* kUpb_FieldType_SInt64 */
+  };
+  return upb_IsRepeatedOrMap(f) ? sizeof(void*) : sizes[f->descriptortype];
+}
+
+bool upb_MiniTable_HasField(const upb_Message* msg,
+                            const upb_MiniTable_Field* field) {
+  if (_upb_MiniTable_Field_InOneOf(field)) {
+    return _upb_getoneofcase_field(msg, field) == field->number;
+  } else if (field->presence > 0) {
+    return _upb_hasbit_field(msg, field);
+  } else {
+    UPB_ASSERT(field->descriptortype == kUpb_FieldType_Message ||
+               field->descriptortype == kUpb_FieldType_Group);
+    return upb_MiniTable_GetMessage(msg, field) != NULL;
+  }
+}
+
+void upb_MiniTable_ClearField(upb_Message* msg,
+                              const upb_MiniTable_Field* field) {
+  char* mem = UPB_PTR_AT(msg, field->offset, char);
+  if (field->presence > 0) {
+    _upb_clearhas_field(msg, field);
+  } else if (_upb_MiniTable_Field_InOneOf(field)) {
+    uint32_t* oneof_case = _upb_oneofcase_field(msg, field);
+    if (*oneof_case != field->number) return;
+    *oneof_case = 0;
+  }
+  memset(mem, 0, upb_MiniTable_Field_GetSize(field));
+}
+
+typedef struct {
+  const char* ptr;
+  uint64_t val;
+} decode_vret;
+
+UPB_NOINLINE
+static decode_vret decode_longvarint64(const char* ptr, uint64_t val) {
+  decode_vret ret = {NULL, 0};
+  uint64_t byte;
+  int i;
+  for (i = 1; i < 10; i++) {
+    byte = (uint8_t)ptr[i];
+    val += (byte - 1) << (i * 7);
+    if (!(byte & 0x80)) {
+      ret.ptr = ptr + i + 1;
+      ret.val = val;
+      return ret;
+    }
+  }
+  return ret;
+}
+
+UPB_FORCEINLINE
+static const char* decode_varint64(const char* ptr, uint64_t* val) {
+  uint64_t byte = (uint8_t)*ptr;
+  if (UPB_LIKELY((byte & 0x80) == 0)) {
+    *val = byte;
+    return ptr + 1;
+  } else {
+    decode_vret res = decode_longvarint64(ptr, byte);
+    if (!res.ptr) return NULL;
+    *val = res.val;
+    return res.ptr;
+  }
+}
+
+UPB_FORCEINLINE
+static const char* decode_tag(const char* ptr, uint32_t* val) {
+  uint64_t byte = (uint8_t)*ptr;
+  if (UPB_LIKELY((byte & 0x80) == 0)) {
+    *val = (uint32_t)byte;
+    return ptr + 1;
+  } else {
+    const char* start = ptr;
+    decode_vret res = decode_longvarint64(ptr, byte);
+    if (!res.ptr || res.ptr - start > 5 || res.val > UINT32_MAX) {
+      return NULL;  // Malformed.
+    }
+    *val = (uint32_t)res.val;
+    return res.ptr;
+  }
+}
+
+typedef enum {
+  kUpb_FindUnknown_Ok,
+  kUpb_FindUnknown_NotPresent,
+  kUpb_FindUnknown_ParseError,
+} upb_FindUnknown_Status;
+
+typedef struct {
+  upb_FindUnknown_Status status;
+  const char* ptr;
+  size_t len;
+} find_unknown_ret;
+
+static find_unknown_ret UnknownFieldSet_FindField(const upb_Message* msg,
+                                                  int field_number);
+
+upb_GetExtension_Status upb_MiniTable_GetOrPromoteExtension(
+    upb_Message* msg, const upb_MiniTable_Extension* ext_table,
+    int decode_options, upb_Arena* arena,
+    const upb_Message_Extension** extension) {
+  UPB_ASSERT(ext_table->field.descriptortype == kUpb_FieldType_Message);
+  *extension = _upb_Message_Getext(msg, ext_table);
+  if (*extension) {
+    return kUpb_GetExtension_Ok;
+  }
+
+  // Check unknown fields, if available promote.
+  int field_number = ext_table->field.number;
+  find_unknown_ret result = UnknownFieldSet_FindField(msg, field_number);
+  if (result.status != kUpb_FindUnknown_Ok) {
+    UPB_ASSERT(result.status != kUpb_GetExtension_ParseError);
+    return kUpb_GetExtension_NotPresent;
+  }
+  // Decode and promote from unknown.
+  const upb_MiniTable* extension_table = ext_table->sub.submsg;
+  upb_Message* extension_msg = _upb_Message_New(extension_table, arena);
+  if (!extension_msg) {
+    return kUpb_GetExtension_OutOfMemory;
+  }
+  const char* data = result.ptr;
+  uint32_t tag;
+  uint64_t message_len;
+  data = decode_tag(data, &tag);
+  data = decode_varint64(data, &message_len);
+  upb_DecodeStatus status =
+      upb_Decode(data, message_len, extension_msg, extension_table, NULL,
+                 decode_options, arena);
+  if (status == kUpb_DecodeStatus_OutOfMemory) {
+    return kUpb_GetExtension_OutOfMemory;
+  }
+  if (status != kUpb_DecodeStatus_Ok) return kUpb_GetExtension_ParseError;
+  // Add to extensions.
+  upb_Message_Extension* ext =
+      _upb_Message_GetOrCreateExtension(msg, ext_table, arena);
+  if (!ext) {
+    return kUpb_GetExtension_OutOfMemory;
+  }
+  memcpy(&ext->data, &extension_msg, sizeof(extension_msg));
+  *extension = ext;
+  // Remove unknown field.
+  upb_Message_Internal* in = upb_Message_Getinternal(msg);
+  const char* internal_unknown_end =
+      UPB_PTR_AT(in->internal, in->internal->unknown_end, char);
+  if ((result.ptr + result.len) != internal_unknown_end) {
+    memmove((char*)result.ptr, result.ptr + result.len,
+            internal_unknown_end - result.ptr - result.len);
+  }
+  in->internal->unknown_end -= result.len;
+  return kUpb_GetExtension_Ok;
+}
+
+upb_GetExtensionAsBytes_Status upb_MiniTable_GetExtensionAsBytes(
+    const upb_Message* msg, const upb_MiniTable_Extension* ext_table,
+    int encode_options, upb_Arena* arena, const char** extension_data,
+    size_t* len) {
+  const upb_Message_Extension* msg_ext = _upb_Message_Getext(msg, ext_table);
+  UPB_ASSERT(ext_table->field.descriptortype == kUpb_FieldType_Message);
+  if (msg_ext) {
+    *extension_data = upb_Encode(msg_ext->data.ptr, msg_ext->ext->sub.submsg,
+                                 encode_options, arena, len);
+    if (extension_data) {
+      return kUpb_GetExtensionAsBytes_Ok;
+    }
+    return kUpb_GetExtensionAsBytes_EncodeError;
+  }
+  int field_number = ext_table->field.number;
+  find_unknown_ret result = UnknownFieldSet_FindField(msg, field_number);
+  if (result.status != kUpb_FindUnknown_Ok) {
+    UPB_ASSERT(result.status != kUpb_GetExtension_ParseError);
+    return kUpb_GetExtensionAsBytes_NotPresent;
+  }
+  const char* data = result.ptr;
+  uint32_t tag;
+  uint64_t message_len;
+  data = decode_tag(data, &tag);
+  data = decode_varint64(data, &message_len);
+  *extension_data = data;
+  *len = message_len;
+  return kUpb_GetExtensionAsBytes_Ok;
+}
+
+static const char* UnknownFieldSet_SkipGroup(const char* ptr, const char* end,
+                                             int group_number);
+
+static const char* UnknownFieldSet_SkipField(const char* ptr, const char* end,
+                                             uint32_t tag) {
+  int field_number = tag >> 3;
+  int wire_type = tag & 7;
+  switch (wire_type) {
+    case kUpb_WireType_Varint: {
+      uint64_t val;
+      return decode_varint64(ptr, &val);
+    }
+    case kUpb_WireType_64Bit:
+      if (end - ptr < 8) return NULL;
+      return ptr + 8;
+    case kUpb_WireType_32Bit:
+      if (end - ptr < 4) return NULL;
+      return ptr + 4;
+    case kUpb_WireType_Delimited: {
+      uint64_t size;
+      ptr = decode_varint64(ptr, &size);
+      if (!ptr || end - ptr < size) return NULL;
+      return ptr + size;
+    }
+    case kUpb_WireType_StartGroup:
+      return UnknownFieldSet_SkipGroup(ptr, end, field_number);
+    case kUpb_WireType_EndGroup:
+      return NULL;
+    default:
+      assert(0);
+      return NULL;
+  }
+}
+
+static const char* UnknownFieldSet_SkipGroup(const char* ptr, const char* end,
+                                             int group_number) {
+  uint32_t end_tag = (group_number << 3) | kUpb_WireType_EndGroup;
+  while (true) {
+    if (ptr == end) return NULL;
+    uint64_t tag;
+    ptr = decode_varint64(ptr, &tag);
+    if (!ptr) return NULL;
+    if (tag == end_tag) return ptr;
+    ptr = UnknownFieldSet_SkipField(ptr, end, (uint32_t)tag);
+    if (!ptr) return NULL;
+  }
+  return ptr;
+}
+
+enum {
+  kUpb_MessageSet_StartItemTag = (1 << 3) | kUpb_WireType_StartGroup,
+  kUpb_MessageSet_EndItemTag = (1 << 3) | kUpb_WireType_EndGroup,
+  kUpb_MessageSet_TypeIdTag = (2 << 3) | kUpb_WireType_Varint,
+  kUpb_MessageSet_MessageTag = (3 << 3) | kUpb_WireType_Delimited,
+};
+
+static find_unknown_ret UnknownFieldSet_FindField(const upb_Message* msg,
+                                                  int field_number) {
+  size_t size;
+  find_unknown_ret ret;
+
+  const char* ptr = upb_Message_GetUnknown(msg, &size);
+  if (size == 0) {
+    ret.ptr = NULL;
+    return ret;
+  }
+  const char* end = ptr + size;
+  uint64_t uint64_val;
+
+  while (ptr < end) {
+    uint32_t tag;
+    int field;
+    int wire_type;
+    const char* unknown_begin = ptr;
+    ptr = decode_tag(ptr, &tag);
+    field = tag >> 3;
+    wire_type = tag & 7;
+    switch (wire_type) {
+      case kUpb_WireType_EndGroup:
+        ret.status = kUpb_FindUnknown_ParseError;
+        return ret;
+      case kUpb_WireType_Varint:
+        ptr = decode_varint64(ptr, &uint64_val);
+        if (!ptr) {
+          ret.status = kUpb_FindUnknown_ParseError;
+          return ret;
+        }
+        break;
+      case kUpb_WireType_32Bit:
+        ptr += 4;
+        break;
+      case kUpb_WireType_64Bit:
+        ptr += 8;
+        break;
+      case kUpb_WireType_Delimited:
+        // Read size.
+        ptr = decode_varint64(ptr, &uint64_val);
+        if (uint64_val >= INT32_MAX || !ptr) {
+          ret.status = kUpb_FindUnknown_ParseError;
+          return ret;
+        }
+        ptr += uint64_val;
+        break;
+      case kUpb_WireType_StartGroup:
+        // tag >> 3 specifies the group number, recurse and skip
+        // until we see group end tag.
+        ptr = UnknownFieldSet_SkipGroup(ptr, end, field_number);
+        break;
+      default:
+        ret.status = kUpb_FindUnknown_ParseError;
+        return ret;
+    }
+    if (field_number == field) {
+      ret.status = kUpb_FindUnknown_Ok;
+      ret.ptr = unknown_begin;
+      ret.len = ptr - unknown_begin;
+      return ret;
+    }
+  }
+  ret.status = kUpb_FindUnknown_NotPresent;
+  ret.ptr = NULL;
+  ret.len = 0;
+  return ret;
+}