Revert "remove all temporary immortalization"

This reverts commit 41c6218.

Include/internal/pycore_gc.h

@@ -344,6 +344,14 @@ struct _gc_runtime_state {
        collections, and are awaiting to undergo a full collection for
        the first time. */
     Py_ssize_t long_lived_pending;
+
+    /* gh-117783: Deferred reference counting is not fully implemented yet, so
+       as a temporary measure we treat objects using deferred reference
+       counting as immortal. The value may be zero, one, or a negative number:
+        0: immortalize deferred RC objects once the first thread is created
+        1: immortalize all deferred RC objects immediately
+        <0: suppressed; don't immortalize objects */
+    int immortalize;
 #endif
 };
 

Modules/_testinternalcapi.c

@@ -1968,13 +1968,27 @@ get_py_thread_id(PyObject *self, PyObject *Py_UNUSED(ignored))
 static PyObject *
 suppress_immortalization(PyObject *self, PyObject *value)
 {
+#ifdef Py_GIL_DISABLED
+    int suppress = PyObject_IsTrue(value);
+    if (suppress < 0) {
+        return NULL;
+    }
+    PyInterpreterState *interp = PyInterpreterState_Get();
+    // Subtract two to suppress immortalization (so that 1 -> -1)
+    _Py_atomic_add_int(&interp->gc.immortalize, suppress ? -2 : 2);
+#endif
     Py_RETURN_NONE;
 }
 
 static PyObject *
 get_immortalize_deferred(PyObject *self, PyObject *Py_UNUSED(ignored))
 {
+#ifdef Py_GIL_DISABLED
+    PyInterpreterState *interp = PyInterpreterState_Get();
+    return PyBool_FromLong(_Py_atomic_load_int(&interp->gc.immortalize) >= 0);
+#else
     Py_RETURN_FALSE;
+#endif
 }
 
 static PyObject *

Objects/codeobject.c

@@ -105,6 +105,16 @@ PyCode_ClearWatcher(int watcher_id)
 static int
 should_intern_string(PyObject *o)
 {
+#ifdef Py_GIL_DISABLED
+    // The free-threaded build interns (and immortalizes) all string constants
+    // unless we've disabled immortalizing objects that use deferred reference
+    // counting.
+    PyInterpreterState *interp = _PyInterpreterState_GET();
+    if (_Py_atomic_load_int(&interp->gc.immortalize) < 0) {
+        return 1;
+    }
+#endif
+
     // compute if s matches [a-zA-Z0-9_]
     const unsigned char *s, *e;
 
@@ -120,6 +130,10 @@ should_intern_string(PyObject *o)
     return 1;
 }
 
+#ifdef Py_GIL_DISABLED
+static PyObject *intern_one_constant(PyObject *op);
+#endif
+
 static int
 intern_strings(PyObject *tuple)
 {
@@ -221,6 +235,27 @@ intern_constants(PyObject *tuple, int *modified)
             }
             Py_DECREF(tmp);
         }
+
+        // Intern non-string constants in the free-threaded build, but only if
+        // we are also immortalizing objects that use deferred reference
+        // counting.
+        PyThreadState *tstate = PyThreadState_GET();
+        if (!_Py_IsImmortal(v) && !PyCode_Check(v) &&
+            !PyUnicode_CheckExact(v) &&
+            _Py_atomic_load_int(&tstate->interp->gc.immortalize) >= 0)
+        {
+            PyObject *interned = intern_one_constant(v);
+            if (interned == NULL) {
+                return -1;
+            }
+            else if (interned != v) {
+                PyTuple_SET_ITEM(tuple, i, interned);
+                Py_SETREF(v, interned);
+                if (modified) {
+                    *modified = 1;
+                }
+            }
+        }
 #endif
     }
     return 0;
@@ -2460,6 +2495,36 @@ _PyCode_ConstantKey(PyObject *op)
 }
 
 #ifdef Py_GIL_DISABLED
+static PyObject *
+intern_one_constant(PyObject *op)
+{
+    PyInterpreterState *interp = _PyInterpreterState_GET();
+    _Py_hashtable_t *consts = interp->code_state.constants;
+
+    assert(!PyUnicode_CheckExact(op));  // strings are interned separately
+
+    _Py_hashtable_entry_t *entry = _Py_hashtable_get_entry(consts, op);
+    if (entry == NULL) {
+        if (_Py_hashtable_set(consts, op, op) != 0) {
+            return NULL;
+        }
+
+#ifdef Py_REF_DEBUG
+        Py_ssize_t refcnt = Py_REFCNT(op);
+        if (refcnt != 1) {
+            // Adjust the reftotal to account for the fact that we only
+            // restore a single reference in _PyCode_Fini.
+            _Py_AddRefTotal(_PyThreadState_GET(), -(refcnt - 1));
+        }
+#endif
+
+        _Py_SetImmortal(op);
+        return op;
+    }
+
+    assert(_Py_IsImmortal(entry->value));
+    return (PyObject *)entry->value;
+}
 
 static int
 compare_constants(const void *key1, const void *key2) {

Python/bltinmodule.c

@@ -866,8 +866,21 @@ builtin_compile_impl(PyObject *module, PyObject *source, PyObject *filename,
     if (str == NULL)
         goto error;
 
+#ifdef Py_GIL_DISABLED
+    // gh-118527: Disable immortalization of code constants for explicit
+    // compile() calls to get consistent frozen outputs between the default
+    // and free-threaded builds.
+    // Subtract two to suppress immortalization (so that 1 -> -1)
+    PyInterpreterState *interp = _PyInterpreterState_GET();
+    _Py_atomic_add_int(&interp->gc.immortalize, -2);
+#endif
+
     result = Py_CompileStringObject(str, filename, start[compile_mode], &cf, optimize);
 
+#ifdef Py_GIL_DISABLED
+    _Py_atomic_add_int(&interp->gc.immortalize, 2);
+#endif
+
     Py_XDECREF(source_copy);
     goto finally;
 

Python/gc_free_threading.c

@@ -755,6 +755,10 @@ _PyGC_Init(PyInterpreterState *interp)
 {
     GCState *gcstate = &interp->gc;
 
+    // gh-117783: immortalize objects that would use deferred refcounting
+    // once the first non-main thread is created (but not in subinterpreters).
+    gcstate->immortalize = _Py_IsMainInterpreter(interp) ? 0 : -1;
+
     gcstate->garbage = PyList_New(0);
     if (gcstate->garbage == NULL) {
         return _PyStatus_NO_MEMORY();