// 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;
}
/* _CHECK_PERIODIC_AT_END is not a viable micro-op for tier 2 */
case _CHECK_PERIODIC_IF_NOT_YIELD_FROM: {
break;
}
/* _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: {
JitOptRef value;
value = GETLOCAL(oparg);
if (sym_is_null(value)) {
ctx->done = true;
}
assert(!PyJitRef_IsUnique(value));
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = value;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOAD_FAST: {
JitOptRef value;
value = GETLOCAL(oparg);
assert(!PyJitRef_IsUnique(value));
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = value;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOAD_FAST_BORROW: {
JitOptRef value;
value = PyJitRef_Borrow(GETLOCAL(oparg));
assert(!PyJitRef_IsUnique(value));
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = value;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOAD_FAST_AND_CLEAR: {
JitOptRef value;
value = GETLOCAL(oparg);
JitOptRef temp = sym_new_null(ctx);
GETLOCAL(oparg) = temp;
assert(!PyJitRef_IsUnique(value));
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = value;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOAD_CONST: {
JitOptRef value;
PyCodeObject *co = get_current_code_object(ctx);
PyObject *val = PyTuple_GET_ITEM(co->co_consts, oparg);
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)val);
value = PyJitRef_Borrow(sym_new_const(ctx, val));
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = value;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOAD_SMALL_INT: {
JitOptRef value;
PyObject *val = PyLong_FromLong(oparg);
assert(val);
assert(_Py_IsImmortal(val));
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)val);
value = PyJitRef_Borrow(sym_new_const(ctx, val));
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = value;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _SWAP_FAST: {
JitOptRef value;
JitOptRef trash;
value = stack_pointer[-1];
JitOptRef tmp = GETLOCAL(oparg);
GETLOCAL(oparg) = PyJitRef_RemoveUnique(value);
trash = tmp;
stack_pointer[-1] = trash;
break;
}
case _POP_TOP: {
JitOptRef value;
value = stack_pointer[-1];
optimize_pop_top(ctx, this_instr, value);
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _POP_TOP_NOP: {
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _POP_TOP_INT: {
JitOptRef value;
value = stack_pointer[-1];
if (PyJitRef_IsBorrowed(value)) {
ADD_OP(_POP_TOP_NOP, 0, 0);
}
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _POP_TOP_FLOAT: {
JitOptRef value;
value = stack_pointer[-1];
if (PyJitRef_IsBorrowed(value)) {
ADD_OP(_POP_TOP_NOP, 0, 0);
}
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _POP_TOP_UNICODE: {
JitOptRef value;
value = stack_pointer[-1];
if (PyJitRef_IsBorrowed(value)) {
ADD_OP(_POP_TOP_NOP, 0, 0);
}
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _POP_TOP_OPARG: {
JitOptRef *args;
args = &stack_pointer[-oparg];
for (int i = oparg-1; i >= 0; i--) {
optimize_pop_top(ctx, this_instr, args[i]);
}
CHECK_STACK_BOUNDS(-oparg);
stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _PUSH_NULL: {
JitOptRef res;
res = PyJitRef_Borrow(sym_new_null(ctx));
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = res;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _END_FOR: {
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _POP_ITER: {
CHECK_STACK_BOUNDS(-2);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _END_SEND: {
JitOptRef val;
val = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(-2);
stack_pointer[-3] = val;
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _UNARY_NEGATIVE: {
JitOptRef value;
JitOptRef res;
JitOptRef v;
value = stack_pointer[-1];
v = value;
if (
sym_is_safe_const(ctx, value)
) {
JitOptRef value_sym = value;
_PyStackRef value = sym_get_const_as_stackref(ctx, value_sym);
_PyStackRef res_stackref;
_PyStackRef v_stackref;
/* Start of uop copied from bytecodes for constant evaluation */
PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value));
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
res_stackref = PyStackRef_FromPyObjectSteal(res_o);
v_stackref = value;
/* End of uop copied from bytecodes for constant evaluation */
(void)v_stackref;
res = sym_new_const_steal(ctx, PyStackRef_AsPyObjectSteal(res_stackref));
if (sym_is_const(ctx, res)) {
PyObject *result = sym_get_const(ctx, res);
if (_Py_IsImmortal(result)) {
// Replace with _LOAD_CONST_INLINE_BORROW + _SWAP since we have one input and an immortal result
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)result);
ADD_OP(_SWAP, 2, 0);
}
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = res;
stack_pointer[0] = v;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
if (sym_matches_type(value, &PyFloat_Type) && PyJitRef_IsUnique(value)) {
ADD_OP(_UNARY_NEGATIVE_FLOAT_INPLACE, 0, 0);
v = PyJitRef_Borrow(sym_new_null(ctx));
res = PyJitRef_MakeUnique(sym_new_type(ctx, &PyFloat_Type));
}
else if (sym_is_compact_int(value)) {
res = sym_new_compact_int(ctx);
}
else {
PyTypeObject *type = sym_get_type(value);
if (type == &PyLong_Type || type == &PyFloat_Type) {
res = sym_new_type(ctx, type);
}
else {
res = sym_new_not_null(ctx);
}
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = res;
stack_pointer[0] = v;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _UNARY_NEGATIVE_FLOAT_INPLACE: {
JitOptRef res;
JitOptRef v;
res = sym_new_not_null(ctx);
v = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = res;
stack_pointer[0] = v;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _UNARY_NOT: {
JitOptRef value;
JitOptRef res;
value = stack_pointer[-1];
if (
sym_is_safe_const(ctx, value)
) {
JitOptRef value_sym = value;
_PyStackRef value = sym_get_const_as_stackref(ctx, value_sym);
_PyStackRef res_stackref;
/* Start of uop copied from bytecodes for constant evaluation */
assert(PyStackRef_BoolCheck(value));
res_stackref = PyStackRef_IsFalse(value)
? PyStackRef_True : PyStackRef_False;
/* End of uop copied from bytecodes for constant evaluation */
res = sym_new_const_steal(ctx, PyStackRef_AsPyObjectSteal(res_stackref));
if (sym_is_const(ctx, res)) {
PyObject *result = sym_get_const(ctx, res);
if (_Py_IsImmortal(result)) {
// Replace with _POP_TOP + _LOAD_CONST_INLINE_BORROW since we have one input and an immortal result
ADD_OP(_POP_TOP, 0, 0);
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)result);
}
}
stack_pointer[-1] = res;
break;
}
sym_set_type(value, &PyBool_Type);
res = sym_new_truthiness(ctx, value, false);
stack_pointer[-1] = res;
break;
}
case _TO_BOOL: {
JitOptRef value;
JitOptRef res;
value = stack_pointer[-1];
int already_bool = optimize_to_bool(this_instr, ctx, value, &res,
_POP_TOP, _NOP);
if (!already_bool) {
res = sym_new_truthiness(ctx, value, true);
}
stack_pointer[-1] = res;
break;
}
case _TO_BOOL_BOOL: {
JitOptRef value;
value = stack_pointer[-1];
int already_bool = optimize_to_bool(this_instr, ctx, value, &value,
_POP_TOP, _NOP);
if (!already_bool) {
sym_set_type(value, &PyBool_Type);
}
stack_pointer[-1] = value;
break;
}
case _TO_BOOL_INT: {
JitOptRef value;
JitOptRef res;
JitOptRef v;
value = stack_pointer[-1];
int already_bool = optimize_to_bool(this_instr, ctx, value, &res,
_NOP, _SWAP);
if (!already_bool) {
sym_set_type(value, &PyLong_Type);
res = sym_new_truthiness(ctx, value, true);
}
v = value;
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = res;
stack_pointer[0] = v;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_NOS_LIST: {
JitOptRef nos;
nos = stack_pointer[-2];
if (sym_matches_type(nos, &PyList_Type)) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_type(nos, &PyList_Type);
}
break;
}
case _GUARD_TOS_LIST: {
JitOptRef tos;
tos = stack_pointer[-1];
if (sym_matches_type(tos, &PyList_Type)) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_type(tos, &PyList_Type);
}
break;
}
case _GUARD_TOS_SLICE: {
JitOptRef tos;
tos = stack_pointer[-1];
if (sym_matches_type(tos, &PySlice_Type)) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_type(tos, &PySlice_Type);
}
break;
}
case _TO_BOOL_LIST: {
JitOptRef value;
JitOptRef res;
JitOptRef v;
value = stack_pointer[-1];
int already_bool = optimize_to_bool(this_instr, ctx, value, &res,
_NOP, _SWAP);
if (!already_bool) {
res = sym_new_type(ctx, &PyBool_Type);
}
v = value;
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = res;
stack_pointer[0] = v;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _TO_BOOL_NONE: {
JitOptRef value;
JitOptRef res;
value = stack_pointer[-1];
int already_bool = optimize_to_bool(this_instr, ctx, value, &res,
_POP_TOP, _NOP);
if (!already_bool) {
sym_set_const(value, Py_None);
res = sym_new_const(ctx, Py_False);
}
stack_pointer[-1] = res;
break;
}
case _GUARD_NOS_COMPACT_ASCII: {
JitOptRef nos;
nos = stack_pointer[-2];
sym_set_type(nos, &PyUnicode_Type);
break;
}
case _GUARD_NOS_UNICODE: {
JitOptRef nos;
nos = stack_pointer[-2];
if (sym_matches_type(nos, &PyUnicode_Type)) {
ADD_OP(_NOP, 0, 0);
}
sym_set_type(nos, &PyUnicode_Type);
break;
}
case _GUARD_TOS_UNICODE: {
JitOptRef value;
value = stack_pointer[-1];
if (sym_matches_type(value, &PyUnicode_Type)) {
ADD_OP(_NOP, 0, 0);
}
sym_set_type(value, &PyUnicode_Type);
break;
}
case _TO_BOOL_STR: {
JitOptRef value;
JitOptRef res;
JitOptRef v;
value = stack_pointer[-1];
int already_bool = optimize_to_bool(this_instr, ctx, value, &res,
_NOP, _SWAP);
v = value;
if (!already_bool) {
res = sym_new_truthiness(ctx, value, true);
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = res;
stack_pointer[0] = v;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _REPLACE_WITH_TRUE: {
JitOptRef value;
JitOptRef res;
JitOptRef v;
value = stack_pointer[-1];
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)Py_True);
ADD_OP(_SWAP, 2, 0);
res = sym_new_const(ctx, Py_True);
v = value;
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = res;
stack_pointer[0] = v;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _UNARY_INVERT: {
JitOptRef value;
JitOptRef res;
JitOptRef v;
value = stack_pointer[-1];
v = value;
if (!sym_matches_type(value, &PyBool_Type)) {
if (
sym_is_safe_const(ctx, value)
) {
JitOptRef value_sym = value;
_PyStackRef value = sym_get_const_as_stackref(ctx, value_sym);
_PyStackRef res_stackref;
_PyStackRef v_stackref;
/* Start of uop copied from bytecodes for constant evaluation */
PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value));
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
res_stackref = PyStackRef_FromPyObjectSteal(res_o);
v_stackref = value;
/* End of uop copied from bytecodes for constant evaluation */
(void)v_stackref;
res = sym_new_const_steal(ctx, PyStackRef_AsPyObjectSteal(res_stackref));
if (sym_is_const(ctx, res)) {
PyObject *result = sym_get_const(ctx, res);
if (_Py_IsImmortal(result)) {
// Replace with _LOAD_CONST_INLINE_BORROW + _SWAP since we have one input and an immortal result
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)result);
ADD_OP(_SWAP, 2, 0);
}
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = res;
stack_pointer[0] = v;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
}
if (sym_matches_type(value, &PyLong_Type)) {
res = sym_new_type(ctx, &PyLong_Type);
}
else {
res = sym_new_not_null(ctx);
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = res;
stack_pointer[0] = v;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_NOS_INT: {
JitOptRef left;
left = stack_pointer[-2];
if (sym_is_compact_int(left)) {
ADD_OP(_NOP, 0, 0);
}
else {
if (sym_get_type(left) == &PyLong_Type) {
ADD_OP(_GUARD_NOS_OVERFLOWED, 0, 0);
}
sym_set_compact_int(left);
}
break;
}
case _GUARD_TOS_INT: {
JitOptRef value;
value = stack_pointer[-1];
if (sym_is_compact_int(value)) {
ADD_OP(_NOP, 0, 0);
}
else {
if (sym_get_type(value) == &PyLong_Type) {
ADD_OP(_GUARD_TOS_OVERFLOWED, 0, 0);
}
sym_set_compact_int(value);
}
break;
}
case _GUARD_TOS_EXACT_INT: {
JitOptRef value;
value = stack_pointer[-1];
if (sym_matches_type(value, &PyLong_Type)) {
ADD_OP(_NOP, 0, 0);
}
sym_set_type(value, &PyLong_Type);
break;
}
case _GUARD_NOS_OVERFLOWED: {
break;
}
case _GUARD_TOS_OVERFLOWED: {
break;
}
case _BINARY_OP_MULTIPLY_INT: {
JitOptRef right;
JitOptRef left;
JitOptRef res;
JitOptRef l;
JitOptRef r;
right = stack_pointer[-1];
left = stack_pointer[-2];
if (PyJitRef_IsUnique(left)) {
REPLACE_OP(this_instr, _BINARY_OP_MULTIPLY_INT_INPLACE, 0, 0);
}
else if (PyJitRef_IsUnique(right)) {
REPLACE_OP(this_instr, _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT, 0, 0);
}
res = PyJitRef_MakeUnique(sym_new_compact_int(ctx));
l = left;
r = right;
if (
sym_is_safe_const(ctx, left) &&
sym_is_safe_const(ctx, right)
) {
JitOptRef left_sym = left;
JitOptRef right_sym = right;
_PyStackRef left = sym_get_const_as_stackref(ctx, left_sym);
_PyStackRef right = sym_get_const_as_stackref(ctx, right_sym);
_PyStackRef res_stackref;
_PyStackRef l_stackref;
_PyStackRef r_stackref;
/* Start of uop copied from bytecodes for constant evaluation */
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
assert(PyLong_CheckExact(left_o));
assert(PyLong_CheckExact(right_o));
assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o));
STAT_INC(BINARY_OP, hit);
res_stackref = _PyCompactLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o);
if (PyStackRef_IsNull(res_stackref )) {
ctx->done = true;
break;
}
l_stackref = left;
r_stackref = right;
/* End of uop copied from bytecodes for constant evaluation */
(void)l_stackref;
(void)r_stackref;
res = sym_new_const_steal(ctx, PyStackRef_AsPyObjectSteal(res_stackref));
if (sym_is_const(ctx, res)) {
PyObject *result = sym_get_const(ctx, res);
if (_Py_IsImmortal(result)) {
// Replace with _LOAD_CONST_INLINE_BORROW + _RROT_3 since we have two inputs and an immortal result
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)result);
ADD_OP(_RROT_3, 0, 0);
}
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_ADD_INT: {
JitOptRef right;
JitOptRef left;
JitOptRef res;
JitOptRef l;
JitOptRef r;
right = stack_pointer[-1];
left = stack_pointer[-2];
if (PyJitRef_IsUnique(left)) {
REPLACE_OP(this_instr, _BINARY_OP_ADD_INT_INPLACE, 0, 0);
}
else if (PyJitRef_IsUnique(right)) {
REPLACE_OP(this_instr, _BINARY_OP_ADD_INT_INPLACE_RIGHT, 0, 0);
}
res = PyJitRef_MakeUnique(sym_new_compact_int(ctx));
l = left;
r = right;
if (
sym_is_safe_const(ctx, left) &&
sym_is_safe_const(ctx, right)
) {
JitOptRef left_sym = left;
JitOptRef right_sym = right;
_PyStackRef left = sym_get_const_as_stackref(ctx, left_sym);
_PyStackRef right = sym_get_const_as_stackref(ctx, right_sym);
_PyStackRef res_stackref;
_PyStackRef l_stackref;
_PyStackRef r_stackref;
/* Start of uop copied from bytecodes for constant evaluation */
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
assert(PyLong_CheckExact(left_o));
assert(PyLong_CheckExact(right_o));
assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o));
STAT_INC(BINARY_OP, hit);
res_stackref = _PyCompactLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o);
if (PyStackRef_IsNull(res_stackref )) {
ctx->done = true;
break;
}
l_stackref = left;
r_stackref = right;
/* End of uop copied from bytecodes for constant evaluation */
(void)l_stackref;
(void)r_stackref;
res = sym_new_const_steal(ctx, PyStackRef_AsPyObjectSteal(res_stackref));
if (sym_is_const(ctx, res)) {
PyObject *result = sym_get_const(ctx, res);
if (_Py_IsImmortal(result)) {
// Replace with _LOAD_CONST_INLINE_BORROW + _RROT_3 since we have two inputs and an immortal result
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)result);
ADD_OP(_RROT_3, 0, 0);
}
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_SUBTRACT_INT: {
JitOptRef right;
JitOptRef left;
JitOptRef res;
JitOptRef l;
JitOptRef r;
right = stack_pointer[-1];
left = stack_pointer[-2];
if (PyJitRef_IsUnique(left)) {
REPLACE_OP(this_instr, _BINARY_OP_SUBTRACT_INT_INPLACE, 0, 0);
}
else if (PyJitRef_IsUnique(right)) {
REPLACE_OP(this_instr, _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT, 0, 0);
}
res = PyJitRef_MakeUnique(sym_new_compact_int(ctx));
l = left;
r = right;
if (
sym_is_safe_const(ctx, left) &&
sym_is_safe_const(ctx, right)
) {
JitOptRef left_sym = left;
JitOptRef right_sym = right;
_PyStackRef left = sym_get_const_as_stackref(ctx, left_sym);
_PyStackRef right = sym_get_const_as_stackref(ctx, right_sym);
_PyStackRef res_stackref;
_PyStackRef l_stackref;
_PyStackRef r_stackref;
/* Start of uop copied from bytecodes for constant evaluation */
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
assert(PyLong_CheckExact(left_o));
assert(PyLong_CheckExact(right_o));
assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o));
STAT_INC(BINARY_OP, hit);
res_stackref = _PyCompactLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o);
if (PyStackRef_IsNull(res_stackref )) {
ctx->done = true;
break;
}
l_stackref = left;
r_stackref = right;
/* End of uop copied from bytecodes for constant evaluation */
(void)l_stackref;
(void)r_stackref;
res = sym_new_const_steal(ctx, PyStackRef_AsPyObjectSteal(res_stackref));
if (sym_is_const(ctx, res)) {
PyObject *result = sym_get_const(ctx, res);
if (_Py_IsImmortal(result)) {
// Replace with _LOAD_CONST_INLINE_BORROW + _RROT_3 since we have two inputs and an immortal result
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)result);
ADD_OP(_RROT_3, 0, 0);
}
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_ADD_INT_INPLACE: {
JitOptRef res;
JitOptRef l;
JitOptRef r;
res = sym_new_not_null(ctx);
l = sym_new_not_null(ctx);
r = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_SUBTRACT_INT_INPLACE: {
JitOptRef res;
JitOptRef l;
JitOptRef r;
res = sym_new_not_null(ctx);
l = sym_new_not_null(ctx);
r = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_MULTIPLY_INT_INPLACE: {
JitOptRef res;
JitOptRef l;
JitOptRef r;
res = sym_new_not_null(ctx);
l = sym_new_not_null(ctx);
r = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_ADD_INT_INPLACE_RIGHT: {
JitOptRef res;
JitOptRef l;
JitOptRef r;
res = sym_new_not_null(ctx);
l = sym_new_not_null(ctx);
r = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT: {
JitOptRef res;
JitOptRef l;
JitOptRef r;
res = sym_new_not_null(ctx);
l = sym_new_not_null(ctx);
r = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT: {
JitOptRef res;
JitOptRef l;
JitOptRef r;
res = sym_new_not_null(ctx);
l = sym_new_not_null(ctx);
r = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_NOS_FLOAT: {
JitOptRef left;
left = stack_pointer[-2];
if (sym_matches_type(left, &PyFloat_Type)) {
ADD_OP(_NOP, 0, 0);
}
sym_set_type(left, &PyFloat_Type);
break;
}
case _GUARD_TOS_FLOAT: {
JitOptRef value;
value = stack_pointer[-1];
if (sym_matches_type(value, &PyFloat_Type)) {
ADD_OP(_NOP, 0, 0);
}
sym_set_type(value, &PyFloat_Type);
break;
}
case _BINARY_OP_MULTIPLY_FLOAT: {
JitOptRef right;
JitOptRef left;
JitOptRef res;
JitOptRef l;
JitOptRef r;
right = stack_pointer[-1];
left = stack_pointer[-2];
if (PyJitRef_IsUnique(left)) {
ADD_OP(_BINARY_OP_MULTIPLY_FLOAT_INPLACE, 0, 0);
l = PyJitRef_Borrow(sym_new_null(ctx));
r = right;
}
else if (PyJitRef_IsUnique(right)) {
ADD_OP(_BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT, 0, 0);
l = left;
r = PyJitRef_Borrow(sym_new_null(ctx));
}
else {
l = left;
r = right;
}
res = PyJitRef_MakeUnique(sym_new_type(ctx, &PyFloat_Type));
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_ADD_FLOAT: {
JitOptRef right;
JitOptRef left;
JitOptRef res;
JitOptRef l;
JitOptRef r;
right = stack_pointer[-1];
left = stack_pointer[-2];
if (PyJitRef_IsUnique(left)) {
ADD_OP(_BINARY_OP_ADD_FLOAT_INPLACE, 0, 0);
l = PyJitRef_Borrow(sym_new_null(ctx));
r = right;
}
else if (PyJitRef_IsUnique(right)) {
ADD_OP(_BINARY_OP_ADD_FLOAT_INPLACE_RIGHT, 0, 0);
l = left;
r = PyJitRef_Borrow(sym_new_null(ctx));
}
else {
l = left;
r = right;
}
res = PyJitRef_MakeUnique(sym_new_type(ctx, &PyFloat_Type));
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_SUBTRACT_FLOAT: {
JitOptRef right;
JitOptRef left;
JitOptRef res;
JitOptRef l;
JitOptRef r;
right = stack_pointer[-1];
left = stack_pointer[-2];
if (PyJitRef_IsUnique(left)) {
ADD_OP(_BINARY_OP_SUBTRACT_FLOAT_INPLACE, 0, 0);
l = PyJitRef_Borrow(sym_new_null(ctx));
r = right;
}
else if (PyJitRef_IsUnique(right)) {
ADD_OP(_BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT, 0, 0);
l = left;
r = PyJitRef_Borrow(sym_new_null(ctx));
}
else {
l = left;
r = right;
}
res = PyJitRef_MakeUnique(sym_new_type(ctx, &PyFloat_Type));
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_ADD_FLOAT_INPLACE: {
JitOptRef res;
JitOptRef l;
JitOptRef r;
res = sym_new_not_null(ctx);
l = sym_new_not_null(ctx);
r = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_SUBTRACT_FLOAT_INPLACE: {
JitOptRef res;
JitOptRef l;
JitOptRef r;
res = sym_new_not_null(ctx);
l = sym_new_not_null(ctx);
r = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_MULTIPLY_FLOAT_INPLACE: {
JitOptRef res;
JitOptRef l;
JitOptRef r;
res = sym_new_not_null(ctx);
l = sym_new_not_null(ctx);
r = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT: {
JitOptRef res;
JitOptRef l;
JitOptRef r;
res = sym_new_not_null(ctx);
l = sym_new_not_null(ctx);
r = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT: {
JitOptRef res;
JitOptRef l;
JitOptRef r;
res = sym_new_not_null(ctx);
l = sym_new_not_null(ctx);
r = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT: {
JitOptRef res;
JitOptRef l;
JitOptRef r;
res = sym_new_not_null(ctx);
l = sym_new_not_null(ctx);
r = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_TRUEDIV_FLOAT: {
JitOptRef res;
JitOptRef l;
JitOptRef r;
res = sym_new_not_null(ctx);
l = sym_new_not_null(ctx);
r = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_TRUEDIV_FLOAT_INPLACE: {
JitOptRef res;
JitOptRef l;
JitOptRef r;
res = sym_new_not_null(ctx);
l = sym_new_not_null(ctx);
r = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT: {
JitOptRef res;
JitOptRef l;
JitOptRef r;
res = sym_new_not_null(ctx);
l = sym_new_not_null(ctx);
r = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_ADD_UNICODE: {
JitOptRef right;
JitOptRef left;
JitOptRef res;
JitOptRef l;
JitOptRef r;
right = stack_pointer[-1];
left = stack_pointer[-2];
res = sym_new_type(ctx, &PyUnicode_Type);
l = left;
r = right;
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_INPLACE_ADD_UNICODE: {
JitOptRef right;
JitOptRef left;
JitOptRef 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);
CHECK_STACK_BOUNDS(-1);
stack_pointer[-2] = res;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
Py_DECREF(temp);
}
else {
res = sym_new_type(ctx, &PyUnicode_Type);
stack_pointer += -1;
}
GETLOCAL(this_instr->operand0) = sym_new_null(ctx);
stack_pointer[-1] = res;
break;
}
case _GUARD_BINARY_OP_EXTEND_LHS: {
JitOptRef left;
left = stack_pointer[-2];
PyObject *descr = (PyObject *)this_instr->operand0;
_PyBinaryOpSpecializationDescr *d = (_PyBinaryOpSpecializationDescr *)descr;
assert(d != NULL && d->guard == NULL && d->lhs_type != NULL);
if (sym_matches_type(left, d->lhs_type)) {
ADD_OP(_NOP, 0, 0);
}
sym_set_type(left, d->lhs_type);
break;
}
case _GUARD_BINARY_OP_EXTEND_RHS: {
JitOptRef right;
right = stack_pointer[-1];
PyObject *descr = (PyObject *)this_instr->operand0;
_PyBinaryOpSpecializationDescr *d = (_PyBinaryOpSpecializationDescr *)descr;
assert(d != NULL && d->guard == NULL && d->rhs_type != NULL);
if (sym_matches_type(right, d->rhs_type)) {
ADD_OP(_NOP, 0, 0);
}
sym_set_type(right, d->rhs_type);
break;
}
case _GUARD_BINARY_OP_EXTEND: {
JitOptRef right;
JitOptRef left;
right = stack_pointer[-1];
left = stack_pointer[-2];
PyObject *descr = (PyObject *)this_instr->operand0;
_PyBinaryOpSpecializationDescr *d = (_PyBinaryOpSpecializationDescr *)descr;
if (d != NULL && d->guard == NULL) {
assert(d->lhs_type != NULL && d->rhs_type != NULL);
bool lhs_known = sym_matches_type(left, d->lhs_type);
bool rhs_known = sym_matches_type(right, d->rhs_type);
if (lhs_known && rhs_known) {
ADD_OP(_NOP, 0, 0);
}
else if (lhs_known) {
ADD_OP(_GUARD_BINARY_OP_EXTEND_RHS, 0, (uintptr_t)d);
sym_set_type(right, d->rhs_type);
}
else if (rhs_known) {
ADD_OP(_GUARD_BINARY_OP_EXTEND_LHS, 0, (uintptr_t)d);
sym_set_type(left, d->lhs_type);
}
}
break;
}
case _BINARY_OP_EXTEND: {
JitOptRef right;
JitOptRef left;
JitOptRef res;
JitOptRef l;
JitOptRef r;
right = stack_pointer[-1];
left = stack_pointer[-2];
PyObject *descr = (PyObject *)this_instr->operand0;
_PyBinaryOpSpecializationDescr *d = (_PyBinaryOpSpecializationDescr *)descr;
if (d != NULL && d->result_type != NULL) {
res = sym_new_type(ctx, d->result_type);
if (d->result_unique) {
res = PyJitRef_MakeUnique(res);
}
}
else {
res = sym_new_not_null(ctx);
}
l = left;
r = right;
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_SLICE: {
JitOptRef container;
JitOptRef res;
container = stack_pointer[-3];
PyTypeObject *type = sym_get_type(container);
if (type == &PyUnicode_Type ||
type == &PyList_Type ||
type == &PyTuple_Type)
{
res = sym_new_type(ctx, type);
}
else {
res = sym_new_not_null(ctx);
}
CHECK_STACK_BOUNDS(-2);
stack_pointer[-3] = res;
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _STORE_SLICE: {
CHECK_STACK_BOUNDS(-4);
stack_pointer += -4;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_SUBSCR_LIST_INT: {
JitOptRef sub_st;
JitOptRef list_st;
JitOptRef res;
JitOptRef ls;
JitOptRef ss;
sub_st = stack_pointer[-1];
list_st = stack_pointer[-2];
res = sym_new_unknown(ctx);
ls = list_st;
ss = sub_st;
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = ls;
stack_pointer[0] = ss;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_SUBSCR_LIST_SLICE: {
JitOptRef sub_st;
JitOptRef list_st;
JitOptRef res;
JitOptRef ls;
JitOptRef ss;
sub_st = stack_pointer[-1];
list_st = stack_pointer[-2];
res = sym_new_type(ctx, &PyList_Type);
ls = list_st;
ss = sub_st;
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = ls;
stack_pointer[0] = ss;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_SUBSCR_STR_INT: {
JitOptRef sub_st;
JitOptRef str_st;
JitOptRef res;
JitOptRef s;
JitOptRef i;
sub_st = stack_pointer[-1];
str_st = stack_pointer[-2];
res = sym_new_type(ctx, &PyUnicode_Type);
s = str_st;
i = sub_st;
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = s;
stack_pointer[0] = i;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_SUBSCR_USTR_INT: {
JitOptRef sub_st;
JitOptRef str_st;
JitOptRef res;
JitOptRef s;
JitOptRef i;
sub_st = stack_pointer[-1];
str_st = stack_pointer[-2];
res = sym_new_type(ctx, &PyUnicode_Type);
s = str_st;
i = sub_st;
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = s;
stack_pointer[0] = i;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_NOS_TUPLE: {
JitOptRef nos;
nos = stack_pointer[-2];
if (sym_matches_type(nos, &PyTuple_Type)) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_type(nos, &PyTuple_Type);
}
break;
}
case _GUARD_TOS_TUPLE: {
JitOptRef tos;
tos = stack_pointer[-1];
if (sym_matches_type(tos, &PyTuple_Type)) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_type(tos, &PyTuple_Type);
}
break;
}
case _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS: {
JitOptRef sub_st;
JitOptRef tuple_st;
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);
Py_ssize_t tuple_length = sym_tuple_length(tuple_st);
if (tuple_length != -1 && index < tuple_length) {
ADD_OP(_NOP, 0, 0);
}
}
break;
}
case _BINARY_OP_SUBSCR_TUPLE_INT: {
JitOptRef sub_st;
JitOptRef tuple_st;
JitOptRef res;
JitOptRef ts;
JitOptRef ss;
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);
Py_ssize_t 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);
}
ts = tuple_st;
ss = sub_st;
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = ts;
stack_pointer[0] = ss;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_NOS_DICT_SUBSCRIPT: {
JitOptRef nos;
nos = stack_pointer[-2];
PyTypeObject *tp = sym_get_type(nos);
bool definite = true;
if (!tp) {
tp = sym_get_probable_type(nos);
definite = false;
}
if (tp && tp->tp_as_mapping &&
tp->tp_as_mapping->mp_subscript == _PyDict_Subscript) {
if (definite) {
ADD_OP(_NOP, 0, 0);
}
else {
ADD_OP(_GUARD_TYPE, 0, (uintptr_t)tp);
sym_set_type(nos, tp);
}
PyType_Watch(TYPE_WATCHER_ID, (PyObject *)tp);
_Py_BloomFilter_Add(dependencies, tp);
}
break;
}
case _GUARD_NOS_DICT_STORE_SUBSCRIPT: {
JitOptRef nos;
nos = stack_pointer[-2];
PyTypeObject *tp = sym_get_type(nos);
bool definite = true;
if (!tp) {
tp = sym_get_probable_type(nos);
definite = false;
}
if (tp && tp->tp_as_mapping &&
tp->tp_as_mapping->mp_ass_subscript == _PyDict_StoreSubscript) {
if (definite) {
ADD_OP(_NOP, 0, 0);
}
else {
ADD_OP(_GUARD_TYPE, 0, (uintptr_t)tp);
sym_set_type(nos, tp);
}
PyType_Watch(TYPE_WATCHER_ID, (PyObject *)tp);
_Py_BloomFilter_Add(dependencies, tp);
}
break;
}
case _GUARD_TOS_ANY_DICT: {
JitOptRef tos;
tos = stack_pointer[-1];
PyTypeObject *tp = sym_get_type(tos);
if (tp == &PyDict_Type || tp == &PyFrozenDict_Type) {
ADD_OP(_NOP, 0, 0);
}
else {
tp = sym_get_probable_type(tos);
if (tp == &PyDict_Type) {
ADD_OP(_GUARD_TOS_DICT, 0, 0);
}
else if (tp == &PyFrozenDict_Type) {
ADD_OP(_GUARD_TOS_FROZENDICT, 0, 0);
}
}
break;
}
case _GUARD_TOS_DICT: {
JitOptRef tos;
tos = stack_pointer[-1];
if (sym_matches_type(tos, &PyDict_Type)) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_type(tos, &PyDict_Type);
}
break;
}
case _GUARD_TOS_FROZENDICT: {
JitOptRef tos;
tos = stack_pointer[-1];
if (sym_matches_type(tos, &PyFrozenDict_Type)) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_type(tos, &PyFrozenDict_Type);
}
break;
}
case _BINARY_OP_SUBSCR_DICT_KNOWN_HASH: {
JitOptRef res;
JitOptRef ds;
JitOptRef ss;
res = sym_new_not_null(ctx);
ds = sym_new_not_null(ctx);
ss = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = ds;
stack_pointer[0] = ss;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_SUBSCR_DICT: {
JitOptRef sub_st;
JitOptRef dict_st;
JitOptRef res;
JitOptRef ds;
JitOptRef ss;
sub_st = stack_pointer[-1];
dict_st = stack_pointer[-2];
res = sym_new_not_null(ctx);
ds = dict_st;
ss = sub_st;
PyObject *sub = sym_get_const(ctx, sub_st);
if (sym_is_not_container(sub_st) &&
sym_matches_type(dict_st, &PyFrozenDict_Type)) {
if (
sym_is_safe_const(ctx, dict_st) &&
sym_is_safe_const(ctx, sub_st)
) {
JitOptRef dict_st_sym = dict_st;
JitOptRef sub_st_sym = sub_st;
_PyStackRef dict_st = sym_get_const_as_stackref(ctx, dict_st_sym);
_PyStackRef sub_st = sym_get_const_as_stackref(ctx, sub_st_sym);
_PyStackRef res_stackref;
_PyStackRef ds_stackref;
_PyStackRef ss_stackref;
/* Start of uop copied from bytecodes for constant evaluation */
PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st);
PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st);
assert(Py_TYPE(dict)->tp_as_mapping->mp_subscript == _PyDict_Subscript);
STAT_INC(BINARY_OP, hit);
PyObject *res_o = _PyDict_Subscript(dict, sub);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
res_stackref = PyStackRef_FromPyObjectSteal(res_o);
ds_stackref = dict_st;
ss_stackref = sub_st;
/* End of uop copied from bytecodes for constant evaluation */
(void)ds_stackref;
(void)ss_stackref;
res = sym_new_const_steal(ctx, PyStackRef_AsPyObjectSteal(res_stackref));
if (sym_is_const(ctx, res)) {
PyObject *result = sym_get_const(ctx, res);
if (_Py_IsImmortal(result)) {
// Replace with _LOAD_CONST_INLINE_BORROW + _RROT_3 since we have two inputs and an immortal result
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)result);
ADD_OP(_RROT_3, 0, 0);
}
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = ds;
stack_pointer[0] = ss;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
}
else if (sub != NULL) {
optimize_dict_known_hash(ctx, dependencies, this_instr,
sub, _BINARY_OP_SUBSCR_DICT_KNOWN_HASH);
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = ds;
stack_pointer[0] = ss;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_SUBSCR_CHECK_FUNC: {
JitOptRef container;
JitOptRef getitem;
container = stack_pointer[-2];
getitem = sym_new_not_null(ctx);
PyTypeObject *tp = sym_get_type(container);
if (tp == NULL) {
PyObject *c = sym_get_probable_value(container);
if (c != NULL) {
tp = Py_TYPE(c);
}
}
if (tp != NULL) {
PyObject *getitem_o = ((PyHeapTypeObject *)tp)->_spec_cache.getitem;
sym_set_recorded_value(getitem, getitem_o);
}
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = getitem;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP_SUBSCR_INIT_CALL: {
JitOptRef getitem;
JitOptRef sub;
JitOptRef container;
JitOptRef new_frame;
getitem = stack_pointer[-1];
sub = stack_pointer[-2];
container = stack_pointer[-3];
_Py_UOpsAbstractFrame *f = frame_new_from_symbol(ctx, getitem, NULL, 0);
if (f == NULL) {
break;
}
f->locals[0] = container;
f->locals[1] = sub;
new_frame = PyJitRef_WrapInvalid(f);
CHECK_STACK_BOUNDS(-2);
stack_pointer[-3] = new_frame;
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LIST_APPEND: {
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _SET_ADD: {
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _STORE_SUBSCR: {
CHECK_STACK_BOUNDS(-3);
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _STORE_SUBSCR_LIST_INT: {
JitOptRef sub_st;
JitOptRef list_st;
JitOptRef value;
JitOptRef ls;
JitOptRef ss;
sub_st = stack_pointer[-1];
list_st = stack_pointer[-2];
value = stack_pointer[-3];
(void)value;
ls = list_st;
ss = sub_st;
CHECK_STACK_BOUNDS(-1);
stack_pointer[-3] = ls;
stack_pointer[-2] = ss;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _STORE_SUBSCR_DICT: {
JitOptRef sub;
JitOptRef dict_st;
JitOptRef value;
JitOptRef st;
sub = stack_pointer[-1];
dict_st = stack_pointer[-2];
value = stack_pointer[-3];
PyObject *sub_o = sym_get_const(ctx, sub);
if (sub_o != NULL) {
optimize_dict_known_hash(ctx, dependencies, this_instr,
sub_o, _STORE_SUBSCR_DICT_KNOWN_HASH);
}
(void)value;
st = dict_st;
CHECK_STACK_BOUNDS(-2);
stack_pointer[-3] = st;
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _STORE_SUBSCR_DICT_KNOWN_HASH: {
JitOptRef st;
st = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(-2);
stack_pointer[-3] = st;
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _DELETE_SUBSCR: {
CHECK_STACK_BOUNDS(-2);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _CALL_INTRINSIC_1: {
JitOptRef value;
JitOptRef res;
JitOptRef v;
value = stack_pointer[-1];
res = sym_new_not_null(ctx);
v = value;
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = res;
stack_pointer[0] = v;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _CALL_INTRINSIC_2: {
JitOptRef value1_st;
JitOptRef value2_st;
JitOptRef res;
JitOptRef vs1;
JitOptRef vs2;
value1_st = stack_pointer[-1];
value2_st = stack_pointer[-2];
res = sym_new_not_null(ctx);
vs1 = value1_st;
vs2 = value2_st;
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = vs1;
stack_pointer[0] = vs2;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _MAKE_HEAP_SAFE: {
JitOptRef value;
value = stack_pointer[-1];
if (sym_is_immortal(PyJitRef_Unwrap(value))) {
ADD_OP(_NOP, 0, 0);
}
value = PyJitRef_StripBorrowInfo(value);
stack_pointer[-1] = value;
break;
}
case _RETURN_VALUE: {
JitOptRef retval;
JitOptRef res;
retval = stack_pointer[-1];
JitOptRef temp = retval;
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
ctx->frame->stack_pointer = stack_pointer;
assert(this_instr[1].opcode == _RECORD_CODE);
PyCodeObject *returning_code = (PyCodeObject *)this_instr[1].operand0;
assert(PyCode_Check(returning_code));
if (returning_code == NULL) {
ctx->done = true;
break;
}
if (frame_pop(ctx, returning_code)) {
break;
}
stack_pointer = ctx->frame->stack_pointer;
res = temp;
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = res;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GET_AITER: {
JitOptRef iter;
iter = sym_new_not_null(ctx);
stack_pointer[-1] = iter;
break;
}
case _GET_ANEXT: {
JitOptRef aiter;
JitOptRef awaitable;
aiter = stack_pointer[-1];
if (sym_matches_type(aiter, &PyAsyncGen_Type)) {
awaitable = sym_new_type(ctx, &_PyAsyncGenASend_Type);
}
else {
awaitable = sym_new_not_null(ctx);
}
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = awaitable;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GET_AWAITABLE: {
JitOptRef iter;
iter = sym_new_not_null(ctx);
stack_pointer[-1] = iter;
break;
}
case _SEND_GEN_FRAME: {
JitOptRef v;
JitOptRef receiver;
JitOptRef gen_frame;
v = stack_pointer[-1];
receiver = stack_pointer[-3];
_Py_UOpsAbstractFrame *new_frame = frame_new_from_symbol(ctx, receiver, NULL, 0);
if (new_frame == NULL) {
ctx->done = true;
break;
}
new_frame->stack_pointer[0] = PyJitRef_StripReferenceInfo(v);
new_frame->stack_pointer++;
gen_frame = PyJitRef_WrapInvalid(new_frame);
stack_pointer[-1] = gen_frame;
break;
}
case _GUARD_TOS_IS_NONE: {
break;
}
case _GUARD_NOS_NOT_NULL: {
JitOptRef nos;
nos = stack_pointer[-2];
if (sym_is_not_null(nos)) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_non_null(nos);
}
break;
}
/* _SEND_VIRTUAL is not a viable micro-op for tier 2 */
case _SEND_VIRTUAL_TIER_TWO: {
JitOptRef next;
next = sym_new_not_null(ctx);
stack_pointer[-1] = next;
break;
}
case _GUARD_3OS_ASYNC_GEN_ASEND: {
JitOptRef iter;
iter = stack_pointer[-3];
if (sym_matches_type(iter, &_PyAsyncGenASend_Type)) {
REPLACE_OP(this_instr, _NOP, 0, 0);
}
else {
sym_set_type(iter, &_PyAsyncGenASend_Type);
}
break;
}
/* _SEND_ASYNC_GEN is not a viable micro-op for tier 2 */
case _SEND_ASYNC_GEN_TIER_TWO: {
JitOptRef asend;
JitOptRef null_out;
JitOptRef retval;
asend = sym_new_not_null(ctx);
null_out = sym_new_not_null(ctx);
retval = sym_new_not_null(ctx);
stack_pointer[-3] = asend;
stack_pointer[-2] = null_out;
stack_pointer[-1] = retval;
break;
}
case _YIELD_VALUE: {
JitOptRef retval;
JitOptRef value;
retval = stack_pointer[-1];
JitOptRef temp = retval;
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
ctx->frame->stack_pointer = stack_pointer;
assert(this_instr[1].opcode == _RECORD_CODE);
PyCodeObject *returning_code = (PyCodeObject *)this_instr[1].operand0;
if (returning_code == NULL) {
ctx->done = true;
break;
}
assert(PyCode_Check(returning_code));
if (frame_pop(ctx, returning_code)) {
break;
}
stack_pointer = ctx->frame->stack_pointer;
value = temp;
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = value;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _POP_EXCEPT: {
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOAD_COMMON_CONSTANT: {
JitOptRef value;
assert(oparg < NUM_COMMON_CONSTANTS);
PyObject *val = PyStackRef_AsPyObjectBorrow(
_PyInterpreterState_GET()->common_consts[oparg]);
assert(_Py_IsImmortal(val));
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)val);
value = PyJitRef_Borrow(sym_new_const(ctx, val));
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = value;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOAD_BUILD_CLASS: {
JitOptRef bc;
bc = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = bc;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _STORE_NAME: {
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _UNPACK_SEQUENCE: {
JitOptRef *values;
JitOptRef *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);
}
CHECK_STACK_BOUNDS(-1 + oparg);
stack_pointer += -1 + oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _UNPACK_SEQUENCE_TWO_TUPLE: {
JitOptRef seq;
JitOptRef val1;
JitOptRef val0;
seq = stack_pointer[-1];
if (PyJitRef_IsUnique(seq) && sym_tuple_length(seq) == 2) {
ADD_OP(_UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE, oparg, 0);
}
val0 = sym_tuple_getitem(ctx, seq, 0);
val1 = sym_tuple_getitem(ctx, seq, 1);
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = val1;
stack_pointer[0] = val0;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE: {
JitOptRef val1;
JitOptRef val0;
val1 = sym_new_not_null(ctx);
val0 = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = val1;
stack_pointer[0] = val0;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE: {
JitOptRef val2;
JitOptRef val1;
JitOptRef val0;
val2 = sym_new_not_null(ctx);
val1 = sym_new_not_null(ctx);
val0 = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(2);
stack_pointer[-1] = val2;
stack_pointer[0] = val1;
stack_pointer[1] = val0;
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _UNPACK_SEQUENCE_TUPLE: {
JitOptRef seq;
JitOptRef *values;
seq = stack_pointer[-1];
values = &stack_pointer[-1];
if (PyJitRef_IsUnique(seq) && sym_tuple_length(seq) == 3) {
ADD_OP(_UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE, oparg, 0);
}
else if (PyJitRef_IsUnique(seq) && sym_tuple_length(seq) == oparg) {
ADD_OP(_UNPACK_SEQUENCE_UNIQUE_TUPLE, oparg, 0);
}
for (int i = 0; i < oparg; i++) {
values[i] = sym_tuple_getitem(ctx, seq, oparg - i - 1);
}
CHECK_STACK_BOUNDS(-1 + oparg);
stack_pointer += -1 + oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _UNPACK_SEQUENCE_UNIQUE_TUPLE: {
JitOptRef *values;
values = &stack_pointer[-1];
for (int _i = oparg; --_i >= 0;) {
values[_i] = sym_new_not_null(ctx);
}
CHECK_STACK_BOUNDS(-1 + oparg);
stack_pointer += -1 + oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _UNPACK_SEQUENCE_LIST: {
JitOptRef *values;
values = &stack_pointer[-1];
for (int _i = oparg; --_i >= 0;) {
values[_i] = sym_new_not_null(ctx);
}
CHECK_STACK_BOUNDS(-1 + oparg);
stack_pointer += -1 + oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _UNPACK_EX: {
JitOptRef *values;
JitOptRef *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);
}
CHECK_STACK_BOUNDS((oparg & 0xFF) + (oparg >> 8));
stack_pointer += (oparg & 0xFF) + (oparg >> 8);
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _STORE_ATTR: {
CHECK_STACK_BOUNDS(-2);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _STORE_GLOBAL: {
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOAD_LOCALS: {
JitOptRef locals;
locals = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = locals;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
/* _LOAD_FROM_DICT_OR_GLOBALS is not a viable micro-op for tier 2 */
case _LOAD_NAME: {
JitOptRef v;
v = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = v;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOAD_GLOBAL: {
JitOptRef *res;
res = &stack_pointer[0];
res[0] = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _PUSH_NULL_CONDITIONAL: {
JitOptRef *null;
null = &stack_pointer[0];
if (oparg & 1) {
ADD_OP(_PUSH_NULL, 0, 0);
null[0] = sym_new_null(ctx);
}
else {
ADD_OP(_NOP, 0, 0);
}
CHECK_STACK_BOUNDS((oparg & 1));
stack_pointer += (oparg & 1);
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_GLOBALS_VERSION: {
uint16_t version = (uint16_t)this_instr->operand0;
if (ctx->frame->func != NULL) {
PyObject *globals = ctx->frame->func->func_globals;
if (incorrect_keys(globals, version)) {
OPT_STAT_INC(remove_globals_incorrect_keys);
ctx->done = true;
}
else if (get_mutations(globals) >= _Py_MAX_ALLOWED_GLOBALS_MODIFICATIONS) {
}
else {
if (!ctx->frame->globals_watched) {
PyDict_Watch(GLOBALS_WATCHER_ID, globals);
_Py_BloomFilter_Add(dependencies, globals);
ctx->frame->globals_watched = true;
}
if (ctx->frame->globals_checked_version == version) {
ADD_OP(_NOP, 0, 0);
}
}
}
ctx->frame->globals_checked_version = version;
break;
}
case _LOAD_GLOBAL_MODULE: {
JitOptRef res;
uint16_t version = (uint16_t)this_instr->operand0;
uint16_t index = (uint16_t)this_instr->operand1;
(void)index;
PyObject *cnst = NULL;
if (ctx->frame->func != NULL) {
PyObject *globals = ctx->frame->func->func_globals;
if (incorrect_keys(globals, version)) {
OPT_STAT_INC(remove_globals_incorrect_keys);
ctx->done = true;
}
else if (get_mutations(globals) >= _Py_MAX_ALLOWED_GLOBALS_MODIFICATIONS) {
}
else {
if (!ctx->frame->globals_watched) {
PyDict_Watch(GLOBALS_WATCHER_ID, globals);
_Py_BloomFilter_Add(dependencies, globals);
ctx->frame->globals_watched = true;
}
if (ctx->frame->globals_checked_version != version && this_instr[-1].opcode == _NOP) {
REPLACE_OP(uop_buffer_last(&ctx->out_buffer), _GUARD_GLOBALS_VERSION, 0, version);
ctx->frame->globals_checked_version = version;
}
if (ctx->frame->globals_checked_version == version) {
cnst = convert_global_to_const(this_instr, globals);
}
}
}
if (cnst == NULL) {
res = sym_new_not_null(ctx);
}
else {
if (_Py_IsImmortal(cnst)) {
res = PyJitRef_Borrow(sym_new_const(ctx, cnst));
}
else {
res = sym_new_const(ctx, cnst);
}
}
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = res;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOAD_GLOBAL_BUILTINS: {
JitOptRef res;
uint16_t version = (uint16_t)this_instr->operand0;
uint16_t index = (uint16_t)this_instr->operand1;
(void)version;
(void)index;
PyObject *cnst = NULL;
PyInterpreterState *interp = _PyInterpreterState_GET();
PyObject *builtins = interp->builtins;
if (incorrect_keys(builtins, version)) {
OPT_STAT_INC(remove_globals_incorrect_keys);
ctx->done = true;
}
else if (interp->rare_events.builtin_dict >= _Py_MAX_ALLOWED_BUILTINS_MODIFICATIONS) {
}
else {
if (!ctx->builtins_watched) {
PyDict_Watch(BUILTINS_WATCHER_ID, builtins);
ctx->builtins_watched = true;
}
if (ctx->frame->globals_checked_version != 0 && ctx->frame->globals_watched) {
cnst = convert_global_to_const(this_instr, builtins);
}
}
if (cnst == NULL) {
res = sym_new_not_null(ctx);
}
else {
if (_Py_IsImmortal(cnst)) {
res = PyJitRef_Borrow(sym_new_const(ctx, cnst));
}
else {
res = sym_new_const(ctx, cnst);
}
}
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = res;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _DELETE_FAST: {
break;
}
case _MAKE_CELL: {
break;
}
case _DELETE_DEREF: {
break;
}
case _LOAD_FROM_DICT_OR_DEREF: {
JitOptRef value;
value = sym_new_not_null(ctx);
stack_pointer[-1] = value;
break;
}
case _LOAD_DEREF: {
JitOptRef value;
value = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = value;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _STORE_DEREF: {
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _COPY_FREE_VARS: {
PyCodeObject *co = get_current_code_object(ctx);
if (co == NULL) {
ctx->done = true;
break;
}
int offset = co->co_nlocalsplus - oparg;
for (int i = 0; i < oparg; ++i) {
ctx->frame->locals[offset + i] = sym_new_not_null(ctx);
}
break;
}
case _BUILD_STRING: {
JitOptRef str;
str = sym_new_type(ctx, &PyUnicode_Type);
CHECK_STACK_BOUNDS(1 - oparg);
stack_pointer[-oparg] = str;
stack_pointer += 1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BUILD_INTERPOLATION: {
JitOptRef interpolation;
interpolation = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(-1 - (oparg & 1));
stack_pointer[-2 - (oparg & 1)] = interpolation;
stack_pointer += -1 - (oparg & 1);
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BUILD_TEMPLATE: {
JitOptRef template;
template = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(-1);
stack_pointer[-2] = template;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BUILD_TUPLE: {
JitOptRef *values;
JitOptRef tup;
values = &stack_pointer[-oparg];
tup = sym_new_tuple(ctx, oparg, values);
tup = PyJitRef_MakeUnique(tup);
CHECK_STACK_BOUNDS(1 - oparg);
stack_pointer[-oparg] = tup;
stack_pointer += 1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BUILD_LIST: {
JitOptRef list;
list = sym_new_type(ctx, &PyList_Type);
CHECK_STACK_BOUNDS(1 - oparg);
stack_pointer[-oparg] = list;
stack_pointer += 1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LIST_EXTEND: {
JitOptRef iterable_st;
JitOptRef list_st;
JitOptRef i;
iterable_st = stack_pointer[-1];
list_st = stack_pointer[-2 - (oparg-1)];
(void)list_st;
i = iterable_st;
stack_pointer[-1] = i;
break;
}
case _SET_UPDATE: {
JitOptRef iterable;
JitOptRef set;
JitOptRef i;
iterable = stack_pointer[-1];
set = stack_pointer[-2 - (oparg-1)];
(void)set;
i = iterable;
stack_pointer[-1] = i;
break;
}
case _BUILD_SET: {
JitOptRef set;
set = sym_new_type(ctx, &PySet_Type);
CHECK_STACK_BOUNDS(1 - oparg);
stack_pointer[-oparg] = set;
stack_pointer += 1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BUILD_MAP: {
JitOptRef map;
map = sym_new_type(ctx, &PyDict_Type);
CHECK_STACK_BOUNDS(1 - oparg*2);
stack_pointer[-oparg*2] = map;
stack_pointer += 1 - oparg*2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _SETUP_ANNOTATIONS: {
break;
}
case _DICT_UPDATE: {
JitOptRef update;
JitOptRef dict;
JitOptRef upd;
update = stack_pointer[-1];
dict = stack_pointer[-2 - (oparg - 1)];
(void)dict;
upd = update;
stack_pointer[-1] = upd;
break;
}
case _DICT_MERGE: {
JitOptRef update;
JitOptRef dict;
JitOptRef callable;
JitOptRef u;
update = stack_pointer[-1];
dict = stack_pointer[-2 - (oparg - 1)];
callable = stack_pointer[-5 - (oparg - 1)];
(void)callable;
(void)dict;
u = update;
stack_pointer[-1] = u;
break;
}
case _MAP_ADD: {
CHECK_STACK_BOUNDS(-2);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOAD_SUPER_ATTR_ATTR: {
JitOptRef attr_st;
attr_st = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(-2);
stack_pointer[-3] = attr_st;
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_NOS_TYPE_VERSION: {
break;
}
case _GUARD_LOAD_SUPER_ATTR_METHOD: {
JitOptRef class_st;
JitOptRef global_super_st;
class_st = stack_pointer[-2];
global_super_st = stack_pointer[-3];
if (sym_get_const(ctx, global_super_st) == (PyObject *)&PySuper_Type) {
PyTypeObject *probable = (PyTypeObject *)sym_get_probable_value(class_st);
PyTypeObject *known = (PyTypeObject *)sym_get_const(ctx, class_st);
if (known == NULL && probable != NULL && PyType_Check(probable)) {
ADD_OP(_GUARD_NOS_TYPE_VERSION, 0, probable->tp_version_tag);
known = probable;
}
sym_set_const(class_st, (PyObject *)known);
}
else {
sym_set_const(global_super_st, (PyObject *)&PySuper_Type);
sym_set_type(class_st, &PyType_Type);
}
break;
}
case _LOAD_SUPER_ATTR_METHOD: {
JitOptRef self_st;
JitOptRef class_st;
JitOptRef attr;
JitOptRef self_or_null;
self_st = stack_pointer[-1];
class_st = stack_pointer[-2];
self_or_null = self_st;
PyTypeObject *su_type = (PyTypeObject *)sym_get_const(ctx, class_st);
PyTypeObject *obj_type = sym_get_type(self_st);
CHECK_STACK_BOUNDS(-3);
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
PyObject *name = get_co_name(ctx, oparg >> 2);
attr = lookup_super_attr(ctx, dependencies, this_instr,
su_type, obj_type, name,
_LOAD_CONST_INLINE_BORROW,
_LOAD_CONST_INLINE, _SWAP);
CHECK_STACK_BOUNDS(2);
stack_pointer[0] = attr;
stack_pointer[1] = self_or_null;
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOAD_ATTR: {
JitOptRef owner;
JitOptRef attr;
JitOptRef *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);
}
CHECK_STACK_BOUNDS((oparg&1));
stack_pointer[-1] = attr;
stack_pointer += (oparg&1);
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_TYPE_VERSION: {
JitOptRef owner;
owner = stack_pointer[-1];
uint32_t type_version = (uint32_t)this_instr->operand0;
assert(type_version);
assert(this_instr[-1].opcode == _RECORD_TOS_TYPE || this_instr[-1].opcode == _RECORD_TOS);
if (sym_matches_type_version(owner, type_version)) {
ADD_OP(_NOP, 0, 0);
}
else {
PyTypeObject *probable_type = sym_get_probable_type(owner);
if (probable_type != NULL &&
probable_type->tp_version_tag == type_version) {
sym_set_type(owner, probable_type);
sym_set_type_version(owner, type_version);
watch_type(probable_type, dependencies);
}
else {
ctx->contradiction = true;
ctx->done = true;
break;
}
}
break;
}
case _GUARD_TYPE_VERSION_LOCKED: {
JitOptRef 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)) {
ADD_OP(_NOP, 0, 0);
}
else {
PyTypeObject *probable_type = sym_get_probable_type(owner);
if (probable_type != NULL &&
probable_type->tp_version_tag == type_version) {
sym_set_type(owner, probable_type);
sym_set_type_version(owner, type_version);
watch_type(probable_type, dependencies);
}
else {
ctx->contradiction = true;
ctx->done = true;
break;
}
}
break;
}
case _GUARD_TYPE: {
break;
}
case _CHECK_MANAGED_OBJECT_HAS_VALUES: {
break;
}
case _LOAD_ATTR_INSTANCE_VALUE: {
JitOptRef owner;
JitOptRef attr;
JitOptRef o;
owner = stack_pointer[-1];
uint16_t offset = (uint16_t)this_instr->operand0;
attr = sym_new_not_null(ctx);
(void)offset;
o = owner;
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = attr;
stack_pointer[0] = o;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOAD_ATTR_MODULE: {
JitOptRef owner;
JitOptRef attr;
JitOptRef o;
owner = stack_pointer[-1];
uint32_t dict_version = (uint32_t)this_instr->operand0;
uint16_t index = (uint16_t)this_instr->operand1;
(void)dict_version;
(void)index;
attr = PyJitRef_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);
if (res == NULL) {
attr = sym_new_not_null(ctx);
}
else {
bool immortal = _Py_IsImmortal(res);
ADD_OP(immortal ? _LOAD_CONST_INLINE_BORROW : _LOAD_CONST_INLINE,
0, (uintptr_t)res);
ADD_OP(_SWAP, 2, 0);
attr = sym_new_const(ctx, res);
}
}
}
}
if (PyJitRef_IsNull(attr)) {
attr = sym_new_not_null(ctx);
}
o = owner;
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = attr;
stack_pointer[0] = o;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOAD_ATTR_WITH_HINT: {
JitOptRef owner;
JitOptRef attr;
JitOptRef o;
owner = stack_pointer[-1];
uint16_t hint = (uint16_t)this_instr->operand0;
attr = sym_new_not_null(ctx);
(void)hint;
o = owner;
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = attr;
stack_pointer[0] = o;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOAD_ATTR_SLOT: {
JitOptRef owner;
JitOptRef attr;
JitOptRef o;
owner = stack_pointer[-1];
uint16_t index = (uint16_t)this_instr->operand0;
attr = sym_new_not_null(ctx);
(void)index;
o = owner;
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = attr;
stack_pointer[0] = o;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _CHECK_ATTR_CLASS: {
JitOptRef owner;
owner = stack_pointer[-1];
uint32_t type_version = (uint32_t)this_instr->operand0;
PyObject *type = sym_get_probable_value(owner);
if (type != NULL && ((PyTypeObject *)type)->tp_version_tag == type_version) {
if (type == sym_get_const(ctx, owner)) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_const(owner, type);
watch_type((PyTypeObject *)type, dependencies);
}
}
break;
}
case _LOAD_ATTR_CLASS: {
JitOptRef owner;
JitOptRef attr;
owner = stack_pointer[-1];
PyObject *descr = (PyObject *)this_instr->operand0;
(void)descr;
PyTypeObject *type = (PyTypeObject *)sym_get_const(ctx, owner);
PyObject *name = get_co_name(ctx, oparg >> 1);
attr = lookup_attr(ctx, dependencies, this_instr, type, name,
_POP_TOP, _NOP);
stack_pointer[-1] = attr;
break;
}
case _LOAD_ATTR_PROPERTY_FRAME: {
JitOptRef owner;
JitOptRef new_frame;
owner = stack_pointer[-1];
uint32_t func_version = (uint32_t)this_instr->operand0;
PyObject *fget = (PyObject *)this_instr->operand1;
PyFunctionObject *func = (PyFunctionObject *)fget;
if (sym_get_type_version(owner) == 0 ||
func->func_version != func_version) {
ctx->contradiction = true;
ctx->done = true;
break;
}
_Py_BloomFilter_Add(dependencies, fget);
PyCodeObject *co = (PyCodeObject *)func->func_code;
_Py_UOpsAbstractFrame *f = frame_new(ctx, co, NULL, 0);
if (f == NULL) {
break;
}
f->locals[0] = owner;
f->func = func;
new_frame = PyJitRef_WrapInvalid(f);
stack_pointer[-1] = new_frame;
break;
}
case _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN_FRAME: {
JitOptRef owner;
JitOptRef new_frame;
owner = stack_pointer[-1];
uint32_t func_version = (uint32_t)this_instr->operand0;
PyObject *getattribute = (PyObject *)this_instr->operand1;
PyFunctionObject *func = (PyFunctionObject *)getattribute;
if (sym_get_type_version(owner) == 0 ||
func->func_version != func_version) {
ctx->contradiction = true;
ctx->done = true;
break;
}
_Py_BloomFilter_Add(dependencies, func);
PyCodeObject *co = (PyCodeObject *)func->func_code;
_Py_UOpsAbstractFrame *f = frame_new(ctx, co, NULL, 0);
if (f == NULL) {
break;
}
PyObject *name = get_co_name(ctx, oparg >> 1);
f->locals[0] = owner;
f->locals[1] = sym_new_const(ctx, name);
f->func = func;
new_frame = PyJitRef_WrapInvalid(f);
stack_pointer[-1] = new_frame;
break;
}
case _GUARD_DORV_NO_DICT: {
break;
}
case _STORE_ATTR_INSTANCE_VALUE: {
JitOptRef owner;
JitOptRef value;
JitOptRef o;
owner = stack_pointer[-1];
value = stack_pointer[-2];
uint16_t offset = (uint16_t)this_instr->operand0;
(void)offset;
(void)value;
o = owner;
CHECK_STACK_BOUNDS(-1);
stack_pointer[-2] = o;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOCK_OBJECT: {
break;
}
case _STORE_ATTR_WITH_HINT: {
JitOptRef owner;
JitOptRef value;
JitOptRef o;
owner = stack_pointer[-1];
value = stack_pointer[-2];
uint16_t hint = (uint16_t)this_instr->operand0;
(void)hint;
(void)value;
o = owner;
CHECK_STACK_BOUNDS(-1);
stack_pointer[-2] = o;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _STORE_ATTR_SLOT: {
JitOptRef owner;
JitOptRef value;
JitOptRef o;
owner = stack_pointer[-1];
value = stack_pointer[-2];
uint16_t index = (uint16_t)this_instr->operand0;
(void)index;
(void)value;
o = owner;
CHECK_STACK_BOUNDS(-1);
stack_pointer[-2] = o;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _COMPARE_OP: {
JitOptRef right;
JitOptRef left;
JitOptRef res;
right = stack_pointer[-1];
left = stack_pointer[-2];
if (
sym_is_safe_const(ctx, left) &&
sym_is_safe_const(ctx, right)
) {
JitOptRef left_sym = left;
JitOptRef right_sym = right;
_PyStackRef left = sym_get_const_as_stackref(ctx, left_sym);
_PyStackRef right = sym_get_const_as_stackref(ctx, right_sym);
_PyStackRef res_stackref;
/* Start of uop copied from bytecodes for constant evaluation */
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
assert((oparg >> 5) > 5);
if (res_o == NULL) {
goto error;
}
if (oparg & 16) {
int res_bool = PyObject_IsTrue(res_o);
Py_DECREF(res_o);
if (res_bool < 0) {
goto error;
}
res_stackref = res_bool ? PyStackRef_True : PyStackRef_False;
}
else {
res_stackref = PyStackRef_FromPyObjectSteal(res_o);
}
/* End of uop copied from bytecodes for constant evaluation */
res = sym_new_const_steal(ctx, PyStackRef_AsPyObjectSteal(res_stackref));
if (sym_is_const(ctx, res)) {
PyObject *result = sym_get_const(ctx, res);
if (_Py_IsImmortal(result)) {
// Replace with _POP_TOP + _POP_TOP + _LOAD_CONST_INLINE_BORROW since we have two inputs and an immortal result
ADD_OP(_POP_TOP, 0, 0);
ADD_OP(_POP_TOP, 0, 0);
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)result);
}
}
CHECK_STACK_BOUNDS(-1);
stack_pointer[-2] = res;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
if (oparg & 16) {
res = sym_new_type(ctx, &PyBool_Type);
}
else {
res = _Py_uop_sym_new_not_null(ctx);
}
CHECK_STACK_BOUNDS(-1);
stack_pointer[-2] = res;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _COMPARE_OP_FLOAT: {
JitOptRef right;
JitOptRef left;
JitOptRef res;
JitOptRef l;
JitOptRef r;
right = stack_pointer[-1];
left = stack_pointer[-2];
int cmp_mask = oparg & (COMPARE_LT_MASK | COMPARE_GT_MASK | COMPARE_EQ_MASK);
if (cmp_mask == COMPARE_EQ_MASK) {
res = sym_new_predicate(ctx, left, right, JIT_PRED_EQ);
}
else if (cmp_mask == (COMPARE_LT_MASK | COMPARE_GT_MASK)) {
res = sym_new_predicate(ctx, left, right, JIT_PRED_NE);
}
else {
res = sym_new_type(ctx, &PyBool_Type);
}
l = left;
r = right;
if (
sym_is_safe_const(ctx, left) &&
sym_is_safe_const(ctx, right)
) {
JitOptRef left_sym = left;
JitOptRef right_sym = right;
_PyStackRef left = sym_get_const_as_stackref(ctx, left_sym);
_PyStackRef right = sym_get_const_as_stackref(ctx, right_sym);
_PyStackRef res_stackref;
_PyStackRef l_stackref;
_PyStackRef r_stackref;
/* Start of uop copied from bytecodes for constant evaluation */
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
STAT_INC(COMPARE_OP, hit);
double dleft = PyFloat_AS_DOUBLE(left_o);
double dright = PyFloat_AS_DOUBLE(right_o);
int sign_ish = COMPARISON_BIT(dleft, dright);
l_stackref = left;
r_stackref = right;
res_stackref = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False;
/* End of uop copied from bytecodes for constant evaluation */
(void)l_stackref;
(void)r_stackref;
res = sym_new_const_steal(ctx, PyStackRef_AsPyObjectSteal(res_stackref));
if (sym_is_const(ctx, res)) {
PyObject *result = sym_get_const(ctx, res);
if (_Py_IsImmortal(result)) {
// Replace with _LOAD_CONST_INLINE_BORROW + _RROT_3 since we have two inputs and an immortal result
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)result);
ADD_OP(_RROT_3, 0, 0);
}
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _COMPARE_OP_INT: {
JitOptRef right;
JitOptRef left;
JitOptRef res;
JitOptRef l;
JitOptRef r;
right = stack_pointer[-1];
left = stack_pointer[-2];
int cmp_mask = oparg & (COMPARE_LT_MASK | COMPARE_GT_MASK | COMPARE_EQ_MASK);
if (cmp_mask == COMPARE_EQ_MASK) {
res = sym_new_predicate(ctx, left, right, JIT_PRED_EQ);
}
else if (cmp_mask == (COMPARE_LT_MASK | COMPARE_GT_MASK)) {
res = sym_new_predicate(ctx, left, right, JIT_PRED_NE);
}
else {
res = sym_new_type(ctx, &PyBool_Type);
}
l = left;
r = right;
if (
sym_is_safe_const(ctx, left) &&
sym_is_safe_const(ctx, right)
) {
JitOptRef left_sym = left;
JitOptRef right_sym = right;
_PyStackRef left = sym_get_const_as_stackref(ctx, left_sym);
_PyStackRef right = sym_get_const_as_stackref(ctx, right_sym);
_PyStackRef res_stackref;
_PyStackRef l_stackref;
_PyStackRef r_stackref;
/* Start of uop copied from bytecodes for constant evaluation */
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
assert(_PyLong_IsCompact((PyLongObject *)left_o));
assert(_PyLong_IsCompact((PyLongObject *)right_o));
STAT_INC(COMPARE_OP, hit);
assert(_PyLong_DigitCount((PyLongObject *)left_o) 5) == Py_EQ || (oparg >> 5) == Py_NE);
l_stackref = left;
r_stackref = right;
assert(eq == 0 || eq == 1);
assert((oparg & 0xf) == COMPARISON_NOT_EQUALS || (oparg & 0xf) == COMPARISON_EQUALS);
assert(COMPARISON_NOT_EQUALS + 1 == COMPARISON_EQUALS);
res_stackref = ((COMPARISON_NOT_EQUALS + eq) & oparg) ? PyStackRef_True : PyStackRef_False;
/* End of uop copied from bytecodes for constant evaluation */
(void)l_stackref;
(void)r_stackref;
res = sym_new_const_steal(ctx, PyStackRef_AsPyObjectSteal(res_stackref));
if (sym_is_const(ctx, res)) {
PyObject *result = sym_get_const(ctx, res);
if (_Py_IsImmortal(result)) {
// Replace with _LOAD_CONST_INLINE_BORROW + _RROT_3 since we have two inputs and an immortal result
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)result);
ADD_OP(_RROT_3, 0, 0);
}
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _IS_OP: {
JitOptRef right;
JitOptRef left;
JitOptRef b;
JitOptRef l;
JitOptRef r;
right = stack_pointer[-1];
left = stack_pointer[-2];
b = sym_new_predicate(ctx, left, right, (oparg ? JIT_PRED_IS_NOT : JIT_PRED_IS));
l = left;
r = right;
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = b;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _CONTAINS_OP: {
JitOptRef right;
JitOptRef left;
JitOptRef b;
JitOptRef l;
JitOptRef r;
right = stack_pointer[-1];
left = stack_pointer[-2];
b = sym_new_type(ctx, &PyBool_Type);
l = left;
r = right;
if (
sym_is_safe_const(ctx, left) &&
sym_is_safe_const(ctx, right)
) {
JitOptRef left_sym = left;
JitOptRef right_sym = right;
_PyStackRef left = sym_get_const_as_stackref(ctx, left_sym);
_PyStackRef right = sym_get_const_as_stackref(ctx, right_sym);
_PyStackRef b_stackref;
_PyStackRef l_stackref;
_PyStackRef r_stackref;
/* Start of uop copied from bytecodes for constant evaluation */
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
int res = PySequence_Contains(right_o, left_o);
if (res < 0) {
JUMP_TO_LABEL(error);
}
b_stackref = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;
l_stackref = left;
r_stackref = right;
/* End of uop copied from bytecodes for constant evaluation */
(void)l_stackref;
(void)r_stackref;
b = sym_new_const_steal(ctx, PyStackRef_AsPyObjectSteal(b_stackref));
if (sym_is_const(ctx, b)) {
PyObject *result = sym_get_const(ctx, b);
if (_Py_IsImmortal(result)) {
// Replace with _LOAD_CONST_INLINE_BORROW + _RROT_3 since we have two inputs and an immortal result
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)result);
ADD_OP(_RROT_3, 0, 0);
}
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = b;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = b;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_TOS_ANY_SET: {
JitOptRef tos;
tos = stack_pointer[-1];
PyTypeObject *tp = sym_get_type(tos);
if (tp == &PySet_Type || tp == &PyFrozenSet_Type) {
ADD_OP(_NOP, 0, 0);
}
else {
tp = sym_get_probable_type(tos);
if (tp == &PySet_Type) {
ADD_OP(_GUARD_TOS_SET, 0, 0);
}
else if (tp == &PyFrozenSet_Type) {
ADD_OP(_GUARD_TOS_FROZENSET, 0, 0);
}
}
break;
}
case _GUARD_TOS_SET: {
JitOptRef tos;
tos = stack_pointer[-1];
if (sym_matches_type(tos, &PySet_Type)) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_type(tos, &PySet_Type);
}
break;
}
case _GUARD_TOS_FROZENSET: {
JitOptRef tos;
tos = stack_pointer[-1];
if (sym_matches_type(tos, &PyFrozenSet_Type)) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_type(tos, &PyFrozenSet_Type);
}
break;
}
case _CONTAINS_OP_SET: {
JitOptRef right;
JitOptRef left;
JitOptRef b;
JitOptRef l;
JitOptRef r;
right = stack_pointer[-1];
left = stack_pointer[-2];
b = sym_new_type(ctx, &PyBool_Type);
l = left;
r = right;
if (sym_is_not_container(left) &&
sym_matches_type(right, &PyFrozenSet_Type)) {
if (
sym_is_safe_const(ctx, left) &&
sym_is_safe_const(ctx, right)
) {
JitOptRef left_sym = left;
JitOptRef right_sym = right;
_PyStackRef left = sym_get_const_as_stackref(ctx, left_sym);
_PyStackRef right = sym_get_const_as_stackref(ctx, right_sym);
_PyStackRef b_stackref;
_PyStackRef l_stackref;
_PyStackRef r_stackref;
/* Start of uop copied from bytecodes for constant evaluation */
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
assert(PyAnySet_CheckExact(right_o));
STAT_INC(CONTAINS_OP, hit);
int res = _PySet_Contains((PySetObject *)right_o, left_o);
if (res < 0) {
JUMP_TO_LABEL(error);
}
b_stackref = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;
l_stackref = left;
r_stackref = right;
/* End of uop copied from bytecodes for constant evaluation */
(void)l_stackref;
(void)r_stackref;
b = sym_new_const_steal(ctx, PyStackRef_AsPyObjectSteal(b_stackref));
if (sym_is_const(ctx, b)) {
PyObject *result = sym_get_const(ctx, b);
if (_Py_IsImmortal(result)) {
// Replace with _LOAD_CONST_INLINE_BORROW + _RROT_3 since we have two inputs and an immortal result
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)result);
ADD_OP(_RROT_3, 0, 0);
}
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = b;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = b;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _CONTAINS_OP_DICT: {
JitOptRef right;
JitOptRef left;
JitOptRef b;
JitOptRef l;
JitOptRef r;
right = stack_pointer[-1];
left = stack_pointer[-2];
b = sym_new_type(ctx, &PyBool_Type);
l = left;
r = right;
if (sym_is_not_container(left) &&
sym_matches_type(right, &PyFrozenDict_Type)) {
if (
sym_is_safe_const(ctx, left) &&
sym_is_safe_const(ctx, right)
) {
JitOptRef left_sym = left;
JitOptRef right_sym = right;
_PyStackRef left = sym_get_const_as_stackref(ctx, left_sym);
_PyStackRef right = sym_get_const_as_stackref(ctx, right_sym);
_PyStackRef b_stackref;
_PyStackRef l_stackref;
_PyStackRef r_stackref;
/* Start of uop copied from bytecodes for constant evaluation */
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
assert(PyAnyDict_CheckExact(right_o));
STAT_INC(CONTAINS_OP, hit);
int res = PyDict_Contains(right_o, left_o);
if (res < 0) {
JUMP_TO_LABEL(error);
}
b_stackref = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;
l_stackref = left;
r_stackref = right;
/* End of uop copied from bytecodes for constant evaluation */
(void)l_stackref;
(void)r_stackref;
b = sym_new_const_steal(ctx, PyStackRef_AsPyObjectSteal(b_stackref));
if (sym_is_const(ctx, b)) {
PyObject *result = sym_get_const(ctx, b);
if (_Py_IsImmortal(result)) {
// Replace with _LOAD_CONST_INLINE_BORROW + _RROT_3 since we have two inputs and an immortal result
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)result);
ADD_OP(_RROT_3, 0, 0);
}
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = b;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = b;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _CHECK_EG_MATCH: {
JitOptRef rest;
JitOptRef 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: {
JitOptRef b;
b = sym_new_not_null(ctx);
stack_pointer[-1] = b;
break;
}
case _IMPORT_NAME: {
JitOptRef res;
res = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(-1);
stack_pointer[-2] = res;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _IMPORT_FROM: {
JitOptRef res;
res = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = res;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
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: {
JitOptRef value;
JitOptRef b;
value = stack_pointer[-1];
if (sym_is_const(ctx, value)) {
PyObject *value_o = sym_get_const(ctx, value);
b = sym_new_const(ctx, Py_IsNone(value_o) ? Py_True : Py_False);
}
else {
b = sym_new_type(ctx, &PyBool_Type);
}
stack_pointer[-1] = b;
break;
}
/* _JUMP_BACKWARD_NO_INTERRUPT is not a viable micro-op for tier 2 */
case _GET_LEN: {
JitOptRef obj;
JitOptRef len;
obj = stack_pointer[-1];
Py_ssize_t 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_FromSsize_t(tuple_length);
if (temp == NULL) {
goto error;
}
if (_Py_IsImmortal(temp)) {
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)temp);
}
len = sym_new_const(ctx, temp);
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = len;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
Py_DECREF(temp);
stack_pointer += -1;
}
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = len;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _MATCH_CLASS: {
JitOptRef names;
JitOptRef type;
JitOptRef subject;
JitOptRef attrs;
JitOptRef s;
JitOptRef tp;
JitOptRef n;
names = stack_pointer[-1];
type = stack_pointer[-2];
subject = stack_pointer[-3];
attrs = sym_new_not_null(ctx);
s = subject;
tp = type;
n = names;
CHECK_STACK_BOUNDS(1);
stack_pointer[-3] = attrs;
stack_pointer[-2] = s;
stack_pointer[-1] = tp;
stack_pointer[0] = n;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _MATCH_MAPPING: {
JitOptRef res;
res = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = res;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _MATCH_SEQUENCE: {
JitOptRef res;
res = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = res;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _MATCH_KEYS: {
JitOptRef values_or_none;
values_or_none = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = values_or_none;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GET_ITER: {
JitOptRef iterable;
JitOptRef iter;
JitOptRef index_or_null;
iterable = stack_pointer[-1];
bool is_coro = false;
bool is_trad = false;
bool definite = true;
PyTypeObject *tp = sym_get_type(iterable);
if (tp == NULL) {
definite = false;
tp = sym_get_probable_type(iterable);
}
if (oparg == GET_ITER_YIELD_FROM_NO_CHECK) {
if (tp == &PyCoro_Type) {
if (!definite) {
ADD_OP(_GUARD_TYPE, 0, (uintptr_t)tp);
sym_set_type(iterable, tp);
}
ADD_OP(_PUSH_NULL, 0, 0);
is_coro = true;
}
}
if (tp != NULL &&
tp->_tp_iteritem == NULL &&
tp->tp_iter != NULL &&
tp->tp_iter != PyObject_SelfIter &&
tp->tp_flags & Py_TPFLAGS_IMMUTABLETYPE
) {
assert(tp != &PyCoro_Type);
is_trad = true;
if (!definite) {
ADD_OP(_GUARD_TYPE, 0, (uintptr_t)tp);
sym_set_type(iterable, tp);
}
ADD_OP(_GET_ITER_TRAD, 0, 0);
}
if (is_coro) {
assert(!is_trad);
iter = iterable;
index_or_null = sym_new_null(ctx);
}
else if (is_trad) {
iter = sym_new_not_null(ctx);
index_or_null = sym_new_null(ctx);
}
else {
iter = sym_new_not_null(ctx);
index_or_null = sym_new_unknown(ctx);
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = iter;
stack_pointer[0] = index_or_null;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_ITERATOR: {
JitOptRef iterable;
iterable = stack_pointer[-1];
bool definite = true;
PyTypeObject *tp = sym_get_type(iterable);
if (tp == NULL) {
definite = false;
tp = sym_get_probable_type(iterable);
}
if (tp != NULL && tp->tp_iter == PyObject_SelfIter) {
if (definite) {
ADD_OP(_NOP, 0, 0);
}
else {
ADD_OP(_GUARD_TYPE, 0, (uintptr_t)tp);
sym_set_type(iterable, tp);
}
}
break;
}
case _GUARD_ITER_VIRTUAL: {
JitOptRef iterable;
iterable = stack_pointer[-1];
bool definite = true;
PyTypeObject *tp = sym_get_type(iterable);
if (tp == NULL) {
definite = false;
tp = sym_get_probable_type(iterable);
}
if (tp != NULL && tp->_tp_iteritem != NULL) {
if (definite) {
ADD_OP(_NOP, 0, 0);
}
else {
ADD_OP(_GUARD_TYPE, 0, (uintptr_t)tp);
sym_set_type(iterable, tp);
}
}
break;
}
case _PUSH_TAGGED_ZERO: {
JitOptRef zero;
zero = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = zero;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GET_ITER_TRAD: {
JitOptRef iter;
JitOptRef index_or_null;
iter = sym_new_not_null(ctx);
index_or_null = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = iter;
stack_pointer[0] = index_or_null;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
/* _FOR_ITER is not a viable micro-op for tier 2 */
case _FOR_ITER_TIER_TWO: {
JitOptRef iter;
JitOptRef next;
iter = stack_pointer[-2];
bool definite = true;
PyTypeObject *type = sym_get_type(iter);
if (type == NULL) {
type = sym_get_probable_type(iter);
definite = false;
}
if (type != NULL && type != &PyGen_Type && type->tp_iternext != NULL
&& !_PyType_HasSlotTpIternext(type)) {
PyType_Watch(TYPE_WATCHER_ID, (PyObject *)type);
_Py_BloomFilter_Add(dependencies, type);
if (!definite) {
sym_set_type(iter, type);
assert((this_instr - 1)->opcode == _RECORD_NOS_TYPE);
int32_t orig_target = (this_instr - 1)->target;
ADD_OP(_GUARD_TYPE_ITER, 0, (uintptr_t)type);
uop_buffer_last(&ctx->out_buffer)->target = orig_target;
}
ADD_OP(_ITER_NEXT_INLINE, 0, (uintptr_t)type->tp_iternext);
}
next = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = next;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_TYPE_ITER: {
break;
}
case _ITER_NEXT_INLINE: {
JitOptRef next;
next = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = next;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_NOS_ITER_VIRTUAL: {
break;
}
case _GUARD_TOS_NOT_NULL: {
JitOptRef null_or_index;
null_or_index = stack_pointer[-1];
if (sym_is_not_null(null_or_index)) {
REPLACE_OP(this_instr, _NOP, 0, 0);
}
else {
sym_set_non_null(null_or_index);
}
break;
}
/* _FOR_ITER_VIRTUAL is not a viable micro-op for tier 2 */
case _FOR_ITER_VIRTUAL_TIER_TWO: {
JitOptRef next;
next = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = next;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
/* _INSTRUMENTED_FOR_ITER is not a viable micro-op for tier 2 */
case _ITER_CHECK_LIST: {
JitOptRef iter;
iter = stack_pointer[-2];
if (sym_matches_type(iter, &PyList_Type)) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_type(iter, &PyList_Type);
}
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: {
JitOptRef next;
next = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = next;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _ITER_CHECK_TUPLE: {
JitOptRef iter;
iter = stack_pointer[-2];
if (sym_matches_type(iter, &PyTuple_Type)) {
ADD_OP(_NOP, 0, 0);
}
sym_set_type(iter, &PyTuple_Type);
break;
}
/* _ITER_JUMP_TUPLE is not a viable micro-op for tier 2 */
case _GUARD_NOT_EXHAUSTED_TUPLE: {
break;
}
case _ITER_NEXT_TUPLE: {
JitOptRef next;
next = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = next;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _ITER_CHECK_RANGE: {
JitOptRef iter;
iter = stack_pointer[-2];
if (sym_matches_type(iter, &PyRangeIter_Type)) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_type(iter, &PyRangeIter_Type);
}
break;
}
/* _ITER_JUMP_RANGE is not a viable micro-op for tier 2 */
case _GUARD_NOT_EXHAUSTED_RANGE: {
break;
}
case _ITER_NEXT_RANGE: {
JitOptRef next;
next = sym_new_type(ctx, &PyLong_Type);
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = next;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _FOR_ITER_GEN_FRAME: {
JitOptRef iter;
JitOptRef gen_frame;
iter = stack_pointer[-2];
_Py_UOpsAbstractFrame *new_frame = frame_new_from_symbol(ctx, iter, NULL, 0);
if (new_frame == NULL) {
ctx->done = true;
break;
}
new_frame->stack_pointer[0] = sym_new_const(ctx, Py_None);
new_frame->stack_pointer++;
gen_frame = PyJitRef_WrapInvalid(new_frame);
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = gen_frame;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _INSERT_NULL: {
JitOptRef self;
JitOptRef *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;
CHECK_STACK_BOUNDS(1);
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOAD_SPECIAL: {
JitOptRef *method_and_self;
method_and_self = &stack_pointer[-2];
bool optimized = false;
PyTypeObject *type = sym_get_probable_type(method_and_self[1]);
if (type != NULL) {
PyObject *name = _Py_SpecialMethods[oparg].name;
PyObject *descr = _PyType_Lookup(type, name);
if (descr != NULL && (Py_TYPE(descr)->tp_flags & Py_TPFLAGS_METHOD_DESCRIPTOR)) {
_PyUOpInstruction *insert_null = uop_buffer_last(&ctx->out_buffer);
assert(insert_null->opcode == _INSERT_NULL);
assert(insert_null->target == this_instr->target);
REPLACE_OP(insert_null, _GUARD_TYPE_VERSION, 0, type->tp_version_tag);
ADD_OP(_INSERT_NULL, 0, 0);
bool immortal = _Py_IsImmortal(descr) || (type->tp_flags & Py_TPFLAGS_IMMUTABLETYPE);
ADD_OP(immortal ? _LOAD_CONST_INLINE_BORROW : _LOAD_CONST_INLINE,
0, (uintptr_t)descr);
ADD_OP(_SWAP, 3, 0);
optimize_pop_top(ctx, this_instr, method_and_self[0]);
watch_type(type, dependencies);
method_and_self[0] = sym_new_const(ctx, descr);
optimized = true;
}
}
if (!optimized) {
method_and_self[0] = sym_new_not_null(ctx);
method_and_self[1] = sym_new_unknown(ctx);
}
break;
}
case _WITH_EXCEPT_START: {
JitOptRef res;
res = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = res;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _PUSH_EXC_INFO: {
JitOptRef prev_exc;
JitOptRef new_exc;
prev_exc = sym_new_not_null(ctx);
new_exc = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = prev_exc;
stack_pointer[0] = new_exc;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOAD_ATTR_METHOD_WITH_VALUES: {
JitOptRef owner;
JitOptRef attr;
JitOptRef self;
owner = stack_pointer[-1];
PyObject *descr = (PyObject *)this_instr->operand0;
(void)descr;
PyTypeObject *type = sym_get_type(owner);
PyObject *name = get_co_name(ctx, oparg >> 1);
attr = lookup_attr(ctx, dependencies, this_instr, type, name,
_NOP, _SWAP);
self = owner;
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = attr;
stack_pointer[0] = self;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOAD_ATTR_METHOD_NO_DICT: {
JitOptRef owner;
JitOptRef attr;
JitOptRef self;
owner = stack_pointer[-1];
PyObject *descr = (PyObject *)this_instr->operand0;
(void)descr;
PyTypeObject *type = sym_get_type(owner);
PyObject *name = get_co_name(ctx, oparg >> 1);
attr = lookup_attr(ctx, dependencies, this_instr, type, name,
_NOP, _SWAP);
self = owner;
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = attr;
stack_pointer[0] = self;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES: {
JitOptRef owner;
JitOptRef attr;
owner = stack_pointer[-1];
PyObject *descr = (PyObject *)this_instr->operand0;
(void)descr;
PyTypeObject *type = sym_get_type(owner);
PyObject *name = get_co_name(ctx, oparg >> 1);
attr = lookup_attr(ctx, dependencies, this_instr, type, name,
_POP_TOP, _NOP);
stack_pointer[-1] = attr;
break;
}
case _LOAD_ATTR_NONDESCRIPTOR_NO_DICT: {
JitOptRef owner;
JitOptRef attr;
owner = stack_pointer[-1];
PyObject *descr = (PyObject *)this_instr->operand0;
(void)descr;
PyTypeObject *type = sym_get_type(owner);
PyObject *name = get_co_name(ctx, oparg >> 1);
attr = lookup_attr(ctx, dependencies, this_instr, type, name,
_POP_TOP, _NOP);
stack_pointer[-1] = attr;
break;
}
case _CHECK_ATTR_METHOD_LAZY_DICT: {
break;
}
case _LOAD_ATTR_METHOD_LAZY_DICT: {
JitOptRef owner;
JitOptRef attr;
JitOptRef self;
owner = stack_pointer[-1];
PyObject *descr = (PyObject *)this_instr->operand0;
(void)descr;
PyTypeObject *type = sym_get_type(owner);
PyObject *name = get_co_name(ctx, oparg >> 1);
attr = lookup_attr(ctx, dependencies, this_instr, type, name,
_NOP, _SWAP);
self = owner;
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = attr;
stack_pointer[0] = self;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _MAYBE_EXPAND_METHOD: {
JitOptRef *args;
JitOptRef self_or_null;
JitOptRef 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: {
JitOptRef callable;
JitOptRef new_frame;
callable = stack_pointer[-2 - oparg];
new_frame = PyJitRef_WrapInvalid(frame_new_from_symbol(ctx, callable, NULL, 0));
CHECK_STACK_BOUNDS(-1 - oparg);
stack_pointer[-2 - oparg] = new_frame;
stack_pointer += -1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _CHECK_FUNCTION_VERSION: {
JitOptRef callable;
callable = stack_pointer[-2 - oparg];
uint32_t func_version = (uint32_t)this_instr->operand0;
PyObject *func = sym_get_probable_value(callable);
if (func == NULL || !PyFunction_Check(func) || ((PyFunctionObject *)func)->func_version != func_version) {
ctx->contradiction = true;
ctx->done = true;
break;
}
sym_set_const(callable, func);
_Py_BloomFilter_Add(dependencies, func);
break;
}
case _CHECK_FUNCTION_VERSION_INLINE: {
break;
}
case _CHECK_METHOD_VERSION: {
JitOptRef 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, &PyMethod_Type)) {
PyMethodObject *method = (PyMethodObject *)sym_get_const(ctx, callable);
assert(PyMethod_Check(method));
ADD_OP(_CHECK_FUNCTION_VERSION_INLINE, 0, func_version);
uop_buffer_last(&ctx->out_buffer)->operand1 = (uintptr_t)method->im_func;
}
else {
PyObject *bound_method = sym_get_probable_value(callable);
if (bound_method != NULL && Py_TYPE(bound_method) == &PyMethod_Type) {
PyMethodObject *method = (PyMethodObject *)bound_method;
PyObject *func = method->im_func;
if (PyFunction_Check(func) &&
((PyFunctionObject *)func)->func_version == func_version) {
_Py_BloomFilter_Add(dependencies, func);
sym_set_const(callable, bound_method);
}
}
}
sym_set_type(callable, &PyMethod_Type);
break;
}
case _EXPAND_METHOD: {
JitOptRef self_or_null;
JitOptRef callable;
self_or_null = stack_pointer[-1 - oparg];
callable = stack_pointer[-2 - oparg];
if (sym_is_const(ctx, callable) && sym_matches_type(callable, &PyMethod_Type)) {
PyMethodObject *method = (PyMethodObject *)sym_get_const(ctx, callable);
callable = sym_new_const(ctx, method->im_func);
self_or_null = sym_new_const(ctx, method->im_self);
}
else {
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_IS_NOT_PY_CALLABLE: {
JitOptRef callable;
callable = stack_pointer[-2 - oparg];
PyTypeObject *type = sym_get_type(callable);
if (type && type != &PyFunction_Type && type != &PyMethod_Type) {
ADD_OP(_NOP, 0, 0);
}
break;
}
case _CALL_NON_PY_GENERAL: {
JitOptRef res;
res = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(-1 - oparg);
stack_pointer[-2 - oparg] = res;
stack_pointer += -1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _CHECK_CALL_BOUND_METHOD_EXACT_ARGS: {
JitOptRef null;
JitOptRef 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: {
JitOptRef self_or_null;
JitOptRef callable;
self_or_null = stack_pointer[-1 - oparg];
callable = stack_pointer[-2 - oparg];
PyObject *bound_method = sym_get_probable_value(callable);
if (bound_method != NULL && Py_TYPE(bound_method) == &PyMethod_Type) {
PyMethodObject *method = (PyMethodObject *)bound_method;
callable = sym_new_not_null(ctx);
sym_set_recorded_value(callable, method->im_func);
self_or_null = sym_new_not_null(ctx);
sym_set_recorded_value(self_or_null, method->im_self);
}
else {
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) {
ADD_OP(_NOP, 0 ,0);
}
break;
}
case _CHECK_FUNCTION_EXACT_ARGS: {
JitOptRef self_or_null;
JitOptRef 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_not_null(self_or_null)) {
ADD_OP(_NOP, 0 ,0);
}
}
}
break;
}
case _CHECK_STACK_SPACE: {
JitOptRef callable;
callable = stack_pointer[-2 - oparg];
PyCodeObject *co = sym_get_probable_func_code(callable);
if (co == NULL) {
ctx->done = true;
break;
}
ADD_OP(_CHECK_STACK_SPACE_OPERAND, 0, co->co_framesize);
break;
}
case _CHECK_RECURSION_REMAINING: {
break;
}
case _INIT_CALL_PY_EXACT_ARGS: {
JitOptRef *args;
JitOptRef self_or_null;
JitOptRef callable;
JitOptRef new_frame;
args = &stack_pointer[-oparg];
self_or_null = stack_pointer[-1 - oparg];
callable = stack_pointer[-2 - oparg];
int argcount = oparg;
assert(!PyJitRef_IsNull(self_or_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 = PyJitRef_WrapInvalid(frame_new_from_symbol(ctx, callable, args, argcount));
} else {
new_frame = PyJitRef_WrapInvalid(frame_new_from_symbol(ctx, callable, NULL, 0));
}
CHECK_STACK_BOUNDS(-1 - oparg);
stack_pointer[-2 - oparg] = new_frame;
stack_pointer += -1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _PUSH_FRAME: {
JitOptRef new_frame;
new_frame = stack_pointer[-1];
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (!CURRENT_FRAME_IS_INIT_SHIM()) {
ctx->frame->stack_pointer = stack_pointer;
}
ctx->frame->caller = true;
ctx->frame = (_Py_UOpsAbstractFrame *)PyJitRef_Unwrap(new_frame);
ctx->curr_frame_depth++;
stack_pointer = ctx->frame->stack_pointer;
assert(ctx->frame->locals != NULL);
break;
}
case _GUARD_NOS_NULL: {
JitOptRef null;
null = stack_pointer[-2];
if (sym_is_null(null)) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_null(null);
}
break;
}
case _GUARD_THIRD_NULL: {
JitOptRef null;
null = stack_pointer[-3];
if (sym_is_null(null)) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_null(null);
}
break;
}
case _GUARD_CALLABLE_TYPE_1: {
JitOptRef callable;
callable = stack_pointer[-3];
if (sym_get_const(ctx, callable) == (PyObject *)&PyType_Type) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_const(callable, (PyObject *)&PyType_Type);
}
break;
}
case _CALL_TYPE_1: {
JitOptRef arg;
JitOptRef null;
JitOptRef callable;
JitOptRef res;
JitOptRef a;
arg = stack_pointer[-1];
null = stack_pointer[-2];
callable = stack_pointer[-3];
PyObject* type = (PyObject *)sym_get_type(arg);
if (type) {
res = sym_new_const(ctx, type);
ADD_OP(_SWAP, 3, 0);
optimize_pop_top(ctx, this_instr, callable);
optimize_pop_top(ctx, this_instr, null);
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)type);
ADD_OP(_SWAP, 2, 0);
}
else {
res = sym_new_not_null(ctx);
}
a = arg;
CHECK_STACK_BOUNDS(-1);
stack_pointer[-3] = res;
stack_pointer[-2] = a;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_CALLABLE_STR_1: {
JitOptRef callable;
callable = stack_pointer[-3];
if (sym_get_const(ctx, callable) == (PyObject *)&PyUnicode_Type) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_const(callable, (PyObject *)&PyUnicode_Type);
}
break;
}
case _CALL_STR_1: {
JitOptRef arg;
JitOptRef res;
JitOptRef a;
arg = stack_pointer[-1];
if (sym_matches_type(arg, &PyUnicode_Type)) {
res = PyJitRef_StripReferenceInfo(arg);
}
else {
res = sym_new_type(ctx, &PyUnicode_Type);
}
a = arg;
CHECK_STACK_BOUNDS(-1);
stack_pointer[-3] = res;
stack_pointer[-2] = a;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_CALLABLE_TUPLE_1: {
JitOptRef callable;
callable = stack_pointer[-3];
if (sym_get_const(ctx, callable) == (PyObject *)&PyTuple_Type) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_const(callable, (PyObject *)&PyTuple_Type);
}
break;
}
case _CALL_TUPLE_1: {
JitOptRef arg;
JitOptRef res;
JitOptRef a;
arg = stack_pointer[-1];
if (sym_matches_type(arg, &PyTuple_Type)) {
res = PyJitRef_StripReferenceInfo(arg);
}
else {
res = sym_new_type(ctx, &PyTuple_Type);
}
a = arg;
CHECK_STACK_BOUNDS(-1);
stack_pointer[-3] = res;
stack_pointer[-2] = a;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _CHECK_OBJECT: {
JitOptRef self_or_null;
JitOptRef callable;
self_or_null = stack_pointer[-1 - oparg];
callable = stack_pointer[-2 - oparg];
uint32_t type_version = (uint32_t)this_instr->operand0;
PyObject *probable_callable = sym_get_probable_value(callable);
assert(probable_callable != NULL);
PyObject *const_callable = sym_get_const(ctx, callable);
bool is_probable = const_callable == NULL && probable_callable != NULL;
PyObject *callable_o = const_callable != NULL ? const_callable : probable_callable;
if (sym_is_null(self_or_null) &&
callable_o != NULL &&
PyType_Check(callable_o) &&
((PyTypeObject *)callable_o)->tp_version_tag == type_version) {
if (!is_probable) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_const(callable, callable_o);
}
PyHeapTypeObject *cls = (PyHeapTypeObject *)callable_o;
PyObject *init = cls->_spec_cache.init;
assert(init != NULL);
assert(PyFunction_Check(init));
callable = sym_new_const(ctx, init);
stack_pointer[-2 - oparg] = callable;
watch_type((PyTypeObject *)callable_o, dependencies);
}
else {
callable = sym_new_not_null(ctx);
}
stack_pointer[-2 - oparg] = callable;
break;
}
case _ALLOCATE_OBJECT: {
JitOptRef self_or_null;
self_or_null = stack_pointer[-1 - oparg];
self_or_null = sym_new_not_null(ctx);
stack_pointer[-1 - oparg] = self_or_null;
break;
}
case _CREATE_INIT_FRAME: {
JitOptRef *args;
JitOptRef self;
JitOptRef init;
JitOptRef init_frame;
args = &stack_pointer[-oparg];
self = stack_pointer[-1 - oparg];
init = stack_pointer[-2 - oparg];
ctx->frame->stack_pointer = stack_pointer - oparg - 2;
_Py_UOpsAbstractFrame *shim = frame_new(ctx, (PyCodeObject *)&_Py_InitCleanup, NULL, 0);
if (shim == NULL) {
break;
}
shim->stack_pointer[0] = self;
shim->stack_pointer++;
assert((int)(shim->stack_pointer - shim->stack) == 1);
ctx->frame = shim;
ctx->curr_frame_depth++;
assert((this_instr + 1)->opcode == _PUSH_FRAME);
init_frame = PyJitRef_WrapInvalid(frame_new_from_symbol(ctx, init, args-1, oparg+1));
CHECK_STACK_BOUNDS(-1 - oparg);
stack_pointer[-2 - oparg] = init_frame;
stack_pointer += -1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _EXIT_INIT_CHECK: {
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_CALLABLE_BUILTIN_CLASS: {
JitOptRef callable;
callable = stack_pointer[-2 - oparg];
PyObject *callable_o = sym_get_const(ctx, callable);
if (callable_o && sym_matches_type(callable, &PyType_Type)) {
PyTypeObject *tp = (PyTypeObject *)callable_o;
if (tp->tp_vectorcall != NULL) {
ADD_OP(_NOP, 0, 0);
}
}
else {
sym_set_type(callable, &PyType_Type);
}
break;
}
case _CALL_BUILTIN_CLASS: {
JitOptRef callable;
callable = stack_pointer[-2 - oparg];
callable = sym_new_not_null(ctx);
stack_pointer[-2 - oparg] = callable;
break;
}
case _GUARD_CALLABLE_BUILTIN_O: {
JitOptRef self_or_null;
JitOptRef callable;
self_or_null = stack_pointer[-1 - oparg];
callable = stack_pointer[-2 - oparg];
PyObject *callable_o = sym_get_const(ctx, callable);
if (callable_o && sym_matches_type(callable, &PyCFunction_Type) &&
(sym_is_not_null(self_or_null) || sym_is_null(self_or_null))) {
int total_args = oparg;
if (sym_is_not_null(self_or_null)) {
total_args++;
}
if (total_args == 1 && PyCFunction_GET_FLAGS(callable_o) == METH_O) {
ADD_OP(_NOP, 0, 0);
}
}
else {
sym_set_type(callable, &PyCFunction_Type);
}
break;
}
case _CALL_BUILTIN_O: {
JitOptRef *args;
JitOptRef self_or_null;
JitOptRef callable;
JitOptRef res;
JitOptRef c;
JitOptRef s;
args = &stack_pointer[-oparg];
self_or_null = stack_pointer[-1 - oparg];
callable = stack_pointer[-2 - oparg];
res = sym_new_not_null(ctx);
c = callable;
if (sym_is_not_null(self_or_null)) {
args--;
s = args[0];
}
else if (sym_is_null(self_or_null)) {
s = args[0];
}
else {
s = sym_new_unknown(ctx);
}
CHECK_STACK_BOUNDS(1 - oparg);
stack_pointer[-2 - oparg] = res;
stack_pointer[-1 - oparg] = c;
stack_pointer[-oparg] = s;
stack_pointer += 1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_CALLABLE_BUILTIN_FAST: {
JitOptRef callable;
callable = stack_pointer[-2 - oparg];
PyObject *callable_o = sym_get_const(ctx, callable);
if (callable_o && sym_matches_type(callable, &PyCFunction_Type)) {
if (PyCFunction_GET_FLAGS(callable_o) == METH_FASTCALL) {
ADD_OP(_NOP, 0, 0);
}
}
else {
sym_set_type(callable, &PyCFunction_Type);
}
break;
}
case _CALL_BUILTIN_FAST: {
JitOptRef callable;
callable = stack_pointer[-2 - oparg];
callable = sym_new_not_null(ctx);
stack_pointer[-2 - oparg] = callable;
break;
}
case _GUARD_CALLABLE_BUILTIN_FAST_WITH_KEYWORDS: {
JitOptRef callable;
callable = stack_pointer[-2 - oparg];
PyObject *callable_o = sym_get_const(ctx, callable);
if (callable_o && sym_matches_type(callable, &PyCFunction_Type)) {
if (PyCFunction_GET_FLAGS(callable_o) == (METH_FASTCALL | METH_KEYWORDS)) {
ADD_OP(_NOP, 0, 0);
}
}
else {
sym_set_type(callable, &PyCFunction_Type);
}
break;
}
case _CALL_BUILTIN_FAST_WITH_KEYWORDS: {
JitOptRef callable;
callable = stack_pointer[-2 - oparg];
callable = sym_new_not_null(ctx);
stack_pointer[-2 - oparg] = callable;
break;
}
case _GUARD_CALLABLE_LEN: {
JitOptRef callable;
callable = stack_pointer[-3];
PyObject *len = _PyInterpreterState_GET()->callable_cache.len;
if (sym_get_const(ctx, callable) == len) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_const(callable, len);
}
break;
}
case _CALL_LEN: {
JitOptRef arg;
JitOptRef null;
JitOptRef callable;
JitOptRef res;
JitOptRef a;
JitOptRef c;
arg = stack_pointer[-1];
null = stack_pointer[-2];
callable = stack_pointer[-3];
res = sym_new_type(ctx, &PyLong_Type);
Py_ssize_t length = sym_tuple_length(arg);
if (length < 0 && sym_is_const(ctx, arg)) {
PyObject *const_val = sym_get_const(ctx, arg);
if (const_val != NULL) {
if (PyUnicode_CheckExact(const_val)) {
length = PyUnicode_GET_LENGTH(const_val);
}
else if (PyBytes_CheckExact(const_val)) {
length = PyBytes_GET_SIZE(const_val);
}
else if (PyFrozenDict_CheckExact(const_val)) {
length = PyDict_GET_SIZE(const_val);
}
else if (PyFrozenSet_CheckExact(const_val)) {
length = PySet_GET_SIZE(const_val);
}
}
}
if (length >= 0) {
PyObject *temp = PyLong_FromSsize_t(length);
if (temp == NULL) {
goto error;
}
if (_Py_IsImmortal(temp)) {
ADD_OP(_SWAP, 2, 0);
optimize_pop_top(ctx, this_instr, null);
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)temp);
ADD_OP(_SWAP, 3, 0);
}
res = sym_new_const(ctx, temp);
CHECK_STACK_BOUNDS(-2);
stack_pointer[-3] = res;
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
Py_DECREF(temp);
stack_pointer += 2;
}
a = arg;
c = callable;
stack_pointer[-3] = res;
stack_pointer[-2] = a;
stack_pointer[-1] = c;
break;
}
case _GUARD_CALLABLE_ISINSTANCE: {
JitOptRef callable;
callable = stack_pointer[-4];
PyObject *isinstance = _PyInterpreterState_GET()->callable_cache.isinstance;
if (sym_get_const(ctx, callable) == isinstance) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_const(callable, isinstance);
}
break;
}
case _CALL_ISINSTANCE: {
JitOptRef cls;
JitOptRef instance;
JitOptRef null;
JitOptRef callable;
JitOptRef res;
cls = stack_pointer[-1];
instance = stack_pointer[-2];
null = stack_pointer[-3];
callable = stack_pointer[-4];
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);
optimize_pop_top(ctx, this_instr, cls);
optimize_pop_top(ctx, this_instr, instance);
optimize_pop_top(ctx, this_instr, null);
optimize_pop_top(ctx, this_instr, callable);
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)out);
}
CHECK_STACK_BOUNDS(-3);
stack_pointer[-4] = res;
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_CALLABLE_LIST_APPEND: {
JitOptRef callable;
callable = stack_pointer[-3];
PyObject *list_append = _PyInterpreterState_GET()->callable_cache.list_append;
if (sym_get_const(ctx, callable) == list_append) {
ADD_OP(_NOP, 0, 0);
}
else {
sym_set_const(callable, list_append);
}
break;
}
case _CALL_LIST_APPEND: {
JitOptRef arg;
JitOptRef self;
JitOptRef callable;
JitOptRef none;
JitOptRef c;
JitOptRef s;
arg = stack_pointer[-1];
self = stack_pointer[-2];
callable = stack_pointer[-3];
(void)(arg);
c = callable;
s = self;
none = sym_new_const(ctx, Py_None);
stack_pointer[-3] = none;
stack_pointer[-2] = c;
stack_pointer[-1] = s;
break;
}
case _GUARD_CALLABLE_METHOD_DESCRIPTOR_O: {
JitOptRef *args;
JitOptRef self_or_null;
JitOptRef callable;
args = &stack_pointer[-oparg];
self_or_null = stack_pointer[-1 - oparg];
callable = stack_pointer[-2 - oparg];
PyObject *callable_o = sym_get_const(ctx, callable);
if (callable_o && sym_matches_type(callable, &PyMethodDescr_Type) &&
(sym_is_not_null(self_or_null) || sym_is_null(self_or_null))) {
int total_args = oparg;
if (sym_is_not_null(self_or_null)) {
total_args++;
}
PyTypeObject *self_type = NULL;
if (sym_is_not_null(self_or_null)) {
self_type = sym_get_type(self_or_null);
}
else {
self_type = sym_get_type(args[0]);
}
PyTypeObject *d_type = ((PyMethodDescrObject *)callable_o)->d_common.d_type;
if (total_args == 2 &&
((PyMethodDescrObject *)callable_o)->d_method->ml_flags == METH_O &&
self_type == d_type) {
ADD_OP(_NOP, 0, 0);
}
}
else {
sym_set_type(callable, &PyMethodDescr_Type);
}
break;
}
case _CALL_METHOD_DESCRIPTOR_O: {
JitOptRef *args;
JitOptRef self_or_null;
JitOptRef callable;
JitOptRef res;
JitOptRef c;
JitOptRef s;
JitOptRef a;
args = &stack_pointer[-oparg];
self_or_null = stack_pointer[-1 - oparg];
callable = stack_pointer[-2 - oparg];
PyObject *callable_o = sym_get_const(ctx, callable);
if (callable_o && Py_IS_TYPE(callable_o, &PyMethodDescr_Type)
&& sym_is_not_null(self_or_null)) {
PyMethodDescrObject *method = (PyMethodDescrObject *)callable_o;
PyCFunction cfunc = method->d_method->ml_meth;
ADD_OP(_CALL_METHOD_DESCRIPTOR_O_INLINE, oparg + 1, (uintptr_t)cfunc);
}
res = sym_new_not_null(ctx);
c = callable;
if (sym_is_not_null(self_or_null)) {
args--;
s = args[0];
a = args[1];
}
else {
s = sym_new_unknown(ctx);
a = sym_new_unknown(ctx);
}
CHECK_STACK_BOUNDS(2 - oparg);
stack_pointer[-2 - oparg] = res;
stack_pointer[-1 - oparg] = c;
stack_pointer[-oparg] = s;
stack_pointer[1 - oparg] = a;
stack_pointer += 2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _CHECK_RECURSION_LIMIT: {
if (ctx->frame->is_c_recursion_checked) {
ADD_OP(_NOP, 0, 0);
}
ctx->frame->is_c_recursion_checked = true;
break;
}
case _CALL_METHOD_DESCRIPTOR_O_INLINE: {
JitOptRef res;
JitOptRef c;
JitOptRef s;
JitOptRef a;
res = sym_new_not_null(ctx);
c = sym_new_not_null(ctx);
s = sym_new_not_null(ctx);
a = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(3 - oparg);
stack_pointer[-1 - oparg] = res;
stack_pointer[-oparg] = c;
stack_pointer[1 - oparg] = s;
stack_pointer[2 - oparg] = a;
stack_pointer += 3 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS: {
JitOptRef *args;
JitOptRef self_or_null;
JitOptRef callable;
args = &stack_pointer[-oparg];
self_or_null = stack_pointer[-1 - oparg];
callable = stack_pointer[-2 - oparg];
PyObject *callable_o = sym_get_const(ctx, callable);
if (callable_o && sym_matches_type(callable, &PyMethodDescr_Type) &&
(sym_is_not_null(self_or_null) || sym_is_null(self_or_null))) {
int total_args = oparg;
if (sym_is_not_null(self_or_null)) {
total_args++;
}
PyTypeObject *self_type = NULL;
if (sym_is_not_null(self_or_null)) {
self_type = sym_get_type(self_or_null);
}
else {
self_type = sym_get_type(args[0]);
}
PyTypeObject *d_type = ((PyMethodDescrObject *)callable_o)->d_common.d_type;
if (total_args != 0 &&
((PyMethodDescrObject *)callable_o)->d_method->ml_flags == (METH_FASTCALL|METH_KEYWORDS) &&
self_type == d_type) {
ADD_OP(_NOP, 0, 0);
}
}
else {
sym_set_type(callable, &PyMethodDescr_Type);
}
break;
}
case _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS: {
JitOptRef self_or_null;
JitOptRef callable;
self_or_null = stack_pointer[-1 - oparg];
callable = stack_pointer[-2 - oparg];
PyObject *callable_o = sym_get_const(ctx, callable);
if (callable_o && Py_IS_TYPE(callable_o, &PyMethodDescr_Type)
&& sym_is_not_null(self_or_null)) {
PyMethodDescrObject *method = (PyMethodDescrObject *)callable_o;
PyCFunction cfunc = method->d_method->ml_meth;
ADD_OP(_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_INLINE, oparg, (uintptr_t)cfunc);
}
callable = sym_new_not_null(ctx);
stack_pointer[-2 - oparg] = callable;
break;
}
case _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_INLINE: {
break;
}
case _GUARD_CALLABLE_METHOD_DESCRIPTOR_NOARGS: {
JitOptRef *args;
JitOptRef self_or_null;
JitOptRef callable;
args = &stack_pointer[-oparg];
self_or_null = stack_pointer[-1 - oparg];
callable = stack_pointer[-2 - oparg];
PyObject *callable_o = sym_get_const(ctx, callable);
if (callable_o && sym_matches_type(callable, &PyMethodDescr_Type) &&
(sym_is_not_null(self_or_null) || sym_is_null(self_or_null))) {
int total_args = oparg;
if (sym_is_not_null(self_or_null)) {
total_args++;
}
PyTypeObject *self_type = NULL;
if (sym_is_not_null(self_or_null)) {
self_type = sym_get_type(self_or_null);
}
else {
self_type = sym_get_type(args[0]);
}
PyTypeObject *d_type = ((PyMethodDescrObject *)callable_o)->d_common.d_type;
if (total_args == 1 &&
((PyMethodDescrObject *)callable_o)->d_method->ml_flags == METH_NOARGS &&
self_type == d_type) {
ADD_OP(_NOP, 0, 0);
}
}
else {
sym_set_type(callable, &PyMethodDescr_Type);
}
break;
}
case _CALL_METHOD_DESCRIPTOR_NOARGS: {
JitOptRef *args;
JitOptRef self_or_null;
JitOptRef callable;
JitOptRef res;
JitOptRef c;
JitOptRef s;
args = &stack_pointer[-oparg];
self_or_null = stack_pointer[-1 - oparg];
callable = stack_pointer[-2 - oparg];
PyObject *callable_o = sym_get_const(ctx, callable);
if (callable_o && Py_IS_TYPE(callable_o, &PyMethodDescr_Type)
&& sym_is_not_null(self_or_null)) {
PyMethodDescrObject *method = (PyMethodDescrObject *)callable_o;
PyCFunction cfunc = method->d_method->ml_meth;
ADD_OP(_CALL_METHOD_DESCRIPTOR_NOARGS_INLINE, oparg + 1, (uintptr_t)cfunc);
}
res = sym_new_not_null(ctx);
c = callable;
if (sym_is_not_null(self_or_null)) {
args--;
s = args[0];
}
else if (sym_is_null(self_or_null)) {
s = args[0];
}
else {
s = sym_new_unknown(ctx);
}
CHECK_STACK_BOUNDS(1 - oparg);
stack_pointer[-2 - oparg] = res;
stack_pointer[-1 - oparg] = c;
stack_pointer[-oparg] = s;
stack_pointer += 1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _CALL_METHOD_DESCRIPTOR_NOARGS_INLINE: {
JitOptRef res;
JitOptRef c;
JitOptRef s;
res = sym_new_not_null(ctx);
c = sym_new_not_null(ctx);
s = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(2 - oparg);
stack_pointer[-1 - oparg] = res;
stack_pointer[-oparg] = c;
stack_pointer[1 - oparg] = s;
stack_pointer += 2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST: {
JitOptRef *args;
JitOptRef self_or_null;
JitOptRef callable;
args = &stack_pointer[-oparg];
self_or_null = stack_pointer[-1 - oparg];
callable = stack_pointer[-2 - oparg];
PyObject *callable_o = sym_get_const(ctx, callable);
if (callable_o && sym_matches_type(callable, &PyMethodDescr_Type) &&
(sym_is_not_null(self_or_null) || sym_is_null(self_or_null))) {
int total_args = oparg;
if (sym_is_not_null(self_or_null)) {
total_args++;
}
PyTypeObject *self_type = NULL;
if (sym_is_not_null(self_or_null)) {
self_type = sym_get_type(self_or_null);
}
else {
self_type = sym_get_type(args[0]);
}
PyTypeObject *d_type = ((PyMethodDescrObject *)callable_o)->d_common.d_type;
if (total_args != 0 &&
((PyMethodDescrObject *)callable_o)->d_method->ml_flags == METH_FASTCALL &&
self_type == d_type) {
ADD_OP(_NOP, 0, 0);
}
}
else {
sym_set_type(callable, &PyMethodDescr_Type);
}
break;
}
case _CALL_METHOD_DESCRIPTOR_FAST: {
JitOptRef self_or_null;
JitOptRef callable;
self_or_null = stack_pointer[-1 - oparg];
callable = stack_pointer[-2 - oparg];
PyObject *callable_o = sym_get_const(ctx, callable);
if (callable_o && Py_IS_TYPE(callable_o, &PyMethodDescr_Type)
&& sym_is_not_null(self_or_null)) {
PyMethodDescrObject *method = (PyMethodDescrObject *)callable_o;
PyCFunction cfunc = method->d_method->ml_meth;
ADD_OP(_CALL_METHOD_DESCRIPTOR_FAST_INLINE, oparg, (uintptr_t)cfunc);
}
callable = sym_new_not_null(ctx);
stack_pointer[-2 - oparg] = callable;
break;
}
case _CALL_METHOD_DESCRIPTOR_FAST_INLINE: {
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: {
JitOptRef callable;
JitOptRef new_frame;
callable = stack_pointer[-3 - oparg];
new_frame = PyJitRef_WrapInvalid(frame_new_from_symbol(ctx, callable, NULL, 0));
CHECK_STACK_BOUNDS(-2 - oparg);
stack_pointer[-3 - oparg] = new_frame;
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _CHECK_FUNCTION_VERSION_KW: {
JitOptRef callable;
callable = stack_pointer[-3 - oparg];
uint32_t func_version = (uint32_t)this_instr->operand0;
PyObject *func = sym_get_probable_value(callable);
if (func == NULL || !PyFunction_Check(func) || ((PyFunctionObject *)func)->func_version != func_version) {
ctx->contradiction = true;
ctx->done = true;
break;
}
sym_set_const(callable, func);
_Py_BloomFilter_Add(dependencies, func);
break;
}
case _CHECK_METHOD_VERSION_KW: {
JitOptRef callable;
callable = stack_pointer[-3 - oparg];
uint32_t func_version = (uint32_t)this_instr->operand0;
if (sym_is_const(ctx, callable) && sym_matches_type(callable, &PyMethod_Type)) {
PyMethodObject *method = (PyMethodObject *)sym_get_const(ctx, callable);
assert(PyMethod_Check(method));
ADD_OP(_CHECK_FUNCTION_VERSION_INLINE, 0, func_version);
uop_buffer_last(&ctx->out_buffer)->operand1 = (uintptr_t)method->im_func;
}
else {
PyObject *bound_method = sym_get_probable_value(callable);
if (bound_method != NULL && Py_TYPE(bound_method) == &PyMethod_Type) {
PyMethodObject *method = (PyMethodObject *)bound_method;
PyObject *func = method->im_func;
if (PyFunction_Check(func) &&
((PyFunctionObject *)func)->func_version == func_version) {
_Py_BloomFilter_Add(dependencies, func);
sym_set_const(callable, bound_method);
}
}
}
sym_set_type(callable, &PyMethod_Type);
break;
}
case _EXPAND_METHOD_KW: {
JitOptRef self_or_null;
JitOptRef callable;
self_or_null = stack_pointer[-2 - oparg];
callable = stack_pointer[-3 - oparg];
if (sym_is_const(ctx, callable) && sym_matches_type(callable, &PyMethod_Type)) {
PyMethodObject *method = (PyMethodObject *)sym_get_const(ctx, callable);
callable = sym_new_const(ctx, method->im_func);
self_or_null = sym_new_const(ctx, method->im_self);
}
else {
callable = sym_new_not_null(ctx);
self_or_null = sym_new_not_null(ctx);
}
stack_pointer[-3 - oparg] = callable;
stack_pointer[-2 - oparg] = self_or_null;
break;
}
case _CHECK_IS_NOT_PY_CALLABLE_KW: {
JitOptRef callable;
callable = stack_pointer[-3 - oparg];
PyTypeObject *type = sym_get_type(callable);
if (type && type != &PyFunction_Type && type != &PyMethod_Type) {
ADD_OP(_NOP, 0, 0);
}
break;
}
case _CALL_KW_NON_PY: {
JitOptRef res;
res = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(-2 - oparg);
stack_pointer[-3 - oparg] = res;
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _MAKE_CALLARGS_A_TUPLE: {
break;
}
/* _DO_CALL_FUNCTION_EX is not a viable micro-op for tier 2 */
case _CHECK_IS_PY_CALLABLE_EX: {
break;
}
case _PY_FRAME_EX: {
JitOptRef func_st;
JitOptRef ex_frame;
func_st = stack_pointer[-4];
ex_frame = PyJitRef_WrapInvalid(frame_new_from_symbol(ctx, func_st, NULL, 0));
CHECK_STACK_BOUNDS(-3);
stack_pointer[-4] = ex_frame;
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _CHECK_IS_NOT_PY_CALLABLE_EX: {
JitOptRef func_st;
func_st = stack_pointer[-4];
PyTypeObject *type = sym_get_type(func_st);
if (type && type != &PyFunction_Type) {
ADD_OP(_NOP, 0, 0);
}
break;
}
case _CALL_FUNCTION_EX_NON_PY_GENERAL: {
JitOptRef result;
result = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(-3);
stack_pointer[-4] = result;
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _MAKE_FUNCTION: {
JitOptRef codeobj_st;
JitOptRef func;
JitOptRef co;
codeobj_st = stack_pointer[-1];
func = sym_new_type(ctx, &PyFunction_Type);
co = codeobj_st;
CHECK_STACK_BOUNDS(1);
stack_pointer[-1] = func;
stack_pointer[0] = co;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _SET_FUNCTION_ATTRIBUTE: {
JitOptRef func_out;
func_out = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(-1);
stack_pointer[-2] = func_out;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _RETURN_GENERATOR: {
JitOptRef res;
ctx->frame->stack_pointer = stack_pointer;
assert(this_instr[1].opcode == _RECORD_CODE);
PyCodeObject *returning_code = (PyCodeObject *)this_instr[1].operand0;
if (returning_code == NULL) {
ctx->done = true;
break;
}
assert(PyCode_Check(returning_code));
if (frame_pop(ctx, returning_code)) {
break;
}
stack_pointer = ctx->frame->stack_pointer;
res = sym_new_unknown(ctx);
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = res;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BUILD_SLICE: {
JitOptRef slice;
slice = sym_new_type(ctx, &PySlice_Type);
CHECK_STACK_BOUNDS(1 - oparg);
stack_pointer[-oparg] = slice;
stack_pointer += 1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _CONVERT_VALUE: {
JitOptRef result;
result = sym_new_not_null(ctx);
stack_pointer[-1] = result;
break;
}
case _FORMAT_SIMPLE: {
JitOptRef res;
res = sym_new_not_null(ctx);
stack_pointer[-1] = res;
break;
}
case _FORMAT_WITH_SPEC: {
JitOptRef res;
res = sym_new_not_null(ctx);
CHECK_STACK_BOUNDS(-1);
stack_pointer[-2] = res;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _COPY: {
JitOptRef bottom;
JitOptRef top;
bottom = stack_pointer[-1 - (oparg-1)];
assert(oparg > 0);
bottom = PyJitRef_RemoveUnique(bottom);
top = bottom;
CHECK_STACK_BOUNDS(1);
stack_pointer[-1 - (oparg-1)] = bottom;
stack_pointer[0] = top;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _BINARY_OP: {
JitOptRef rhs;
JitOptRef lhs;
JitOptRef res;
JitOptRef l;
JitOptRef r;
rhs = stack_pointer[-1];
lhs = stack_pointer[-2];
l = lhs;
r = rhs;
if (
sym_is_safe_const(ctx, lhs) &&
sym_is_safe_const(ctx, rhs)
) {
JitOptRef lhs_sym = lhs;
JitOptRef rhs_sym = rhs;
_PyStackRef lhs = sym_get_const_as_stackref(ctx, lhs_sym);
_PyStackRef rhs = sym_get_const_as_stackref(ctx, rhs_sym);
_PyStackRef res_stackref;
_PyStackRef l_stackref;
_PyStackRef r_stackref;
/* Start of uop copied from bytecodes for constant evaluation */
PyObject *lhs_o = PyStackRef_AsPyObjectBorrow(lhs);
PyObject *rhs_o = PyStackRef_AsPyObjectBorrow(rhs);
assert(_PyEval_BinaryOps[oparg]);
PyObject *res_o = _PyEval_BinaryOps[oparg](lhs_o, rhs_o);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
res_stackref = PyStackRef_FromPyObjectSteal(res_o);
l_stackref = lhs;
r_stackref = rhs;
/* End of uop copied from bytecodes for constant evaluation */
(void)l_stackref;
(void)r_stackref;
res = sym_new_const_steal(ctx, PyStackRef_AsPyObjectSteal(res_stackref));
if (sym_is_const(ctx, res)) {
PyObject *result = sym_get_const(ctx, res);
if (_Py_IsImmortal(result)) {
// Replace with _LOAD_CONST_INLINE_BORROW + _RROT_3 since we have two inputs and an immortal result
ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)result);
ADD_OP(_RROT_3, 0, 0);
}
}
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
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);
bool is_truediv = (oparg == NB_TRUE_DIVIDE
|| oparg == NB_INPLACE_TRUE_DIVIDE);
bool is_remainder = (oparg == NB_REMAINDER
|| oparg == NB_INPLACE_REMAINDER);
int emit_op = _BINARY_OP;
if (is_truediv || is_remainder) {
if (!sym_has_type(rhs)
&& sym_get_probable_type(rhs) == &PyFloat_Type) {
ADD_OP(_GUARD_TOS_FLOAT, 0, 0);
sym_set_type(rhs, &PyFloat_Type);
rhs_float = true;
}
if (!sym_has_type(lhs)
&& sym_get_probable_type(lhs) == &PyFloat_Type) {
ADD_OP(_GUARD_NOS_FLOAT, 0, 0);
sym_set_type(lhs, &PyFloat_Type);
lhs_float = true;
}
}
if (is_truediv && lhs_float && rhs_float) {
if (PyJitRef_IsUnique(lhs)) {
emit_op = _BINARY_OP_TRUEDIV_FLOAT_INPLACE;
l = sym_new_null(ctx);
r = rhs;
}
else if (PyJitRef_IsUnique(rhs)) {
emit_op = _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT;
l = lhs;
r = sym_new_null(ctx);
}
else {
emit_op = _BINARY_OP_TRUEDIV_FLOAT;
l = lhs;
r = rhs;
}
res = PyJitRef_MakeUnique(sym_new_type(ctx, &PyFloat_Type));
}
else if (is_truediv
&& (lhs_int || lhs_float) && (rhs_int || rhs_float)) {
res = PyJitRef_MakeUnique(sym_new_type(ctx, &PyFloat_Type));
}
else 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 = PyJitRef_MakeUnique(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 = PyJitRef_MakeUnique(sym_new_type(ctx, &PyFloat_Type));
}
else {
res = sym_new_type(ctx, &PyLong_Type);
}
}
else if (lhs_int && rhs_int) {
res = sym_new_type(ctx, &PyLong_Type);
}
else {
res = PyJitRef_MakeUnique(sym_new_type(ctx, &PyFloat_Type));
}
ADD_OP(emit_op, oparg, 0);
CHECK_STACK_BOUNDS(1);
stack_pointer[-2] = res;
stack_pointer[-1] = l;
stack_pointer[0] = r;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _SWAP: {
JitOptRef top;
JitOptRef bottom;
top = stack_pointer[-1];
bottom = stack_pointer[-2 - (oparg-2)];
JitOptRef 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: {
JitOptRef flag;
flag = stack_pointer[-1];
sym_apply_predicate_narrowing(ctx, flag, true);
if (sym_is_const(ctx, flag)) {
PyObject *value = sym_get_const(ctx, flag);
assert(value != NULL);
eliminate_pop_guard(this_instr, ctx, value != Py_True);
}
else {
int bit = get_test_bit_for_bools();
if (bit) {
REPLACE_OP(this_instr,
test_bit_set_in_true(bit) ?
_GUARD_BIT_IS_SET_POP :
_GUARD_BIT_IS_UNSET_POP, bit, 0);
}
}
sym_set_const(flag, Py_True);
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_IS_FALSE_POP: {
JitOptRef flag;
flag = stack_pointer[-1];
sym_apply_predicate_narrowing(ctx, flag, false);
if (sym_is_const(ctx, flag)) {
PyObject *value = sym_get_const(ctx, flag);
assert(value != NULL);
eliminate_pop_guard(this_instr, ctx, value != Py_False);
}
else {
int bit = get_test_bit_for_bools();
if (bit) {
REPLACE_OP(this_instr,
test_bit_set_in_true(bit) ?
_GUARD_BIT_IS_UNSET_POP :
_GUARD_BIT_IS_SET_POP, bit, 0);
}
}
sym_set_const(flag, Py_False);
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_BIT_IS_SET_POP: {
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_BIT_IS_UNSET_POP: {
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_IS_NONE_POP: {
JitOptRef 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, ctx, !Py_IsNone(value));
}
else if (sym_has_type(val)) {
assert(!sym_matches_type(val, &_PyNone_Type));
eliminate_pop_guard(this_instr, ctx, true);
}
sym_set_const(val, Py_None);
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _GUARD_IS_NOT_NONE_POP: {
JitOptRef 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, ctx, Py_IsNone(value));
}
else if (sym_has_type(val)) {
assert(!sym_matches_type(val, &_PyNone_Type));
eliminate_pop_guard(this_instr, ctx, false);
}
CHECK_STACK_BOUNDS(-1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
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;
break;
}
case _SAVE_RETURN_OFFSET: {
break;
}
case _EXIT_TRACE: {
PyObject *exit_p = (PyObject *)this_instr->operand0;
(void)exit_p;
ctx->done = true;
break;
}
case _DYNAMIC_EXIT: {
break;
}
case _CHECK_VALIDITY: {
break;
}
case _LOAD_CONST_INLINE: {
JitOptRef value;
PyObject *ptr = (PyObject *)this_instr->operand0;
value = sym_new_const(ctx, ptr);
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = value;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _LOAD_CONST_INLINE_BORROW: {
JitOptRef value;
PyObject *ptr = (PyObject *)this_instr->operand0;
value = PyJitRef_Borrow(sym_new_const(ctx, ptr));
CHECK_STACK_BOUNDS(1);
stack_pointer[0] = value;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
break;
}
case _RROT_3: {
JitOptRef top;
JitOptRef middle;
JitOptRef bottom;
top = stack_pointer[-1];
middle = stack_pointer[-2];
bottom = stack_pointer[-3];
JitOptRef temp = top;
top = middle;
middle = bottom;
bottom = temp;
stack_pointer[-3] = bottom;
stack_pointer[-2] = middle;
stack_pointer[-1] = top;
break;
}
case _START_EXECUTOR: {
break;
}
case _MAKE_WARM: {
break;
}
case _FATAL_ERROR: {
break;
}
case _DEOPT: {
ctx->done = true;
break;
}
case _HANDLE_PENDING_AND_DEOPT: {
break;
}
case _ERROR_POP_N: {
break;
}
case _SPILL_OR_RELOAD: {
break;
}
case _TIER2_RESUME_CHECK: {
break;
}
case _COLD_EXIT: {
break;
}
case _COLD_DYNAMIC_EXIT: {
break;
}
case _GUARD_CODE_VERSION__PUSH_FRAME: {
uint32_t version = (uint32_t)this_instr->operand0;
PyCodeObject *co = get_current_code_object(ctx);
if (co->co_version == version) {
_Py_BloomFilter_Add(dependencies, co);
PyFunctionObject *func = (PyFunctionObject *)sym_get_const(ctx, ctx->frame->callable);
if (func != NULL && func->func_version == version) {
REPLACE_OP(this_instr, _NOP, 0, 0);
}
}
else {
ctx->done = true;
}
break;
}
case _GUARD_CODE_VERSION_YIELD_VALUE: {
uint32_t version = (uint32_t)this_instr->operand0;
(void)version;
if (ctx->frame->caller) {
REPLACE_OP(this_instr, _NOP, 0, 0);
}
break;
}
case _GUARD_CODE_VERSION_RETURN_VALUE: {
uint32_t version = (uint32_t)this_instr->operand0;
(void)version;
if (ctx->frame->caller) {
REPLACE_OP(this_instr, _NOP, 0, 0);
}
break;
}
case _GUARD_CODE_VERSION_RETURN_GENERATOR: {
uint32_t version = (uint32_t)this_instr->operand0;
(void)version;
if (ctx->frame->caller) {
REPLACE_OP(this_instr, _NOP, 0, 0);
}
break;
}
case _GUARD_IP__PUSH_FRAME: {
PyObject *ip = (PyObject *)this_instr->operand0;
(void)ip;
stack_pointer = sym_set_stack_depth((int)this_instr->operand1, stack_pointer);
PyFunctionObject *func = (PyFunctionObject *)sym_get_const(ctx, ctx->frame->callable);
if (func != NULL && func->func_version != 0 &&
// We can remove this guard for simple function call targets.
(((PyCodeObject *)ctx->frame->func->func_code)->co_flags &
(CO_GENERATOR | CO_COROUTINE | CO_ASYNC_GENERATOR)) == 0) {
REPLACE_OP(this_instr, _NOP, 0, 0);
}
break;
}
case _GUARD_IP_YIELD_VALUE: {
PyObject *ip = (PyObject *)this_instr->operand0;
(void)ip;
if (ctx->frame->caller) {
REPLACE_OP(this_instr, _NOP, 0, 0);
}
stack_pointer = sym_set_stack_depth((int)this_instr->operand1, stack_pointer);
break;
}
case _GUARD_IP_RETURN_VALUE: {
PyObject *ip = (PyObject *)this_instr->operand0;
(void)ip;
if (ctx->frame->caller) {
REPLACE_OP(this_instr, _NOP, 0, 0);
}
stack_pointer = sym_set_stack_depth((int)this_instr->operand1, stack_pointer);
break;
}
case _GUARD_IP_RETURN_GENERATOR: {
PyObject *ip = (PyObject *)this_instr->operand0;
(void)ip;
if (ctx->frame->caller) {
REPLACE_OP(this_instr, _NOP, 0, 0);
}
stack_pointer = sym_set_stack_depth((int)this_instr->operand1, stack_pointer);
break;
}
case _RECORD_TOS: {
JitOptRef tos;
tos = stack_pointer[-1];
sym_set_recorded_value(tos, (PyObject *)this_instr->operand0);
break;
}
case _RECORD_TOS_TYPE: {
JitOptRef tos;
tos = stack_pointer[-1];
PyTypeObject *tp = (PyTypeObject *)this_instr->operand0;
sym_set_recorded_type(tos, tp);
break;
}
case _RECORD_NOS: {
JitOptRef nos;
nos = stack_pointer[-2];
sym_set_recorded_value(nos, (PyObject *)this_instr->operand0);
break;
}
case _RECORD_NOS_TYPE: {
JitOptRef nos;
nos = stack_pointer[-2];
PyTypeObject *tp = (PyTypeObject *)this_instr->operand0;
sym_set_recorded_type(nos, tp);
break;
}
case _RECORD_NOS_GEN_FUNC: {
JitOptRef nos;
nos = stack_pointer[-2];
PyFunctionObject *func = (PyFunctionObject *)this_instr->operand0;
assert(func == NULL || PyFunction_Check(func));
sym_set_recorded_gen_func(nos, func);
break;
}
case _RECORD_3OS_GEN_FUNC: {
JitOptRef gen;
gen = stack_pointer[-3];
PyFunctionObject *func = (PyFunctionObject *)this_instr->operand0;
assert(func == NULL || PyFunction_Check(func));
sym_set_recorded_gen_func(gen, func);
break;
}
case _RECORD_4OS: {
JitOptRef value;
value = stack_pointer[-4];
sym_set_recorded_value(value, (PyObject *)this_instr->operand0);
break;
}
case _RECORD_CALLABLE: {
JitOptRef func;
func = stack_pointer[-2 - oparg];
sym_set_recorded_value(func, (PyObject *)this_instr->operand0);
break;
}
case _RECORD_CALLABLE_KW: {
JitOptRef func;
func = stack_pointer[-3 - oparg];
sym_set_recorded_value(func, (PyObject *)this_instr->operand0);
break;
}
case _RECORD_BOUND_METHOD: {
JitOptRef callable;
callable = stack_pointer[-2 - oparg];
sym_set_recorded_value(callable, (PyObject *)this_instr->operand0);
break;
}
case _RECORD_CODE: {
break;
}
/* _TRACE_RECORD is not a viable micro-op for tier 2 */