#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.h" // _PyOpcode_Caches

#include "frameobject.h" // PyFrameObject

#include "pycore_frame.h"

#include "opcode.h" // EXTENDED_ARG

#include "structmember.h" // PyMemberDef

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

static PyMemberDef frame_memberlist[] = {

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

{"f_trace_opcodes", T_BOOL, OFF(f_trace_opcodes), 0},

{NULL} /* Sentinel */

};

static PyObject *

frame_getlocals(PyFrameObject *f, void *closure)

{

if (PyFrame_FastToLocalsWithError(f) < 0)

return NULL;

PyObject *locals = f->f_frame->f_locals;

Py_INCREF(locals);

return locals;

}

PyFrame_GetLineNumber(PyFrameObject *f)

{

assert(f != NULL);

if (f->f_lineno != 0) {

return f->f_lineno;

}

else {

return _PyInterpreterFrame_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;

}

Py_INCREF(globals);

return globals;

}

static PyObject *

frame_getbuiltins(PyFrameObject *f, void *closure)

{

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

if (builtins == NULL) {

builtins = Py_None;

}

Py_INCREF(builtins);

return 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 unsigned int

get_arg(const _Py_CODEUNIT *codestr, Py_ssize_t i)

{

_Py_CODEUNIT word;

unsigned int oparg = _Py_OPARG(codestr[i]);

if (i >= 1 && _Py_OPCODE(word = codestr[i-1]) == EXTENDED_ARG) {

oparg |= _Py_OPARG(word) << 8;

if (i >= 2 && _Py_OPCODE(word = codestr[i-2]) == EXTENDED_ARG) {

oparg |= _Py_OPARG(word) << 16;

if (i >= 3 && _Py_OPCODE(word = codestr[i-3]) == EXTENDED_ARG) {

oparg |= _Py_OPARG(word) << 24;

}

}

}

return oparg;

}

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

int64_t next_stack = stacks[i];

if (next_stack == UNINITIALIZED) {

continue;

}

opcode = _Py_OPCODE(code[i]);

switch (opcode) {

case JUMP_IF_FALSE_OR_POP:

case JUMP_IF_TRUE_OR_POP:

case POP_JUMP_IF_FALSE:

case POP_JUMP_IF_TRUE:

{

int64_t target_stack;

int j = get_arg(code, i);

j += i + 1;

assert(j < len);

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

todo = 1;

}

if (opcode == JUMP_IF_FALSE_OR_POP ||

opcode == JUMP_IF_TRUE_OR_POP)

{

target_stack = next_stack;

next_stack = pop_value(next_stack);

}

else {

next_stack = pop_value(next_stack);

target_stack = next_stack;

}

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

stacks[j] = target_stack;

stacks[i+1] = next_stack;

break;

}

case SEND:

j = get_arg(code, i) + i + 1;

assert(j < len);

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

stacks[j] = pop_value(next_stack);

stacks[i+1] = next_stack;

break;

case JUMP_FORWARD:

j = get_arg(code, i) + 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 = i + 1 - get_arg(code, i);

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[i+1] = next_stack;

break;

case FOR_ITER:

{

int64_t target_stack = push_value(next_stack, Object);

stacks[i+1] = target_stack;

j = get_arg(code, i) + 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[i+1] = next_stack;

break;

case PUSH_EXC_INFO:

next_stack = push_value(next_stack, Except);

stacks[i+1] = next_stack;

break;

case POP_EXCEPT:

assert(top_of_stack(next_stack) == Except);

next_stack = pop_value(next_stack);

stacks[i+1] = next_stack;

break;

case RETURN_VALUE:

assert(pop_value(next_stack) == EMPTY_STACK);

assert(top_of_stack(next_stack) == Object);

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[i+1] = next_stack;

break;

case LOAD_GLOBAL:

{

int j = get_arg(code, i);

if (j & 1) {

next_stack = push_value(next_stack, Null);

}

next_stack = push_value(next_stack, Object);

stacks[i+1] = next_stack;

break;

}

case LOAD_ATTR:

{

assert(top_of_stack(next_stack) == Object);

int j = get_arg(code, i);

if (j & 1) {

next_stack = pop_value(next_stack);

next_stack = push_value(next_stack, Null);

next_stack = push_value(next_stack, Object);

}

stacks[i+1] = next_stack;

break;

}

case CALL:

{

int args = get_arg(code, i);

for (int j = 0; j < args+2; j++) {

next_stack = pop_value(next_stack);

}

next_stack = push_value(next_stack, Object);

stacks[i+1] = next_stack;

break;

}

case SWAP:

{

int n = get_arg(code, i);

next_stack = stack_swap(next_stack, n);

stacks[i+1] = next_stack;

break;

}

case COPY:

{

int n = get_arg(code, i);

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

stacks[i+1] = next_stack;

break;

}

default:

{

int delta = PyCompile_OpcodeStackEffect(opcode, get_arg(code, i));

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[i+1] = next_stack;

}

}

}

/* 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 PyFrameState

_PyFrame_GetState(PyFrameObject *frame)

{

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

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

return FRAME_CLEARED;

}

switch(frame->f_frame->owner) {

case FRAME_OWNED_BY_GENERATOR:

{

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

return gen->gi_frame_state;

}

case FRAME_OWNED_BY_THREAD:

{

if (_PyInterpreterFrame_LASTI(frame->f_frame) < 0) {

return FRAME_CREATED;

}

switch (_Py_OPCODE(*frame->f_frame->prev_instr))

{

case COPY_FREE_VARS:

case MAKE_CELL:

case RETURN_GENERATOR:

/* Frame not fully initialized */

return FRAME_CREATED;

default:

return FRAME_EXECUTING;

}

}

case FRAME_OWNED_BY_FRAME_OBJECT:

return FRAME_COMPLETED;

}

Py_UNREACHABLE();

}

static void

add_load_fast_null_checks(PyCodeObject *co)

{

int changed = 0;

_Py_CODEUNIT *instructions = _PyCode_CODE(co);

for (Py_ssize_t i = 0; i < Py_SIZE(co); i++) {

int opcode = _Py_OPCODE(instructions[i]);

switch (opcode) {

case LOAD_FAST:

case LOAD_FAST__LOAD_FAST:

case LOAD_FAST__LOAD_CONST:

changed = 1;

_Py_SET_OPCODE(instructions[i], LOAD_FAST_CHECK);

break;

case LOAD_CONST__LOAD_FAST:

changed = 1;

_Py_SET_OPCODE(instructions[i], LOAD_CONST);

break;

case STORE_FAST__LOAD_FAST:

changed = 1;

_Py_SET_OPCODE(instructions[i], STORE_FAST);

break;

}

i += _PyOpcode_Caches[_PyOpcode_Deopt[opcode]];

}

if (changed && co->_co_cached != NULL) {

// invalidate cached co_code object

Py_CLEAR(co->_co_cached->_co_code);

Py_CLEAR(co->_co_cached->_co_cellvars);

Py_CLEAR(co->_co_cached->_co_freevars);

Py_CLEAR(co->_co_cached->_co_varnames);

PyMem_Free(co->_co_cached);

co->_co_cached = NULL;

}

}

static int

frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno, void *Py_UNUSED(ignored))

{

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;

}

PyFrameState state = _PyFrame_GetState(f);

/*

switch(PyThreadState_GET()->tracing_what) {

case PyTrace_EXCEPTION:

PyErr_SetString(PyExc_ValueError,

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

return -1;

case PyTrace_CALL:

PyErr_Format(PyExc_ValueError,

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

return -1;

case PyTrace_LINE:

break;

case PyTrace_RETURN:

if (state == FRAME_SUSPENDED) {

break;

}

/* fall through */

default:

PyErr_SetString(PyExc_ValueError,

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

return -1;

}

if (!f->f_trace) {

PyErr_Format(PyExc_ValueError,

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

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 < f->f_frame->f_code->co_firstlineno) {

PyErr_Format(PyExc_ValueError,

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

new_lineno);

return -1;

}

add_load_fast_null_checks(f->f_frame->f_code);

/* PyCode_NewWithPosOnlyArgs limits co_code to be under INT_MAX so this

int len = (int)Py_SIZE(f->f_frame->f_code);

int *lines = marklines(f->f_frame->f_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(f->f_frame->f_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;

}

if (state == FRAME_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->prev_instr = _PyCode_CODE(f->f_frame->f_code) + best_addr;

return 0;

}

static PyObject *

frame_gettrace(PyFrameObject *f, void *closure)

{

PyObject* trace = f->f_trace;

if (trace == NULL)

trace = Py_None;

Py_INCREF(trace);

return trace;

}

static int

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

{

if (v == Py_None) {

v = NULL;

}

Py_XINCREF(v);

Py_XSETREF(f->f_trace, 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},

{0}

};

static void

frame_dealloc(PyFrameObject *f)

{

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

assert(f->f_frame->owner != FRAME_OWNED_BY_GENERATOR ||

_PyFrame_GetGenerator(f->f_frame)->gi_frame_state == FRAME_CLEARED);

if (_PyObject_GC_IS_TRACKED(f)) {

_PyObject_GC_UNTRACK(f);

}

Py_TRASHCAN_BEGIN(f, frame_dealloc);

PyCodeObject *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;

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 = f->f_frame->f_code;

res += (code->co_nlocalsplus+code->co_stacksize) * 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 = f->f_frame->f_code;

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,