Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.4.8__cp311-cp311-win_amd64.whl

nuitka/build/static_src/CompiledGeneratorTypeUncompiledIntegration.c

@@ -1,20 +1,5 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     Part of "Nuitka", an optimizing Python compiler that is compatible and
-//     integrates with CPython, but also works on its own.
-//
-//     Licensed under the Apache License, Version 2.0 (the "License");
-//     you may not use this file except in compliance with the License.
-//     You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//     Unless required by applicable law or agreed to in writing, software
-//     distributed under the License is distributed on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//     See the License for the specific language governing permissions and
-//     limitations under the License.
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
 /** Uncompiled generator integration
  *
  * This is for use in compiled generator, coroutine, async types. The file in
@@ -34,9 +19,39 @@
 #undef Py_BUILD_CORE
 #endif
 
+#if PYTHON_VERSION >= 0x300
+static PyObject *Nuitka_CallGeneratorThrowMethod(PyObject *throw_method,
+                                                 struct Nuitka_ExceptionPreservationItem *exception_state);
+#endif
+
+#if PYTHON_VERSION >= 0x300
+static PyBaseExceptionObject *Nuitka_BaseExceptionSingleArg_new(PyThreadState *tstate, PyTypeObject *type,
+                                                                PyObject *arg) {
+    PyBaseExceptionObject *result = (PyBaseExceptionObject *)type->tp_alloc(type, 0);
+
+    result->dict = NULL;
+    result->traceback = NULL;
+    result->cause = NULL;
+    result->context = NULL;
+    result->suppress_context = 0;
+
+    result->args = MAKE_TUPLE1(tstate, arg);
+
+    return result;
+}
+
+static PyObject *Nuitka_CreateStopIteration(PyThreadState *tstate, PyObject *value) {
+    PyStopIterationObject *result =
+        (PyStopIterationObject *)Nuitka_BaseExceptionSingleArg_new(tstate, (PyTypeObject *)PyExc_StopIteration, value);
+
+    result->value = value;
+    Py_INCREF(value);
+
+    return (PyObject *)result;
+}
+
 // This function takes no reference to value, and publishes a StopIteration
 // exception with it.
-#if PYTHON_VERSION >= 0x300
 static void Nuitka_SetStopIterationValue(PyThreadState *tstate, PyObject *value) {
     CHECK_OBJECT(value);
 
@@ -47,8 +62,11 @@ static void Nuitka_SetStopIterationValue(PyThreadState *tstate, PyObject *value)
         return;
     }
 
-    Py_INCREF(PyExc_StopIteration);
-    RESTORE_ERROR_OCCURRED(tstate, PyExc_StopIteration, stop_value, NULL);
+    SET_CURRENT_EXCEPTION_TYPE0_VALUE1(tstate, PyExc_StopIteration, stop_value);
+#elif PYTHON_VERSION >= 0x3c0
+    struct Nuitka_ExceptionPreservationItem exception_state = {Nuitka_CreateStopIteration(tstate, value)};
+
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &exception_state);
 #else
     if (likely(!PyTuple_Check(value) && !PyExceptionInstance_Check(value))) {
         Py_INCREF(PyExc_StopIteration);
@@ -56,15 +74,10 @@ static void Nuitka_SetStopIterationValue(PyThreadState *tstate, PyObject *value)
 
         RESTORE_ERROR_OCCURRED(tstate, PyExc_StopIteration, value, NULL);
     } else {
-        PyObject *stop_value = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, PyExc_StopIteration, value);
+        struct Nuitka_ExceptionPreservationItem exception_state = {Py_NewRef(PyExc_StopIteration),
+                                                                   Nuitka_CreateStopIteration(tstate, value)};
 
-        if (unlikely(stop_value == NULL)) {
-            return;
-        }
-
-        Py_INCREF(PyExc_StopIteration);
-
-        RESTORE_ERROR_OCCURRED(tstate, PyExc_StopIteration, stop_value, NULL);
+        RESTORE_ERROR_OCCURRED_STATE(tstate, &exception_state);
     }
 #endif
 }
@@ -115,45 +128,10 @@ static inline bool Nuitka_PyFrameHasCompleted(PyFrameObject *const frame) {
 // what it does. It's unrelated to compiled generators, and used from coroutines
 // and asyncgen to interact with them.
 static PyObject *Nuitka_PyGen_Send(PyThreadState *tstate, PyGenObject *gen, PyObject *arg) {
-#if defined(PY_NOGIL)
-    PyObject *res;
-
-    if (gen->status == GEN_CREATED) {
-        if (unlikely(arg != Py_None)) {
-            char const *msg = "generator raised StopIteration";
-            if (PyCoro_CheckExact(gen)) {
-                msg = "coroutine raised StopIteration";
-            } else if (PyAsyncGen_CheckExact(gen)) {
-                msg = "async generator raised StopIteration";
-            }
-
-            _PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);
-            return NULL;
-        }
-        arg = NULL;
-    }
-
-    res = PyEval2_EvalGen(gen, arg);
-
-    if (likely(res != NULL)) {
-        assert(gen->status == GEN_SUSPENDED);
-        return res;
-    }
-
-    if (likely(gen->return_value == Py_None)) {
-        gen->return_value = NULL;
-        SET_CURRENT_EXCEPTION_TYPE0(tstate,
-                                    PyAsyncGen_CheckExact(gen) ? PyExc_StopAsyncIteration : PyExc_StopIteration);
-        return NULL;
-    } else if (gen->return_value != NULL) {
-        Nuitka_SetStopIterationValue(tstate, gen->return_value);
-        return NULL;
-    } else {
-        return gen_wrap_exception(gen);
-    }
-#elif PYTHON_VERSION >= 0x3a0
+#if PYTHON_VERSION >= 0x3a0
     PyObject *result;
 
+    // TODO: Avoid API call for performance.
     PySendResult res = PyIter_Send((PyObject *)gen, arg, &result);
 
     switch (res) {
@@ -271,10 +249,11 @@ static PyObject *Nuitka_PyGen_Send(PyThreadState *tstate, PyGenObject *gen, PyOb
         if (result == Py_None) {
             SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopIteration);
         } else {
-            PyObject *e = PyObject_CallFunctionObjArgs(PyExc_StopIteration, result, NULL);
+            PyObject *e = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, (PyObject *)PyExc_StopIteration, result);
 
-            if (e != NULL) {
-                SET_CURRENT_EXCEPTION_TYPE0_VALUE1(tstate, PyExc_StopIteration, e);
+            if (likely(e != NULL)) {
+                Py_INCREF(PyExc_StopIteration);
+                RESTORE_ERROR_OCCURRED(tstate, PyExc_StopIteration, e, NULL);
             }
         }
 
@@ -299,7 +278,7 @@ static PyObject *Nuitka_PyGen_Send(PyThreadState *tstate, PyGenObject *gen, PyOb
 #endif
 
         // Now release frame.
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
         gen->gi_frame->f_gen = NULL;
 #endif
         gen->gi_frame = NULL;
@@ -313,7 +292,7 @@ static PyObject *Nuitka_PyGen_Send(PyThreadState *tstate, PyGenObject *gen, PyOb
         assert(result == Py_None || !PyAsyncGen_CheckExact(gen));
 
         if (result == Py_None && !PyAsyncGen_CheckExact(gen)) {
-            Py_DECREF(result);
+            Py_DECREF_IMMORTAL(result);
             result = NULL;
         }
     } else {
@@ -348,26 +327,20 @@ static PyObject *Nuitka_PyGen_Send(PyThreadState *tstate, PyGenObject *gen, PyOb
 
 #endif
 
-// TODO: Disabled for NOGIL until it becomes more ready.
+// TODO: Disabled for Python 3.13 until it becomes more ready.
 // Not done for earlier versions yet, indicate usability for compiled
 // generators, but it seems that mostly coroutines need it anyway, so the
 // benefit would be only for performance and not by a lot.
-#if PYTHON_VERSION >= 0x340 && !defined(PY_NOGIL)
+#if PYTHON_VERSION >= 0x300 && PYTHON_VERSION < 0x3d0
 #define NUITKA_UNCOMPILED_THROW_INTEGRATION 1
 #endif
 
-// TODO: Disabled for Python3.12 until release of it
-#if PYTHON_VERSION >= 0x3c0
-#undef NUITKA_UNCOMPILED_THROW_INTEGRATION
-#define NUITKA_UNCOMPILED_THROW_INTEGRATION 0
-#endif
-
 #if NUITKA_UNCOMPILED_THROW_INTEGRATION
 
-static bool _Nuitka_Generator_check_throw2(PyThreadState *tstate, PyObject **exception_type, PyObject **exception_value,
-                                           PyTracebackObject **exception_tb);
+static bool _Nuitka_Generator_check_throw(PyThreadState *tstate,
+                                          struct Nuitka_ExceptionPreservationItem *exception_state);
 
-#if PYTHON_VERSION < 0x3B0
+#if PYTHON_VERSION < 0x3b0
 #include <opcode.h>
 // Clashes with our helper names.
 #undef CALL_FUNCTION
@@ -386,11 +359,9 @@ static int Nuitka_PyGen_gen_close_iter(PyThreadState *tstate, PyObject *yf);
 // spell-checker: ignore classderef,getattribute,precall
 const uint8_t Nuitka_PyOpcode_Deopt[256] = {
 #if PYTHON_VERSION >= 0x3c0
-    [ASYNC_GEN_WRAP] = ASYNC_GEN_WRAP,
     [BEFORE_ASYNC_WITH] = BEFORE_ASYNC_WITH,
     [BEFORE_WITH] = BEFORE_WITH,
     [BINARY_OP] = BINARY_OP,
-    [BINARY_OP_ADAPTIVE] = BINARY_OP,
     [BINARY_OP_ADD_FLOAT] = BINARY_OP,
     [BINARY_OP_ADD_INT] = BINARY_OP,
     [BINARY_OP_ADD_UNICODE] = BINARY_OP,
@@ -401,7 +372,6 @@ const uint8_t Nuitka_PyOpcode_Deopt[256] = {
     [BINARY_OP_SUBTRACT_INT] = BINARY_OP,
     [BINARY_SLICE] = BINARY_SLICE,
     [BINARY_SUBSCR] = BINARY_SUBSCR,
-    [BINARY_SUBSCR_ADAPTIVE] = BINARY_SUBSCR,
     [BINARY_SUBSCR_DICT] = BINARY_SUBSCR,
     [BINARY_SUBSCR_GETITEM] = BINARY_SUBSCR,
     [BINARY_SUBSCR_LIST_INT] = BINARY_SUBSCR,
@@ -415,11 +385,12 @@ const uint8_t Nuitka_PyOpcode_Deopt[256] = {
     [BUILD_TUPLE] = BUILD_TUPLE,
     [CACHE] = CACHE,
     [CALL] = CALL,
-    [CALL_ADAPTIVE] = CALL,
     [CALL_BOUND_METHOD_EXACT_ARGS] = CALL,
     [CALL_BUILTIN_CLASS] = CALL,
     [CALL_BUILTIN_FAST_WITH_KEYWORDS] = CALL,
     [CALL_FUNCTION_EX] = CALL_FUNCTION_EX,
+    [CALL_INTRINSIC_1] = CALL_INTRINSIC_1,
+    [CALL_INTRINSIC_2] = CALL_INTRINSIC_2,
     [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = CALL,
     [CALL_NO_KW_BUILTIN_FAST] = CALL,
     [CALL_NO_KW_BUILTIN_O] = CALL,
@@ -438,10 +409,9 @@ const uint8_t Nuitka_PyOpcode_Deopt[256] = {
     [CHECK_EXC_MATCH] = CHECK_EXC_MATCH,
     [CLEANUP_THROW] = CLEANUP_THROW,
     [COMPARE_OP] = COMPARE_OP,
-    [COMPARE_OP_ADAPTIVE] = COMPARE_OP,
-    [COMPARE_OP_FLOAT_JUMP] = COMPARE_OP,
-    [COMPARE_OP_INT_JUMP] = COMPARE_OP,
-    [COMPARE_OP_STR_JUMP] = COMPARE_OP,
+    [COMPARE_OP_FLOAT] = COMPARE_OP,
+    [COMPARE_OP_INT] = COMPARE_OP,
+    [COMPARE_OP_STR] = COMPARE_OP,
     [CONTAINS_OP] = CONTAINS_OP,
     [COPY] = COPY,
     [COPY_FREE_VARS] = COPY_FREE_VARS,
@@ -454,13 +424,15 @@ const uint8_t Nuitka_PyOpcode_Deopt[256] = {
     [DICT_MERGE] = DICT_MERGE,
     [DICT_UPDATE] = DICT_UPDATE,
     [END_ASYNC_FOR] = END_ASYNC_FOR,
+    [END_FOR] = END_FOR,
+    [END_SEND] = END_SEND,
     [EXTENDED_ARG] = EXTENDED_ARG,
-    [EXTENDED_ARG_QUICK] = EXTENDED_ARG,
     [FORMAT_VALUE] = FORMAT_VALUE,
     [FOR_ITER] = FOR_ITER,
-    [FOR_ITER_ADAPTIVE] = FOR_ITER,
+    [FOR_ITER_GEN] = FOR_ITER,
     [FOR_ITER_LIST] = FOR_ITER,
     [FOR_ITER_RANGE] = FOR_ITER,
+    [FOR_ITER_TUPLE] = FOR_ITER,
     [GET_AITER] = GET_AITER,
     [GET_ANEXT] = GET_ANEXT,
     [GET_AWAITABLE] = GET_AWAITABLE,
@@ -469,47 +441,64 @@ const uint8_t Nuitka_PyOpcode_Deopt[256] = {
     [GET_YIELD_FROM_ITER] = GET_YIELD_FROM_ITER,
     [IMPORT_FROM] = IMPORT_FROM,
     [IMPORT_NAME] = IMPORT_NAME,
-    [IMPORT_STAR] = IMPORT_STAR,
+    [INSTRUMENTED_CALL] = INSTRUMENTED_CALL,
+    [INSTRUMENTED_CALL_FUNCTION_EX] = INSTRUMENTED_CALL_FUNCTION_EX,
+    [INSTRUMENTED_END_FOR] = INSTRUMENTED_END_FOR,
+    [INSTRUMENTED_END_SEND] = INSTRUMENTED_END_SEND,
+    [INSTRUMENTED_FOR_ITER] = INSTRUMENTED_FOR_ITER,
+    [INSTRUMENTED_INSTRUCTION] = INSTRUMENTED_INSTRUCTION,
+    [INSTRUMENTED_JUMP_BACKWARD] = INSTRUMENTED_JUMP_BACKWARD,
+    [INSTRUMENTED_JUMP_FORWARD] = INSTRUMENTED_JUMP_FORWARD,
+    [INSTRUMENTED_LINE] = INSTRUMENTED_LINE,
+    [INSTRUMENTED_LOAD_SUPER_ATTR] = INSTRUMENTED_LOAD_SUPER_ATTR,
+    [INSTRUMENTED_POP_JUMP_IF_FALSE] = INSTRUMENTED_POP_JUMP_IF_FALSE,
+    [INSTRUMENTED_POP_JUMP_IF_NONE] = INSTRUMENTED_POP_JUMP_IF_NONE,
+    [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = INSTRUMENTED_POP_JUMP_IF_NOT_NONE,
+    [INSTRUMENTED_POP_JUMP_IF_TRUE] = INSTRUMENTED_POP_JUMP_IF_TRUE,
+    [INSTRUMENTED_RESUME] = INSTRUMENTED_RESUME,
+    [INSTRUMENTED_RETURN_CONST] = INSTRUMENTED_RETURN_CONST,
+    [INSTRUMENTED_RETURN_VALUE] = INSTRUMENTED_RETURN_VALUE,
+    [INSTRUMENTED_YIELD_VALUE] = INSTRUMENTED_YIELD_VALUE,
+    [INTERPRETER_EXIT] = INTERPRETER_EXIT,
     [IS_OP] = IS_OP,
     [JUMP_BACKWARD] = JUMP_BACKWARD,
     [JUMP_BACKWARD_NO_INTERRUPT] = JUMP_BACKWARD_NO_INTERRUPT,
-    [JUMP_BACKWARD_QUICK] = JUMP_BACKWARD,
     [JUMP_FORWARD] = JUMP_FORWARD,
-    [JUMP_IF_FALSE_OR_POP] = JUMP_IF_FALSE_OR_POP,
-    [JUMP_IF_TRUE_OR_POP] = JUMP_IF_TRUE_OR_POP,
     [KW_NAMES] = KW_NAMES,
     [LIST_APPEND] = LIST_APPEND,
     [LIST_EXTEND] = LIST_EXTEND,
-    [LIST_TO_TUPLE] = LIST_TO_TUPLE,
     [LOAD_ASSERTION_ERROR] = LOAD_ASSERTION_ERROR,
     [LOAD_ATTR] = LOAD_ATTR,
-    [LOAD_ATTR_ADAPTIVE] = LOAD_ATTR,
     [LOAD_ATTR_CLASS] = LOAD_ATTR,
     [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = LOAD_ATTR,
     [LOAD_ATTR_INSTANCE_VALUE] = LOAD_ATTR,
     [LOAD_ATTR_METHOD_LAZY_DICT] = LOAD_ATTR,
     [LOAD_ATTR_METHOD_NO_DICT] = LOAD_ATTR,
-    [LOAD_ATTR_METHOD_WITH_DICT] = LOAD_ATTR,
     [LOAD_ATTR_METHOD_WITH_VALUES] = LOAD_ATTR,
     [LOAD_ATTR_MODULE] = LOAD_ATTR,
     [LOAD_ATTR_PROPERTY] = LOAD_ATTR,
     [LOAD_ATTR_SLOT] = LOAD_ATTR,
     [LOAD_ATTR_WITH_HINT] = LOAD_ATTR,
     [LOAD_BUILD_CLASS] = LOAD_BUILD_CLASS,
-    [LOAD_CLASSDEREF] = LOAD_CLASSDEREF,
     [LOAD_CLOSURE] = LOAD_CLOSURE,
     [LOAD_CONST] = LOAD_CONST,
     [LOAD_CONST__LOAD_FAST] = LOAD_CONST,
     [LOAD_DEREF] = LOAD_DEREF,
     [LOAD_FAST] = LOAD_FAST,
+    [LOAD_FAST_AND_CLEAR] = LOAD_FAST_AND_CLEAR,
     [LOAD_FAST_CHECK] = LOAD_FAST_CHECK,
     [LOAD_FAST__LOAD_CONST] = LOAD_FAST,
     [LOAD_FAST__LOAD_FAST] = LOAD_FAST,
+    [LOAD_FROM_DICT_OR_DEREF] = LOAD_FROM_DICT_OR_DEREF,
+    [LOAD_FROM_DICT_OR_GLOBALS] = LOAD_FROM_DICT_OR_GLOBALS,
     [LOAD_GLOBAL] = LOAD_GLOBAL,
-    [LOAD_GLOBAL_ADAPTIVE] = LOAD_GLOBAL,
     [LOAD_GLOBAL_BUILTIN] = LOAD_GLOBAL,
     [LOAD_GLOBAL_MODULE] = LOAD_GLOBAL,
+    [LOAD_LOCALS] = LOAD_LOCALS,
     [LOAD_NAME] = LOAD_NAME,
+    [LOAD_SUPER_ATTR] = LOAD_SUPER_ATTR,
+    [LOAD_SUPER_ATTR_ATTR] = LOAD_SUPER_ATTR,
+    [LOAD_SUPER_ATTR_METHOD] = LOAD_SUPER_ATTR,
     [MAKE_CELL] = MAKE_CELL,
     [MAKE_FUNCTION] = MAKE_FUNCTION,
     [MAP_ADD] = MAP_ADD,
@@ -524,22 +513,21 @@ const uint8_t Nuitka_PyOpcode_Deopt[256] = {
     [POP_JUMP_IF_NOT_NONE] = POP_JUMP_IF_NOT_NONE,
     [POP_JUMP_IF_TRUE] = POP_JUMP_IF_TRUE,
     [POP_TOP] = POP_TOP,
-    [PREP_RERAISE_STAR] = PREP_RERAISE_STAR,
-    [PRINT_EXPR] = PRINT_EXPR,
     [PUSH_EXC_INFO] = PUSH_EXC_INFO,
     [PUSH_NULL] = PUSH_NULL,
     [RAISE_VARARGS] = RAISE_VARARGS,
     [RERAISE] = RERAISE,
+    [RESERVED] = RESERVED,
     [RESUME] = RESUME,
-    [RESUME_QUICK] = RESUME,
+    [RETURN_CONST] = RETURN_CONST,
     [RETURN_GENERATOR] = RETURN_GENERATOR,
     [RETURN_VALUE] = RETURN_VALUE,
     [SEND] = SEND,
+    [SEND_GEN] = SEND,
     [SETUP_ANNOTATIONS] = SETUP_ANNOTATIONS,
     [SET_ADD] = SET_ADD,
     [SET_UPDATE] = SET_UPDATE,
     [STORE_ATTR] = STORE_ATTR,
-    [STORE_ATTR_ADAPTIVE] = STORE_ATTR,
     [STORE_ATTR_INSTANCE_VALUE] = STORE_ATTR,
     [STORE_ATTR_SLOT] = STORE_ATTR,
     [STORE_ATTR_WITH_HINT] = STORE_ATTR,
@@ -551,17 +539,14 @@ const uint8_t Nuitka_PyOpcode_Deopt[256] = {
     [STORE_NAME] = STORE_NAME,
     [STORE_SLICE] = STORE_SLICE,
     [STORE_SUBSCR] = STORE_SUBSCR,
-    [STORE_SUBSCR_ADAPTIVE] = STORE_SUBSCR,
     [STORE_SUBSCR_DICT] = STORE_SUBSCR,
     [STORE_SUBSCR_LIST_INT] = STORE_SUBSCR,
     [SWAP] = SWAP,
     [UNARY_INVERT] = UNARY_INVERT,
     [UNARY_NEGATIVE] = UNARY_NEGATIVE,
     [UNARY_NOT] = UNARY_NOT,
-    [UNARY_POSITIVE] = UNARY_POSITIVE,
     [UNPACK_EX] = UNPACK_EX,
     [UNPACK_SEQUENCE] = UNPACK_SEQUENCE,
-    [UNPACK_SEQUENCE_ADAPTIVE] = UNPACK_SEQUENCE,
     [UNPACK_SEQUENCE_LIST] = UNPACK_SEQUENCE,
     [UNPACK_SEQUENCE_TUPLE] = UNPACK_SEQUENCE,
     [UNPACK_SEQUENCE_TWO_TUPLE] = UNPACK_SEQUENCE,
@@ -776,6 +761,7 @@ PyObject *Nuitka_PyGen_yf(PyGenObject *gen) {
     return yf;
 }
 
+#if PYTHON_VERSION < 0x3c0
 // Because it is not exported, we need to duplicate this.
 static PyFrameObject *_Nuitka_PyFrame_New_NoTrack(PyCodeObject *code) {
     int slots = code->co_nlocalsplus + code->co_stacksize;
@@ -800,17 +786,15 @@ static PyFrameObject *_Nuitka_PyFrame_New_NoTrack(PyCodeObject *code) {
 static PyFrameObject *_Nuitka_PyFrame_MakeAndSetFrameObject(PyThreadState *tstate, _PyInterpreterFrame *frame) {
     assert(frame->frame_obj == NULL);
 
-    PyObject *error_type, *error_value;
-    PyTracebackObject *error_traceback;
-
-    FETCH_ERROR_OCCURRED(tstate, &error_type, &error_value, &error_traceback);
+    struct Nuitka_ExceptionPreservationItem saved_exception_state;
+    FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 
     PyFrameObject *f = _Nuitka_PyFrame_New_NoTrack(frame->f_code);
 
     // Out of memory should be rare.
     assert(f != NULL);
 
-    RESTORE_ERROR_OCCURRED(tstate, error_type, error_value, error_traceback);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 
     // Apparently there are situations where there is a race with what code creates the
     // frame, and this time it's not us.
@@ -846,7 +830,6 @@ static inline PyFrameObject *_Nuitka_PyFrame_GetFrameObject(PyThreadState *tstat
 }
 
 // Also not exported, taking over a frame object.
-
 static void _Nuitka_take_ownership(PyThreadState *tstate, PyFrameObject *f, _PyInterpreterFrame *frame) {
     assert(frame->owner != FRAME_OWNED_BY_FRAME_OBJECT);
     assert(frame->owner != FRAME_CLEARED);
@@ -915,9 +898,17 @@ static void _Nuitka_PyFrame_Clear(PyThreadState *tstate, _PyInterpreterFrame *fr
 #else
     Py_DECREF(frame->f_funcobj);
 #endif
-    Py_DECREF(frame->f_code);
+
+#if PYTHON_VERSION < 0x3d0
+    Py_XDECREF(frame->f_code);
+#else
+    Py_XDECREF(frame->f_executable);
+#endif
 }
+#endif
 
+// Needs to be similar to "gen_send_ex2" implementation in CPython. This is the low
+// end of an uncompiled generator receiving a value.
 static PySendResult Nuitka_PyGen_gen_send_ex2(PyThreadState *tstate, PyGenObject *gen, PyObject *arg,
                                               PyObject **presult, int exc, int closing) {
     _PyInterpreterFrame *frame = (_PyInterpreterFrame *)gen->gi_iframe;
@@ -955,7 +946,7 @@ static PySendResult Nuitka_PyGen_gen_send_ex2(PyThreadState *tstate, PyGenObject
             SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_RuntimeError, "cannot reuse already awaited coroutine");
         } else if (arg && !exc) {
             *presult = Py_None;
-            Py_INCREF(*presult);
+            Py_INCREF_IMMORTAL(*presult);
             return PYGEN_RETURN;
         }
         return PYGEN_ERROR;
@@ -968,9 +959,13 @@ static PySendResult Nuitka_PyGen_gen_send_ex2(PyThreadState *tstate, PyGenObject
     Py_INCREF(result);
     _PyFrame_StackPush(frame, result);
 
-    frame->previous = tstate->cframe->current_frame;
+#if PYTHON_VERSION < 0x3c0
+    frame->previous = CURRENT_TSTATE_INTERPRETER_FRAME(tstate);
+#endif
+
+    _PyErr_StackItem *prev_exc_info = tstate->exc_info;
+    gen->gi_exc_state.previous_item = prev_exc_info;
 
-    gen->gi_exc_state.previous_item = tstate->exc_info;
     tstate->exc_info = &gen->gi_exc_state;
 
     if (exc) {
@@ -980,15 +975,21 @@ static PySendResult Nuitka_PyGen_gen_send_ex2(PyThreadState *tstate, PyGenObject
 
     gen->gi_frame_state = FRAME_EXECUTING;
     result = _PyEval_EvalFrame(tstate, frame, exc);
+#if PYTHON_VERSION < 0x3c0
     if (gen->gi_frame_state == FRAME_EXECUTING) {
         gen->gi_frame_state = FRAME_COMPLETED;
     }
     tstate->exc_info = gen->gi_exc_state.previous_item;
     gen->gi_exc_state.previous_item = NULL;
 
-    assert(tstate->cframe->current_frame == frame->previous);
+    assert(CURRENT_TSTATE_INTERPRETER_FRAME(tstate) == frame->previous);
     frame->previous = NULL;
-
+#else
+    assert(tstate->exc_info == prev_exc_info);
+    assert(gen->gi_exc_state.previous_item == NULL);
+    assert(gen->gi_frame_state != FRAME_EXECUTING);
+    assert(frame->previous == NULL);
+#endif
     if (result != NULL) {
         if (gen->gi_frame_state == FRAME_SUSPENDED) {
             *presult = result;
@@ -998,9 +999,12 @@ static PySendResult Nuitka_PyGen_gen_send_ex2(PyThreadState *tstate, PyGenObject
         assert(result == Py_None || !PyAsyncGen_CheckExact(gen));
 
         if (result == Py_None && !PyAsyncGen_CheckExact(gen) && !arg) {
+            // TODO: Have Py_CLEAR_IMMORTAL maybe
+
             Py_CLEAR(result);
         }
     } else {
+#if PYTHON_VERSION < 0x3c0
         if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
             const char *msg = "generator raised StopIteration";
             if (PyCoro_CheckExact(gen)) {
@@ -1013,12 +1017,20 @@ static PySendResult Nuitka_PyGen_gen_send_ex2(PyThreadState *tstate, PyGenObject
             const char *msg = "async generator raised StopAsyncIteration";
             _PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);
         }
+#else
+        assert(!PyErr_ExceptionMatches(PyExc_StopIteration));
+        assert(!PyAsyncGen_CheckExact(gen) || !PyErr_ExceptionMatches(PyExc_StopAsyncIteration));
+
+#endif
     }
 
     _PyErr_ClearExcState(&gen->gi_exc_state);
 
     gen->gi_frame_state = FRAME_CLEARED;
+
+#if PYTHON_VERSION < 0x3c0
     _Nuitka_PyFrame_Clear(tstate, frame);
+#endif
 
     *presult = result;
     return result ? PYGEN_RETURN : PYGEN_ERROR;
@@ -1035,7 +1047,7 @@ static PyObject *Nuitka_PyGen_gen_send_ex(PyThreadState *tstate, PyGenObject *ge
         } else if (result == Py_None) {
             SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopIteration);
         } else {
-            _PyGen_SetStopIterationValue(result);
+            Nuitka_SetStopIterationValue(tstate, result);
         }
 
         Py_DECREF(result);
@@ -1052,12 +1064,11 @@ static PyObject *Nuitka_PyGen_gen_send_ex(PyThreadState *tstate, PyGenObject *ge
 //   value of exception_type will not be NULL, but the actual exception will not necessarily
 //   be normalized.
 static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenObject *gen, int close_on_genexit,
-                                                  PyObject *exception_type, PyObject *exception_value,
-                                                  PyTracebackObject *exception_tb) {
+                                                  struct Nuitka_ExceptionPreservationItem *exception_state) {
 #if _DEBUG_GENERATOR
     PRINT_STRING("Nuitka_UncompiledGenerator_throw: Enter ");
     PRINT_ITEM((PyObject *)gen);
-    PRINT_EXCEPTION(exception_type, exception_value, exception_tb);
+    PRINT_EXCEPTION_STATE(exception_state);
     PRINT_NEW_LINE();
 #endif
 
@@ -1066,7 +1077,7 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
     if (yf != NULL) {
         _PyInterpreterFrame *frame = (_PyInterpreterFrame *)gen->gi_iframe;
 
-        if (close_on_genexit && EXCEPTION_MATCH_BOOL_SINGLE(tstate, exception_type, PyExc_GeneratorExit)) {
+        if (close_on_genexit && EXCEPTION_STATE_MATCH_BOOL_SINGLE(tstate, exception_state, PyExc_GeneratorExit)) {
             PyFrameState state = (PyFrameState)gen->gi_frame_state;
             gen->gi_frame_state = FRAME_EXECUTING;
 
@@ -1079,9 +1090,7 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
             if (err < 0) {
                 // Releasing exception, we are done with it, raising instead the error just
                 // occurred.
-                Py_DECREF(exception_type);
-                Py_XDECREF(exception_value);
-                Py_XDECREF(exception_tb);
+                RELEASE_ERROR_OCCURRED_STATE(exception_state);
 
                 return Nuitka_PyGen_gen_send_ex(tstate, gen, Py_None, 1, 0);
             }
@@ -1093,17 +1102,16 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
         PyObject *ret;
 
         if (PyGen_CheckExact(yf) || PyCoro_CheckExact(yf)) {
-            _PyInterpreterFrame *prev = tstate->cframe->current_frame;
+            _PyInterpreterFrame *prev = CURRENT_TSTATE_INTERPRETER_FRAME(tstate);
             frame->previous = prev;
-            tstate->cframe->current_frame = frame;
+            CURRENT_TSTATE_INTERPRETER_FRAME(tstate) = frame;
             PyFrameState state = (PyFrameState)gen->gi_frame_state;
             gen->gi_frame_state = FRAME_EXECUTING;
 
             // Handing exception ownership to "Nuitka_UncompiledGenerator_throw".
-            ret = Nuitka_UncompiledGenerator_throw(tstate, (PyGenObject *)yf, close_on_genexit, exception_type,
-                                                   exception_value, exception_tb);
+            ret = Nuitka_UncompiledGenerator_throw(tstate, (PyGenObject *)yf, close_on_genexit, exception_state);
             gen->gi_frame_state = state;
-            tstate->cframe->current_frame = prev;
+            CURRENT_TSTATE_INTERPRETER_FRAME(tstate) = prev;
             frame->previous = NULL;
         } else {
 #if 0
@@ -1129,21 +1137,19 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
             PyFrameState state = (PyFrameState)gen->gi_frame_state;
             gen->gi_frame_state = FRAME_EXECUTING;
 
-            // TODO: Faster call code should be used.
-            ret = PyObject_CallFunctionObjArgs(meth, exception_type, exception_value, exception_tb, NULL);
+            ret = Nuitka_CallGeneratorThrowMethod(meth, exception_state);
 
             gen->gi_frame_state = state;
 
             // Releasing exception, we are done with it.
-            Py_DECREF(exception_type);
-            Py_XDECREF(exception_value);
-            Py_XDECREF(exception_tb);
+            RELEASE_ERROR_OCCURRED_STATE(exception_state);
 
             Py_DECREF(meth);
         }
         Py_DECREF(yf);
 
         if (ret == NULL) {
+#if PYTHON_VERSION < 0x3c0
             PyObject *val;
             assert(gen->gi_frame_state < FRAME_CLEARED);
             ret = _PyFrame_StackPop((_PyInterpreterFrame *)gen->gi_iframe);
@@ -1156,7 +1162,9 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
             if (_PyGen_FetchStopIterationValue(&val) == 0) {
                 ret = Nuitka_PyGen_gen_send_ex(tstate, gen, val, 0, 0);
                 Py_DECREF(val);
-            } else {
+            } else
+#endif
+            {
                 ret = Nuitka_PyGen_gen_send_ex(tstate, gen, Py_None, 1, 0);
             }
         }
@@ -1165,51 +1173,19 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
     }
 
 throw_here:
-    if (exception_tb == (PyTracebackObject *)Py_None) {
-        exception_tb = NULL;
-        Py_DECREF(exception_tb);
-    } else if (exception_tb != NULL && !PyTraceBack_Check(exception_tb)) {
-        SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "throw() third argument must be a traceback object");
-        goto failed_throw;
-    }
-
     tstate = _PyThreadState_GET();
 
-    if (PyExceptionClass_Check(exception_type)) {
-        Nuitka_Err_NormalizeException(tstate, &exception_type, &exception_value, &exception_tb);
-    } else if (PyExceptionInstance_Check(exception_type)) {
-        if (exception_value && exception_value != Py_None) {
-            SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError,
-                                            "instance exception may not have a separate value");
-            goto failed_throw;
-        } else {
-            // Normalize manually here via APIs
-            Py_XDECREF(exception_value);
-            exception_value = exception_type;
-            exception_type = PyExceptionInstance_Class(exception_type);
-            Py_INCREF(exception_type);
-
-            if (exception_tb == NULL) {
-                // Can remain NULL if no traceback is available.
-                exception_tb = GET_EXCEPTION_TRACEBACK(exception_value);
-                Py_XINCREF(exception_tb);
-            }
-        }
-    } else {
-        // Raisable
-        SET_CURRENT_EXCEPTION_TYPE_COMPLAINT(
-            "exceptions must be classes or instances deriving from BaseException, not %s", exception_type);
-        goto failed_throw;
+    if (unlikely(_Nuitka_Generator_check_throw(tstate, exception_state) == false)) {
+        // Exception was released by _Nuitka_Generator_check_throw already.
+        return NULL;
     }
 
-    RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, exception_tb);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, exception_state);
 
     return Nuitka_PyGen_gen_send_ex(tstate, gen, Py_None, 1, 1);
 
 failed_throw:
-    Py_DECREF(exception_type);
-    Py_XDECREF(exception_value);
-    Py_XDECREF(exception_tb);
+    RELEASE_ERROR_OCCURRED_STATE(exception_state);
 
     return NULL;
 }
@@ -1379,6 +1355,7 @@ static PyObject *Nuitka_PyGen_gen_send_ex(PyThreadState *tstate, PyGenObject *ge
             Nuitka_SetStopIterationValue(tstate, result);
         }
 
+        // TODO: Add Py_CLEAR_IMMORTAL maybe
         Py_CLEAR(result);
     }
 #if PYTHON_VERSION >= 0x350
@@ -1446,6 +1423,7 @@ static PyObject *Nuitka_PyGen_gen_send_ex(PyThreadState *tstate, PyGenObject *ge
         }
         assert(result == Py_None || !PyAsyncGen_CheckExact(gen));
         if (result == Py_None && !PyAsyncGen_CheckExact(gen) && !arg) {
+            // TODO: Add Py_CLEAR_IMMORTAL maybe
             Py_CLEAR(result);
         }
     } else {
@@ -1482,19 +1460,19 @@ static PyObject *Nuitka_PyGen_gen_send_ex(PyThreadState *tstate, PyGenObject *ge
 //   value of exception_type will not be NULL, but the actual exception will not necessarily
 //   be normalized.
 static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenObject *gen, int close_on_genexit,
-                                                  PyObject *exception_type, PyObject *exception_value,
-                                                  PyTracebackObject *exception_tb) {
+                                                  struct Nuitka_ExceptionPreservationItem *exception_state) {
 #if _DEBUG_GENERATOR
     PRINT_STRING("Nuitka_UncompiledGenerator_throw: Enter ");
     PRINT_ITEM((PyObject *)gen);
-    PRINT_EXCEPTION(exception_type, exception_value, exception_tb);
+    PRINT_EXCEPTION_STATE(exception_state);
     PRINT_NEW_LINE();
 #endif
 
     PyObject *yf = Nuitka_PyGen_yf(gen);
 
     if (yf != NULL) {
-        if (close_on_genexit && EXCEPTION_MATCH_BOOL_SINGLE(tstate, exception_type, PyExc_GeneratorExit)) {
+        if (close_on_genexit &&
+            EXCEPTION_MATCH_BOOL_SINGLE(tstate, exception_state->exception_type, PyExc_GeneratorExit)) {
 #if PYTHON_VERSION < 0x3a0
             gen->gi_running = 1;
 #else
@@ -1513,9 +1491,7 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
             if (err < 0) {
                 // Releasing exception, we are done with it, raising instead the error just
                 // occurred.
-                Py_DECREF(exception_type);
-                Py_XDECREF(exception_value);
-                Py_XDECREF(exception_tb);
+                RELEASE_ERROR_OCCURRED_STATE(exception_state);
 
                 return Nuitka_PyGen_gen_send_ex(tstate, gen, Py_None, 1, 0);
             }
@@ -1539,8 +1515,7 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
 #endif
 
             // Handing exception ownership to "Nuitka_UncompiledGenerator_throw".
-            ret = Nuitka_UncompiledGenerator_throw(tstate, (PyGenObject *)yf, close_on_genexit, exception_type,
-                                                   exception_value, exception_tb);
+            ret = Nuitka_UncompiledGenerator_throw(tstate, (PyGenObject *)yf, close_on_genexit, exception_state);
 
 #if PYTHON_VERSION < 0x3a0
             gen->gi_running = 0;
@@ -1562,9 +1537,7 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
                     Py_DECREF(yf);
 
                     // Releasing exception, we are done with it.
-                    Py_DECREF(exception_type);
-                    Py_XDECREF(exception_value);
-                    Py_XDECREF(exception_tb);
+                    RELEASE_ERROR_OCCURRED_STATE(exception_state);
 
                     return NULL;
                 }
@@ -1583,7 +1556,8 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
             gen->gi_frame->f_state = FRAME_EXECUTING;
 #endif
             // TODO: Faster call code should be used.
-            ret = PyObject_CallFunctionObjArgs(meth, exception_type, exception_value, exception_tb, NULL);
+            ret = Nuitka_CallGeneratorThrowMethod(meth, exception_state);
+
 #if PYTHON_VERSION < 0x3a0
             gen->gi_running = 0;
 #else
@@ -1591,9 +1565,7 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
 #endif
 
             // Releasing exception, we are done with it.
-            Py_DECREF(exception_type);
-            Py_XDECREF(exception_value);
-            Py_XDECREF(exception_tb);
+            RELEASE_ERROR_OCCURRED_STATE(exception_state);
 
             Py_DECREF(meth);
         }
@@ -1616,10 +1588,10 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
             gen->gi_frame->f_lasti += 1;
 #endif
 
-            if (_PyGen_FetchStopIterationValue(&exception_value) == 0) {
-                ret = Nuitka_PyGen_gen_send_ex(tstate, gen, exception_value, 0, 0);
+            if (_PyGen_FetchStopIterationValue(&exception_state->exception_value) == 0) {
+                ret = Nuitka_PyGen_gen_send_ex(tstate, gen, exception_state->exception_value, 0, 0);
 
-                Py_DECREF(exception_value);
+                Py_DECREF(exception_state->exception_value);
             } else {
                 ret = Nuitka_PyGen_gen_send_ex(tstate, gen, Py_None, 1, 0);
             }
@@ -1629,13 +1601,13 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
 
 throw_here:
     // We continue to have exception ownership here.
-    if (unlikely(_Nuitka_Generator_check_throw2(tstate, &exception_type, &exception_value, &exception_tb) == false)) {
-        // Exception was released by _Nuitka_Generator_check_throw2 already.
+    if (unlikely(_Nuitka_Generator_check_throw(tstate, exception_state) == false)) {
+        // Exception was released by _Nuitka_Generator_check_throw already.
         return NULL;
     }
 
     // Transfer exception ownership to published exception.
-    RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, (PyTracebackObject *)exception_tb);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, exception_state);
 
     return Nuitka_PyGen_gen_send_ex(tstate, gen, Py_None, 1, 1);
 }
@@ -1734,10 +1706,25 @@ static PyObject *Nuitka_PyGen_gen_close(PyThreadState *tstate, PyGenObject *gen,
     if (PyErr_ExceptionMatches(PyExc_StopIteration) || PyErr_ExceptionMatches(PyExc_GeneratorExit)) {
         CLEAR_ERROR_OCCURRED(tstate);
 
-        Py_INCREF(Py_None);
+        Py_INCREF_IMMORTAL(Py_None);
         return Py_None;
     }
     return NULL;
 }
 
 #endif
+
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.