[skip ci] Traverse all DSOs to find memory::guarded_delete with matching RTTI.

Author: rwgk

include/pybind11/detail/internals.h

@@ -255,9 +255,7 @@ struct internals {
 
     type_map<PyObject *> native_enum_type_map;
 
-    // Note: get_internals().get_memory_guarded_delete does
-    //       not need to be wrapped in with_internals().
-    memory::get_guarded_delete_fn get_memory_guarded_delete = memory::get_guarded_delete;
+    std::vector<memory::get_guarded_delete_fn> memory_guarded_delete_fns; // See PRs #5728, #5700.
 
     internals()
         : static_property_type(make_static_property_type()),
@@ -267,6 +265,7 @@ struct internals {
 
         istate = cur_tstate->interp;
         registered_exception_translators.push_front(&translate_exception);
+        memory_guarded_delete_fns.push_back(memory::get_guarded_delete);
 #ifdef Py_GIL_DISABLED
         // Scale proportional to the number of cores. 2x is a heuristic to reduce contention.
         auto num_shards
@@ -676,6 +675,19 @@ inline auto with_exception_translators(const F &cb)
               local_internals.registered_exception_translators);
 }
 
+// Traverse all DSOs to find memory::guarded_delete with matching RTTI.
+inline memory::guarded_delete *find_memory_guarded_delete(const std::shared_ptr<void> &ptr) {
+    return with_internals([&](detail::internals &internals) -> memory::guarded_delete * {
+        for (auto fn : internals.memory_guarded_delete_fns) {
+            memory::guarded_delete *gd = fn(ptr);
+            if (gd) {
+                return gd;
+            }
+        }
+        return nullptr;
+    });
+}
+
 inline std::uint64_t mix64(std::uint64_t z) {
     // David Stafford's variant 13 of the MurmurHash3 finalizer popularized
     // by the SplitMix PRNG.

include/pybind11/detail/type_caster_base.h

@@ -532,7 +532,7 @@ struct value_and_holder_helper {
 
     // have_holder() must be true or this function will fail.
     void throw_if_instance_is_currently_owned_by_shared_ptr() const {
-        auto *vptr_gd_ptr = get_internals().get_memory_guarded_delete(holder().vptr);
+        auto *vptr_gd_ptr = find_memory_guarded_delete(holder().vptr);
         if (vptr_gd_ptr != nullptr && !vptr_gd_ptr->released_ptr.expired()) {
             throw value_error("Python instance is currently owned by a std::shared_ptr.");
         }
@@ -576,7 +576,7 @@ handle smart_holder_from_unique_ptr(std::unique_ptr<T, D> &&src,
                 }
                 // Critical transfer-of-ownership section. This must stay together.
                 self_life_support->deactivate_life_support();
-                holder.reclaim_disowned(get_internals().get_memory_guarded_delete);
+                holder.reclaim_disowned(find_memory_guarded_delete);
                 (void) src.release();
                 // Critical section end.
                 return existing_inst;
@@ -763,7 +763,7 @@ struct load_helper : value_and_holder_helper {
         }
         auto *type_raw_ptr = static_cast<T *>(void_raw_ptr);
         if (python_instance_is_alias && !force_potentially_slicing_shared_ptr) {
-            auto *vptr_gd_ptr = get_internals().get_memory_guarded_delete(holder().vptr);
+            auto *vptr_gd_ptr = find_memory_guarded_delete(holder().vptr);
             if (vptr_gd_ptr != nullptr) {
                 std::shared_ptr<void> released_ptr = vptr_gd_ptr->released_ptr.lock();
                 if (released_ptr) {
@@ -818,14 +818,14 @@ struct load_helper : value_and_holder_helper {
         // This is enforced indirectly by a static_assert in the class_ implementation:
         assert(!python_instance_is_alias || self_life_support);
 
-        std::unique_ptr<D> extracted_deleter = holder().template extract_deleter<T, D>(
-            context, get_internals().get_memory_guarded_delete);
+        std::unique_ptr<D> extracted_deleter
+            = holder().template extract_deleter<T, D>(context, find_memory_guarded_delete);
 
         // Critical transfer-of-ownership section. This must stay together.
         if (self_life_support != nullptr) {
-            holder().disown(get_internals().get_memory_guarded_delete);
+            holder().disown(find_memory_guarded_delete);
         } else {
-            holder().release_ownership(get_internals().get_memory_guarded_delete);
+            holder().release_ownership(find_memory_guarded_delete);
         }
         auto result = unique_with_deleter<T, D>(raw_type_ptr, std::move(extracted_deleter));
         if (self_life_support != nullptr) {
@@ -851,7 +851,7 @@ struct load_helper : value_and_holder_helper {
         holder().template ensure_compatible_rtti_uqp_del<T, D>(context);
         return unique_with_deleter<T, D>(raw_type_ptr,
                                          std::move(holder().template extract_deleter<T, D>(
-                                             context, get_internals().get_memory_guarded_delete)));
+                                             context, find_memory_guarded_delete)));
     }
 };