/* Generic object operations; and implementation of None */

#include "Python.h"

#include "pycore_brc.h" // _Py_brc_queue_object()

#include "pycore_call.h" // _PyObject_CallNoArgs()

#include "pycore_ceval.h" // _Py_EnterRecursiveCallTstate()

#include "pycore_context.h" // _PyContextTokenMissing_Type

#include "pycore_critical_section.h" // Py_BEGIN_CRITICAL_SECTION

#include "pycore_descrobject.h" // _PyMethodWrapper_Type

#include "pycore_dict.h" // _PyObject_MaterializeManagedDict()

#include "pycore_floatobject.h" // _PyFloat_DebugMallocStats()

#include "pycore_freelist.h" // _PyObject_ClearFreeLists()

#include "pycore_genobject.h" // _PyAsyncGenAThrow_Type

#include "pycore_hamt.h" // _PyHamtItems_Type

#include "pycore_initconfig.h" // _PyStatus_OK()

#include "pycore_instruction_sequence.h" // _PyInstructionSequence_Type

#include "pycore_list.h" // _PyList_DebugMallocStats()

#include "pycore_long.h" // _PyLong_GetZero()

#include "pycore_memoryobject.h" // _PyManagedBuffer_Type

#include "pycore_namespace.h" // _PyNamespace_Type

#include "pycore_object.h" // export _Py_SwappedOp

#include "pycore_optimizer.h" // _PyUOpExecutor_Type

#include "pycore_pyerrors.h" // _PyErr_Occurred()

#include "pycore_pymem.h" // _PyMem_IsPtrFreed()

#include "pycore_pystate.h" // _PyThreadState_GET()

#include "pycore_symtable.h" // PySTEntry_Type

#include "pycore_tuple.h" // _PyTuple_DebugMallocStats()

#include "pycore_typeobject.h" // _PyBufferWrapper_Type

#include "pycore_typevarobject.h" // _PyTypeAlias_Type

#include "pycore_unionobject.h" // _PyUnion_Type

#ifdef Py_LIMITED_API

// Prevent recursive call _Py_IncRef() <=> Py_INCREF()

# error "Py_LIMITED_API macro must not be defined"

#endif

/* Defined in tracemalloc.c */

extern void _PyMem_DumpTraceback(int fd, const void *ptr);

int

_PyObject_CheckConsistency(PyObject *op, int check_content)

{

#define CHECK(expr) \

do { if (!(expr)) { _PyObject_ASSERT_FAILED_MSG(op, Py_STRINGIFY(expr)); } } while (0)

CHECK(!_PyObject_IsFreed(op));

CHECK(Py_REFCNT(op) >= 1);

_PyType_CheckConsistency(Py_TYPE(op));

if (PyUnicode_Check(op)) {

_PyUnicode_CheckConsistency(op, check_content);

}

else if (PyDict_Check(op)) {

_PyDict_CheckConsistency(op, check_content);

}

return 1;

#undef CHECK

}

#ifdef Py_REF_DEBUG

/* We keep the legacy symbol around for backward compatibility. */

Py_ssize_t _Py_RefTotal;

static inline Py_ssize_t

get_legacy_reftotal(void)

{

return _Py_RefTotal;

}

#endif

#ifdef Py_REF_DEBUG

# define REFTOTAL(interp) \

interp->object_state.reftotal

static inline void

reftotal_add(PyThreadState *tstate, Py_ssize_t n)

{

#ifdef Py_GIL_DISABLED

_PyThreadStateImpl *tstate_impl = (_PyThreadStateImpl *)tstate;

// relaxed store to avoid data race with read in get_reftotal()

Py_ssize_t reftotal = tstate_impl->reftotal + n;

_Py_atomic_store_ssize_relaxed(&tstate_impl->reftotal, reftotal);

#else

REFTOTAL(tstate->interp) += n;

#endif

}

static inline Py_ssize_t get_global_reftotal(_PyRuntimeState *);

/* We preserve the number of refs leaked during runtime finalization,

so they can be reported if the runtime is initialized again. */

// XXX We don't lose any information by dropping this,

// so we should consider doing so.

static Py_ssize_t last_final_reftotal = 0;

void

_Py_FinalizeRefTotal(_PyRuntimeState *runtime)

{

last_final_reftotal = get_global_reftotal(runtime);

runtime->object_state.interpreter_leaks = 0;

}

void

_PyInterpreterState_FinalizeRefTotal(PyInterpreterState *interp)

{

interp->runtime->object_state.interpreter_leaks += REFTOTAL(interp);

REFTOTAL(interp) = 0;

}

static inline Py_ssize_t

get_reftotal(PyInterpreterState *interp)

{

/* For a single interpreter, we ignore the legacy _Py_RefTotal,

since we can't determine which interpreter updated it. */

Py_ssize_t total = REFTOTAL(interp);

#ifdef Py_GIL_DISABLED

_Py_FOR_EACH_TSTATE_UNLOCKED(interp, p) {

/* This may race with other threads modifications to their reftotal */

_PyThreadStateImpl *tstate_impl = (_PyThreadStateImpl *)p;

total += _Py_atomic_load_ssize_relaxed(&tstate_impl->reftotal);

}

#endif

return total;

}

static inline Py_ssize_t

get_global_reftotal(_PyRuntimeState *runtime)

{

Py_ssize_t total = 0;

/* Add up the total from each interpreter. */

HEAD_LOCK(&_PyRuntime);

PyInterpreterState *interp = PyInterpreterState_Head();

for (; interp != NULL; interp = PyInterpreterState_Next(interp)) {

total += get_reftotal(interp);

}

HEAD_UNLOCK(&_PyRuntime);

/* Add in the updated value from the legacy _Py_RefTotal. */

total += get_legacy_reftotal();

total += last_final_reftotal;

total += runtime->object_state.interpreter_leaks;

return total;

}

#undef REFTOTAL

void

_PyDebug_PrintTotalRefs(void) {

_PyRuntimeState *runtime = &_PyRuntime;

fprintf(stderr,

"[%zd refs, %zd blocks]\n",

get_global_reftotal(runtime), _Py_GetGlobalAllocatedBlocks());

/* It may be helpful to also print the "legacy" reftotal separately.

Likewise for the total for each interpreter. */

}

#endif /* Py_REF_DEBUG */

/* Object allocation routines used by NEWOBJ and NEWVAROBJ macros.

These are used by the individual routines for object creation.

Do not call them otherwise, they do not initialize the object! */

#ifdef Py_TRACE_REFS

#define REFCHAIN(interp) interp->object_state.refchain

#define REFCHAIN_VALUE ((void*)(uintptr_t)1)

static inline int

has_own_refchain(PyInterpreterState *interp)

{

if (interp->feature_flags & Py_RTFLAGS_USE_MAIN_OBMALLOC) {

return (_Py_IsMainInterpreter(interp)

|| _PyInterpreterState_Main() == NULL);

}

return 1;

}

static int

refchain_init(PyInterpreterState *interp)

{

if (!has_own_refchain(interp)) {

// Legacy subinterpreters share a refchain with the main interpreter.

REFCHAIN(interp) = REFCHAIN(_PyInterpreterState_Main());

return 0;

}

_Py_hashtable_allocator_t alloc = {

// Don't use default PyMem_Malloc() and PyMem_Free() which

// require the caller to hold the GIL.

.malloc = PyMem_RawMalloc,

.free = PyMem_RawFree,

};

REFCHAIN(interp) = _Py_hashtable_new_full(

_Py_hashtable_hash_ptr, _Py_hashtable_compare_direct,

NULL, NULL, &alloc);

if (REFCHAIN(interp) == NULL) {

return -1;

}

return 0;

}

static void

refchain_fini(PyInterpreterState *interp)

{

if (has_own_refchain(interp) && REFCHAIN(interp) != NULL) {

_Py_hashtable_destroy(REFCHAIN(interp));

}

REFCHAIN(interp) = NULL;

}

bool

_PyRefchain_IsTraced(PyInterpreterState *interp, PyObject *obj)

{

return (_Py_hashtable_get(REFCHAIN(interp), obj) == REFCHAIN_VALUE);

}

static void

_PyRefchain_Trace(PyInterpreterState *interp, PyObject *obj)

{

if (_Py_hashtable_set(REFCHAIN(interp), obj, REFCHAIN_VALUE) < 0) {

// Use a fatal error because _Py_NewReference() cannot report

// the error to the caller.

Py_FatalError("_Py_hashtable_set() memory allocation failed");

}

}

static void

_PyRefchain_Remove(PyInterpreterState *interp, PyObject *obj)

{

void *value = _Py_hashtable_steal(REFCHAIN(interp), obj);

#ifndef NDEBUG

assert(value == REFCHAIN_VALUE);

#else

(void)value;

#endif

}

/* Add an object to the refchain hash table.

*

* Note that objects are normally added to the list by PyObject_Init()

* indirectly. Not all objects are initialized that way, though; exceptions

* include statically allocated type objects, and statically allocated

* singletons (like Py_True and Py_None). */

void

_Py_AddToAllObjects(PyObject *op)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

if (!_PyRefchain_IsTraced(interp, op)) {

_PyRefchain_Trace(interp, op);

}

}

#endif /* Py_TRACE_REFS */

#ifdef Py_REF_DEBUG

/* Log a fatal error; doesn't return. */

void

_Py_NegativeRefcount(const char *filename, int lineno, PyObject *op)

{

_PyObject_AssertFailed(op, NULL, "object has negative ref count",

filename, lineno, __func__);

}

/* This is used strictly by Py_INCREF(). */

void

_Py_INCREF_IncRefTotal(void)

{

reftotal_add(_PyThreadState_GET(), 1);

}

/* This is used strictly by Py_DECREF(). */

void

_Py_DECREF_DecRefTotal(void)

{

reftotal_add(_PyThreadState_GET(), -1);

}

void

_Py_IncRefTotal(PyThreadState *tstate)

{

reftotal_add(tstate, 1);

}

void

_Py_DecRefTotal(PyThreadState *tstate)

{

reftotal_add(tstate, -1);

}

void

_Py_AddRefTotal(PyThreadState *tstate, Py_ssize_t n)

{

reftotal_add(tstate, n);

}

/* This includes the legacy total

and any carried over from the last runtime init/fini cycle. */

Py_ssize_t

_Py_GetGlobalRefTotal(void)

{

return get_global_reftotal(&_PyRuntime);

}

Py_ssize_t

_Py_GetLegacyRefTotal(void)

{

return get_legacy_reftotal();

}

Py_ssize_t

_PyInterpreterState_GetRefTotal(PyInterpreterState *interp)

{

HEAD_LOCK(&_PyRuntime);

Py_ssize_t total = get_reftotal(interp);

HEAD_UNLOCK(&_PyRuntime);

return total;

}

#endif /* Py_REF_DEBUG */

void

Py_IncRef(PyObject *o)

{

Py_XINCREF(o);

}

void

Py_DecRef(PyObject *o)

{

Py_XDECREF(o);

}

void

_Py_IncRef(PyObject *o)

{

Py_INCREF(o);

}

void

_Py_DecRef(PyObject *o)

{

Py_DECREF(o);

}

#ifdef Py_GIL_DISABLED

# ifdef Py_REF_DEBUG

static int

is_dead(PyObject *o)

{

# if SIZEOF_SIZE_T == 8

return (uintptr_t)o->ob_type == 0xDDDDDDDDDDDDDDDD;

# else

return (uintptr_t)o->ob_type == 0xDDDDDDDD;

# endif

}

# endif

// Decrement the shared reference count of an object. Return 1 if the object

// is dead and should be deallocated, 0 otherwise.

static int

_Py_DecRefSharedIsDead(PyObject *o, const char *filename, int lineno)

{

// Should we queue the object for the owning thread to merge?

int should_queue;

Py_ssize_t new_shared;

Py_ssize_t shared = _Py_atomic_load_ssize_relaxed(&o->ob_ref_shared);

do {

should_queue = (shared == 0 || shared == _Py_REF_MAYBE_WEAKREF);

if (should_queue) {

// If the object had refcount zero, not queued, and not merged,

// then we enqueue the object to be merged by the owning thread.

// In this case, we don't subtract one from the reference count

// because the queue holds a reference.

new_shared = _Py_REF_QUEUED;

}

else {

// Otherwise, subtract one from the reference count. This might

// be negative!

new_shared = shared - (1 << _Py_REF_SHARED_SHIFT);

}

#ifdef Py_REF_DEBUG

if ((new_shared < 0 && _Py_REF_IS_MERGED(new_shared)) ||

(should_queue && is_dead(o)))

{

_Py_NegativeRefcount(filename, lineno, o);

}

#endif

} while (!_Py_atomic_compare_exchange_ssize(&o->ob_ref_shared,

&shared, new_shared));

if (should_queue) {

#ifdef Py_REF_DEBUG

_Py_IncRefTotal(_PyThreadState_GET());

#endif

_Py_brc_queue_object(o);

}

else if (new_shared == _Py_REF_MERGED) {

// refcount is zero AND merged

return 1;

}

return 0;

}

void

_Py_DecRefSharedDebug(PyObject *o, const char *filename, int lineno)

{

if (_Py_DecRefSharedIsDead(o, filename, lineno)) {

_Py_Dealloc(o);

}

}

void

_Py_DecRefShared(PyObject *o)

{

_Py_DecRefSharedDebug(o, NULL, 0);

}

void

_Py_MergeZeroLocalRefcount(PyObject *op)

{

assert(op->ob_ref_local == 0);

Py_ssize_t shared = _Py_atomic_load_ssize_acquire(&op->ob_ref_shared);

if (shared == 0) {

// Fast-path: shared refcount is zero (including flags)

_Py_Dealloc(op);

return;

}

// gh-121794: This must be before the store to `ob_ref_shared` (gh-119999),

// but should outside the fast-path to maintain the invariant that

// a zero `ob_tid` implies a merged refcount.

_Py_atomic_store_uintptr_relaxed(&op->ob_tid, 0);

// Slow-path: atomically set the flags (low two bits) to _Py_REF_MERGED.

Py_ssize_t new_shared;

do {

new_shared = (shared & ~_Py_REF_SHARED_FLAG_MASK) | _Py_REF_MERGED;

} while (!_Py_atomic_compare_exchange_ssize(&op->ob_ref_shared,

&shared, new_shared));

if (new_shared == _Py_REF_MERGED) {

// i.e., the shared refcount is zero (only the flags are set) so we

// deallocate the object.

_Py_Dealloc(op);

}

}

Py_ssize_t

_Py_ExplicitMergeRefcount(PyObject *op, Py_ssize_t extra)

{

assert(!_Py_IsImmortal(op));

#ifdef Py_REF_DEBUG

_Py_AddRefTotal(_PyThreadState_GET(), extra);

#endif

// gh-119999: Write to ob_ref_local and ob_tid before merging the refcount.

Py_ssize_t local = (Py_ssize_t)op->ob_ref_local;

_Py_atomic_store_uint32_relaxed(&op->ob_ref_local, 0);

_Py_atomic_store_uintptr_relaxed(&op->ob_tid, 0);

Py_ssize_t refcnt;

Py_ssize_t new_shared;

Py_ssize_t shared = _Py_atomic_load_ssize_relaxed(&op->ob_ref_shared);

do {

refcnt = Py_ARITHMETIC_RIGHT_SHIFT(Py_ssize_t, shared, _Py_REF_SHARED_SHIFT);

refcnt += local;

refcnt += extra;

new_shared = _Py_REF_SHARED(refcnt, _Py_REF_MERGED);

} while (!_Py_atomic_compare_exchange_ssize(&op->ob_ref_shared,

&shared, new_shared));

return refcnt;

}

// The more complicated "slow" path for undoing the resurrection of an object.

int

_PyObject_ResurrectEndSlow(PyObject *op)

{

if (_Py_IsImmortal(op)) {

return 1;

}

if (_Py_IsOwnedByCurrentThread(op)) {

// If the object is owned by the current thread, give up ownership and

// merge the refcount. This isn't necessary in all cases, but it

// simplifies the implementation.

Py_ssize_t refcount = _Py_ExplicitMergeRefcount(op, -1);

if (refcount == 0) {

#ifdef Py_TRACE_REFS

_Py_ForgetReference(op);

#endif

return 0;

}

return 1;

}

int is_dead = _Py_DecRefSharedIsDead(op, NULL, 0);

if (is_dead) {

#ifdef Py_TRACE_REFS

_Py_ForgetReference(op);

#endif

return 0;

}

return 1;

}

#endif /* Py_GIL_DISABLED */

/**************************************/

PyObject *

PyObject_Init(PyObject *op, PyTypeObject *tp)

{

if (op == NULL) {

return PyErr_NoMemory();

}

_PyObject_Init(op, tp);

return op;

}

PyVarObject *

PyObject_InitVar(PyVarObject *op, PyTypeObject *tp, Py_ssize_t size)

{

if (op == NULL) {

return (PyVarObject *) PyErr_NoMemory();

}

_PyObject_InitVar(op, tp, size);

return op;

}

PyObject *

_PyObject_New(PyTypeObject *tp)

{

PyObject *op = (PyObject *) PyObject_Malloc(_PyObject_SIZE(tp));

if (op == NULL) {

return PyErr_NoMemory();

}

_PyObject_Init(op, tp);

return op;

}

PyVarObject *

_PyObject_NewVar(PyTypeObject *tp, Py_ssize_t nitems)

{

PyVarObject *op;

const size_t size = _PyObject_VAR_SIZE(tp, nitems);

op = (PyVarObject *) PyObject_Malloc(size);

if (op == NULL) {

return (PyVarObject *)PyErr_NoMemory();

}

_PyObject_InitVar(op, tp, nitems);

return op;

}

void

PyObject_CallFinalizer(PyObject *self)

{

PyTypeObject *tp = Py_TYPE(self);

if (tp->tp_finalize == NULL)

return;

/* tp_finalize should only be called once. */

if (_PyType_IS_GC(tp) && _PyGC_FINALIZED(self))

return;

tp->tp_finalize(self);

if (_PyType_IS_GC(tp)) {

_PyGC_SET_FINALIZED(self);

}

}

int

PyObject_CallFinalizerFromDealloc(PyObject *self)

{

if (Py_REFCNT(self) != 0) {

_PyObject_ASSERT_FAILED_MSG(self,

"PyObject_CallFinalizerFromDealloc called "

"on object with a non-zero refcount");

}

/* Temporarily resurrect the object. */

_PyObject_ResurrectStart(self);

PyObject_CallFinalizer(self);

_PyObject_ASSERT_WITH_MSG(self,

Py_REFCNT(self) > 0,

"refcount is too small");

_PyObject_ASSERT(self,

(!_PyType_IS_GC(Py_TYPE(self))

|| _PyObject_GC_IS_TRACKED(self)));

/* Undo the temporary resurrection; can't use DECREF here, it would

* cause a recursive call. */

if (_PyObject_ResurrectEnd(self)) {

/* tp_finalize resurrected it!

gh-130202: Note that the object may still be dead in the free

threaded build in some circumstances, so it's not safe to access

`self` after this point. For example, the last reference to the

resurrected `self` may be held by another thread, which can

concurrently deallocate it. */

return -1;

}

/* this is the normal path out, the caller continues with deallocation. */

return 0;

}

int

PyObject_Print(PyObject *op, FILE *fp, int flags)

{

int ret = 0;

int write_error = 0;

if (PyErr_CheckSignals())

return -1;

if (_Py_EnterRecursiveCall(" printing an object")) {

return -1;

}

clearerr(fp); /* Clear any previous error condition */

if (op == NULL) {

Py_BEGIN_ALLOW_THREADS

fprintf(fp, "<nil>");

Py_END_ALLOW_THREADS

}

else {

if (Py_REFCNT(op) <= 0) {

Py_BEGIN_ALLOW_THREADS

fprintf(fp, "<refcnt %zd at %p>", Py_REFCNT(op), (void *)op);

Py_END_ALLOW_THREADS

}

else {

PyObject *s;

if (flags & Py_PRINT_RAW)

s = PyObject_Str(op);

else

s = PyObject_Repr(op);

if (s == NULL) {

ret = -1;

}

else {

assert(PyUnicode_Check(s));

const char *t;

Py_ssize_t len;

t = PyUnicode_AsUTF8AndSize(s, &len);

if (t == NULL) {

ret = -1;

}

else {

/* Versions of Android and OpenBSD from before 2023 fail to

set the `ferror` indicator when writing to a read-only

stream, so we need to check the return value.

(https://github.com/openbsd/src/commit/fc99cf9338942ecd9adc94ea08bf6188f0428c15) */

if (fwrite(t, 1, len, fp) != (size_t)len) {

write_error = 1;

}

}

Py_DECREF(s);

}

}

}

if (ret == 0) {

if (write_error || ferror(fp)) {

PyErr_SetFromErrno(PyExc_OSError);

clearerr(fp);

ret = -1;

}

}

return ret;

}

/* For debugging convenience. Set a breakpoint here and call it from your DLL */

void

_Py_BreakPoint(void)

{

}

/* Heuristic checking if the object memory is uninitialized or deallocated.

Rely on the debug hooks on Python memory allocators:

see _PyMem_IsPtrFreed().

The function can be used to prevent segmentation fault on dereferencing

pointers like 0xDDDDDDDDDDDDDDDD. */

int

_PyObject_IsFreed(PyObject *op)

{

if (_PyMem_IsPtrFreed(op) || _PyMem_IsPtrFreed(Py_TYPE(op))) {

return 1;

}

return 0;

}

/* For debugging convenience. See Misc/gdbinit for some useful gdb hooks */

void

_PyObject_Dump(PyObject* op)

{

if (_PyObject_IsFreed(op)) {

/* It seems like the object memory has been freed:

don't access it to prevent a segmentation fault. */

fprintf(stderr, "<object at %p is freed>\n", op);

fflush(stderr);

return;

}

/* first, write fields which are the least likely to crash */

fprintf(stderr, "object address : %p\n", (void *)op);

fprintf(stderr, "object refcount : %zd\n", Py_REFCNT(op));

fflush(stderr);

PyTypeObject *type = Py_TYPE(op);

fprintf(stderr, "object type : %p\n", type);

fprintf(stderr, "object type name: %s\n",

type==NULL ? "NULL" : type->tp_name);

/* the most dangerous part */

fprintf(stderr, "object repr : ");

fflush(stderr);

PyGILState_STATE gil = PyGILState_Ensure();

PyObject *exc = PyErr_GetRaisedException();

(void)PyObject_Print(op, stderr, 0);

fflush(stderr);

PyErr_SetRaisedException(exc);

PyGILState_Release(gil);

fprintf(stderr, "\n");

fflush(stderr);

}

PyObject *

PyObject_Repr(PyObject *v)

{

PyObject *res;

if (PyErr_CheckSignals())

return NULL;

if (v == NULL)

return PyUnicode_FromString("<NULL>");

if (Py_TYPE(v)->tp_repr == NULL)

return PyUnicode_FromFormat("<%s object at %p>",

Py_TYPE(v)->tp_name, v);

PyThreadState *tstate = _PyThreadState_GET();

#ifdef Py_DEBUG

/* PyObject_Repr() must not be called with an exception set,

because it can clear it (directly or indirectly) and so the

caller loses its exception */

assert(!_PyErr_Occurred(tstate));

#endif

/* It is possible for a type to have a tp_repr representation that loops

infinitely. */

if (_Py_EnterRecursiveCallTstate(tstate,

" while getting the repr of an object")) {

return NULL;

}

res = (*Py_TYPE(v)->tp_repr)(v);

_Py_LeaveRecursiveCallTstate(tstate);

if (res == NULL) {

return NULL;

}

if (!PyUnicode_Check(res)) {

_PyErr_Format(tstate, PyExc_TypeError,

"__repr__ returned non-string (type %.200s)",

Py_TYPE(res)->tp_name);

Py_DECREF(res);

return NULL;

}

return res;

}

PyObject *

PyObject_Str(PyObject *v)

{

PyObject *res;

if (PyErr_CheckSignals())

return NULL;

if (v == NULL)

return PyUnicode_FromString("<NULL>");

if (PyUnicode_CheckExact(v)) {

return Py_NewRef(v);

}

if (Py_TYPE(v)->tp_str == NULL)

return PyObject_Repr(v);

PyThreadState *tstate = _PyThreadState_GET();

#ifdef Py_DEBUG

/* PyObject_Str() must not be called with an exception set,

because it can clear it (directly or indirectly) and so the

caller loses its exception */

assert(!_PyErr_Occurred(tstate));

#endif

/* It is possible for a type to have a tp_str representation that loops

infinitely. */

if (_Py_EnterRecursiveCallTstate(tstate, " while getting the str of an object")) {

return NULL;

}

res = (*Py_TYPE(v)->tp_str)(v);

_Py_LeaveRecursiveCallTstate(tstate);

if (res == NULL) {

return NULL;

}

if (!PyUnicode_Check(res)) {

_PyErr_Format(tstate, PyExc_TypeError,

"__str__ returned non-string (type %.200s)",

Py_TYPE(res)->tp_name);

Py_DECREF(res);

return NULL;

}

assert(_PyUnicode_CheckConsistency(res, 1));

return res;

}

PyObject *

PyObject_ASCII(PyObject *v)

{

PyObject *repr, *ascii, *res;

repr = PyObject_Repr(v);

if (repr == NULL)

return NULL;

if (PyUnicode_IS_ASCII(repr))

return repr;

/* repr is guaranteed to be a PyUnicode object by PyObject_Repr */

ascii = _PyUnicode_AsASCIIString(repr, "backslashreplace");

Py_DECREF(repr);

if (ascii == NULL)

return NULL;

res = PyUnicode_DecodeASCII(

PyBytes_AS_STRING(ascii),

PyBytes_GET_SIZE(ascii),

NULL);

Py_DECREF(ascii);

return res;

}

PyObject *

PyObject_Bytes(PyObject *v)

{

PyObject *result, *func;

if (v == NULL)

return PyBytes_FromString("<NULL>");

if (PyBytes_CheckExact(v)) {

return Py_NewRef(v);

}

func = _PyObject_LookupSpecial(v, &_Py_ID(__bytes__));

if (func != NULL) {

result = _PyObject_CallNoArgs(func);

Py_DECREF(func);

if (result == NULL)

return NULL;

if (!PyBytes_Check(result)) {

PyErr_Format(PyExc_TypeError,

"__bytes__ returned non-bytes (type %.200s)",

Py_TYPE(result)->tp_name);

Py_DECREF(result);

return NULL;

}

return result;

}

else if (PyErr_Occurred())

return NULL;

return PyBytes_FromObject(v);

}

static void

clear_freelist(struct _Py_freelist *freelist, int is_finalization,

freefunc dofree)

{

void *ptr;

while ((ptr = _PyFreeList_PopNoStats(freelist)) != NULL) {

dofree(ptr);

}

assert(freelist->size == 0 || freelist->size == -1);

assert(freelist->freelist == NULL);

if (is_finalization) {

freelist->size = -1;

}

}

static void

free_object(void *obj)

{

PyObject *op = (PyObject *)obj;

PyTypeObject *tp = Py_TYPE(op);

tp->tp_free(op);

Py_DECREF(tp);

}

void

_PyObject_ClearFreeLists(struct _Py_freelists *freelists, int is_finalization)

{

// In the free-threaded build, freelists are per-PyThreadState and cleared in PyThreadState_Clear()

// In the default build, freelists are per-interpreter and cleared in finalize_interp_types()

clear_freelist(&freelists->floats, is_finalization, free_object);

for (Py_ssize_t i = 0; i < PyTuple_MAXSAVESIZE; i++) {

clear_freelist(&freelists->tuples[i], is_finalization, free_object);

}

clear_freelist(&freelists->lists, is_finalization, free_object);

clear_freelist(&freelists->list_iters, is_finalization, free_object);

clear_freelist(&freelists->tuple_iters, is_finalization, free_object);

clear_freelist(&freelists->dicts, is_finalization, free_object);

clear_freelist(&freelists->dictkeys, is_finalization, PyMem_Free);

clear_freelist(&freelists->slices, is_finalization, free_object);

clear_freelist(&freelists->contexts, is_finalization, free_object);

clear_freelist(&freelists->async_gens, is_finalization, free_object);

clear_freelist(&freelists->async_gen_asends, is_finalization, free_object);

clear_freelist(&freelists->futureiters, is_finalization, free_object);

if (is_finalization) {

// Only clear object stack chunks during finalization. We use object

// stacks during GC, so emptying the free-list is counterproductive.

clear_freelist(&freelists->object_stack_chunks, 1, PyMem_RawFree);

}

clear_freelist(&freelists->unicode_writers, is_finalization, PyMem_Free);

clear_freelist(&freelists->ints, is_finalization, free_object);

clear_freelist(&freelists->pycfunctionobject, is_finalization, PyObject_GC_Del);

clear_freelist(&freelists->pycmethodobject, is_finalization, PyObject_GC_Del);

clear_freelist(&freelists->pymethodobjects, is_finalization, free_object);

}

/*

def _PyObject_FunctionStr(x):

try:

qualname = x.__qualname__

except AttributeError:

return str(x)

try:

mod = x.__module__

if mod is not None and mod != 'builtins':

return f"{x.__module__}.{qualname}()"

except AttributeError:

pass

return qualname

*/

PyObject *

_PyObject_FunctionStr(PyObject *x)

{

assert(!PyErr_Occurred());

PyObject *qualname;

int ret = PyObject_GetOptionalAttr(x, &_Py_ID(__qualname__), &qualname);

if (qualname == NULL) {

if (ret < 0) {

return NULL;

}

return PyObject_Str(x);

}

PyObject *module;

PyObject *result = NULL;

ret = PyObject_GetOptionalAttr(x, &_Py_ID(__module__), &module);

if (module != NULL && module != Py_None) {

ret = PyObject_RichCompareBool(module, &_Py_ID(builtins), Py_NE);

if (ret < 0) {

// error

goto done;

}

if (ret > 0) {

result = PyUnicode_FromFormat("%S.%S()", module, qualname);

goto done;

}

}

else if (ret < 0) {

goto done;

}

result = PyUnicode_FromFormat("%S()", qualname);

done:

Py_DECREF(qualname);

Py_XDECREF(module);

return result;

}

/* For Python 3.0.1 and later, the old three-way comparison has been