GH-128939: Refactor JIT optimize structs (GH-128940)

1 files changed, 291 insertions, 285 deletions

diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h
index 1f2b29c9474..fa0b4ed4345 100644
--- a/Python/optimizer_cases.c.h
+++ b/Python/optimizer_cases.c.h
@@ -26,7 +26,7 @@
         /* _MONITOR_RESUME is not a viable micro-op for tier 2 */
 
         case _LOAD_FAST_CHECK: {
-            _Py_UopsSymbol *value;
+            JitOptSymbol *value;
             value = GETLOCAL(oparg);
             // We guarantee this will error - just bail and don't optimize it.
             if (sym_is_null(value)) {
@@ -39,7 +39,7 @@
         }
 
         case _LOAD_FAST: {
-            _Py_UopsSymbol *value;
+            JitOptSymbol *value;
             value = GETLOCAL(oparg);
             stack_pointer[0] = value;
             stack_pointer += 1;
@@ -48,9 +48,9 @@
         }
 
         case _LOAD_FAST_AND_CLEAR: {
-            _Py_UopsSymbol *value;
+            JitOptSymbol *value;
             value = GETLOCAL(oparg);
-            _Py_UopsSymbol *temp = sym_new_null(ctx);
+            JitOptSymbol *temp = sym_new_null(ctx);
             GETLOCAL(oparg) = temp;
             stack_pointer[0] = value;
             stack_pointer += 1;
@@ -61,7 +61,7 @@
         /* _LOAD_CONST is not a viable micro-op for tier 2 */
 
         case _LOAD_CONST_MORTAL: {
-            _Py_UopsSymbol *value;
+            JitOptSymbol *value;
             PyObject *val = PyTuple_GET_ITEM(co->co_consts, this_instr->oparg);
             int opcode = _Py_IsImmortal(val) ? _LOAD_CONST_INLINE_BORROW : _LOAD_CONST_INLINE;
             REPLACE_OP(this_instr, opcode, 0, (uintptr_t)val);
@@ -73,7 +73,7 @@
         }
 
         case _LOAD_CONST_IMMORTAL: {
-            _Py_UopsSymbol *value;
+            JitOptSymbol *value;
             PyObject *val = PyTuple_GET_ITEM(co->co_consts, this_instr->oparg);
             REPLACE_OP(this_instr, _LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)val);
             value = sym_new_const(ctx, val);
@@ -84,7 +84,7 @@
         }
 
         case _LOAD_SMALL_INT: {
-            _Py_UopsSymbol *value;
+            JitOptSymbol *value;
             PyObject *val = PyLong_FromLong(this_instr->oparg);
             value = sym_new_const(ctx, val);
             stack_pointer[0] = value;
@@ -94,7 +94,7 @@
         }
 
         case _STORE_FAST: {
-            _Py_UopsSymbol *value;
+            JitOptSymbol *value;
             value = stack_pointer[-1];
             GETLOCAL(oparg) = value;
             stack_pointer += -1;
@@ -109,7 +109,7 @@
         }
 
         case _PUSH_NULL: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_null(ctx);
             stack_pointer[0] = res;
             stack_pointer += 1;
@@ -124,7 +124,7 @@
         }
 
         case _END_SEND: {
-            _Py_UopsSymbol *val;
+            JitOptSymbol *val;
             val = sym_new_not_null(ctx);
             stack_pointer[-2] = val;
             stack_pointer += -1;
@@ -133,22 +133,22 @@
         }
 
         case _UNARY_NEGATIVE: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-1] = res;
             break;
         }
 
         case _UNARY_NOT: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-1] = res;
             break;
         }
 
         case _TO_BOOL: {
-            _Py_UopsSymbol *value;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *value;
+            JitOptSymbol *res;
             value = stack_pointer[-1];
             if (!optimize_to_bool(this_instr, ctx, value, &res)) {
                 res = sym_new_type(ctx, &PyBool_Type);
@@ -158,8 +158,8 @@
         }
 
         case _TO_BOOL_BOOL: {
-            _Py_UopsSymbol *value;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *value;
+            JitOptSymbol *res;
             value = stack_pointer[-1];
             if (!optimize_to_bool(this_instr, ctx, value, &res)) {
                 sym_set_type(value, &PyBool_Type);
@@ -170,8 +170,8 @@
         }
 
         case _TO_BOOL_INT: {
-            _Py_UopsSymbol *value;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *value;
+            JitOptSymbol *res;
             value = stack_pointer[-1];
             if (!optimize_to_bool(this_instr, ctx, value, &res)) {
                 sym_set_type(value, &PyLong_Type);
@@ -182,8 +182,8 @@
         }
 
         case _TO_BOOL_LIST: {
-            _Py_UopsSymbol *value;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *value;
+            JitOptSymbol *res;
             value = stack_pointer[-1];
             if (!optimize_to_bool(this_instr, ctx, value, &res)) {
                 sym_set_type(value, &PyList_Type);
@@ -194,8 +194,8 @@
         }
 
         case _TO_BOOL_NONE: {
-            _Py_UopsSymbol *value;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *value;
+            JitOptSymbol *res;
             value = stack_pointer[-1];
             if (!optimize_to_bool(this_instr, ctx, value, &res)) {
                 sym_set_const(value, Py_None);
@@ -206,8 +206,8 @@
         }
 
         case _TO_BOOL_STR: {
-            _Py_UopsSymbol *value;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *value;
+            JitOptSymbol *res;
             value = stack_pointer[-1];
             if (!optimize_to_bool(this_instr, ctx, value, &res)) {
                 res = sym_new_type(ctx, &PyBool_Type);
@@ -218,22 +218,22 @@
         }
 
         case _REPLACE_WITH_TRUE: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_const(ctx, Py_True);
             stack_pointer[-1] = res;
             break;
         }
 
         case _UNARY_INVERT: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-1] = res;
             break;
         }
 
         case _GUARD_BOTH_INT: {
-            _Py_UopsSymbol *right;
-            _Py_UopsSymbol *left;
+            JitOptSymbol *right;
+            JitOptSymbol *left;
             right = stack_pointer[-1];
             left = stack_pointer[-2];
             if (sym_matches_type(left, &PyLong_Type)) {
@@ -263,9 +263,9 @@
         }
 
         case _BINARY_OP_MULTIPLY_INT: {
-            _Py_UopsSymbol *right;
-            _Py_UopsSymbol *left;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *right;
+            JitOptSymbol *left;
+            JitOptSymbol *res;
             right = stack_pointer[-1];
             left = stack_pointer[-2];
             if (sym_is_const(left) && sym_is_const(right) &&
@@ -296,9 +296,9 @@
         }
 
         case _BINARY_OP_ADD_INT: {
-            _Py_UopsSymbol *right;
-            _Py_UopsSymbol *left;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *right;
+            JitOptSymbol *left;
+            JitOptSymbol *res;
             right = stack_pointer[-1];
             left = stack_pointer[-2];
             if (sym_is_const(left) && sym_is_const(right) &&
@@ -329,9 +329,9 @@
         }
 
         case _BINARY_OP_SUBTRACT_INT: {
-            _Py_UopsSymbol *right;
-            _Py_UopsSymbol *left;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *right;
+            JitOptSymbol *left;
+            JitOptSymbol *res;
             right = stack_pointer[-1];
             left = stack_pointer[-2];
             if (sym_is_const(left) && sym_is_const(right) &&
@@ -362,8 +362,8 @@
         }
 
         case _GUARD_BOTH_FLOAT: {
-            _Py_UopsSymbol *right;
-            _Py_UopsSymbol *left;
+            JitOptSymbol *right;
+            JitOptSymbol *left;
             right = stack_pointer[-1];
             left = stack_pointer[-2];
             if (sym_matches_type(left, &PyFloat_Type)) {
@@ -393,9 +393,9 @@
         }
 
         case _BINARY_OP_MULTIPLY_FLOAT: {
-            _Py_UopsSymbol *right;
-            _Py_UopsSymbol *left;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *right;
+            JitOptSymbol *left;
+            JitOptSymbol *res;
             right = stack_pointer[-1];
             left = stack_pointer[-2];
             if (sym_is_const(left) && sym_is_const(right) &&
@@ -427,9 +427,9 @@
         }
 
         case _BINARY_OP_ADD_FLOAT: {
-            _Py_UopsSymbol *right;
-            _Py_UopsSymbol *left;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *right;
+            JitOptSymbol *left;
+            JitOptSymbol *res;
             right = stack_pointer[-1];
             left = stack_pointer[-2];
             if (sym_is_const(left) && sym_is_const(right) &&
@@ -461,9 +461,9 @@
         }
 
         case _BINARY_OP_SUBTRACT_FLOAT: {
-            _Py_UopsSymbol *right;
-            _Py_UopsSymbol *left;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *right;
+            JitOptSymbol *left;
+            JitOptSymbol *res;
             right = stack_pointer[-1];
             left = stack_pointer[-2];
             if (sym_is_const(left) && sym_is_const(right) &&
@@ -495,8 +495,8 @@
         }
 
         case _GUARD_BOTH_UNICODE: {
-            _Py_UopsSymbol *right;
-            _Py_UopsSymbol *left;
+            JitOptSymbol *right;
+            JitOptSymbol *left;
             right = stack_pointer[-1];
             left = stack_pointer[-2];
             if (sym_matches_type(left, &PyUnicode_Type) &&
@@ -509,9 +509,9 @@
         }
 
         case _BINARY_OP_ADD_UNICODE: {
-            _Py_UopsSymbol *right;
-            _Py_UopsSymbol *left;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *right;
+            JitOptSymbol *left;
+            JitOptSymbol *res;
             right = stack_pointer[-1];
             left = stack_pointer[-2];
             if (sym_is_const(left) && sym_is_const(right) &&
@@ -536,11 +536,11 @@
         }
 
         case _BINARY_OP_INPLACE_ADD_UNICODE: {
-            _Py_UopsSymbol *right;
-            _Py_UopsSymbol *left;
+            JitOptSymbol *right;
+            JitOptSymbol *left;
             right = stack_pointer[-1];
             left = stack_pointer[-2];
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             if (sym_is_const(left) && sym_is_const(right) &&
                 sym_matches_type(left, &PyUnicode_Type) && sym_matches_type(right, &PyUnicode_Type)) {
                 PyObject *temp = PyUnicode_Concat(sym_get_const(left), sym_get_const(right));
@@ -567,7 +567,7 @@
         }
 
         case _BINARY_OP_EXTEND: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-2] = res;
             stack_pointer += -1;
@@ -576,7 +576,7 @@
         }
 
         case _BINARY_SUBSCR: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-2] = res;
             stack_pointer += -1;
@@ -585,7 +585,7 @@
         }
 
         case _BINARY_SLICE: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-3] = res;
             stack_pointer += -2;
@@ -600,7 +600,7 @@
         }
 
         case _BINARY_SUBSCR_LIST_INT: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-2] = res;
             stack_pointer += -1;
@@ -609,7 +609,7 @@
         }
 
         case _BINARY_SUBSCR_STR_INT: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-2] = res;
             stack_pointer += -1;
@@ -618,7 +618,7 @@
         }
 
         case _BINARY_SUBSCR_TUPLE_INT: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-2] = res;
             stack_pointer += -1;
@@ -627,7 +627,7 @@
         }
 
         case _BINARY_SUBSCR_DICT: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-2] = res;
             stack_pointer += -1;
@@ -636,7 +636,7 @@
         }
 
         case _BINARY_SUBSCR_CHECK_FUNC: {
-            _Py_UopsSymbol *getitem;
+            JitOptSymbol *getitem;
             getitem = sym_new_not_null(ctx);
             stack_pointer[0] = getitem;
             stack_pointer += 1;
@@ -645,9 +645,9 @@
         }
 
         case _BINARY_SUBSCR_INIT_CALL: {
-            _Py_UopsSymbol *getitem;
-            _Py_UopsSymbol *sub;
-            _Py_UopsSymbol *container;
+            JitOptSymbol *getitem;
+            JitOptSymbol *sub;
+            JitOptSymbol *container;
             _Py_UOpsAbstractFrame *new_frame;
             getitem = stack_pointer[-1];
             sub = stack_pointer[-2];
@@ -657,7 +657,7 @@
             (void)getitem;
             new_frame = NULL;
             ctx->done = true;
-            stack_pointer[-3] = (_Py_UopsSymbol *)new_frame;
+            stack_pointer[-3] = (JitOptSymbol *)new_frame;
             stack_pointer += -2;
             assert(WITHIN_STACK_BOUNDS());
             break;
@@ -700,14 +700,14 @@
         }
 
         case _CALL_INTRINSIC_1: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-1] = res;
             break;
         }
 
         case _CALL_INTRINSIC_2: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-2] = res;
             stack_pointer += -1;
@@ -716,8 +716,8 @@
         }
 
         case _RETURN_VALUE: {
-            _Py_UopsSymbol *retval;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *retval;
+            JitOptSymbol *res;
             retval = stack_pointer[-1];
             stack_pointer += -1;
             assert(WITHIN_STACK_BOUNDS());
@@ -744,14 +744,14 @@
         }
 
         case _GET_AITER: {
-            _Py_UopsSymbol *iter;
+            JitOptSymbol *iter;
             iter = sym_new_not_null(ctx);
             stack_pointer[-1] = iter;
             break;
         }
 
         case _GET_ANEXT: {
-            _Py_UopsSymbol *awaitable;
+            JitOptSymbol *awaitable;
             awaitable = sym_new_not_null(ctx);
             stack_pointer[0] = awaitable;
             stack_pointer += 1;
@@ -760,7 +760,7 @@
         }
 
         case _GET_AWAITABLE: {
-            _Py_UopsSymbol *iter;
+            JitOptSymbol *iter;
             iter = sym_new_not_null(ctx);
             stack_pointer[-1] = iter;
             break;
@@ -775,7 +775,7 @@
         }
 
         case _YIELD_VALUE: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_unknown(ctx);
             stack_pointer[-1] = res;
             break;
@@ -788,7 +788,7 @@
         }
 
         case _LOAD_COMMON_CONSTANT: {
-            _Py_UopsSymbol *value;
+            JitOptSymbol *value;
             value = sym_new_not_null(ctx);
             stack_pointer[0] = value;
             stack_pointer += 1;
@@ -797,7 +797,7 @@
         }
 
         case _LOAD_BUILD_CLASS: {
-            _Py_UopsSymbol *bc;
+            JitOptSymbol *bc;
             bc = sym_new_not_null(ctx);
             stack_pointer[0] = bc;
             stack_pointer += 1;
@@ -816,8 +816,8 @@
         }
 
         case _UNPACK_SEQUENCE: {
-            _Py_UopsSymbol *seq;
-            _Py_UopsSymbol **values;
+            JitOptSymbol *seq;
+            JitOptSymbol **values;
             seq = stack_pointer[-1];
             values = &stack_pointer[-1];
             /* This has to be done manually */
@@ -831,10 +831,12 @@
         }
 
         case _UNPACK_SEQUENCE_TWO_TUPLE: {
-            _Py_UopsSymbol *val1;
-            _Py_UopsSymbol *val0;
-            val1 = sym_new_not_null(ctx);
-            val0 = sym_new_not_null(ctx);
+            JitOptSymbol *seq;
+            JitOptSymbol *val1;
+            JitOptSymbol *val0;
+            seq = stack_pointer[-1];
+            val0 = sym_tuple_getitem(ctx, seq, 0);
+            val1 = sym_tuple_getitem(ctx, seq, 1);
             stack_pointer[-1] = val1;
             stack_pointer[0] = val0;
             stack_pointer += 1;
@@ -843,10 +845,12 @@
         }
 
         case _UNPACK_SEQUENCE_TUPLE: {
-            _Py_UopsSymbol **values;
+            JitOptSymbol *seq;
+            JitOptSymbol **values;
+            seq = stack_pointer[-1];
             values = &stack_pointer[-1];
-            for (int _i = oparg; --_i >= 0;) {
-                values[_i] = sym_new_not_null(ctx);
+            for (int i = 0; i < oparg; i++) {
+                values[i] = sym_tuple_getitem(ctx, seq, i);
             }
             stack_pointer += -1 + oparg;
             assert(WITHIN_STACK_BOUNDS());
@@ -854,7 +858,7 @@
         }
 
         case _UNPACK_SEQUENCE_LIST: {
-            _Py_UopsSymbol **values;
+            JitOptSymbol **values;
             values = &stack_pointer[-1];
             for (int _i = oparg; --_i >= 0;) {
                 values[_i] = sym_new_not_null(ctx);
@@ -865,8 +869,8 @@
         }
 
         case _UNPACK_EX: {
-            _Py_UopsSymbol *seq;
-            _Py_UopsSymbol **values;
+            JitOptSymbol *seq;
+            JitOptSymbol **values;
             seq = stack_pointer[-1];
             values = &stack_pointer[-1];
             /* This has to be done manually */
@@ -903,7 +907,7 @@
         }
 
         case _LOAD_LOCALS: {
-            _Py_UopsSymbol *locals;
+            JitOptSymbol *locals;
             locals = sym_new_not_null(ctx);
             stack_pointer[0] = locals;
             stack_pointer += 1;
@@ -914,7 +918,7 @@
         /* _LOAD_FROM_DICT_OR_GLOBALS is not a viable micro-op for tier 2 */
 
         case _LOAD_NAME: {
-            _Py_UopsSymbol *v;
+            JitOptSymbol *v;
             v = sym_new_not_null(ctx);
             stack_pointer[0] = v;
             stack_pointer += 1;
@@ -923,8 +927,8 @@
         }
 
         case _LOAD_GLOBAL: {
-            _Py_UopsSymbol **res;
-            _Py_UopsSymbol *null = NULL;
+            JitOptSymbol **res;
+            JitOptSymbol *null = NULL;
             res = &stack_pointer[0];
             res[0] = sym_new_not_null(ctx);
             null = sym_new_null(ctx);
@@ -939,7 +943,7 @@
         }
 
         case _GUARD_GLOBALS_VERSION_PUSH_KEYS: {
-            _Py_UopsSymbol *globals_keys;
+            JitOptSymbol *globals_keys;
             uint16_t version = (uint16_t)this_instr->operand0;
             globals_keys = sym_new_unknown(ctx);
             (void)version;
@@ -950,7 +954,7 @@
         }
 
         case _GUARD_BUILTINS_VERSION_PUSH_KEYS: {
-            _Py_UopsSymbol *builtins_keys;
+            JitOptSymbol *builtins_keys;
             uint16_t version = (uint16_t)this_instr->operand0;
             builtins_keys = sym_new_unknown(ctx);
             (void)version;
@@ -961,8 +965,8 @@
         }
 
         case _LOAD_GLOBAL_MODULE_FROM_KEYS: {
-            _Py_UopsSymbol *res;
-            _Py_UopsSymbol *null = NULL;
+            JitOptSymbol *res;
+            JitOptSymbol *null = NULL;
             res = sym_new_not_null(ctx);
             null = sym_new_null(ctx);
             stack_pointer[-1] = res;
@@ -973,8 +977,8 @@
         }
 
         case _LOAD_GLOBAL_BUILTINS_FROM_KEYS: {
-            _Py_UopsSymbol *res;
-            _Py_UopsSymbol *null = NULL;
+            JitOptSymbol *res;
+            JitOptSymbol *null = NULL;
             res = sym_new_not_null(ctx);
             null = sym_new_null(ctx);
             stack_pointer[-1] = res;
@@ -997,14 +1001,14 @@
         }
 
         case _LOAD_FROM_DICT_OR_DEREF: {
-            _Py_UopsSymbol *value;
+            JitOptSymbol *value;
             value = sym_new_not_null(ctx);
             stack_pointer[-1] = value;
             break;
         }
 
         case _LOAD_DEREF: {
-            _Py_UopsSymbol *value;
+            JitOptSymbol *value;
             value = sym_new_not_null(ctx);
             stack_pointer[0] = value;
             stack_pointer += 1;
@@ -1023,7 +1027,7 @@
         }
 
         case _BUILD_STRING: {
-            _Py_UopsSymbol *str;
+            JitOptSymbol *str;
             str = sym_new_not_null(ctx);
             stack_pointer[-oparg] = str;
             stack_pointer += 1 - oparg;
@@ -1032,8 +1036,10 @@
         }
 
         case _BUILD_TUPLE: {
-            _Py_UopsSymbol *tup;
-            tup = sym_new_not_null(ctx);
+            JitOptSymbol **values;
+            JitOptSymbol *tup;
+            values = &stack_pointer[-oparg];
+            tup = sym_new_tuple(ctx, oparg, values);
             stack_pointer[-oparg] = tup;
             stack_pointer += 1 - oparg;
             assert(WITHIN_STACK_BOUNDS());
@@ -1041,7 +1047,7 @@
         }
 
         case _BUILD_LIST: {
-            _Py_UopsSymbol *list;
+            JitOptSymbol *list;
             list = sym_new_not_null(ctx);
             stack_pointer[-oparg] = list;
             stack_pointer += 1 - oparg;
@@ -1062,7 +1068,7 @@
         }
 
         case _BUILD_SET: {
-            _Py_UopsSymbol *set;
+            JitOptSymbol *set;
             set = sym_new_not_null(ctx);
             stack_pointer[-oparg] = set;
             stack_pointer += 1 - oparg;
@@ -1071,7 +1077,7 @@
         }
 
         case _BUILD_MAP: {
-            _Py_UopsSymbol *map;
+            JitOptSymbol *map;
             map = sym_new_not_null(ctx);
             stack_pointer[-oparg*2] = map;
             stack_pointer += 1 - oparg*2;
@@ -1104,7 +1110,7 @@
         /* _INSTRUMENTED_LOAD_SUPER_ATTR is not a viable micro-op for tier 2 */
 
         case _LOAD_SUPER_ATTR_ATTR: {
-            _Py_UopsSymbol *attr_st;
+            JitOptSymbol *attr_st;
             attr_st = sym_new_not_null(ctx);
             stack_pointer[-3] = attr_st;
             stack_pointer += -2;
@@ -1113,8 +1119,8 @@
         }
 
         case _LOAD_SUPER_ATTR_METHOD: {
-            _Py_UopsSymbol *attr;
-            _Py_UopsSymbol *self_or_null;
+            JitOptSymbol *attr;
+            JitOptSymbol *self_or_null;
             attr = sym_new_not_null(ctx);
             self_or_null = sym_new_not_null(ctx);
             stack_pointer[-3] = attr;
@@ -1125,9 +1131,9 @@
         }
 
         case _LOAD_ATTR: {
-            _Py_UopsSymbol *owner;
-            _Py_UopsSymbol *attr;
-            _Py_UopsSymbol *self_or_null = NULL;
+            JitOptSymbol *owner;
+            JitOptSymbol *attr;
+            JitOptSymbol *self_or_null = NULL;
             owner = stack_pointer[-1];
             (void)owner;
             attr = sym_new_not_null(ctx);
@@ -1140,7 +1146,7 @@
         }
 
         case _GUARD_TYPE_VERSION: {
-            _Py_UopsSymbol *owner;
+            JitOptSymbol *owner;
             owner = stack_pointer[-1];
             uint32_t type_version = (uint32_t)this_instr->operand0;
             assert(type_version);
@@ -1174,9 +1180,9 @@
         }
 
         case _LOAD_ATTR_INSTANCE_VALUE: {
-            _Py_UopsSymbol *owner;
-            _Py_UopsSymbol *attr;
-            _Py_UopsSymbol *null = NULL;
+            JitOptSymbol *owner;
+            JitOptSymbol *attr;
+            JitOptSymbol *null = NULL;
             owner = stack_pointer[-1];
             uint16_t offset = (uint16_t)this_instr->operand0;
             attr = sym_new_not_null(ctx);
@@ -1191,8 +1197,8 @@
         }
 
         case _CHECK_ATTR_MODULE_PUSH_KEYS: {
-            _Py_UopsSymbol *owner;
-            _Py_UopsSymbol *mod_keys;
+            JitOptSymbol *owner;
+            JitOptSymbol *mod_keys;
             owner = stack_pointer[-1];
             uint32_t dict_version = (uint32_t)this_instr->operand0;
             (void)dict_version;
@@ -1222,9 +1228,9 @@
         }
 
         case _LOAD_ATTR_MODULE_FROM_KEYS: {
-            _Py_UopsSymbol *owner;
-            _Py_UopsSymbol *attr;
-            _Py_UopsSymbol *null = NULL;
+            JitOptSymbol *owner;
+            JitOptSymbol *attr;
+            JitOptSymbol *null = NULL;
             owner = stack_pointer[-2];
             uint16_t index = (uint16_t)this_instr->operand0;
             (void)index;
@@ -1263,8 +1269,8 @@
         }
 
         case _CHECK_ATTR_WITH_HINT: {
-            _Py_UopsSymbol *owner;
-            _Py_UopsSymbol *dict;
+            JitOptSymbol *owner;
+            JitOptSymbol *dict;
             owner = stack_pointer[-1];
             dict = sym_new_not_null(ctx);
             (void)owner;
@@ -1275,10 +1281,10 @@
         }
 
         case _LOAD_ATTR_WITH_HINT: {
-            _Py_UopsSymbol *dict;
-            _Py_UopsSymbol *owner;
-            _Py_UopsSymbol *attr;
-            _Py_UopsSymbol *null = NULL;
+            JitOptSymbol *dict;
+            JitOptSymbol *owner;
+            JitOptSymbol *attr;
+            JitOptSymbol *null = NULL;
             dict = stack_pointer[-1];
             owner = stack_pointer[-2];
             uint16_t hint = (uint16_t)this_instr->operand0;
@@ -1295,9 +1301,9 @@
         }
 
         case _LOAD_ATTR_SLOT: {
-            _Py_UopsSymbol *owner;
-            _Py_UopsSymbol *attr;
-            _Py_UopsSymbol *null = NULL;
+            JitOptSymbol *owner;
+            JitOptSymbol *attr;
+            JitOptSymbol *null = NULL;
             owner = stack_pointer[-1];
             uint16_t index = (uint16_t)this_instr->operand0;
             attr = sym_new_not_null(ctx);
@@ -1316,9 +1322,9 @@
         }
 
         case _LOAD_ATTR_CLASS: {
-            _Py_UopsSymbol *owner;
-            _Py_UopsSymbol *attr;
-            _Py_UopsSymbol *null = NULL;
+            JitOptSymbol *owner;
+            JitOptSymbol *attr;
+            JitOptSymbol *null = NULL;
             owner = stack_pointer[-1];
             PyObject *descr = (PyObject *)this_instr->operand0;
             attr = sym_new_not_null(ctx);
@@ -1333,7 +1339,7 @@
         }
 
         case _LOAD_ATTR_PROPERTY_FRAME: {
-            _Py_UopsSymbol *owner;
+            JitOptSymbol *owner;
             _Py_UOpsAbstractFrame *new_frame;
             owner = stack_pointer[-1];
             PyObject *fget = (PyObject *)this_instr->operand0;
@@ -1341,7 +1347,7 @@
             (void)owner;
             new_frame = NULL;
             ctx->done = true;
-            stack_pointer[-1] = (_Py_UopsSymbol *)new_frame;
+            stack_pointer[-1] = (JitOptSymbol *)new_frame;
             break;
         }
 
@@ -1370,9 +1376,9 @@
         }
 
         case _COMPARE_OP: {
-            _Py_UopsSymbol *right;
-            _Py_UopsSymbol *left;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *right;
+            JitOptSymbol *left;
+            JitOptSymbol *res;
             right = stack_pointer[-1];
             left = stack_pointer[-2];
             (void)left;
@@ -1394,9 +1400,9 @@
         }
 
         case _COMPARE_OP_FLOAT: {
-            _Py_UopsSymbol *right;
-            _Py_UopsSymbol *left;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *right;
+            JitOptSymbol *left;
+            JitOptSymbol *res;
             right = stack_pointer[-1];
             left = stack_pointer[-2];
             (void)left;
@@ -1409,9 +1415,9 @@
         }
 
         case _COMPARE_OP_INT: {
-            _Py_UopsSymbol *right;
-            _Py_UopsSymbol *left;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *right;
+            JitOptSymbol *left;
+            JitOptSymbol *res;
             right = stack_pointer[-1];
             left = stack_pointer[-2];
             (void)left;
@@ -1424,9 +1430,9 @@
         }
 
         case _COMPARE_OP_STR: {
-            _Py_UopsSymbol *right;
-            _Py_UopsSymbol *left;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *right;
+            JitOptSymbol *left;
+            JitOptSymbol *res;
             right = stack_pointer[-1];
             left = stack_pointer[-2];
             (void)left;
@@ -1439,9 +1445,9 @@
         }
 
         case _IS_OP: {
-            _Py_UopsSymbol *right;
-            _Py_UopsSymbol *left;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *right;
+            JitOptSymbol *left;
+            JitOptSymbol *res;
             right = stack_pointer[-1];
             left = stack_pointer[-2];
             (void)left;
@@ -1454,9 +1460,9 @@
         }
 
         case _CONTAINS_OP: {
-            _Py_UopsSymbol *right;
-            _Py_UopsSymbol *left;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *right;
+            JitOptSymbol *left;
+            JitOptSymbol *res;
             right = stack_pointer[-1];
             left = stack_pointer[-2];
             (void)left;
@@ -1469,7 +1475,7 @@
         }
 
         case _CONTAINS_OP_SET: {
-            _Py_UopsSymbol *b;
+            JitOptSymbol *b;
             b = sym_new_not_null(ctx);
             stack_pointer[-2] = b;
             stack_pointer += -1;
@@ -1478,7 +1484,7 @@
         }
 
         case _CONTAINS_OP_DICT: {
-            _Py_UopsSymbol *b;
+            JitOptSymbol *b;
             b = sym_new_not_null(ctx);
             stack_pointer[-2] = b;
             stack_pointer += -1;
@@ -1487,8 +1493,8 @@
         }
 
         case _CHECK_EG_MATCH: {
-            _Py_UopsSymbol *rest;
-            _Py_UopsSymbol *match;
+            JitOptSymbol *rest;
+            JitOptSymbol *match;
             rest = sym_new_not_null(ctx);
             match = sym_new_not_null(ctx);
             stack_pointer[-2] = rest;
@@ -1497,14 +1503,14 @@
         }
 
         case _CHECK_EXC_MATCH: {
-            _Py_UopsSymbol *b;
+            JitOptSymbol *b;
             b = sym_new_not_null(ctx);
             stack_pointer[-1] = b;
             break;
         }
 
         case _IMPORT_NAME: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-2] = res;
             stack_pointer += -1;
@@ -1513,7 +1519,7 @@
         }
 
         case _IMPORT_FROM: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[0] = res;
             stack_pointer += 1;
@@ -1526,14 +1532,14 @@
         /* _POP_JUMP_IF_TRUE is not a viable micro-op for tier 2 */
 
         case _IS_NONE: {
-            _Py_UopsSymbol *b;
+            JitOptSymbol *b;
             b = sym_new_not_null(ctx);
             stack_pointer[-1] = b;
             break;
         }
 
         case _GET_LEN: {
-            _Py_UopsSymbol *len;
+            JitOptSymbol *len;
             len = sym_new_not_null(ctx);
             stack_pointer[0] = len;
             stack_pointer += 1;
@@ -1542,7 +1548,7 @@
         }
 
         case _MATCH_CLASS: {
-            _Py_UopsSymbol *attrs;
+            JitOptSymbol *attrs;
             attrs = sym_new_not_null(ctx);
             stack_pointer[-3] = attrs;
             stack_pointer += -2;
@@ -1551,7 +1557,7 @@
         }
 
         case _MATCH_MAPPING: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[0] = res;
             stack_pointer += 1;
@@ -1560,7 +1566,7 @@
         }
 
         case _MATCH_SEQUENCE: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[0] = res;
             stack_pointer += 1;
@@ -1569,7 +1575,7 @@
         }
 
         case _MATCH_KEYS: {
-            _Py_UopsSymbol *values_or_none;
+            JitOptSymbol *values_or_none;
             values_or_none = sym_new_not_null(ctx);
             stack_pointer[0] = values_or_none;
             stack_pointer += 1;
@@ -1578,14 +1584,14 @@
         }
 
         case _GET_ITER: {
-            _Py_UopsSymbol *iter;
+            JitOptSymbol *iter;
             iter = sym_new_not_null(ctx);
             stack_pointer[-1] = iter;
             break;
         }
 
         case _GET_YIELD_FROM_ITER: {
-            _Py_UopsSymbol *iter;
+            JitOptSymbol *iter;
             iter = sym_new_not_null(ctx);
             stack_pointer[-1] = iter;
             break;
@@ -1594,7 +1600,7 @@
         /* _FOR_ITER is not a viable micro-op for tier 2 */
 
         case _FOR_ITER_TIER_TWO: {
-            _Py_UopsSymbol *next;
+            JitOptSymbol *next;
             next = sym_new_not_null(ctx);
             stack_pointer[0] = next;
             stack_pointer += 1;
@@ -1615,7 +1621,7 @@
         }
 
         case _ITER_NEXT_LIST: {
-            _Py_UopsSymbol *next;
+            JitOptSymbol *next;
             next = sym_new_not_null(ctx);
             stack_pointer[0] = next;
             stack_pointer += 1;
@@ -1634,7 +1640,7 @@
         }
 
         case _ITER_NEXT_TUPLE: {
-            _Py_UopsSymbol *next;
+            JitOptSymbol *next;
             next = sym_new_not_null(ctx);
             stack_pointer[0] = next;
             stack_pointer += 1;
@@ -1653,8 +1659,8 @@
         }
 
         case _ITER_NEXT_RANGE: {
-            _Py_UopsSymbol *iter;
-            _Py_UopsSymbol *next;
+            JitOptSymbol *iter;
+            JitOptSymbol *next;
             iter = stack_pointer[-1];
             next = sym_new_type(ctx, &PyLong_Type);
             (void)iter;
@@ -1671,9 +1677,9 @@
         }
 
         case _LOAD_SPECIAL: {
-            _Py_UopsSymbol *owner;
-            _Py_UopsSymbol *attr;
-            _Py_UopsSymbol *self_or_null;
+            JitOptSymbol *owner;
+            JitOptSymbol *attr;
+            JitOptSymbol *self_or_null;
             owner = stack_pointer[-1];
             (void)owner;
             attr = sym_new_not_null(ctx);
@@ -1686,7 +1692,7 @@
         }
 
         case _WITH_EXCEPT_START: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[0] = res;
             stack_pointer += 1;
@@ -1695,8 +1701,8 @@
         }
 
         case _PUSH_EXC_INFO: {
-            _Py_UopsSymbol *prev_exc;
-            _Py_UopsSymbol *new_exc;
+            JitOptSymbol *prev_exc;
+            JitOptSymbol *new_exc;
             prev_exc = sym_new_not_null(ctx);
             new_exc = sym_new_not_null(ctx);
             stack_pointer[-1] = prev_exc;
@@ -1715,9 +1721,9 @@
         }
 
         case _LOAD_ATTR_METHOD_WITH_VALUES: {
-            _Py_UopsSymbol *owner;
-            _Py_UopsSymbol *attr;
-            _Py_UopsSymbol *self = NULL;
+            JitOptSymbol *owner;
+            JitOptSymbol *attr;
+            JitOptSymbol *self = NULL;
             owner = stack_pointer[-1];
             PyObject *descr = (PyObject *)this_instr->operand0;
             (void)descr;
@@ -1731,9 +1737,9 @@
         }
 
         case _LOAD_ATTR_METHOD_NO_DICT: {
-            _Py_UopsSymbol *owner;
-            _Py_UopsSymbol *attr;
-            _Py_UopsSymbol *self = NULL;
+            JitOptSymbol *owner;
+            JitOptSymbol *attr;
+            JitOptSymbol *self = NULL;
             owner = stack_pointer[-1];
             PyObject *descr = (PyObject *)this_instr->operand0;
             (void)descr;
@@ -1747,14 +1753,14 @@
         }
 
         case _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES: {
-            _Py_UopsSymbol *attr;
+            JitOptSymbol *attr;
             attr = sym_new_not_null(ctx);
             stack_pointer[-1] = attr;
             break;
         }
 
         case _LOAD_ATTR_NONDESCRIPTOR_NO_DICT: {
-            _Py_UopsSymbol *attr;
+            JitOptSymbol *attr;
             attr = sym_new_not_null(ctx);
             stack_pointer[-1] = attr;
             break;
@@ -1765,9 +1771,9 @@
         }
 
         case _LOAD_ATTR_METHOD_LAZY_DICT: {
-            _Py_UopsSymbol *owner;
-            _Py_UopsSymbol *attr;
-            _Py_UopsSymbol *self = NULL;
+            JitOptSymbol *owner;
+            JitOptSymbol *attr;
+            JitOptSymbol *self = NULL;
             owner = stack_pointer[-1];
             PyObject *descr = (PyObject *)this_instr->operand0;
             (void)descr;
@@ -1781,11 +1787,11 @@
         }
 
         case _MAYBE_EXPAND_METHOD: {
-            _Py_UopsSymbol **args;
-            _Py_UopsSymbol *self_or_null;
-            _Py_UopsSymbol *callable;
-            _Py_UopsSymbol *func;
-            _Py_UopsSymbol *maybe_self;
+            JitOptSymbol **args;
+            JitOptSymbol *self_or_null;
+            JitOptSymbol *callable;
+            JitOptSymbol *func;
+            JitOptSymbol *maybe_self;
             args = &stack_pointer[-oparg];
             self_or_null = stack_pointer[-1 - oparg];
             callable = stack_pointer[-2 - oparg];
@@ -1805,8 +1811,8 @@
         /* _MONITOR_CALL is not a viable micro-op for tier 2 */
 
         case _PY_FRAME_GENERAL: {
-            _Py_UopsSymbol *self_or_null;
-            _Py_UopsSymbol *callable;
+            JitOptSymbol *self_or_null;
+            JitOptSymbol *callable;
             _Py_UOpsAbstractFrame *new_frame;
             self_or_null = stack_pointer[-1 - oparg];
             callable = stack_pointer[-2 - oparg];
@@ -1822,15 +1828,15 @@
                 break;
             }
             new_frame = frame_new(ctx, co, 0, NULL, 0);
-            stack_pointer[0] = (_Py_UopsSymbol *)new_frame;
+            stack_pointer[0] = (JitOptSymbol *)new_frame;
             stack_pointer += 1;
             assert(WITHIN_STACK_BOUNDS());
             break;
         }
 
         case _CHECK_FUNCTION_VERSION: {
-            _Py_UopsSymbol *self_or_null;
-            _Py_UopsSymbol *callable;
+            JitOptSymbol *self_or_null;
+            JitOptSymbol *callable;
             self_or_null = stack_pointer[-1 - oparg];
             callable = stack_pointer[-2 - oparg];
             uint32_t func_version = (uint32_t)this_instr->operand0;
@@ -1853,8 +1859,8 @@
         }
 
         case _EXPAND_METHOD: {
-            _Py_UopsSymbol **method;
-            _Py_UopsSymbol **self;
+            JitOptSymbol **method;
+            JitOptSymbol **self;
             method = &stack_pointer[-2 - oparg];
             self = &stack_pointer[-1 - oparg];
             method[0] = sym_new_not_null(ctx);
@@ -1867,7 +1873,7 @@
         }
 
         case _CALL_NON_PY_GENERAL: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-2 - oparg] = res;
             stack_pointer += -1 - oparg;
@@ -1876,8 +1882,8 @@
         }
 
         case _CHECK_CALL_BOUND_METHOD_EXACT_ARGS: {
-            _Py_UopsSymbol *null;
-            _Py_UopsSymbol *callable;
+            JitOptSymbol *null;
+            JitOptSymbol *callable;
             null = stack_pointer[-1 - oparg];
             callable = stack_pointer[-2 - oparg];
             sym_set_null(null);
@@ -1886,9 +1892,9 @@
         }
 
         case _INIT_CALL_BOUND_METHOD_EXACT_ARGS: {
-            _Py_UopsSymbol *callable;
-            _Py_UopsSymbol *func;
-            _Py_UopsSymbol *self;
+            JitOptSymbol *callable;
+            JitOptSymbol *func;
+            JitOptSymbol *self;
             callable = stack_pointer[-2 - oparg];
             (void)callable;
             func = sym_new_not_null(ctx);
@@ -1908,8 +1914,8 @@
         }
 
         case _CHECK_FUNCTION_EXACT_ARGS: {
-            _Py_UopsSymbol *self_or_null;
-            _Py_UopsSymbol *callable;
+            JitOptSymbol *self_or_null;
+            JitOptSymbol *callable;
             self_or_null = stack_pointer[-1 - oparg];
             callable = stack_pointer[-2 - oparg];
             assert(sym_matches_type(callable, &PyFunction_Type));
@@ -1933,9 +1939,9 @@
         }
 
         case _INIT_CALL_PY_EXACT_ARGS: {
-            _Py_UopsSymbol **args;
-            _Py_UopsSymbol *self_or_null;
-            _Py_UopsSymbol *callable;
+            JitOptSymbol **args;
+            JitOptSymbol *self_or_null;
+            JitOptSymbol *callable;
             _Py_UOpsAbstractFrame *new_frame;
             args = &stack_pointer[-oparg];
             self_or_null = stack_pointer[-1 - oparg];
@@ -1963,7 +1969,7 @@
             } else {
                 new_frame = frame_new(ctx, co, 0, NULL, 0);
             }
-            stack_pointer[0] = (_Py_UopsSymbol *)new_frame;
+            stack_pointer[0] = (JitOptSymbol *)new_frame;
             stack_pointer += 1;
             assert(WITHIN_STACK_BOUNDS());
             break;
@@ -2008,7 +2014,7 @@
         }
 
         case _CALL_TYPE_1: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-3] = res;
             stack_pointer += -2;
@@ -2017,7 +2023,7 @@
         }
 
         case _CALL_STR_1: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-3] = res;
             stack_pointer += -2;
@@ -2026,7 +2032,7 @@
         }
 
         case _CALL_TUPLE_1: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-3] = res;
             stack_pointer += -2;
@@ -2035,11 +2041,11 @@
         }
 
         case _CHECK_AND_ALLOCATE_OBJECT: {
-            _Py_UopsSymbol **args;
-            _Py_UopsSymbol *null;
-            _Py_UopsSymbol *callable;
-            _Py_UopsSymbol *self;
-            _Py_UopsSymbol *init;
+            JitOptSymbol **args;
+            JitOptSymbol *null;
+            JitOptSymbol *callable;
+            JitOptSymbol *self;
+            JitOptSymbol *init;
             args = &stack_pointer[-oparg];
             null = stack_pointer[-1 - oparg];
             callable = stack_pointer[-2 - oparg];
@@ -2057,9 +2063,9 @@
         }
 
         case _CREATE_INIT_FRAME: {
-            _Py_UopsSymbol **args;
-            _Py_UopsSymbol *init;
-            _Py_UopsSymbol *self;
+            JitOptSymbol **args;
+            JitOptSymbol *init;
+            JitOptSymbol *self;
             _Py_UOpsAbstractFrame *init_frame;
             args = &stack_pointer[-oparg];
             init = stack_pointer[-1 - oparg];
@@ -2069,7 +2075,7 @@
             (void)args;
             init_frame = NULL;
             ctx->done = true;
-            stack_pointer[-2 - oparg] = (_Py_UopsSymbol *)init_frame;
+            stack_pointer[-2 - oparg] = (JitOptSymbol *)init_frame;
             stack_pointer += -1 - oparg;
             assert(WITHIN_STACK_BOUNDS());
             break;
@@ -2082,7 +2088,7 @@
         }
 
         case _CALL_BUILTIN_CLASS: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-2 - oparg] = res;
             stack_pointer += -1 - oparg;
@@ -2091,7 +2097,7 @@
         }
 
         case _CALL_BUILTIN_O: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-2 - oparg] = res;
             stack_pointer += -1 - oparg;
@@ -2100,7 +2106,7 @@
         }
 
         case _CALL_BUILTIN_FAST: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-2 - oparg] = res;
             stack_pointer += -1 - oparg;
@@ -2109,7 +2115,7 @@
         }
 
         case _CALL_BUILTIN_FAST_WITH_KEYWORDS: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-2 - oparg] = res;
             stack_pointer += -1 - oparg;
@@ -2118,7 +2124,7 @@
         }
 
         case _CALL_LEN: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-2 - oparg] = res;
             stack_pointer += -1 - oparg;
@@ -2127,7 +2133,7 @@
         }
 
         case _CALL_ISINSTANCE: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-2 - oparg] = res;
             stack_pointer += -1 - oparg;
@@ -2142,7 +2148,7 @@
         }
 
         case _CALL_METHOD_DESCRIPTOR_O: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-2 - oparg] = res;
             stack_pointer += -1 - oparg;
@@ -2151,7 +2157,7 @@
         }
 
         case _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-2 - oparg] = res;
             stack_pointer += -1 - oparg;
@@ -2160,7 +2166,7 @@
         }
 
         case _CALL_METHOD_DESCRIPTOR_NOARGS: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-2 - oparg] = res;
             stack_pointer += -1 - oparg;
@@ -2169,7 +2175,7 @@
         }
 
         case _CALL_METHOD_DESCRIPTOR_FAST: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-2 - oparg] = res;
             stack_pointer += -1 - oparg;
@@ -2180,10 +2186,10 @@
         /* _INSTRUMENTED_CALL_KW is not a viable micro-op for tier 2 */
 
         case _MAYBE_EXPAND_METHOD_KW: {
-            _Py_UopsSymbol **func;
-            _Py_UopsSymbol **maybe_self;
-            _Py_UopsSymbol **args;
-            _Py_UopsSymbol *kwnames_out;
+            JitOptSymbol **func;
+            JitOptSymbol **maybe_self;
+            JitOptSymbol **args;
+            JitOptSymbol *kwnames_out;
             func = &stack_pointer[-3 - oparg];
             maybe_self = &stack_pointer[-2 - oparg];
             args = &stack_pointer[-1 - oparg];
@@ -2200,10 +2206,10 @@
         /* _DO_CALL_KW is not a viable micro-op for tier 2 */
 
         case _PY_FRAME_KW: {
-            _Py_UopsSymbol *kwnames;
-            _Py_UopsSymbol **args;
-            _Py_UopsSymbol *self_or_null;
-            _Py_UopsSymbol *callable;
+            JitOptSymbol *kwnames;
+            JitOptSymbol **args;
+            JitOptSymbol *self_or_null;
+            JitOptSymbol *callable;
             _Py_UOpsAbstractFrame *new_frame;
             kwnames = stack_pointer[-1];
             args = &stack_pointer[-1 - oparg];
@@ -2215,7 +2221,7 @@
             (void)kwnames;
             new_frame = NULL;
             ctx->done = true;
-            stack_pointer[-3 - oparg] = (_Py_UopsSymbol *)new_frame;
+            stack_pointer[-3 - oparg] = (JitOptSymbol *)new_frame;
             stack_pointer += -2 - oparg;
             assert(WITHIN_STACK_BOUNDS());
             break;
@@ -2230,8 +2236,8 @@
         }
 
         case _EXPAND_METHOD_KW: {
-            _Py_UopsSymbol **method;
-            _Py_UopsSymbol **self;
+            JitOptSymbol **method;
+            JitOptSymbol **self;
             method = &stack_pointer[-3 - oparg];
             self = &stack_pointer[-2 - oparg];
             method[0] = sym_new_not_null(ctx);
@@ -2244,7 +2250,7 @@
         }
 
         case _CALL_KW_NON_PY: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-3 - oparg] = res;
             stack_pointer += -2 - oparg;
@@ -2255,8 +2261,8 @@
         /* _INSTRUMENTED_CALL_FUNCTION_EX is not a viable micro-op for tier 2 */
 
         case _MAKE_CALLARGS_A_TUPLE: {
-            _Py_UopsSymbol *tuple;
-            _Py_UopsSymbol *kwargs_out = NULL;
+            JitOptSymbol *tuple;
+            JitOptSymbol *kwargs_out = NULL;
             tuple = sym_new_not_null(ctx);
             kwargs_out = sym_new_not_null(ctx);
             stack_pointer[-1 - (oparg & 1)] = tuple;
@@ -2267,14 +2273,14 @@
         /* _DO_CALL_FUNCTION_EX is not a viable micro-op for tier 2 */
 
         case _MAKE_FUNCTION: {
-            _Py_UopsSymbol *func;
+            JitOptSymbol *func;
             func = sym_new_not_null(ctx);
             stack_pointer[-1] = func;
             break;
         }
 
         case _SET_FUNCTION_ATTRIBUTE: {
-            _Py_UopsSymbol *func_out;
+            JitOptSymbol *func_out;
             func_out = sym_new_not_null(ctx);
             stack_pointer[-2] = func_out;
             stack_pointer += -1;
@@ -2283,7 +2289,7 @@
         }
 
         case _RETURN_GENERATOR: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             ctx->frame->stack_pointer = stack_pointer;
             frame_pop(ctx);
             stack_pointer = ctx->frame->stack_pointer;
@@ -2307,7 +2313,7 @@
         }
 
         case _BUILD_SLICE: {
-            _Py_UopsSymbol *slice;
+            JitOptSymbol *slice;
             slice = sym_new_not_null(ctx);
             stack_pointer[-2 - ((oparg == 3) ? 1 : 0)] = slice;
             stack_pointer += -1 - ((oparg == 3) ? 1 : 0);
@@ -2316,21 +2322,21 @@
         }
 
         case _CONVERT_VALUE: {
-            _Py_UopsSymbol *result;
+            JitOptSymbol *result;
             result = sym_new_not_null(ctx);
             stack_pointer[-1] = result;
             break;
         }
 
         case _FORMAT_SIMPLE: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-1] = res;
             break;
         }
 
         case _FORMAT_WITH_SPEC: {
-            _Py_UopsSymbol *res;
+            JitOptSymbol *res;
             res = sym_new_not_null(ctx);
             stack_pointer[-2] = res;
             stack_pointer += -1;
@@ -2339,8 +2345,8 @@
         }
 
         case _COPY: {
-            _Py_UopsSymbol *bottom;
-            _Py_UopsSymbol *top;
+            JitOptSymbol *bottom;
+            JitOptSymbol *top;
             bottom = stack_pointer[-1 - (oparg-1)];
             assert(oparg > 0);
             top = bottom;
@@ -2351,9 +2357,9 @@
         }
 
         case _BINARY_OP: {
-            _Py_UopsSymbol *right;
-            _Py_UopsSymbol *left;
-            _Py_UopsSymbol *res;
+            JitOptSymbol *right;
+            JitOptSymbol *left;
+            JitOptSymbol *res;
             right = stack_pointer[-1];
             left = stack_pointer[-2];
             bool lhs_int = sym_matches_type(left, &PyLong_Type);
@@ -2426,10 +2432,10 @@
         }
 
         case _SWAP: {
-            _Py_UopsSymbol *top_in;
-            _Py_UopsSymbol *bottom_in;
-            _Py_UopsSymbol *top_out;
-            _Py_UopsSymbol *bottom_out;
+            JitOptSymbol *top_in;
+            JitOptSymbol *bottom_in;
+            JitOptSymbol *top_out;
+            JitOptSymbol *bottom_out;
             top_in = stack_pointer[-1];
             bottom_in = stack_pointer[-2 - (oparg-2)];
             bottom_out = bottom_in;
@@ -2458,7 +2464,7 @@
         /* _INSTRUMENTED_POP_JUMP_IF_NOT_NONE is not a viable micro-op for tier 2 */
 
         case _GUARD_IS_TRUE_POP: {
-            _Py_UopsSymbol *flag;
+            JitOptSymbol *flag;
             flag = stack_pointer[-1];
             if (sym_is_const(flag)) {
                 PyObject *value = sym_get_const(flag);
@@ -2475,7 +2481,7 @@
         }
 
         case _GUARD_IS_FALSE_POP: {
-            _Py_UopsSymbol *flag;
+            JitOptSymbol *flag;
             flag = stack_pointer[-1];
             if (sym_is_const(flag)) {
                 PyObject *value = sym_get_const(flag);
@@ -2492,7 +2498,7 @@
         }
 
         case _GUARD_IS_NONE_POP: {
-            _Py_UopsSymbol *flag;
+            JitOptSymbol *flag;
             flag = stack_pointer[-1];
             if (sym_is_const(flag)) {
                 PyObject *value = sym_get_const(flag);
@@ -2517,7 +2523,7 @@
         }
 
         case _GUARD_IS_NOT_NONE_POP: {
-            _Py_UopsSymbol *flag;
+            JitOptSymbol *flag;
             flag = stack_pointer[-1];
             if (sym_is_const(flag)) {
                 PyObject *value = sym_get_const(flag);
@@ -2575,7 +2581,7 @@
         }
 
         case _LOAD_CONST_INLINE: {
-            _Py_UopsSymbol *value;
+            JitOptSymbol *value;
             PyObject *ptr = (PyObject *)this_instr->operand0;
             value = sym_new_const(ctx, ptr);
             stack_pointer[0] = value;
@@ -2585,7 +2591,7 @@
         }
 
         case _LOAD_CONST_INLINE_BORROW: {
-            _Py_UopsSymbol *value;
+            JitOptSymbol *value;
             PyObject *ptr = (PyObject *)this_instr->operand0;
             value = sym_new_const(ctx, ptr);
             stack_pointer[0] = value;
@@ -2595,15 +2601,15 @@
         }
 
         case _POP_TOP_LOAD_CONST_INLINE_BORROW: {
-            _Py_UopsSymbol *value;
+            JitOptSymbol *value;
             value = sym_new_not_null(ctx);
             stack_pointer[-1] = value;
             break;
         }
 
         case _LOAD_CONST_INLINE_WITH_NULL: {
-            _Py_UopsSymbol *value;
-            _Py_UopsSymbol *null;
+            JitOptSymbol *value;
+            JitOptSymbol *null;
             PyObject *ptr = (PyObject *)this_instr->operand0;
             value = sym_new_const(ctx, ptr);
             null = sym_new_null(ctx);
@@ -2615,8 +2621,8 @@
         }
 
         case _LOAD_CONST_INLINE_BORROW_WITH_NULL: {
-            _Py_UopsSymbol *value;
-            _Py_UopsSymbol *null;
+            JitOptSymbol *value;
+            JitOptSymbol *null;
             PyObject *ptr = (PyObject *)this_instr->operand0;
             value = sym_new_const(ctx, ptr);
             null = sym_new_null(ctx);
@@ -2632,8 +2638,8 @@
         }
 
         case _LOAD_GLOBAL_MODULE: {
-            _Py_UopsSymbol *res;
-            _Py_UopsSymbol *null = NULL;
+            JitOptSymbol *res;
+            JitOptSymbol *null = NULL;
             res = sym_new_not_null(ctx);
             null = sym_new_null(ctx);
             stack_pointer[0] = res;
@@ -2644,8 +2650,8 @@
         }
 
         case _LOAD_GLOBAL_BUILTINS: {
-            _Py_UopsSymbol *res;
-            _Py_UopsSymbol *null = NULL;
+            JitOptSymbol *res;
+            JitOptSymbol *null = NULL;
             res = sym_new_not_null(ctx);
             null = sym_new_null(ctx);
             stack_pointer[0] = res;
@@ -2656,8 +2662,8 @@
         }
 
         case _LOAD_ATTR_MODULE: {
-            _Py_UopsSymbol *attr;
-            _Py_UopsSymbol *null = NULL;
+            JitOptSymbol *attr;
+            JitOptSymbol *null = NULL;
             attr = sym_new_not_null(ctx);
             null = sym_new_null(ctx);
             stack_pointer[-1] = attr;