diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 59f3db48f80283..ef42a10c4d572e 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -140,7 +140,7 @@ dummy_func( DECREF_INPUTS(); } - inst(PUSH_NULL, (-- res)) { + inst(PUSH_NULL, (-- res: NULL)) { res = NULL; } @@ -184,7 +184,7 @@ dummy_func( }; - inst(BINARY_OP_MULTIPLY_INT, (unused/1, left, right -- prod)) { + inst(BINARY_OP_MULTIPLY_INT, (unused/1, left, right -- prod: PyLong_Type)) { assert(cframe.use_tracing == 0); DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP); DEOPT_IF(!PyLong_CheckExact(right), BINARY_OP); @@ -195,7 +195,7 @@ dummy_func( ERROR_IF(prod == NULL, error); } - inst(BINARY_OP_MULTIPLY_FLOAT, (unused/1, left, right -- prod)) { + inst(BINARY_OP_MULTIPLY_FLOAT, (unused/1, left, right -- prod: PyFloat_Type)) { assert(cframe.use_tracing == 0); DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP); DEOPT_IF(!PyFloat_CheckExact(right), BINARY_OP); @@ -208,7 +208,7 @@ dummy_func( ERROR_IF(prod == NULL, error); } - inst(BINARY_OP_SUBTRACT_INT, (unused/1, left, right -- sub)) { + inst(BINARY_OP_SUBTRACT_INT, (unused/1, left, right -- sub: PyLong_Type)) { assert(cframe.use_tracing == 0); DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP); DEOPT_IF(!PyLong_CheckExact(right), BINARY_OP); @@ -219,7 +219,7 @@ dummy_func( ERROR_IF(sub == NULL, error); } - inst(BINARY_OP_SUBTRACT_FLOAT, (unused/1, left, right -- sub)) { + inst(BINARY_OP_SUBTRACT_FLOAT, (unused/1, left, right -- sub: PyFloat_Type)) { assert(cframe.use_tracing == 0); DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP); DEOPT_IF(!PyFloat_CheckExact(right), BINARY_OP); @@ -231,7 +231,7 @@ dummy_func( ERROR_IF(sub == NULL, error); } - inst(BINARY_OP_ADD_UNICODE, (unused/1, left, right -- res)) { + inst(BINARY_OP_ADD_UNICODE, (unused/1, left, right -- res: PyUnicode_Type)) { assert(cframe.use_tracing == 0); DEOPT_IF(!PyUnicode_CheckExact(left), BINARY_OP); DEOPT_IF(Py_TYPE(right) != Py_TYPE(left), BINARY_OP); @@ -278,7 +278,7 @@ dummy_func( JUMPBY(INLINE_CACHE_ENTRIES_BINARY_OP + 1); } - inst(BINARY_OP_ADD_FLOAT, (unused/1, left, right -- sum)) { + inst(BINARY_OP_ADD_FLOAT, (unused/1, left, right -- sum: PyFloat_Type)) { assert(cframe.use_tracing == 0); DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP); DEOPT_IF(Py_TYPE(right) != Py_TYPE(left), BINARY_OP); @@ -291,7 +291,7 @@ dummy_func( ERROR_IF(sum == NULL, error); } - macro_inst(BINARY_OP_ADD_INT, (unused/1, left, right -- sum)) { + macro_inst(BINARY_OP_ADD_INT, (unused/1, left, right -- sum: PyLong_Type)) { assert(cframe.use_tracing == 0); DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP); DEOPT_IF(Py_TYPE(right) != Py_TYPE(left), BINARY_OP); @@ -303,7 +303,7 @@ dummy_func( bb_test = PyLong_CheckExact(left) && (Py_TYPE(left) == Py_TYPE(right)); } - u_inst(BINARY_OP_ADD_INT_REST, (left : PyLong_Type, right : PyLong_Type -- sum : PyLong_Type)) { + u_inst(BINARY_OP_ADD_INT_REST, (left, right -- sum : PyLong_Type)) { STAT_INC(BINARY_OP, hit); sum = _PyLong_Add((PyLongObject *)left, (PyLongObject *)right); _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free); @@ -1274,7 +1274,7 @@ dummy_func( } } - inst(BUILD_STRING, (pieces[oparg] -- str)) { + inst(BUILD_STRING, (pieces[oparg] -- str: PyUnicode_Type)) { str = _PyUnicode_JoinArray(&_Py_STR(empty), pieces, oparg); for (int i = 0; i < oparg; i++) { Py_DECREF(pieces[i]); @@ -1282,12 +1282,12 @@ dummy_func( ERROR_IF(str == NULL, error); } - inst(BUILD_TUPLE, (values[oparg] -- tup)) { + inst(BUILD_TUPLE, (values[oparg] -- tup: PyTuple_Type)) { tup = _PyTuple_FromArraySteal(values, oparg); ERROR_IF(tup == NULL, error); } - inst(BUILD_LIST, (values[oparg] -- list)) { + inst(BUILD_LIST, (values[oparg] -- list: PyList_Type)) { list = _PyList_FromArraySteal(values, oparg); ERROR_IF(list == NULL, error); } @@ -1316,7 +1316,7 @@ dummy_func( ERROR_IF(err < 0, error); } - inst(BUILD_SET, (values[oparg] -- set)) { + inst(BUILD_SET, (values[oparg] -- set: PySet_Type)) { set = PySet_New(NULL); if (set == NULL) goto error; @@ -1333,7 +1333,7 @@ dummy_func( } } - inst(BUILD_MAP, (values[oparg*2] -- map)) { + inst(BUILD_MAP, (values[oparg*2] -- map: PyDict_Type)) { map = _PyDict_FromItems( values, 2, values+1, 2, @@ -1390,7 +1390,7 @@ dummy_func( } } - inst(BUILD_CONST_KEY_MAP, (values[oparg], keys -- map)) { + inst(BUILD_CONST_KEY_MAP, (values[oparg], keys -- map: PyDict_Type)) { if (!PyTuple_CheckExact(keys) || PyTuple_GET_SIZE(keys) != (Py_ssize_t)oparg) { _PyErr_SetString(tstate, PyExc_SystemError, @@ -1835,13 +1835,13 @@ dummy_func( } } - inst(IS_OP, (left, right -- b)) { + inst(IS_OP, (left, right -- b: PyBool_Type)) { int res = Py_Is(left, right) ^ oparg; DECREF_INPUTS(); b = Py_NewRef(res ? Py_True : Py_False); } - inst(CONTAINS_OP, (left, right -- b)) { + inst(CONTAINS_OP, (left, right -- b: PyBool_Type)) { int res = PySequence_Contains(right, left); DECREF_INPUTS(); ERROR_IF(res < 0, error); @@ -1869,7 +1869,7 @@ dummy_func( } } - inst(CHECK_EXC_MATCH, (left, right -- left, b)) { + inst(CHECK_EXC_MATCH, (left, right -- left, b: PyBool_Type)) { assert(PyExceptionInstance_Check(left)); if (check_except_type_valid(tstate, right) < 0) { DECREF_INPUTS(); @@ -2155,7 +2155,7 @@ dummy_func( JUMPBY(-oparg); } - inst(GET_LEN, (obj -- obj, len_o)) { + inst(GET_LEN, (obj -- obj, len_o: PyLong_Type)) { // PUSH(len(TOS)) Py_ssize_t len_i = PyObject_Length(obj); ERROR_IF(len_i < 0, error); @@ -2178,13 +2178,13 @@ dummy_func( } } - inst(MATCH_MAPPING, (subject -- subject, res)) { + inst(MATCH_MAPPING, (subject -- subject, res: PyBool_Type)) { int match = Py_TYPE(subject)->tp_flags & Py_TPFLAGS_MAPPING; res = Py_NewRef(match ? Py_True : Py_False); PREDICT(POP_JUMP_IF_FALSE); } - inst(MATCH_SEQUENCE, (subject -- subject, res)) { + inst(MATCH_SEQUENCE, (subject -- subject, res: PyBool_Type)) { int match = Py_TYPE(subject)->tp_flags & Py_TPFLAGS_SEQUENCE; res = Py_NewRef(match ? Py_True : Py_False); PREDICT(POP_JUMP_IF_FALSE); @@ -2455,7 +2455,7 @@ dummy_func( } } - inst(WITH_EXCEPT_START, (exit_func, lasti, unused, val -- exit_func, lasti, unused, val, res)) { + inst(WITH_EXCEPT_START, (exit_func, lasti, unused, val -- exit_func, lasti: PyLong_Type, unused, val, res)) { /* At the top of the stack are 4 values: - val: TOP = exc_info() - unused: SECOND = previous exception @@ -3247,7 +3247,7 @@ dummy_func( } } - inst(COPY, (bottom, unused[oparg-1] -- bottom, unused[oparg-1], top)) { + inst(COPY, (bottom, unused[oparg-1] -- bottom, unused[oparg-1], top: *bottom)) { assert(oparg > 0); top = Py_NewRef(bottom); } @@ -3274,7 +3274,7 @@ dummy_func( } inst(SWAP, (bottom, unused[oparg-2], top -- - top, unused[oparg-2], bottom)) { + top : *top, unused[oparg-2], bottom : *bottom)) { assert(oparg >= 2); } diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index ba0aa72c68f22d..8aac7f5e2fa8f9 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -1,5 +1,5 @@ -// This file is generated by Tools\cases_generator\generate_cases.py -// from Python\bytecodes.c +// This file is generated by Tools/cases_generator/generate_cases.py +// from Python/bytecodes.c // Do not edit! #define UOP_BINARY_OP_ADD_INT_REST() \ @@ -2646,7 +2646,7 @@ // This gets set so BRANCH_BB knows whether to pop // the type stack (type propagation) when generating the // target BB - gen_bb_requires_pop = jump; + gen_bb_requires_pop = !jump; STACK_SHRINK(1); STACK_GROW((jump ? 1 : 0)); DISPATCH(); @@ -2710,7 +2710,7 @@ // This gets set so BRANCH_BB knows whether to pop // the type stack (type propagation) when generating the // target BB - gen_bb_requires_pop = jump; + gen_bb_requires_pop = !jump; STACK_SHRINK(1); STACK_GROW((jump ? 1 : 0)); DISPATCH(); diff --git a/Python/tier2_typepropagator.c.h b/Python/tier2_typepropagator.c.h index 786eff5afbcf23..787d956eab0e72 100644 --- a/Python/tier2_typepropagator.c.h +++ b/Python/tier2_typepropagator.c.h @@ -1,5 +1,5 @@ -// This file is generated by Tools\cases_generator\generate_cases.py @TODO: make this a seperate argument -// from Python\bytecodes.c +// This file is generated by Tools/cases_generator/generate_cases.py @TODO: make this a seperate argument +// from Python/bytecodes.c // Do not edit! TARGET(NOP) { @@ -46,7 +46,6 @@ } TARGET(POP_TOP) { - PyTypeObject *value = TYPESTACK_PEEK(1); STACK_SHRINK(1); break; } @@ -59,243 +58,181 @@ TARGET(END_FOR) { { - PyTypeObject *value = TYPESTACK_PEEK(1); STACK_SHRINK(1); } { - PyTypeObject *value = TYPESTACK_PEEK(1); STACK_SHRINK(1); } break; } TARGET(UNARY_NEGATIVE) { - PyTypeObject *value = TYPESTACK_PEEK(1); TYPESTACK_POKE(1, NULL); break; } TARGET(UNARY_NOT) { - PyTypeObject *value = TYPESTACK_PEEK(1); TYPESTACK_POKE(1, NULL); break; } TARGET(UNARY_INVERT) { - PyTypeObject *value = TYPESTACK_PEEK(1); TYPESTACK_POKE(1, NULL); break; } TARGET(BINARY_OP_MULTIPLY_INT) { - PyTypeObject *right = TYPESTACK_PEEK(1); - PyTypeObject *left = TYPESTACK_PEEK(2); STACK_SHRINK(1); - TYPESTACK_POKE(1, NULL); + TYPESTACK_POKE(1, &PyLong_Type); break; } TARGET(BINARY_OP_MULTIPLY_FLOAT) { - PyTypeObject *right = TYPESTACK_PEEK(1); - PyTypeObject *left = TYPESTACK_PEEK(2); STACK_SHRINK(1); - TYPESTACK_POKE(1, NULL); + TYPESTACK_POKE(1, &PyFloat_Type); break; } TARGET(BINARY_OP_SUBTRACT_INT) { - PyTypeObject *right = TYPESTACK_PEEK(1); - PyTypeObject *left = TYPESTACK_PEEK(2); STACK_SHRINK(1); - TYPESTACK_POKE(1, NULL); + TYPESTACK_POKE(1, &PyLong_Type); break; } TARGET(BINARY_OP_SUBTRACT_FLOAT) { - PyTypeObject *right = TYPESTACK_PEEK(1); - PyTypeObject *left = TYPESTACK_PEEK(2); STACK_SHRINK(1); - TYPESTACK_POKE(1, NULL); + TYPESTACK_POKE(1, &PyFloat_Type); break; } TARGET(BINARY_OP_ADD_UNICODE) { - PyTypeObject *right = TYPESTACK_PEEK(1); - PyTypeObject *left = TYPESTACK_PEEK(2); STACK_SHRINK(1); - TYPESTACK_POKE(1, NULL); + TYPESTACK_POKE(1, &PyUnicode_Type); break; } TARGET(BINARY_OP_INPLACE_ADD_UNICODE) { - PyTypeObject *right = TYPESTACK_PEEK(1); - PyTypeObject *left = TYPESTACK_PEEK(2); STACK_SHRINK(2); break; } TARGET(BINARY_OP_ADD_FLOAT) { - PyTypeObject *right = TYPESTACK_PEEK(1); - PyTypeObject *left = TYPESTACK_PEEK(2); STACK_SHRINK(1); - TYPESTACK_POKE(1, NULL); + TYPESTACK_POKE(1, &PyFloat_Type); break; } TARGET(BINARY_OP_ADD_INT) { - PyTypeObject *right = TYPESTACK_PEEK(1); - PyTypeObject *left = TYPESTACK_PEEK(2); STACK_SHRINK(1); - TYPESTACK_POKE(1, NULL); + TYPESTACK_POKE(1, &PyLong_Type); break; } TARGET(BINARY_CHECK_INT) { - PyTypeObject *right = TYPESTACK_PEEK(1); - PyTypeObject *left = TYPESTACK_PEEK(2); TYPESTACK_POKE(1, &PyLong_Type); TYPESTACK_POKE(2, &PyLong_Type); break; } TARGET(BINARY_OP_ADD_INT_REST) { - PyTypeObject *right = TYPESTACK_PEEK(1); - PyTypeObject *left = TYPESTACK_PEEK(2); STACK_SHRINK(1); TYPESTACK_POKE(1, &PyLong_Type); break; } TARGET(BINARY_SUBSCR) { - PyTypeObject *sub = TYPESTACK_PEEK(1); - PyTypeObject *container = TYPESTACK_PEEK(2); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); break; } TARGET(BINARY_SLICE) { - PyTypeObject *stop = TYPESTACK_PEEK(1); - PyTypeObject *start = TYPESTACK_PEEK(2); - PyTypeObject *container = TYPESTACK_PEEK(3); STACK_SHRINK(2); TYPESTACK_POKE(1, NULL); break; } TARGET(STORE_SLICE) { - PyTypeObject *stop = TYPESTACK_PEEK(1); - PyTypeObject *start = TYPESTACK_PEEK(2); - PyTypeObject *container = TYPESTACK_PEEK(3); - PyTypeObject *v = TYPESTACK_PEEK(4); STACK_SHRINK(4); break; } TARGET(BINARY_SUBSCR_LIST_INT) { - PyTypeObject *sub = TYPESTACK_PEEK(1); - PyTypeObject *list = TYPESTACK_PEEK(2); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); break; } TARGET(BINARY_SUBSCR_TUPLE_INT) { - PyTypeObject *sub = TYPESTACK_PEEK(1); - PyTypeObject *tuple = TYPESTACK_PEEK(2); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); break; } TARGET(BINARY_SUBSCR_DICT) { - PyTypeObject *sub = TYPESTACK_PEEK(1); - PyTypeObject *dict = TYPESTACK_PEEK(2); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); break; } TARGET(BINARY_SUBSCR_GETITEM) { - PyTypeObject *sub = TYPESTACK_PEEK(1); - PyTypeObject *container = TYPESTACK_PEEK(2); STACK_SHRINK(1); break; } TARGET(LIST_APPEND) { - PyTypeObject *v = TYPESTACK_PEEK(1); - PyTypeObject *list = TYPESTACK_PEEK(2 + (oparg-1)); STACK_SHRINK(1); break; } TARGET(SET_ADD) { - PyTypeObject *v = TYPESTACK_PEEK(1); - PyTypeObject *set = TYPESTACK_PEEK(2 + (oparg-1)); STACK_SHRINK(1); break; } TARGET(STORE_SUBSCR) { - PyTypeObject *sub = TYPESTACK_PEEK(1); - PyTypeObject *container = TYPESTACK_PEEK(2); - PyTypeObject *v = TYPESTACK_PEEK(3); STACK_SHRINK(3); break; } TARGET(STORE_SUBSCR_LIST_INT) { - PyTypeObject *sub = TYPESTACK_PEEK(1); - PyTypeObject *list = TYPESTACK_PEEK(2); - PyTypeObject *value = TYPESTACK_PEEK(3); STACK_SHRINK(3); break; } TARGET(STORE_SUBSCR_DICT) { - PyTypeObject *sub = TYPESTACK_PEEK(1); - PyTypeObject *dict = TYPESTACK_PEEK(2); - PyTypeObject *value = TYPESTACK_PEEK(3); STACK_SHRINK(3); break; } TARGET(DELETE_SUBSCR) { - PyTypeObject *sub = TYPESTACK_PEEK(1); - PyTypeObject *container = TYPESTACK_PEEK(2); STACK_SHRINK(2); break; } TARGET(CALL_INTRINSIC_1) { - PyTypeObject *value = TYPESTACK_PEEK(1); TYPESTACK_POKE(1, NULL); break; } TARGET(CALL_INTRINSIC_2) { - PyTypeObject *value1 = TYPESTACK_PEEK(1); - PyTypeObject *value2 = TYPESTACK_PEEK(2); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); break; } TARGET(RAISE_VARARGS) { - PyTypeObject **args = &TYPESTACK_PEEK(oparg); - STACK_SHRINK(oparg); + fprintf(stderr, "Type propagation across `RAISE_VARARGS` shouldn't be handled statically!\n"); + Py_UNREACHABLE(); break; } TARGET(INTERPRETER_EXIT) { - PyTypeObject *retval = TYPESTACK_PEEK(1); STACK_SHRINK(1); break; } TARGET(RETURN_VALUE) { - PyTypeObject *retval = TYPESTACK_PEEK(1); STACK_SHRINK(1); break; } @@ -305,67 +242,57 @@ } TARGET(GET_AITER) { - PyTypeObject *obj = TYPESTACK_PEEK(1); TYPESTACK_POKE(1, NULL); break; } TARGET(GET_ANEXT) { - PyTypeObject *aiter = TYPESTACK_PEEK(1); STACK_GROW(1); TYPESTACK_POKE(1, NULL); break; } TARGET(GET_AWAITABLE) { - PyTypeObject *iterable = TYPESTACK_PEEK(1); TYPESTACK_POKE(1, NULL); break; } TARGET(SEND) { - PyTypeObject *v = TYPESTACK_PEEK(1); - PyTypeObject *receiver = TYPESTACK_PEEK(2); - TYPESTACK_POKE(1, NULL); + fprintf(stderr, "Type propagation across `SEND` shouldn't be handled statically!\n"); + Py_UNREACHABLE(); break; } TARGET(SEND_GEN) { - PyTypeObject *v = TYPESTACK_PEEK(1); - PyTypeObject *receiver = TYPESTACK_PEEK(2); - STACK_SHRINK(1); + fprintf(stderr, "Type propagation across `SEND_GEN` shouldn't be handled statically!\n"); + Py_UNREACHABLE(); break; } TARGET(YIELD_VALUE) { - PyTypeObject *retval = TYPESTACK_PEEK(1); + fprintf(stderr, "Type propagation across `YIELD_VALUE` shouldn't be handled statically!\n"); + Py_UNREACHABLE(); break; } TARGET(POP_EXCEPT) { - PyTypeObject *exc_value = TYPESTACK_PEEK(1); - STACK_SHRINK(1); + fprintf(stderr, "Type propagation across `POP_EXCEPT` shouldn't be handled statically!\n"); + Py_UNREACHABLE(); break; } TARGET(RERAISE) { - PyTypeObject *exc = TYPESTACK_PEEK(1); - PyTypeObject **values = &TYPESTACK_PEEK(1 + oparg); - STACK_SHRINK(1); + fprintf(stderr, "Type propagation across `RERAISE` shouldn't be handled statically!\n"); + Py_UNREACHABLE(); break; } TARGET(END_ASYNC_FOR) { - PyTypeObject *exc = TYPESTACK_PEEK(1); - PyTypeObject *awaitable = TYPESTACK_PEEK(2); STACK_SHRINK(2); break; } TARGET(CLEANUP_THROW) { - PyTypeObject *exc_value = TYPESTACK_PEEK(1); - PyTypeObject *last_sent_val = TYPESTACK_PEEK(2); - PyTypeObject *sub_iter = TYPESTACK_PEEK(3); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); TYPESTACK_POKE(2, NULL); @@ -385,7 +312,6 @@ } TARGET(STORE_NAME) { - PyTypeObject *v = TYPESTACK_PEEK(1); STACK_SHRINK(1); break; } @@ -395,14 +321,12 @@ } TARGET(UNPACK_SEQUENCE) { - PyTypeObject *seq = TYPESTACK_PEEK(1); STACK_SHRINK(1); STACK_GROW(oparg); break; } TARGET(UNPACK_SEQUENCE_TWO_TUPLE) { - PyTypeObject *seq = TYPESTACK_PEEK(1); STACK_SHRINK(1); STACK_GROW(oparg); TYPESTACK_POKE(oparg, NULL); @@ -410,7 +334,6 @@ } TARGET(UNPACK_SEQUENCE_TUPLE) { - PyTypeObject *seq = TYPESTACK_PEEK(1); STACK_SHRINK(1); STACK_GROW(oparg); TYPESTACK_POKE(oparg, NULL); @@ -418,7 +341,6 @@ } TARGET(UNPACK_SEQUENCE_LIST) { - PyTypeObject *seq = TYPESTACK_PEEK(1); STACK_SHRINK(1); STACK_GROW(oparg); TYPESTACK_POKE(oparg, NULL); @@ -426,26 +348,21 @@ } TARGET(UNPACK_EX) { - PyTypeObject *seq = TYPESTACK_PEEK(1); STACK_GROW((oparg & 0xFF) + (oparg >> 8)); break; } TARGET(STORE_ATTR) { - PyTypeObject *owner = TYPESTACK_PEEK(1); - PyTypeObject *v = TYPESTACK_PEEK(2); STACK_SHRINK(2); break; } TARGET(DELETE_ATTR) { - PyTypeObject *owner = TYPESTACK_PEEK(1); STACK_SHRINK(1); break; } TARGET(STORE_GLOBAL) { - PyTypeObject *v = TYPESTACK_PEEK(1); STACK_SHRINK(1); break; } @@ -485,12 +402,14 @@ } TARGET(DELETE_FAST) { - TYPELOCALS_SET(oparg, NULL) + fprintf(stderr, "Type propagation across `DELETE_FAST` shouldn't be handled statically!\n"); + Py_UNREACHABLE(); break; } TARGET(MAKE_CELL) { - TYPELOCALS_SET(oparg, NULL) + fprintf(stderr, "Type propagation across `MAKE_CELL` shouldn't be handled statically!\n"); + Py_UNREACHABLE(); break; } @@ -505,13 +424,12 @@ } TARGET(LOAD_DEREF) { - STACK_GROW(1); - TYPESTACK_POKE(1, NULL); + fprintf(stderr, "Type propagation across `LOAD_DEREF` shouldn't be handled statically!\n"); + Py_UNREACHABLE(); break; } TARGET(STORE_DEREF) { - PyTypeObject *v = TYPESTACK_PEEK(1); STACK_SHRINK(1); break; } @@ -521,56 +439,47 @@ } TARGET(BUILD_STRING) { - PyTypeObject **pieces = &TYPESTACK_PEEK(oparg); STACK_SHRINK(oparg); STACK_GROW(1); - TYPESTACK_POKE(1, NULL); + TYPESTACK_POKE(1, &PyUnicode_Type); break; } TARGET(BUILD_TUPLE) { - PyTypeObject **values = &TYPESTACK_PEEK(oparg); STACK_SHRINK(oparg); STACK_GROW(1); - TYPESTACK_POKE(1, NULL); + TYPESTACK_POKE(1, &PyTuple_Type); break; } TARGET(BUILD_LIST) { - PyTypeObject **values = &TYPESTACK_PEEK(oparg); STACK_SHRINK(oparg); STACK_GROW(1); - TYPESTACK_POKE(1, NULL); + TYPESTACK_POKE(1, &PyList_Type); break; } TARGET(LIST_EXTEND) { - PyTypeObject *iterable = TYPESTACK_PEEK(1); - PyTypeObject *list = TYPESTACK_PEEK(2 + (oparg-1)); STACK_SHRINK(1); break; } TARGET(SET_UPDATE) { - PyTypeObject *iterable = TYPESTACK_PEEK(1); - PyTypeObject *set = TYPESTACK_PEEK(2 + (oparg-1)); STACK_SHRINK(1); break; } TARGET(BUILD_SET) { - PyTypeObject **values = &TYPESTACK_PEEK(oparg); STACK_SHRINK(oparg); STACK_GROW(1); - TYPESTACK_POKE(1, NULL); + TYPESTACK_POKE(1, &PySet_Type); break; } TARGET(BUILD_MAP) { - PyTypeObject **values = &TYPESTACK_PEEK(oparg*2); STACK_SHRINK(oparg*2); STACK_GROW(1); - TYPESTACK_POKE(1, NULL); + TYPESTACK_POKE(1, &PyDict_Type); break; } @@ -579,34 +488,27 @@ } TARGET(BUILD_CONST_KEY_MAP) { - PyTypeObject *keys = TYPESTACK_PEEK(1); - PyTypeObject **values = &TYPESTACK_PEEK(1 + oparg); STACK_SHRINK(oparg); - TYPESTACK_POKE(1, NULL); + TYPESTACK_POKE(1, &PyDict_Type); break; } TARGET(DICT_UPDATE) { - PyTypeObject *update = TYPESTACK_PEEK(1); STACK_SHRINK(1); break; } TARGET(DICT_MERGE) { - PyTypeObject *update = TYPESTACK_PEEK(1); STACK_SHRINK(1); break; } TARGET(MAP_ADD) { - PyTypeObject *value = TYPESTACK_PEEK(1); - PyTypeObject *key = TYPESTACK_PEEK(2); STACK_SHRINK(2); break; } TARGET(LOAD_ATTR) { - PyTypeObject *owner = TYPESTACK_PEEK(1); STACK_GROW(((oparg & 1) ? 1 : 0)); TYPESTACK_POKE(1, NULL); if (oparg & 1) { TYPESTACK_POKE(1 + ((oparg & 1) ? 1 : 0), NULL); } @@ -614,7 +516,6 @@ } TARGET(LOAD_ATTR_INSTANCE_VALUE) { - PyTypeObject *owner = TYPESTACK_PEEK(1); STACK_GROW(((oparg & 1) ? 1 : 0)); TYPESTACK_POKE(1, NULL); if (oparg & 1) { TYPESTACK_POKE(1 + ((oparg & 1) ? 1 : 0), NULL); } @@ -622,7 +523,6 @@ } TARGET(LOAD_ATTR_MODULE) { - PyTypeObject *owner = TYPESTACK_PEEK(1); STACK_GROW(((oparg & 1) ? 1 : 0)); TYPESTACK_POKE(1, NULL); if (oparg & 1) { TYPESTACK_POKE(1 + ((oparg & 1) ? 1 : 0), NULL); } @@ -630,7 +530,6 @@ } TARGET(LOAD_ATTR_WITH_HINT) { - PyTypeObject *owner = TYPESTACK_PEEK(1); STACK_GROW(((oparg & 1) ? 1 : 0)); TYPESTACK_POKE(1, NULL); if (oparg & 1) { TYPESTACK_POKE(1 + ((oparg & 1) ? 1 : 0), NULL); } @@ -638,7 +537,6 @@ } TARGET(LOAD_ATTR_SLOT) { - PyTypeObject *owner = TYPESTACK_PEEK(1); STACK_GROW(((oparg & 1) ? 1 : 0)); TYPESTACK_POKE(1, NULL); if (oparg & 1) { TYPESTACK_POKE(1 + ((oparg & 1) ? 1 : 0), NULL); } @@ -646,7 +544,6 @@ } TARGET(LOAD_ATTR_CLASS) { - PyTypeObject *cls = TYPESTACK_PEEK(1); STACK_GROW(((oparg & 1) ? 1 : 0)); TYPESTACK_POKE(1, NULL); if (oparg & 1) { TYPESTACK_POKE(1 + ((oparg & 1) ? 1 : 0), NULL); } @@ -654,115 +551,86 @@ } TARGET(LOAD_ATTR_PROPERTY) { - PyTypeObject *owner = TYPESTACK_PEEK(1); STACK_GROW(((oparg & 1) ? 1 : 0)); break; } TARGET(LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN) { - PyTypeObject *owner = TYPESTACK_PEEK(1); STACK_GROW(((oparg & 1) ? 1 : 0)); break; } TARGET(STORE_ATTR_INSTANCE_VALUE) { - PyTypeObject *owner = TYPESTACK_PEEK(1); - PyTypeObject *value = TYPESTACK_PEEK(2); STACK_SHRINK(2); break; } TARGET(STORE_ATTR_WITH_HINT) { - PyTypeObject *owner = TYPESTACK_PEEK(1); - PyTypeObject *value = TYPESTACK_PEEK(2); STACK_SHRINK(2); break; } TARGET(STORE_ATTR_SLOT) { - PyTypeObject *owner = TYPESTACK_PEEK(1); - PyTypeObject *value = TYPESTACK_PEEK(2); STACK_SHRINK(2); break; } TARGET(COMPARE_OP) { - PyTypeObject *right = TYPESTACK_PEEK(1); - PyTypeObject *left = TYPESTACK_PEEK(2); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); break; } TARGET(COMPARE_AND_BRANCH) { - PyTypeObject *right = TYPESTACK_PEEK(1); - PyTypeObject *left = TYPESTACK_PEEK(2); STACK_SHRINK(2); break; } TARGET(COMPARE_AND_BRANCH_FLOAT) { - PyTypeObject *right = TYPESTACK_PEEK(1); - PyTypeObject *left = TYPESTACK_PEEK(2); STACK_SHRINK(2); break; } TARGET(COMPARE_AND_BRANCH_INT) { - PyTypeObject *right = TYPESTACK_PEEK(1); - PyTypeObject *left = TYPESTACK_PEEK(2); STACK_SHRINK(2); break; } TARGET(COMPARE_AND_BRANCH_STR) { - PyTypeObject *right = TYPESTACK_PEEK(1); - PyTypeObject *left = TYPESTACK_PEEK(2); STACK_SHRINK(2); break; } TARGET(IS_OP) { - PyTypeObject *right = TYPESTACK_PEEK(1); - PyTypeObject *left = TYPESTACK_PEEK(2); STACK_SHRINK(1); - TYPESTACK_POKE(1, NULL); + TYPESTACK_POKE(1, &PyBool_Type); break; } TARGET(CONTAINS_OP) { - PyTypeObject *right = TYPESTACK_PEEK(1); - PyTypeObject *left = TYPESTACK_PEEK(2); STACK_SHRINK(1); - TYPESTACK_POKE(1, NULL); + TYPESTACK_POKE(1, &PyBool_Type); break; } TARGET(CHECK_EG_MATCH) { - PyTypeObject *match_type = TYPESTACK_PEEK(1); - PyTypeObject *exc_value = TYPESTACK_PEEK(2); TYPESTACK_POKE(1, NULL); TYPESTACK_POKE(2, NULL); break; } TARGET(CHECK_EXC_MATCH) { - PyTypeObject *right = TYPESTACK_PEEK(1); - PyTypeObject *left = TYPESTACK_PEEK(2); - TYPESTACK_POKE(1, NULL); + TYPESTACK_POKE(1, &PyBool_Type); break; } TARGET(IMPORT_NAME) { - PyTypeObject *fromlist = TYPESTACK_PEEK(1); - PyTypeObject *level = TYPESTACK_PEEK(2); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); break; } TARGET(IMPORT_FROM) { - PyTypeObject *from = TYPESTACK_PEEK(1); STACK_GROW(1); TYPESTACK_POKE(1, NULL); break; @@ -781,73 +649,65 @@ } TARGET(POP_JUMP_IF_FALSE) { - PyTypeObject *cond = TYPESTACK_PEEK(1); STACK_SHRINK(1); break; } TARGET(BB_TEST_POP_IF_FALSE) { - PyTypeObject *cond = TYPESTACK_PEEK(1); STACK_SHRINK(1); break; } TARGET(POP_JUMP_IF_TRUE) { - PyTypeObject *cond = TYPESTACK_PEEK(1); STACK_SHRINK(1); break; } TARGET(BB_TEST_POP_IF_TRUE) { - PyTypeObject *cond = TYPESTACK_PEEK(1); STACK_SHRINK(1); break; } TARGET(POP_JUMP_IF_NOT_NONE) { - PyTypeObject *value = TYPESTACK_PEEK(1); STACK_SHRINK(1); break; } TARGET(BB_TEST_POP_IF_NOT_NONE) { - PyTypeObject *value = TYPESTACK_PEEK(1); STACK_SHRINK(1); break; } TARGET(POP_JUMP_IF_NONE) { - PyTypeObject *value = TYPESTACK_PEEK(1); STACK_SHRINK(1); break; } TARGET(BB_TEST_POP_IF_NONE) { - PyTypeObject *value = TYPESTACK_PEEK(1); STACK_SHRINK(1); break; } TARGET(JUMP_IF_FALSE_OR_POP) { - fprintf(stderr, "Type propagation across `{self.name}` shouldn't be handled statically!\n"); + fprintf(stderr, "Type propagation across `JUMP_IF_FALSE_OR_POP` shouldn't be handled statically!\n"); Py_UNREACHABLE(); break; } TARGET(BB_TEST_IF_FALSE_OR_POP) { - fprintf(stderr, "Type propagation across `{self.name}` shouldn't be handled statically!\n"); + fprintf(stderr, "Type propagation across `BB_TEST_IF_FALSE_OR_POP` shouldn't be handled statically!\n"); Py_UNREACHABLE(); break; } TARGET(JUMP_IF_TRUE_OR_POP) { - fprintf(stderr, "Type propagation across `{self.name}` shouldn't be handled statically!\n"); + fprintf(stderr, "Type propagation across `JUMP_IF_TRUE_OR_POP` shouldn't be handled statically!\n"); Py_UNREACHABLE(); break; } TARGET(BB_TEST_IF_TRUE_OR_POP) { - fprintf(stderr, "Type propagation across `{self.name}` shouldn't be handled statically!\n"); + fprintf(stderr, "Type propagation across `BB_TEST_IF_TRUE_OR_POP` shouldn't be handled statically!\n"); Py_UNREACHABLE(); break; } @@ -857,98 +717,81 @@ } TARGET(GET_LEN) { - PyTypeObject *obj = TYPESTACK_PEEK(1); STACK_GROW(1); - TYPESTACK_POKE(1, NULL); + TYPESTACK_POKE(1, &PyLong_Type); break; } TARGET(MATCH_CLASS) { - PyTypeObject *names = TYPESTACK_PEEK(1); - PyTypeObject *type = TYPESTACK_PEEK(2); - PyTypeObject *subject = TYPESTACK_PEEK(3); STACK_SHRINK(2); TYPESTACK_POKE(1, NULL); break; } TARGET(MATCH_MAPPING) { - PyTypeObject *subject = TYPESTACK_PEEK(1); - STACK_GROW(1); - TYPESTACK_POKE(1, NULL); + fprintf(stderr, "Type propagation across `MATCH_MAPPING` shouldn't be handled statically!\n"); + Py_UNREACHABLE(); break; } TARGET(MATCH_SEQUENCE) { - PyTypeObject *subject = TYPESTACK_PEEK(1); - STACK_GROW(1); - TYPESTACK_POKE(1, NULL); + fprintf(stderr, "Type propagation across `MATCH_SEQUENCE` shouldn't be handled statically!\n"); + Py_UNREACHABLE(); break; } TARGET(MATCH_KEYS) { - PyTypeObject *keys = TYPESTACK_PEEK(1); - PyTypeObject *subject = TYPESTACK_PEEK(2); - STACK_GROW(1); - TYPESTACK_POKE(1, NULL); + fprintf(stderr, "Type propagation across `MATCH_KEYS` shouldn't be handled statically!\n"); + Py_UNREACHABLE(); break; } TARGET(GET_ITER) { - PyTypeObject *iterable = TYPESTACK_PEEK(1); TYPESTACK_POKE(1, NULL); break; } TARGET(GET_YIELD_FROM_ITER) { - PyTypeObject *iterable = TYPESTACK_PEEK(1); TYPESTACK_POKE(1, NULL); break; } TARGET(FOR_ITER) { - PyTypeObject *iter = TYPESTACK_PEEK(1); STACK_GROW(1); TYPESTACK_POKE(1, NULL); break; } TARGET(BB_TEST_ITER) { - PyTypeObject *iter = TYPESTACK_PEEK(1); STACK_GROW(1); TYPESTACK_POKE(1, NULL); break; } TARGET(FOR_ITER_LIST) { - PyTypeObject *iter = TYPESTACK_PEEK(1); STACK_GROW(1); TYPESTACK_POKE(1, NULL); break; } TARGET(FOR_ITER_TUPLE) { - PyTypeObject *iter = TYPESTACK_PEEK(1); STACK_GROW(1); TYPESTACK_POKE(1, NULL); break; } TARGET(FOR_ITER_RANGE) { - PyTypeObject *iter = TYPESTACK_PEEK(1); STACK_GROW(1); TYPESTACK_POKE(1, NULL); break; } TARGET(FOR_ITER_GEN) { - PyTypeObject *iter = TYPESTACK_PEEK(1); STACK_GROW(1); break; } TARGET(BEFORE_ASYNC_WITH) { - PyTypeObject *mgr = TYPESTACK_PEEK(1); STACK_GROW(1); TYPESTACK_POKE(1, NULL); TYPESTACK_POKE(2, NULL); @@ -956,7 +799,6 @@ } TARGET(BEFORE_WITH) { - PyTypeObject *mgr = TYPESTACK_PEEK(1); STACK_GROW(1); TYPESTACK_POKE(1, NULL); TYPESTACK_POKE(2, NULL); @@ -964,24 +806,18 @@ } TARGET(WITH_EXCEPT_START) { - PyTypeObject *val = TYPESTACK_PEEK(1); - PyTypeObject *lasti = TYPESTACK_PEEK(3); - PyTypeObject *exit_func = TYPESTACK_PEEK(4); - STACK_GROW(1); - TYPESTACK_POKE(1, NULL); + fprintf(stderr, "Type propagation across `WITH_EXCEPT_START` shouldn't be handled statically!\n"); + Py_UNREACHABLE(); break; } TARGET(PUSH_EXC_INFO) { - PyTypeObject *new_exc = TYPESTACK_PEEK(1); - STACK_GROW(1); - TYPESTACK_POKE(1, new_exc); - TYPESTACK_POKE(2, NULL); + fprintf(stderr, "Type propagation across `PUSH_EXC_INFO` shouldn't be handled statically!\n"); + Py_UNREACHABLE(); break; } TARGET(LOAD_ATTR_METHOD_WITH_VALUES) { - PyTypeObject *self = TYPESTACK_PEEK(1); STACK_GROW(((oparg & 1) ? 1 : 0)); TYPESTACK_POKE(1, NULL); if (oparg & 1) { TYPESTACK_POKE(1 + ((oparg & 1) ? 1 : 0), NULL); } @@ -989,7 +825,6 @@ } TARGET(LOAD_ATTR_METHOD_NO_DICT) { - PyTypeObject *self = TYPESTACK_PEEK(1); STACK_GROW(((oparg & 1) ? 1 : 0)); TYPESTACK_POKE(1, NULL); if (oparg & 1) { TYPESTACK_POKE(1 + ((oparg & 1) ? 1 : 0), NULL); } @@ -997,7 +832,6 @@ } TARGET(LOAD_ATTR_METHOD_LAZY_DICT) { - PyTypeObject *self = TYPESTACK_PEEK(1); STACK_GROW(((oparg & 1) ? 1 : 0)); TYPESTACK_POKE(1, NULL); if (oparg & 1) { TYPESTACK_POKE(1 + ((oparg & 1) ? 1 : 0), NULL); } @@ -1009,9 +843,6 @@ } TARGET(CALL) { - PyTypeObject **args = &TYPESTACK_PEEK(oparg); - PyTypeObject *callable = TYPESTACK_PEEK(1 + oparg); - PyTypeObject *method = TYPESTACK_PEEK(2 + oparg); STACK_SHRINK(oparg); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); @@ -1019,35 +850,24 @@ } TARGET(CALL_BOUND_METHOD_EXACT_ARGS) { - PyTypeObject *callable = TYPESTACK_PEEK(1 + oparg); - PyTypeObject *method = TYPESTACK_PEEK(2 + oparg); STACK_SHRINK(oparg); STACK_SHRINK(1); break; } TARGET(CALL_PY_EXACT_ARGS) { - PyTypeObject **args = &TYPESTACK_PEEK(oparg); - PyTypeObject *callable = TYPESTACK_PEEK(1 + oparg); - PyTypeObject *method = TYPESTACK_PEEK(2 + oparg); STACK_SHRINK(oparg); STACK_SHRINK(1); break; } TARGET(CALL_PY_WITH_DEFAULTS) { - PyTypeObject **args = &TYPESTACK_PEEK(oparg); - PyTypeObject *callable = TYPESTACK_PEEK(1 + oparg); - PyTypeObject *method = TYPESTACK_PEEK(2 + oparg); STACK_SHRINK(oparg); STACK_SHRINK(1); break; } TARGET(CALL_NO_KW_TYPE_1) { - PyTypeObject **args = &TYPESTACK_PEEK(oparg); - PyTypeObject *callable = TYPESTACK_PEEK(1 + oparg); - PyTypeObject *null = TYPESTACK_PEEK(2 + oparg); STACK_SHRINK(oparg); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); @@ -1055,9 +875,6 @@ } TARGET(CALL_NO_KW_STR_1) { - PyTypeObject **args = &TYPESTACK_PEEK(oparg); - PyTypeObject *callable = TYPESTACK_PEEK(1 + oparg); - PyTypeObject *null = TYPESTACK_PEEK(2 + oparg); STACK_SHRINK(oparg); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); @@ -1065,9 +882,6 @@ } TARGET(CALL_NO_KW_TUPLE_1) { - PyTypeObject **args = &TYPESTACK_PEEK(oparg); - PyTypeObject *callable = TYPESTACK_PEEK(1 + oparg); - PyTypeObject *null = TYPESTACK_PEEK(2 + oparg); STACK_SHRINK(oparg); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); @@ -1075,9 +889,6 @@ } TARGET(CALL_BUILTIN_CLASS) { - PyTypeObject **args = &TYPESTACK_PEEK(oparg); - PyTypeObject *callable = TYPESTACK_PEEK(1 + oparg); - PyTypeObject *method = TYPESTACK_PEEK(2 + oparg); STACK_SHRINK(oparg); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); @@ -1085,9 +896,6 @@ } TARGET(CALL_NO_KW_BUILTIN_O) { - PyTypeObject **args = &TYPESTACK_PEEK(oparg); - PyTypeObject *callable = TYPESTACK_PEEK(1 + oparg); - PyTypeObject *method = TYPESTACK_PEEK(2 + oparg); STACK_SHRINK(oparg); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); @@ -1095,9 +903,6 @@ } TARGET(CALL_NO_KW_BUILTIN_FAST) { - PyTypeObject **args = &TYPESTACK_PEEK(oparg); - PyTypeObject *callable = TYPESTACK_PEEK(1 + oparg); - PyTypeObject *method = TYPESTACK_PEEK(2 + oparg); STACK_SHRINK(oparg); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); @@ -1105,9 +910,6 @@ } TARGET(CALL_BUILTIN_FAST_WITH_KEYWORDS) { - PyTypeObject **args = &TYPESTACK_PEEK(oparg); - PyTypeObject *callable = TYPESTACK_PEEK(1 + oparg); - PyTypeObject *method = TYPESTACK_PEEK(2 + oparg); STACK_SHRINK(oparg); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); @@ -1115,9 +917,6 @@ } TARGET(CALL_NO_KW_LEN) { - PyTypeObject **args = &TYPESTACK_PEEK(oparg); - PyTypeObject *callable = TYPESTACK_PEEK(1 + oparg); - PyTypeObject *method = TYPESTACK_PEEK(2 + oparg); STACK_SHRINK(oparg); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); @@ -1125,9 +924,6 @@ } TARGET(CALL_NO_KW_ISINSTANCE) { - PyTypeObject **args = &TYPESTACK_PEEK(oparg); - PyTypeObject *callable = TYPESTACK_PEEK(1 + oparg); - PyTypeObject *method = TYPESTACK_PEEK(2 + oparg); STACK_SHRINK(oparg); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); @@ -1135,17 +931,12 @@ } TARGET(CALL_NO_KW_LIST_APPEND) { - PyTypeObject **args = &TYPESTACK_PEEK(oparg); - PyTypeObject *self = TYPESTACK_PEEK(1 + oparg); - PyTypeObject *method = TYPESTACK_PEEK(2 + oparg); STACK_SHRINK(oparg); STACK_SHRINK(1); break; } TARGET(CALL_NO_KW_METHOD_DESCRIPTOR_O) { - PyTypeObject **args = &TYPESTACK_PEEK(oparg); - PyTypeObject *method = TYPESTACK_PEEK(2 + oparg); STACK_SHRINK(oparg); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); @@ -1153,8 +944,6 @@ } TARGET(CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS) { - PyTypeObject **args = &TYPESTACK_PEEK(oparg); - PyTypeObject *method = TYPESTACK_PEEK(2 + oparg); STACK_SHRINK(oparg); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); @@ -1162,8 +951,6 @@ } TARGET(CALL_NO_KW_METHOD_DESCRIPTOR_NOARGS) { - PyTypeObject **args = &TYPESTACK_PEEK(oparg); - PyTypeObject *method = TYPESTACK_PEEK(2 + oparg); STACK_SHRINK(oparg); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); @@ -1171,8 +958,6 @@ } TARGET(CALL_NO_KW_METHOD_DESCRIPTOR_FAST) { - PyTypeObject **args = &TYPESTACK_PEEK(oparg); - PyTypeObject *method = TYPESTACK_PEEK(2 + oparg); STACK_SHRINK(oparg); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); @@ -1180,9 +965,6 @@ } TARGET(CALL_FUNCTION_EX) { - PyTypeObject *kwargs = (oparg & 1) ? TYPESTACK_PEEK(((oparg & 1) ? 1 : 0)) : NULL; - PyTypeObject *callargs = TYPESTACK_PEEK(1 + ((oparg & 1) ? 1 : 0)); - PyTypeObject *func = TYPESTACK_PEEK(2 + ((oparg & 1) ? 1 : 0)); STACK_SHRINK(((oparg & 1) ? 1 : 0)); STACK_SHRINK(2); TYPESTACK_POKE(1, NULL); @@ -1190,11 +972,6 @@ } TARGET(MAKE_FUNCTION) { - PyTypeObject *codeobj = TYPESTACK_PEEK(1); - PyTypeObject *closure = (oparg & 0x08) ? TYPESTACK_PEEK(1 + ((oparg & 0x08) ? 1 : 0)) : NULL; - PyTypeObject *annotations = (oparg & 0x04) ? TYPESTACK_PEEK(1 + ((oparg & 0x08) ? 1 : 0) + ((oparg & 0x04) ? 1 : 0)) : NULL; - PyTypeObject *kwdefaults = (oparg & 0x02) ? TYPESTACK_PEEK(1 + ((oparg & 0x08) ? 1 : 0) + ((oparg & 0x04) ? 1 : 0) + ((oparg & 0x02) ? 1 : 0)) : NULL; - PyTypeObject *defaults = (oparg & 0x01) ? TYPESTACK_PEEK(1 + ((oparg & 0x08) ? 1 : 0) + ((oparg & 0x04) ? 1 : 0) + ((oparg & 0x02) ? 1 : 0) + ((oparg & 0x01) ? 1 : 0)) : NULL; STACK_SHRINK(((oparg & 0x01) ? 1 : 0) + ((oparg & 0x02) ? 1 : 0) + ((oparg & 0x04) ? 1 : 0) + ((oparg & 0x08) ? 1 : 0)); TYPESTACK_POKE(1, NULL); break; @@ -1205,9 +982,6 @@ } TARGET(BUILD_SLICE) { - PyTypeObject *step = (oparg == 3) ? TYPESTACK_PEEK(((oparg == 3) ? 1 : 0)) : NULL; - PyTypeObject *stop = TYPESTACK_PEEK(1 + ((oparg == 3) ? 1 : 0)); - PyTypeObject *start = TYPESTACK_PEEK(2 + ((oparg == 3) ? 1 : 0)); STACK_SHRINK(((oparg == 3) ? 1 : 0)); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); @@ -1215,8 +989,6 @@ } TARGET(FORMAT_VALUE) { - PyTypeObject *fmt_spec = ((oparg & FVS_MASK) == FVS_HAVE_SPEC) ? TYPESTACK_PEEK((((oparg & FVS_MASK) == FVS_HAVE_SPEC) ? 1 : 0)) : NULL; - PyTypeObject *value = TYPESTACK_PEEK(1 + (((oparg & FVS_MASK) == FVS_HAVE_SPEC) ? 1 : 0)); STACK_SHRINK((((oparg & FVS_MASK) == FVS_HAVE_SPEC) ? 1 : 0)); TYPESTACK_POKE(1, NULL); break; @@ -1225,13 +997,11 @@ TARGET(COPY) { PyTypeObject *bottom = TYPESTACK_PEEK(1 + (oparg-1)); STACK_GROW(1); - TYPESTACK_POKE(1, NULL); + TYPESTACK_POKE(1, bottom); break; } TARGET(BINARY_OP) { - PyTypeObject *rhs = TYPESTACK_PEEK(1); - PyTypeObject *lhs = TYPESTACK_PEEK(2); STACK_SHRINK(1); TYPESTACK_POKE(1, NULL); break; @@ -1246,6 +1016,8 @@ } TARGET(EXTENDED_ARG) { + fprintf(stderr, "Type propagation across `EXTENDED_ARG` shouldn't be handled statically!\n"); + Py_UNREACHABLE(); break; } diff --git a/Tools/cases_generator/generate_cases.py b/Tools/cases_generator/generate_cases.py index 3c37a47d21c2cf..ab83895f1fabd2 100644 --- a/Tools/cases_generator/generate_cases.py +++ b/Tools/cases_generator/generate_cases.py @@ -16,7 +16,7 @@ from enum import Enum, auto import parser -from parser import StackEffect, StackVarTypeLiteral, StackVarTypeIndex +from parser import StackEffect, StackVarTypeLiteral, StackVarTypeIndex, StackVarInputVar from parser import LocalEffect, LocalEffectVarLiteral, LocalEffectVarStack HERE = os.path.dirname(__file__) @@ -49,13 +49,29 @@ UNUSED = "unused" BITS_PER_CODE_UNIT = 16 -# Type propagation across these instructions are forbidden -# due to conditional effects that can't be determined statically -# The handling of type propagation across these opcodes are handled elsewhere -# within tier2. TYPE_PROPAGATOR_FORBIDDEN = [ + # Type propagator shouldn't see these "JUMP_IF_FALSE_OR_POP", - "JUMP_IF_TRUE_OR_POP", # Type propagator shouldn't see these + "JUMP_IF_TRUE_OR_POP", + "SEND", + "SEND_GEN", + "YIELD_VALUE", + "RAISE_VARARGS", + "PUSH_EXC_INFO", + "RERAISE", + "POP_EXCEPT", + "LOAD_DEREF", + "MAKE_CELL", + "DELETE_FAST", + "MATCH_MAPPING", + "MATCH_SEQUENCE", + "MATCH_KEYS", + "EXTENDED_ARG", + "WITH_EXCEPT_START", + # Type propagation across these instructions are forbidden + # due to conditional effects that can't be determined statically + # The handling of type propagation across these opcodes are handled elsewhere + # within tier2. "BB_TEST_IF_FALSE_OR_POP", "BB_TEST_IF_TRUE_OR_POP" # Type propagator handles this in BB_BRANCH ] @@ -317,15 +333,34 @@ def write_typeprop(self, out: Formatter) -> None: """Write one instruction's type propagation rules""" if self.name in TYPE_PROPAGATOR_FORBIDDEN: - out.emit('fprintf(stderr, "Type propagation across `{self.name}` shouldn\'t be handled statically!\\n");') + out.emit(f'fprintf(stderr, "Type propagation across `{self.name}` shouldn\'t be handled statically!\\n");') out.emit("Py_UNREACHABLE();") return + need_to_declare = [] + # Stack input is used in local effect + if self.local_effects and \ + isinstance(val := self.local_effects.value, LocalEffectVarStack): + need_to_declare.append(val.name) + # Stack input is used in output effect + for oeffect in self.output_effects: + if not (typ := oeffect.type_annotation): continue + if not isinstance(typ, StackVarInputVar): continue + if oeffect.name in self.unmoved_names: + print( + f"Warn: {self.name} type annotation for {oeffect.name} will be ignored " + "as it is unmoved") + continue + need_to_declare.append(typ.name) + # Write input stack effect variable declarations and initializations ieffects = list(reversed(self.input_effects)) usable_for_local_effect = {} all_input_effect_names = {} for i, ieffect in enumerate(ieffects): + + if ieffect.name not in need_to_declare: continue + isize = string_effect_size( list_effect_size([ieff for ieff in ieffects[: i + 1]]) ) @@ -379,6 +414,13 @@ def write_typeprop(self, out: Formatter) -> None: if val != "NULL": val = f"&{val}" case StackVarTypeIndex(array=arr, index=idx): val = f"{'TYPELOCALS_GET' if arr == 'locals' else 'TYPECONST_GET'}({idx})" + case StackVarInputVar(name=val): + # We determined above that we don't need to write this stack effect + if val not in need_to_declare: + continue + # Unmoved var, don't need to write + if oeffect.name in self.unmoved_names: + continue case _: typing.assert_never(typ) if oeffect.cond: @@ -387,18 +429,8 @@ def write_typeprop(self, out: Formatter) -> None: out.emit(f"TYPESTACK_POKE({osize}, {val});") continue - # Check if it's part of input effect - # TODO: Can we assume that they have the same type? - if oeffect.name in all_input_effect_names: - ieffect, j = all_input_effect_names[oeffect.name] - assert not ieffect.cond, \ - "`cond` stackvar not supported for type prop" - # The stack var stays at the same pos - if len(oeffects) - i == len(ieffects) - j: continue - if oeffect.cond: - out.emit(f"if ({oeffect.cond}) {{ TYPESTACK_POKE({osize}, {oeffect.name}); }}") - else: - out.emit(f"TYPESTACK_POKE({osize}, {oeffect.name});") + # Don't touch unmoved stack vars + if oeffect.name in self.unmoved_names: continue # Just output null diff --git a/Tools/cases_generator/parser.py b/Tools/cases_generator/parser.py index 1e84119854edf2..d4feee6599fe7c 100644 --- a/Tools/cases_generator/parser.py +++ b/Tools/cases_generator/parser.py @@ -78,8 +78,12 @@ class StackVarTypeIndex(Node): array: Literal["locals", "consts"] index: str +@dataclass +class StackVarInputVar(Node): + name: str + -StackVarType: TypeAlias = StackVarTypeLiteral | StackVarTypeIndex +StackVarType: TypeAlias = StackVarTypeLiteral | StackVarTypeIndex | StackVarInputVar @dataclass @@ -91,6 +95,9 @@ class StackEffect(Node): size: str = "" # Optional `[size]` # Note: size cannot be combined with type or cond + def __eq__(self, other: 'StackEffect') -> bool: + return self.name == other.name + @dataclass class Expression(Node): @@ -270,7 +277,13 @@ def inputs(self) -> list[InputEffect] | None: @contextual def input(self) -> InputEffect | None: - return self.cache_effect() or self.stack_effect() + if r := self.cache_effect(): + return r + r = self.stack_effect() + if r is None: return r + assert r.type_annotation is None, \ + "Type annotations aren't allowed in input stack effect." + return r def outputs(self) -> list[OutputEffect] | None: # output (, output)* @@ -344,10 +357,16 @@ def stackvar_type(self) -> StackVarType | None: return StackVarTypeIndex( "locals" if idstr == "locals" else "consts", index) + elif self.expect(lx.TIMES): + id = self.require(lx.IDENTIFIER) + return StackVarInputVar(id.text.strip()) + @contextual def local_effect(self) -> LocalEffect | None: - if self.expect(lx.IDENTIFIER).text.strip() == "locals": + if tok := self.expect(lx.IDENTIFIER): + if tok.text.strip() != "locals": + return self.require(lx.LBRACKET) if id := self.expect(lx.IDENTIFIER): index = id.text.strip()