Make the default build work

Author: mpage

Include/internal/pycore_stackref.h

@@ -425,7 +425,6 @@ static inline void PyStackRef_CheckValid(_PyStackRef ref) {
             assert(!_Py_IsStaticImmortal(obj));
             break;
         case Py_TAG_REFCNT:
-            assert(obj == NULL || _Py_IsImmortal(obj));
             break;
         default:
             assert(0);
@@ -438,24 +437,29 @@ static inline void PyStackRef_CheckValid(_PyStackRef ref) {
 
 #endif
 
-#define PyStackRef_Borrow(ref) PyStackRef_DUP(ref)
-
 #ifdef _WIN32
-#define PyStackRef_RefcountOnObject(REF) (((REF).bits & Py_TAG_BITS) == 0)
+#define PyStackRef_RefcountOnObject(REF) (((REF).bits & Py_TAG_REFCNT) == 0)
 #define PyStackRef_AsPyObjectBorrow BITS_TO_PTR_MASKED
+#define PyStackRef_Borrow(REF) (_PyStackRef){ .bits = ((REF).bits) | Py_TAG_REFCNT};
 #else
 /* Does this ref not have an embedded refcount and thus not refer to a declared immmortal object? */
 static inline int
 PyStackRef_RefcountOnObject(_PyStackRef ref)
 {
-    return (ref.bits & Py_TAG_BITS) == 0;
+    return (ref.bits & Py_TAG_REFCNT) == 0;
 }
 
 static inline PyObject *
 PyStackRef_AsPyObjectBorrow(_PyStackRef ref)
 {
     return BITS_TO_PTR_MASKED(ref);
 }
+
+static inline _PyStackRef
+PyStackRef_Borrow(_PyStackRef ref)
+{
+    return (_PyStackRef){ .bits = ref.bits | Py_TAG_REFCNT };
+}
 #endif
 
 static inline PyObject *

Objects/floatobject.c

@@ -134,44 +134,13 @@ PyFloat_FromDouble(double fval)
     return (PyObject *) op;
 }
 
-#ifdef Py_GIL_DISABLED
-
 _PyStackRef _PyFloat_FromDouble_ConsumeInputs(_PyStackRef left, _PyStackRef right, double value)
 {
     PyStackRef_CLOSE_SPECIALIZED(left, _PyFloat_ExactDealloc);
     PyStackRef_CLOSE_SPECIALIZED(right, _PyFloat_ExactDealloc);
     return PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(value));
 }
 
-#else // Py_GIL_DISABLED
-
-_PyStackRef _PyFloat_FromDouble_ConsumeInputs(_PyStackRef left, _PyStackRef right, double value)
-{
-    PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
-    PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
-    if (Py_REFCNT(left_o) == 1) {
-        ((PyFloatObject *)left_o)->ob_fval = value;
-        PyStackRef_CLOSE_SPECIALIZED(right, _PyFloat_ExactDealloc);
-        return left;
-    }
-    else if (Py_REFCNT(right_o) == 1)  {
-        ((PyFloatObject *)right_o)->ob_fval = value;
-        PyStackRef_CLOSE_SPECIALIZED(left, _PyFloat_ExactDealloc);
-        return right;
-    }
-    else {
-        PyObject *result = PyFloat_FromDouble(value);
-        PyStackRef_CLOSE_SPECIALIZED(left, _PyFloat_ExactDealloc);
-        PyStackRef_CLOSE_SPECIALIZED(right, _PyFloat_ExactDealloc);
-        if (result == NULL) {
-            return PyStackRef_NULL;
-        }
-        return PyStackRef_FromPyObjectStealMortal(result);
-    }
-}
-
-#endif // Py_GIL_DISABLED
-
 static PyObject *
 float_from_string_inner(const char *s, Py_ssize_t len, void *obj)
 {

Python/gc.c

@@ -543,6 +543,12 @@ visit_decref(PyObject *op, void *parent)
 int
 _PyGC_VisitStackRef(_PyStackRef *ref, visitproc visit, void *arg)
 {
+    // This is a bit tricky! We want to ignore stackrefs with embedded
+    // refcounts when computing the incoming references, but otherwise treat
+    // them like normal.
+    if (!PyStackRef_RefcountOnObject(*ref) && (visit == visit_decref)) {
+        return 0;
+    }
     Py_VISIT(PyStackRef_AsPyObjectBorrow(*ref));
     return 0;
 }
@@ -553,7 +559,7 @@ _PyGC_VisitFrameStack(_PyInterpreterFrame *frame, visitproc visit, void *arg)
     _PyStackRef *ref = _PyFrame_GetLocalsArray(frame);
     /* locals and stack */
     for (; ref < frame->stackpointer; ref++) {
-        Py_VISIT(PyStackRef_AsPyObjectBorrow(*ref));
+        _Py_VISIT_STACKREF(*ref);
     }
     return 0;
 }

Python/marshal.c

@@ -382,11 +382,12 @@ w_ref(PyObject *v, char *flag, WFILE *p)
     if (p->version < 3 || p->hashtable == NULL)
         return 0; /* not writing object references */
 
-    /* If it has only one reference, it definitely isn't shared.
-     * But we use TYPE_REF always for interned string, to PYC file stable
+    /* If it has only one reference, it definitely isn't shared.  But we use
+     * TYPE_REF always for interned string and code objects, to PYC file stable
      * as possible.
      */
     if (Py_REFCNT(v) == 1 &&
+            !PyCode_Check(v) &&
             !(PyUnicode_CheckExact(v) && PyUnicode_CHECK_INTERNED(v))) {
         return 0;
     }