Nuitka-winsvc 2.2.3__cp311-cp311-win_amd64.whl → 2.3.2__cp311-cp311-win_amd64.whl

nuitka/build/include/nuitka/prelude.h

@@ -106,12 +106,23 @@ extern _PyRuntimeState _PyRuntime;
 
 static inline size_t Nuitka_static_builtin_index_get(PyTypeObject *self) { return (size_t)self->tp_subclasses - 1; }
 
-static inline static_builtin_state *Nuitka_static_builtin_state_get(PyInterpreterState *interp, PyTypeObject *self) {
+// Changed internal type access for Python3.13
+#if PYTHON_VERSION < 0x3d0
+#define managed_static_type_state static_builtin_state
+
+static inline managed_static_type_state *Nuitka_static_builtin_state_get(PyInterpreterState *interp,
+                                                                         PyTypeObject *self) {
     return &(interp->types.builtins[Nuitka_static_builtin_index_get(self)]);
 }
+#else
+static inline managed_static_type_state *Nuitka_static_builtin_state_get(PyInterpreterState *interp,
+                                                                         PyTypeObject *self) {
+    return &(interp->types.builtins.initialized[Nuitka_static_builtin_index_get(self)]);
+}
+#endif
 
-NUITKA_MAY_BE_UNUSED static inline static_builtin_state *Nuitka_PyStaticType_GetState(PyInterpreterState *interp,
-                                                                                      PyTypeObject *self) {
+NUITKA_MAY_BE_UNUSED static inline managed_static_type_state *Nuitka_PyStaticType_GetState(PyInterpreterState *interp,
+                                                                                           PyTypeObject *self) {
     assert(self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN);
     return Nuitka_static_builtin_state_get(interp, self);
 }
@@ -148,7 +159,11 @@ NUITKA_MAY_BE_UNUSED static inline static_builtin_state *Nuitka_PyStaticType_Get
 
 // Uncompiled generator integration requires these.
 #if PYTHON_VERSION >= 0x3b0
+#if PYTHON_VERSION >= 0x3d0
+#include <opcode_ids.h>
+#else
 #include <internal/pycore_opcode.h>
+#endif
 // Clashes with our helper names.
 #undef CALL_FUNCTION
 #endif
@@ -170,6 +185,13 @@ NUITKA_MAY_BE_UNUSED static inline static_builtin_state *Nuitka_PyStaticType_Get
 #include <objimpl.h>
 #endif
 
+#if PYTHON_VERSION >= 0x3d0
+#include <internal/pycore_freelist.h>
+#include <internal/pycore_intrinsics.h>
+#include <internal/pycore_modsupport.h>
+#include <internal/pycore_setobject.h>
+#endif
+
 #undef Py_BUILD_CORE
 
 #endif
@@ -272,8 +294,15 @@ NUITKA_MAY_BE_UNUSED static inline bool Nuitka_StringOrUnicode_CheckExact(PyObje
 #define PyUnicode_UTF8(op)                                                                                             \
     (assert(PyUnicode_IS_READY(op)),                                                                                   \
      PyUnicode_IS_COMPACT_ASCII(op) ? ((char *)((PyASCIIObject *)(op) + 1)) : _PyUnicode_UTF8(op))
+#ifdef __NUITKA_NO_ASSERT__
 #define Nuitka_String_AsString_Unchecked PyUnicode_UTF8
-
+#else
+NUITKA_MAY_BE_UNUSED static char const *Nuitka_String_AsString_Unchecked(PyObject *object) {
+    char const *result = PyUnicode_UTF8(object);
+    assert(result != NULL);
+    return result;
+}
+#endif
 #define Nuitka_String_Check PyUnicode_Check
 #define Nuitka_String_CheckExact PyUnicode_CheckExact
 #define Nuitka_StringOrUnicode_CheckExact PyUnicode_CheckExact
@@ -412,6 +441,21 @@ extern PyThreadState *_PyThreadState_Current;
 #define PyFloat_SET_DOUBLE(op, value) ((PyFloatObject *)(op))->ob_fval = value
 #endif
 
+#ifndef Py_NewRef
+static inline PyObject *_Py_NewRef(PyObject *obj) {
+    Py_INCREF(obj);
+    return obj;
+}
+
+static inline PyObject *_Py_XNewRef(PyObject *obj) {
+    Py_XINCREF(obj);
+    return obj;
+}
+
+#define Py_NewRef(obj) _Py_NewRef((PyObject *)(obj))
+#define Py_XNewRef(obj) _Py_XNewRef((PyObject *)(obj))
+#endif
+
 // For older Python, we don't have a feature "CLASS" anymore, that's implied now.
 #if PYTHON_VERSION < 0x300
 #define NuitkaType_HasFeatureClass(descr) (PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))
@@ -452,7 +496,7 @@ typedef long nuitka_digit;
 #include "nuitka/compiled_function.h"
 
 /* Sentinel PyObject to be used for all our call iterator endings. */
-extern PyObject *_sentinel_value;
+extern PyObject *Nuitka_sentinel_value;
 
 /* Value to use for __compiled__ value of all modules. */
 extern PyObject *Nuitka_dunder_compiled_value;

nuitka/build/include/nuitka/safe_string_ops.h

@@ -19,6 +19,7 @@ extern void appendStringSafe(char *target, char const *source, size_t buffer_siz
 
 /* Safe to use functions to append a wide char string, will abort program for overflow. */
 extern void appendCharSafeW(wchar_t *target, char c, size_t buffer_size);
+extern void appendWCharSafeW(wchar_t *target, wchar_t c, size_t buffer_size);
 extern void appendStringSafeW(wchar_t *target, char const *source, size_t buffer_size);
 extern void appendWStringSafeW(wchar_t *target, wchar_t const *source, size_t buffer_size);
 

nuitka/build/include/nuitka/threading.h

@@ -14,19 +14,24 @@ extern volatile int _Py_Ticker;
 #ifdef NUITKA_USE_PYCORE_THREAD_STATE
 
 #if PYTHON_VERSION < 0x380
+
 // Signals pending got their own indicator only in 3.8, covered by calls to do before.
 #define HAS_WORK_TO_DO(ceval, ceval2) (ceval2->pending.calls_to_do._value)
-#else
+#elif PYTHON_VERSION < 0x3d0
 #define HAS_WORK_TO_DO(ceval, ceval2) (ceval->signals_pending._value || ceval2->pending.calls_to_do._value)
+#else
+#define HAS_WORK_TO_DO(ceval, ceval2) _Py_eval_breaker_bit_is_set(tstate, _PY_SIGNALS_PENDING_BIT | _PY_CALLS_TO_DO_BIT)
 #endif
 
+#ifndef Py_GIL_DISABLED
 NUITKA_MAY_BE_UNUSED static inline bool CONSIDER_THREADING(PyThreadState *tstate) {
-#if PYTHON_VERSION >= 0x390
-    _PyRuntimeState *const runtime = tstate->interp->runtime;
-#else
+#if PYTHON_VERSION < 0x390
     _PyRuntimeState *const runtime = &_PyRuntime;
+#else
+    _PyRuntimeState *const runtime = tstate->interp->runtime;
 #endif
 
+#if PYTHON_VERSION < 0x3d0
     // This was split in 2 parts in 3.9 or higher.
     struct _ceval_runtime_state *ceval = &runtime->ceval;
 #if PYTHON_VERSION >= 0x390
@@ -34,7 +39,7 @@ NUITKA_MAY_BE_UNUSED static inline bool CONSIDER_THREADING(PyThreadState *tstate
 #else
     struct _ceval_runtime_state *ceval2 = ceval;
 #endif
-
+#endif
     // Pending signals or calls to do
     if (HAS_WORK_TO_DO(ceval, ceval2)) {
         int res = Py_MakePendingCalls();
@@ -44,12 +49,9 @@ NUITKA_MAY_BE_UNUSED static inline bool CONSIDER_THREADING(PyThreadState *tstate
         }
     }
 
-#ifdef PY_NOGIL
-    /* load eval breaker */
-    uintptr_t b = _Py_atomic_load_uintptr(&tstate->eval_breaker);
-
+#if PYTHON_VERSION >= 0x3d0
     /* GIL drop request */
-    if ((b & EVAL_PENDING_SIGNALS) != 0) {
+    if (_Py_eval_breaker_bit_is_set(tstate, _PY_GIL_DROP_REQUEST_BIT)) {
 #else
     /* GIL drop request */
     if (ceval2->gil_drop_request._value) {
@@ -70,6 +72,7 @@ NUITKA_MAY_BE_UNUSED static inline bool CONSIDER_THREADING(PyThreadState *tstate
 
     return true;
 }
+#endif
 
 #else
 

nuitka/build/static_src/CompiledAsyncgenType.c

@@ -124,7 +124,7 @@ static PyObject *Nuitka_Asyncgen_get_ag_await(struct Nuitka_AsyncgenObject *asyn
         Py_INCREF(asyncgen->m_yield_from);
         return asyncgen->m_yield_from;
     } else {
-        Py_INCREF(Py_None);
+        Py_INCREF_IMMORTAL(Py_None);
         return Py_None;
     }
 }
@@ -154,7 +154,7 @@ static PyObject *Nuitka_Asyncgen_get_frame(struct Nuitka_AsyncgenObject *asyncge
         Py_INCREF(asyncgen->m_frame);
         return (PyObject *)asyncgen->m_frame;
     } else {
-        Py_INCREF(Py_None);
+        Py_INCREF_IMMORTAL(Py_None);
         return Py_None;
     }
 }
@@ -1352,7 +1352,13 @@ struct _PyAsyncGenWrappedValue {
         PyObject *agw_val;
 };
 
+#if PYTHON_VERSION < 0x3d0
 #define _PyAsyncGenWrappedValue_CheckExact(o) (Py_TYPE(o) == &_PyAsyncGenWrappedValue_Type)
+#else
+static PyTypeObject *Nuitka_PyAsyncGenWrappedValue_Type = NULL;
+
+#define _PyAsyncGenWrappedValue_CheckExact(o) (Py_TYPE(o) == Nuitka_PyAsyncGenWrappedValue_Type)
+#endif
 
 static PyObject *_Nuitka_Asyncgen_unwrap_value(PyThreadState *tstate, struct Nuitka_AsyncgenObject *asyncgen,
                                                PyObject *result) {
@@ -1378,9 +1384,7 @@ static PyObject *_Nuitka_Asyncgen_unwrap_value(PyThreadState *tstate, struct Nui
 
     if (_PyAsyncGenWrappedValue_CheckExact(result)) {
         /* async yield */
-        // TODO: Unify with coroutines and generators, who do things manually with a shared
-        // helper, "Nuitka_SetStopIterationValue" should be usable instead.
-        _PyGen_SetStopIterationValue(((struct _PyAsyncGenWrappedValue *)result)->agw_val);
+        Nuitka_SetStopIterationValue(tstate, ((struct _PyAsyncGenWrappedValue *)result)->agw_val);
 
         Py_DECREF(result);
 
@@ -1390,7 +1394,7 @@ static PyObject *_Nuitka_Asyncgen_unwrap_value(PyThreadState *tstate, struct Nui
         return NULL;
     } else if (Nuitka_AsyncgenWrappedValue_CheckExact(result)) {
         /* async yield */
-        _PyGen_SetStopIterationValue(((struct Nuitka_AsyncgenWrappedValueObject *)result)->m_value);
+        Nuitka_SetStopIterationValue(tstate, ((struct Nuitka_AsyncgenWrappedValueObject *)result)->m_value);
 
         Py_DECREF(result);
 
@@ -1642,7 +1646,7 @@ static PyObject *_Nuitka_AsyncgenAsend_throw2(PyThreadState *tstate, struct Nuit
 static PyObject *Nuitka_AsyncgenAsend_close(struct Nuitka_AsyncgenAsendObject *asyncgen_asend, PyObject *args) {
     asyncgen_asend->m_state = AWAITABLE_STATE_CLOSED;
 
-    Py_INCREF(Py_None);
+    Py_INCREF_IMMORTAL(Py_None);
     return Py_None;
 }
 
@@ -2049,7 +2053,7 @@ static PyObject *Nuitka_AsyncgenAthrow_tp_iternext(struct Nuitka_AsyncgenAthrowO
 static PyObject *Nuitka_AsyncgenAthrow_close(struct Nuitka_AsyncgenAthrowObject *asyncgen_athrow) {
     asyncgen_athrow->m_state = AWAITABLE_STATE_CLOSED;
 
-    Py_INCREF(Py_None);
+    Py_INCREF_IMMORTAL(Py_None);
     return Py_None;
 }
 
@@ -2180,6 +2184,13 @@ static void _initCompiledAsyncgenTypes(void) {
     Nuitka_PyType_Ready(&Nuitka_AsyncgenAsend_Type, NULL, true, false, true, true, false);
     Nuitka_PyType_Ready(&Nuitka_AsyncgenAthrow_Type, NULL, true, false, true, true, false);
     Nuitka_PyType_Ready(&Nuitka_AsyncgenValueWrapper_Type, NULL, false, false, false, false, false);
+
+#if PYTHON_VERSION >= 0x3d0
+    PyThreadState *tstate = PyThreadState_GET();
+    PyObject *asyncgen_wrapper_object = _PyIntrinsics_UnaryFunctions[INTRINSIC_ASYNC_GEN_WRAP].func(tstate, Py_None);
+    Nuitka_PyAsyncGenWrappedValue_Type = Py_TYPE(asyncgen_wrapper_object);
+    Py_DECREF(asyncgen_wrapper_object);
+#endif
 }
 
 //     Part of "Nuitka", an optimizing Python compiler that is compatible and

nuitka/build/static_src/CompiledCellType.c

@@ -124,7 +124,7 @@ static PyObject *Nuitka_Cell_tp_richcompare(PyObject *a, PyObject *b, int op) {
         return NULL;
     }
 
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 #endif

nuitka/build/static_src/CompiledCodeHelpers.c

@@ -30,7 +30,7 @@ static void _initBuiltinTypeMethods(void) {
     _initListBuiltinMethods();
 }
 
-#if PYTHON_VERSION >= 0x3b0
+#if PYTHON_VERSION >= 0x350
 #include "HelpersAllocator.c"
 #endif
 
@@ -81,7 +81,7 @@ static PyObject *_BUILTIN_RANGE_INT3(long low, long high, long step) {
         size = ESTIMATE_RANGE(high, low, -step);
     }
 
-    PyObject *result = MAKE_LIST_EMPTY(size);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, size);
 
     long current = low;
 
@@ -96,7 +96,7 @@ static PyObject *_BUILTIN_RANGE_INT3(long low, long high, long step) {
 static PyObject *_BUILTIN_RANGE_INT2(long low, long high) { return _BUILTIN_RANGE_INT3(low, high, 1); }
 
 static PyObject *_BUILTIN_RANGE_INT(long boundary) {
-    PyObject *result = MAKE_LIST_EMPTY(boundary > 0 ? boundary : 0);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, boundary > 0 ? boundary : 0);
 
     for (int i = 0; i < boundary; i++) {
         PyList_SET_ITEM(result, i, PyInt_FromLong(i));
@@ -191,7 +191,7 @@ PyObject *BUILTIN_RANGE2(PyThreadState *tstate, PyObject *low, PyObject *high) {
 
     if (fallback) {
         // Transfers references to tuple.
-        PyObject *pos_args = MAKE_TUPLE2_0(low_temp, high_temp);
+        PyObject *pos_args = MAKE_TUPLE2_0(tstate, low_temp, high_temp);
         NUITKA_ASSIGN_BUILTIN(range);
 
         PyObject *result = CALL_FUNCTION_WITH_POSARGS2(tstate, NUITKA_ACCESS_BUILTIN(range), pos_args);
@@ -250,7 +250,7 @@ PyObject *BUILTIN_RANGE3(PyThreadState *tstate, PyObject *low, PyObject *high, P
     }
 
     if (fallback) {
-        PyObject *pos_args = MAKE_TUPLE3_0(low_temp, high_temp, step_temp);
+        PyObject *pos_args = MAKE_TUPLE3_0(tstate, low_temp, high_temp, step_temp);
 
         NUITKA_ASSIGN_BUILTIN(range);
 
@@ -585,7 +585,7 @@ PyObject *BUILTIN_ALL(PyThreadState *tstate, PyObject *value) {
 
         if (cmp == 0) {
             Py_DECREF(it);
-            Py_INCREF(Py_False);
+            Py_INCREF_IMMORTAL(Py_False);
             return Py_False;
         }
     }
@@ -596,7 +596,7 @@ PyObject *BUILTIN_ALL(PyThreadState *tstate, PyObject *value) {
         return NULL;
     }
 
-    Py_INCREF(Py_True);
+    Py_INCREF_IMMORTAL(Py_True);
     return Py_True;
 }
 
@@ -635,7 +635,7 @@ PyObject *BUILTIN_ANY(PyThreadState *tstate, PyObject *value) {
         }
         if (cmp > 0) {
             Py_DECREF(it);
-            Py_INCREF(Py_True);
+            Py_INCREF_IMMORTAL(Py_True);
             return Py_True;
         }
     }
@@ -645,7 +645,7 @@ PyObject *BUILTIN_ANY(PyThreadState *tstate, PyObject *value) {
         return NULL;
     }
 
-    Py_INCREF(Py_False);
+    Py_INCREF_IMMORTAL(Py_False);
     return Py_False;
 }
 
@@ -808,7 +808,7 @@ bool PRINT_ITEM_TO(PyObject *file, PyObject *object) {
     FETCH_ERROR_OCCURRED_STATE_UNTRACED(tstate, &saved_exception_state);
 
     // TODO: Have a helper that creates a dictionary for PyObject **
-    PyObject *print_kw = MAKE_DICT_EMPTY();
+    PyObject *print_kw = MAKE_DICT_EMPTY(tstate);
     DICT_SET_ITEM(print_kw, const_str_plain_end, const_str_empty);
 
     if (file == NULL) {
@@ -817,7 +817,7 @@ bool PRINT_ITEM_TO(PyObject *file, PyObject *object) {
         DICT_SET_ITEM(print_kw, const_str_plain_file, file);
     }
 
-    PyObject *print_args = MAKE_TUPLE1(object);
+    PyObject *print_args = MAKE_TUPLE1(tstate, object);
 
     PyObject *result = CALL_FUNCTION(tstate, NUITKA_ACCESS_BUILTIN(print), print_args, print_kw);
 
@@ -967,7 +967,7 @@ void PRINT_TRACEBACK(PyTracebackObject *traceback) {
         PyFrameObject *frame = traceback->tb_frame;
 
         while (frame != NULL) {
-            printf("  Frame at %s\n", PyString_AsString(PyObject_Str((PyObject *)frame->f_code)));
+            printf("  Frame at %s\n", PyString_AsString(PyObject_Str((PyObject *)Nuitka_Frame_GetCodeObject(frame))));
 
             frame = frame->f_back;
         }
@@ -1160,7 +1160,7 @@ static PyObject *nuitka_class_getattr(PyClassObject *klass, PyObject *attr_name)
             return klass->cl_bases;
         } else if (strcmp(sattr_name, "__name__") == 0) {
             if (klass->cl_name == NULL) {
-                Py_INCREF(Py_None);
+                Py_INCREF_IMMORTAL(Py_None);
                 return Py_None;
             } else {
                 Py_INCREF(klass->cl_name);
@@ -1382,7 +1382,7 @@ PyObject *BUILTIN_SUM1(PyThreadState *tstate, PyObject *sequence) {
 #endif
 
         if (item == Py_False) {
-            Py_DECREF(item);
+            Py_DECREF_IMMORTAL(item);
             continue;
         }
 
@@ -1459,7 +1459,7 @@ PyObject *BUILTIN_SUM2(PyThreadState *tstate, PyObject *sequence, PyObject *star
     CHECK_OBJECT(sequence);
     CHECK_OBJECT(start);
 
-    PyObject *pos_args = MAKE_TUPLE2(sequence, start);
+    PyObject *pos_args = MAKE_TUPLE2(tstate, sequence, start);
 
     PyObject *result = CALL_FUNCTION_WITH_POSARGS2(tstate, NUITKA_ACCESS_BUILTIN(sum), pos_args);
 
@@ -2002,7 +2002,9 @@ volatile int _Py_Ticker = _Py_CheckInterval;
 iternextfunc default_iternext;
 
 void _initSlotIterNext(void) {
-    PyObject *pos_args = MAKE_TUPLE1((PyObject *)&PyBaseObject_Type);
+    PyThreadState *tstate = PyThreadState_GET();
+
+    PyObject *pos_args = MAKE_TUPLE1(tstate, (PyObject *)&PyBaseObject_Type);
 
     // Note: Not using MAKE_DICT_EMPTY on purpose, this is called early on.
     PyObject *kw_args = PyDict_New();

nuitka/build/static_src/CompiledCoroutineType.c

@@ -124,7 +124,7 @@ static PyObject *Nuitka_Coroutine_get_cr_await(struct Nuitka_CoroutineObject *co
         Py_INCREF(coroutine->m_yield_from);
         return coroutine->m_yield_from;
     } else {
-        Py_INCREF(Py_None);
+        Py_INCREF_IMMORTAL(Py_None);
         return Py_None;
     }
 }
@@ -154,7 +154,7 @@ static PyObject *Nuitka_Coroutine_get_frame(struct Nuitka_CoroutineObject *corou
         Py_INCREF(coroutine->m_frame);
         return (PyObject *)coroutine->m_frame;
     } else {
-        Py_INCREF(Py_None);
+        Py_INCREF_IMMORTAL(Py_None);
         return Py_None;
     }
 }
@@ -222,7 +222,7 @@ static PyObject *_Nuitka_YieldFromCore(PyThreadState *tstate, PyObject *yield_fr
         struct Nuitka_CoroutineObject *yieldfrom_coroutine =
             ((struct Nuitka_CoroutineWrapperObject *)yield_from)->m_coroutine;
 
-        Py_INCREF(Py_None);
+        Py_INCREF_IMMORTAL(Py_None);
 
         struct Nuitka_ExceptionPreservationItem no_exception_state;
         INIT_ERROR_OCCURRED_STATE(&no_exception_state);
@@ -245,7 +245,7 @@ static PyObject *_Nuitka_YieldFromCore(PyThreadState *tstate, PyObject *yield_fr
         PyObject *error = GET_ERROR_OCCURRED(tstate);
 
         if (error == NULL) {
-            Py_INCREF(Py_None);
+            Py_INCREF_IMMORTAL(Py_None);
             *returned_value = Py_None;
         } else if (likely(EXCEPTION_MATCH_BOOL_SINGLE(tstate, error, PyExc_StopIteration))) {
             // The sub-generator has given an exception. In case of
@@ -593,9 +593,7 @@ static PyObject *_Nuitka_Coroutine_send(PyThreadState *tstate, struct Nuitka_Cor
 
     switch (res) {
     case PYGEN_RETURN:
-        if (result == NULL) {
-            SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopIteration);
-        } else {
+        if (result != NULL) {
             if (result != Py_None) {
                 Nuitka_SetStopIterationValue(tstate, result);
             }
@@ -670,7 +668,7 @@ static PyObject *Nuitka_Coroutine_close(struct Nuitka_CoroutineObject *coroutine
     if (unlikely(r == false)) {
         return NULL;
     } else {
-        Py_INCREF(Py_None);
+        Py_INCREF_IMMORTAL(Py_None);
         return Py_None;
     }
 }
@@ -1353,12 +1351,15 @@ static int Nuitka_PyInterpreterFrame_GetLine(_PyInterpreterFrame *frame) {
     // we have the line number stored.
 
     int addr = _PyInterpreterFrame_LASTI(frame) * sizeof(_Py_CODEUNIT);
+#if PYTHON_VERSION < 0x3d0
     return PyCode_Addr2Line(frame->f_code, addr);
+#else
+    return PyCode_Addr2Line((PyCodeObject *)frame->f_executable, addr);
+#endif
 }
 
-static PyObject *computeCoroutineOrigin(int origin_depth) {
-    PyThreadState *tstate = _PyThreadState_GET();
-    _PyInterpreterFrame *current_frame = tstate->cframe->current_frame;
+static PyObject *computeCoroutineOrigin(PyThreadState *tstate, int origin_depth) {
+    _PyInterpreterFrame *current_frame = CURRENT_TSTATE_INTERPRETER_FRAME(tstate);
 
     // Create result tuple with correct size.
     int frame_count = 0;
@@ -1367,11 +1368,11 @@ static PyObject *computeCoroutineOrigin(int origin_depth) {
         frame = frame->previous;
         frame_count += 1;
     }
-    PyObject *cr_origin = MAKE_TUPLE_EMPTY_VAR(frame_count);
+    PyObject *cr_origin = MAKE_TUPLE_EMPTY_VAR(tstate, frame_count);
 
     frame = current_frame;
     for (int i = 0; i < frame_count; i++) {
-        PyCodeObject *code = frame->f_code;
+        PyCodeObject *code = Nuitka_InterpreterFrame_GetCodeObject(frame);
 
         int line = Nuitka_PyInterpreterFrame_GetLine(frame);
 
@@ -1386,7 +1387,7 @@ static PyObject *computeCoroutineOrigin(int origin_depth) {
 }
 
 #elif PYTHON_VERSION >= 0x370
-static PyObject *computeCoroutineOrigin(int origin_depth) {
+static PyObject *computeCoroutineOrigin(PyThreadState *tstate, int origin_depth) {
     PyFrameObject *frame = PyEval_GetFrame();
 
     int frame_count = 0;
@@ -1396,13 +1397,13 @@ static PyObject *computeCoroutineOrigin(int origin_depth) {
         frame_count += 1;
     }
 
-    PyObject *cr_origin = MAKE_TUPLE_EMPTY(frame_count);
+    PyObject *cr_origin = MAKE_TUPLE_EMPTY(tstate, frame_count);
 
     frame = PyEval_GetFrame();
 
     for (int i = 0; i < frame_count; i++) {
-        PyObject *frame_info =
-            Py_BuildValue("OiO", frame->f_code->co_filename, PyFrame_GetLineNumber(frame), frame->f_code->co_name);
+        PyObject *frame_info = Py_BuildValue("OiO", Nuitka_Frame_GetCodeObject(frame)->co_filename,
+                                             PyFrame_GetLineNumber(frame), frame->f_code->co_name);
 
         assert(frame_info);
 
@@ -1478,7 +1479,7 @@ PyObject *Nuitka_Coroutine_New(PyThreadState *tstate, coroutine_code code, PyObj
     if (origin_depth == 0) {
         result->m_origin = NULL;
     } else {
-        result->m_origin = computeCoroutineOrigin(origin_depth);
+        result->m_origin = computeCoroutineOrigin(tstate, origin_depth);
     }
 #endif
 
@@ -1496,9 +1497,12 @@ PyObject *Nuitka_Coroutine_New(PyThreadState *tstate, coroutine_code code, PyObj
 static inline PyCodeObject *_Nuitka_PyGen_GetCode(PyGenObject *gen) {
 #if PYTHON_VERSION < 0x3c0
     return (PyCodeObject *)gen->gi_code;
-#else
+#elif PYTHON_VERSION < 0x3d0
     _PyInterpreterFrame *frame = (_PyInterpreterFrame *)(gen->gi_iframe);
     return frame->f_code;
+#else
+    _PyInterpreterFrame *frame = (_PyInterpreterFrame *)(gen->gi_iframe);
+    return (PyCodeObject *)frame->f_executable;
 #endif
 }