mirror of https://github.com/python/cpython
239 lines
7.4 KiB
C
239 lines
7.4 KiB
C
#ifndef Py_INTERNAL_FRAME_H
|
|
#define Py_INTERNAL_FRAME_H
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include <stdbool.h>
|
|
#include <stddef.h>
|
|
#include "pycore_code.h" // STATS
|
|
|
|
/* See Objects/frame_layout.md for an explanation of the frame stack
|
|
* including explanation of the PyFrameObject and _PyInterpreterFrame
|
|
* structs. */
|
|
|
|
|
|
struct _frame {
|
|
PyObject_HEAD
|
|
PyFrameObject *f_back; /* previous frame, or NULL */
|
|
struct _PyInterpreterFrame *f_frame; /* points to the frame data */
|
|
PyObject *f_trace; /* Trace function */
|
|
int f_lineno; /* Current line number. Only valid if non-zero */
|
|
char f_trace_lines; /* Emit per-line trace events? */
|
|
char f_trace_opcodes; /* Emit per-opcode trace events? */
|
|
char f_fast_as_locals; /* Have the fast locals of this frame been converted to a dict? */
|
|
/* The frame data, if this frame object owns the frame */
|
|
PyObject *_f_frame_data[1];
|
|
};
|
|
|
|
extern PyFrameObject* _PyFrame_New_NoTrack(PyCodeObject *code);
|
|
|
|
|
|
/* other API */
|
|
|
|
typedef enum _framestate {
|
|
FRAME_CREATED = -2,
|
|
FRAME_SUSPENDED = -1,
|
|
FRAME_EXECUTING = 0,
|
|
FRAME_COMPLETED = 1,
|
|
FRAME_CLEARED = 4
|
|
} PyFrameState;
|
|
|
|
enum _frameowner {
|
|
FRAME_OWNED_BY_THREAD = 0,
|
|
FRAME_OWNED_BY_GENERATOR = 1,
|
|
FRAME_OWNED_BY_FRAME_OBJECT = 2
|
|
};
|
|
|
|
typedef struct _PyInterpreterFrame {
|
|
/* "Specials" section */
|
|
PyObject *f_funcobj; /* Strong reference */
|
|
PyObject *f_globals; /* Borrowed reference */
|
|
PyObject *f_builtins; /* Borrowed reference */
|
|
PyObject *f_locals; /* Strong reference, may be NULL */
|
|
PyCodeObject *f_code; /* Strong reference */
|
|
PyFrameObject *frame_obj; /* Strong reference, may be NULL */
|
|
/* Linkage section */
|
|
struct _PyInterpreterFrame *previous;
|
|
// NOTE: This is not necessarily the last instruction started in the given
|
|
// frame. Rather, it is the code unit *prior to* the *next* instruction. For
|
|
// example, it may be an inline CACHE entry, an instruction we just jumped
|
|
// over, or (in the case of a newly-created frame) a totally invalid value:
|
|
_Py_CODEUNIT *prev_instr;
|
|
int stacktop; /* Offset of TOS from localsplus */
|
|
bool is_entry; // Whether this is the "root" frame for the current _PyCFrame.
|
|
char owner;
|
|
/* Locals and stack */
|
|
PyObject *localsplus[1];
|
|
} _PyInterpreterFrame;
|
|
|
|
#define _PyInterpreterFrame_LASTI(IF) \
|
|
((int)((IF)->prev_instr - _PyCode_CODE((IF)->f_code)))
|
|
|
|
static inline PyObject **_PyFrame_Stackbase(_PyInterpreterFrame *f) {
|
|
return f->localsplus + f->f_code->co_nlocalsplus;
|
|
}
|
|
|
|
static inline PyObject *_PyFrame_StackPeek(_PyInterpreterFrame *f) {
|
|
assert(f->stacktop > f->f_code->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);
|
|
f->stacktop--;
|
|
return f->localsplus[f->stacktop];
|
|
}
|
|
|
|
static inline void _PyFrame_StackPush(_PyInterpreterFrame *f, PyObject *value) {
|
|
f->localsplus[f->stacktop] = value;
|
|
f->stacktop++;
|
|
}
|
|
|
|
#define FRAME_SPECIALS_SIZE ((sizeof(_PyInterpreterFrame)-1)/sizeof(PyObject *))
|
|
|
|
void _PyFrame_Copy(_PyInterpreterFrame *src, _PyInterpreterFrame *dest);
|
|
|
|
/* Consumes reference to func and locals */
|
|
static inline void
|
|
_PyFrame_InitializeSpecials(
|
|
_PyInterpreterFrame *frame, PyFunctionObject *func,
|
|
PyObject *locals, PyCodeObject *code)
|
|
{
|
|
frame->f_funcobj = (PyObject *)func;
|
|
frame->f_code = (PyCodeObject *)Py_NewRef(code);
|
|
frame->f_builtins = func->func_builtins;
|
|
frame->f_globals = func->func_globals;
|
|
frame->f_locals = locals;
|
|
frame->stacktop = code->co_nlocalsplus;
|
|
frame->frame_obj = NULL;
|
|
frame->prev_instr = _PyCode_CODE(code) - 1;
|
|
frame->is_entry = false;
|
|
frame->owner = FRAME_OWNED_BY_THREAD;
|
|
}
|
|
|
|
/* Gets the pointer to the locals array
|
|
* that precedes this frame.
|
|
*/
|
|
static inline PyObject**
|
|
_PyFrame_GetLocalsArray(_PyInterpreterFrame *frame)
|
|
{
|
|
return frame->localsplus;
|
|
}
|
|
|
|
static inline PyObject**
|
|
_PyFrame_GetStackPointer(_PyInterpreterFrame *frame)
|
|
{
|
|
return frame->localsplus+frame->stacktop;
|
|
}
|
|
|
|
static inline void
|
|
_PyFrame_SetStackPointer(_PyInterpreterFrame *frame, PyObject **stack_pointer)
|
|
{
|
|
frame->stacktop = (int)(stack_pointer - frame->localsplus);
|
|
}
|
|
|
|
/* Determine whether a frame is incomplete.
|
|
* A frame is incomplete if it is part way through
|
|
* creating cell objects or a generator or coroutine.
|
|
*
|
|
* Frames on the frame stack are incomplete until the
|
|
* first RESUME instruction.
|
|
* Frames owned by a generator are always complete.
|
|
*/
|
|
static inline bool
|
|
_PyFrame_IsIncomplete(_PyInterpreterFrame *frame)
|
|
{
|
|
return frame->owner != FRAME_OWNED_BY_GENERATOR &&
|
|
frame->prev_instr < _PyCode_CODE(frame->f_code) + frame->f_code->_co_firsttraceable;
|
|
}
|
|
|
|
/* For use by _PyFrame_GetFrameObject
|
|
Do not call directly. */
|
|
PyFrameObject *
|
|
_PyFrame_MakeAndSetFrameObject(_PyInterpreterFrame *frame);
|
|
|
|
/* Gets the PyFrameObject for this frame, lazily
|
|
* creating it if necessary.
|
|
* Returns a borrowed referennce */
|
|
static inline PyFrameObject *
|
|
_PyFrame_GetFrameObject(_PyInterpreterFrame *frame)
|
|
{
|
|
|
|
assert(!_PyFrame_IsIncomplete(frame));
|
|
PyFrameObject *res = frame->frame_obj;
|
|
if (res != NULL) {
|
|
return res;
|
|
}
|
|
return _PyFrame_MakeAndSetFrameObject(frame);
|
|
}
|
|
|
|
/* Clears all references in the frame.
|
|
* If take is non-zero, then the _PyInterpreterFrame frame
|
|
* may be transferred to the frame object it references
|
|
* instead of being cleared. Either way
|
|
* the caller no longer owns the references
|
|
* in the frame.
|
|
* take should be set to 1 for heap allocated
|
|
* frames like the ones in generators and coroutines.
|
|
*/
|
|
void
|
|
_PyFrame_Clear(_PyInterpreterFrame * frame);
|
|
|
|
int
|
|
_PyFrame_Traverse(_PyInterpreterFrame *frame, visitproc visit, void *arg);
|
|
|
|
int
|
|
_PyFrame_FastToLocalsWithError(_PyInterpreterFrame *frame);
|
|
|
|
void
|
|
_PyFrame_LocalsToFast(_PyInterpreterFrame *frame, int clear);
|
|
|
|
static inline bool
|
|
_PyThreadState_HasStackSpace(PyThreadState *tstate, int size)
|
|
{
|
|
assert(
|
|
(tstate->datastack_top == NULL && tstate->datastack_limit == NULL)
|
|
||
|
|
(tstate->datastack_top != NULL && tstate->datastack_limit != NULL)
|
|
);
|
|
return tstate->datastack_top != NULL &&
|
|
size < tstate->datastack_limit - tstate->datastack_top;
|
|
}
|
|
|
|
extern _PyInterpreterFrame *
|
|
_PyThreadState_PushFrame(PyThreadState *tstate, size_t size);
|
|
|
|
void _PyThreadState_PopFrame(PyThreadState *tstate, _PyInterpreterFrame *frame);
|
|
|
|
/* Pushes a frame without checking for space.
|
|
* Must be guarded by _PyThreadState_HasStackSpace()
|
|
* Consumes reference to func. */
|
|
static inline _PyInterpreterFrame *
|
|
_PyFrame_PushUnchecked(PyThreadState *tstate, PyFunctionObject *func)
|
|
{
|
|
CALL_STAT_INC(frames_pushed);
|
|
PyCodeObject *code = (PyCodeObject *)func->func_code;
|
|
_PyInterpreterFrame *new_frame = (_PyInterpreterFrame *)tstate->datastack_top;
|
|
tstate->datastack_top += code->co_framesize;
|
|
assert(tstate->datastack_top < tstate->datastack_limit);
|
|
_PyFrame_InitializeSpecials(new_frame, func, NULL, code);
|
|
return new_frame;
|
|
}
|
|
|
|
int _PyInterpreterFrame_GetLine(_PyInterpreterFrame *frame);
|
|
|
|
static inline
|
|
PyGenObject *_PyFrame_GetGenerator(_PyInterpreterFrame *frame)
|
|
{
|
|
assert(frame->owner == FRAME_OWNED_BY_GENERATOR);
|
|
size_t offset_in_gen = offsetof(PyGenObject, gi_iframe);
|
|
return (PyGenObject *)(((char *)frame) - offset_in_gen);
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
#endif /* !Py_INTERNAL_FRAME_H */
|