fix: Narrow conditions for load_value to give invalid address

docs/advanced/classes.rst

@@ -1427,4 +1427,12 @@ You can do that using ``py::custom_type_setup``:
    cls.def("size", &ContainerOwnsPythonObjects::size);
    cls.def("clear", &ContainerOwnsPythonObjects::clear);
 
+.. note::
+
+   The ``py::detail::is_holder_constructed()`` guards above are required. During garbage
+   collection, ``tp_traverse`` and ``tp_clear`` may be handed an instance whose C++ value has
+   not been constructed yet -- for example one created with ``__new__`` before ``__init__``
+   has run. Casting such an instance raises ``ValueError``, and an exception must not be
+   allowed to escape either of these slots.
+
 .. versionadded:: 2.8

include/pybind11/cast.h

@@ -2160,7 +2160,12 @@ class argument_loader {
     static constexpr auto arg_names
         = ::pybind11::detail::concat(type_descr(make_caster<Args>::name)...);
 
-    bool load_args(function_call &call) { return load_impl_sequence(call, indices{}); }
+    /// `old_style_init_frame` is non-null only for an old-style constructor candidate, whose
+    /// `self` (positional argument 0) may reach not-yet-constructed storage. Every other call
+    /// passes nullptr and pays nothing for the per-argument bookkeeping.
+    bool load_args(function_call &call, loader_life_support *old_style_init_frame = nullptr) {
+        return load_impl_sequence(call, indices{}, old_style_init_frame);
+    }
 
     template <typename Return, typename Guard, typename Func>
     // NOLINTNEXTLINE(readability-const-return-type)
@@ -2177,21 +2182,39 @@ class argument_loader {
     }
 
 private:
-    static bool load_impl_sequence(function_call &, index_sequence<>) { return true; }
+    static bool load_impl_sequence(function_call &, index_sequence<>, loader_life_support *) {
+        return true;
+    }
+
+    // Loads one positional argument, telling an old-style constructor frame (if any) which
+    // argument is being loaded: only argument 0 is the constructor's `self`.
+    template <size_t I>
+    bool load_one(loader_life_support *old_style_init_frame, function_call &call) {
+        // The phase only *changes* at argument 0 (`self_argument`) and argument 1
+        // (`later_argument`); from argument 2 on it is already `later_argument`. `I` is a
+        // template parameter, so `I < 2` folds at compile time and arguments 2 and beyond
+        // do not even test the pointer.
+        if (I < 2 && old_style_init_frame != nullptr) {
+            old_style_init_frame->begin_argument_load(I);
+        }
+        return std::get<I>(argcasters).load(call.args[I], call.args_convert[I]);
+    }
 
     template <size_t... Is>
-    bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
+    bool load_impl_sequence(function_call &call,
+                            index_sequence<Is...>,
+                            loader_life_support *old_style_init_frame) {
         PYBIND11_WARNING_PUSH
 #if !defined(__clang__) && defined(__GNUC__) && __GNUC__ >= 13
         // Work around a GCC -Warray-bounds false positive in argument_vector usage.
         PYBIND11_WARNING_DISABLE_GCC("-Warray-bounds")
 #endif
 #ifdef __cpp_fold_expressions
-        if ((... || !std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is]))) {
+        if ((... || !load_one<Is>(old_style_init_frame, call))) {
             return false;
         }
 #else
-        for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...}) {
+        for (bool r : {load_one<Is>(old_style_init_frame, call)...}) {
             if (!r) {
                 return false;
             }

include/pybind11/detail/common.h

@@ -664,8 +664,10 @@ struct instance {
      * the [bb...] block (but not independently allocated).
      *
      * Status bits indicate whether the associated holder is constructed (&
-     * status_holder_constructed) and whether the value pointer is registered (&
-     * status_instance_registered) in `registered_instances`.
+     * status_holder_constructed), whether the value pointer is registered (&
+     * status_instance_registered) in `registered_instances`, and whether a constructor is
+     * currently constructing the C++ value in that slot (& status_value_constructing), during
+     * which the value pointer must not be treated as denoting a live C++ object.
      */
     bool simple_layout : 1;
     /// For simple layout, tracks whether the holder has been constructed
@@ -676,6 +678,8 @@ struct instance {
     bool has_patients : 1;
     /// If true, this Python object needs to be kept alive for the lifetime of the C++ value.
     bool is_alias : 1;
+    /// For simple layout, tracks whether a constructor is currently constructing the C++ value.
+    bool simple_value_constructing : 1;
 
     /// Initializes all of the above type/values/holders data (but not the instance values
     /// themselves)
@@ -693,6 +697,7 @@ struct instance {
     /// Bit values for the non-simple status flags
     static constexpr uint8_t status_holder_constructed = 1;
     static constexpr uint8_t status_instance_registered = 2;
+    static constexpr uint8_t status_value_constructing = 4;
 };
 
 static_assert(std::is_standard_layout<instance>::value,