[BINARY_OP_ADD_FLOAT] = { true, INSTR_FMT_IXC, HAS_EXIT_FLAG | HAS_ERROR_FLAG },
[BINARY_OP_ADD_INT] = { true, INSTR_FMT_IXC, HAS_EXIT_FLAG | HAS_ERROR_FLAG },
[BINARY_OP_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_EXIT_FLAG | HAS_ERROR_FLAG },
- [BINARY_OP_INPLACE_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
+ [BINARY_OP_INPLACE_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG },
[BINARY_OP_MULTIPLY_FLOAT] = { true, INSTR_FMT_IXC, HAS_EXIT_FLAG | HAS_ERROR_FLAG },
[BINARY_OP_MULTIPLY_INT] = { true, INSTR_FMT_IXC, HAS_EXIT_FLAG | HAS_ERROR_FLAG },
[BINARY_OP_SUBTRACT_FLOAT] = { true, INSTR_FMT_IXC, HAS_EXIT_FLAG | HAS_ERROR_FLAG },
[DICT_UPDATE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[END_ASYNC_FOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
[END_FOR] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_NO_SAVE_IP_FLAG },
- [END_SEND] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_PURE_FLAG },
+ [END_SEND] = { true, INSTR_FMT_IX, HAS_PURE_FLAG },
[ENTER_EXECUTOR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG },
[EXIT_INIT_CHECK] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
[EXTENDED_ARG] = { true, INSTR_FMT_IB, HAS_ARG_FLAG },
[LOAD_SPECIAL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[LOAD_SUPER_ATTR_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
- [LOAD_SUPER_ATTR_METHOD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
+ [LOAD_SUPER_ATTR_METHOD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
[MAKE_CELL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
[MAKE_FUNCTION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[MAP_ADD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[_POP_TOP] = HAS_PURE_FLAG,
[_PUSH_NULL] = HAS_PURE_FLAG,
[_END_FOR] = HAS_ESCAPES_FLAG | HAS_NO_SAVE_IP_FLAG,
- [_END_SEND] = HAS_ESCAPES_FLAG | HAS_PURE_FLAG,
+ [_END_SEND] = HAS_PURE_FLAG,
[_UNARY_NEGATIVE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_UNARY_NOT] = HAS_PURE_FLAG,
[_TO_BOOL] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_BINARY_OP_SUBTRACT_FLOAT] = HAS_ERROR_FLAG | HAS_PURE_FLAG,
[_GUARD_BOTH_UNICODE] = HAS_EXIT_FLAG,
[_BINARY_OP_ADD_UNICODE] = HAS_ERROR_FLAG | HAS_PURE_FLAG,
- [_BINARY_OP_INPLACE_ADD_UNICODE] = HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
+ [_BINARY_OP_INPLACE_ADD_UNICODE] = HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG,
[_BINARY_SUBSCR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_BINARY_SLICE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_STORE_SLICE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_DICT_MERGE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_MAP_ADD] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_LOAD_SUPER_ATTR_ATTR] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
- [_LOAD_SUPER_ATTR_METHOD] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
+ [_LOAD_SUPER_ATTR_METHOD] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG,
[_LOAD_ATTR] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_GUARD_TYPE_VERSION] = HAS_EXIT_FLAG,
[_GUARD_TYPE_VERSION_AND_LOCK] = HAS_EXIT_FLAG,
with self.assertRaises(SyntaxError):
self.run_cases_test(input, "")
+ def test_kill_in_wrong_order(self):
+ input = """
+ inst(OP, (a, b -- c)) {
+ c = b;
+ PyStackRef_CLOSE(a);
+ PyStackRef_CLOSE(b);
+ }
+ """
+ with self.assertRaises(SyntaxError):
+ self.run_cases_test(input, "")
+
+
class TestGeneratedAbstractCases(unittest.TestCase):
def setUp(self) -> None:
super().setUp()
(void)receiver;
val = value;
DEAD(value);
- PyStackRef_CLOSE(receiver);
+ DECREF_INPUTS();
}
tier1 inst(INSTRUMENTED_END_SEND, (receiver, value -- val)) {
STAT_INC(BINARY_OP, hit);
PyObject *res_o = PyUnicode_Concat(left_o, right_o);
- PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);
PyStackRef_CLOSE_SPECIALIZED(right, _PyUnicode_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);
INPUTS_DEAD();
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
* that the string is safe to mutate.
*/
assert(Py_REFCNT(left_o) >= 2);
- PyStackRef_CLOSE(left);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);
DEAD(left);
PyObject *temp = PyStackRef_AsPyObjectSteal(*target_local);
PyUnicode_Append(&temp, right_o);
err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), slice, PyStackRef_AsPyObjectBorrow(v));
Py_DECREF(slice);
}
- PyStackRef_CLOSE(v);
- PyStackRef_CLOSE(container);
+ DECREF_INPUTS();
ERROR_IF(err, error);
}
int method_found = 0;
PyObject *attr_o = _PySuper_Lookup(cls, self, name,
Py_TYPE(self)->tp_getattro == PyObject_GenericGetAttr ? &method_found : NULL);
- PyStackRef_CLOSE(global_super_st);
- PyStackRef_CLOSE(class_st);
if (attr_o == NULL) {
- PyStackRef_CLOSE(self_st);
- ERROR_IF(true, error);
+ ERROR_NO_POP();
}
if (method_found) {
self_or_null = self_st; // transfer ownership
PyStackRef_CLOSE(self_st);
self_or_null = PyStackRef_NULL;
}
+ PyStackRef_CLOSE(class_st);
+ PyStackRef_CLOSE(global_super_st);
attr = PyStackRef_FromPyObjectSteal(attr_o);
}
else {
/* `iterable` is not a generator. */
PyObject *iter_o = PyObject_GetIter(iterable_o);
- DEAD(iterable);
if (iter_o == NULL) {
ERROR_NO_POP();
}
/* Callable is not a normal Python function */
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
DEAD(self_or_null);
+ PyStackRef_CLOSE(callable[0]);
ERROR_IF(true, error);
}
PyObject *res_o = PyObject_Vectorcall(
}
}
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
DEAD(self_or_null);
+ PyStackRef_CLOSE(callable[0]);
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
NULL);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
DEAD(self_or_null);
+ PyStackRef_CLOSE(callable[0]);
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
op(_CALL_BUILTIN_CLASS, (callable[1], self_or_null[1], args[oparg] -- res)) {
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
-
+ DEOPT_IF(!PyType_Check(callable_o));
+ PyTypeObject *tp = (PyTypeObject *)callable_o;
int total_args = oparg;
+ _PyStackRef *arguments = args;
if (!PyStackRef_IsNull(self_or_null[0])) {
- args--;
+ arguments--;
total_args++;
}
- DEAD(self_or_null);
- DEOPT_IF(!PyType_Check(callable_o));
- PyTypeObject *tp = (PyTypeObject *)callable_o;
DEOPT_IF(tp->tp_vectorcall == NULL);
STAT_INC(CALL, hit);
- STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
+ STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
DECREF_INPUTS();
ERROR_IF(true, error);
}
+ DEAD(self_or_null);
PyObject *res_o = tp->tp_vectorcall((PyObject *)tp, args_o, total_args, NULL);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
/* Free the arguments. */
for (int i = 0; i < total_args; i++) {
- PyStackRef_CLOSE(args[i]);
+ PyStackRef_CLOSE(arguments[i]);
}
+ DEAD(args);
PyStackRef_CLOSE(callable[0]);
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
+ _PyStackRef *arguments = args;
if (!PyStackRef_IsNull(self_or_null[0])) {
- args--;
+ arguments--;
total_args++;
}
- DEAD(self_or_null);
DEOPT_IF(!PyCFunction_CheckExact(callable_o));
DEOPT_IF(PyCFunction_GET_FLAGS(callable_o) != METH_FASTCALL);
STAT_INC(CALL, hit);
PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o);
/* res = func(self, args, nargs) */
- STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
+ STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
DECREF_INPUTS();
ERROR_IF(true, error);
}
+ DEAD(self_or_null);
PyObject *res_o = ((PyCFunctionFast)(void(*)(void))cfunc)(
PyCFunction_GET_SELF(callable_o),
args_o,
/* Free the arguments. */
for (int i = 0; i < total_args; i++) {
- PyStackRef_CLOSE(args[i]);
+ PyStackRef_CLOSE(arguments[i]);
}
+ DEAD(args);
PyStackRef_CLOSE(callable[0]);
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
if (res_o == NULL) {
GOTO_ERROR(error);
}
- PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(arg_stackref);
+ DEAD(args);
+ DEAD(self_or_null);
+ PyStackRef_CLOSE(callable[0]);
res = PyStackRef_FromPyObjectSteal(res_o);
}
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
+ _PyStackRef *arguments = args;
if (!PyStackRef_IsNull(self_or_null[0])) {
- args--;
+ arguments--;
total_args++;
}
DEOPT_IF(total_args != 2);
PyInterpreterState *interp = tstate->interp;
DEOPT_IF(callable_o != interp->callable_cache.isinstance);
STAT_INC(CALL, hit);
- _PyStackRef cls_stackref = args[1];
- _PyStackRef inst_stackref = args[0];
+ _PyStackRef cls_stackref = arguments[1];
+ _PyStackRef inst_stackref = arguments[0];
int retval = PyObject_IsInstance(PyStackRef_AsPyObjectBorrow(inst_stackref), PyStackRef_AsPyObjectBorrow(cls_stackref));
if (retval < 0) {
ERROR_NO_POP();
}
res = retval ? PyStackRef_True : PyStackRef_False;
assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(inst_stackref);
- PyStackRef_CLOSE(cls_stackref);
- PyStackRef_CLOSE(callable[0]);
+ DECREF_INPUTS();
}
// This is secretly a super-instruction
}
PyStackRef_CLOSE(kwnames);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
DEAD(self_or_null);
+ PyStackRef_CLOSE(callable[0]);
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs);
if (PyTuple_CheckExact(callargs_o)) {
tuple = callargs;
+ kwargs_out = kwargs_in;
+ DEAD(kwargs_in);
DEAD(callargs);
}
else {
if (tuple_o == NULL) {
ERROR_NO_POP();
}
+ kwargs_out = kwargs_in;
+ DEAD(kwargs_in);
PyStackRef_CLOSE(callargs);
tuple = PyStackRef_FromPyObjectSteal(tuple_o);
}
- kwargs_out = kwargs_in;
- DEAD(kwargs_in);
}
op(_DO_CALL_FUNCTION_EX, (func_st, unused, callargs_st, kwargs_st if (oparg & 1) -- result)) {
inst(FORMAT_WITH_SPEC, (value, fmt_spec -- res)) {
PyObject *res_o = PyObject_Format(PyStackRef_AsPyObjectBorrow(value), PyStackRef_AsPyObjectBorrow(fmt_spec));
- PyStackRef_CLOSE(value);
- PyStackRef_CLOSE(fmt_spec);
+ DECREF_INPUTS();
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
assert(PyUnicode_CheckExact(right_o));
STAT_INC(BINARY_OP, hit);
PyObject *res_o = PyUnicode_Concat(left_o, right_o);
- PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);
PyStackRef_CLOSE_SPECIALIZED(right, _PyUnicode_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);
if (res_o == NULL) JUMP_TO_ERROR();
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2] = res;
* that the string is safe to mutate.
*/
assert(Py_REFCNT(left_o) >= 2);
- PyStackRef_CLOSE(left);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);
PyObject *temp = PyStackRef_AsPyObjectSteal(*target_local);
PyUnicode_Append(&temp, right_o);
*target_local = PyStackRef_FromPyObjectSteal(temp);
PyObject *attr_o = _PySuper_Lookup(cls, self, name,
Py_TYPE(self)->tp_getattro == PyObject_GenericGetAttr ? &method_found : NULL);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(global_super_st);
- PyStackRef_CLOSE(class_st);
if (attr_o == NULL) {
- PyStackRef_CLOSE(self_st);
- if (true) JUMP_TO_ERROR();
+ JUMP_TO_ERROR();
}
if (method_found) {
self_or_null = self_st; // transfer ownership
PyStackRef_CLOSE(self_st);
self_or_null = PyStackRef_NULL;
}
+ PyStackRef_CLOSE(class_st);
+ PyStackRef_CLOSE(global_super_st);
attr = PyStackRef_FromPyObjectSteal(attr_o);
stack_pointer[-3] = attr;
stack_pointer[-2] = self_or_null;
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
PyStackRef_CLOSE(callable[0]);
- PyStackRef_CLOSE(self_or_null[0]);
+ PyStackRef_XCLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) JUMP_TO_ERROR();
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = res;
self_or_null = &stack_pointer[-1 - oparg];
callable = &stack_pointer[-2 - oparg];
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
- int total_args = oparg;
- if (!PyStackRef_IsNull(self_or_null[0])) {
- args--;
- total_args++;
- }
if (!PyType_Check(callable_o)) {
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
}
PyTypeObject *tp = (PyTypeObject *)callable_o;
+ int total_args = oparg;
+ _PyStackRef *arguments = args;
+ if (!PyStackRef_IsNull(self_or_null[0])) {
+ arguments--;
+ total_args++;
+ }
if (tp->tp_vectorcall == NULL) {
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
}
STAT_INC(CALL, hit);
- STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
+ STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
PyStackRef_CLOSE(callable[0]);
- PyStackRef_CLOSE(self_or_null[0]);
+ PyStackRef_XCLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
/* Free the arguments. */
for (int i = 0; i < total_args; i++) {
- PyStackRef_CLOSE(args[i]);
+ PyStackRef_CLOSE(arguments[i]);
}
PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) JUMP_TO_ERROR();
/* Builtin METH_FASTCALL functions, without keywords */
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
+ _PyStackRef *arguments = args;
if (!PyStackRef_IsNull(self_or_null[0])) {
- args--;
+ arguments--;
total_args++;
}
if (!PyCFunction_CheckExact(callable_o)) {
STAT_INC(CALL, hit);
PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o);
/* res = func(self, args, nargs) */
- STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
+ STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
PyStackRef_CLOSE(callable[0]);
- PyStackRef_CLOSE(self_or_null[0]);
+ PyStackRef_XCLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
/* Free the arguments. */
for (int i = 0; i < total_args; i++) {
- PyStackRef_CLOSE(args[i]);
+ PyStackRef_CLOSE(arguments[i]);
}
PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) JUMP_TO_ERROR();
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
PyStackRef_CLOSE(callable[0]);
- PyStackRef_CLOSE(self_or_null[0]);
+ PyStackRef_XCLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
if (res_o == NULL) {
GOTO_ERROR(error);
}
- PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(arg_stackref);
+ PyStackRef_CLOSE(callable[0]);
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = res;
stack_pointer += -1 - oparg;
/* isinstance(o, o2) */
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
+ _PyStackRef *arguments = args;
if (!PyStackRef_IsNull(self_or_null[0])) {
- args--;
+ arguments--;
total_args++;
}
if (total_args != 2) {
JUMP_TO_JUMP_TARGET();
}
STAT_INC(CALL, hit);
- _PyStackRef cls_stackref = args[1];
- _PyStackRef inst_stackref = args[0];
+ _PyStackRef cls_stackref = arguments[1];
+ _PyStackRef inst_stackref = arguments[0];
_PyFrame_SetStackPointer(frame, stack_pointer);
int retval = PyObject_IsInstance(PyStackRef_AsPyObjectBorrow(inst_stackref), PyStackRef_AsPyObjectBorrow(cls_stackref));
stack_pointer = _PyFrame_GetStackPointer(frame);
}
res = retval ? PyStackRef_True : PyStackRef_False;
assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(inst_stackref);
- PyStackRef_CLOSE(cls_stackref);
PyStackRef_CLOSE(callable[0]);
+ PyStackRef_XCLOSE(self_or_null[0]);
+ for (int _i = oparg; --_i >= 0;) {
+ PyStackRef_CLOSE(args[_i]);
+ }
stack_pointer[-2 - oparg] = res;
stack_pointer += -1 - oparg;
assert(WITHIN_STACK_BOUNDS());
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
PyStackRef_CLOSE(callable[0]);
- PyStackRef_CLOSE(self_or_null[0]);
+ PyStackRef_XCLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
PyStackRef_CLOSE(callable[0]);
- PyStackRef_CLOSE(self_or_null[0]);
+ PyStackRef_XCLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
PyStackRef_CLOSE(callable[0]);
- PyStackRef_CLOSE(self_or_null[0]);
+ PyStackRef_XCLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs);
if (PyTuple_CheckExact(callargs_o)) {
tuple = callargs;
+ kwargs_out = kwargs_in;
}
else {
_PyFrame_SetStackPointer(frame, stack_pointer);
if (tuple_o == NULL) {
JUMP_TO_ERROR();
}
+ kwargs_out = kwargs_in;
PyStackRef_CLOSE(callargs);
tuple = PyStackRef_FromPyObjectSteal(tuple_o);
}
- kwargs_out = kwargs_in;
stack_pointer[-1 - (oparg & 1)] = tuple;
if (oparg & 1) stack_pointer[-(oparg & 1)] = kwargs_out;
break;
assert(PyUnicode_CheckExact(right_o));
STAT_INC(BINARY_OP, hit);
PyObject *res_o = PyUnicode_Concat(left_o, right_o);
- PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);
PyStackRef_CLOSE_SPECIALIZED(right, _PyUnicode_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);
if (res_o == NULL) goto pop_2_error;
res = PyStackRef_FromPyObjectSteal(res_o);
}
* that the string is safe to mutate.
*/
assert(Py_REFCNT(left_o) >= 2);
- PyStackRef_CLOSE(left);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);
PyObject *temp = PyStackRef_AsPyObjectSteal(*target_local);
PyUnicode_Append(&temp, right_o);
*target_local = PyStackRef_FromPyObjectSteal(temp);
/* Callable is not a normal Python function */
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
+ PyStackRef_CLOSE(callable[0]);
{
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
}
}
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) {
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
self_or_null = &stack_pointer[-1 - oparg];
callable = &stack_pointer[-2 - oparg];
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
+ DEOPT_IF(!PyType_Check(callable_o), CALL);
+ PyTypeObject *tp = (PyTypeObject *)callable_o;
int total_args = oparg;
+ _PyStackRef *arguments = args;
if (!PyStackRef_IsNull(self_or_null[0])) {
- args--;
+ arguments--;
total_args++;
}
- DEOPT_IF(!PyType_Check(callable_o), CALL);
- PyTypeObject *tp = (PyTypeObject *)callable_o;
DEOPT_IF(tp->tp_vectorcall == NULL, CALL);
STAT_INC(CALL, hit);
- STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
+ STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
PyStackRef_CLOSE(callable[0]);
- PyStackRef_CLOSE(self_or_null[0]);
+ PyStackRef_XCLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
/* Free the arguments. */
for (int i = 0; i < total_args; i++) {
- PyStackRef_CLOSE(args[i]);
+ PyStackRef_CLOSE(arguments[i]);
}
PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) {
/* Builtin METH_FASTCALL functions, without keywords */
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
+ _PyStackRef *arguments = args;
if (!PyStackRef_IsNull(self_or_null[0])) {
- args--;
+ arguments--;
total_args++;
}
DEOPT_IF(!PyCFunction_CheckExact(callable_o), CALL);
STAT_INC(CALL, hit);
PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o);
/* res = func(self, args, nargs) */
- STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
+ STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
PyStackRef_CLOSE(callable[0]);
- PyStackRef_CLOSE(self_or_null[0]);
+ PyStackRef_XCLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
/* Free the arguments. */
for (int i = 0; i < total_args; i++) {
- PyStackRef_CLOSE(args[i]);
+ PyStackRef_CLOSE(arguments[i]);
}
PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) {
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
PyStackRef_CLOSE(callable[0]);
- PyStackRef_CLOSE(self_or_null[0]);
+ PyStackRef_XCLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs);
if (PyTuple_CheckExact(callargs_o)) {
tuple = callargs;
+ kwargs_out = kwargs_in;
}
else {
_PyFrame_SetStackPointer(frame, stack_pointer);
if (tuple_o == NULL) {
goto error;
}
+ kwargs_out = kwargs_in;
PyStackRef_CLOSE(callargs);
tuple = PyStackRef_FromPyObjectSteal(tuple_o);
}
- kwargs_out = kwargs_in;
}
// _DO_CALL_FUNCTION_EX
{
/* isinstance(o, o2) */
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
+ _PyStackRef *arguments = args;
if (!PyStackRef_IsNull(self_or_null[0])) {
- args--;
+ arguments--;
total_args++;
}
DEOPT_IF(total_args != 2, CALL);
PyInterpreterState *interp = tstate->interp;
DEOPT_IF(callable_o != interp->callable_cache.isinstance, CALL);
STAT_INC(CALL, hit);
- _PyStackRef cls_stackref = args[1];
- _PyStackRef inst_stackref = args[0];
+ _PyStackRef cls_stackref = arguments[1];
+ _PyStackRef inst_stackref = arguments[0];
_PyFrame_SetStackPointer(frame, stack_pointer);
int retval = PyObject_IsInstance(PyStackRef_AsPyObjectBorrow(inst_stackref), PyStackRef_AsPyObjectBorrow(cls_stackref));
stack_pointer = _PyFrame_GetStackPointer(frame);
}
res = retval ? PyStackRef_True : PyStackRef_False;
assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(inst_stackref);
- PyStackRef_CLOSE(cls_stackref);
PyStackRef_CLOSE(callable[0]);
+ PyStackRef_XCLOSE(self_or_null[0]);
+ for (int _i = oparg; --_i >= 0;) {
+ PyStackRef_CLOSE(args[_i]);
+ }
stack_pointer[-2 - oparg] = res;
stack_pointer += -1 - oparg;
assert(WITHIN_STACK_BOUNDS());
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
PyStackRef_CLOSE(callable[0]);
- PyStackRef_CLOSE(self_or_null[0]);
+ PyStackRef_XCLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
}
PyStackRef_CLOSE(kwnames);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) {
stack_pointer += -3 - oparg;
assert(WITHIN_STACK_BOUNDS());
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
PyStackRef_CLOSE(callable[0]);
- PyStackRef_CLOSE(self_or_null[0]);
+ PyStackRef_XCLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
if (res_o == NULL) {
GOTO_ERROR(error);
}
- PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(arg_stackref);
+ PyStackRef_CLOSE(callable[0]);
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = res;
stack_pointer += -1 - oparg;
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
PyStackRef_CLOSE(callable[0]);
- PyStackRef_CLOSE(self_or_null[0]);
+ PyStackRef_XCLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
PyStackRef_CLOSE(callable[0]);
- PyStackRef_CLOSE(self_or_null[0]);
+ PyStackRef_XCLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
PyStackRef_CLOSE(callable[0]);
- PyStackRef_CLOSE(self_or_null[0]);
+ PyStackRef_XCLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) {
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
/* Callable is not a normal Python function */
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
+ PyStackRef_CLOSE(callable[0]);
{
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
}
}
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) {
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
PyObject *attr_o = _PySuper_Lookup(cls, self, name,
Py_TYPE(self)->tp_getattro == PyObject_GenericGetAttr ? &method_found : NULL);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(global_super_st);
- PyStackRef_CLOSE(class_st);
if (attr_o == NULL) {
- PyStackRef_CLOSE(self_st);
- goto pop_3_error;
+ goto error;
}
if (method_found) {
self_or_null = self_st; // transfer ownership
PyStackRef_CLOSE(self_st);
self_or_null = PyStackRef_NULL;
}
+ PyStackRef_CLOSE(class_st);
+ PyStackRef_CLOSE(global_super_st);
attr = PyStackRef_FromPyObjectSteal(attr_o);
stack_pointer[-3] = attr;
stack_pointer[-2] = self_or_null;
return False
return tkn.text in {"true", "1"}
+NON_ESCAPING_DEALLOCS = {
+ "_PyFloat_ExactDealloc",
+ "_PyLong_ExactDealloc",
+ "_PyUnicode_ExactDealloc",
+}
class Emitter:
out: CWriter
"SAVE_STACK": self.save_stack,
"RELOAD_STACK": self.reload_stack,
"PyStackRef_CLOSE": self.stackref_close,
- "PyStackRef_CLOSE_SPECIALIZED": self.stackref_close,
+ "PyStackRef_CLOSE_SPECIALIZED": self.stackref_close_specialized,
"PyStackRef_AsPyObjectSteal": self.stackref_steal,
"DISPATCH": self.dispatch,
"INSTRUCTION_SIZE": self.instruction_size,
next(tkn_iter)
next(tkn_iter)
self.out.emit_at("", tkn)
- for var in uop.stack.inputs:
- if var.name == "unused" or var.name == "null" or var.peek:
+ for var in storage.inputs:
+ if not var.defined:
+ continue
+ if var.name == "null":
continue
+ close = "PyStackRef_CLOSE"
+ if "null" in var.name or var.condition and var.condition != "1":
+ close = "PyStackRef_XCLOSE"
if var.size:
if var.size == "1":
- self.out.emit(f"PyStackRef_CLOSE({var.name}[0]);\n")
+ self.out.emit(f"{close}({var.name}[0]);\n")
else:
self.out.emit(f"for (int _i = {var.size}; --_i >= 0;) {{\n")
- self.out.emit(f"PyStackRef_CLOSE({var.name}[_i]);\n")
+ self.out.emit(f"{close}({var.name}[_i]);\n")
self.out.emit("}\n")
elif var.condition:
- if var.condition == "1":
- self.out.emit(f"PyStackRef_CLOSE({var.name});\n")
- elif var.condition != "0":
- self.out.emit(f"PyStackRef_XCLOSE({var.name});\n")
+ if var.condition != "0":
+ self.out.emit(f"{close}({var.name});\n")
else:
- self.out.emit(f"PyStackRef_CLOSE({var.name});\n")
+ self.out.emit(f"{close}({var.name});\n")
for input in storage.inputs:
input.defined = False
return True
raise analysis_error(f"'{name}' is not a live input-only variable", name_tkn)
return True
+ def stackref_kill(
+ self,
+ name: Token,
+ storage: Storage,
+ escapes: bool
+ ) -> bool:
+ live = ""
+ for var in reversed(storage.inputs):
+ if var.name == name.text:
+ if live and escapes:
+ raise analysis_error(
+ f"Cannot close '{name.text}' when "
+ f"'{live}' is still live", name)
+ var.defined = False
+ break
+ if var.defined:
+ live = var.name
+ return True
+
def stackref_close(
self,
tkn: Token,
name = next(tkn_iter)
self.out.emit(name)
if name.kind == "IDENTIFIER":
- for var in storage.inputs:
- if var.name == name.text:
- var.defined = False
+ return self.stackref_kill(name, storage, True)
rparen = emit_to(self.out, tkn_iter, "RPAREN")
self.emit(rparen)
return True
- stackref_steal = stackref_close
+ def stackref_close_specialized(
+ self,
+ tkn: Token,
+ tkn_iter: TokenIterator,
+ uop: Uop,
+ storage: Storage,
+ inst: Instruction | None,
+ ) -> bool:
+
+ self.out.emit(tkn)
+ tkn = next(tkn_iter)
+ assert tkn.kind == "LPAREN"
+ self.out.emit(tkn)
+ name = next(tkn_iter)
+ self.out.emit(name)
+ comma = next(tkn_iter)
+ if comma.kind != "COMMA":
+ raise analysis_error("Expected comma", comma)
+ self.out.emit(comma)
+ dealloc = next(tkn_iter)
+ if dealloc.kind != "IDENTIFIER":
+ raise analysis_error("Expected identifier", dealloc)
+ self.out.emit(dealloc)
+ if name.kind == "IDENTIFIER":
+ escapes = dealloc.text not in NON_ESCAPING_DEALLOCS
+ return self.stackref_kill(name, storage, escapes)
+ rparen = emit_to(self.out, tkn_iter, "RPAREN")
+ self.emit(rparen)
+ return True
+
+ def stackref_steal(
+ self,
+ tkn: Token,
+ tkn_iter: TokenIterator,
+ uop: Uop,
+ storage: Storage,
+ inst: Instruction | None,
+ ) -> bool:
+ self.out.emit(tkn)
+ tkn = next(tkn_iter)
+ assert tkn.kind == "LPAREN"
+ self.out.emit(tkn)
+ name = next(tkn_iter)
+ self.out.emit(name)
+ if name.kind == "IDENTIFIER":
+ return self.stackref_kill(name, storage, False)
+ rparen = emit_to(self.out, tkn_iter, "RPAREN")
+ self.emit(rparen)
+ return True
def sync_sp(
self,
storage.push_outputs()
self._print_storage(storage)
except StackError as ex:
- raise analysis_error(ex.args[0], rbrace)
+ raise analysis_error(ex.args[0], rbrace) from None
return storage
def emit(self, txt: str | Token) -> None:
projects / thirdparty / Python / cpython.git / commitdiff
