#include "Python.h"

#include "pycore_optimizer.h"

#include "pycore_uops.h"

#include "pycore_uop_ids.h"

#include "internal/pycore_moduleobject.h"

#define op(name, ...) /* NAME is ignored */

typedef struct _Py_UOpsAbstractFrame _Py_UOpsAbstractFrame;

#define sym_is_not_null _Py_uop_sym_is_not_null

#define sym_is_const _Py_uop_sym_is_const

#define sym_get_const _Py_uop_sym_get_const

#define sym_new_unknown _Py_uop_sym_new_unknown

#define sym_new_not_null _Py_uop_sym_new_not_null

#define sym_new_type _Py_uop_sym_new_type

#define sym_is_null _Py_uop_sym_is_null

#define sym_new_const _Py_uop_sym_new_const

#define sym_new_null _Py_uop_sym_new_null

#define sym_matches_type _Py_uop_sym_matches_type

#define sym_matches_type_version _Py_uop_sym_matches_type_version

#define sym_get_type _Py_uop_sym_get_type

#define sym_has_type _Py_uop_sym_has_type

#define sym_set_null(SYM) _Py_uop_sym_set_null(ctx, SYM)

#define sym_set_non_null(SYM) _Py_uop_sym_set_non_null(ctx, SYM)

#define sym_set_type(SYM, TYPE) _Py_uop_sym_set_type(ctx, SYM, TYPE)

#define sym_set_type_version(SYM, VERSION) _Py_uop_sym_set_type_version(ctx, SYM, VERSION)

#define sym_set_const(SYM, CNST) _Py_uop_sym_set_const(ctx, SYM, CNST)

#define sym_set_compact_int(SYM) _Py_uop_sym_set_compact_int(ctx, SYM)

#define sym_is_bottom _Py_uop_sym_is_bottom

#define frame_new _Py_uop_frame_new

#define frame_new_from_symbol _Py_uop_frame_new_from_symbol

#define frame_pop _Py_uop_frame_pop

#define sym_new_tuple _Py_uop_sym_new_tuple

#define sym_tuple_getitem _Py_uop_sym_tuple_getitem

#define sym_tuple_length _Py_uop_sym_tuple_length

#define sym_is_immortal _Py_uop_symbol_is_immortal

#define sym_new_compact_int _Py_uop_sym_new_compact_int

#define sym_is_compact_int _Py_uop_sym_is_compact_int

#define sym_new_truthiness _Py_uop_sym_new_truthiness

#define sym_new_predicate _Py_uop_sym_new_predicate

#define sym_apply_predicate_narrowing _Py_uop_sym_apply_predicate_narrowing

#define sym_set_recorded_type(SYM, TYPE) _Py_uop_sym_set_recorded_type(ctx, SYM, TYPE)

#define sym_set_recorded_value(SYM, VAL) _Py_uop_sym_set_recorded_value(ctx, SYM, VAL)

#define sym_set_recorded_gen_func(SYM, VAL) _Py_uop_sym_set_recorded_gen_func(ctx, SYM, VAL)

#define sym_get_probable_func_code _Py_uop_sym_get_probable_func_code

#define sym_get_probable_value _Py_uop_sym_get_probable_value

#define sym_get_probable_type _Py_uop_sym_get_probable_type

#define sym_set_stack_depth(DEPTH, SP) _Py_uop_sym_set_stack_depth(ctx, DEPTH, SP)

extern int

optimize_to_bool(

bool insert_mode);

extern void

eliminate_pop_guard(_PyUOpInstruction *this_instr, JitOptContext *ctx, bool exit);

extern PyCodeObject *get_code(_PyUOpInstruction *op);

static int

dummy_func(void) {

PyCodeObject *co;

int oparg;

JitOptSymbol *flag;

JitOptSymbol *left;

JitOptSymbol *right;

JitOptSymbol *value;

JitOptSymbol *res;

JitOptSymbol *iter;

JitOptSymbol *top;

JitOptSymbol *bottom;

_Py_UOpsAbstractFrame *frame;

_Py_UOpsAbstractFrame *new_frame;

JitOptContext *ctx;

_PyUOpInstruction *this_instr;

_PyBloomFilter *dependencies;

int modified;

int curr_space;

int max_space;

_PyUOpInstruction *first_valid_check_stack;

_PyUOpInstruction *corresponding_check_stack;

op(_MAKE_HEAP_SAFE, (value -- value)) {

// eliminate _MAKE_HEAP_SAFE when we *know* the value is immortal

if (sym_is_immortal(PyJitRef_Unwrap(value))) {

ADD_OP(_NOP, 0, 0);

}

value = PyJitRef_StripBorrowInfo(value);

}

op(_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);

}

}

op(_LOAD_FAST_CHECK, (-- value)) {

value = GETLOCAL(oparg);

// We guarantee this will error - just bail and don't optimize it.

if (sym_is_null(value)) {

ctx->done = true;

}

assert(!PyJitRef_IsUnique(value));

}

op(_LOAD_FAST, (-- value)) {

value = GETLOCAL(oparg);

assert(!PyJitRef_IsUnique(value));

}

op(_LOAD_FAST_BORROW, (-- value)) {

value = PyJitRef_Borrow(GETLOCAL(oparg));

assert(!PyJitRef_IsUnique(value));

}

op(_LOAD_FAST_AND_CLEAR, (-- value)) {

value = GETLOCAL(oparg);

JitOptRef temp = sym_new_null(ctx);

GETLOCAL(oparg) = temp;

assert(!PyJitRef_IsUnique(value));

}

op(_STORE_ATTR_INSTANCE_VALUE, (offset/1, value, owner -- o)) {

(void)offset;

(void)value;

o = owner;

}

op(_STORE_ATTR_WITH_HINT, (hint/1, value, owner -- o)) {

(void)hint;

(void)value;

o = owner;

}

op(_SWAP_FAST, (value -- trash)) {

JitOptRef tmp = GETLOCAL(oparg);

GETLOCAL(oparg) = PyJitRef_RemoveUnique(value);

trash = tmp;

}

op(_STORE_SUBSCR_LIST_INT, (value, list_st, sub_st -- ls, ss)) {

(void)value;

ls = list_st;

ss = sub_st;

}

op(_STORE_ATTR_SLOT, (index/1, value, owner -- o)) {

(void)index;

(void)value;

o = owner;

}

op(_STORE_SUBSCR_DICT, (value, dict_st, sub -- st)) {

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;

}

op(_PUSH_NULL, (-- res)) {

res = PyJitRef_Borrow(sym_new_null(ctx));

}

op(_GUARD_TOS_INT, (value -- value)) {

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);

}

}

op(_GUARD_NOS_INT, (left, unused -- left, unused)) {

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);

}

}

op(_CHECK_ATTR_CLASS, (type_version/2, owner -- owner)) {

PyObject *type = (PyObject *)_PyType_LookupByVersion(type_version);

if (type) {

if (type == sym_get_const(ctx, owner)) {

ADD_OP(_NOP, 0, 0);

}

else {

sym_set_const(owner, type);

}

}

}

op(_GUARD_TYPE_VERSION, (type_version/2, owner -- owner)) {

assert(type_version);

assert(this_instr[-1].opcode == _RECORD_TOS_TYPE);

if (sym_matches_type_version(owner, type_version)) {

ADD_OP(_NOP, 0, 0);

} else {

// add watcher so that whenever the type changes we invalidate this

PyTypeObject *type = _PyType_LookupByVersion(type_version);

// if the type is null, it was not found in the cache (there was a conflict)

// with the key, in which case we can't trust the version

if (type) {

// if the type version was set properly, then add a watcher

// if it wasn't this means that the type version was previously set to something else

// and we set the owner to bottom, so we don't need to add a watcher because we must have

// already added one earlier.

if (sym_set_type_version(owner, type_version)) {

PyType_Watch(TYPE_WATCHER_ID, (PyObject *)type);

_Py_BloomFilter_Add(dependencies, type);

}

}

}

}

op(_GUARD_TOS_FLOAT, (value -- value)) {

if (sym_matches_type(value, &PyFloat_Type)) {

ADD_OP(_NOP, 0, 0);

}

sym_set_type(value, &PyFloat_Type);

}

op(_GUARD_NOS_FLOAT, (left, unused -- left, unused)) {

if (sym_matches_type(left, &PyFloat_Type)) {

ADD_OP(_NOP, 0, 0);

}

sym_set_type(left, &PyFloat_Type);

}

op(_BINARY_OP, (lhs, rhs -- res, l, r)) {

l = lhs;

r = rhs;

REPLACE_OPCODE_IF_EVALUATES_PURE(lhs, rhs, res);

bool lhs_int = sym_matches_type(lhs, &PyLong_Type);

bool rhs_int = sym_matches_type(rhs, &PyLong_Type);

bool lhs_float = sym_matches_type(lhs, &PyFloat_Type);

bool rhs_float = sym_matches_type(rhs, &PyFloat_Type);

if (!((lhs_int || lhs_float) && (rhs_int || rhs_float))) {

// There's something other than an int or float involved:

res = sym_new_unknown(ctx);

}

else if (oparg == NB_POWER || oparg == NB_INPLACE_POWER) {

// This one's fun... the *type* of the result depends on the

// *values* being exponentiated. However, exponents with one

// constant part are reasonably common, so it's probably worth

// trying to infer some simple cases:

// - A: 1 ** 1 -> 1 (int ** int -> int)

// - B: 1 ** -1 -> 1.0 (int ** int -> float)

// - C: 1.0 ** 1 -> 1.0 (float ** int -> float)

// - D: 1 ** 1.0 -> 1.0 (int ** float -> float)

// - E: -1 ** 0.5 ~> 1j (int ** float -> complex)

// - F: 1.0 ** 1.0 -> 1.0 (float ** float -> float)

// - G: -1.0 ** 0.5 ~> 1j (float ** float -> complex)

if (rhs_float) {

// Case D, E, F, or G... can't know without the sign of the LHS

// or whether the RHS is whole, which isn't worth the effort:

res = sym_new_unknown(ctx);

}

else if (lhs_float) {

// Case C:

res = sym_new_type(ctx, &PyFloat_Type);

}

else if (!sym_is_const(ctx, rhs)) {

// Case A or B... can't know without the sign of the RHS:

res = sym_new_unknown(ctx);

}

else if (_PyLong_IsNegative((PyLongObject *)sym_get_const(ctx, rhs))) {

// Case B:

res = sym_new_type(ctx, &PyFloat_Type);

}

else {

// Case A:

res = sym_new_type(ctx, &PyLong_Type);

}

}

else if (oparg == NB_TRUE_DIVIDE || oparg == NB_INPLACE_TRUE_DIVIDE) {

res = sym_new_type(ctx, &PyFloat_Type);

}

else if (lhs_int && rhs_int) {

res = sym_new_type(ctx, &PyLong_Type);

}

else {

res = sym_new_type(ctx, &PyFloat_Type);

}

}

op(_BINARY_OP_ADD_INT, (left, right -- res, l, r)) {

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);

}

// Result may be a unique compact int or a cached small int

// at runtime. Mark as unique; inplace ops verify at runtime.

res = PyJitRef_MakeUnique(sym_new_compact_int(ctx));

l = left;

r = right;

REPLACE_OPCODE_IF_EVALUATES_PURE(left, right, res);

}

op(_BINARY_OP_SUBTRACT_INT, (left, right -- res, l, r)) {

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;

REPLACE_OPCODE_IF_EVALUATES_PURE(left, right, res);

}

op(_BINARY_OP_MULTIPLY_INT, (left, right -- res, l, r)) {

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;

REPLACE_OPCODE_IF_EVALUATES_PURE(left, right, res);

}

op(_BINARY_OP_ADD_FLOAT, (left, right -- res, l, r)) {

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));

}

op(_BINARY_OP_SUBTRACT_FLOAT, (left, right -- res, l, r)) {

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));

}

op(_BINARY_OP_MULTIPLY_FLOAT, (left, right -- res, l, r)) {

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));

}

op(_BINARY_OP_ADD_UNICODE, (left, right -- res, l, r)) {

res = sym_new_type(ctx, &PyUnicode_Type);

l = left;

r = right;

}

op(_BINARY_OP_EXTEND, (descr/4, left, right -- res, l, r)) {

_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;

}

op(_BINARY_OP_INPLACE_ADD_UNICODE, (left, right -- res)) {

if (sym_is_const(ctx, left) && sym_is_const(ctx, right)) {

assert(PyUnicode_CheckExact(sym_get_const(ctx, left)));

assert(PyUnicode_CheckExact(sym_get_const(ctx, right)));

PyObject *temp = PyUnicode_Concat(sym_get_const(ctx, left), sym_get_const(ctx, right));

if (temp == NULL) {

goto error;

}

res = sym_new_const(ctx, temp);

Py_DECREF(temp);

}

else {

res = sym_new_type(ctx, &PyUnicode_Type);

}

GETLOCAL(this_instr->operand0) = sym_new_null(ctx);

}

op(_BINARY_OP_SUBSCR_CHECK_FUNC, (container, unused -- container, unused, getitem)) {

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);

}

}

op(_BINARY_OP_SUBSCR_INIT_CALL, (container, sub, getitem -- new_frame)) {

_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);

}

op(_BINARY_OP_SUBSCR_STR_INT, (str_st, sub_st -- res, s, i)) {

res = sym_new_type(ctx, &PyUnicode_Type);

s = str_st;

i = sub_st;

}

op(_BINARY_OP_SUBSCR_USTR_INT, (str_st, sub_st -- res, s, i)) {

res = sym_new_type(ctx, &PyUnicode_Type);

s = str_st;

i = sub_st;

}

op(_GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS, (tuple_st, sub_st -- tuple_st, sub_st)) {

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);

}

}

}

op(_BINARY_OP_SUBSCR_TUPLE_INT, (tuple_st, sub_st -- res, ts, ss)) {

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) {

// Unknown length

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;

}

op(_BINARY_OP_SUBSCR_DICT, (dict_st, sub_st -- res, ds, ss)) {

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)) {

REPLACE_OPCODE_IF_EVALUATES_PURE(dict_st, sub_st, res);

}

else if (sub != NULL) {

optimize_dict_known_hash(ctx, dependencies, this_instr,

sub, _BINARY_OP_SUBSCR_DICT_KNOWN_HASH);

}

}

op(_BINARY_OP_SUBSCR_LIST_SLICE, (list_st, sub_st -- res, ls, ss)) {

res = sym_new_type(ctx, &PyList_Type);

ls = list_st;

ss = sub_st;

}

op(_TO_BOOL, (value -- res)) {

int already_bool = optimize_to_bool(this_instr, ctx, value, &res,

_POP_TOP, _LOAD_CONST_INLINE_BORROW);

if (!already_bool) {

res = sym_new_truthiness(ctx, value, true);

}

}

op(_TO_BOOL_BOOL, (value -- value)) {

int already_bool = optimize_to_bool(this_instr, ctx, value, &value,

_POP_TOP, _LOAD_CONST_INLINE_BORROW);

if (!already_bool) {

sym_set_type(value, &PyBool_Type);

}

}

op(_TO_BOOL_INT, (value -- res, v)) {

int already_bool = optimize_to_bool(this_instr, ctx, value, &res,

_NOP, _INSERT_1_LOAD_CONST_INLINE_BORROW);

if (!already_bool) {

sym_set_type(value, &PyLong_Type);

res = sym_new_truthiness(ctx, value, true);

}

v = value;

}

op(_TO_BOOL_LIST, (value -- res, v)) {

int already_bool = optimize_to_bool(this_instr, ctx, value, &res,

_NOP, _INSERT_1_LOAD_CONST_INLINE_BORROW);

if (!already_bool) {

res = sym_new_type(ctx, &PyBool_Type);

}

v = value;

}

op(_TO_BOOL_NONE, (value -- res)) {

int already_bool = optimize_to_bool(this_instr, ctx, value, &res,

_POP_TOP, _LOAD_CONST_INLINE_BORROW);

if (!already_bool) {

sym_set_const(value, Py_None);

res = sym_new_const(ctx, Py_False);

}

}

op(_GUARD_NOS_UNICODE, (nos, unused -- nos, unused)) {

if (sym_matches_type(nos, &PyUnicode_Type)) {

ADD_OP(_NOP, 0, 0);

}

sym_set_type(nos, &PyUnicode_Type);

}

op(_GUARD_NOS_COMPACT_ASCII, (nos, unused -- nos, unused)) {

sym_set_type(nos, &PyUnicode_Type);

}

op(_GUARD_TOS_UNICODE, (value -- value)) {

if (sym_matches_type(value, &PyUnicode_Type)) {

ADD_OP(_NOP, 0, 0);

}

sym_set_type(value, &PyUnicode_Type);

}

op(_TO_BOOL_STR, (value -- res, v)) {

int already_bool = optimize_to_bool(this_instr, ctx, value, &res,

_NOP, _INSERT_1_LOAD_CONST_INLINE_BORROW);

v = value;

if (!already_bool) {

res = sym_new_truthiness(ctx, value, true);

}

}

op(_UNARY_NOT, (value -- res)) {

REPLACE_OPCODE_IF_EVALUATES_PURE(value, res);

sym_set_type(value, &PyBool_Type);

res = sym_new_truthiness(ctx, value, false);

}

op(_UNARY_NEGATIVE, (value -- res, v)) {

v = value;

REPLACE_OPCODE_IF_EVALUATES_PURE(value, res);

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);

}

}

}

op(_UNARY_INVERT, (value -- res, v)) {

v = value;

// Required to avoid a warning due to the deprecation of bitwise inversion of bools

if (!sym_matches_type(value, &PyBool_Type)) {

REPLACE_OPCODE_IF_EVALUATES_PURE(value, res);

}

if (sym_matches_type(value, &PyLong_Type)) {

res = sym_new_type(ctx, &PyLong_Type);

}

else {

res = sym_new_not_null(ctx);

}

}

op(_COMPARE_OP, (left, right -- res)) {

// Comparison between bytes and str or int is not impacted by this optimization as bytes

// is not a safe type (due to its ability to raise a warning during comparisons).

REPLACE_OPCODE_IF_EVALUATES_PURE(left, right, res);

if (oparg & 16) {

res = sym_new_type(ctx, &PyBool_Type);

}

else {

res = _Py_uop_sym_new_not_null(ctx);

}

}

op(_COMPARE_OP_INT, (left, right -- res, l, r)) {

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;

REPLACE_OPCODE_IF_EVALUATES_PURE(left, right, res);

}

op(_COMPARE_OP_FLOAT, (left, right -- res, l, r)) {

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;

REPLACE_OPCODE_IF_EVALUATES_PURE(left, right, res);

}

op(_COMPARE_OP_STR, (left, right -- res, l, r)) {

/* Cannot use predicate optimization here, as `a == b`

res = sym_new_type(ctx, &PyBool_Type);

l = left;

r = right;

REPLACE_OPCODE_IF_EVALUATES_PURE(left, right, res);

}

op(_IS_OP, (left, right -- b, l, r)) {

b = sym_new_predicate(ctx, left, right, (oparg ? JIT_PRED_IS_NOT : JIT_PRED_IS));

l = left;

r = right;

}

op(_CONTAINS_OP, (left, right -- b, l, r)) {

b = sym_new_type(ctx, &PyBool_Type);

l = left;

r = right;

REPLACE_OPCODE_IF_EVALUATES_PURE(left, right, b);

}

op(_CONTAINS_OP_SET, (left, right -- b, l, r)) {

b = sym_new_type(ctx, &PyBool_Type);

l = left;

r = right;

if (sym_is_not_container(left) &&

sym_matches_type(right, &PyFrozenSet_Type)) {

REPLACE_OPCODE_IF_EVALUATES_PURE(left, right, b);

}

}

op(_CONTAINS_OP_DICT, (left, right -- b, l, r)) {

b = sym_new_type(ctx, &PyBool_Type);

l = left;

r = right;

}

op(_LOAD_CONST, (-- 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));

}

op(_LOAD_COMMON_CONSTANT, (-- value)) {

assert(oparg < NUM_COMMON_CONSTANTS);

PyObject *val = _PyInterpreterState_GET()->common_consts[oparg];

ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)val);

value = PyJitRef_Borrow(sym_new_const(ctx, val));

}

op(_LOAD_SMALL_INT, (-- 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));

}

op(_LOAD_CONST_INLINE, (ptr/4 -- value)) {

value = sym_new_const(ctx, ptr);

}

op(_LOAD_CONST_INLINE_BORROW, (ptr/4 -- value)) {

value = PyJitRef_Borrow(sym_new_const(ctx, ptr));

}

op(_POP_CALL_LOAD_CONST_INLINE_BORROW, (ptr/4, unused, unused -- value)) {

value = PyJitRef_Borrow(sym_new_const(ctx, ptr));

}

op(_POP_CALL_TWO_LOAD_CONST_INLINE_BORROW, (ptr/4, unused, unused, unused, unused -- value)) {

value = PyJitRef_Borrow(sym_new_const(ctx, ptr));

}

op(_SHUFFLE_2_LOAD_CONST_INLINE_BORROW, (ptr/4, unused, unused, arg -- res, a)) {

res = PyJitRef_Borrow(sym_new_const(ctx, ptr));

a = arg;

}

op(_POP_TOP, (value -- )) {

PyTypeObject *typ = sym_get_type(value);

if (PyJitRef_IsBorrowed(value) ||

sym_is_immortal(PyJitRef_Unwrap(value)) ||

sym_is_null(value)) {

ADD_OP(_POP_TOP_NOP, 0, 0);

}

else if (typ == &PyLong_Type) {

ADD_OP(_POP_TOP_INT, 0, 0);

}

else if (typ == &PyFloat_Type) {

ADD_OP(_POP_TOP_FLOAT, 0, 0);

}

else if (typ == &PyUnicode_Type) {

ADD_OP(_POP_TOP_UNICODE, 0, 0);

}

}

op(_POP_TOP_INT, (value --)) {

if (PyJitRef_IsBorrowed(value)) {

ADD_OP(_POP_TOP_NOP, 0, 0);

}

}

op(_POP_TOP_FLOAT, (value --)) {

if (PyJitRef_IsBorrowed(value)) {

ADD_OP(_POP_TOP_NOP, 0, 0);

}

}

op(_POP_TOP_UNICODE, (value --)) {

if (PyJitRef_IsBorrowed(value)) {

ADD_OP(_POP_TOP_NOP, 0, 0);

}

}

op(_COPY, (bottom, unused[oparg-1] -- bottom, unused[oparg-1], top)) {

assert(oparg > 0);

bottom = PyJitRef_RemoveUnique(bottom);

top = bottom;

}

op(_SWAP, (bottom, unused[oparg-2], top -- bottom, unused[oparg-2], top)) {

JitOptRef temp = bottom;

bottom = top;

top = temp;

assert(oparg >= 2);

}

op(_LOAD_ATTR_INSTANCE_VALUE, (offset/1, owner -- attr, o)) {

attr = sym_new_not_null(ctx);

(void)offset;

o = owner;

}

op(_LOAD_ATTR_MODULE, (dict_version/2, index/1, owner -- attr, o)) {

(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;

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,

_INSERT_1_LOAD_CONST_INLINE_BORROW, _INSERT_1_LOAD_CONST_INLINE);

if (res == NULL) {

attr = sym_new_not_null(ctx);

}

else {

attr = sym_new_const(ctx, res);

}

}

}

}

if (PyJitRef_IsNull(attr)) {

/* No conversion made. We don't know what `attr` is. */

attr = sym_new_not_null(ctx);

}

o = owner;

}

op (_PUSH_NULL_CONDITIONAL, ( -- null[oparg & 1])) {

if (oparg & 1) {

ADD_OP(_PUSH_NULL, 0, 0);

null[0] = sym_new_null(ctx);

}

else {

ADD_OP(_NOP, 0, 0);

}

}

op(_LOAD_ATTR, (owner -- attr, self_or_null[oparg&1])) {

(void)owner;

attr = sym_new_not_null(ctx);

if (oparg & 1) {

self_or_null[0] = sym_new_unknown(ctx);

}

}

op(_LOAD_ATTR_WITH_HINT, (hint/1, owner -- attr, o)) {

attr = sym_new_not_null(ctx);

(void)hint;

o = owner;

}

op(_LOAD_ATTR_SLOT, (index/1, owner -- attr, o)) {

attr = sym_new_not_null(ctx);

(void)index;

o = owner;

}

op(_LOAD_ATTR_CLASS, (descr/4, owner -- attr)) {

(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, _LOAD_CONST_INLINE_BORROW, _LOAD_CONST_INLINE);

}

op(_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES, (descr/4, owner -- attr)) {

(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, _LOAD_CONST_INLINE_BORROW, _LOAD_CONST_INLINE);

}

op(_LOAD_ATTR_NONDESCRIPTOR_NO_DICT, (descr/4, owner -- attr)) {

(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, _LOAD_CONST_INLINE_BORROW, _LOAD_CONST_INLINE);

}

op(_LOAD_ATTR_METHOD_WITH_VALUES, (descr/4, owner -- attr, self)) {

(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, _INSERT_1_LOAD_CONST_INLINE_BORROW, _INSERT_1_LOAD_CONST_INLINE);

self = owner;

}

op(_LOAD_ATTR_METHOD_NO_DICT, (descr/4, owner -- attr, self)) {

(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, _INSERT_1_LOAD_CONST_INLINE_BORROW, _INSERT_1_LOAD_CONST_INLINE);

self = owner;

}

op(_LOAD_ATTR_METHOD_LAZY_DICT, (descr/4, owner -- attr, self)) {

(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, _INSERT_1_LOAD_CONST_INLINE_BORROW, _INSERT_1_LOAD_CONST_INLINE);

self = owner;

}

op(_GUARD_LOAD_SUPER_ATTR_METHOD, (global_super_st, class_st, unused -- global_super_st, class_st, unused)) {

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);

// not known, but has a probable type, promote the probable type

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);

}

}

op(_LOAD_SUPER_ATTR_METHOD, (global_super_st, class_st, self_st -- attr, self_or_null)) {

self_or_null = self_st;

PyTypeObject *su_type = (PyTypeObject *)sym_get_const(ctx, class_st);

PyTypeObject *obj_type = sym_get_type(self_st);

PyObject *name = get_co_name(ctx, oparg >> 2);

attr = lookup_super_attr(ctx, dependencies, this_instr,

su_type, obj_type, name,

_INSERT_1_LOAD_CONST_INLINE_BORROW,

_INSERT_1_LOAD_CONST_INLINE);

}

op(_LOAD_ATTR_PROPERTY_FRAME, (fget/4, owner -- new_frame)) {

// + 1 for _SAVE_RETURN_OFFSET

// FIX ME -- This needs a version check and function watcher

PyCodeObject *co = (PyCodeObject *)((PyFunctionObject *)fget)->func_code;

_Py_UOpsAbstractFrame *f = frame_new(ctx, co, NULL, 0);

if (f == NULL) {

break;

}

f->locals[0] = owner;

new_frame = PyJitRef_WrapInvalid(f);

}

op(_INIT_CALL_BOUND_METHOD_EXACT_ARGS, (callable, self_or_null, unused[oparg] -- callable, self_or_null, unused[oparg])) {

callable = sym_new_not_null(ctx);

self_or_null = sym_new_not_null(ctx);

}

op(_CHECK_FUNCTION_VERSION, (func_version/2, callable, self_or_null, unused[oparg] -- callable, self_or_null, unused[oparg])) {

if (sym_get_func_version(callable) == func_version) {

REPLACE_OP(this_instr, _NOP, 0, 0);

}

else {

sym_set_func_version(ctx, callable, func_version);

}

}

op(_CHECK_METHOD_VERSION, (func_version/2, callable, null, unused[oparg] -- callable, null, unused[oparg])) {