571 lines
27 KiB
Python
571 lines
27 KiB
Python
#!/usr/bin/env python3
|
|
"""Guard C89 local ordering and frame operation order."""
|
|
import sys
|
|
from pathlib import Path
|
|
from typing import NoReturn
|
|
|
|
|
|
def fail(message: str) -> NoReturn:
|
|
print(message, file=sys.stderr)
|
|
raise SystemExit(1)
|
|
|
|
|
|
def extract_function(source: str, signature: str) -> str:
|
|
start = source.find(signature)
|
|
if start < 0:
|
|
fail(f"missing function signature: {signature}")
|
|
brace = source.find("{", start + len(signature))
|
|
if brace < 0:
|
|
fail("missing function body")
|
|
depth = 0
|
|
for end in range(brace, len(source)):
|
|
if source[end] == "{":
|
|
depth += 1
|
|
elif source[end] == "}":
|
|
depth -= 1
|
|
if depth == 0:
|
|
return source[brace + 1:end]
|
|
fail("unterminated function body")
|
|
|
|
|
|
source = Path(sys.argv[1]).read_text(encoding="utf-8")
|
|
if "#define WILL_OVERFLOW (PY_ULL(1)<<((MAX_STACK_ENTRIES-1)*BITS_PER_BLOCK))" not in source:
|
|
fail("frame stack overflow threshold must use Python's portable unsigned-long-long macro")
|
|
if "#define WILL_OVERFLOW (1ULL<<" in source:
|
|
fail("frame stack overflow threshold must not use a compiler-specific ULL literal")
|
|
body = extract_function(source, "frame_getlocals(PyFrameObject *f, void *closure)")
|
|
declaration = " PyObject *locals;"
|
|
if declaration not in body or "PyObject *locals =" in body:
|
|
fail("frame_getlocals locals must be declared without initializer at entry")
|
|
if not body.find("if (PyFrame_FastToLocalsWithError(f) < 0)") < body.find("locals = f->f_frame->f_locals;") < body.find("Py_INCREF(locals);") < body.find("return locals;"):
|
|
fail("frame_getlocals must preserve conversion, lookup, incref, and return order")
|
|
|
|
swap = extract_function(source, "stack_swap(int64_t stack, int n)")
|
|
for declaration in (" Kind to_swap, top;", " int shift;", " int64_t replaced_low, replaced_top;"):
|
|
if declaration not in swap:
|
|
fail("stack_swap locals must be declared before its assertion")
|
|
if "Kind to_swap =" in swap or "Kind top =" in swap or "int shift =" in swap or "int64_t replaced_low =" in swap or "int64_t replaced_top =" in swap:
|
|
fail("stack_swap temporaries must not be initialized after statements")
|
|
if not swap.find("assert(n >= 1);") < swap.find("to_swap = peek(stack, n);") < swap.find("top = top_of_stack(stack);") < swap.find("shift = BITS_PER_BLOCK*(n-1);") < swap.find("replaced_low =") < swap.find("replaced_top ="):
|
|
fail("stack_swap must preserve peek, top, shift, and replacement order")
|
|
|
|
pop_level = extract_function(source, "pop_to_level(int64_t stack, int level)")
|
|
if " int64_t max_item, level_max_stack;" not in pop_level:
|
|
fail("pop_to_level locals must be declared at function entry")
|
|
if "int64_t max_item =" in pop_level or "int64_t level_max_stack =" in pop_level:
|
|
fail("pop_to_level locals must not be initialized after the early return")
|
|
if not pop_level.find("if (level == 0)") < pop_level.find("max_item = (1<<BITS_PER_BLOCK) - 1;") < pop_level.find("level_max_stack = max_item <<") < pop_level.find("while (stack > level_max_stack)"):
|
|
fail("pop_to_level must preserve level guard and stack reduction order")
|
|
|
|
mark = extract_function(source, "mark_stacks(PyCodeObject *code_obj, int len)")
|
|
for declaration in (
|
|
" PyObject *co_code;", " _Py_CODEUNIT *code;", " int64_t *stacks;",
|
|
" int i, j, opcode, todo;", " int64_t next_stack, target_stack;",
|
|
" int n, delta;", " unsigned char *start, *end, *scan;",
|
|
" int start_offset, size, handler, depth_and_lasti, level, lasti;",
|
|
" uint64_t exception_target_stack;",
|
|
):
|
|
if declaration not in mark:
|
|
fail("mark_stacks locals must be declared at function entry")
|
|
if "for (int " in mark or "int64_t target_stack =" in mark or "uint64_t target_stack =" in mark or "int64_t next_stack =" in mark:
|
|
fail("mark_stacks must not introduce declarations after statements")
|
|
if not mark.find("co_code = _PyCode_GetCode(code_obj);") < mark.find("code = (_Py_CODEUNIT *)PyBytes_AS_STRING(co_code);") < mark.find("stacks = PyMem_New(int64_t, len+1);"):
|
|
fail("mark_stacks must preserve code lookup and stack allocation order")
|
|
|
|
explain = extract_function(source, "explain_incompatible_stack(int64_t to_stack)")
|
|
if " Kind target_kind;" not in explain or "Kind target_kind =" in explain:
|
|
fail("explain_incompatible_stack target kind must be declared at function entry")
|
|
if not explain.find("assert(to_stack != 0);") < explain.find("target_kind = top_of_stack(to_stack);") < explain.find("switch(target_kind)"):
|
|
fail("explain_incompatible_stack must preserve assertion and dispatch order")
|
|
|
|
marklines = extract_function(source, "marklines(PyCodeObject *code, int len)")
|
|
for declaration in (" PyCodeAddressRange bounds;", " int last_line;", " int *linestarts;", " int i;"):
|
|
if declaration not in marklines:
|
|
fail("marklines locals must be declared at function entry")
|
|
if "int last_line =" in marklines or "int *linestarts =" in marklines or "for (int i =" in marklines:
|
|
fail("marklines must not declare locals after statements")
|
|
if not marklines.find("_PyCode_InitAddressRange(code, &bounds);") < marklines.find("last_line = -1;") < marklines.find("linestarts = PyMem_New(int, len);") < marklines.find("for (i = 0; i < len; i++)"):
|
|
fail("marklines must preserve range-init/allocation/initialization order")
|
|
|
|
firstline = extract_function(source, "first_line_not_before(int *lines, int len, int line)")
|
|
if " int result, i;" not in firstline or "for (int i =" in firstline:
|
|
fail("first_line_not_before loop index must be declared at function entry")
|
|
if not firstline.find("result = INT_MAX;") < firstline.find("for (i = 0; i < len; i++)"):
|
|
fail("first_line_not_before must initialize its minimum before scanning")
|
|
|
|
setlineno = extract_function(source, 'frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno, void *Py_UNUSED(ignored))')
|
|
entry_declarations = (
|
|
'PyFrameState state;',
|
|
'int i;',
|
|
'int new_lineno;',
|
|
'int overflow;',
|
|
'long l_new_lineno;',
|
|
'int len;',
|
|
'int *lines;',
|
|
'int64_t *stacks;',
|
|
'int64_t best_stack;',
|
|
'int best_addr;',
|
|
'int64_t start_stack;',
|
|
'int err;',
|
|
'const char *msg;',
|
|
)
|
|
remaining = setlineno.lstrip()
|
|
for declaration in entry_declarations:
|
|
if not remaining.startswith(declaration + "\n"):
|
|
fail("frame_setlineno function-entry declaration missing or out of order: " + declaration)
|
|
remaining = remaining[len(declaration):].lstrip()
|
|
|
|
# Freeze the execution body, including validation, cleanup, error selection,
|
|
# loop order, frame stack operations, and unchanged nested block declarations.
|
|
# Only blank lines and indentation are ignored; no executable text is omitted.
|
|
expected_execution = r"""
|
|
|
|
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;
|
|
}
|
|
|
|
state = _PyFrame_GetState(f);
|
|
/*
|
|
* This code preserves the historical restrictions on
|
|
* setting the line number of a frame.
|
|
* Jumps are forbidden on a 'return' trace event (except after a yield).
|
|
* Jumps from 'call' trace events are also forbidden.
|
|
* In addition, jumps are forbidden when not tracing,
|
|
* as this is a debugging feature.
|
|
*/
|
|
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;
|
|
}
|
|
|
|
|
|
/* Fail if the line falls outside the code block and
|
|
select first line with actual code. */
|
|
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
|
|
#endif
|
|
) {
|
|
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;
|
|
}
|
|
|
|
/* PyCode_NewWithPosOnlyArgs limits co_code to be under INT_MAX so this
|
|
* should never overflow. */
|
|
len = (int)Py_SIZE(f->f_frame->f_code);
|
|
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;
|
|
}
|
|
|
|
stacks = mark_stacks(f->f_frame->f_code, len);
|
|
if (stacks == NULL) {
|
|
PyMem_Free(lines);
|
|
return -1;
|
|
}
|
|
|
|
best_stack = OVERFLOWED;
|
|
best_addr = -1;
|
|
start_stack = stacks[_PyInterpreterFrame_LASTI(f->f_frame)];
|
|
err = -1;
|
|
msg = "cannot find bytecode for specified line";
|
|
for (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;
|
|
"""
|
|
def execution_lines(text: str) -> list:
|
|
return [line.strip() for line in text.splitlines() if line.strip()]
|
|
|
|
if execution_lines(remaining) != execution_lines(expected_execution):
|
|
fail("frame_setlineno execution body changed or contains a late function-scope declaration")
|
|
|
|
frame_dealloc = extract_function(source, "frame_dealloc(PyFrameObject *f)")
|
|
expected_dealloc_declarations = (
|
|
"PyCodeObject *co;",
|
|
"_PyInterpreterFrame *frame;",
|
|
"PyObject **locals;",
|
|
"int i;",
|
|
)
|
|
remaining = frame_dealloc.lstrip()
|
|
for declaration in expected_dealloc_declarations:
|
|
if not remaining.startswith(declaration + "\n"):
|
|
fail("frame_dealloc entry declaration missing or out of order: " + declaration)
|
|
remaining = remaining[len(declaration):].lstrip()
|
|
if "PyCodeObject *co =" in frame_dealloc or "_PyInterpreterFrame *frame =" in frame_dealloc or "PyObject **locals =" in frame_dealloc or "for (int i =" in frame_dealloc:
|
|
fail("frame_dealloc must not declare locals after statements")
|
|
ordered_dealloc = (
|
|
"Py_TRASHCAN_BEGIN(f, frame_dealloc);",
|
|
"co = NULL;",
|
|
"frame = (_PyInterpreterFrame *)f->_f_frame_data;",
|
|
"if (f->f_frame == frame && frame->owner == FRAME_OWNED_BY_FRAME_OBJECT)",
|
|
"co = frame->f_code;",
|
|
"frame->f_code = NULL;",
|
|
"Py_CLEAR(frame->f_func);",
|
|
"Py_CLEAR(frame->f_locals);",
|
|
"locals = _PyFrame_GetLocalsArray(frame);",
|
|
"for (i = 0; i < frame->stacktop; i++)",
|
|
"Py_CLEAR(f->f_back);",
|
|
"Py_CLEAR(f->f_trace);",
|
|
"PyObject_GC_Del(f);",
|
|
"Py_XDECREF(co);",
|
|
"Py_TRASHCAN_END;",
|
|
)
|
|
positions = [frame_dealloc.find(token) for token in ordered_dealloc]
|
|
if any(position < 0 for position in positions) or positions != sorted(positions):
|
|
fail("frame_dealloc must preserve trashcan, owned-frame cleanup, and decref order")
|
|
|
|
frame_clear_locals = extract_function(source, "frame_tp_clear(PyFrameObject *f)")
|
|
remaining = frame_clear_locals.lstrip()
|
|
for declaration in ("PyObject **locals;", "int i;"):
|
|
if not remaining.startswith(declaration + "\n"):
|
|
fail("frame_tp_clear entry declaration missing or out of order: " + declaration)
|
|
remaining = remaining[len(declaration):].lstrip()
|
|
if "PyObject **locals =" in frame_clear_locals or "for (int i =" in frame_clear_locals:
|
|
fail("frame_tp_clear must not declare locals after statements")
|
|
ordered_clear = (
|
|
"Py_CLEAR(f->f_trace);",
|
|
"locals = _PyFrame_GetLocalsArray(f->f_frame);",
|
|
"assert(f->f_frame->stacktop >= 0);",
|
|
"for (i = 0; i < f->f_frame->stacktop; i++)",
|
|
"Py_CLEAR(locals[i]);",
|
|
"f->f_frame->stacktop = 0;",
|
|
)
|
|
positions = [frame_clear_locals.find(token) for token in ordered_clear]
|
|
if any(position < 0 for position in positions) or positions != sorted(positions):
|
|
fail("frame_tp_clear must preserve trace/local/stack cleanup order")
|
|
|
|
frame_sizeof = extract_function(source, "frame_sizeof(PyFrameObject *f, PyObject *Py_UNUSED(ignored))")
|
|
remaining = frame_sizeof.lstrip()
|
|
for declaration in ("Py_ssize_t res;", "PyCodeObject *code;"):
|
|
if not remaining.startswith(declaration + "\n"):
|
|
fail("frame_sizeof entry declaration missing or out of order: " + declaration)
|
|
remaining = remaining[len(declaration):].lstrip()
|
|
if "PyCodeObject *code =" in frame_sizeof:
|
|
fail("frame_sizeof code pointer must not be declared after initialization")
|
|
ordered_sizeof = (
|
|
"res = offsetof(PyFrameObject, _f_frame_data) + offsetof(_PyInterpreterFrame, localsplus);",
|
|
"code = f->f_frame->f_code;",
|
|
"res += (code->co_nlocalsplus+code->co_stacksize) * sizeof(PyObject *);",
|
|
"return PyLong_FromSsize_t(res);",
|
|
)
|
|
positions = [frame_sizeof.find(token) for token in ordered_sizeof]
|
|
if any(position < 0 for position in positions) or positions != sorted(positions):
|
|
fail("frame_sizeof must preserve size calculation and return order")
|
|
|
|
init_frame = extract_function(source, "init_frame(_PyInterpreterFrame *frame, PyFunctionObject *func, PyObject *locals)")
|
|
remaining = init_frame.lstrip()
|
|
for declaration in ("PyCodeObject *code;", "Py_ssize_t i;"):
|
|
if not remaining.startswith(declaration + "\n"):
|
|
fail("init_frame entry declaration missing or out of order: " + declaration)
|
|
remaining = remaining[len(declaration):].lstrip()
|
|
if "PyCodeObject *code =" in init_frame or "for (Py_ssize_t i =" in init_frame:
|
|
fail("init_frame must not declare locals after statements")
|
|
ordered_init_frame = (
|
|
"Py_INCREF(func);",
|
|
"code = (PyCodeObject *)func->func_code;",
|
|
"_PyFrame_InitializeSpecials(frame, func, locals, code->co_nlocalsplus);",
|
|
"frame->previous = NULL;",
|
|
"for (i = 0; i < code->co_nlocalsplus; i++)",
|
|
"frame->localsplus[i] = NULL;",
|
|
)
|
|
positions = [init_frame.find(token) for token in ordered_init_frame]
|
|
if any(position < 0 for position in positions) or positions != sorted(positions):
|
|
fail("init_frame must preserve reference and frame initialization order")
|
|
|
|
new_no_track = extract_function(source, "_PyFrame_New_NoTrack(PyCodeObject *code)")
|
|
remaining = new_no_track.lstrip()
|
|
for declaration in ("int slots;", "PyFrameObject *f;"):
|
|
if not remaining.startswith(declaration + "\n"):
|
|
fail("_PyFrame_New_NoTrack entry declaration missing or out of order: " + declaration)
|
|
remaining = remaining[len(declaration):].lstrip()
|
|
if "int slots =" in new_no_track or "PyFrameObject *f =" in new_no_track:
|
|
fail("_PyFrame_New_NoTrack locals must not be initialized after statements")
|
|
ordered_new_no_track = (
|
|
"CALL_STAT_INC(frame_objects_created);",
|
|
"slots = code->co_nlocalsplus + code->co_stacksize;",
|
|
"f = PyObject_GC_NewVar(PyFrameObject, &PyFrame_Type, slots);",
|
|
"if (f == NULL)",
|
|
"f->f_back = NULL;",
|
|
"f->f_lineno = 0;",
|
|
"return f;",
|
|
)
|
|
positions = [new_no_track.find(token) for token in ordered_new_no_track]
|
|
if any(position < 0 for position in positions) or positions != sorted(positions):
|
|
fail("_PyFrame_New_NoTrack must preserve stat, allocation, and initialization order")
|
|
|
|
frame_new = extract_function(source, "PyFrame_New(PyThreadState *tstate, PyCodeObject *code,")
|
|
remaining = frame_new.lstrip()
|
|
for declaration in (
|
|
"PyObject *builtins;",
|
|
"PyFrameConstructor desc;",
|
|
"PyFunctionObject *func;",
|
|
"PyFrameObject *f;",
|
|
):
|
|
if not remaining.startswith(declaration + "\n"):
|
|
fail("PyFrame_New entry declaration missing or out of order: " + declaration)
|
|
remaining = remaining[len(declaration):].lstrip()
|
|
if "PyFrameConstructor desc =" in frame_new or "PyFunctionObject *func =" in frame_new or "PyFrameObject *f =" in frame_new:
|
|
fail("PyFrame_New must not use initialized late declarations")
|
|
if "\n .fc_globals =" in frame_new or "\n .fc_builtins =" in frame_new:
|
|
fail("PyFrame_New constructor must not use designated initializers")
|
|
ordered_frame_new = (
|
|
"builtins = _PyEval_BuiltinsFromGlobals(tstate, globals);",
|
|
"if (builtins == NULL)",
|
|
"desc.fc_globals = globals;",
|
|
"desc.fc_builtins = builtins;",
|
|
"desc.fc_name = code->co_name;",
|
|
"desc.fc_qualname = code->co_name;",
|
|
"desc.fc_code = (PyObject *)code;",
|
|
"desc.fc_defaults = NULL;",
|
|
"desc.fc_kwdefaults = NULL;",
|
|
"desc.fc_closure = NULL;",
|
|
"func = _PyFunction_FromConstructor(&desc);",
|
|
"if (func == NULL)",
|
|
"f = _PyFrame_New_NoTrack(code);",
|
|
"if (f == NULL)",
|
|
"init_frame((_PyInterpreterFrame *)f->_f_frame_data, func, locals);",
|
|
"Py_DECREF(func);",
|
|
"return f;",
|
|
)
|
|
positions = [frame_new.rfind(token) if token == "Py_DECREF(func);" else frame_new.find(token) for token in ordered_frame_new]
|
|
if any(position < 0 for position in positions) or positions != sorted(positions):
|
|
fail("PyFrame_New must preserve validation, construction, and cleanup order")
|
|
|
|
op_already_ran = extract_function(source, "_PyFrame_OpAlreadyRan(_PyInterpreterFrame *frame, int opcode, int oparg)")
|
|
remaining = op_already_ran.lstrip()
|
|
for declaration in ("int check_oparg;", "_Py_CODEUNIT *instruction;"):
|
|
if not remaining.startswith(declaration + "\n"):
|
|
fail("_PyFrame_OpAlreadyRan entry declaration missing or out of order: " + declaration)
|
|
remaining = remaining[len(declaration):].lstrip()
|
|
if "int check_oparg =" in op_already_ran or "for (_Py_CODEUNIT *instruction =" in op_already_ran:
|
|
fail("_PyFrame_OpAlreadyRan must not declare locals after statements")
|
|
ordered_op_check = (
|
|
"assert(_PyOpcode_Deopt[opcode] == opcode);",
|
|
"check_oparg = 0;",
|
|
"for (instruction = _PyCode_CODE(frame->f_code);",
|
|
"instruction < frame->prev_instr; instruction++)",
|
|
"int check_opcode = _PyOpcode_Deopt[_Py_OPCODE(*instruction)];",
|
|
"check_oparg |= _Py_OPARG(*instruction);",
|
|
"instruction += _PyOpcode_Caches[check_opcode];",
|
|
"return 0;",
|
|
)
|
|
positions = [op_already_ran.find(token) for token in ordered_op_check]
|
|
if any(position < 0 for position in positions) or positions != sorted(positions):
|
|
fail("_PyFrame_OpAlreadyRan must preserve assert, opcode scan, and return order")
|
|
|
|
fast_to_locals = extract_function(source, "_PyFrame_FastToLocalsWithError(_PyInterpreterFrame *frame)")
|
|
entry_statements = fast_to_locals.find("locals = frame->f_locals;")
|
|
for declaration in ("int lasti;", "int i;"):
|
|
if fast_to_locals.find(declaration) < 0 or fast_to_locals.find(declaration) > entry_statements:
|
|
fail("_PyFrame_FastToLocalsWithError loop/state locals must be declared at entry: " + declaration)
|
|
if "int lasti =" in fast_to_locals or "for (int i =" in fast_to_locals:
|
|
fail("_PyFrame_FastToLocalsWithError must not use late or loop declarations")
|
|
if not fast_to_locals.find("lasti = _PyInterpreterFrame_LASTI(frame);") < fast_to_locals.find("if (lasti < 0"):
|
|
fail("_PyFrame_FastToLocalsWithError must preserve instruction-state lookup order")
|
|
if "PyObject *name;" not in fast_to_locals or "PyObject *value;" not in fast_to_locals:
|
|
fail("_PyFrame_FastToLocalsWithError loop item locals must be declared before loop statements")
|
|
if not fast_to_locals.find("if (kind & CO_FAST_FREE && !(co->co_flags & CO_OPTIMIZED))") < fast_to_locals.find("name = PyTuple_GET_ITEM(co->co_localsplusnames, i);") < fast_to_locals.find("value = fast[i];"):
|
|
fail("_PyFrame_FastToLocalsWithError must preserve skip and local lookup order")
|
|
|
|
public_fast_to_locals = extract_function(source, "PyFrame_FastToLocalsWithError(PyFrameObject *f)")
|
|
if not public_fast_to_locals.lstrip().startswith("int err;") or "int err =" in public_fast_to_locals:
|
|
fail("PyFrame_FastToLocalsWithError result must be declared at function entry")
|
|
ordered_public_fast = (
|
|
"assert(!_PyFrame_IsIncomplete(f->f_frame));",
|
|
"if (f == NULL)",
|
|
"err = _PyFrame_FastToLocalsWithError(f->f_frame);",
|
|
"if (err == 0)",
|
|
"f->f_fast_as_locals = 1;",
|
|
"return err;",
|
|
)
|
|
positions = [public_fast_to_locals.find(token) for token in ordered_public_fast]
|
|
if any(position < 0 for position in positions) or positions != sorted(positions):
|
|
fail("PyFrame_FastToLocalsWithError must preserve guard and status-update order")
|
|
|
|
locals_to_fast = extract_function(source, "_PyFrame_LocalsToFast(_PyInterpreterFrame *frame, int clear)")
|
|
entry_statement = locals_to_fast.find("locals = frame->f_locals;")
|
|
if "int i;" not in locals_to_fast or locals_to_fast.find("int i;") > entry_statement or "for (int i =" in locals_to_fast:
|
|
fail("_PyFrame_LocalsToFast index must be declared before execution")
|
|
if "PyObject *name;" not in locals_to_fast or "PyObject *value;" not in locals_to_fast or "PyObject *oldvalue;" not in locals_to_fast or "PyObject *cell;" not in locals_to_fast:
|
|
fail("_PyFrame_LocalsToFast loop temporaries must be declared at loop entry")
|
|
if "PyObject *name =" in locals_to_fast or "PyObject *value =" in locals_to_fast or "PyObject *oldvalue =" in locals_to_fast or "PyObject *cell =" in locals_to_fast:
|
|
fail("_PyFrame_LocalsToFast must not use late initialized declarations")
|
|
ordered_locals_to_fast = (
|
|
"PyErr_Fetch(&error_type, &error_value, &error_traceback);",
|
|
"for (i = 0; i < co->co_nlocalsplus; i++)",
|
|
"kind = _PyLocals_GetKind(co->co_localspluskinds, i);",
|
|
"if (kind & CO_FAST_FREE && !(co->co_flags & CO_OPTIMIZED))",
|
|
"name = PyTuple_GET_ITEM(co->co_localsplusnames, i);",
|
|
"value = PyObject_GetItem(locals, name);",
|
|
"if (value == NULL)",
|
|
"oldvalue = fast[i];",
|
|
"cell = NULL;",
|
|
"Py_XDECREF(value);",
|
|
"PyErr_Restore(error_type, error_value, error_traceback);",
|
|
)
|
|
positions = [locals_to_fast.find(token) for token in ordered_locals_to_fast]
|
|
if any(position < 0 for position in positions) or positions != sorted(positions):
|
|
fail("_PyFrame_LocalsToFast must preserve error, lookup, and refcount order")
|
|
|
|
get_code = extract_function(source, "PyFrame_GetCode(PyFrameObject *frame)")
|
|
if not get_code.lstrip().startswith("PyCodeObject *code;") or "PyCodeObject *code =" in get_code:
|
|
fail("PyFrame_GetCode local must be declared at function entry")
|
|
ordered_get_code = (
|
|
"assert(frame != NULL);",
|
|
"assert(!_PyFrame_IsIncomplete(frame->f_frame));",
|
|
"code = frame->f_frame->f_code;",
|
|
"assert(code != NULL);",
|
|
"Py_INCREF(code);",
|
|
"return code;",
|
|
)
|
|
positions = [get_code.find(token) for token in ordered_get_code]
|
|
if any(position < 0 for position in positions) or positions != sorted(positions):
|
|
fail("PyFrame_GetCode must preserve validation and reference ownership order")
|
|
|
|
get_back = extract_function(source, "PyFrame_GetBack(PyFrameObject *frame)")
|
|
if not get_back.lstrip().startswith("PyFrameObject *back;") or "PyFrameObject *back =" in get_back:
|
|
fail("PyFrame_GetBack local must be declared at function entry")
|
|
ordered_get_back = (
|
|
"assert(frame != NULL);",
|
|
"assert(!_PyFrame_IsIncomplete(frame->f_frame));",
|
|
"back = frame->f_back;",
|
|
"if (back == NULL)",
|
|
"_PyInterpreterFrame *prev = frame->f_frame->previous;",
|
|
"back = _PyFrame_GetFrameObject(prev);",
|
|
"Py_XINCREF(back);",
|
|
"return back;",
|
|
)
|
|
positions = [get_back.find(token) for token in ordered_get_back]
|
|
if any(position < 0 for position in positions) or positions != sorted(positions):
|
|
fail("PyFrame_GetBack must preserve frame-chain lookup and incref order")
|
|
|
|
get_lasti = extract_function(source, "PyFrame_GetLasti(PyFrameObject *frame)")
|
|
if not get_lasti.lstrip().startswith("int lasti;") or "int lasti =" in get_lasti:
|
|
fail("PyFrame_GetLasti local must be declared at function entry")
|
|
ordered_get_lasti = (
|
|
"assert(!_PyFrame_IsIncomplete(frame->f_frame));",
|
|
"lasti = _PyInterpreterFrame_LASTI(frame->f_frame);",
|
|
"if (lasti < 0)",
|
|
"return lasti * sizeof(_Py_CODEUNIT);",
|
|
)
|
|
positions = [get_lasti.find(token) for token in ordered_get_lasti]
|
|
if any(position < 0 for position in positions) or positions != sorted(positions):
|
|
fail("PyFrame_GetLasti must preserve assertion and bytecode-offset order")
|
|
|
|
get_generator = extract_function(source, "PyFrame_GetGenerator(PyFrameObject *frame)")
|
|
if not get_generator.lstrip().startswith("PyGenObject *gen;") or "PyGenObject *gen =" in get_generator:
|
|
fail("PyFrame_GetGenerator local must be declared at function entry")
|
|
ordered_get_generator = (
|
|
"assert(!_PyFrame_IsIncomplete(frame->f_frame));",
|
|
"if (frame->f_frame->owner != FRAME_OWNED_BY_GENERATOR)",
|
|
"return NULL;",
|
|
"gen = _PyFrame_GetGenerator(frame->f_frame);",
|
|
"return Py_NewRef(gen);",
|
|
)
|
|
positions = [get_generator.find(token) for token in ordered_get_generator]
|
|
if any(position < 0 for position in positions) or positions != sorted(positions):
|
|
fail("PyFrame_GetGenerator must preserve owner guard and new-reference order")
|
|
|
|
print("frameobject C89 declarations and frame locals ownership order: PASS")
|