2021-05-21 06:57:35 -03:00
|
|
|
#ifndef Py_INTERNAL_FRAME_H
|
|
|
|
#define Py_INTERNAL_FRAME_H
|
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif
|
|
|
|
|
2023-08-21 14:15:52 -03:00
|
|
|
#ifndef Py_BUILD_CORE
|
|
|
|
# error "this header requires Py_BUILD_CORE define"
|
|
|
|
#endif
|
|
|
|
|
2022-01-05 07:30:26 -04:00
|
|
|
#include <stdbool.h>
|
2023-07-25 10:28:30 -03:00
|
|
|
#include <stddef.h> // offsetof()
|
|
|
|
#include "pycore_code.h" // STATS
|
2024-06-26 16:10:43 -03:00
|
|
|
#include "pycore_stackref.h" // _PyStackRef
|
2022-01-05 07:30:26 -04:00
|
|
|
|
2024-07-10 18:59:14 -03:00
|
|
|
/* See InternalDocs/frames.md for an explanation of the frame stack
|
2022-04-11 12:05:20 -03:00
|
|
|
* including explanation of the PyFrameObject and _PyInterpreterFrame
|
|
|
|
* structs. */
|
|
|
|
|
|
|
|
|
2022-02-25 07:53:19 -04:00
|
|
|
struct _frame {
|
|
|
|
PyObject_HEAD
|
|
|
|
PyFrameObject *f_back; /* previous frame, or NULL */
|
2022-02-25 11:22:00 -04:00
|
|
|
struct _PyInterpreterFrame *f_frame; /* points to the frame data */
|
2022-02-25 07:53:19 -04:00
|
|
|
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? */
|
2024-05-04 08:12:10 -03:00
|
|
|
PyObject *f_extra_locals; /* Dict for locals set by users using f_locals, could be NULL */
|
2024-07-16 16:17:47 -03:00
|
|
|
/* This is purely for backwards compatibility for PyEval_GetLocals.
|
|
|
|
PyEval_GetLocals requires a borrowed reference so the actual reference
|
|
|
|
is stored here */
|
|
|
|
PyObject *f_locals_cache;
|
2022-02-25 07:53:19 -04:00
|
|
|
/* The frame data, if this frame object owns the frame */
|
|
|
|
PyObject *_f_frame_data[1];
|
|
|
|
};
|
2021-12-09 15:59:26 -04:00
|
|
|
|
2022-02-25 11:07:14 -04:00
|
|
|
extern PyFrameObject* _PyFrame_New_NoTrack(PyCodeObject *code);
|
|
|
|
|
2021-12-09 15:59:26 -04:00
|
|
|
|
|
|
|
/* other API */
|
|
|
|
|
2022-03-22 09:57:19 -03:00
|
|
|
typedef enum _framestate {
|
2023-11-03 07:01:36 -03:00
|
|
|
FRAME_CREATED = -3,
|
|
|
|
FRAME_SUSPENDED = -2,
|
|
|
|
FRAME_SUSPENDED_YIELD_FROM = -1,
|
2021-07-26 07:22:16 -03:00
|
|
|
FRAME_EXECUTING = 0,
|
2022-03-22 09:57:19 -03:00
|
|
|
FRAME_COMPLETED = 1,
|
2021-07-26 07:22:16 -03:00
|
|
|
FRAME_CLEARED = 4
|
2022-03-22 09:57:19 -03:00
|
|
|
} PyFrameState;
|
2021-05-21 06:57:35 -03:00
|
|
|
|
2023-11-03 07:01:36 -03:00
|
|
|
#define FRAME_STATE_SUSPENDED(S) ((S) == FRAME_SUSPENDED || (S) == FRAME_SUSPENDED_YIELD_FROM)
|
2023-11-09 06:27:20 -04:00
|
|
|
#define FRAME_STATE_FINISHED(S) ((S) >= FRAME_COMPLETED)
|
2023-11-03 07:01:36 -03:00
|
|
|
|
2022-03-22 09:57:19 -03:00
|
|
|
enum _frameowner {
|
|
|
|
FRAME_OWNED_BY_THREAD = 0,
|
|
|
|
FRAME_OWNED_BY_GENERATOR = 1,
|
2022-11-10 08:34:57 -04:00
|
|
|
FRAME_OWNED_BY_FRAME_OBJECT = 2,
|
|
|
|
FRAME_OWNED_BY_CSTACK = 3,
|
2022-03-22 09:57:19 -03:00
|
|
|
};
|
2021-07-26 07:22:16 -03:00
|
|
|
|
2022-02-25 11:22:00 -04:00
|
|
|
typedef struct _PyInterpreterFrame {
|
2024-09-12 13:37:06 -03:00
|
|
|
_PyStackRef f_executable; /* Deferred or strong reference (code object or None) */
|
2023-02-13 07:31:15 -04:00
|
|
|
struct _PyInterpreterFrame *previous;
|
2024-09-24 17:08:18 -03:00
|
|
|
_PyStackRef f_funcobj; /* Deferred or strong reference. Only valid if not on C stack */
|
2023-06-08 07:41:24 -03:00
|
|
|
PyObject *f_globals; /* Borrowed reference. Only valid if not on C stack */
|
|
|
|
PyObject *f_builtins; /* Borrowed reference. Only valid if not on C stack */
|
|
|
|
PyObject *f_locals; /* Strong reference, may be NULL. Only valid if not on C stack */
|
|
|
|
PyFrameObject *frame_obj; /* Strong reference, may be NULL. Only valid if not on C stack */
|
2023-10-26 10:43:10 -03:00
|
|
|
_Py_CODEUNIT *instr_ptr; /* Instruction currently executing (or about to begin) */
|
2024-07-18 08:47:21 -03:00
|
|
|
_PyStackRef *stackpointer;
|
2023-10-26 10:43:10 -03:00
|
|
|
uint16_t return_offset; /* Only relevant during a function call */
|
2022-03-22 09:57:19 -03:00
|
|
|
char owner;
|
2022-04-11 12:05:20 -03:00
|
|
|
/* Locals and stack */
|
2024-06-26 16:10:43 -03:00
|
|
|
_PyStackRef localsplus[1];
|
2022-02-25 11:22:00 -04:00
|
|
|
} _PyInterpreterFrame;
|
2021-07-26 07:22:16 -03:00
|
|
|
|
2022-04-07 16:31:01 -03:00
|
|
|
#define _PyInterpreterFrame_LASTI(IF) \
|
2023-10-26 10:43:10 -03:00
|
|
|
((int)((IF)->instr_ptr - _PyCode_CODE(_PyFrame_GetCode(IF))))
|
2023-06-14 09:46:37 -03:00
|
|
|
|
|
|
|
static inline PyCodeObject *_PyFrame_GetCode(_PyInterpreterFrame *f) {
|
2024-09-12 13:37:06 -03:00
|
|
|
PyObject *executable = PyStackRef_AsPyObjectBorrow(f->f_executable);
|
|
|
|
assert(PyCode_Check(executable));
|
|
|
|
return (PyCodeObject *)executable;
|
2023-06-14 09:46:37 -03:00
|
|
|
}
|
2022-04-07 16:31:01 -03:00
|
|
|
|
2024-09-24 17:08:18 -03:00
|
|
|
static inline PyFunctionObject *_PyFrame_GetFunction(_PyInterpreterFrame *f) {
|
|
|
|
PyObject *func = PyStackRef_AsPyObjectBorrow(f->f_funcobj);
|
|
|
|
assert(PyFunction_Check(func));
|
|
|
|
return (PyFunctionObject *)func;
|
|
|
|
}
|
|
|
|
|
2024-06-26 16:10:43 -03:00
|
|
|
static inline _PyStackRef *_PyFrame_Stackbase(_PyInterpreterFrame *f) {
|
|
|
|
return (f->localsplus + _PyFrame_GetCode(f)->co_nlocalsplus);
|
2021-08-25 09:44:20 -03:00
|
|
|
}
|
|
|
|
|
2024-06-26 16:10:43 -03:00
|
|
|
static inline _PyStackRef _PyFrame_StackPeek(_PyInterpreterFrame *f) {
|
2024-07-18 08:47:21 -03:00
|
|
|
assert(f->stackpointer > f->localsplus + _PyFrame_GetCode(f)->co_nlocalsplus);
|
|
|
|
assert(!PyStackRef_IsNull(f->stackpointer[-1]));
|
|
|
|
return f->stackpointer[-1];
|
2021-08-25 09:44:20 -03:00
|
|
|
}
|
|
|
|
|
2024-06-26 16:10:43 -03:00
|
|
|
static inline _PyStackRef _PyFrame_StackPop(_PyInterpreterFrame *f) {
|
2024-07-18 08:47:21 -03:00
|
|
|
assert(f->stackpointer > f->localsplus + _PyFrame_GetCode(f)->co_nlocalsplus);
|
|
|
|
f->stackpointer--;
|
|
|
|
return *f->stackpointer;
|
2021-08-25 09:44:20 -03:00
|
|
|
}
|
|
|
|
|
2024-06-26 16:10:43 -03:00
|
|
|
static inline void _PyFrame_StackPush(_PyInterpreterFrame *f, _PyStackRef value) {
|
2024-07-18 08:47:21 -03:00
|
|
|
*f->stackpointer = value;
|
|
|
|
f->stackpointer++;
|
2021-08-25 09:44:20 -03:00
|
|
|
}
|
|
|
|
|
2023-01-04 09:37:06 -04:00
|
|
|
#define FRAME_SPECIALS_SIZE ((int)((sizeof(_PyInterpreterFrame)-1)/sizeof(PyObject *)))
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
_PyFrame_NumSlotsForCodeObject(PyCodeObject *code)
|
|
|
|
{
|
|
|
|
/* This function needs to remain in sync with the calculation of
|
|
|
|
* co_framesize in Tools/build/deepfreeze.py */
|
|
|
|
assert(code->co_framesize >= FRAME_SPECIALS_SIZE);
|
|
|
|
return code->co_framesize - FRAME_SPECIALS_SIZE;
|
|
|
|
}
|
2021-07-26 07:22:16 -03:00
|
|
|
|
2024-04-25 07:32:47 -03:00
|
|
|
static inline void _PyFrame_Copy(_PyInterpreterFrame *src, _PyInterpreterFrame *dest)
|
|
|
|
{
|
|
|
|
*dest = *src;
|
2024-07-18 08:47:21 -03:00
|
|
|
assert(src->stackpointer != NULL);
|
|
|
|
int stacktop = (int)(src->stackpointer - src->localsplus);
|
|
|
|
assert(stacktop >= _PyFrame_GetCode(src)->co_nlocalsplus);
|
|
|
|
dest->stackpointer = dest->localsplus + stacktop;
|
|
|
|
for (int i = 1; i < stacktop; i++) {
|
2024-04-25 07:32:47 -03:00
|
|
|
dest->localsplus[i] = src->localsplus[i];
|
|
|
|
}
|
|
|
|
// Don't leave a dangling pointer to the old frame when creating generators
|
|
|
|
// and coroutines:
|
|
|
|
dest->previous = NULL;
|
2024-08-15 13:09:11 -03:00
|
|
|
|
|
|
|
#ifdef Py_GIL_DISABLED
|
2024-09-12 13:37:06 -03:00
|
|
|
PyCodeObject *co = _PyFrame_GetCode(dest);
|
2024-08-15 13:09:11 -03:00
|
|
|
for (int i = stacktop; i < co->co_nlocalsplus + co->co_stacksize; i++) {
|
|
|
|
dest->localsplus[i] = PyStackRef_NULL;
|
|
|
|
}
|
|
|
|
#endif
|
2024-04-25 07:32:47 -03:00
|
|
|
}
|
2021-07-26 07:22:16 -03:00
|
|
|
|
2022-12-23 10:45:53 -04:00
|
|
|
/* Consumes reference to func and locals.
|
|
|
|
Does not initialize frame->previous, which happens
|
|
|
|
when frame is linked into the frame stack.
|
|
|
|
*/
|
2021-07-26 07:22:16 -03:00
|
|
|
static inline void
|
2023-01-06 10:55:56 -04:00
|
|
|
_PyFrame_Initialize(
|
2024-09-24 17:08:18 -03:00
|
|
|
_PyInterpreterFrame *frame, _PyStackRef func,
|
2024-08-20 12:52:58 -03:00
|
|
|
PyObject *locals, PyCodeObject *code, int null_locals_from, _PyInterpreterFrame *previous)
|
2021-05-21 06:57:35 -03:00
|
|
|
{
|
2024-08-20 12:52:58 -03:00
|
|
|
frame->previous = previous;
|
2024-09-24 17:08:18 -03:00
|
|
|
frame->f_funcobj = func;
|
2024-09-12 13:37:06 -03:00
|
|
|
frame->f_executable = PyStackRef_FromPyObjectNew(code);
|
2024-09-24 17:08:18 -03:00
|
|
|
PyFunctionObject *func_obj = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(func);
|
|
|
|
frame->f_builtins = func_obj->func_builtins;
|
|
|
|
frame->f_globals = func_obj->func_globals;
|
2022-06-20 08:59:25 -03:00
|
|
|
frame->f_locals = locals;
|
2024-07-18 08:47:21 -03:00
|
|
|
frame->stackpointer = frame->localsplus + code->co_nlocalsplus;
|
2021-07-26 07:22:16 -03:00
|
|
|
frame->frame_obj = NULL;
|
2023-10-26 10:43:10 -03:00
|
|
|
frame->instr_ptr = _PyCode_CODE(code);
|
2023-04-13 12:19:07 -03:00
|
|
|
frame->return_offset = 0;
|
2022-03-22 09:57:19 -03:00
|
|
|
frame->owner = FRAME_OWNED_BY_THREAD;
|
2023-01-06 10:55:56 -04:00
|
|
|
|
|
|
|
for (int i = null_locals_from; i < code->co_nlocalsplus; i++) {
|
2024-06-26 16:10:43 -03:00
|
|
|
frame->localsplus[i] = PyStackRef_NULL;
|
2023-01-06 10:55:56 -04:00
|
|
|
}
|
2024-08-15 13:09:11 -03:00
|
|
|
|
|
|
|
#ifdef Py_GIL_DISABLED
|
|
|
|
// On GIL disabled, we walk the entire stack in GC. Since stacktop
|
|
|
|
// is not always in sync with the real stack pointer, we have
|
|
|
|
// no choice but to traverse the entire stack.
|
|
|
|
// This just makes sure we don't pass the GC invalid stack values.
|
|
|
|
for (int i = code->co_nlocalsplus; i < code->co_nlocalsplus + code->co_stacksize; i++) {
|
|
|
|
frame->localsplus[i] = PyStackRef_NULL;
|
|
|
|
}
|
|
|
|
#endif
|
2021-05-21 06:57:35 -03:00
|
|
|
}
|
|
|
|
|
2021-07-26 07:22:16 -03:00
|
|
|
/* Gets the pointer to the locals array
|
|
|
|
* that precedes this frame.
|
|
|
|
*/
|
2024-06-26 16:10:43 -03:00
|
|
|
static inline _PyStackRef*
|
2022-02-25 11:22:00 -04:00
|
|
|
_PyFrame_GetLocalsArray(_PyInterpreterFrame *frame)
|
2021-05-21 06:57:35 -03:00
|
|
|
{
|
2021-08-25 09:44:20 -03:00
|
|
|
return frame->localsplus;
|
|
|
|
}
|
|
|
|
|
2024-07-18 08:47:21 -03:00
|
|
|
/* Fetches the stack pointer, and sets stackpointer to NULL.
|
|
|
|
Having stackpointer == NULL ensures that invalid
|
|
|
|
values are not visible to the cycle GC. */
|
2024-06-26 16:10:43 -03:00
|
|
|
static inline _PyStackRef*
|
2022-02-25 11:22:00 -04:00
|
|
|
_PyFrame_GetStackPointer(_PyInterpreterFrame *frame)
|
2021-08-25 09:44:20 -03:00
|
|
|
{
|
2024-07-18 08:47:21 -03:00
|
|
|
assert(frame->stackpointer != NULL);
|
|
|
|
_PyStackRef *sp = frame->stackpointer;
|
|
|
|
frame->stackpointer = NULL;
|
2023-04-12 08:04:55 -03:00
|
|
|
return sp;
|
2021-08-25 09:44:20 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
2024-06-26 16:10:43 -03:00
|
|
|
_PyFrame_SetStackPointer(_PyInterpreterFrame *frame, _PyStackRef *stack_pointer)
|
2021-08-25 09:44:20 -03:00
|
|
|
{
|
2024-07-18 08:47:21 -03:00
|
|
|
assert(frame->stackpointer == NULL);
|
|
|
|
frame->stackpointer = stack_pointer;
|
2021-05-21 06:57:35 -03:00
|
|
|
}
|
|
|
|
|
2022-07-01 07:08:20 -03:00
|
|
|
/* 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)
|
|
|
|
{
|
2023-06-14 09:46:37 -03:00
|
|
|
if (frame->owner == FRAME_OWNED_BY_CSTACK) {
|
|
|
|
return true;
|
|
|
|
}
|
2022-07-01 07:08:20 -03:00
|
|
|
return frame->owner != FRAME_OWNED_BY_GENERATOR &&
|
2023-10-26 10:43:10 -03:00
|
|
|
frame->instr_ptr < _PyCode_CODE(_PyFrame_GetCode(frame)) + _PyFrame_GetCode(frame)->_co_firsttraceable;
|
2022-07-01 07:08:20 -03:00
|
|
|
}
|
|
|
|
|
2023-01-09 16:20:04 -04:00
|
|
|
static inline _PyInterpreterFrame *
|
|
|
|
_PyFrame_GetFirstComplete(_PyInterpreterFrame *frame)
|
|
|
|
{
|
|
|
|
while (frame && _PyFrame_IsIncomplete(frame)) {
|
|
|
|
frame = frame->previous;
|
|
|
|
}
|
|
|
|
return frame;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline _PyInterpreterFrame *
|
|
|
|
_PyThreadState_GetFrame(PyThreadState *tstate)
|
|
|
|
{
|
2023-08-17 07:16:03 -03:00
|
|
|
return _PyFrame_GetFirstComplete(tstate->current_frame);
|
2023-01-09 16:20:04 -04:00
|
|
|
}
|
|
|
|
|
2021-07-26 07:22:16 -03:00
|
|
|
/* For use by _PyFrame_GetFrameObject
|
|
|
|
Do not call directly. */
|
|
|
|
PyFrameObject *
|
2022-02-25 11:22:00 -04:00
|
|
|
_PyFrame_MakeAndSetFrameObject(_PyInterpreterFrame *frame);
|
2021-07-26 07:22:16 -03:00
|
|
|
|
|
|
|
/* Gets the PyFrameObject for this frame, lazily
|
|
|
|
* creating it if necessary.
|
2024-06-20 00:16:14 -03:00
|
|
|
* Returns a borrowed reference */
|
2021-07-26 07:22:16 -03:00
|
|
|
static inline PyFrameObject *
|
2022-02-25 11:22:00 -04:00
|
|
|
_PyFrame_GetFrameObject(_PyInterpreterFrame *frame)
|
2021-06-18 07:00:29 -03:00
|
|
|
{
|
2022-07-01 07:08:20 -03:00
|
|
|
|
|
|
|
assert(!_PyFrame_IsIncomplete(frame));
|
2021-07-26 07:22:16 -03:00
|
|
|
PyFrameObject *res = frame->frame_obj;
|
|
|
|
if (res != NULL) {
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
return _PyFrame_MakeAndSetFrameObject(frame);
|
2021-06-18 07:00:29 -03:00
|
|
|
}
|
|
|
|
|
2024-04-30 15:32:25 -03:00
|
|
|
void
|
|
|
|
_PyFrame_ClearLocals(_PyInterpreterFrame *frame);
|
|
|
|
|
2021-07-26 07:22:16 -03:00
|
|
|
/* Clears all references in the frame.
|
2022-02-25 11:22:00 -04:00
|
|
|
* If take is non-zero, then the _PyInterpreterFrame frame
|
2021-10-06 15:32:38 -03:00
|
|
|
* may be transferred to the frame object it references
|
2021-07-26 07:22:16 -03:00
|
|
|
* 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.
|
|
|
|
*/
|
2021-11-29 08:34:59 -04:00
|
|
|
void
|
2023-02-23 06:19:01 -04:00
|
|
|
_PyFrame_ClearExceptCode(_PyInterpreterFrame * frame);
|
2021-07-26 07:22:16 -03:00
|
|
|
|
|
|
|
int
|
2022-02-25 11:22:00 -04:00
|
|
|
_PyFrame_Traverse(_PyInterpreterFrame *frame, visitproc visit, void *arg);
|
2021-07-26 07:22:16 -03:00
|
|
|
|
2024-05-04 08:12:10 -03:00
|
|
|
bool
|
|
|
|
_PyFrame_HasHiddenLocals(_PyInterpreterFrame *frame);
|
2021-07-26 07:22:16 -03:00
|
|
|
|
2024-05-04 08:12:10 -03:00
|
|
|
PyObject *
|
|
|
|
_PyFrame_GetLocals(_PyInterpreterFrame *frame);
|
2021-07-26 07:22:16 -03:00
|
|
|
|
2022-06-20 08:59:25 -03:00
|
|
|
static inline bool
|
|
|
|
_PyThreadState_HasStackSpace(PyThreadState *tstate, int size)
|
2021-10-28 12:14:59 -03:00
|
|
|
{
|
2022-09-06 12:45:43 -03:00
|
|
|
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;
|
2021-10-28 12:14:59 -03:00
|
|
|
}
|
|
|
|
|
2022-06-20 08:59:25 -03:00
|
|
|
extern _PyInterpreterFrame *
|
|
|
|
_PyThreadState_PushFrame(PyThreadState *tstate, size_t size);
|
|
|
|
|
2024-04-25 07:32:47 -03:00
|
|
|
PyAPI_FUNC(void) _PyThreadState_PopFrame(PyThreadState *tstate, _PyInterpreterFrame *frame);
|
2021-05-21 06:57:35 -03:00
|
|
|
|
2022-06-20 08:59:25 -03:00
|
|
|
/* Pushes a frame without checking for space.
|
|
|
|
* Must be guarded by _PyThreadState_HasStackSpace()
|
|
|
|
* Consumes reference to func. */
|
|
|
|
static inline _PyInterpreterFrame *
|
2024-09-24 17:08:18 -03:00
|
|
|
_PyFrame_PushUnchecked(PyThreadState *tstate, _PyStackRef func, int null_locals_from, _PyInterpreterFrame * previous)
|
2022-06-20 08:59:25 -03:00
|
|
|
{
|
|
|
|
CALL_STAT_INC(frames_pushed);
|
2024-09-24 17:08:18 -03:00
|
|
|
PyFunctionObject *func_obj = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(func);
|
|
|
|
PyCodeObject *code = (PyCodeObject *)func_obj->func_code;
|
2022-06-20 08:59:25 -03:00
|
|
|
_PyInterpreterFrame *new_frame = (_PyInterpreterFrame *)tstate->datastack_top;
|
|
|
|
tstate->datastack_top += code->co_framesize;
|
|
|
|
assert(tstate->datastack_top < tstate->datastack_limit);
|
2024-08-20 12:52:58 -03:00
|
|
|
_PyFrame_Initialize(new_frame, func, NULL, code, null_locals_from, previous);
|
2022-06-20 08:59:25 -03:00
|
|
|
return new_frame;
|
|
|
|
}
|
2022-01-28 08:42:30 -04:00
|
|
|
|
2023-06-22 05:48:19 -03:00
|
|
|
/* Pushes a trampoline frame without checking for space.
|
|
|
|
* Must be guarded by _PyThreadState_HasStackSpace() */
|
|
|
|
static inline _PyInterpreterFrame *
|
2024-08-20 12:52:58 -03:00
|
|
|
_PyFrame_PushTrampolineUnchecked(PyThreadState *tstate, PyCodeObject *code, int stackdepth, _PyInterpreterFrame * previous)
|
2023-06-22 05:48:19 -03:00
|
|
|
{
|
|
|
|
CALL_STAT_INC(frames_pushed);
|
|
|
|
_PyInterpreterFrame *frame = (_PyInterpreterFrame *)tstate->datastack_top;
|
|
|
|
tstate->datastack_top += code->co_framesize;
|
|
|
|
assert(tstate->datastack_top < tstate->datastack_limit);
|
2024-08-20 12:52:58 -03:00
|
|
|
frame->previous = previous;
|
2024-09-24 17:08:18 -03:00
|
|
|
frame->f_funcobj = PyStackRef_None;
|
2024-09-12 13:37:06 -03:00
|
|
|
frame->f_executable = PyStackRef_FromPyObjectNew(code);
|
2023-06-22 05:48:19 -03:00
|
|
|
#ifdef Py_DEBUG
|
|
|
|
frame->f_builtins = NULL;
|
|
|
|
frame->f_globals = NULL;
|
|
|
|
#endif
|
|
|
|
frame->f_locals = NULL;
|
2024-07-18 08:47:21 -03:00
|
|
|
assert(stackdepth <= code->co_stacksize);
|
|
|
|
frame->stackpointer = frame->localsplus + code->co_nlocalsplus + stackdepth;
|
2023-06-22 05:48:19 -03:00
|
|
|
frame->frame_obj = NULL;
|
2023-10-26 10:43:10 -03:00
|
|
|
frame->instr_ptr = _PyCode_CODE(code);
|
2023-06-22 05:48:19 -03:00
|
|
|
frame->owner = FRAME_OWNED_BY_THREAD;
|
|
|
|
frame->return_offset = 0;
|
2024-08-15 13:09:11 -03:00
|
|
|
|
|
|
|
#ifdef Py_GIL_DISABLED
|
|
|
|
assert(code->co_nlocalsplus == 0);
|
|
|
|
for (int i = 0; i < code->co_stacksize; i++) {
|
|
|
|
frame->localsplus[i] = PyStackRef_NULL;
|
|
|
|
}
|
|
|
|
#endif
|
2023-06-22 05:48:19 -03:00
|
|
|
return frame;
|
|
|
|
}
|
|
|
|
|
2024-05-04 08:11:11 -03:00
|
|
|
PyAPI_FUNC(_PyInterpreterFrame *)
|
2024-09-24 17:08:18 -03:00
|
|
|
_PyEvalFramePushAndInit(PyThreadState *tstate, _PyStackRef func,
|
2024-06-26 16:10:43 -03:00
|
|
|
PyObject *locals, _PyStackRef const* args,
|
2024-08-20 12:52:58 -03:00
|
|
|
size_t argcount, PyObject *kwnames,
|
|
|
|
_PyInterpreterFrame *previous);
|
2024-05-04 08:11:11 -03:00
|
|
|
|
2021-05-21 06:57:35 -03:00
|
|
|
#ifdef __cplusplus
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif /* !Py_INTERNAL_FRAME_H */
|