#include "Python.h"

#include "pycore_ceval.h" // _PyEval_BuiltinsFromGlobals()

#include "pycore_code.h" // CO_FAST_LOCAL, etc.

#include "pycore_function.h" // _PyFunction_FromConstructor()

#include "pycore_moduleobject.h" // _PyModule_GetDict()

#include "pycore_object.h" // _PyObject_GC_UNTRACK()

#include "pycore_opcode_metadata.h" // _PyOpcode_Deopt, _PyOpcode_Caches

#include "frameobject.h" // PyFrameObject

#include "pycore_frame.h"

#include "opcode.h" // EXTENDED_ARG

#define OFF(x) offsetof(PyFrameObject, x)

static PyMemberDef frame_memberlist[] = {

{"f_trace_lines", Py_T_BOOL, OFF(f_trace_lines), 0},

{NULL} /* Sentinel */

};

static PyObject *

frame_getlocals(PyFrameObject *f, void *closure)

{

if (f == NULL) {

PyErr_BadInternalCall();

return NULL;

}

assert(!_PyFrame_IsIncomplete(f->f_frame));

PyObject *locals = _PyFrame_GetLocals(f->f_frame, 1);

if (locals) {

f->f_fast_as_locals = 1;

}

return locals;

}

PyFrame_GetLineNumber(PyFrameObject *f)

{

assert(f != NULL);

if (f->f_lineno != 0) {

return f->f_lineno;

}

else {

return PyUnstable_InterpreterFrame_GetLine(f->f_frame);

}

}

static PyObject *

frame_getlineno(PyFrameObject *f, void *closure)

{

int lineno = PyFrame_GetLineNumber(f);

if (lineno < 0) {

Py_RETURN_NONE;

}

else {

return PyLong_FromLong(lineno);

}

}

static PyObject *

frame_getlasti(PyFrameObject *f, void *closure)

{

int lasti = _PyInterpreterFrame_LASTI(f->f_frame);

if (lasti < 0) {

return PyLong_FromLong(-1);

}

return PyLong_FromLong(lasti * sizeof(_Py_CODEUNIT));

}

static PyObject *

frame_getglobals(PyFrameObject *f, void *closure)

{

PyObject *globals = f->f_frame->f_globals;

if (globals == NULL) {

globals = Py_None;

}

return Py_NewRef(globals);

}

static PyObject *

frame_getbuiltins(PyFrameObject *f, void *closure)

{

PyObject *builtins = f->f_frame->f_builtins;

if (builtins == NULL) {

builtins = Py_None;

}

return Py_NewRef(builtins);

}

static PyObject *

frame_getcode(PyFrameObject *f, void *closure)

{

if (PySys_Audit("object.__getattr__", "Os", f, "f_code") < 0) {

return NULL;

}

return (PyObject *)PyFrame_GetCode(f);

}

static PyObject *

frame_getback(PyFrameObject *f, void *closure)

{

PyObject *res = (PyObject *)PyFrame_GetBack(f);

if (res == NULL) {

Py_RETURN_NONE;

}

return res;

}

static PyObject *

frame_gettrace_opcodes(PyFrameObject *f, void *closure)

{

PyObject *result = f->f_trace_opcodes ? Py_True : Py_False;

return Py_NewRef(result);

}

static int

frame_settrace_opcodes(PyFrameObject *f, PyObject* value, void *Py_UNUSED(ignored))

{

if (!PyBool_Check(value)) {

PyErr_SetString(PyExc_TypeError,

"attribute value type must be bool");

return -1;

}

if (value == Py_True) {

f->f_trace_opcodes = 1;

_PyInterpreterState_GET()->f_opcode_trace_set = true;

}

else {

f->f_trace_opcodes = 0;

}

return 0;

}

typedef enum kind {

} Kind;

static int

compatible_kind(Kind from, Kind to) {

if (to == 0) {

return 0;

}

if (to == Object) {

return from != Null;

}

if (to == Null) {

return 1;

}

return from == to;

}

#define BITS_PER_BLOCK 3

#define UNINITIALIZED -2

#define OVERFLOWED -1

#define MAX_STACK_ENTRIES (63/BITS_PER_BLOCK)

#define WILL_OVERFLOW (1ULL<<((MAX_STACK_ENTRIES-1)*BITS_PER_BLOCK))

#define EMPTY_STACK 0

static inline int64_t

push_value(int64_t stack, Kind kind)

{

if (((uint64_t)stack) >= WILL_OVERFLOW) {

return OVERFLOWED;

}

else {

return (stack << BITS_PER_BLOCK) | kind;

}

}

static inline int64_t

pop_value(int64_t stack)

{

return Py_ARITHMETIC_RIGHT_SHIFT(int64_t, stack, BITS_PER_BLOCK);

}

#define MASK ((1<<BITS_PER_BLOCK)-1)

static inline Kind

top_of_stack(int64_t stack)

{

return stack & MASK;

}

static inline Kind

peek(int64_t stack, int n)

{

assert(n >= 1);

return (stack>>(BITS_PER_BLOCK*(n-1))) & MASK;

}

static Kind

stack_swap(int64_t stack, int n)

{

assert(n >= 1);

Kind to_swap = peek(stack, n);

Kind top = top_of_stack(stack);

int shift = BITS_PER_BLOCK*(n-1);

int64_t replaced_low = (stack & ~(MASK << shift)) | (top << shift);

int64_t replaced_top = (replaced_low & ~MASK) | to_swap;

return replaced_top;

}

static int64_t

pop_to_level(int64_t stack, int level) {

if (level == 0) {

return EMPTY_STACK;

}

int64_t max_item = (1<<BITS_PER_BLOCK) - 1;

int64_t level_max_stack = max_item << ((level-1) * BITS_PER_BLOCK);

while (stack > level_max_stack) {

stack = pop_value(stack);

}

return stack;

}

#if 0

static char

tos_char(int64_t stack) {

switch(top_of_stack(stack)) {

case Iterator:

return 'I';

case Except:

return 'E';

case Object:

return 'O';

case Lasti:

return 'L';

case Null:

return 'N';

}

return '?';

}

static void

print_stack(int64_t stack) {

if (stack < 0) {

if (stack == UNINITIALIZED) {

printf("---");

}

else if (stack == OVERFLOWED) {

printf("OVERFLOWED");

}

else {

printf("??");

}

return;

}

while (stack) {

printf("%c", tos_char(stack));

stack = pop_value(stack);

}

}

static void

print_stacks(int64_t *stacks, int n) {

for (int i = 0; i < n; i++) {

printf("%d: ", i);

print_stack(stacks[i]);

printf("\n");

}

}

static int64_t *

mark_stacks(PyCodeObject *code_obj, int len)

{

PyObject *co_code = _PyCode_GetCode(code_obj);

if (co_code == NULL) {

return NULL;

}

_Py_CODEUNIT *code = (_Py_CODEUNIT *)PyBytes_AS_STRING(co_code);

int64_t *stacks = PyMem_New(int64_t, len+1);

int i, j, opcode;

if (stacks == NULL) {

PyErr_NoMemory();

Py_DECREF(co_code);

return NULL;

}

for (int i = 1; i <= len; i++) {

stacks[i] = UNINITIALIZED;

}

stacks[0] = EMPTY_STACK;

if (code_obj->co_flags & (CO_GENERATOR | CO_COROUTINE | CO_ASYNC_GENERATOR))

{

// Generators get sent None while starting:

stacks[0] = push_value(stacks[0], Object);

}

int todo = 1;

while (todo) {

todo = 0;

/* Scan instructions */

for (i = 0; i < len;) {

int64_t next_stack = stacks[i];

opcode = _Py_GetBaseOpcode(code_obj, i);

int oparg = 0;

while (opcode == EXTENDED_ARG) {

oparg = (oparg << 8) | code[i].op.arg;

i++;

opcode = _Py_GetBaseOpcode(code_obj, i);

stacks[i] = next_stack;

}

int next_i = i + _PyOpcode_Caches[opcode] + 1;

if (next_stack == UNINITIALIZED) {

i = next_i;

continue;

}

oparg = (oparg << 8) | code[i].op.arg;

switch (opcode) {

case POP_JUMP_IF_FALSE:

case POP_JUMP_IF_TRUE:

case POP_JUMP_IF_NONE:

case POP_JUMP_IF_NOT_NONE:

{

int64_t target_stack;

int j = next_i + oparg;

assert(j < len);

next_stack = pop_value(next_stack);

target_stack = next_stack;

assert(stacks[j] == UNINITIALIZED || stacks[j] == target_stack);

stacks[j] = target_stack;

stacks[next_i] = next_stack;

break;

}

case SEND:

j = oparg + i + INLINE_CACHE_ENTRIES_SEND + 1;

assert(j < len);

assert(stacks[j] == UNINITIALIZED || stacks[j] == next_stack);

stacks[j] = next_stack;

stacks[next_i] = next_stack;

break;

case JUMP_FORWARD:

j = oparg + i + 1;

assert(j < len);

assert(stacks[j] == UNINITIALIZED || stacks[j] == next_stack);

stacks[j] = next_stack;

break;

case JUMP_BACKWARD:

case JUMP_BACKWARD_NO_INTERRUPT:

j = next_i - oparg;

assert(j >= 0);

assert(j < len);

if (stacks[j] == UNINITIALIZED && j < i) {

todo = 1;

}

assert(stacks[j] == UNINITIALIZED || stacks[j] == next_stack);

stacks[j] = next_stack;

break;

case GET_ITER:

case GET_AITER:

next_stack = push_value(pop_value(next_stack), Iterator);

stacks[next_i] = next_stack;

break;

case FOR_ITER:

{

int64_t target_stack = push_value(next_stack, Object);

stacks[next_i] = target_stack;

j = oparg + 1 + INLINE_CACHE_ENTRIES_FOR_ITER + i;

assert(j < len);

assert(stacks[j] == UNINITIALIZED || stacks[j] == target_stack);

stacks[j] = target_stack;

break;

}

case END_ASYNC_FOR:

next_stack = pop_value(pop_value(next_stack));

stacks[next_i] = next_stack;

break;

case PUSH_EXC_INFO:

next_stack = push_value(next_stack, Except);

stacks[next_i] = next_stack;

break;

case POP_EXCEPT:

assert(top_of_stack(next_stack) == Except);

next_stack = pop_value(next_stack);

stacks[next_i] = next_stack;

break;

case RETURN_VALUE:

assert(pop_value(next_stack) == EMPTY_STACK);

assert(top_of_stack(next_stack) == Object);

break;

case RETURN_CONST:

break;

case RAISE_VARARGS:

break;

case RERAISE:

assert(top_of_stack(next_stack) == Except);

/* End of block */

break;

case PUSH_NULL:

next_stack = push_value(next_stack, Null);

stacks[next_i] = next_stack;

break;

case LOAD_GLOBAL:

{

int j = oparg;

next_stack = push_value(next_stack, Object);

if (j & 1) {

next_stack = push_value(next_stack, Null);

}

stacks[next_i] = next_stack;

break;

}

case LOAD_ATTR:

{

assert(top_of_stack(next_stack) == Object);

int j = oparg;

if (j & 1) {

next_stack = pop_value(next_stack);

next_stack = push_value(next_stack, Object);

next_stack = push_value(next_stack, Null);

}

stacks[next_i] = next_stack;

break;

}

case SWAP:

{

int n = oparg;

next_stack = stack_swap(next_stack, n);

stacks[next_i] = next_stack;

break;

}

case COPY:

{

int n = oparg;

next_stack = push_value(next_stack, peek(next_stack, n));

stacks[next_i] = next_stack;

break;

}

case CACHE:

case RESERVED:

{

assert(0);

}

default:

{

int delta = PyCompile_OpcodeStackEffect(opcode, oparg);

assert(delta != PY_INVALID_STACK_EFFECT);

while (delta < 0) {

next_stack = pop_value(next_stack);

delta++;

}

while (delta > 0) {

next_stack = push_value(next_stack, Object);

delta--;

}

stacks[next_i] = next_stack;

}

}

i = next_i;

}

/* Scan exception table */

unsigned char *start = (unsigned char *)PyBytes_AS_STRING(code_obj->co_exceptiontable);

unsigned char *end = start + PyBytes_GET_SIZE(code_obj->co_exceptiontable);

unsigned char *scan = start;

while (scan < end) {

int start_offset, size, handler;

scan = parse_varint(scan, &start_offset);

assert(start_offset >= 0 && start_offset < len);

scan = parse_varint(scan, &size);

assert(size >= 0 && start_offset+size <= len);

scan = parse_varint(scan, &handler);

assert(handler >= 0 && handler < len);

int depth_and_lasti;

scan = parse_varint(scan, &depth_and_lasti);

int level = depth_and_lasti >> 1;

int lasti = depth_and_lasti & 1;

if (stacks[start_offset] != UNINITIALIZED) {

if (stacks[handler] == UNINITIALIZED) {

todo = 1;

uint64_t target_stack = pop_to_level(stacks[start_offset], level);

if (lasti) {

target_stack = push_value(target_stack, Lasti);

}

target_stack = push_value(target_stack, Except);

stacks[handler] = target_stack;

}

}

}

}

Py_DECREF(co_code);

return stacks;

}

static int

compatible_stack(int64_t from_stack, int64_t to_stack)

{

if (from_stack < 0 || to_stack < 0) {

return 0;

}

while(from_stack > to_stack) {

from_stack = pop_value(from_stack);

}

while(from_stack) {

Kind from_top = top_of_stack(from_stack);

Kind to_top = top_of_stack(to_stack);

if (!compatible_kind(from_top, to_top)) {

return 0;

}

from_stack = pop_value(from_stack);

to_stack = pop_value(to_stack);

}

return to_stack == 0;

}

static const char *

explain_incompatible_stack(int64_t to_stack)

{

assert(to_stack != 0);

if (to_stack == OVERFLOWED) {

return "stack is too deep to analyze";

}

if (to_stack == UNINITIALIZED) {

return "can't jump into an exception handler, or code may be unreachable";

}

Kind target_kind = top_of_stack(to_stack);

switch(target_kind) {

case Except:

return "can't jump into an 'except' block as there's no exception";

case Lasti:

return "can't jump into a re-raising block as there's no location";

case Object:

case Null:

return "incompatible stacks";

case Iterator:

return "can't jump into the body of a for loop";

default:

Py_UNREACHABLE();

}

}

static int *

marklines(PyCodeObject *code, int len)

{

PyCodeAddressRange bounds;

_PyCode_InitAddressRange(code, &bounds);

assert (bounds.ar_end == 0);

int last_line = -1;

int *linestarts = PyMem_New(int, len);

if (linestarts == NULL) {

return NULL;

}

for (int i = 0; i < len; i++) {

linestarts[i] = -1;

}

while (_PyLineTable_NextAddressRange(&bounds)) {

assert(bounds.ar_start / (int)sizeof(_Py_CODEUNIT) < len);

if (bounds.ar_line != last_line && bounds.ar_line != -1) {

linestarts[bounds.ar_start / sizeof(_Py_CODEUNIT)] = bounds.ar_line;

last_line = bounds.ar_line;

}

}

return linestarts;

}

static int

first_line_not_before(int *lines, int len, int line)

{

int result = INT_MAX;

for (int i = 0; i < len; i++) {

if (lines[i] < result && lines[i] >= line) {

result = lines[i];

}

}

if (result == INT_MAX) {

return -1;

}

return result;

}

static bool

frame_is_cleared(PyFrameObject *frame)

{

assert(!_PyFrame_IsIncomplete(frame->f_frame));

if (frame->f_frame->stacktop == 0) {

return true;

}

if (frame->f_frame->owner == FRAME_OWNED_BY_GENERATOR) {

PyGenObject *gen = _PyFrame_GetGenerator(frame->f_frame);

return gen->gi_frame_state == FRAME_CLEARED;

}

return false;

}

static bool frame_is_suspended(PyFrameObject *frame)

{

assert(!_PyFrame_IsIncomplete(frame->f_frame));

if (frame->f_frame->owner == FRAME_OWNED_BY_GENERATOR) {

PyGenObject *gen = _PyFrame_GetGenerator(frame->f_frame);

return gen->gi_frame_state == FRAME_SUSPENDED;

}

return false;

}

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;

}

/* f_lineno must be an integer. */

if (!PyLong_CheckExact(p_new_lineno)) {

PyErr_SetString(PyExc_ValueError,

"lineno must be an integer");

return -1;

}

bool is_suspended = frame_is_suspended(f);

/*

int what_event = PyThreadState_GET()->what_event;

if (what_event < 0) {

PyErr_Format(PyExc_ValueError,

"f_lineno can only be set in a trace function");

return -1;

}

switch (what_event) {

case PY_MONITORING_EVENT_PY_RESUME:

case PY_MONITORING_EVENT_JUMP:

case PY_MONITORING_EVENT_BRANCH:

case PY_MONITORING_EVENT_LINE:

case PY_MONITORING_EVENT_PY_YIELD:

/* Setting f_lineno is allowed for the above events */

break;

case PY_MONITORING_EVENT_PY_START:

PyErr_Format(PyExc_ValueError,

"can't jump from the 'call' trace event of a new frame");

return -1;

case PY_MONITORING_EVENT_CALL:

case PY_MONITORING_EVENT_C_RETURN:

PyErr_SetString(PyExc_ValueError,

"can't jump during a call");

return -1;

case PY_MONITORING_EVENT_PY_RETURN:

case PY_MONITORING_EVENT_PY_UNWIND:

case PY_MONITORING_EVENT_PY_THROW:

case PY_MONITORING_EVENT_RAISE:

case PY_MONITORING_EVENT_C_RAISE:

case PY_MONITORING_EVENT_INSTRUCTION:

case PY_MONITORING_EVENT_EXCEPTION_HANDLED:

PyErr_Format(PyExc_ValueError,

"can only jump from a 'line' trace event");

return -1;

default:

PyErr_SetString(PyExc_SystemError,

"unexpected event type");

return -1;

}

int new_lineno;

/* Fail if the line falls outside the code block and

int overflow;

long l_new_lineno = PyLong_AsLongAndOverflow(p_new_lineno, &overflow);

if (overflow

#if SIZEOF_LONG > SIZEOF_INT

|| l_new_lineno > INT_MAX

|| l_new_lineno < INT_MIN

) {

PyErr_SetString(PyExc_ValueError,

"lineno out of range");

return -1;

}

new_lineno = (int)l_new_lineno;

if (new_lineno < code->co_firstlineno) {

PyErr_Format(PyExc_ValueError,

"line %d comes before the current code block",

new_lineno);

return -1;

}

/* PyCode_NewWithPosOnlyArgs limits co_code to be under INT_MAX so this

int len = (int)Py_SIZE(code);

int *lines = marklines(code, len);

if (lines == NULL) {

return -1;

}

new_lineno = first_line_not_before(lines, len, new_lineno);

if (new_lineno < 0) {

PyErr_Format(PyExc_ValueError,

"line %d comes after the current code block",

(int)l_new_lineno);

PyMem_Free(lines);

return -1;

}

int64_t *stacks = mark_stacks(code, len);

if (stacks == NULL) {

PyMem_Free(lines);

return -1;

}

int64_t best_stack = OVERFLOWED;

int best_addr = -1;

int64_t start_stack = stacks[_PyInterpreterFrame_LASTI(f->f_frame)];

int err = -1;

const char *msg = "cannot find bytecode for specified line";

for (int i = 0; i < len; i++) {

if (lines[i] == new_lineno) {

int64_t target_stack = stacks[i];

if (compatible_stack(start_stack, target_stack)) {

err = 0;

if (target_stack > best_stack) {

best_stack = target_stack;

best_addr = i;

}

}

else if (err < 0) {

if (start_stack == OVERFLOWED) {

msg = "stack to deep to analyze";

}

else if (start_stack == UNINITIALIZED) {

msg = "can't jump from unreachable code";

}

else {

msg = explain_incompatible_stack(target_stack);

err = 1;

}

}

}

}

PyMem_Free(stacks);

PyMem_Free(lines);

if (err) {

PyErr_SetString(PyExc_ValueError, msg);

return -1;

}

// Populate any NULL locals that the compiler might have "proven" to exist

// in the new location. Rather than crashing or changing co_code, just bind

// None instead:

int unbound = 0;

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;

}

if (unbound) {

const char *e = "assigning None to %d unbound local%s";

const char *s = (unbound == 1) ? "" : "s";

if (PyErr_WarnFormat(PyExc_RuntimeWarning, 0, e, unbound, s)) {

return -1;

}

// 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 < code->co_nlocalsplus; i++) {

if (f->f_frame->localsplus[i] == NULL) {

f->f_frame->localsplus[i] = Py_NewRef(Py_None);

unbound--;

}

}

assert(unbound == 0);

}

if (is_suspended) {

/* Account for value popped by yield */

start_stack = pop_value(start_stack);

}

while (start_stack > best_stack) {

if (top_of_stack(start_stack) == Except) {

/* Pop exception stack as well as the evaluation stack */

PyThreadState *tstate = _PyThreadState_GET();

_PyErr_StackItem *exc_info = tstate->exc_info;

PyObject *value = exc_info->exc_value;

PyObject *exc = _PyFrame_StackPop(f->f_frame);

assert(PyExceptionInstance_Check(exc) || exc == Py_None);

exc_info->exc_value = exc;

Py_XDECREF(value);

}

else {

PyObject *v = _PyFrame_StackPop(f->f_frame);

Py_XDECREF(v);

}

start_stack = pop_value(start_stack);

}

/* Finally set the new lasti and return OK. */

f->f_lineno = 0;

f->f_frame->instr_ptr = _PyCode_CODE(code) + best_addr;

return 0;

}

static PyObject *

frame_gettrace(PyFrameObject *f, void *closure)

{

PyObject* trace = f->f_trace;

if (trace == NULL)

trace = Py_None;

return Py_NewRef(trace);

}

static int

frame_settrace(PyFrameObject *f, PyObject* v, void *closure)

{

if (v == Py_None) {

v = NULL;

}

if (v != f->f_trace) {

Py_XSETREF(f->f_trace, Py_XNewRef(v));

}

return 0;

}

static PyGetSetDef frame_getsetlist[] = {

{"f_back", (getter)frame_getback, NULL, NULL},

{"f_locals", (getter)frame_getlocals, NULL, NULL},

{"f_lineno", (getter)frame_getlineno,

(setter)frame_setlineno, NULL},

{"f_trace", (getter)frame_gettrace, (setter)frame_settrace, NULL},

{"f_lasti", (getter)frame_getlasti, NULL, NULL},

{"f_globals", (getter)frame_getglobals, NULL, NULL},

{"f_builtins", (getter)frame_getbuiltins, NULL, NULL},

{"f_code", (getter)frame_getcode, NULL, NULL},

{"f_trace_opcodes", (getter)frame_gettrace_opcodes, (setter)frame_settrace_opcodes, NULL},

{0}

};

static void

frame_dealloc(PyFrameObject *f)

{

/* It is the responsibility of the owning generator/coroutine

if (_PyObject_GC_IS_TRACKED(f)) {

_PyObject_GC_UNTRACK(f);

}

Py_TRASHCAN_BEGIN(f, frame_dealloc);

PyObject *co = NULL;

/* GH-106092: If f->f_frame was on the stack and we reached the maximum

_PyInterpreterFrame *frame = (_PyInterpreterFrame *)f->_f_frame_data;

/* Kill all local variables including specials, if we own them */

if (f->f_frame == frame && frame->owner == FRAME_OWNED_BY_FRAME_OBJECT) {

/* Don't clear code object until the end */

co = frame->f_executable;

frame->f_executable = NULL;

Py_CLEAR(frame->f_funcobj);

Py_CLEAR(frame->f_locals);

PyObject **locals = _PyFrame_GetLocalsArray(frame);

for (int i = 0; i < frame->stacktop; i++) {

Py_CLEAR(locals[i]);

}

}

Py_CLEAR(f->f_back);

Py_CLEAR(f->f_trace);

PyObject_GC_Del(f);

Py_XDECREF(co);

Py_TRASHCAN_END;

}

static int

frame_traverse(PyFrameObject *f, visitproc visit, void *arg)

{

Py_VISIT(f->f_back);

Py_VISIT(f->f_trace);

if (f->f_frame->owner != FRAME_OWNED_BY_FRAME_OBJECT) {

return 0;

}

assert(f->f_frame->frame_obj == NULL);

return _PyFrame_Traverse(f->f_frame, visit, arg);

}

static int

frame_tp_clear(PyFrameObject *f)

{

Py_CLEAR(f->f_trace);

/* locals and stack */

PyObject **locals = _PyFrame_GetLocalsArray(f->f_frame);

assert(f->f_frame->stacktop >= 0);

for (int i = 0; i < f->f_frame->stacktop; i++) {

Py_CLEAR(locals[i]);

}

f->f_frame->stacktop = 0;

return 0;

}

static PyObject *

frame_clear(PyFrameObject *f, PyObject *Py_UNUSED(ignored))

{

if (f->f_frame->owner == FRAME_OWNED_BY_GENERATOR) {

PyGenObject *gen = _PyFrame_GetGenerator(f->f_frame);

if (gen->gi_frame_state == FRAME_EXECUTING) {

goto running;

}

_PyGen_Finalize((PyObject *)gen);

}

else if (f->f_frame->owner == FRAME_OWNED_BY_THREAD) {

goto running;

}

else {

assert(f->f_frame->owner == FRAME_OWNED_BY_FRAME_OBJECT);

(void)frame_tp_clear(f);

}

Py_RETURN_NONE;

running:

PyErr_SetString(PyExc_RuntimeError,

"cannot clear an executing frame");

return NULL;

}

PyDoc_STRVAR(clear__doc__,

"F.clear(): clear most references held by the frame");

static PyObject *

frame_sizeof(PyFrameObject *f, PyObject *Py_UNUSED(ignored))

{

Py_ssize_t res;

res = offsetof(PyFrameObject, _f_frame_data) + offsetof(_PyInterpreterFrame, localsplus);

PyCodeObject *code = _PyFrame_GetCode(f->f_frame);

res += _PyFrame_NumSlotsForCodeObject(code) * sizeof(PyObject *);

return PyLong_FromSsize_t(res);

}

PyDoc_STRVAR(sizeof__doc__,

"F.__sizeof__() -> size of F in memory, in bytes");

static PyObject *

frame_repr(PyFrameObject *f)

{

int lineno = PyFrame_GetLineNumber(f);

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);

}

static PyMethodDef frame_methods[] = {

{"clear", (PyCFunction)frame_clear, METH_NOARGS,

clear__doc__},

{"__sizeof__", (PyCFunction)frame_sizeof, METH_NOARGS,

sizeof__doc__},

{NULL, NULL} /* sentinel */

};

PyTypeObject PyFrame_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"frame",

offsetof(PyFrameObject, _f_frame_data) +

offsetof(_PyInterpreterFrame, localsplus),

sizeof(PyObject *),

(destructor)frame_dealloc, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

(reprfunc)frame_repr, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */