From be968c72100f35bc18a14310be954b56863630da Mon Sep 17 00:00:00 2001 From: Hai Zhu Date: Tue, 28 Apr 2026 20:41:16 +0800 Subject: [PATCH 1/4] gh-148571: [JIT] Preserve family-head recorder layouts for specialized opcode families (GH-148730) * Records the same objects for each member of family before execution * Records derived values when recording the trace * This makes sure that specialization, or deoptimization, does not cause invalid values to be recorded --- Include/internal/pycore_optimizer.h | 14 ++ Lib/test/test_capi/test_opt.py | 13 ++ Lib/test/test_generated_cases.py | 187 +++++++++++++++- ...-04-18-16-41-04.gh-issue-148571.Q6WB3A.rst | 1 + Python/optimizer.c | 51 ++++- Python/record_functions.c.h | 123 +++++++++- .../record_function_generator.py | 211 +++++++++++++++--- 7 files changed, 555 insertions(+), 45 deletions(-) create mode 100644 Misc/NEWS.d/next/Core_and_Builtins/2026-04-18-16-41-04.gh-issue-148571.Q6WB3A.rst diff --git a/Include/internal/pycore_optimizer.h b/Include/internal/pycore_optimizer.h index 7c2e0e95a80c3f..f356d60ae5c7a7 100644 --- a/Include/internal/pycore_optimizer.h +++ b/Include/internal/pycore_optimizer.h @@ -534,7 +534,21 @@ typedef struct { uint8_t count; uint8_t indices[MAX_RECORDED_VALUES]; } _PyOpcodeRecordEntry; + +typedef struct { + uint8_t count; + uint8_t transform_mask; + uint8_t slots[MAX_RECORDED_VALUES]; +} _PyOpcodeRecordSlotMap; + PyAPI_DATA(const _PyOpcodeRecordEntry) _PyOpcode_RecordEntries[256]; +PyAPI_DATA(const _PyOpcodeRecordSlotMap) _PyOpcode_RecordSlotMaps[256]; + +/* Convert a family-recorded value to the form a recorder uop expects. + * If no transform is needed, return the input value unchanged. + * Takes ownership of `value` and returns a new strong reference or NULL. + */ +PyAPI_FUNC(PyObject *) _PyOpcode_RecordTransformValue(int uop, PyObject *value); #endif #ifdef __cplusplus diff --git a/Lib/test/test_capi/test_opt.py b/Lib/test/test_capi/test_opt.py index 39075fc64cf02b..b37c35495983c3 100644 --- a/Lib/test/test_capi/test_opt.py +++ b/Lib/test/test_capi/test_opt.py @@ -5849,6 +5849,19 @@ def testfunc(n): self.assertNotIn("_LOAD_SUPER_ATTR_METHOD", uops) self.assertEqual(uops.count("_GUARD_NOS_TYPE_VERSION"), 2) + def test_settrace_then_polymorphic_call_does_not_crash(self): + script_helper.assert_python_ok("-c", textwrap.dedent(""" + import sys + sys.settrace(lambda *_: None) + sys.settrace(None) + + class C: + def __init__(self, x): + pass + + for i in 0, 1, 0, 1: + C(0) if i else str(0) + """)) def global_identity(x): return x diff --git a/Lib/test/test_generated_cases.py b/Lib/test/test_generated_cases.py index 62cf0c0c6af0b2..748309b54593a1 100644 --- a/Lib/test/test_generated_cases.py +++ b/Lib/test/test_generated_cases.py @@ -2074,19 +2074,33 @@ def tearDown(self) -> None: pass super().tearDown() - def generate_tables(self, input: str) -> str: - import io + def analyze_input(self, input: str): with open(self.temp_input_filename, "w+") as f: f.write(parser.BEGIN_MARKER) f.write(input) f.write(parser.END_MARKER) with handle_stderr(): - analysis = analyze_files([self.temp_input_filename]) + return analyze_files([self.temp_input_filename]) + + def generate_tables(self, input: str) -> str: + import io + analysis = self.analyze_input(input) buf = io.StringIO() out = CWriter(buf, 0, False) record_function_generator.generate_recorder_tables(analysis, out) return buf.getvalue() + def get_slot_map_section(self, output: str) -> str: + return output.split( + "const _PyOpcodeRecordSlotMap _PyOpcode_RecordSlotMaps[256] = {\n", + 1, + )[1].split("};\n\n", 1)[0] + + def assert_slot_map_lines(self, output: str, *lines: str) -> None: + slot_map_section = self.get_slot_map_section(output) + for line in lines: + self.assertIn(line, slot_map_section) + def test_single_recording_uop_generates_count(self): input = """ tier2 op(_RECORD_TOS, (value -- value)) { @@ -2145,6 +2159,173 @@ def test_four_recording_uops_rejected(self): with self.assertRaisesRegex(ValueError, "exceeds MAX_RECORDED_VALUES"): self.generate_tables(input) + def test_family_member_needs_transform_only_when_shape_changes(self): + input = """ + tier2 op(_RECORD_TOS, (value -- value)) { + RECORD_VALUE(value); + } + tier2 op(_RECORD_TOS_TYPE, (value -- value)) { + RECORD_VALUE(Py_TYPE(value)); + } + op(_DO_STUFF, (value -- res)) { + res = value; + } + macro(OP_RAW) = _RECORD_TOS + _DO_STUFF; + macro(OP_RAW_SPECIALIZED) = _RECORD_TOS_TYPE + _DO_STUFF; + family(OP_RAW, INLINE_CACHE_ENTRIES_OP_RAW) = { OP_RAW_SPECIALIZED }; + + macro(OP_TYPED) = _RECORD_TOS_TYPE + _DO_STUFF; + macro(OP_TYPED_SPECIALIZED) = _RECORD_TOS_TYPE + _DO_STUFF; + family(OP_TYPED, INLINE_CACHE_ENTRIES_OP_TYPED) = { OP_TYPED_SPECIALIZED }; + """ + output = self.generate_tables(input) + self.assert_slot_map_lines( + output, + "[OP_RAW] = {1, 1, {0}}", + "[OP_RAW_SPECIALIZED] = {1, 0, {0}}", + "[OP_TYPED] = {1, 0, {0}}", + "[OP_TYPED_SPECIALIZED] = {1, 0, {0}}", + ) + + def test_family_member_maps_positional_recorders_to_family_slots(self): + input = """ + tier2 op(_RECORD_TOS, (sub -- sub)) { + RECORD_VALUE(sub); + } + tier2 op(_RECORD_NOS, (container, sub -- container, sub)) { + RECORD_VALUE(container); + } + op(_DO_STUFF, (container, sub -- res)) { + res = container; + } + macro(OP) = _RECORD_TOS + _RECORD_NOS + _DO_STUFF; + macro(OP_SPECIALIZED) = _RECORD_NOS + _DO_STUFF; + family(OP, INLINE_CACHE_ENTRIES_OP) = { OP_SPECIALIZED }; + """ + output = self.generate_tables(input) + self.assert_slot_map_lines( + output, + "[OP] = {2, 0, {1, 0}}", + "[OP_SPECIALIZED] = {1, 0, {0}}", + ) + + def test_family_member_maps_non_positional_recorders_by_stack_shape(self): + input = """ + tier2 op(_RECORD_CALLABLE, (callable, self, args[oparg] -- callable, self, args[oparg])) { + RECORD_VALUE(callable); + } + tier2 op(_RECORD_BOUND_METHOD, (callable, self, args[oparg] -- callable, self, args[oparg])) { + RECORD_VALUE(callable); + } + op(_DO_STUFF, (callable, self, args[oparg] -- res)) { + res = callable; + } + macro(OP) = _RECORD_CALLABLE + _DO_STUFF; + macro(OP_SPECIALIZED) = _RECORD_BOUND_METHOD + _DO_STUFF; + family(OP, INLINE_CACHE_ENTRIES_OP) = { OP_SPECIALIZED }; + """ + output = self.generate_tables(input) + self.assert_slot_map_lines( + output, + "[OP] = {1, 1, {0}}", + "[OP_SPECIALIZED] = {1, 0, {0}}", + ) + + def test_family_head_records_union_of_member_recorders(self): + input = """ + tier2 op(_RECORD_TOS, (value -- value)) { + RECORD_VALUE(value); + } + op(_DO_STUFF, (value -- res)) { + res = value; + } + macro(OP) = _DO_STUFF; + macro(OP_SPECIALIZED) = _RECORD_TOS + _DO_STUFF; + family(OP, INLINE_CACHE_ENTRIES_OP) = { OP_SPECIALIZED }; + """ + output = self.generate_tables(input) + self.assertIn("[OP] = {1, {_RECORD_TOS_INDEX}}", output) + self.assertIn("[OP_SPECIALIZED] = {1, {_RECORD_TOS_INDEX}}", output) + self.assert_slot_map_lines(output, "[OP_SPECIALIZED] = {1, 0, {0}}") + + def test_family_detects_base_and_specialized_recording_difference(self): + input = """ + tier2 op(_RECORD_TOS, (value -- value)) { + RECORD_VALUE(value); + } + tier2 op(_RECORD_TOS_TYPE, (value -- value)) { + RECORD_VALUE(Py_TYPE(value)); + } + op(_DO_STUFF, (value -- res)) { + res = value; + } + macro(OP) = _RECORD_TOS + _DO_STUFF; + macro(OP_SPECIALIZED) = _RECORD_TOS_TYPE + _DO_STUFF; + family(OP, INLINE_CACHE_ENTRIES_OP) = { OP_SPECIALIZED }; + """ + analysis = self.analyze_input(input) + output = self.generate_tables(input) + self.assertEqual( + record_function_generator.get_instruction_record_names( + analysis.instructions["OP"] + ), + ["_RECORD_TOS"], + ) + self.assertEqual( + record_function_generator.get_instruction_record_names( + analysis.instructions["OP_SPECIALIZED"] + ), + ["_RECORD_TOS_TYPE"], + ) + self.assertIn("[OP] = {1, {_RECORD_TOS_TYPE_INDEX}}", output) + self.assertIn("[OP_SPECIALIZED] = {1, {_RECORD_TOS_TYPE_INDEX}}", output) + self.assert_slot_map_lines( + output, + "[OP] = {1, 1, {0}}", + "[OP_SPECIALIZED] = {1, 0, {0}}", + ) + + def test_family_head_falls_back_for_missing_member_slots(self): + input = """ + tier2 op(_RECORD_TOS, (value -- value)) { + RECORD_VALUE(value); + } + op(_DO_STUFF, (value -- res)) { + res = value; + } + macro(OP) = _RECORD_TOS + _DO_STUFF; + macro(OP_SPECIALIZED) = _DO_STUFF; + family(OP, INLINE_CACHE_ENTRIES_OP) = { OP_SPECIALIZED }; + """ + output = self.generate_tables(input) + self.assertIn("[OP] = {1, {_RECORD_TOS_INDEX}}", output) + self.assertIn("[OP_SPECIALIZED] = {1, {_RECORD_TOS_INDEX}}", output) + + def test_family_mixed_slots_only_transform_changed_recorders(self): + input = """ + tier2 op(_RECORD_TOS_TYPE, (left, right -- left, right)) { + RECORD_VALUE(Py_TYPE(right)); + } + tier2 op(_RECORD_NOS_TYPE, (left, right -- left, right)) { + RECORD_VALUE(Py_TYPE(left)); + } + tier2 op(_RECORD_NOS, (left, right -- left, right)) { + RECORD_VALUE(left); + } + op(_DO_STUFF, (left, right -- res)) { + res = left; + } + macro(OP) = _RECORD_TOS_TYPE + _RECORD_NOS_TYPE + _DO_STUFF; + macro(OP_SPECIALIZED) = _RECORD_NOS + _DO_STUFF; + family(OP, INLINE_CACHE_ENTRIES_OP) = { OP_SPECIALIZED }; + """ + output = self.generate_tables(input) + self.assertIn("[OP] = {2, {_RECORD_NOS_INDEX, _RECORD_TOS_TYPE_INDEX}}", output) + self.assert_slot_map_lines( + output, + "[OP] = {2, 2, {1, 0}}", + "[OP_SPECIALIZED] = {1, 0, {0}}", + ) class TestGeneratedAbstractCases(unittest.TestCase): def setUp(self) -> None: diff --git a/Misc/NEWS.d/next/Core_and_Builtins/2026-04-18-16-41-04.gh-issue-148571.Q6WB3A.rst b/Misc/NEWS.d/next/Core_and_Builtins/2026-04-18-16-41-04.gh-issue-148571.Q6WB3A.rst new file mode 100644 index 00000000000000..70eeada34320ac --- /dev/null +++ b/Misc/NEWS.d/next/Core_and_Builtins/2026-04-18-16-41-04.gh-issue-148571.Q6WB3A.rst @@ -0,0 +1 @@ +Fix a crash in the JIT optimizer when specialized opcode families inherited incompatible recorded operand layouts. diff --git a/Python/optimizer.c b/Python/optimizer.c index 2ce4da0910f3c4..820a0771a2cb0f 100644 --- a/Python/optimizer.c +++ b/Python/optimizer.c @@ -660,6 +660,44 @@ is_terminator(const _PyUOpInstruction *uop) ); } +static PyObject * +record_trace_transform_to_type(PyObject *value) +{ + PyObject *tp = Py_NewRef((PyObject *)Py_TYPE(value)); + Py_DECREF(value); + return tp; +} + +/* _RECORD_NOS_GEN_FUNC and _RECORD_3OS_GEN_FUNC record the raw receiver. + * If it is a generator, return its function object; otherwise return NULL. + */ +static PyObject * +record_trace_transform_gen_func(PyObject *value) +{ + PyObject *func = NULL; + if (PyGen_Check(value)) { + _PyStackRef f = ((PyGenObject *)value)->gi_iframe.f_funcobj; + if (!PyStackRef_IsNull(f)) { + func = Py_NewRef(PyStackRef_AsPyObjectBorrow(f)); + } + } + Py_DECREF(value); + return func; +} + +/* _RECORD_BOUND_METHOD records the raw callable. + * Keep it only for bound methods; otherwise return NULL. + */ +static PyObject * +record_trace_transform_bound_method(PyObject *value) +{ + if (Py_TYPE(value) == &PyMethod_Type) { + return value; + } + Py_DECREF(value); + return NULL; +} + /* Returns 1 on success (added to trace), 0 on trace end. */ // gh-142543: inlining this function causes stack overflows @@ -833,6 +871,8 @@ _PyJit_translate_single_bytecode_to_trace( // One for possible _DEOPT, one because _CHECK_VALIDITY itself might _DEOPT trace->end -= 2; + const _PyOpcodeRecordSlotMap *record_slot_map = &_PyOpcode_RecordSlotMaps[opcode]; + assert(opcode != ENTER_EXECUTOR && opcode != EXTENDED_ARG); assert(!_PyErr_Occurred(tstate)); @@ -1029,8 +1069,15 @@ _PyJit_translate_single_bytecode_to_trace( } } else if (_PyUop_Flags[uop] & HAS_RECORDS_VALUE_FLAG) { - PyObject *recorded_value = tracer->prev_state.recorded_values[record_idx]; - tracer->prev_state.recorded_values[record_idx] = NULL; + assert(record_idx < record_slot_map->count); + uint8_t record_slot = record_slot_map->slots[record_idx]; + assert(record_slot < tracer->prev_state.recorded_count); + PyObject *recorded_value = tracer->prev_state.recorded_values[record_slot]; + tracer->prev_state.recorded_values[record_slot] = NULL; + if ((record_slot_map->transform_mask & (1u << record_idx)) && + recorded_value != NULL) { + recorded_value = _PyOpcode_RecordTransformValue(uop, recorded_value); + } record_idx++; operand = (uintptr_t)recorded_value; } diff --git a/Python/record_functions.c.h b/Python/record_functions.c.h index dff13bfb45e5b0..504f6e1d9901c3 100644 --- a/Python/record_functions.c.h +++ b/Python/record_functions.c.h @@ -103,19 +103,45 @@ void _PyOpcode_RecordFunction_CODE(_PyInterpreterFrame *frame, _PyStackRef *stac #define _RECORD_3OS_GEN_FUNC_INDEX 3 #define _RECORD_NOS_GEN_FUNC_INDEX 4 #define _RECORD_CALLABLE_INDEX 5 -#define _RECORD_BOUND_METHOD_INDEX 6 -#define _RECORD_CALLABLE_KW_INDEX 7 -#define _RECORD_4OS_INDEX 8 -#define _RECORD_NOS_TYPE_INDEX 9 +#define _RECORD_CALLABLE_KW_INDEX 6 +#define _RECORD_4OS_INDEX 7 const _PyOpcodeRecordEntry _PyOpcode_RecordEntries[256] = { + [TO_BOOL_BOOL] = {1, {_RECORD_TOS_TYPE_INDEX}}, + [TO_BOOL_NONE] = {1, {_RECORD_TOS_TYPE_INDEX}}, + [LOAD_SUPER_ATTR_ATTR] = {1, {_RECORD_NOS_INDEX}}, + [TO_BOOL] = {1, {_RECORD_TOS_TYPE_INDEX}}, + [TO_BOOL_INT] = {1, {_RECORD_TOS_TYPE_INDEX}}, + [TO_BOOL_LIST] = {1, {_RECORD_TOS_TYPE_INDEX}}, + [TO_BOOL_STR] = {1, {_RECORD_TOS_TYPE_INDEX}}, [TO_BOOL_ALWAYS_TRUE] = {1, {_RECORD_TOS_TYPE_INDEX}}, - [BINARY_OP_SUBSCR_GETITEM] = {1, {_RECORD_NOS_INDEX}}, + [BINARY_OP_MULTIPLY_INT] = {2, {_RECORD_NOS_INDEX, _RECORD_TOS_TYPE_INDEX}}, + [BINARY_OP_ADD_INT] = {2, {_RECORD_NOS_INDEX, _RECORD_TOS_TYPE_INDEX}}, + [BINARY_OP_SUBTRACT_INT] = {2, {_RECORD_NOS_INDEX, _RECORD_TOS_TYPE_INDEX}}, + [BINARY_OP_MULTIPLY_FLOAT] = {2, {_RECORD_NOS_INDEX, _RECORD_TOS_TYPE_INDEX}}, + [BINARY_OP_ADD_FLOAT] = {2, {_RECORD_NOS_INDEX, _RECORD_TOS_TYPE_INDEX}}, + [BINARY_OP_SUBTRACT_FLOAT] = {2, {_RECORD_NOS_INDEX, _RECORD_TOS_TYPE_INDEX}}, + [BINARY_OP_ADD_UNICODE] = {2, {_RECORD_NOS_INDEX, _RECORD_TOS_TYPE_INDEX}}, + [BINARY_OP_EXTEND] = {2, {_RECORD_NOS_INDEX, _RECORD_TOS_TYPE_INDEX}}, + [BINARY_OP_INPLACE_ADD_UNICODE] = {2, {_RECORD_NOS_INDEX, _RECORD_TOS_TYPE_INDEX}}, + [BINARY_OP_SUBSCR_LIST_INT] = {2, {_RECORD_NOS_INDEX, _RECORD_TOS_TYPE_INDEX}}, + [BINARY_OP_SUBSCR_LIST_SLICE] = {2, {_RECORD_NOS_INDEX, _RECORD_TOS_TYPE_INDEX}}, + [BINARY_OP_SUBSCR_STR_INT] = {2, {_RECORD_NOS_INDEX, _RECORD_TOS_TYPE_INDEX}}, + [BINARY_OP_SUBSCR_USTR_INT] = {2, {_RECORD_NOS_INDEX, _RECORD_TOS_TYPE_INDEX}}, + [BINARY_OP_SUBSCR_TUPLE_INT] = {2, {_RECORD_NOS_INDEX, _RECORD_TOS_TYPE_INDEX}}, + [BINARY_OP_SUBSCR_DICT] = {2, {_RECORD_NOS_INDEX, _RECORD_TOS_TYPE_INDEX}}, + [BINARY_OP_SUBSCR_GETITEM] = {2, {_RECORD_NOS_INDEX, _RECORD_TOS_TYPE_INDEX}}, + [SEND] = {1, {_RECORD_3OS_GEN_FUNC_INDEX}}, [SEND_GEN] = {1, {_RECORD_3OS_GEN_FUNC_INDEX}}, + [STORE_ATTR] = {1, {_RECORD_TOS_TYPE_INDEX}}, + [LOAD_SUPER_ATTR] = {1, {_RECORD_NOS_INDEX}}, [LOAD_SUPER_ATTR_METHOD] = {1, {_RECORD_NOS_INDEX}}, + [LOAD_ATTR] = {1, {_RECORD_TOS_TYPE_INDEX}}, [LOAD_ATTR_INSTANCE_VALUE] = {1, {_RECORD_TOS_TYPE_INDEX}}, + [LOAD_ATTR_MODULE] = {1, {_RECORD_TOS_TYPE_INDEX}}, [LOAD_ATTR_WITH_HINT] = {1, {_RECORD_TOS_TYPE_INDEX}}, [LOAD_ATTR_SLOT] = {1, {_RECORD_TOS_TYPE_INDEX}}, + [LOAD_ATTR_CLASS] = {1, {_RECORD_TOS_TYPE_INDEX}}, [LOAD_ATTR_CLASS_WITH_METACLASS_CHECK] = {1, {_RECORD_TOS_TYPE_INDEX}}, [LOAD_ATTR_PROPERTY] = {1, {_RECORD_TOS_TYPE_INDEX}}, [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = {1, {_RECORD_TOS_TYPE_INDEX}}, @@ -125,6 +151,11 @@ const _PyOpcodeRecordEntry _PyOpcode_RecordEntries[256] = { [GET_ITER] = {1, {_RECORD_TOS_TYPE_INDEX}}, [GET_ITER_SELF] = {1, {_RECORD_TOS_TYPE_INDEX}}, [GET_ITER_VIRTUAL] = {1, {_RECORD_TOS_TYPE_INDEX}}, + [FOR_ITER] = {1, {_RECORD_NOS_GEN_FUNC_INDEX}}, + [FOR_ITER_VIRTUAL] = {1, {_RECORD_NOS_GEN_FUNC_INDEX}}, + [FOR_ITER_LIST] = {1, {_RECORD_NOS_GEN_FUNC_INDEX}}, + [FOR_ITER_TUPLE] = {1, {_RECORD_NOS_GEN_FUNC_INDEX}}, + [FOR_ITER_RANGE] = {1, {_RECORD_NOS_GEN_FUNC_INDEX}}, [FOR_ITER_GEN] = {1, {_RECORD_NOS_GEN_FUNC_INDEX}}, [LOAD_SPECIAL] = {1, {_RECORD_TOS_TYPE_INDEX}}, [LOAD_ATTR_METHOD_WITH_VALUES] = {1, {_RECORD_TOS_TYPE_INDEX}}, @@ -132,34 +163,104 @@ const _PyOpcodeRecordEntry _PyOpcode_RecordEntries[256] = { [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = {1, {_RECORD_TOS_TYPE_INDEX}}, [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = {1, {_RECORD_TOS_TYPE_INDEX}}, [LOAD_ATTR_METHOD_LAZY_DICT] = {1, {_RECORD_TOS_TYPE_INDEX}}, + [CALL] = {1, {_RECORD_CALLABLE_INDEX}}, [CALL_PY_GENERAL] = {1, {_RECORD_CALLABLE_INDEX}}, - [CALL_BOUND_METHOD_GENERAL] = {1, {_RECORD_BOUND_METHOD_INDEX}}, + [CALL_BOUND_METHOD_GENERAL] = {1, {_RECORD_CALLABLE_INDEX}}, [CALL_NON_PY_GENERAL] = {1, {_RECORD_CALLABLE_INDEX}}, - [CALL_BOUND_METHOD_EXACT_ARGS] = {1, {_RECORD_BOUND_METHOD_INDEX}}, + [CALL_BOUND_METHOD_EXACT_ARGS] = {1, {_RECORD_CALLABLE_INDEX}}, [CALL_PY_EXACT_ARGS] = {1, {_RECORD_CALLABLE_INDEX}}, + [CALL_TYPE_1] = {1, {_RECORD_CALLABLE_INDEX}}, + [CALL_STR_1] = {1, {_RECORD_CALLABLE_INDEX}}, + [CALL_TUPLE_1] = {1, {_RECORD_CALLABLE_INDEX}}, [CALL_ALLOC_AND_ENTER_INIT] = {1, {_RECORD_CALLABLE_INDEX}}, [CALL_BUILTIN_CLASS] = {1, {_RECORD_CALLABLE_INDEX}}, [CALL_BUILTIN_O] = {1, {_RECORD_CALLABLE_INDEX}}, [CALL_BUILTIN_FAST] = {1, {_RECORD_CALLABLE_INDEX}}, [CALL_BUILTIN_FAST_WITH_KEYWORDS] = {1, {_RECORD_CALLABLE_INDEX}}, + [CALL_LEN] = {1, {_RECORD_CALLABLE_INDEX}}, + [CALL_ISINSTANCE] = {1, {_RECORD_CALLABLE_INDEX}}, + [CALL_LIST_APPEND] = {1, {_RECORD_CALLABLE_INDEX}}, [CALL_METHOD_DESCRIPTOR_O] = {1, {_RECORD_CALLABLE_INDEX}}, [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = {1, {_RECORD_CALLABLE_INDEX}}, [CALL_METHOD_DESCRIPTOR_NOARGS] = {1, {_RECORD_CALLABLE_INDEX}}, + [CALL_METHOD_DESCRIPTOR_FAST] = {1, {_RECORD_CALLABLE_INDEX}}, [CALL_KW_PY] = {1, {_RECORD_CALLABLE_KW_INDEX}}, [CALL_KW_BOUND_METHOD] = {1, {_RECORD_CALLABLE_KW_INDEX}}, + [CALL_KW] = {1, {_RECORD_CALLABLE_KW_INDEX}}, + [CALL_KW_NON_PY] = {1, {_RECORD_CALLABLE_KW_INDEX}}, + [CALL_FUNCTION_EX] = {1, {_RECORD_4OS_INDEX}}, [CALL_EX_PY] = {1, {_RECORD_4OS_INDEX}}, - [BINARY_OP] = {2, {_RECORD_TOS_TYPE_INDEX, _RECORD_NOS_TYPE_INDEX}}, + [CALL_EX_NON_PY_GENERAL] = {1, {_RECORD_4OS_INDEX}}, + [BINARY_OP] = {2, {_RECORD_NOS_INDEX, _RECORD_TOS_TYPE_INDEX}}, }; -const _Py_RecordFuncPtr _PyOpcode_RecordFunctions[10] = { +const _PyOpcodeRecordSlotMap _PyOpcode_RecordSlotMaps[256] = { + [TO_BOOL_ALWAYS_TRUE] = {1, 0, {0}}, + [BINARY_OP_SUBSCR_GETITEM] = {1, 0, {0}}, + [SEND_GEN] = {1, 0, {0}}, + [LOAD_SUPER_ATTR_METHOD] = {1, 0, {0}}, + [LOAD_ATTR_INSTANCE_VALUE] = {1, 0, {0}}, + [LOAD_ATTR_WITH_HINT] = {1, 0, {0}}, + [LOAD_ATTR_SLOT] = {1, 0, {0}}, + [LOAD_ATTR_CLASS_WITH_METACLASS_CHECK] = {1, 0, {0}}, + [LOAD_ATTR_PROPERTY] = {1, 0, {0}}, + [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = {1, 0, {0}}, + [STORE_ATTR_INSTANCE_VALUE] = {1, 0, {0}}, + [STORE_ATTR_WITH_HINT] = {1, 0, {0}}, + [STORE_ATTR_SLOT] = {1, 0, {0}}, + [GET_ITER] = {1, 0, {0}}, + [GET_ITER_SELF] = {1, 0, {0}}, + [GET_ITER_VIRTUAL] = {1, 0, {0}}, + [FOR_ITER_GEN] = {1, 0, {0}}, + [LOAD_SPECIAL] = {1, 0, {0}}, + [LOAD_ATTR_METHOD_WITH_VALUES] = {1, 0, {0}}, + [LOAD_ATTR_METHOD_NO_DICT] = {1, 0, {0}}, + [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = {1, 0, {0}}, + [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = {1, 0, {0}}, + [LOAD_ATTR_METHOD_LAZY_DICT] = {1, 0, {0}}, + [CALL_PY_GENERAL] = {1, 0, {0}}, + [CALL_BOUND_METHOD_GENERAL] = {1, 1, {0}}, + [CALL_NON_PY_GENERAL] = {1, 0, {0}}, + [CALL_BOUND_METHOD_EXACT_ARGS] = {1, 1, {0}}, + [CALL_PY_EXACT_ARGS] = {1, 0, {0}}, + [CALL_ALLOC_AND_ENTER_INIT] = {1, 0, {0}}, + [CALL_BUILTIN_CLASS] = {1, 0, {0}}, + [CALL_BUILTIN_O] = {1, 0, {0}}, + [CALL_BUILTIN_FAST] = {1, 0, {0}}, + [CALL_BUILTIN_FAST_WITH_KEYWORDS] = {1, 0, {0}}, + [CALL_METHOD_DESCRIPTOR_O] = {1, 0, {0}}, + [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = {1, 0, {0}}, + [CALL_METHOD_DESCRIPTOR_NOARGS] = {1, 0, {0}}, + [CALL_KW_PY] = {1, 0, {0}}, + [CALL_KW_BOUND_METHOD] = {1, 0, {0}}, + [CALL_EX_PY] = {1, 0, {0}}, + [BINARY_OP] = {2, 2, {1, 0}}, +}; + +const _Py_RecordFuncPtr _PyOpcode_RecordFunctions[8] = { [0] = NULL, [_RECORD_TOS_TYPE_INDEX] = _PyOpcode_RecordFunction_TOS_TYPE, [_RECORD_NOS_INDEX] = _PyOpcode_RecordFunction_NOS, [_RECORD_3OS_GEN_FUNC_INDEX] = _PyOpcode_RecordFunction_3OS_GEN_FUNC, [_RECORD_NOS_GEN_FUNC_INDEX] = _PyOpcode_RecordFunction_NOS_GEN_FUNC, [_RECORD_CALLABLE_INDEX] = _PyOpcode_RecordFunction_CALLABLE, - [_RECORD_BOUND_METHOD_INDEX] = _PyOpcode_RecordFunction_BOUND_METHOD, [_RECORD_CALLABLE_KW_INDEX] = _PyOpcode_RecordFunction_CALLABLE_KW, [_RECORD_4OS_INDEX] = _PyOpcode_RecordFunction_4OS, - [_RECORD_NOS_TYPE_INDEX] = _PyOpcode_RecordFunction_NOS_TYPE, }; + +PyObject * +_PyOpcode_RecordTransformValue(int uop, PyObject *value) +{ + switch (uop) { + case _RECORD_TOS_TYPE: + case _RECORD_NOS_TYPE: + return record_trace_transform_to_type(value); + case _RECORD_NOS_GEN_FUNC: + case _RECORD_3OS_GEN_FUNC: + return record_trace_transform_gen_func(value); + case _RECORD_BOUND_METHOD: + return record_trace_transform_bound_method(value); + default: + return value; + } +} diff --git a/Tools/cases_generator/record_function_generator.py b/Tools/cases_generator/record_function_generator.py index d7ae0ebf79fe62..6f518ffdcf2ac2 100644 --- a/Tools/cases_generator/record_function_generator.py +++ b/Tools/cases_generator/record_function_generator.py @@ -28,6 +28,21 @@ # Must match MAX_RECORDED_VALUES in Include/internal/pycore_optimizer.h. MAX_RECORDED_VALUES = 3 +# Map `_RECORD_*` uops to the helper that converts a raw family-recorded +# value to the form the specialized member consumes. +_RECORD_TRANSFORM_HELPERS: dict[str, str] = { + "_RECORD_TOS_TYPE": "record_trace_transform_to_type", + "_RECORD_NOS_TYPE": "record_trace_transform_to_type", + "_RECORD_NOS_GEN_FUNC": "record_trace_transform_gen_func", + "_RECORD_3OS_GEN_FUNC": "record_trace_transform_gen_func", + "_RECORD_BOUND_METHOD": "record_trace_transform_bound_method", +} + +# Recorder uops whose slot kind differs from the leading word of their name. +_RECORD_SLOT_KIND_OVERRIDES: dict[str, str] = { + "_RECORD_BOUND_METHOD": "CALLABLE", +} + class RecorderEmitter(Emitter): def __init__(self, out: CWriter): @@ -52,9 +67,83 @@ def record_value( return True +def get_record_slot_kind(record_name: str) -> str: + if record_name in _RECORD_SLOT_KIND_OVERRIDES: + return _RECORD_SLOT_KIND_OVERRIDES[record_name] + if not record_name.startswith("_RECORD_"): + return record_name + return record_name.removeprefix("_RECORD_").partition("_")[0] + + +def get_instruction_record_names(inst: Instruction) -> list[str]: + return [part.name for part in inst.parts if part.properties.records_value] + + +def get_family_record_names( + family_head: Instruction, + family_members: list[Instruction], + instruction_records: dict[str, list[str]], + record_slot_keys: dict[str, str], +) -> list[str]: + member_records = [instruction_records[m.name] for m in family_members] + all_member_names = {n for names in member_records for n in names} + records: list[str] = [] + slot_index: dict[str, int] = {} + + def add(name: str) -> None: + kind = record_slot_keys[name] + # Prefer the raw recorder if any member uses it; otherwise the given form. + raw = f"_RECORD_{kind}" + source = raw if raw in all_member_names else name + existing = slot_index.get(kind) + if existing is None: + slot_index[kind] = len(records) + records.append(source) + elif records[existing] != source: + raise ValueError( + f"Family {family_head.name} has incompatible recorders for " + f"slot {kind}: {records[existing]} and {source}" + ) + + for names in member_records: + for name in names: + add(name) + # Family head supplies any slots no member exercises. + for name in instruction_records[family_head.name]: + if record_slot_keys[name] not in slot_index: + slot_index[record_slot_keys[name]] = len(records) + records.append(name) + return records + + +def get_record_consumer_layout( + inst_name: str, + source_records: list[str], + own_records: list[str], + record_slot_keys: dict[str, str], +) -> tuple[list[int], int]: + used = [False] * len(source_records) + slot_map: list[int] = [] + transform_mask = 0 + for i, own in enumerate(own_records): + own_kind = record_slot_keys[own] + for j, src in enumerate(source_records): + if not used[j] and record_slot_keys[src] == own_kind: + used[j] = True + slot_map.append(j) + if src != own: + transform_mask |= 1 << i + break + else: + raise ValueError( + f"Instruction {inst_name} has no compatible family slot for " + f"{own} in {source_records}" + ) + return slot_map, transform_mask + def generate_recorder_functions(filenames: list[str], analysis: Analysis, out: CWriter) -> None: - write_header(__file__, filenames, outfile) - outfile.write( + write_header(__file__, filenames, out.out) + out.out.write( """ #ifdef TIER_ONE #error "This file is for Tier 2 only" @@ -63,13 +152,10 @@ def generate_recorder_functions(filenames: list[str], analysis: Analysis, out: C ) args = "_PyInterpreterFrame *frame, _PyStackRef *stack_pointer, int oparg, PyObject **recorded_value" emitter = RecorderEmitter(out) - func_count = 0 nop = analysis.instructions["NOP"] - function_table: dict[str, int] = dict() - for name, uop in analysis.uops.items(): + for uop in analysis.uops.values(): if not uop.properties.records_value: continue - func_count += 1 out.emit(f"void _PyOpcode_RecordFunction{uop.name[7:]}({args}) {{\n") seen = {"unused"} for var in uop.stack.inputs: @@ -83,42 +169,109 @@ def generate_recorder_functions(filenames: list[str], analysis: Analysis, out: C out.emit("\n\n") def generate_recorder_tables(analysis: Analysis, out: CWriter) -> None: - record_function_indexes: dict[str, int] = dict() + instruction_records = { + inst.name: get_instruction_record_names(inst) + for inst in analysis.instructions.values() + } + record_uop_names = [ + name for name, uop in analysis.uops.items() if uop.properties.records_value + ] + record_slot_keys = {name: get_record_slot_kind(name) for name in record_uop_names} + family_record_table = { + family.name: get_family_record_names( + analysis.instructions[family.name], + family.members, + instruction_records, + record_slot_keys, + ) + for family in analysis.families.values() + } + record_table: dict[str, list[str]] = {} - index = 1 + record_consumer_table: dict[str, tuple[list[int], int]] = {} + record_function_indexes: dict[str, int] = {} for inst in analysis.instructions.values(): - if not inst.properties.records_value: + own_records = instruction_records[inst.name] + # TRACE_RECORD runs before execution, but specialization may rewrite + # the opcode before translation. Record the raw family shape (union + # of head + members) so any opcode in the family can be translated + # from the same recorded layout. + family = inst.family or analysis.families.get(inst.name) + records = family_record_table[family.name] if family is not None else own_records + if not records: continue - records: list[str] = [] - for part in inst.parts: - if not part.properties.records_value: - continue - if part.name not in record_function_indexes: - record_function_indexes[part.name] = index - index += 1 - records.append(part.name) - if records: - if len(records) > MAX_RECORDED_VALUES: - raise ValueError( - f"Instruction {inst.name} has {len(records)} recording ops, " - f"exceeds MAX_RECORDED_VALUES ({MAX_RECORDED_VALUES})" - ) - record_table[inst.name] = records - func_count = len(record_function_indexes) + if len(records) > MAX_RECORDED_VALUES: + raise ValueError( + f"Instruction {inst.name} has {len(records)} recording ops, " + f"exceeds MAX_RECORDED_VALUES ({MAX_RECORDED_VALUES})" + ) + record_table[inst.name] = records + for name in records: + if name not in record_function_indexes: + record_function_indexes[name] = len(record_function_indexes) + 1 + if own_records: + record_consumer_table[inst.name] = get_record_consumer_layout( + inst.name, records, own_records, record_slot_keys + ) for name, index in record_function_indexes.items(): out.emit(f"#define {name}_INDEX {index}\n") out.emit("\n") + out.emit("const _PyOpcodeRecordEntry _PyOpcode_RecordEntries[256] = {\n") - for inst_name, record_names in record_table.items(): - indices = ", ".join(f"{name}_INDEX" for name in record_names) - out.emit(f" [{inst_name}] = {{{len(record_names)}, {{{indices}}}}},\n") + for inst_name, records in record_table.items(): + indices = ", ".join(f"{name}_INDEX" for name in records) + out.emit(f" [{inst_name}] = {{{len(records)}, {{{indices}}}}},\n") + out.emit("};\n\n") + + out.emit("const _PyOpcodeRecordSlotMap _PyOpcode_RecordSlotMaps[256] = {\n") + for inst_name, (slots, mask) in record_consumer_table.items(): + slot_list = ", ".join(str(s) for s in slots) + out.emit( + f" [{inst_name}] = {{{len(slots)}, {mask}, {{{slot_list}}}}},\n" + ) out.emit("};\n\n") - out.emit(f"const _Py_RecordFuncPtr _PyOpcode_RecordFunctions[{func_count+1}] = {{\n") + + out.emit( + f"const _Py_RecordFuncPtr _PyOpcode_RecordFunctions" + f"[{len(record_function_indexes) + 1}] = {{\n" + ) out.emit(" [0] = NULL,\n") for name in record_function_indexes: out.emit(f" [{name}_INDEX] = _PyOpcode_RecordFunction{name[7:]},\n") out.emit("};\n") + generate_record_transform_dispatcher(record_uop_names, out) + + +def generate_record_transform_dispatcher( + record_uop_names: list[str], out: CWriter +) -> None: + """Emit a switch that converts a family-recorded value for a recorder uop. + + Only `_RECORD_*` uops that need conversion get a case; the default + returns the input value unchanged. Helpers live in Python/optimizer.c. + """ + cases: dict[str, list[str]] = {} + for record_name in record_uop_names: + helper = _RECORD_TRANSFORM_HELPERS.get(record_name) + if helper is None: + continue + cases.setdefault(helper, []).append(record_name) + out.emit("\n") + out.emit( + "PyObject *\n" + "_PyOpcode_RecordTransformValue(int uop, PyObject *value)\n" + "{\n" + ) + out.emit(" switch (uop) {\n") + for helper, names in cases.items(): + for name in names: + out.emit(f" case {name}:\n") + out.emit(f" return {helper}(value);\n") + out.emit(" default:\n") + out.emit(" return value;\n") + out.emit(" }\n") + out.emit("}\n") arg_parser = argparse.ArgumentParser( From 2b6a13710f0fbf90a0d5f009d7188e934fab8d08 Mon Sep 17 00:00:00 2001 From: Neko Asakura Date: Tue, 28 Apr 2026 20:48:23 +0800 Subject: [PATCH 2/4] gh-148211: decompose `_SHUFFLE_3_LOAD_CONST_INLINE_BORROW` in JIT (GH-148816) --- Include/internal/pycore_uop_ids.h | 2041 ++++++++++++------------ Include/internal/pycore_uop_metadata.h | 21 - Lib/test/test_capi/test_opt.py | 2 +- Python/bytecodes.c | 7 - Python/executor_cases.c.h | 100 -- Python/optimizer_bytecodes.c | 5 +- Python/optimizer_cases.c.h | 20 +- 7 files changed, 1029 insertions(+), 1167 deletions(-) diff --git a/Include/internal/pycore_uop_ids.h b/Include/internal/pycore_uop_ids.h index 6b96f9bc78e8fe..9e54cb5f06adb2 100644 --- a/Include/internal/pycore_uop_ids.h +++ b/Include/internal/pycore_uop_ids.h @@ -382,1038 +382,1033 @@ extern "C" { #define _SET_ADD SET_ADD #define _SET_FUNCTION_ATTRIBUTE SET_FUNCTION_ATTRIBUTE #define _SET_UPDATE 606 -#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW 607 -#define _SPILL_OR_RELOAD 608 -#define _START_EXECUTOR 609 -#define _STORE_ATTR 610 -#define _STORE_ATTR_INSTANCE_VALUE 611 -#define _STORE_ATTR_SLOT 612 -#define _STORE_ATTR_WITH_HINT 613 +#define _SPILL_OR_RELOAD 607 +#define _START_EXECUTOR 608 +#define _STORE_ATTR 609 +#define _STORE_ATTR_INSTANCE_VALUE 610 +#define _STORE_ATTR_SLOT 611 +#define _STORE_ATTR_WITH_HINT 612 #define _STORE_DEREF STORE_DEREF #define _STORE_GLOBAL STORE_GLOBAL #define _STORE_NAME STORE_NAME -#define _STORE_SLICE 614 -#define _STORE_SUBSCR 615 -#define _STORE_SUBSCR_DICT 616 -#define _STORE_SUBSCR_DICT_KNOWN_HASH 617 -#define _STORE_SUBSCR_LIST_INT 618 -#define _SWAP 619 -#define _SWAP_2 620 -#define _SWAP_3 621 -#define _SWAP_FAST 622 -#define _SWAP_FAST_0 623 -#define _SWAP_FAST_1 624 -#define _SWAP_FAST_2 625 -#define _SWAP_FAST_3 626 -#define _SWAP_FAST_4 627 -#define _SWAP_FAST_5 628 -#define _SWAP_FAST_6 629 -#define _SWAP_FAST_7 630 -#define _TIER2_RESUME_CHECK 631 -#define _TO_BOOL 632 +#define _STORE_SLICE 613 +#define _STORE_SUBSCR 614 +#define _STORE_SUBSCR_DICT 615 +#define _STORE_SUBSCR_DICT_KNOWN_HASH 616 +#define _STORE_SUBSCR_LIST_INT 617 +#define _SWAP 618 +#define _SWAP_2 619 +#define _SWAP_3 620 +#define _SWAP_FAST 621 +#define _SWAP_FAST_0 622 +#define _SWAP_FAST_1 623 +#define _SWAP_FAST_2 624 +#define _SWAP_FAST_3 625 +#define _SWAP_FAST_4 626 +#define _SWAP_FAST_5 627 +#define _SWAP_FAST_6 628 +#define _SWAP_FAST_7 629 +#define _TIER2_RESUME_CHECK 630 +#define _TO_BOOL 631 #define _TO_BOOL_BOOL TO_BOOL_BOOL -#define _TO_BOOL_INT 633 -#define _TO_BOOL_LIST 634 +#define _TO_BOOL_INT 632 +#define _TO_BOOL_LIST 633 #define _TO_BOOL_NONE TO_BOOL_NONE -#define _TO_BOOL_STR 635 +#define _TO_BOOL_STR 634 #define _TRACE_RECORD TRACE_RECORD -#define _UNARY_INVERT 636 -#define _UNARY_NEGATIVE 637 -#define _UNARY_NEGATIVE_FLOAT_INPLACE 638 +#define _UNARY_INVERT 635 +#define _UNARY_NEGATIVE 636 +#define _UNARY_NEGATIVE_FLOAT_INPLACE 637 #define _UNARY_NOT UNARY_NOT #define _UNPACK_EX UNPACK_EX -#define _UNPACK_SEQUENCE 639 -#define _UNPACK_SEQUENCE_LIST 640 -#define _UNPACK_SEQUENCE_TUPLE 641 -#define _UNPACK_SEQUENCE_TWO_TUPLE 642 -#define _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE 643 -#define _UNPACK_SEQUENCE_UNIQUE_TUPLE 644 -#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE 645 +#define _UNPACK_SEQUENCE 638 +#define _UNPACK_SEQUENCE_LIST 639 +#define _UNPACK_SEQUENCE_TUPLE 640 +#define _UNPACK_SEQUENCE_TWO_TUPLE 641 +#define _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE 642 +#define _UNPACK_SEQUENCE_UNIQUE_TUPLE 643 +#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE 644 #define _WITH_EXCEPT_START WITH_EXCEPT_START -#define _YIELD_VALUE 646 -#define MAX_UOP_ID 646 -#define _ALLOCATE_OBJECT_r00 647 -#define _BINARY_OP_r23 648 -#define _BINARY_OP_ADD_FLOAT_r03 649 -#define _BINARY_OP_ADD_FLOAT_r13 650 -#define _BINARY_OP_ADD_FLOAT_r23 651 -#define _BINARY_OP_ADD_FLOAT_INPLACE_r03 652 -#define _BINARY_OP_ADD_FLOAT_INPLACE_r13 653 -#define _BINARY_OP_ADD_FLOAT_INPLACE_r23 654 -#define _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT_r03 655 -#define _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT_r13 656 -#define _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT_r23 657 -#define _BINARY_OP_ADD_INT_r03 658 -#define _BINARY_OP_ADD_INT_r13 659 -#define _BINARY_OP_ADD_INT_r23 660 -#define _BINARY_OP_ADD_INT_INPLACE_r03 661 -#define _BINARY_OP_ADD_INT_INPLACE_r13 662 -#define _BINARY_OP_ADD_INT_INPLACE_r23 663 -#define _BINARY_OP_ADD_INT_INPLACE_RIGHT_r03 664 -#define _BINARY_OP_ADD_INT_INPLACE_RIGHT_r13 665 -#define _BINARY_OP_ADD_INT_INPLACE_RIGHT_r23 666 -#define _BINARY_OP_ADD_UNICODE_r03 667 -#define _BINARY_OP_ADD_UNICODE_r13 668 -#define _BINARY_OP_ADD_UNICODE_r23 669 -#define _BINARY_OP_EXTEND_r23 670 -#define _BINARY_OP_INPLACE_ADD_UNICODE_r21 671 -#define _BINARY_OP_MULTIPLY_FLOAT_r03 672 -#define _BINARY_OP_MULTIPLY_FLOAT_r13 673 -#define _BINARY_OP_MULTIPLY_FLOAT_r23 674 -#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_r03 675 -#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_r13 676 -#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_r23 677 -#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT_r03 678 -#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT_r13 679 -#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT_r23 680 -#define _BINARY_OP_MULTIPLY_INT_r03 681 -#define _BINARY_OP_MULTIPLY_INT_r13 682 -#define _BINARY_OP_MULTIPLY_INT_r23 683 -#define _BINARY_OP_MULTIPLY_INT_INPLACE_r03 684 -#define _BINARY_OP_MULTIPLY_INT_INPLACE_r13 685 -#define _BINARY_OP_MULTIPLY_INT_INPLACE_r23 686 -#define _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT_r03 687 -#define _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT_r13 688 -#define _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT_r23 689 -#define _BINARY_OP_SUBSCR_CHECK_FUNC_r23 690 -#define _BINARY_OP_SUBSCR_DICT_r23 691 -#define _BINARY_OP_SUBSCR_DICT_KNOWN_HASH_r23 692 -#define _BINARY_OP_SUBSCR_INIT_CALL_r01 693 -#define _BINARY_OP_SUBSCR_INIT_CALL_r11 694 -#define _BINARY_OP_SUBSCR_INIT_CALL_r21 695 -#define _BINARY_OP_SUBSCR_INIT_CALL_r31 696 -#define _BINARY_OP_SUBSCR_LIST_INT_r23 697 -#define _BINARY_OP_SUBSCR_LIST_SLICE_r23 698 -#define _BINARY_OP_SUBSCR_STR_INT_r23 699 -#define _BINARY_OP_SUBSCR_TUPLE_INT_r03 700 -#define _BINARY_OP_SUBSCR_TUPLE_INT_r13 701 -#define _BINARY_OP_SUBSCR_TUPLE_INT_r23 702 -#define _BINARY_OP_SUBSCR_USTR_INT_r23 703 -#define _BINARY_OP_SUBTRACT_FLOAT_r03 704 -#define _BINARY_OP_SUBTRACT_FLOAT_r13 705 -#define _BINARY_OP_SUBTRACT_FLOAT_r23 706 -#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_r03 707 -#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_r13 708 -#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_r23 709 -#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT_r03 710 -#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT_r13 711 -#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT_r23 712 -#define _BINARY_OP_SUBTRACT_INT_r03 713 -#define _BINARY_OP_SUBTRACT_INT_r13 714 -#define _BINARY_OP_SUBTRACT_INT_r23 715 -#define _BINARY_OP_SUBTRACT_INT_INPLACE_r03 716 -#define _BINARY_OP_SUBTRACT_INT_INPLACE_r13 717 -#define _BINARY_OP_SUBTRACT_INT_INPLACE_r23 718 -#define _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT_r03 719 -#define _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT_r13 720 -#define _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT_r23 721 -#define _BINARY_OP_TRUEDIV_FLOAT_r23 722 -#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_r03 723 -#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_r13 724 -#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_r23 725 -#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r03 726 -#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r13 727 -#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r23 728 -#define _BINARY_SLICE_r31 729 -#define _BUILD_INTERPOLATION_r01 730 -#define _BUILD_LIST_r01 731 -#define _BUILD_MAP_r01 732 -#define _BUILD_SET_r01 733 -#define _BUILD_SLICE_r01 734 -#define _BUILD_STRING_r01 735 -#define _BUILD_TEMPLATE_r21 736 -#define _BUILD_TUPLE_r01 737 -#define _CALL_BUILTIN_CLASS_r00 738 -#define _CALL_BUILTIN_FAST_r00 739 -#define _CALL_BUILTIN_FAST_WITH_KEYWORDS_r00 740 -#define _CALL_BUILTIN_O_r03 741 -#define _CALL_FUNCTION_EX_NON_PY_GENERAL_r31 742 -#define _CALL_INTRINSIC_1_r12 743 -#define _CALL_INTRINSIC_2_r23 744 -#define _CALL_ISINSTANCE_r31 745 -#define _CALL_KW_NON_PY_r11 746 -#define _CALL_LEN_r33 747 -#define _CALL_LIST_APPEND_r03 748 -#define _CALL_LIST_APPEND_r13 749 -#define _CALL_LIST_APPEND_r23 750 -#define _CALL_LIST_APPEND_r33 751 -#define _CALL_METHOD_DESCRIPTOR_FAST_r00 752 -#define _CALL_METHOD_DESCRIPTOR_FAST_INLINE_r00 753 -#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r00 754 -#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_INLINE_r00 755 -#define _CALL_METHOD_DESCRIPTOR_NOARGS_r03 756 -#define _CALL_METHOD_DESCRIPTOR_NOARGS_INLINE_r03 757 -#define _CALL_METHOD_DESCRIPTOR_O_r03 758 -#define _CALL_METHOD_DESCRIPTOR_O_INLINE_r03 759 -#define _CALL_NON_PY_GENERAL_r01 760 -#define _CALL_STR_1_r32 761 -#define _CALL_TUPLE_1_r32 762 -#define _CALL_TYPE_1_r02 763 -#define _CALL_TYPE_1_r12 764 -#define _CALL_TYPE_1_r22 765 -#define _CALL_TYPE_1_r32 766 -#define _CHECK_ATTR_CLASS_r01 767 -#define _CHECK_ATTR_CLASS_r11 768 -#define _CHECK_ATTR_CLASS_r22 769 -#define _CHECK_ATTR_CLASS_r33 770 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r01 771 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r11 772 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r22 773 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r33 774 -#define _CHECK_CALL_BOUND_METHOD_EXACT_ARGS_r00 775 -#define _CHECK_EG_MATCH_r22 776 -#define _CHECK_EXC_MATCH_r22 777 -#define _CHECK_FUNCTION_EXACT_ARGS_r00 778 -#define _CHECK_FUNCTION_VERSION_r00 779 -#define _CHECK_FUNCTION_VERSION_INLINE_r00 780 -#define _CHECK_FUNCTION_VERSION_INLINE_r11 781 -#define _CHECK_FUNCTION_VERSION_INLINE_r22 782 -#define _CHECK_FUNCTION_VERSION_INLINE_r33 783 -#define _CHECK_FUNCTION_VERSION_KW_r11 784 -#define _CHECK_IS_NOT_PY_CALLABLE_r00 785 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r03 786 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r13 787 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r23 788 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r33 789 -#define _CHECK_IS_NOT_PY_CALLABLE_KW_r11 790 -#define _CHECK_IS_PY_CALLABLE_EX_r03 791 -#define _CHECK_IS_PY_CALLABLE_EX_r13 792 -#define _CHECK_IS_PY_CALLABLE_EX_r23 793 -#define _CHECK_IS_PY_CALLABLE_EX_r33 794 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r01 795 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r11 796 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r22 797 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r33 798 -#define _CHECK_METHOD_VERSION_r00 799 -#define _CHECK_METHOD_VERSION_KW_r11 800 -#define _CHECK_OBJECT_r00 801 -#define _CHECK_PEP_523_r00 802 -#define _CHECK_PEP_523_r11 803 -#define _CHECK_PEP_523_r22 804 -#define _CHECK_PEP_523_r33 805 -#define _CHECK_PERIODIC_r00 806 -#define _CHECK_PERIODIC_AT_END_r00 807 -#define _CHECK_PERIODIC_IF_NOT_YIELD_FROM_r00 808 -#define _CHECK_RECURSION_LIMIT_r00 809 -#define _CHECK_RECURSION_LIMIT_r11 810 -#define _CHECK_RECURSION_LIMIT_r22 811 -#define _CHECK_RECURSION_LIMIT_r33 812 -#define _CHECK_RECURSION_REMAINING_r00 813 -#define _CHECK_RECURSION_REMAINING_r11 814 -#define _CHECK_RECURSION_REMAINING_r22 815 -#define _CHECK_RECURSION_REMAINING_r33 816 -#define _CHECK_STACK_SPACE_r00 817 -#define _CHECK_STACK_SPACE_OPERAND_r00 818 -#define _CHECK_STACK_SPACE_OPERAND_r11 819 -#define _CHECK_STACK_SPACE_OPERAND_r22 820 -#define _CHECK_STACK_SPACE_OPERAND_r33 821 -#define _CHECK_VALIDITY_r00 822 -#define _CHECK_VALIDITY_r11 823 -#define _CHECK_VALIDITY_r22 824 -#define _CHECK_VALIDITY_r33 825 -#define _COLD_DYNAMIC_EXIT_r00 826 -#define _COLD_EXIT_r00 827 -#define _COMPARE_OP_r21 828 -#define _COMPARE_OP_FLOAT_r03 829 -#define _COMPARE_OP_FLOAT_r13 830 -#define _COMPARE_OP_FLOAT_r23 831 -#define _COMPARE_OP_INT_r23 832 -#define _COMPARE_OP_STR_r23 833 -#define _CONTAINS_OP_r23 834 -#define _CONTAINS_OP_DICT_r23 835 -#define _CONTAINS_OP_SET_r23 836 -#define _CONVERT_VALUE_r11 837 -#define _COPY_r01 838 -#define _COPY_1_r02 839 -#define _COPY_1_r12 840 -#define _COPY_1_r23 841 -#define _COPY_2_r03 842 -#define _COPY_2_r13 843 -#define _COPY_2_r23 844 -#define _COPY_3_r03 845 -#define _COPY_3_r13 846 -#define _COPY_3_r23 847 -#define _COPY_3_r33 848 -#define _COPY_FREE_VARS_r00 849 -#define _COPY_FREE_VARS_r11 850 -#define _COPY_FREE_VARS_r22 851 -#define _COPY_FREE_VARS_r33 852 -#define _CREATE_INIT_FRAME_r01 853 -#define _DELETE_ATTR_r10 854 -#define _DELETE_DEREF_r00 855 -#define _DELETE_FAST_r00 856 -#define _DELETE_GLOBAL_r00 857 -#define _DELETE_NAME_r00 858 -#define _DELETE_SUBSCR_r20 859 -#define _DEOPT_r00 860 -#define _DEOPT_r10 861 -#define _DEOPT_r20 862 -#define _DEOPT_r30 863 -#define _DICT_MERGE_r11 864 -#define _DICT_UPDATE_r11 865 -#define _DO_CALL_r01 866 -#define _DO_CALL_FUNCTION_EX_r31 867 -#define _DO_CALL_KW_r11 868 -#define _DYNAMIC_EXIT_r00 869 -#define _DYNAMIC_EXIT_r10 870 -#define _DYNAMIC_EXIT_r20 871 -#define _DYNAMIC_EXIT_r30 872 -#define _END_FOR_r10 873 -#define _END_SEND_r31 874 -#define _ERROR_POP_N_r00 875 -#define _EXIT_INIT_CHECK_r10 876 -#define _EXIT_TRACE_r00 877 -#define _EXIT_TRACE_r10 878 -#define _EXIT_TRACE_r20 879 -#define _EXIT_TRACE_r30 880 -#define _EXPAND_METHOD_r00 881 -#define _EXPAND_METHOD_KW_r11 882 -#define _FATAL_ERROR_r00 883 -#define _FATAL_ERROR_r11 884 -#define _FATAL_ERROR_r22 885 -#define _FATAL_ERROR_r33 886 -#define _FORMAT_SIMPLE_r11 887 -#define _FORMAT_WITH_SPEC_r21 888 -#define _FOR_ITER_r23 889 -#define _FOR_ITER_GEN_FRAME_r03 890 -#define _FOR_ITER_GEN_FRAME_r13 891 -#define _FOR_ITER_GEN_FRAME_r23 892 -#define _FOR_ITER_TIER_TWO_r23 893 -#define _FOR_ITER_VIRTUAL_r23 894 -#define _FOR_ITER_VIRTUAL_TIER_TWO_r23 895 -#define _GET_AITER_r11 896 -#define _GET_ANEXT_r12 897 -#define _GET_AWAITABLE_r11 898 -#define _GET_ITER_r12 899 -#define _GET_ITER_TRAD_r12 900 -#define _GET_LEN_r12 901 -#define _GUARD_BINARY_OP_EXTEND_r22 902 -#define _GUARD_BINARY_OP_EXTEND_LHS_r02 903 -#define _GUARD_BINARY_OP_EXTEND_LHS_r12 904 -#define _GUARD_BINARY_OP_EXTEND_LHS_r22 905 -#define _GUARD_BINARY_OP_EXTEND_LHS_r33 906 -#define _GUARD_BINARY_OP_EXTEND_RHS_r02 907 -#define _GUARD_BINARY_OP_EXTEND_RHS_r12 908 -#define _GUARD_BINARY_OP_EXTEND_RHS_r22 909 -#define _GUARD_BINARY_OP_EXTEND_RHS_r33 910 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r02 911 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r12 912 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r22 913 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r33 914 -#define _GUARD_BIT_IS_SET_POP_r00 915 -#define _GUARD_BIT_IS_SET_POP_r10 916 -#define _GUARD_BIT_IS_SET_POP_r21 917 -#define _GUARD_BIT_IS_SET_POP_r32 918 -#define _GUARD_BIT_IS_SET_POP_4_r00 919 -#define _GUARD_BIT_IS_SET_POP_4_r10 920 -#define _GUARD_BIT_IS_SET_POP_4_r21 921 -#define _GUARD_BIT_IS_SET_POP_4_r32 922 -#define _GUARD_BIT_IS_SET_POP_5_r00 923 -#define _GUARD_BIT_IS_SET_POP_5_r10 924 -#define _GUARD_BIT_IS_SET_POP_5_r21 925 -#define _GUARD_BIT_IS_SET_POP_5_r32 926 -#define _GUARD_BIT_IS_SET_POP_6_r00 927 -#define _GUARD_BIT_IS_SET_POP_6_r10 928 -#define _GUARD_BIT_IS_SET_POP_6_r21 929 -#define _GUARD_BIT_IS_SET_POP_6_r32 930 -#define _GUARD_BIT_IS_SET_POP_7_r00 931 -#define _GUARD_BIT_IS_SET_POP_7_r10 932 -#define _GUARD_BIT_IS_SET_POP_7_r21 933 -#define _GUARD_BIT_IS_SET_POP_7_r32 934 -#define _GUARD_BIT_IS_UNSET_POP_r00 935 -#define _GUARD_BIT_IS_UNSET_POP_r10 936 -#define _GUARD_BIT_IS_UNSET_POP_r21 937 -#define _GUARD_BIT_IS_UNSET_POP_r32 938 -#define _GUARD_BIT_IS_UNSET_POP_4_r00 939 -#define _GUARD_BIT_IS_UNSET_POP_4_r10 940 -#define _GUARD_BIT_IS_UNSET_POP_4_r21 941 -#define _GUARD_BIT_IS_UNSET_POP_4_r32 942 -#define _GUARD_BIT_IS_UNSET_POP_5_r00 943 -#define _GUARD_BIT_IS_UNSET_POP_5_r10 944 -#define _GUARD_BIT_IS_UNSET_POP_5_r21 945 -#define _GUARD_BIT_IS_UNSET_POP_5_r32 946 -#define _GUARD_BIT_IS_UNSET_POP_6_r00 947 -#define _GUARD_BIT_IS_UNSET_POP_6_r10 948 -#define _GUARD_BIT_IS_UNSET_POP_6_r21 949 -#define _GUARD_BIT_IS_UNSET_POP_6_r32 950 -#define _GUARD_BIT_IS_UNSET_POP_7_r00 951 -#define _GUARD_BIT_IS_UNSET_POP_7_r10 952 -#define _GUARD_BIT_IS_UNSET_POP_7_r21 953 -#define _GUARD_BIT_IS_UNSET_POP_7_r32 954 -#define _GUARD_CALLABLE_BUILTIN_CLASS_r00 955 -#define _GUARD_CALLABLE_BUILTIN_FAST_r00 956 -#define _GUARD_CALLABLE_BUILTIN_FAST_WITH_KEYWORDS_r00 957 -#define _GUARD_CALLABLE_BUILTIN_O_r00 958 -#define _GUARD_CALLABLE_ISINSTANCE_r03 959 -#define _GUARD_CALLABLE_ISINSTANCE_r13 960 -#define _GUARD_CALLABLE_ISINSTANCE_r23 961 -#define _GUARD_CALLABLE_ISINSTANCE_r33 962 -#define _GUARD_CALLABLE_LEN_r03 963 -#define _GUARD_CALLABLE_LEN_r13 964 -#define _GUARD_CALLABLE_LEN_r23 965 -#define _GUARD_CALLABLE_LEN_r33 966 -#define _GUARD_CALLABLE_LIST_APPEND_r03 967 -#define _GUARD_CALLABLE_LIST_APPEND_r13 968 -#define _GUARD_CALLABLE_LIST_APPEND_r23 969 -#define _GUARD_CALLABLE_LIST_APPEND_r33 970 -#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST_r00 971 -#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r00 972 -#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_NOARGS_r00 973 -#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_O_r00 974 -#define _GUARD_CALLABLE_STR_1_r03 975 -#define _GUARD_CALLABLE_STR_1_r13 976 -#define _GUARD_CALLABLE_STR_1_r23 977 -#define _GUARD_CALLABLE_STR_1_r33 978 -#define _GUARD_CALLABLE_TUPLE_1_r03 979 -#define _GUARD_CALLABLE_TUPLE_1_r13 980 -#define _GUARD_CALLABLE_TUPLE_1_r23 981 -#define _GUARD_CALLABLE_TUPLE_1_r33 982 -#define _GUARD_CALLABLE_TYPE_1_r03 983 -#define _GUARD_CALLABLE_TYPE_1_r13 984 -#define _GUARD_CALLABLE_TYPE_1_r23 985 -#define _GUARD_CALLABLE_TYPE_1_r33 986 -#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r00 987 -#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r11 988 -#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r22 989 -#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r33 990 -#define _GUARD_CODE_VERSION_RETURN_VALUE_r00 991 -#define _GUARD_CODE_VERSION_RETURN_VALUE_r11 992 -#define _GUARD_CODE_VERSION_RETURN_VALUE_r22 993 -#define _GUARD_CODE_VERSION_RETURN_VALUE_r33 994 -#define _GUARD_CODE_VERSION_YIELD_VALUE_r00 995 -#define _GUARD_CODE_VERSION_YIELD_VALUE_r11 996 -#define _GUARD_CODE_VERSION_YIELD_VALUE_r22 997 -#define _GUARD_CODE_VERSION_YIELD_VALUE_r33 998 -#define _GUARD_CODE_VERSION__PUSH_FRAME_r00 999 -#define _GUARD_CODE_VERSION__PUSH_FRAME_r11 1000 -#define _GUARD_CODE_VERSION__PUSH_FRAME_r22 1001 -#define _GUARD_CODE_VERSION__PUSH_FRAME_r33 1002 -#define _GUARD_DORV_NO_DICT_r01 1003 -#define _GUARD_DORV_NO_DICT_r11 1004 -#define _GUARD_DORV_NO_DICT_r22 1005 -#define _GUARD_DORV_NO_DICT_r33 1006 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r01 1007 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r11 1008 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r22 1009 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r33 1010 -#define _GUARD_GLOBALS_VERSION_r00 1011 -#define _GUARD_GLOBALS_VERSION_r11 1012 -#define _GUARD_GLOBALS_VERSION_r22 1013 -#define _GUARD_GLOBALS_VERSION_r33 1014 -#define _GUARD_IP_RETURN_GENERATOR_r00 1015 -#define _GUARD_IP_RETURN_GENERATOR_r11 1016 -#define _GUARD_IP_RETURN_GENERATOR_r22 1017 -#define _GUARD_IP_RETURN_GENERATOR_r33 1018 -#define _GUARD_IP_RETURN_VALUE_r00 1019 -#define _GUARD_IP_RETURN_VALUE_r11 1020 -#define _GUARD_IP_RETURN_VALUE_r22 1021 -#define _GUARD_IP_RETURN_VALUE_r33 1022 -#define _GUARD_IP_YIELD_VALUE_r00 1023 -#define _GUARD_IP_YIELD_VALUE_r11 1024 -#define _GUARD_IP_YIELD_VALUE_r22 1025 -#define _GUARD_IP_YIELD_VALUE_r33 1026 -#define _GUARD_IP__PUSH_FRAME_r00 1027 -#define _GUARD_IP__PUSH_FRAME_r11 1028 -#define _GUARD_IP__PUSH_FRAME_r22 1029 -#define _GUARD_IP__PUSH_FRAME_r33 1030 -#define _GUARD_IS_FALSE_POP_r00 1031 -#define _GUARD_IS_FALSE_POP_r10 1032 -#define _GUARD_IS_FALSE_POP_r21 1033 -#define _GUARD_IS_FALSE_POP_r32 1034 -#define _GUARD_IS_NONE_POP_r00 1035 -#define _GUARD_IS_NONE_POP_r10 1036 -#define _GUARD_IS_NONE_POP_r21 1037 -#define _GUARD_IS_NONE_POP_r32 1038 -#define _GUARD_IS_NOT_NONE_POP_r10 1039 -#define _GUARD_IS_TRUE_POP_r00 1040 -#define _GUARD_IS_TRUE_POP_r10 1041 -#define _GUARD_IS_TRUE_POP_r21 1042 -#define _GUARD_IS_TRUE_POP_r32 1043 -#define _GUARD_ITERATOR_r01 1044 -#define _GUARD_ITERATOR_r11 1045 -#define _GUARD_ITERATOR_r22 1046 -#define _GUARD_ITERATOR_r33 1047 -#define _GUARD_ITER_VIRTUAL_r01 1048 -#define _GUARD_ITER_VIRTUAL_r11 1049 -#define _GUARD_ITER_VIRTUAL_r22 1050 -#define _GUARD_ITER_VIRTUAL_r33 1051 -#define _GUARD_KEYS_VERSION_r01 1052 -#define _GUARD_KEYS_VERSION_r11 1053 -#define _GUARD_KEYS_VERSION_r22 1054 -#define _GUARD_KEYS_VERSION_r33 1055 -#define _GUARD_LOAD_SUPER_ATTR_METHOD_r03 1056 -#define _GUARD_LOAD_SUPER_ATTR_METHOD_r13 1057 -#define _GUARD_LOAD_SUPER_ATTR_METHOD_r23 1058 -#define _GUARD_LOAD_SUPER_ATTR_METHOD_r33 1059 -#define _GUARD_NOS_ANY_DICT_r02 1060 -#define _GUARD_NOS_ANY_DICT_r12 1061 -#define _GUARD_NOS_ANY_DICT_r22 1062 -#define _GUARD_NOS_ANY_DICT_r33 1063 -#define _GUARD_NOS_COMPACT_ASCII_r02 1064 -#define _GUARD_NOS_COMPACT_ASCII_r12 1065 -#define _GUARD_NOS_COMPACT_ASCII_r22 1066 -#define _GUARD_NOS_COMPACT_ASCII_r33 1067 -#define _GUARD_NOS_DICT_r02 1068 -#define _GUARD_NOS_DICT_r12 1069 -#define _GUARD_NOS_DICT_r22 1070 -#define _GUARD_NOS_DICT_r33 1071 -#define _GUARD_NOS_FLOAT_r02 1072 -#define _GUARD_NOS_FLOAT_r12 1073 -#define _GUARD_NOS_FLOAT_r22 1074 -#define _GUARD_NOS_FLOAT_r33 1075 -#define _GUARD_NOS_INT_r02 1076 -#define _GUARD_NOS_INT_r12 1077 -#define _GUARD_NOS_INT_r22 1078 -#define _GUARD_NOS_INT_r33 1079 -#define _GUARD_NOS_ITER_VIRTUAL_r02 1080 -#define _GUARD_NOS_ITER_VIRTUAL_r12 1081 -#define _GUARD_NOS_ITER_VIRTUAL_r22 1082 -#define _GUARD_NOS_ITER_VIRTUAL_r33 1083 -#define _GUARD_NOS_LIST_r02 1084 -#define _GUARD_NOS_LIST_r12 1085 -#define _GUARD_NOS_LIST_r22 1086 -#define _GUARD_NOS_LIST_r33 1087 -#define _GUARD_NOS_NOT_NULL_r02 1088 -#define _GUARD_NOS_NOT_NULL_r12 1089 -#define _GUARD_NOS_NOT_NULL_r22 1090 -#define _GUARD_NOS_NOT_NULL_r33 1091 -#define _GUARD_NOS_NULL_r02 1092 -#define _GUARD_NOS_NULL_r12 1093 -#define _GUARD_NOS_NULL_r22 1094 -#define _GUARD_NOS_NULL_r33 1095 -#define _GUARD_NOS_OVERFLOWED_r02 1096 -#define _GUARD_NOS_OVERFLOWED_r12 1097 -#define _GUARD_NOS_OVERFLOWED_r22 1098 -#define _GUARD_NOS_OVERFLOWED_r33 1099 -#define _GUARD_NOS_TUPLE_r02 1100 -#define _GUARD_NOS_TUPLE_r12 1101 -#define _GUARD_NOS_TUPLE_r22 1102 -#define _GUARD_NOS_TUPLE_r33 1103 -#define _GUARD_NOS_TYPE_VERSION_r02 1104 -#define _GUARD_NOS_TYPE_VERSION_r12 1105 -#define _GUARD_NOS_TYPE_VERSION_r22 1106 -#define _GUARD_NOS_TYPE_VERSION_r33 1107 -#define _GUARD_NOS_UNICODE_r02 1108 -#define _GUARD_NOS_UNICODE_r12 1109 -#define _GUARD_NOS_UNICODE_r22 1110 -#define _GUARD_NOS_UNICODE_r33 1111 -#define _GUARD_NOT_EXHAUSTED_LIST_r02 1112 -#define _GUARD_NOT_EXHAUSTED_LIST_r12 1113 -#define _GUARD_NOT_EXHAUSTED_LIST_r22 1114 -#define _GUARD_NOT_EXHAUSTED_LIST_r33 1115 -#define _GUARD_NOT_EXHAUSTED_RANGE_r02 1116 -#define _GUARD_NOT_EXHAUSTED_RANGE_r12 1117 -#define _GUARD_NOT_EXHAUSTED_RANGE_r22 1118 -#define _GUARD_NOT_EXHAUSTED_RANGE_r33 1119 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r02 1120 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r12 1121 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r22 1122 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r33 1123 -#define _GUARD_THIRD_NULL_r03 1124 -#define _GUARD_THIRD_NULL_r13 1125 -#define _GUARD_THIRD_NULL_r23 1126 -#define _GUARD_THIRD_NULL_r33 1127 -#define _GUARD_TOS_ANY_DICT_r01 1128 -#define _GUARD_TOS_ANY_DICT_r11 1129 -#define _GUARD_TOS_ANY_DICT_r22 1130 -#define _GUARD_TOS_ANY_DICT_r33 1131 -#define _GUARD_TOS_ANY_SET_r01 1132 -#define _GUARD_TOS_ANY_SET_r11 1133 -#define _GUARD_TOS_ANY_SET_r22 1134 -#define _GUARD_TOS_ANY_SET_r33 1135 -#define _GUARD_TOS_DICT_r01 1136 -#define _GUARD_TOS_DICT_r11 1137 -#define _GUARD_TOS_DICT_r22 1138 -#define _GUARD_TOS_DICT_r33 1139 -#define _GUARD_TOS_FLOAT_r01 1140 -#define _GUARD_TOS_FLOAT_r11 1141 -#define _GUARD_TOS_FLOAT_r22 1142 -#define _GUARD_TOS_FLOAT_r33 1143 -#define _GUARD_TOS_FROZENDICT_r01 1144 -#define _GUARD_TOS_FROZENDICT_r11 1145 -#define _GUARD_TOS_FROZENDICT_r22 1146 -#define _GUARD_TOS_FROZENDICT_r33 1147 -#define _GUARD_TOS_FROZENSET_r01 1148 -#define _GUARD_TOS_FROZENSET_r11 1149 -#define _GUARD_TOS_FROZENSET_r22 1150 -#define _GUARD_TOS_FROZENSET_r33 1151 -#define _GUARD_TOS_INT_r01 1152 -#define _GUARD_TOS_INT_r11 1153 -#define _GUARD_TOS_INT_r22 1154 -#define _GUARD_TOS_INT_r33 1155 -#define _GUARD_TOS_LIST_r01 1156 -#define _GUARD_TOS_LIST_r11 1157 -#define _GUARD_TOS_LIST_r22 1158 -#define _GUARD_TOS_LIST_r33 1159 -#define _GUARD_TOS_OVERFLOWED_r01 1160 -#define _GUARD_TOS_OVERFLOWED_r11 1161 -#define _GUARD_TOS_OVERFLOWED_r22 1162 -#define _GUARD_TOS_OVERFLOWED_r33 1163 -#define _GUARD_TOS_SET_r01 1164 -#define _GUARD_TOS_SET_r11 1165 -#define _GUARD_TOS_SET_r22 1166 -#define _GUARD_TOS_SET_r33 1167 -#define _GUARD_TOS_SLICE_r01 1168 -#define _GUARD_TOS_SLICE_r11 1169 -#define _GUARD_TOS_SLICE_r22 1170 -#define _GUARD_TOS_SLICE_r33 1171 -#define _GUARD_TOS_TUPLE_r01 1172 -#define _GUARD_TOS_TUPLE_r11 1173 -#define _GUARD_TOS_TUPLE_r22 1174 -#define _GUARD_TOS_TUPLE_r33 1175 -#define _GUARD_TOS_UNICODE_r01 1176 -#define _GUARD_TOS_UNICODE_r11 1177 -#define _GUARD_TOS_UNICODE_r22 1178 -#define _GUARD_TOS_UNICODE_r33 1179 -#define _GUARD_TYPE_r01 1180 -#define _GUARD_TYPE_r11 1181 -#define _GUARD_TYPE_r22 1182 -#define _GUARD_TYPE_r33 1183 -#define _GUARD_TYPE_VERSION_r01 1184 -#define _GUARD_TYPE_VERSION_r11 1185 -#define _GUARD_TYPE_VERSION_r22 1186 -#define _GUARD_TYPE_VERSION_r33 1187 -#define _GUARD_TYPE_VERSION_LOCKED_r01 1188 -#define _GUARD_TYPE_VERSION_LOCKED_r11 1189 -#define _GUARD_TYPE_VERSION_LOCKED_r22 1190 -#define _GUARD_TYPE_VERSION_LOCKED_r33 1191 -#define _HANDLE_PENDING_AND_DEOPT_r00 1192 -#define _HANDLE_PENDING_AND_DEOPT_r10 1193 -#define _HANDLE_PENDING_AND_DEOPT_r20 1194 -#define _HANDLE_PENDING_AND_DEOPT_r30 1195 -#define _IMPORT_FROM_r12 1196 -#define _IMPORT_NAME_r21 1197 -#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS_r00 1198 -#define _INIT_CALL_PY_EXACT_ARGS_r01 1199 -#define _INIT_CALL_PY_EXACT_ARGS_0_r01 1200 -#define _INIT_CALL_PY_EXACT_ARGS_1_r01 1201 -#define _INIT_CALL_PY_EXACT_ARGS_2_r01 1202 -#define _INIT_CALL_PY_EXACT_ARGS_3_r01 1203 -#define _INIT_CALL_PY_EXACT_ARGS_4_r01 1204 -#define _INSERT_NULL_r10 1205 -#define _INSTRUMENTED_FOR_ITER_r23 1206 -#define _INSTRUMENTED_INSTRUCTION_r00 1207 -#define _INSTRUMENTED_JUMP_FORWARD_r00 1208 -#define _INSTRUMENTED_JUMP_FORWARD_r11 1209 -#define _INSTRUMENTED_JUMP_FORWARD_r22 1210 -#define _INSTRUMENTED_JUMP_FORWARD_r33 1211 -#define _INSTRUMENTED_LINE_r00 1212 -#define _INSTRUMENTED_NOT_TAKEN_r00 1213 -#define _INSTRUMENTED_NOT_TAKEN_r11 1214 -#define _INSTRUMENTED_NOT_TAKEN_r22 1215 -#define _INSTRUMENTED_NOT_TAKEN_r33 1216 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r00 1217 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r10 1218 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r21 1219 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r32 1220 -#define _INSTRUMENTED_POP_JUMP_IF_NONE_r10 1221 -#define _INSTRUMENTED_POP_JUMP_IF_NOT_NONE_r10 1222 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r00 1223 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r10 1224 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r21 1225 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r32 1226 -#define _IS_NONE_r11 1227 -#define _IS_OP_r03 1228 -#define _IS_OP_r13 1229 -#define _IS_OP_r23 1230 -#define _ITER_CHECK_LIST_r02 1231 -#define _ITER_CHECK_LIST_r12 1232 -#define _ITER_CHECK_LIST_r22 1233 -#define _ITER_CHECK_LIST_r33 1234 -#define _ITER_CHECK_RANGE_r02 1235 -#define _ITER_CHECK_RANGE_r12 1236 -#define _ITER_CHECK_RANGE_r22 1237 -#define _ITER_CHECK_RANGE_r33 1238 -#define _ITER_CHECK_TUPLE_r02 1239 -#define _ITER_CHECK_TUPLE_r12 1240 -#define _ITER_CHECK_TUPLE_r22 1241 -#define _ITER_CHECK_TUPLE_r33 1242 -#define _ITER_JUMP_LIST_r02 1243 -#define _ITER_JUMP_LIST_r12 1244 -#define _ITER_JUMP_LIST_r22 1245 -#define _ITER_JUMP_LIST_r33 1246 -#define _ITER_JUMP_RANGE_r02 1247 -#define _ITER_JUMP_RANGE_r12 1248 -#define _ITER_JUMP_RANGE_r22 1249 -#define _ITER_JUMP_RANGE_r33 1250 -#define _ITER_JUMP_TUPLE_r02 1251 -#define _ITER_JUMP_TUPLE_r12 1252 -#define _ITER_JUMP_TUPLE_r22 1253 -#define _ITER_JUMP_TUPLE_r33 1254 -#define _ITER_NEXT_LIST_r23 1255 -#define _ITER_NEXT_LIST_TIER_TWO_r23 1256 -#define _ITER_NEXT_RANGE_r03 1257 -#define _ITER_NEXT_RANGE_r13 1258 -#define _ITER_NEXT_RANGE_r23 1259 -#define _ITER_NEXT_TUPLE_r03 1260 -#define _ITER_NEXT_TUPLE_r13 1261 -#define _ITER_NEXT_TUPLE_r23 1262 -#define _JUMP_BACKWARD_NO_INTERRUPT_r00 1263 -#define _JUMP_BACKWARD_NO_INTERRUPT_r11 1264 -#define _JUMP_BACKWARD_NO_INTERRUPT_r22 1265 -#define _JUMP_BACKWARD_NO_INTERRUPT_r33 1266 -#define _JUMP_TO_TOP_r00 1267 -#define _LIST_APPEND_r10 1268 -#define _LIST_EXTEND_r11 1269 -#define _LOAD_ATTR_r10 1270 -#define _LOAD_ATTR_CLASS_r11 1271 -#define _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN_FRAME_r11 1272 -#define _LOAD_ATTR_INSTANCE_VALUE_r02 1273 -#define _LOAD_ATTR_INSTANCE_VALUE_r12 1274 -#define _LOAD_ATTR_INSTANCE_VALUE_r23 1275 -#define _LOAD_ATTR_METHOD_LAZY_DICT_r02 1276 -#define _LOAD_ATTR_METHOD_LAZY_DICT_r12 1277 -#define _LOAD_ATTR_METHOD_LAZY_DICT_r23 1278 -#define _LOAD_ATTR_METHOD_NO_DICT_r02 1279 -#define _LOAD_ATTR_METHOD_NO_DICT_r12 1280 -#define _LOAD_ATTR_METHOD_NO_DICT_r23 1281 -#define _LOAD_ATTR_METHOD_WITH_VALUES_r02 1282 -#define _LOAD_ATTR_METHOD_WITH_VALUES_r12 1283 -#define _LOAD_ATTR_METHOD_WITH_VALUES_r23 1284 -#define _LOAD_ATTR_MODULE_r12 1285 -#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT_r11 1286 -#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES_r11 1287 -#define _LOAD_ATTR_PROPERTY_FRAME_r01 1288 -#define _LOAD_ATTR_PROPERTY_FRAME_r11 1289 -#define _LOAD_ATTR_PROPERTY_FRAME_r22 1290 -#define _LOAD_ATTR_PROPERTY_FRAME_r33 1291 -#define _LOAD_ATTR_SLOT_r02 1292 -#define _LOAD_ATTR_SLOT_r12 1293 -#define _LOAD_ATTR_SLOT_r23 1294 -#define _LOAD_ATTR_WITH_HINT_r12 1295 -#define _LOAD_BUILD_CLASS_r01 1296 -#define _LOAD_BYTECODE_r00 1297 -#define _LOAD_COMMON_CONSTANT_r01 1298 -#define _LOAD_COMMON_CONSTANT_r12 1299 -#define _LOAD_COMMON_CONSTANT_r23 1300 -#define _LOAD_CONST_r01 1301 -#define _LOAD_CONST_r12 1302 -#define _LOAD_CONST_r23 1303 -#define _LOAD_CONST_INLINE_r01 1304 -#define _LOAD_CONST_INLINE_r12 1305 -#define _LOAD_CONST_INLINE_r23 1306 -#define _LOAD_CONST_INLINE_BORROW_r01 1307 -#define _LOAD_CONST_INLINE_BORROW_r12 1308 -#define _LOAD_CONST_INLINE_BORROW_r23 1309 -#define _LOAD_DEREF_r01 1310 -#define _LOAD_FAST_r01 1311 -#define _LOAD_FAST_r12 1312 -#define _LOAD_FAST_r23 1313 -#define _LOAD_FAST_0_r01 1314 -#define _LOAD_FAST_0_r12 1315 -#define _LOAD_FAST_0_r23 1316 -#define _LOAD_FAST_1_r01 1317 -#define _LOAD_FAST_1_r12 1318 -#define _LOAD_FAST_1_r23 1319 -#define _LOAD_FAST_2_r01 1320 -#define _LOAD_FAST_2_r12 1321 -#define _LOAD_FAST_2_r23 1322 -#define _LOAD_FAST_3_r01 1323 -#define _LOAD_FAST_3_r12 1324 -#define _LOAD_FAST_3_r23 1325 -#define _LOAD_FAST_4_r01 1326 -#define _LOAD_FAST_4_r12 1327 -#define _LOAD_FAST_4_r23 1328 -#define _LOAD_FAST_5_r01 1329 -#define _LOAD_FAST_5_r12 1330 -#define _LOAD_FAST_5_r23 1331 -#define _LOAD_FAST_6_r01 1332 -#define _LOAD_FAST_6_r12 1333 -#define _LOAD_FAST_6_r23 1334 -#define _LOAD_FAST_7_r01 1335 -#define _LOAD_FAST_7_r12 1336 -#define _LOAD_FAST_7_r23 1337 -#define _LOAD_FAST_AND_CLEAR_r01 1338 -#define _LOAD_FAST_AND_CLEAR_r12 1339 -#define _LOAD_FAST_AND_CLEAR_r23 1340 -#define _LOAD_FAST_BORROW_r01 1341 -#define _LOAD_FAST_BORROW_r12 1342 -#define _LOAD_FAST_BORROW_r23 1343 -#define _LOAD_FAST_BORROW_0_r01 1344 -#define _LOAD_FAST_BORROW_0_r12 1345 -#define _LOAD_FAST_BORROW_0_r23 1346 -#define _LOAD_FAST_BORROW_1_r01 1347 -#define _LOAD_FAST_BORROW_1_r12 1348 -#define _LOAD_FAST_BORROW_1_r23 1349 -#define _LOAD_FAST_BORROW_2_r01 1350 -#define _LOAD_FAST_BORROW_2_r12 1351 -#define _LOAD_FAST_BORROW_2_r23 1352 -#define _LOAD_FAST_BORROW_3_r01 1353 -#define _LOAD_FAST_BORROW_3_r12 1354 -#define _LOAD_FAST_BORROW_3_r23 1355 -#define _LOAD_FAST_BORROW_4_r01 1356 -#define _LOAD_FAST_BORROW_4_r12 1357 -#define _LOAD_FAST_BORROW_4_r23 1358 -#define _LOAD_FAST_BORROW_5_r01 1359 -#define _LOAD_FAST_BORROW_5_r12 1360 -#define _LOAD_FAST_BORROW_5_r23 1361 -#define _LOAD_FAST_BORROW_6_r01 1362 -#define _LOAD_FAST_BORROW_6_r12 1363 -#define _LOAD_FAST_BORROW_6_r23 1364 -#define _LOAD_FAST_BORROW_7_r01 1365 -#define _LOAD_FAST_BORROW_7_r12 1366 -#define _LOAD_FAST_BORROW_7_r23 1367 -#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r02 1368 -#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r13 1369 -#define _LOAD_FAST_CHECK_r01 1370 -#define _LOAD_FAST_CHECK_r12 1371 -#define _LOAD_FAST_CHECK_r23 1372 -#define _LOAD_FAST_LOAD_FAST_r02 1373 -#define _LOAD_FAST_LOAD_FAST_r13 1374 -#define _LOAD_FROM_DICT_OR_DEREF_r11 1375 -#define _LOAD_FROM_DICT_OR_GLOBALS_r11 1376 -#define _LOAD_GLOBAL_r00 1377 -#define _LOAD_GLOBAL_BUILTINS_r01 1378 -#define _LOAD_GLOBAL_MODULE_r01 1379 -#define _LOAD_LOCALS_r01 1380 -#define _LOAD_LOCALS_r12 1381 -#define _LOAD_LOCALS_r23 1382 -#define _LOAD_NAME_r01 1383 -#define _LOAD_SMALL_INT_r01 1384 -#define _LOAD_SMALL_INT_r12 1385 -#define _LOAD_SMALL_INT_r23 1386 -#define _LOAD_SMALL_INT_0_r01 1387 -#define _LOAD_SMALL_INT_0_r12 1388 -#define _LOAD_SMALL_INT_0_r23 1389 -#define _LOAD_SMALL_INT_1_r01 1390 -#define _LOAD_SMALL_INT_1_r12 1391 -#define _LOAD_SMALL_INT_1_r23 1392 -#define _LOAD_SMALL_INT_2_r01 1393 -#define _LOAD_SMALL_INT_2_r12 1394 -#define _LOAD_SMALL_INT_2_r23 1395 -#define _LOAD_SMALL_INT_3_r01 1396 -#define _LOAD_SMALL_INT_3_r12 1397 -#define _LOAD_SMALL_INT_3_r23 1398 -#define _LOAD_SPECIAL_r00 1399 -#define _LOAD_SUPER_ATTR_ATTR_r31 1400 -#define _LOAD_SUPER_ATTR_METHOD_r32 1401 -#define _LOCK_OBJECT_r01 1402 -#define _LOCK_OBJECT_r11 1403 -#define _LOCK_OBJECT_r22 1404 -#define _LOCK_OBJECT_r33 1405 -#define _MAKE_CALLARGS_A_TUPLE_r33 1406 -#define _MAKE_CELL_r00 1407 -#define _MAKE_FUNCTION_r12 1408 -#define _MAKE_HEAP_SAFE_r01 1409 -#define _MAKE_HEAP_SAFE_r11 1410 -#define _MAKE_HEAP_SAFE_r22 1411 -#define _MAKE_HEAP_SAFE_r33 1412 -#define _MAKE_WARM_r00 1413 -#define _MAKE_WARM_r11 1414 -#define _MAKE_WARM_r22 1415 -#define _MAKE_WARM_r33 1416 -#define _MAP_ADD_r20 1417 -#define _MATCH_CLASS_r33 1418 -#define _MATCH_KEYS_r23 1419 -#define _MATCH_MAPPING_r02 1420 -#define _MATCH_MAPPING_r12 1421 -#define _MATCH_MAPPING_r23 1422 -#define _MATCH_SEQUENCE_r02 1423 -#define _MATCH_SEQUENCE_r12 1424 -#define _MATCH_SEQUENCE_r23 1425 -#define _MAYBE_EXPAND_METHOD_r00 1426 -#define _MAYBE_EXPAND_METHOD_KW_r11 1427 -#define _MONITOR_CALL_r00 1428 -#define _MONITOR_CALL_KW_r11 1429 -#define _MONITOR_JUMP_BACKWARD_r00 1430 -#define _MONITOR_JUMP_BACKWARD_r11 1431 -#define _MONITOR_JUMP_BACKWARD_r22 1432 -#define _MONITOR_JUMP_BACKWARD_r33 1433 -#define _MONITOR_RESUME_r00 1434 -#define _NOP_r00 1435 -#define _NOP_r11 1436 -#define _NOP_r22 1437 -#define _NOP_r33 1438 -#define _POP_EXCEPT_r10 1439 -#define _POP_ITER_r20 1440 -#define _POP_JUMP_IF_FALSE_r00 1441 -#define _POP_JUMP_IF_FALSE_r10 1442 -#define _POP_JUMP_IF_FALSE_r21 1443 -#define _POP_JUMP_IF_FALSE_r32 1444 -#define _POP_JUMP_IF_TRUE_r00 1445 -#define _POP_JUMP_IF_TRUE_r10 1446 -#define _POP_JUMP_IF_TRUE_r21 1447 -#define _POP_JUMP_IF_TRUE_r32 1448 -#define _POP_TOP_r10 1449 -#define _POP_TOP_FLOAT_r00 1450 -#define _POP_TOP_FLOAT_r10 1451 -#define _POP_TOP_FLOAT_r21 1452 -#define _POP_TOP_FLOAT_r32 1453 -#define _POP_TOP_INT_r00 1454 -#define _POP_TOP_INT_r10 1455 -#define _POP_TOP_INT_r21 1456 -#define _POP_TOP_INT_r32 1457 -#define _POP_TOP_NOP_r00 1458 -#define _POP_TOP_NOP_r10 1459 -#define _POP_TOP_NOP_r21 1460 -#define _POP_TOP_NOP_r32 1461 -#define _POP_TOP_OPARG_r00 1462 -#define _POP_TOP_UNICODE_r00 1463 -#define _POP_TOP_UNICODE_r10 1464 -#define _POP_TOP_UNICODE_r21 1465 -#define _POP_TOP_UNICODE_r32 1466 -#define _PUSH_EXC_INFO_r02 1467 -#define _PUSH_EXC_INFO_r12 1468 -#define _PUSH_EXC_INFO_r23 1469 -#define _PUSH_FRAME_r10 1470 -#define _PUSH_NULL_r01 1471 -#define _PUSH_NULL_r12 1472 -#define _PUSH_NULL_r23 1473 -#define _PUSH_NULL_CONDITIONAL_r00 1474 -#define _PUSH_TAGGED_ZERO_r01 1475 -#define _PUSH_TAGGED_ZERO_r12 1476 -#define _PUSH_TAGGED_ZERO_r23 1477 -#define _PY_FRAME_EX_r31 1478 -#define _PY_FRAME_GENERAL_r01 1479 -#define _PY_FRAME_KW_r11 1480 -#define _REPLACE_WITH_TRUE_r02 1481 -#define _REPLACE_WITH_TRUE_r12 1482 -#define _REPLACE_WITH_TRUE_r23 1483 -#define _RESUME_CHECK_r00 1484 -#define _RESUME_CHECK_r11 1485 -#define _RESUME_CHECK_r22 1486 -#define _RESUME_CHECK_r33 1487 -#define _RETURN_GENERATOR_r01 1488 -#define _RETURN_VALUE_r11 1489 -#define _SAVE_RETURN_OFFSET_r00 1490 -#define _SAVE_RETURN_OFFSET_r11 1491 -#define _SAVE_RETURN_OFFSET_r22 1492 -#define _SAVE_RETURN_OFFSET_r33 1493 -#define _SEND_r33 1494 -#define _SEND_GEN_FRAME_r33 1495 -#define _SETUP_ANNOTATIONS_r00 1496 -#define _SET_ADD_r10 1497 -#define _SET_FUNCTION_ATTRIBUTE_r01 1498 -#define _SET_FUNCTION_ATTRIBUTE_r11 1499 -#define _SET_FUNCTION_ATTRIBUTE_r21 1500 -#define _SET_FUNCTION_ATTRIBUTE_r32 1501 -#define _SET_IP_r00 1502 -#define _SET_IP_r11 1503 -#define _SET_IP_r22 1504 -#define _SET_IP_r33 1505 -#define _SET_UPDATE_r11 1506 -#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r03 1507 -#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r13 1508 -#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r23 1509 -#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r33 1510 -#define _SPILL_OR_RELOAD_r01 1511 -#define _SPILL_OR_RELOAD_r02 1512 -#define _SPILL_OR_RELOAD_r03 1513 -#define _SPILL_OR_RELOAD_r10 1514 -#define _SPILL_OR_RELOAD_r12 1515 -#define _SPILL_OR_RELOAD_r13 1516 -#define _SPILL_OR_RELOAD_r20 1517 -#define _SPILL_OR_RELOAD_r21 1518 -#define _SPILL_OR_RELOAD_r23 1519 -#define _SPILL_OR_RELOAD_r30 1520 -#define _SPILL_OR_RELOAD_r31 1521 -#define _SPILL_OR_RELOAD_r32 1522 -#define _START_EXECUTOR_r00 1523 -#define _STORE_ATTR_r20 1524 -#define _STORE_ATTR_INSTANCE_VALUE_r21 1525 -#define _STORE_ATTR_SLOT_r21 1526 -#define _STORE_ATTR_WITH_HINT_r21 1527 -#define _STORE_DEREF_r10 1528 -#define _STORE_FAST_LOAD_FAST_r11 1529 -#define _STORE_FAST_STORE_FAST_r20 1530 -#define _STORE_GLOBAL_r10 1531 -#define _STORE_NAME_r10 1532 -#define _STORE_SLICE_r30 1533 -#define _STORE_SUBSCR_r30 1534 -#define _STORE_SUBSCR_DICT_r31 1535 -#define _STORE_SUBSCR_DICT_KNOWN_HASH_r31 1536 -#define _STORE_SUBSCR_LIST_INT_r32 1537 -#define _SWAP_r11 1538 -#define _SWAP_2_r02 1539 -#define _SWAP_2_r12 1540 -#define _SWAP_2_r22 1541 -#define _SWAP_2_r33 1542 -#define _SWAP_3_r03 1543 -#define _SWAP_3_r13 1544 -#define _SWAP_3_r23 1545 -#define _SWAP_3_r33 1546 -#define _SWAP_FAST_r01 1547 -#define _SWAP_FAST_r11 1548 -#define _SWAP_FAST_r22 1549 -#define _SWAP_FAST_r33 1550 -#define _SWAP_FAST_0_r01 1551 -#define _SWAP_FAST_0_r11 1552 -#define _SWAP_FAST_0_r22 1553 -#define _SWAP_FAST_0_r33 1554 -#define _SWAP_FAST_1_r01 1555 -#define _SWAP_FAST_1_r11 1556 -#define _SWAP_FAST_1_r22 1557 -#define _SWAP_FAST_1_r33 1558 -#define _SWAP_FAST_2_r01 1559 -#define _SWAP_FAST_2_r11 1560 -#define _SWAP_FAST_2_r22 1561 -#define _SWAP_FAST_2_r33 1562 -#define _SWAP_FAST_3_r01 1563 -#define _SWAP_FAST_3_r11 1564 -#define _SWAP_FAST_3_r22 1565 -#define _SWAP_FAST_3_r33 1566 -#define _SWAP_FAST_4_r01 1567 -#define _SWAP_FAST_4_r11 1568 -#define _SWAP_FAST_4_r22 1569 -#define _SWAP_FAST_4_r33 1570 -#define _SWAP_FAST_5_r01 1571 -#define _SWAP_FAST_5_r11 1572 -#define _SWAP_FAST_5_r22 1573 -#define _SWAP_FAST_5_r33 1574 -#define _SWAP_FAST_6_r01 1575 -#define _SWAP_FAST_6_r11 1576 -#define _SWAP_FAST_6_r22 1577 -#define _SWAP_FAST_6_r33 1578 -#define _SWAP_FAST_7_r01 1579 -#define _SWAP_FAST_7_r11 1580 -#define _SWAP_FAST_7_r22 1581 -#define _SWAP_FAST_7_r33 1582 -#define _TIER2_RESUME_CHECK_r00 1583 -#define _TIER2_RESUME_CHECK_r11 1584 -#define _TIER2_RESUME_CHECK_r22 1585 -#define _TIER2_RESUME_CHECK_r33 1586 -#define _TO_BOOL_r11 1587 -#define _TO_BOOL_BOOL_r01 1588 -#define _TO_BOOL_BOOL_r11 1589 -#define _TO_BOOL_BOOL_r22 1590 -#define _TO_BOOL_BOOL_r33 1591 -#define _TO_BOOL_INT_r02 1592 -#define _TO_BOOL_INT_r12 1593 -#define _TO_BOOL_INT_r23 1594 -#define _TO_BOOL_LIST_r02 1595 -#define _TO_BOOL_LIST_r12 1596 -#define _TO_BOOL_LIST_r23 1597 -#define _TO_BOOL_NONE_r01 1598 -#define _TO_BOOL_NONE_r11 1599 -#define _TO_BOOL_NONE_r22 1600 -#define _TO_BOOL_NONE_r33 1601 -#define _TO_BOOL_STR_r02 1602 -#define _TO_BOOL_STR_r12 1603 -#define _TO_BOOL_STR_r23 1604 -#define _TRACE_RECORD_r00 1605 -#define _UNARY_INVERT_r12 1606 -#define _UNARY_NEGATIVE_r12 1607 -#define _UNARY_NEGATIVE_FLOAT_INPLACE_r02 1608 -#define _UNARY_NEGATIVE_FLOAT_INPLACE_r12 1609 -#define _UNARY_NEGATIVE_FLOAT_INPLACE_r23 1610 -#define _UNARY_NOT_r01 1611 -#define _UNARY_NOT_r11 1612 -#define _UNARY_NOT_r22 1613 -#define _UNARY_NOT_r33 1614 -#define _UNPACK_EX_r10 1615 -#define _UNPACK_SEQUENCE_r10 1616 -#define _UNPACK_SEQUENCE_LIST_r10 1617 -#define _UNPACK_SEQUENCE_TUPLE_r10 1618 -#define _UNPACK_SEQUENCE_TWO_TUPLE_r12 1619 -#define _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE_r03 1620 -#define _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE_r13 1621 -#define _UNPACK_SEQUENCE_UNIQUE_TUPLE_r10 1622 -#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r02 1623 -#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r12 1624 -#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r23 1625 -#define _WITH_EXCEPT_START_r33 1626 -#define _YIELD_VALUE_r11 1627 -#define MAX_UOP_REGS_ID 1627 +#define _YIELD_VALUE 645 +#define MAX_UOP_ID 645 +#define _ALLOCATE_OBJECT_r00 646 +#define _BINARY_OP_r23 647 +#define _BINARY_OP_ADD_FLOAT_r03 648 +#define _BINARY_OP_ADD_FLOAT_r13 649 +#define _BINARY_OP_ADD_FLOAT_r23 650 +#define _BINARY_OP_ADD_FLOAT_INPLACE_r03 651 +#define _BINARY_OP_ADD_FLOAT_INPLACE_r13 652 +#define _BINARY_OP_ADD_FLOAT_INPLACE_r23 653 +#define _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT_r03 654 +#define _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT_r13 655 +#define _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT_r23 656 +#define _BINARY_OP_ADD_INT_r03 657 +#define _BINARY_OP_ADD_INT_r13 658 +#define _BINARY_OP_ADD_INT_r23 659 +#define _BINARY_OP_ADD_INT_INPLACE_r03 660 +#define _BINARY_OP_ADD_INT_INPLACE_r13 661 +#define _BINARY_OP_ADD_INT_INPLACE_r23 662 +#define _BINARY_OP_ADD_INT_INPLACE_RIGHT_r03 663 +#define _BINARY_OP_ADD_INT_INPLACE_RIGHT_r13 664 +#define _BINARY_OP_ADD_INT_INPLACE_RIGHT_r23 665 +#define _BINARY_OP_ADD_UNICODE_r03 666 +#define _BINARY_OP_ADD_UNICODE_r13 667 +#define _BINARY_OP_ADD_UNICODE_r23 668 +#define _BINARY_OP_EXTEND_r23 669 +#define _BINARY_OP_INPLACE_ADD_UNICODE_r21 670 +#define _BINARY_OP_MULTIPLY_FLOAT_r03 671 +#define _BINARY_OP_MULTIPLY_FLOAT_r13 672 +#define _BINARY_OP_MULTIPLY_FLOAT_r23 673 +#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_r03 674 +#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_r13 675 +#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_r23 676 +#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT_r03 677 +#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT_r13 678 +#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT_r23 679 +#define _BINARY_OP_MULTIPLY_INT_r03 680 +#define _BINARY_OP_MULTIPLY_INT_r13 681 +#define _BINARY_OP_MULTIPLY_INT_r23 682 +#define _BINARY_OP_MULTIPLY_INT_INPLACE_r03 683 +#define _BINARY_OP_MULTIPLY_INT_INPLACE_r13 684 +#define _BINARY_OP_MULTIPLY_INT_INPLACE_r23 685 +#define _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT_r03 686 +#define _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT_r13 687 +#define _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT_r23 688 +#define _BINARY_OP_SUBSCR_CHECK_FUNC_r23 689 +#define _BINARY_OP_SUBSCR_DICT_r23 690 +#define _BINARY_OP_SUBSCR_DICT_KNOWN_HASH_r23 691 +#define _BINARY_OP_SUBSCR_INIT_CALL_r01 692 +#define _BINARY_OP_SUBSCR_INIT_CALL_r11 693 +#define _BINARY_OP_SUBSCR_INIT_CALL_r21 694 +#define _BINARY_OP_SUBSCR_INIT_CALL_r31 695 +#define _BINARY_OP_SUBSCR_LIST_INT_r23 696 +#define _BINARY_OP_SUBSCR_LIST_SLICE_r23 697 +#define _BINARY_OP_SUBSCR_STR_INT_r23 698 +#define _BINARY_OP_SUBSCR_TUPLE_INT_r03 699 +#define _BINARY_OP_SUBSCR_TUPLE_INT_r13 700 +#define _BINARY_OP_SUBSCR_TUPLE_INT_r23 701 +#define _BINARY_OP_SUBSCR_USTR_INT_r23 702 +#define _BINARY_OP_SUBTRACT_FLOAT_r03 703 +#define _BINARY_OP_SUBTRACT_FLOAT_r13 704 +#define _BINARY_OP_SUBTRACT_FLOAT_r23 705 +#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_r03 706 +#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_r13 707 +#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_r23 708 +#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT_r03 709 +#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT_r13 710 +#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT_r23 711 +#define _BINARY_OP_SUBTRACT_INT_r03 712 +#define _BINARY_OP_SUBTRACT_INT_r13 713 +#define _BINARY_OP_SUBTRACT_INT_r23 714 +#define _BINARY_OP_SUBTRACT_INT_INPLACE_r03 715 +#define _BINARY_OP_SUBTRACT_INT_INPLACE_r13 716 +#define _BINARY_OP_SUBTRACT_INT_INPLACE_r23 717 +#define _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT_r03 718 +#define _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT_r13 719 +#define _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT_r23 720 +#define _BINARY_OP_TRUEDIV_FLOAT_r23 721 +#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_r03 722 +#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_r13 723 +#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_r23 724 +#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r03 725 +#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r13 726 +#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r23 727 +#define _BINARY_SLICE_r31 728 +#define _BUILD_INTERPOLATION_r01 729 +#define _BUILD_LIST_r01 730 +#define _BUILD_MAP_r01 731 +#define _BUILD_SET_r01 732 +#define _BUILD_SLICE_r01 733 +#define _BUILD_STRING_r01 734 +#define _BUILD_TEMPLATE_r21 735 +#define _BUILD_TUPLE_r01 736 +#define _CALL_BUILTIN_CLASS_r00 737 +#define _CALL_BUILTIN_FAST_r00 738 +#define _CALL_BUILTIN_FAST_WITH_KEYWORDS_r00 739 +#define _CALL_BUILTIN_O_r03 740 +#define _CALL_FUNCTION_EX_NON_PY_GENERAL_r31 741 +#define _CALL_INTRINSIC_1_r12 742 +#define _CALL_INTRINSIC_2_r23 743 +#define _CALL_ISINSTANCE_r31 744 +#define _CALL_KW_NON_PY_r11 745 +#define _CALL_LEN_r33 746 +#define _CALL_LIST_APPEND_r03 747 +#define _CALL_LIST_APPEND_r13 748 +#define _CALL_LIST_APPEND_r23 749 +#define _CALL_LIST_APPEND_r33 750 +#define _CALL_METHOD_DESCRIPTOR_FAST_r00 751 +#define _CALL_METHOD_DESCRIPTOR_FAST_INLINE_r00 752 +#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r00 753 +#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_INLINE_r00 754 +#define _CALL_METHOD_DESCRIPTOR_NOARGS_r03 755 +#define _CALL_METHOD_DESCRIPTOR_NOARGS_INLINE_r03 756 +#define _CALL_METHOD_DESCRIPTOR_O_r03 757 +#define _CALL_METHOD_DESCRIPTOR_O_INLINE_r03 758 +#define _CALL_NON_PY_GENERAL_r01 759 +#define _CALL_STR_1_r32 760 +#define _CALL_TUPLE_1_r32 761 +#define _CALL_TYPE_1_r02 762 +#define _CALL_TYPE_1_r12 763 +#define _CALL_TYPE_1_r22 764 +#define _CALL_TYPE_1_r32 765 +#define _CHECK_ATTR_CLASS_r01 766 +#define _CHECK_ATTR_CLASS_r11 767 +#define _CHECK_ATTR_CLASS_r22 768 +#define _CHECK_ATTR_CLASS_r33 769 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r01 770 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r11 771 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r22 772 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r33 773 +#define _CHECK_CALL_BOUND_METHOD_EXACT_ARGS_r00 774 +#define _CHECK_EG_MATCH_r22 775 +#define _CHECK_EXC_MATCH_r22 776 +#define _CHECK_FUNCTION_EXACT_ARGS_r00 777 +#define _CHECK_FUNCTION_VERSION_r00 778 +#define _CHECK_FUNCTION_VERSION_INLINE_r00 779 +#define _CHECK_FUNCTION_VERSION_INLINE_r11 780 +#define _CHECK_FUNCTION_VERSION_INLINE_r22 781 +#define _CHECK_FUNCTION_VERSION_INLINE_r33 782 +#define _CHECK_FUNCTION_VERSION_KW_r11 783 +#define _CHECK_IS_NOT_PY_CALLABLE_r00 784 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r03 785 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r13 786 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r23 787 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r33 788 +#define _CHECK_IS_NOT_PY_CALLABLE_KW_r11 789 +#define _CHECK_IS_PY_CALLABLE_EX_r03 790 +#define _CHECK_IS_PY_CALLABLE_EX_r13 791 +#define _CHECK_IS_PY_CALLABLE_EX_r23 792 +#define _CHECK_IS_PY_CALLABLE_EX_r33 793 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r01 794 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r11 795 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r22 796 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r33 797 +#define _CHECK_METHOD_VERSION_r00 798 +#define _CHECK_METHOD_VERSION_KW_r11 799 +#define _CHECK_OBJECT_r00 800 +#define _CHECK_PEP_523_r00 801 +#define _CHECK_PEP_523_r11 802 +#define _CHECK_PEP_523_r22 803 +#define _CHECK_PEP_523_r33 804 +#define _CHECK_PERIODIC_r00 805 +#define _CHECK_PERIODIC_AT_END_r00 806 +#define _CHECK_PERIODIC_IF_NOT_YIELD_FROM_r00 807 +#define _CHECK_RECURSION_LIMIT_r00 808 +#define _CHECK_RECURSION_LIMIT_r11 809 +#define _CHECK_RECURSION_LIMIT_r22 810 +#define _CHECK_RECURSION_LIMIT_r33 811 +#define _CHECK_RECURSION_REMAINING_r00 812 +#define _CHECK_RECURSION_REMAINING_r11 813 +#define _CHECK_RECURSION_REMAINING_r22 814 +#define _CHECK_RECURSION_REMAINING_r33 815 +#define _CHECK_STACK_SPACE_r00 816 +#define _CHECK_STACK_SPACE_OPERAND_r00 817 +#define _CHECK_STACK_SPACE_OPERAND_r11 818 +#define _CHECK_STACK_SPACE_OPERAND_r22 819 +#define _CHECK_STACK_SPACE_OPERAND_r33 820 +#define _CHECK_VALIDITY_r00 821 +#define _CHECK_VALIDITY_r11 822 +#define _CHECK_VALIDITY_r22 823 +#define _CHECK_VALIDITY_r33 824 +#define _COLD_DYNAMIC_EXIT_r00 825 +#define _COLD_EXIT_r00 826 +#define _COMPARE_OP_r21 827 +#define _COMPARE_OP_FLOAT_r03 828 +#define _COMPARE_OP_FLOAT_r13 829 +#define _COMPARE_OP_FLOAT_r23 830 +#define _COMPARE_OP_INT_r23 831 +#define _COMPARE_OP_STR_r23 832 +#define _CONTAINS_OP_r23 833 +#define _CONTAINS_OP_DICT_r23 834 +#define _CONTAINS_OP_SET_r23 835 +#define _CONVERT_VALUE_r11 836 +#define _COPY_r01 837 +#define _COPY_1_r02 838 +#define _COPY_1_r12 839 +#define _COPY_1_r23 840 +#define _COPY_2_r03 841 +#define _COPY_2_r13 842 +#define _COPY_2_r23 843 +#define _COPY_3_r03 844 +#define _COPY_3_r13 845 +#define _COPY_3_r23 846 +#define _COPY_3_r33 847 +#define _COPY_FREE_VARS_r00 848 +#define _COPY_FREE_VARS_r11 849 +#define _COPY_FREE_VARS_r22 850 +#define _COPY_FREE_VARS_r33 851 +#define _CREATE_INIT_FRAME_r01 852 +#define _DELETE_ATTR_r10 853 +#define _DELETE_DEREF_r00 854 +#define _DELETE_FAST_r00 855 +#define _DELETE_GLOBAL_r00 856 +#define _DELETE_NAME_r00 857 +#define _DELETE_SUBSCR_r20 858 +#define _DEOPT_r00 859 +#define _DEOPT_r10 860 +#define _DEOPT_r20 861 +#define _DEOPT_r30 862 +#define _DICT_MERGE_r11 863 +#define _DICT_UPDATE_r11 864 +#define _DO_CALL_r01 865 +#define _DO_CALL_FUNCTION_EX_r31 866 +#define _DO_CALL_KW_r11 867 +#define _DYNAMIC_EXIT_r00 868 +#define _DYNAMIC_EXIT_r10 869 +#define _DYNAMIC_EXIT_r20 870 +#define _DYNAMIC_EXIT_r30 871 +#define _END_FOR_r10 872 +#define _END_SEND_r31 873 +#define _ERROR_POP_N_r00 874 +#define _EXIT_INIT_CHECK_r10 875 +#define _EXIT_TRACE_r00 876 +#define _EXIT_TRACE_r10 877 +#define _EXIT_TRACE_r20 878 +#define _EXIT_TRACE_r30 879 +#define _EXPAND_METHOD_r00 880 +#define _EXPAND_METHOD_KW_r11 881 +#define _FATAL_ERROR_r00 882 +#define _FATAL_ERROR_r11 883 +#define _FATAL_ERROR_r22 884 +#define _FATAL_ERROR_r33 885 +#define _FORMAT_SIMPLE_r11 886 +#define _FORMAT_WITH_SPEC_r21 887 +#define _FOR_ITER_r23 888 +#define _FOR_ITER_GEN_FRAME_r03 889 +#define _FOR_ITER_GEN_FRAME_r13 890 +#define _FOR_ITER_GEN_FRAME_r23 891 +#define _FOR_ITER_TIER_TWO_r23 892 +#define _FOR_ITER_VIRTUAL_r23 893 +#define _FOR_ITER_VIRTUAL_TIER_TWO_r23 894 +#define _GET_AITER_r11 895 +#define _GET_ANEXT_r12 896 +#define _GET_AWAITABLE_r11 897 +#define _GET_ITER_r12 898 +#define _GET_ITER_TRAD_r12 899 +#define _GET_LEN_r12 900 +#define _GUARD_BINARY_OP_EXTEND_r22 901 +#define _GUARD_BINARY_OP_EXTEND_LHS_r02 902 +#define _GUARD_BINARY_OP_EXTEND_LHS_r12 903 +#define _GUARD_BINARY_OP_EXTEND_LHS_r22 904 +#define _GUARD_BINARY_OP_EXTEND_LHS_r33 905 +#define _GUARD_BINARY_OP_EXTEND_RHS_r02 906 +#define _GUARD_BINARY_OP_EXTEND_RHS_r12 907 +#define _GUARD_BINARY_OP_EXTEND_RHS_r22 908 +#define _GUARD_BINARY_OP_EXTEND_RHS_r33 909 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r02 910 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r12 911 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r22 912 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r33 913 +#define _GUARD_BIT_IS_SET_POP_r00 914 +#define _GUARD_BIT_IS_SET_POP_r10 915 +#define _GUARD_BIT_IS_SET_POP_r21 916 +#define _GUARD_BIT_IS_SET_POP_r32 917 +#define _GUARD_BIT_IS_SET_POP_4_r00 918 +#define _GUARD_BIT_IS_SET_POP_4_r10 919 +#define _GUARD_BIT_IS_SET_POP_4_r21 920 +#define _GUARD_BIT_IS_SET_POP_4_r32 921 +#define _GUARD_BIT_IS_SET_POP_5_r00 922 +#define _GUARD_BIT_IS_SET_POP_5_r10 923 +#define _GUARD_BIT_IS_SET_POP_5_r21 924 +#define _GUARD_BIT_IS_SET_POP_5_r32 925 +#define _GUARD_BIT_IS_SET_POP_6_r00 926 +#define _GUARD_BIT_IS_SET_POP_6_r10 927 +#define _GUARD_BIT_IS_SET_POP_6_r21 928 +#define _GUARD_BIT_IS_SET_POP_6_r32 929 +#define _GUARD_BIT_IS_SET_POP_7_r00 930 +#define _GUARD_BIT_IS_SET_POP_7_r10 931 +#define _GUARD_BIT_IS_SET_POP_7_r21 932 +#define _GUARD_BIT_IS_SET_POP_7_r32 933 +#define _GUARD_BIT_IS_UNSET_POP_r00 934 +#define _GUARD_BIT_IS_UNSET_POP_r10 935 +#define _GUARD_BIT_IS_UNSET_POP_r21 936 +#define _GUARD_BIT_IS_UNSET_POP_r32 937 +#define _GUARD_BIT_IS_UNSET_POP_4_r00 938 +#define _GUARD_BIT_IS_UNSET_POP_4_r10 939 +#define _GUARD_BIT_IS_UNSET_POP_4_r21 940 +#define _GUARD_BIT_IS_UNSET_POP_4_r32 941 +#define _GUARD_BIT_IS_UNSET_POP_5_r00 942 +#define _GUARD_BIT_IS_UNSET_POP_5_r10 943 +#define _GUARD_BIT_IS_UNSET_POP_5_r21 944 +#define _GUARD_BIT_IS_UNSET_POP_5_r32 945 +#define _GUARD_BIT_IS_UNSET_POP_6_r00 946 +#define _GUARD_BIT_IS_UNSET_POP_6_r10 947 +#define _GUARD_BIT_IS_UNSET_POP_6_r21 948 +#define _GUARD_BIT_IS_UNSET_POP_6_r32 949 +#define _GUARD_BIT_IS_UNSET_POP_7_r00 950 +#define _GUARD_BIT_IS_UNSET_POP_7_r10 951 +#define _GUARD_BIT_IS_UNSET_POP_7_r21 952 +#define _GUARD_BIT_IS_UNSET_POP_7_r32 953 +#define _GUARD_CALLABLE_BUILTIN_CLASS_r00 954 +#define _GUARD_CALLABLE_BUILTIN_FAST_r00 955 +#define _GUARD_CALLABLE_BUILTIN_FAST_WITH_KEYWORDS_r00 956 +#define _GUARD_CALLABLE_BUILTIN_O_r00 957 +#define _GUARD_CALLABLE_ISINSTANCE_r03 958 +#define _GUARD_CALLABLE_ISINSTANCE_r13 959 +#define _GUARD_CALLABLE_ISINSTANCE_r23 960 +#define _GUARD_CALLABLE_ISINSTANCE_r33 961 +#define _GUARD_CALLABLE_LEN_r03 962 +#define _GUARD_CALLABLE_LEN_r13 963 +#define _GUARD_CALLABLE_LEN_r23 964 +#define _GUARD_CALLABLE_LEN_r33 965 +#define _GUARD_CALLABLE_LIST_APPEND_r03 966 +#define _GUARD_CALLABLE_LIST_APPEND_r13 967 +#define _GUARD_CALLABLE_LIST_APPEND_r23 968 +#define _GUARD_CALLABLE_LIST_APPEND_r33 969 +#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST_r00 970 +#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r00 971 +#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_NOARGS_r00 972 +#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_O_r00 973 +#define _GUARD_CALLABLE_STR_1_r03 974 +#define _GUARD_CALLABLE_STR_1_r13 975 +#define _GUARD_CALLABLE_STR_1_r23 976 +#define _GUARD_CALLABLE_STR_1_r33 977 +#define _GUARD_CALLABLE_TUPLE_1_r03 978 +#define _GUARD_CALLABLE_TUPLE_1_r13 979 +#define _GUARD_CALLABLE_TUPLE_1_r23 980 +#define _GUARD_CALLABLE_TUPLE_1_r33 981 +#define _GUARD_CALLABLE_TYPE_1_r03 982 +#define _GUARD_CALLABLE_TYPE_1_r13 983 +#define _GUARD_CALLABLE_TYPE_1_r23 984 +#define _GUARD_CALLABLE_TYPE_1_r33 985 +#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r00 986 +#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r11 987 +#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r22 988 +#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r33 989 +#define _GUARD_CODE_VERSION_RETURN_VALUE_r00 990 +#define _GUARD_CODE_VERSION_RETURN_VALUE_r11 991 +#define _GUARD_CODE_VERSION_RETURN_VALUE_r22 992 +#define _GUARD_CODE_VERSION_RETURN_VALUE_r33 993 +#define _GUARD_CODE_VERSION_YIELD_VALUE_r00 994 +#define _GUARD_CODE_VERSION_YIELD_VALUE_r11 995 +#define _GUARD_CODE_VERSION_YIELD_VALUE_r22 996 +#define _GUARD_CODE_VERSION_YIELD_VALUE_r33 997 +#define _GUARD_CODE_VERSION__PUSH_FRAME_r00 998 +#define _GUARD_CODE_VERSION__PUSH_FRAME_r11 999 +#define _GUARD_CODE_VERSION__PUSH_FRAME_r22 1000 +#define _GUARD_CODE_VERSION__PUSH_FRAME_r33 1001 +#define _GUARD_DORV_NO_DICT_r01 1002 +#define _GUARD_DORV_NO_DICT_r11 1003 +#define _GUARD_DORV_NO_DICT_r22 1004 +#define _GUARD_DORV_NO_DICT_r33 1005 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r01 1006 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r11 1007 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r22 1008 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r33 1009 +#define _GUARD_GLOBALS_VERSION_r00 1010 +#define _GUARD_GLOBALS_VERSION_r11 1011 +#define _GUARD_GLOBALS_VERSION_r22 1012 +#define _GUARD_GLOBALS_VERSION_r33 1013 +#define _GUARD_IP_RETURN_GENERATOR_r00 1014 +#define _GUARD_IP_RETURN_GENERATOR_r11 1015 +#define _GUARD_IP_RETURN_GENERATOR_r22 1016 +#define _GUARD_IP_RETURN_GENERATOR_r33 1017 +#define _GUARD_IP_RETURN_VALUE_r00 1018 +#define _GUARD_IP_RETURN_VALUE_r11 1019 +#define _GUARD_IP_RETURN_VALUE_r22 1020 +#define _GUARD_IP_RETURN_VALUE_r33 1021 +#define _GUARD_IP_YIELD_VALUE_r00 1022 +#define _GUARD_IP_YIELD_VALUE_r11 1023 +#define _GUARD_IP_YIELD_VALUE_r22 1024 +#define _GUARD_IP_YIELD_VALUE_r33 1025 +#define _GUARD_IP__PUSH_FRAME_r00 1026 +#define _GUARD_IP__PUSH_FRAME_r11 1027 +#define _GUARD_IP__PUSH_FRAME_r22 1028 +#define _GUARD_IP__PUSH_FRAME_r33 1029 +#define _GUARD_IS_FALSE_POP_r00 1030 +#define _GUARD_IS_FALSE_POP_r10 1031 +#define _GUARD_IS_FALSE_POP_r21 1032 +#define _GUARD_IS_FALSE_POP_r32 1033 +#define _GUARD_IS_NONE_POP_r00 1034 +#define _GUARD_IS_NONE_POP_r10 1035 +#define _GUARD_IS_NONE_POP_r21 1036 +#define _GUARD_IS_NONE_POP_r32 1037 +#define _GUARD_IS_NOT_NONE_POP_r10 1038 +#define _GUARD_IS_TRUE_POP_r00 1039 +#define _GUARD_IS_TRUE_POP_r10 1040 +#define _GUARD_IS_TRUE_POP_r21 1041 +#define _GUARD_IS_TRUE_POP_r32 1042 +#define _GUARD_ITERATOR_r01 1043 +#define _GUARD_ITERATOR_r11 1044 +#define _GUARD_ITERATOR_r22 1045 +#define _GUARD_ITERATOR_r33 1046 +#define _GUARD_ITER_VIRTUAL_r01 1047 +#define _GUARD_ITER_VIRTUAL_r11 1048 +#define _GUARD_ITER_VIRTUAL_r22 1049 +#define _GUARD_ITER_VIRTUAL_r33 1050 +#define _GUARD_KEYS_VERSION_r01 1051 +#define _GUARD_KEYS_VERSION_r11 1052 +#define _GUARD_KEYS_VERSION_r22 1053 +#define _GUARD_KEYS_VERSION_r33 1054 +#define _GUARD_LOAD_SUPER_ATTR_METHOD_r03 1055 +#define _GUARD_LOAD_SUPER_ATTR_METHOD_r13 1056 +#define _GUARD_LOAD_SUPER_ATTR_METHOD_r23 1057 +#define _GUARD_LOAD_SUPER_ATTR_METHOD_r33 1058 +#define _GUARD_NOS_ANY_DICT_r02 1059 +#define _GUARD_NOS_ANY_DICT_r12 1060 +#define _GUARD_NOS_ANY_DICT_r22 1061 +#define _GUARD_NOS_ANY_DICT_r33 1062 +#define _GUARD_NOS_COMPACT_ASCII_r02 1063 +#define _GUARD_NOS_COMPACT_ASCII_r12 1064 +#define _GUARD_NOS_COMPACT_ASCII_r22 1065 +#define _GUARD_NOS_COMPACT_ASCII_r33 1066 +#define _GUARD_NOS_DICT_r02 1067 +#define _GUARD_NOS_DICT_r12 1068 +#define _GUARD_NOS_DICT_r22 1069 +#define _GUARD_NOS_DICT_r33 1070 +#define _GUARD_NOS_FLOAT_r02 1071 +#define _GUARD_NOS_FLOAT_r12 1072 +#define _GUARD_NOS_FLOAT_r22 1073 +#define _GUARD_NOS_FLOAT_r33 1074 +#define _GUARD_NOS_INT_r02 1075 +#define _GUARD_NOS_INT_r12 1076 +#define _GUARD_NOS_INT_r22 1077 +#define _GUARD_NOS_INT_r33 1078 +#define _GUARD_NOS_ITER_VIRTUAL_r02 1079 +#define _GUARD_NOS_ITER_VIRTUAL_r12 1080 +#define _GUARD_NOS_ITER_VIRTUAL_r22 1081 +#define _GUARD_NOS_ITER_VIRTUAL_r33 1082 +#define _GUARD_NOS_LIST_r02 1083 +#define _GUARD_NOS_LIST_r12 1084 +#define _GUARD_NOS_LIST_r22 1085 +#define _GUARD_NOS_LIST_r33 1086 +#define _GUARD_NOS_NOT_NULL_r02 1087 +#define _GUARD_NOS_NOT_NULL_r12 1088 +#define _GUARD_NOS_NOT_NULL_r22 1089 +#define _GUARD_NOS_NOT_NULL_r33 1090 +#define _GUARD_NOS_NULL_r02 1091 +#define _GUARD_NOS_NULL_r12 1092 +#define _GUARD_NOS_NULL_r22 1093 +#define _GUARD_NOS_NULL_r33 1094 +#define _GUARD_NOS_OVERFLOWED_r02 1095 +#define _GUARD_NOS_OVERFLOWED_r12 1096 +#define _GUARD_NOS_OVERFLOWED_r22 1097 +#define _GUARD_NOS_OVERFLOWED_r33 1098 +#define _GUARD_NOS_TUPLE_r02 1099 +#define _GUARD_NOS_TUPLE_r12 1100 +#define _GUARD_NOS_TUPLE_r22 1101 +#define _GUARD_NOS_TUPLE_r33 1102 +#define _GUARD_NOS_TYPE_VERSION_r02 1103 +#define _GUARD_NOS_TYPE_VERSION_r12 1104 +#define _GUARD_NOS_TYPE_VERSION_r22 1105 +#define _GUARD_NOS_TYPE_VERSION_r33 1106 +#define _GUARD_NOS_UNICODE_r02 1107 +#define _GUARD_NOS_UNICODE_r12 1108 +#define _GUARD_NOS_UNICODE_r22 1109 +#define _GUARD_NOS_UNICODE_r33 1110 +#define _GUARD_NOT_EXHAUSTED_LIST_r02 1111 +#define _GUARD_NOT_EXHAUSTED_LIST_r12 1112 +#define _GUARD_NOT_EXHAUSTED_LIST_r22 1113 +#define _GUARD_NOT_EXHAUSTED_LIST_r33 1114 +#define _GUARD_NOT_EXHAUSTED_RANGE_r02 1115 +#define _GUARD_NOT_EXHAUSTED_RANGE_r12 1116 +#define _GUARD_NOT_EXHAUSTED_RANGE_r22 1117 +#define _GUARD_NOT_EXHAUSTED_RANGE_r33 1118 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r02 1119 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r12 1120 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r22 1121 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r33 1122 +#define _GUARD_THIRD_NULL_r03 1123 +#define _GUARD_THIRD_NULL_r13 1124 +#define _GUARD_THIRD_NULL_r23 1125 +#define _GUARD_THIRD_NULL_r33 1126 +#define _GUARD_TOS_ANY_DICT_r01 1127 +#define _GUARD_TOS_ANY_DICT_r11 1128 +#define _GUARD_TOS_ANY_DICT_r22 1129 +#define _GUARD_TOS_ANY_DICT_r33 1130 +#define _GUARD_TOS_ANY_SET_r01 1131 +#define _GUARD_TOS_ANY_SET_r11 1132 +#define _GUARD_TOS_ANY_SET_r22 1133 +#define _GUARD_TOS_ANY_SET_r33 1134 +#define _GUARD_TOS_DICT_r01 1135 +#define _GUARD_TOS_DICT_r11 1136 +#define _GUARD_TOS_DICT_r22 1137 +#define _GUARD_TOS_DICT_r33 1138 +#define _GUARD_TOS_FLOAT_r01 1139 +#define _GUARD_TOS_FLOAT_r11 1140 +#define _GUARD_TOS_FLOAT_r22 1141 +#define _GUARD_TOS_FLOAT_r33 1142 +#define _GUARD_TOS_FROZENDICT_r01 1143 +#define _GUARD_TOS_FROZENDICT_r11 1144 +#define _GUARD_TOS_FROZENDICT_r22 1145 +#define _GUARD_TOS_FROZENDICT_r33 1146 +#define _GUARD_TOS_FROZENSET_r01 1147 +#define _GUARD_TOS_FROZENSET_r11 1148 +#define _GUARD_TOS_FROZENSET_r22 1149 +#define _GUARD_TOS_FROZENSET_r33 1150 +#define _GUARD_TOS_INT_r01 1151 +#define _GUARD_TOS_INT_r11 1152 +#define _GUARD_TOS_INT_r22 1153 +#define _GUARD_TOS_INT_r33 1154 +#define _GUARD_TOS_LIST_r01 1155 +#define _GUARD_TOS_LIST_r11 1156 +#define _GUARD_TOS_LIST_r22 1157 +#define _GUARD_TOS_LIST_r33 1158 +#define _GUARD_TOS_OVERFLOWED_r01 1159 +#define _GUARD_TOS_OVERFLOWED_r11 1160 +#define _GUARD_TOS_OVERFLOWED_r22 1161 +#define _GUARD_TOS_OVERFLOWED_r33 1162 +#define _GUARD_TOS_SET_r01 1163 +#define _GUARD_TOS_SET_r11 1164 +#define _GUARD_TOS_SET_r22 1165 +#define _GUARD_TOS_SET_r33 1166 +#define _GUARD_TOS_SLICE_r01 1167 +#define _GUARD_TOS_SLICE_r11 1168 +#define _GUARD_TOS_SLICE_r22 1169 +#define _GUARD_TOS_SLICE_r33 1170 +#define _GUARD_TOS_TUPLE_r01 1171 +#define _GUARD_TOS_TUPLE_r11 1172 +#define _GUARD_TOS_TUPLE_r22 1173 +#define _GUARD_TOS_TUPLE_r33 1174 +#define _GUARD_TOS_UNICODE_r01 1175 +#define _GUARD_TOS_UNICODE_r11 1176 +#define _GUARD_TOS_UNICODE_r22 1177 +#define _GUARD_TOS_UNICODE_r33 1178 +#define _GUARD_TYPE_r01 1179 +#define _GUARD_TYPE_r11 1180 +#define _GUARD_TYPE_r22 1181 +#define _GUARD_TYPE_r33 1182 +#define _GUARD_TYPE_VERSION_r01 1183 +#define _GUARD_TYPE_VERSION_r11 1184 +#define _GUARD_TYPE_VERSION_r22 1185 +#define _GUARD_TYPE_VERSION_r33 1186 +#define _GUARD_TYPE_VERSION_LOCKED_r01 1187 +#define _GUARD_TYPE_VERSION_LOCKED_r11 1188 +#define _GUARD_TYPE_VERSION_LOCKED_r22 1189 +#define _GUARD_TYPE_VERSION_LOCKED_r33 1190 +#define _HANDLE_PENDING_AND_DEOPT_r00 1191 +#define _HANDLE_PENDING_AND_DEOPT_r10 1192 +#define _HANDLE_PENDING_AND_DEOPT_r20 1193 +#define _HANDLE_PENDING_AND_DEOPT_r30 1194 +#define _IMPORT_FROM_r12 1195 +#define _IMPORT_NAME_r21 1196 +#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS_r00 1197 +#define _INIT_CALL_PY_EXACT_ARGS_r01 1198 +#define _INIT_CALL_PY_EXACT_ARGS_0_r01 1199 +#define _INIT_CALL_PY_EXACT_ARGS_1_r01 1200 +#define _INIT_CALL_PY_EXACT_ARGS_2_r01 1201 +#define _INIT_CALL_PY_EXACT_ARGS_3_r01 1202 +#define _INIT_CALL_PY_EXACT_ARGS_4_r01 1203 +#define _INSERT_NULL_r10 1204 +#define _INSTRUMENTED_FOR_ITER_r23 1205 +#define _INSTRUMENTED_INSTRUCTION_r00 1206 +#define _INSTRUMENTED_JUMP_FORWARD_r00 1207 +#define _INSTRUMENTED_JUMP_FORWARD_r11 1208 +#define _INSTRUMENTED_JUMP_FORWARD_r22 1209 +#define _INSTRUMENTED_JUMP_FORWARD_r33 1210 +#define _INSTRUMENTED_LINE_r00 1211 +#define _INSTRUMENTED_NOT_TAKEN_r00 1212 +#define _INSTRUMENTED_NOT_TAKEN_r11 1213 +#define _INSTRUMENTED_NOT_TAKEN_r22 1214 +#define _INSTRUMENTED_NOT_TAKEN_r33 1215 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r00 1216 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r10 1217 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r21 1218 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r32 1219 +#define _INSTRUMENTED_POP_JUMP_IF_NONE_r10 1220 +#define _INSTRUMENTED_POP_JUMP_IF_NOT_NONE_r10 1221 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r00 1222 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r10 1223 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r21 1224 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r32 1225 +#define _IS_NONE_r11 1226 +#define _IS_OP_r03 1227 +#define _IS_OP_r13 1228 +#define _IS_OP_r23 1229 +#define _ITER_CHECK_LIST_r02 1230 +#define _ITER_CHECK_LIST_r12 1231 +#define _ITER_CHECK_LIST_r22 1232 +#define _ITER_CHECK_LIST_r33 1233 +#define _ITER_CHECK_RANGE_r02 1234 +#define _ITER_CHECK_RANGE_r12 1235 +#define _ITER_CHECK_RANGE_r22 1236 +#define _ITER_CHECK_RANGE_r33 1237 +#define _ITER_CHECK_TUPLE_r02 1238 +#define _ITER_CHECK_TUPLE_r12 1239 +#define _ITER_CHECK_TUPLE_r22 1240 +#define _ITER_CHECK_TUPLE_r33 1241 +#define _ITER_JUMP_LIST_r02 1242 +#define _ITER_JUMP_LIST_r12 1243 +#define _ITER_JUMP_LIST_r22 1244 +#define _ITER_JUMP_LIST_r33 1245 +#define _ITER_JUMP_RANGE_r02 1246 +#define _ITER_JUMP_RANGE_r12 1247 +#define _ITER_JUMP_RANGE_r22 1248 +#define _ITER_JUMP_RANGE_r33 1249 +#define _ITER_JUMP_TUPLE_r02 1250 +#define _ITER_JUMP_TUPLE_r12 1251 +#define _ITER_JUMP_TUPLE_r22 1252 +#define _ITER_JUMP_TUPLE_r33 1253 +#define _ITER_NEXT_LIST_r23 1254 +#define _ITER_NEXT_LIST_TIER_TWO_r23 1255 +#define _ITER_NEXT_RANGE_r03 1256 +#define _ITER_NEXT_RANGE_r13 1257 +#define _ITER_NEXT_RANGE_r23 1258 +#define _ITER_NEXT_TUPLE_r03 1259 +#define _ITER_NEXT_TUPLE_r13 1260 +#define _ITER_NEXT_TUPLE_r23 1261 +#define _JUMP_BACKWARD_NO_INTERRUPT_r00 1262 +#define _JUMP_BACKWARD_NO_INTERRUPT_r11 1263 +#define _JUMP_BACKWARD_NO_INTERRUPT_r22 1264 +#define _JUMP_BACKWARD_NO_INTERRUPT_r33 1265 +#define _JUMP_TO_TOP_r00 1266 +#define _LIST_APPEND_r10 1267 +#define _LIST_EXTEND_r11 1268 +#define _LOAD_ATTR_r10 1269 +#define _LOAD_ATTR_CLASS_r11 1270 +#define _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN_FRAME_r11 1271 +#define _LOAD_ATTR_INSTANCE_VALUE_r02 1272 +#define _LOAD_ATTR_INSTANCE_VALUE_r12 1273 +#define _LOAD_ATTR_INSTANCE_VALUE_r23 1274 +#define _LOAD_ATTR_METHOD_LAZY_DICT_r02 1275 +#define _LOAD_ATTR_METHOD_LAZY_DICT_r12 1276 +#define _LOAD_ATTR_METHOD_LAZY_DICT_r23 1277 +#define _LOAD_ATTR_METHOD_NO_DICT_r02 1278 +#define _LOAD_ATTR_METHOD_NO_DICT_r12 1279 +#define _LOAD_ATTR_METHOD_NO_DICT_r23 1280 +#define _LOAD_ATTR_METHOD_WITH_VALUES_r02 1281 +#define _LOAD_ATTR_METHOD_WITH_VALUES_r12 1282 +#define _LOAD_ATTR_METHOD_WITH_VALUES_r23 1283 +#define _LOAD_ATTR_MODULE_r12 1284 +#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT_r11 1285 +#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES_r11 1286 +#define _LOAD_ATTR_PROPERTY_FRAME_r01 1287 +#define _LOAD_ATTR_PROPERTY_FRAME_r11 1288 +#define _LOAD_ATTR_PROPERTY_FRAME_r22 1289 +#define _LOAD_ATTR_PROPERTY_FRAME_r33 1290 +#define _LOAD_ATTR_SLOT_r02 1291 +#define _LOAD_ATTR_SLOT_r12 1292 +#define _LOAD_ATTR_SLOT_r23 1293 +#define _LOAD_ATTR_WITH_HINT_r12 1294 +#define _LOAD_BUILD_CLASS_r01 1295 +#define _LOAD_BYTECODE_r00 1296 +#define _LOAD_COMMON_CONSTANT_r01 1297 +#define _LOAD_COMMON_CONSTANT_r12 1298 +#define _LOAD_COMMON_CONSTANT_r23 1299 +#define _LOAD_CONST_r01 1300 +#define _LOAD_CONST_r12 1301 +#define _LOAD_CONST_r23 1302 +#define _LOAD_CONST_INLINE_r01 1303 +#define _LOAD_CONST_INLINE_r12 1304 +#define _LOAD_CONST_INLINE_r23 1305 +#define _LOAD_CONST_INLINE_BORROW_r01 1306 +#define _LOAD_CONST_INLINE_BORROW_r12 1307 +#define _LOAD_CONST_INLINE_BORROW_r23 1308 +#define _LOAD_DEREF_r01 1309 +#define _LOAD_FAST_r01 1310 +#define _LOAD_FAST_r12 1311 +#define _LOAD_FAST_r23 1312 +#define _LOAD_FAST_0_r01 1313 +#define _LOAD_FAST_0_r12 1314 +#define _LOAD_FAST_0_r23 1315 +#define _LOAD_FAST_1_r01 1316 +#define _LOAD_FAST_1_r12 1317 +#define _LOAD_FAST_1_r23 1318 +#define _LOAD_FAST_2_r01 1319 +#define _LOAD_FAST_2_r12 1320 +#define _LOAD_FAST_2_r23 1321 +#define _LOAD_FAST_3_r01 1322 +#define _LOAD_FAST_3_r12 1323 +#define _LOAD_FAST_3_r23 1324 +#define _LOAD_FAST_4_r01 1325 +#define _LOAD_FAST_4_r12 1326 +#define _LOAD_FAST_4_r23 1327 +#define _LOAD_FAST_5_r01 1328 +#define _LOAD_FAST_5_r12 1329 +#define _LOAD_FAST_5_r23 1330 +#define _LOAD_FAST_6_r01 1331 +#define _LOAD_FAST_6_r12 1332 +#define _LOAD_FAST_6_r23 1333 +#define _LOAD_FAST_7_r01 1334 +#define _LOAD_FAST_7_r12 1335 +#define _LOAD_FAST_7_r23 1336 +#define _LOAD_FAST_AND_CLEAR_r01 1337 +#define _LOAD_FAST_AND_CLEAR_r12 1338 +#define _LOAD_FAST_AND_CLEAR_r23 1339 +#define _LOAD_FAST_BORROW_r01 1340 +#define _LOAD_FAST_BORROW_r12 1341 +#define _LOAD_FAST_BORROW_r23 1342 +#define _LOAD_FAST_BORROW_0_r01 1343 +#define _LOAD_FAST_BORROW_0_r12 1344 +#define _LOAD_FAST_BORROW_0_r23 1345 +#define _LOAD_FAST_BORROW_1_r01 1346 +#define _LOAD_FAST_BORROW_1_r12 1347 +#define _LOAD_FAST_BORROW_1_r23 1348 +#define _LOAD_FAST_BORROW_2_r01 1349 +#define _LOAD_FAST_BORROW_2_r12 1350 +#define _LOAD_FAST_BORROW_2_r23 1351 +#define _LOAD_FAST_BORROW_3_r01 1352 +#define _LOAD_FAST_BORROW_3_r12 1353 +#define _LOAD_FAST_BORROW_3_r23 1354 +#define _LOAD_FAST_BORROW_4_r01 1355 +#define _LOAD_FAST_BORROW_4_r12 1356 +#define _LOAD_FAST_BORROW_4_r23 1357 +#define _LOAD_FAST_BORROW_5_r01 1358 +#define _LOAD_FAST_BORROW_5_r12 1359 +#define _LOAD_FAST_BORROW_5_r23 1360 +#define _LOAD_FAST_BORROW_6_r01 1361 +#define _LOAD_FAST_BORROW_6_r12 1362 +#define _LOAD_FAST_BORROW_6_r23 1363 +#define _LOAD_FAST_BORROW_7_r01 1364 +#define _LOAD_FAST_BORROW_7_r12 1365 +#define _LOAD_FAST_BORROW_7_r23 1366 +#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r02 1367 +#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r13 1368 +#define _LOAD_FAST_CHECK_r01 1369 +#define _LOAD_FAST_CHECK_r12 1370 +#define _LOAD_FAST_CHECK_r23 1371 +#define _LOAD_FAST_LOAD_FAST_r02 1372 +#define _LOAD_FAST_LOAD_FAST_r13 1373 +#define _LOAD_FROM_DICT_OR_DEREF_r11 1374 +#define _LOAD_FROM_DICT_OR_GLOBALS_r11 1375 +#define _LOAD_GLOBAL_r00 1376 +#define _LOAD_GLOBAL_BUILTINS_r01 1377 +#define _LOAD_GLOBAL_MODULE_r01 1378 +#define _LOAD_LOCALS_r01 1379 +#define _LOAD_LOCALS_r12 1380 +#define _LOAD_LOCALS_r23 1381 +#define _LOAD_NAME_r01 1382 +#define _LOAD_SMALL_INT_r01 1383 +#define _LOAD_SMALL_INT_r12 1384 +#define _LOAD_SMALL_INT_r23 1385 +#define _LOAD_SMALL_INT_0_r01 1386 +#define _LOAD_SMALL_INT_0_r12 1387 +#define _LOAD_SMALL_INT_0_r23 1388 +#define _LOAD_SMALL_INT_1_r01 1389 +#define _LOAD_SMALL_INT_1_r12 1390 +#define _LOAD_SMALL_INT_1_r23 1391 +#define _LOAD_SMALL_INT_2_r01 1392 +#define _LOAD_SMALL_INT_2_r12 1393 +#define _LOAD_SMALL_INT_2_r23 1394 +#define _LOAD_SMALL_INT_3_r01 1395 +#define _LOAD_SMALL_INT_3_r12 1396 +#define _LOAD_SMALL_INT_3_r23 1397 +#define _LOAD_SPECIAL_r00 1398 +#define _LOAD_SUPER_ATTR_ATTR_r31 1399 +#define _LOAD_SUPER_ATTR_METHOD_r32 1400 +#define _LOCK_OBJECT_r01 1401 +#define _LOCK_OBJECT_r11 1402 +#define _LOCK_OBJECT_r22 1403 +#define _LOCK_OBJECT_r33 1404 +#define _MAKE_CALLARGS_A_TUPLE_r33 1405 +#define _MAKE_CELL_r00 1406 +#define _MAKE_FUNCTION_r12 1407 +#define _MAKE_HEAP_SAFE_r01 1408 +#define _MAKE_HEAP_SAFE_r11 1409 +#define _MAKE_HEAP_SAFE_r22 1410 +#define _MAKE_HEAP_SAFE_r33 1411 +#define _MAKE_WARM_r00 1412 +#define _MAKE_WARM_r11 1413 +#define _MAKE_WARM_r22 1414 +#define _MAKE_WARM_r33 1415 +#define _MAP_ADD_r20 1416 +#define _MATCH_CLASS_r33 1417 +#define _MATCH_KEYS_r23 1418 +#define _MATCH_MAPPING_r02 1419 +#define _MATCH_MAPPING_r12 1420 +#define _MATCH_MAPPING_r23 1421 +#define _MATCH_SEQUENCE_r02 1422 +#define _MATCH_SEQUENCE_r12 1423 +#define _MATCH_SEQUENCE_r23 1424 +#define _MAYBE_EXPAND_METHOD_r00 1425 +#define _MAYBE_EXPAND_METHOD_KW_r11 1426 +#define _MONITOR_CALL_r00 1427 +#define _MONITOR_CALL_KW_r11 1428 +#define _MONITOR_JUMP_BACKWARD_r00 1429 +#define _MONITOR_JUMP_BACKWARD_r11 1430 +#define _MONITOR_JUMP_BACKWARD_r22 1431 +#define _MONITOR_JUMP_BACKWARD_r33 1432 +#define _MONITOR_RESUME_r00 1433 +#define _NOP_r00 1434 +#define _NOP_r11 1435 +#define _NOP_r22 1436 +#define _NOP_r33 1437 +#define _POP_EXCEPT_r10 1438 +#define _POP_ITER_r20 1439 +#define _POP_JUMP_IF_FALSE_r00 1440 +#define _POP_JUMP_IF_FALSE_r10 1441 +#define _POP_JUMP_IF_FALSE_r21 1442 +#define _POP_JUMP_IF_FALSE_r32 1443 +#define _POP_JUMP_IF_TRUE_r00 1444 +#define _POP_JUMP_IF_TRUE_r10 1445 +#define _POP_JUMP_IF_TRUE_r21 1446 +#define _POP_JUMP_IF_TRUE_r32 1447 +#define _POP_TOP_r10 1448 +#define _POP_TOP_FLOAT_r00 1449 +#define _POP_TOP_FLOAT_r10 1450 +#define _POP_TOP_FLOAT_r21 1451 +#define _POP_TOP_FLOAT_r32 1452 +#define _POP_TOP_INT_r00 1453 +#define _POP_TOP_INT_r10 1454 +#define _POP_TOP_INT_r21 1455 +#define _POP_TOP_INT_r32 1456 +#define _POP_TOP_NOP_r00 1457 +#define _POP_TOP_NOP_r10 1458 +#define _POP_TOP_NOP_r21 1459 +#define _POP_TOP_NOP_r32 1460 +#define _POP_TOP_OPARG_r00 1461 +#define _POP_TOP_UNICODE_r00 1462 +#define _POP_TOP_UNICODE_r10 1463 +#define _POP_TOP_UNICODE_r21 1464 +#define _POP_TOP_UNICODE_r32 1465 +#define _PUSH_EXC_INFO_r02 1466 +#define _PUSH_EXC_INFO_r12 1467 +#define _PUSH_EXC_INFO_r23 1468 +#define _PUSH_FRAME_r10 1469 +#define _PUSH_NULL_r01 1470 +#define _PUSH_NULL_r12 1471 +#define _PUSH_NULL_r23 1472 +#define _PUSH_NULL_CONDITIONAL_r00 1473 +#define _PUSH_TAGGED_ZERO_r01 1474 +#define _PUSH_TAGGED_ZERO_r12 1475 +#define _PUSH_TAGGED_ZERO_r23 1476 +#define _PY_FRAME_EX_r31 1477 +#define _PY_FRAME_GENERAL_r01 1478 +#define _PY_FRAME_KW_r11 1479 +#define _REPLACE_WITH_TRUE_r02 1480 +#define _REPLACE_WITH_TRUE_r12 1481 +#define _REPLACE_WITH_TRUE_r23 1482 +#define _RESUME_CHECK_r00 1483 +#define _RESUME_CHECK_r11 1484 +#define _RESUME_CHECK_r22 1485 +#define _RESUME_CHECK_r33 1486 +#define _RETURN_GENERATOR_r01 1487 +#define _RETURN_VALUE_r11 1488 +#define _SAVE_RETURN_OFFSET_r00 1489 +#define _SAVE_RETURN_OFFSET_r11 1490 +#define _SAVE_RETURN_OFFSET_r22 1491 +#define _SAVE_RETURN_OFFSET_r33 1492 +#define _SEND_r33 1493 +#define _SEND_GEN_FRAME_r33 1494 +#define _SETUP_ANNOTATIONS_r00 1495 +#define _SET_ADD_r10 1496 +#define _SET_FUNCTION_ATTRIBUTE_r01 1497 +#define _SET_FUNCTION_ATTRIBUTE_r11 1498 +#define _SET_FUNCTION_ATTRIBUTE_r21 1499 +#define _SET_FUNCTION_ATTRIBUTE_r32 1500 +#define _SET_IP_r00 1501 +#define _SET_IP_r11 1502 +#define _SET_IP_r22 1503 +#define _SET_IP_r33 1504 +#define _SET_UPDATE_r11 1505 +#define _SPILL_OR_RELOAD_r01 1506 +#define _SPILL_OR_RELOAD_r02 1507 +#define _SPILL_OR_RELOAD_r03 1508 +#define _SPILL_OR_RELOAD_r10 1509 +#define _SPILL_OR_RELOAD_r12 1510 +#define _SPILL_OR_RELOAD_r13 1511 +#define _SPILL_OR_RELOAD_r20 1512 +#define _SPILL_OR_RELOAD_r21 1513 +#define _SPILL_OR_RELOAD_r23 1514 +#define _SPILL_OR_RELOAD_r30 1515 +#define _SPILL_OR_RELOAD_r31 1516 +#define _SPILL_OR_RELOAD_r32 1517 +#define _START_EXECUTOR_r00 1518 +#define _STORE_ATTR_r20 1519 +#define _STORE_ATTR_INSTANCE_VALUE_r21 1520 +#define _STORE_ATTR_SLOT_r21 1521 +#define _STORE_ATTR_WITH_HINT_r21 1522 +#define _STORE_DEREF_r10 1523 +#define _STORE_FAST_LOAD_FAST_r11 1524 +#define _STORE_FAST_STORE_FAST_r20 1525 +#define _STORE_GLOBAL_r10 1526 +#define _STORE_NAME_r10 1527 +#define _STORE_SLICE_r30 1528 +#define _STORE_SUBSCR_r30 1529 +#define _STORE_SUBSCR_DICT_r31 1530 +#define _STORE_SUBSCR_DICT_KNOWN_HASH_r31 1531 +#define _STORE_SUBSCR_LIST_INT_r32 1532 +#define _SWAP_r11 1533 +#define _SWAP_2_r02 1534 +#define _SWAP_2_r12 1535 +#define _SWAP_2_r22 1536 +#define _SWAP_2_r33 1537 +#define _SWAP_3_r03 1538 +#define _SWAP_3_r13 1539 +#define _SWAP_3_r23 1540 +#define _SWAP_3_r33 1541 +#define _SWAP_FAST_r01 1542 +#define _SWAP_FAST_r11 1543 +#define _SWAP_FAST_r22 1544 +#define _SWAP_FAST_r33 1545 +#define _SWAP_FAST_0_r01 1546 +#define _SWAP_FAST_0_r11 1547 +#define _SWAP_FAST_0_r22 1548 +#define _SWAP_FAST_0_r33 1549 +#define _SWAP_FAST_1_r01 1550 +#define _SWAP_FAST_1_r11 1551 +#define _SWAP_FAST_1_r22 1552 +#define _SWAP_FAST_1_r33 1553 +#define _SWAP_FAST_2_r01 1554 +#define _SWAP_FAST_2_r11 1555 +#define _SWAP_FAST_2_r22 1556 +#define _SWAP_FAST_2_r33 1557 +#define _SWAP_FAST_3_r01 1558 +#define _SWAP_FAST_3_r11 1559 +#define _SWAP_FAST_3_r22 1560 +#define _SWAP_FAST_3_r33 1561 +#define _SWAP_FAST_4_r01 1562 +#define _SWAP_FAST_4_r11 1563 +#define _SWAP_FAST_4_r22 1564 +#define _SWAP_FAST_4_r33 1565 +#define _SWAP_FAST_5_r01 1566 +#define _SWAP_FAST_5_r11 1567 +#define _SWAP_FAST_5_r22 1568 +#define _SWAP_FAST_5_r33 1569 +#define _SWAP_FAST_6_r01 1570 +#define _SWAP_FAST_6_r11 1571 +#define _SWAP_FAST_6_r22 1572 +#define _SWAP_FAST_6_r33 1573 +#define _SWAP_FAST_7_r01 1574 +#define _SWAP_FAST_7_r11 1575 +#define _SWAP_FAST_7_r22 1576 +#define _SWAP_FAST_7_r33 1577 +#define _TIER2_RESUME_CHECK_r00 1578 +#define _TIER2_RESUME_CHECK_r11 1579 +#define _TIER2_RESUME_CHECK_r22 1580 +#define _TIER2_RESUME_CHECK_r33 1581 +#define _TO_BOOL_r11 1582 +#define _TO_BOOL_BOOL_r01 1583 +#define _TO_BOOL_BOOL_r11 1584 +#define _TO_BOOL_BOOL_r22 1585 +#define _TO_BOOL_BOOL_r33 1586 +#define _TO_BOOL_INT_r02 1587 +#define _TO_BOOL_INT_r12 1588 +#define _TO_BOOL_INT_r23 1589 +#define _TO_BOOL_LIST_r02 1590 +#define _TO_BOOL_LIST_r12 1591 +#define _TO_BOOL_LIST_r23 1592 +#define _TO_BOOL_NONE_r01 1593 +#define _TO_BOOL_NONE_r11 1594 +#define _TO_BOOL_NONE_r22 1595 +#define _TO_BOOL_NONE_r33 1596 +#define _TO_BOOL_STR_r02 1597 +#define _TO_BOOL_STR_r12 1598 +#define _TO_BOOL_STR_r23 1599 +#define _TRACE_RECORD_r00 1600 +#define _UNARY_INVERT_r12 1601 +#define _UNARY_NEGATIVE_r12 1602 +#define _UNARY_NEGATIVE_FLOAT_INPLACE_r02 1603 +#define _UNARY_NEGATIVE_FLOAT_INPLACE_r12 1604 +#define _UNARY_NEGATIVE_FLOAT_INPLACE_r23 1605 +#define _UNARY_NOT_r01 1606 +#define _UNARY_NOT_r11 1607 +#define _UNARY_NOT_r22 1608 +#define _UNARY_NOT_r33 1609 +#define _UNPACK_EX_r10 1610 +#define _UNPACK_SEQUENCE_r10 1611 +#define _UNPACK_SEQUENCE_LIST_r10 1612 +#define _UNPACK_SEQUENCE_TUPLE_r10 1613 +#define _UNPACK_SEQUENCE_TWO_TUPLE_r12 1614 +#define _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE_r03 1615 +#define _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE_r13 1616 +#define _UNPACK_SEQUENCE_UNIQUE_TUPLE_r10 1617 +#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r02 1618 +#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r12 1619 +#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r23 1620 +#define _WITH_EXCEPT_START_r33 1621 +#define _YIELD_VALUE_r11 1622 +#define MAX_UOP_REGS_ID 1622 #ifdef __cplusplus } diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index 8465fd4345e9a5..17fd5d04838309 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -397,7 +397,6 @@ const uint32_t _PyUop_Flags[MAX_UOP_ID+1] = { [_CHECK_VALIDITY] = HAS_DEOPT_FLAG, [_LOAD_CONST_INLINE] = HAS_PURE_FLAG, [_LOAD_CONST_INLINE_BORROW] = HAS_PURE_FLAG, - [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW] = 0, [_START_EXECUTOR] = HAS_DEOPT_FLAG, [_MAKE_WARM] = 0, [_FATAL_ERROR] = 0, @@ -3700,15 +3699,6 @@ const _PyUopCachingInfo _PyUop_Caching[MAX_UOP_ID+1] = { { -1, -1, -1 }, }, }, - [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW] = { - .best = { 0, 1, 2, 3 }, - .entries = { - { 3, 0, _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r03 }, - { 3, 1, _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r13 }, - { 3, 2, _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r23 }, - { 3, 3, _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r33 }, - }, - }, [_START_EXECUTOR] = { .best = { 0, 0, 0, 0 }, .entries = { @@ -4705,10 +4695,6 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_LOAD_CONST_INLINE_BORROW_r01] = _LOAD_CONST_INLINE_BORROW, [_LOAD_CONST_INLINE_BORROW_r12] = _LOAD_CONST_INLINE_BORROW, [_LOAD_CONST_INLINE_BORROW_r23] = _LOAD_CONST_INLINE_BORROW, - [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r03] = _SHUFFLE_3_LOAD_CONST_INLINE_BORROW, - [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r13] = _SHUFFLE_3_LOAD_CONST_INLINE_BORROW, - [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r23] = _SHUFFLE_3_LOAD_CONST_INLINE_BORROW, - [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r33] = _SHUFFLE_3_LOAD_CONST_INLINE_BORROW, [_START_EXECUTOR_r00] = _START_EXECUTOR, [_MAKE_WARM_r00] = _MAKE_WARM, [_MAKE_WARM_r11] = _MAKE_WARM, @@ -5933,11 +5919,6 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_SET_IP_r33] = "_SET_IP_r33", [_SET_UPDATE] = "_SET_UPDATE", [_SET_UPDATE_r11] = "_SET_UPDATE_r11", - [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW] = "_SHUFFLE_3_LOAD_CONST_INLINE_BORROW", - [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r03] = "_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r03", - [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r13] = "_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r13", - [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r23] = "_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r23", - [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r33] = "_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r33", [_SPILL_OR_RELOAD] = "_SPILL_OR_RELOAD", [_SPILL_OR_RELOAD_r01] = "_SPILL_OR_RELOAD_r01", [_SPILL_OR_RELOAD_r02] = "_SPILL_OR_RELOAD_r02", @@ -6827,8 +6808,6 @@ int _PyUop_num_popped(int opcode, int oparg) return 0; case _LOAD_CONST_INLINE_BORROW: return 0; - case _SHUFFLE_3_LOAD_CONST_INLINE_BORROW: - return 3; case _START_EXECUTOR: return 0; case _MAKE_WARM: diff --git a/Lib/test/test_capi/test_opt.py b/Lib/test/test_capi/test_opt.py index b37c35495983c3..79643587a60002 100644 --- a/Lib/test/test_capi/test_opt.py +++ b/Lib/test/test_capi/test_opt.py @@ -2963,7 +2963,7 @@ def testfunc(n): self.assertIsNotNone(ex) uops = get_opnames(ex) self.assertNotIn("_CALL_LEN", uops) - self.assertEqual(count_ops(ex, "_SHUFFLE_3_LOAD_CONST_INLINE_BORROW"), 4) + self.assertGreaterEqual(count_ops(ex, "_LOAD_CONST_INLINE_BORROW"), 8) def test_call_len_known_length_small_int(self): # Make sure that len(t) is optimized for a tuple of length 5. diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 59db0eb399b121..a73df99f3f5578 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -6107,13 +6107,6 @@ dummy_func( value = PyStackRef_FromPyObjectBorrow(ptr); } - tier2 op(_SHUFFLE_3_LOAD_CONST_INLINE_BORROW, (ptr/4, callable, null, arg -- res, a, c)) { - res = PyStackRef_FromPyObjectBorrow(ptr); - a = arg; - c = callable; - INPUTS_DEAD(); - } - tier2 op(_START_EXECUTOR, (executor/4 --)) { #ifndef _Py_JIT assert(current_executor == (_PyExecutorObject*)executor); diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 93d39bee1b9ff6..5a7129c1ffdea5 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -22337,106 +22337,6 @@ break; } - case _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r03: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef callable; - _PyStackRef res; - _PyStackRef a; - _PyStackRef c; - arg = stack_pointer[-1]; - callable = stack_pointer[-3]; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectBorrow(ptr); - a = arg; - c = callable; - _tos_cache2 = c; - _tos_cache1 = a; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r13: { - CHECK_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef callable; - _PyStackRef res; - _PyStackRef a; - _PyStackRef c; - _PyStackRef _stack_item_0 = _tos_cache0; - arg = _stack_item_0; - callable = stack_pointer[-2]; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectBorrow(ptr); - a = arg; - c = callable; - _tos_cache2 = c; - _tos_cache1 = a; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r23: { - CHECK_CURRENT_CACHED_VALUES(2); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef callable; - _PyStackRef res; - _PyStackRef a; - _PyStackRef c; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - arg = _stack_item_1; - callable = stack_pointer[-1]; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectBorrow(ptr); - a = arg; - c = callable; - _tos_cache2 = c; - _tos_cache1 = a; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r33: { - CHECK_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef callable; - _PyStackRef res; - _PyStackRef a; - _PyStackRef c; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - arg = _stack_item_2; - callable = _stack_item_0; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectBorrow(ptr); - a = arg; - c = callable; - _tos_cache2 = c; - _tos_cache1 = a; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - case _START_EXECUTOR_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); diff --git a/Python/optimizer_bytecodes.c b/Python/optimizer_bytecodes.c index daebef4a04320b..ae9e19341441ea 100644 --- a/Python/optimizer_bytecodes.c +++ b/Python/optimizer_bytecodes.c @@ -2330,7 +2330,10 @@ dummy_func(void) { goto error; } if (_Py_IsImmortal(temp)) { - ADD_OP(_SHUFFLE_3_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)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); Py_DECREF(temp); diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index c3c889e9de9a7e..d48f38a95f7b16 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -4514,11 +4514,13 @@ 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); @@ -4544,7 +4546,10 @@ goto error; } if (_Py_IsImmortal(temp)) { - ADD_OP(_SHUFFLE_3_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)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); @@ -5497,19 +5502,6 @@ break; } - case _SHUFFLE_3_LOAD_CONST_INLINE_BORROW: { - JitOptRef res; - JitOptRef a; - JitOptRef c; - res = sym_new_not_null(ctx); - a = sym_new_not_null(ctx); - c = sym_new_not_null(ctx); - stack_pointer[-3] = res; - stack_pointer[-2] = a; - stack_pointer[-1] = c; - break; - } - case _START_EXECUTOR: { break; } From 993e204ad44fd95ac522a7903f83a4bbe5d3af9c Mon Sep 17 00:00:00 2001 From: ivonastojanovic <80911834+ivonastojanovic@users.noreply.github.com> Date: Tue, 28 Apr 2026 17:42:21 +0100 Subject: [PATCH 3/4] gh-142927: Fix inverted flamegraph width (#148568) Fix inverted flamegraph width The inverted view used thread presence as a proxy for self time. This missed self samples on C-level wrapper frames like _run_code, where the node's thread always appears in its children too. Those samples were silently dropped, causing the chart to render narrower than full width. Now uses the explicit self field on each node instead of the thread heuristic. --- .../sampling/_flamegraph_assets/flamegraph.js | 15 +++++---------- 1 file changed, 5 insertions(+), 10 deletions(-) diff --git a/Lib/profiling/sampling/_flamegraph_assets/flamegraph.js b/Lib/profiling/sampling/_flamegraph_assets/flamegraph.js index d7a8890d4a1ad9..3f884c4c690fd1 100644 --- a/Lib/profiling/sampling/_flamegraph_assets/flamegraph.js +++ b/Lib/profiling/sampling/_flamegraph_assets/flamegraph.js @@ -1063,11 +1063,7 @@ function populateStats(data) { funcname = funcname || 'unknown'; if (filename !== 'unknown' && funcname !== 'unknown' && node.value > 0) { - let childrenValue = 0; - if (node.children) { - childrenValue = node.children.reduce((sum, child) => sum + child.value, 0); - } - const directSamples = Math.max(0, node.value - childrenValue); + const directSamples = node.self || 0; const funcKey = `${filename}:${node.lineno || '?'}:${funcname}`; @@ -1345,14 +1341,13 @@ function processLeaf(invertedRoot, path, leafNode, isDifferential) { } function traverseInvert(path, currentNode, invertedRoot, isDifferential) { - const children = currentNode.children || []; - const childThreads = new Set(children.flatMap(c => c.threads || [])); - const selfThreads = (currentNode.threads || []).filter(t => !childThreads.has(t)); + const selfValue = currentNode.self || 0; - if (selfThreads.length > 0) { - processLeaf(invertedRoot, path, { ...currentNode, threads: selfThreads }, isDifferential); + if (selfValue > 0) { + processLeaf(invertedRoot, path, { ...currentNode, value: selfValue }, isDifferential); } + const children = currentNode.children || []; children.forEach(child => traverseInvert(path.concat([child]), child, invertedRoot, isDifferential)); } From 8a8d737be200aef4d3f4ffd576505d2ff660a3a8 Mon Sep 17 00:00:00 2001 From: John Belmonte Date: Tue, 28 Apr 2026 09:45:55 -0700 Subject: [PATCH 4/4] gh-108951: document addition of TaskGroup.cancel() (#149031) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Alex Grönholm Co-authored-by: Bénédikt Tran <10796600+picnixz@users.noreply.github.com> --- Doc/library/asyncio-task.rst | 4 ++-- Doc/whatsnew/3.15.rst | 11 +++++++++++ .../2024-11-24-07-18-40.gh-issue-108951.jyKygP.rst | 3 ++- 3 files changed, 15 insertions(+), 3 deletions(-) diff --git a/Doc/library/asyncio-task.rst b/Doc/library/asyncio-task.rst index f0fe91b363d95e..2e17d0dc70c7a5 100644 --- a/Doc/library/asyncio-task.rst +++ b/Doc/library/asyncio-task.rst @@ -394,8 +394,8 @@ Example:: The ``async with`` statement will wait for all tasks in the group to finish. While waiting, new tasks may still be added to the group (for example, by passing ``tg`` into one of the coroutines -and calling ``tg.create_task()`` in that coroutine). There is also opportunity -to short-circuit the entire task group with ``tg.cancel()``, based on some condition. +and calling ``tg.create_task()`` in that coroutine). There is also opportunity to +request termination of the entire task group with ``tg.cancel()``, based on some condition. Once the last task has finished and the ``async with`` block is exited, no new tasks may be added to the group. diff --git a/Doc/whatsnew/3.15.rst b/Doc/whatsnew/3.15.rst index 6f0f7021de8e7a..eb08f8c4ed69e7 100644 --- a/Doc/whatsnew/3.15.rst +++ b/Doc/whatsnew/3.15.rst @@ -741,6 +741,17 @@ ast (Contributed by Stan Ulbrych in :gh:`148981`.) +asyncio +------- + +* Added :meth:`TaskGroup.cancel ` to allow early + termination of a task group, for instance, when the goal of the tasks has + been achieved or their services are no longer needed. + Previously this would involve unintuitive boilerplate such as an extra task + raising a custom exception which is then suppressed as it exits the task group. + (Contributed by John Belmonte in :gh:`127214`.) + + base64 ------ diff --git a/Misc/NEWS.d/next/Library/2024-11-24-07-18-40.gh-issue-108951.jyKygP.rst b/Misc/NEWS.d/next/Library/2024-11-24-07-18-40.gh-issue-108951.jyKygP.rst index 1696a2dd1728ed..0e0280c9b6b0e7 100644 --- a/Misc/NEWS.d/next/Library/2024-11-24-07-18-40.gh-issue-108951.jyKygP.rst +++ b/Misc/NEWS.d/next/Library/2024-11-24-07-18-40.gh-issue-108951.jyKygP.rst @@ -1 +1,2 @@ -Add :meth:`~asyncio.TaskGroup.cancel` which cancels unfinished tasks and exits the group without error. +:mod:`asyncio`: Add :meth:`TaskGroup.cancel ` which cancels +unfinished tasks and exits the group without raising :exc:`asyncio.CancelledError`.