"no locals found");
ERROR_IF(true, error);
}
- locals = PyStackRef_FromPyObjectNew(l);;
+ locals = PyStackRef_FromPyObjectNew(l);
}
inst(LOAD_FROM_DICT_OR_GLOBALS, (mod_or_class_dict -- v)) {
}
STAT_INC(UNPACK_SEQUENCE, hit);
val0 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 0));
+ stack_pointer[0] = val0;
val1 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 1));
- PyStackRef_CLOSE(seq);
stack_pointer[-1] = val1;
- stack_pointer[0] = val0;
+ PyStackRef_CLOSE(seq);
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
"no locals found");
if (true) JUMP_TO_ERROR();
}
- locals = PyStackRef_FromPyObjectNew(l);;
+ locals = PyStackRef_FromPyObjectNew(l);
stack_pointer[0] = locals;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
STAT_INC(LOAD_ATTR, hit);
null = PyStackRef_NULL;
attr = PyStackRef_FromPyObjectNew(attr_o);
- PyStackRef_CLOSE(owner);
stack_pointer[-1] = attr;
+ PyStackRef_CLOSE(owner);
break;
}
STAT_INC(LOAD_ATTR, hit);
null = PyStackRef_NULL;
attr = PyStackRef_FromPyObjectNew(attr_o);
- PyStackRef_CLOSE(owner);
stack_pointer[-1] = attr;
+ PyStackRef_CLOSE(owner);
stack_pointer[0] = null;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
STAT_INC(LOAD_ATTR, hit);
assert(descr != NULL);
attr = PyStackRef_FromPyObjectNew(descr);
+ stack_pointer[-1] = attr;
null = PyStackRef_NULL;
PyStackRef_CLOSE(owner);
- stack_pointer[-1] = attr;
break;
}
STAT_INC(LOAD_ATTR, hit);
assert(descr != NULL);
attr = PyStackRef_FromPyObjectNew(descr);
+ stack_pointer[-1] = attr;
null = PyStackRef_NULL;
PyStackRef_CLOSE(owner);
- stack_pointer[-1] = attr;
stack_pointer[0] = null;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
assert(descr != NULL);
assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
attr = PyStackRef_FromPyObjectNew(descr);
- self = owner;
stack_pointer[-1] = attr;
+ self = owner;
stack_pointer[0] = self;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
assert(descr != NULL);
assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
attr = PyStackRef_FromPyObjectNew(descr);
- self = owner;
stack_pointer[-1] = attr;
+ self = owner;
stack_pointer[0] = self;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
assert(descr != NULL);
assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
attr = PyStackRef_FromPyObjectNew(descr);
- self = owner;
stack_pointer[-1] = attr;
+ self = owner;
stack_pointer[0] = self;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
PyObject *self = ((PyMethodObject *)callable_o)->im_self;
maybe_self = PyStackRef_FromPyObjectNew(self);
+ stack_pointer[-1 - oparg] = maybe_self;
PyObject *method = ((PyMethodObject *)callable_o)->im_func;
func = PyStackRef_FromPyObjectNew(method);
+ stack_pointer[-2 - oparg] = func;
/* Make sure that callable and all args are in memory */
args[-2] = func;
args[-1] = maybe_self;
func = callable;
maybe_self = self_or_null;
}
- stack_pointer[-2 - oparg] = func;
- stack_pointer[-1 - oparg] = maybe_self;
break;
}
assert(PyStackRef_IsNull(null));
assert(Py_TYPE(callable_o) == &PyMethod_Type);
self = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
+ stack_pointer[-1 - oparg] = self;
method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ stack_pointer[-2 - oparg] = method;
assert(PyStackRef_FunctionCheck(method));
PyStackRef_CLOSE(callable);
- stack_pointer[-2 - oparg] = method;
- stack_pointer[-1 - oparg] = self;
break;
}
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
STAT_INC(CALL, hit);
self = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
+ stack_pointer[-1 - oparg] = self;
func = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
- PyStackRef_CLOSE(callable);
stack_pointer[-2 - oparg] = func;
- stack_pointer[-1 - oparg] = self;
+ PyStackRef_CLOSE(callable);
break;
}
_PyStackRef null;
PyObject *ptr = (PyObject *)CURRENT_OPERAND();
value = PyStackRef_FromPyObjectNew(ptr);
- null = PyStackRef_NULL;
stack_pointer[0] = value;
+ null = PyStackRef_NULL;
stack_pointer[1] = null;
stack_pointer += 2;
assert(WITHIN_STACK_BOUNDS());
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
PyObject *self = ((PyMethodObject *)callable_o)->im_self;
maybe_self = PyStackRef_FromPyObjectNew(self);
+ stack_pointer[-1 - oparg] = maybe_self;
PyObject *method = ((PyMethodObject *)callable_o)->im_func;
func = PyStackRef_FromPyObjectNew(method);
+ stack_pointer[-2 - oparg] = func;
/* Make sure that callable and all args are in memory */
args[-2] = func;
args[-1] = maybe_self;
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
STAT_INC(CALL, hit);
self = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
+ stack_pointer[-1 - oparg] = self;
func = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ stack_pointer[-2 - oparg] = func;
PyStackRef_CLOSE(callable);
}
// flush
- stack_pointer[-2 - oparg] = func;
- stack_pointer[-1 - oparg] = self;
// _CHECK_FUNCTION_VERSION
callable = stack_pointer[-2 - oparg];
{
assert(PyStackRef_IsNull(null));
assert(Py_TYPE(callable_o) == &PyMethod_Type);
self = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
+ stack_pointer[-1 - oparg] = self;
method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ stack_pointer[-2 - oparg] = method;
assert(PyStackRef_FunctionCheck(method));
PyStackRef_CLOSE(callable);
}
// flush
- stack_pointer[-2 - oparg] = method;
- stack_pointer[-1 - oparg] = self;
// _PY_FRAME_GENERAL
args = &stack_pointer[-oparg];
self_or_null = stack_pointer[-1 - oparg];
int matches = PyErr_GivenExceptionMatches(exc_value, PyExc_StopIteration);
if (matches) {
value = PyStackRef_FromPyObjectNew(((PyStopIterationObject *)exc_value)->value);
+ stack_pointer[-2] = value;
PyStackRef_CLOSE(sub_iter_st);
PyStackRef_CLOSE(last_sent_val_st);
PyStackRef_CLOSE(exc_value_st);
goto exception_unwind;
}
stack_pointer[-3] = none;
- stack_pointer[-2] = value;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
assert(seq);
assert(it->it_index < PyList_GET_SIZE(seq));
next = PyStackRef_FromPyObjectNew(PyList_GET_ITEM(seq, it->it_index++));
+ stack_pointer[0] = next;
}
- stack_pointer[0] = next;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
assert(seq);
assert(it->it_index < PyTuple_GET_SIZE(seq));
next = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq, it->it_index++));
+ stack_pointer[0] = next;
}
- stack_pointer[0] = next;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
PyObject *self = ((PyMethodObject *)callable_o)->im_self;
maybe_self = PyStackRef_FromPyObjectNew(self);
+ stack_pointer[-1 - oparg] = maybe_self;
PyObject *method = ((PyMethodObject *)callable_o)->im_func;
func = PyStackRef_FromPyObjectNew(method);
+ stack_pointer[-2 - oparg] = func;
/* Make sure that callable and all args are in memory */
args[-2] = func;
args[-1] = maybe_self;
// _LOAD_CONST
{
value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg));
+ stack_pointer[0] = value;
}
// _RETURN_VALUE_EVENT
val = value;
STAT_INC(LOAD_ATTR, hit);
assert(descr != NULL);
attr = PyStackRef_FromPyObjectNew(descr);
+ stack_pointer[-1] = attr;
null = PyStackRef_NULL;
PyStackRef_CLOSE(owner);
}
- stack_pointer[-1] = attr;
if (oparg & 1) stack_pointer[0] = null;
stack_pointer += (oparg & 1);
assert(WITHIN_STACK_BOUNDS());
assert(descr != NULL);
assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
attr = PyStackRef_FromPyObjectNew(descr);
+ stack_pointer[-1] = attr;
self = owner;
}
- stack_pointer[-1] = attr;
stack_pointer[0] = self;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
assert(descr != NULL);
assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
attr = PyStackRef_FromPyObjectNew(descr);
+ stack_pointer[-1] = attr;
self = owner;
}
- stack_pointer[-1] = attr;
stack_pointer[0] = self;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
assert(descr != NULL);
assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
attr = PyStackRef_FromPyObjectNew(descr);
+ stack_pointer[-1] = attr;
self = owner;
}
- stack_pointer[-1] = attr;
stack_pointer[0] = self;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
assert(descr != NULL);
PyStackRef_CLOSE(owner);
attr = PyStackRef_FromPyObjectNew(descr);
+ stack_pointer[-1] = attr;
}
- stack_pointer[-1] = attr;
DISPATCH();
}
assert(descr != NULL);
PyStackRef_CLOSE(owner);
attr = PyStackRef_FromPyObjectNew(descr);
+ stack_pointer[-1] = attr;
}
- stack_pointer[-1] = attr;
DISPATCH();
}
STAT_INC(LOAD_ATTR, hit);
null = PyStackRef_NULL;
attr = PyStackRef_FromPyObjectNew(attr_o);
+ stack_pointer[-1] = attr;
PyStackRef_CLOSE(owner);
}
/* Skip 5 cache entries */
- stack_pointer[-1] = attr;
if (oparg & 1) stack_pointer[0] = null;
stack_pointer += (oparg & 1);
assert(WITHIN_STACK_BOUNDS());
"no locals found");
if (true) goto error;
}
- locals = PyStackRef_FromPyObjectNew(l);;
+ locals = PyStackRef_FromPyObjectNew(l);
stack_pointer[0] = locals;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
// _LOAD_CONST
{
value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg));
+ stack_pointer[0] = value;
}
// _RETURN_VALUE
retval = value;
DEOPT_IF(PyTuple_GET_SIZE(seq_o) != 2, UNPACK_SEQUENCE);
STAT_INC(UNPACK_SEQUENCE, hit);
val0 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 0));
+ stack_pointer[0] = val0;
val1 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 1));
- PyStackRef_CLOSE(seq);
stack_pointer[-1] = val1;
- stack_pointer[0] = val0;
+ PyStackRef_CLOSE(seq);
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
annotations: list[str]
stack: StackEffect
caches: list[CacheEntry]
+ deferred_refs: dict[lexer.Token, str | None]
body: list[lexer.Token]
properties: Properties
_size: int = -1
return [CacheEntry(i.name, int(i.size)) for i in caches]
+def analyze_deferred_refs(node: parser.InstDef) -> dict[lexer.Token, str | None]:
+ """Look for PyStackRef_FromPyObjectNew() calls"""
+
+ def find_assignment_target(idx: int) -> list[lexer.Token]:
+ """Find the tokens that make up the left-hand side of an assignment"""
+ offset = 1
+ for tkn in reversed(node.block.tokens[:idx-1]):
+ if tkn.kind == "SEMI" or tkn.kind == "LBRACE" or tkn.kind == "RBRACE":
+ return node.block.tokens[idx-offset:idx-1]
+ offset += 1
+ return []
+
+ refs: dict[lexer.Token, str | None] = {}
+ for idx, tkn in enumerate(node.block.tokens):
+ if tkn.kind != "IDENTIFIER" or tkn.text != "PyStackRef_FromPyObjectNew":
+ continue
+
+ if idx == 0 or node.block.tokens[idx-1].kind != "EQUALS":
+ raise analysis_error("Expected '=' before PyStackRef_FromPyObjectNew", tkn)
+
+ lhs = find_assignment_target(idx)
+ if len(lhs) == 0:
+ raise analysis_error("PyStackRef_FromPyObjectNew() must be assigned to an output", tkn)
+
+ if lhs[0].kind == "TIMES" or any(t.kind == "ARROW" or t.kind == "LBRACKET" for t in lhs[1:]):
+ # Don't handle: *ptr = ..., ptr->field = ..., or ptr[field] = ...
+ # Assume that they are visible to the GC.
+ refs[tkn] = None
+ continue
+
+ if len(lhs) != 1 or lhs[0].kind != "IDENTIFIER":
+ raise analysis_error("PyStackRef_FromPyObjectNew() must be assigned to an output", tkn)
+
+ name = lhs[0].text
+ if not any(var.name == name for var in node.outputs):
+ raise analysis_error(f"PyStackRef_FromPyObjectNew() must be assigned to an output, not '{name}'", tkn)
+
+ refs[tkn] = name
+
+ return refs
+
def variable_used(node: parser.InstDef, name: str) -> bool:
"""Determine whether a variable with a given name is used in a node."""
return any(
annotations=op.annotations,
stack=analyze_stack(op),
caches=analyze_caches(inputs),
+ deferred_refs=analyze_deferred_refs(op),
body=op.block.tokens,
properties=compute_properties(op),
)
annotations=op.annotations,
stack=analyze_stack(op, bit),
caches=analyze_caches(inputs),
+ deferred_refs=analyze_deferred_refs(op),
body=op.block.tokens,
properties=properties,
)
annotations=op.annotations,
stack=analyze_stack(op),
caches=analyze_caches(inputs),
+ deferred_refs=analyze_deferred_refs(op),
body=op.block.tokens,
properties=properties,
)
Uop,
Properties,
StackItem,
+ analysis_error,
)
from cwriter import CWriter
from typing import Callable, Mapping, TextIO, Iterator
"DECREF_INPUTS": self.decref_inputs,
"CHECK_EVAL_BREAKER": self.check_eval_breaker,
"SYNC_SP": self.sync_sp,
+ "PyStackRef_FromPyObjectNew": self.py_stack_ref_from_py_object_new,
}
self.out = out
if not uop.properties.ends_with_eval_breaker:
self.out.emit_at("CHECK_EVAL_BREAKER();", tkn)
+ def py_stack_ref_from_py_object_new(
+ self,
+ tkn: Token,
+ tkn_iter: Iterator[Token],
+ uop: Uop,
+ stack: Stack,
+ inst: Instruction | None,
+ ) -> None:
+ self.out.emit(tkn)
+ emit_to(self.out, tkn_iter, "SEMI")
+ self.out.emit(";\n")
+
+ target = uop.deferred_refs[tkn]
+ if target is None:
+ # An assignment we don't handle, such as to a pointer or array.
+ return
+
+ # Flush the assignment to the stack. Note that we don't flush the
+ # stack pointer here, and instead are currently relying on initializing
+ # unused portions of the stack to NULL.
+ stack.flush_single_var(self.out, target, uop.stack.outputs)
+
+
def emit_tokens(
self,
uop: Uop,
return SyntaxError(message, (filename, line, column, line_text))
-@dataclass(slots=True)
+@dataclass(slots=True, frozen=True)
class Token:
filename: str
kind: str
top_offset.push(var)
return "\n".join(res)
+ @staticmethod
+ def _do_emit(out: CWriter, var: StackItem, base_offset: StackOffset,
+ cast_type: str = "uintptr_t", extract_bits: bool = False) -> None:
+ cast = f"({cast_type})" if var.type else ""
+ bits = ".bits" if cast and not extract_bits else ""
+ if var.condition == "0":
+ return
+ if var.condition and var.condition != "1":
+ out.emit(f"if ({var.condition}) ")
+ out.emit(
+ f"stack_pointer[{base_offset.to_c()}]{bits} = {cast}{var.name};\n"
+ )
+
@staticmethod
def _do_flush(out: CWriter, variables: list[Local], base_offset: StackOffset, top_offset: StackOffset,
cast_type: str = "uintptr_t", extract_bits: bool = False) -> None:
out.start_line()
for var in variables:
if var.cached and not var.in_memory and not var.item.peek and not var.name in UNUSED:
- cast = f"({cast_type})" if var.item.type else ""
- bits = ".bits" if cast and not extract_bits else ""
- if var.condition == "0":
- continue
- if var.condition and var.condition != "1":
- out.emit(f"if ({var.condition}) ")
- out.emit(
- f"stack_pointer[{base_offset.to_c()}]{bits} = {cast}{var.name};\n"
- )
+ Stack._do_emit(out, var.item, base_offset, cast_type, extract_bits)
base_offset.push(var.item)
if base_offset.to_c() != top_offset.to_c():
print("base", base_offset, "top", top_offset)
self.base_offset.clear()
self.top_offset.clear()
+ def flush_single_var(self, out: CWriter, var_name: str, outputs: list[StackItem],
+ cast_type: str = "uintptr_t", extract_bits: bool = False) -> None:
+ assert any(var.name == var_name for var in outputs)
+ base_offset = self.base_offset.copy()
+ top_offset = self.top_offset.copy()
+ for var in self.variables:
+ base_offset.push(var.item)
+ for var in outputs:
+ if any(var == v.item for v in self.variables):
+ # The variable is already on the stack, such as a peeked value
+ # in the tier1 generator
+ continue
+ if var.name == var_name:
+ Stack._do_emit(out, var, base_offset, cast_type, extract_bits)
+ base_offset.push(var)
+ top_offset.push(var)
+ if base_offset.to_c() != top_offset.to_c():
+ print("base", base_offset, "top", top_offset)
+ assert False
+
def peek_offset(self) -> str:
return self.top_offset.to_c()
if braces:
emitter.emit("{\n")
emitter.out.emit(stack.define_output_arrays(uop.stack.outputs))
+ outputs: list[Local] = []
+ for var in uop.stack.outputs:
+ if not var.peek:
+ if var.name in locals:
+ local = locals[var.name]
+ elif var.name == "unused":
+ local = Local.unused(var)
+ else:
+ local = Local.local(var)
+ outputs.append(local)
for cache in uop.caches:
if cache.name != "unused":
emitter.emit(f"(void){cache.name};\n")
offset += cache.size
emitter.emit_tokens(uop, stack, inst)
- for i, var in enumerate(uop.stack.outputs):
- if not var.peek:
- if var.name in locals:
- local = locals[var.name]
- elif var.name == "unused":
- local = Local.unused(var)
- else:
- local = Local.local(var)
- emitter.emit(stack.push(local))
+ for output in outputs:
+ if output.name in uop.deferred_refs.values():
+ # We've already spilled this when emitting tokens
+ output.cached = False
+ emitter.emit(stack.push(output))
if braces:
emitter.out.start_line()
emitter.emit("}\n")
if local.defined:
locals[local.name] = local
emitter.emit(stack.define_output_arrays(uop.stack.outputs))
+ outputs: list[Local] = []
+ for var in uop.stack.outputs:
+ if var.name in locals:
+ local = locals[var.name]
+ else:
+ local = Local.local(var)
+ outputs.append(local)
for cache in uop.caches:
if cache.name != "unused":
if cache.size == 4:
cast = f"uint{cache.size*16}_t"
emitter.emit(f"{type}{cache.name} = ({cast})CURRENT_OPERAND();\n")
emitter.emit_tokens(uop, stack, None)
- for i, var in enumerate(uop.stack.outputs):
- if var.name in locals:
- local = locals[var.name]
- else:
- local = Local.local(var)
- emitter.emit(stack.push(local))
+ for output in outputs:
+ if output.name in uop.deferred_refs.values():
+ # We've already spilled this when emitting tokens
+ output.cached = False
+ emitter.emit(stack.push(output))
except StackError as ex:
raise analysis_error(ex.args[0], uop.body[0]) from None
projects / thirdparty / Python / cpython.git / commitdiff
