Refactor interpreter frame code into its own file. Improve a few names.

Author: markshannon

Include/internal/pycore_frame.h

@@ -49,7 +49,8 @@ static inline int _PyFrameHasCompleted(InterpreterFrame *f) {
 
 #define FRAME_SPECIALS_SIZE ((sizeof(InterpreterFrame)-1)/sizeof(PyObject *))
 
-void _PyFrame_TakeInterpreterFrame(PyFrameObject *f, InterpreterFrame *locals);
+InterpreterFrame *
+_PyInterpreterFrame_HeapAlloc(PyFrameConstructor *con, PyObject *locals);
 
 static inline void
 _PyFrame_InitializeSpecials(
@@ -68,17 +69,6 @@ _PyFrame_InitializeSpecials(
     frame->f_state = FRAME_CREATED;
 }
 
-static inline void
-_PyFrame_ClearSpecials(InterpreterFrame *frame)
-{
-    frame->generator = NULL;
-    Py_XDECREF(frame->frame_obj);
-    Py_XDECREF(frame->f_locals);
-    Py_DECREF(frame->f_globals);
-    Py_DECREF(frame->f_builtins);
-    Py_DECREF(frame->f_code);
-}
-
 /* Gets the pointer to the locals array
  * that precedes this frame.
  */
@@ -118,6 +108,9 @@ _PyFrame_GetFrameObject(InterpreterFrame *frame)
 int
 _PyFrame_Clear(InterpreterFrame * frame, int take);
 
+int
+_PyFrame_Traverse(InterpreterFrame *frame, visitproc visit, void *arg);
+
 int
 _PyFrame_FastToLocalsWithError(InterpreterFrame *frame);
 

Makefile.pre.in

@@ -350,6 +350,7 @@ PYTHON_OBJS=	\
 		Python/context.o \
 		Python/dynamic_annotations.o \
 		Python/errors.o \
+		Python/frame.o \
 		Python/frozenmain.o \
 		Python/future.o \
 		Python/getargs.o \

Objects/frameobject.c

@@ -671,21 +671,7 @@ frame_traverse(PyFrameObject *f, visitproc visit, void *arg)
         return 0;
     }
     assert(f->f_frame->frame_obj == NULL);
-    /* locals */
-    PyObject **locals = _PyFrame_GetLocalsArray(f->f_frame);
-    for (int i = 0; i < f->f_frame->nlocalsplus; i++) {
-        Py_VISIT(locals[i]);
-    }
-    /* stack */
-    for (int i = 0; i < f->f_frame->stackdepth; i++) {
-        Py_VISIT(f->f_frame->stack[i]);
-    }
-
-    Py_VISIT(f->f_frame->f_globals);
-    Py_VISIT(f->f_frame->f_builtins);
-    Py_VISIT(f->f_frame->f_locals);
-    Py_VISIT(f->f_frame->f_code);
-    return 0;
+    return _PyFrame_Traverse(f->f_frame, visit, arg);
 }
 
 static int
@@ -856,35 +842,6 @@ frame_alloc(InterpreterFrame *frame, int owns)
     return f;
 }
 
-void
-_PyFrame_TakeInterpreterFrame(PyFrameObject *f, InterpreterFrame *frame)
-{
-    assert(f->f_own_locals_memory == 0);
-    assert(frame->frame_obj == NULL);
-
-    f->f_own_locals_memory = 1;
-    f->f_frame = frame;
-    assert(f->f_back == NULL);
-    if (frame->previous != NULL) {
-        /* Link PyFrameObjects.f_back and remove link through InterpreterFrame.previous */
-        PyFrameObject *back = _PyFrame_GetFrameObject(frame->previous);
-        if (back == NULL) {
-            /* Memory error here. */
-            assert(_PyErr_GetTopmostException(_PyThreadState_GET())->exc_type == PyExc_MemoryError);
-            /* Nothing we can do about it */
-            PyErr_Clear();
-            _PyErr_WriteUnraisableMsg("Out of memory lazily allocating frame->f_back", NULL);
-        }
-        else {
-            f->f_back = (PyFrameObject *)Py_NewRef(back);
-        }
-        frame->previous = NULL;
-    }
-    if (!_PyObject_GC_IS_TRACKED((PyObject *)f)) {
-        _PyObject_GC_TRACK((PyObject *)f);
-    }
-}
-
 PyFrameObject* _Py_HOT_FUNCTION
 _PyFrame_New_NoTrack(InterpreterFrame *frame, int owns)
 {

Objects/genobject.c

@@ -38,21 +38,10 @@ gen_traverse(PyGenObject *gen, visitproc visit, void *arg)
     InterpreterFrame *frame = gen->gi_xframe;
     if (frame != NULL) {
         assert(frame->frame_obj == NULL || frame->frame_obj->f_own_locals_memory == 0);
-        Py_VISIT(frame->frame_obj);
-        /* locals */
-        PyObject **locals = _PyFrame_GetLocalsArray(frame);
-        for (int i = 0; i < frame->nlocalsplus; i++) {
-            Py_VISIT(locals[i]);
+        int err = _PyFrame_Traverse(frame, visit, arg);
+        if (err) {
+            return err;
         }
-        /* stack */
-        for (int i = 0; i < frame->stackdepth; i++) {
-            Py_VISIT(frame->stack[i]);
-        }
-
-        Py_VISIT(frame->f_globals);
-        Py_VISIT(frame->f_builtins);
-        Py_VISIT(frame->f_locals);
-        Py_VISIT(frame->f_code);
     }
     /* No need to visit cr_origin, because it's just tuples/str/int, so can't
        participate in a reference cycle. */

PCbuild/pythoncore.vcxproj

@@ -455,6 +455,7 @@
     <ClCompile Include="..\Python\errors.c" />
     <ClCompile Include="..\Python\fileutils.c" />
     <ClCompile Include="..\Python\formatter_unicode.c" />
+    <ClCompile Include="..\Python\frame.c" />
     <ClCompile Include="..\Python\frozen.c" />
     <ClCompile Include="..\Python\future.c" />
     <ClCompile Include="..\Python\getargs.c" />

Python/ceval.c

@@ -5113,75 +5113,6 @@ _PyEvalFramePushAndInit(PyThreadState *tstate, PyFrameConstructor *con,
     return frame;
 }
 
-PyFrameObject *
-_PyFrame_MakeAndSetFrameObject(InterpreterFrame *frame)
-{
-    assert(frame->frame_obj == NULL);
-    PyObject *error_type, *error_value, *error_traceback;
-    PyErr_Fetch(&error_type, &error_value, &error_traceback);
-    PyFrameObject *f = _PyFrame_New_NoTrack(frame, 0);
-    if (f == NULL) {
-        Py_XDECREF(error_type);
-        Py_XDECREF(error_value);
-        Py_XDECREF(error_traceback);
-    }
-    else {
-        PyErr_Restore(error_type, error_value, error_traceback);
-    }
-    frame->frame_obj = f;
-    return f;
-}
-
-static InterpreterFrame *
-copy_frame_to_heap(InterpreterFrame *frame)
-{
-
-    Py_ssize_t size = ((char*)&frame->stack[frame->stackdepth]) - (char *)_PyFrame_GetLocalsArray(frame);
-    PyObject **copy = PyMem_Malloc(size);
-    if (copy == NULL) {
-        PyErr_NoMemory();
-        return NULL;
-    }
-    PyObject **locals = _PyFrame_GetLocalsArray(frame);
-    memcpy(copy, locals, size);
-    InterpreterFrame *res = (InterpreterFrame *)(copy + frame->nlocalsplus);
-    return res;
-}
-
-int
-_PyFrame_Clear(InterpreterFrame * frame, int take)
-{
-    PyObject **localsarray = ((PyObject **)frame)-frame->nlocalsplus;
-    if (frame->frame_obj) {
-        PyFrameObject *f = frame->frame_obj;
-        frame->frame_obj = NULL;
-        if (Py_REFCNT(f) > 1) {
-            if (!take) {
-                frame = copy_frame_to_heap(frame);
-                if (frame == NULL) {
-                    return -1;
-                }
-            }
-            _PyFrame_TakeInterpreterFrame(f, frame);
-            Py_DECREF(f);
-            return 0;
-        }
-        Py_DECREF(f);
-    }
-    for (int i = 0; i < frame->nlocalsplus; i++) {
-        Py_XDECREF(localsarray[i]);
-    }
-    assert(frame->stackdepth >= 0);
-    for (int i = 0; i < frame->stackdepth; i++) {
-        Py_DECREF(frame->stack[i]);
-    }
-    _PyFrame_ClearSpecials(frame);
-    if (take) {
-        PyMem_Free(_PyFrame_GetLocalsArray(frame));
-    }
-    return 0;
-}
-
 static int
 _PyEvalFrameClearAndPop(PyThreadState *tstate, InterpreterFrame * frame)
 {

Python/frame.c

@@ -0,0 +1,135 @@
+
+#include "Python.h"
+#include "frameobject.h"
+#include "pycore_frame.h"
+#include "pycore_object.h"        // _PyObject_GC_UNTRACK()
+
+int
+_PyFrame_Traverse(InterpreterFrame *frame, visitproc visit, void *arg)
+{
+    Py_VISIT(frame->frame_obj);
+    Py_VISIT(frame->f_globals);
+    Py_VISIT(frame->f_builtins);
+    Py_VISIT(frame->f_locals);
+    Py_VISIT(frame->f_code);
+   /* locals */
+    PyObject **locals = _PyFrame_GetLocalsArray(frame);
+    for (int i = 0; i < frame->nlocalsplus; i++) {
+        Py_VISIT(locals[i]);
+    }
+    /* stack */
+    for (int i = 0; i <frame->stackdepth; i++) {
+        Py_VISIT(frame->stack[i]);
+    }
+    return 0;
+}
+
+PyFrameObject *
+_PyFrame_MakeAndSetFrameObject(InterpreterFrame *frame)
+{
+    assert(frame->frame_obj == NULL);
+    PyObject *error_type, *error_value, *error_traceback;
+    PyErr_Fetch(&error_type, &error_value, &error_traceback);
+    PyFrameObject *f = _PyFrame_New_NoTrack(frame, 0);
+    if (f == NULL) {
+        Py_XDECREF(error_type);
+        Py_XDECREF(error_value);
+        Py_XDECREF(error_traceback);
+    }
+    else {
+        PyErr_Restore(error_type, error_value, error_traceback);
+    }
+    frame->frame_obj = f;
+    return f;
+}
+
+
+static InterpreterFrame *
+copy_frame_to_heap(InterpreterFrame *frame)
+{
+
+    Py_ssize_t size = ((char*)&frame->stack[frame->stackdepth]) - (char *)_PyFrame_GetLocalsArray(frame);
+    PyObject **copy = PyMem_Malloc(size);
+    if (copy == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    PyObject **locals = _PyFrame_GetLocalsArray(frame);
+    memcpy(copy, locals, size);
+    InterpreterFrame *res = (InterpreterFrame *)(copy + frame->nlocalsplus);
+    return res;
+}
+
+static inline void
+clear_specials(InterpreterFrame *frame)
+{
+    frame->generator = NULL;
+    Py_XDECREF(frame->frame_obj);
+    Py_XDECREF(frame->f_locals);
+    Py_DECREF(frame->f_globals);
+    Py_DECREF(frame->f_builtins);
+    Py_DECREF(frame->f_code);
+}
+
+static void
+take_ownership(PyFrameObject *f, InterpreterFrame *frame)
+{
+    assert(f->f_own_locals_memory == 0);
+    assert(frame->frame_obj == NULL);
+
+    f->f_own_locals_memory = 1;
+    f->f_frame = frame;
+    assert(f->f_back == NULL);
+    if (frame->previous != NULL) {
+        /* Link PyFrameObjects.f_back and remove link through InterpreterFrame.previous */
+        PyFrameObject *back = _PyFrame_GetFrameObject(frame->previous);
+        if (back == NULL) {
+            /* Memory error here. */
+            assert(_PyErr_GetTopmostException(_PyThreadState_GET())->exc_type == PyExc_MemoryError);
+            /* Nothing we can do about it */
+            PyErr_Clear();
+            _PyErr_WriteUnraisableMsg("Out of memory lazily allocating frame->f_back", NULL);
+        }
+        else {
+            f->f_back = (PyFrameObject *)Py_NewRef(back);
+        }
+        frame->previous = NULL;
+    }
+    if (!_PyObject_GC_IS_TRACKED((PyObject *)f)) {
+        _PyObject_GC_TRACK((PyObject *)f);
+    }
+}
+
+int
+_PyFrame_Clear(InterpreterFrame * frame, int take)
+{
+    PyObject **localsarray = ((PyObject **)frame)-frame->nlocalsplus;
+    if (frame->frame_obj) {
+        PyFrameObject *f = frame->frame_obj;
+        frame->frame_obj = NULL;
+        if (Py_REFCNT(f) > 1) {
+            if (!take) {
+                frame = copy_frame_to_heap(frame);
+                if (frame == NULL) {
+                    return -1;
+                }
+            }
+            take_ownership(f, frame);
+            Py_DECREF(f);
+            return 0;
+        }
+        Py_DECREF(f);
+    }
+    for (int i = 0; i < frame->nlocalsplus; i++) {
+        Py_XDECREF(localsarray[i]);
+    }
+    assert(frame->stackdepth >= 0);
+    for (int i = 0; i < frame->stackdepth; i++) {
+        Py_DECREF(frame->stack[i]);
+    }
+    clear_specials(frame);
+    if (take) {
+        PyMem_Free(_PyFrame_GetLocalsArray(frame));
+    }
+    return 0;
+}