From a4afdd73818d4ab37e3620a4145813ee5ccc4eee Mon Sep 17 00:00:00 2001 From: meanmail Date: Wed, 14 Oct 2026 20:36:30 +0400 Subject: [PATCH 1/4] Add experimental None-aware attribute access on Python 3.15 --- Doc/library/token-list.inc | 2 + Doc/none-aware-prototype.md | 70 ++++++++ Grammar/Tokens | 1 + Grammar/python.gram | 5 +- Include/internal/pycore_ast.h | 19 +- Include/internal/pycore_ast_state.h | 2 + Include/internal/pycore_token.h | 29 ++-- Lib/_ast_unparse.py | 10 ++ Lib/test/test_none_aware.py | 260 ++++++++++++++++++++++++++++ Lib/token.py | 32 ++-- Parser/Python.asdl | 2 + Parser/action_helpers.c | 29 ++++ Parser/parser.c | 53 +++++- Parser/pegen.h | 1 + Parser/token.c | 6 + Python/Python-ast.c | 248 ++++++++++++++++++++++++++ Python/ast.c | 6 + Python/ast_preprocess.c | 6 + Python/ast_unparse.c | 9 + Python/codegen.c | 54 ++++++ Python/symtable.c | 9 + 21 files changed, 816 insertions(+), 37 deletions(-) create mode 100644 Doc/none-aware-prototype.md create mode 100644 Lib/test/test_none_aware.py diff --git a/Doc/library/token-list.inc b/Doc/library/token-list.inc index 655758c4a400cc..f158bfd7029ed9 100644 --- a/Doc/library/token-list.inc +++ b/Doc/library/token-list.inc @@ -102,3 +102,5 @@ - ``":="`` * - .. data:: EXCLAMATION - ``"!"`` + * - .. data:: MAYBEDOT + - ``"?."`` diff --git a/Doc/none-aware-prototype.md b/Doc/none-aware-prototype.md new file mode 100644 index 00000000000000..8927863aaba40d --- /dev/null +++ b/Doc/none-aware-prototype.md @@ -0,0 +1,70 @@ +# None-aware attribute access prototype + +This experimental fork adds `?.` to CPython 3.15.0. The prototype branch is +`meanmail/none-aware-access-3.15`, based on upstream tag `v3.15.0` at +`d220409a13b77de7a6c30abe16ea90db01528edc`. The default `main` branch is reserved +for upstream synchronization. + +```python +name = user?.profile?.name +name = user?.profile.name.upper() or "Unknown" +``` + +Each `?.` evaluates its left operand once. If it is `None`, the remaining +attribute accesses, calls and subscripts in that primary expression are skipped +and the result is `None`. Other falsy values are processed normally. No temporary +names are introduced and no exceptions from existing objects are suppressed. + +- `user?.profile.name` returns `None` when `user` is `None`. +- If `user` exists but `user.profile` is `None`, `.name` raises `AttributeError`. +- `user?.profile?.name` also checks the profile for `None`. +- `user?.method(expensive())[index()]` skips both functions when `user` is `None`. +- `(user?.profile).name` ends the chain at the closing parenthesis and may raise. +- Direct assignments, augmented assignments and deletion through a chain are + rejected. `(user?.profile).name = value` is an ordinary assignment to the + independently evaluated result and retains ordinary Python behavior. + +The lexer recognizes `?.` as one token; whitespace between `?` and `.` is not +supported. This is an intentionally small experiment inspired by +[PEP 823](https://peps.python.org/pep-0823/), not a full implementation of that +proposal. `?[...]`, `?()`, `??` and `??=` are not implemented. + +## Implementation + +`NoneAwareAttribute(value, attr)` represents each checked access. +`OptionalChain(value)` marks the whole primary expression containing checked +accesses. Wrapping occurs when a primary expression is completed, so parentheses +and independently evaluated arguments establish distinct chains. The compiler +uses existing `COPY` and `POP_JUMP_IF_NONE` instructions, leaving `None` on the +stack and jumping past the tail when a check fails. No new opcode is needed. + +Both AST nodes support validation, preprocessing, symbol analysis and unparsing. +Unparsing includes parentheses around an optional chain to preserve its boundary. +Programs without the new syntax keep their original AST and compilation path. +External IDEs, formatters and type checkers do not yet understand this syntax. + +## Build and run + +Install the ordinary CPython build dependencies first. On macOS with Homebrew: + +```sh +brew install pkgconf openssl@3 readline sqlite xz zstd +./configure --with-pydebug --with-openssl="$(brew --prefix openssl@3)" +make -j8 +./python.exe -c 'user = None; print(user?.profile.name)' +``` + +On Linux, use the normal CPython build prerequisites and `./python` instead of +`./python.exe`. This prototype is tested locally on macOS arm64. + +After editing the grammar or AST, regenerate the derived source files in order: + +```sh +make regen-token +make regen-ast +make regen-pegen +make -j8 +./python.exe -m test test_none_aware test_grammar test_ast test_unparse test_tokenize test_compile test_symtable +``` + +The ordinary CPython and Python Software Foundation licensing continues to apply. diff --git a/Grammar/Tokens b/Grammar/Tokens index 0547e6ed08f79a..e3cfedc73c654c 100644 --- a/Grammar/Tokens +++ b/Grammar/Tokens @@ -59,6 +59,7 @@ RARROW '->' ELLIPSIS '...' COLONEQUAL ':=' EXCLAMATION '!' +MAYBEDOT '?.' OP TYPE_IGNORE diff --git a/Grammar/python.gram b/Grammar/python.gram index 4408d69d9a06e1..677fb58fa84340 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -869,10 +869,11 @@ power[expr_ty]: # Primary elements are things like "obj.something.something", "obj[something]", "obj(something)", "obj" ... await_primary[expr_ty] (memo): - | 'await' a=primary { CHECK_VERSION(expr_ty, 5, "Await expressions are", _PyAST_Await(a, EXTRA)) } - | primary + | 'await' a=primary { CHECK_VERSION(expr_ty, 5, "Await expressions are", _PyAST_Await(CHECK(expr_ty, _PyPegen_optional_chain(p, a)), EXTRA)) } + | a=primary { _PyPegen_optional_chain(p, a) } primary[expr_ty]: + | a=primary '?.' b=NAME { _PyAST_NoneAwareAttribute(a, b->v.Name.id, EXTRA) } | a=primary '.' b=NAME { _PyAST_Attribute(a, b->v.Name.id, Load, EXTRA) } | a=primary b=genexp { _PyAST_Call(a, CHECK(asdl_expr_seq*, (asdl_expr_seq*)_PyPegen_singleton_seq(p, b)), NULL, EXTRA) } | a=primary '(' b=[arguments] ')' { diff --git a/Include/internal/pycore_ast.h b/Include/internal/pycore_ast.h index b47398669bbe51..57e6d3bed84a9d 100644 --- a/Include/internal/pycore_ast.h +++ b/Include/internal/pycore_ast.h @@ -365,8 +365,9 @@ enum _expr_kind {BoolOp_kind=1, NamedExpr_kind=2, BinOp_kind=3, UnaryOp_kind=4, YieldFrom_kind=15, Compare_kind=16, Call_kind=17, FormattedValue_kind=18, Interpolation_kind=19, JoinedStr_kind=20, TemplateStr_kind=21, Constant_kind=22, - Attribute_kind=23, Subscript_kind=24, Starred_kind=25, - Name_kind=26, List_kind=27, Tuple_kind=28, Slice_kind=29}; + NoneAwareAttribute_kind=23, OptionalChain_kind=24, + Attribute_kind=25, Subscript_kind=26, Starred_kind=27, + Name_kind=28, List_kind=29, Tuple_kind=30, Slice_kind=31}; struct _expr { enum _expr_kind kind; union { @@ -482,6 +483,15 @@ struct _expr { string kind; } Constant; + struct { + expr_ty value; + identifier attr; + } NoneAwareAttribute; + + struct { + expr_ty value; + } OptionalChain; + struct { expr_ty value; identifier attr; @@ -846,6 +856,11 @@ expr_ty _PyAST_TemplateStr(asdl_expr_seq * values, int lineno, int col_offset, expr_ty _PyAST_Constant(constant value, string kind, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_NoneAwareAttribute(expr_ty value, identifier attr, int lineno, + int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_OptionalChain(expr_ty value, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); expr_ty _PyAST_Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena); diff --git a/Include/internal/pycore_ast_state.h b/Include/internal/pycore_ast_state.h index 32c12fb5875e8e..174a90c187a062 100644 --- a/Include/internal/pycore_ast_state.h +++ b/Include/internal/pycore_ast_state.h @@ -112,6 +112,7 @@ struct ast_state { PyObject *Mult_type; PyObject *Name_type; PyObject *NamedExpr_type; + PyObject *NoneAwareAttribute_type; PyObject *Nonlocal_type; PyObject *NotEq_singleton; PyObject *NotEq_type; @@ -119,6 +120,7 @@ struct ast_state { PyObject *NotIn_type; PyObject *Not_singleton; PyObject *Not_type; + PyObject *OptionalChain_type; PyObject *Or_singleton; PyObject *Or_type; PyObject *ParamSpec_type; diff --git a/Include/internal/pycore_token.h b/Include/internal/pycore_token.h index 5de1f719a2f1a2..a1248b9f4841ee 100644 --- a/Include/internal/pycore_token.h +++ b/Include/internal/pycore_token.h @@ -68,20 +68,21 @@ extern "C" { #define ELLIPSIS 52 #define COLONEQUAL 53 #define EXCLAMATION 54 -#define OP 55 -#define TYPE_IGNORE 56 -#define TYPE_COMMENT 57 -#define SOFT_KEYWORD 58 -#define FSTRING_START 59 -#define FSTRING_MIDDLE 60 -#define FSTRING_END 61 -#define TSTRING_START 62 -#define TSTRING_MIDDLE 63 -#define TSTRING_END 64 -#define COMMENT 65 -#define NL 66 -#define ERRORTOKEN 67 -#define N_TOKENS 69 +#define MAYBEDOT 55 +#define OP 56 +#define TYPE_IGNORE 57 +#define TYPE_COMMENT 58 +#define SOFT_KEYWORD 59 +#define FSTRING_START 60 +#define FSTRING_MIDDLE 61 +#define FSTRING_END 62 +#define TSTRING_START 63 +#define TSTRING_MIDDLE 64 +#define TSTRING_END 65 +#define COMMENT 66 +#define NL 67 +#define ERRORTOKEN 68 +#define N_TOKENS 70 #define NT_OFFSET 256 /* Special definitions for cooperation with parser */ diff --git a/Lib/_ast_unparse.py b/Lib/_ast_unparse.py index 916bb25d74dee9..112ae2f4d3581b 100644 --- a/Lib/_ast_unparse.py +++ b/Lib/_ast_unparse.py @@ -919,6 +919,16 @@ def increasing_level_traverse(node): s = f" {operator} " self.interleave(lambda: self.write(s), increasing_level_traverse, node.values) + def visit_NoneAwareAttribute(self, node: NoneAwareAttribute) -> None: + self.set_precedence(_Precedence.ATOM, node.value) + self.traverse(node.value) + self.write("?.") + self.write(node.attr) + + def visit_OptionalChain(self, node: OptionalChain) -> None: + with self.delimit("(", ")"): + self.traverse(node.value) + def visit_Attribute(self, node): self.set_precedence(_Precedence.ATOM, node.value) self.traverse(node.value) diff --git a/Lib/test/test_none_aware.py b/Lib/test/test_none_aware.py new file mode 100644 index 00000000000000..e0e057cd98effa --- /dev/null +++ b/Lib/test/test_none_aware.py @@ -0,0 +1,260 @@ +import ast +import io +import tokenize +import unittest +from types import SimpleNamespace +from typing import Any + + +class NoneAwareTests(unittest.TestCase): + def evaluate(self, source: str, **namespace: Any) -> Any: + return eval(source, namespace) + + def test_attribute(self) -> None: + self.assertIsNone(self.evaluate("value?.name", value=None)) + self.assertEqual( + self.evaluate("value?.name", value=SimpleNamespace(name="Ada")), + "Ada", + ) + + def test_only_none_short_circuits(self) -> None: + for value in (0, False, "", [], {}): + with self.subTest(value=value): + self.assertIs( + self.evaluate("value?.__class__", value=value), type(value) + ) + + def test_does_not_test_truthiness(self) -> None: + class Value: + name = "Ada" + + def __bool__(self) -> bool: + raise AssertionError("Truthiness must not be evaluated") + + self.assertEqual(self.evaluate("value?.name", value=Value()), "Ada") + + def test_base_evaluated_once(self) -> None: + calls = [] + + def make() -> SimpleNamespace: + calls.append(1) + return SimpleNamespace(name="Ada") + + self.assertEqual(self.evaluate("make()?.name", make=make), "Ada") + self.assertEqual(calls, [1]) + + def test_chain(self) -> None: + source = "value?.profile.name.upper()" + self.assertIsNone(self.evaluate(source, value=None)) + self.assertEqual( + self.evaluate( + source, + value=SimpleNamespace(profile=SimpleNamespace(name="Ada")), + ), + "ADA", + ) + + def test_multiple_checks(self) -> None: + source = "value?.profile?.name" + for value in (None, SimpleNamespace(profile=None)): + with self.subTest(value=value): + self.assertIsNone(self.evaluate(source, value=value)) + self.assertEqual( + self.evaluate( + source, + value=SimpleNamespace(profile=SimpleNamespace(name="Ada")), + ), + "Ada", + ) + + def test_unchecked_none_still_raises(self) -> None: + with self.assertRaises(AttributeError): + self.evaluate( + "value?.profile.name", value=SimpleNamespace(profile=None) + ) + + def test_missing_attribute_still_raises(self) -> None: + with self.assertRaises(AttributeError): + self.evaluate("value?.missing", value=object()) + + def test_property_error_still_raises(self) -> None: + class Value: + @property + def name(self) -> str: + raise ValueError("Property failed") + + with self.assertRaisesRegex(ValueError, "Property failed"): + self.evaluate("value?.name", value=Value()) + + def test_call_arguments_skipped(self) -> None: + def fail() -> None: + raise AssertionError("Argument must not be evaluated") + + for source in ( + "value?.method(fail())", + "value?.method(key=fail())", + "value?.method(*fail(), **fail())", + ): + with self.subTest(source=source): + self.assertIsNone(self.evaluate(source, value=None, fail=fail)) + + def test_call_arguments_evaluated(self) -> None: + value = SimpleNamespace(method=lambda *args, **kwargs: (args, kwargs)) + self.assertEqual( + self.evaluate( + "value?.method(1, *[2], key=3, **{'other': 4})", value=value + ), + ((1, 2), {"key": 3, "other": 4}), + ) + + def test_subscript_tail(self) -> None: + self.assertIsNone(self.evaluate("value?.items[missing]", value=None)) + self.assertEqual( + self.evaluate( + "value?.items[1]", value=SimpleNamespace(items=[1, 2]) + ), + 2, + ) + self.assertEqual( + self.evaluate( + "value?.items[1:]", value=SimpleNamespace(items=[1, 2, 3]) + ), + [2, 3], + ) + + def test_parentheses_end_chain(self) -> None: + with self.assertRaises(AttributeError): + self.evaluate("(value?.profile).name", value=None) + with self.assertRaises(TypeError): + self.evaluate("(value?.method)(missing)", value=None, missing=1) + self.assertIsNone(self.evaluate("(value?.profile)?.name", value=None)) + + def test_nested_argument_is_independent(self) -> None: + self.assertEqual( + self.evaluate( + "identity(value?.name).real", value=None, identity=lambda x: 5 + ), + 5, + ) + + def test_boolean_and_conditional_context(self) -> None: + self.assertEqual( + self.evaluate("value?.name or 'fallback'", value=None), "fallback" + ) + self.assertEqual( + self.evaluate("1 if value?.name else 2", value=None), 2 + ) + self.assertTrue(self.evaluate("value?.name is None", value=None)) + + def test_lambda_and_comprehension(self) -> None: + self.assertEqual( + self.evaluate( + "[value?.name for value in values]", + values=[None, SimpleNamespace(name="Ada")], + ), + [None, "Ada"], + ) + self.assertIsNone(self.evaluate("(lambda value: value?.name)(None)")) + + def test_fstring(self) -> None: + self.assertEqual(self.evaluate("f'{value?.name}'", value=None), "None") + + def test_no_temporary_names(self) -> None: + namespace = {"value": SimpleNamespace(name="Ada"), "__builtins__": {}} + self.assertEqual(eval("value?.name", namespace), "Ada") + self.assertEqual(set(namespace), {"value", "__builtins__"}) + + def test_invalid_targets(self) -> None: + for source in ( + "value?.name = 1", + "value?.name += 1", + "value?.profile.name = 1", + "value?.items[0] = 1", + "del value?.name", + "del value?.items[0]", + "for value?.name in []: pass", + "value?.name: int = 1", + ): + with self.subTest(source=source), self.assertRaises(SyntaxError): + compile(source, "", "exec") + + def test_other_question_mark_operators_rejected(self) -> None: + for source in ("value?", "value?[0]", "value?()", "value ?? 1"): + with self.subTest(source=source), self.assertRaises(SyntaxError): + compile(source, "", "eval") + + def test_ast_roundtrip(self) -> None: + for source in ( + "value?.name", + "value?.profile.name.upper()", + "(value?.profile).name", + "value?.items[key?.name]", + "value?.profile?.name", + ): + with self.subTest(source=source): + tree = ast.parse(source, mode="eval") + self.assertIsInstance( + tree.body, + ast.OptionalChain + if not source.startswith("(") + else ast.Attribute, + ) + self.assertEqual( + ast.dump(ast.parse(ast.unparse(tree), mode="eval")), + ast.dump(tree), + ) + compile(tree, "", "eval") + + def test_tokenize_roundtrip(self) -> None: + source = "value?.name" + tokens = list(tokenize.generate_tokens(io.StringIO(source).readline)) + self.assertEqual(tokenize.untokenize(tokens), source) + self.assertNotIn(tokenize.ERRORTOKEN, [token.type for token in tokens]) + + def test_generator_call(self) -> None: + self.assertIsNone( + self.evaluate("value?.method(x for x in missing)", value=None) + ) + self.assertEqual( + self.evaluate( + "value?.method(x for x in [1, 2])", + value=SimpleNamespace(method=list), + ), + [1, 2], + ) + + def test_nested_chain_arguments(self) -> None: + self.assertEqual( + self.evaluate( + "value?.method(other?.name).real", + value=SimpleNamespace(method=lambda x: 5), + other=None, + ), + 5, + ) + + def test_grouped_assignment(self) -> None: + profile = SimpleNamespace(name="Ada") + namespace = {"value": SimpleNamespace(profile=profile)} + exec("(value?.profile).name = 'Grace'", namespace) + self.assertEqual(profile.name, "Grace") + + def test_annotation_unparse(self) -> None: + namespace = {"value": None} + exec("from __future__ import annotations\nx: value?.name", namespace) + annotation = namespace["__annotations__"]["x"] + self.assertIsNone(eval(annotation, namespace)) + + def test_numeric_base(self) -> None: + self.assertEqual(self.evaluate("1?.real"), 1) + self.assertEqual(self.evaluate("1.5?.real"), 1.5) + + def test_ast_validation(self) -> None: + tree = ast.parse("value?.name", mode="eval") + tree.body.value.value.ctx = ast.Store() + with self.assertRaises(ValueError): + compile(tree, "", "eval") + + +if __name__ == "__main__": + unittest.main() diff --git a/Lib/token.py b/Lib/token.py index f61723cc09da02..2b5e3231872a73 100644 --- a/Lib/token.py +++ b/Lib/token.py @@ -59,22 +59,23 @@ ELLIPSIS = 52 COLONEQUAL = 53 EXCLAMATION = 54 -OP = 55 -TYPE_IGNORE = 56 -TYPE_COMMENT = 57 -SOFT_KEYWORD = 58 -FSTRING_START = 59 -FSTRING_MIDDLE = 60 -FSTRING_END = 61 -TSTRING_START = 62 -TSTRING_MIDDLE = 63 -TSTRING_END = 64 -COMMENT = 65 -NL = 66 +MAYBEDOT = 55 +OP = 56 +TYPE_IGNORE = 57 +TYPE_COMMENT = 58 +SOFT_KEYWORD = 59 +FSTRING_START = 60 +FSTRING_MIDDLE = 61 +FSTRING_END = 62 +TSTRING_START = 63 +TSTRING_MIDDLE = 64 +TSTRING_END = 65 +COMMENT = 66 +NL = 67 # These aren't used by the C tokenizer but are needed for tokenize.py -ERRORTOKEN = 67 -ENCODING = 68 -N_TOKENS = 69 +ERRORTOKEN = 68 +ENCODING = 69 +N_TOKENS = 70 # Special definitions for cooperation with parser NT_OFFSET = 256 @@ -121,6 +122,7 @@ '>=': GREATEREQUAL, '>>': RIGHTSHIFT, '>>=': RIGHTSHIFTEQUAL, + '?.': MAYBEDOT, '@': AT, '@=': ATEQUAL, '[': LSQB, diff --git a/Parser/Python.asdl b/Parser/Python.asdl index 2f0b123858f8d1..6f4a2b88548032 100644 --- a/Parser/Python.asdl +++ b/Parser/Python.asdl @@ -82,6 +82,8 @@ module Python | JoinedStr(expr* values) | TemplateStr(expr* values) | Constant(constant value, string? kind) + | NoneAwareAttribute(expr value, identifier attr) + | OptionalChain(expr value) -- the following expression can appear in assignment context | Attribute(expr value, identifier attr, expr_context ctx) diff --git a/Parser/action_helpers.c b/Parser/action_helpers.c index 94d2a0a65dd33c..94189212c256cc 100644 --- a/Parser/action_helpers.c +++ b/Parser/action_helpers.c @@ -1085,6 +1085,9 @@ _PyPegen_get_expr_name(expr_ty e) { assert(e != NULL); switch (e->kind) { + case NoneAwareAttribute_kind: + case OptionalChain_kind: + return "optional chain"; case Attribute_kind: return "attribute"; case Subscript_kind: @@ -2132,3 +2135,29 @@ _PyPegen_register_stmts(Parser *p, asdl_stmt_seq* stmts) { p->last_stmt_location.end_col_offset = last_stmt->end_col_offset; return stmts; } + +/* Wrap a completed primary, without crossing independent expression boundaries. */ +expr_ty +_PyPegen_optional_chain(Parser *p, expr_ty value) +{ + expr_ty current = value; + for (;;) { + switch (current->kind) { + case NoneAwareAttribute_kind: + return _PyAST_OptionalChain(value, value->lineno, + value->col_offset, value->end_lineno, + value->end_col_offset, p->arena); + case Attribute_kind: + current = current->v.Attribute.value; + break; + case Call_kind: + current = current->v.Call.func; + break; + case Subscript_kind: + current = current->v.Subscript.value; + break; + default: + return value; + } + } +} diff --git a/Parser/parser.c b/Parser/parser.c index bc4219bae2851c..6114fcb44d1862 100644 --- a/Parser/parser.c +++ b/Parser/parser.c @@ -14844,7 +14844,7 @@ await_primary_rule(Parser *p) UNUSED(_end_lineno); // Only used by EXTRA macro int _end_col_offset = _token->end_col_offset; UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = CHECK_VERSION ( expr_ty , 5 , "Await expressions are" , _PyAST_Await ( a , EXTRA ) ); + _res = CHECK_VERSION ( expr_ty , 5 , "Await expressions are" , _PyAST_Await ( CHECK ( expr_ty , _PyPegen_optional_chain ( p , a ) ) , EXTRA ) ); if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -14862,13 +14862,18 @@ await_primary_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> await_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary")); - expr_ty primary_var; + expr_ty a; if ( - (primary_var = primary_rule(p)) // primary + (a = primary_rule(p)) // primary ) { D(fprintf(stderr, "%*c+ await_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary")); - _res = primary_var; + _res = _PyPegen_optional_chain ( p , a ); + if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } goto done; } p->mark = _mark; @@ -14884,6 +14889,7 @@ await_primary_rule(Parser *p) // Left-recursive // primary: +// | primary '?.' NAME // | primary '.' NAME // | primary genexp // | primary '(' arguments? ')' @@ -14945,6 +14951,45 @@ primary_raw(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + { // primary '?.' NAME + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '?.' NAME")); + Token * _literal; + expr_ty a; + expr_ty b; + if ( + (a = primary_rule(p)) // primary + && + (_literal = _PyPegen_expect_token(p, 55)) // token='?.' + && + (b = _PyPegen_name_token(p)) // NAME + ) + { + D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '?.' NAME")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_NoneAwareAttribute ( a , b -> v . Name . id , EXTRA ); + if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '?.' NAME")); + } { // primary '.' NAME if (p->error_indicator) { p->level--; diff --git a/Parser/pegen.h b/Parser/pegen.h index cbf44ba474fa39..bed837c4379eea 100644 --- a/Parser/pegen.h +++ b/Parser/pegen.h @@ -370,6 +370,7 @@ ResultTokenWithMetadata *_PyPegen_setup_full_format_spec(Parser *, Token *, asdl mod_ty _PyPegen_make_module(Parser *, asdl_stmt_seq *); void *_PyPegen_arguments_parsing_error(Parser *, expr_ty); expr_ty _PyPegen_get_last_comprehension_item(comprehension_ty comprehension); +expr_ty _PyPegen_optional_chain(Parser *p, expr_ty value); void *_PyPegen_nonparen_genexp_in_call(Parser *p, expr_ty args, asdl_comprehension_seq *comprehensions); stmt_ty _PyPegen_checked_from_import(Parser *p, asdl_seq *dots, expr_ty module_name, asdl_alias_seq *names, expr_ty lazy_token, int lineno, diff --git a/Parser/token.c b/Parser/token.c index a6e7ce35dfad85..601ec1e0b8be2f 100644 --- a/Parser/token.c +++ b/Parser/token.c @@ -61,6 +61,7 @@ const char * const _PyParser_TokenNames[] = { "ELLIPSIS", "COLONEQUAL", "EXCLAMATION", + "MAYBEDOT", "OP", "TYPE_IGNORE", "TYPE_COMMENT", @@ -177,6 +178,11 @@ _PyToken_TwoChars(int c1, int c2) case '>': return RIGHTSHIFT; } break; + case '?': + switch (c2) { + case '.': return MAYBEDOT; + } + break; case '@': switch (c2) { case '=': return ATEQUAL; diff --git a/Python/Python-ast.c b/Python/Python-ast.c index 63b0215ebe2c0a..59c2585efa9261 100644 --- a/Python/Python-ast.c +++ b/Python/Python-ast.c @@ -129,6 +129,7 @@ void _PyAST_Fini(PyInterpreterState *interp) Py_CLEAR(state->Mult_type); Py_CLEAR(state->Name_type); Py_CLEAR(state->NamedExpr_type); + Py_CLEAR(state->NoneAwareAttribute_type); Py_CLEAR(state->Nonlocal_type); Py_CLEAR(state->NotEq_singleton); Py_CLEAR(state->NotEq_type); @@ -136,6 +137,7 @@ void _PyAST_Fini(PyInterpreterState *interp) Py_CLEAR(state->NotIn_type); Py_CLEAR(state->Not_singleton); Py_CLEAR(state->Not_type); + Py_CLEAR(state->OptionalChain_type); Py_CLEAR(state->Or_singleton); Py_CLEAR(state->Or_type); Py_CLEAR(state->ParamSpec_type); @@ -644,6 +646,13 @@ static const char * const Constant_fields[]={ "value", "kind", }; +static const char * const NoneAwareAttribute_fields[]={ + "value", + "attr", +}; +static const char * const OptionalChain_fields[]={ + "value", +}; static const char * const Attribute_fields[]={ "value", "attr", @@ -3393,6 +3402,71 @@ add_ast_annotations(struct ast_state *state) return 0; } Py_DECREF(Constant_annotations); + PyObject *NoneAwareAttribute_annotations = PyDict_New(); + if (!NoneAwareAttribute_annotations) return 0; + { + PyObject *type = state->expr_type; + Py_INCREF(type); + cond = PyDict_SetItemString(NoneAwareAttribute_annotations, "value", + type) == 0; + Py_DECREF(type); + if (!cond) { + Py_DECREF(NoneAwareAttribute_annotations); + return 0; + } + } + { + PyObject *type = (PyObject *)&PyUnicode_Type; + Py_INCREF(type); + cond = PyDict_SetItemString(NoneAwareAttribute_annotations, "attr", + type) == 0; + Py_DECREF(type); + if (!cond) { + Py_DECREF(NoneAwareAttribute_annotations); + return 0; + } + } + cond = PyObject_SetAttrString(state->NoneAwareAttribute_type, + "_field_types", + NoneAwareAttribute_annotations) == 0; + if (!cond) { + Py_DECREF(NoneAwareAttribute_annotations); + return 0; + } + cond = PyObject_SetAttrString(state->NoneAwareAttribute_type, + "__annotations__", + NoneAwareAttribute_annotations) == 0; + if (!cond) { + Py_DECREF(NoneAwareAttribute_annotations); + return 0; + } + Py_DECREF(NoneAwareAttribute_annotations); + PyObject *OptionalChain_annotations = PyDict_New(); + if (!OptionalChain_annotations) return 0; + { + PyObject *type = state->expr_type; + Py_INCREF(type); + cond = PyDict_SetItemString(OptionalChain_annotations, "value", type) + == 0; + Py_DECREF(type); + if (!cond) { + Py_DECREF(OptionalChain_annotations); + return 0; + } + } + cond = PyObject_SetAttrString(state->OptionalChain_type, "_field_types", + OptionalChain_annotations) == 0; + if (!cond) { + Py_DECREF(OptionalChain_annotations); + return 0; + } + cond = PyObject_SetAttrString(state->OptionalChain_type, "__annotations__", + OptionalChain_annotations) == 0; + if (!cond) { + Py_DECREF(OptionalChain_annotations); + return 0; + } + Py_DECREF(OptionalChain_annotations); PyObject *Attribute_annotations = PyDict_New(); if (!Attribute_annotations) return 0; { @@ -6361,6 +6435,8 @@ init_types(void *arg) " | JoinedStr(expr* values)\n" " | TemplateStr(expr* values)\n" " | Constant(constant value, string? kind)\n" + " | NoneAwareAttribute(expr value, identifier attr)\n" + " | OptionalChain(expr value)\n" " | Attribute(expr value, identifier attr, expr_context ctx)\n" " | Subscript(expr value, expr slice, expr_context ctx)\n" " | Starred(expr value, expr_context ctx)\n" @@ -6479,6 +6555,16 @@ init_types(void *arg) if (!state->Constant_type) return -1; if (PyObject_SetAttr(state->Constant_type, state->kind, Py_None) == -1) return -1; + state->NoneAwareAttribute_type = make_type(state, "NoneAwareAttribute", + state->expr_type, + NoneAwareAttribute_fields, 2, + "NoneAwareAttribute(expr value, identifier attr)"); + if (!state->NoneAwareAttribute_type) return -1; + state->OptionalChain_type = make_type(state, "OptionalChain", + state->expr_type, + OptionalChain_fields, 1, + "OptionalChain(expr value)"); + if (!state->OptionalChain_type) return -1; state->Attribute_type = make_type(state, "Attribute", state->expr_type, Attribute_fields, 3, "Attribute(expr value, identifier attr, expr_context ctx)"); @@ -8243,6 +8329,57 @@ _PyAST_Constant(constant value, string kind, int lineno, int col_offset, int return p; } +expr_ty +_PyAST_NoneAwareAttribute(expr_ty value, identifier attr, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena) +{ + expr_ty p; + if (!value) { + PyErr_SetString(PyExc_ValueError, + "field 'value' is required for NoneAwareAttribute"); + return NULL; + } + if (!attr) { + PyErr_SetString(PyExc_ValueError, + "field 'attr' is required for NoneAwareAttribute"); + return NULL; + } + p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p)); + if (!p) + return NULL; + p->kind = NoneAwareAttribute_kind; + p->v.NoneAwareAttribute.value = value; + p->v.NoneAwareAttribute.attr = attr; + p->lineno = lineno; + p->col_offset = col_offset; + p->end_lineno = end_lineno; + p->end_col_offset = end_col_offset; + return p; +} + +expr_ty +_PyAST_OptionalChain(expr_ty value, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena) +{ + expr_ty p; + if (!value) { + PyErr_SetString(PyExc_ValueError, + "field 'value' is required for OptionalChain"); + return NULL; + } + p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p)); + if (!p) + return NULL; + p->kind = OptionalChain_kind; + p->v.OptionalChain.value = value; + p->lineno = lineno; + p->col_offset = col_offset; + p->end_lineno = end_lineno; + p->end_col_offset = end_col_offset; + return p; +} + expr_ty _PyAST_Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int lineno, int col_offset, int end_lineno, int end_col_offset, @@ -9911,6 +10048,31 @@ ast2obj_expr(struct ast_state *state, void* _o) goto failed; Py_DECREF(value); break; + case NoneAwareAttribute_kind: + tp = (PyTypeObject *)state->NoneAwareAttribute_type; + result = PyType_GenericNew(tp, NULL, NULL); + if (!result) goto failed; + value = ast2obj_expr(state, o->v.NoneAwareAttribute.value); + if (!value) goto failed; + if (PyObject_SetAttr(result, state->value, value) == -1) + goto failed; + Py_DECREF(value); + value = ast2obj_identifier(state, o->v.NoneAwareAttribute.attr); + if (!value) goto failed; + if (PyObject_SetAttr(result, state->attr, value) == -1) + goto failed; + Py_DECREF(value); + break; + case OptionalChain_kind: + tp = (PyTypeObject *)state->OptionalChain_type; + result = PyType_GenericNew(tp, NULL, NULL); + if (!result) goto failed; + value = ast2obj_expr(state, o->v.OptionalChain.value); + if (!value) goto failed; + if (PyObject_SetAttr(result, state->value, value) == -1) + goto failed; + Py_DECREF(value); + break; case Attribute_kind: tp = (PyTypeObject *)state->Attribute_type; result = PyType_GenericNew(tp, NULL, NULL); @@ -15275,6 +15437,84 @@ obj2ast_expr(struct ast_state *state, PyObject* obj, expr_ty* out, PyArena* if (*out == NULL) goto failed; return 0; } + tp = state->NoneAwareAttribute_type; + isinstance = PyObject_IsInstance(obj, tp); + if (isinstance == -1) { + return -1; + } + if (isinstance) { + expr_ty value; + identifier attr; + + if (PyObject_GetOptionalAttr(obj, state->value, &tmp) < 0) { + return -1; + } + if (tmp == NULL) { + PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from NoneAwareAttribute"); + return -1; + } + else { + int res; + if (_Py_EnterRecursiveCall(" while traversing 'NoneAwareAttribute' node")) { + goto failed; + } + res = obj2ast_expr(state, tmp, &value, arena); + _Py_LeaveRecursiveCall(); + if (res != 0) goto failed; + Py_CLEAR(tmp); + } + if (PyObject_GetOptionalAttr(obj, state->attr, &tmp) < 0) { + return -1; + } + if (tmp == NULL) { + PyErr_SetString(PyExc_TypeError, "required field \"attr\" missing from NoneAwareAttribute"); + return -1; + } + else { + int res; + if (_Py_EnterRecursiveCall(" while traversing 'NoneAwareAttribute' node")) { + goto failed; + } + res = obj2ast_identifier(state, tmp, &attr, arena); + _Py_LeaveRecursiveCall(); + if (res != 0) goto failed; + Py_CLEAR(tmp); + } + *out = _PyAST_NoneAwareAttribute(value, attr, lineno, col_offset, + end_lineno, end_col_offset, arena); + if (*out == NULL) goto failed; + return 0; + } + tp = state->OptionalChain_type; + isinstance = PyObject_IsInstance(obj, tp); + if (isinstance == -1) { + return -1; + } + if (isinstance) { + expr_ty value; + + if (PyObject_GetOptionalAttr(obj, state->value, &tmp) < 0) { + return -1; + } + if (tmp == NULL) { + PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from OptionalChain"); + return -1; + } + else { + int res; + if (_Py_EnterRecursiveCall(" while traversing 'OptionalChain' node")) { + goto failed; + } + res = obj2ast_expr(state, tmp, &value, arena); + _Py_LeaveRecursiveCall(); + if (res != 0) goto failed; + Py_CLEAR(tmp); + } + *out = _PyAST_OptionalChain(value, lineno, col_offset, end_lineno, + end_col_offset, arena); + if (*out == NULL) goto failed; + return 0; + } tp = state->Attribute_type; isinstance = PyObject_IsInstance(obj, tp); if (isinstance == -1) { @@ -18212,6 +18452,14 @@ astmodule_exec(PyObject *m) if (PyModule_AddObjectRef(m, "Constant", state->Constant_type) < 0) { return -1; } + if (PyModule_AddObjectRef(m, "NoneAwareAttribute", + state->NoneAwareAttribute_type) < 0) { + return -1; + } + if (PyModule_AddObjectRef(m, "OptionalChain", state->OptionalChain_type) < + 0) { + return -1; + } if (PyModule_AddObjectRef(m, "Attribute", state->Attribute_type) < 0) { return -1; } diff --git a/Python/ast.c b/Python/ast.c index 1befd177811492..56ea197e6b3ea4 100644 --- a/Python/ast.c +++ b/Python/ast.c @@ -371,6 +371,12 @@ validate_expr(expr_ty exp, expr_context_ty ctx) case Attribute_kind: ret = validate_expr(exp->v.Attribute.value, Load); break; + case NoneAwareAttribute_kind: + ret = validate_expr(exp->v.NoneAwareAttribute.value, Load); + break; + case OptionalChain_kind: + ret = validate_expr(exp->v.OptionalChain.value, Load); + break; case Subscript_kind: ret = validate_expr(exp->v.Subscript.slice, Load) && validate_expr(exp->v.Subscript.value, Load); diff --git a/Python/ast_preprocess.c b/Python/ast_preprocess.c index 951b3f71522b25..7fc9ce84fa0601 100644 --- a/Python/ast_preprocess.c +++ b/Python/ast_preprocess.c @@ -601,6 +601,12 @@ astfold_expr(expr_ty node_, PyArena *ctx_, _PyASTPreprocessState *state) case Attribute_kind: CALL(astfold_expr, expr_ty, node_->v.Attribute.value); break; + case NoneAwareAttribute_kind: + CALL(astfold_expr, expr_ty, node_->v.NoneAwareAttribute.value); + break; + case OptionalChain_kind: + CALL(astfold_expr, expr_ty, node_->v.OptionalChain.value); + break; case Subscript_kind: CALL(astfold_expr, expr_ty, node_->v.Subscript.value); CALL(astfold_expr, expr_ty, node_->v.Subscript.slice); diff --git a/Python/ast_unparse.c b/Python/ast_unparse.c index 6050c351cff68f..a4afc5f605249e 100644 --- a/Python/ast_unparse.c +++ b/Python/ast_unparse.c @@ -992,6 +992,15 @@ append_ast_expr(PyUnicodeWriter *writer, expr_ty e, int level) /* The following exprs can be assignment targets. */ case Attribute_kind: return append_ast_attribute(writer, e); + case NoneAwareAttribute_kind: + APPEND_EXPR(e->v.NoneAwareAttribute.value, PR_ATOM); + APPEND_STR("?."); + return PyUnicodeWriter_WriteStr(writer, e->v.NoneAwareAttribute.attr); + case OptionalChain_kind: + APPEND_CHAR('('); + APPEND_EXPR(e->v.OptionalChain.value, PR_TEST); + APPEND_CHAR(')'); + return 0; case Subscript_kind: return append_ast_subscript(writer, e); case Starred_kind: diff --git a/Python/codegen.c b/Python/codegen.c index dbe889c5441182..820cdbccf1f796 100644 --- a/Python/codegen.c +++ b/Python/codegen.c @@ -5372,6 +5372,56 @@ codegen_with(compiler *c, stmt_ty s) return codegen_with_inner(c, s, 0); } +/* Every checked access in this primary jumps to the same chain boundary. */ +static int +codegen_optional_chain_tail(compiler *c, expr_ty e, jump_target_label end) +{ + if (Py_EnterRecursiveCall(" during compilation")) { + return ERROR; + } + location loc = LOC(e); + switch (e->kind) { + case NoneAwareAttribute_kind: + RETURN_IF_ERROR(codegen_optional_chain_tail( + c, e->v.NoneAwareAttribute.value, end)); + ADDOP_I(c, loc, COPY, 1); + ADDOP_JUMP(c, loc, POP_JUMP_IF_NONE, end); + ADDOP_NAME(c, loc, LOAD_ATTR, e->v.NoneAwareAttribute.attr, names); + break; + case Attribute_kind: + RETURN_IF_ERROR(codegen_optional_chain_tail( + c, e->v.Attribute.value, end)); + ADDOP_NAME(c, loc, LOAD_ATTR, e->v.Attribute.attr, names); + break; + case Subscript_kind: + RETURN_IF_ERROR(codegen_optional_chain_tail( + c, e->v.Subscript.value, end)); + VISIT(c, expr, e->v.Subscript.slice); + ADDOP_I(c, loc, BINARY_OP, NB_SUBSCR); + break; + case Call_kind: + RETURN_IF_ERROR(codegen_validate_keywords(c, e->v.Call.keywords)); + RETURN_IF_ERROR(codegen_optional_chain_tail(c, e->v.Call.func, end)); + ADDOP(c, LOC(e->v.Call.func), PUSH_NULL); + RETURN_IF_ERROR(codegen_call_helper( + c, loc, 0, e->v.Call.args, e->v.Call.keywords)); + break; + default: + VISIT(c, expr, e); + break; + } + return SUCCESS; +} + +static int +codegen_optional_chain(compiler *c, expr_ty value) +{ + NEW_JUMP_TARGET_LABEL(c, end); + RETURN_IF_ERROR(codegen_optional_chain_tail(c, value, end)); + USE_LABEL(c, end); + return SUCCESS; +} + static int codegen_visit_expr(compiler *c, expr_ty e) { @@ -5459,6 +5509,10 @@ codegen_visit_expr(compiler *c, expr_ty e) case Constant_kind: ADDOP_LOAD_CONST(c, loc, e->v.Constant.value); break; + case NoneAwareAttribute_kind: + return codegen_optional_chain(c, e); + case OptionalChain_kind: + return codegen_optional_chain(c, e->v.OptionalChain.value); case JoinedStr_kind: return codegen_joined_str(c, e); case TemplateStr_kind: diff --git a/Python/symtable.c b/Python/symtable.c index ff4c75514851cf..038c2898948597 100644 --- a/Python/symtable.c +++ b/Python/symtable.c @@ -2626,6 +2626,15 @@ symtable_visit_expr(struct symtable *st, expr_ty e) } VISIT(st, expr, e->v.Attribute.value); break; + case NoneAwareAttribute_kind: + if (!check_name(st, e->v.NoneAwareAttribute.attr, LOCATION(e), Load)) { + return 0; + } + VISIT(st, expr, e->v.NoneAwareAttribute.value); + break; + case OptionalChain_kind: + VISIT(st, expr, e->v.OptionalChain.value); + break; case Subscript_kind: VISIT(st, expr, e->v.Subscript.value); VISIT(st, expr, e->v.Subscript.slice); From 733dee071f2ec3374537a90aa71f4336f7c39d7b Mon Sep 17 00:00:00 2001 From: meanmail Date: Wed, 14 Oct 2026 22:25:48 +0400 Subject: [PATCH 2/4] Fuse fast-local loads for None-aware access without reloading operands --- Doc/none-aware-prototype.md | 42 +++++++++++++++ Lib/test/test_none_aware.py | 103 ++++++++++++++++++++++++++++++++++++ Python/flowgraph.c | 15 ++++++ 3 files changed, 160 insertions(+) diff --git a/Doc/none-aware-prototype.md b/Doc/none-aware-prototype.md index 8927863aaba40d..57a420f99ce0f4 100644 --- a/Doc/none-aware-prototype.md +++ b/Doc/none-aware-prototype.md @@ -38,11 +38,53 @@ and independently evaluated arguments establish distinct chains. The compiler uses existing `COPY` and `POP_JUMP_IF_NONE` instructions, leaving `None` on the stack and jumping past the tail when a check fails. No new opcode is needed. +For an initialized fast local in slots 0 through 15, the CFG optimizer combines +`LOAD_FAST; COPY 1; POP_JUMP_IF_NONE` into +`LOAD_FAST_LOAD_FAST; POP_JUMP_IF_NONE`. This removes one instruction dispatch +without adding another lookup after the check. Both stack references refer to +the original operand, even if an opcode trace callback rebinds the local before +the check. The references retain their normal ownership. Uninitialized locals, +higher-numbered slots, dynamic name lookups and intermediate chain results keep +the original implementation. Fusion also respects source-line boundaries. + Both AST nodes support validation, preprocessing, symbol analysis and unparsing. Unparsing includes parentheses around an optional chain to preserve its boundary. Programs without the new syntax keep their original AST and compilation path. External IDEs, formatters and type checkers do not yet understand this syntax. +## Local optimization measurements + +Measured on Apple M3 Pro with a non-debug Clang `-O3` build, without PGO or LTO. +Each sample times one million function calls. Each build runs 51 rounds, with +shuffled cases and shuffled ordering of the optional and explicit variants. +Objects are `types.SimpleNamespace` instances. The explicit chain uses two +`is None` checks and stores `profile` in a temporary local. Values below are +median nanoseconds per call, including the function call itself. + +| Case | Original `?.` | Fused `?.` | Explicit check in fused build | +| --- | ---: | ---: | ---: | +| Attribute, `None` | 16.01 | 16.05 | 15.22 | +| Attribute, object | 34.02 | 34.11 | 34.22 | +| Chain, `None` | 16.31 | 16.29 | 17.04 | +| Chain, missing profile | 37.69 | 36.25 | 37.60 | +| Chain, full object | 52.98 | 51.67 | 53.91 | + +The original and fused builds were timed separately, so cross-build differences +also include scheduling and clock variation. Background load produced outliers; +these figures do not establish statistically significant speedups. Fusion +removes an instruction dispatch, but does not remove reference ownership costs +or the `COPY` used for intermediate results. Object access is approximately on +par with the explicit check here; the `None` case still shows a small difference. +Zero overhead across all cases is not established. + +Optimization regression tests cover bytecode fusion, the local-slot limit, +unbound locals, dynamic namespace lookup, expression stack balance and rebinding +through opcode tracing. The earlier local-reload approach was discarded because +it failed the tracing regression. After fusion, the compiler, AST, grammar, +unparser, tokenizer, symbol-table, peephole, disassembly, tracing and monitoring +test files pass. The earlier full-suite result applies to the original prototype; +the complete suite has not been repeated for this optimization. + ## Build and run Install the ordinary CPython build dependencies first. On macOS with Homebrew: diff --git a/Lib/test/test_none_aware.py b/Lib/test/test_none_aware.py index e0e057cd98effa..191b74ed8ee50b 100644 --- a/Lib/test/test_none_aware.py +++ b/Lib/test/test_none_aware.py @@ -1,5 +1,7 @@ import ast +import dis import io +import sys import tokenize import unittest from types import SimpleNamespace @@ -43,6 +45,107 @@ def make() -> SimpleNamespace: self.assertEqual(self.evaluate("make()?.name", make=make), "Ada") self.assertEqual(calls, [1]) + def test_local_access_uses_fused_load(self) -> None: + namespace: dict[str, Any] = {"Any": Any} + exec( + "def optional(value: Any) -> Any:\n" + " return value?.name\n" + "def explicit(value: Any) -> Any:\n" + " return value.name if value is not None else None\n", + namespace, + ) + optional = namespace["optional"] + explicit = namespace["explicit"] + self.assertIn( + "LOAD_FAST_LOAD_FAST", + [instruction.opname for instruction in dis.get_instructions(optional)], + ) + self.assertNotIn( + "COPY", + [instruction.opname for instruction in dis.get_instructions(optional)], + ) + for value in (None, SimpleNamespace(name="Ada")): + self.assertEqual(optional(value), explicit(value)) + + def test_traced_local_rebinding_preserves_operand(self) -> None: + namespace: dict[str, Any] = {"Any": Any} + exec("def access(value: Any) -> Any:\n return value?.name\n", namespace) + access = namespace["access"] + check_offset = next( + instruction.offset + for instruction in dis.get_instructions(access) + if instruction.opname == "POP_JUMP_IF_NONE" + ) + + def trace(frame: Any, event: str, argument: Any) -> Any: + if frame.f_code is access.__code__: + frame.f_trace_opcodes = True + if event == "opcode" and frame.f_lasti == check_offset: + frame.f_locals["value"] = None + return trace + + previous_trace = sys.gettrace() + sys.settrace(trace) + try: + self.assertEqual(access(SimpleNamespace(name="Ada")), "Ada") + finally: + sys.settrace(previous_trace) + + def test_local_access_outside_fused_load_range(self) -> None: + namespace: dict[str, Any] = {"Any": Any} + parameters = [f"arg{index}: Any" for index in range(16)] + parameters.append("value: Any") + exec( + f"def access({', '.join(parameters)}) -> Any:\n" + " return value?.name\n", + namespace, + ) + access = namespace["access"] + self.assertIn( + "COPY", [instruction.opname for instruction in dis.get_instructions(access)] + ) + for value, expected in ((None, None), (SimpleNamespace(name="Ada"), "Ada")): + self.assertEqual(access(*([None] * 16), value), expected) + + def test_local_access_in_expression_and_chain(self) -> None: + namespace: dict[str, Any] = {"Any": Any} + exec( + "def access(value: Any) -> Any:\n" + " result = ('prefix', value?.profile?.name)\n" + " return result\n", + namespace, + ) + for value, expected in ( + (None, None), + (SimpleNamespace(profile=None), None), + (SimpleNamespace(profile=SimpleNamespace(name="Ada")), "Ada"), + ): + self.assertEqual(namespace["access"](value), ("prefix", expected)) + + def test_unbound_local_access(self) -> None: + namespace: dict[str, Any] = {"Any": Any} + exec( + "def access() -> Any:\n" + " result = value?.name\n" + " value = None\n" + " return result\n", + namespace, + ) + with self.assertRaises(UnboundLocalError): + namespace["access"]() + + def test_dynamic_name_lookup_once(self) -> None: + class Namespace(dict[str, Any]): + def __getitem__(self, key: str) -> Any: + if key == "value": + calls.append(key) + return SimpleNamespace(name="Ada") + return super().__getitem__(key) + + calls: list[str] = [] + self.assertEqual(eval("value?.name", {}, Namespace()), "Ada") + self.assertEqual(calls, ["value"]) + def test_chain(self) -> None: source = "value?.profile.name.upper()" self.assertIsNone(self.evaluate(source, value=None)) diff --git a/Python/flowgraph.c b/Python/flowgraph.c index 9accd111440f05..25349759d5c346 100644 --- a/Python/flowgraph.c +++ b/Python/flowgraph.c @@ -2707,6 +2707,21 @@ insert_superinstructions(cfg_builder *g) if (nextop == LOAD_FAST) { make_super_instruction(inst, &b->b_instr[i + 1], LOAD_FAST_LOAD_FAST); } + else if (nextop == COPY && inst->i_oparg < 16 && + b->b_instr[i + 1].i_oparg == 1 && + i + 2 < b->b_iused && + b->b_instr[i + 2].i_opcode == POP_JUMP_IF_NONE) { + cfg_instr *copy = &b->b_instr[i + 1]; + if (inst->i_loc.lineno < 0 || copy->i_loc.lineno < 0 || + inst->i_loc.lineno == copy->i_loc.lineno) { + /* Keep the checked operand on the stack, including + * when tracing changes the local after this load. */ + int local = inst->i_oparg; + INSTR_SET_OP1(inst, LOAD_FAST_LOAD_FAST, + (local << 4) | local); + INSTR_SET_OP0(copy, NOP); + } + } break; case STORE_FAST: switch (nextop) { From 06d6757db610be62c3990ece29809fb4e66ac888 Mon Sep 17 00:00:00 2001 From: meanmail Date: Wed, 14 Oct 2026 22:27:29 +0400 Subject: [PATCH 3/4] Format None-aware optimization regression tests --- Lib/test/test_none_aware.py | 26 +++++++++++++++++++++----- 1 file changed, 21 insertions(+), 5 deletions(-) diff --git a/Lib/test/test_none_aware.py b/Lib/test/test_none_aware.py index 191b74ed8ee50b..b69db55f53f77d 100644 --- a/Lib/test/test_none_aware.py +++ b/Lib/test/test_none_aware.py @@ -58,18 +58,27 @@ def test_local_access_uses_fused_load(self) -> None: explicit = namespace["explicit"] self.assertIn( "LOAD_FAST_LOAD_FAST", - [instruction.opname for instruction in dis.get_instructions(optional)], + [ + instruction.opname + for instruction in dis.get_instructions(optional) + ], ) self.assertNotIn( "COPY", - [instruction.opname for instruction in dis.get_instructions(optional)], + [ + instruction.opname + for instruction in dis.get_instructions(optional) + ], ) for value in (None, SimpleNamespace(name="Ada")): self.assertEqual(optional(value), explicit(value)) def test_traced_local_rebinding_preserves_operand(self) -> None: namespace: dict[str, Any] = {"Any": Any} - exec("def access(value: Any) -> Any:\n return value?.name\n", namespace) + exec( + "def access(value: Any) -> Any:\n return value?.name\n", + namespace, + ) access = namespace["access"] check_offset = next( instruction.offset @@ -102,9 +111,16 @@ def test_local_access_outside_fused_load_range(self) -> None: ) access = namespace["access"] self.assertIn( - "COPY", [instruction.opname for instruction in dis.get_instructions(access)] + "COPY", + [ + instruction.opname + for instruction in dis.get_instructions(access) + ], ) - for value, expected in ((None, None), (SimpleNamespace(name="Ada"), "Ada")): + for value, expected in ( + (None, None), + (SimpleNamespace(name="Ada"), "Ada"), + ): self.assertEqual(access(*([None] * 16), value), expected) def test_local_access_in_expression_and_chain(self) -> None: From f9ef20f920387f494ac4ed7f728f569fb678ef13 Mon Sep 17 00:00:00 2001 From: meanmail Date: Wed, 14 Oct 2026 23:02:22 +0400 Subject: [PATCH 4/4] Compile None-aware access with stack-preserving jump opcodes --- Doc/none-aware-prototype.md | 140 +- Include/internal/pycore_magic_number.h | 3 +- Include/internal/pycore_opcode_metadata.h | 40 +- Include/internal/pycore_opcode_utils.h | 4 +- Include/internal/pycore_uop_ids.h | 2430 +++++++++++---------- Include/internal/pycore_uop_metadata.h | 61 + Include/opcode_ids.h | 112 +- Lib/_opcode_metadata.py | 112 +- Lib/opcode.py | 6 + Lib/test/test_importlib/test_util.py | 2 +- Lib/test/test_none_aware.py | 171 +- Modules/_testinternalcapi/test_cases.c.h | 102 + Modules/_testinternalcapi/test_targets.h | 36 +- Programs/test_frozenmain.h | 18 +- Python/bytecodes.c | 32 + Python/codegen.c | 3 +- Python/executor_cases.c.h | 220 ++ Python/flowgraph.c | 27 +- Python/generated_cases.c.h | 102 + Python/instrumentation.c | 14 + Python/opcode_targets.h | 36 +- Python/optimizer.c | 11 +- Python/optimizer_bytecodes.c | 14 + Python/optimizer_cases.c.h | 33 + Python/pystats.c | 2 + Python/specialize.c | 2 + 26 files changed, 2294 insertions(+), 1439 deletions(-) diff --git a/Doc/none-aware-prototype.md b/Doc/none-aware-prototype.md index 57a420f99ce0f4..fdffb7f2c48244 100644 --- a/Doc/none-aware-prototype.md +++ b/Doc/none-aware-prototype.md @@ -35,17 +35,41 @@ proposal. `?[...]`, `?()`, `??` and `??=` are not implemented. `OptionalChain(value)` marks the whole primary expression containing checked accesses. Wrapping occurs when a primary expression is completed, so parentheses and independently evaluated arguments establish distinct chains. The compiler -uses existing `COPY` and `POP_JUMP_IF_NONE` instructions, leaving `None` on the -stack and jumping past the tail when a check fails. No new opcode is needed. - -For an initialized fast local in slots 0 through 15, the CFG optimizer combines -`LOAD_FAST; COPY 1; POP_JUMP_IF_NONE` into -`LOAD_FAST_LOAD_FAST; POP_JUMP_IF_NONE`. This removes one instruction dispatch -without adding another lookup after the check. Both stack references refer to -the original operand, even if an opcode trace callback rebinds the local before -the check. The references retain their normal ownership. Uninitialized locals, -higher-numbered slots, dynamic name lookups and intermediate chain results keep -the original implementation. Fusion also respects source-line boundaries. +emits `JUMP_IF_NONE` for every checked access. This opcode checks the top stack +reference by identity and preserves it on both branch outcomes. A `None` jumps +past the whole chain; otherwise the following `LOAD_ATTR` consumes the original +operand. There is no `COPY`, repeated lookup or temporary local. The same opcode +handles local variables at any slot, globals, calls and intermediate results. +Its stack effect is zero for both branch outcomes. Jump offsets and local loads +use the ordinary `EXTENDED_ARG` encoding when necessary. + +For example, `return user?.profile?.name` compiles to: + +```text +LOAD_FAST user +JUMP_IF_NONE end +NOT_TAKEN +LOAD_ATTR profile +JUMP_IF_NONE end +NOT_TAKEN +LOAD_ATTR name +end: +RETURN_VALUE +``` + +`JUMP_IF_NOT_NONE` is the stack-preserving inverse used when the CFG normalizes a +backward conditional jump. Both opcodes have one branch-history cache entry, +instrumented variants for `sys.monitoring`, and stack-preserving tier-two guards. +The CFG reference analysis keeps the operand owned across the branch boundary; +it does not borrow a local whose lifetime has not been proven across blocks. +Opcode tracing and monitoring callbacks may rebind locals without changing the +operand already on the stack. + +The former fast-local/COPY fusion has been removed. Adding the opcodes changes +bytecode numbering, so this fork uses `.pyc` magic number 3667 instead of stock +3.15.0's 3666. Cached bytecode from the previous build is invalidated. Generated +opcode metadata, interpreter cases and the frozen-main test fixture must match +the new instruction set. Both AST nodes support validation, preprocessing, symbol analysis and unparsing. Unparsing includes parentheses around an optional chain to preserve its boundary. @@ -55,35 +79,56 @@ External IDEs, formatters and type checkers do not yet understand this syntax. ## Local optimization measurements Measured on Apple M3 Pro with a non-debug Clang `-O3` build, without PGO or LTO. -Each sample times one million function calls. Each build runs 51 rounds, with +Each sample times one million function calls; each build runs 51 rounds with shuffled cases and shuffled ordering of the optional and explicit variants. -Objects are `types.SimpleNamespace` instances. The explicit chain uses two -`is None` checks and stores `profile` in a temporary local. Values below are -median nanoseconds per call, including the function call itself. - -| Case | Original `?.` | Fused `?.` | Explicit check in fused build | -| --- | ---: | ---: | ---: | -| Attribute, `None` | 16.01 | 16.05 | 15.22 | -| Attribute, object | 34.02 | 34.11 | 34.22 | -| Chain, `None` | 16.31 | 16.29 | 17.04 | -| Chain, missing profile | 37.69 | 36.25 | 37.60 | -| Chain, full object | 52.98 | 51.67 | 53.91 | - -The original and fused builds were timed separately, so cross-build differences -also include scheduling and clock variation. Background load produced outliers; -these figures do not establish statistically significant speedups. Fusion -removes an instruction dispatch, but does not remove reference ownership costs -or the `COPY` used for intermediate results. Object access is approximately on -par with the explicit check here; the `None` case still shows a small difference. -Zero overhead across all cases is not established. - -Optimization regression tests cover bytecode fusion, the local-slot limit, -unbound locals, dynamic namespace lookup, expression stack balance and rebinding -through opcode tracing. The earlier local-reload approach was discarded because -it failed the tracing regression. After fusion, the compiler, AST, grammar, -unparser, tokenizer, symbol-table, peephole, disassembly, tracing and monitoring -test files pass. The earlier full-suite result applies to the original prototype; -the complete suite has not been repeated for this optimization. +Objects are `types.SimpleNamespace` instances. The explicit chain checks `user` +and then `profile` for `None`, saving `profile` in a temporary local. Timings +include the function call itself. The final new-opcode run was performed after +the full test suite and all builds finished. + +| Case | Original COPY-based `?.`, ns | New opcode `?.`, ns | Explicit check, ns | Median paired ratio | +| --- | ---: | ---: | ---: | ---: | +| Attribute, `None` | 15.15 | 15.52 | 15.70 | 0.989 | +| Attribute, object | 33.72 | 32.71 | 35.89 | 0.915 | +| Chain, `None` | 15.33 | 15.50 | 16.36 | 0.944 | +| Chain, missing profile | 36.28 | 34.00 | 38.63 | 0.867 | +| Chain, full object | 51.04 | 48.96 | 51.95 | 0.935 | + +The ratio is the median of the within-round optional/explicit time ratios. The +explicit column comes from the same new-opcode build. The original prototype +was timed separately; cross-build differences also include scheduling, clock +and interpreter layout changes. An earlier new-opcode run while the last GUI +test was still running gave 15.72/15.97 ns for `None` and 31.71/35.73 ns for +object access, showing the remaining variability. These local microbenchmarks +show no measured penalty against explicit checks in these five cases, but do +not prove zero overhead for all expressions, objects or workloads. In particular, +method-call optimization and whole-application performance were not measured. + +Verification on macOS arm64: + +- Full debug-build suite: `./python.exe -E -Wd -m test -j8 -u all --timeout=900 + --rerun --slowest`, exit 0, `FAILURE then SUCCESS`. All 558 test files were + processed; 478 passed, 78 were skipped and two resource-denied. The runner + counted 53,158 test cases, three initial failures and 2,607 skips. The initial + frozen-main fixture failure was fixed by regenerating it for the new opcode + numbering; two Tkinter failures passed their automatic targeted rerun. Duration + 14 minutes 16 seconds. This was not a clean first-pass result. +- A separate debug build with `--enable-experimental-jit=interpreter` passed + `test_none_aware test_capi.test_opt test_monitoring test_sys_settrace -j2 + --timeout=600`: 890 test cases, four skips, all four files passed. The feature + test confirms that executors contain the new stack-preserving guards and that + mixed `None`/object chains return correct results after warmup. +- The non-debug release build passed all 38 feature tests, with the tier-two test + skipped because that build disables tier two. Tests cover local slots 16 and + 256, extended jump offsets, both monitored branch outcomes, original-operand + lifetime under opcode tracing, unbound locals and dynamic namespace lookups. +- Ruff formatting and `ruff check --fix --unsafe-fixes --preview` passed for the + changed tests. Configured mypy checks passed for `Tools/cases_generator` (19 + source files) and `Tools/build` (12 source files). + +Native JIT machine-code generation, free-threaded builds and Linux/Windows were +not validated. The earlier FinCtrl application tests apply to the original +prototype; they were not repeated after adding the opcode. ## Build and run @@ -109,4 +154,21 @@ make -j8 ./python.exe -m test test_none_aware test_grammar test_ast test_unparse test_tokenize test_compile test_symtable ``` +After changing opcodes, regenerate interpreter sources and the frozen-main +fixture with the newly built interpreter: + +```sh +make regen-cases +make -j8 +make regen-test-frozenmain +make -j8 +./python.exe -m test test_none_aware test_embed test_importlib test_monitoring +``` + +To exercise tier-two translation without building native JIT stencils, configure +a separate checkout with `--with-pydebug --enable-experimental-jit=interpreter` +and run `test_none_aware`, `test_capi.test_opt`, `test_monitoring` and +`test_sys_settrace`. Native JIT code generation and free-threaded builds need +separate validation. + The ordinary CPython and Python Software Foundation licensing continues to apply. diff --git a/Include/internal/pycore_magic_number.h b/Include/internal/pycore_magic_number.h index 177938e3cdb5eb..5c96ca589e3007 100644 --- a/Include/internal/pycore_magic_number.h +++ b/Include/internal/pycore_magic_number.h @@ -297,6 +297,7 @@ Known values: Python 3.15a8 3664 (Fix __qualname__ for __annotate__ functions) Python 3.15a8 3665 (Add FOR_ITER_VIRTUAL and GET_ITER specializations) Python 3.15b1 3666 (Add SEND_VIRTUAL and SEND_ASYNC_GEN specializations) + Python 3.15 ?. prototype 3667 (Add stack-preserving None-check jumps) Python 3.16 will start with 3700 @@ -310,7 +311,7 @@ PC/launcher.c must also be updated. */ -#define PYC_MAGIC_NUMBER 3666 +#define PYC_MAGIC_NUMBER 3667 /* This is equivalent to converting PYC_MAGIC_NUMBER to 2 bytes (little-endian) and then appending b'\r\n'. */ #define PYC_MAGIC_NUMBER_TOKEN \ diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 7d9babf358971d..5d4bf2712a3a47 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -260,6 +260,10 @@ int _PyOpcode_num_popped(int opcode, int oparg) { return 0; case INSTRUMENTED_JUMP_FORWARD: return 0; + case INSTRUMENTED_JUMP_IF_NONE: + return 1; + case INSTRUMENTED_JUMP_IF_NOT_NONE: + return 1; case INSTRUMENTED_LINE: return 0; case INSTRUMENTED_LOAD_SUPER_ATTR: @@ -300,6 +304,10 @@ int _PyOpcode_num_popped(int opcode, int oparg) { return 0; case JUMP_IF_FALSE: return 1; + case JUMP_IF_NONE: + return 1; + case JUMP_IF_NOT_NONE: + return 1; case JUMP_IF_TRUE: return 1; case JUMP_NO_INTERRUPT: @@ -761,6 +769,10 @@ int _PyOpcode_num_pushed(int opcode, int oparg) { return 0; case INSTRUMENTED_JUMP_FORWARD: return 0; + case INSTRUMENTED_JUMP_IF_NONE: + return 1; + case INSTRUMENTED_JUMP_IF_NOT_NONE: + return 1; case INSTRUMENTED_LINE: return 0; case INSTRUMENTED_LOAD_SUPER_ATTR: @@ -801,6 +813,10 @@ int _PyOpcode_num_pushed(int opcode, int oparg) { return 0; case JUMP_IF_FALSE: return 1; + case JUMP_IF_NONE: + return 1; + case JUMP_IF_NOT_NONE: + return 1; case JUMP_IF_TRUE: return 1; case JUMP_NO_INTERRUPT: @@ -1223,6 +1239,8 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[267] = { [INSTRUMENTED_INSTRUCTION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_JUMP_FORWARD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [INSTRUMENTED_JUMP_IF_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, + [INSTRUMENTED_JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, [INSTRUMENTED_LINE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_SYNC_SP_FLAG }, [INSTRUMENTED_LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_NOT_TAKEN] = { true, INSTR_FMT_IX, 0 }, @@ -1241,6 +1259,8 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[267] = { [JUMP_BACKWARD_NO_INTERRUPT] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_JUMP_FLAG }, [JUMP_BACKWARD_NO_JIT] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [JUMP_FORWARD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_JUMP_FLAG }, + [JUMP_IF_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG }, + [JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG }, [LIST_APPEND] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [LIST_EXTEND] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [LOAD_ATTR] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -1467,6 +1487,8 @@ _PyOpcode_macro_expansion[256] = { [JUMP_BACKWARD] = { .nuops = 2, .uops = { { _CHECK_PERIODIC, OPARG_SIMPLE, 1 }, { _JUMP_BACKWARD_NO_INTERRUPT, OPARG_REPLACED, 1 } } }, [JUMP_BACKWARD_NO_INTERRUPT] = { .nuops = 1, .uops = { { _JUMP_BACKWARD_NO_INTERRUPT, OPARG_REPLACED, 0 } } }, [JUMP_BACKWARD_NO_JIT] = { .nuops = 2, .uops = { { _CHECK_PERIODIC, OPARG_SIMPLE, 1 }, { _JUMP_BACKWARD_NO_INTERRUPT, OPARG_REPLACED, 1 } } }, + [JUMP_IF_NONE] = { .nuops = 2, .uops = { { _IS_NONE_KEEP, OPARG_SIMPLE, 1 }, { _POP_JUMP_IF_TRUE, OPARG_REPLACED, 1 } } }, + [JUMP_IF_NOT_NONE] = { .nuops = 2, .uops = { { _IS_NONE_KEEP, OPARG_SIMPLE, 1 }, { _POP_JUMP_IF_FALSE, OPARG_REPLACED, 1 } } }, [LIST_APPEND] = { .nuops = 1, .uops = { { _LIST_APPEND, OPARG_SIMPLE, 0 } } }, [LIST_EXTEND] = { .nuops = 2, .uops = { { _LIST_EXTEND, OPARG_SIMPLE, 0 }, { _POP_TOP, OPARG_SIMPLE, 0 } } }, [LOAD_ATTR] = { .nuops = 1, .uops = { { _LOAD_ATTR, OPARG_SIMPLE, 8 } } }, @@ -1682,6 +1704,8 @@ const char *_PyOpcode_OpName[267] = { [INSTRUMENTED_INSTRUCTION] = "INSTRUMENTED_INSTRUCTION", [INSTRUMENTED_JUMP_BACKWARD] = "INSTRUMENTED_JUMP_BACKWARD", [INSTRUMENTED_JUMP_FORWARD] = "INSTRUMENTED_JUMP_FORWARD", + [INSTRUMENTED_JUMP_IF_NONE] = "INSTRUMENTED_JUMP_IF_NONE", + [INSTRUMENTED_JUMP_IF_NOT_NONE] = "INSTRUMENTED_JUMP_IF_NOT_NONE", [INSTRUMENTED_LINE] = "INSTRUMENTED_LINE", [INSTRUMENTED_LOAD_SUPER_ATTR] = "INSTRUMENTED_LOAD_SUPER_ATTR", [INSTRUMENTED_NOT_TAKEN] = "INSTRUMENTED_NOT_TAKEN", @@ -1702,6 +1726,8 @@ const char *_PyOpcode_OpName[267] = { [JUMP_BACKWARD_NO_JIT] = "JUMP_BACKWARD_NO_JIT", [JUMP_FORWARD] = "JUMP_FORWARD", [JUMP_IF_FALSE] = "JUMP_IF_FALSE", + [JUMP_IF_NONE] = "JUMP_IF_NONE", + [JUMP_IF_NOT_NONE] = "JUMP_IF_NOT_NONE", [JUMP_IF_TRUE] = "JUMP_IF_TRUE", [JUMP_NO_INTERRUPT] = "JUMP_NO_INTERRUPT", [LIST_APPEND] = "LIST_APPEND", @@ -1838,6 +1864,8 @@ const uint8_t _PyOpcode_Caches[256] = { [POP_JUMP_IF_FALSE] = 1, [POP_JUMP_IF_NONE] = 1, [POP_JUMP_IF_NOT_NONE] = 1, + [JUMP_IF_NONE] = 1, + [JUMP_IF_NOT_NONE] = 1, [GET_ITER] = 1, [CALL] = 3, [CALL_KW] = 3, @@ -1849,8 +1877,6 @@ const uint8_t _PyOpcode_Caches[256] = { PyAPI_DATA(const uint8_t) _PyOpcode_Deopt[256]; #ifdef NEED_OPCODE_METADATA const uint8_t _PyOpcode_Deopt[256] = { - [120] = 120, - [121] = 121, [122] = 122, [123] = 123, [124] = 124, @@ -1869,8 +1895,6 @@ const uint8_t _PyOpcode_Deopt[256] = { [228] = 228, [229] = 229, [230] = 230, - [231] = 231, - [232] = 232, [BINARY_OP] = BINARY_OP, [BINARY_OP_ADD_FLOAT] = BINARY_OP, [BINARY_OP_ADD_INT] = BINARY_OP, @@ -1982,6 +2006,8 @@ const uint8_t _PyOpcode_Deopt[256] = { [INSTRUMENTED_INSTRUCTION] = INSTRUMENTED_INSTRUCTION, [INSTRUMENTED_JUMP_BACKWARD] = INSTRUMENTED_JUMP_BACKWARD, [INSTRUMENTED_JUMP_FORWARD] = INSTRUMENTED_JUMP_FORWARD, + [INSTRUMENTED_JUMP_IF_NONE] = INSTRUMENTED_JUMP_IF_NONE, + [INSTRUMENTED_JUMP_IF_NOT_NONE] = INSTRUMENTED_JUMP_IF_NOT_NONE, [INSTRUMENTED_LINE] = INSTRUMENTED_LINE, [INSTRUMENTED_LOAD_SUPER_ATTR] = INSTRUMENTED_LOAD_SUPER_ATTR, [INSTRUMENTED_NOT_TAKEN] = INSTRUMENTED_NOT_TAKEN, @@ -2000,6 +2026,8 @@ const uint8_t _PyOpcode_Deopt[256] = { [JUMP_BACKWARD_NO_INTERRUPT] = JUMP_BACKWARD_NO_INTERRUPT, [JUMP_BACKWARD_NO_JIT] = JUMP_BACKWARD, [JUMP_FORWARD] = JUMP_FORWARD, + [JUMP_IF_NONE] = JUMP_IF_NONE, + [JUMP_IF_NOT_NONE] = JUMP_IF_NOT_NONE, [LIST_APPEND] = LIST_APPEND, [LIST_EXTEND] = LIST_EXTEND, [LOAD_ATTR] = LOAD_ATTR, @@ -2110,8 +2138,6 @@ const uint8_t _PyOpcode_Deopt[256] = { #endif // NEED_OPCODE_METADATA #define EXTRA_CASES \ - case 120: \ - case 121: \ case 122: \ case 123: \ case 124: \ @@ -2130,8 +2156,6 @@ const uint8_t _PyOpcode_Deopt[256] = { case 228: \ case 229: \ case 230: \ - case 231: \ - case 232: \ ; struct pseudo_targets { uint8_t as_sequence; diff --git a/Include/internal/pycore_opcode_utils.h b/Include/internal/pycore_opcode_utils.h index 3e2c4ae411c925..fcf6285752ae70 100644 --- a/Include/internal/pycore_opcode_utils.h +++ b/Include/internal/pycore_opcode_utils.h @@ -47,7 +47,9 @@ extern "C" { ((opcode) == POP_JUMP_IF_FALSE || \ (opcode) == POP_JUMP_IF_TRUE || \ (opcode) == POP_JUMP_IF_NONE || \ - (opcode) == POP_JUMP_IF_NOT_NONE) + (opcode) == POP_JUMP_IF_NOT_NONE || \ + (opcode) == JUMP_IF_NONE || \ + (opcode) == JUMP_IF_NOT_NONE) #define IS_SCOPE_EXIT_OPCODE(opcode) \ ((opcode) == RETURN_VALUE || \ diff --git a/Include/internal/pycore_uop_ids.h b/Include/internal/pycore_uop_ids.h index 7c44c0a430b731..6a19b2647dd177 100644 --- a/Include/internal/pycore_uop_ids.h +++ b/Include/internal/pycore_uop_ids.h @@ -194,1257 +194,1281 @@ extern "C" { #define _GUARD_IP_YIELD_VALUE 455 #define _GUARD_IP__PUSH_FRAME 456 #define _GUARD_IS_FALSE_POP 457 -#define _GUARD_IS_NONE_POP 458 -#define _GUARD_IS_NOT_NONE_POP 459 -#define _GUARD_IS_TRUE_POP 460 -#define _GUARD_ITERATOR 461 -#define _GUARD_ITER_VIRTUAL 462 -#define _GUARD_KEYS_VERSION 463 -#define _GUARD_LOAD_SUPER_ATTR_METHOD 464 -#define _GUARD_NOS_COMPACT_ASCII 465 -#define _GUARD_NOS_DICT_STORE_SUBSCRIPT 466 -#define _GUARD_NOS_DICT_SUBSCRIPT 467 -#define _GUARD_NOS_FLOAT 468 -#define _GUARD_NOS_INT 469 -#define _GUARD_NOS_ITER_VIRTUAL 470 -#define _GUARD_NOS_LIST 471 -#define _GUARD_NOS_NOT_NULL 472 -#define _GUARD_NOS_NULL 473 -#define _GUARD_NOS_OVERFLOWED 474 -#define _GUARD_NOS_TUPLE 475 -#define _GUARD_NOS_TYPE_VERSION 476 -#define _GUARD_NOS_UNICODE 477 -#define _GUARD_NOT_EXHAUSTED_LIST 478 -#define _GUARD_NOT_EXHAUSTED_RANGE 479 -#define _GUARD_NOT_EXHAUSTED_TUPLE 480 -#define _GUARD_THIRD_NULL 481 -#define _GUARD_TOS_ANY_DICT 482 -#define _GUARD_TOS_ANY_SET 483 -#define _GUARD_TOS_DICT 484 -#define _GUARD_TOS_FLOAT 485 -#define _GUARD_TOS_FROZENDICT 486 -#define _GUARD_TOS_FROZENSET 487 -#define _GUARD_TOS_INT 488 -#define _GUARD_TOS_IS_NONE 489 -#define _GUARD_TOS_LIST 490 -#define _GUARD_TOS_NOT_NULL 491 -#define _GUARD_TOS_OVERFLOWED 492 -#define _GUARD_TOS_SET 493 -#define _GUARD_TOS_SLICE 494 -#define _GUARD_TOS_TUPLE 495 -#define _GUARD_TOS_UNICODE 496 -#define _GUARD_TYPE 497 -#define _GUARD_TYPE_ITER 498 -#define _GUARD_TYPE_VERSION 499 -#define _GUARD_TYPE_VERSION_LOCKED 500 -#define _HANDLE_PENDING_AND_DEOPT 501 +#define _GUARD_IS_NONE_KEEP 458 +#define _GUARD_IS_NONE_POP 459 +#define _GUARD_IS_NOT_NONE_KEEP 460 +#define _GUARD_IS_NOT_NONE_POP 461 +#define _GUARD_IS_TRUE_POP 462 +#define _GUARD_ITERATOR 463 +#define _GUARD_ITER_VIRTUAL 464 +#define _GUARD_KEYS_VERSION 465 +#define _GUARD_LOAD_SUPER_ATTR_METHOD 466 +#define _GUARD_NOS_COMPACT_ASCII 467 +#define _GUARD_NOS_DICT_STORE_SUBSCRIPT 468 +#define _GUARD_NOS_DICT_SUBSCRIPT 469 +#define _GUARD_NOS_FLOAT 470 +#define _GUARD_NOS_INT 471 +#define _GUARD_NOS_ITER_VIRTUAL 472 +#define _GUARD_NOS_LIST 473 +#define _GUARD_NOS_NOT_NULL 474 +#define _GUARD_NOS_NULL 475 +#define _GUARD_NOS_OVERFLOWED 476 +#define _GUARD_NOS_TUPLE 477 +#define _GUARD_NOS_TYPE_VERSION 478 +#define _GUARD_NOS_UNICODE 479 +#define _GUARD_NOT_EXHAUSTED_LIST 480 +#define _GUARD_NOT_EXHAUSTED_RANGE 481 +#define _GUARD_NOT_EXHAUSTED_TUPLE 482 +#define _GUARD_THIRD_NULL 483 +#define _GUARD_TOS_ANY_DICT 484 +#define _GUARD_TOS_ANY_SET 485 +#define _GUARD_TOS_DICT 486 +#define _GUARD_TOS_FLOAT 487 +#define _GUARD_TOS_FROZENDICT 488 +#define _GUARD_TOS_FROZENSET 489 +#define _GUARD_TOS_INT 490 +#define _GUARD_TOS_IS_NONE 491 +#define _GUARD_TOS_LIST 492 +#define _GUARD_TOS_NOT_NULL 493 +#define _GUARD_TOS_OVERFLOWED 494 +#define _GUARD_TOS_SET 495 +#define _GUARD_TOS_SLICE 496 +#define _GUARD_TOS_TUPLE 497 +#define _GUARD_TOS_UNICODE 498 +#define _GUARD_TYPE 499 +#define _GUARD_TYPE_ITER 500 +#define _GUARD_TYPE_VERSION 501 +#define _GUARD_TYPE_VERSION_LOCKED 502 +#define _HANDLE_PENDING_AND_DEOPT 503 #define _IMPORT_FROM IMPORT_FROM #define _IMPORT_NAME IMPORT_NAME -#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS 502 -#define _INIT_CALL_PY_EXACT_ARGS 503 -#define _INIT_CALL_PY_EXACT_ARGS_0 504 -#define _INIT_CALL_PY_EXACT_ARGS_1 505 -#define _INIT_CALL_PY_EXACT_ARGS_2 506 -#define _INIT_CALL_PY_EXACT_ARGS_3 507 -#define _INIT_CALL_PY_EXACT_ARGS_4 508 -#define _INSERT_NULL 509 +#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS 504 +#define _INIT_CALL_PY_EXACT_ARGS 505 +#define _INIT_CALL_PY_EXACT_ARGS_0 506 +#define _INIT_CALL_PY_EXACT_ARGS_1 507 +#define _INIT_CALL_PY_EXACT_ARGS_2 508 +#define _INIT_CALL_PY_EXACT_ARGS_3 509 +#define _INIT_CALL_PY_EXACT_ARGS_4 510 +#define _INSERT_NULL 511 #define _INSTRUMENTED_FOR_ITER INSTRUMENTED_FOR_ITER #define _INSTRUMENTED_INSTRUCTION INSTRUMENTED_INSTRUCTION #define _INSTRUMENTED_JUMP_FORWARD INSTRUMENTED_JUMP_FORWARD +#define _INSTRUMENTED_JUMP_IF_NONE INSTRUMENTED_JUMP_IF_NONE +#define _INSTRUMENTED_JUMP_IF_NOT_NONE INSTRUMENTED_JUMP_IF_NOT_NONE #define _INSTRUMENTED_LINE INSTRUMENTED_LINE #define _INSTRUMENTED_NOT_TAKEN INSTRUMENTED_NOT_TAKEN #define _INSTRUMENTED_POP_JUMP_IF_FALSE INSTRUMENTED_POP_JUMP_IF_FALSE #define _INSTRUMENTED_POP_JUMP_IF_NONE INSTRUMENTED_POP_JUMP_IF_NONE #define _INSTRUMENTED_POP_JUMP_IF_NOT_NONE INSTRUMENTED_POP_JUMP_IF_NOT_NONE #define _INSTRUMENTED_POP_JUMP_IF_TRUE INSTRUMENTED_POP_JUMP_IF_TRUE -#define _IS_NONE 510 -#define _IS_OP 511 -#define _ITER_CHECK_LIST 512 -#define _ITER_CHECK_RANGE 513 -#define _ITER_CHECK_TUPLE 514 -#define _ITER_JUMP_LIST 515 -#define _ITER_JUMP_RANGE 516 -#define _ITER_JUMP_TUPLE 517 -#define _ITER_NEXT_INLINE 518 -#define _ITER_NEXT_LIST 519 -#define _ITER_NEXT_LIST_TIER_TWO 520 -#define _ITER_NEXT_RANGE 521 -#define _ITER_NEXT_TUPLE 522 +#define _IS_NONE 512 +#define _IS_NONE_KEEP 513 +#define _IS_OP 514 +#define _ITER_CHECK_LIST 515 +#define _ITER_CHECK_RANGE 516 +#define _ITER_CHECK_TUPLE 517 +#define _ITER_JUMP_LIST 518 +#define _ITER_JUMP_RANGE 519 +#define _ITER_JUMP_TUPLE 520 +#define _ITER_NEXT_INLINE 521 +#define _ITER_NEXT_LIST 522 +#define _ITER_NEXT_LIST_TIER_TWO 523 +#define _ITER_NEXT_RANGE 524 +#define _ITER_NEXT_TUPLE 525 #define _JUMP_BACKWARD_NO_INTERRUPT JUMP_BACKWARD_NO_INTERRUPT -#define _JUMP_TO_TOP 523 +#define _JUMP_TO_TOP 526 #define _LIST_APPEND LIST_APPEND -#define _LIST_EXTEND 524 -#define _LOAD_ATTR 525 -#define _LOAD_ATTR_CLASS 526 -#define _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN_FRAME 527 -#define _LOAD_ATTR_INSTANCE_VALUE 528 -#define _LOAD_ATTR_METHOD_LAZY_DICT 529 -#define _LOAD_ATTR_METHOD_NO_DICT 530 -#define _LOAD_ATTR_METHOD_WITH_VALUES 531 -#define _LOAD_ATTR_MODULE 532 -#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT 533 -#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES 534 -#define _LOAD_ATTR_PROPERTY_FRAME 535 -#define _LOAD_ATTR_SLOT 536 -#define _LOAD_ATTR_WITH_HINT 537 +#define _LIST_EXTEND 527 +#define _LOAD_ATTR 528 +#define _LOAD_ATTR_CLASS 529 +#define _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN_FRAME 530 +#define _LOAD_ATTR_INSTANCE_VALUE 531 +#define _LOAD_ATTR_METHOD_LAZY_DICT 532 +#define _LOAD_ATTR_METHOD_NO_DICT 533 +#define _LOAD_ATTR_METHOD_WITH_VALUES 534 +#define _LOAD_ATTR_MODULE 535 +#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT 536 +#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES 537 +#define _LOAD_ATTR_PROPERTY_FRAME 538 +#define _LOAD_ATTR_SLOT 539 +#define _LOAD_ATTR_WITH_HINT 540 #define _LOAD_BUILD_CLASS LOAD_BUILD_CLASS -#define _LOAD_BYTECODE 538 +#define _LOAD_BYTECODE 541 #define _LOAD_COMMON_CONSTANT LOAD_COMMON_CONSTANT #define _LOAD_CONST LOAD_CONST -#define _LOAD_CONST_INLINE 539 -#define _LOAD_CONST_INLINE_BORROW 540 +#define _LOAD_CONST_INLINE 542 +#define _LOAD_CONST_INLINE_BORROW 543 #define _LOAD_DEREF LOAD_DEREF -#define _LOAD_FAST 541 -#define _LOAD_FAST_0 542 -#define _LOAD_FAST_1 543 -#define _LOAD_FAST_2 544 -#define _LOAD_FAST_3 545 -#define _LOAD_FAST_4 546 -#define _LOAD_FAST_5 547 -#define _LOAD_FAST_6 548 -#define _LOAD_FAST_7 549 +#define _LOAD_FAST 544 +#define _LOAD_FAST_0 545 +#define _LOAD_FAST_1 546 +#define _LOAD_FAST_2 547 +#define _LOAD_FAST_3 548 +#define _LOAD_FAST_4 549 +#define _LOAD_FAST_5 550 +#define _LOAD_FAST_6 551 +#define _LOAD_FAST_7 552 #define _LOAD_FAST_AND_CLEAR LOAD_FAST_AND_CLEAR -#define _LOAD_FAST_BORROW 550 -#define _LOAD_FAST_BORROW_0 551 -#define _LOAD_FAST_BORROW_1 552 -#define _LOAD_FAST_BORROW_2 553 -#define _LOAD_FAST_BORROW_3 554 -#define _LOAD_FAST_BORROW_4 555 -#define _LOAD_FAST_BORROW_5 556 -#define _LOAD_FAST_BORROW_6 557 -#define _LOAD_FAST_BORROW_7 558 +#define _LOAD_FAST_BORROW 553 +#define _LOAD_FAST_BORROW_0 554 +#define _LOAD_FAST_BORROW_1 555 +#define _LOAD_FAST_BORROW_2 556 +#define _LOAD_FAST_BORROW_3 557 +#define _LOAD_FAST_BORROW_4 558 +#define _LOAD_FAST_BORROW_5 559 +#define _LOAD_FAST_BORROW_6 560 +#define _LOAD_FAST_BORROW_7 561 #define _LOAD_FAST_CHECK LOAD_FAST_CHECK #define _LOAD_FROM_DICT_OR_DEREF LOAD_FROM_DICT_OR_DEREF #define _LOAD_FROM_DICT_OR_GLOBALS LOAD_FROM_DICT_OR_GLOBALS -#define _LOAD_GLOBAL 559 -#define _LOAD_GLOBAL_BUILTINS 560 -#define _LOAD_GLOBAL_MODULE 561 +#define _LOAD_GLOBAL 562 +#define _LOAD_GLOBAL_BUILTINS 563 +#define _LOAD_GLOBAL_MODULE 564 #define _LOAD_LOCALS LOAD_LOCALS #define _LOAD_NAME LOAD_NAME -#define _LOAD_SMALL_INT 562 -#define _LOAD_SMALL_INT_0 563 -#define _LOAD_SMALL_INT_1 564 -#define _LOAD_SMALL_INT_2 565 -#define _LOAD_SMALL_INT_3 566 -#define _LOAD_SPECIAL 567 +#define _LOAD_SMALL_INT 565 +#define _LOAD_SMALL_INT_0 566 +#define _LOAD_SMALL_INT_1 567 +#define _LOAD_SMALL_INT_2 568 +#define _LOAD_SMALL_INT_3 569 +#define _LOAD_SPECIAL 570 #define _LOAD_SUPER_ATTR_ATTR LOAD_SUPER_ATTR_ATTR -#define _LOAD_SUPER_ATTR_METHOD 568 -#define _LOCK_OBJECT 569 -#define _MAKE_CALLARGS_A_TUPLE 570 +#define _LOAD_SUPER_ATTR_METHOD 571 +#define _LOCK_OBJECT 572 +#define _MAKE_CALLARGS_A_TUPLE 573 #define _MAKE_CELL MAKE_CELL -#define _MAKE_FUNCTION 571 -#define _MAKE_HEAP_SAFE 572 -#define _MAKE_WARM 573 +#define _MAKE_FUNCTION 574 +#define _MAKE_HEAP_SAFE 575 +#define _MAKE_WARM 576 #define _MAP_ADD MAP_ADD -#define _MATCH_CLASS 574 +#define _MATCH_CLASS 577 #define _MATCH_KEYS MATCH_KEYS #define _MATCH_MAPPING MATCH_MAPPING #define _MATCH_SEQUENCE MATCH_SEQUENCE -#define _MAYBE_EXPAND_METHOD 575 -#define _MAYBE_EXPAND_METHOD_KW 576 -#define _MONITOR_CALL 577 -#define _MONITOR_CALL_KW 578 -#define _MONITOR_JUMP_BACKWARD 579 -#define _MONITOR_RESUME 580 +#define _MAYBE_EXPAND_METHOD 578 +#define _MAYBE_EXPAND_METHOD_KW 579 +#define _MONITOR_CALL 580 +#define _MONITOR_CALL_KW 581 +#define _MONITOR_JUMP_BACKWARD 582 +#define _MONITOR_RESUME 583 #define _NOP NOP #define _POP_EXCEPT POP_EXCEPT #define _POP_ITER POP_ITER -#define _POP_JUMP_IF_FALSE 581 -#define _POP_JUMP_IF_TRUE 582 +#define _POP_JUMP_IF_FALSE 584 +#define _POP_JUMP_IF_TRUE 585 #define _POP_TOP POP_TOP -#define _POP_TOP_FLOAT 583 -#define _POP_TOP_INT 584 -#define _POP_TOP_NOP 585 -#define _POP_TOP_OPARG 586 -#define _POP_TOP_UNICODE 587 +#define _POP_TOP_FLOAT 586 +#define _POP_TOP_INT 587 +#define _POP_TOP_NOP 588 +#define _POP_TOP_OPARG 589 +#define _POP_TOP_UNICODE 590 #define _PUSH_EXC_INFO PUSH_EXC_INFO -#define _PUSH_FRAME 588 +#define _PUSH_FRAME 591 #define _PUSH_NULL PUSH_NULL -#define _PUSH_NULL_CONDITIONAL 589 -#define _PUSH_TAGGED_ZERO 590 -#define _PY_FRAME_EX 591 -#define _PY_FRAME_GENERAL 592 -#define _PY_FRAME_KW 593 -#define _RECORD_3OS_GEN_FUNC 594 -#define _RECORD_4OS 595 -#define _RECORD_BOUND_METHOD 596 -#define _RECORD_CALLABLE 597 -#define _RECORD_CALLABLE_KW 598 -#define _RECORD_CODE 599 -#define _RECORD_NOS 600 -#define _RECORD_NOS_GEN_FUNC 601 -#define _RECORD_NOS_TYPE 602 -#define _RECORD_TOS 603 -#define _RECORD_TOS_TYPE 604 -#define _REPLACE_WITH_TRUE 605 -#define _RESUME_CHECK 606 +#define _PUSH_NULL_CONDITIONAL 592 +#define _PUSH_TAGGED_ZERO 593 +#define _PY_FRAME_EX 594 +#define _PY_FRAME_GENERAL 595 +#define _PY_FRAME_KW 596 +#define _RECORD_3OS_GEN_FUNC 597 +#define _RECORD_4OS 598 +#define _RECORD_BOUND_METHOD 599 +#define _RECORD_CALLABLE 600 +#define _RECORD_CALLABLE_KW 601 +#define _RECORD_CODE 602 +#define _RECORD_NOS 603 +#define _RECORD_NOS_GEN_FUNC 604 +#define _RECORD_NOS_TYPE 605 +#define _RECORD_TOS 606 +#define _RECORD_TOS_TYPE 607 +#define _REPLACE_WITH_TRUE 608 +#define _RESUME_CHECK 609 #define _RETURN_GENERATOR RETURN_GENERATOR -#define _RETURN_VALUE 607 -#define _RROT_3 608 -#define _SAVE_RETURN_OFFSET 609 -#define _SEND_ASYNC_GEN 610 -#define _SEND_ASYNC_GEN_TIER_TWO 611 -#define _SEND_GEN_FRAME 612 -#define _SEND_VIRTUAL 613 -#define _SEND_VIRTUAL_TIER_TWO 614 +#define _RETURN_VALUE 610 +#define _RROT_3 611 +#define _SAVE_RETURN_OFFSET 612 +#define _SEND_ASYNC_GEN 613 +#define _SEND_ASYNC_GEN_TIER_TWO 614 +#define _SEND_GEN_FRAME 615 +#define _SEND_VIRTUAL 616 +#define _SEND_VIRTUAL_TIER_TWO 617 #define _SETUP_ANNOTATIONS SETUP_ANNOTATIONS #define _SET_ADD SET_ADD #define _SET_FUNCTION_ATTRIBUTE SET_FUNCTION_ATTRIBUTE -#define _SET_UPDATE 615 -#define _SPILL_OR_RELOAD 616 -#define _START_EXECUTOR 617 -#define _STORE_ATTR 618 -#define _STORE_ATTR_INSTANCE_VALUE 619 -#define _STORE_ATTR_SLOT 620 -#define _STORE_ATTR_WITH_HINT 621 +#define _SET_UPDATE 618 +#define _SPILL_OR_RELOAD 619 +#define _START_EXECUTOR 620 +#define _STORE_ATTR 621 +#define _STORE_ATTR_INSTANCE_VALUE 622 +#define _STORE_ATTR_SLOT 623 +#define _STORE_ATTR_WITH_HINT 624 #define _STORE_DEREF STORE_DEREF #define _STORE_GLOBAL STORE_GLOBAL #define _STORE_NAME STORE_NAME -#define _STORE_SLICE 622 -#define _STORE_SUBSCR 623 -#define _STORE_SUBSCR_DICT 624 -#define _STORE_SUBSCR_DICT_KNOWN_HASH 625 -#define _STORE_SUBSCR_LIST_INT 626 -#define _SWAP 627 -#define _SWAP_2 628 -#define _SWAP_3 629 -#define _SWAP_FAST 630 -#define _SWAP_FAST_0 631 -#define _SWAP_FAST_1 632 -#define _SWAP_FAST_2 633 -#define _SWAP_FAST_3 634 -#define _SWAP_FAST_4 635 -#define _SWAP_FAST_5 636 -#define _SWAP_FAST_6 637 -#define _SWAP_FAST_7 638 -#define _TIER2_RESUME_CHECK 639 -#define _TO_BOOL 640 +#define _STORE_SLICE 625 +#define _STORE_SUBSCR 626 +#define _STORE_SUBSCR_DICT 627 +#define _STORE_SUBSCR_DICT_KNOWN_HASH 628 +#define _STORE_SUBSCR_LIST_INT 629 +#define _SWAP 630 +#define _SWAP_2 631 +#define _SWAP_3 632 +#define _SWAP_FAST 633 +#define _SWAP_FAST_0 634 +#define _SWAP_FAST_1 635 +#define _SWAP_FAST_2 636 +#define _SWAP_FAST_3 637 +#define _SWAP_FAST_4 638 +#define _SWAP_FAST_5 639 +#define _SWAP_FAST_6 640 +#define _SWAP_FAST_7 641 +#define _TIER2_RESUME_CHECK 642 +#define _TO_BOOL 643 #define _TO_BOOL_BOOL TO_BOOL_BOOL -#define _TO_BOOL_INT 641 -#define _TO_BOOL_LIST 642 +#define _TO_BOOL_INT 644 +#define _TO_BOOL_LIST 645 #define _TO_BOOL_NONE TO_BOOL_NONE -#define _TO_BOOL_STR 643 +#define _TO_BOOL_STR 646 #define _TRACE_RECORD TRACE_RECORD -#define _UNARY_INVERT 644 -#define _UNARY_NEGATIVE 645 -#define _UNARY_NEGATIVE_FLOAT_INPLACE 646 +#define _UNARY_INVERT 647 +#define _UNARY_NEGATIVE 648 +#define _UNARY_NEGATIVE_FLOAT_INPLACE 649 #define _UNARY_NOT UNARY_NOT #define _UNPACK_EX UNPACK_EX -#define _UNPACK_SEQUENCE 647 -#define _UNPACK_SEQUENCE_LIST 648 -#define _UNPACK_SEQUENCE_TUPLE 649 -#define _UNPACK_SEQUENCE_TWO_TUPLE 650 -#define _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE 651 -#define _UNPACK_SEQUENCE_UNIQUE_TUPLE 652 -#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE 653 +#define _UNPACK_SEQUENCE 650 +#define _UNPACK_SEQUENCE_LIST 651 +#define _UNPACK_SEQUENCE_TUPLE 652 +#define _UNPACK_SEQUENCE_TWO_TUPLE 653 +#define _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE 654 +#define _UNPACK_SEQUENCE_UNIQUE_TUPLE 655 +#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE 656 #define _WITH_EXCEPT_START WITH_EXCEPT_START -#define _YIELD_VALUE 654 -#define MAX_UOP_ID 654 -#define _ALLOCATE_OBJECT_r00 655 -#define _BINARY_OP_r23 656 -#define _BINARY_OP_ADD_FLOAT_r03 657 -#define _BINARY_OP_ADD_FLOAT_r13 658 -#define _BINARY_OP_ADD_FLOAT_r23 659 -#define _BINARY_OP_ADD_FLOAT_INPLACE_r03 660 -#define _BINARY_OP_ADD_FLOAT_INPLACE_r13 661 -#define _BINARY_OP_ADD_FLOAT_INPLACE_r23 662 -#define _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT_r03 663 -#define _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT_r13 664 -#define _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT_r23 665 -#define _BINARY_OP_ADD_INT_r03 666 -#define _BINARY_OP_ADD_INT_r13 667 -#define _BINARY_OP_ADD_INT_r23 668 -#define _BINARY_OP_ADD_INT_INPLACE_r03 669 -#define _BINARY_OP_ADD_INT_INPLACE_r13 670 -#define _BINARY_OP_ADD_INT_INPLACE_r23 671 -#define _BINARY_OP_ADD_INT_INPLACE_RIGHT_r03 672 -#define _BINARY_OP_ADD_INT_INPLACE_RIGHT_r13 673 -#define _BINARY_OP_ADD_INT_INPLACE_RIGHT_r23 674 -#define _BINARY_OP_ADD_UNICODE_r03 675 -#define _BINARY_OP_ADD_UNICODE_r13 676 -#define _BINARY_OP_ADD_UNICODE_r23 677 -#define _BINARY_OP_EXTEND_r23 678 -#define _BINARY_OP_INPLACE_ADD_UNICODE_r21 679 -#define _BINARY_OP_MULTIPLY_FLOAT_r03 680 -#define _BINARY_OP_MULTIPLY_FLOAT_r13 681 -#define _BINARY_OP_MULTIPLY_FLOAT_r23 682 -#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_r03 683 -#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_r13 684 -#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_r23 685 -#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT_r03 686 -#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT_r13 687 -#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT_r23 688 -#define _BINARY_OP_MULTIPLY_INT_r03 689 -#define _BINARY_OP_MULTIPLY_INT_r13 690 -#define _BINARY_OP_MULTIPLY_INT_r23 691 -#define _BINARY_OP_MULTIPLY_INT_INPLACE_r03 692 -#define _BINARY_OP_MULTIPLY_INT_INPLACE_r13 693 -#define _BINARY_OP_MULTIPLY_INT_INPLACE_r23 694 -#define _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT_r03 695 -#define _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT_r13 696 -#define _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT_r23 697 -#define _BINARY_OP_SUBSCR_CHECK_FUNC_r23 698 -#define _BINARY_OP_SUBSCR_DICT_r23 699 -#define _BINARY_OP_SUBSCR_DICT_KNOWN_HASH_r23 700 -#define _BINARY_OP_SUBSCR_INIT_CALL_r01 701 -#define _BINARY_OP_SUBSCR_INIT_CALL_r11 702 -#define _BINARY_OP_SUBSCR_INIT_CALL_r21 703 -#define _BINARY_OP_SUBSCR_INIT_CALL_r31 704 -#define _BINARY_OP_SUBSCR_LIST_INT_r23 705 -#define _BINARY_OP_SUBSCR_LIST_SLICE_r23 706 -#define _BINARY_OP_SUBSCR_STR_INT_r23 707 -#define _BINARY_OP_SUBSCR_TUPLE_INT_r03 708 -#define _BINARY_OP_SUBSCR_TUPLE_INT_r13 709 -#define _BINARY_OP_SUBSCR_TUPLE_INT_r23 710 -#define _BINARY_OP_SUBSCR_USTR_INT_r23 711 -#define _BINARY_OP_SUBTRACT_FLOAT_r03 712 -#define _BINARY_OP_SUBTRACT_FLOAT_r13 713 -#define _BINARY_OP_SUBTRACT_FLOAT_r23 714 -#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_r03 715 -#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_r13 716 -#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_r23 717 -#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT_r03 718 -#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT_r13 719 -#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT_r23 720 -#define _BINARY_OP_SUBTRACT_INT_r03 721 -#define _BINARY_OP_SUBTRACT_INT_r13 722 -#define _BINARY_OP_SUBTRACT_INT_r23 723 -#define _BINARY_OP_SUBTRACT_INT_INPLACE_r03 724 -#define _BINARY_OP_SUBTRACT_INT_INPLACE_r13 725 -#define _BINARY_OP_SUBTRACT_INT_INPLACE_r23 726 -#define _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT_r03 727 -#define _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT_r13 728 -#define _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT_r23 729 -#define _BINARY_OP_TRUEDIV_FLOAT_r23 730 -#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_r03 731 -#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_r13 732 -#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_r23 733 -#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r03 734 -#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r13 735 -#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r23 736 -#define _BINARY_SLICE_r31 737 -#define _BUILD_INTERPOLATION_r01 738 -#define _BUILD_LIST_r01 739 -#define _BUILD_MAP_r01 740 -#define _BUILD_SET_r01 741 -#define _BUILD_SLICE_r01 742 -#define _BUILD_STRING_r01 743 -#define _BUILD_TEMPLATE_r21 744 -#define _BUILD_TUPLE_r01 745 -#define _CALL_BUILTIN_CLASS_r00 746 -#define _CALL_BUILTIN_FAST_r00 747 -#define _CALL_BUILTIN_FAST_WITH_KEYWORDS_r00 748 -#define _CALL_BUILTIN_O_r03 749 -#define _CALL_FUNCTION_EX_NON_PY_GENERAL_r31 750 -#define _CALL_INTRINSIC_1_r12 751 -#define _CALL_INTRINSIC_2_r23 752 -#define _CALL_ISINSTANCE_r31 753 -#define _CALL_KW_NON_PY_r11 754 -#define _CALL_LEN_r33 755 -#define _CALL_LIST_APPEND_r03 756 -#define _CALL_LIST_APPEND_r13 757 -#define _CALL_LIST_APPEND_r23 758 -#define _CALL_LIST_APPEND_r33 759 -#define _CALL_METHOD_DESCRIPTOR_FAST_r00 760 -#define _CALL_METHOD_DESCRIPTOR_FAST_INLINE_r00 761 -#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r00 762 -#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_INLINE_r00 763 -#define _CALL_METHOD_DESCRIPTOR_NOARGS_r03 764 -#define _CALL_METHOD_DESCRIPTOR_NOARGS_INLINE_r03 765 -#define _CALL_METHOD_DESCRIPTOR_O_r03 766 -#define _CALL_METHOD_DESCRIPTOR_O_INLINE_r03 767 -#define _CALL_NON_PY_GENERAL_r01 768 -#define _CALL_STR_1_r32 769 -#define _CALL_TUPLE_1_r32 770 -#define _CALL_TYPE_1_r02 771 -#define _CALL_TYPE_1_r12 772 -#define _CALL_TYPE_1_r22 773 -#define _CALL_TYPE_1_r32 774 -#define _CHECK_ATTR_CLASS_r01 775 -#define _CHECK_ATTR_CLASS_r11 776 -#define _CHECK_ATTR_CLASS_r22 777 -#define _CHECK_ATTR_CLASS_r33 778 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r01 779 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r11 780 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r22 781 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r33 782 -#define _CHECK_CALL_BOUND_METHOD_EXACT_ARGS_r00 783 -#define _CHECK_EG_MATCH_r22 784 -#define _CHECK_EXC_MATCH_r22 785 -#define _CHECK_FUNCTION_EXACT_ARGS_r00 786 -#define _CHECK_FUNCTION_VERSION_r00 787 -#define _CHECK_FUNCTION_VERSION_INLINE_r00 788 -#define _CHECK_FUNCTION_VERSION_INLINE_r11 789 -#define _CHECK_FUNCTION_VERSION_INLINE_r22 790 -#define _CHECK_FUNCTION_VERSION_INLINE_r33 791 -#define _CHECK_FUNCTION_VERSION_KW_r11 792 -#define _CHECK_IS_NOT_PY_CALLABLE_r00 793 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r03 794 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r13 795 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r23 796 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r33 797 -#define _CHECK_IS_NOT_PY_CALLABLE_KW_r11 798 -#define _CHECK_IS_PY_CALLABLE_EX_r03 799 -#define _CHECK_IS_PY_CALLABLE_EX_r13 800 -#define _CHECK_IS_PY_CALLABLE_EX_r23 801 -#define _CHECK_IS_PY_CALLABLE_EX_r33 802 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r01 803 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r11 804 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r22 805 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r33 806 -#define _CHECK_METHOD_VERSION_r00 807 -#define _CHECK_METHOD_VERSION_KW_r11 808 -#define _CHECK_OBJECT_r00 809 -#define _CHECK_PEP_523_r00 810 -#define _CHECK_PEP_523_r11 811 -#define _CHECK_PEP_523_r22 812 -#define _CHECK_PEP_523_r33 813 -#define _CHECK_PERIODIC_r00 814 -#define _CHECK_PERIODIC_AT_END_r00 815 -#define _CHECK_PERIODIC_IF_NOT_YIELD_FROM_r00 816 -#define _CHECK_RECURSION_LIMIT_r00 817 -#define _CHECK_RECURSION_LIMIT_r11 818 -#define _CHECK_RECURSION_LIMIT_r22 819 -#define _CHECK_RECURSION_LIMIT_r33 820 -#define _CHECK_RECURSION_REMAINING_r00 821 -#define _CHECK_RECURSION_REMAINING_r11 822 -#define _CHECK_RECURSION_REMAINING_r22 823 -#define _CHECK_RECURSION_REMAINING_r33 824 -#define _CHECK_STACK_SPACE_r00 825 -#define _CHECK_STACK_SPACE_OPERAND_r00 826 -#define _CHECK_STACK_SPACE_OPERAND_r11 827 -#define _CHECK_STACK_SPACE_OPERAND_r22 828 -#define _CHECK_STACK_SPACE_OPERAND_r33 829 -#define _CHECK_VALIDITY_r00 830 -#define _CHECK_VALIDITY_r11 831 -#define _CHECK_VALIDITY_r22 832 -#define _CHECK_VALIDITY_r33 833 -#define _COLD_DYNAMIC_EXIT_r00 834 -#define _COLD_EXIT_r00 835 -#define _COMPARE_OP_r21 836 -#define _COMPARE_OP_FLOAT_r03 837 -#define _COMPARE_OP_FLOAT_r13 838 -#define _COMPARE_OP_FLOAT_r23 839 -#define _COMPARE_OP_INT_r23 840 -#define _COMPARE_OP_STR_r23 841 -#define _CONTAINS_OP_r23 842 -#define _CONTAINS_OP_DICT_r23 843 -#define _CONTAINS_OP_SET_r23 844 -#define _CONVERT_VALUE_r11 845 -#define _COPY_r01 846 -#define _COPY_1_r02 847 -#define _COPY_1_r12 848 -#define _COPY_1_r23 849 -#define _COPY_2_r03 850 -#define _COPY_2_r13 851 -#define _COPY_2_r23 852 -#define _COPY_3_r03 853 -#define _COPY_3_r13 854 -#define _COPY_3_r23 855 -#define _COPY_3_r33 856 -#define _COPY_FREE_VARS_r00 857 -#define _COPY_FREE_VARS_r11 858 -#define _COPY_FREE_VARS_r22 859 -#define _COPY_FREE_VARS_r33 860 -#define _CREATE_INIT_FRAME_r01 861 -#define _DELETE_ATTR_r10 862 -#define _DELETE_DEREF_r00 863 -#define _DELETE_FAST_r00 864 -#define _DELETE_GLOBAL_r00 865 -#define _DELETE_NAME_r00 866 -#define _DELETE_SUBSCR_r20 867 -#define _DEOPT_r00 868 -#define _DEOPT_r10 869 -#define _DEOPT_r20 870 -#define _DEOPT_r30 871 -#define _DICT_MERGE_r11 872 -#define _DICT_UPDATE_r11 873 -#define _DO_CALL_r01 874 -#define _DO_CALL_FUNCTION_EX_r31 875 -#define _DO_CALL_KW_r11 876 -#define _DYNAMIC_EXIT_r00 877 -#define _DYNAMIC_EXIT_r10 878 -#define _DYNAMIC_EXIT_r20 879 -#define _DYNAMIC_EXIT_r30 880 -#define _END_FOR_r10 881 -#define _END_SEND_r31 882 -#define _ERROR_POP_N_r00 883 -#define _EXIT_INIT_CHECK_r10 884 -#define _EXIT_TRACE_r00 885 -#define _EXIT_TRACE_r10 886 -#define _EXIT_TRACE_r20 887 -#define _EXIT_TRACE_r30 888 -#define _EXPAND_METHOD_r00 889 -#define _EXPAND_METHOD_KW_r11 890 -#define _FATAL_ERROR_r00 891 -#define _FATAL_ERROR_r11 892 -#define _FATAL_ERROR_r22 893 -#define _FATAL_ERROR_r33 894 -#define _FORMAT_SIMPLE_r11 895 -#define _FORMAT_WITH_SPEC_r21 896 -#define _FOR_ITER_r23 897 -#define _FOR_ITER_GEN_FRAME_r03 898 -#define _FOR_ITER_GEN_FRAME_r13 899 -#define _FOR_ITER_GEN_FRAME_r23 900 -#define _FOR_ITER_TIER_TWO_r23 901 -#define _FOR_ITER_VIRTUAL_r23 902 -#define _FOR_ITER_VIRTUAL_TIER_TWO_r23 903 -#define _GET_AITER_r11 904 -#define _GET_ANEXT_r12 905 -#define _GET_AWAITABLE_r11 906 -#define _GET_ITER_r12 907 -#define _GET_ITER_TRAD_r12 908 -#define _GET_LEN_r12 909 -#define _GUARD_3OS_ASYNC_GEN_ASEND_r03 910 -#define _GUARD_3OS_ASYNC_GEN_ASEND_r13 911 -#define _GUARD_3OS_ASYNC_GEN_ASEND_r23 912 -#define _GUARD_3OS_ASYNC_GEN_ASEND_r33 913 -#define _GUARD_BINARY_OP_EXTEND_r22 914 -#define _GUARD_BINARY_OP_EXTEND_LHS_r02 915 -#define _GUARD_BINARY_OP_EXTEND_LHS_r12 916 -#define _GUARD_BINARY_OP_EXTEND_LHS_r22 917 -#define _GUARD_BINARY_OP_EXTEND_LHS_r33 918 -#define _GUARD_BINARY_OP_EXTEND_RHS_r02 919 -#define _GUARD_BINARY_OP_EXTEND_RHS_r12 920 -#define _GUARD_BINARY_OP_EXTEND_RHS_r22 921 -#define _GUARD_BINARY_OP_EXTEND_RHS_r33 922 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r02 923 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r12 924 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r22 925 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r33 926 -#define _GUARD_BIT_IS_SET_POP_r00 927 -#define _GUARD_BIT_IS_SET_POP_r10 928 -#define _GUARD_BIT_IS_SET_POP_r21 929 -#define _GUARD_BIT_IS_SET_POP_r32 930 -#define _GUARD_BIT_IS_SET_POP_4_r00 931 -#define _GUARD_BIT_IS_SET_POP_4_r10 932 -#define _GUARD_BIT_IS_SET_POP_4_r21 933 -#define _GUARD_BIT_IS_SET_POP_4_r32 934 -#define _GUARD_BIT_IS_SET_POP_5_r00 935 -#define _GUARD_BIT_IS_SET_POP_5_r10 936 -#define _GUARD_BIT_IS_SET_POP_5_r21 937 -#define _GUARD_BIT_IS_SET_POP_5_r32 938 -#define _GUARD_BIT_IS_SET_POP_6_r00 939 -#define _GUARD_BIT_IS_SET_POP_6_r10 940 -#define _GUARD_BIT_IS_SET_POP_6_r21 941 -#define _GUARD_BIT_IS_SET_POP_6_r32 942 -#define _GUARD_BIT_IS_SET_POP_7_r00 943 -#define _GUARD_BIT_IS_SET_POP_7_r10 944 -#define _GUARD_BIT_IS_SET_POP_7_r21 945 -#define _GUARD_BIT_IS_SET_POP_7_r32 946 -#define _GUARD_BIT_IS_UNSET_POP_r00 947 -#define _GUARD_BIT_IS_UNSET_POP_r10 948 -#define _GUARD_BIT_IS_UNSET_POP_r21 949 -#define _GUARD_BIT_IS_UNSET_POP_r32 950 -#define _GUARD_BIT_IS_UNSET_POP_4_r00 951 -#define _GUARD_BIT_IS_UNSET_POP_4_r10 952 -#define _GUARD_BIT_IS_UNSET_POP_4_r21 953 -#define _GUARD_BIT_IS_UNSET_POP_4_r32 954 -#define _GUARD_BIT_IS_UNSET_POP_5_r00 955 -#define _GUARD_BIT_IS_UNSET_POP_5_r10 956 -#define _GUARD_BIT_IS_UNSET_POP_5_r21 957 -#define _GUARD_BIT_IS_UNSET_POP_5_r32 958 -#define _GUARD_BIT_IS_UNSET_POP_6_r00 959 -#define _GUARD_BIT_IS_UNSET_POP_6_r10 960 -#define _GUARD_BIT_IS_UNSET_POP_6_r21 961 -#define _GUARD_BIT_IS_UNSET_POP_6_r32 962 -#define _GUARD_BIT_IS_UNSET_POP_7_r00 963 -#define _GUARD_BIT_IS_UNSET_POP_7_r10 964 -#define _GUARD_BIT_IS_UNSET_POP_7_r21 965 -#define _GUARD_BIT_IS_UNSET_POP_7_r32 966 -#define _GUARD_CALLABLE_BUILTIN_CLASS_r00 967 -#define _GUARD_CALLABLE_BUILTIN_FAST_r00 968 -#define _GUARD_CALLABLE_BUILTIN_FAST_WITH_KEYWORDS_r00 969 -#define _GUARD_CALLABLE_BUILTIN_O_r00 970 -#define _GUARD_CALLABLE_ISINSTANCE_r03 971 -#define _GUARD_CALLABLE_ISINSTANCE_r13 972 -#define _GUARD_CALLABLE_ISINSTANCE_r23 973 -#define _GUARD_CALLABLE_ISINSTANCE_r33 974 -#define _GUARD_CALLABLE_LEN_r03 975 -#define _GUARD_CALLABLE_LEN_r13 976 -#define _GUARD_CALLABLE_LEN_r23 977 -#define _GUARD_CALLABLE_LEN_r33 978 -#define _GUARD_CALLABLE_LIST_APPEND_r03 979 -#define _GUARD_CALLABLE_LIST_APPEND_r13 980 -#define _GUARD_CALLABLE_LIST_APPEND_r23 981 -#define _GUARD_CALLABLE_LIST_APPEND_r33 982 -#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST_r00 983 -#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r00 984 -#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_NOARGS_r00 985 -#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_O_r00 986 -#define _GUARD_CALLABLE_STR_1_r03 987 -#define _GUARD_CALLABLE_STR_1_r13 988 -#define _GUARD_CALLABLE_STR_1_r23 989 -#define _GUARD_CALLABLE_STR_1_r33 990 -#define _GUARD_CALLABLE_TUPLE_1_r03 991 -#define _GUARD_CALLABLE_TUPLE_1_r13 992 -#define _GUARD_CALLABLE_TUPLE_1_r23 993 -#define _GUARD_CALLABLE_TUPLE_1_r33 994 -#define _GUARD_CALLABLE_TYPE_1_r03 995 -#define _GUARD_CALLABLE_TYPE_1_r13 996 -#define _GUARD_CALLABLE_TYPE_1_r23 997 -#define _GUARD_CALLABLE_TYPE_1_r33 998 -#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r00 999 -#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r11 1000 -#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r22 1001 -#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r33 1002 -#define _GUARD_CODE_VERSION_RETURN_VALUE_r00 1003 -#define _GUARD_CODE_VERSION_RETURN_VALUE_r11 1004 -#define _GUARD_CODE_VERSION_RETURN_VALUE_r22 1005 -#define _GUARD_CODE_VERSION_RETURN_VALUE_r33 1006 -#define _GUARD_CODE_VERSION_YIELD_VALUE_r00 1007 -#define _GUARD_CODE_VERSION_YIELD_VALUE_r11 1008 -#define _GUARD_CODE_VERSION_YIELD_VALUE_r22 1009 -#define _GUARD_CODE_VERSION_YIELD_VALUE_r33 1010 -#define _GUARD_CODE_VERSION__PUSH_FRAME_r00 1011 -#define _GUARD_CODE_VERSION__PUSH_FRAME_r11 1012 -#define _GUARD_CODE_VERSION__PUSH_FRAME_r22 1013 -#define _GUARD_CODE_VERSION__PUSH_FRAME_r33 1014 -#define _GUARD_DORV_NO_DICT_r01 1015 -#define _GUARD_DORV_NO_DICT_r11 1016 -#define _GUARD_DORV_NO_DICT_r22 1017 -#define _GUARD_DORV_NO_DICT_r33 1018 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r01 1019 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r11 1020 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r22 1021 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r33 1022 -#define _GUARD_GLOBALS_VERSION_r00 1023 -#define _GUARD_GLOBALS_VERSION_r11 1024 -#define _GUARD_GLOBALS_VERSION_r22 1025 -#define _GUARD_GLOBALS_VERSION_r33 1026 -#define _GUARD_IP_RETURN_GENERATOR_r00 1027 -#define _GUARD_IP_RETURN_GENERATOR_r11 1028 -#define _GUARD_IP_RETURN_GENERATOR_r22 1029 -#define _GUARD_IP_RETURN_GENERATOR_r33 1030 -#define _GUARD_IP_RETURN_VALUE_r00 1031 -#define _GUARD_IP_RETURN_VALUE_r11 1032 -#define _GUARD_IP_RETURN_VALUE_r22 1033 -#define _GUARD_IP_RETURN_VALUE_r33 1034 -#define _GUARD_IP_YIELD_VALUE_r00 1035 -#define _GUARD_IP_YIELD_VALUE_r11 1036 -#define _GUARD_IP_YIELD_VALUE_r22 1037 -#define _GUARD_IP_YIELD_VALUE_r33 1038 -#define _GUARD_IP__PUSH_FRAME_r00 1039 -#define _GUARD_IP__PUSH_FRAME_r11 1040 -#define _GUARD_IP__PUSH_FRAME_r22 1041 -#define _GUARD_IP__PUSH_FRAME_r33 1042 -#define _GUARD_IS_FALSE_POP_r00 1043 -#define _GUARD_IS_FALSE_POP_r10 1044 -#define _GUARD_IS_FALSE_POP_r21 1045 -#define _GUARD_IS_FALSE_POP_r32 1046 -#define _GUARD_IS_NONE_POP_r00 1047 -#define _GUARD_IS_NONE_POP_r10 1048 -#define _GUARD_IS_NONE_POP_r21 1049 -#define _GUARD_IS_NONE_POP_r32 1050 -#define _GUARD_IS_NOT_NONE_POP_r10 1051 -#define _GUARD_IS_TRUE_POP_r00 1052 -#define _GUARD_IS_TRUE_POP_r10 1053 -#define _GUARD_IS_TRUE_POP_r21 1054 -#define _GUARD_IS_TRUE_POP_r32 1055 -#define _GUARD_ITERATOR_r01 1056 -#define _GUARD_ITERATOR_r11 1057 -#define _GUARD_ITERATOR_r22 1058 -#define _GUARD_ITERATOR_r33 1059 -#define _GUARD_ITER_VIRTUAL_r01 1060 -#define _GUARD_ITER_VIRTUAL_r11 1061 -#define _GUARD_ITER_VIRTUAL_r22 1062 -#define _GUARD_ITER_VIRTUAL_r33 1063 -#define _GUARD_KEYS_VERSION_r01 1064 -#define _GUARD_KEYS_VERSION_r11 1065 -#define _GUARD_KEYS_VERSION_r22 1066 -#define _GUARD_KEYS_VERSION_r33 1067 -#define _GUARD_LOAD_SUPER_ATTR_METHOD_r03 1068 -#define _GUARD_LOAD_SUPER_ATTR_METHOD_r13 1069 -#define _GUARD_LOAD_SUPER_ATTR_METHOD_r23 1070 -#define _GUARD_LOAD_SUPER_ATTR_METHOD_r33 1071 -#define _GUARD_NOS_COMPACT_ASCII_r02 1072 -#define _GUARD_NOS_COMPACT_ASCII_r12 1073 -#define _GUARD_NOS_COMPACT_ASCII_r22 1074 -#define _GUARD_NOS_COMPACT_ASCII_r33 1075 -#define _GUARD_NOS_DICT_STORE_SUBSCRIPT_r03 1076 -#define _GUARD_NOS_DICT_STORE_SUBSCRIPT_r13 1077 -#define _GUARD_NOS_DICT_STORE_SUBSCRIPT_r23 1078 -#define _GUARD_NOS_DICT_STORE_SUBSCRIPT_r33 1079 -#define _GUARD_NOS_DICT_SUBSCRIPT_r02 1080 -#define _GUARD_NOS_DICT_SUBSCRIPT_r12 1081 -#define _GUARD_NOS_DICT_SUBSCRIPT_r22 1082 -#define _GUARD_NOS_DICT_SUBSCRIPT_r33 1083 -#define _GUARD_NOS_FLOAT_r02 1084 -#define _GUARD_NOS_FLOAT_r12 1085 -#define _GUARD_NOS_FLOAT_r22 1086 -#define _GUARD_NOS_FLOAT_r33 1087 -#define _GUARD_NOS_INT_r02 1088 -#define _GUARD_NOS_INT_r12 1089 -#define _GUARD_NOS_INT_r22 1090 -#define _GUARD_NOS_INT_r33 1091 -#define _GUARD_NOS_ITER_VIRTUAL_r02 1092 -#define _GUARD_NOS_ITER_VIRTUAL_r12 1093 -#define _GUARD_NOS_ITER_VIRTUAL_r22 1094 -#define _GUARD_NOS_ITER_VIRTUAL_r33 1095 -#define _GUARD_NOS_LIST_r02 1096 -#define _GUARD_NOS_LIST_r12 1097 -#define _GUARD_NOS_LIST_r22 1098 -#define _GUARD_NOS_LIST_r33 1099 -#define _GUARD_NOS_NOT_NULL_r02 1100 -#define _GUARD_NOS_NOT_NULL_r12 1101 -#define _GUARD_NOS_NOT_NULL_r22 1102 -#define _GUARD_NOS_NOT_NULL_r33 1103 -#define _GUARD_NOS_NULL_r02 1104 -#define _GUARD_NOS_NULL_r12 1105 -#define _GUARD_NOS_NULL_r22 1106 -#define _GUARD_NOS_NULL_r33 1107 -#define _GUARD_NOS_OVERFLOWED_r02 1108 -#define _GUARD_NOS_OVERFLOWED_r12 1109 -#define _GUARD_NOS_OVERFLOWED_r22 1110 -#define _GUARD_NOS_OVERFLOWED_r33 1111 -#define _GUARD_NOS_TUPLE_r02 1112 -#define _GUARD_NOS_TUPLE_r12 1113 -#define _GUARD_NOS_TUPLE_r22 1114 -#define _GUARD_NOS_TUPLE_r33 1115 -#define _GUARD_NOS_TYPE_VERSION_r02 1116 -#define _GUARD_NOS_TYPE_VERSION_r12 1117 -#define _GUARD_NOS_TYPE_VERSION_r22 1118 -#define _GUARD_NOS_TYPE_VERSION_r33 1119 -#define _GUARD_NOS_UNICODE_r02 1120 -#define _GUARD_NOS_UNICODE_r12 1121 -#define _GUARD_NOS_UNICODE_r22 1122 -#define _GUARD_NOS_UNICODE_r33 1123 -#define _GUARD_NOT_EXHAUSTED_LIST_r02 1124 -#define _GUARD_NOT_EXHAUSTED_LIST_r12 1125 -#define _GUARD_NOT_EXHAUSTED_LIST_r22 1126 -#define _GUARD_NOT_EXHAUSTED_LIST_r33 1127 -#define _GUARD_NOT_EXHAUSTED_RANGE_r02 1128 -#define _GUARD_NOT_EXHAUSTED_RANGE_r12 1129 -#define _GUARD_NOT_EXHAUSTED_RANGE_r22 1130 -#define _GUARD_NOT_EXHAUSTED_RANGE_r33 1131 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r02 1132 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r12 1133 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r22 1134 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r33 1135 -#define _GUARD_THIRD_NULL_r03 1136 -#define _GUARD_THIRD_NULL_r13 1137 -#define _GUARD_THIRD_NULL_r23 1138 -#define _GUARD_THIRD_NULL_r33 1139 -#define _GUARD_TOS_ANY_DICT_r01 1140 -#define _GUARD_TOS_ANY_DICT_r11 1141 -#define _GUARD_TOS_ANY_DICT_r22 1142 -#define _GUARD_TOS_ANY_DICT_r33 1143 -#define _GUARD_TOS_ANY_SET_r01 1144 -#define _GUARD_TOS_ANY_SET_r11 1145 -#define _GUARD_TOS_ANY_SET_r22 1146 -#define _GUARD_TOS_ANY_SET_r33 1147 -#define _GUARD_TOS_DICT_r01 1148 -#define _GUARD_TOS_DICT_r11 1149 -#define _GUARD_TOS_DICT_r22 1150 -#define _GUARD_TOS_DICT_r33 1151 -#define _GUARD_TOS_FLOAT_r01 1152 -#define _GUARD_TOS_FLOAT_r11 1153 -#define _GUARD_TOS_FLOAT_r22 1154 -#define _GUARD_TOS_FLOAT_r33 1155 -#define _GUARD_TOS_FROZENDICT_r01 1156 -#define _GUARD_TOS_FROZENDICT_r11 1157 -#define _GUARD_TOS_FROZENDICT_r22 1158 -#define _GUARD_TOS_FROZENDICT_r33 1159 -#define _GUARD_TOS_FROZENSET_r01 1160 -#define _GUARD_TOS_FROZENSET_r11 1161 -#define _GUARD_TOS_FROZENSET_r22 1162 -#define _GUARD_TOS_FROZENSET_r33 1163 -#define _GUARD_TOS_INT_r01 1164 -#define _GUARD_TOS_INT_r11 1165 -#define _GUARD_TOS_INT_r22 1166 -#define _GUARD_TOS_INT_r33 1167 -#define _GUARD_TOS_IS_NONE_r01 1168 -#define _GUARD_TOS_IS_NONE_r11 1169 -#define _GUARD_TOS_IS_NONE_r22 1170 -#define _GUARD_TOS_IS_NONE_r33 1171 -#define _GUARD_TOS_LIST_r01 1172 -#define _GUARD_TOS_LIST_r11 1173 -#define _GUARD_TOS_LIST_r22 1174 -#define _GUARD_TOS_LIST_r33 1175 -#define _GUARD_TOS_NOT_NULL_r01 1176 -#define _GUARD_TOS_NOT_NULL_r11 1177 -#define _GUARD_TOS_NOT_NULL_r22 1178 -#define _GUARD_TOS_NOT_NULL_r33 1179 -#define _GUARD_TOS_OVERFLOWED_r01 1180 -#define _GUARD_TOS_OVERFLOWED_r11 1181 -#define _GUARD_TOS_OVERFLOWED_r22 1182 -#define _GUARD_TOS_OVERFLOWED_r33 1183 -#define _GUARD_TOS_SET_r01 1184 -#define _GUARD_TOS_SET_r11 1185 -#define _GUARD_TOS_SET_r22 1186 -#define _GUARD_TOS_SET_r33 1187 -#define _GUARD_TOS_SLICE_r01 1188 -#define _GUARD_TOS_SLICE_r11 1189 -#define _GUARD_TOS_SLICE_r22 1190 -#define _GUARD_TOS_SLICE_r33 1191 -#define _GUARD_TOS_TUPLE_r01 1192 -#define _GUARD_TOS_TUPLE_r11 1193 -#define _GUARD_TOS_TUPLE_r22 1194 -#define _GUARD_TOS_TUPLE_r33 1195 -#define _GUARD_TOS_UNICODE_r01 1196 -#define _GUARD_TOS_UNICODE_r11 1197 -#define _GUARD_TOS_UNICODE_r22 1198 -#define _GUARD_TOS_UNICODE_r33 1199 -#define _GUARD_TYPE_r01 1200 -#define _GUARD_TYPE_r11 1201 -#define _GUARD_TYPE_r22 1202 -#define _GUARD_TYPE_r33 1203 -#define _GUARD_TYPE_ITER_r02 1204 -#define _GUARD_TYPE_ITER_r12 1205 -#define _GUARD_TYPE_ITER_r22 1206 -#define _GUARD_TYPE_ITER_r33 1207 -#define _GUARD_TYPE_VERSION_r01 1208 -#define _GUARD_TYPE_VERSION_r11 1209 -#define _GUARD_TYPE_VERSION_r22 1210 -#define _GUARD_TYPE_VERSION_r33 1211 -#define _GUARD_TYPE_VERSION_LOCKED_r01 1212 -#define _GUARD_TYPE_VERSION_LOCKED_r11 1213 -#define _GUARD_TYPE_VERSION_LOCKED_r22 1214 -#define _GUARD_TYPE_VERSION_LOCKED_r33 1215 -#define _HANDLE_PENDING_AND_DEOPT_r00 1216 -#define _HANDLE_PENDING_AND_DEOPT_r10 1217 -#define _HANDLE_PENDING_AND_DEOPT_r20 1218 -#define _HANDLE_PENDING_AND_DEOPT_r30 1219 -#define _IMPORT_FROM_r12 1220 -#define _IMPORT_NAME_r21 1221 -#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS_r00 1222 -#define _INIT_CALL_PY_EXACT_ARGS_r01 1223 -#define _INIT_CALL_PY_EXACT_ARGS_0_r01 1224 -#define _INIT_CALL_PY_EXACT_ARGS_1_r01 1225 -#define _INIT_CALL_PY_EXACT_ARGS_2_r01 1226 -#define _INIT_CALL_PY_EXACT_ARGS_3_r01 1227 -#define _INIT_CALL_PY_EXACT_ARGS_4_r01 1228 -#define _INSERT_NULL_r10 1229 -#define _INSTRUMENTED_FOR_ITER_r23 1230 -#define _INSTRUMENTED_INSTRUCTION_r00 1231 -#define _INSTRUMENTED_JUMP_FORWARD_r00 1232 -#define _INSTRUMENTED_JUMP_FORWARD_r11 1233 -#define _INSTRUMENTED_JUMP_FORWARD_r22 1234 -#define _INSTRUMENTED_JUMP_FORWARD_r33 1235 -#define _INSTRUMENTED_LINE_r00 1236 -#define _INSTRUMENTED_NOT_TAKEN_r00 1237 -#define _INSTRUMENTED_NOT_TAKEN_r11 1238 -#define _INSTRUMENTED_NOT_TAKEN_r22 1239 -#define _INSTRUMENTED_NOT_TAKEN_r33 1240 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r00 1241 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r10 1242 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r21 1243 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r32 1244 -#define _INSTRUMENTED_POP_JUMP_IF_NONE_r10 1245 -#define _INSTRUMENTED_POP_JUMP_IF_NOT_NONE_r10 1246 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r00 1247 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r10 1248 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r21 1249 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r32 1250 -#define _IS_NONE_r11 1251 -#define _IS_OP_r03 1252 -#define _IS_OP_r13 1253 -#define _IS_OP_r23 1254 -#define _ITER_CHECK_LIST_r02 1255 -#define _ITER_CHECK_LIST_r12 1256 -#define _ITER_CHECK_LIST_r22 1257 -#define _ITER_CHECK_LIST_r33 1258 -#define _ITER_CHECK_RANGE_r02 1259 -#define _ITER_CHECK_RANGE_r12 1260 -#define _ITER_CHECK_RANGE_r22 1261 -#define _ITER_CHECK_RANGE_r33 1262 -#define _ITER_CHECK_TUPLE_r02 1263 -#define _ITER_CHECK_TUPLE_r12 1264 -#define _ITER_CHECK_TUPLE_r22 1265 -#define _ITER_CHECK_TUPLE_r33 1266 -#define _ITER_JUMP_LIST_r02 1267 -#define _ITER_JUMP_LIST_r12 1268 -#define _ITER_JUMP_LIST_r22 1269 -#define _ITER_JUMP_LIST_r33 1270 -#define _ITER_JUMP_RANGE_r02 1271 -#define _ITER_JUMP_RANGE_r12 1272 -#define _ITER_JUMP_RANGE_r22 1273 -#define _ITER_JUMP_RANGE_r33 1274 -#define _ITER_JUMP_TUPLE_r02 1275 -#define _ITER_JUMP_TUPLE_r12 1276 -#define _ITER_JUMP_TUPLE_r22 1277 -#define _ITER_JUMP_TUPLE_r33 1278 -#define _ITER_NEXT_INLINE_r23 1279 -#define _ITER_NEXT_LIST_r23 1280 -#define _ITER_NEXT_LIST_TIER_TWO_r23 1281 -#define _ITER_NEXT_RANGE_r03 1282 -#define _ITER_NEXT_RANGE_r13 1283 -#define _ITER_NEXT_RANGE_r23 1284 -#define _ITER_NEXT_TUPLE_r03 1285 -#define _ITER_NEXT_TUPLE_r13 1286 -#define _ITER_NEXT_TUPLE_r23 1287 -#define _JUMP_BACKWARD_NO_INTERRUPT_r00 1288 -#define _JUMP_BACKWARD_NO_INTERRUPT_r11 1289 -#define _JUMP_BACKWARD_NO_INTERRUPT_r22 1290 -#define _JUMP_BACKWARD_NO_INTERRUPT_r33 1291 -#define _JUMP_TO_TOP_r00 1292 -#define _LIST_APPEND_r10 1293 -#define _LIST_EXTEND_r11 1294 -#define _LOAD_ATTR_r10 1295 -#define _LOAD_ATTR_CLASS_r11 1296 -#define _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN_FRAME_r11 1297 -#define _LOAD_ATTR_INSTANCE_VALUE_r02 1298 -#define _LOAD_ATTR_INSTANCE_VALUE_r12 1299 -#define _LOAD_ATTR_INSTANCE_VALUE_r23 1300 -#define _LOAD_ATTR_METHOD_LAZY_DICT_r02 1301 -#define _LOAD_ATTR_METHOD_LAZY_DICT_r12 1302 -#define _LOAD_ATTR_METHOD_LAZY_DICT_r23 1303 -#define _LOAD_ATTR_METHOD_NO_DICT_r02 1304 -#define _LOAD_ATTR_METHOD_NO_DICT_r12 1305 -#define _LOAD_ATTR_METHOD_NO_DICT_r23 1306 -#define _LOAD_ATTR_METHOD_WITH_VALUES_r02 1307 -#define _LOAD_ATTR_METHOD_WITH_VALUES_r12 1308 -#define _LOAD_ATTR_METHOD_WITH_VALUES_r23 1309 -#define _LOAD_ATTR_MODULE_r12 1310 -#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT_r11 1311 -#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES_r11 1312 -#define _LOAD_ATTR_PROPERTY_FRAME_r01 1313 -#define _LOAD_ATTR_PROPERTY_FRAME_r11 1314 -#define _LOAD_ATTR_PROPERTY_FRAME_r22 1315 -#define _LOAD_ATTR_PROPERTY_FRAME_r33 1316 -#define _LOAD_ATTR_SLOT_r02 1317 -#define _LOAD_ATTR_SLOT_r12 1318 -#define _LOAD_ATTR_SLOT_r23 1319 -#define _LOAD_ATTR_WITH_HINT_r12 1320 -#define _LOAD_BUILD_CLASS_r01 1321 -#define _LOAD_BYTECODE_r00 1322 -#define _LOAD_COMMON_CONSTANT_r01 1323 -#define _LOAD_COMMON_CONSTANT_r12 1324 -#define _LOAD_COMMON_CONSTANT_r23 1325 -#define _LOAD_CONST_r01 1326 -#define _LOAD_CONST_r12 1327 -#define _LOAD_CONST_r23 1328 -#define _LOAD_CONST_INLINE_r01 1329 -#define _LOAD_CONST_INLINE_r12 1330 -#define _LOAD_CONST_INLINE_r23 1331 -#define _LOAD_CONST_INLINE_BORROW_r01 1332 -#define _LOAD_CONST_INLINE_BORROW_r12 1333 -#define _LOAD_CONST_INLINE_BORROW_r23 1334 -#define _LOAD_DEREF_r01 1335 -#define _LOAD_FAST_r01 1336 -#define _LOAD_FAST_r12 1337 -#define _LOAD_FAST_r23 1338 -#define _LOAD_FAST_0_r01 1339 -#define _LOAD_FAST_0_r12 1340 -#define _LOAD_FAST_0_r23 1341 -#define _LOAD_FAST_1_r01 1342 -#define _LOAD_FAST_1_r12 1343 -#define _LOAD_FAST_1_r23 1344 -#define _LOAD_FAST_2_r01 1345 -#define _LOAD_FAST_2_r12 1346 -#define _LOAD_FAST_2_r23 1347 -#define _LOAD_FAST_3_r01 1348 -#define _LOAD_FAST_3_r12 1349 -#define _LOAD_FAST_3_r23 1350 -#define _LOAD_FAST_4_r01 1351 -#define _LOAD_FAST_4_r12 1352 -#define _LOAD_FAST_4_r23 1353 -#define _LOAD_FAST_5_r01 1354 -#define _LOAD_FAST_5_r12 1355 -#define _LOAD_FAST_5_r23 1356 -#define _LOAD_FAST_6_r01 1357 -#define _LOAD_FAST_6_r12 1358 -#define _LOAD_FAST_6_r23 1359 -#define _LOAD_FAST_7_r01 1360 -#define _LOAD_FAST_7_r12 1361 -#define _LOAD_FAST_7_r23 1362 -#define _LOAD_FAST_AND_CLEAR_r01 1363 -#define _LOAD_FAST_AND_CLEAR_r12 1364 -#define _LOAD_FAST_AND_CLEAR_r23 1365 -#define _LOAD_FAST_BORROW_r01 1366 -#define _LOAD_FAST_BORROW_r12 1367 -#define _LOAD_FAST_BORROW_r23 1368 -#define _LOAD_FAST_BORROW_0_r01 1369 -#define _LOAD_FAST_BORROW_0_r12 1370 -#define _LOAD_FAST_BORROW_0_r23 1371 -#define _LOAD_FAST_BORROW_1_r01 1372 -#define _LOAD_FAST_BORROW_1_r12 1373 -#define _LOAD_FAST_BORROW_1_r23 1374 -#define _LOAD_FAST_BORROW_2_r01 1375 -#define _LOAD_FAST_BORROW_2_r12 1376 -#define _LOAD_FAST_BORROW_2_r23 1377 -#define _LOAD_FAST_BORROW_3_r01 1378 -#define _LOAD_FAST_BORROW_3_r12 1379 -#define _LOAD_FAST_BORROW_3_r23 1380 -#define _LOAD_FAST_BORROW_4_r01 1381 -#define _LOAD_FAST_BORROW_4_r12 1382 -#define _LOAD_FAST_BORROW_4_r23 1383 -#define _LOAD_FAST_BORROW_5_r01 1384 -#define _LOAD_FAST_BORROW_5_r12 1385 -#define _LOAD_FAST_BORROW_5_r23 1386 -#define _LOAD_FAST_BORROW_6_r01 1387 -#define _LOAD_FAST_BORROW_6_r12 1388 -#define _LOAD_FAST_BORROW_6_r23 1389 -#define _LOAD_FAST_BORROW_7_r01 1390 -#define _LOAD_FAST_BORROW_7_r12 1391 -#define _LOAD_FAST_BORROW_7_r23 1392 -#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r02 1393 -#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r13 1394 -#define _LOAD_FAST_CHECK_r01 1395 -#define _LOAD_FAST_CHECK_r12 1396 -#define _LOAD_FAST_CHECK_r23 1397 -#define _LOAD_FAST_LOAD_FAST_r02 1398 -#define _LOAD_FAST_LOAD_FAST_r13 1399 -#define _LOAD_FROM_DICT_OR_DEREF_r11 1400 -#define _LOAD_FROM_DICT_OR_GLOBALS_r11 1401 -#define _LOAD_GLOBAL_r00 1402 -#define _LOAD_GLOBAL_BUILTINS_r01 1403 -#define _LOAD_GLOBAL_MODULE_r01 1404 -#define _LOAD_LOCALS_r01 1405 -#define _LOAD_LOCALS_r12 1406 -#define _LOAD_LOCALS_r23 1407 -#define _LOAD_NAME_r01 1408 -#define _LOAD_SMALL_INT_r01 1409 -#define _LOAD_SMALL_INT_r12 1410 -#define _LOAD_SMALL_INT_r23 1411 -#define _LOAD_SMALL_INT_0_r01 1412 -#define _LOAD_SMALL_INT_0_r12 1413 -#define _LOAD_SMALL_INT_0_r23 1414 -#define _LOAD_SMALL_INT_1_r01 1415 -#define _LOAD_SMALL_INT_1_r12 1416 -#define _LOAD_SMALL_INT_1_r23 1417 -#define _LOAD_SMALL_INT_2_r01 1418 -#define _LOAD_SMALL_INT_2_r12 1419 -#define _LOAD_SMALL_INT_2_r23 1420 -#define _LOAD_SMALL_INT_3_r01 1421 -#define _LOAD_SMALL_INT_3_r12 1422 -#define _LOAD_SMALL_INT_3_r23 1423 -#define _LOAD_SPECIAL_r00 1424 -#define _LOAD_SUPER_ATTR_ATTR_r31 1425 -#define _LOAD_SUPER_ATTR_METHOD_r32 1426 -#define _LOCK_OBJECT_r01 1427 -#define _LOCK_OBJECT_r11 1428 -#define _LOCK_OBJECT_r22 1429 -#define _LOCK_OBJECT_r33 1430 -#define _MAKE_CALLARGS_A_TUPLE_r33 1431 -#define _MAKE_CELL_r00 1432 -#define _MAKE_FUNCTION_r12 1433 -#define _MAKE_HEAP_SAFE_r01 1434 -#define _MAKE_HEAP_SAFE_r11 1435 -#define _MAKE_HEAP_SAFE_r22 1436 -#define _MAKE_HEAP_SAFE_r33 1437 -#define _MAKE_WARM_r00 1438 -#define _MAKE_WARM_r11 1439 -#define _MAKE_WARM_r22 1440 -#define _MAKE_WARM_r33 1441 -#define _MAP_ADD_r20 1442 -#define _MATCH_CLASS_r33 1443 -#define _MATCH_KEYS_r23 1444 -#define _MATCH_MAPPING_r02 1445 -#define _MATCH_MAPPING_r12 1446 -#define _MATCH_MAPPING_r23 1447 -#define _MATCH_SEQUENCE_r02 1448 -#define _MATCH_SEQUENCE_r12 1449 -#define _MATCH_SEQUENCE_r23 1450 -#define _MAYBE_EXPAND_METHOD_r00 1451 -#define _MAYBE_EXPAND_METHOD_KW_r11 1452 -#define _MONITOR_CALL_r00 1453 -#define _MONITOR_CALL_KW_r11 1454 -#define _MONITOR_JUMP_BACKWARD_r00 1455 -#define _MONITOR_JUMP_BACKWARD_r11 1456 -#define _MONITOR_JUMP_BACKWARD_r22 1457 -#define _MONITOR_JUMP_BACKWARD_r33 1458 -#define _MONITOR_RESUME_r00 1459 -#define _NOP_r00 1460 -#define _NOP_r11 1461 -#define _NOP_r22 1462 -#define _NOP_r33 1463 -#define _POP_EXCEPT_r10 1464 -#define _POP_ITER_r20 1465 -#define _POP_JUMP_IF_FALSE_r00 1466 -#define _POP_JUMP_IF_FALSE_r10 1467 -#define _POP_JUMP_IF_FALSE_r21 1468 -#define _POP_JUMP_IF_FALSE_r32 1469 -#define _POP_JUMP_IF_TRUE_r00 1470 -#define _POP_JUMP_IF_TRUE_r10 1471 -#define _POP_JUMP_IF_TRUE_r21 1472 -#define _POP_JUMP_IF_TRUE_r32 1473 -#define _POP_TOP_r10 1474 -#define _POP_TOP_FLOAT_r00 1475 -#define _POP_TOP_FLOAT_r10 1476 -#define _POP_TOP_FLOAT_r21 1477 -#define _POP_TOP_FLOAT_r32 1478 -#define _POP_TOP_INT_r00 1479 -#define _POP_TOP_INT_r10 1480 -#define _POP_TOP_INT_r21 1481 -#define _POP_TOP_INT_r32 1482 -#define _POP_TOP_NOP_r00 1483 -#define _POP_TOP_NOP_r10 1484 -#define _POP_TOP_NOP_r21 1485 -#define _POP_TOP_NOP_r32 1486 -#define _POP_TOP_OPARG_r00 1487 -#define _POP_TOP_UNICODE_r00 1488 -#define _POP_TOP_UNICODE_r10 1489 -#define _POP_TOP_UNICODE_r21 1490 -#define _POP_TOP_UNICODE_r32 1491 -#define _PUSH_EXC_INFO_r02 1492 -#define _PUSH_EXC_INFO_r12 1493 -#define _PUSH_EXC_INFO_r23 1494 -#define _PUSH_FRAME_r10 1495 -#define _PUSH_NULL_r01 1496 -#define _PUSH_NULL_r12 1497 -#define _PUSH_NULL_r23 1498 -#define _PUSH_NULL_CONDITIONAL_r00 1499 -#define _PUSH_TAGGED_ZERO_r01 1500 -#define _PUSH_TAGGED_ZERO_r12 1501 -#define _PUSH_TAGGED_ZERO_r23 1502 -#define _PY_FRAME_EX_r31 1503 -#define _PY_FRAME_GENERAL_r01 1504 -#define _PY_FRAME_KW_r11 1505 -#define _REPLACE_WITH_TRUE_r02 1506 -#define _REPLACE_WITH_TRUE_r12 1507 -#define _REPLACE_WITH_TRUE_r23 1508 -#define _RESUME_CHECK_r00 1509 -#define _RESUME_CHECK_r11 1510 -#define _RESUME_CHECK_r22 1511 -#define _RESUME_CHECK_r33 1512 -#define _RETURN_GENERATOR_r01 1513 -#define _RETURN_VALUE_r11 1514 -#define _RROT_3_r03 1515 -#define _RROT_3_r13 1516 -#define _RROT_3_r23 1517 -#define _RROT_3_r33 1518 -#define _SAVE_RETURN_OFFSET_r00 1519 -#define _SAVE_RETURN_OFFSET_r11 1520 -#define _SAVE_RETURN_OFFSET_r22 1521 -#define _SAVE_RETURN_OFFSET_r33 1522 -#define _SEND_ASYNC_GEN_r33 1523 -#define _SEND_ASYNC_GEN_TIER_TWO_r33 1524 -#define _SEND_GEN_FRAME_r33 1525 -#define _SEND_VIRTUAL_r33 1526 -#define _SEND_VIRTUAL_TIER_TWO_r03 1527 -#define _SEND_VIRTUAL_TIER_TWO_r13 1528 -#define _SEND_VIRTUAL_TIER_TWO_r23 1529 -#define _SEND_VIRTUAL_TIER_TWO_r33 1530 -#define _SETUP_ANNOTATIONS_r00 1531 -#define _SET_ADD_r10 1532 -#define _SET_FUNCTION_ATTRIBUTE_r01 1533 -#define _SET_FUNCTION_ATTRIBUTE_r11 1534 -#define _SET_FUNCTION_ATTRIBUTE_r21 1535 -#define _SET_FUNCTION_ATTRIBUTE_r32 1536 -#define _SET_IP_r00 1537 -#define _SET_IP_r11 1538 -#define _SET_IP_r22 1539 -#define _SET_IP_r33 1540 -#define _SET_UPDATE_r11 1541 -#define _SPILL_OR_RELOAD_r01 1542 -#define _SPILL_OR_RELOAD_r02 1543 -#define _SPILL_OR_RELOAD_r03 1544 -#define _SPILL_OR_RELOAD_r10 1545 -#define _SPILL_OR_RELOAD_r12 1546 -#define _SPILL_OR_RELOAD_r13 1547 -#define _SPILL_OR_RELOAD_r20 1548 -#define _SPILL_OR_RELOAD_r21 1549 -#define _SPILL_OR_RELOAD_r23 1550 -#define _SPILL_OR_RELOAD_r30 1551 -#define _SPILL_OR_RELOAD_r31 1552 -#define _SPILL_OR_RELOAD_r32 1553 -#define _START_EXECUTOR_r00 1554 -#define _STORE_ATTR_r20 1555 -#define _STORE_ATTR_INSTANCE_VALUE_r21 1556 -#define _STORE_ATTR_SLOT_r21 1557 -#define _STORE_ATTR_WITH_HINT_r21 1558 -#define _STORE_DEREF_r10 1559 -#define _STORE_FAST_LOAD_FAST_r11 1560 -#define _STORE_FAST_STORE_FAST_r20 1561 -#define _STORE_GLOBAL_r10 1562 -#define _STORE_NAME_r10 1563 -#define _STORE_SLICE_r30 1564 -#define _STORE_SUBSCR_r30 1565 -#define _STORE_SUBSCR_DICT_r31 1566 -#define _STORE_SUBSCR_DICT_KNOWN_HASH_r31 1567 -#define _STORE_SUBSCR_LIST_INT_r32 1568 -#define _SWAP_r11 1569 -#define _SWAP_2_r02 1570 -#define _SWAP_2_r12 1571 -#define _SWAP_2_r22 1572 -#define _SWAP_2_r33 1573 -#define _SWAP_3_r03 1574 -#define _SWAP_3_r13 1575 -#define _SWAP_3_r23 1576 -#define _SWAP_3_r33 1577 -#define _SWAP_FAST_r01 1578 -#define _SWAP_FAST_r11 1579 -#define _SWAP_FAST_r22 1580 -#define _SWAP_FAST_r33 1581 -#define _SWAP_FAST_0_r01 1582 -#define _SWAP_FAST_0_r11 1583 -#define _SWAP_FAST_0_r22 1584 -#define _SWAP_FAST_0_r33 1585 -#define _SWAP_FAST_1_r01 1586 -#define _SWAP_FAST_1_r11 1587 -#define _SWAP_FAST_1_r22 1588 -#define _SWAP_FAST_1_r33 1589 -#define _SWAP_FAST_2_r01 1590 -#define _SWAP_FAST_2_r11 1591 -#define _SWAP_FAST_2_r22 1592 -#define _SWAP_FAST_2_r33 1593 -#define _SWAP_FAST_3_r01 1594 -#define _SWAP_FAST_3_r11 1595 -#define _SWAP_FAST_3_r22 1596 -#define _SWAP_FAST_3_r33 1597 -#define _SWAP_FAST_4_r01 1598 -#define _SWAP_FAST_4_r11 1599 -#define _SWAP_FAST_4_r22 1600 -#define _SWAP_FAST_4_r33 1601 -#define _SWAP_FAST_5_r01 1602 -#define _SWAP_FAST_5_r11 1603 -#define _SWAP_FAST_5_r22 1604 -#define _SWAP_FAST_5_r33 1605 -#define _SWAP_FAST_6_r01 1606 -#define _SWAP_FAST_6_r11 1607 -#define _SWAP_FAST_6_r22 1608 -#define _SWAP_FAST_6_r33 1609 -#define _SWAP_FAST_7_r01 1610 -#define _SWAP_FAST_7_r11 1611 -#define _SWAP_FAST_7_r22 1612 -#define _SWAP_FAST_7_r33 1613 -#define _TIER2_RESUME_CHECK_r00 1614 -#define _TIER2_RESUME_CHECK_r11 1615 -#define _TIER2_RESUME_CHECK_r22 1616 -#define _TIER2_RESUME_CHECK_r33 1617 -#define _TO_BOOL_r11 1618 -#define _TO_BOOL_BOOL_r01 1619 -#define _TO_BOOL_BOOL_r11 1620 -#define _TO_BOOL_BOOL_r22 1621 -#define _TO_BOOL_BOOL_r33 1622 -#define _TO_BOOL_INT_r02 1623 -#define _TO_BOOL_INT_r12 1624 -#define _TO_BOOL_INT_r23 1625 -#define _TO_BOOL_LIST_r02 1626 -#define _TO_BOOL_LIST_r12 1627 -#define _TO_BOOL_LIST_r23 1628 -#define _TO_BOOL_NONE_r01 1629 -#define _TO_BOOL_NONE_r11 1630 -#define _TO_BOOL_NONE_r22 1631 -#define _TO_BOOL_NONE_r33 1632 -#define _TO_BOOL_STR_r02 1633 -#define _TO_BOOL_STR_r12 1634 -#define _TO_BOOL_STR_r23 1635 -#define _TRACE_RECORD_r00 1636 -#define _UNARY_INVERT_r12 1637 -#define _UNARY_NEGATIVE_r12 1638 -#define _UNARY_NEGATIVE_FLOAT_INPLACE_r02 1639 -#define _UNARY_NEGATIVE_FLOAT_INPLACE_r12 1640 -#define _UNARY_NEGATIVE_FLOAT_INPLACE_r23 1641 -#define _UNARY_NOT_r01 1642 -#define _UNARY_NOT_r11 1643 -#define _UNARY_NOT_r22 1644 -#define _UNARY_NOT_r33 1645 -#define _UNPACK_EX_r10 1646 -#define _UNPACK_SEQUENCE_r10 1647 -#define _UNPACK_SEQUENCE_LIST_r10 1648 -#define _UNPACK_SEQUENCE_TUPLE_r10 1649 -#define _UNPACK_SEQUENCE_TWO_TUPLE_r12 1650 -#define _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE_r03 1651 -#define _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE_r13 1652 -#define _UNPACK_SEQUENCE_UNIQUE_TUPLE_r10 1653 -#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r02 1654 -#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r12 1655 -#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r23 1656 -#define _WITH_EXCEPT_START_r33 1657 -#define _YIELD_VALUE_r11 1658 -#define MAX_UOP_REGS_ID 1658 +#define _YIELD_VALUE 657 +#define MAX_UOP_ID 657 +#define _ALLOCATE_OBJECT_r00 658 +#define _BINARY_OP_r23 659 +#define _BINARY_OP_ADD_FLOAT_r03 660 +#define _BINARY_OP_ADD_FLOAT_r13 661 +#define _BINARY_OP_ADD_FLOAT_r23 662 +#define _BINARY_OP_ADD_FLOAT_INPLACE_r03 663 +#define _BINARY_OP_ADD_FLOAT_INPLACE_r13 664 +#define _BINARY_OP_ADD_FLOAT_INPLACE_r23 665 +#define _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT_r03 666 +#define _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT_r13 667 +#define _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT_r23 668 +#define _BINARY_OP_ADD_INT_r03 669 +#define _BINARY_OP_ADD_INT_r13 670 +#define _BINARY_OP_ADD_INT_r23 671 +#define _BINARY_OP_ADD_INT_INPLACE_r03 672 +#define _BINARY_OP_ADD_INT_INPLACE_r13 673 +#define _BINARY_OP_ADD_INT_INPLACE_r23 674 +#define _BINARY_OP_ADD_INT_INPLACE_RIGHT_r03 675 +#define _BINARY_OP_ADD_INT_INPLACE_RIGHT_r13 676 +#define _BINARY_OP_ADD_INT_INPLACE_RIGHT_r23 677 +#define _BINARY_OP_ADD_UNICODE_r03 678 +#define _BINARY_OP_ADD_UNICODE_r13 679 +#define _BINARY_OP_ADD_UNICODE_r23 680 +#define _BINARY_OP_EXTEND_r23 681 +#define _BINARY_OP_INPLACE_ADD_UNICODE_r21 682 +#define _BINARY_OP_MULTIPLY_FLOAT_r03 683 +#define _BINARY_OP_MULTIPLY_FLOAT_r13 684 +#define _BINARY_OP_MULTIPLY_FLOAT_r23 685 +#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_r03 686 +#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_r13 687 +#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_r23 688 +#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT_r03 689 +#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT_r13 690 +#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT_r23 691 +#define _BINARY_OP_MULTIPLY_INT_r03 692 +#define _BINARY_OP_MULTIPLY_INT_r13 693 +#define _BINARY_OP_MULTIPLY_INT_r23 694 +#define _BINARY_OP_MULTIPLY_INT_INPLACE_r03 695 +#define _BINARY_OP_MULTIPLY_INT_INPLACE_r13 696 +#define _BINARY_OP_MULTIPLY_INT_INPLACE_r23 697 +#define _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT_r03 698 +#define _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT_r13 699 +#define _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT_r23 700 +#define _BINARY_OP_SUBSCR_CHECK_FUNC_r23 701 +#define _BINARY_OP_SUBSCR_DICT_r23 702 +#define _BINARY_OP_SUBSCR_DICT_KNOWN_HASH_r23 703 +#define _BINARY_OP_SUBSCR_INIT_CALL_r01 704 +#define _BINARY_OP_SUBSCR_INIT_CALL_r11 705 +#define _BINARY_OP_SUBSCR_INIT_CALL_r21 706 +#define _BINARY_OP_SUBSCR_INIT_CALL_r31 707 +#define _BINARY_OP_SUBSCR_LIST_INT_r23 708 +#define _BINARY_OP_SUBSCR_LIST_SLICE_r23 709 +#define _BINARY_OP_SUBSCR_STR_INT_r23 710 +#define _BINARY_OP_SUBSCR_TUPLE_INT_r03 711 +#define _BINARY_OP_SUBSCR_TUPLE_INT_r13 712 +#define _BINARY_OP_SUBSCR_TUPLE_INT_r23 713 +#define _BINARY_OP_SUBSCR_USTR_INT_r23 714 +#define _BINARY_OP_SUBTRACT_FLOAT_r03 715 +#define _BINARY_OP_SUBTRACT_FLOAT_r13 716 +#define _BINARY_OP_SUBTRACT_FLOAT_r23 717 +#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_r03 718 +#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_r13 719 +#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_r23 720 +#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT_r03 721 +#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT_r13 722 +#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT_r23 723 +#define _BINARY_OP_SUBTRACT_INT_r03 724 +#define _BINARY_OP_SUBTRACT_INT_r13 725 +#define _BINARY_OP_SUBTRACT_INT_r23 726 +#define _BINARY_OP_SUBTRACT_INT_INPLACE_r03 727 +#define _BINARY_OP_SUBTRACT_INT_INPLACE_r13 728 +#define _BINARY_OP_SUBTRACT_INT_INPLACE_r23 729 +#define _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT_r03 730 +#define _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT_r13 731 +#define _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT_r23 732 +#define _BINARY_OP_TRUEDIV_FLOAT_r23 733 +#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_r03 734 +#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_r13 735 +#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_r23 736 +#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r03 737 +#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r13 738 +#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r23 739 +#define _BINARY_SLICE_r31 740 +#define _BUILD_INTERPOLATION_r01 741 +#define _BUILD_LIST_r01 742 +#define _BUILD_MAP_r01 743 +#define _BUILD_SET_r01 744 +#define _BUILD_SLICE_r01 745 +#define _BUILD_STRING_r01 746 +#define _BUILD_TEMPLATE_r21 747 +#define _BUILD_TUPLE_r01 748 +#define _CALL_BUILTIN_CLASS_r00 749 +#define _CALL_BUILTIN_FAST_r00 750 +#define _CALL_BUILTIN_FAST_WITH_KEYWORDS_r00 751 +#define _CALL_BUILTIN_O_r03 752 +#define _CALL_FUNCTION_EX_NON_PY_GENERAL_r31 753 +#define _CALL_INTRINSIC_1_r12 754 +#define _CALL_INTRINSIC_2_r23 755 +#define _CALL_ISINSTANCE_r31 756 +#define _CALL_KW_NON_PY_r11 757 +#define _CALL_LEN_r33 758 +#define _CALL_LIST_APPEND_r03 759 +#define _CALL_LIST_APPEND_r13 760 +#define _CALL_LIST_APPEND_r23 761 +#define _CALL_LIST_APPEND_r33 762 +#define _CALL_METHOD_DESCRIPTOR_FAST_r00 763 +#define _CALL_METHOD_DESCRIPTOR_FAST_INLINE_r00 764 +#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r00 765 +#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_INLINE_r00 766 +#define _CALL_METHOD_DESCRIPTOR_NOARGS_r03 767 +#define _CALL_METHOD_DESCRIPTOR_NOARGS_INLINE_r03 768 +#define _CALL_METHOD_DESCRIPTOR_O_r03 769 +#define _CALL_METHOD_DESCRIPTOR_O_INLINE_r03 770 +#define _CALL_NON_PY_GENERAL_r01 771 +#define _CALL_STR_1_r32 772 +#define _CALL_TUPLE_1_r32 773 +#define _CALL_TYPE_1_r02 774 +#define _CALL_TYPE_1_r12 775 +#define _CALL_TYPE_1_r22 776 +#define _CALL_TYPE_1_r32 777 +#define _CHECK_ATTR_CLASS_r01 778 +#define _CHECK_ATTR_CLASS_r11 779 +#define _CHECK_ATTR_CLASS_r22 780 +#define _CHECK_ATTR_CLASS_r33 781 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r01 782 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r11 783 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r22 784 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r33 785 +#define _CHECK_CALL_BOUND_METHOD_EXACT_ARGS_r00 786 +#define _CHECK_EG_MATCH_r22 787 +#define _CHECK_EXC_MATCH_r22 788 +#define _CHECK_FUNCTION_EXACT_ARGS_r00 789 +#define _CHECK_FUNCTION_VERSION_r00 790 +#define _CHECK_FUNCTION_VERSION_INLINE_r00 791 +#define _CHECK_FUNCTION_VERSION_INLINE_r11 792 +#define _CHECK_FUNCTION_VERSION_INLINE_r22 793 +#define _CHECK_FUNCTION_VERSION_INLINE_r33 794 +#define _CHECK_FUNCTION_VERSION_KW_r11 795 +#define _CHECK_IS_NOT_PY_CALLABLE_r00 796 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r03 797 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r13 798 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r23 799 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r33 800 +#define _CHECK_IS_NOT_PY_CALLABLE_KW_r11 801 +#define _CHECK_IS_PY_CALLABLE_EX_r03 802 +#define _CHECK_IS_PY_CALLABLE_EX_r13 803 +#define _CHECK_IS_PY_CALLABLE_EX_r23 804 +#define _CHECK_IS_PY_CALLABLE_EX_r33 805 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r01 806 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r11 807 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r22 808 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r33 809 +#define _CHECK_METHOD_VERSION_r00 810 +#define _CHECK_METHOD_VERSION_KW_r11 811 +#define _CHECK_OBJECT_r00 812 +#define _CHECK_PEP_523_r00 813 +#define _CHECK_PEP_523_r11 814 +#define _CHECK_PEP_523_r22 815 +#define _CHECK_PEP_523_r33 816 +#define _CHECK_PERIODIC_r00 817 +#define _CHECK_PERIODIC_AT_END_r00 818 +#define _CHECK_PERIODIC_IF_NOT_YIELD_FROM_r00 819 +#define _CHECK_RECURSION_LIMIT_r00 820 +#define _CHECK_RECURSION_LIMIT_r11 821 +#define _CHECK_RECURSION_LIMIT_r22 822 +#define _CHECK_RECURSION_LIMIT_r33 823 +#define _CHECK_RECURSION_REMAINING_r00 824 +#define _CHECK_RECURSION_REMAINING_r11 825 +#define _CHECK_RECURSION_REMAINING_r22 826 +#define _CHECK_RECURSION_REMAINING_r33 827 +#define _CHECK_STACK_SPACE_r00 828 +#define _CHECK_STACK_SPACE_OPERAND_r00 829 +#define _CHECK_STACK_SPACE_OPERAND_r11 830 +#define _CHECK_STACK_SPACE_OPERAND_r22 831 +#define _CHECK_STACK_SPACE_OPERAND_r33 832 +#define _CHECK_VALIDITY_r00 833 +#define _CHECK_VALIDITY_r11 834 +#define _CHECK_VALIDITY_r22 835 +#define _CHECK_VALIDITY_r33 836 +#define _COLD_DYNAMIC_EXIT_r00 837 +#define _COLD_EXIT_r00 838 +#define _COMPARE_OP_r21 839 +#define _COMPARE_OP_FLOAT_r03 840 +#define _COMPARE_OP_FLOAT_r13 841 +#define _COMPARE_OP_FLOAT_r23 842 +#define _COMPARE_OP_INT_r23 843 +#define _COMPARE_OP_STR_r23 844 +#define _CONTAINS_OP_r23 845 +#define _CONTAINS_OP_DICT_r23 846 +#define _CONTAINS_OP_SET_r23 847 +#define _CONVERT_VALUE_r11 848 +#define _COPY_r01 849 +#define _COPY_1_r02 850 +#define _COPY_1_r12 851 +#define _COPY_1_r23 852 +#define _COPY_2_r03 853 +#define _COPY_2_r13 854 +#define _COPY_2_r23 855 +#define _COPY_3_r03 856 +#define _COPY_3_r13 857 +#define _COPY_3_r23 858 +#define _COPY_3_r33 859 +#define _COPY_FREE_VARS_r00 860 +#define _COPY_FREE_VARS_r11 861 +#define _COPY_FREE_VARS_r22 862 +#define _COPY_FREE_VARS_r33 863 +#define _CREATE_INIT_FRAME_r01 864 +#define _DELETE_ATTR_r10 865 +#define _DELETE_DEREF_r00 866 +#define _DELETE_FAST_r00 867 +#define _DELETE_GLOBAL_r00 868 +#define _DELETE_NAME_r00 869 +#define _DELETE_SUBSCR_r20 870 +#define _DEOPT_r00 871 +#define _DEOPT_r10 872 +#define _DEOPT_r20 873 +#define _DEOPT_r30 874 +#define _DICT_MERGE_r11 875 +#define _DICT_UPDATE_r11 876 +#define _DO_CALL_r01 877 +#define _DO_CALL_FUNCTION_EX_r31 878 +#define _DO_CALL_KW_r11 879 +#define _DYNAMIC_EXIT_r00 880 +#define _DYNAMIC_EXIT_r10 881 +#define _DYNAMIC_EXIT_r20 882 +#define _DYNAMIC_EXIT_r30 883 +#define _END_FOR_r10 884 +#define _END_SEND_r31 885 +#define _ERROR_POP_N_r00 886 +#define _EXIT_INIT_CHECK_r10 887 +#define _EXIT_TRACE_r00 888 +#define _EXIT_TRACE_r10 889 +#define _EXIT_TRACE_r20 890 +#define _EXIT_TRACE_r30 891 +#define _EXPAND_METHOD_r00 892 +#define _EXPAND_METHOD_KW_r11 893 +#define _FATAL_ERROR_r00 894 +#define _FATAL_ERROR_r11 895 +#define _FATAL_ERROR_r22 896 +#define _FATAL_ERROR_r33 897 +#define _FORMAT_SIMPLE_r11 898 +#define _FORMAT_WITH_SPEC_r21 899 +#define _FOR_ITER_r23 900 +#define _FOR_ITER_GEN_FRAME_r03 901 +#define _FOR_ITER_GEN_FRAME_r13 902 +#define _FOR_ITER_GEN_FRAME_r23 903 +#define _FOR_ITER_TIER_TWO_r23 904 +#define _FOR_ITER_VIRTUAL_r23 905 +#define _FOR_ITER_VIRTUAL_TIER_TWO_r23 906 +#define _GET_AITER_r11 907 +#define _GET_ANEXT_r12 908 +#define _GET_AWAITABLE_r11 909 +#define _GET_ITER_r12 910 +#define _GET_ITER_TRAD_r12 911 +#define _GET_LEN_r12 912 +#define _GUARD_3OS_ASYNC_GEN_ASEND_r03 913 +#define _GUARD_3OS_ASYNC_GEN_ASEND_r13 914 +#define _GUARD_3OS_ASYNC_GEN_ASEND_r23 915 +#define _GUARD_3OS_ASYNC_GEN_ASEND_r33 916 +#define _GUARD_BINARY_OP_EXTEND_r22 917 +#define _GUARD_BINARY_OP_EXTEND_LHS_r02 918 +#define _GUARD_BINARY_OP_EXTEND_LHS_r12 919 +#define _GUARD_BINARY_OP_EXTEND_LHS_r22 920 +#define _GUARD_BINARY_OP_EXTEND_LHS_r33 921 +#define _GUARD_BINARY_OP_EXTEND_RHS_r02 922 +#define _GUARD_BINARY_OP_EXTEND_RHS_r12 923 +#define _GUARD_BINARY_OP_EXTEND_RHS_r22 924 +#define _GUARD_BINARY_OP_EXTEND_RHS_r33 925 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r02 926 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r12 927 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r22 928 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r33 929 +#define _GUARD_BIT_IS_SET_POP_r00 930 +#define _GUARD_BIT_IS_SET_POP_r10 931 +#define _GUARD_BIT_IS_SET_POP_r21 932 +#define _GUARD_BIT_IS_SET_POP_r32 933 +#define _GUARD_BIT_IS_SET_POP_4_r00 934 +#define _GUARD_BIT_IS_SET_POP_4_r10 935 +#define _GUARD_BIT_IS_SET_POP_4_r21 936 +#define _GUARD_BIT_IS_SET_POP_4_r32 937 +#define _GUARD_BIT_IS_SET_POP_5_r00 938 +#define _GUARD_BIT_IS_SET_POP_5_r10 939 +#define _GUARD_BIT_IS_SET_POP_5_r21 940 +#define _GUARD_BIT_IS_SET_POP_5_r32 941 +#define _GUARD_BIT_IS_SET_POP_6_r00 942 +#define _GUARD_BIT_IS_SET_POP_6_r10 943 +#define _GUARD_BIT_IS_SET_POP_6_r21 944 +#define _GUARD_BIT_IS_SET_POP_6_r32 945 +#define _GUARD_BIT_IS_SET_POP_7_r00 946 +#define _GUARD_BIT_IS_SET_POP_7_r10 947 +#define _GUARD_BIT_IS_SET_POP_7_r21 948 +#define _GUARD_BIT_IS_SET_POP_7_r32 949 +#define _GUARD_BIT_IS_UNSET_POP_r00 950 +#define _GUARD_BIT_IS_UNSET_POP_r10 951 +#define _GUARD_BIT_IS_UNSET_POP_r21 952 +#define _GUARD_BIT_IS_UNSET_POP_r32 953 +#define _GUARD_BIT_IS_UNSET_POP_4_r00 954 +#define _GUARD_BIT_IS_UNSET_POP_4_r10 955 +#define _GUARD_BIT_IS_UNSET_POP_4_r21 956 +#define _GUARD_BIT_IS_UNSET_POP_4_r32 957 +#define _GUARD_BIT_IS_UNSET_POP_5_r00 958 +#define _GUARD_BIT_IS_UNSET_POP_5_r10 959 +#define _GUARD_BIT_IS_UNSET_POP_5_r21 960 +#define _GUARD_BIT_IS_UNSET_POP_5_r32 961 +#define _GUARD_BIT_IS_UNSET_POP_6_r00 962 +#define _GUARD_BIT_IS_UNSET_POP_6_r10 963 +#define _GUARD_BIT_IS_UNSET_POP_6_r21 964 +#define _GUARD_BIT_IS_UNSET_POP_6_r32 965 +#define _GUARD_BIT_IS_UNSET_POP_7_r00 966 +#define _GUARD_BIT_IS_UNSET_POP_7_r10 967 +#define _GUARD_BIT_IS_UNSET_POP_7_r21 968 +#define _GUARD_BIT_IS_UNSET_POP_7_r32 969 +#define _GUARD_CALLABLE_BUILTIN_CLASS_r00 970 +#define _GUARD_CALLABLE_BUILTIN_FAST_r00 971 +#define _GUARD_CALLABLE_BUILTIN_FAST_WITH_KEYWORDS_r00 972 +#define _GUARD_CALLABLE_BUILTIN_O_r00 973 +#define _GUARD_CALLABLE_ISINSTANCE_r03 974 +#define _GUARD_CALLABLE_ISINSTANCE_r13 975 +#define _GUARD_CALLABLE_ISINSTANCE_r23 976 +#define _GUARD_CALLABLE_ISINSTANCE_r33 977 +#define _GUARD_CALLABLE_LEN_r03 978 +#define _GUARD_CALLABLE_LEN_r13 979 +#define _GUARD_CALLABLE_LEN_r23 980 +#define _GUARD_CALLABLE_LEN_r33 981 +#define _GUARD_CALLABLE_LIST_APPEND_r03 982 +#define _GUARD_CALLABLE_LIST_APPEND_r13 983 +#define _GUARD_CALLABLE_LIST_APPEND_r23 984 +#define _GUARD_CALLABLE_LIST_APPEND_r33 985 +#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST_r00 986 +#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r00 987 +#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_NOARGS_r00 988 +#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_O_r00 989 +#define _GUARD_CALLABLE_STR_1_r03 990 +#define _GUARD_CALLABLE_STR_1_r13 991 +#define _GUARD_CALLABLE_STR_1_r23 992 +#define _GUARD_CALLABLE_STR_1_r33 993 +#define _GUARD_CALLABLE_TUPLE_1_r03 994 +#define _GUARD_CALLABLE_TUPLE_1_r13 995 +#define _GUARD_CALLABLE_TUPLE_1_r23 996 +#define _GUARD_CALLABLE_TUPLE_1_r33 997 +#define _GUARD_CALLABLE_TYPE_1_r03 998 +#define _GUARD_CALLABLE_TYPE_1_r13 999 +#define _GUARD_CALLABLE_TYPE_1_r23 1000 +#define _GUARD_CALLABLE_TYPE_1_r33 1001 +#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r00 1002 +#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r11 1003 +#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r22 1004 +#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r33 1005 +#define _GUARD_CODE_VERSION_RETURN_VALUE_r00 1006 +#define _GUARD_CODE_VERSION_RETURN_VALUE_r11 1007 +#define _GUARD_CODE_VERSION_RETURN_VALUE_r22 1008 +#define _GUARD_CODE_VERSION_RETURN_VALUE_r33 1009 +#define _GUARD_CODE_VERSION_YIELD_VALUE_r00 1010 +#define _GUARD_CODE_VERSION_YIELD_VALUE_r11 1011 +#define _GUARD_CODE_VERSION_YIELD_VALUE_r22 1012 +#define _GUARD_CODE_VERSION_YIELD_VALUE_r33 1013 +#define _GUARD_CODE_VERSION__PUSH_FRAME_r00 1014 +#define _GUARD_CODE_VERSION__PUSH_FRAME_r11 1015 +#define _GUARD_CODE_VERSION__PUSH_FRAME_r22 1016 +#define _GUARD_CODE_VERSION__PUSH_FRAME_r33 1017 +#define _GUARD_DORV_NO_DICT_r01 1018 +#define _GUARD_DORV_NO_DICT_r11 1019 +#define _GUARD_DORV_NO_DICT_r22 1020 +#define _GUARD_DORV_NO_DICT_r33 1021 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r01 1022 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r11 1023 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r22 1024 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r33 1025 +#define _GUARD_GLOBALS_VERSION_r00 1026 +#define _GUARD_GLOBALS_VERSION_r11 1027 +#define _GUARD_GLOBALS_VERSION_r22 1028 +#define _GUARD_GLOBALS_VERSION_r33 1029 +#define _GUARD_IP_RETURN_GENERATOR_r00 1030 +#define _GUARD_IP_RETURN_GENERATOR_r11 1031 +#define _GUARD_IP_RETURN_GENERATOR_r22 1032 +#define _GUARD_IP_RETURN_GENERATOR_r33 1033 +#define _GUARD_IP_RETURN_VALUE_r00 1034 +#define _GUARD_IP_RETURN_VALUE_r11 1035 +#define _GUARD_IP_RETURN_VALUE_r22 1036 +#define _GUARD_IP_RETURN_VALUE_r33 1037 +#define _GUARD_IP_YIELD_VALUE_r00 1038 +#define _GUARD_IP_YIELD_VALUE_r11 1039 +#define _GUARD_IP_YIELD_VALUE_r22 1040 +#define _GUARD_IP_YIELD_VALUE_r33 1041 +#define _GUARD_IP__PUSH_FRAME_r00 1042 +#define _GUARD_IP__PUSH_FRAME_r11 1043 +#define _GUARD_IP__PUSH_FRAME_r22 1044 +#define _GUARD_IP__PUSH_FRAME_r33 1045 +#define _GUARD_IS_FALSE_POP_r00 1046 +#define _GUARD_IS_FALSE_POP_r10 1047 +#define _GUARD_IS_FALSE_POP_r21 1048 +#define _GUARD_IS_FALSE_POP_r32 1049 +#define _GUARD_IS_NONE_KEEP_r01 1050 +#define _GUARD_IS_NONE_KEEP_r11 1051 +#define _GUARD_IS_NONE_KEEP_r22 1052 +#define _GUARD_IS_NONE_KEEP_r33 1053 +#define _GUARD_IS_NONE_POP_r00 1054 +#define _GUARD_IS_NONE_POP_r10 1055 +#define _GUARD_IS_NONE_POP_r21 1056 +#define _GUARD_IS_NONE_POP_r32 1057 +#define _GUARD_IS_NOT_NONE_KEEP_r01 1058 +#define _GUARD_IS_NOT_NONE_KEEP_r11 1059 +#define _GUARD_IS_NOT_NONE_KEEP_r22 1060 +#define _GUARD_IS_NOT_NONE_KEEP_r33 1061 +#define _GUARD_IS_NOT_NONE_POP_r10 1062 +#define _GUARD_IS_TRUE_POP_r00 1063 +#define _GUARD_IS_TRUE_POP_r10 1064 +#define _GUARD_IS_TRUE_POP_r21 1065 +#define _GUARD_IS_TRUE_POP_r32 1066 +#define _GUARD_ITERATOR_r01 1067 +#define _GUARD_ITERATOR_r11 1068 +#define _GUARD_ITERATOR_r22 1069 +#define _GUARD_ITERATOR_r33 1070 +#define _GUARD_ITER_VIRTUAL_r01 1071 +#define _GUARD_ITER_VIRTUAL_r11 1072 +#define _GUARD_ITER_VIRTUAL_r22 1073 +#define _GUARD_ITER_VIRTUAL_r33 1074 +#define _GUARD_KEYS_VERSION_r01 1075 +#define _GUARD_KEYS_VERSION_r11 1076 +#define _GUARD_KEYS_VERSION_r22 1077 +#define _GUARD_KEYS_VERSION_r33 1078 +#define _GUARD_LOAD_SUPER_ATTR_METHOD_r03 1079 +#define _GUARD_LOAD_SUPER_ATTR_METHOD_r13 1080 +#define _GUARD_LOAD_SUPER_ATTR_METHOD_r23 1081 +#define _GUARD_LOAD_SUPER_ATTR_METHOD_r33 1082 +#define _GUARD_NOS_COMPACT_ASCII_r02 1083 +#define _GUARD_NOS_COMPACT_ASCII_r12 1084 +#define _GUARD_NOS_COMPACT_ASCII_r22 1085 +#define _GUARD_NOS_COMPACT_ASCII_r33 1086 +#define _GUARD_NOS_DICT_STORE_SUBSCRIPT_r03 1087 +#define _GUARD_NOS_DICT_STORE_SUBSCRIPT_r13 1088 +#define _GUARD_NOS_DICT_STORE_SUBSCRIPT_r23 1089 +#define _GUARD_NOS_DICT_STORE_SUBSCRIPT_r33 1090 +#define _GUARD_NOS_DICT_SUBSCRIPT_r02 1091 +#define _GUARD_NOS_DICT_SUBSCRIPT_r12 1092 +#define _GUARD_NOS_DICT_SUBSCRIPT_r22 1093 +#define _GUARD_NOS_DICT_SUBSCRIPT_r33 1094 +#define _GUARD_NOS_FLOAT_r02 1095 +#define _GUARD_NOS_FLOAT_r12 1096 +#define _GUARD_NOS_FLOAT_r22 1097 +#define _GUARD_NOS_FLOAT_r33 1098 +#define _GUARD_NOS_INT_r02 1099 +#define _GUARD_NOS_INT_r12 1100 +#define _GUARD_NOS_INT_r22 1101 +#define _GUARD_NOS_INT_r33 1102 +#define _GUARD_NOS_ITER_VIRTUAL_r02 1103 +#define _GUARD_NOS_ITER_VIRTUAL_r12 1104 +#define _GUARD_NOS_ITER_VIRTUAL_r22 1105 +#define _GUARD_NOS_ITER_VIRTUAL_r33 1106 +#define _GUARD_NOS_LIST_r02 1107 +#define _GUARD_NOS_LIST_r12 1108 +#define _GUARD_NOS_LIST_r22 1109 +#define _GUARD_NOS_LIST_r33 1110 +#define _GUARD_NOS_NOT_NULL_r02 1111 +#define _GUARD_NOS_NOT_NULL_r12 1112 +#define _GUARD_NOS_NOT_NULL_r22 1113 +#define _GUARD_NOS_NOT_NULL_r33 1114 +#define _GUARD_NOS_NULL_r02 1115 +#define _GUARD_NOS_NULL_r12 1116 +#define _GUARD_NOS_NULL_r22 1117 +#define _GUARD_NOS_NULL_r33 1118 +#define _GUARD_NOS_OVERFLOWED_r02 1119 +#define _GUARD_NOS_OVERFLOWED_r12 1120 +#define _GUARD_NOS_OVERFLOWED_r22 1121 +#define _GUARD_NOS_OVERFLOWED_r33 1122 +#define _GUARD_NOS_TUPLE_r02 1123 +#define _GUARD_NOS_TUPLE_r12 1124 +#define _GUARD_NOS_TUPLE_r22 1125 +#define _GUARD_NOS_TUPLE_r33 1126 +#define _GUARD_NOS_TYPE_VERSION_r02 1127 +#define _GUARD_NOS_TYPE_VERSION_r12 1128 +#define _GUARD_NOS_TYPE_VERSION_r22 1129 +#define _GUARD_NOS_TYPE_VERSION_r33 1130 +#define _GUARD_NOS_UNICODE_r02 1131 +#define _GUARD_NOS_UNICODE_r12 1132 +#define _GUARD_NOS_UNICODE_r22 1133 +#define _GUARD_NOS_UNICODE_r33 1134 +#define _GUARD_NOT_EXHAUSTED_LIST_r02 1135 +#define _GUARD_NOT_EXHAUSTED_LIST_r12 1136 +#define _GUARD_NOT_EXHAUSTED_LIST_r22 1137 +#define _GUARD_NOT_EXHAUSTED_LIST_r33 1138 +#define _GUARD_NOT_EXHAUSTED_RANGE_r02 1139 +#define _GUARD_NOT_EXHAUSTED_RANGE_r12 1140 +#define _GUARD_NOT_EXHAUSTED_RANGE_r22 1141 +#define _GUARD_NOT_EXHAUSTED_RANGE_r33 1142 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r02 1143 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r12 1144 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r22 1145 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r33 1146 +#define _GUARD_THIRD_NULL_r03 1147 +#define _GUARD_THIRD_NULL_r13 1148 +#define _GUARD_THIRD_NULL_r23 1149 +#define _GUARD_THIRD_NULL_r33 1150 +#define _GUARD_TOS_ANY_DICT_r01 1151 +#define _GUARD_TOS_ANY_DICT_r11 1152 +#define _GUARD_TOS_ANY_DICT_r22 1153 +#define _GUARD_TOS_ANY_DICT_r33 1154 +#define _GUARD_TOS_ANY_SET_r01 1155 +#define _GUARD_TOS_ANY_SET_r11 1156 +#define _GUARD_TOS_ANY_SET_r22 1157 +#define _GUARD_TOS_ANY_SET_r33 1158 +#define _GUARD_TOS_DICT_r01 1159 +#define _GUARD_TOS_DICT_r11 1160 +#define _GUARD_TOS_DICT_r22 1161 +#define _GUARD_TOS_DICT_r33 1162 +#define _GUARD_TOS_FLOAT_r01 1163 +#define _GUARD_TOS_FLOAT_r11 1164 +#define _GUARD_TOS_FLOAT_r22 1165 +#define _GUARD_TOS_FLOAT_r33 1166 +#define _GUARD_TOS_FROZENDICT_r01 1167 +#define _GUARD_TOS_FROZENDICT_r11 1168 +#define _GUARD_TOS_FROZENDICT_r22 1169 +#define _GUARD_TOS_FROZENDICT_r33 1170 +#define _GUARD_TOS_FROZENSET_r01 1171 +#define _GUARD_TOS_FROZENSET_r11 1172 +#define _GUARD_TOS_FROZENSET_r22 1173 +#define _GUARD_TOS_FROZENSET_r33 1174 +#define _GUARD_TOS_INT_r01 1175 +#define _GUARD_TOS_INT_r11 1176 +#define _GUARD_TOS_INT_r22 1177 +#define _GUARD_TOS_INT_r33 1178 +#define _GUARD_TOS_IS_NONE_r01 1179 +#define _GUARD_TOS_IS_NONE_r11 1180 +#define _GUARD_TOS_IS_NONE_r22 1181 +#define _GUARD_TOS_IS_NONE_r33 1182 +#define _GUARD_TOS_LIST_r01 1183 +#define _GUARD_TOS_LIST_r11 1184 +#define _GUARD_TOS_LIST_r22 1185 +#define _GUARD_TOS_LIST_r33 1186 +#define _GUARD_TOS_NOT_NULL_r01 1187 +#define _GUARD_TOS_NOT_NULL_r11 1188 +#define _GUARD_TOS_NOT_NULL_r22 1189 +#define _GUARD_TOS_NOT_NULL_r33 1190 +#define _GUARD_TOS_OVERFLOWED_r01 1191 +#define _GUARD_TOS_OVERFLOWED_r11 1192 +#define _GUARD_TOS_OVERFLOWED_r22 1193 +#define _GUARD_TOS_OVERFLOWED_r33 1194 +#define _GUARD_TOS_SET_r01 1195 +#define _GUARD_TOS_SET_r11 1196 +#define _GUARD_TOS_SET_r22 1197 +#define _GUARD_TOS_SET_r33 1198 +#define _GUARD_TOS_SLICE_r01 1199 +#define _GUARD_TOS_SLICE_r11 1200 +#define _GUARD_TOS_SLICE_r22 1201 +#define _GUARD_TOS_SLICE_r33 1202 +#define _GUARD_TOS_TUPLE_r01 1203 +#define _GUARD_TOS_TUPLE_r11 1204 +#define _GUARD_TOS_TUPLE_r22 1205 +#define _GUARD_TOS_TUPLE_r33 1206 +#define _GUARD_TOS_UNICODE_r01 1207 +#define _GUARD_TOS_UNICODE_r11 1208 +#define _GUARD_TOS_UNICODE_r22 1209 +#define _GUARD_TOS_UNICODE_r33 1210 +#define _GUARD_TYPE_r01 1211 +#define _GUARD_TYPE_r11 1212 +#define _GUARD_TYPE_r22 1213 +#define _GUARD_TYPE_r33 1214 +#define _GUARD_TYPE_ITER_r02 1215 +#define _GUARD_TYPE_ITER_r12 1216 +#define _GUARD_TYPE_ITER_r22 1217 +#define _GUARD_TYPE_ITER_r33 1218 +#define _GUARD_TYPE_VERSION_r01 1219 +#define _GUARD_TYPE_VERSION_r11 1220 +#define _GUARD_TYPE_VERSION_r22 1221 +#define _GUARD_TYPE_VERSION_r33 1222 +#define _GUARD_TYPE_VERSION_LOCKED_r01 1223 +#define _GUARD_TYPE_VERSION_LOCKED_r11 1224 +#define _GUARD_TYPE_VERSION_LOCKED_r22 1225 +#define _GUARD_TYPE_VERSION_LOCKED_r33 1226 +#define _HANDLE_PENDING_AND_DEOPT_r00 1227 +#define _HANDLE_PENDING_AND_DEOPT_r10 1228 +#define _HANDLE_PENDING_AND_DEOPT_r20 1229 +#define _HANDLE_PENDING_AND_DEOPT_r30 1230 +#define _IMPORT_FROM_r12 1231 +#define _IMPORT_NAME_r21 1232 +#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS_r00 1233 +#define _INIT_CALL_PY_EXACT_ARGS_r01 1234 +#define _INIT_CALL_PY_EXACT_ARGS_0_r01 1235 +#define _INIT_CALL_PY_EXACT_ARGS_1_r01 1236 +#define _INIT_CALL_PY_EXACT_ARGS_2_r01 1237 +#define _INIT_CALL_PY_EXACT_ARGS_3_r01 1238 +#define _INIT_CALL_PY_EXACT_ARGS_4_r01 1239 +#define _INSERT_NULL_r10 1240 +#define _INSTRUMENTED_FOR_ITER_r23 1241 +#define _INSTRUMENTED_INSTRUCTION_r00 1242 +#define _INSTRUMENTED_JUMP_FORWARD_r00 1243 +#define _INSTRUMENTED_JUMP_FORWARD_r11 1244 +#define _INSTRUMENTED_JUMP_FORWARD_r22 1245 +#define _INSTRUMENTED_JUMP_FORWARD_r33 1246 +#define _INSTRUMENTED_JUMP_IF_NONE_r01 1247 +#define _INSTRUMENTED_JUMP_IF_NONE_r11 1248 +#define _INSTRUMENTED_JUMP_IF_NONE_r22 1249 +#define _INSTRUMENTED_JUMP_IF_NONE_r33 1250 +#define _INSTRUMENTED_JUMP_IF_NOT_NONE_r01 1251 +#define _INSTRUMENTED_JUMP_IF_NOT_NONE_r11 1252 +#define _INSTRUMENTED_JUMP_IF_NOT_NONE_r22 1253 +#define _INSTRUMENTED_JUMP_IF_NOT_NONE_r33 1254 +#define _INSTRUMENTED_LINE_r00 1255 +#define _INSTRUMENTED_NOT_TAKEN_r00 1256 +#define _INSTRUMENTED_NOT_TAKEN_r11 1257 +#define _INSTRUMENTED_NOT_TAKEN_r22 1258 +#define _INSTRUMENTED_NOT_TAKEN_r33 1259 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r00 1260 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r10 1261 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r21 1262 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r32 1263 +#define _INSTRUMENTED_POP_JUMP_IF_NONE_r10 1264 +#define _INSTRUMENTED_POP_JUMP_IF_NOT_NONE_r10 1265 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r00 1266 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r10 1267 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r21 1268 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r32 1269 +#define _IS_NONE_r11 1270 +#define _IS_NONE_KEEP_r02 1271 +#define _IS_NONE_KEEP_r12 1272 +#define _IS_NONE_KEEP_r23 1273 +#define _IS_OP_r03 1274 +#define _IS_OP_r13 1275 +#define _IS_OP_r23 1276 +#define _ITER_CHECK_LIST_r02 1277 +#define _ITER_CHECK_LIST_r12 1278 +#define _ITER_CHECK_LIST_r22 1279 +#define _ITER_CHECK_LIST_r33 1280 +#define _ITER_CHECK_RANGE_r02 1281 +#define _ITER_CHECK_RANGE_r12 1282 +#define _ITER_CHECK_RANGE_r22 1283 +#define _ITER_CHECK_RANGE_r33 1284 +#define _ITER_CHECK_TUPLE_r02 1285 +#define _ITER_CHECK_TUPLE_r12 1286 +#define _ITER_CHECK_TUPLE_r22 1287 +#define _ITER_CHECK_TUPLE_r33 1288 +#define _ITER_JUMP_LIST_r02 1289 +#define _ITER_JUMP_LIST_r12 1290 +#define _ITER_JUMP_LIST_r22 1291 +#define _ITER_JUMP_LIST_r33 1292 +#define _ITER_JUMP_RANGE_r02 1293 +#define _ITER_JUMP_RANGE_r12 1294 +#define _ITER_JUMP_RANGE_r22 1295 +#define _ITER_JUMP_RANGE_r33 1296 +#define _ITER_JUMP_TUPLE_r02 1297 +#define _ITER_JUMP_TUPLE_r12 1298 +#define _ITER_JUMP_TUPLE_r22 1299 +#define _ITER_JUMP_TUPLE_r33 1300 +#define _ITER_NEXT_INLINE_r23 1301 +#define _ITER_NEXT_LIST_r23 1302 +#define _ITER_NEXT_LIST_TIER_TWO_r23 1303 +#define _ITER_NEXT_RANGE_r03 1304 +#define _ITER_NEXT_RANGE_r13 1305 +#define _ITER_NEXT_RANGE_r23 1306 +#define _ITER_NEXT_TUPLE_r03 1307 +#define _ITER_NEXT_TUPLE_r13 1308 +#define _ITER_NEXT_TUPLE_r23 1309 +#define _JUMP_BACKWARD_NO_INTERRUPT_r00 1310 +#define _JUMP_BACKWARD_NO_INTERRUPT_r11 1311 +#define _JUMP_BACKWARD_NO_INTERRUPT_r22 1312 +#define _JUMP_BACKWARD_NO_INTERRUPT_r33 1313 +#define _JUMP_TO_TOP_r00 1314 +#define _LIST_APPEND_r10 1315 +#define _LIST_EXTEND_r11 1316 +#define _LOAD_ATTR_r10 1317 +#define _LOAD_ATTR_CLASS_r11 1318 +#define _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN_FRAME_r11 1319 +#define _LOAD_ATTR_INSTANCE_VALUE_r02 1320 +#define _LOAD_ATTR_INSTANCE_VALUE_r12 1321 +#define _LOAD_ATTR_INSTANCE_VALUE_r23 1322 +#define _LOAD_ATTR_METHOD_LAZY_DICT_r02 1323 +#define _LOAD_ATTR_METHOD_LAZY_DICT_r12 1324 +#define _LOAD_ATTR_METHOD_LAZY_DICT_r23 1325 +#define _LOAD_ATTR_METHOD_NO_DICT_r02 1326 +#define _LOAD_ATTR_METHOD_NO_DICT_r12 1327 +#define _LOAD_ATTR_METHOD_NO_DICT_r23 1328 +#define _LOAD_ATTR_METHOD_WITH_VALUES_r02 1329 +#define _LOAD_ATTR_METHOD_WITH_VALUES_r12 1330 +#define _LOAD_ATTR_METHOD_WITH_VALUES_r23 1331 +#define _LOAD_ATTR_MODULE_r12 1332 +#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT_r11 1333 +#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES_r11 1334 +#define _LOAD_ATTR_PROPERTY_FRAME_r01 1335 +#define _LOAD_ATTR_PROPERTY_FRAME_r11 1336 +#define _LOAD_ATTR_PROPERTY_FRAME_r22 1337 +#define _LOAD_ATTR_PROPERTY_FRAME_r33 1338 +#define _LOAD_ATTR_SLOT_r02 1339 +#define _LOAD_ATTR_SLOT_r12 1340 +#define _LOAD_ATTR_SLOT_r23 1341 +#define _LOAD_ATTR_WITH_HINT_r12 1342 +#define _LOAD_BUILD_CLASS_r01 1343 +#define _LOAD_BYTECODE_r00 1344 +#define _LOAD_COMMON_CONSTANT_r01 1345 +#define _LOAD_COMMON_CONSTANT_r12 1346 +#define _LOAD_COMMON_CONSTANT_r23 1347 +#define _LOAD_CONST_r01 1348 +#define _LOAD_CONST_r12 1349 +#define _LOAD_CONST_r23 1350 +#define _LOAD_CONST_INLINE_r01 1351 +#define _LOAD_CONST_INLINE_r12 1352 +#define _LOAD_CONST_INLINE_r23 1353 +#define _LOAD_CONST_INLINE_BORROW_r01 1354 +#define _LOAD_CONST_INLINE_BORROW_r12 1355 +#define _LOAD_CONST_INLINE_BORROW_r23 1356 +#define _LOAD_DEREF_r01 1357 +#define _LOAD_FAST_r01 1358 +#define _LOAD_FAST_r12 1359 +#define _LOAD_FAST_r23 1360 +#define _LOAD_FAST_0_r01 1361 +#define _LOAD_FAST_0_r12 1362 +#define _LOAD_FAST_0_r23 1363 +#define _LOAD_FAST_1_r01 1364 +#define _LOAD_FAST_1_r12 1365 +#define _LOAD_FAST_1_r23 1366 +#define _LOAD_FAST_2_r01 1367 +#define _LOAD_FAST_2_r12 1368 +#define _LOAD_FAST_2_r23 1369 +#define _LOAD_FAST_3_r01 1370 +#define _LOAD_FAST_3_r12 1371 +#define _LOAD_FAST_3_r23 1372 +#define _LOAD_FAST_4_r01 1373 +#define _LOAD_FAST_4_r12 1374 +#define _LOAD_FAST_4_r23 1375 +#define _LOAD_FAST_5_r01 1376 +#define _LOAD_FAST_5_r12 1377 +#define _LOAD_FAST_5_r23 1378 +#define _LOAD_FAST_6_r01 1379 +#define _LOAD_FAST_6_r12 1380 +#define _LOAD_FAST_6_r23 1381 +#define _LOAD_FAST_7_r01 1382 +#define _LOAD_FAST_7_r12 1383 +#define _LOAD_FAST_7_r23 1384 +#define _LOAD_FAST_AND_CLEAR_r01 1385 +#define _LOAD_FAST_AND_CLEAR_r12 1386 +#define _LOAD_FAST_AND_CLEAR_r23 1387 +#define _LOAD_FAST_BORROW_r01 1388 +#define _LOAD_FAST_BORROW_r12 1389 +#define _LOAD_FAST_BORROW_r23 1390 +#define _LOAD_FAST_BORROW_0_r01 1391 +#define _LOAD_FAST_BORROW_0_r12 1392 +#define _LOAD_FAST_BORROW_0_r23 1393 +#define _LOAD_FAST_BORROW_1_r01 1394 +#define _LOAD_FAST_BORROW_1_r12 1395 +#define _LOAD_FAST_BORROW_1_r23 1396 +#define _LOAD_FAST_BORROW_2_r01 1397 +#define _LOAD_FAST_BORROW_2_r12 1398 +#define _LOAD_FAST_BORROW_2_r23 1399 +#define _LOAD_FAST_BORROW_3_r01 1400 +#define _LOAD_FAST_BORROW_3_r12 1401 +#define _LOAD_FAST_BORROW_3_r23 1402 +#define _LOAD_FAST_BORROW_4_r01 1403 +#define _LOAD_FAST_BORROW_4_r12 1404 +#define _LOAD_FAST_BORROW_4_r23 1405 +#define _LOAD_FAST_BORROW_5_r01 1406 +#define _LOAD_FAST_BORROW_5_r12 1407 +#define _LOAD_FAST_BORROW_5_r23 1408 +#define _LOAD_FAST_BORROW_6_r01 1409 +#define _LOAD_FAST_BORROW_6_r12 1410 +#define _LOAD_FAST_BORROW_6_r23 1411 +#define _LOAD_FAST_BORROW_7_r01 1412 +#define _LOAD_FAST_BORROW_7_r12 1413 +#define _LOAD_FAST_BORROW_7_r23 1414 +#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r02 1415 +#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r13 1416 +#define _LOAD_FAST_CHECK_r01 1417 +#define _LOAD_FAST_CHECK_r12 1418 +#define _LOAD_FAST_CHECK_r23 1419 +#define _LOAD_FAST_LOAD_FAST_r02 1420 +#define _LOAD_FAST_LOAD_FAST_r13 1421 +#define _LOAD_FROM_DICT_OR_DEREF_r11 1422 +#define _LOAD_FROM_DICT_OR_GLOBALS_r11 1423 +#define _LOAD_GLOBAL_r00 1424 +#define _LOAD_GLOBAL_BUILTINS_r01 1425 +#define _LOAD_GLOBAL_MODULE_r01 1426 +#define _LOAD_LOCALS_r01 1427 +#define _LOAD_LOCALS_r12 1428 +#define _LOAD_LOCALS_r23 1429 +#define _LOAD_NAME_r01 1430 +#define _LOAD_SMALL_INT_r01 1431 +#define _LOAD_SMALL_INT_r12 1432 +#define _LOAD_SMALL_INT_r23 1433 +#define _LOAD_SMALL_INT_0_r01 1434 +#define _LOAD_SMALL_INT_0_r12 1435 +#define _LOAD_SMALL_INT_0_r23 1436 +#define _LOAD_SMALL_INT_1_r01 1437 +#define _LOAD_SMALL_INT_1_r12 1438 +#define _LOAD_SMALL_INT_1_r23 1439 +#define _LOAD_SMALL_INT_2_r01 1440 +#define _LOAD_SMALL_INT_2_r12 1441 +#define _LOAD_SMALL_INT_2_r23 1442 +#define _LOAD_SMALL_INT_3_r01 1443 +#define _LOAD_SMALL_INT_3_r12 1444 +#define _LOAD_SMALL_INT_3_r23 1445 +#define _LOAD_SPECIAL_r00 1446 +#define _LOAD_SUPER_ATTR_ATTR_r31 1447 +#define _LOAD_SUPER_ATTR_METHOD_r32 1448 +#define _LOCK_OBJECT_r01 1449 +#define _LOCK_OBJECT_r11 1450 +#define _LOCK_OBJECT_r22 1451 +#define _LOCK_OBJECT_r33 1452 +#define _MAKE_CALLARGS_A_TUPLE_r33 1453 +#define _MAKE_CELL_r00 1454 +#define _MAKE_FUNCTION_r12 1455 +#define _MAKE_HEAP_SAFE_r01 1456 +#define _MAKE_HEAP_SAFE_r11 1457 +#define _MAKE_HEAP_SAFE_r22 1458 +#define _MAKE_HEAP_SAFE_r33 1459 +#define _MAKE_WARM_r00 1460 +#define _MAKE_WARM_r11 1461 +#define _MAKE_WARM_r22 1462 +#define _MAKE_WARM_r33 1463 +#define _MAP_ADD_r20 1464 +#define _MATCH_CLASS_r33 1465 +#define _MATCH_KEYS_r23 1466 +#define _MATCH_MAPPING_r02 1467 +#define _MATCH_MAPPING_r12 1468 +#define _MATCH_MAPPING_r23 1469 +#define _MATCH_SEQUENCE_r02 1470 +#define _MATCH_SEQUENCE_r12 1471 +#define _MATCH_SEQUENCE_r23 1472 +#define _MAYBE_EXPAND_METHOD_r00 1473 +#define _MAYBE_EXPAND_METHOD_KW_r11 1474 +#define _MONITOR_CALL_r00 1475 +#define _MONITOR_CALL_KW_r11 1476 +#define _MONITOR_JUMP_BACKWARD_r00 1477 +#define _MONITOR_JUMP_BACKWARD_r11 1478 +#define _MONITOR_JUMP_BACKWARD_r22 1479 +#define _MONITOR_JUMP_BACKWARD_r33 1480 +#define _MONITOR_RESUME_r00 1481 +#define _NOP_r00 1482 +#define _NOP_r11 1483 +#define _NOP_r22 1484 +#define _NOP_r33 1485 +#define _POP_EXCEPT_r10 1486 +#define _POP_ITER_r20 1487 +#define _POP_JUMP_IF_FALSE_r00 1488 +#define _POP_JUMP_IF_FALSE_r10 1489 +#define _POP_JUMP_IF_FALSE_r21 1490 +#define _POP_JUMP_IF_FALSE_r32 1491 +#define _POP_JUMP_IF_TRUE_r00 1492 +#define _POP_JUMP_IF_TRUE_r10 1493 +#define _POP_JUMP_IF_TRUE_r21 1494 +#define _POP_JUMP_IF_TRUE_r32 1495 +#define _POP_TOP_r10 1496 +#define _POP_TOP_FLOAT_r00 1497 +#define _POP_TOP_FLOAT_r10 1498 +#define _POP_TOP_FLOAT_r21 1499 +#define _POP_TOP_FLOAT_r32 1500 +#define _POP_TOP_INT_r00 1501 +#define _POP_TOP_INT_r10 1502 +#define _POP_TOP_INT_r21 1503 +#define _POP_TOP_INT_r32 1504 +#define _POP_TOP_NOP_r00 1505 +#define _POP_TOP_NOP_r10 1506 +#define _POP_TOP_NOP_r21 1507 +#define _POP_TOP_NOP_r32 1508 +#define _POP_TOP_OPARG_r00 1509 +#define _POP_TOP_UNICODE_r00 1510 +#define _POP_TOP_UNICODE_r10 1511 +#define _POP_TOP_UNICODE_r21 1512 +#define _POP_TOP_UNICODE_r32 1513 +#define _PUSH_EXC_INFO_r02 1514 +#define _PUSH_EXC_INFO_r12 1515 +#define _PUSH_EXC_INFO_r23 1516 +#define _PUSH_FRAME_r10 1517 +#define _PUSH_NULL_r01 1518 +#define _PUSH_NULL_r12 1519 +#define _PUSH_NULL_r23 1520 +#define _PUSH_NULL_CONDITIONAL_r00 1521 +#define _PUSH_TAGGED_ZERO_r01 1522 +#define _PUSH_TAGGED_ZERO_r12 1523 +#define _PUSH_TAGGED_ZERO_r23 1524 +#define _PY_FRAME_EX_r31 1525 +#define _PY_FRAME_GENERAL_r01 1526 +#define _PY_FRAME_KW_r11 1527 +#define _REPLACE_WITH_TRUE_r02 1528 +#define _REPLACE_WITH_TRUE_r12 1529 +#define _REPLACE_WITH_TRUE_r23 1530 +#define _RESUME_CHECK_r00 1531 +#define _RESUME_CHECK_r11 1532 +#define _RESUME_CHECK_r22 1533 +#define _RESUME_CHECK_r33 1534 +#define _RETURN_GENERATOR_r01 1535 +#define _RETURN_VALUE_r11 1536 +#define _RROT_3_r03 1537 +#define _RROT_3_r13 1538 +#define _RROT_3_r23 1539 +#define _RROT_3_r33 1540 +#define _SAVE_RETURN_OFFSET_r00 1541 +#define _SAVE_RETURN_OFFSET_r11 1542 +#define _SAVE_RETURN_OFFSET_r22 1543 +#define _SAVE_RETURN_OFFSET_r33 1544 +#define _SEND_ASYNC_GEN_r33 1545 +#define _SEND_ASYNC_GEN_TIER_TWO_r33 1546 +#define _SEND_GEN_FRAME_r33 1547 +#define _SEND_VIRTUAL_r33 1548 +#define _SEND_VIRTUAL_TIER_TWO_r03 1549 +#define _SEND_VIRTUAL_TIER_TWO_r13 1550 +#define _SEND_VIRTUAL_TIER_TWO_r23 1551 +#define _SEND_VIRTUAL_TIER_TWO_r33 1552 +#define _SETUP_ANNOTATIONS_r00 1553 +#define _SET_ADD_r10 1554 +#define _SET_FUNCTION_ATTRIBUTE_r01 1555 +#define _SET_FUNCTION_ATTRIBUTE_r11 1556 +#define _SET_FUNCTION_ATTRIBUTE_r21 1557 +#define _SET_FUNCTION_ATTRIBUTE_r32 1558 +#define _SET_IP_r00 1559 +#define _SET_IP_r11 1560 +#define _SET_IP_r22 1561 +#define _SET_IP_r33 1562 +#define _SET_UPDATE_r11 1563 +#define _SPILL_OR_RELOAD_r01 1564 +#define _SPILL_OR_RELOAD_r02 1565 +#define _SPILL_OR_RELOAD_r03 1566 +#define _SPILL_OR_RELOAD_r10 1567 +#define _SPILL_OR_RELOAD_r12 1568 +#define _SPILL_OR_RELOAD_r13 1569 +#define _SPILL_OR_RELOAD_r20 1570 +#define _SPILL_OR_RELOAD_r21 1571 +#define _SPILL_OR_RELOAD_r23 1572 +#define _SPILL_OR_RELOAD_r30 1573 +#define _SPILL_OR_RELOAD_r31 1574 +#define _SPILL_OR_RELOAD_r32 1575 +#define _START_EXECUTOR_r00 1576 +#define _STORE_ATTR_r20 1577 +#define _STORE_ATTR_INSTANCE_VALUE_r21 1578 +#define _STORE_ATTR_SLOT_r21 1579 +#define _STORE_ATTR_WITH_HINT_r21 1580 +#define _STORE_DEREF_r10 1581 +#define _STORE_FAST_LOAD_FAST_r11 1582 +#define _STORE_FAST_STORE_FAST_r20 1583 +#define _STORE_GLOBAL_r10 1584 +#define _STORE_NAME_r10 1585 +#define _STORE_SLICE_r30 1586 +#define _STORE_SUBSCR_r30 1587 +#define _STORE_SUBSCR_DICT_r31 1588 +#define _STORE_SUBSCR_DICT_KNOWN_HASH_r31 1589 +#define _STORE_SUBSCR_LIST_INT_r32 1590 +#define _SWAP_r11 1591 +#define _SWAP_2_r02 1592 +#define _SWAP_2_r12 1593 +#define _SWAP_2_r22 1594 +#define _SWAP_2_r33 1595 +#define _SWAP_3_r03 1596 +#define _SWAP_3_r13 1597 +#define _SWAP_3_r23 1598 +#define _SWAP_3_r33 1599 +#define _SWAP_FAST_r01 1600 +#define _SWAP_FAST_r11 1601 +#define _SWAP_FAST_r22 1602 +#define _SWAP_FAST_r33 1603 +#define _SWAP_FAST_0_r01 1604 +#define _SWAP_FAST_0_r11 1605 +#define _SWAP_FAST_0_r22 1606 +#define _SWAP_FAST_0_r33 1607 +#define _SWAP_FAST_1_r01 1608 +#define _SWAP_FAST_1_r11 1609 +#define _SWAP_FAST_1_r22 1610 +#define _SWAP_FAST_1_r33 1611 +#define _SWAP_FAST_2_r01 1612 +#define _SWAP_FAST_2_r11 1613 +#define _SWAP_FAST_2_r22 1614 +#define _SWAP_FAST_2_r33 1615 +#define _SWAP_FAST_3_r01 1616 +#define _SWAP_FAST_3_r11 1617 +#define _SWAP_FAST_3_r22 1618 +#define _SWAP_FAST_3_r33 1619 +#define _SWAP_FAST_4_r01 1620 +#define _SWAP_FAST_4_r11 1621 +#define _SWAP_FAST_4_r22 1622 +#define _SWAP_FAST_4_r33 1623 +#define _SWAP_FAST_5_r01 1624 +#define _SWAP_FAST_5_r11 1625 +#define _SWAP_FAST_5_r22 1626 +#define _SWAP_FAST_5_r33 1627 +#define _SWAP_FAST_6_r01 1628 +#define _SWAP_FAST_6_r11 1629 +#define _SWAP_FAST_6_r22 1630 +#define _SWAP_FAST_6_r33 1631 +#define _SWAP_FAST_7_r01 1632 +#define _SWAP_FAST_7_r11 1633 +#define _SWAP_FAST_7_r22 1634 +#define _SWAP_FAST_7_r33 1635 +#define _TIER2_RESUME_CHECK_r00 1636 +#define _TIER2_RESUME_CHECK_r11 1637 +#define _TIER2_RESUME_CHECK_r22 1638 +#define _TIER2_RESUME_CHECK_r33 1639 +#define _TO_BOOL_r11 1640 +#define _TO_BOOL_BOOL_r01 1641 +#define _TO_BOOL_BOOL_r11 1642 +#define _TO_BOOL_BOOL_r22 1643 +#define _TO_BOOL_BOOL_r33 1644 +#define _TO_BOOL_INT_r02 1645 +#define _TO_BOOL_INT_r12 1646 +#define _TO_BOOL_INT_r23 1647 +#define _TO_BOOL_LIST_r02 1648 +#define _TO_BOOL_LIST_r12 1649 +#define _TO_BOOL_LIST_r23 1650 +#define _TO_BOOL_NONE_r01 1651 +#define _TO_BOOL_NONE_r11 1652 +#define _TO_BOOL_NONE_r22 1653 +#define _TO_BOOL_NONE_r33 1654 +#define _TO_BOOL_STR_r02 1655 +#define _TO_BOOL_STR_r12 1656 +#define _TO_BOOL_STR_r23 1657 +#define _TRACE_RECORD_r00 1658 +#define _UNARY_INVERT_r12 1659 +#define _UNARY_NEGATIVE_r12 1660 +#define _UNARY_NEGATIVE_FLOAT_INPLACE_r02 1661 +#define _UNARY_NEGATIVE_FLOAT_INPLACE_r12 1662 +#define _UNARY_NEGATIVE_FLOAT_INPLACE_r23 1663 +#define _UNARY_NOT_r01 1664 +#define _UNARY_NOT_r11 1665 +#define _UNARY_NOT_r22 1666 +#define _UNARY_NOT_r33 1667 +#define _UNPACK_EX_r10 1668 +#define _UNPACK_SEQUENCE_r10 1669 +#define _UNPACK_SEQUENCE_LIST_r10 1670 +#define _UNPACK_SEQUENCE_TUPLE_r10 1671 +#define _UNPACK_SEQUENCE_TWO_TUPLE_r12 1672 +#define _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE_r03 1673 +#define _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE_r13 1674 +#define _UNPACK_SEQUENCE_UNIQUE_TUPLE_r10 1675 +#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r02 1676 +#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r12 1677 +#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r23 1678 +#define _WITH_EXCEPT_START_r33 1679 +#define _YIELD_VALUE_r11 1680 +#define MAX_UOP_REGS_ID 1680 #ifdef __cplusplus } diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index a61df9c29769d0..47a9ceeae3cf28 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -257,6 +257,7 @@ const uint32_t _PyUop_Flags[MAX_UOP_ID+1] = { [_IMPORT_NAME] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_IMPORT_FROM] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_IS_NONE] = HAS_ESCAPES_FLAG, + [_IS_NONE_KEEP] = 0, [_GET_LEN] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_MATCH_CLASS] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_MATCH_MAPPING] = 0, @@ -395,6 +396,8 @@ const uint32_t _PyUop_Flags[MAX_UOP_ID+1] = { [_GUARD_BIT_IS_UNSET_POP_7] = HAS_EXIT_FLAG, [_GUARD_BIT_IS_UNSET_POP] = HAS_ARG_FLAG | HAS_EXIT_FLAG, [_GUARD_IS_NONE_POP] = HAS_EXIT_FLAG, + [_GUARD_IS_NONE_KEEP] = HAS_EXIT_FLAG, + [_GUARD_IS_NOT_NONE_KEEP] = HAS_EXIT_FLAG, [_GUARD_IS_NOT_NONE_POP] = HAS_EXIT_FLAG | HAS_ESCAPES_FLAG, [_JUMP_TO_TOP] = 0, [_SET_IP] = 0, @@ -2448,6 +2451,15 @@ const _PyUopCachingInfo _PyUop_Caching[MAX_UOP_ID+1] = { { -1, -1, -1 }, }, }, + [_IS_NONE_KEEP] = { + .best = { 0, 1, 2, 2 }, + .entries = { + { 2, 0, _IS_NONE_KEEP_r02 }, + { 2, 1, _IS_NONE_KEEP_r12 }, + { 3, 2, _IS_NONE_KEEP_r23 }, + { -1, -1, -1 }, + }, + }, [_GET_LEN] = { .best = { 1, 1, 1, 1 }, .entries = { @@ -3690,6 +3702,24 @@ const _PyUopCachingInfo _PyUop_Caching[MAX_UOP_ID+1] = { { 2, 2, _GUARD_IS_NONE_POP_r32 }, }, }, + [_GUARD_IS_NONE_KEEP] = { + .best = { 0, 1, 2, 3 }, + .entries = { + { 1, 1, _GUARD_IS_NONE_KEEP_r01 }, + { 1, 1, _GUARD_IS_NONE_KEEP_r11 }, + { 2, 2, _GUARD_IS_NONE_KEEP_r22 }, + { 3, 3, _GUARD_IS_NONE_KEEP_r33 }, + }, + }, + [_GUARD_IS_NOT_NONE_KEEP] = { + .best = { 0, 1, 2, 3 }, + .entries = { + { 1, 1, _GUARD_IS_NOT_NONE_KEEP_r01 }, + { 1, 1, _GUARD_IS_NOT_NONE_KEEP_r11 }, + { 2, 2, _GUARD_IS_NOT_NONE_KEEP_r22 }, + { 3, 3, _GUARD_IS_NOT_NONE_KEEP_r33 }, + }, + }, [_GUARD_IS_NOT_NONE_POP] = { .best = { 1, 1, 1, 1 }, .entries = { @@ -4473,6 +4503,9 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_IMPORT_NAME_r21] = _IMPORT_NAME, [_IMPORT_FROM_r12] = _IMPORT_FROM, [_IS_NONE_r11] = _IS_NONE, + [_IS_NONE_KEEP_r02] = _IS_NONE_KEEP, + [_IS_NONE_KEEP_r12] = _IS_NONE_KEEP, + [_IS_NONE_KEEP_r23] = _IS_NONE_KEEP, [_GET_LEN_r12] = _GET_LEN, [_MATCH_CLASS_r33] = _MATCH_CLASS, [_MATCH_MAPPING_r02] = _MATCH_MAPPING, @@ -4776,6 +4809,14 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_GUARD_IS_NONE_POP_r10] = _GUARD_IS_NONE_POP, [_GUARD_IS_NONE_POP_r21] = _GUARD_IS_NONE_POP, [_GUARD_IS_NONE_POP_r32] = _GUARD_IS_NONE_POP, + [_GUARD_IS_NONE_KEEP_r01] = _GUARD_IS_NONE_KEEP, + [_GUARD_IS_NONE_KEEP_r11] = _GUARD_IS_NONE_KEEP, + [_GUARD_IS_NONE_KEEP_r22] = _GUARD_IS_NONE_KEEP, + [_GUARD_IS_NONE_KEEP_r33] = _GUARD_IS_NONE_KEEP, + [_GUARD_IS_NOT_NONE_KEEP_r01] = _GUARD_IS_NOT_NONE_KEEP, + [_GUARD_IS_NOT_NONE_KEEP_r11] = _GUARD_IS_NOT_NONE_KEEP, + [_GUARD_IS_NOT_NONE_KEEP_r22] = _GUARD_IS_NOT_NONE_KEEP, + [_GUARD_IS_NOT_NONE_KEEP_r33] = _GUARD_IS_NOT_NONE_KEEP, [_GUARD_IS_NOT_NONE_POP_r10] = _GUARD_IS_NOT_NONE_POP, [_JUMP_TO_TOP_r00] = _JUMP_TO_TOP, [_SET_IP_r00] = _SET_IP, @@ -5462,11 +5503,21 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_GUARD_IS_FALSE_POP_r10] = "_GUARD_IS_FALSE_POP_r10", [_GUARD_IS_FALSE_POP_r21] = "_GUARD_IS_FALSE_POP_r21", [_GUARD_IS_FALSE_POP_r32] = "_GUARD_IS_FALSE_POP_r32", + [_GUARD_IS_NONE_KEEP] = "_GUARD_IS_NONE_KEEP", + [_GUARD_IS_NONE_KEEP_r01] = "_GUARD_IS_NONE_KEEP_r01", + [_GUARD_IS_NONE_KEEP_r11] = "_GUARD_IS_NONE_KEEP_r11", + [_GUARD_IS_NONE_KEEP_r22] = "_GUARD_IS_NONE_KEEP_r22", + [_GUARD_IS_NONE_KEEP_r33] = "_GUARD_IS_NONE_KEEP_r33", [_GUARD_IS_NONE_POP] = "_GUARD_IS_NONE_POP", [_GUARD_IS_NONE_POP_r00] = "_GUARD_IS_NONE_POP_r00", [_GUARD_IS_NONE_POP_r10] = "_GUARD_IS_NONE_POP_r10", [_GUARD_IS_NONE_POP_r21] = "_GUARD_IS_NONE_POP_r21", [_GUARD_IS_NONE_POP_r32] = "_GUARD_IS_NONE_POP_r32", + [_GUARD_IS_NOT_NONE_KEEP] = "_GUARD_IS_NOT_NONE_KEEP", + [_GUARD_IS_NOT_NONE_KEEP_r01] = "_GUARD_IS_NOT_NONE_KEEP_r01", + [_GUARD_IS_NOT_NONE_KEEP_r11] = "_GUARD_IS_NOT_NONE_KEEP_r11", + [_GUARD_IS_NOT_NONE_KEEP_r22] = "_GUARD_IS_NOT_NONE_KEEP_r22", + [_GUARD_IS_NOT_NONE_KEEP_r33] = "_GUARD_IS_NOT_NONE_KEEP_r33", [_GUARD_IS_NOT_NONE_POP] = "_GUARD_IS_NOT_NONE_POP", [_GUARD_IS_NOT_NONE_POP_r10] = "_GUARD_IS_NOT_NONE_POP_r10", [_GUARD_IS_TRUE_POP] = "_GUARD_IS_TRUE_POP", @@ -5701,6 +5752,10 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_INSERT_NULL_r10] = "_INSERT_NULL_r10", [_IS_NONE] = "_IS_NONE", [_IS_NONE_r11] = "_IS_NONE_r11", + [_IS_NONE_KEEP] = "_IS_NONE_KEEP", + [_IS_NONE_KEEP_r02] = "_IS_NONE_KEEP_r02", + [_IS_NONE_KEEP_r12] = "_IS_NONE_KEEP_r12", + [_IS_NONE_KEEP_r23] = "_IS_NONE_KEEP_r23", [_IS_OP] = "_IS_OP", [_IS_OP_r03] = "_IS_OP_r03", [_IS_OP_r13] = "_IS_OP_r13", @@ -6681,6 +6736,8 @@ int _PyUop_num_popped(int opcode, int oparg) return 0; case _IS_NONE: return 1; + case _IS_NONE_KEEP: + return 0; case _GET_LEN: return 0; case _MATCH_CLASS: @@ -6957,6 +7014,10 @@ int _PyUop_num_popped(int opcode, int oparg) return 1; case _GUARD_IS_NONE_POP: return 1; + case _GUARD_IS_NONE_KEEP: + return 0; + case _GUARD_IS_NOT_NONE_KEEP: + return 0; case _GUARD_IS_NOT_NONE_POP: return 1; case _JUMP_TO_TOP: diff --git a/Include/opcode_ids.h b/Include/opcode_ids.h index 758542720acf31..8160ed6dd75e8d 100644 --- a/Include/opcode_ids.h +++ b/Include/opcode_ids.h @@ -87,49 +87,51 @@ extern "C" { #define JUMP_BACKWARD 74 #define JUMP_BACKWARD_NO_INTERRUPT 75 #define JUMP_FORWARD 76 -#define LIST_APPEND 77 -#define LIST_EXTEND 78 -#define LOAD_ATTR 79 -#define LOAD_COMMON_CONSTANT 80 -#define LOAD_CONST 81 -#define LOAD_DEREF 82 -#define LOAD_FAST 83 -#define LOAD_FAST_AND_CLEAR 84 -#define LOAD_FAST_BORROW 85 -#define LOAD_FAST_BORROW_LOAD_FAST_BORROW 86 -#define LOAD_FAST_CHECK 87 -#define LOAD_FAST_LOAD_FAST 88 -#define LOAD_FROM_DICT_OR_DEREF 89 -#define LOAD_FROM_DICT_OR_GLOBALS 90 -#define LOAD_GLOBAL 91 -#define LOAD_NAME 92 -#define LOAD_SMALL_INT 93 -#define LOAD_SPECIAL 94 -#define LOAD_SUPER_ATTR 95 -#define MAKE_CELL 96 -#define MAP_ADD 97 -#define MATCH_CLASS 98 -#define POP_JUMP_IF_FALSE 99 -#define POP_JUMP_IF_NONE 100 -#define POP_JUMP_IF_NOT_NONE 101 -#define POP_JUMP_IF_TRUE 102 -#define RAISE_VARARGS 103 -#define RERAISE 104 -#define SEND 105 -#define SET_ADD 106 -#define SET_FUNCTION_ATTRIBUTE 107 -#define SET_UPDATE 108 -#define STORE_ATTR 109 -#define STORE_DEREF 110 -#define STORE_FAST 111 -#define STORE_FAST_LOAD_FAST 112 -#define STORE_FAST_STORE_FAST 113 -#define STORE_GLOBAL 114 -#define STORE_NAME 115 -#define SWAP 116 -#define UNPACK_EX 117 -#define UNPACK_SEQUENCE 118 -#define YIELD_VALUE 119 +#define JUMP_IF_NONE 77 +#define JUMP_IF_NOT_NONE 78 +#define LIST_APPEND 79 +#define LIST_EXTEND 80 +#define LOAD_ATTR 81 +#define LOAD_COMMON_CONSTANT 82 +#define LOAD_CONST 83 +#define LOAD_DEREF 84 +#define LOAD_FAST 85 +#define LOAD_FAST_AND_CLEAR 86 +#define LOAD_FAST_BORROW 87 +#define LOAD_FAST_BORROW_LOAD_FAST_BORROW 88 +#define LOAD_FAST_CHECK 89 +#define LOAD_FAST_LOAD_FAST 90 +#define LOAD_FROM_DICT_OR_DEREF 91 +#define LOAD_FROM_DICT_OR_GLOBALS 92 +#define LOAD_GLOBAL 93 +#define LOAD_NAME 94 +#define LOAD_SMALL_INT 95 +#define LOAD_SPECIAL 96 +#define LOAD_SUPER_ATTR 97 +#define MAKE_CELL 98 +#define MAP_ADD 99 +#define MATCH_CLASS 100 +#define POP_JUMP_IF_FALSE 101 +#define POP_JUMP_IF_NONE 102 +#define POP_JUMP_IF_NOT_NONE 103 +#define POP_JUMP_IF_TRUE 104 +#define RAISE_VARARGS 105 +#define RERAISE 106 +#define SEND 107 +#define SET_ADD 108 +#define SET_FUNCTION_ATTRIBUTE 109 +#define SET_UPDATE 110 +#define STORE_ATTR 111 +#define STORE_DEREF 112 +#define STORE_FAST 113 +#define STORE_FAST_LOAD_FAST 114 +#define STORE_FAST_STORE_FAST 115 +#define STORE_GLOBAL 116 +#define STORE_NAME 117 +#define SWAP 118 +#define UNPACK_EX 119 +#define UNPACK_SEQUENCE 120 +#define YIELD_VALUE 121 #define RESUME 128 #define BINARY_OP_ADD_FLOAT 129 #define BINARY_OP_ADD_INT 130 @@ -221,16 +223,18 @@ extern "C" { #define UNPACK_SEQUENCE_LIST 216 #define UNPACK_SEQUENCE_TUPLE 217 #define UNPACK_SEQUENCE_TWO_TUPLE 218 -#define INSTRUMENTED_END_FOR 233 -#define INSTRUMENTED_POP_ITER 234 -#define INSTRUMENTED_END_SEND 235 -#define INSTRUMENTED_FOR_ITER 236 -#define INSTRUMENTED_INSTRUCTION 237 -#define INSTRUMENTED_JUMP_FORWARD 238 -#define INSTRUMENTED_NOT_TAKEN 239 -#define INSTRUMENTED_POP_JUMP_IF_TRUE 240 -#define INSTRUMENTED_POP_JUMP_IF_FALSE 241 -#define INSTRUMENTED_POP_JUMP_IF_NONE 242 +#define INSTRUMENTED_END_FOR 231 +#define INSTRUMENTED_POP_ITER 232 +#define INSTRUMENTED_END_SEND 233 +#define INSTRUMENTED_FOR_ITER 234 +#define INSTRUMENTED_INSTRUCTION 235 +#define INSTRUMENTED_JUMP_FORWARD 236 +#define INSTRUMENTED_NOT_TAKEN 237 +#define INSTRUMENTED_POP_JUMP_IF_TRUE 238 +#define INSTRUMENTED_POP_JUMP_IF_FALSE 239 +#define INSTRUMENTED_POP_JUMP_IF_NONE 240 +#define INSTRUMENTED_JUMP_IF_NONE 241 +#define INSTRUMENTED_JUMP_IF_NOT_NONE 242 #define INSTRUMENTED_POP_JUMP_IF_NOT_NONE 243 #define INSTRUMENTED_RESUME 244 #define INSTRUMENTED_RETURN_VALUE 245 @@ -258,7 +262,7 @@ extern "C" { #define HAVE_ARGUMENT 41 #define MIN_SPECIALIZED_OPCODE 129 -#define MIN_INSTRUMENTED_OPCODE 233 +#define MIN_INSTRUMENTED_OPCODE 231 #ifdef __cplusplus } diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py index 183d0af30acf43..3ef2b3db4713ef 100644 --- a/Lib/_opcode_metadata.py +++ b/Lib/_opcode_metadata.py @@ -307,59 +307,63 @@ JUMP_BACKWARD=74, JUMP_BACKWARD_NO_INTERRUPT=75, JUMP_FORWARD=76, - LIST_APPEND=77, - LIST_EXTEND=78, - LOAD_ATTR=79, - LOAD_COMMON_CONSTANT=80, - LOAD_CONST=81, - LOAD_DEREF=82, - LOAD_FAST=83, - LOAD_FAST_AND_CLEAR=84, - LOAD_FAST_BORROW=85, - LOAD_FAST_BORROW_LOAD_FAST_BORROW=86, - LOAD_FAST_CHECK=87, - LOAD_FAST_LOAD_FAST=88, - LOAD_FROM_DICT_OR_DEREF=89, - LOAD_FROM_DICT_OR_GLOBALS=90, - LOAD_GLOBAL=91, - LOAD_NAME=92, - LOAD_SMALL_INT=93, - LOAD_SPECIAL=94, - LOAD_SUPER_ATTR=95, - MAKE_CELL=96, - MAP_ADD=97, - MATCH_CLASS=98, - POP_JUMP_IF_FALSE=99, - POP_JUMP_IF_NONE=100, - POP_JUMP_IF_NOT_NONE=101, - POP_JUMP_IF_TRUE=102, - RAISE_VARARGS=103, - RERAISE=104, - SEND=105, - SET_ADD=106, - SET_FUNCTION_ATTRIBUTE=107, - SET_UPDATE=108, - STORE_ATTR=109, - STORE_DEREF=110, - STORE_FAST=111, - STORE_FAST_LOAD_FAST=112, - STORE_FAST_STORE_FAST=113, - STORE_GLOBAL=114, - STORE_NAME=115, - SWAP=116, - UNPACK_EX=117, - UNPACK_SEQUENCE=118, - YIELD_VALUE=119, - INSTRUMENTED_END_FOR=233, - INSTRUMENTED_POP_ITER=234, - INSTRUMENTED_END_SEND=235, - INSTRUMENTED_FOR_ITER=236, - INSTRUMENTED_INSTRUCTION=237, - INSTRUMENTED_JUMP_FORWARD=238, - INSTRUMENTED_NOT_TAKEN=239, - INSTRUMENTED_POP_JUMP_IF_TRUE=240, - INSTRUMENTED_POP_JUMP_IF_FALSE=241, - INSTRUMENTED_POP_JUMP_IF_NONE=242, + JUMP_IF_NONE=77, + JUMP_IF_NOT_NONE=78, + LIST_APPEND=79, + LIST_EXTEND=80, + LOAD_ATTR=81, + LOAD_COMMON_CONSTANT=82, + LOAD_CONST=83, + LOAD_DEREF=84, + LOAD_FAST=85, + LOAD_FAST_AND_CLEAR=86, + LOAD_FAST_BORROW=87, + LOAD_FAST_BORROW_LOAD_FAST_BORROW=88, + LOAD_FAST_CHECK=89, + LOAD_FAST_LOAD_FAST=90, + LOAD_FROM_DICT_OR_DEREF=91, + LOAD_FROM_DICT_OR_GLOBALS=92, + LOAD_GLOBAL=93, + LOAD_NAME=94, + LOAD_SMALL_INT=95, + LOAD_SPECIAL=96, + LOAD_SUPER_ATTR=97, + MAKE_CELL=98, + MAP_ADD=99, + MATCH_CLASS=100, + POP_JUMP_IF_FALSE=101, + POP_JUMP_IF_NONE=102, + POP_JUMP_IF_NOT_NONE=103, + POP_JUMP_IF_TRUE=104, + RAISE_VARARGS=105, + RERAISE=106, + SEND=107, + SET_ADD=108, + SET_FUNCTION_ATTRIBUTE=109, + SET_UPDATE=110, + STORE_ATTR=111, + STORE_DEREF=112, + STORE_FAST=113, + STORE_FAST_LOAD_FAST=114, + STORE_FAST_STORE_FAST=115, + STORE_GLOBAL=116, + STORE_NAME=117, + SWAP=118, + UNPACK_EX=119, + UNPACK_SEQUENCE=120, + YIELD_VALUE=121, + INSTRUMENTED_END_FOR=231, + INSTRUMENTED_POP_ITER=232, + INSTRUMENTED_END_SEND=233, + INSTRUMENTED_FOR_ITER=234, + INSTRUMENTED_INSTRUCTION=235, + INSTRUMENTED_JUMP_FORWARD=236, + INSTRUMENTED_NOT_TAKEN=237, + INSTRUMENTED_POP_JUMP_IF_TRUE=238, + INSTRUMENTED_POP_JUMP_IF_FALSE=239, + INSTRUMENTED_POP_JUMP_IF_NONE=240, + INSTRUMENTED_JUMP_IF_NONE=241, + INSTRUMENTED_JUMP_IF_NOT_NONE=242, INSTRUMENTED_POP_JUMP_IF_NOT_NONE=243, INSTRUMENTED_RESUME=244, INSTRUMENTED_RETURN_VALUE=245, @@ -384,4 +388,4 @@ ) HAVE_ARGUMENT = 41 -MIN_INSTRUMENTED_OPCODE = 233 +MIN_INSTRUMENTED_OPCODE = 231 diff --git a/Lib/opcode.py b/Lib/opcode.py index 4e60fb5af34f22..e35ca9951e9fa0 100644 --- a/Lib/opcode.py +++ b/Lib/opcode.py @@ -122,6 +122,12 @@ POP_JUMP_IF_NONE=frozendict( counter=1, ), + JUMP_IF_NONE=frozendict( + counter=1, + ), + JUMP_IF_NOT_NONE=frozendict( + counter=1, + ), POP_JUMP_IF_NOT_NONE=frozendict( counter=1, ), diff --git a/Lib/test/test_importlib/test_util.py b/Lib/test/test_importlib/test_util.py index 8a911c1b751a4b..01a8233e6ed9d7 100644 --- a/Lib/test/test_importlib/test_util.py +++ b/Lib/test/test_importlib/test_util.py @@ -647,7 +647,7 @@ def test_magic_number(self): # stakeholders such as OS package maintainers must be notified # in advance. Such exceptional releases will then require an # adjustment to this test case. - EXPECTED_MAGIC_NUMBER = 3666 + EXPECTED_MAGIC_NUMBER = 3667 actual = int.from_bytes(importlib.util.MAGIC_NUMBER[:2], 'little') msg = ( diff --git a/Lib/test/test_none_aware.py b/Lib/test/test_none_aware.py index b69db55f53f77d..dd6fe22522f72d 100644 --- a/Lib/test/test_none_aware.py +++ b/Lib/test/test_none_aware.py @@ -1,4 +1,5 @@ import ast +import _opcode import dis import io import sys @@ -45,7 +46,7 @@ def make() -> SimpleNamespace: self.assertEqual(self.evaluate("make()?.name", make=make), "Ada") self.assertEqual(calls, [1]) - def test_local_access_uses_fused_load(self) -> None: + def test_local_access_uses_none_jump(self) -> None: namespace: dict[str, Any] = {"Any": Any} exec( "def optional(value: Any) -> Any:\n" @@ -57,7 +58,7 @@ def test_local_access_uses_fused_load(self) -> None: optional = namespace["optional"] explicit = namespace["explicit"] self.assertIn( - "LOAD_FAST_LOAD_FAST", + "JUMP_IF_NONE", [ instruction.opname for instruction in dis.get_instructions(optional) @@ -83,7 +84,7 @@ def test_traced_local_rebinding_preserves_operand(self) -> None: check_offset = next( instruction.offset for instruction in dis.get_instructions(access) - if instruction.opname == "POP_JUMP_IF_NONE" + if instruction.opname == "JUMP_IF_NONE" ) def trace(frame: Any, event: str, argument: Any) -> Any: @@ -100,28 +101,160 @@ def trace(frame: Any, event: str, argument: Any) -> Any: finally: sys.settrace(previous_trace) - def test_local_access_outside_fused_load_range(self) -> None: + def test_local_access_above_short_operand_range(self) -> None: + for slot in (16, 256): + with self.subTest(slot=slot): + namespace: dict[str, Any] = {"Any": Any} + parameters = [f"arg{index}: Any" for index in range(slot)] + parameters.append("value: Any") + exec( + f"def access({', '.join(parameters)}) -> Any:\n" + " return value?.name\n", + namespace, + ) + access = namespace["access"] + opnames = [i.opname for i in dis.get_instructions(access)] + self.assertIn("JUMP_IF_NONE", opnames) + self.assertNotIn("COPY", opnames) + for value, expected in ( + (None, None), + (SimpleNamespace(name="Ada"), "Ada"), + ): + self.assertEqual(access(*([None] * slot), value), expected) + + def test_chain_uses_stack_preserving_jumps(self) -> None: namespace: dict[str, Any] = {"Any": Any} - parameters = [f"arg{index}: Any" for index in range(16)] - parameters.append("value: Any") exec( - f"def access({', '.join(parameters)}) -> Any:\n" - " return value?.name\n", + "def access(value: Any) -> Any:\n" + " return value?.profile?.name\n", + namespace, + ) + instructions = list(dis.get_instructions(namespace["access"])) + checks = [i for i in instructions if i.opname == "JUMP_IF_NONE"] + self.assertEqual(len(checks), 2) + self.assertNotIn("COPY", [i.opname for i in instructions]) + for check in checks: + for jump in (False, True): + self.assertEqual( + dis.stack_effect(check.opcode, check.arg, jump=jump), 0 + ) + + def test_optional_branch_monitoring(self) -> None: + monitoring = sys.monitoring + tool = 5 + if monitoring.get_tool(tool) is not None: + self.skipTest("Monitoring tool slot is in use") + namespace: dict[str, Any] = {"Any": Any} + exec( + "def access(value: Any) -> Any:\n" + " return value?.profile?.name\n", namespace, ) access = namespace["access"] - self.assertIn( - "COPY", - [ - instruction.opname - for instruction in dis.get_instructions(access) - ], + events: list[str] = [] + + def left(code: Any, offset: int, destination: int) -> None: + if code is access.__code__: + events.append("left") + + def right(code: Any, offset: int, destination: int) -> None: + if code is access.__code__: + events.append("right") + + monitoring.use_tool_id(tool, "none-aware-test") + try: + monitoring.register_callback( + tool, monitoring.events.BRANCH_LEFT, left + ) + monitoring.register_callback( + tool, monitoring.events.BRANCH_RIGHT, right + ) + monitoring.set_local_events( + tool, + access.__code__, + monitoring.events.BRANCH_LEFT | monitoring.events.BRANCH_RIGHT, + ) + for value, expected, branches in ( + (None, None, ["right"]), + (SimpleNamespace(profile=None), None, ["left", "right"]), + ( + SimpleNamespace(profile=SimpleNamespace(name="Ada")), + "Ada", + ["left", "left"], + ), + ): + events.clear() + self.assertEqual(access(value), expected) + self.assertEqual(events, branches) + finally: + monitoring.set_local_events(tool, access.__code__, 0) + monitoring.register_callback( + tool, monitoring.events.BRANCH_LEFT, None + ) + monitoring.register_callback( + tool, monitoring.events.BRANCH_RIGHT, None + ) + monitoring.free_tool_id(tool) + self.assertEqual( + access(SimpleNamespace(profile=SimpleNamespace(name="Ada"))), "Ada" ) - for value, expected in ( - (None, None), - (SimpleNamespace(name="Ada"), "Ada"), - ): - self.assertEqual(access(*([None] * 16), value), expected) + + def test_long_chain_jump_arguments(self) -> None: + namespace: dict[str, Any] = {"Any": Any} + expression = "value" + "?.next" * 40 + "?.name" + exec( + f"def access(value: Any) -> Any:\n return {expression}\n", + namespace, + ) + access = namespace["access"] + checks = [ + i + for i in dis.get_instructions(access) + if i.opname == "JUMP_IF_NONE" + ] + self.assertEqual(len(checks), 41) + self.assertGreater(checks[0].arg, 255) + self.assertIsNone(access(None)) + value = SimpleNamespace(name="Ada") + for _ in range(40): + value = SimpleNamespace(next=value) + self.assertEqual(access(value), "Ada") + + @unittest.skipUnless(sys._jit.is_enabled(), "requires tier-two execution") + def test_tier_two_mixed_chains(self) -> None: + namespace: dict[str, Any] = {"Any": Any} + exec( + "def count(values: tuple[Any, ...], repetitions: int) -> int:\n" + " total = 0\n" + " for _ in range(repetitions):\n" + " for value in values:\n" + " total += value?.profile?.name is not None\n" + " return total\n", + namespace, + ) + count = namespace["count"] + values = ( + None, + SimpleNamespace(profile=None), + SimpleNamespace(profile=SimpleNamespace(name="Ada")), + ) + self.assertEqual(count(values, 10_000), 10_000) + executors = [] + for offset in range(0, len(count.__code__.co_code), 2): + try: + executors.append(_opcode.get_executor(count.__code__, offset)) + except ValueError: + pass + self.assertTrue(executors) + opnames = { + instruction[0] + for executor in executors + for instruction in executor + } + self.assertTrue( + {"_GUARD_IS_NONE_KEEP", "_GUARD_IS_NOT_NONE_KEEP"} & opnames + ) + self.assertEqual(count(values, 100), 100) def test_local_access_in_expression_and_chain(self) -> None: namespace: dict[str, Any] = {"Any": Any} diff --git a/Modules/_testinternalcapi/test_cases.c.h b/Modules/_testinternalcapi/test_cases.c.h index 3e909c21e44044..9588d0409af7e7 100644 --- a/Modules/_testinternalcapi/test_cases.c.h +++ b/Modules/_testinternalcapi/test_cases.c.h @@ -7437,6 +7437,48 @@ DISPATCH(); } + TARGET(INSTRUMENTED_JUMP_IF_NONE) { + #if _Py_TAIL_CALL_INTERP + int opcode = INSTRUMENTED_JUMP_IF_NONE; + (void)(opcode); + #endif + _Py_CODEUNIT* const this_instr = next_instr; + (void)this_instr; + frame->instr_ptr = next_instr; + next_instr += 2; + INSTRUCTION_STATS(INSTRUMENTED_JUMP_IF_NONE); + _PyStackRef value; + /* Skip 1 cache entry */ + value = stack_pointer[-1]; + int jump = PyStackRef_IsNone(value); + RECORD_BRANCH_TAKEN(this_instr[1].cache, jump); + if (jump) { + INSTRUMENTED_JUMP(this_instr, next_instr + oparg, PY_MONITORING_EVENT_BRANCH_RIGHT); + } + DISPATCH(); + } + + TARGET(INSTRUMENTED_JUMP_IF_NOT_NONE) { + #if _Py_TAIL_CALL_INTERP + int opcode = INSTRUMENTED_JUMP_IF_NOT_NONE; + (void)(opcode); + #endif + _Py_CODEUNIT* const this_instr = next_instr; + (void)this_instr; + frame->instr_ptr = next_instr; + next_instr += 2; + INSTRUCTION_STATS(INSTRUMENTED_JUMP_IF_NOT_NONE); + _PyStackRef value; + /* Skip 1 cache entry */ + value = stack_pointer[-1]; + int jump = !PyStackRef_IsNone(value); + RECORD_BRANCH_TAKEN(this_instr[1].cache, jump); + if (jump) { + INSTRUMENTED_JUMP(this_instr, next_instr + oparg, PY_MONITORING_EVENT_BRANCH_RIGHT); + } + DISPATCH(); + } + TARGET(INSTRUMENTED_LINE) { #if _Py_TAIL_CALL_INTERP int opcode = INSTRUMENTED_LINE; @@ -8192,6 +8234,66 @@ DISPATCH(); } + TARGET(JUMP_IF_NONE) { + #if _Py_TAIL_CALL_INTERP + int opcode = JUMP_IF_NONE; + (void)(opcode); + #endif + _Py_CODEUNIT* const this_instr = next_instr; + (void)this_instr; + frame->instr_ptr = next_instr; + next_instr += 2; + INSTRUCTION_STATS(JUMP_IF_NONE); + _PyStackRef value; + _PyStackRef b; + _PyStackRef cond; + /* Skip 1 cache entry */ + // _IS_NONE_KEEP + { + value = stack_pointer[-1]; + b = PyStackRef_IsNone(value) ? PyStackRef_True : PyStackRef_False; + } + // _POP_JUMP_IF_TRUE + { + cond = b; + assert(PyStackRef_BoolCheck(cond)); + int flag = PyStackRef_IsTrue(cond); + RECORD_BRANCH_TAKEN(this_instr[1].cache, flag); + JUMPBY(flag ? oparg : next_instr->op.code == NOT_TAKEN); + } + DISPATCH(); + } + + TARGET(JUMP_IF_NOT_NONE) { + #if _Py_TAIL_CALL_INTERP + int opcode = JUMP_IF_NOT_NONE; + (void)(opcode); + #endif + _Py_CODEUNIT* const this_instr = next_instr; + (void)this_instr; + frame->instr_ptr = next_instr; + next_instr += 2; + INSTRUCTION_STATS(JUMP_IF_NOT_NONE); + _PyStackRef value; + _PyStackRef b; + _PyStackRef cond; + /* Skip 1 cache entry */ + // _IS_NONE_KEEP + { + value = stack_pointer[-1]; + b = PyStackRef_IsNone(value) ? PyStackRef_True : PyStackRef_False; + } + // _POP_JUMP_IF_FALSE + { + cond = b; + assert(PyStackRef_BoolCheck(cond)); + int flag = PyStackRef_IsFalse(cond); + RECORD_BRANCH_TAKEN(this_instr[1].cache, flag); + JUMPBY(flag ? oparg : next_instr->op.code == NOT_TAKEN); + } + DISPATCH(); + } + TARGET(LIST_APPEND) { #if _Py_TAIL_CALL_INTERP int opcode = LIST_APPEND; diff --git a/Modules/_testinternalcapi/test_targets.h b/Modules/_testinternalcapi/test_targets.h index 1a7eb9169fc837..caa64febcc073a 100644 --- a/Modules/_testinternalcapi/test_targets.h +++ b/Modules/_testinternalcapi/test_targets.h @@ -77,6 +77,8 @@ static void *opcode_targets_table[256] = { &&TARGET_JUMP_BACKWARD, &&TARGET_JUMP_BACKWARD_NO_INTERRUPT, &&TARGET_JUMP_FORWARD, + &&TARGET_JUMP_IF_NONE, + &&TARGET_JUMP_IF_NOT_NONE, &&TARGET_LIST_APPEND, &&TARGET_LIST_EXTEND, &&TARGET_LOAD_ATTR, @@ -126,8 +128,6 @@ static void *opcode_targets_table[256] = { &&_unknown_opcode, &&_unknown_opcode, &&_unknown_opcode, - &&_unknown_opcode, - &&_unknown_opcode, &&TARGET_RESUME, &&TARGET_BINARY_OP_ADD_FLOAT, &&TARGET_BINARY_OP_ADD_INT, @@ -231,8 +231,6 @@ static void *opcode_targets_table[256] = { &&_unknown_opcode, &&_unknown_opcode, &&_unknown_opcode, - &&_unknown_opcode, - &&_unknown_opcode, &&TARGET_INSTRUMENTED_END_FOR, &&TARGET_INSTRUMENTED_POP_ITER, &&TARGET_INSTRUMENTED_END_SEND, @@ -243,6 +241,8 @@ static void *opcode_targets_table[256] = { &&TARGET_INSTRUMENTED_POP_JUMP_IF_TRUE, &&TARGET_INSTRUMENTED_POP_JUMP_IF_FALSE, &&TARGET_INSTRUMENTED_POP_JUMP_IF_NONE, + &&TARGET_INSTRUMENTED_JUMP_IF_NONE, + &&TARGET_INSTRUMENTED_JUMP_IF_NOT_NONE, &&TARGET_INSTRUMENTED_POP_JUMP_IF_NOT_NONE, &&TARGET_INSTRUMENTED_RESUME, &&TARGET_INSTRUMENTED_RETURN_VALUE, @@ -379,8 +379,8 @@ static void *opcode_tracing_targets_table[256] = { &&TARGET_TRACE_RECORD, &&TARGET_TRACE_RECORD, &&TARGET_TRACE_RECORD, - &&_unknown_opcode, - &&_unknown_opcode, + &&TARGET_TRACE_RECORD, + &&TARGET_TRACE_RECORD, &&_unknown_opcode, &&_unknown_opcode, &&_unknown_opcode, @@ -490,8 +490,8 @@ static void *opcode_tracing_targets_table[256] = { &&_unknown_opcode, &&_unknown_opcode, &&_unknown_opcode, - &&_unknown_opcode, - &&_unknown_opcode, + &&TARGET_TRACE_RECORD, + &&TARGET_TRACE_RECORD, &&TARGET_TRACE_RECORD, &&TARGET_TRACE_RECORD, &&TARGET_TRACE_RECORD, @@ -642,6 +642,8 @@ static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_INSTRUMENTED_FOR_ITER(TAIL_CALL_ static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_INSTRUMENTED_INSTRUCTION(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_INSTRUMENTED_JUMP_BACKWARD(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_INSTRUMENTED_JUMP_FORWARD(TAIL_CALL_PARAMS); +static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_INSTRUMENTED_JUMP_IF_NONE(TAIL_CALL_PARAMS); +static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_INSTRUMENTED_JUMP_IF_NOT_NONE(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_INSTRUMENTED_LINE(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_INSTRUMENTED_LOAD_SUPER_ATTR(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_INSTRUMENTED_NOT_TAKEN(TAIL_CALL_PARAMS); @@ -660,6 +662,8 @@ static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_JUMP_BACKWARD_JIT(TAIL_CALL_PARA static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_JUMP_BACKWARD_NO_INTERRUPT(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_JUMP_BACKWARD_NO_JIT(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_JUMP_FORWARD(TAIL_CALL_PARAMS); +static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_JUMP_IF_NONE(TAIL_CALL_PARAMS); +static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_JUMP_IF_NOT_NONE(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_LIST_APPEND(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_LIST_EXTEND(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_LOAD_ATTR(TAIL_CALL_PARAMS); @@ -888,6 +892,8 @@ static py_tail_call_funcptr instruction_funcptr_handler_table[256] = { [INSTRUMENTED_INSTRUCTION] = _TAIL_CALL_INSTRUMENTED_INSTRUCTION, [INSTRUMENTED_JUMP_BACKWARD] = _TAIL_CALL_INSTRUMENTED_JUMP_BACKWARD, [INSTRUMENTED_JUMP_FORWARD] = _TAIL_CALL_INSTRUMENTED_JUMP_FORWARD, + [INSTRUMENTED_JUMP_IF_NONE] = _TAIL_CALL_INSTRUMENTED_JUMP_IF_NONE, + [INSTRUMENTED_JUMP_IF_NOT_NONE] = _TAIL_CALL_INSTRUMENTED_JUMP_IF_NOT_NONE, [INSTRUMENTED_LINE] = _TAIL_CALL_INSTRUMENTED_LINE, [INSTRUMENTED_LOAD_SUPER_ATTR] = _TAIL_CALL_INSTRUMENTED_LOAD_SUPER_ATTR, [INSTRUMENTED_NOT_TAKEN] = _TAIL_CALL_INSTRUMENTED_NOT_TAKEN, @@ -906,6 +912,8 @@ static py_tail_call_funcptr instruction_funcptr_handler_table[256] = { [JUMP_BACKWARD_NO_INTERRUPT] = _TAIL_CALL_JUMP_BACKWARD_NO_INTERRUPT, [JUMP_BACKWARD_NO_JIT] = _TAIL_CALL_JUMP_BACKWARD_NO_JIT, [JUMP_FORWARD] = _TAIL_CALL_JUMP_FORWARD, + [JUMP_IF_NONE] = _TAIL_CALL_JUMP_IF_NONE, + [JUMP_IF_NOT_NONE] = _TAIL_CALL_JUMP_IF_NOT_NONE, [LIST_APPEND] = _TAIL_CALL_LIST_APPEND, [LIST_EXTEND] = _TAIL_CALL_LIST_EXTEND, [LOAD_ATTR] = _TAIL_CALL_LOAD_ATTR, @@ -1011,8 +1019,6 @@ static py_tail_call_funcptr instruction_funcptr_handler_table[256] = { [UNPACK_SEQUENCE_TWO_TUPLE] = _TAIL_CALL_UNPACK_SEQUENCE_TWO_TUPLE, [WITH_EXCEPT_START] = _TAIL_CALL_WITH_EXCEPT_START, [YIELD_VALUE] = _TAIL_CALL_YIELD_VALUE, - [120] = _TAIL_CALL_UNKNOWN_OPCODE, - [121] = _TAIL_CALL_UNKNOWN_OPCODE, [122] = _TAIL_CALL_UNKNOWN_OPCODE, [123] = _TAIL_CALL_UNKNOWN_OPCODE, [124] = _TAIL_CALL_UNKNOWN_OPCODE, @@ -1031,8 +1037,6 @@ static py_tail_call_funcptr instruction_funcptr_handler_table[256] = { [228] = _TAIL_CALL_UNKNOWN_OPCODE, [229] = _TAIL_CALL_UNKNOWN_OPCODE, [230] = _TAIL_CALL_UNKNOWN_OPCODE, - [231] = _TAIL_CALL_UNKNOWN_OPCODE, - [232] = _TAIL_CALL_UNKNOWN_OPCODE, }; static py_tail_call_funcptr instruction_funcptr_tracing_table[256] = { [BINARY_OP] = _TAIL_CALL_TRACE_RECORD, @@ -1146,6 +1150,8 @@ static py_tail_call_funcptr instruction_funcptr_tracing_table[256] = { [INSTRUMENTED_INSTRUCTION] = _TAIL_CALL_TRACE_RECORD, [INSTRUMENTED_JUMP_BACKWARD] = _TAIL_CALL_TRACE_RECORD, [INSTRUMENTED_JUMP_FORWARD] = _TAIL_CALL_TRACE_RECORD, + [INSTRUMENTED_JUMP_IF_NONE] = _TAIL_CALL_TRACE_RECORD, + [INSTRUMENTED_JUMP_IF_NOT_NONE] = _TAIL_CALL_TRACE_RECORD, [INSTRUMENTED_LINE] = _TAIL_CALL_TRACE_RECORD, [INSTRUMENTED_LOAD_SUPER_ATTR] = _TAIL_CALL_TRACE_RECORD, [INSTRUMENTED_NOT_TAKEN] = _TAIL_CALL_TRACE_RECORD, @@ -1164,6 +1170,8 @@ static py_tail_call_funcptr instruction_funcptr_tracing_table[256] = { [JUMP_BACKWARD_NO_INTERRUPT] = _TAIL_CALL_TRACE_RECORD, [JUMP_BACKWARD_NO_JIT] = _TAIL_CALL_TRACE_RECORD, [JUMP_FORWARD] = _TAIL_CALL_TRACE_RECORD, + [JUMP_IF_NONE] = _TAIL_CALL_TRACE_RECORD, + [JUMP_IF_NOT_NONE] = _TAIL_CALL_TRACE_RECORD, [LIST_APPEND] = _TAIL_CALL_TRACE_RECORD, [LIST_EXTEND] = _TAIL_CALL_TRACE_RECORD, [LOAD_ATTR] = _TAIL_CALL_TRACE_RECORD, @@ -1269,8 +1277,6 @@ static py_tail_call_funcptr instruction_funcptr_tracing_table[256] = { [UNPACK_SEQUENCE_TWO_TUPLE] = _TAIL_CALL_TRACE_RECORD, [WITH_EXCEPT_START] = _TAIL_CALL_TRACE_RECORD, [YIELD_VALUE] = _TAIL_CALL_TRACE_RECORD, - [120] = _TAIL_CALL_UNKNOWN_OPCODE, - [121] = _TAIL_CALL_UNKNOWN_OPCODE, [122] = _TAIL_CALL_UNKNOWN_OPCODE, [123] = _TAIL_CALL_UNKNOWN_OPCODE, [124] = _TAIL_CALL_UNKNOWN_OPCODE, @@ -1289,7 +1295,5 @@ static py_tail_call_funcptr instruction_funcptr_tracing_table[256] = { [228] = _TAIL_CALL_UNKNOWN_OPCODE, [229] = _TAIL_CALL_UNKNOWN_OPCODE, [230] = _TAIL_CALL_UNKNOWN_OPCODE, - [231] = _TAIL_CALL_UNKNOWN_OPCODE, - [232] = _TAIL_CALL_UNKNOWN_OPCODE, }; #endif /* _Py_TAIL_CALL_INTERP */ diff --git a/Programs/test_frozenmain.h b/Programs/test_frozenmain.h index 1bcf98a7600851..6a9504787117d7 100644 --- a/Programs/test_frozenmain.h +++ b/Programs/test_frozenmain.h @@ -1,19 +1,19 @@ // Auto-generated by Programs/freeze_test_frozenmain.py unsigned char M_test_frozenmain[] = { 227,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0, - 0,0,0,0,0,243,188,0,0,0,128,0,0,0,93,0, - 80,7,72,0,115,0,93,0,80,7,72,4,115,1,92,2, - 31,0,81,1,50,1,0,0,0,0,0,0,29,0,92,2, - 31,0,81,2,92,0,79,6,0,0,0,0,0,0,0,0, + 0,0,0,0,0,243,188,0,0,0,128,0,0,0,95,0, + 82,7,72,0,117,0,95,0,82,7,72,4,117,1,94,2, + 31,0,83,1,50,1,0,0,0,0,0,0,29,0,94,2, + 31,0,83,2,94,0,81,6,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,50,2,0,0,0,0, - 0,0,29,0,92,1,79,8,0,0,0,0,0,0,0,0, + 0,0,29,0,94,1,81,8,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,31,0,50,0,0,0, - 0,0,0,0,81,3,42,26,0,0,0,0,0,0,0,0, - 0,0,115,5,81,6,70,0,0,0,68,24,0,0,115,6, - 92,2,31,0,81,4,92,6,12,0,81,5,92,5,92,6, + 0,0,0,0,83,3,42,26,0,0,0,0,0,0,0,0, + 0,0,117,5,83,6,70,0,0,0,68,24,0,0,117,6, + 94,2,31,0,83,4,94,6,12,0,83,5,94,5,94,6, 42,26,0,0,0,0,0,0,0,0,0,0,12,0,48,4, 50,1,0,0,0,0,0,0,29,0,74,26,0,0,9,0, - 28,0,80,7,33,0,41,7,233,0,0,0,0,122,18,70, + 28,0,82,7,33,0,41,7,233,0,0,0,0,122,18,70, 114,111,122,101,110,32,72,101,108,108,111,32,87,111,114,108, 100,122,8,115,121,115,46,97,114,103,118,218,6,99,111,110, 102,105,103,122,7,99,111,110,102,105,103,32,122,2,58,32, diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 8e487d0b88ff59..0ff1473108df4f 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -3643,6 +3643,10 @@ dummy_func( } } + op(_IS_NONE_KEEP, (value -- value, b)) { + b = PyStackRef_IsNone(value) ? PyStackRef_True : PyStackRef_False; + } + macro(POP_JUMP_IF_TRUE) = unused/1 + _POP_JUMP_IF_TRUE; macro(POP_JUMP_IF_FALSE) = unused/1 + _POP_JUMP_IF_FALSE; @@ -3651,6 +3655,10 @@ dummy_func( macro(POP_JUMP_IF_NOT_NONE) = unused/1 + _IS_NONE + _POP_JUMP_IF_FALSE; + macro(JUMP_IF_NONE) = unused/1 + _IS_NONE_KEEP + _POP_JUMP_IF_TRUE; + + macro(JUMP_IF_NOT_NONE) = unused/1 + _IS_NONE_KEEP + _POP_JUMP_IF_FALSE; + replaced inst(JUMP_BACKWARD_NO_INTERRUPT, (--)) { /* This bytecode is used in the `yield from` or `await` loop. * If there is an interrupt, we want it handled in the innermost @@ -6034,6 +6042,22 @@ dummy_func( } } + inst(INSTRUMENTED_JUMP_IF_NONE, (unused/1, value -- value)) { + int jump = PyStackRef_IsNone(value); + RECORD_BRANCH_TAKEN(this_instr[1].cache, jump); + if (jump) { + INSTRUMENTED_JUMP(this_instr, next_instr + oparg, PY_MONITORING_EVENT_BRANCH_RIGHT); + } + } + + inst(INSTRUMENTED_JUMP_IF_NOT_NONE, (unused/1, value -- value)) { + int jump = !PyStackRef_IsNone(value); + RECORD_BRANCH_TAKEN(this_instr[1].cache, jump); + if (jump) { + INSTRUMENTED_JUMP(this_instr, next_instr + oparg, PY_MONITORING_EVENT_BRANCH_RIGHT); + } + } + inst(INSTRUMENTED_POP_JUMP_IF_NOT_NONE, (unused/1, value -- )) { int jump = !PyStackRef_IsNone(value); RECORD_BRANCH_TAKEN(this_instr[1].cache, jump); @@ -6109,6 +6133,14 @@ dummy_func( DEAD(val); } + op(_GUARD_IS_NONE_KEEP, (val -- val)) { + AT_END_EXIT_IF(!PyStackRef_IsNone(val)); + } + + op(_GUARD_IS_NOT_NONE_KEEP, (val -- val)) { + AT_END_EXIT_IF(PyStackRef_IsNone(val)); + } + op (_GUARD_IS_NOT_NONE_POP, (val -- )) { int is_none = PyStackRef_IsNone(val); PyStackRef_CLOSE(val); diff --git a/Python/codegen.c b/Python/codegen.c index 820cdbccf1f796..522490dc3ac9b7 100644 --- a/Python/codegen.c +++ b/Python/codegen.c @@ -5384,8 +5384,7 @@ codegen_optional_chain_tail(compiler *c, expr_ty e, jump_target_label end) case NoneAwareAttribute_kind: RETURN_IF_ERROR(codegen_optional_chain_tail( c, e->v.NoneAwareAttribute.value, end)); - ADDOP_I(c, loc, COPY, 1); - ADDOP_JUMP(c, loc, POP_JUMP_IF_NONE, end); + ADDOP_JUMP(c, loc, JUMP_IF_NONE, end); ADDOP_NAME(c, loc, LOAD_ATTR, e->v.NoneAwareAttribute.attr, names); break; case Attribute_kind: diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 8c02c0c89e862f..0a08a0fd15ca2f 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -14076,6 +14076,54 @@ break; } + case _IS_NONE_KEEP_r02: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef b; + value = stack_pointer[-1]; + b = PyStackRef_IsNone(value) ? PyStackRef_True : PyStackRef_False; + _tos_cache1 = b; + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _IS_NONE_KEEP_r12: { + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef b; + _PyStackRef _stack_item_0 = _tos_cache0; + value = _stack_item_0; + b = PyStackRef_IsNone(value) ? PyStackRef_True : PyStackRef_False; + _tos_cache1 = b; + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _IS_NONE_KEEP_r23: { + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef b; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + value = _stack_item_1; + b = PyStackRef_IsNone(value) ? PyStackRef_True : PyStackRef_False; + _tos_cache2 = b; + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + /* _JUMP_BACKWARD_NO_INTERRUPT is not a viable micro-op for tier 2 because it is replaced */ case _GET_LEN_r12: { @@ -21082,6 +21130,10 @@ /* _INSTRUMENTED_POP_JUMP_IF_NONE is not a viable micro-op for tier 2 because it is instrumented */ + /* _INSTRUMENTED_JUMP_IF_NONE is not a viable micro-op for tier 2 because it is instrumented */ + + /* _INSTRUMENTED_JUMP_IF_NOT_NONE is not a viable micro-op for tier 2 because it is instrumented */ + /* _INSTRUMENTED_POP_JUMP_IF_NOT_NONE is not a viable micro-op for tier 2 because it is instrumented */ case _GUARD_IS_TRUE_POP_r00: { @@ -22427,6 +22479,174 @@ break; } + case _GUARD_IS_NONE_KEEP_r01: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef val; + val = stack_pointer[-1]; + if (!PyStackRef_IsNone(val)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = val; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = val; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _GUARD_IS_NONE_KEEP_r11: { + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef val; + _PyStackRef _stack_item_0 = _tos_cache0; + val = _stack_item_0; + if (!PyStackRef_IsNone(val)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = val; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = val; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _GUARD_IS_NONE_KEEP_r22: { + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef val; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + val = _stack_item_1; + if (!PyStackRef_IsNone(val)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = val; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = val; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _GUARD_IS_NONE_KEEP_r33: { + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef val; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + val = _stack_item_2; + if (!PyStackRef_IsNone(val)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = val; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = val; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _GUARD_IS_NOT_NONE_KEEP_r01: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef val; + val = stack_pointer[-1]; + if (PyStackRef_IsNone(val)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = val; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = val; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _GUARD_IS_NOT_NONE_KEEP_r11: { + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef val; + _PyStackRef _stack_item_0 = _tos_cache0; + val = _stack_item_0; + if (PyStackRef_IsNone(val)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = val; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = val; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _GUARD_IS_NOT_NONE_KEEP_r22: { + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef val; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + val = _stack_item_1; + if (PyStackRef_IsNone(val)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = val; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = val; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _GUARD_IS_NOT_NONE_KEEP_r33: { + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef val; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + val = _stack_item_2; + if (PyStackRef_IsNone(val)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = val; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = val; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + case _GUARD_IS_NOT_NONE_POP_r10: { CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); diff --git a/Python/flowgraph.c b/Python/flowgraph.c index 25349759d5c346..5da808b2d6d3ea 100644 --- a/Python/flowgraph.c +++ b/Python/flowgraph.c @@ -559,6 +559,12 @@ normalize_jumps_in_block(cfg_builder *g, basicblock *b) { int reversed_opcode = 0; switch(last->i_opcode) { + case JUMP_IF_NONE: + reversed_opcode = JUMP_IF_NOT_NONE; + break; + case JUMP_IF_NOT_NONE: + reversed_opcode = JUMP_IF_NONE; + break; case POP_JUMP_IF_NOT_NONE: reversed_opcode = POP_JUMP_IF_NONE; break; @@ -2707,21 +2713,6 @@ insert_superinstructions(cfg_builder *g) if (nextop == LOAD_FAST) { make_super_instruction(inst, &b->b_instr[i + 1], LOAD_FAST_LOAD_FAST); } - else if (nextop == COPY && inst->i_oparg < 16 && - b->b_instr[i + 1].i_oparg == 1 && - i + 2 < b->b_iused && - b->b_instr[i + 2].i_opcode == POP_JUMP_IF_NONE) { - cfg_instr *copy = &b->b_instr[i + 1]; - if (inst->i_loc.lineno < 0 || copy->i_loc.lineno < 0 || - inst->i_loc.lineno == copy->i_loc.lineno) { - /* Keep the checked operand on the stack, including - * when tracing changes the local after this load. */ - int local = inst->i_oparg; - INSTR_SET_OP1(inst, LOAD_FAST_LOAD_FAST, - (local << 4) | local); - INSTR_SET_OP0(copy, NOP); - } - } break; case STORE_FAST: switch (nextop) { @@ -3123,6 +3114,12 @@ optimize_load_fast(cfg_builder *g) } // Opcodes that consume all of their inputs + case JUMP_IF_NONE: + case JUMP_IF_NOT_NONE: + /* The original reference survives both branch outcomes. */ + load_fast_push_block(&sp, instr->i_target, refs.size); + break; + default: { int num_popped = _PyOpcode_num_popped(opcode, oparg); int num_pushed = _PyOpcode_num_pushed(opcode, oparg); diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index d312fef398794f..b843e2c798fdf6 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -7437,6 +7437,48 @@ DISPATCH(); } + TARGET(INSTRUMENTED_JUMP_IF_NONE) { + #if _Py_TAIL_CALL_INTERP + int opcode = INSTRUMENTED_JUMP_IF_NONE; + (void)(opcode); + #endif + _Py_CODEUNIT* const this_instr = next_instr; + (void)this_instr; + frame->instr_ptr = next_instr; + next_instr += 2; + INSTRUCTION_STATS(INSTRUMENTED_JUMP_IF_NONE); + _PyStackRef value; + /* Skip 1 cache entry */ + value = stack_pointer[-1]; + int jump = PyStackRef_IsNone(value); + RECORD_BRANCH_TAKEN(this_instr[1].cache, jump); + if (jump) { + INSTRUMENTED_JUMP(this_instr, next_instr + oparg, PY_MONITORING_EVENT_BRANCH_RIGHT); + } + DISPATCH(); + } + + TARGET(INSTRUMENTED_JUMP_IF_NOT_NONE) { + #if _Py_TAIL_CALL_INTERP + int opcode = INSTRUMENTED_JUMP_IF_NOT_NONE; + (void)(opcode); + #endif + _Py_CODEUNIT* const this_instr = next_instr; + (void)this_instr; + frame->instr_ptr = next_instr; + next_instr += 2; + INSTRUCTION_STATS(INSTRUMENTED_JUMP_IF_NOT_NONE); + _PyStackRef value; + /* Skip 1 cache entry */ + value = stack_pointer[-1]; + int jump = !PyStackRef_IsNone(value); + RECORD_BRANCH_TAKEN(this_instr[1].cache, jump); + if (jump) { + INSTRUMENTED_JUMP(this_instr, next_instr + oparg, PY_MONITORING_EVENT_BRANCH_RIGHT); + } + DISPATCH(); + } + TARGET(INSTRUMENTED_LINE) { #if _Py_TAIL_CALL_INTERP int opcode = INSTRUMENTED_LINE; @@ -8191,6 +8233,66 @@ DISPATCH(); } + TARGET(JUMP_IF_NONE) { + #if _Py_TAIL_CALL_INTERP + int opcode = JUMP_IF_NONE; + (void)(opcode); + #endif + _Py_CODEUNIT* const this_instr = next_instr; + (void)this_instr; + frame->instr_ptr = next_instr; + next_instr += 2; + INSTRUCTION_STATS(JUMP_IF_NONE); + _PyStackRef value; + _PyStackRef b; + _PyStackRef cond; + /* Skip 1 cache entry */ + // _IS_NONE_KEEP + { + value = stack_pointer[-1]; + b = PyStackRef_IsNone(value) ? PyStackRef_True : PyStackRef_False; + } + // _POP_JUMP_IF_TRUE + { + cond = b; + assert(PyStackRef_BoolCheck(cond)); + int flag = PyStackRef_IsTrue(cond); + RECORD_BRANCH_TAKEN(this_instr[1].cache, flag); + JUMPBY(flag ? oparg : next_instr->op.code == NOT_TAKEN); + } + DISPATCH(); + } + + TARGET(JUMP_IF_NOT_NONE) { + #if _Py_TAIL_CALL_INTERP + int opcode = JUMP_IF_NOT_NONE; + (void)(opcode); + #endif + _Py_CODEUNIT* const this_instr = next_instr; + (void)this_instr; + frame->instr_ptr = next_instr; + next_instr += 2; + INSTRUCTION_STATS(JUMP_IF_NOT_NONE); + _PyStackRef value; + _PyStackRef b; + _PyStackRef cond; + /* Skip 1 cache entry */ + // _IS_NONE_KEEP + { + value = stack_pointer[-1]; + b = PyStackRef_IsNone(value) ? PyStackRef_True : PyStackRef_False; + } + // _POP_JUMP_IF_FALSE + { + cond = b; + assert(PyStackRef_BoolCheck(cond)); + int flag = PyStackRef_IsFalse(cond); + RECORD_BRANCH_TAKEN(this_instr[1].cache, flag); + JUMPBY(flag ? oparg : next_instr->op.code == NOT_TAKEN); + } + DISPATCH(); + } + TARGET(LIST_APPEND) { #if _Py_TAIL_CALL_INTERP int opcode = LIST_APPEND; diff --git a/Python/instrumentation.c b/Python/instrumentation.c index 646fc15c6872e5..f1461d78baac24 100644 --- a/Python/instrumentation.c +++ b/Python/instrumentation.c @@ -89,12 +89,16 @@ static const int8_t EVENT_FOR_OPCODE[256] = { [JUMP_BACKWARD] = PY_MONITORING_EVENT_JUMP, [POP_JUMP_IF_FALSE] = PY_MONITORING_EVENT_BRANCH_RIGHT, [POP_JUMP_IF_TRUE] = PY_MONITORING_EVENT_BRANCH_RIGHT, + [JUMP_IF_NONE] = PY_MONITORING_EVENT_BRANCH_RIGHT, + [JUMP_IF_NOT_NONE] = PY_MONITORING_EVENT_BRANCH_RIGHT, [POP_JUMP_IF_NONE] = PY_MONITORING_EVENT_BRANCH_RIGHT, [POP_JUMP_IF_NOT_NONE] = PY_MONITORING_EVENT_BRANCH_RIGHT, [INSTRUMENTED_JUMP_FORWARD] = PY_MONITORING_EVENT_JUMP, [INSTRUMENTED_JUMP_BACKWARD] = PY_MONITORING_EVENT_JUMP, [INSTRUMENTED_POP_JUMP_IF_FALSE] = PY_MONITORING_EVENT_BRANCH_RIGHT, [INSTRUMENTED_POP_JUMP_IF_TRUE] = PY_MONITORING_EVENT_BRANCH_RIGHT, + [INSTRUMENTED_JUMP_IF_NONE] = PY_MONITORING_EVENT_BRANCH_RIGHT, + [INSTRUMENTED_JUMP_IF_NOT_NONE] = PY_MONITORING_EVENT_BRANCH_RIGHT, [INSTRUMENTED_POP_JUMP_IF_NONE] = PY_MONITORING_EVENT_BRANCH_RIGHT, [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = PY_MONITORING_EVENT_BRANCH_RIGHT, [FOR_ITER] = PY_MONITORING_EVENT_BRANCH_LEFT, @@ -121,6 +125,8 @@ static const uint8_t DE_INSTRUMENT[256] = { [INSTRUMENTED_JUMP_BACKWARD] = JUMP_BACKWARD, [INSTRUMENTED_POP_JUMP_IF_FALSE] = POP_JUMP_IF_FALSE, [INSTRUMENTED_POP_JUMP_IF_TRUE] = POP_JUMP_IF_TRUE, + [INSTRUMENTED_JUMP_IF_NONE] = JUMP_IF_NONE, + [INSTRUMENTED_JUMP_IF_NOT_NONE] = JUMP_IF_NOT_NONE, [INSTRUMENTED_POP_JUMP_IF_NONE] = POP_JUMP_IF_NONE, [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = POP_JUMP_IF_NOT_NONE, [INSTRUMENTED_FOR_ITER] = FOR_ITER, @@ -153,6 +159,10 @@ static const uint8_t INSTRUMENTED_OPCODES[256] = { [INSTRUMENTED_POP_JUMP_IF_FALSE] = INSTRUMENTED_POP_JUMP_IF_FALSE, [POP_JUMP_IF_TRUE] = INSTRUMENTED_POP_JUMP_IF_TRUE, [INSTRUMENTED_POP_JUMP_IF_TRUE] = INSTRUMENTED_POP_JUMP_IF_TRUE, + [JUMP_IF_NONE] = INSTRUMENTED_JUMP_IF_NONE, + [INSTRUMENTED_JUMP_IF_NONE] = INSTRUMENTED_JUMP_IF_NONE, + [JUMP_IF_NOT_NONE] = INSTRUMENTED_JUMP_IF_NOT_NONE, + [INSTRUMENTED_JUMP_IF_NOT_NONE] = INSTRUMENTED_JUMP_IF_NOT_NONE, [POP_JUMP_IF_NONE] = INSTRUMENTED_POP_JUMP_IF_NONE, [INSTRUMENTED_POP_JUMP_IF_NONE] = INSTRUMENTED_POP_JUMP_IF_NONE, [POP_JUMP_IF_NOT_NONE] = INSTRUMENTED_POP_JUMP_IF_NOT_NONE, @@ -1608,6 +1618,8 @@ initialize_lines(_PyCoLineInstrumentationData *line_data, PyCodeObject *code, in switch (opcode) { case POP_JUMP_IF_FALSE: case POP_JUMP_IF_TRUE: + case JUMP_IF_NONE: + case JUMP_IF_NOT_NONE: case POP_JUMP_IF_NONE: case POP_JUMP_IF_NOT_NONE: case JUMP_FORWARD: @@ -3155,6 +3167,8 @@ branchesiter_next(PyObject *op) return int_triple(offset*2, next_offset*2, target*2); case POP_JUMP_IF_FALSE: case POP_JUMP_IF_TRUE: + case JUMP_IF_NONE: + case JUMP_IF_NOT_NONE: case POP_JUMP_IF_NONE: case POP_JUMP_IF_NOT_NONE: oparg = (oparg << 8) | inst.op.arg; diff --git a/Python/opcode_targets.h b/Python/opcode_targets.h index 1a7eb9169fc837..caa64febcc073a 100644 --- a/Python/opcode_targets.h +++ b/Python/opcode_targets.h @@ -77,6 +77,8 @@ static void *opcode_targets_table[256] = { &&TARGET_JUMP_BACKWARD, &&TARGET_JUMP_BACKWARD_NO_INTERRUPT, &&TARGET_JUMP_FORWARD, + &&TARGET_JUMP_IF_NONE, + &&TARGET_JUMP_IF_NOT_NONE, &&TARGET_LIST_APPEND, &&TARGET_LIST_EXTEND, &&TARGET_LOAD_ATTR, @@ -126,8 +128,6 @@ static void *opcode_targets_table[256] = { &&_unknown_opcode, &&_unknown_opcode, &&_unknown_opcode, - &&_unknown_opcode, - &&_unknown_opcode, &&TARGET_RESUME, &&TARGET_BINARY_OP_ADD_FLOAT, &&TARGET_BINARY_OP_ADD_INT, @@ -231,8 +231,6 @@ static void *opcode_targets_table[256] = { &&_unknown_opcode, &&_unknown_opcode, &&_unknown_opcode, - &&_unknown_opcode, - &&_unknown_opcode, &&TARGET_INSTRUMENTED_END_FOR, &&TARGET_INSTRUMENTED_POP_ITER, &&TARGET_INSTRUMENTED_END_SEND, @@ -243,6 +241,8 @@ static void *opcode_targets_table[256] = { &&TARGET_INSTRUMENTED_POP_JUMP_IF_TRUE, &&TARGET_INSTRUMENTED_POP_JUMP_IF_FALSE, &&TARGET_INSTRUMENTED_POP_JUMP_IF_NONE, + &&TARGET_INSTRUMENTED_JUMP_IF_NONE, + &&TARGET_INSTRUMENTED_JUMP_IF_NOT_NONE, &&TARGET_INSTRUMENTED_POP_JUMP_IF_NOT_NONE, &&TARGET_INSTRUMENTED_RESUME, &&TARGET_INSTRUMENTED_RETURN_VALUE, @@ -379,8 +379,8 @@ static void *opcode_tracing_targets_table[256] = { &&TARGET_TRACE_RECORD, &&TARGET_TRACE_RECORD, &&TARGET_TRACE_RECORD, - &&_unknown_opcode, - &&_unknown_opcode, + &&TARGET_TRACE_RECORD, + &&TARGET_TRACE_RECORD, &&_unknown_opcode, &&_unknown_opcode, &&_unknown_opcode, @@ -490,8 +490,8 @@ static void *opcode_tracing_targets_table[256] = { &&_unknown_opcode, &&_unknown_opcode, &&_unknown_opcode, - &&_unknown_opcode, - &&_unknown_opcode, + &&TARGET_TRACE_RECORD, + &&TARGET_TRACE_RECORD, &&TARGET_TRACE_RECORD, &&TARGET_TRACE_RECORD, &&TARGET_TRACE_RECORD, @@ -642,6 +642,8 @@ static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_INSTRUMENTED_FOR_ITER(TAIL_CALL_ static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_INSTRUMENTED_INSTRUCTION(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_INSTRUMENTED_JUMP_BACKWARD(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_INSTRUMENTED_JUMP_FORWARD(TAIL_CALL_PARAMS); +static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_INSTRUMENTED_JUMP_IF_NONE(TAIL_CALL_PARAMS); +static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_INSTRUMENTED_JUMP_IF_NOT_NONE(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_INSTRUMENTED_LINE(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_INSTRUMENTED_LOAD_SUPER_ATTR(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_INSTRUMENTED_NOT_TAKEN(TAIL_CALL_PARAMS); @@ -660,6 +662,8 @@ static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_JUMP_BACKWARD_JIT(TAIL_CALL_PARA static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_JUMP_BACKWARD_NO_INTERRUPT(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_JUMP_BACKWARD_NO_JIT(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_JUMP_FORWARD(TAIL_CALL_PARAMS); +static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_JUMP_IF_NONE(TAIL_CALL_PARAMS); +static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_JUMP_IF_NOT_NONE(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_LIST_APPEND(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_LIST_EXTEND(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_LOAD_ATTR(TAIL_CALL_PARAMS); @@ -888,6 +892,8 @@ static py_tail_call_funcptr instruction_funcptr_handler_table[256] = { [INSTRUMENTED_INSTRUCTION] = _TAIL_CALL_INSTRUMENTED_INSTRUCTION, [INSTRUMENTED_JUMP_BACKWARD] = _TAIL_CALL_INSTRUMENTED_JUMP_BACKWARD, [INSTRUMENTED_JUMP_FORWARD] = _TAIL_CALL_INSTRUMENTED_JUMP_FORWARD, + [INSTRUMENTED_JUMP_IF_NONE] = _TAIL_CALL_INSTRUMENTED_JUMP_IF_NONE, + [INSTRUMENTED_JUMP_IF_NOT_NONE] = _TAIL_CALL_INSTRUMENTED_JUMP_IF_NOT_NONE, [INSTRUMENTED_LINE] = _TAIL_CALL_INSTRUMENTED_LINE, [INSTRUMENTED_LOAD_SUPER_ATTR] = _TAIL_CALL_INSTRUMENTED_LOAD_SUPER_ATTR, [INSTRUMENTED_NOT_TAKEN] = _TAIL_CALL_INSTRUMENTED_NOT_TAKEN, @@ -906,6 +912,8 @@ static py_tail_call_funcptr instruction_funcptr_handler_table[256] = { [JUMP_BACKWARD_NO_INTERRUPT] = _TAIL_CALL_JUMP_BACKWARD_NO_INTERRUPT, [JUMP_BACKWARD_NO_JIT] = _TAIL_CALL_JUMP_BACKWARD_NO_JIT, [JUMP_FORWARD] = _TAIL_CALL_JUMP_FORWARD, + [JUMP_IF_NONE] = _TAIL_CALL_JUMP_IF_NONE, + [JUMP_IF_NOT_NONE] = _TAIL_CALL_JUMP_IF_NOT_NONE, [LIST_APPEND] = _TAIL_CALL_LIST_APPEND, [LIST_EXTEND] = _TAIL_CALL_LIST_EXTEND, [LOAD_ATTR] = _TAIL_CALL_LOAD_ATTR, @@ -1011,8 +1019,6 @@ static py_tail_call_funcptr instruction_funcptr_handler_table[256] = { [UNPACK_SEQUENCE_TWO_TUPLE] = _TAIL_CALL_UNPACK_SEQUENCE_TWO_TUPLE, [WITH_EXCEPT_START] = _TAIL_CALL_WITH_EXCEPT_START, [YIELD_VALUE] = _TAIL_CALL_YIELD_VALUE, - [120] = _TAIL_CALL_UNKNOWN_OPCODE, - [121] = _TAIL_CALL_UNKNOWN_OPCODE, [122] = _TAIL_CALL_UNKNOWN_OPCODE, [123] = _TAIL_CALL_UNKNOWN_OPCODE, [124] = _TAIL_CALL_UNKNOWN_OPCODE, @@ -1031,8 +1037,6 @@ static py_tail_call_funcptr instruction_funcptr_handler_table[256] = { [228] = _TAIL_CALL_UNKNOWN_OPCODE, [229] = _TAIL_CALL_UNKNOWN_OPCODE, [230] = _TAIL_CALL_UNKNOWN_OPCODE, - [231] = _TAIL_CALL_UNKNOWN_OPCODE, - [232] = _TAIL_CALL_UNKNOWN_OPCODE, }; static py_tail_call_funcptr instruction_funcptr_tracing_table[256] = { [BINARY_OP] = _TAIL_CALL_TRACE_RECORD, @@ -1146,6 +1150,8 @@ static py_tail_call_funcptr instruction_funcptr_tracing_table[256] = { [INSTRUMENTED_INSTRUCTION] = _TAIL_CALL_TRACE_RECORD, [INSTRUMENTED_JUMP_BACKWARD] = _TAIL_CALL_TRACE_RECORD, [INSTRUMENTED_JUMP_FORWARD] = _TAIL_CALL_TRACE_RECORD, + [INSTRUMENTED_JUMP_IF_NONE] = _TAIL_CALL_TRACE_RECORD, + [INSTRUMENTED_JUMP_IF_NOT_NONE] = _TAIL_CALL_TRACE_RECORD, [INSTRUMENTED_LINE] = _TAIL_CALL_TRACE_RECORD, [INSTRUMENTED_LOAD_SUPER_ATTR] = _TAIL_CALL_TRACE_RECORD, [INSTRUMENTED_NOT_TAKEN] = _TAIL_CALL_TRACE_RECORD, @@ -1164,6 +1170,8 @@ static py_tail_call_funcptr instruction_funcptr_tracing_table[256] = { [JUMP_BACKWARD_NO_INTERRUPT] = _TAIL_CALL_TRACE_RECORD, [JUMP_BACKWARD_NO_JIT] = _TAIL_CALL_TRACE_RECORD, [JUMP_FORWARD] = _TAIL_CALL_TRACE_RECORD, + [JUMP_IF_NONE] = _TAIL_CALL_TRACE_RECORD, + [JUMP_IF_NOT_NONE] = _TAIL_CALL_TRACE_RECORD, [LIST_APPEND] = _TAIL_CALL_TRACE_RECORD, [LIST_EXTEND] = _TAIL_CALL_TRACE_RECORD, [LOAD_ATTR] = _TAIL_CALL_TRACE_RECORD, @@ -1269,8 +1277,6 @@ static py_tail_call_funcptr instruction_funcptr_tracing_table[256] = { [UNPACK_SEQUENCE_TWO_TUPLE] = _TAIL_CALL_TRACE_RECORD, [WITH_EXCEPT_START] = _TAIL_CALL_TRACE_RECORD, [YIELD_VALUE] = _TAIL_CALL_TRACE_RECORD, - [120] = _TAIL_CALL_UNKNOWN_OPCODE, - [121] = _TAIL_CALL_UNKNOWN_OPCODE, [122] = _TAIL_CALL_UNKNOWN_OPCODE, [123] = _TAIL_CALL_UNKNOWN_OPCODE, [124] = _TAIL_CALL_UNKNOWN_OPCODE, @@ -1289,7 +1295,5 @@ static py_tail_call_funcptr instruction_funcptr_tracing_table[256] = { [228] = _TAIL_CALL_UNKNOWN_OPCODE, [229] = _TAIL_CALL_UNKNOWN_OPCODE, [230] = _TAIL_CALL_UNKNOWN_OPCODE, - [231] = _TAIL_CALL_UNKNOWN_OPCODE, - [232] = _TAIL_CALL_UNKNOWN_OPCODE, }; #endif /* _Py_TAIL_CALL_INTERP */ diff --git a/Python/optimizer.c b/Python/optimizer.c index 1699ba5544ff59..f7e72b67f4667f 100644 --- a/Python/optimizer.c +++ b/Python/optimizer.c @@ -909,6 +909,8 @@ _PyJit_translate_single_bytecode_to_trace( } switch (opcode) { + case JUMP_IF_NONE: + case JUMP_IF_NOT_NONE: case POP_JUMP_IF_NONE: case POP_JUMP_IF_NOT_NONE: case POP_JUMP_IF_FALSE: @@ -920,7 +922,14 @@ _PyJit_translate_single_bytecode_to_trace( assert(next_instr == computed_next_instr || next_instr == computed_jump_instr); int jump_happened = target_instr[1].cache & 1; assert(jump_happened ? (next_instr == computed_jump_instr) : (next_instr == computed_next_instr)); - uint32_t uopcode = BRANCH_TO_GUARD[opcode - POP_JUMP_IF_FALSE][jump_happened]; + uint32_t uopcode; + if (opcode == JUMP_IF_NONE || opcode == JUMP_IF_NOT_NONE) { + bool is_none = jump_happened == (opcode == JUMP_IF_NONE); + uopcode = is_none ? _GUARD_IS_NONE_KEEP : _GUARD_IS_NOT_NONE_KEEP; + } + else { + uopcode = BRANCH_TO_GUARD[opcode - POP_JUMP_IF_FALSE][jump_happened]; + } ADD_TO_TRACE(uopcode, 0, 0, INSTR_IP(jump_happened ? computed_next_instr : computed_jump_instr, old_code)); int bp = compute_branch_penalty(target_instr[1].cache); tracer->translator_state.fitness -= bp; diff --git a/Python/optimizer_bytecodes.c b/Python/optimizer_bytecodes.c index 96dbaea5a5797e..9984bb96b01927 100644 --- a/Python/optimizer_bytecodes.c +++ b/Python/optimizer_bytecodes.c @@ -834,6 +834,20 @@ dummy_func(void) { } } + op(_IS_NONE_KEEP, (value -- value, b)) { + if (sym_is_const(ctx, value)) { + PyObject *value_o = sym_get_const(ctx, value); + b = sym_new_const(ctx, Py_IsNone(value_o) ? Py_True : Py_False); + } + else { + b = sym_new_type(ctx, &PyBool_Type); + } + } + + op(_GUARD_IS_NONE_KEEP, (val -- val)) { + sym_set_const(val, Py_None); + } + op(_CONTAINS_OP, (left, right -- b, l, r)) { b = sym_new_type(ctx, &PyBool_Type); l = left; diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 2e34f2e9f1df20..f8195b4a00752d 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -3487,6 +3487,24 @@ break; } + case _IS_NONE_KEEP: { + JitOptRef value; + JitOptRef b; + value = stack_pointer[-1]; + if (sym_is_const(ctx, value)) { + PyObject *value_o = sym_get_const(ctx, value); + b = sym_new_const(ctx, Py_IsNone(value_o) ? Py_True : Py_False); + } + else { + b = sym_new_type(ctx, &PyBool_Type); + } + CHECK_STACK_BOUNDS(1); + stack_pointer[0] = b; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + break; + } + /* _JUMP_BACKWARD_NO_INTERRUPT is not a viable micro-op for tier 2 */ case _GET_LEN: { @@ -5454,6 +5472,10 @@ /* _INSTRUMENTED_POP_JUMP_IF_NONE is not a viable micro-op for tier 2 */ + /* _INSTRUMENTED_JUMP_IF_NONE is not a viable micro-op for tier 2 */ + + /* _INSTRUMENTED_JUMP_IF_NOT_NONE is not a viable micro-op for tier 2 */ + /* _INSTRUMENTED_POP_JUMP_IF_NOT_NONE is not a viable micro-op for tier 2 */ case _GUARD_IS_TRUE_POP: { @@ -5539,6 +5561,17 @@ break; } + case _GUARD_IS_NONE_KEEP: { + JitOptRef val; + val = stack_pointer[-1]; + sym_set_const(val, Py_None); + break; + } + + case _GUARD_IS_NOT_NONE_KEEP: { + break; + } + case _GUARD_IS_NOT_NONE_POP: { JitOptRef val; val = stack_pointer[-1]; diff --git a/Python/pystats.c b/Python/pystats.c index 2fac2db1b738c7..5ee9d7a0028c57 100644 --- a/Python/pystats.c +++ b/Python/pystats.c @@ -160,6 +160,8 @@ print_spec_stats(FILE *out, OpcodeStats *stats) switch (i) { case POP_JUMP_IF_FALSE: case POP_JUMP_IF_TRUE: + case JUMP_IF_NONE: + case JUMP_IF_NOT_NONE: case POP_JUMP_IF_NONE: case POP_JUMP_IF_NOT_NONE: case JUMP_BACKWARD: diff --git a/Python/specialize.c b/Python/specialize.c index 12a8c624f24d71..6b548f36bf8098 100644 --- a/Python/specialize.c +++ b/Python/specialize.c @@ -97,6 +97,8 @@ _PyCode_Quicken(_Py_CODEUNIT *instructions, Py_ssize_t size, int enable_counters break; case POP_JUMP_IF_FALSE: case POP_JUMP_IF_TRUE: + case JUMP_IF_NONE: + case JUMP_IF_NOT_NONE: case POP_JUMP_IF_NONE: case POP_JUMP_IF_NOT_NONE: instructions[i + 1].cache = 0x5555; // Alternating 0, 1 bits