ruby_memprofiler_pprof 0.0.1

data/ext/ruby_memprofiler_pprof/vendor/upb/python/dist/BUILD.bazel

@@ -0,0 +1,193 @@
+# 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.
+
+load("//bazel:py_proto_library.bzl", "py_proto_library")
+load(":dist.bzl", "py_dist", "py_dist_module")
+load("@bazel_skylib//lib:selects.bzl", "selects")
+load("@com_google_protobuf//:protobuf_version.bzl", "PROTOBUF_PYTHON_VERSION")
+load("@rules_python//python:packaging.bzl", "py_wheel")
+load("@system_python//:version.bzl", "SYSTEM_PYTHON_VERSION")
+
+licenses(["notice"])
+
+py_dist_module(
+    name = "message_mod",
+    extension = "//python:_message_binary",
+    module_name = "google._upb._message",
+)
+
+py_proto_library(
+    name = "well_known_proto_py_pb2",
+    deps = [
+        "@com_google_protobuf//:any_proto",
+        "@com_google_protobuf//:api_proto",
+        "@com_google_protobuf//:compiler_plugin_proto",
+        "@com_google_protobuf//:descriptor_proto",
+        "@com_google_protobuf//:duration_proto",
+        "@com_google_protobuf//:empty_proto",
+        "@com_google_protobuf//:field_mask_proto",
+        "@com_google_protobuf//:source_context_proto",
+        "@com_google_protobuf//:struct_proto",
+        "@com_google_protobuf//:timestamp_proto",
+        "@com_google_protobuf//:type_proto",
+        "@com_google_protobuf//:wrappers_proto",
+    ],
+)
+
+config_setting(
+    name = "aarch64_cpu",
+    values = {"cpu": "linux-aarch_64"},
+)
+
+config_setting(
+    name = "x86_64_cpu",
+    values = {"cpu": "linux-x86_64"},
+)
+
+config_setting(
+    name = "osx-x86_64_cpu",
+    values = {"cpu": "osx-x86_64"},
+)
+
+config_setting(
+    name = "osx-aarch64_cpu",
+    values = {"cpu": "osx-aarch_64"},
+)
+
+config_setting(
+    name = "osx-universal2_cpu",
+    values = {"cpu": "osx-universal2"},
+)
+
+config_setting(
+    name = "win32_cpu",
+    values = {"cpu": "win32"},
+)
+
+config_setting(
+    name = "win64_cpu",
+    values = {"cpu": "win64"},
+)
+
+py_wheel(
+    name = "binary_wheel",
+    abi = select({
+        "//python:full_api_3.7": "cp37m",
+        "//python:full_api_3.8": "cp38",
+        "//python:full_api_3.9": "cp39",
+        "//conditions:default": "abi3",
+    }),
+    distribution = "protobuf",
+    platform = select({
+        ":x86_64_cpu": "manylinux2014_x86_64",
+        ":aarch64_cpu": "manylinux2014_aarch64",
+        ":osx-universal2_cpu": "macosx_10_9_universal2",
+        ":win32_cpu": "win32",
+        ":win64_cpu": "win_amd64",
+        "//conditions:default": "any",
+    }),
+    python_tag = selects.with_or({
+        ("//python:limited_api_3.7", "//python:full_api_3.7"): "cp37",
+        "//python:full_api_3.8": "cp38",
+        "//python:full_api_3.9": "cp39",
+        "//python:limited_api_3.10": "cp310",
+        "//conditions:default": "cp" + SYSTEM_PYTHON_VERSION,
+    }),
+    strip_path_prefixes = [
+        "python/dist/",
+        "python/",
+    ],
+    version = PROTOBUF_PYTHON_VERSION,
+    deps = [
+        ":message_mod",
+        ":well_known_proto_py_pb2",
+        "@com_google_protobuf//:python_srcs",
+    ],
+)
+
+py_wheel(
+    name = "pure_python_wheel",
+    abi = "none",
+    distribution = "protobuf",
+    platform = "any",
+    python_tag = "py3",
+    strip_path_prefixes = [
+        "python/",
+    ],
+    version = PROTOBUF_PYTHON_VERSION,
+    deps = [
+        ":well_known_proto_py_pb2",
+        "@com_google_protobuf//:python_srcs",
+    ],
+)
+
+py_wheel(
+    name = "test_wheel",
+    abi = "none",
+    distribution = "protobuftests",
+    platform = "any",
+    python_tag = "py3",
+    strip_path_prefixes = ["python/"],
+    version = PROTOBUF_PYTHON_VERSION,
+    deps = [
+        "//python/pb_unit_tests:test_files",
+        "@com_google_protobuf//:python_common_test_protos",
+        "@com_google_protobuf//:python_specific_test_protos",
+        "@com_google_protobuf//:python_test_srcs",
+        "@com_google_protobuf//:testdata",
+    ],
+)
+
+py_dist(
+    name = "dist",
+    binary_wheel = ":binary_wheel",
+    full_api_cpus = [
+        # TODO(b/231485326): fix win32 build
+        # "win32",
+        "win64",
+    ],
+    # Windows needs version-specific wheels until 3.10.
+    full_api_versions = [
+        "37",
+        "38",
+        "39",
+    ],
+    # Limited API: these wheels will satisfy any Python version >= the
+    # given version.
+    #
+    # Technically the limited API doesn't have the functions we need until
+    # 3.10, but on Linux we can get away with using 3.7 (see ../python_api.h for
+    # details).
+    limited_api_wheels = {
+        # TODO(b/231485326): fix win32 build
+        # "win32": "310",
+        "win64": "310",
+        "linux-x86_64": "37",
+        "linux-aarch_64": "37",
+        "osx-universal2": "37",
+    },
+    pure_python_wheel = ":pure_python_wheel",
+    tags = ["manual"],
+)

data/ext/ruby_memprofiler_pprof/vendor/upb/python/dist/dist.bzl

@@ -0,0 +1,190 @@
+"""Rules to create python distribution files and properly name them"""
+
+load("@bazel_skylib//rules:common_settings.bzl", "BuildSettingInfo")
+load("@system_python//:version.bzl", "SYSTEM_PYTHON_VERSION")
+
+def _get_suffix(limited_api, python_version, cpu):
+    """Computes an ABI version tag for an extension module per PEP 3149."""
+    suffix = "pyd" if ("win" in cpu) else "so"
+
+    if limited_api == True:
+        if "win" not in cpu:
+            suffix = "abi3." + suffix
+        return "." + suffix
+
+    if "win32" in cpu or "win64" in cpu:
+        if "win32" in cpu:
+            abi = "win32"
+        elif "win64" in cpu:
+            abi = "win_amd64"
+        else:
+            fail("Unsupported CPU: " + cpu)
+        return ".cp{}-{}.{}".format(python_version, abi, suffix)
+
+    if python_version == "system":
+        python_version = SYSTEM_PYTHON_VERSION
+        if int(python_version) < 38:
+            python_version += "m"
+        abis = {
+            "darwin": "darwin",
+            "osx-x86_64": "darwin",
+            "osx-aarch_64": "darwin",
+            "linux-aarch_64": "aarch64-linux-gnu",
+            "linux-x86_64": "x86_64-linux-gnu",
+            "k8": "x86_64-linux-gnu",
+        }
+
+        return ".cpython-{}-{}.{}".format(python_version, abis[cpu], suffix)
+
+    fail("Unsupported combination of flags")
+
+def _declare_module_file(ctx, module_name, python_version, limited_api):
+    """Declares an output file for a Python module with this name, version, and limited api."""
+    base_filename = module_name.replace(".", "/")
+    suffix = _get_suffix(
+        python_version = python_version,
+        limited_api = limited_api,
+        cpu = ctx.var["TARGET_CPU"],
+    )
+    filename = base_filename + suffix
+    return ctx.actions.declare_file(filename)
+
+# --------------------------------------------------------------------------------------------------
+# py_dist_module()
+#
+# Creates a Python binary extension module that is ready for distribution.
+#
+#   py_dist_module(
+#       name = "message_mod",
+#       extension = "//python:_message_binary",
+#       module_name = "google._upb._message",
+#   )
+#
+# In the simple case, this simply involves copying the input file to the proper filename for
+# our current configuration (module_name, cpu, python_version, limited_abi).
+#
+# For multiarch platforms (osx-universal2), we must combine binaries for multiple architectures
+# into a single output binary using the "llvm-lipo" tool.  A config transition depends on multiple
+# architectures to get us the input files we need.
+
+def _py_multiarch_transition_impl(settings, attr):
+    if settings["//command_line_option:cpu"] == "osx-universal2":
+        return [{"//command_line_option:cpu": cpu} for cpu in ["osx-aarch_64", "osx-x86_64"]]
+    else:
+        return settings
+
+_py_multiarch_transition = transition(
+    implementation = _py_multiarch_transition_impl,
+    inputs = ["//command_line_option:cpu"],
+    outputs = ["//command_line_option:cpu"],
+)
+
+def _py_dist_module_impl(ctx):
+    output_file = _declare_module_file(
+        ctx = ctx,
+        module_name = ctx.attr.module_name,
+        python_version = ctx.attr._python_version[BuildSettingInfo].value,
+        limited_api = ctx.attr._limited_api[BuildSettingInfo].value,
+    )
+    if len(ctx.attr.extension) == 1:
+        src = ctx.attr.extension[0][DefaultInfo].files.to_list()[0]
+        ctx.actions.run(
+            executable = "cp",
+            arguments = [src.path, output_file.path],
+            inputs = [src],
+            outputs = [output_file],
+        )
+        return [
+            DefaultInfo(files = depset([output_file])),
+        ]
+    else:
+        srcs = [mod[DefaultInfo].files.to_list()[0] for mod in ctx.attr.extension]
+        ctx.actions.run(
+            executable = "/usr/local/bin/llvm-lipo",
+            arguments = ["-create", "-output", output_file.path] + [src.path for src in srcs],
+            inputs = srcs,
+            outputs = [output_file],
+        )
+        return [
+            DefaultInfo(files = depset([output_file])),
+        ]
+
+py_dist_module = rule(
+    output_to_genfiles = True,
+    implementation = _py_dist_module_impl,
+    attrs = {
+        "module_name": attr.string(mandatory = True),
+        "extension": attr.label(
+            mandatory = True,
+            cfg = _py_multiarch_transition,
+        ),
+        "_limited_api": attr.label(default = "//python:limited_api"),
+        "_python_version": attr.label(default = "//python:python_version"),
+        "_allowlist_function_transition": attr.label(
+            default = "@bazel_tools//tools/allowlists/function_transition_allowlist",
+        ),
+    },
+)
+
+# --------------------------------------------------------------------------------------------------
+# py_dist()
+#
+# A rule that builds a collection of binary wheels, using transitions to depend on many different
+# python versions and cpus.
+
+def _py_dist_transition_impl(settings, attr):
+    _ignore = (settings)  # @unused
+    transitions = []
+
+    for cpu, version in attr.limited_api_wheels.items():
+        transitions.append({
+            "//command_line_option:cpu": cpu,
+            "//python:python_version": version,
+            "//python:limited_api": True,
+        })
+
+    for version in attr.full_api_versions:
+        for cpu in attr.full_api_cpus:
+            transitions.append({
+                "//command_line_option:cpu": cpu,
+                "//python:python_version": version,
+                "//python:limited_api": False,
+            })
+
+    return transitions
+
+_py_dist_transition = transition(
+    implementation = _py_dist_transition_impl,
+    inputs = [],
+    outputs = [
+        "//command_line_option:cpu",
+        "//python:python_version",
+        "//python:limited_api",
+    ],
+)
+
+def _py_dist_impl(ctx):
+    binary_files = [dep[DefaultInfo].files for dep in ctx.attr.binary_wheel]
+    pure_python_files = [ctx.attr.pure_python_wheel[DefaultInfo].files]
+    return [
+        DefaultInfo(files = depset(
+            transitive = binary_files + pure_python_files,
+        )),
+    ]
+
+py_dist = rule(
+    implementation = _py_dist_impl,
+    attrs = {
+        "binary_wheel": attr.label(
+            mandatory = True,
+            cfg = _py_dist_transition,
+        ),
+        "pure_python_wheel": attr.label(mandatory = True),
+        "limited_api_wheels": attr.string_dict(),
+        "full_api_versions": attr.string_list(),
+        "full_api_cpus": attr.string_list(),
+        "_allowlist_function_transition": attr.label(
+            default = "@bazel_tools//tools/allowlists/function_transition_allowlist",
+        ),
+    },
+)

data/ext/ruby_memprofiler_pprof/vendor/upb/python/extension_dict.c

@@ -0,0 +1,247 @@
+/*
+ * 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 "python/extension_dict.h"
+
+#include "python/message.h"
+#include "python/protobuf.h"
+
+// -----------------------------------------------------------------------------
+// ExtensionDict
+// -----------------------------------------------------------------------------
+
+typedef struct {
+  PyObject_HEAD;
+  PyObject* msg;  // Owning ref to our parent pessage.
+} PyUpb_ExtensionDict;
+
+PyObject* PyUpb_ExtensionDict_New(PyObject* msg) {
+  PyUpb_ModuleState* state = PyUpb_ModuleState_Get();
+  PyUpb_ExtensionDict* ext_dict =
+      (void*)PyType_GenericAlloc(state->extension_dict_type, 0);
+  ext_dict->msg = msg;
+  Py_INCREF(ext_dict->msg);
+  return &ext_dict->ob_base;
+}
+
+static PyObject* PyUpb_ExtensionDict_FindExtensionByName(PyObject* _self,
+                                                         PyObject* key) {
+  PyUpb_ExtensionDict* self = (PyUpb_ExtensionDict*)_self;
+  const char* name = PyUpb_GetStrData(key);
+  const upb_MessageDef* m = PyUpb_CMessage_GetMsgdef(self->msg);
+  const upb_FileDef* file = upb_MessageDef_File(m);
+  const upb_DefPool* symtab = upb_FileDef_Pool(file);
+  const upb_FieldDef* ext = upb_DefPool_FindExtensionByName(symtab, name);
+  if (ext) {
+    return PyUpb_FieldDescriptor_Get(ext);
+  } else {
+    Py_RETURN_NONE;
+  }
+}
+
+static PyObject* PyUpb_ExtensionDict_FindExtensionByNumber(PyObject* _self,
+                                                           PyObject* arg) {
+  PyUpb_ExtensionDict* self = (PyUpb_ExtensionDict*)_self;
+  const upb_MessageDef* m = PyUpb_CMessage_GetMsgdef(self->msg);
+  const upb_MiniTable* l = upb_MessageDef_MiniTable(m);
+  const upb_FileDef* file = upb_MessageDef_File(m);
+  const upb_DefPool* symtab = upb_FileDef_Pool(file);
+  const upb_ExtensionRegistry* reg = upb_DefPool_ExtensionRegistry(symtab);
+  int64_t number = PyLong_AsLong(arg);
+  const upb_MiniTable_Extension* ext =
+      (upb_MiniTable_Extension*)_upb_extreg_get(reg, l, number);
+  if (ext) {
+    const upb_FieldDef* f = _upb_DefPool_FindExtensionByMiniTable(symtab, ext);
+    return PyUpb_FieldDescriptor_Get(f);
+  } else {
+    Py_RETURN_NONE;
+  }
+}
+
+static void PyUpb_ExtensionDict_Dealloc(PyUpb_ExtensionDict* self) {
+  PyUpb_CMessage_ClearExtensionDict(self->msg);
+  Py_DECREF(self->msg);
+  PyUpb_Dealloc(self);
+}
+
+static PyObject* PyUpb_ExtensionDict_RichCompare(PyObject* _self,
+                                                 PyObject* _other, int opid) {
+  // Only equality comparisons are implemented.
+  if (opid != Py_EQ && opid != Py_NE) {
+    Py_INCREF(Py_NotImplemented);
+    return Py_NotImplemented;
+  }
+  PyUpb_ExtensionDict* self = (PyUpb_ExtensionDict*)_self;
+  bool equals = false;
+  if (PyObject_TypeCheck(_other, Py_TYPE(_self))) {
+    PyUpb_ExtensionDict* other = (PyUpb_ExtensionDict*)_other;
+    equals = self->msg == other->msg;
+  }
+  bool ret = opid == Py_EQ ? equals : !equals;
+  return PyBool_FromLong(ret);
+}
+
+static int PyUpb_ExtensionDict_Contains(PyObject* _self, PyObject* key) {
+  PyUpb_ExtensionDict* self = (PyUpb_ExtensionDict*)_self;
+  const upb_FieldDef* f = PyUpb_CMessage_GetExtensionDef(self->msg, key);
+  if (!f) return -1;
+  upb_Message* msg = PyUpb_CMessage_GetIfReified(self->msg);
+  if (!msg) return 0;
+  if (upb_FieldDef_IsRepeated(f)) {
+    upb_MessageValue val = upb_Message_Get(msg, f);
+    return upb_Array_Size(val.array_val) > 0;
+  } else {
+    return upb_Message_Has(msg, f);
+  }
+}
+
+static Py_ssize_t PyUpb_ExtensionDict_Length(PyObject* _self) {
+  PyUpb_ExtensionDict* self = (PyUpb_ExtensionDict*)_self;
+  upb_Message* msg = PyUpb_CMessage_GetIfReified(self->msg);
+  return msg ? upb_Message_ExtensionCount(msg) : 0;
+}
+
+static PyObject* PyUpb_ExtensionDict_Subscript(PyObject* _self, PyObject* key) {
+  PyUpb_ExtensionDict* self = (PyUpb_ExtensionDict*)_self;
+  const upb_FieldDef* f = PyUpb_CMessage_GetExtensionDef(self->msg, key);
+  if (!f) return NULL;
+  return PyUpb_CMessage_GetFieldValue(self->msg, f);
+}
+
+static int PyUpb_ExtensionDict_AssignSubscript(PyObject* _self, PyObject* key,
+                                               PyObject* val) {
+  PyUpb_ExtensionDict* self = (PyUpb_ExtensionDict*)_self;
+  const upb_FieldDef* f = PyUpb_CMessage_GetExtensionDef(self->msg, key);
+  if (!f) return -1;
+  if (val) {
+    return PyUpb_CMessage_SetFieldValue(self->msg, f, val, PyExc_TypeError);
+  } else {
+    PyUpb_CMessage_DoClearField(self->msg, f);
+    return 0;
+  }
+}
+
+static PyObject* PyUpb_ExtensionIterator_New(PyObject* _ext_dict);
+
+static PyMethodDef PyUpb_ExtensionDict_Methods[] = {
+    {"_FindExtensionByName", PyUpb_ExtensionDict_FindExtensionByName, METH_O,
+     "Finds an extension by name."},
+    {"_FindExtensionByNumber", PyUpb_ExtensionDict_FindExtensionByNumber,
+     METH_O, "Finds an extension by number."},
+    {NULL, NULL},
+};
+
+static PyType_Slot PyUpb_ExtensionDict_Slots[] = {
+    {Py_tp_dealloc, PyUpb_ExtensionDict_Dealloc},
+    {Py_tp_methods, PyUpb_ExtensionDict_Methods},
+    //{Py_tp_getset, PyUpb_ExtensionDict_Getters},
+    //{Py_tp_hash, PyObject_HashNotImplemented},
+    {Py_tp_richcompare, PyUpb_ExtensionDict_RichCompare},
+    {Py_tp_iter, PyUpb_ExtensionIterator_New},
+    {Py_sq_contains, PyUpb_ExtensionDict_Contains},
+    {Py_sq_length, PyUpb_ExtensionDict_Length},
+    {Py_mp_length, PyUpb_ExtensionDict_Length},
+    {Py_mp_subscript, PyUpb_ExtensionDict_Subscript},
+    {Py_mp_ass_subscript, PyUpb_ExtensionDict_AssignSubscript},
+    {0, NULL}};
+
+static PyType_Spec PyUpb_ExtensionDict_Spec = {
+    PYUPB_MODULE_NAME ".ExtensionDict",  // tp_name
+    sizeof(PyUpb_ExtensionDict),         // tp_basicsize
+    0,                                   // tp_itemsize
+    Py_TPFLAGS_DEFAULT,                  // tp_flags
+    PyUpb_ExtensionDict_Slots,
+};
+
+// -----------------------------------------------------------------------------
+// ExtensionIterator
+// -----------------------------------------------------------------------------
+
+typedef struct {
+  PyObject_HEAD;
+  PyObject* msg;
+  size_t iter;
+} PyUpb_ExtensionIterator;
+
+static PyObject* PyUpb_ExtensionIterator_New(PyObject* _ext_dict) {
+  PyUpb_ExtensionDict* ext_dict = (PyUpb_ExtensionDict*)_ext_dict;
+  PyUpb_ModuleState* state = PyUpb_ModuleState_Get();
+  PyUpb_ExtensionIterator* iter =
+      (void*)PyType_GenericAlloc(state->extension_iterator_type, 0);
+  if (!iter) return NULL;
+  iter->msg = ext_dict->msg;
+  iter->iter = kUpb_Message_Begin;
+  Py_INCREF(iter->msg);
+  return &iter->ob_base;
+}
+
+static void PyUpb_ExtensionIterator_Dealloc(void* _self) {
+  PyUpb_ExtensionIterator* self = (PyUpb_ExtensionIterator*)_self;
+  Py_DECREF(self->msg);
+  PyUpb_Dealloc(_self);
+}
+
+PyObject* PyUpb_ExtensionIterator_IterNext(PyObject* _self) {
+  PyUpb_ExtensionIterator* self = (PyUpb_ExtensionIterator*)_self;
+  upb_Message* msg = PyUpb_CMessage_GetIfReified(self->msg);
+  if (!msg) return NULL;
+  const upb_MessageDef* m = PyUpb_CMessage_GetMsgdef(self->msg);
+  const upb_DefPool* symtab = upb_FileDef_Pool(upb_MessageDef_File(m));
+  while (true) {
+    const upb_FieldDef* f;
+    upb_MessageValue val;
+    if (!upb_Message_Next(msg, m, symtab, &f, &val, &self->iter)) return NULL;
+    if (upb_FieldDef_IsExtension(f)) return PyUpb_FieldDescriptor_Get(f);
+  }
+}
+
+static PyType_Slot PyUpb_ExtensionIterator_Slots[] = {
+    {Py_tp_dealloc, PyUpb_ExtensionIterator_Dealloc},
+    {Py_tp_iter, PyObject_SelfIter},
+    {Py_tp_iternext, PyUpb_ExtensionIterator_IterNext},
+    {0, NULL}};
+
+static PyType_Spec PyUpb_ExtensionIterator_Spec = {
+    PYUPB_MODULE_NAME ".ExtensionIterator",  // tp_name
+    sizeof(PyUpb_ExtensionIterator),         // tp_basicsize
+    0,                                       // tp_itemsize
+    Py_TPFLAGS_DEFAULT,                      // tp_flags
+    PyUpb_ExtensionIterator_Slots,
+};
+
+// -----------------------------------------------------------------------------
+// Top Level
+// -----------------------------------------------------------------------------
+
+bool PyUpb_InitExtensionDict(PyObject* m) {
+  PyUpb_ModuleState* s = PyUpb_ModuleState_GetFromModule(m);
+
+  s->extension_dict_type = PyUpb_AddClass(m, &PyUpb_ExtensionDict_Spec);
+  s->extension_iterator_type = PyUpb_AddClass(m, &PyUpb_ExtensionIterator_Spec);
+
+  return s->extension_dict_type && s->extension_iterator_type;
+}

data/ext/ruby_memprofiler_pprof/vendor/upb/python/extension_dict.h

@@ -0,0 +1,39 @@
+/*
+ * 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 PYUPB_EXTENSION_DICT_H__
+#define PYUPB_EXTENSION_DICT_H__
+
+#include <stdbool.h>
+
+#include "python/python_api.h"
+
+PyObject* PyUpb_ExtensionDict_New(PyObject* msg);
+
+bool PyUpb_InitExtensionDict(PyObject* m);
+
+#endif  // PYUPB_EXTENSION_DICT_H__