ruby_memprofiler_pprof 0.0.1

data/ext/ruby_memprofiler_pprof/vendor/upb/upb/util/def_to_proto_test.cc

@@ -0,0 +1,143 @@
+/*
+ * 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/util/def_to_proto.h"
+
+#include "gmock/gmock.h"
+#include "google/protobuf/descriptor.pb.h"
+#include "google/protobuf/descriptor.upbdefs.h"
+#include "google/protobuf/dynamic_message.h"
+#include "google/protobuf/util/message_differencer.h"
+#include "gtest/gtest.h"
+#include "upb/def.hpp"
+#include "upb/upb.hpp"
+#include "upb/util/def_to_proto_test.upbdefs.h"
+
+// Loads and retrieves a descriptor for `msgdef` into the given `pool`.
+const google::protobuf::Descriptor* AddMessageDescriptor(
+    upb::MessageDefPtr msgdef, google::protobuf::DescriptorPool* pool) {
+  upb::Arena tmp_arena;
+  upb::FileDefPtr file = msgdef.file();
+  google_protobuf_FileDescriptorProto* upb_proto =
+      upb_FileDef_ToProto(file.ptr(), tmp_arena.ptr());
+  size_t size;
+  const char* buf = google_protobuf_FileDescriptorProto_serialize(
+      upb_proto, tmp_arena.ptr(), &size);
+  google::protobuf::FileDescriptorProto google_proto;
+  google_proto.ParseFromArray(buf, size);
+  const google::protobuf::FileDescriptor* file_desc =
+      pool->BuildFile(google_proto);
+  EXPECT_TRUE(file_desc != nullptr);
+  return pool->FindMessageTypeByName(msgdef.full_name());
+}
+
+// Converts a upb `msg` (with type `msgdef`) into a protobuf Message object from
+// the given factory and descriptor.
+std::unique_ptr<google::protobuf::Message> ToProto(
+    const upb_Message* msg, const upb_MessageDef* msgdef,
+    const google::protobuf::Descriptor* desc,
+    google::protobuf::MessageFactory* factory) {
+  upb::Arena arena;
+  EXPECT_TRUE(desc != nullptr);
+  std::unique_ptr<google::protobuf::Message> google_msg(
+      factory->GetPrototype(desc)->New());
+  size_t size;
+  const char* buf =
+      upb_Encode(msg, upb_MessageDef_MiniTable(msgdef), 0, arena.ptr(), &size);
+  google_msg->ParseFromArray(buf, size);
+  return google_msg;
+}
+
+// A gtest matcher that verifies that a proto is equal to `proto`.  Both `proto`
+// and `arg` must be messages of type `msgdef_func` (a .upbdefs.h function that
+// loads a known msgdef into the given symtab).
+MATCHER_P2(EqualsUpbProto, proto, msgdef_func,
+           negation ? "are not equal" : "are equal") {
+  upb::SymbolTable symtab;
+  google::protobuf::DescriptorPool pool;
+  google::protobuf::DynamicMessageFactory factory;
+  upb::MessageDefPtr msgdef(msgdef_func(symtab.ptr()));
+  EXPECT_TRUE(msgdef.ptr() != nullptr);
+  const google::protobuf::Descriptor* desc =
+      AddMessageDescriptor(msgdef, &pool);
+  EXPECT_TRUE(desc != nullptr);
+  std::unique_ptr<google::protobuf::Message> m1(
+      ToProto(proto, msgdef.ptr(), desc, &factory));
+  std::unique_ptr<google::protobuf::Message> m2(
+      ToProto(arg, msgdef.ptr(), desc, &factory));
+  std::string differences;
+  google::protobuf::util::MessageDifferencer differencer;
+  differencer.ReportDifferencesToString(&differences);
+  bool eq = differencer.Compare(*m2, *m1);
+  if (!eq) {
+    *result_listener << differences;
+  }
+  return eq;
+}
+
+// Verifies that the given upb FileDef can be converted to a proto that matches
+// `proto`.
+void CheckFile(const upb::FileDefPtr file,
+               const google_protobuf_FileDescriptorProto* proto) {
+  upb::Arena arena;
+  google_protobuf_FileDescriptorProto* proto2 =
+      upb_FileDef_ToProto(file.ptr(), arena.ptr());
+  ASSERT_THAT(
+      proto,
+      EqualsUpbProto(proto2, google_protobuf_FileDescriptorProto_getmsgdef));
+}
+
+// Verifies that upb/util/def_to_proto_test.proto can round-trip:
+//   serialized descriptor -> upb def -> serialized descriptor
+TEST(DefToProto, Test) {
+  upb::Arena arena;
+  upb::SymbolTable symtab;
+  upb_StringView test_file_desc =
+      upb_util_def_to_proto_test_proto_upbdefinit.descriptor;
+  const auto* file_desc = google_protobuf_FileDescriptorProto_parse(
+      test_file_desc.data, test_file_desc.size, arena.ptr());
+
+  upb::MessageDefPtr msgdef(pkg_Message_getmsgdef(symtab.ptr()));
+  upb::FileDefPtr file = msgdef.file();
+  CheckFile(file, file_desc);
+}
+
+// Like the previous test, but uses a message layout built at runtime.
+TEST(DefToProto, TestRuntimeReflection) {
+  upb::Arena arena;
+  upb::SymbolTable symtab;
+  upb_StringView test_file_desc =
+      upb_util_def_to_proto_test_proto_upbdefinit.descriptor;
+  const auto* file_desc = google_protobuf_FileDescriptorProto_parse(
+      test_file_desc.data, test_file_desc.size, arena.ptr());
+
+  _upb_DefPool_LoadDefInitEx(
+      symtab.ptr(), &upb_util_def_to_proto_test_proto_upbdefinit, true);
+  upb::FileDefPtr file = symtab.FindFileByName(
+      upb_util_def_to_proto_test_proto_upbdefinit.filename);
+  CheckFile(file, file_desc);
+}

data/ext/ruby_memprofiler_pprof/vendor/upb/upb/util/def_to_proto_test.proto

@@ -0,0 +1,119 @@
+/*
+ * 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.
+ */
+
+syntax = "proto2";
+
+package pkg;
+
+import public "upb/util/def_to_proto_public_import_test.proto";
+
+import "upb/util/def_to_proto_regular_import_test.proto";
+
+option optimize_for = CODE_SIZE;
+option go_package = "foo_go_package";
+option java_package = "bar_java_package";
+option java_outer_classname = "baz_java_outer_classname";
+option csharp_namespace = "quux_csharp_namespace";
+option objc_class_prefix = "the_objc_prefix";
+option cc_enable_arenas = true;
+
+message Message {
+  optional int32 a = 1 [default = 3];
+  oneof foo {
+    string oneof_string = 2 [default = "abc\n"];
+    string oneof_bool = 3 [default = "true"];
+    bytes oneof_bytes = 4 [default = "abc\xef\xfe"];
+  }
+  optional pkg.RegularImportMessage regular_import_message = 6;
+  optional pkg.PublicImportMessage public_import_message = 7;
+  optional pkg.Proto3Enum proto3_enum = 8;
+  extensions 1000 to max;
+  extend Message {
+    optional int32 ext = 1000;
+  }
+
+  message NestedMessage {}
+  message NestedEnum {}
+
+  // TODO: support reserved ranges in defs.
+  // (At the moment they are ignored and will not round-trip through defs).
+  // reserved 4, 6 to 8;
+}
+
+enum Enum {
+  ZERO = 0;
+  ONE = 1;
+  NEGATIVE_ONE = -1;
+}
+
+enum EnumUpper32Value {
+  UPPER32_VALUE = 40;
+}
+
+enum HasDuplicateValues {
+  option allow_alias = true;
+
+  A = 0;
+  B = 1;
+  C = 120;
+  D = 130;
+
+  G = 120;
+  F = 1;
+  E = 0;
+  H = 121;
+  I = 121;
+  J = 121;
+  K = 121;
+}
+
+service Service {
+  rpc Bar(Message) returns (Message);
+}
+
+extend Message {
+  optional int32 ext = 1001;
+}
+
+enum Has31 {
+  VALUE_31 = 31;
+}
+
+message PretendMessageSet {
+  option message_set_wire_format = true;
+
+  // Since this is message_set_wire_format, "max" here means INT32_MAX.
+  // (For normal messages "max" would mean 2**29 - 1).
+  extensions 4 to max;
+}
+
+message MessageSetItem {
+  extend PretendMessageSet {
+    // Since max is exclusive, this is INT32_MAX-1, not INT32_MAX.
+    optional MessageSetItem message_set_extension = 2147483646;
+  }
+}

data/ext/ruby_memprofiler_pprof/vendor/upb/upb/util/def_to_proto_weak_import_test.proto

@@ -0,0 +1,28 @@
+/*
+ * 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.
+ */
+
+syntax = "proto3";

data/ext/ruby_memprofiler_pprof/vendor/upb/upb/util/def_to_proto_wweak_import_test.proto

@@ -0,0 +1,28 @@
+/*
+ * 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.
+ */
+
+syntax = "proto3";

data/ext/ruby_memprofiler_pprof/vendor/upb/upb/util/required_fields.c

@@ -0,0 +1,311 @@
+/*
+ * 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/util/required_fields.h"
+
+#include <inttypes.h>
+#include <setjmp.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+#include "upb/reflection.h"
+
+// Must be last.
+#include "upb/port_def.inc"
+
+////////////////////////////////////////////////////////////////////////////////
+// upb_FieldPath_ToText()
+////////////////////////////////////////////////////////////////////////////////
+
+typedef struct {
+  char* buf;
+  char* ptr;
+  char* end;
+  size_t overflow;
+} upb_PrintfAppender;
+
+UPB_PRINTF(2, 3)
+static void upb_FieldPath_Printf(upb_PrintfAppender* a, const char* fmt, ...) {
+  size_t n;
+  size_t have = a->end - a->ptr;
+  va_list args;
+
+  va_start(args, fmt);
+  n = vsnprintf(a->ptr, have, fmt, args);
+  va_end(args);
+
+  if (UPB_LIKELY(have > n)) {
+    // We can't end up here if the user passed (NULL, 0), therefore ptr is known
+    // to be non-NULL, and UPB_PTRADD() is not necessary.
+    assert(a->ptr);
+    a->ptr += n;
+  } else {
+    a->ptr = UPB_PTRADD(a->ptr, have);
+    a->overflow += (n - have);
+  }
+}
+
+static size_t upb_FieldPath_NullTerminate(upb_PrintfAppender* d, size_t size) {
+  size_t ret = d->ptr - d->buf + d->overflow;
+
+  if (size > 0) {
+    if (d->ptr == d->end) d->ptr--;
+    *d->ptr = '\0';
+  }
+
+  return ret;
+}
+
+static void upb_FieldPath_PutMapKey(upb_PrintfAppender* a,
+                                    upb_MessageValue map_key,
+                                    const upb_FieldDef* key_f) {
+  switch (upb_FieldDef_CType(key_f)) {
+    case kUpb_CType_Int32:
+      upb_FieldPath_Printf(a, "[%" PRId32 "]", map_key.int32_val);
+      break;
+    case kUpb_CType_Int64:
+      upb_FieldPath_Printf(a, "[%" PRId64 "]", map_key.int64_val);
+      break;
+    case kUpb_CType_UInt32:
+      upb_FieldPath_Printf(a, "[%" PRIu32 "]", map_key.uint32_val);
+      break;
+    case kUpb_CType_UInt64:
+      upb_FieldPath_Printf(a, "[%" PRIu64 "]", map_key.uint64_val);
+      break;
+    case kUpb_CType_Bool:
+      upb_FieldPath_Printf(a, "[%s]", map_key.bool_val ? "true" : "false");
+      break;
+    case kUpb_CType_String:
+      upb_FieldPath_Printf(a, "[\"");
+      for (size_t i = 0; i < map_key.str_val.size; i++) {
+        char ch = map_key.str_val.data[i];
+        if (ch == '"') {
+          upb_FieldPath_Printf(a, "\\\"");
+        } else {
+          upb_FieldPath_Printf(a, "%c", ch);
+        }
+      }
+      upb_FieldPath_Printf(a, "\"]");
+      break;
+    default:
+      UPB_UNREACHABLE();  // Other types can't be map keys.
+  }
+}
+
+size_t upb_FieldPath_ToText(upb_FieldPathEntry** path, char* buf, size_t size) {
+  upb_FieldPathEntry* ptr = *path;
+  upb_PrintfAppender appender;
+  appender.buf = buf;
+  appender.ptr = buf;
+  appender.end = UPB_PTRADD(buf, size);
+  appender.overflow = 0;
+  bool first = true;
+
+  while (ptr->field) {
+    const upb_FieldDef* f = ptr->field;
+
+    upb_FieldPath_Printf(&appender, first ? "%s" : ".%s", upb_FieldDef_Name(f));
+    first = false;
+    ptr++;
+
+    if (upb_FieldDef_IsMap(f)) {
+      const upb_FieldDef* key_f =
+          upb_MessageDef_Field(upb_FieldDef_MessageSubDef(f), 0);
+      upb_FieldPath_PutMapKey(&appender, ptr->map_key, key_f);
+      ptr++;
+    } else if (upb_FieldDef_IsRepeated(f)) {
+      upb_FieldPath_Printf(&appender, "[%zu]", ptr->array_index);
+      ptr++;
+    }
+  }
+
+  // Advance beyond terminating NULL.
+  ptr++;
+  *path = ptr;
+  return upb_FieldPath_NullTerminate(&appender, size);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// upb_util_HasUnsetRequired()
+////////////////////////////////////////////////////////////////////////////////
+
+typedef struct {
+  upb_FieldPathEntry* path;
+  size_t size;
+  size_t cap;
+} upb_FieldPathVector;
+
+typedef struct {
+  upb_FieldPathVector stack;
+  upb_FieldPathVector out_fields;
+  const upb_DefPool* ext_pool;
+  jmp_buf err;
+  bool has_unset_required;
+  bool save_paths;
+} upb_FindContext;
+
+static void upb_FieldPathVector_Init(upb_FieldPathVector* vec) {
+  vec->path = NULL;
+  vec->size = 0;
+  vec->cap = 0;
+}
+
+static void upb_FieldPathVector_Reserve(upb_FindContext* ctx,
+                                        upb_FieldPathVector* vec,
+                                        size_t elems) {
+  if (vec->cap - vec->size < elems) {
+    size_t need = vec->size + elems;
+    vec->cap = UPB_MAX(4, vec->cap);
+    while (vec->cap < need) vec->cap *= 2;
+    vec->path = realloc(vec->path, vec->cap * sizeof(*vec->path));
+    if (!vec->path) {
+      UPB_LONGJMP(ctx->err, 1);
+    }
+  }
+}
+
+static void upb_FindContext_Push(upb_FindContext* ctx, upb_FieldPathEntry ent) {
+  if (!ctx->save_paths) return;
+  upb_FieldPathVector_Reserve(ctx, &ctx->stack, 1);
+  ctx->stack.path[ctx->stack.size++] = ent;
+}
+
+static void upb_FindContext_Pop(upb_FindContext* ctx) {
+  if (!ctx->save_paths) return;
+  assert(ctx->stack.size != 0);
+  ctx->stack.size--;
+}
+
+static void upb_util_FindUnsetInMessage(upb_FindContext* ctx,
+                                        const upb_Message* msg,
+                                        const upb_MessageDef* m) {
+  // Iterate over all fields to see if any required fields are missing.
+  for (int i = 0, n = upb_MessageDef_FieldCount(m); i < n; i++) {
+    const upb_FieldDef* f = upb_MessageDef_Field(m, i);
+    if (upb_FieldDef_Label(f) != kUpb_Label_Required) continue;
+
+    if (!msg || !upb_Message_Has(msg, f)) {
+      // A required field is missing.
+      ctx->has_unset_required = true;
+
+      if (ctx->save_paths) {
+        // Append the contents of the stack to the out array, then
+        // NULL-terminate.
+        upb_FieldPathVector_Reserve(ctx, &ctx->out_fields, ctx->stack.size + 2);
+        if (ctx->stack.size) {
+          memcpy(&ctx->out_fields.path[ctx->out_fields.size], ctx->stack.path,
+                 ctx->stack.size * sizeof(*ctx->stack.path));
+        }
+        ctx->out_fields.size += ctx->stack.size;
+        ctx->out_fields.path[ctx->out_fields.size++] =
+            (upb_FieldPathEntry){.field = f};
+        ctx->out_fields.path[ctx->out_fields.size++] =
+            (upb_FieldPathEntry){.field = NULL};
+      }
+    }
+  }
+}
+
+static void upb_util_FindUnsetRequiredInternal(upb_FindContext* ctx,
+                                               const upb_Message* msg,
+                                               const upb_MessageDef* m) {
+  // OPT: add markers in the schema for where we can avoid iterating:
+  // 1. messages with no required fields.
+  // 2. messages that cannot possibly reach any required fields.
+
+  upb_util_FindUnsetInMessage(ctx, msg, m);
+  if (!msg) return;
+
+  // Iterate over all present fields to find sub-messages that might be missing
+  // required fields.  This may revisit some of the fields already inspected
+  // in the previous loop.  We do this separately because this loop will also
+  // find present extensions, which the previous loop will not.
+  //
+  // TODO(haberman): consider changing upb_Message_Next() to be capable of
+  // visiting extensions only, for example with a kUpb_Message_BeginEXT
+  // constant.
+  size_t iter = kUpb_Message_Begin;
+  const upb_FieldDef* f;
+  upb_MessageValue val;
+  while (upb_Message_Next(msg, m, ctx->ext_pool, &f, &val, &iter)) {
+    // Skip non-submessage fields.
+    if (!upb_FieldDef_IsSubMessage(f)) continue;
+
+    upb_FindContext_Push(ctx, (upb_FieldPathEntry){.field = f});
+    const upb_MessageDef* sub_m = upb_FieldDef_MessageSubDef(f);
+
+    if (upb_FieldDef_IsMap(f)) {
+      // Map field.
+      const upb_FieldDef* val_f = upb_MessageDef_Field(sub_m, 1);
+      const upb_MessageDef* val_m = upb_FieldDef_MessageSubDef(val_f);
+      if (!val_m) continue;
+      const upb_Map* map = val.map_val;
+      size_t iter = kUpb_Map_Begin;
+      while (upb_MapIterator_Next(map, &iter)) {
+        upb_MessageValue key = upb_MapIterator_Key(map, iter);
+        upb_MessageValue map_val = upb_MapIterator_Value(map, iter);
+        upb_FindContext_Push(ctx, (upb_FieldPathEntry){.map_key = key});
+        upb_util_FindUnsetRequiredInternal(ctx, map_val.msg_val, val_m);
+        upb_FindContext_Pop(ctx);
+      }
+    } else if (upb_FieldDef_IsRepeated(f)) {
+      // Repeated field.
+      const upb_Array* arr = val.array_val;
+      for (size_t i = 0, n = upb_Array_Size(arr); i < n; i++) {
+        upb_MessageValue elem = upb_Array_Get(arr, i);
+        upb_FindContext_Push(ctx, (upb_FieldPathEntry){.array_index = i});
+        upb_util_FindUnsetRequiredInternal(ctx, elem.msg_val, sub_m);
+        upb_FindContext_Pop(ctx);
+      }
+    } else {
+      // Scalar sub-message field.
+      upb_util_FindUnsetRequiredInternal(ctx, val.msg_val, sub_m);
+    }
+
+    upb_FindContext_Pop(ctx);
+  }
+}
+
+bool upb_util_HasUnsetRequired(const upb_Message* msg, const upb_MessageDef* m,
+                               const upb_DefPool* ext_pool,
+                               upb_FieldPathEntry** fields) {
+  upb_FindContext ctx;
+  ctx.has_unset_required = false;
+  ctx.save_paths = fields != NULL;
+  ctx.ext_pool = ext_pool;
+  upb_FieldPathVector_Init(&ctx.stack);
+  upb_FieldPathVector_Init(&ctx.out_fields);
+  upb_util_FindUnsetRequiredInternal(&ctx, msg, m);
+  free(ctx.stack.path);
+  if (fields) {
+    upb_FieldPathVector_Reserve(&ctx, &ctx.out_fields, 1);
+    ctx.out_fields.path[ctx.out_fields.size] =
+        (upb_FieldPathEntry){.field = NULL};
+    *fields = ctx.out_fields.path;
+  }
+  return ctx.has_unset_required;
+}