diff --git a/Include/cpython/ceval.h b/Include/cpython/ceval.h
index 0fbbee10c2edce..3dbc31af902aaf 100644
--- a/Include/cpython/ceval.h
+++ b/Include/cpython/ceval.h
@@ -2,6 +2,7 @@
 #  error "this header file must not be included directly"
 #endif
 
+
 PyAPI_FUNC(void) PyEval_SetProfile(Py_tracefunc, PyObject *);
 PyAPI_FUNC(void) PyEval_SetProfileAllThreads(Py_tracefunc, PyObject *);
 PyAPI_DATA(int) _PyEval_SetProfile(PyThreadState *tstate, Py_tracefunc func, PyObject *arg);
diff --git a/Include/cpython/pystate.h b/Include/cpython/pystate.h
index 3efb241e8237e7..2309d5e1b8ea6a 100644
--- a/Include/cpython/pystate.h
+++ b/Include/cpython/pystate.h
@@ -59,6 +59,8 @@ typedef int (*Py_tracefunc)(PyObject *, PyFrameObject *, int, PyObject *);
 #define PyTrace_OPCODE 7
 
 
+struct _PyInterpreterFrame;
+
 typedef struct {
     PyCodeObject *code; // The code object for the bounds. May be NULL.
     PyCodeAddressRange bounds; // Only valid if code != NULL.
@@ -79,7 +81,7 @@ typedef struct _PyCFrame {
      */
     uint8_t use_tracing;  // 0 or 255 (or'ed into opcode, hence 8-bit type)
     /* Pointer to the currently executing frame (it can be NULL) */
-    struct _PyInterpreterFrame *current_frame;
+    struct _PyFrame *current_frame;
     struct _PyCFrame *previous;
 } _PyCFrame;
 
diff --git a/Include/internal/pycore_ceval.h b/Include/internal/pycore_ceval.h
index deda070a6dea79..b49c983b448d36 100644
--- a/Include/internal/pycore_ceval.h
+++ b/Include/internal/pycore_ceval.h
@@ -80,6 +80,8 @@ extern PyStatus _PyPerfTrampoline_AfterFork_Child(void);
 extern _PyPerf_Callbacks _Py_perfmap_callbacks;
 #endif
 
+struct _PyInterpreterFrame;
+
 static inline PyObject*
 _PyEval_EvalFrame(PyThreadState *tstate, struct _PyInterpreterFrame *frame, int throwflag)
 {
diff --git a/Include/internal/pycore_frame.h b/Include/internal/pycore_frame.h
index 5806cf05f174a9..b072843ee3eca3 100644
--- a/Include/internal/pycore_frame.h
+++ b/Include/internal/pycore_frame.h
@@ -46,9 +46,13 @@ enum _frameowner {
     FRAME_OWNED_BY_CSTACK = 3,
 };
 
+typedef struct _PyFrame {
+    PyObject *f_executable; /* Strong reference */
+    struct _PyFrame *previous;
+} _PyFrame;
+
 typedef struct _PyInterpreterFrame {
-    PyCodeObject *f_code; /* Strong reference */
-    struct _PyInterpreterFrame *previous;
+    _PyFrame base;
     PyObject *f_funcobj; /* Strong reference. Only valid if not on C stack */
     PyObject *f_globals; /* Borrowed reference. Only valid if not on C stack */
     PyObject *f_builtins; /* Borrowed reference. Only valid if not on C stack */
@@ -67,20 +71,25 @@ typedef struct _PyInterpreterFrame {
 } _PyInterpreterFrame;
 
 #define _PyInterpreterFrame_LASTI(IF) \
-    ((int)((IF)->prev_instr - _PyCode_CODE((IF)->f_code)))
+    ((int)((IF)->prev_instr - _PyCode_CODE(_PyFrame_GetCode(IF))))
+
+static inline PyCodeObject *_PyFrame_GetCode(_PyInterpreterFrame *f) {
+    assert(PyCode_Check(f->base.f_executable));
+    return (PyCodeObject *)f->base.f_executable;
+}
 
 static inline PyObject **_PyFrame_Stackbase(_PyInterpreterFrame *f) {
-    return f->localsplus + f->f_code->co_nlocalsplus;
+    return f->localsplus + _PyFrame_GetCode(f)->co_nlocalsplus;
 }
 
 static inline PyObject *_PyFrame_StackPeek(_PyInterpreterFrame *f) {
-    assert(f->stacktop > f->f_code->co_nlocalsplus);
+    assert(f->stacktop > _PyFrame_GetCode(f)->co_nlocalsplus);
     assert(f->localsplus[f->stacktop-1] != NULL);
     return f->localsplus[f->stacktop-1];
 }
 
 static inline PyObject *_PyFrame_StackPop(_PyInterpreterFrame *f) {
-    assert(f->stacktop > f->f_code->co_nlocalsplus);
+    assert(f->stacktop > _PyFrame_GetCode(f)->co_nlocalsplus);
     f->stacktop--;
     return f->localsplus[f->stacktop];
 }
@@ -113,7 +122,7 @@ _PyFrame_Initialize(
     PyObject *locals, PyCodeObject *code, int null_locals_from)
 {
     frame->f_funcobj = (PyObject *)func;
-    frame->f_code = (PyCodeObject *)Py_NewRef(code);
+    frame->base.f_executable = Py_NewRef(code);
     frame->f_builtins = func->func_builtins;
     frame->f_globals = func->func_globals;
     frame->f_locals = locals;
@@ -158,19 +167,26 @@ _PyFrame_SetStackPointer(_PyInterpreterFrame *frame, PyObject **stack_pointer)
  * Frames owned by a generator are always complete.
  */
 static inline bool
-_PyFrame_IsIncomplete(_PyInterpreterFrame *frame)
+_PyFrame_IsIncomplete(_PyFrame *frameptr)
 {
+    if (!PyCode_Check(frameptr->f_executable)) {
+        return true;
+    }
+    _PyInterpreterFrame *frame = (_PyInterpreterFrame *)frameptr;
+    if (frame->owner == FRAME_OWNED_BY_CSTACK) {
+        return true;
+    }
     return frame->owner != FRAME_OWNED_BY_GENERATOR &&
-    frame->prev_instr < _PyCode_CODE(frame->f_code) + frame->f_code->_co_firsttraceable;
+    frame->prev_instr < _PyCode_CODE(_PyFrame_GetCode(frame)) + _PyFrame_GetCode(frame)->_co_firsttraceable;
 }
 
 static inline _PyInterpreterFrame *
-_PyFrame_GetFirstComplete(_PyInterpreterFrame *frame)
+_PyFrame_GetFirstComplete(_PyFrame *frame)
 {
-    while (frame && _PyFrame_IsIncomplete(frame)) {
+    while (frame != NULL && _PyFrame_IsIncomplete(frame)) {
         frame = frame->previous;
     }
-    return frame;
+    return (_PyInterpreterFrame *)frame;
 }
 
 static inline _PyInterpreterFrame *
@@ -191,7 +207,7 @@ static inline PyFrameObject *
 _PyFrame_GetFrameObject(_PyInterpreterFrame *frame)
 {
 
-    assert(!_PyFrame_IsIncomplete(frame));
+    assert(!_PyFrame_IsIncomplete(&frame->base));
     PyFrameObject *res =  frame->frame_obj;
     if (res != NULL) {
         return res;
diff --git a/Lib/test/test_capi/test_misc.py b/Lib/test/test_capi/test_misc.py
index c34ee578b5c83f..eb9965d770dc46 100644
--- a/Lib/test/test_capi/test_misc.py
+++ b/Lib/test/test_capi/test_misc.py
@@ -206,6 +206,7 @@ def test_return_null_without_error(self):
                     r'returned NULL without setting an exception\n'
                 r'\n'
                 r'Current thread.*:\n'
+                    r'  Builtin function return_null_without_error\n'
                 r'  File .*", line 6 in <module>\n')
         else:
             with self.assertRaises(SystemError) as cm:
@@ -240,6 +241,7 @@ def test_return_result_with_error(self):
                         r'returned a result with an exception set\n'
                     r'\n'
                     r'Current thread.*:\n'
+                    r'  Builtin function return_result_with_error\n'
                     r'  File .*, line 6 in <module>\n')
         else:
             with self.assertRaises(SystemError) as cm:
@@ -270,6 +272,7 @@ def test_getitem_with_error(self):
                     r'ValueError: bug\n'
                     r'\n'
                     r'Current thread .* \(most recent call first\):\n'
+                    r'  Builtin function getitem_with_error\n'
                     r'  File .*, line 6 in <module>\n'
                     r'\n'
                     r'Extension modules: _testcapi \(total: 1\)\n')
diff --git a/Lib/test/test_faulthandler.py b/Lib/test/test_faulthandler.py
index 8d106daaf6520a..0d57510fad230b 100644
--- a/Lib/test/test_faulthandler.py
+++ b/Lib/test/test_faulthandler.py
@@ -118,7 +118,9 @@ def check_error(self, code, lineno, fatal_error, *,
         # Enable MULTILINE flag
         regex = f'(?m){regex}'
         output, exitcode = self.get_output(code, filename=filename, fd=fd)
-        output = '\n'.join(output)
+        output = '\n'.join([line for line in output if
+                            "Builtin function" not in line and
+                            "Method descriptor" not in line])
         self.assertRegex(output, regex)
         self.assertNotEqual(exitcode, 0)
 
@@ -484,11 +486,19 @@ def funcA():
             lineno = 14
         expected = [
             'Stack (most recent call first):',
+            '  Builtin function dump_traceback',
             '  File "<string>", line %s in funcB' % lineno,
             '  File "<string>", line 17 in funcA',
             '  File "<string>", line 19 in <module>'
         ]
         trace, exitcode = self.get_output(code, filename, fd)
+        if trace != expected:
+            print("Trace")
+            print("-----------------")
+            print(trace)
+            print("Expected")
+            print("-----------------")
+            print(expected)
         self.assertEqual(trace, expected)
         self.assertEqual(exitcode, 0)
 
@@ -522,6 +532,7 @@ def {func_name}():
         )
         expected = [
             'Stack (most recent call first):',
+            '  Builtin function dump_traceback',
             '  File "<string>", line 4 in %s' % truncated,
             '  File "<string>", line 6 in <module>'
         ]
@@ -568,7 +579,9 @@ def run(self):
             """
         code = code.format(filename=repr(filename))
         output, exitcode = self.get_output(code, filename)
-        output = '\n'.join(output)
+        output = '\n'.join([line for line in output if
+                            "Builtin function" not in line and
+                            "Method descriptor" not in line])
         if filename:
             lineno = 8
         else:
@@ -644,8 +657,9 @@ def func(timeout, repeat, cancel, file, loops):
             fd=fd,
         )
         trace, exitcode = self.get_output(code, filename)
-        trace = '\n'.join(trace)
-
+        trace = '\n'.join([line for line in trace if
+                            "Builtin function" not in line and
+                            "Method descriptor" not in line])
         if not cancel:
             count = loops
             if repeat:
@@ -747,7 +761,7 @@ def handler(signum, frame):
             fd=fd,
         )
         trace, exitcode = self.get_output(code, filename)
-        trace = '\n'.join(trace)
+        trace = '\n'.join([line for line in trace if "Builtin function" not in line ])
         if not unregister:
             if all_threads:
                 regex = r'Current thread 0x[0-9a-f]+ \(most recent call first\):\n'
diff --git a/Modules/_tracemalloc.c b/Modules/_tracemalloc.c
index d69c5636486da9..af38999c1dabca 100644
--- a/Modules/_tracemalloc.c
+++ b/Modules/_tracemalloc.c
@@ -263,7 +263,7 @@ tracemalloc_get_frame(_PyInterpreterFrame *pyframe, frame_t *frame)
     }
     frame->lineno = (unsigned int)lineno;
 
-    PyObject *filename = pyframe->f_code->co_filename;
+    PyObject *filename = _PyFrame_GetCode(pyframe)->co_filename;
 
     if (filename == NULL) {
 #ifdef TRACE_DEBUG
@@ -358,7 +358,7 @@ traceback_get_frames(traceback_t *traceback)
         if (traceback->total_nframe < UINT16_MAX) {
             traceback->total_nframe++;
         }
-        pyframe = _PyFrame_GetFirstComplete(pyframe->previous);
+        pyframe = _PyFrame_GetFirstComplete(pyframe->base.previous);
     }
 }
 
diff --git a/Modules/_xxsubinterpretersmodule.c b/Modules/_xxsubinterpretersmodule.c
index 9648f080cd756c..e2d1ceddb7c1d7 100644
--- a/Modules/_xxsubinterpretersmodule.c
+++ b/Modules/_xxsubinterpretersmodule.c
@@ -385,8 +385,7 @@ _is_running(PyInterpreterState *interp)
     }
 
     assert(!PyErr_Occurred());
-    _PyInterpreterFrame *frame = tstate->cframe->current_frame;
-    if (frame == NULL) {
+    if (tstate->cframe->current_frame == NULL) {
         return 0;
     }
     return 1;
diff --git a/Objects/frameobject.c b/Objects/frameobject.c
index 63590d58809e3e..5558ade87dde4d 100644
--- a/Objects/frameobject.c
+++ b/Objects/frameobject.c
@@ -577,7 +577,7 @@ first_line_not_before(int *lines, int len, int line)
 static PyFrameState
 _PyFrame_GetState(PyFrameObject *frame)
 {
-    assert(!_PyFrame_IsIncomplete(frame->f_frame));
+    assert(!_PyFrame_IsIncomplete(&frame->f_frame->base));
     if (frame->f_frame->stacktop == 0) {
         return FRAME_CLEARED;
     }
@@ -626,6 +626,7 @@ _PyFrame_GetState(PyFrameObject *frame)
 static int
 frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno, void *Py_UNUSED(ignored))
 {
+    PyCodeObject *code = _PyFrame_GetCode(f->f_frame);
     if (p_new_lineno == NULL) {
         PyErr_SetString(PyExc_AttributeError, "cannot delete attribute");
         return -1;
@@ -691,7 +692,7 @@ frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno, void *Py_UNUSED(ignore
     }
     new_lineno = (int)l_new_lineno;
 
-    if (new_lineno < f->f_frame->f_code->co_firstlineno) {
+    if (new_lineno < code->co_firstlineno) {
         PyErr_Format(PyExc_ValueError,
                     "line %d comes before the current code block",
                     new_lineno);
@@ -700,8 +701,8 @@ frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno, void *Py_UNUSED(ignore
 
     /* PyCode_NewWithPosOnlyArgs limits co_code to be under INT_MAX so this
      * should never overflow. */
-    int len = (int)Py_SIZE(f->f_frame->f_code);
-    int *lines = marklines(f->f_frame->f_code, len);
+    int len = (int)Py_SIZE(code);
+    int *lines = marklines(code, len);
     if (lines == NULL) {
         return -1;
     }
@@ -715,7 +716,7 @@ frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno, void *Py_UNUSED(ignore
         return -1;
     }
 
-    int64_t *stacks = mark_stacks(f->f_frame->f_code, len);
+    int64_t *stacks = mark_stacks(code, len);
     if (stacks == NULL) {
         PyMem_Free(lines);
         return -1;
@@ -760,7 +761,7 @@ frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno, void *Py_UNUSED(ignore
     // in the new location. Rather than crashing or changing co_code, just bind
     // None instead:
     int unbound = 0;
-    for (int i = 0; i < f->f_frame->f_code->co_nlocalsplus; i++) {
+    for (int i = 0; i < code->co_nlocalsplus; i++) {
         // Counting every unbound local is overly-cautious, but a full flow
         // analysis (like we do in the compiler) is probably too expensive:
         unbound += f->f_frame->localsplus[i] == NULL;
@@ -773,7 +774,7 @@ frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno, void *Py_UNUSED(ignore
         }
         // Do this in a second pass to avoid writing a bunch of Nones when
         // warnings are being treated as errors and the previous bit raises:
-        for (int i = 0; i < f->f_frame->f_code->co_nlocalsplus; i++) {
+        for (int i = 0; i < code->co_nlocalsplus; i++) {
             if (f->f_frame->localsplus[i] == NULL) {
                 f->f_frame->localsplus[i] = Py_NewRef(Py_None);
                 unbound--;
@@ -804,7 +805,7 @@ frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno, void *Py_UNUSED(ignore
     }
     /* Finally set the new lasti and return OK. */
     f->f_lineno = 0;
-    f->f_frame->prev_instr = _PyCode_CODE(f->f_frame->f_code) + best_addr;
+    f->f_frame->prev_instr = _PyCode_CODE(code) + best_addr;
     return 0;
 }
 
@@ -855,15 +856,15 @@ frame_dealloc(PyFrameObject *f)
     }
 
     Py_TRASHCAN_BEGIN(f, frame_dealloc);
-    PyCodeObject *co = NULL;
+    PyObject *co = NULL;
 
     /* Kill all local variables including specials, if we own them */
     if (f->f_frame->owner == FRAME_OWNED_BY_FRAME_OBJECT) {
         assert(f->f_frame == (_PyInterpreterFrame *)f->_f_frame_data);
         _PyInterpreterFrame *frame = (_PyInterpreterFrame *)f->_f_frame_data;
         /* Don't clear code object until the end */
-        co = frame->f_code;
-        frame->f_code = NULL;
+        co = frame->base.f_executable;
+        frame->base.f_executable = NULL;
         Py_CLEAR(frame->f_funcobj);
         Py_CLEAR(frame->f_locals);
         PyObject **locals = _PyFrame_GetLocalsArray(frame);
@@ -937,7 +938,7 @@ frame_sizeof(PyFrameObject *f, PyObject *Py_UNUSED(ignored))
 {
     Py_ssize_t res;
     res = offsetof(PyFrameObject, _f_frame_data) + offsetof(_PyInterpreterFrame, localsplus);
-    PyCodeObject *code = f->f_frame->f_code;
+    PyCodeObject *code = _PyFrame_GetCode(f->f_frame);
     res += _PyFrame_NumSlotsForCodeObject(code) * sizeof(PyObject *);
     return PyLong_FromSsize_t(res);
 }
@@ -949,7 +950,7 @@ static PyObject *
 frame_repr(PyFrameObject *f)
 {
     int lineno = PyFrame_GetLineNumber(f);
-    PyCodeObject *code = f->f_frame->f_code;
+    PyCodeObject *code = _PyFrame_GetCode(f->f_frame);
     return PyUnicode_FromFormat(
         "<frame at %p, file %R, line %d, code %S>",
         f, code->co_filename, lineno, code->co_name);
@@ -1005,7 +1006,7 @@ init_frame(_PyInterpreterFrame *frame, PyFunctionObject *func, PyObject *locals)
     PyCodeObject *code = (PyCodeObject *)func->func_code;
     _PyFrame_Initialize(frame, (PyFunctionObject*)Py_NewRef(func),
                         Py_XNewRef(locals), code, 0);
-    frame->previous = NULL;
+    frame->base.previous = NULL;
 }
 
 PyFrameObject*
@@ -1059,7 +1060,7 @@ PyFrame_New(PyThreadState *tstate, PyCodeObject *code,
     f->f_frame->owner = FRAME_OWNED_BY_FRAME_OBJECT;
     // This frame needs to be "complete", so pretend that the first RESUME ran:
     f->f_frame->prev_instr = _PyCode_CODE(code) + code->_co_firsttraceable;
-    assert(!_PyFrame_IsIncomplete(f->f_frame));
+    assert(!_PyFrame_IsIncomplete(&f->f_frame->base));
     Py_DECREF(func);
     _PyObject_GC_TRACK(f);
     return f;
@@ -1071,7 +1072,7 @@ _PyFrame_OpAlreadyRan(_PyInterpreterFrame *frame, int opcode, int oparg)
     // This only works when opcode is a non-quickened form:
     assert(_PyOpcode_Deopt[opcode] == opcode);
     int check_oparg = 0;
-    for (_Py_CODEUNIT *instruction = _PyCode_CODE(frame->f_code);
+    for (_Py_CODEUNIT *instruction = _PyCode_CODE(_PyFrame_GetCode(frame));
          instruction < frame->prev_instr; instruction++)
     {
         int check_opcode = _PyOpcode_Deopt[instruction->op.code];
@@ -1097,7 +1098,7 @@ frame_init_get_vars(_PyInterpreterFrame *frame)
 {
     // COPY_FREE_VARS has no quickened forms, so no need to use _PyOpcode_Deopt
     // here:
-    PyCodeObject *co = frame->f_code;
+    PyCodeObject *co = _PyFrame_GetCode(frame);
     int lasti = _PyInterpreterFrame_LASTI(frame);
     if (!(lasti < 0 && _PyCode_CODE(co)->op.code == COPY_FREE_VARS
           && PyFunction_Check(frame->f_funcobj)))
@@ -1114,7 +1115,7 @@ frame_init_get_vars(_PyInterpreterFrame *frame)
         frame->localsplus[offset + i] = Py_NewRef(o);
     }
     // COPY_FREE_VARS doesn't have inline CACHEs, either:
-    frame->prev_instr = _PyCode_CODE(frame->f_code);
+    frame->prev_instr = _PyCode_CODE(_PyFrame_GetCode(frame));
 }
 
 
@@ -1182,7 +1183,7 @@ _PyFrame_FastToLocalsWithError(_PyInterpreterFrame *frame)
 
     frame_init_get_vars(frame);
 
-    PyCodeObject *co = frame->f_code;
+    PyCodeObject *co = _PyFrame_GetCode(frame);
     for (int i = 0; i < co->co_nlocalsplus; i++) {
         PyObject *value;  // borrowed reference
         if (!frame_get_var(frame, co, i, &value)) {
@@ -1222,7 +1223,7 @@ PyFrame_GetVar(PyFrameObject *frame_obj, PyObject *name)
     _PyInterpreterFrame *frame = frame_obj->f_frame;
     frame_init_get_vars(frame);
 
-    PyCodeObject *co = frame->f_code;
+    PyCodeObject *co = _PyFrame_GetCode(frame);
     for (int i = 0; i < co->co_nlocalsplus; i++) {
         PyObject *var_name = PyTuple_GET_ITEM(co->co_localsplusnames, i);
         if (!_PyUnicode_Equal(var_name, name)) {
@@ -1260,7 +1261,7 @@ PyFrame_GetVarString(PyFrameObject *frame, const char *name)
 int
 PyFrame_FastToLocalsWithError(PyFrameObject *f)
 {
-    assert(!_PyFrame_IsIncomplete(f->f_frame));
+    assert(!_PyFrame_IsIncomplete(&f->f_frame->base));
     if (f == NULL) {
         PyErr_BadInternalCall();
         return -1;
@@ -1276,7 +1277,7 @@ void
 PyFrame_FastToLocals(PyFrameObject *f)
 {
     int res;
-    assert(!_PyFrame_IsIncomplete(f->f_frame));
+    assert(!_PyFrame_IsIncomplete(&f->f_frame->base));
     assert(!PyErr_Occurred());
 
     res = PyFrame_FastToLocalsWithError(f);
@@ -1296,7 +1297,7 @@ _PyFrame_LocalsToFast(_PyInterpreterFrame *frame, int clear)
         return;
     }
     fast = _PyFrame_GetLocalsArray(frame);
-    co = frame->f_code;
+    co = _PyFrame_GetCode(frame);
 
     PyObject *exc = PyErr_GetRaisedException();
     for (int i = 0; i < co->co_nlocalsplus; i++) {
@@ -1361,9 +1362,11 @@ _PyFrame_LocalsToFast(_PyInterpreterFrame *frame, int clear)
 void
 PyFrame_LocalsToFast(PyFrameObject *f, int clear)
 {
-    assert(!_PyFrame_IsIncomplete(f->f_frame));
+    if (_PyFrame_IsIncomplete(&f->f_frame->base)) {
+        return;
+    }
     if (f && f->f_fast_as_locals && _PyFrame_GetState(f) != FRAME_CLEARED) {
-        _PyFrame_LocalsToFast(f->f_frame, clear);
+        _PyFrame_LocalsToFast((_PyInterpreterFrame *)f->f_frame, clear);
         f->f_fast_as_locals = 0;
     }
 }
@@ -1373,16 +1376,16 @@ _PyFrame_IsEntryFrame(PyFrameObject *frame)
 {
     assert(frame != NULL);
     _PyInterpreterFrame *f = frame->f_frame;
-    assert(!_PyFrame_IsIncomplete(f));
-    return f->previous && f->previous->owner == FRAME_OWNED_BY_CSTACK;
+    assert(!_PyFrame_IsIncomplete(&f->base));
+    return f->base.previous && f->base.previous->f_executable == Py_None;
 }
 
 PyCodeObject *
 PyFrame_GetCode(PyFrameObject *frame)
 {
     assert(frame != NULL);
-    assert(!_PyFrame_IsIncomplete(frame->f_frame));
-    PyCodeObject *code = frame->f_frame->f_code;
+    assert(!_PyFrame_IsIncomplete(&frame->f_frame->base));
+    PyCodeObject *code = _PyFrame_GetCode(frame->f_frame);
     assert(code != NULL);
     return (PyCodeObject*)Py_NewRef(code);
 }
@@ -1392,13 +1395,13 @@ PyFrameObject*
 PyFrame_GetBack(PyFrameObject *frame)
 {
     assert(frame != NULL);
-    assert(!_PyFrame_IsIncomplete(frame->f_frame));
+    assert(!_PyFrame_IsIncomplete(&frame->f_frame->base));
     PyFrameObject *back = frame->f_back;
     if (back == NULL) {
-        _PyInterpreterFrame *prev = frame->f_frame->previous;
-        prev = _PyFrame_GetFirstComplete(prev);
-        if (prev) {
-            back = _PyFrame_GetFrameObject(prev);
+        _PyFrame *prev = frame->f_frame->base.previous;
+        _PyInterpreterFrame *py_prev = _PyFrame_GetFirstComplete(prev);
+        if (py_prev) {
+            back = _PyFrame_GetFrameObject(py_prev);
         }
     }
     return (PyFrameObject*)Py_XNewRef(back);
@@ -1407,28 +1410,28 @@ PyFrame_GetBack(PyFrameObject *frame)
 PyObject*
 PyFrame_GetLocals(PyFrameObject *frame)
 {
-    assert(!_PyFrame_IsIncomplete(frame->f_frame));
+    assert(!_PyFrame_IsIncomplete(&frame->f_frame->base));
     return frame_getlocals(frame, NULL);
 }
 
 PyObject*
 PyFrame_GetGlobals(PyFrameObject *frame)
 {
-    assert(!_PyFrame_IsIncomplete(frame->f_frame));
+    assert(!_PyFrame_IsIncomplete(&frame->f_frame->base));
     return frame_getglobals(frame, NULL);
 }
 
 PyObject*
 PyFrame_GetBuiltins(PyFrameObject *frame)
 {
-    assert(!_PyFrame_IsIncomplete(frame->f_frame));
+    assert(!_PyFrame_IsIncomplete(&frame->f_frame->base));
     return frame_getbuiltins(frame, NULL);
 }
 
 int
 PyFrame_GetLasti(PyFrameObject *frame)
 {
-    assert(!_PyFrame_IsIncomplete(frame->f_frame));
+    assert(!_PyFrame_IsIncomplete(&frame->f_frame->base));
     int lasti = _PyInterpreterFrame_LASTI(frame->f_frame);
     if (lasti < 0) {
         return -1;
@@ -1439,7 +1442,7 @@ PyFrame_GetLasti(PyFrameObject *frame)
 PyObject *
 PyFrame_GetGenerator(PyFrameObject *frame)
 {
-    assert(!_PyFrame_IsIncomplete(frame->f_frame));
+    assert(!_PyFrame_IsIncomplete(&frame->f_frame->base));
     if (frame->f_frame->owner != FRAME_OWNED_BY_GENERATOR) {
         return NULL;
     }
diff --git a/Objects/genobject.c b/Objects/genobject.c
index 6316fa9865fe65..706d9c3df9063c 100644
--- a/Objects/genobject.c
+++ b/Objects/genobject.c
@@ -28,7 +28,7 @@ static const char *ASYNC_GEN_IGNORED_EXIT_MSG =
 static inline PyCodeObject *
 _PyGen_GetCode(PyGenObject *gen) {
     _PyInterpreterFrame *frame = (_PyInterpreterFrame *)(gen->gi_iframe);
-    return frame->f_code;
+    return _PyFrame_GetCode(frame);
 }
 
 PyCodeObject *
@@ -146,7 +146,7 @@ gen_dealloc(PyGenObject *gen)
     if (gen->gi_frame_state < FRAME_CLEARED) {
         _PyInterpreterFrame *frame = (_PyInterpreterFrame *)gen->gi_iframe;
         gen->gi_frame_state = FRAME_CLEARED;
-        frame->previous = NULL;
+        frame->base.previous = NULL;
         _PyFrame_ClearExceptCode(frame);
     }
     if (_PyGen_GetCode(gen)->co_flags & CO_COROUTINE) {
@@ -230,7 +230,7 @@ gen_send_ex2(PyGenObject *gen, PyObject *arg, PyObject **presult,
     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);
+    assert(frame->base.previous == NULL);
 
     /* If the generator just returned (as opposed to yielding), signal
      * that the generator is exhausted. */
@@ -459,9 +459,9 @@ _gen_throw(PyGenObject *gen, int close_on_genexit,
                will be reported correctly to the user. */
             /* XXX We should probably be updating the current frame
                somewhere in ceval.c. */
-            _PyInterpreterFrame *prev = tstate->cframe->current_frame;
-            frame->previous = prev;
-            tstate->cframe->current_frame = frame;
+            _PyFrame *prev = tstate->cframe->current_frame;
+            frame->base.previous = prev;
+            tstate->cframe->current_frame = &frame->base;
             /* Close the generator that we are currently iterating with
                'yield from' or awaiting on with 'await'. */
             PyFrameState state = gen->gi_frame_state;
@@ -470,7 +470,7 @@ _gen_throw(PyGenObject *gen, int close_on_genexit,
                              typ, val, tb);
             gen->gi_frame_state = state;
             tstate->cframe->current_frame = prev;
-            frame->previous = NULL;
+            frame->base.previous = NULL;
         } else {
             /* `yf` is an iterator or a coroutine-like object. */
             PyObject *meth;
@@ -921,11 +921,11 @@ _Py_MakeCoro(PyFunctionObject *func)
     if (origin_depth == 0) {
         ((PyCoroObject *)coro)->cr_origin_or_finalizer = NULL;
     } else {
-        _PyInterpreterFrame *frame = tstate->cframe->current_frame;
+        _PyFrame *frame = tstate->cframe->current_frame;
         assert(frame);
         assert(_PyFrame_IsIncomplete(frame));
-        frame = _PyFrame_GetFirstComplete(frame->previous);
-        PyObject *cr_origin = compute_cr_origin(origin_depth, frame);
+        _PyInterpreterFrame * pyframe = _PyFrame_GetFirstComplete(frame->previous);
+        PyObject *cr_origin = compute_cr_origin(origin_depth, pyframe);
         ((PyCoroObject *)coro)->cr_origin_or_finalizer = cr_origin;
         if (!cr_origin) {
             Py_DECREF(coro);
@@ -939,7 +939,7 @@ static PyObject *
 gen_new_with_qualname(PyTypeObject *type, PyFrameObject *f,
                       PyObject *name, PyObject *qualname)
 {
-    PyCodeObject *code = f->f_frame->f_code;
+    PyCodeObject *code = _PyFrame_GetCode(f->f_frame);
     int size = code->co_nlocalsplus + code->co_stacksize;
     PyGenObject *gen = PyObject_GC_NewVar(PyGenObject, type, size);
     if (gen == NULL) {
@@ -1311,7 +1311,7 @@ compute_cr_origin(int origin_depth, _PyInterpreterFrame *current_frame)
     /* First count how many frames we have */
     int frame_count = 0;
     for (; frame && frame_count < origin_depth; ++frame_count) {
-        frame = _PyFrame_GetFirstComplete(frame->previous);
+        frame = _PyFrame_GetFirstComplete(frame->base.previous);
     }
 
     /* Now collect them */
@@ -1321,7 +1321,7 @@ compute_cr_origin(int origin_depth, _PyInterpreterFrame *current_frame)
     }
     frame = current_frame;
     for (int i = 0; i < frame_count; ++i) {
-        PyCodeObject *code = frame->f_code;
+        PyCodeObject *code = _PyFrame_GetCode(frame);
         int line = _PyInterpreterFrame_GetLine(frame);
         PyObject *frameinfo = Py_BuildValue("OiO", code->co_filename, line,
                                             code->co_name);
@@ -1330,7 +1330,7 @@ compute_cr_origin(int origin_depth, _PyInterpreterFrame *current_frame)
             return NULL;
         }
         PyTuple_SET_ITEM(cr_origin, i, frameinfo);
-        frame = _PyFrame_GetFirstComplete(frame->previous);
+        frame = _PyFrame_GetFirstComplete(frame->base.previous);
     }
 
     return cr_origin;
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index 69e84743f13aac..95f1d41c919da8 100644
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -9516,7 +9516,7 @@ super_init_without_args(_PyInterpreterFrame *cframe, PyCodeObject *co,
         return -1;
     }
 
-    assert(cframe->f_code->co_nlocalsplus > 0);
+    assert(_PyFrame_GetCode(cframe)->co_nlocalsplus > 0);
     PyObject *firstarg = _PyFrame_GetLocalsArray(cframe)[0];
     // The first argument might be a cell.
     if (firstarg != NULL && (_PyLocals_GetKind(co->co_localspluskinds, 0) & CO_FAST_CELL)) {
@@ -9609,7 +9609,7 @@ super_init_impl(PyObject *self, PyTypeObject *type, PyObject *obj) {
                             "super(): no current frame");
             return -1;
         }
-        int res = super_init_without_args(frame, frame->f_code, &type, &obj);
+        int res = super_init_without_args(frame, _PyFrame_GetCode(frame), &type, &obj);
 
         if (res < 0) {
             return -1;
diff --git a/Python/_warnings.c b/Python/_warnings.c
index d510381c365b66..b87da8cd10a569 100644
--- a/Python/_warnings.c
+++ b/Python/_warnings.c
@@ -901,7 +901,7 @@ setup_context(Py_ssize_t stack_level,
     }
     else {
         globals = f->f_frame->f_globals;
-        *filename = Py_NewRef(f->f_frame->f_code->co_filename);
+        *filename = Py_NewRef(_PyFrame_GetCode(f->f_frame)->co_filename);
         *lineno = PyFrame_GetLineNumber(f);
         Py_DECREF(f);
     }
diff --git a/Python/bytecodes.c b/Python/bytecodes.c
index 2fe85dfeedf47f..1d83de0cb5574c 100644
--- a/Python/bytecodes.c
+++ b/Python/bytecodes.c
@@ -87,7 +87,7 @@ dummy_func(
 
         inst(RESUME, (--)) {
             assert(tstate->cframe == &cframe);
-            assert(frame == cframe.current_frame);
+            assert(&frame->base == cframe.current_frame);
             if (_Py_atomic_load_relaxed_int32(eval_breaker) && oparg < 2) {
                 goto handle_eval_breaker;
             }
@@ -113,7 +113,7 @@ dummy_func(
         }
 
         inst(LOAD_CONST, (-- value)) {
-            value = GETITEM(frame->f_code->co_consts, oparg);
+            value = GETITEM(CONSTS(), oparg);
             Py_INCREF(value);
         }
 
@@ -520,13 +520,11 @@ dummy_func(
 
         inst(INTERPRETER_EXIT, (retval --)) {
             assert(frame == &entry_frame);
-            assert(_PyFrame_IsIncomplete(frame));
-            STACK_SHRINK(1);  // Since we're not going to DISPATCH()
-            assert(EMPTY());
+            assert(_PyFrame_IsIncomplete(&frame->base));
             /* Restore previous cframe and return. */
             tstate->cframe = cframe.previous;
             tstate->cframe->use_tracing = cframe.use_tracing;
-            assert(tstate->cframe->current_frame == frame->previous);
+            assert(tstate->cframe->current_frame == frame->base.previous);
             assert(!_PyErr_Occurred(tstate));
             _Py_LeaveRecursiveCallTstate(tstate);
             return retval;
@@ -542,14 +540,15 @@ dummy_func(
             assert(frame != &entry_frame);
             // GH-99729: We need to unlink the frame *before* clearing it:
             _PyInterpreterFrame *dying = frame;
-            frame = cframe.current_frame = dying->previous;
+            frame = (_PyInterpreterFrame *)dying->base.previous;
+            cframe.current_frame = &frame->base;
             _PyEvalFrameClearAndPop(tstate, dying);
             _PyFrame_StackPush(frame, retval);
             goto resume_frame;
         }
 
         inst(RETURN_CONST, (--)) {
-            PyObject *retval = GETITEM(frame->f_code->co_consts, oparg);
+            PyObject *retval = GETITEM(CONSTS(), oparg);
             Py_INCREF(retval);
             assert(EMPTY());
             _PyFrame_SetStackPointer(frame, stack_pointer);
@@ -559,7 +558,8 @@ dummy_func(
             assert(frame != &entry_frame);
             // GH-99729: We need to unlink the frame *before* clearing it:
             _PyInterpreterFrame *dying = frame;
-            frame = cframe.current_frame = dying->previous;
+            frame = (_PyInterpreterFrame *)dying->base.previous;
+            cframe.current_frame = &frame->base;
             _PyEvalFrameClearAndPop(tstate, dying);
             _PyFrame_StackPush(frame, retval);
             goto resume_frame;
@@ -748,8 +748,9 @@ dummy_func(
             gen->gi_exc_state.previous_item = NULL;
             _Py_LeaveRecursiveCallPy(tstate);
             _PyInterpreterFrame *gen_frame = frame;
-            frame = cframe.current_frame = frame->previous;
-            gen_frame->previous = NULL;
+            frame = (_PyInterpreterFrame *)frame->base.previous;
+            cframe.current_frame = &frame->base;
+            gen_frame->base.previous = NULL;
             frame->prev_instr -= frame->yield_offset;
             _PyFrame_StackPush(frame, retval);
             goto resume_frame;
@@ -765,7 +766,7 @@ dummy_func(
             if (oparg) {
                 PyObject *lasti = values[0];
                 if (PyLong_Check(lasti)) {
-                    frame->prev_instr = _PyCode_CODE(frame->f_code) + PyLong_AsLong(lasti);
+                    frame->prev_instr = _PyCode_CODE(_PyFrame_GetCode(frame)) + PyLong_AsLong(lasti);
                     assert(!_PyErr_Occurred(tstate));
                 }
                 else {
@@ -835,7 +836,7 @@ dummy_func(
         }
 
         inst(STORE_NAME, (v -- )) {
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+            PyObject *name = GETITEM(NAMES(), oparg);
             PyObject *ns = LOCALS();
             int err;
             if (ns == NULL) {
@@ -853,7 +854,7 @@ dummy_func(
         }
 
         inst(DELETE_NAME, (--)) {
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+            PyObject *name = GETITEM(NAMES(), oparg);
             PyObject *ns = LOCALS();
             int err;
             if (ns == NULL) {
@@ -947,7 +948,7 @@ dummy_func(
             #if ENABLE_SPECIALIZATION
             if (ADAPTIVE_COUNTER_IS_ZERO(counter)) {
                 assert(cframe.use_tracing == 0);
-                PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+                PyObject *name = GETITEM(NAMES(), oparg);
                 next_instr--;
                 _Py_Specialize_StoreAttr(owner, next_instr, name);
                 DISPATCH_SAME_OPARG();
@@ -958,28 +959,28 @@ dummy_func(
             #else
             (void)counter;  // Unused.
             #endif  /* ENABLE_SPECIALIZATION */
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+            PyObject *name = GETITEM(NAMES(), oparg);
             int err = PyObject_SetAttr(owner, name, v);
             DECREF_INPUTS();
             ERROR_IF(err, error);
         }
 
         inst(DELETE_ATTR, (owner --)) {
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+            PyObject *name = GETITEM(NAMES(), oparg);
             int err = PyObject_SetAttr(owner, name, (PyObject *)NULL);
             DECREF_INPUTS();
             ERROR_IF(err, error);
         }
 
         inst(STORE_GLOBAL, (v --)) {
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+            PyObject *name = GETITEM(NAMES(), oparg);
             int err = PyDict_SetItem(GLOBALS(), name, v);
             DECREF_INPUTS();
             ERROR_IF(err, error);
         }
 
         inst(DELETE_GLOBAL, (--)) {
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+            PyObject *name = GETITEM(NAMES(), oparg);
             int err;
             err = PyDict_DelItem(GLOBALS(), name);
             // Can't use ERROR_IF here.
@@ -993,7 +994,7 @@ dummy_func(
         }
 
         inst(LOAD_NAME, ( -- v)) {
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+            PyObject *name = GETITEM(NAMES(), oparg);
             PyObject *locals = LOCALS();
             if (locals == NULL) {
                 _PyErr_Format(tstate, PyExc_SystemError,
@@ -1064,7 +1065,7 @@ dummy_func(
             _PyLoadGlobalCache *cache = (_PyLoadGlobalCache *)next_instr;
             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
                 assert(cframe.use_tracing == 0);
-                PyObject *name = GETITEM(frame->f_code->co_names, oparg>>1);
+                PyObject *name = GETITEM(NAMES(), oparg>>1);
                 next_instr--;
                 _Py_Specialize_LoadGlobal(GLOBALS(), BUILTINS(), next_instr, name);
                 DISPATCH_SAME_OPARG();
@@ -1072,7 +1073,7 @@ dummy_func(
             STAT_INC(LOAD_GLOBAL, deferred);
             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
             #endif  /* ENABLE_SPECIALIZATION */
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg>>1);
+            PyObject *name = GETITEM(NAMES(), oparg>>1);
             if (PyDict_CheckExact(GLOBALS())
                 && PyDict_CheckExact(BUILTINS()))
             {
@@ -1168,7 +1169,7 @@ dummy_func(
             // Can't use ERROR_IF here.
             // Fortunately we don't need its superpower.
             if (oldobj == NULL) {
-                format_exc_unbound(tstate, frame->f_code, oparg);
+                format_exc_unbound(tstate, _PyFrame_GetCode(frame), oparg);
                 goto error;
             }
             PyCell_SET(cell, NULL);
@@ -1178,8 +1179,8 @@ dummy_func(
         inst(LOAD_CLASSDEREF, ( -- value)) {
             PyObject *name, *locals = LOCALS();
             assert(locals);
-            assert(oparg >= 0 && oparg < frame->f_code->co_nlocalsplus);
-            name = PyTuple_GET_ITEM(frame->f_code->co_localsplusnames, oparg);
+            assert(oparg >= 0 && oparg < _PyFrame_GetCode(frame)->co_nlocalsplus);
+            name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg);
             if (PyDict_CheckExact(locals)) {
                 value = PyDict_GetItemWithError(locals, name);
                 if (value != NULL) {
@@ -1202,7 +1203,7 @@ dummy_func(
                 PyObject *cell = GETLOCAL(oparg);
                 value = PyCell_GET(cell);
                 if (value == NULL) {
-                    format_exc_unbound(tstate, frame->f_code, oparg);
+                    format_exc_unbound(tstate, _PyFrame_GetCode(frame), oparg);
                     goto error;
                 }
                 Py_INCREF(value);
@@ -1213,7 +1214,7 @@ dummy_func(
             PyObject *cell = GETLOCAL(oparg);
             value = PyCell_GET(cell);
             if (value == NULL) {
-                format_exc_unbound(tstate, frame->f_code, oparg);
+                format_exc_unbound(tstate, _PyFrame_GetCode(frame), oparg);
                 ERROR_IF(true, error);
             }
             Py_INCREF(value);
@@ -1228,7 +1229,7 @@ dummy_func(
 
         inst(COPY_FREE_VARS, (--)) {
             /* Copy closure variables to free variables */
-            PyCodeObject *co = frame->f_code;
+            PyCodeObject *co = _PyFrame_GetCode(frame);
             assert(PyFunction_Check(frame->f_funcobj));
             PyObject *closure = ((PyFunctionObject *)frame->f_funcobj)->func_closure;
             assert(oparg == co->co_nfreevars);
@@ -1418,7 +1419,7 @@ dummy_func(
             _PyAttrCache *cache = (_PyAttrCache *)next_instr;
             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
                 assert(cframe.use_tracing == 0);
-                PyObject *name = GETITEM(frame->f_code->co_names, oparg>>1);
+                PyObject *name = GETITEM(NAMES(), oparg>>1);
                 next_instr--;
                 _Py_Specialize_LoadAttr(owner, next_instr, name);
                 DISPATCH_SAME_OPARG();
@@ -1426,7 +1427,7 @@ dummy_func(
             STAT_INC(LOAD_ATTR, deferred);
             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
             #endif  /* ENABLE_SPECIALIZATION */
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg >> 1);
+            PyObject *name = GETITEM(NAMES(), oparg >> 1);
             if (oparg & 1) {
                 /* Designed to work in tandem with CALL, pushes two values. */
                 PyObject* meth = NULL;
@@ -1507,7 +1508,7 @@ dummy_func(
             PyDictObject *dict = (PyDictObject *)_PyDictOrValues_GetDict(dorv);
             DEOPT_IF(dict == NULL, LOAD_ATTR);
             assert(PyDict_CheckExact((PyObject *)dict));
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg>>1);
+            PyObject *name = GETITEM(NAMES(), oparg>>1);
             uint16_t hint = index;
             DEOPT_IF(hint >= (size_t)dict->ma_keys->dk_nentries, LOAD_ATTR);
             if (DK_IS_UNICODE(dict->ma_keys)) {
@@ -1598,7 +1599,7 @@ dummy_func(
             DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), LOAD_ATTR);
             STAT_INC(LOAD_ATTR, hit);
 
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg >> 1);
+            PyObject *name = GETITEM(NAMES(), oparg >> 1);
             Py_INCREF(f);
             _PyInterpreterFrame *new_frame = _PyFrame_PushUnchecked(tstate, f, 2);
             // Manipulate stack directly because we exit with DISPATCH_INLINED().
@@ -1643,7 +1644,7 @@ dummy_func(
             PyDictObject *dict = (PyDictObject *)_PyDictOrValues_GetDict(dorv);
             DEOPT_IF(dict == NULL, STORE_ATTR);
             assert(PyDict_CheckExact((PyObject *)dict));
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+            PyObject *name = GETITEM(NAMES(), oparg);
             DEOPT_IF(hint >= (size_t)dict->ma_keys->dk_nentries, STORE_ATTR);
             PyObject *old_value;
             uint64_t new_version;
@@ -1811,14 +1812,14 @@ dummy_func(
         }
 
          inst(IMPORT_NAME, (level, fromlist -- res)) {
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+            PyObject *name = GETITEM(NAMES(), oparg);
             res = import_name(tstate, frame, name, fromlist, level);
             DECREF_INPUTS();
             ERROR_IF(res == NULL, error);
         }
 
         inst(IMPORT_FROM, (from -- from, res)) {
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+            PyObject *name = GETITEM(NAMES(), oparg);
             res = import_from(tstate, from, name);
             ERROR_IF(res == NULL, error);
         }
@@ -1954,7 +1955,7 @@ dummy_func(
             /* before: [obj]; after [getiter(obj)] */
             if (PyCoro_CheckExact(iterable)) {
                 /* `iterable` is a coroutine */
-                if (!(frame->f_code->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) {
+                if (!(_PyFrame_GetCode(frame)->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) {
                     /* and it is used in a 'yield from' expression of a
                        regular generator. */
                     _PyErr_SetString(tstate, PyExc_TypeError,
@@ -2266,8 +2267,8 @@ dummy_func(
 
         inst(KW_NAMES, (--)) {
             assert(kwnames == NULL);
-            assert(oparg < PyTuple_GET_SIZE(frame->f_code->co_consts));
-            kwnames = GETITEM(frame->f_code->co_consts, oparg);
+            assert(oparg < PyTuple_GET_SIZE(CONSTS()));
+            kwnames = GETITEM(CONSTS(), oparg);
         }
 
         // Cache layout: counter/1, func_version/2, min_args/1
@@ -2353,6 +2354,7 @@ dummy_func(
                 JUMPBY(INLINE_CACHE_ENTRIES_CALL);
                 DISPATCH_INLINED(new_frame);
             }
+
             /* Callable is not a normal Python function */
             if (cframe.use_tracing) {
                 res = trace_call_function(
@@ -2360,10 +2362,10 @@ dummy_func(
                     positional_args, kwnames);
             }
             else {
-                res = PyObject_Vectorcall(
+                CALL_WITH_NATIVE_FRAME(callable, res = PyObject_Vectorcall(
                     callable, args,
                     positional_args | PY_VECTORCALL_ARGUMENTS_OFFSET,
-                    kwnames);
+                    kwnames));
             }
             kwnames = NULL;
             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
@@ -2504,8 +2506,8 @@ dummy_func(
             PyTypeObject *tp = (PyTypeObject *)callable;
             DEOPT_IF(tp->tp_vectorcall == NULL, CALL);
             STAT_INC(CALL, hit);
-            res = tp->tp_vectorcall((PyObject *)tp, args,
-                                    total_args - kwnames_len, kwnames);
+            CALL_WITH_NATIVE_FRAME(callable, res = tp->tp_vectorcall((PyObject *)tp, args,
+                                    total_args - kwnames_len, kwnames));
             kwnames = NULL;
             /* Free the arguments. */
             for (int i = 0; i < total_args; i++) {
@@ -2538,7 +2540,7 @@ dummy_func(
                 goto error;
             }
             PyObject *arg = args[0];
-            res = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable), arg);
+            CALL_WITH_NATIVE_FRAME(callable, res = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable), arg));
             _Py_LeaveRecursiveCallTstate(tstate);
             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
 
@@ -2564,10 +2566,10 @@ dummy_func(
             STAT_INC(CALL, hit);
             PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable);
             /* res = func(self, args, nargs) */
-            res = ((_PyCFunctionFast)(void(*)(void))cfunc)(
+            CALL_WITH_NATIVE_FRAME(callable, res = ((_PyCFunctionFast)(void(*)(void))cfunc)(
                 PyCFunction_GET_SELF(callable),
                 args,
-                total_args);
+                total_args));
             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
 
             /* Free the arguments. */
@@ -2602,12 +2604,12 @@ dummy_func(
             _PyCFunctionFastWithKeywords cfunc =
                 (_PyCFunctionFastWithKeywords)(void(*)(void))
                 PyCFunction_GET_FUNCTION(callable);
-            res = cfunc(
+            CALL_WITH_NATIVE_FRAME(callable, res = cfunc(
                 PyCFunction_GET_SELF(callable),
                 args,
                 total_args - KWNAMES_LEN(),
                 kwnames
-            );
+            ));
             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
             kwnames = NULL;
 
@@ -2636,7 +2638,8 @@ dummy_func(
             DEOPT_IF(callable != interp->callable_cache.len, CALL);
             STAT_INC(CALL, hit);
             PyObject *arg = args[0];
-            Py_ssize_t len_i = PyObject_Length(arg);
+            Py_ssize_t len_i;
+            CALL_WITH_NATIVE_FRAME(callable, len_i = PyObject_Length(arg));
             if (len_i < 0) {
                 goto error;
             }
@@ -2665,6 +2668,7 @@ dummy_func(
             STAT_INC(CALL, hit);
             PyObject *cls = args[1];
             PyObject *inst = args[0];
+
             int retval = PyObject_IsInstance(inst, cls);
             if (retval < 0) {
                 goto error;
@@ -2906,9 +2910,10 @@ dummy_func(
             gen_frame->owner = FRAME_OWNED_BY_GENERATOR;
             _Py_LeaveRecursiveCallPy(tstate);
             assert(frame != &entry_frame);
-            _PyInterpreterFrame *prev = frame->previous;
+            _PyInterpreterFrame *prev = (_PyInterpreterFrame *)frame->base.previous;
             _PyThreadState_PopFrame(tstate, frame);
-            frame = cframe.current_frame = prev;
+            frame = prev;
+            cframe.current_frame = &prev->base;
             _PyFrame_StackPush(frame, (PyObject *)gen);
             goto resume_frame;
         }
diff --git a/Python/ceval.c b/Python/ceval.c
index 7d60cf987e9c47..f536683a616444 100644
--- a/Python/ceval.c
+++ b/Python/ceval.c
@@ -127,6 +127,9 @@ lltrace_instruction(_PyInterpreterFrame *frame,
                     PyObject **stack_pointer,
                     _Py_CODEUNIT *next_instr)
 {
+    if (frame->owner == FRAME_OWNED_BY_CSTACK) {
+        return;
+    }
     /* This dump_stack() operation is risky, since the repr() of some
        objects enters the interpreter recursively. It is also slow.
        So you might want to comment it out. */
@@ -135,7 +138,7 @@ lltrace_instruction(_PyInterpreterFrame *frame,
     int opcode = next_instr->op.code;
     const char *opname = _PyOpcode_OpName[opcode];
     assert(opname != NULL);
-    int offset = (int)(next_instr - _PyCode_CODE(frame->f_code));
+    int offset = (int)(next_instr - _PyCode_CODE(_PyFrame_GetCode(frame)));
     if (HAS_ARG((int)_PyOpcode_Deopt[opcode])) {
         printf("%d: %s %d\n", offset * 2, opname, oparg);
     }
@@ -743,16 +746,16 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
     entry_frame.f_globals = (PyObject*)0xaaa3;
     entry_frame.f_builtins = (PyObject*)0xaaa4;
 #endif
-    entry_frame.f_code = tstate->interp->interpreter_trampoline;
+    entry_frame.base.f_executable = Py_None;
     entry_frame.prev_instr =
         _PyCode_CODE(tstate->interp->interpreter_trampoline);
     entry_frame.stacktop = 0;
     entry_frame.owner = FRAME_OWNED_BY_CSTACK;
     entry_frame.yield_offset = 0;
     /* Push frame */
-    entry_frame.previous = prev_cframe->current_frame;
-    frame->previous = &entry_frame;
-    cframe.current_frame = frame;
+    entry_frame.base.previous = prev_cframe->current_frame;
+    frame->base.previous = &entry_frame.base;
+    cframe.current_frame = &frame->base;
 
     if (_Py_EnterRecursiveCallTstate(tstate, "")) {
         tstate->c_recursion_remaining--;
@@ -778,7 +781,6 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
 
 /* Sets the above local variables from the frame */
 #define SET_LOCALS_FROM_FRAME() \
-    assert(_PyInterpreterFrame_LASTI(frame) >= -1); \
     /* Jump back to the last instruction executed... */ \
     next_instr = frame->prev_instr + 1; \
     stack_pointer = _PyFrame_GetStackPointer(frame); \
@@ -853,7 +855,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
     {
         assert(cframe.use_tracing);
         assert(tstate->tracing == 0);
-        if (INSTR_OFFSET() >= frame->f_code->_co_firsttraceable) {
+        if (frame->owner != FRAME_OWNED_BY_CSTACK && INSTR_OFFSET() >= _PyFrame_GetCode(frame)->_co_firsttraceable) {
             int instr_prev = _PyInterpreterFrame_LASTI(frame);
             frame->prev_instr = next_instr;
             NEXTOPARG();
@@ -940,7 +942,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
             opcode = next_instr->op.code;
             _PyErr_Format(tstate, PyExc_SystemError,
                           "%U:%d: unknown opcode %d",
-                          frame->f_code->co_filename,
+                          _PyFrame_GetCode(frame)->co_filename,
                           _PyInterpreterFrame_GetLine(frame),
                           opcode);
             goto error;
@@ -955,7 +957,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
         {
             format_exc_check_arg(tstate, PyExc_UnboundLocalError,
                 UNBOUNDLOCAL_ERROR_MSG,
-                PyTuple_GetItem(frame->f_code->co_localsplusnames, oparg)
+                PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg)
             );
             goto error;
         }
@@ -982,7 +984,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
 
         /* Log traceback info. */
         assert(frame != &entry_frame);
-        if (!_PyFrame_IsIncomplete(frame)) {
+        if (!_PyFrame_IsIncomplete(&frame->base)) {
             PyFrameObject *f = _PyFrame_GetFrameObject(frame);
             if (f != NULL) {
                 PyTraceBack_Here(f);
@@ -1000,7 +1002,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
             /* We can't use frame->f_lasti here, as RERAISE may have set it */
             int offset = INSTR_OFFSET()-1;
             int level, handler, lasti;
-            if (get_exception_handler(frame->f_code, offset, &level, &handler, &lasti) == 0) {
+            if (get_exception_handler(_PyFrame_GetCode(frame), offset, &level, &handler, &lasti) == 0) {
                 // No handlers, so exit.
                 assert(_PyErr_Occurred(tstate));
 
@@ -1049,13 +1051,14 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
     assert(frame != &entry_frame);
     // GH-99729: We need to unlink the frame *before* clearing it:
     _PyInterpreterFrame *dying = frame;
-    frame = cframe.current_frame = dying->previous;
+    cframe.current_frame = dying->base.previous;
+    frame = (_PyInterpreterFrame *)cframe.current_frame;
     _PyEvalFrameClearAndPop(tstate, dying);
     if (frame == &entry_frame) {
         /* Restore previous cframe and exit */
         tstate->cframe = cframe.previous;
         tstate->cframe->use_tracing = cframe.use_tracing;
-        assert(tstate->cframe->current_frame == frame->previous);
+        assert(tstate->cframe->current_frame == frame->base.previous);
         _Py_LeaveRecursiveCallTstate(tstate);
         return NULL;
     }
@@ -1593,12 +1596,12 @@ clear_thread_frame(PyThreadState *tstate, _PyInterpreterFrame * frame)
     assert(frame->owner == FRAME_OWNED_BY_THREAD);
     // Make sure that this is, indeed, the top frame. We can't check this in
     // _PyThreadState_PopFrame, since f_code is already cleared at that point:
-    assert((PyObject **)frame + frame->f_code->co_framesize ==
+    assert((PyObject **)frame + _PyFrame_GetCode(frame)->co_framesize ==
         tstate->datastack_top);
     tstate->c_recursion_remaining--;
     assert(frame->frame_obj == NULL || frame->frame_obj->f_frame == frame);
     _PyFrame_ClearExceptCode(frame);
-    Py_DECREF(frame->f_code);
+    Py_DECREF(frame->base.f_executable);
     tstate->c_recursion_remaining++;
     _PyThreadState_PopFrame(tstate, frame);
 }
@@ -1616,7 +1619,7 @@ clear_gen_frame(PyThreadState *tstate, _PyInterpreterFrame * frame)
     assert(frame->frame_obj == NULL || frame->frame_obj->f_frame == frame);
     _PyFrame_ClearExceptCode(frame);
     tstate->c_recursion_remaining++;
-    frame->previous = NULL;
+    frame->base.previous = NULL;
 }
 
 static void
@@ -2070,7 +2073,7 @@ call_trace_protected(Py_tracefunc func, PyObject *obj,
 static void
 initialize_trace_info(PyTraceInfo *trace_info, _PyInterpreterFrame *frame)
 {
-    PyCodeObject *code = frame->f_code;
+    PyCodeObject *code = _PyFrame_GetCode(frame);
     if (trace_info->code != code) {
         trace_info->code = code;
         _PyCode_InitAddressRange(code, &trace_info->bounds);
@@ -2109,10 +2112,10 @@ call_trace(Py_tracefunc func, PyObject *obj,
     tstate->tracing_what = what;
     PyThreadState_EnterTracing(tstate);
     assert(_PyInterpreterFrame_LASTI(frame) >= 0);
-    if (_PyCode_InitLineArray(frame->f_code)) {
+    if (_PyCode_InitLineArray(_PyFrame_GetCode(frame))) {
         return -1;
     }
-    f->f_lineno = _PyCode_LineNumberFromArray(frame->f_code, _PyInterpreterFrame_LASTI(frame));
+    f->f_lineno = _PyCode_LineNumberFromArray(_PyFrame_GetCode(frame), _PyInterpreterFrame_LASTI(frame));
     result = func(obj, f, what, arg);
     f->f_lineno = 0;
     PyThreadState_LeaveTracing(tstate);
@@ -2149,17 +2152,17 @@ maybe_call_line_trace(Py_tracefunc func, PyObject *obj,
        represents a jump backwards, update the frame's line number and
        then call the trace function if we're tracing source lines.
     */
-    if (_PyCode_InitLineArray(frame->f_code)) {
+    if (_PyCode_InitLineArray(_PyFrame_GetCode(frame))) {
         return -1;
     }
     int lastline;
-    if (instr_prev <= frame->f_code->_co_firsttraceable) {
+    if (instr_prev <= _PyFrame_GetCode(frame)->_co_firsttraceable) {
         lastline = -1;
     }
     else {
-        lastline = _PyCode_LineNumberFromArray(frame->f_code, instr_prev);
+        lastline = _PyCode_LineNumberFromArray(_PyFrame_GetCode(frame), instr_prev);
     }
-    int line = _PyCode_LineNumberFromArray(frame->f_code, _PyInterpreterFrame_LASTI(frame));
+    int line = _PyCode_LineNumberFromArray(_PyFrame_GetCode(frame), _PyInterpreterFrame_LASTI(frame));
     PyFrameObject *f = _PyFrame_GetFrameObject(frame);
     if (f == NULL) {
         return -1;
@@ -2451,11 +2454,11 @@ int
 PyEval_MergeCompilerFlags(PyCompilerFlags *cf)
 {
     PyThreadState *tstate = _PyThreadState_GET();
-    _PyInterpreterFrame *current_frame = tstate->cframe->current_frame;
+    _PyFrame *current_frame = tstate->cframe->current_frame;
     int result = cf->cf_flags != 0;
 
-    if (current_frame != NULL) {
-        const int codeflags = current_frame->f_code->co_flags;
+    if (current_frame != NULL && PyCode_Check(current_frame->f_executable)) {
+        const int codeflags = ((PyCodeObject *)current_frame->f_executable)->co_flags;
         const int compilerflags = codeflags & PyCF_MASK;
         if (compilerflags) {
             result = 1;
@@ -2495,7 +2498,7 @@ PyEval_GetFuncDesc(PyObject *func)
 #define C_TRACE(x, call) \
 if (use_tracing && tstate->c_profilefunc) { \
     if (call_trace(tstate->c_profilefunc, tstate->c_profileobj, \
-        tstate, tstate->cframe->current_frame, \
+        tstate, (_PyInterpreterFrame *)tstate->cframe->current_frame, \
         PyTrace_C_CALL, func)) { \
         x = NULL; \
     } \
@@ -2505,13 +2508,13 @@ if (use_tracing && tstate->c_profilefunc) { \
             if (x == NULL) { \
                 call_trace_protected(tstate->c_profilefunc, \
                     tstate->c_profileobj, \
-                    tstate, tstate->cframe->current_frame, \
+                    tstate, (_PyInterpreterFrame *)tstate->cframe->current_frame, \
                     PyTrace_C_EXCEPTION, func); \
                 /* XXX should pass (type, value, tb) */ \
             } else { \
                 if (call_trace(tstate->c_profilefunc, \
                     tstate->c_profileobj, \
-                    tstate, tstate->cframe->current_frame, \
+                    tstate, (_PyInterpreterFrame *)tstate->cframe->current_frame, \
                     PyTrace_C_RETURN, func)) { \
                     Py_DECREF(x); \
                     x = NULL; \
@@ -2980,7 +2983,7 @@ dtrace_function_entry(_PyInterpreterFrame *frame)
     const char *funcname;
     int lineno;
 
-    PyCodeObject *code = frame->f_code;
+    PyCodeObject *code = _PyFrame_GetCode(frame);
     filename = PyUnicode_AsUTF8(code->co_filename);
     funcname = PyUnicode_AsUTF8(code->co_name);
     lineno = _PyInterpreterFrame_GetLine(frame);
@@ -2995,7 +2998,7 @@ dtrace_function_return(_PyInterpreterFrame *frame)
     const char *funcname;
     int lineno;
 
-    PyCodeObject *code = frame->f_code;
+    PyCodeObject *code = _PyFrame_GetCode(frame);
     filename = PyUnicode_AsUTF8(code->co_filename);
     funcname = PyUnicode_AsUTF8(code->co_name);
     lineno = _PyInterpreterFrame_GetLine(frame);
@@ -3023,11 +3026,11 @@ maybe_dtrace_line(_PyInterpreterFrame *frame,
         if (_PyInterpreterFrame_LASTI(frame) < instr_prev ||
             (line != lastline && addr == trace_info->bounds.ar_start))
         {
-            co_filename = PyUnicode_AsUTF8(frame->f_code->co_filename);
+            co_filename = PyUnicode_AsUTF8(_PyFrame_GetCode(frame)->co_filename);
             if (!co_filename) {
                 co_filename = "?";
             }
-            co_name = PyUnicode_AsUTF8(frame->f_code->co_name);
+            co_name = PyUnicode_AsUTF8(_PyFrame_GetCode(frame)->co_name);
             if (!co_name) {
                 co_name = "?";
             }
diff --git a/Python/ceval_macros.h b/Python/ceval_macros.h
index c2257515a30599..7a0d1e52ee5032 100644
--- a/Python/ceval_macros.h
+++ b/Python/ceval_macros.h
@@ -110,8 +110,9 @@
     do {                                                \
         _PyFrame_SetStackPointer(frame, stack_pointer); \
         frame->prev_instr = next_instr - 1;             \
-        (NEW_FRAME)->previous = frame;                  \
-        frame = cframe.current_frame = (NEW_FRAME);     \
+        (NEW_FRAME)->base.previous = &frame->base;      \
+        frame = (NEW_FRAME);                            \
+        cframe.current_frame = &frame->base;            \
         CALL_STAT_INC(inlined_py_calls);                \
         goto start_frame;                               \
     } while (0)
@@ -140,13 +141,13 @@ GETITEM(PyObject *v, Py_ssize_t i) {
 /* Code access macros */
 
 /* The integer overflow is checked by an assertion below. */
-#define INSTR_OFFSET() ((int)(next_instr - _PyCode_CODE(frame->f_code)))
+#define INSTR_OFFSET() ((int)(next_instr - _PyCode_CODE(_PyFrame_GetCode(frame))))
 #define NEXTOPARG()  do { \
         _Py_CODEUNIT word = *next_instr; \
         opcode = word.op.code; \
         oparg = word.op.arg; \
     } while (0)
-#define JUMPTO(x)       (next_instr = _PyCode_CODE(frame->f_code) + (x))
+#define JUMPTO(x)       (next_instr = _PyCode_CODE(_PyFrame_GetCode(frame)) + (x))
 #define JUMPBY(x)       (next_instr += (x))
 
 /* OpCode prediction macros
@@ -199,7 +200,7 @@ GETITEM(PyObject *v, Py_ssize_t i) {
 /* The stack can grow at most MAXINT deep, as co_nlocals and
    co_stacksize are ints. */
 #define STACK_LEVEL()     ((int)(stack_pointer - _PyFrame_Stackbase(frame)))
-#define STACK_SIZE()      (frame->f_code->co_stacksize)
+#define STACK_SIZE()      (_PyFrame_GetCode(frame)->co_stacksize)
 #define EMPTY()           (STACK_LEVEL() == 0)
 #define TOP()             (stack_pointer[-1])
 #define SECOND()          (stack_pointer[-2])
@@ -282,6 +283,8 @@ GETITEM(PyObject *v, Py_ssize_t i) {
 #define GLOBALS() frame->f_globals
 #define BUILTINS() frame->f_builtins
 #define LOCALS() frame->f_locals
+#define CONSTS() ((PyCodeObject *)frame->base.f_executable)->co_consts
+#define NAMES() ((PyCodeObject *)frame->base.f_executable)->co_names
 
 /* Shared opcode macros */
 
@@ -352,6 +355,18 @@ GETITEM(PyObject *v, Py_ssize_t i) {
 #define KWNAMES_LEN() \
     (kwnames == NULL ? 0 : ((int)PyTuple_GET_SIZE(kwnames)))
 
+
+#define CALL_WITH_NATIVE_FRAME(_callable, _call) \
+    do { \
+        assert(cframe.current_frame == &frame->base); \
+        _PyFrame _bframe; \
+        _bframe.f_executable = _callable; \
+        _bframe.previous = &frame->base; \
+        cframe.current_frame = &_bframe; \
+        (_call); \
+        cframe.current_frame = &frame->base; \
+    } while (0)
+
 #define DECREF_INPUTS_AND_REUSE_FLOAT(left, right, dval, result) \
 do { \
     if (Py_REFCNT(left) == 1) { \
diff --git a/Python/frame.c b/Python/frame.c
index c2c0be30113912..58e310dfb66728 100644
--- a/Python/frame.c
+++ b/Python/frame.c
@@ -14,7 +14,7 @@ _PyFrame_Traverse(_PyInterpreterFrame *frame, visitproc visit, void *arg)
     Py_VISIT(frame->frame_obj);
     Py_VISIT(frame->f_locals);
     Py_VISIT(frame->f_funcobj);
-    Py_VISIT(frame->f_code);
+    Py_VISIT(_PyFrame_GetCode(frame));
    /* locals */
     PyObject **locals = _PyFrame_GetLocalsArray(frame);
     int i = 0;
@@ -31,7 +31,7 @@ _PyFrame_MakeAndSetFrameObject(_PyInterpreterFrame *frame)
     assert(frame->frame_obj == NULL);
     PyObject *exc = PyErr_GetRaisedException();
 
-    PyFrameObject *f = _PyFrame_New_NoTrack(frame->f_code);
+    PyFrameObject *f = _PyFrame_New_NoTrack(_PyFrame_GetCode(frame));
     if (f == NULL) {
         Py_XDECREF(exc);
         return NULL;
@@ -65,12 +65,12 @@ _PyFrame_MakeAndSetFrameObject(_PyInterpreterFrame *frame)
 void
 _PyFrame_Copy(_PyInterpreterFrame *src, _PyInterpreterFrame *dest)
 {
-    assert(src->stacktop >= src->f_code->co_nlocalsplus);
+    assert(src->stacktop >= _PyFrame_GetCode(src)->co_nlocalsplus);
     Py_ssize_t size = ((char*)&src->localsplus[src->stacktop]) - (char *)src;
     memcpy(dest, src, size);
     // Don't leave a dangling pointer to the old frame when creating generators
     // and coroutines:
-    dest->previous = NULL;
+    dest->base.previous = NULL;
 }
 
 
@@ -81,21 +81,21 @@ take_ownership(PyFrameObject *f, _PyInterpreterFrame *frame)
     assert(frame->owner != FRAME_OWNED_BY_FRAME_OBJECT);
     assert(frame->owner != FRAME_CLEARED);
     Py_ssize_t size = ((char*)&frame->localsplus[frame->stacktop]) - (char *)frame;
-    Py_INCREF(frame->f_code);
+    Py_INCREF(_PyFrame_GetCode(frame));
     memcpy((_PyInterpreterFrame *)f->_f_frame_data, frame, size);
     frame = (_PyInterpreterFrame *)f->_f_frame_data;
     f->f_frame = frame;
     frame->owner = FRAME_OWNED_BY_FRAME_OBJECT;
-    if (_PyFrame_IsIncomplete(frame)) {
+    if (_PyFrame_IsIncomplete(&frame->base)) {
         // This may be a newly-created generator or coroutine frame. Since it's
         // dead anyways, just pretend that the first RESUME ran:
-        PyCodeObject *code = frame->f_code;
+        PyCodeObject *code = _PyFrame_GetCode(frame);
         frame->prev_instr = _PyCode_CODE(code) + code->_co_firsttraceable;
     }
-    assert(!_PyFrame_IsIncomplete(frame));
+    assert(!_PyFrame_IsIncomplete(&frame->base));
     assert(f->f_back == NULL);
-    _PyInterpreterFrame *prev = _PyFrame_GetFirstComplete(frame->previous);
-    frame->previous = NULL;
+    _PyInterpreterFrame *prev = _PyFrame_GetFirstComplete(frame->base.previous);
+    frame->base.previous = NULL;
     if (prev) {
         assert(prev->owner != FRAME_OWNED_BY_CSTACK);
         /* Link PyFrameObjects.f_back and remove link through _PyInterpreterFrame.previous */
@@ -124,7 +124,7 @@ _PyFrame_ClearExceptCode(_PyInterpreterFrame *frame)
         _PyFrame_GetGenerator(frame)->gi_frame_state == FRAME_CLEARED);
     // GH-99729: Clearing this frame can expose the stack (via finalizers). It's
     // crucial that this frame has been unlinked, and is no longer visible:
-    assert(_PyThreadState_GET()->cframe->current_frame != frame);
+    assert(_PyThreadState_GET()->cframe->current_frame != &frame->base);
     if (frame->frame_obj) {
         PyFrameObject *f = frame->frame_obj;
         frame->frame_obj = NULL;
@@ -148,5 +148,5 @@ int
 _PyInterpreterFrame_GetLine(_PyInterpreterFrame *frame)
 {
     int addr = _PyInterpreterFrame_LASTI(frame) * sizeof(_Py_CODEUNIT);
-    return PyCode_Addr2Line(frame->f_code, addr);
+    return PyCode_Addr2Line(_PyFrame_GetCode(frame), addr);
 }
diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h
index d793c1e23bc48e..9a25148b3b37f3 100644
--- a/Python/generated_cases.c.h
+++ b/Python/generated_cases.c.h
@@ -10,7 +10,7 @@
         TARGET(RESUME) {
             #line 89 "Python/bytecodes.c"
             assert(tstate->cframe == &cframe);
-            assert(frame == cframe.current_frame);
+            assert(&frame->base == cframe.current_frame);
             if (_Py_atomic_load_relaxed_int32(eval_breaker) && oparg < 2) {
                 goto handle_eval_breaker;
             }
@@ -59,7 +59,7 @@
             PREDICTED(LOAD_CONST);
             PyObject *value;
             #line 116 "Python/bytecodes.c"
-            value = GETITEM(frame->f_code->co_consts, oparg);
+            value = GETITEM(CONSTS(), oparg);
             Py_INCREF(value);
             #line 65 "Python/generated_cases.c.h"
             STACK_GROW(1);
@@ -120,7 +120,7 @@
             {
                 PyObject *value;
                 #line 116 "Python/bytecodes.c"
-                value = GETITEM(frame->f_code->co_consts, oparg);
+                value = GETITEM(CONSTS(), oparg);
                 Py_INCREF(value);
                 #line 126 "Python/generated_cases.c.h"
                 _tmp_1 = value;
@@ -179,7 +179,7 @@
             {
                 PyObject *value;
                 #line 116 "Python/bytecodes.c"
-                value = GETITEM(frame->f_code->co_consts, oparg);
+                value = GETITEM(CONSTS(), oparg);
                 Py_INCREF(value);
                 #line 185 "Python/generated_cases.c.h"
                 _tmp_2 = value;
@@ -827,22 +827,20 @@
             PyObject *retval = stack_pointer[-1];
             #line 522 "Python/bytecodes.c"
             assert(frame == &entry_frame);
-            assert(_PyFrame_IsIncomplete(frame));
-            STACK_SHRINK(1);  // Since we're not going to DISPATCH()
-            assert(EMPTY());
+            assert(_PyFrame_IsIncomplete(&frame->base));
             /* Restore previous cframe and return. */
             tstate->cframe = cframe.previous;
             tstate->cframe->use_tracing = cframe.use_tracing;
-            assert(tstate->cframe->current_frame == frame->previous);
+            assert(tstate->cframe->current_frame == frame->base.previous);
             assert(!_PyErr_Occurred(tstate));
             _Py_LeaveRecursiveCallTstate(tstate);
             return retval;
-            #line 841 "Python/generated_cases.c.h"
+            #line 839 "Python/generated_cases.c.h"
         }
 
         TARGET(RETURN_VALUE) {
             PyObject *retval = stack_pointer[-1];
-            #line 536 "Python/bytecodes.c"
+            #line 534 "Python/bytecodes.c"
             STACK_SHRINK(1);
             assert(EMPTY());
             _PyFrame_SetStackPointer(frame, stack_pointer);
@@ -852,16 +850,17 @@
             assert(frame != &entry_frame);
             // GH-99729: We need to unlink the frame *before* clearing it:
             _PyInterpreterFrame *dying = frame;
-            frame = cframe.current_frame = dying->previous;
+            frame = (_PyInterpreterFrame *)dying->base.previous;
+            cframe.current_frame = &frame->base;
             _PyEvalFrameClearAndPop(tstate, dying);
             _PyFrame_StackPush(frame, retval);
             goto resume_frame;
-            #line 860 "Python/generated_cases.c.h"
+            #line 859 "Python/generated_cases.c.h"
         }
 
         TARGET(RETURN_CONST) {
-            #line 552 "Python/bytecodes.c"
-            PyObject *retval = GETITEM(frame->f_code->co_consts, oparg);
+            #line 551 "Python/bytecodes.c"
+            PyObject *retval = GETITEM(CONSTS(), oparg);
             Py_INCREF(retval);
             assert(EMPTY());
             _PyFrame_SetStackPointer(frame, stack_pointer);
@@ -871,7 +870,8 @@
             assert(frame != &entry_frame);
             // GH-99729: We need to unlink the frame *before* clearing it:
             _PyInterpreterFrame *dying = frame;
-            frame = cframe.current_frame = dying->previous;
+            frame = (_PyInterpreterFrame *)dying->base.previous;
+            cframe.current_frame = &frame->base;
             _PyEvalFrameClearAndPop(tstate, dying);
             _PyFrame_StackPush(frame, retval);
             goto resume_frame;
@@ -1097,20 +1097,21 @@
             gen->gi_exc_state.previous_item = NULL;
             _Py_LeaveRecursiveCallPy(tstate);
             _PyInterpreterFrame *gen_frame = frame;
-            frame = cframe.current_frame = frame->previous;
-            gen_frame->previous = NULL;
+            frame = (_PyInterpreterFrame *)frame->base.previous;
+            cframe.current_frame = &frame->base;
+            gen_frame->base.previous = NULL;
             frame->prev_instr -= frame->yield_offset;
             _PyFrame_StackPush(frame, retval);
             goto resume_frame;
-            #line 1106 "Python/generated_cases.c.h"
+            #line 1107 "Python/generated_cases.c.h"
         }
 
         TARGET(POP_EXCEPT) {
             PyObject *exc_value = stack_pointer[-1];
-            #line 759 "Python/bytecodes.c"
+            #line 760 "Python/bytecodes.c"
             _PyErr_StackItem *exc_info = tstate->exc_info;
             Py_XSETREF(exc_info->exc_value, exc_value);
-            #line 1114 "Python/generated_cases.c.h"
+            #line 1115 "Python/generated_cases.c.h"
             STACK_SHRINK(1);
             DISPATCH();
         }
@@ -1118,12 +1119,12 @@
         TARGET(RERAISE) {
             PyObject *exc = stack_pointer[-1];
             PyObject **values = (stack_pointer - (1 + oparg));
-            #line 764 "Python/bytecodes.c"
+            #line 765 "Python/bytecodes.c"
             assert(oparg >= 0 && oparg <= 2);
             if (oparg) {
                 PyObject *lasti = values[0];
                 if (PyLong_Check(lasti)) {
-                    frame->prev_instr = _PyCode_CODE(frame->f_code) + PyLong_AsLong(lasti);
+                    frame->prev_instr = _PyCode_CODE(_PyFrame_GetCode(frame)) + PyLong_AsLong(lasti);
                     assert(!_PyErr_Occurred(tstate));
                 }
                 else {
@@ -1136,26 +1137,26 @@
             Py_INCREF(exc);
             _PyErr_SetRaisedException(tstate, exc);
             goto exception_unwind;
-            #line 1140 "Python/generated_cases.c.h"
+            #line 1141 "Python/generated_cases.c.h"
         }
 
         TARGET(END_ASYNC_FOR) {
             PyObject *exc = stack_pointer[-1];
             PyObject *awaitable = stack_pointer[-2];
-            #line 784 "Python/bytecodes.c"
+            #line 785 "Python/bytecodes.c"
             assert(exc && PyExceptionInstance_Check(exc));
             if (PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration)) {
-            #line 1149 "Python/generated_cases.c.h"
+            #line 1150 "Python/generated_cases.c.h"
                 Py_DECREF(awaitable);
                 Py_DECREF(exc);
-            #line 787 "Python/bytecodes.c"
+            #line 788 "Python/bytecodes.c"
             }
             else {
                 Py_INCREF(exc);
                 _PyErr_SetRaisedException(tstate, exc);
                 goto exception_unwind;
             }
-            #line 1159 "Python/generated_cases.c.h"
+            #line 1160 "Python/generated_cases.c.h"
             STACK_SHRINK(2);
             DISPATCH();
         }
@@ -1166,23 +1167,23 @@
             PyObject *sub_iter = stack_pointer[-3];
             PyObject *none;
             PyObject *value;
-            #line 796 "Python/bytecodes.c"
+            #line 797 "Python/bytecodes.c"
             assert(throwflag);
             assert(exc_value && PyExceptionInstance_Check(exc_value));
             if (PyErr_GivenExceptionMatches(exc_value, PyExc_StopIteration)) {
                 value = Py_NewRef(((PyStopIterationObject *)exc_value)->value);
-            #line 1175 "Python/generated_cases.c.h"
+            #line 1176 "Python/generated_cases.c.h"
                 Py_DECREF(sub_iter);
                 Py_DECREF(last_sent_val);
                 Py_DECREF(exc_value);
-            #line 801 "Python/bytecodes.c"
+            #line 802 "Python/bytecodes.c"
                 none = Py_NewRef(Py_None);
             }
             else {
                 _PyErr_SetRaisedException(tstate, Py_NewRef(exc_value));
                 goto exception_unwind;
             }
-            #line 1186 "Python/generated_cases.c.h"
+            #line 1187 "Python/generated_cases.c.h"
             STACK_SHRINK(1);
             stack_pointer[-1] = value;
             stack_pointer[-2] = none;
@@ -1191,9 +1192,9 @@
 
         TARGET(LOAD_ASSERTION_ERROR) {
             PyObject *value;
-            #line 810 "Python/bytecodes.c"
+            #line 811 "Python/bytecodes.c"
             value = Py_NewRef(PyExc_AssertionError);
-            #line 1197 "Python/generated_cases.c.h"
+            #line 1198 "Python/generated_cases.c.h"
             STACK_GROW(1);
             stack_pointer[-1] = value;
             DISPATCH();
@@ -1201,7 +1202,7 @@
 
         TARGET(LOAD_BUILD_CLASS) {
             PyObject *bc;
-            #line 814 "Python/bytecodes.c"
+            #line 815 "Python/bytecodes.c"
             if (PyDict_CheckExact(BUILTINS())) {
                 bc = _PyDict_GetItemWithError(BUILTINS(),
                                               &_Py_ID(__build_class__));
@@ -1223,7 +1224,7 @@
                     if (true) goto error;
                 }
             }
-            #line 1227 "Python/generated_cases.c.h"
+            #line 1228 "Python/generated_cases.c.h"
             STACK_GROW(1);
             stack_pointer[-1] = bc;
             DISPATCH();
@@ -1231,34 +1232,34 @@
 
         TARGET(STORE_NAME) {
             PyObject *v = stack_pointer[-1];
-            #line 838 "Python/bytecodes.c"
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+            #line 839 "Python/bytecodes.c"
+            PyObject *name = GETITEM(NAMES(), oparg);
             PyObject *ns = LOCALS();
             int err;
             if (ns == NULL) {
                 _PyErr_Format(tstate, PyExc_SystemError,
                               "no locals found when storing %R", name);
-            #line 1242 "Python/generated_cases.c.h"
+            #line 1243 "Python/generated_cases.c.h"
                 Py_DECREF(v);
-            #line 845 "Python/bytecodes.c"
+            #line 846 "Python/bytecodes.c"
                 if (true) goto pop_1_error;
             }
             if (PyDict_CheckExact(ns))
                 err = PyDict_SetItem(ns, name, v);
             else
                 err = PyObject_SetItem(ns, name, v);
-            #line 1251 "Python/generated_cases.c.h"
+            #line 1252 "Python/generated_cases.c.h"
             Py_DECREF(v);
-            #line 852 "Python/bytecodes.c"
+            #line 853 "Python/bytecodes.c"
             if (err) goto pop_1_error;
-            #line 1255 "Python/generated_cases.c.h"
+            #line 1256 "Python/generated_cases.c.h"
             STACK_SHRINK(1);
             DISPATCH();
         }
 
         TARGET(DELETE_NAME) {
-            #line 856 "Python/bytecodes.c"
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+            #line 857 "Python/bytecodes.c"
+            PyObject *name = GETITEM(NAMES(), oparg);
             PyObject *ns = LOCALS();
             int err;
             if (ns == NULL) {
@@ -1274,7 +1275,7 @@
                                      name);
                 goto error;
             }
-            #line 1278 "Python/generated_cases.c.h"
+            #line 1279 "Python/generated_cases.c.h"
             DISPATCH();
         }
 
@@ -1282,7 +1283,7 @@
             PREDICTED(UNPACK_SEQUENCE);
             static_assert(INLINE_CACHE_ENTRIES_UNPACK_SEQUENCE == 1, "incorrect cache size");
             PyObject *seq = stack_pointer[-1];
-            #line 882 "Python/bytecodes.c"
+            #line 883 "Python/bytecodes.c"
             #if ENABLE_SPECIALIZATION
             _PyUnpackSequenceCache *cache = (_PyUnpackSequenceCache *)next_instr;
             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
@@ -1296,11 +1297,11 @@
             #endif  /* ENABLE_SPECIALIZATION */
             PyObject **top = stack_pointer + oparg - 1;
             int res = unpack_iterable(tstate, seq, oparg, -1, top);
-            #line 1300 "Python/generated_cases.c.h"
+            #line 1301 "Python/generated_cases.c.h"
             Py_DECREF(seq);
-            #line 896 "Python/bytecodes.c"
+            #line 897 "Python/bytecodes.c"
             if (res == 0) goto pop_1_error;
-            #line 1304 "Python/generated_cases.c.h"
+            #line 1305 "Python/generated_cases.c.h"
             STACK_SHRINK(1);
             STACK_GROW(oparg);
             next_instr += 1;
@@ -1310,14 +1311,14 @@
         TARGET(UNPACK_SEQUENCE_TWO_TUPLE) {
             PyObject *seq = stack_pointer[-1];
             PyObject **values = stack_pointer - (1);
-            #line 900 "Python/bytecodes.c"
+            #line 901 "Python/bytecodes.c"
             DEOPT_IF(!PyTuple_CheckExact(seq), UNPACK_SEQUENCE);
             DEOPT_IF(PyTuple_GET_SIZE(seq) != 2, UNPACK_SEQUENCE);
             assert(oparg == 2);
             STAT_INC(UNPACK_SEQUENCE, hit);
             values[0] = Py_NewRef(PyTuple_GET_ITEM(seq, 1));
             values[1] = Py_NewRef(PyTuple_GET_ITEM(seq, 0));
-            #line 1321 "Python/generated_cases.c.h"
+            #line 1322 "Python/generated_cases.c.h"
             Py_DECREF(seq);
             STACK_SHRINK(1);
             STACK_GROW(oparg);
@@ -1328,7 +1329,7 @@
         TARGET(UNPACK_SEQUENCE_TUPLE) {
             PyObject *seq = stack_pointer[-1];
             PyObject **values = stack_pointer - (1);
-            #line 910 "Python/bytecodes.c"
+            #line 911 "Python/bytecodes.c"
             DEOPT_IF(!PyTuple_CheckExact(seq), UNPACK_SEQUENCE);
             DEOPT_IF(PyTuple_GET_SIZE(seq) != oparg, UNPACK_SEQUENCE);
             STAT_INC(UNPACK_SEQUENCE, hit);
@@ -1336,7 +1337,7 @@
             for (int i = oparg; --i >= 0; ) {
                 *values++ = Py_NewRef(items[i]);
             }
-            #line 1340 "Python/generated_cases.c.h"
+            #line 1341 "Python/generated_cases.c.h"
             Py_DECREF(seq);
             STACK_SHRINK(1);
             STACK_GROW(oparg);
@@ -1347,7 +1348,7 @@
         TARGET(UNPACK_SEQUENCE_LIST) {
             PyObject *seq = stack_pointer[-1];
             PyObject **values = stack_pointer - (1);
-            #line 921 "Python/bytecodes.c"
+            #line 922 "Python/bytecodes.c"
             DEOPT_IF(!PyList_CheckExact(seq), UNPACK_SEQUENCE);
             DEOPT_IF(PyList_GET_SIZE(seq) != oparg, UNPACK_SEQUENCE);
             STAT_INC(UNPACK_SEQUENCE, hit);
@@ -1355,7 +1356,7 @@
             for (int i = oparg; --i >= 0; ) {
                 *values++ = Py_NewRef(items[i]);
             }
-            #line 1359 "Python/generated_cases.c.h"
+            #line 1360 "Python/generated_cases.c.h"
             Py_DECREF(seq);
             STACK_SHRINK(1);
             STACK_GROW(oparg);
@@ -1365,15 +1366,15 @@
 
         TARGET(UNPACK_EX) {
             PyObject *seq = stack_pointer[-1];
-            #line 932 "Python/bytecodes.c"
+            #line 933 "Python/bytecodes.c"
             int totalargs = 1 + (oparg & 0xFF) + (oparg >> 8);
             PyObject **top = stack_pointer + totalargs - 1;
             int res = unpack_iterable(tstate, seq, oparg & 0xFF, oparg >> 8, top);
-            #line 1373 "Python/generated_cases.c.h"
+            #line 1374 "Python/generated_cases.c.h"
             Py_DECREF(seq);
-            #line 936 "Python/bytecodes.c"
+            #line 937 "Python/bytecodes.c"
             if (res == 0) goto pop_1_error;
-            #line 1377 "Python/generated_cases.c.h"
+            #line 1378 "Python/generated_cases.c.h"
             STACK_GROW((oparg & 0xFF) + (oparg >> 8));
             DISPATCH();
         }
@@ -1384,11 +1385,11 @@
             PyObject *owner = stack_pointer[-1];
             PyObject *v = stack_pointer[-2];
             uint16_t counter = read_u16(&next_instr[0].cache);
-            #line 947 "Python/bytecodes.c"
+            #line 948 "Python/bytecodes.c"
             #if ENABLE_SPECIALIZATION
             if (ADAPTIVE_COUNTER_IS_ZERO(counter)) {
                 assert(cframe.use_tracing == 0);
-                PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+                PyObject *name = GETITEM(NAMES(), oparg);
                 next_instr--;
                 _Py_Specialize_StoreAttr(owner, next_instr, name);
                 DISPATCH_SAME_OPARG();
@@ -1399,14 +1400,14 @@
             #else
             (void)counter;  // Unused.
             #endif  /* ENABLE_SPECIALIZATION */
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+            PyObject *name = GETITEM(NAMES(), oparg);
             int err = PyObject_SetAttr(owner, name, v);
-            #line 1405 "Python/generated_cases.c.h"
+            #line 1406 "Python/generated_cases.c.h"
             Py_DECREF(v);
             Py_DECREF(owner);
-            #line 964 "Python/bytecodes.c"
+            #line 965 "Python/bytecodes.c"
             if (err) goto pop_2_error;
-            #line 1410 "Python/generated_cases.c.h"
+            #line 1411 "Python/generated_cases.c.h"
             STACK_SHRINK(2);
             next_instr += 4;
             DISPATCH();
@@ -1414,35 +1415,35 @@
 
         TARGET(DELETE_ATTR) {
             PyObject *owner = stack_pointer[-1];
-            #line 968 "Python/bytecodes.c"
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+            #line 969 "Python/bytecodes.c"
+            PyObject *name = GETITEM(NAMES(), oparg);
             int err = PyObject_SetAttr(owner, name, (PyObject *)NULL);
-            #line 1421 "Python/generated_cases.c.h"
+            #line 1422 "Python/generated_cases.c.h"
             Py_DECREF(owner);
-            #line 971 "Python/bytecodes.c"
+            #line 972 "Python/bytecodes.c"
             if (err) goto pop_1_error;
-            #line 1425 "Python/generated_cases.c.h"
+            #line 1426 "Python/generated_cases.c.h"
             STACK_SHRINK(1);
             DISPATCH();
         }
 
         TARGET(STORE_GLOBAL) {
             PyObject *v = stack_pointer[-1];
-            #line 975 "Python/bytecodes.c"
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+            #line 976 "Python/bytecodes.c"
+            PyObject *name = GETITEM(NAMES(), oparg);
             int err = PyDict_SetItem(GLOBALS(), name, v);
-            #line 1435 "Python/generated_cases.c.h"
+            #line 1436 "Python/generated_cases.c.h"
             Py_DECREF(v);
-            #line 978 "Python/bytecodes.c"
+            #line 979 "Python/bytecodes.c"
             if (err) goto pop_1_error;
-            #line 1439 "Python/generated_cases.c.h"
+            #line 1440 "Python/generated_cases.c.h"
             STACK_SHRINK(1);
             DISPATCH();
         }
 
         TARGET(DELETE_GLOBAL) {
-            #line 982 "Python/bytecodes.c"
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+            #line 983 "Python/bytecodes.c"
+            PyObject *name = GETITEM(NAMES(), oparg);
             int err;
             err = PyDict_DelItem(GLOBALS(), name);
             // Can't use ERROR_IF here.
@@ -1453,14 +1454,14 @@
                 }
                 goto error;
             }
-            #line 1457 "Python/generated_cases.c.h"
+            #line 1458 "Python/generated_cases.c.h"
             DISPATCH();
         }
 
         TARGET(LOAD_NAME) {
             PyObject *v;
-            #line 996 "Python/bytecodes.c"
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+            #line 997 "Python/bytecodes.c"
+            PyObject *name = GETITEM(NAMES(), oparg);
             PyObject *locals = LOCALS();
             if (locals == NULL) {
                 _PyErr_Format(tstate, PyExc_SystemError,
@@ -1518,7 +1519,7 @@
                     }
                 }
             }
-            #line 1522 "Python/generated_cases.c.h"
+            #line 1523 "Python/generated_cases.c.h"
             STACK_GROW(1);
             stack_pointer[-1] = v;
             DISPATCH();
@@ -1529,12 +1530,12 @@
             static_assert(INLINE_CACHE_ENTRIES_LOAD_GLOBAL == 4, "incorrect cache size");
             PyObject *null = NULL;
             PyObject *v;
-            #line 1063 "Python/bytecodes.c"
+            #line 1064 "Python/bytecodes.c"
             #if ENABLE_SPECIALIZATION
             _PyLoadGlobalCache *cache = (_PyLoadGlobalCache *)next_instr;
             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
                 assert(cframe.use_tracing == 0);
-                PyObject *name = GETITEM(frame->f_code->co_names, oparg>>1);
+                PyObject *name = GETITEM(NAMES(), oparg>>1);
                 next_instr--;
                 _Py_Specialize_LoadGlobal(GLOBALS(), BUILTINS(), next_instr, name);
                 DISPATCH_SAME_OPARG();
@@ -1542,7 +1543,7 @@
             STAT_INC(LOAD_GLOBAL, deferred);
             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
             #endif  /* ENABLE_SPECIALIZATION */
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg>>1);
+            PyObject *name = GETITEM(NAMES(), oparg>>1);
             if (PyDict_CheckExact(GLOBALS())
                 && PyDict_CheckExact(BUILTINS()))
             {
@@ -1582,7 +1583,7 @@
                 }
             }
             null = NULL;
-            #line 1586 "Python/generated_cases.c.h"
+            #line 1587 "Python/generated_cases.c.h"
             STACK_GROW(1);
             STACK_GROW(((oparg & 1) ? 1 : 0));
             stack_pointer[-1] = v;
@@ -1596,7 +1597,7 @@
             PyObject *res;
             uint16_t index = read_u16(&next_instr[1].cache);
             uint16_t version = read_u16(&next_instr[2].cache);
-            #line 1118 "Python/bytecodes.c"
+            #line 1119 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             DEOPT_IF(!PyDict_CheckExact(GLOBALS()), LOAD_GLOBAL);
             PyDictObject *dict = (PyDictObject *)GLOBALS();
@@ -1608,7 +1609,7 @@
             Py_INCREF(res);
             STAT_INC(LOAD_GLOBAL, hit);
             null = NULL;
-            #line 1612 "Python/generated_cases.c.h"
+            #line 1613 "Python/generated_cases.c.h"
             STACK_GROW(1);
             STACK_GROW(((oparg & 1) ? 1 : 0));
             stack_pointer[-1] = res;
@@ -1623,7 +1624,7 @@
             uint16_t index = read_u16(&next_instr[1].cache);
             uint16_t mod_version = read_u16(&next_instr[2].cache);
             uint16_t bltn_version = read_u16(&next_instr[3].cache);
-            #line 1132 "Python/bytecodes.c"
+            #line 1133 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             DEOPT_IF(!PyDict_CheckExact(GLOBALS()), LOAD_GLOBAL);
             DEOPT_IF(!PyDict_CheckExact(BUILTINS()), LOAD_GLOBAL);
@@ -1638,7 +1639,7 @@
             Py_INCREF(res);
             STAT_INC(LOAD_GLOBAL, hit);
             null = NULL;
-            #line 1642 "Python/generated_cases.c.h"
+            #line 1643 "Python/generated_cases.c.h"
             STACK_GROW(1);
             STACK_GROW(((oparg & 1) ? 1 : 0));
             stack_pointer[-1] = res;
@@ -1648,16 +1649,16 @@
         }
 
         TARGET(DELETE_FAST) {
-            #line 1149 "Python/bytecodes.c"
+            #line 1150 "Python/bytecodes.c"
             PyObject *v = GETLOCAL(oparg);
             if (v == NULL) goto unbound_local_error;
             SETLOCAL(oparg, NULL);
-            #line 1656 "Python/generated_cases.c.h"
+            #line 1657 "Python/generated_cases.c.h"
             DISPATCH();
         }
 
         TARGET(MAKE_CELL) {
-            #line 1155 "Python/bytecodes.c"
+            #line 1156 "Python/bytecodes.c"
             // "initial" is probably NULL but not if it's an arg (or set
             // via PyFrame_LocalsToFast() before MAKE_CELL has run).
             PyObject *initial = GETLOCAL(oparg);
@@ -1666,33 +1667,33 @@
                 goto resume_with_error;
             }
             SETLOCAL(oparg, cell);
-            #line 1670 "Python/generated_cases.c.h"
+            #line 1671 "Python/generated_cases.c.h"
             DISPATCH();
         }
 
         TARGET(DELETE_DEREF) {
-            #line 1166 "Python/bytecodes.c"
+            #line 1167 "Python/bytecodes.c"
             PyObject *cell = GETLOCAL(oparg);
             PyObject *oldobj = PyCell_GET(cell);
             // Can't use ERROR_IF here.
             // Fortunately we don't need its superpower.
             if (oldobj == NULL) {
-                format_exc_unbound(tstate, frame->f_code, oparg);
+                format_exc_unbound(tstate, _PyFrame_GetCode(frame), oparg);
                 goto error;
             }
             PyCell_SET(cell, NULL);
             Py_DECREF(oldobj);
-            #line 1686 "Python/generated_cases.c.h"
+            #line 1687 "Python/generated_cases.c.h"
             DISPATCH();
         }
 
         TARGET(LOAD_CLASSDEREF) {
             PyObject *value;
-            #line 1179 "Python/bytecodes.c"
+            #line 1180 "Python/bytecodes.c"
             PyObject *name, *locals = LOCALS();
             assert(locals);
-            assert(oparg >= 0 && oparg < frame->f_code->co_nlocalsplus);
-            name = PyTuple_GET_ITEM(frame->f_code->co_localsplusnames, oparg);
+            assert(oparg >= 0 && oparg < _PyFrame_GetCode(frame)->co_nlocalsplus);
+            name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg);
             if (PyDict_CheckExact(locals)) {
                 value = PyDict_GetItemWithError(locals, name);
                 if (value != NULL) {
@@ -1715,12 +1716,12 @@
                 PyObject *cell = GETLOCAL(oparg);
                 value = PyCell_GET(cell);
                 if (value == NULL) {
-                    format_exc_unbound(tstate, frame->f_code, oparg);
+                    format_exc_unbound(tstate, _PyFrame_GetCode(frame), oparg);
                     goto error;
                 }
                 Py_INCREF(value);
             }
-            #line 1724 "Python/generated_cases.c.h"
+            #line 1725 "Python/generated_cases.c.h"
             STACK_GROW(1);
             stack_pointer[-1] = value;
             DISPATCH();
@@ -1728,15 +1729,15 @@
 
         TARGET(LOAD_DEREF) {
             PyObject *value;
-            #line 1213 "Python/bytecodes.c"
+            #line 1214 "Python/bytecodes.c"
             PyObject *cell = GETLOCAL(oparg);
             value = PyCell_GET(cell);
             if (value == NULL) {
-                format_exc_unbound(tstate, frame->f_code, oparg);
+                format_exc_unbound(tstate, _PyFrame_GetCode(frame), oparg);
                 if (true) goto error;
             }
             Py_INCREF(value);
-            #line 1740 "Python/generated_cases.c.h"
+            #line 1741 "Python/generated_cases.c.h"
             STACK_GROW(1);
             stack_pointer[-1] = value;
             DISPATCH();
@@ -1744,20 +1745,20 @@
 
         TARGET(STORE_DEREF) {
             PyObject *v = stack_pointer[-1];
-            #line 1223 "Python/bytecodes.c"
+            #line 1224 "Python/bytecodes.c"
             PyObject *cell = GETLOCAL(oparg);
             PyObject *oldobj = PyCell_GET(cell);
             PyCell_SET(cell, v);
             Py_XDECREF(oldobj);
-            #line 1753 "Python/generated_cases.c.h"
+            #line 1754 "Python/generated_cases.c.h"
             STACK_SHRINK(1);
             DISPATCH();
         }
 
         TARGET(COPY_FREE_VARS) {
-            #line 1230 "Python/bytecodes.c"
+            #line 1231 "Python/bytecodes.c"
             /* Copy closure variables to free variables */
-            PyCodeObject *co = frame->f_code;
+            PyCodeObject *co = _PyFrame_GetCode(frame);
             assert(PyFunction_Check(frame->f_funcobj));
             PyObject *closure = ((PyFunctionObject *)frame->f_funcobj)->func_closure;
             assert(oparg == co->co_nfreevars);
@@ -1766,22 +1767,22 @@
                 PyObject *o = PyTuple_GET_ITEM(closure, i);
                 frame->localsplus[offset + i] = Py_NewRef(o);
             }
-            #line 1770 "Python/generated_cases.c.h"
+            #line 1771 "Python/generated_cases.c.h"
             DISPATCH();
         }
 
         TARGET(BUILD_STRING) {
             PyObject **pieces = (stack_pointer - oparg);
             PyObject *str;
-            #line 1243 "Python/bytecodes.c"
+            #line 1244 "Python/bytecodes.c"
             str = _PyUnicode_JoinArray(&_Py_STR(empty), pieces, oparg);
-            #line 1779 "Python/generated_cases.c.h"
+            #line 1780 "Python/generated_cases.c.h"
             for (int _i = oparg; --_i >= 0;) {
                 Py_DECREF(pieces[_i]);
             }
-            #line 1245 "Python/bytecodes.c"
+            #line 1246 "Python/bytecodes.c"
             if (str == NULL) { STACK_SHRINK(oparg); goto error; }
-            #line 1785 "Python/generated_cases.c.h"
+            #line 1786 "Python/generated_cases.c.h"
             STACK_SHRINK(oparg);
             STACK_GROW(1);
             stack_pointer[-1] = str;
@@ -1791,10 +1792,10 @@
         TARGET(BUILD_TUPLE) {
             PyObject **values = (stack_pointer - oparg);
             PyObject *tup;
-            #line 1249 "Python/bytecodes.c"
+            #line 1250 "Python/bytecodes.c"
             tup = _PyTuple_FromArraySteal(values, oparg);
             if (tup == NULL) { STACK_SHRINK(oparg); goto error; }
-            #line 1798 "Python/generated_cases.c.h"
+            #line 1799 "Python/generated_cases.c.h"
             STACK_SHRINK(oparg);
             STACK_GROW(1);
             stack_pointer[-1] = tup;
@@ -1804,10 +1805,10 @@
         TARGET(BUILD_LIST) {
             PyObject **values = (stack_pointer - oparg);
             PyObject *list;
-            #line 1254 "Python/bytecodes.c"
+            #line 1255 "Python/bytecodes.c"
             list = _PyList_FromArraySteal(values, oparg);
             if (list == NULL) { STACK_SHRINK(oparg); goto error; }
-            #line 1811 "Python/generated_cases.c.h"
+            #line 1812 "Python/generated_cases.c.h"
             STACK_SHRINK(oparg);
             STACK_GROW(1);
             stack_pointer[-1] = list;
@@ -1817,7 +1818,7 @@
         TARGET(LIST_EXTEND) {
             PyObject *iterable = stack_pointer[-1];
             PyObject *list = stack_pointer[-(2 + (oparg-1))];
-            #line 1259 "Python/bytecodes.c"
+            #line 1260 "Python/bytecodes.c"
             PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable);
             if (none_val == NULL) {
                 if (_PyErr_ExceptionMatches(tstate, PyExc_TypeError) &&
@@ -1828,13 +1829,13 @@
                           "Value after * must be an iterable, not %.200s",
                           Py_TYPE(iterable)->tp_name);
                 }
-            #line 1832 "Python/generated_cases.c.h"
+            #line 1833 "Python/generated_cases.c.h"
                 Py_DECREF(iterable);
-            #line 1270 "Python/bytecodes.c"
+            #line 1271 "Python/bytecodes.c"
                 if (true) goto pop_1_error;
             }
             Py_DECREF(none_val);
-            #line 1838 "Python/generated_cases.c.h"
+            #line 1839 "Python/generated_cases.c.h"
             Py_DECREF(iterable);
             STACK_SHRINK(1);
             DISPATCH();
@@ -1843,13 +1844,13 @@
         TARGET(SET_UPDATE) {
             PyObject *iterable = stack_pointer[-1];
             PyObject *set = stack_pointer[-(2 + (oparg-1))];
-            #line 1277 "Python/bytecodes.c"
+            #line 1278 "Python/bytecodes.c"
             int err = _PySet_Update(set, iterable);
-            #line 1849 "Python/generated_cases.c.h"
+            #line 1850 "Python/generated_cases.c.h"
             Py_DECREF(iterable);
-            #line 1279 "Python/bytecodes.c"
+            #line 1280 "Python/bytecodes.c"
             if (err < 0) goto pop_1_error;
-            #line 1853 "Python/generated_cases.c.h"
+            #line 1854 "Python/generated_cases.c.h"
             STACK_SHRINK(1);
             DISPATCH();
         }
@@ -1857,7 +1858,7 @@
         TARGET(BUILD_SET) {
             PyObject **values = (stack_pointer - oparg);
             PyObject *set;
-            #line 1283 "Python/bytecodes.c"
+            #line 1284 "Python/bytecodes.c"
             set = PySet_New(NULL);
             if (set == NULL)
                 goto error;
@@ -1872,7 +1873,7 @@
                 Py_DECREF(set);
                 if (true) { STACK_SHRINK(oparg); goto error; }
             }
-            #line 1876 "Python/generated_cases.c.h"
+            #line 1877 "Python/generated_cases.c.h"
             STACK_SHRINK(oparg);
             STACK_GROW(1);
             stack_pointer[-1] = set;
@@ -1882,7 +1883,7 @@
         TARGET(BUILD_MAP) {
             PyObject **values = (stack_pointer - oparg*2);
             PyObject *map;
-            #line 1300 "Python/bytecodes.c"
+            #line 1301 "Python/bytecodes.c"
             map = _PyDict_FromItems(
                     values, 2,
                     values+1, 2,
@@ -1890,13 +1891,13 @@
             if (map == NULL)
                 goto error;
 
-            #line 1894 "Python/generated_cases.c.h"
+            #line 1895 "Python/generated_cases.c.h"
             for (int _i = oparg*2; --_i >= 0;) {
                 Py_DECREF(values[_i]);
             }
-            #line 1308 "Python/bytecodes.c"
+            #line 1309 "Python/bytecodes.c"
             if (map == NULL) { STACK_SHRINK(oparg*2); goto error; }
-            #line 1900 "Python/generated_cases.c.h"
+            #line 1901 "Python/generated_cases.c.h"
             STACK_SHRINK(oparg*2);
             STACK_GROW(1);
             stack_pointer[-1] = map;
@@ -1904,7 +1905,7 @@
         }
 
         TARGET(SETUP_ANNOTATIONS) {
-            #line 1312 "Python/bytecodes.c"
+            #line 1313 "Python/bytecodes.c"
             int err;
             PyObject *ann_dict;
             if (LOCALS() == NULL) {
@@ -1944,7 +1945,7 @@
                     Py_DECREF(ann_dict);
                 }
             }
-            #line 1948 "Python/generated_cases.c.h"
+            #line 1949 "Python/generated_cases.c.h"
             DISPATCH();
         }
 
@@ -1952,7 +1953,7 @@
             PyObject *keys = stack_pointer[-1];
             PyObject **values = (stack_pointer - (1 + oparg));
             PyObject *map;
-            #line 1354 "Python/bytecodes.c"
+            #line 1355 "Python/bytecodes.c"
             if (!PyTuple_CheckExact(keys) ||
                 PyTuple_GET_SIZE(keys) != (Py_ssize_t)oparg) {
                 _PyErr_SetString(tstate, PyExc_SystemError,
@@ -1962,14 +1963,14 @@
             map = _PyDict_FromItems(
                     &PyTuple_GET_ITEM(keys, 0), 1,
                     values, 1, oparg);
-            #line 1966 "Python/generated_cases.c.h"
+            #line 1967 "Python/generated_cases.c.h"
             for (int _i = oparg; --_i >= 0;) {
                 Py_DECREF(values[_i]);
             }
             Py_DECREF(keys);
-            #line 1364 "Python/bytecodes.c"
+            #line 1365 "Python/bytecodes.c"
             if (map == NULL) { STACK_SHRINK(oparg); goto pop_1_error; }
-            #line 1973 "Python/generated_cases.c.h"
+            #line 1974 "Python/generated_cases.c.h"
             STACK_SHRINK(oparg);
             stack_pointer[-1] = map;
             DISPATCH();
@@ -1977,7 +1978,7 @@
 
         TARGET(DICT_UPDATE) {
             PyObject *update = stack_pointer[-1];
-            #line 1368 "Python/bytecodes.c"
+            #line 1369 "Python/bytecodes.c"
             PyObject *dict = PEEK(oparg + 1);  // update is still on the stack
             if (PyDict_Update(dict, update) < 0) {
                 if (_PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) {
@@ -1985,12 +1986,12 @@
                                     "'%.200s' object is not a mapping",
                                     Py_TYPE(update)->tp_name);
                 }
-            #line 1989 "Python/generated_cases.c.h"
+            #line 1990 "Python/generated_cases.c.h"
                 Py_DECREF(update);
-            #line 1376 "Python/bytecodes.c"
+            #line 1377 "Python/bytecodes.c"
                 if (true) goto pop_1_error;
             }
-            #line 1994 "Python/generated_cases.c.h"
+            #line 1995 "Python/generated_cases.c.h"
             Py_DECREF(update);
             STACK_SHRINK(1);
             DISPATCH();
@@ -1998,17 +1999,17 @@
 
         TARGET(DICT_MERGE) {
             PyObject *update = stack_pointer[-1];
-            #line 1382 "Python/bytecodes.c"
+            #line 1383 "Python/bytecodes.c"
             PyObject *dict = PEEK(oparg + 1);  // update is still on the stack
 
             if (_PyDict_MergeEx(dict, update, 2) < 0) {
                 format_kwargs_error(tstate, PEEK(3 + oparg), update);
-            #line 2007 "Python/generated_cases.c.h"
+            #line 2008 "Python/generated_cases.c.h"
                 Py_DECREF(update);
-            #line 1387 "Python/bytecodes.c"
+            #line 1388 "Python/bytecodes.c"
                 if (true) goto pop_1_error;
             }
-            #line 2012 "Python/generated_cases.c.h"
+            #line 2013 "Python/generated_cases.c.h"
             Py_DECREF(update);
             STACK_SHRINK(1);
             PREDICT(CALL_FUNCTION_EX);
@@ -2018,13 +2019,13 @@
         TARGET(MAP_ADD) {
             PyObject *value = stack_pointer[-1];
             PyObject *key = stack_pointer[-2];
-            #line 1394 "Python/bytecodes.c"
+            #line 1395 "Python/bytecodes.c"
             PyObject *dict = PEEK(oparg + 2);  // key, value are still on the stack
             assert(PyDict_CheckExact(dict));
             /* dict[key] = value */
             // Do not DECREF INPUTS because the function steals the references
             if (_PyDict_SetItem_Take2((PyDictObject *)dict, key, value) != 0) goto pop_2_error;
-            #line 2028 "Python/generated_cases.c.h"
+            #line 2029 "Python/generated_cases.c.h"
             STACK_SHRINK(2);
             PREDICT(JUMP_BACKWARD);
             DISPATCH();
@@ -2036,12 +2037,12 @@
             PyObject *owner = stack_pointer[-1];
             PyObject *res2 = NULL;
             PyObject *res;
-            #line 1417 "Python/bytecodes.c"
+            #line 1418 "Python/bytecodes.c"
             #if ENABLE_SPECIALIZATION
             _PyAttrCache *cache = (_PyAttrCache *)next_instr;
             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
                 assert(cframe.use_tracing == 0);
-                PyObject *name = GETITEM(frame->f_code->co_names, oparg>>1);
+                PyObject *name = GETITEM(NAMES(), oparg>>1);
                 next_instr--;
                 _Py_Specialize_LoadAttr(owner, next_instr, name);
                 DISPATCH_SAME_OPARG();
@@ -2049,7 +2050,7 @@
             STAT_INC(LOAD_ATTR, deferred);
             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
             #endif  /* ENABLE_SPECIALIZATION */
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg >> 1);
+            PyObject *name = GETITEM(NAMES(), oparg >> 1);
             if (oparg & 1) {
                 /* Designed to work in tandem with CALL, pushes two values. */
                 PyObject* meth = NULL;
@@ -2071,9 +2072,9 @@
 
                        NULL | meth | arg1 | ... | argN
                     */
-            #line 2075 "Python/generated_cases.c.h"
+            #line 2076 "Python/generated_cases.c.h"
                     Py_DECREF(owner);
-            #line 1452 "Python/bytecodes.c"
+            #line 1453 "Python/bytecodes.c"
                     if (meth == NULL) goto pop_1_error;
                     res2 = NULL;
                     res = meth;
@@ -2082,12 +2083,12 @@
             else {
                 /* Classic, pushes one value. */
                 res = PyObject_GetAttr(owner, name);
-            #line 2086 "Python/generated_cases.c.h"
+            #line 2087 "Python/generated_cases.c.h"
                 Py_DECREF(owner);
-            #line 1461 "Python/bytecodes.c"
+            #line 1462 "Python/bytecodes.c"
                 if (res == NULL) goto pop_1_error;
             }
-            #line 2091 "Python/generated_cases.c.h"
+            #line 2092 "Python/generated_cases.c.h"
             STACK_GROW(((oparg & 1) ? 1 : 0));
             stack_pointer[-1] = res;
             if (oparg & 1) { stack_pointer[-(1 + ((oparg & 1) ? 1 : 0))] = res2; }
@@ -2101,7 +2102,7 @@
             PyObject *res;
             uint32_t type_version = read_u32(&next_instr[1].cache);
             uint16_t index = read_u16(&next_instr[3].cache);
-            #line 1466 "Python/bytecodes.c"
+            #line 1467 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             PyTypeObject *tp = Py_TYPE(owner);
             assert(type_version != 0);
@@ -2115,7 +2116,7 @@
             STAT_INC(LOAD_ATTR, hit);
             Py_INCREF(res);
             res2 = NULL;
-            #line 2119 "Python/generated_cases.c.h"
+            #line 2120 "Python/generated_cases.c.h"
             Py_DECREF(owner);
             STACK_GROW(((oparg & 1) ? 1 : 0));
             stack_pointer[-1] = res;
@@ -2130,7 +2131,7 @@
             PyObject *res;
             uint32_t type_version = read_u32(&next_instr[1].cache);
             uint16_t index = read_u16(&next_instr[3].cache);
-            #line 1483 "Python/bytecodes.c"
+            #line 1484 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             DEOPT_IF(!PyModule_CheckExact(owner), LOAD_ATTR);
             PyDictObject *dict = (PyDictObject *)((PyModuleObject *)owner)->md_dict;
@@ -2144,7 +2145,7 @@
             STAT_INC(LOAD_ATTR, hit);
             Py_INCREF(res);
             res2 = NULL;
-            #line 2148 "Python/generated_cases.c.h"
+            #line 2149 "Python/generated_cases.c.h"
             Py_DECREF(owner);
             STACK_GROW(((oparg & 1) ? 1 : 0));
             stack_pointer[-1] = res;
@@ -2159,7 +2160,7 @@
             PyObject *res;
             uint32_t type_version = read_u32(&next_instr[1].cache);
             uint16_t index = read_u16(&next_instr[3].cache);
-            #line 1500 "Python/bytecodes.c"
+            #line 1501 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             PyTypeObject *tp = Py_TYPE(owner);
             assert(type_version != 0);
@@ -2170,7 +2171,7 @@
             PyDictObject *dict = (PyDictObject *)_PyDictOrValues_GetDict(dorv);
             DEOPT_IF(dict == NULL, LOAD_ATTR);
             assert(PyDict_CheckExact((PyObject *)dict));
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg>>1);
+            PyObject *name = GETITEM(NAMES(), oparg>>1);
             uint16_t hint = index;
             DEOPT_IF(hint >= (size_t)dict->ma_keys->dk_nentries, LOAD_ATTR);
             if (DK_IS_UNICODE(dict->ma_keys)) {
@@ -2187,7 +2188,7 @@
             STAT_INC(LOAD_ATTR, hit);
             Py_INCREF(res);
             res2 = NULL;
-            #line 2191 "Python/generated_cases.c.h"
+            #line 2192 "Python/generated_cases.c.h"
             Py_DECREF(owner);
             STACK_GROW(((oparg & 1) ? 1 : 0));
             stack_pointer[-1] = res;
@@ -2202,7 +2203,7 @@
             PyObject *res;
             uint32_t type_version = read_u32(&next_instr[1].cache);
             uint16_t index = read_u16(&next_instr[3].cache);
-            #line 1531 "Python/bytecodes.c"
+            #line 1532 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             PyTypeObject *tp = Py_TYPE(owner);
             assert(type_version != 0);
@@ -2213,7 +2214,7 @@
             STAT_INC(LOAD_ATTR, hit);
             Py_INCREF(res);
             res2 = NULL;
-            #line 2217 "Python/generated_cases.c.h"
+            #line 2218 "Python/generated_cases.c.h"
             Py_DECREF(owner);
             STACK_GROW(((oparg & 1) ? 1 : 0));
             stack_pointer[-1] = res;
@@ -2228,7 +2229,7 @@
             PyObject *res;
             uint32_t type_version = read_u32(&next_instr[1].cache);
             PyObject *descr = read_obj(&next_instr[5].cache);
-            #line 1545 "Python/bytecodes.c"
+            #line 1546 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
 
             DEOPT_IF(!PyType_Check(cls), LOAD_ATTR);
@@ -2241,7 +2242,7 @@
             res = descr;
             assert(res != NULL);
             Py_INCREF(res);
-            #line 2245 "Python/generated_cases.c.h"
+            #line 2246 "Python/generated_cases.c.h"
             Py_DECREF(cls);
             STACK_GROW(((oparg & 1) ? 1 : 0));
             stack_pointer[-1] = res;
@@ -2255,7 +2256,7 @@
             uint32_t type_version = read_u32(&next_instr[1].cache);
             uint32_t func_version = read_u32(&next_instr[3].cache);
             PyObject *fget = read_obj(&next_instr[5].cache);
-            #line 1561 "Python/bytecodes.c"
+            #line 1562 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             DEOPT_IF(tstate->interp->eval_frame, LOAD_ATTR);
 
@@ -2279,7 +2280,7 @@
             new_frame->localsplus[0] = owner;
             JUMPBY(INLINE_CACHE_ENTRIES_LOAD_ATTR);
             DISPATCH_INLINED(new_frame);
-            #line 2283 "Python/generated_cases.c.h"
+            #line 2284 "Python/generated_cases.c.h"
         }
 
         TARGET(LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN) {
@@ -2287,7 +2288,7 @@
             uint32_t type_version = read_u32(&next_instr[1].cache);
             uint32_t func_version = read_u32(&next_instr[3].cache);
             PyObject *getattribute = read_obj(&next_instr[5].cache);
-            #line 1587 "Python/bytecodes.c"
+            #line 1588 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             DEOPT_IF(tstate->interp->eval_frame, LOAD_ATTR);
             PyTypeObject *cls = Py_TYPE(owner);
@@ -2302,7 +2303,7 @@
             DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), LOAD_ATTR);
             STAT_INC(LOAD_ATTR, hit);
 
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg >> 1);
+            PyObject *name = GETITEM(NAMES(), oparg >> 1);
             Py_INCREF(f);
             _PyInterpreterFrame *new_frame = _PyFrame_PushUnchecked(tstate, f, 2);
             // Manipulate stack directly because we exit with DISPATCH_INLINED().
@@ -2313,7 +2314,7 @@
             new_frame->localsplus[1] = Py_NewRef(name);
             JUMPBY(INLINE_CACHE_ENTRIES_LOAD_ATTR);
             DISPATCH_INLINED(new_frame);
-            #line 2317 "Python/generated_cases.c.h"
+            #line 2318 "Python/generated_cases.c.h"
         }
 
         TARGET(STORE_ATTR_INSTANCE_VALUE) {
@@ -2321,7 +2322,7 @@
             PyObject *value = stack_pointer[-2];
             uint32_t type_version = read_u32(&next_instr[1].cache);
             uint16_t index = read_u16(&next_instr[3].cache);
-            #line 1615 "Python/bytecodes.c"
+            #line 1616 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             PyTypeObject *tp = Py_TYPE(owner);
             assert(type_version != 0);
@@ -2340,7 +2341,7 @@
                 Py_DECREF(old_value);
             }
             Py_DECREF(owner);
-            #line 2344 "Python/generated_cases.c.h"
+            #line 2345 "Python/generated_cases.c.h"
             STACK_SHRINK(2);
             next_instr += 4;
             DISPATCH();
@@ -2351,7 +2352,7 @@
             PyObject *value = stack_pointer[-2];
             uint32_t type_version = read_u32(&next_instr[1].cache);
             uint16_t hint = read_u16(&next_instr[3].cache);
-            #line 1636 "Python/bytecodes.c"
+            #line 1637 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             PyTypeObject *tp = Py_TYPE(owner);
             assert(type_version != 0);
@@ -2362,7 +2363,7 @@
             PyDictObject *dict = (PyDictObject *)_PyDictOrValues_GetDict(dorv);
             DEOPT_IF(dict == NULL, STORE_ATTR);
             assert(PyDict_CheckExact((PyObject *)dict));
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+            PyObject *name = GETITEM(NAMES(), oparg);
             DEOPT_IF(hint >= (size_t)dict->ma_keys->dk_nentries, STORE_ATTR);
             PyObject *old_value;
             uint64_t new_version;
@@ -2391,7 +2392,7 @@
             /* PEP 509 */
             dict->ma_version_tag = new_version;
             Py_DECREF(owner);
-            #line 2395 "Python/generated_cases.c.h"
+            #line 2396 "Python/generated_cases.c.h"
             STACK_SHRINK(2);
             next_instr += 4;
             DISPATCH();
@@ -2402,7 +2403,7 @@
             PyObject *value = stack_pointer[-2];
             uint32_t type_version = read_u32(&next_instr[1].cache);
             uint16_t index = read_u16(&next_instr[3].cache);
-            #line 1678 "Python/bytecodes.c"
+            #line 1679 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             PyTypeObject *tp = Py_TYPE(owner);
             assert(type_version != 0);
@@ -2413,7 +2414,7 @@
             *(PyObject **)addr = value;
             Py_XDECREF(old_value);
             Py_DECREF(owner);
-            #line 2417 "Python/generated_cases.c.h"
+            #line 2418 "Python/generated_cases.c.h"
             STACK_SHRINK(2);
             next_instr += 4;
             DISPATCH();
@@ -2425,7 +2426,7 @@
             PyObject *right = stack_pointer[-1];
             PyObject *left = stack_pointer[-2];
             PyObject *res;
-            #line 1698 "Python/bytecodes.c"
+            #line 1699 "Python/bytecodes.c"
             #if ENABLE_SPECIALIZATION
             _PyCompareOpCache *cache = (_PyCompareOpCache *)next_instr;
             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
@@ -2439,12 +2440,12 @@
             #endif  /* ENABLE_SPECIALIZATION */
             assert((oparg >> 4) <= Py_GE);
             res = PyObject_RichCompare(left, right, oparg>>4);
-            #line 2443 "Python/generated_cases.c.h"
+            #line 2444 "Python/generated_cases.c.h"
             Py_DECREF(left);
             Py_DECREF(right);
-            #line 1712 "Python/bytecodes.c"
+            #line 1713 "Python/bytecodes.c"
             if (res == NULL) goto pop_2_error;
-            #line 2448 "Python/generated_cases.c.h"
+            #line 2449 "Python/generated_cases.c.h"
             STACK_SHRINK(1);
             stack_pointer[-1] = res;
             next_instr += 1;
@@ -2455,7 +2456,7 @@
             PyObject *right = stack_pointer[-1];
             PyObject *left = stack_pointer[-2];
             PyObject *res;
-            #line 1716 "Python/bytecodes.c"
+            #line 1717 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             DEOPT_IF(!PyFloat_CheckExact(left), COMPARE_OP);
             DEOPT_IF(!PyFloat_CheckExact(right), COMPARE_OP);
@@ -2468,7 +2469,7 @@
             _Py_DECREF_SPECIALIZED(right, _PyFloat_ExactDealloc);
             res = (sign_ish & oparg) ? Py_True : Py_False;
             Py_INCREF(res);
-            #line 2472 "Python/generated_cases.c.h"
+            #line 2473 "Python/generated_cases.c.h"
             STACK_SHRINK(1);
             stack_pointer[-1] = res;
             next_instr += 1;
@@ -2479,7 +2480,7 @@
             PyObject *right = stack_pointer[-1];
             PyObject *left = stack_pointer[-2];
             PyObject *res;
-            #line 1732 "Python/bytecodes.c"
+            #line 1733 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             DEOPT_IF(!PyLong_CheckExact(left), COMPARE_OP);
             DEOPT_IF(!PyLong_CheckExact(right), COMPARE_OP);
@@ -2496,7 +2497,7 @@
             _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);
             res = (sign_ish & oparg) ? Py_True : Py_False;
             Py_INCREF(res);
-            #line 2500 "Python/generated_cases.c.h"
+            #line 2501 "Python/generated_cases.c.h"
             STACK_SHRINK(1);
             stack_pointer[-1] = res;
             next_instr += 1;
@@ -2507,7 +2508,7 @@
             PyObject *right = stack_pointer[-1];
             PyObject *left = stack_pointer[-2];
             PyObject *res;
-            #line 1752 "Python/bytecodes.c"
+            #line 1753 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             DEOPT_IF(!PyUnicode_CheckExact(left), COMPARE_OP);
             DEOPT_IF(!PyUnicode_CheckExact(right), COMPARE_OP);
@@ -2521,7 +2522,7 @@
             assert(COMPARISON_NOT_EQUALS + 1 == COMPARISON_EQUALS);
             res = ((COMPARISON_NOT_EQUALS + eq) & oparg) ? Py_True : Py_False;
             Py_INCREF(res);
-            #line 2525 "Python/generated_cases.c.h"
+            #line 2526 "Python/generated_cases.c.h"
             STACK_SHRINK(1);
             stack_pointer[-1] = res;
             next_instr += 1;
@@ -2532,14 +2533,14 @@
             PyObject *right = stack_pointer[-1];
             PyObject *left = stack_pointer[-2];
             PyObject *b;
-            #line 1768 "Python/bytecodes.c"
+            #line 1769 "Python/bytecodes.c"
             int res = Py_Is(left, right) ^ oparg;
-            #line 2538 "Python/generated_cases.c.h"
+            #line 2539 "Python/generated_cases.c.h"
             Py_DECREF(left);
             Py_DECREF(right);
-            #line 1770 "Python/bytecodes.c"
+            #line 1771 "Python/bytecodes.c"
             b = Py_NewRef(res ? Py_True : Py_False);
-            #line 2543 "Python/generated_cases.c.h"
+            #line 2544 "Python/generated_cases.c.h"
             STACK_SHRINK(1);
             stack_pointer[-1] = b;
             DISPATCH();
@@ -2549,15 +2550,15 @@
             PyObject *right = stack_pointer[-1];
             PyObject *left = stack_pointer[-2];
             PyObject *b;
-            #line 1774 "Python/bytecodes.c"
+            #line 1775 "Python/bytecodes.c"
             int res = PySequence_Contains(right, left);
-            #line 2555 "Python/generated_cases.c.h"
+            #line 2556 "Python/generated_cases.c.h"
             Py_DECREF(left);
             Py_DECREF(right);
-            #line 1776 "Python/bytecodes.c"
+            #line 1777 "Python/bytecodes.c"
             if (res < 0) goto pop_2_error;
             b = Py_NewRef((res^oparg) ? Py_True : Py_False);
-            #line 2561 "Python/generated_cases.c.h"
+            #line 2562 "Python/generated_cases.c.h"
             STACK_SHRINK(1);
             stack_pointer[-1] = b;
             DISPATCH();
@@ -2568,12 +2569,12 @@
             PyObject *exc_value = stack_pointer[-2];
             PyObject *rest;
             PyObject *match;
-            #line 1781 "Python/bytecodes.c"
+            #line 1782 "Python/bytecodes.c"
             if (check_except_star_type_valid(tstate, match_type) < 0) {
-            #line 2574 "Python/generated_cases.c.h"
+            #line 2575 "Python/generated_cases.c.h"
                 Py_DECREF(exc_value);
                 Py_DECREF(match_type);
-            #line 1783 "Python/bytecodes.c"
+            #line 1784 "Python/bytecodes.c"
                 if (true) goto pop_2_error;
             }
 
@@ -2581,10 +2582,10 @@
             rest = NULL;
             int res = exception_group_match(exc_value, match_type,
                                             &match, &rest);
-            #line 2585 "Python/generated_cases.c.h"
+            #line 2586 "Python/generated_cases.c.h"
             Py_DECREF(exc_value);
             Py_DECREF(match_type);
-            #line 1791 "Python/bytecodes.c"
+            #line 1792 "Python/bytecodes.c"
             if (res < 0) goto pop_2_error;
 
             assert((match == NULL) == (rest == NULL));
@@ -2593,7 +2594,7 @@
             if (!Py_IsNone(match)) {
                 PyErr_SetExcInfo(NULL, Py_NewRef(match), NULL);
             }
-            #line 2597 "Python/generated_cases.c.h"
+            #line 2598 "Python/generated_cases.c.h"
             stack_pointer[-1] = match;
             stack_pointer[-2] = rest;
             DISPATCH();
@@ -2603,21 +2604,21 @@
             PyObject *right = stack_pointer[-1];
             PyObject *left = stack_pointer[-2];
             PyObject *b;
-            #line 1802 "Python/bytecodes.c"
+            #line 1803 "Python/bytecodes.c"
             assert(PyExceptionInstance_Check(left));
             if (check_except_type_valid(tstate, right) < 0) {
-            #line 2610 "Python/generated_cases.c.h"
+            #line 2611 "Python/generated_cases.c.h"
                  Py_DECREF(right);
-            #line 1805 "Python/bytecodes.c"
+            #line 1806 "Python/bytecodes.c"
                  if (true) goto pop_1_error;
             }
 
             int res = PyErr_GivenExceptionMatches(left, right);
-            #line 2617 "Python/generated_cases.c.h"
+            #line 2618 "Python/generated_cases.c.h"
             Py_DECREF(right);
-            #line 1810 "Python/bytecodes.c"
+            #line 1811 "Python/bytecodes.c"
             b = Py_NewRef(res ? Py_True : Py_False);
-            #line 2621 "Python/generated_cases.c.h"
+            #line 2622 "Python/generated_cases.c.h"
             stack_pointer[-1] = b;
             DISPATCH();
         }
@@ -2626,15 +2627,15 @@
             PyObject *fromlist = stack_pointer[-1];
             PyObject *level = stack_pointer[-2];
             PyObject *res;
-            #line 1814 "Python/bytecodes.c"
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+            #line 1815 "Python/bytecodes.c"
+            PyObject *name = GETITEM(NAMES(), oparg);
             res = import_name(tstate, frame, name, fromlist, level);
-            #line 2633 "Python/generated_cases.c.h"
+            #line 2634 "Python/generated_cases.c.h"
             Py_DECREF(level);
             Py_DECREF(fromlist);
-            #line 1817 "Python/bytecodes.c"
+            #line 1818 "Python/bytecodes.c"
             if (res == NULL) goto pop_2_error;
-            #line 2638 "Python/generated_cases.c.h"
+            #line 2639 "Python/generated_cases.c.h"
             STACK_SHRINK(1);
             stack_pointer[-1] = res;
             DISPATCH();
@@ -2643,29 +2644,29 @@
         TARGET(IMPORT_FROM) {
             PyObject *from = stack_pointer[-1];
             PyObject *res;
-            #line 1821 "Python/bytecodes.c"
-            PyObject *name = GETITEM(frame->f_code->co_names, oparg);
+            #line 1822 "Python/bytecodes.c"
+            PyObject *name = GETITEM(NAMES(), oparg);
             res = import_from(tstate, from, name);
             if (res == NULL) goto error;
-            #line 2651 "Python/generated_cases.c.h"
+            #line 2652 "Python/generated_cases.c.h"
             STACK_GROW(1);
             stack_pointer[-1] = res;
             DISPATCH();
         }
 
         TARGET(JUMP_FORWARD) {
-            #line 1827 "Python/bytecodes.c"
+            #line 1828 "Python/bytecodes.c"
             JUMPBY(oparg);
-            #line 2660 "Python/generated_cases.c.h"
+            #line 2661 "Python/generated_cases.c.h"
             DISPATCH();
         }
 
         TARGET(JUMP_BACKWARD) {
             PREDICTED(JUMP_BACKWARD);
-            #line 1831 "Python/bytecodes.c"
+            #line 1832 "Python/bytecodes.c"
             assert(oparg < INSTR_OFFSET());
             JUMPBY(-oparg);
-            #line 2669 "Python/generated_cases.c.h"
+            #line 2670 "Python/generated_cases.c.h"
             CHECK_EVAL_BREAKER();
             DISPATCH();
         }
@@ -2673,7 +2674,7 @@
         TARGET(POP_JUMP_IF_FALSE) {
             PREDICTED(POP_JUMP_IF_FALSE);
             PyObject *cond = stack_pointer[-1];
-            #line 1837 "Python/bytecodes.c"
+            #line 1838 "Python/bytecodes.c"
             if (Py_IsTrue(cond)) {
                 _Py_DECREF_NO_DEALLOC(cond);
             }
@@ -2683,9 +2684,9 @@
             }
             else {
                 int err = PyObject_IsTrue(cond);
-            #line 2687 "Python/generated_cases.c.h"
+            #line 2688 "Python/generated_cases.c.h"
                 Py_DECREF(cond);
-            #line 1847 "Python/bytecodes.c"
+            #line 1848 "Python/bytecodes.c"
                 if (err == 0) {
                     JUMPBY(oparg);
                 }
@@ -2693,14 +2694,14 @@
                     if (err < 0) goto pop_1_error;
                 }
             }
-            #line 2697 "Python/generated_cases.c.h"
+            #line 2698 "Python/generated_cases.c.h"
             STACK_SHRINK(1);
             DISPATCH();
         }
 
         TARGET(POP_JUMP_IF_TRUE) {
             PyObject *cond = stack_pointer[-1];
-            #line 1857 "Python/bytecodes.c"
+            #line 1858 "Python/bytecodes.c"
             if (Py_IsFalse(cond)) {
                 _Py_DECREF_NO_DEALLOC(cond);
             }
@@ -2710,9 +2711,9 @@
             }
             else {
                 int err = PyObject_IsTrue(cond);
-            #line 2714 "Python/generated_cases.c.h"
+            #line 2715 "Python/generated_cases.c.h"
                 Py_DECREF(cond);
-            #line 1867 "Python/bytecodes.c"
+            #line 1868 "Python/bytecodes.c"
                 if (err > 0) {
                     JUMPBY(oparg);
                 }
@@ -2720,67 +2721,67 @@
                     if (err < 0) goto pop_1_error;
                 }
             }
-            #line 2724 "Python/generated_cases.c.h"
+            #line 2725 "Python/generated_cases.c.h"
             STACK_SHRINK(1);
             DISPATCH();
         }
 
         TARGET(POP_JUMP_IF_NOT_NONE) {
             PyObject *value = stack_pointer[-1];
-            #line 1877 "Python/bytecodes.c"
+            #line 1878 "Python/bytecodes.c"
             if (!Py_IsNone(value)) {
-            #line 2733 "Python/generated_cases.c.h"
+            #line 2734 "Python/generated_cases.c.h"
                 Py_DECREF(value);
-            #line 1879 "Python/bytecodes.c"
+            #line 1880 "Python/bytecodes.c"
                 JUMPBY(oparg);
             }
             else {
                 _Py_DECREF_NO_DEALLOC(value);
             }
-            #line 2741 "Python/generated_cases.c.h"
+            #line 2742 "Python/generated_cases.c.h"
             STACK_SHRINK(1);
             DISPATCH();
         }
 
         TARGET(POP_JUMP_IF_NONE) {
             PyObject *value = stack_pointer[-1];
-            #line 1887 "Python/bytecodes.c"
+            #line 1888 "Python/bytecodes.c"
             if (Py_IsNone(value)) {
                 _Py_DECREF_NO_DEALLOC(value);
                 JUMPBY(oparg);
             }
             else {
-            #line 2754 "Python/generated_cases.c.h"
+            #line 2755 "Python/generated_cases.c.h"
                 Py_DECREF(value);
-            #line 1893 "Python/bytecodes.c"
+            #line 1894 "Python/bytecodes.c"
             }
-            #line 2758 "Python/generated_cases.c.h"
+            #line 2759 "Python/generated_cases.c.h"
             STACK_SHRINK(1);
             DISPATCH();
         }
 
         TARGET(JUMP_BACKWARD_NO_INTERRUPT) {
-            #line 1897 "Python/bytecodes.c"
+            #line 1898 "Python/bytecodes.c"
             /* This bytecode is used in the `yield from` or `await` loop.
              * If there is an interrupt, we want it handled in the innermost
              * generator or coroutine, so we deliberately do not check it here.
              * (see bpo-30039).
              */
             JUMPBY(-oparg);
-            #line 2771 "Python/generated_cases.c.h"
+            #line 2772 "Python/generated_cases.c.h"
             DISPATCH();
         }
 
         TARGET(GET_LEN) {
             PyObject *obj = stack_pointer[-1];
             PyObject *len_o;
-            #line 1906 "Python/bytecodes.c"
+            #line 1907 "Python/bytecodes.c"
             // PUSH(len(TOS))
             Py_ssize_t len_i = PyObject_Length(obj);
             if (len_i < 0) goto error;
             len_o = PyLong_FromSsize_t(len_i);
             if (len_o == NULL) goto error;
-            #line 2784 "Python/generated_cases.c.h"
+            #line 2785 "Python/generated_cases.c.h"
             STACK_GROW(1);
             stack_pointer[-1] = len_o;
             DISPATCH();
@@ -2791,16 +2792,16 @@
             PyObject *type = stack_pointer[-2];
             PyObject *subject = stack_pointer[-3];
             PyObject *attrs;
-            #line 1914 "Python/bytecodes.c"
+            #line 1915 "Python/bytecodes.c"
             // Pop TOS and TOS1. Set TOS to a tuple of attributes on success, or
             // None on failure.
             assert(PyTuple_CheckExact(names));
             attrs = match_class(tstate, subject, type, oparg, names);
-            #line 2800 "Python/generated_cases.c.h"
+            #line 2801 "Python/generated_cases.c.h"
             Py_DECREF(subject);
             Py_DECREF(type);
             Py_DECREF(names);
-            #line 1919 "Python/bytecodes.c"
+            #line 1920 "Python/bytecodes.c"
             if (attrs) {
                 assert(PyTuple_CheckExact(attrs));  // Success!
             }
@@ -2808,7 +2809,7 @@
                 if (_PyErr_Occurred(tstate)) goto pop_3_error;
                 attrs = Py_NewRef(Py_None);  // Failure!
             }
-            #line 2812 "Python/generated_cases.c.h"
+            #line 2813 "Python/generated_cases.c.h"
             STACK_SHRINK(2);
             stack_pointer[-1] = attrs;
             DISPATCH();
@@ -2817,10 +2818,10 @@
         TARGET(MATCH_MAPPING) {
             PyObject *subject = stack_pointer[-1];
             PyObject *res;
-            #line 1929 "Python/bytecodes.c"
+            #line 1930 "Python/bytecodes.c"
             int match = Py_TYPE(subject)->tp_flags & Py_TPFLAGS_MAPPING;
             res = Py_NewRef(match ? Py_True : Py_False);
-            #line 2824 "Python/generated_cases.c.h"
+            #line 2825 "Python/generated_cases.c.h"
             STACK_GROW(1);
             stack_pointer[-1] = res;
             PREDICT(POP_JUMP_IF_FALSE);
@@ -2830,10 +2831,10 @@
         TARGET(MATCH_SEQUENCE) {
             PyObject *subject = stack_pointer[-1];
             PyObject *res;
-            #line 1935 "Python/bytecodes.c"
+            #line 1936 "Python/bytecodes.c"
             int match = Py_TYPE(subject)->tp_flags & Py_TPFLAGS_SEQUENCE;
             res = Py_NewRef(match ? Py_True : Py_False);
-            #line 2837 "Python/generated_cases.c.h"
+            #line 2838 "Python/generated_cases.c.h"
             STACK_GROW(1);
             stack_pointer[-1] = res;
             PREDICT(POP_JUMP_IF_FALSE);
@@ -2844,11 +2845,11 @@
             PyObject *keys = stack_pointer[-1];
             PyObject *subject = stack_pointer[-2];
             PyObject *values_or_none;
-            #line 1941 "Python/bytecodes.c"
+            #line 1942 "Python/bytecodes.c"
             // On successful match, PUSH(values). Otherwise, PUSH(None).
             values_or_none = match_keys(tstate, subject, keys);
             if (values_or_none == NULL) goto error;
-            #line 2852 "Python/generated_cases.c.h"
+            #line 2853 "Python/generated_cases.c.h"
             STACK_GROW(1);
             stack_pointer[-1] = values_or_none;
             DISPATCH();
@@ -2857,14 +2858,14 @@
         TARGET(GET_ITER) {
             PyObject *iterable = stack_pointer[-1];
             PyObject *iter;
-            #line 1947 "Python/bytecodes.c"
+            #line 1948 "Python/bytecodes.c"
             /* before: [obj]; after [getiter(obj)] */
             iter = PyObject_GetIter(iterable);
-            #line 2864 "Python/generated_cases.c.h"
+            #line 2865 "Python/generated_cases.c.h"
             Py_DECREF(iterable);
-            #line 1950 "Python/bytecodes.c"
+            #line 1951 "Python/bytecodes.c"
             if (iter == NULL) goto pop_1_error;
-            #line 2868 "Python/generated_cases.c.h"
+            #line 2869 "Python/generated_cases.c.h"
             stack_pointer[-1] = iter;
             DISPATCH();
         }
@@ -2872,11 +2873,11 @@
         TARGET(GET_YIELD_FROM_ITER) {
             PyObject *iterable = stack_pointer[-1];
             PyObject *iter;
-            #line 1954 "Python/bytecodes.c"
+            #line 1955 "Python/bytecodes.c"
             /* before: [obj]; after [getiter(obj)] */
             if (PyCoro_CheckExact(iterable)) {
                 /* `iterable` is a coroutine */
-                if (!(frame->f_code->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) {
+                if (!(_PyFrame_GetCode(frame)->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) {
                     /* and it is used in a 'yield from' expression of a
                        regular generator. */
                     _PyErr_SetString(tstate, PyExc_TypeError,
@@ -2895,11 +2896,11 @@
                 if (iter == NULL) {
                     goto error;
                 }
-            #line 2899 "Python/generated_cases.c.h"
+            #line 2900 "Python/generated_cases.c.h"
                 Py_DECREF(iterable);
-            #line 1977 "Python/bytecodes.c"
+            #line 1978 "Python/bytecodes.c"
             }
-            #line 2903 "Python/generated_cases.c.h"
+            #line 2904 "Python/generated_cases.c.h"
             stack_pointer[-1] = iter;
             PREDICT(LOAD_CONST);
             DISPATCH();
@@ -2910,7 +2911,7 @@
             static_assert(INLINE_CACHE_ENTRIES_FOR_ITER == 1, "incorrect cache size");
             PyObject *iter = stack_pointer[-1];
             PyObject *next;
-            #line 1996 "Python/bytecodes.c"
+            #line 1997 "Python/bytecodes.c"
             #if ENABLE_SPECIALIZATION
             _PyForIterCache *cache = (_PyForIterCache *)next_instr;
             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
@@ -2943,7 +2944,7 @@
                 DISPATCH();
             }
             // Common case: no jump, leave it to the code generator
-            #line 2947 "Python/generated_cases.c.h"
+            #line 2948 "Python/generated_cases.c.h"
             STACK_GROW(1);
             stack_pointer[-1] = next;
             next_instr += 1;
@@ -2953,7 +2954,7 @@
         TARGET(FOR_ITER_LIST) {
             PyObject *iter = stack_pointer[-1];
             PyObject *next;
-            #line 2031 "Python/bytecodes.c"
+            #line 2032 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             DEOPT_IF(Py_TYPE(iter) != &PyListIter_Type, FOR_ITER);
             _PyListIterObject *it = (_PyListIterObject *)iter;
@@ -2974,7 +2975,7 @@
             DISPATCH();
         end_for_iter_list:
             // Common case: no jump, leave it to the code generator
-            #line 2978 "Python/generated_cases.c.h"
+            #line 2979 "Python/generated_cases.c.h"
             STACK_GROW(1);
             stack_pointer[-1] = next;
             next_instr += 1;
@@ -2984,7 +2985,7 @@
         TARGET(FOR_ITER_TUPLE) {
             PyObject *iter = stack_pointer[-1];
             PyObject *next;
-            #line 2054 "Python/bytecodes.c"
+            #line 2055 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             _PyTupleIterObject *it = (_PyTupleIterObject *)iter;
             DEOPT_IF(Py_TYPE(it) != &PyTupleIter_Type, FOR_ITER);
@@ -3005,7 +3006,7 @@
             DISPATCH();
         end_for_iter_tuple:
             // Common case: no jump, leave it to the code generator
-            #line 3009 "Python/generated_cases.c.h"
+            #line 3010 "Python/generated_cases.c.h"
             STACK_GROW(1);
             stack_pointer[-1] = next;
             next_instr += 1;
@@ -3015,7 +3016,7 @@
         TARGET(FOR_ITER_RANGE) {
             PyObject *iter = stack_pointer[-1];
             PyObject *next;
-            #line 2077 "Python/bytecodes.c"
+            #line 2078 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             _PyRangeIterObject *r = (_PyRangeIterObject *)iter;
             DEOPT_IF(Py_TYPE(r) != &PyRangeIter_Type, FOR_ITER);
@@ -3034,7 +3035,7 @@
             if (next == NULL) {
                 goto error;
             }
-            #line 3038 "Python/generated_cases.c.h"
+            #line 3039 "Python/generated_cases.c.h"
             STACK_GROW(1);
             stack_pointer[-1] = next;
             next_instr += 1;
@@ -3043,7 +3044,7 @@
 
         TARGET(FOR_ITER_GEN) {
             PyObject *iter = stack_pointer[-1];
-            #line 2098 "Python/bytecodes.c"
+            #line 2099 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             PyGenObject *gen = (PyGenObject *)iter;
             DEOPT_IF(Py_TYPE(gen) != &PyGen_Type, FOR_ITER);
@@ -3058,14 +3059,14 @@
             JUMPBY(INLINE_CACHE_ENTRIES_FOR_ITER + oparg);
             assert(next_instr->op.code == END_FOR);
             DISPATCH_INLINED(gen_frame);
-            #line 3062 "Python/generated_cases.c.h"
+            #line 3063 "Python/generated_cases.c.h"
         }
 
         TARGET(BEFORE_ASYNC_WITH) {
             PyObject *mgr = stack_pointer[-1];
             PyObject *exit;
             PyObject *res;
-            #line 2115 "Python/bytecodes.c"
+            #line 2116 "Python/bytecodes.c"
             PyObject *enter = _PyObject_LookupSpecial(mgr, &_Py_ID(__aenter__));
             if (enter == NULL) {
                 if (!_PyErr_Occurred(tstate)) {
@@ -3088,16 +3089,16 @@
                 Py_DECREF(enter);
                 goto error;
             }
-            #line 3092 "Python/generated_cases.c.h"
+            #line 3093 "Python/generated_cases.c.h"
             Py_DECREF(mgr);
-            #line 2138 "Python/bytecodes.c"
+            #line 2139 "Python/bytecodes.c"
             res = _PyObject_CallNoArgs(enter);
             Py_DECREF(enter);
             if (res == NULL) {
                 Py_DECREF(exit);
                 if (true) goto pop_1_error;
             }
-            #line 3101 "Python/generated_cases.c.h"
+            #line 3102 "Python/generated_cases.c.h"
             STACK_GROW(1);
             stack_pointer[-1] = res;
             stack_pointer[-2] = exit;
@@ -3109,7 +3110,7 @@
             PyObject *mgr = stack_pointer[-1];
             PyObject *exit;
             PyObject *res;
-            #line 2148 "Python/bytecodes.c"
+            #line 2149 "Python/bytecodes.c"
             /* pop the context manager, push its __exit__ and the
              * value returned from calling its __enter__
              */
@@ -3135,16 +3136,16 @@
                 Py_DECREF(enter);
                 goto error;
             }
-            #line 3139 "Python/generated_cases.c.h"
+            #line 3140 "Python/generated_cases.c.h"
             Py_DECREF(mgr);
-            #line 2174 "Python/bytecodes.c"
+            #line 2175 "Python/bytecodes.c"
             res = _PyObject_CallNoArgs(enter);
             Py_DECREF(enter);
             if (res == NULL) {
                 Py_DECREF(exit);
                 if (true) goto pop_1_error;
             }
-            #line 3148 "Python/generated_cases.c.h"
+            #line 3149 "Python/generated_cases.c.h"
             STACK_GROW(1);
             stack_pointer[-1] = res;
             stack_pointer[-2] = exit;
@@ -3156,7 +3157,7 @@
             PyObject *lasti = stack_pointer[-3];
             PyObject *exit_func = stack_pointer[-4];
             PyObject *res;
-            #line 2183 "Python/bytecodes.c"
+            #line 2184 "Python/bytecodes.c"
             /* At the top of the stack are 4 values:
                - val: TOP = exc_info()
                - unused: SECOND = previous exception
@@ -3177,7 +3178,7 @@
             res = PyObject_Vectorcall(exit_func, stack + 1,
                     3 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
             if (res == NULL) goto error;
-            #line 3181 "Python/generated_cases.c.h"
+            #line 3182 "Python/generated_cases.c.h"
             STACK_GROW(1);
             stack_pointer[-1] = res;
             DISPATCH();
@@ -3186,7 +3187,7 @@
         TARGET(PUSH_EXC_INFO) {
             PyObject *new_exc = stack_pointer[-1];
             PyObject *prev_exc;
-            #line 2206 "Python/bytecodes.c"
+            #line 2207 "Python/bytecodes.c"
             _PyErr_StackItem *exc_info = tstate->exc_info;
             if (exc_info->exc_value != NULL) {
                 prev_exc = exc_info->exc_value;
@@ -3196,7 +3197,7 @@
             }
             assert(PyExceptionInstance_Check(new_exc));
             exc_info->exc_value = Py_NewRef(new_exc);
-            #line 3200 "Python/generated_cases.c.h"
+            #line 3201 "Python/generated_cases.c.h"
             STACK_GROW(1);
             stack_pointer[-1] = new_exc;
             stack_pointer[-2] = prev_exc;
@@ -3210,7 +3211,7 @@
             uint32_t type_version = read_u32(&next_instr[1].cache);
             uint32_t keys_version = read_u32(&next_instr[3].cache);
             PyObject *descr = read_obj(&next_instr[5].cache);
-            #line 2218 "Python/bytecodes.c"
+            #line 2219 "Python/bytecodes.c"
             /* Cached method object */
             assert(cframe.use_tracing == 0);
             PyTypeObject *self_cls = Py_TYPE(self);
@@ -3228,7 +3229,7 @@
             assert(_PyType_HasFeature(Py_TYPE(res2), Py_TPFLAGS_METHOD_DESCRIPTOR));
             res = self;
             assert(oparg & 1);
-            #line 3232 "Python/generated_cases.c.h"
+            #line 3233 "Python/generated_cases.c.h"
             STACK_GROW(((oparg & 1) ? 1 : 0));
             stack_pointer[-1] = res;
             if (oparg & 1) { stack_pointer[-(1 + ((oparg & 1) ? 1 : 0))] = res2; }
@@ -3242,7 +3243,7 @@
             PyObject *res;
             uint32_t type_version = read_u32(&next_instr[1].cache);
             PyObject *descr = read_obj(&next_instr[5].cache);
-            #line 2238 "Python/bytecodes.c"
+            #line 2239 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             PyTypeObject *self_cls = Py_TYPE(self);
             DEOPT_IF(self_cls->tp_version_tag != type_version, LOAD_ATTR);
@@ -3253,7 +3254,7 @@
             res2 = Py_NewRef(descr);
             res = self;
             assert(oparg & 1);
-            #line 3257 "Python/generated_cases.c.h"
+            #line 3258 "Python/generated_cases.c.h"
             STACK_GROW(((oparg & 1) ? 1 : 0));
             stack_pointer[-1] = res;
             if (oparg & 1) { stack_pointer[-(1 + ((oparg & 1) ? 1 : 0))] = res2; }
@@ -3267,7 +3268,7 @@
             PyObject *res;
             uint32_t type_version = read_u32(&next_instr[1].cache);
             PyObject *descr = read_obj(&next_instr[5].cache);
-            #line 2251 "Python/bytecodes.c"
+            #line 2252 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             PyTypeObject *self_cls = Py_TYPE(self);
             DEOPT_IF(self_cls->tp_version_tag != type_version, LOAD_ATTR);
@@ -3282,7 +3283,7 @@
             res2 = Py_NewRef(descr);
             res = self;
             assert(oparg & 1);
-            #line 3286 "Python/generated_cases.c.h"
+            #line 3287 "Python/generated_cases.c.h"
             STACK_GROW(((oparg & 1) ? 1 : 0));
             stack_pointer[-1] = res;
             if (oparg & 1) { stack_pointer[-(1 + ((oparg & 1) ? 1 : 0))] = res2; }
@@ -3291,11 +3292,11 @@
         }
 
         TARGET(KW_NAMES) {
-            #line 2268 "Python/bytecodes.c"
+            #line 2269 "Python/bytecodes.c"
             assert(kwnames == NULL);
-            assert(oparg < PyTuple_GET_SIZE(frame->f_code->co_consts));
-            kwnames = GETITEM(frame->f_code->co_consts, oparg);
-            #line 3299 "Python/generated_cases.c.h"
+            assert(oparg < PyTuple_GET_SIZE(CONSTS()));
+            kwnames = GETITEM(CONSTS(), oparg);
+            #line 3300 "Python/generated_cases.c.h"
             DISPATCH();
         }
 
@@ -3306,7 +3307,7 @@
             PyObject *callable = stack_pointer[-(1 + oparg)];
             PyObject *method = stack_pointer[-(2 + oparg)];
             PyObject *res;
-            #line 2304 "Python/bytecodes.c"
+            #line 2305 "Python/bytecodes.c"
             int is_meth = method != NULL;
             int total_args = oparg;
             if (is_meth) {
@@ -3359,6 +3360,7 @@
                 JUMPBY(INLINE_CACHE_ENTRIES_CALL);
                 DISPATCH_INLINED(new_frame);
             }
+
             /* Callable is not a normal Python function */
             if (cframe.use_tracing) {
                 res = trace_call_function(
@@ -3366,10 +3368,10 @@
                     positional_args, kwnames);
             }
             else {
-                res = PyObject_Vectorcall(
+                CALL_WITH_NATIVE_FRAME(callable, res = PyObject_Vectorcall(
                     callable, args,
                     positional_args | PY_VECTORCALL_ARGUMENTS_OFFSET,
-                    kwnames);
+                    kwnames));
             }
             kwnames = NULL;
             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
@@ -3378,7 +3380,7 @@
                 Py_DECREF(args[i]);
             }
             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
-            #line 3382 "Python/generated_cases.c.h"
+            #line 3384 "Python/generated_cases.c.h"
             STACK_SHRINK(oparg);
             STACK_SHRINK(1);
             stack_pointer[-1] = res;
@@ -3390,7 +3392,7 @@
         TARGET(CALL_BOUND_METHOD_EXACT_ARGS) {
             PyObject *callable = stack_pointer[-(1 + oparg)];
             PyObject *method = stack_pointer[-(2 + oparg)];
-            #line 2382 "Python/bytecodes.c"
+            #line 2384 "Python/bytecodes.c"
             DEOPT_IF(method != NULL, CALL);
             DEOPT_IF(Py_TYPE(callable) != &PyMethod_Type, CALL);
             STAT_INC(CALL, hit);
@@ -3400,7 +3402,7 @@
             PEEK(oparg + 2) = Py_NewRef(meth);  // method
             Py_DECREF(callable);
             GO_TO_INSTRUCTION(CALL_PY_EXACT_ARGS);
-            #line 3404 "Python/generated_cases.c.h"
+            #line 3406 "Python/generated_cases.c.h"
         }
 
         TARGET(CALL_PY_EXACT_ARGS) {
@@ -3409,7 +3411,7 @@
             PyObject *callable = stack_pointer[-(1 + oparg)];
             PyObject *method = stack_pointer[-(2 + oparg)];
             uint32_t func_version = read_u32(&next_instr[1].cache);
-            #line 2394 "Python/bytecodes.c"
+            #line 2396 "Python/bytecodes.c"
             assert(kwnames == NULL);
             DEOPT_IF(tstate->interp->eval_frame, CALL);
             int is_meth = method != NULL;
@@ -3434,7 +3436,7 @@
             STACK_SHRINK(oparg + 2);
             JUMPBY(INLINE_CACHE_ENTRIES_CALL);
             DISPATCH_INLINED(new_frame);
-            #line 3438 "Python/generated_cases.c.h"
+            #line 3440 "Python/generated_cases.c.h"
         }
 
         TARGET(CALL_PY_WITH_DEFAULTS) {
@@ -3443,7 +3445,7 @@
             PyObject *method = stack_pointer[-(2 + oparg)];
             uint32_t func_version = read_u32(&next_instr[1].cache);
             uint16_t min_args = read_u16(&next_instr[3].cache);
-            #line 2421 "Python/bytecodes.c"
+            #line 2423 "Python/bytecodes.c"
             assert(kwnames == NULL);
             DEOPT_IF(tstate->interp->eval_frame, CALL);
             int is_meth = method != NULL;
@@ -3473,7 +3475,7 @@
             STACK_SHRINK(oparg + 2);
             JUMPBY(INLINE_CACHE_ENTRIES_CALL);
             DISPATCH_INLINED(new_frame);
-            #line 3477 "Python/generated_cases.c.h"
+            #line 3479 "Python/generated_cases.c.h"
         }
 
         TARGET(CALL_NO_KW_TYPE_1) {
@@ -3481,7 +3483,7 @@
             PyObject *callable = stack_pointer[-(1 + oparg)];
             PyObject *null = stack_pointer[-(2 + oparg)];
             PyObject *res;
-            #line 2453 "Python/bytecodes.c"
+            #line 2455 "Python/bytecodes.c"
             assert(kwnames == NULL);
             assert(cframe.use_tracing == 0);
             assert(oparg == 1);
@@ -3492,7 +3494,7 @@
             res = Py_NewRef(Py_TYPE(obj));
             Py_DECREF(obj);
             Py_DECREF(&PyType_Type);  // I.e., callable
-            #line 3496 "Python/generated_cases.c.h"
+            #line 3498 "Python/generated_cases.c.h"
             STACK_SHRINK(oparg);
             STACK_SHRINK(1);
             stack_pointer[-1] = res;
@@ -3505,7 +3507,7 @@
             PyObject *callable = stack_pointer[-(1 + oparg)];
             PyObject *null = stack_pointer[-(2 + oparg)];
             PyObject *res;
-            #line 2466 "Python/bytecodes.c"
+            #line 2468 "Python/bytecodes.c"
             assert(kwnames == NULL);
             assert(cframe.use_tracing == 0);
             assert(oparg == 1);
@@ -3517,7 +3519,7 @@
             Py_DECREF(arg);
             Py_DECREF(&PyUnicode_Type);  // I.e., callable
             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
-            #line 3521 "Python/generated_cases.c.h"
+            #line 3523 "Python/generated_cases.c.h"
             STACK_SHRINK(oparg);
             STACK_SHRINK(1);
             stack_pointer[-1] = res;
@@ -3531,7 +3533,7 @@
             PyObject *callable = stack_pointer[-(1 + oparg)];
             PyObject *null = stack_pointer[-(2 + oparg)];
             PyObject *res;
-            #line 2481 "Python/bytecodes.c"
+            #line 2483 "Python/bytecodes.c"
             assert(kwnames == NULL);
             assert(oparg == 1);
             DEOPT_IF(null != NULL, CALL);
@@ -3542,7 +3544,7 @@
             Py_DECREF(arg);
             Py_DECREF(&PyTuple_Type);  // I.e., tuple
             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
-            #line 3546 "Python/generated_cases.c.h"
+            #line 3548 "Python/generated_cases.c.h"
             STACK_SHRINK(oparg);
             STACK_SHRINK(1);
             stack_pointer[-1] = res;
@@ -3556,7 +3558,7 @@
             PyObject *callable = stack_pointer[-(1 + oparg)];
             PyObject *method = stack_pointer[-(2 + oparg)];
             PyObject *res;
-            #line 2495 "Python/bytecodes.c"
+            #line 2497 "Python/bytecodes.c"
             int is_meth = method != NULL;
             int total_args = oparg;
             if (is_meth) {
@@ -3569,8 +3571,8 @@
             PyTypeObject *tp = (PyTypeObject *)callable;
             DEOPT_IF(tp->tp_vectorcall == NULL, CALL);
             STAT_INC(CALL, hit);
-            res = tp->tp_vectorcall((PyObject *)tp, args,
-                                    total_args - kwnames_len, kwnames);
+            CALL_WITH_NATIVE_FRAME(callable, res = tp->tp_vectorcall((PyObject *)tp, args,
+                                    total_args - kwnames_len, kwnames));
             kwnames = NULL;
             /* Free the arguments. */
             for (int i = 0; i < total_args; i++) {
@@ -3578,7 +3580,7 @@
             }
             Py_DECREF(tp);
             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
-            #line 3582 "Python/generated_cases.c.h"
+            #line 3584 "Python/generated_cases.c.h"
             STACK_SHRINK(oparg);
             STACK_SHRINK(1);
             stack_pointer[-1] = res;
@@ -3592,7 +3594,7 @@
             PyObject *callable = stack_pointer[-(1 + oparg)];
             PyObject *method = stack_pointer[-(2 + oparg)];
             PyObject *res;
-            #line 2520 "Python/bytecodes.c"
+            #line 2522 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             /* Builtin METH_O functions */
             assert(kwnames == NULL);
@@ -3614,14 +3616,14 @@
                 goto error;
             }
             PyObject *arg = args[0];
-            res = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable), arg);
+            CALL_WITH_NATIVE_FRAME(callable, res = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable), arg));
             _Py_LeaveRecursiveCallTstate(tstate);
             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
 
             Py_DECREF(arg);
             Py_DECREF(callable);
             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
-            #line 3625 "Python/generated_cases.c.h"
+            #line 3627 "Python/generated_cases.c.h"
             STACK_SHRINK(oparg);
             STACK_SHRINK(1);
             stack_pointer[-1] = res;
@@ -3635,7 +3637,7 @@
             PyObject *callable = stack_pointer[-(1 + oparg)];
             PyObject *method = stack_pointer[-(2 + oparg)];
             PyObject *res;
-            #line 2552 "Python/bytecodes.c"
+            #line 2554 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             /* Builtin METH_FASTCALL functions, without keywords */
             assert(kwnames == NULL);
@@ -3651,10 +3653,10 @@
             STAT_INC(CALL, hit);
             PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable);
             /* res = func(self, args, nargs) */
-            res = ((_PyCFunctionFast)(void(*)(void))cfunc)(
+            CALL_WITH_NATIVE_FRAME(callable, res = ((_PyCFunctionFast)(void(*)(void))cfunc)(
                 PyCFunction_GET_SELF(callable),
                 args,
-                total_args);
+                total_args));
             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
 
             /* Free the arguments. */
@@ -3668,7 +3670,7 @@
                    'invalid'). In those cases an exception is set, so we must
                    handle it.
                 */
-            #line 3672 "Python/generated_cases.c.h"
+            #line 3674 "Python/generated_cases.c.h"
             STACK_SHRINK(oparg);
             STACK_SHRINK(1);
             stack_pointer[-1] = res;
@@ -3682,7 +3684,7 @@
             PyObject *callable = stack_pointer[-(1 + oparg)];
             PyObject *method = stack_pointer[-(2 + oparg)];
             PyObject *res;
-            #line 2588 "Python/bytecodes.c"
+            #line 2590 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             /* Builtin METH_FASTCALL | METH_KEYWORDS functions */
             int is_meth = method != NULL;
@@ -3700,12 +3702,12 @@
             _PyCFunctionFastWithKeywords cfunc =
                 (_PyCFunctionFastWithKeywords)(void(*)(void))
                 PyCFunction_GET_FUNCTION(callable);
-            res = cfunc(
+            CALL_WITH_NATIVE_FRAME(callable, res = cfunc(
                 PyCFunction_GET_SELF(callable),
                 args,
                 total_args - KWNAMES_LEN(),
                 kwnames
-            );
+            ));
             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
             kwnames = NULL;
 
@@ -3715,7 +3717,7 @@
             }
             Py_DECREF(callable);
             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
-            #line 3719 "Python/generated_cases.c.h"
+            #line 3721 "Python/generated_cases.c.h"
             STACK_SHRINK(oparg);
             STACK_SHRINK(1);
             stack_pointer[-1] = res;
@@ -3729,7 +3731,7 @@
             PyObject *callable = stack_pointer[-(1 + oparg)];
             PyObject *method = stack_pointer[-(2 + oparg)];
             PyObject *res;
-            #line 2624 "Python/bytecodes.c"
+            #line 2626 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             assert(kwnames == NULL);
             /* len(o) */
@@ -3745,7 +3747,8 @@
             DEOPT_IF(callable != interp->callable_cache.len, CALL);
             STAT_INC(CALL, hit);
             PyObject *arg = args[0];
-            Py_ssize_t len_i = PyObject_Length(arg);
+            Py_ssize_t len_i;
+            CALL_WITH_NATIVE_FRAME(callable, len_i = PyObject_Length(arg));
             if (len_i < 0) {
                 goto error;
             }
@@ -3755,7 +3758,7 @@
             Py_DECREF(callable);
             Py_DECREF(arg);
             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
-            #line 3759 "Python/generated_cases.c.h"
+            #line 3762 "Python/generated_cases.c.h"
             STACK_SHRINK(oparg);
             STACK_SHRINK(1);
             stack_pointer[-1] = res;
@@ -3768,7 +3771,7 @@
             PyObject *callable = stack_pointer[-(1 + oparg)];
             PyObject *method = stack_pointer[-(2 + oparg)];
             PyObject *res;
-            #line 2652 "Python/bytecodes.c"
+            #line 2655 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             assert(kwnames == NULL);
             /* isinstance(o, o2) */
@@ -3785,6 +3788,7 @@
             STAT_INC(CALL, hit);
             PyObject *cls = args[1];
             PyObject *inst = args[0];
+
             int retval = PyObject_IsInstance(inst, cls);
             if (retval < 0) {
                 goto error;
@@ -3796,7 +3800,7 @@
             Py_DECREF(cls);
             Py_DECREF(callable);
             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
-            #line 3800 "Python/generated_cases.c.h"
+            #line 3804 "Python/generated_cases.c.h"
             STACK_SHRINK(oparg);
             STACK_SHRINK(1);
             stack_pointer[-1] = res;
@@ -3808,7 +3812,7 @@
             PyObject **args = (stack_pointer - oparg);
             PyObject *self = stack_pointer[-(1 + oparg)];
             PyObject *method = stack_pointer[-(2 + oparg)];
-            #line 2683 "Python/bytecodes.c"
+            #line 2687 "Python/bytecodes.c"
             assert(cframe.use_tracing == 0);
             assert(kwnames == NULL);
             assert(oparg == 1);
@@ -3827,14 +3831,14 @@
             JUMPBY(INLINE_CACHE_ENTRIES_CALL + 1);
             assert(next_instr[-1].op.code == POP_TOP);
             DISPATCH();
-            #line 3831 "Python/generated_cases.c.h"
+            #line 3835 "Python/generated_cases.c.h"
         }
 
         TARGET(CALL_NO_KW_METHOD_DESCRIPTOR_O) {
             PyObject **args = (stack_pointer - oparg);
             PyObject *method = stack_pointer[-(2 + oparg)];
             PyObject *res;
-            #line 2704 "Python/bytecodes.c"
+            #line 2708 "Python/bytecodes.c"
             assert(kwnames == NULL);
             int is_meth = method != NULL;
             int total_args = oparg;
@@ -3865,7 +3869,7 @@
             Py_DECREF(arg);
             Py_DECREF(callable);
             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
-            #line 3869 "Python/generated_cases.c.h"
+            #line 3873 "Python/generated_cases.c.h"
             STACK_SHRINK(oparg);
             STACK_SHRINK(1);
             stack_pointer[-1] = res;
@@ -3878,7 +3882,7 @@
             PyObject **args = (stack_pointer - oparg);
             PyObject *method = stack_pointer[-(2 + oparg)];
             PyObject *res;
-            #line 2738 "Python/bytecodes.c"
+            #line 2742 "Python/bytecodes.c"
             int is_meth = method != NULL;
             int total_args = oparg;
             if (is_meth) {
@@ -3907,7 +3911,7 @@
             }
             Py_DECREF(callable);
             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
-            #line 3911 "Python/generated_cases.c.h"
+            #line 3915 "Python/generated_cases.c.h"
             STACK_SHRINK(oparg);
             STACK_SHRINK(1);
             stack_pointer[-1] = res;
@@ -3920,7 +3924,7 @@
             PyObject **args = (stack_pointer - oparg);
             PyObject *method = stack_pointer[-(2 + oparg)];
             PyObject *res;
-            #line 2770 "Python/bytecodes.c"
+            #line 2774 "Python/bytecodes.c"
             assert(kwnames == NULL);
             assert(oparg == 0 || oparg == 1);
             int is_meth = method != NULL;
@@ -3949,7 +3953,7 @@
             Py_DECREF(self);
             Py_DECREF(callable);
             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
-            #line 3953 "Python/generated_cases.c.h"
+            #line 3957 "Python/generated_cases.c.h"
             STACK_SHRINK(oparg);
             STACK_SHRINK(1);
             stack_pointer[-1] = res;
@@ -3962,7 +3966,7 @@
             PyObject **args = (stack_pointer - oparg);
             PyObject *method = stack_pointer[-(2 + oparg)];
             PyObject *res;
-            #line 2802 "Python/bytecodes.c"
+            #line 2806 "Python/bytecodes.c"
             assert(kwnames == NULL);
             int is_meth = method != NULL;
             int total_args = oparg;
@@ -3990,7 +3994,7 @@
             }
             Py_DECREF(callable);
             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
-            #line 3994 "Python/generated_cases.c.h"
+            #line 3998 "Python/generated_cases.c.h"
             STACK_SHRINK(oparg);
             STACK_SHRINK(1);
             stack_pointer[-1] = res;
@@ -4005,7 +4009,7 @@
             PyObject *callargs = stack_pointer[-(1 + ((oparg & 1) ? 1 : 0))];
             PyObject *func = stack_pointer[-(2 + ((oparg & 1) ? 1 : 0))];
             PyObject *result;
-            #line 2833 "Python/bytecodes.c"
+            #line 2837 "Python/bytecodes.c"
             if (oparg & 1) {
                 // DICT_MERGE is called before this opcode if there are kwargs.
                 // It converts all dict subtypes in kwargs into regular dicts.
@@ -4024,15 +4028,15 @@
             assert(PyTuple_CheckExact(callargs));
 
             result = do_call_core(tstate, func, callargs, kwargs, cframe.use_tracing);
-            #line 4028 "Python/generated_cases.c.h"
+            #line 4032 "Python/generated_cases.c.h"
             Py_DECREF(func);
             Py_DECREF(callargs);
             Py_XDECREF(kwargs);
-            #line 2852 "Python/bytecodes.c"
+            #line 2856 "Python/bytecodes.c"
 
             assert(PEEK(3 + (oparg & 1)) == NULL);
             if (result == NULL) { STACK_SHRINK(((oparg & 1) ? 1 : 0)); goto pop_3_error; }
-            #line 4036 "Python/generated_cases.c.h"
+            #line 4040 "Python/generated_cases.c.h"
             STACK_SHRINK(((oparg & 1) ? 1 : 0));
             STACK_SHRINK(2);
             stack_pointer[-1] = result;
@@ -4047,7 +4051,7 @@
             PyObject *kwdefaults = (oparg & 0x02) ? stack_pointer[-(1 + ((oparg & 0x08) ? 1 : 0) + ((oparg & 0x04) ? 1 : 0) + ((oparg & 0x02) ? 1 : 0))] : NULL;
             PyObject *defaults = (oparg & 0x01) ? stack_pointer[-(1 + ((oparg & 0x08) ? 1 : 0) + ((oparg & 0x04) ? 1 : 0) + ((oparg & 0x02) ? 1 : 0) + ((oparg & 0x01) ? 1 : 0))] : NULL;
             PyObject *func;
-            #line 2863 "Python/bytecodes.c"
+            #line 2867 "Python/bytecodes.c"
 
             PyFunctionObject *func_obj = (PyFunctionObject *)
                 PyFunction_New(codeobj, GLOBALS());
@@ -4076,14 +4080,14 @@
 
             func_obj->func_version = ((PyCodeObject *)codeobj)->co_version;
             func = (PyObject *)func_obj;
-            #line 4080 "Python/generated_cases.c.h"
+            #line 4084 "Python/generated_cases.c.h"
             STACK_SHRINK(((oparg & 0x01) ? 1 : 0) + ((oparg & 0x02) ? 1 : 0) + ((oparg & 0x04) ? 1 : 0) + ((oparg & 0x08) ? 1 : 0));
             stack_pointer[-1] = func;
             DISPATCH();
         }
 
         TARGET(RETURN_GENERATOR) {
-            #line 2894 "Python/bytecodes.c"
+            #line 2898 "Python/bytecodes.c"
             assert(PyFunction_Check(frame->f_funcobj));
             PyFunctionObject *func = (PyFunctionObject *)frame->f_funcobj;
             PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func);
@@ -4099,12 +4103,13 @@
             gen_frame->owner = FRAME_OWNED_BY_GENERATOR;
             _Py_LeaveRecursiveCallPy(tstate);
             assert(frame != &entry_frame);
-            _PyInterpreterFrame *prev = frame->previous;
+            _PyInterpreterFrame *prev = (_PyInterpreterFrame *)frame->base.previous;
             _PyThreadState_PopFrame(tstate, frame);
-            frame = cframe.current_frame = prev;
+            frame = prev;
+            cframe.current_frame = &prev->base;
             _PyFrame_StackPush(frame, (PyObject *)gen);
             goto resume_frame;
-            #line 4108 "Python/generated_cases.c.h"
+            #line 4113 "Python/generated_cases.c.h"
         }
 
         TARGET(BUILD_SLICE) {
@@ -4112,15 +4117,15 @@
             PyObject *stop = stack_pointer[-(1 + ((oparg == 3) ? 1 : 0))];
             PyObject *start = stack_pointer[-(2 + ((oparg == 3) ? 1 : 0))];
             PyObject *slice;
-            #line 2917 "Python/bytecodes.c"
+            #line 2922 "Python/bytecodes.c"
             slice = PySlice_New(start, stop, step);
-            #line 4118 "Python/generated_cases.c.h"
+            #line 4123 "Python/generated_cases.c.h"
             Py_DECREF(start);
             Py_DECREF(stop);
             Py_XDECREF(step);
-            #line 2919 "Python/bytecodes.c"
+            #line 2924 "Python/bytecodes.c"
             if (slice == NULL) { STACK_SHRINK(((oparg == 3) ? 1 : 0)); goto pop_2_error; }
-            #line 4124 "Python/generated_cases.c.h"
+            #line 4129 "Python/generated_cases.c.h"
             STACK_SHRINK(((oparg == 3) ? 1 : 0));
             STACK_SHRINK(1);
             stack_pointer[-1] = slice;
@@ -4131,7 +4136,7 @@
             PyObject *fmt_spec = ((oparg & FVS_MASK) == FVS_HAVE_SPEC) ? stack_pointer[-((((oparg & FVS_MASK) == FVS_HAVE_SPEC) ? 1 : 0))] : NULL;
             PyObject *value = stack_pointer[-(1 + (((oparg & FVS_MASK) == FVS_HAVE_SPEC) ? 1 : 0))];
             PyObject *result;
-            #line 2923 "Python/bytecodes.c"
+            #line 2928 "Python/bytecodes.c"
             /* Handles f-string value formatting. */
             PyObject *(*conv_fn)(PyObject *);
             int which_conversion = oparg & FVC_MASK;
@@ -4166,7 +4171,7 @@
             Py_DECREF(value);
             Py_XDECREF(fmt_spec);
             if (result == NULL) { STACK_SHRINK((((oparg & FVS_MASK) == FVS_HAVE_SPEC) ? 1 : 0)); goto pop_1_error; }
-            #line 4170 "Python/generated_cases.c.h"
+            #line 4175 "Python/generated_cases.c.h"
             STACK_SHRINK((((oparg & FVS_MASK) == FVS_HAVE_SPEC) ? 1 : 0));
             stack_pointer[-1] = result;
             DISPATCH();
@@ -4175,10 +4180,10 @@
         TARGET(COPY) {
             PyObject *bottom = stack_pointer[-(1 + (oparg-1))];
             PyObject *top;
-            #line 2960 "Python/bytecodes.c"
+            #line 2965 "Python/bytecodes.c"
             assert(oparg > 0);
             top = Py_NewRef(bottom);
-            #line 4182 "Python/generated_cases.c.h"
+            #line 4187 "Python/generated_cases.c.h"
             STACK_GROW(1);
             stack_pointer[-1] = top;
             DISPATCH();
@@ -4190,7 +4195,7 @@
             PyObject *rhs = stack_pointer[-1];
             PyObject *lhs = stack_pointer[-2];
             PyObject *res;
-            #line 2965 "Python/bytecodes.c"
+            #line 2970 "Python/bytecodes.c"
             #if ENABLE_SPECIALIZATION
             _PyBinaryOpCache *cache = (_PyBinaryOpCache *)next_instr;
             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
@@ -4206,12 +4211,12 @@
             assert((unsigned)oparg < Py_ARRAY_LENGTH(binary_ops));
             assert(binary_ops[oparg]);
             res = binary_ops[oparg](lhs, rhs);
-            #line 4210 "Python/generated_cases.c.h"
+            #line 4215 "Python/generated_cases.c.h"
             Py_DECREF(lhs);
             Py_DECREF(rhs);
-            #line 2981 "Python/bytecodes.c"
+            #line 2986 "Python/bytecodes.c"
             if (res == NULL) goto pop_2_error;
-            #line 4215 "Python/generated_cases.c.h"
+            #line 4220 "Python/generated_cases.c.h"
             STACK_SHRINK(1);
             stack_pointer[-1] = res;
             next_instr += 1;
@@ -4221,27 +4226,27 @@
         TARGET(SWAP) {
             PyObject *top = stack_pointer[-1];
             PyObject *bottom = stack_pointer[-(2 + (oparg-2))];
-            #line 2986 "Python/bytecodes.c"
+            #line 2991 "Python/bytecodes.c"
             assert(oparg >= 2);
-            #line 4227 "Python/generated_cases.c.h"
+            #line 4232 "Python/generated_cases.c.h"
             stack_pointer[-1] = bottom;
             stack_pointer[-(2 + (oparg-2))] = top;
             DISPATCH();
         }
 
         TARGET(EXTENDED_ARG) {
-            #line 2990 "Python/bytecodes.c"
+            #line 2995 "Python/bytecodes.c"
             assert(oparg);
             assert(cframe.use_tracing == 0);
             opcode = next_instr->op.code;
             oparg = oparg << 8 | next_instr->op.arg;
             PRE_DISPATCH_GOTO();
             DISPATCH_GOTO();
-            #line 4241 "Python/generated_cases.c.h"
+            #line 4246 "Python/generated_cases.c.h"
         }
 
         TARGET(CACHE) {
-            #line 2999 "Python/bytecodes.c"
+            #line 3004 "Python/bytecodes.c"
             Py_UNREACHABLE();
-            #line 4247 "Python/generated_cases.c.h"
+            #line 4252 "Python/generated_cases.c.h"
         }
diff --git a/Python/intrinsics.c b/Python/intrinsics.c
index cca29d859902a4..f730c174f65a86 100644
--- a/Python/intrinsics.c
+++ b/Python/intrinsics.c
@@ -123,7 +123,8 @@ import_all_from(PyThreadState *tstate, PyObject *locals, PyObject *v)
 static PyObject *
 import_star(PyThreadState* tstate, PyObject *from)
 {
-    _PyInterpreterFrame *frame = tstate->cframe->current_frame;
+    _PyInterpreterFrame *frame = (_PyInterpreterFrame *)tstate->cframe->current_frame;
+    assert(PyCode_Check(frame->base.f_executable));
     if (_PyFrame_FastToLocalsWithError(frame) < 0) {
         return NULL;
     }
@@ -145,20 +146,21 @@ import_star(PyThreadState* tstate, PyObject *from)
 static PyObject *
 stopiteration_error(PyThreadState* tstate, PyObject *exc)
 {
-    _PyInterpreterFrame *frame = tstate->cframe->current_frame;
+    _PyInterpreterFrame *frame = (_PyInterpreterFrame *)tstate->cframe->current_frame;
+    assert(PyCode_Check(frame->base.f_executable));
     assert(frame->owner == FRAME_OWNED_BY_GENERATOR);
     assert(PyExceptionInstance_Check(exc));
     const char *msg = NULL;
     if (PyErr_GivenExceptionMatches(exc, PyExc_StopIteration)) {
         msg = "generator raised StopIteration";
-        if (frame->f_code->co_flags & CO_ASYNC_GENERATOR) {
+        if (_PyFrame_GetCode(frame)->co_flags & CO_ASYNC_GENERATOR) {
             msg = "async generator raised StopIteration";
         }
-        else if (frame->f_code->co_flags & CO_COROUTINE) {
+        else if (_PyFrame_GetCode(frame)->co_flags & CO_COROUTINE) {
             msg = "coroutine raised StopIteration";
         }
     }
-    else if ((frame->f_code->co_flags & CO_ASYNC_GENERATOR) &&
+    else if ((_PyFrame_GetCode(frame)->co_flags & CO_ASYNC_GENERATOR) &&
             PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration))
     {
         /* code in `gen` raised a StopAsyncIteration error:
diff --git a/Python/perf_trampoline.c b/Python/perf_trampoline.c
index 1957ab82c33951..a4ab2e6e2a3f80 100644
--- a/Python/perf_trampoline.c
+++ b/Python/perf_trampoline.c
@@ -377,7 +377,7 @@ py_trampoline_evaluator(PyThreadState *ts, _PyInterpreterFrame *frame,
         perf_status == PERF_STATUS_NO_INIT) {
         goto default_eval;
     }
-    PyCodeObject *co = frame->f_code;
+    PyCodeObject *co = _PyFrame_GetCode(frame);
     py_trampoline f = NULL;
     assert(extra_code_index != -1);
     int ret = _PyCode_GetExtra((PyObject *)co, extra_code_index, (void **)&f);
diff --git a/Python/pystate.c b/Python/pystate.c
index 394b12d24065f2..345d8ff8437adf 100644
--- a/Python/pystate.c
+++ b/Python/pystate.c
@@ -2004,8 +2004,8 @@ _PyThread_CurrentFrames(void)
     for (i = runtime->interpreters.head; i != NULL; i = i->next) {
         PyThreadState *t;
         for (t = i->threads.head; t != NULL; t = t->next) {
-            _PyInterpreterFrame *frame = t->cframe->current_frame;
-            frame = _PyFrame_GetFirstComplete(frame);
+            _PyInterpreterFrame *frame =
+                _PyFrame_GetFirstComplete(t->cframe->current_frame);
             if (frame == NULL) {
                 continue;
             }
diff --git a/Python/sysmodule.c b/Python/sysmodule.c
index 4afb0f1d0b5ed2..13fbe5d2f16981 100644
--- a/Python/sysmodule.c
+++ b/Python/sysmodule.c
@@ -1897,16 +1897,11 @@ sys__getframe_impl(PyObject *module, int depth)
 /*[clinic end generated code: output=d438776c04d59804 input=c1be8a6464b11ee5]*/
 {
     PyThreadState *tstate = _PyThreadState_GET();
-    _PyInterpreterFrame *frame = tstate->cframe->current_frame;
+    _PyInterpreterFrame *frame = _PyFrame_GetFirstComplete(tstate->cframe->current_frame);
 
-    if (frame != NULL) {
-        while (depth > 0) {
-            frame = _PyFrame_GetFirstComplete(frame->previous);
-            if (frame == NULL) {
-                break;
-            }
-            --depth;
-        }
+    while (depth > 0 && frame != NULL) {
+        frame = _PyFrame_GetFirstComplete(frame->base.previous);
+        --depth;
     }
     if (frame == NULL) {
         _PyErr_SetString(tstate, PyExc_ValueError,
@@ -2210,14 +2205,14 @@ sys__getframemodulename_impl(PyObject *module, int depth)
     if (PySys_Audit("sys._getframemodulename", "i", depth) < 0) {
         return NULL;
     }
-    _PyInterpreterFrame *f = _PyThreadState_GET()->cframe->current_frame;
+    _PyFrame *f = _PyThreadState_GET()->cframe->current_frame;
     while (f && (_PyFrame_IsIncomplete(f) || depth-- > 0)) {
         f = f->previous;
     }
-    if (f == NULL || f->f_funcobj == NULL) {
+    if (f == NULL || ((_PyInterpreterFrame *)f)->f_funcobj == NULL) {
         Py_RETURN_NONE;
     }
-    PyObject *r = PyFunction_GetModule(f->f_funcobj);
+    PyObject *r = PyFunction_GetModule(((_PyInterpreterFrame *)f)->f_funcobj);
     if (!r) {
         PyErr_Clear();
         r = Py_None;
diff --git a/Python/traceback.c b/Python/traceback.c
index 097f69c76abfe1..50e0516b76a605 100644
--- a/Python/traceback.c
+++ b/Python/traceback.c
@@ -789,7 +789,7 @@ tb_displayline(PyTracebackObject* tb, PyObject *f, PyObject *filename, int linen
     }
 
     int code_offset = tb->tb_lasti;
-    PyCodeObject* code = frame->f_frame->f_code;
+    PyCodeObject* code = _PyFrame_GetCode(frame->f_frame);
     const Py_ssize_t source_line_len = PyUnicode_GET_LENGTH(source_line);
 
     int start_line;
@@ -1166,10 +1166,10 @@ _Py_DumpASCII(int fd, PyObject *text)
    This function is signal safe. */
 
 static void
-dump_frame(int fd, _PyInterpreterFrame *frame)
+dump_pyframe(int fd, _PyInterpreterFrame *frame)
 {
-    PyCodeObject *code = frame->f_code;
     PUTS(fd, "  File ");
+    PyCodeObject *code =_PyFrame_GetCode(frame);
     if (code->co_filename != NULL
         && PyUnicode_Check(code->co_filename))
     {
@@ -1201,10 +1201,39 @@ dump_frame(int fd, _PyInterpreterFrame *frame)
     PUTS(fd, "\n");
 }
 
+static void
+dump_frame(int fd, _PyFrame *f)
+{
+    PyObject * func = f->f_executable;
+    if (PyCode_Check(func)) {
+        dump_pyframe(fd, (_PyInterpreterFrame *)f);
+        return;
+    }
+    if (func == Py_None) {
+        return;
+    }
+    if (PyType_Check(func)) {
+        PUTS(fd, "  Class ");
+        PUTS(fd, ((PyTypeObject *)func)->tp_name);
+    }
+    else if (PyCFunction_Check(func)) {
+        PUTS(fd, "  Builtin function ");
+        PUTS(fd, ((PyCFunctionObject *)func)->m_ml->ml_name);
+    }
+    else if (Py_TYPE(func) == &PyMethodDescr_Type) {
+        PUTS(fd, "  Method descriptor ");
+        PUTS(fd, ((PyMethodDescrObject *)func)->d_method->ml_name);
+    }
+    else {
+        PUTS(fd, " Other");
+    }
+    PUTS(fd, "\n");
+}
+
 static void
 dump_traceback(int fd, PyThreadState *tstate, int write_header)
 {
-    _PyInterpreterFrame *frame;
+    _PyFrame *frame;
     unsigned int depth;
 
     if (write_header) {
@@ -1218,26 +1247,14 @@ dump_traceback(int fd, PyThreadState *tstate, int write_header)
     }
 
     depth = 0;
-    while (1) {
+    while (frame) {
         if (MAX_FRAME_DEPTH <= depth) {
             PUTS(fd, "  ...\n");
             break;
         }
         dump_frame(fd, frame);
         frame = frame->previous;
-        if (frame == NULL) {
-            break;
-        }
-        if (frame->owner == FRAME_OWNED_BY_CSTACK) {
-            /* Trampoline frame */
-            frame = frame->previous;
-        }
-        if (frame == NULL) {
-            break;
-        }
-        /* Can't have more than one shim frame in a row */
-        assert(frame->owner != FRAME_OWNED_BY_CSTACK);
-        depth++;
+        depth ++;
     }
 }
 
diff --git a/Tools/gdb/libpython.py b/Tools/gdb/libpython.py
index e38bd59e20a305..0ad05e22250cc6 100755
--- a/Tools/gdb/libpython.py
+++ b/Tools/gdb/libpython.py
@@ -1034,14 +1034,18 @@ def __init__(self, gdbval):
         self._gdbval = gdbval
 
         if not self.is_optimized_out():
-            self.co = self._f_code()
-            self.co_name = self.co.pyop_field('co_name')
-            self.co_filename = self.co.pyop_field('co_filename')
-
-            self.f_lasti = self._f_lasti()
-            self.co_nlocals = int_from_int(self.co.field('co_nlocals'))
-            pnames = self.co.field('co_localsplusnames')
-            self.co_localsplusnames = PyTupleObjectPtr.from_pyobject_ptr(pnames)
+            try:
+                self.co = self._f_code()
+                self.co_name = self.co.pyop_field('co_name')
+                self.co_filename = self.co.pyop_field('co_filename')
+
+                self.f_lasti = self._f_lasti()
+                self.co_nlocals = int_from_int(self.co.field('co_nlocals'))
+                pnames = self.co.field('co_localsplusnames')
+                self.co_localsplusnames = PyTupleObjectPtr.from_pyobject_ptr(pnames)
+                self._is_code = True
+            except:
+                self._is_code = False
 
     def is_optimized_out(self):
         return self._gdbval.is_optimized_out
@@ -1076,7 +1080,10 @@ def _f_builtins(self):
         return self._f_special("f_builtins")
 
     def _f_code(self):
-        return self._f_special("f_code", PyCodeObjectPtr.from_pyobject_ptr)
+        return self._f_special("f_executable", PyCodeObjectPtr.from_pyobject_ptr)
+
+    def _f_executable(self):
+        return self._f_special("f_executable", PyObjectPtr.from_pyobject_ptr)
 
     def _f_nlocalsplus(self):
         return self._f_special("nlocalsplus", int_from_int)