pycore_stackref.h | Explore in Territory

#ifndef Py_INTERNAL_STACKREF_H
#define Py_INTERNAL_STACKREF_H
#ifdef __cplusplus
extern "C" {
#endif

#ifndef Py_BUILD_CORE
#  error "this header requires Py_BUILD_CORE define"
#endif

#include "pycore_object_deferred.h"

#include <stddef.h>
#include <stdbool.h>

/*
  This file introduces a new API for handling references on the stack, called
  _PyStackRef. This API is inspired by HPy.

  There are 3 main operations, that convert _PyStackRef to PyObject* and
  vice versa:

    1. Borrow (discouraged)
    2. Steal
    3. New

  Borrow means that the reference is converted without any change in ownership.
  This is discouraged because it makes verification much harder. It also makes
  unboxed integers harder in the future.

  Steal means that ownership is transferred to something else. The total
  number of references to the object stays the same.

  New creates a new reference from the old reference. The old reference
  is still valid.

  With these 3 API, a strict stack discipline must be maintained. All
  _PyStackRef must be operated on by the new reference operations:

    1. DUP
    2. CLOSE

   DUP is roughly equivalent to Py_NewRef. It creates a new reference from an old
   reference. The old reference remains unchanged.

   CLOSE is roughly equivalent to Py_DECREF. It destroys a reference.

   Note that it is unsafe to borrow a _PyStackRef and then do normal
   CPython refcounting operations on it!
*/

_PyStackRef;


#define Py_TAG_DEFERRED …

#define Py_TAG_PTR …
#define Py_TAG_BITS …

#ifdef Py_GIL_DISABLED

static const _PyStackRef PyStackRef_NULL = { .bits = Py_TAG_DEFERRED};
#define PyStackRef_IsNull …
#define PyStackRef_True …
#define PyStackRef_False …
#define PyStackRef_None …

static inline PyObject *
PyStackRef_AsPyObjectBorrow(_PyStackRef stackref)
{
    PyObject *cleared = ((PyObject *)((stackref).bits & (~Py_TAG_BITS)));
    return cleared;
}

#define PyStackRef_IsDeferred …

static inline PyObject *
PyStackRef_NotDeferred_AsPyObject(_PyStackRef stackref)
{
    assert(!PyStackRef_IsDeferred(stackref));
    return (PyObject *)stackref.bits;
}

static inline PyObject *
PyStackRef_AsPyObjectSteal(_PyStackRef stackref)
{
    assert(!PyStackRef_IsNull(stackref));
    if (PyStackRef_IsDeferred(stackref)) {
        return Py_NewRef(PyStackRef_AsPyObjectBorrow(stackref));
    }
    return PyStackRef_AsPyObjectBorrow(stackref);
}

static inline _PyStackRef
_PyStackRef_FromPyObjectSteal(PyObject *obj)
{
    assert(obj != NULL);
    // Make sure we don't take an already tagged value.
    assert(((uintptr_t)obj & Py_TAG_BITS) == 0);
    return (_PyStackRef){ .bits = (uintptr_t)obj };
}
#define PyStackRef_FromPyObjectSteal …

static inline _PyStackRef
PyStackRef_FromPyObjectNew(PyObject *obj)
{
    // Make sure we don't take an already tagged value.
    assert(((uintptr_t)obj & Py_TAG_BITS) == 0);
    assert(obj != NULL);
    if (_Py_IsImmortal(obj) || _PyObject_HasDeferredRefcount(obj)) {
        return (_PyStackRef){ .bits = (uintptr_t)obj | Py_TAG_DEFERRED };
    }
    else {
        return (_PyStackRef){ .bits = (uintptr_t)(Py_NewRef(obj)) | Py_TAG_PTR };
    }
}
#define PyStackRef_FromPyObjectNew …

static inline _PyStackRef
PyStackRef_FromPyObjectImmortal(PyObject *obj)
{
    // Make sure we don't take an already tagged value.
    assert(((uintptr_t)obj & Py_TAG_BITS) == 0);
    assert(obj != NULL);
    assert(_Py_IsImmortal(obj));
    return (_PyStackRef){ .bits = (uintptr_t)obj | Py_TAG_DEFERRED };
}
#define PyStackRef_FromPyObjectImmortal …

#define PyStackRef_CLOSE …

static inline _PyStackRef
PyStackRef_DUP(_PyStackRef stackref)
{
    assert(!PyStackRef_IsNull(stackref));
    if (PyStackRef_IsDeferred(stackref)) {
        assert(_Py_IsImmortal(PyStackRef_AsPyObjectBorrow(stackref)) ||
               _PyObject_HasDeferredRefcount(PyStackRef_AsPyObjectBorrow(stackref))
        );
        return stackref;
    }
    Py_INCREF(PyStackRef_AsPyObjectBorrow(stackref));
    return stackref;
}

// Convert a possibly deferred reference to a strong reference.
static inline _PyStackRef
PyStackRef_AsStrongReference(_PyStackRef stackref)
{
    return PyStackRef_FromPyObjectSteal(PyStackRef_AsPyObjectSteal(stackref));
}

#define PyStackRef_CLOSE_SPECIALIZED …


#else // Py_GIL_DISABLED

// With GIL
static const _PyStackRef PyStackRef_NULL = …;
#define PyStackRef_IsNull(stackref) …
#define PyStackRef_True …
#define PyStackRef_False …
#define PyStackRef_None …

#define PyStackRef_AsPyObjectBorrow(stackref) …

#define PyStackRef_AsPyObjectSteal(stackref) …

#define PyStackRef_FromPyObjectSteal(obj) …

#define PyStackRef_FromPyObjectNew(obj) …

#define PyStackRef_FromPyObjectImmortal(obj) …

#define PyStackRef_CLOSE(stackref) …

#define PyStackRef_DUP(stackref) …

#define PyStackRef_CLOSE_SPECIALIZED(stackref, dealloc) …

#endif // Py_GIL_DISABLED

// Check if a stackref is exactly the same as another stackref, including the
// the deferred bit. This can only be used safely if you know that the deferred
// bits of `a` and `b` match.
#define PyStackRef_IsExactly(a, b) …

// Checks that mask out the deferred bit in the free threading build.
#define PyStackRef_IsNone(ref) …
#define PyStackRef_IsTrue(ref) …
#define PyStackRef_IsFalse(ref) …

// Converts a PyStackRef back to a PyObject *, converting the
// stackref to a new reference.
#define PyStackRef_AsPyObjectNew(stackref) …

#define PyStackRef_TYPE(stackref) …

#define PyStackRef_CLEAR(op) …

#define PyStackRef_XCLOSE(stackref) …



// StackRef type checks

static inline bool
PyStackRef_GenCheck(_PyStackRef stackref)
{ … }

static inline bool
PyStackRef_BoolCheck(_PyStackRef stackref)
{ … }

static inline bool
PyStackRef_LongCheck(_PyStackRef stackref)
{ … }

static inline bool
PyStackRef_ExceptionInstanceCheck(_PyStackRef stackref)
{ … }

static inline bool
PyStackRef_CodeCheck(_PyStackRef stackref)
{ … }

static inline bool
PyStackRef_FunctionCheck(_PyStackRef stackref)
{ … }

#ifdef __cplusplus
}
#endif
#endif /* !Py_INTERNAL_STACKREF_H */
cpython/Include/internal/pycore_stackref.h
