| // This file is generated by Tools/cases_generator/optimizer_generator.py |
| // from: |
| // Python/optimizer_bytecodes.c |
| // Do not edit! |
| |
| case _NOP: { |
| break; |
| } |
| |
| case _CHECK_PERIODIC: { |
| break; |
| } |
| |
| case _CHECK_PERIODIC_IF_NOT_YIELD_FROM: { |
| break; |
| } |
| |
| /* _QUICKEN_RESUME is not a viable micro-op for tier 2 */ |
| |
| /* _LOAD_BYTECODE is not a viable micro-op for tier 2 */ |
| |
| case _RESUME_CHECK: { |
| break; |
| } |
| |
| /* _MONITOR_RESUME is not a viable micro-op for tier 2 */ |
| |
| case _LOAD_FAST_CHECK: { |
| JitOptSymbol *value; |
| value = GETLOCAL(oparg); |
| if (sym_is_null(value)) { |
| ctx->done = true; |
| } |
| stack_pointer[0] = value; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _LOAD_FAST: { |
| JitOptSymbol *value; |
| value = GETLOCAL(oparg); |
| stack_pointer[0] = value; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _LOAD_FAST_BORROW: { |
| JitOptSymbol *value; |
| value = GETLOCAL(oparg); |
| stack_pointer[0] = value; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _LOAD_FAST_AND_CLEAR: { |
| JitOptSymbol *value; |
| value = GETLOCAL(oparg); |
| JitOptSymbol *temp = sym_new_null(ctx); |
| GETLOCAL(oparg) = temp; |
| stack_pointer[0] = value; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _LOAD_CONST: { |
| JitOptSymbol *value; |
| PyObject *val = PyTuple_GET_ITEM(co->co_consts, this_instr->oparg); |
| REPLACE_OP(this_instr, _LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)val); |
| value = sym_new_const(ctx, val); |
| stack_pointer[0] = value; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _LOAD_SMALL_INT: { |
| JitOptSymbol *value; |
| PyObject *val = PyLong_FromLong(this_instr->oparg); |
| value = sym_new_const(ctx, val); |
| stack_pointer[0] = value; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _STORE_FAST: { |
| JitOptSymbol *value; |
| value = stack_pointer[-1]; |
| GETLOCAL(oparg) = value; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _POP_TOP: { |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _POP_TWO: { |
| stack_pointer += -2; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _PUSH_NULL: { |
| JitOptSymbol *res; |
| res = sym_new_null(ctx); |
| stack_pointer[0] = res; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _END_FOR: { |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _END_SEND: { |
| JitOptSymbol *val; |
| val = sym_new_not_null(ctx); |
| stack_pointer[-2] = val; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _UNARY_NEGATIVE: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-1] = res; |
| break; |
| } |
| |
| case _UNARY_NOT: { |
| JitOptSymbol *value; |
| JitOptSymbol *res; |
| value = stack_pointer[-1]; |
| sym_set_type(value, &PyBool_Type); |
| res = sym_new_truthiness(ctx, value, false); |
| stack_pointer[-1] = res; |
| break; |
| } |
| |
| case _TO_BOOL: { |
| JitOptSymbol *value; |
| JitOptSymbol *res; |
| value = stack_pointer[-1]; |
| int already_bool = optimize_to_bool(this_instr, ctx, value, &res); |
| if (!already_bool) { |
| res = sym_new_truthiness(ctx, value, true); |
| } |
| stack_pointer[-1] = res; |
| break; |
| } |
| |
| case _TO_BOOL_BOOL: { |
| JitOptSymbol *value; |
| value = stack_pointer[-1]; |
| int already_bool = optimize_to_bool(this_instr, ctx, value, &value); |
| if (!already_bool) { |
| sym_set_type(value, &PyBool_Type); |
| value = sym_new_truthiness(ctx, value, true); |
| } |
| stack_pointer[-1] = value; |
| break; |
| } |
| |
| case _TO_BOOL_INT: { |
| JitOptSymbol *value; |
| JitOptSymbol *res; |
| value = stack_pointer[-1]; |
| int already_bool = optimize_to_bool(this_instr, ctx, value, &res); |
| if (!already_bool) { |
| sym_set_type(value, &PyLong_Type); |
| res = sym_new_truthiness(ctx, value, true); |
| } |
| stack_pointer[-1] = res; |
| break; |
| } |
| |
| case _GUARD_NOS_LIST: { |
| JitOptSymbol *nos; |
| nos = stack_pointer[-2]; |
| if (sym_matches_type(nos, &PyList_Type)) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_type(nos, &PyList_Type); |
| break; |
| } |
| |
| case _GUARD_TOS_LIST: { |
| JitOptSymbol *tos; |
| tos = stack_pointer[-1]; |
| if (sym_matches_type(tos, &PyList_Type)) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_type(tos, &PyList_Type); |
| break; |
| } |
| |
| case _GUARD_TOS_SLICE: { |
| break; |
| } |
| |
| case _TO_BOOL_LIST: { |
| JitOptSymbol *value; |
| JitOptSymbol *res; |
| value = stack_pointer[-1]; |
| int already_bool = optimize_to_bool(this_instr, ctx, value, &res); |
| if (!already_bool) { |
| res = sym_new_type(ctx, &PyBool_Type); |
| } |
| stack_pointer[-1] = res; |
| break; |
| } |
| |
| case _TO_BOOL_NONE: { |
| JitOptSymbol *value; |
| JitOptSymbol *res; |
| value = stack_pointer[-1]; |
| int already_bool = optimize_to_bool(this_instr, ctx, value, &res); |
| if (!already_bool) { |
| sym_set_const(value, Py_None); |
| res = sym_new_const(ctx, Py_False); |
| } |
| stack_pointer[-1] = res; |
| break; |
| } |
| |
| case _GUARD_NOS_UNICODE: { |
| JitOptSymbol *nos; |
| nos = stack_pointer[-2]; |
| if (sym_matches_type(nos, &PyUnicode_Type)) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_type(nos, &PyUnicode_Type); |
| break; |
| } |
| |
| case _GUARD_TOS_UNICODE: { |
| JitOptSymbol *value; |
| value = stack_pointer[-1]; |
| if (sym_matches_type(value, &PyUnicode_Type)) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_type(value, &PyUnicode_Type); |
| break; |
| } |
| |
| case _TO_BOOL_STR: { |
| JitOptSymbol *value; |
| JitOptSymbol *res; |
| value = stack_pointer[-1]; |
| int already_bool = optimize_to_bool(this_instr, ctx, value, &res); |
| if (!already_bool) { |
| res = sym_new_truthiness(ctx, value, true); |
| } |
| stack_pointer[-1] = res; |
| break; |
| } |
| |
| case _REPLACE_WITH_TRUE: { |
| JitOptSymbol *res; |
| REPLACE_OP(this_instr, _POP_TOP_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)Py_True); |
| res = sym_new_const(ctx, Py_True); |
| stack_pointer[-1] = res; |
| break; |
| } |
| |
| case _UNARY_INVERT: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-1] = res; |
| break; |
| } |
| |
| case _GUARD_NOS_INT: { |
| JitOptSymbol *left; |
| left = stack_pointer[-2]; |
| if (sym_matches_type(left, &PyLong_Type)) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_type(left, &PyLong_Type); |
| break; |
| } |
| |
| case _GUARD_TOS_INT: { |
| JitOptSymbol *value; |
| value = stack_pointer[-1]; |
| if (sym_matches_type(value, &PyLong_Type)) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_type(value, &PyLong_Type); |
| break; |
| } |
| |
| case _BINARY_OP_MULTIPLY_INT: { |
| JitOptSymbol *right; |
| JitOptSymbol *left; |
| JitOptSymbol *res; |
| right = stack_pointer[-1]; |
| left = stack_pointer[-2]; |
| if (sym_is_const(ctx, left) && sym_is_const(ctx, right)) { |
| assert(PyLong_CheckExact(sym_get_const(ctx, left))); |
| assert(PyLong_CheckExact(sym_get_const(ctx, right))); |
| PyObject *temp = _PyLong_Multiply((PyLongObject *)sym_get_const(ctx, left), |
| (PyLongObject *)sym_get_const(ctx, right)); |
| if (temp == NULL) { |
| goto error; |
| } |
| res = sym_new_const(ctx, temp); |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| Py_DECREF(temp); |
| } |
| else { |
| res = sym_new_type(ctx, &PyLong_Type); |
| stack_pointer += -1; |
| } |
| stack_pointer[-1] = res; |
| break; |
| } |
| |
| case _BINARY_OP_ADD_INT: { |
| JitOptSymbol *right; |
| JitOptSymbol *left; |
| JitOptSymbol *res; |
| right = stack_pointer[-1]; |
| left = stack_pointer[-2]; |
| if (sym_is_const(ctx, left) && sym_is_const(ctx, right)) { |
| assert(PyLong_CheckExact(sym_get_const(ctx, left))); |
| assert(PyLong_CheckExact(sym_get_const(ctx, right))); |
| PyObject *temp = _PyLong_Add((PyLongObject *)sym_get_const(ctx, left), |
| (PyLongObject *)sym_get_const(ctx, right)); |
| if (temp == NULL) { |
| goto error; |
| } |
| res = sym_new_const(ctx, temp); |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| Py_DECREF(temp); |
| } |
| else { |
| res = sym_new_type(ctx, &PyLong_Type); |
| stack_pointer += -1; |
| } |
| stack_pointer[-1] = res; |
| break; |
| } |
| |
| case _BINARY_OP_SUBTRACT_INT: { |
| JitOptSymbol *right; |
| JitOptSymbol *left; |
| JitOptSymbol *res; |
| right = stack_pointer[-1]; |
| left = stack_pointer[-2]; |
| if (sym_is_const(ctx, left) && sym_is_const(ctx, right)) { |
| assert(PyLong_CheckExact(sym_get_const(ctx, left))); |
| assert(PyLong_CheckExact(sym_get_const(ctx, right))); |
| PyObject *temp = _PyLong_Subtract((PyLongObject *)sym_get_const(ctx, left), |
| (PyLongObject *)sym_get_const(ctx, right)); |
| if (temp == NULL) { |
| goto error; |
| } |
| res = sym_new_const(ctx, temp); |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| Py_DECREF(temp); |
| } |
| else { |
| res = sym_new_type(ctx, &PyLong_Type); |
| stack_pointer += -1; |
| } |
| stack_pointer[-1] = res; |
| break; |
| } |
| |
| case _GUARD_NOS_FLOAT: { |
| JitOptSymbol *left; |
| left = stack_pointer[-2]; |
| if (sym_matches_type(left, &PyFloat_Type)) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_type(left, &PyFloat_Type); |
| break; |
| } |
| |
| case _GUARD_TOS_FLOAT: { |
| JitOptSymbol *value; |
| value = stack_pointer[-1]; |
| if (sym_matches_type(value, &PyFloat_Type)) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_type(value, &PyFloat_Type); |
| break; |
| } |
| |
| case _BINARY_OP_MULTIPLY_FLOAT: { |
| JitOptSymbol *right; |
| JitOptSymbol *left; |
| JitOptSymbol *res; |
| right = stack_pointer[-1]; |
| left = stack_pointer[-2]; |
| if (sym_is_const(ctx, left) && sym_is_const(ctx, right)) { |
| assert(PyFloat_CheckExact(sym_get_const(ctx, left))); |
| assert(PyFloat_CheckExact(sym_get_const(ctx, right))); |
| PyObject *temp = PyFloat_FromDouble( |
| PyFloat_AS_DOUBLE(sym_get_const(ctx, left)) * |
| PyFloat_AS_DOUBLE(sym_get_const(ctx, right))); |
| if (temp == NULL) { |
| goto error; |
| } |
| res = sym_new_const(ctx, temp); |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| Py_DECREF(temp); |
| } |
| else { |
| res = sym_new_type(ctx, &PyFloat_Type); |
| stack_pointer += -1; |
| } |
| stack_pointer[-1] = res; |
| break; |
| } |
| |
| case _BINARY_OP_ADD_FLOAT: { |
| JitOptSymbol *right; |
| JitOptSymbol *left; |
| JitOptSymbol *res; |
| right = stack_pointer[-1]; |
| left = stack_pointer[-2]; |
| if (sym_is_const(ctx, left) && sym_is_const(ctx, right)) { |
| assert(PyFloat_CheckExact(sym_get_const(ctx, left))); |
| assert(PyFloat_CheckExact(sym_get_const(ctx, right))); |
| PyObject *temp = PyFloat_FromDouble( |
| PyFloat_AS_DOUBLE(sym_get_const(ctx, left)) + |
| PyFloat_AS_DOUBLE(sym_get_const(ctx, right))); |
| if (temp == NULL) { |
| goto error; |
| } |
| res = sym_new_const(ctx, temp); |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| Py_DECREF(temp); |
| } |
| else { |
| res = sym_new_type(ctx, &PyFloat_Type); |
| stack_pointer += -1; |
| } |
| stack_pointer[-1] = res; |
| break; |
| } |
| |
| case _BINARY_OP_SUBTRACT_FLOAT: { |
| JitOptSymbol *right; |
| JitOptSymbol *left; |
| JitOptSymbol *res; |
| right = stack_pointer[-1]; |
| left = stack_pointer[-2]; |
| if (sym_is_const(ctx, left) && sym_is_const(ctx, right)) { |
| assert(PyFloat_CheckExact(sym_get_const(ctx, left))); |
| assert(PyFloat_CheckExact(sym_get_const(ctx, right))); |
| PyObject *temp = PyFloat_FromDouble( |
| PyFloat_AS_DOUBLE(sym_get_const(ctx, left)) - |
| PyFloat_AS_DOUBLE(sym_get_const(ctx, right))); |
| if (temp == NULL) { |
| goto error; |
| } |
| res = sym_new_const(ctx, temp); |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| Py_DECREF(temp); |
| } |
| else { |
| res = sym_new_type(ctx, &PyFloat_Type); |
| stack_pointer += -1; |
| } |
| stack_pointer[-1] = res; |
| break; |
| } |
| |
| case _BINARY_OP_ADD_UNICODE: { |
| JitOptSymbol *right; |
| JitOptSymbol *left; |
| JitOptSymbol *res; |
| right = stack_pointer[-1]; |
| left = stack_pointer[-2]; |
| if (sym_is_const(ctx, left) && sym_is_const(ctx, right)) { |
| assert(PyUnicode_CheckExact(sym_get_const(ctx, left))); |
| assert(PyUnicode_CheckExact(sym_get_const(ctx, right))); |
| PyObject *temp = PyUnicode_Concat(sym_get_const(ctx, left), sym_get_const(ctx, right)); |
| if (temp == NULL) { |
| goto error; |
| } |
| res = sym_new_const(ctx, temp); |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| Py_DECREF(temp); |
| } |
| else { |
| res = sym_new_type(ctx, &PyUnicode_Type); |
| stack_pointer += -1; |
| } |
| stack_pointer[-1] = res; |
| break; |
| } |
| |
| case _BINARY_OP_INPLACE_ADD_UNICODE: { |
| JitOptSymbol *right; |
| JitOptSymbol *left; |
| right = stack_pointer[-1]; |
| left = stack_pointer[-2]; |
| JitOptSymbol *res; |
| if (sym_is_const(ctx, left) && sym_is_const(ctx, right)) { |
| assert(PyUnicode_CheckExact(sym_get_const(ctx, left))); |
| assert(PyUnicode_CheckExact(sym_get_const(ctx, right))); |
| PyObject *temp = PyUnicode_Concat(sym_get_const(ctx, left), sym_get_const(ctx, right)); |
| if (temp == NULL) { |
| goto error; |
| } |
| res = sym_new_const(ctx, temp); |
| Py_DECREF(temp); |
| } |
| else { |
| res = sym_new_type(ctx, &PyUnicode_Type); |
| } |
| GETLOCAL(this_instr->operand0) = res; |
| stack_pointer += -2; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _GUARD_BINARY_OP_EXTEND: { |
| break; |
| } |
| |
| case _BINARY_OP_EXTEND: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _BINARY_SLICE: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-3] = res; |
| stack_pointer += -2; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _STORE_SLICE: { |
| stack_pointer += -4; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _BINARY_OP_SUBSCR_LIST_INT: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _BINARY_OP_SUBSCR_LIST_SLICE: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _BINARY_OP_SUBSCR_STR_INT: { |
| JitOptSymbol *res; |
| res = sym_new_type(ctx, &PyUnicode_Type); |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _GUARD_NOS_TUPLE: { |
| JitOptSymbol *nos; |
| nos = stack_pointer[-2]; |
| if (sym_matches_type(nos, &PyTuple_Type)) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_type(nos, &PyTuple_Type); |
| break; |
| } |
| |
| case _GUARD_TOS_TUPLE: { |
| JitOptSymbol *tos; |
| tos = stack_pointer[-1]; |
| if (sym_matches_type(tos, &PyTuple_Type)) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_type(tos, &PyTuple_Type); |
| break; |
| } |
| |
| case _BINARY_OP_SUBSCR_TUPLE_INT: { |
| JitOptSymbol *sub_st; |
| JitOptSymbol *tuple_st; |
| JitOptSymbol *res; |
| sub_st = stack_pointer[-1]; |
| tuple_st = stack_pointer[-2]; |
| assert(sym_matches_type(tuple_st, &PyTuple_Type)); |
| if (sym_is_const(ctx, sub_st)) { |
| assert(PyLong_CheckExact(sym_get_const(ctx, sub_st))); |
| long index = PyLong_AsLong(sym_get_const(ctx, sub_st)); |
| assert(index >= 0); |
| int tuple_length = sym_tuple_length(tuple_st); |
| if (tuple_length == -1) { |
| res = sym_new_not_null(ctx); |
| } |
| else { |
| assert(index < tuple_length); |
| res = sym_tuple_getitem(ctx, tuple_st, index); |
| } |
| } |
| else { |
| res = sym_new_not_null(ctx); |
| } |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _GUARD_NOS_DICT: { |
| JitOptSymbol *nos; |
| nos = stack_pointer[-2]; |
| if (sym_matches_type(nos, &PyDict_Type)) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_type(nos, &PyDict_Type); |
| break; |
| } |
| |
| case _GUARD_TOS_DICT: { |
| JitOptSymbol *tos; |
| tos = stack_pointer[-1]; |
| if (sym_matches_type(tos, &PyDict_Type)) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_type(tos, &PyDict_Type); |
| break; |
| } |
| |
| case _BINARY_OP_SUBSCR_DICT: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _BINARY_OP_SUBSCR_CHECK_FUNC: { |
| JitOptSymbol *getitem; |
| getitem = sym_new_not_null(ctx); |
| stack_pointer[0] = getitem; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _BINARY_OP_SUBSCR_INIT_CALL: { |
| _Py_UOpsAbstractFrame *new_frame; |
| new_frame = NULL; |
| ctx->done = true; |
| stack_pointer[-3] = (JitOptSymbol *)new_frame; |
| stack_pointer += -2; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _LIST_APPEND: { |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _SET_ADD: { |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _STORE_SUBSCR: { |
| stack_pointer += -3; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _STORE_SUBSCR_LIST_INT: { |
| stack_pointer += -3; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _STORE_SUBSCR_DICT: { |
| stack_pointer += -3; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _DELETE_SUBSCR: { |
| stack_pointer += -2; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _CALL_INTRINSIC_1: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-1] = res; |
| break; |
| } |
| |
| case _CALL_INTRINSIC_2: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _RETURN_VALUE: { |
| JitOptSymbol *retval; |
| JitOptSymbol *res; |
| retval = stack_pointer[-1]; |
| JitOptSymbol *temp = retval; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| ctx->frame->stack_pointer = stack_pointer; |
| frame_pop(ctx); |
| stack_pointer = ctx->frame->stack_pointer; |
| assert(corresponding_check_stack == NULL); |
| assert(co != NULL); |
| int framesize = co->co_framesize; |
| assert(framesize > 0); |
| assert(framesize <= curr_space); |
| curr_space -= framesize; |
| co = get_code(this_instr); |
| if (co == NULL) { |
| ctx->done = true; |
| } |
| res = temp; |
| stack_pointer[0] = res; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _GET_AITER: { |
| JitOptSymbol *iter; |
| iter = sym_new_not_null(ctx); |
| stack_pointer[-1] = iter; |
| break; |
| } |
| |
| case _GET_ANEXT: { |
| JitOptSymbol *awaitable; |
| awaitable = sym_new_not_null(ctx); |
| stack_pointer[0] = awaitable; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _GET_AWAITABLE: { |
| JitOptSymbol *iter; |
| iter = sym_new_not_null(ctx); |
| stack_pointer[-1] = iter; |
| break; |
| } |
| |
| /* _SEND is not a viable micro-op for tier 2 */ |
| |
| case _SEND_GEN_FRAME: { |
| _Py_UOpsAbstractFrame *gen_frame; |
| gen_frame = NULL; |
| ctx->done = true; |
| stack_pointer[-1] = (JitOptSymbol *)gen_frame; |
| break; |
| } |
| |
| case _YIELD_VALUE: { |
| JitOptSymbol *value; |
| value = sym_new_unknown(ctx); |
| stack_pointer[-1] = value; |
| break; |
| } |
| |
| case _POP_EXCEPT: { |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _LOAD_COMMON_CONSTANT: { |
| JitOptSymbol *value; |
| value = sym_new_not_null(ctx); |
| stack_pointer[0] = value; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _LOAD_BUILD_CLASS: { |
| JitOptSymbol *bc; |
| bc = sym_new_not_null(ctx); |
| stack_pointer[0] = bc; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _STORE_NAME: { |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _DELETE_NAME: { |
| break; |
| } |
| |
| case _UNPACK_SEQUENCE: { |
| JitOptSymbol **values; |
| JitOptSymbol **top; |
| values = &stack_pointer[-1]; |
| top = &stack_pointer[-1 + oparg]; |
| (void)top; |
| for (int i = 0; i < oparg; i++) { |
| values[i] = sym_new_unknown(ctx); |
| } |
| stack_pointer += -1 + oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _UNPACK_SEQUENCE_TWO_TUPLE: { |
| JitOptSymbol *seq; |
| JitOptSymbol *val1; |
| JitOptSymbol *val0; |
| seq = stack_pointer[-1]; |
| val0 = sym_tuple_getitem(ctx, seq, 0); |
| val1 = sym_tuple_getitem(ctx, seq, 1); |
| stack_pointer[-1] = val1; |
| stack_pointer[0] = val0; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _UNPACK_SEQUENCE_TUPLE: { |
| JitOptSymbol *seq; |
| JitOptSymbol **values; |
| seq = stack_pointer[-1]; |
| values = &stack_pointer[-1]; |
| for (int i = 0; i < oparg; i++) { |
| values[i] = sym_tuple_getitem(ctx, seq, oparg - i - 1); |
| } |
| stack_pointer += -1 + oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _UNPACK_SEQUENCE_LIST: { |
| JitOptSymbol **values; |
| values = &stack_pointer[-1]; |
| for (int _i = oparg; --_i >= 0;) { |
| values[_i] = sym_new_not_null(ctx); |
| } |
| stack_pointer += -1 + oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _UNPACK_EX: { |
| JitOptSymbol **values; |
| JitOptSymbol **top; |
| values = &stack_pointer[-1]; |
| top = &stack_pointer[(oparg & 0xFF) + (oparg >> 8)]; |
| (void)top; |
| int totalargs = (oparg & 0xFF) + (oparg >> 8) + 1; |
| for (int i = 0; i < totalargs; i++) { |
| values[i] = sym_new_unknown(ctx); |
| } |
| stack_pointer += (oparg & 0xFF) + (oparg >> 8); |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _STORE_ATTR: { |
| stack_pointer += -2; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _DELETE_ATTR: { |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _STORE_GLOBAL: { |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _DELETE_GLOBAL: { |
| break; |
| } |
| |
| case _LOAD_LOCALS: { |
| JitOptSymbol *locals; |
| locals = sym_new_not_null(ctx); |
| stack_pointer[0] = locals; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| /* _LOAD_FROM_DICT_OR_GLOBALS is not a viable micro-op for tier 2 */ |
| |
| case _LOAD_NAME: { |
| JitOptSymbol *v; |
| v = sym_new_not_null(ctx); |
| stack_pointer[0] = v; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _LOAD_GLOBAL: { |
| JitOptSymbol **res; |
| res = &stack_pointer[0]; |
| res[0] = sym_new_not_null(ctx); |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _PUSH_NULL_CONDITIONAL: { |
| JitOptSymbol **null; |
| null = &stack_pointer[0]; |
| if (oparg & 1) { |
| REPLACE_OP(this_instr, _PUSH_NULL, 0, 0); |
| null[0] = sym_new_null(ctx); |
| } |
| else { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| stack_pointer += (oparg & 1); |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _GUARD_GLOBALS_VERSION: { |
| break; |
| } |
| |
| case _LOAD_GLOBAL_MODULE: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[0] = res; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _LOAD_GLOBAL_BUILTINS: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[0] = res; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _DELETE_FAST: { |
| break; |
| } |
| |
| case _MAKE_CELL: { |
| break; |
| } |
| |
| case _DELETE_DEREF: { |
| break; |
| } |
| |
| case _LOAD_FROM_DICT_OR_DEREF: { |
| JitOptSymbol *value; |
| value = sym_new_not_null(ctx); |
| stack_pointer[-1] = value; |
| break; |
| } |
| |
| case _LOAD_DEREF: { |
| JitOptSymbol *value; |
| value = sym_new_not_null(ctx); |
| stack_pointer[0] = value; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _STORE_DEREF: { |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _COPY_FREE_VARS: { |
| break; |
| } |
| |
| case _BUILD_STRING: { |
| JitOptSymbol *str; |
| str = sym_new_type(ctx, &PyUnicode_Type); |
| stack_pointer[-oparg] = str; |
| stack_pointer += 1 - oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _BUILD_INTERPOLATION: { |
| JitOptSymbol *interpolation; |
| interpolation = sym_new_not_null(ctx); |
| stack_pointer[-2 - (oparg & 1)] = interpolation; |
| stack_pointer += -1 - (oparg & 1); |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _BUILD_TEMPLATE: { |
| JitOptSymbol *template; |
| template = sym_new_not_null(ctx); |
| stack_pointer[-2] = template; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _BUILD_TUPLE: { |
| JitOptSymbol **values; |
| JitOptSymbol *tup; |
| values = &stack_pointer[-oparg]; |
| tup = sym_new_tuple(ctx, oparg, values); |
| stack_pointer[-oparg] = tup; |
| stack_pointer += 1 - oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _BUILD_LIST: { |
| JitOptSymbol *list; |
| list = sym_new_type(ctx, &PyList_Type); |
| stack_pointer[-oparg] = list; |
| stack_pointer += 1 - oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _LIST_EXTEND: { |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _SET_UPDATE: { |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _BUILD_SET: { |
| JitOptSymbol *set; |
| set = sym_new_type(ctx, &PySet_Type); |
| stack_pointer[-oparg] = set; |
| stack_pointer += 1 - oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _BUILD_MAP: { |
| JitOptSymbol *map; |
| map = sym_new_type(ctx, &PyDict_Type); |
| stack_pointer[-oparg*2] = map; |
| stack_pointer += 1 - oparg*2; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _SETUP_ANNOTATIONS: { |
| break; |
| } |
| |
| case _DICT_UPDATE: { |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _DICT_MERGE: { |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _MAP_ADD: { |
| stack_pointer += -2; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _LOAD_SUPER_ATTR_ATTR: { |
| JitOptSymbol *attr_st; |
| attr_st = sym_new_not_null(ctx); |
| stack_pointer[-3] = attr_st; |
| stack_pointer += -2; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _LOAD_SUPER_ATTR_METHOD: { |
| JitOptSymbol *attr; |
| JitOptSymbol *self_or_null; |
| attr = sym_new_not_null(ctx); |
| self_or_null = sym_new_not_null(ctx); |
| stack_pointer[-3] = attr; |
| stack_pointer[-2] = self_or_null; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _LOAD_ATTR: { |
| JitOptSymbol *owner; |
| JitOptSymbol *attr; |
| JitOptSymbol **self_or_null; |
| owner = stack_pointer[-1]; |
| self_or_null = &stack_pointer[0]; |
| (void)owner; |
| attr = sym_new_not_null(ctx); |
| if (oparg &1) { |
| self_or_null[0] = sym_new_unknown(ctx); |
| } |
| stack_pointer[-1] = attr; |
| stack_pointer += (oparg&1); |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _GUARD_TYPE_VERSION: { |
| JitOptSymbol *owner; |
| owner = stack_pointer[-1]; |
| uint32_t type_version = (uint32_t)this_instr->operand0; |
| assert(type_version); |
| if (sym_matches_type_version(owner, type_version)) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } else { |
| PyTypeObject *type = _PyType_LookupByVersion(type_version); |
| if (type) { |
| if (sym_set_type_version(owner, type_version)) { |
| PyType_Watch(TYPE_WATCHER_ID, (PyObject *)type); |
| _Py_BloomFilter_Add(dependencies, type); |
| } |
| } |
| } |
| break; |
| } |
| |
| case _GUARD_TYPE_VERSION_AND_LOCK: { |
| break; |
| } |
| |
| case _CHECK_MANAGED_OBJECT_HAS_VALUES: { |
| break; |
| } |
| |
| case _LOAD_ATTR_INSTANCE_VALUE: { |
| JitOptSymbol *attr; |
| uint16_t offset = (uint16_t)this_instr->operand0; |
| attr = sym_new_not_null(ctx); |
| (void)offset; |
| stack_pointer[-1] = attr; |
| break; |
| } |
| |
| case _LOAD_ATTR_MODULE: { |
| JitOptSymbol *owner; |
| JitOptSymbol *attr; |
| owner = stack_pointer[-1]; |
| uint32_t dict_version = (uint32_t)this_instr->operand0; |
| uint16_t index = (uint16_t)this_instr->operand0; |
| (void)dict_version; |
| (void)index; |
| attr = NULL; |
| if (sym_is_const(ctx, owner)) { |
| PyModuleObject *mod = (PyModuleObject *)sym_get_const(ctx, owner); |
| if (PyModule_CheckExact(mod)) { |
| PyObject *dict = mod->md_dict; |
| stack_pointer[-1] = attr; |
| uint64_t watched_mutations = get_mutations(dict); |
| if (watched_mutations < _Py_MAX_ALLOWED_GLOBALS_MODIFICATIONS) { |
| PyDict_Watch(GLOBALS_WATCHER_ID, dict); |
| _Py_BloomFilter_Add(dependencies, dict); |
| PyObject *res = convert_global_to_const(this_instr, dict, true); |
| attr = sym_new_const(ctx, res); |
| } |
| } |
| } |
| if (attr == NULL) { |
| attr = sym_new_not_null(ctx); |
| } |
| stack_pointer[-1] = attr; |
| break; |
| } |
| |
| case _LOAD_ATTR_WITH_HINT: { |
| JitOptSymbol *attr; |
| uint16_t hint = (uint16_t)this_instr->operand0; |
| attr = sym_new_not_null(ctx); |
| (void)hint; |
| stack_pointer[-1] = attr; |
| break; |
| } |
| |
| case _LOAD_ATTR_SLOT: { |
| JitOptSymbol *attr; |
| uint16_t index = (uint16_t)this_instr->operand0; |
| attr = sym_new_not_null(ctx); |
| (void)index; |
| stack_pointer[-1] = attr; |
| break; |
| } |
| |
| case _CHECK_ATTR_CLASS: { |
| JitOptSymbol *owner; |
| owner = stack_pointer[-1]; |
| uint32_t type_version = (uint32_t)this_instr->operand0; |
| PyObject *type = (PyObject *)_PyType_LookupByVersion(type_version); |
| if (type) { |
| if (type == sym_get_const(ctx, owner)) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| else { |
| sym_set_const(owner, type); |
| } |
| } |
| break; |
| } |
| |
| case _LOAD_ATTR_CLASS: { |
| JitOptSymbol *attr; |
| PyObject *descr = (PyObject *)this_instr->operand0; |
| attr = sym_new_not_null(ctx); |
| (void)descr; |
| stack_pointer[-1] = attr; |
| break; |
| } |
| |
| case _LOAD_ATTR_PROPERTY_FRAME: { |
| _Py_UOpsAbstractFrame *new_frame; |
| PyObject *fget = (PyObject *)this_instr->operand0; |
| (void)fget; |
| new_frame = NULL; |
| ctx->done = true; |
| stack_pointer[-1] = (JitOptSymbol *)new_frame; |
| break; |
| } |
| |
| /* _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN is not a viable micro-op for tier 2 */ |
| |
| case _GUARD_DORV_NO_DICT: { |
| break; |
| } |
| |
| case _STORE_ATTR_INSTANCE_VALUE: { |
| stack_pointer += -2; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _STORE_ATTR_WITH_HINT: { |
| stack_pointer += -2; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _STORE_ATTR_SLOT: { |
| stack_pointer += -2; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _COMPARE_OP: { |
| JitOptSymbol *res; |
| if (oparg & 16) { |
| res = sym_new_type(ctx, &PyBool_Type); |
| } |
| else { |
| res = _Py_uop_sym_new_not_null(ctx); |
| } |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _COMPARE_OP_FLOAT: { |
| JitOptSymbol *res; |
| res = sym_new_type(ctx, &PyBool_Type); |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _COMPARE_OP_INT: { |
| JitOptSymbol *right; |
| JitOptSymbol *left; |
| JitOptSymbol *res; |
| right = stack_pointer[-1]; |
| left = stack_pointer[-2]; |
| if (sym_is_const(ctx, left) && sym_is_const(ctx, right)) { |
| assert(PyLong_CheckExact(sym_get_const(ctx, left))); |
| assert(PyLong_CheckExact(sym_get_const(ctx, right))); |
| PyObject *tmp = PyObject_RichCompare(sym_get_const(ctx, left), |
| sym_get_const(ctx, right), |
| oparg >> 5); |
| if (tmp == NULL) { |
| goto error; |
| } |
| assert(PyBool_Check(tmp)); |
| assert(_Py_IsImmortal(tmp)); |
| REPLACE_OP(this_instr, _POP_TWO_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)tmp); |
| res = sym_new_const(ctx, tmp); |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| Py_DECREF(tmp); |
| } |
| else { |
| res = sym_new_type(ctx, &PyBool_Type); |
| stack_pointer += -1; |
| } |
| stack_pointer[-1] = res; |
| break; |
| } |
| |
| case _COMPARE_OP_STR: { |
| JitOptSymbol *res; |
| res = sym_new_type(ctx, &PyBool_Type); |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _IS_OP: { |
| JitOptSymbol *b; |
| b = sym_new_type(ctx, &PyBool_Type); |
| stack_pointer[-2] = b; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _CONTAINS_OP: { |
| JitOptSymbol *b; |
| b = sym_new_type(ctx, &PyBool_Type); |
| stack_pointer[-2] = b; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _GUARD_TOS_ANY_SET: { |
| JitOptSymbol *tos; |
| tos = stack_pointer[-1]; |
| if (sym_matches_type(tos, &PySet_Type) || |
| sym_matches_type(tos, &PyFrozenSet_Type)) |
| { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| break; |
| } |
| |
| case _CONTAINS_OP_SET: { |
| JitOptSymbol *b; |
| b = sym_new_type(ctx, &PyBool_Type); |
| stack_pointer[-2] = b; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _CONTAINS_OP_DICT: { |
| JitOptSymbol *b; |
| b = sym_new_type(ctx, &PyBool_Type); |
| stack_pointer[-2] = b; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _CHECK_EG_MATCH: { |
| JitOptSymbol *rest; |
| JitOptSymbol *match; |
| rest = sym_new_not_null(ctx); |
| match = sym_new_not_null(ctx); |
| stack_pointer[-2] = rest; |
| stack_pointer[-1] = match; |
| break; |
| } |
| |
| case _CHECK_EXC_MATCH: { |
| JitOptSymbol *b; |
| b = sym_new_not_null(ctx); |
| stack_pointer[-1] = b; |
| break; |
| } |
| |
| case _IMPORT_NAME: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _IMPORT_FROM: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[0] = res; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| /* _POP_JUMP_IF_FALSE is not a viable micro-op for tier 2 */ |
| |
| /* _POP_JUMP_IF_TRUE is not a viable micro-op for tier 2 */ |
| |
| case _IS_NONE: { |
| JitOptSymbol *b; |
| b = sym_new_not_null(ctx); |
| stack_pointer[-1] = b; |
| break; |
| } |
| |
| case _GET_LEN: { |
| JitOptSymbol *obj; |
| JitOptSymbol *len; |
| obj = stack_pointer[-1]; |
| int tuple_length = sym_tuple_length(obj); |
| if (tuple_length == -1) { |
| len = sym_new_type(ctx, &PyLong_Type); |
| } |
| else { |
| assert(tuple_length >= 0); |
| PyObject *temp = PyLong_FromLong(tuple_length); |
| if (temp == NULL) { |
| goto error; |
| } |
| if (_Py_IsImmortal(temp)) { |
| REPLACE_OP(this_instr, _LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)temp); |
| } |
| len = sym_new_const(ctx, temp); |
| stack_pointer[0] = len; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| Py_DECREF(temp); |
| stack_pointer += -1; |
| } |
| stack_pointer[0] = len; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _MATCH_CLASS: { |
| JitOptSymbol *attrs; |
| attrs = sym_new_not_null(ctx); |
| stack_pointer[-3] = attrs; |
| stack_pointer += -2; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _MATCH_MAPPING: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[0] = res; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _MATCH_SEQUENCE: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[0] = res; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _MATCH_KEYS: { |
| JitOptSymbol *values_or_none; |
| values_or_none = sym_new_not_null(ctx); |
| stack_pointer[0] = values_or_none; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _GET_ITER: { |
| JitOptSymbol *iter; |
| iter = sym_new_not_null(ctx); |
| stack_pointer[-1] = iter; |
| break; |
| } |
| |
| case _GET_YIELD_FROM_ITER: { |
| JitOptSymbol *iter; |
| iter = sym_new_not_null(ctx); |
| stack_pointer[-1] = iter; |
| break; |
| } |
| |
| /* _FOR_ITER is not a viable micro-op for tier 2 */ |
| |
| case _FOR_ITER_TIER_TWO: { |
| JitOptSymbol *next; |
| next = sym_new_not_null(ctx); |
| stack_pointer[0] = next; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| /* _INSTRUMENTED_FOR_ITER is not a viable micro-op for tier 2 */ |
| |
| case _ITER_CHECK_LIST: { |
| break; |
| } |
| |
| /* _ITER_JUMP_LIST is not a viable micro-op for tier 2 */ |
| |
| case _GUARD_NOT_EXHAUSTED_LIST: { |
| break; |
| } |
| |
| /* _ITER_NEXT_LIST is not a viable micro-op for tier 2 */ |
| |
| case _ITER_NEXT_LIST_TIER_TWO: { |
| JitOptSymbol *next; |
| next = sym_new_not_null(ctx); |
| stack_pointer[0] = next; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _ITER_CHECK_TUPLE: { |
| break; |
| } |
| |
| /* _ITER_JUMP_TUPLE is not a viable micro-op for tier 2 */ |
| |
| case _GUARD_NOT_EXHAUSTED_TUPLE: { |
| break; |
| } |
| |
| case _ITER_NEXT_TUPLE: { |
| JitOptSymbol *next; |
| next = sym_new_not_null(ctx); |
| stack_pointer[0] = next; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _ITER_CHECK_RANGE: { |
| break; |
| } |
| |
| /* _ITER_JUMP_RANGE is not a viable micro-op for tier 2 */ |
| |
| case _GUARD_NOT_EXHAUSTED_RANGE: { |
| break; |
| } |
| |
| case _ITER_NEXT_RANGE: { |
| JitOptSymbol *next; |
| next = sym_new_type(ctx, &PyLong_Type); |
| stack_pointer[0] = next; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _FOR_ITER_GEN_FRAME: { |
| _Py_UOpsAbstractFrame *gen_frame; |
| gen_frame = NULL; |
| ctx->done = true; |
| stack_pointer[0] = (JitOptSymbol *)gen_frame; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _INSERT_NULL: { |
| JitOptSymbol *self; |
| JitOptSymbol **method_and_self; |
| self = stack_pointer[-1]; |
| method_and_self = &stack_pointer[-1]; |
| method_and_self[0] = sym_new_null(ctx); |
| method_and_self[1] = self; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _LOAD_SPECIAL: { |
| JitOptSymbol **method_and_self; |
| method_and_self = &stack_pointer[-2]; |
| method_and_self[0] = sym_new_not_null(ctx); |
| method_and_self[1] = sym_new_unknown(ctx); |
| break; |
| } |
| |
| case _WITH_EXCEPT_START: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[0] = res; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _PUSH_EXC_INFO: { |
| JitOptSymbol *prev_exc; |
| JitOptSymbol *new_exc; |
| prev_exc = sym_new_not_null(ctx); |
| new_exc = sym_new_not_null(ctx); |
| stack_pointer[-1] = prev_exc; |
| stack_pointer[0] = new_exc; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT: { |
| break; |
| } |
| |
| case _GUARD_KEYS_VERSION: { |
| break; |
| } |
| |
| case _LOAD_ATTR_METHOD_WITH_VALUES: { |
| JitOptSymbol *owner; |
| JitOptSymbol *attr; |
| JitOptSymbol *self; |
| owner = stack_pointer[-1]; |
| PyObject *descr = (PyObject *)this_instr->operand0; |
| (void)descr; |
| attr = sym_new_not_null(ctx); |
| self = owner; |
| stack_pointer[-1] = attr; |
| stack_pointer[0] = self; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _LOAD_ATTR_METHOD_NO_DICT: { |
| JitOptSymbol *owner; |
| JitOptSymbol *attr; |
| JitOptSymbol *self; |
| owner = stack_pointer[-1]; |
| PyObject *descr = (PyObject *)this_instr->operand0; |
| (void)descr; |
| attr = sym_new_not_null(ctx); |
| self = owner; |
| stack_pointer[-1] = attr; |
| stack_pointer[0] = self; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES: { |
| JitOptSymbol *attr; |
| attr = sym_new_not_null(ctx); |
| stack_pointer[-1] = attr; |
| break; |
| } |
| |
| case _LOAD_ATTR_NONDESCRIPTOR_NO_DICT: { |
| JitOptSymbol *attr; |
| attr = sym_new_not_null(ctx); |
| stack_pointer[-1] = attr; |
| break; |
| } |
| |
| case _CHECK_ATTR_METHOD_LAZY_DICT: { |
| break; |
| } |
| |
| case _LOAD_ATTR_METHOD_LAZY_DICT: { |
| JitOptSymbol *owner; |
| JitOptSymbol *attr; |
| JitOptSymbol *self; |
| owner = stack_pointer[-1]; |
| PyObject *descr = (PyObject *)this_instr->operand0; |
| (void)descr; |
| attr = sym_new_not_null(ctx); |
| self = owner; |
| stack_pointer[-1] = attr; |
| stack_pointer[0] = self; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _MAYBE_EXPAND_METHOD: { |
| JitOptSymbol **args; |
| JitOptSymbol *self_or_null; |
| JitOptSymbol *callable; |
| args = &stack_pointer[-oparg]; |
| self_or_null = stack_pointer[-1 - oparg]; |
| callable = stack_pointer[-2 - oparg]; |
| (void)args; |
| callable = sym_new_not_null(ctx); |
| self_or_null = sym_new_not_null(ctx); |
| stack_pointer[-2 - oparg] = callable; |
| stack_pointer[-1 - oparg] = self_or_null; |
| break; |
| } |
| |
| /* _DO_CALL is not a viable micro-op for tier 2 */ |
| |
| /* _MONITOR_CALL is not a viable micro-op for tier 2 */ |
| |
| case _PY_FRAME_GENERAL: { |
| _Py_UOpsAbstractFrame *new_frame; |
| PyCodeObject *co = NULL; |
| assert((this_instr + 2)->opcode == _PUSH_FRAME); |
| co = get_code_with_logging((this_instr + 2)); |
| if (co == NULL) { |
| ctx->done = true; |
| break; |
| } |
| new_frame = frame_new(ctx, co, 0, NULL, 0); |
| stack_pointer[-2 - oparg] = (JitOptSymbol *)new_frame; |
| stack_pointer += -1 - oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _CHECK_FUNCTION_VERSION: { |
| JitOptSymbol *callable; |
| callable = stack_pointer[-2 - oparg]; |
| uint32_t func_version = (uint32_t)this_instr->operand0; |
| if (sym_is_const(ctx, callable) && sym_matches_type(callable, &PyFunction_Type)) { |
| assert(PyFunction_Check(sym_get_const(ctx, callable))); |
| REPLACE_OP(this_instr, _CHECK_FUNCTION_VERSION_INLINE, 0, func_version); |
| this_instr->operand1 = (uintptr_t)sym_get_const(ctx, callable); |
| } |
| sym_set_type(callable, &PyFunction_Type); |
| break; |
| } |
| |
| case _CHECK_FUNCTION_VERSION_INLINE: { |
| break; |
| } |
| |
| case _CHECK_METHOD_VERSION: { |
| break; |
| } |
| |
| case _EXPAND_METHOD: { |
| break; |
| } |
| |
| case _CHECK_IS_NOT_PY_CALLABLE: { |
| break; |
| } |
| |
| case _CALL_NON_PY_GENERAL: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-2 - oparg] = res; |
| stack_pointer += -1 - oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _CHECK_CALL_BOUND_METHOD_EXACT_ARGS: { |
| JitOptSymbol *null; |
| JitOptSymbol *callable; |
| null = stack_pointer[-1 - oparg]; |
| callable = stack_pointer[-2 - oparg]; |
| sym_set_null(null); |
| sym_set_type(callable, &PyMethod_Type); |
| break; |
| } |
| |
| case _INIT_CALL_BOUND_METHOD_EXACT_ARGS: { |
| JitOptSymbol *self_or_null; |
| JitOptSymbol *callable; |
| self_or_null = stack_pointer[-1 - oparg]; |
| callable = stack_pointer[-2 - oparg]; |
| callable = sym_new_not_null(ctx); |
| self_or_null = sym_new_not_null(ctx); |
| stack_pointer[-2 - oparg] = callable; |
| stack_pointer[-1 - oparg] = self_or_null; |
| break; |
| } |
| |
| case _CHECK_PEP_523: { |
| if (_PyInterpreterState_GET()->eval_frame == NULL) { |
| REPLACE_OP(this_instr, _NOP, 0 ,0); |
| } |
| break; |
| } |
| |
| case _CHECK_FUNCTION_EXACT_ARGS: { |
| JitOptSymbol *self_or_null; |
| JitOptSymbol *callable; |
| self_or_null = stack_pointer[-1 - oparg]; |
| callable = stack_pointer[-2 - oparg]; |
| assert(sym_matches_type(callable, &PyFunction_Type)); |
| if (sym_is_const(ctx, callable)) { |
| if (sym_is_null(self_or_null) || sym_is_not_null(self_or_null)) { |
| PyFunctionObject *func = (PyFunctionObject *)sym_get_const(ctx, callable); |
| PyCodeObject *co = (PyCodeObject *)func->func_code; |
| if (co->co_argcount == oparg + !sym_is_null(self_or_null)) { |
| REPLACE_OP(this_instr, _NOP, 0 ,0); |
| } |
| } |
| } |
| break; |
| } |
| |
| case _CHECK_STACK_SPACE: { |
| assert(corresponding_check_stack == NULL); |
| corresponding_check_stack = this_instr; |
| break; |
| } |
| |
| case _CHECK_RECURSION_REMAINING: { |
| break; |
| } |
| |
| case _INIT_CALL_PY_EXACT_ARGS: { |
| JitOptSymbol **args; |
| JitOptSymbol *self_or_null; |
| _Py_UOpsAbstractFrame *new_frame; |
| args = &stack_pointer[-oparg]; |
| self_or_null = stack_pointer[-1 - oparg]; |
| int argcount = oparg; |
| PyCodeObject *co = NULL; |
| assert((this_instr + 2)->opcode == _PUSH_FRAME); |
| co = get_code_with_logging((this_instr + 2)); |
| if (co == NULL) { |
| ctx->done = true; |
| break; |
| } |
| assert(self_or_null != NULL); |
| assert(args != NULL); |
| if (sym_is_not_null(self_or_null)) { |
| args--; |
| argcount++; |
| } |
| if (sym_is_null(self_or_null) || sym_is_not_null(self_or_null)) { |
| new_frame = frame_new(ctx, co, 0, args, argcount); |
| } else { |
| new_frame = frame_new(ctx, co, 0, NULL, 0); |
| } |
| stack_pointer[-2 - oparg] = (JitOptSymbol *)new_frame; |
| stack_pointer += -1 - oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _PUSH_FRAME: { |
| _Py_UOpsAbstractFrame *new_frame; |
| new_frame = (_Py_UOpsAbstractFrame *)stack_pointer[-1]; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| ctx->frame->stack_pointer = stack_pointer; |
| ctx->frame = new_frame; |
| ctx->curr_frame_depth++; |
| stack_pointer = new_frame->stack_pointer; |
| co = get_code(this_instr); |
| if (co == NULL) { |
| ctx->done = true; |
| break; |
| } |
| int framesize = co->co_framesize; |
| assert(framesize > 0); |
| curr_space += framesize; |
| if (curr_space < 0 || curr_space > INT32_MAX) { |
| ctx->done = true; |
| break; |
| } |
| max_space = curr_space > max_space ? curr_space : max_space; |
| if (first_valid_check_stack == NULL) { |
| first_valid_check_stack = corresponding_check_stack; |
| } |
| else if (corresponding_check_stack) { |
| corresponding_check_stack->opcode = _NOP; |
| } |
| corresponding_check_stack = NULL; |
| break; |
| } |
| |
| case _GUARD_NOS_NULL: { |
| JitOptSymbol *null; |
| null = stack_pointer[-2]; |
| if (sym_is_null(null)) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_null(null); |
| break; |
| } |
| |
| case _GUARD_NOS_NOT_NULL: { |
| JitOptSymbol *nos; |
| nos = stack_pointer[-2]; |
| if (sym_is_not_null(nos)) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_non_null(nos); |
| break; |
| } |
| |
| case _GUARD_THIRD_NULL: { |
| JitOptSymbol *null; |
| null = stack_pointer[-3]; |
| if (sym_is_null(null)) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_null(null); |
| break; |
| } |
| |
| case _GUARD_CALLABLE_TYPE_1: { |
| JitOptSymbol *callable; |
| callable = stack_pointer[-3]; |
| if (sym_get_const(ctx, callable) == (PyObject *)&PyType_Type) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_const(callable, (PyObject *)&PyType_Type); |
| break; |
| } |
| |
| case _CALL_TYPE_1: { |
| JitOptSymbol *arg; |
| JitOptSymbol *res; |
| arg = stack_pointer[-1]; |
| if (sym_has_type(arg)) { |
| res = sym_new_const(ctx, (PyObject *)sym_get_type(arg)); |
| } |
| else { |
| res = sym_new_not_null(ctx); |
| } |
| stack_pointer[-3] = res; |
| stack_pointer += -2; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _GUARD_CALLABLE_STR_1: { |
| JitOptSymbol *callable; |
| callable = stack_pointer[-3]; |
| if (sym_get_const(ctx, callable) == (PyObject *)&PyUnicode_Type) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_const(callable, (PyObject *)&PyUnicode_Type); |
| break; |
| } |
| |
| case _CALL_STR_1: { |
| JitOptSymbol *arg; |
| JitOptSymbol *res; |
| arg = stack_pointer[-1]; |
| if (sym_matches_type(arg, &PyUnicode_Type)) { |
| res = arg; |
| } |
| else { |
| res = sym_new_type(ctx, &PyUnicode_Type); |
| } |
| stack_pointer[-3] = res; |
| stack_pointer += -2; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _GUARD_CALLABLE_TUPLE_1: { |
| JitOptSymbol *callable; |
| callable = stack_pointer[-3]; |
| if (sym_get_const(ctx, callable) == (PyObject *)&PyTuple_Type) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_const(callable, (PyObject *)&PyTuple_Type); |
| break; |
| } |
| |
| case _CALL_TUPLE_1: { |
| JitOptSymbol *arg; |
| JitOptSymbol *res; |
| arg = stack_pointer[-1]; |
| if (sym_matches_type(arg, &PyTuple_Type)) { |
| res = arg; |
| } |
| else { |
| res = sym_new_type(ctx, &PyTuple_Type); |
| } |
| stack_pointer[-3] = res; |
| stack_pointer += -2; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _CHECK_AND_ALLOCATE_OBJECT: { |
| JitOptSymbol **args; |
| JitOptSymbol *self_or_null; |
| JitOptSymbol *callable; |
| args = &stack_pointer[-oparg]; |
| self_or_null = stack_pointer[-1 - oparg]; |
| callable = stack_pointer[-2 - oparg]; |
| uint32_t type_version = (uint32_t)this_instr->operand0; |
| (void)type_version; |
| (void)args; |
| callable = sym_new_not_null(ctx); |
| self_or_null = sym_new_not_null(ctx); |
| stack_pointer[-2 - oparg] = callable; |
| stack_pointer[-1 - oparg] = self_or_null; |
| break; |
| } |
| |
| case _CREATE_INIT_FRAME: { |
| _Py_UOpsAbstractFrame *init_frame; |
| init_frame = NULL; |
| ctx->done = true; |
| stack_pointer[-2 - oparg] = (JitOptSymbol *)init_frame; |
| stack_pointer += -1 - oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _EXIT_INIT_CHECK: { |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _CALL_BUILTIN_CLASS: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-2 - oparg] = res; |
| stack_pointer += -1 - oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _CALL_BUILTIN_O: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-2 - oparg] = res; |
| stack_pointer += -1 - oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _CALL_BUILTIN_FAST: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-2 - oparg] = res; |
| stack_pointer += -1 - oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _CALL_BUILTIN_FAST_WITH_KEYWORDS: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-2 - oparg] = res; |
| stack_pointer += -1 - oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _GUARD_CALLABLE_LEN: { |
| JitOptSymbol *callable; |
| callable = stack_pointer[-3]; |
| PyObject *len = _PyInterpreterState_GET()->callable_cache.len; |
| if (sym_get_const(ctx, callable) == len) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_const(callable, len); |
| break; |
| } |
| |
| case _CALL_LEN: { |
| JitOptSymbol *res; |
| res = sym_new_type(ctx, &PyLong_Type); |
| stack_pointer[-3] = res; |
| stack_pointer += -2; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _GUARD_CALLABLE_ISINSTANCE: { |
| JitOptSymbol *callable; |
| callable = stack_pointer[-4]; |
| PyObject *isinstance = _PyInterpreterState_GET()->callable_cache.isinstance; |
| if (sym_get_const(ctx, callable) == isinstance) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_const(callable, isinstance); |
| break; |
| } |
| |
| case _CALL_ISINSTANCE: { |
| JitOptSymbol *cls; |
| JitOptSymbol *instance; |
| JitOptSymbol *res; |
| cls = stack_pointer[-1]; |
| instance = stack_pointer[-2]; |
| res = sym_new_type(ctx, &PyBool_Type); |
| PyTypeObject *inst_type = sym_get_type(instance); |
| PyTypeObject *cls_o = (PyTypeObject *)sym_get_const(ctx, cls); |
| if (inst_type && cls_o && sym_matches_type(cls, &PyType_Type)) { |
| PyObject *out = Py_False; |
| if (inst_type == cls_o || PyType_IsSubtype(inst_type, cls_o)) { |
| out = Py_True; |
| } |
| sym_set_const(res, out); |
| REPLACE_OP(this_instr, _POP_CALL_TWO_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)out); |
| } |
| stack_pointer[-4] = res; |
| stack_pointer += -3; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _GUARD_CALLABLE_LIST_APPEND: { |
| JitOptSymbol *callable; |
| callable = stack_pointer[-3]; |
| PyObject *list_append = _PyInterpreterState_GET()->callable_cache.list_append; |
| if (sym_get_const(ctx, callable) == list_append) { |
| REPLACE_OP(this_instr, _NOP, 0, 0); |
| } |
| sym_set_const(callable, list_append); |
| break; |
| } |
| |
| case _CALL_LIST_APPEND: { |
| stack_pointer += -3; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _CALL_METHOD_DESCRIPTOR_O: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-2 - oparg] = res; |
| stack_pointer += -1 - oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-2 - oparg] = res; |
| stack_pointer += -1 - oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _CALL_METHOD_DESCRIPTOR_NOARGS: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-2 - oparg] = res; |
| stack_pointer += -1 - oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _CALL_METHOD_DESCRIPTOR_FAST: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-2 - oparg] = res; |
| stack_pointer += -1 - oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| /* _MONITOR_CALL_KW is not a viable micro-op for tier 2 */ |
| |
| case _MAYBE_EXPAND_METHOD_KW: { |
| break; |
| } |
| |
| /* _DO_CALL_KW is not a viable micro-op for tier 2 */ |
| |
| case _PY_FRAME_KW: { |
| _Py_UOpsAbstractFrame *new_frame; |
| new_frame = NULL; |
| ctx->done = true; |
| stack_pointer[-3 - oparg] = (JitOptSymbol *)new_frame; |
| stack_pointer += -2 - oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _CHECK_FUNCTION_VERSION_KW: { |
| break; |
| } |
| |
| case _CHECK_METHOD_VERSION_KW: { |
| break; |
| } |
| |
| case _EXPAND_METHOD_KW: { |
| break; |
| } |
| |
| case _CHECK_IS_NOT_PY_CALLABLE_KW: { |
| break; |
| } |
| |
| case _CALL_KW_NON_PY: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-3 - oparg] = res; |
| stack_pointer += -2 - oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _MAKE_CALLARGS_A_TUPLE: { |
| break; |
| } |
| |
| /* _DO_CALL_FUNCTION_EX is not a viable micro-op for tier 2 */ |
| |
| case _MAKE_FUNCTION: { |
| JitOptSymbol *func; |
| func = sym_new_not_null(ctx); |
| stack_pointer[-1] = func; |
| break; |
| } |
| |
| case _SET_FUNCTION_ATTRIBUTE: { |
| JitOptSymbol *func_out; |
| func_out = sym_new_not_null(ctx); |
| stack_pointer[-2] = func_out; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _RETURN_GENERATOR: { |
| JitOptSymbol *res; |
| ctx->frame->stack_pointer = stack_pointer; |
| frame_pop(ctx); |
| stack_pointer = ctx->frame->stack_pointer; |
| res = sym_new_unknown(ctx); |
| assert(corresponding_check_stack == NULL); |
| assert(co != NULL); |
| int framesize = co->co_framesize; |
| assert(framesize > 0); |
| assert(framesize <= curr_space); |
| curr_space -= framesize; |
| stack_pointer[0] = res; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| co = get_code(this_instr); |
| if (co == NULL) { |
| ctx->done = true; |
| } |
| break; |
| } |
| |
| case _BUILD_SLICE: { |
| JitOptSymbol *slice; |
| slice = sym_new_type(ctx, &PySlice_Type); |
| stack_pointer[-oparg] = slice; |
| stack_pointer += 1 - oparg; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _CONVERT_VALUE: { |
| JitOptSymbol *result; |
| result = sym_new_not_null(ctx); |
| stack_pointer[-1] = result; |
| break; |
| } |
| |
| case _FORMAT_SIMPLE: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-1] = res; |
| break; |
| } |
| |
| case _FORMAT_WITH_SPEC: { |
| JitOptSymbol *res; |
| res = sym_new_not_null(ctx); |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _COPY: { |
| JitOptSymbol *bottom; |
| JitOptSymbol *top; |
| bottom = stack_pointer[-1 - (oparg-1)]; |
| assert(oparg > 0); |
| top = bottom; |
| stack_pointer[0] = top; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _BINARY_OP: { |
| JitOptSymbol *rhs; |
| JitOptSymbol *lhs; |
| JitOptSymbol *res; |
| rhs = stack_pointer[-1]; |
| lhs = stack_pointer[-2]; |
| bool lhs_int = sym_matches_type(lhs, &PyLong_Type); |
| bool rhs_int = sym_matches_type(rhs, &PyLong_Type); |
| bool lhs_float = sym_matches_type(lhs, &PyFloat_Type); |
| bool rhs_float = sym_matches_type(rhs, &PyFloat_Type); |
| if (!((lhs_int || lhs_float) && (rhs_int || rhs_float))) { |
| res = sym_new_unknown(ctx); |
| } |
| else if (oparg == NB_POWER || oparg == NB_INPLACE_POWER) { |
| if (rhs_float) { |
| res = sym_new_unknown(ctx); |
| } |
| else if (lhs_float) { |
| res = sym_new_type(ctx, &PyFloat_Type); |
| } |
| else if (!sym_is_const(ctx, rhs)) { |
| res = sym_new_unknown(ctx); |
| } |
| else if (_PyLong_IsNegative((PyLongObject *)sym_get_const(ctx, rhs))) { |
| res = sym_new_type(ctx, &PyFloat_Type); |
| } |
| else { |
| res = sym_new_type(ctx, &PyLong_Type); |
| } |
| } |
| else if (oparg == NB_TRUE_DIVIDE || oparg == NB_INPLACE_TRUE_DIVIDE) { |
| res = sym_new_type(ctx, &PyFloat_Type); |
| } |
| else if (lhs_int && rhs_int) { |
| res = sym_new_type(ctx, &PyLong_Type); |
| } |
| else { |
| res = sym_new_type(ctx, &PyFloat_Type); |
| } |
| stack_pointer[-2] = res; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _SWAP: { |
| JitOptSymbol *top; |
| JitOptSymbol *bottom; |
| top = stack_pointer[-1]; |
| bottom = stack_pointer[-2 - (oparg-2)]; |
| JitOptSymbol *temp = bottom; |
| bottom = top; |
| top = temp; |
| assert(oparg >= 2); |
| stack_pointer[-2 - (oparg-2)] = bottom; |
| stack_pointer[-1] = top; |
| break; |
| } |
| |
| /* _INSTRUMENTED_LINE is not a viable micro-op for tier 2 */ |
| |
| /* _INSTRUMENTED_INSTRUCTION is not a viable micro-op for tier 2 */ |
| |
| /* _INSTRUMENTED_JUMP_FORWARD is not a viable micro-op for tier 2 */ |
| |
| /* _MONITOR_JUMP_BACKWARD is not a viable micro-op for tier 2 */ |
| |
| /* _INSTRUMENTED_NOT_TAKEN is not a viable micro-op for tier 2 */ |
| |
| /* _INSTRUMENTED_POP_JUMP_IF_TRUE is not a viable micro-op for tier 2 */ |
| |
| /* _INSTRUMENTED_POP_JUMP_IF_FALSE is not a viable micro-op for tier 2 */ |
| |
| /* _INSTRUMENTED_POP_JUMP_IF_NONE is not a viable micro-op for tier 2 */ |
| |
| /* _INSTRUMENTED_POP_JUMP_IF_NOT_NONE is not a viable micro-op for tier 2 */ |
| |
| case _GUARD_IS_TRUE_POP: { |
| JitOptSymbol *flag; |
| flag = stack_pointer[-1]; |
| if (sym_is_const(ctx, flag)) { |
| PyObject *value = sym_get_const(ctx, flag); |
| assert(value != NULL); |
| eliminate_pop_guard(this_instr, value != Py_True); |
| } |
| sym_set_const(flag, Py_True); |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _GUARD_IS_FALSE_POP: { |
| JitOptSymbol *flag; |
| flag = stack_pointer[-1]; |
| if (sym_is_const(ctx, flag)) { |
| PyObject *value = sym_get_const(ctx, flag); |
| assert(value != NULL); |
| eliminate_pop_guard(this_instr, value != Py_False); |
| } |
| sym_set_const(flag, Py_False); |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _GUARD_IS_NONE_POP: { |
| JitOptSymbol *val; |
| val = stack_pointer[-1]; |
| if (sym_is_const(ctx, val)) { |
| PyObject *value = sym_get_const(ctx, val); |
| assert(value != NULL); |
| eliminate_pop_guard(this_instr, !Py_IsNone(value)); |
| } |
| else if (sym_has_type(val)) { |
| assert(!sym_matches_type(val, &_PyNone_Type)); |
| eliminate_pop_guard(this_instr, true); |
| } |
| sym_set_const(val, Py_None); |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _GUARD_IS_NOT_NONE_POP: { |
| JitOptSymbol *val; |
| val = stack_pointer[-1]; |
| if (sym_is_const(ctx, val)) { |
| PyObject *value = sym_get_const(ctx, val); |
| assert(value != NULL); |
| eliminate_pop_guard(this_instr, Py_IsNone(value)); |
| } |
| else if (sym_has_type(val)) { |
| assert(!sym_matches_type(val, &_PyNone_Type)); |
| eliminate_pop_guard(this_instr, false); |
| } |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _JUMP_TO_TOP: { |
| ctx->done = true; |
| break; |
| } |
| |
| case _SET_IP: { |
| break; |
| } |
| |
| case _CHECK_STACK_SPACE_OPERAND: { |
| uint32_t framesize = (uint32_t)this_instr->operand0; |
| (void)framesize; |
| Py_UNREACHABLE(); |
| break; |
| } |
| |
| case _SAVE_RETURN_OFFSET: { |
| break; |
| } |
| |
| case _EXIT_TRACE: { |
| PyObject *exit_p = (PyObject *)this_instr->operand0; |
| (void)exit_p; |
| ctx->done = true; |
| break; |
| } |
| |
| case _CHECK_VALIDITY: { |
| break; |
| } |
| |
| case _LOAD_CONST_INLINE: { |
| JitOptSymbol *value; |
| PyObject *ptr = (PyObject *)this_instr->operand0; |
| value = sym_new_const(ctx, ptr); |
| stack_pointer[0] = value; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _POP_TOP_LOAD_CONST_INLINE: { |
| JitOptSymbol *value; |
| PyObject *ptr = (PyObject *)this_instr->operand0; |
| value = sym_new_const(ctx, ptr); |
| stack_pointer[-1] = value; |
| break; |
| } |
| |
| case _LOAD_CONST_INLINE_BORROW: { |
| JitOptSymbol *value; |
| PyObject *ptr = (PyObject *)this_instr->operand0; |
| value = sym_new_const(ctx, ptr); |
| stack_pointer[0] = value; |
| stack_pointer += 1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _POP_TOP_LOAD_CONST_INLINE_BORROW: { |
| JitOptSymbol *value; |
| PyObject *ptr = (PyObject *)this_instr->operand0; |
| value = sym_new_const(ctx, ptr); |
| stack_pointer[-1] = value; |
| break; |
| } |
| |
| case _POP_TWO_LOAD_CONST_INLINE_BORROW: { |
| JitOptSymbol *value; |
| value = sym_new_not_null(ctx); |
| stack_pointer[-2] = value; |
| stack_pointer += -1; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _POP_CALL_TWO_LOAD_CONST_INLINE_BORROW: { |
| JitOptSymbol *value; |
| PyObject *ptr = (PyObject *)this_instr->operand0; |
| value = sym_new_const(ctx, ptr); |
| stack_pointer[-4] = value; |
| stack_pointer += -3; |
| assert(WITHIN_STACK_BOUNDS()); |
| break; |
| } |
| |
| case _CHECK_FUNCTION: { |
| break; |
| } |
| |
| case _START_EXECUTOR: { |
| break; |
| } |
| |
| case _MAKE_WARM: { |
| break; |
| } |
| |
| case _FATAL_ERROR: { |
| break; |
| } |
| |
| case _DEOPT: { |
| break; |
| } |
| |
| case _ERROR_POP_N: { |
| break; |
| } |
| |
| case _TIER2_RESUME_CHECK: { |
| break; |
| } |
| |
